• Home
• io.qtjambi
• qtjambi
• 6.7.0
• source code
• QPainter.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.qt.gui.QPainter Maven / Gradle / Ivy

package io.qt.gui;

import io.qt.*;


/**
 * 
Performs low-level painting on widgets and other paint devices
 * 
Java wrapper for Qt class QPainter
 */
public class QPainter extends QtObject
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * This variable stores the meta-object for the class.
     */
    public static final io.qt.core.@NonNull QMetaObject staticMetaObject = io.qt.core.QMetaObject.forType(QPainter.class);
    
    /**
     * 
Java wrapper for Qt enum QPainter::CompositionMode
     */
    public enum CompositionMode implements QtEnumerator {
        /**
         * 
Representing QPainter::CompositionMode_SourceOver
         */
        CompositionMode_SourceOver(0),
        /**
         * 
Representing QPainter::CompositionMode_DestinationOver
         */
        CompositionMode_DestinationOver(1),
        /**
         * 
Representing QPainter::CompositionMode_Clear
         */
        CompositionMode_Clear(2),
        /**
         * 
Representing QPainter::CompositionMode_Source
         */
        CompositionMode_Source(3),
        /**
         * 
Representing QPainter::CompositionMode_Destination
         */
        CompositionMode_Destination(4),
        /**
         * 
Representing QPainter::CompositionMode_SourceIn
         */
        CompositionMode_SourceIn(5),
        /**
         * 
Representing QPainter::CompositionMode_DestinationIn
         */
        CompositionMode_DestinationIn(6),
        /**
         * 
Representing QPainter::CompositionMode_SourceOut
         */
        CompositionMode_SourceOut(7),
        /**
         * 
Representing QPainter::CompositionMode_DestinationOut
         */
        CompositionMode_DestinationOut(8),
        /**
         * 
Representing QPainter::CompositionMode_SourceAtop
         */
        CompositionMode_SourceAtop(9),
        /**
         * 
Representing QPainter::CompositionMode_DestinationAtop
         */
        CompositionMode_DestinationAtop(10),
        /**
         * 
Representing QPainter::CompositionMode_Xor
         */
        CompositionMode_Xor(11),
        /**
         * 
Representing QPainter::CompositionMode_Plus
         */
        CompositionMode_Plus(12),
        /**
         * 
Representing QPainter::CompositionMode_Multiply
         */
        CompositionMode_Multiply(13),
        /**
         * 
Representing QPainter::CompositionMode_Screen
         */
        CompositionMode_Screen(14),
        /**
         * 
Representing QPainter::CompositionMode_Overlay
         */
        CompositionMode_Overlay(15),
        /**
         * 
Representing QPainter::CompositionMode_Darken
         */
        CompositionMode_Darken(16),
        /**
         * 
Representing QPainter::CompositionMode_Lighten
         */
        CompositionMode_Lighten(17),
        /**
         * 
Representing QPainter::CompositionMode_ColorDodge
         */
        CompositionMode_ColorDodge(18),
        /**
         * 
Representing QPainter::CompositionMode_ColorBurn
         */
        CompositionMode_ColorBurn(19),
        /**
         * 
Representing QPainter::CompositionMode_HardLight
         */
        CompositionMode_HardLight(20),
        /**
         * 
Representing QPainter::CompositionMode_SoftLight
         */
        CompositionMode_SoftLight(21),
        /**
         * 
Representing QPainter::CompositionMode_Difference
         */
        CompositionMode_Difference(22),
        /**
         * 
Representing QPainter::CompositionMode_Exclusion
         */
        CompositionMode_Exclusion(23),
        /**
         * 
Representing QPainter::RasterOp_SourceOrDestination
         */
        RasterOp_SourceOrDestination(24),
        /**
         * 
Representing QPainter::RasterOp_SourceAndDestination
         */
        RasterOp_SourceAndDestination(25),
        /**
         * 
Representing QPainter::RasterOp_SourceXorDestination
         */
        RasterOp_SourceXorDestination(26),
        /**
         * 
Representing QPainter::RasterOp_NotSourceAndNotDestination
         */
        RasterOp_NotSourceAndNotDestination(27),
        /**
         * 
Representing QPainter::RasterOp_NotSourceOrNotDestination
         */
        RasterOp_NotSourceOrNotDestination(28),
        /**
         * 
Representing QPainter::RasterOp_NotSourceXorDestination
         */
        RasterOp_NotSourceXorDestination(29),
        /**
         * 
Representing QPainter::RasterOp_NotSource
         */
        RasterOp_NotSource(30),
        /**
         * 
Representing QPainter::RasterOp_NotSourceAndDestination
         */
        RasterOp_NotSourceAndDestination(31),
        /**
         * 
Representing QPainter::RasterOp_SourceAndNotDestination
         */
        RasterOp_SourceAndNotDestination(32),
        /**
         * 
Representing QPainter::RasterOp_NotSourceOrDestination
         */
        RasterOp_NotSourceOrDestination(33),
        /**
         * 
Representing QPainter::RasterOp_SourceOrNotDestination
         */
        RasterOp_SourceOrNotDestination(34),
        /**
         * 
Representing QPainter::RasterOp_ClearDestination
         */
        RasterOp_ClearDestination(35),
        /**
         * 
Representing QPainter::RasterOp_SetDestination
         */
        RasterOp_SetDestination(36),
        /**
         * 
Representing QPainter::RasterOp_NotDestination
         */
        RasterOp_NotDestination(37);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private CompositionMode(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull CompositionMode resolve(int value) {
            switch (value) {
            case 0: return CompositionMode_SourceOver;
            case 1: return CompositionMode_DestinationOver;
            case 2: return CompositionMode_Clear;
            case 3: return CompositionMode_Source;
            case 4: return CompositionMode_Destination;
            case 5: return CompositionMode_SourceIn;
            case 6: return CompositionMode_DestinationIn;
            case 7: return CompositionMode_SourceOut;
            case 8: return CompositionMode_DestinationOut;
            case 9: return CompositionMode_SourceAtop;
            case 10: return CompositionMode_DestinationAtop;
            case 11: return CompositionMode_Xor;
            case 12: return CompositionMode_Plus;
            case 13: return CompositionMode_Multiply;
            case 14: return CompositionMode_Screen;
            case 15: return CompositionMode_Overlay;
            case 16: return CompositionMode_Darken;
            case 17: return CompositionMode_Lighten;
            case 18: return CompositionMode_ColorDodge;
            case 19: return CompositionMode_ColorBurn;
            case 20: return CompositionMode_HardLight;
            case 21: return CompositionMode_SoftLight;
            case 22: return CompositionMode_Difference;
            case 23: return CompositionMode_Exclusion;
            case 24: return RasterOp_SourceOrDestination;
            case 25: return RasterOp_SourceAndDestination;
            case 26: return RasterOp_SourceXorDestination;
            case 27: return RasterOp_NotSourceAndNotDestination;
            case 28: return RasterOp_NotSourceOrNotDestination;
            case 29: return RasterOp_NotSourceXorDestination;
            case 30: return RasterOp_NotSource;
            case 31: return RasterOp_NotSourceAndDestination;
            case 32: return RasterOp_SourceAndNotDestination;
            case 33: return RasterOp_NotSourceOrDestination;
            case 34: return RasterOp_SourceOrNotDestination;
            case 35: return RasterOp_ClearDestination;
            case 36: return RasterOp_SetDestination;
            case 37: return RasterOp_NotDestination;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * 
Java wrapper for Qt enum QPainter::PixmapFragmentHint
     * 
     * @see PixmapFragmentHints
     */
    public enum PixmapFragmentHint implements QtFlagEnumerator {
        /**
         * 
Representing QPainter::OpaqueHint
         */
        OpaqueHint(1);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private PixmapFragmentHint(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        public @NonNull PixmapFragmentHints asFlags() {
            return new PixmapFragmentHints(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull PixmapFragmentHints combined(@NonNull PixmapFragmentHint e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull PixmapFragmentHints cleared(@NonNull PixmapFragmentHint e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link PixmapFragmentHints} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull PixmapFragmentHints flags(@Nullable PixmapFragmentHint @NonNull... values) {
            return new PixmapFragmentHints(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull PixmapFragmentHint resolve(int value) {
            switch (value) {
            case 1: return OpaqueHint;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link PixmapFragmentHint}
     */
    public static final class PixmapFragmentHints extends QFlags implements Comparable {
        private static final long serialVersionUID = 0x5fa96733aac50cb0L;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new PixmapFragmentHints where the flags in args are set.
         * @param args enum entries
         */
        public PixmapFragmentHints(@Nullable PixmapFragmentHint @NonNull... args){
            super(args);
        }

        /**
         * Creates a new PixmapFragmentHints with given value.
         * @param value
         */
        public PixmapFragmentHints(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new PixmapFragmentHints
         */
        @Override
        public final @NonNull PixmapFragmentHints combined(@StrictNonNull PixmapFragmentHint e){
            return new PixmapFragmentHints(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        public final @NonNull PixmapFragmentHints setFlag(@Nullable PixmapFragmentHint e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        public final @NonNull PixmapFragmentHints setFlag(@Nullable PixmapFragmentHint e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this PixmapFragmentHints.
         * @return array of enum entries
         */
        @Override
        public final @NonNull PixmapFragmentHint @NonNull[] flags(){
            return super.flags(PixmapFragmentHint.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull PixmapFragmentHints clone(){
            return new PixmapFragmentHints(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull PixmapFragmentHints other){
            return Integer.compare(value(), other.value());
        }
    }
    
    /**
     * 
Java wrapper for Qt enum QPainter::RenderHint
     * 
     * @see RenderHints
     */
    public enum RenderHint implements QtFlagEnumerator {
        /**
         * 
Representing QPainter::Antialiasing
         */
        Antialiasing(1),
        /**
         * 
Representing QPainter::TextAntialiasing
         */
        TextAntialiasing(2),
        /**
         * 
Representing QPainter::SmoothPixmapTransform
         */
        SmoothPixmapTransform(4),
        /**
         * 
Representing QPainter::VerticalSubpixelPositioning
         */
        VerticalSubpixelPositioning(8),
        /**
         * 
Representing QPainter::LosslessImageRendering
         */
        LosslessImageRendering(64),
        /**
         * 
Representing QPainter::NonCosmeticBrushPatterns
         */
        NonCosmeticBrushPatterns(128);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private RenderHint(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        public @NonNull RenderHints asFlags() {
            return new RenderHints(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull RenderHints combined(@NonNull RenderHint e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull RenderHints cleared(@NonNull RenderHint e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link RenderHints} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull RenderHints flags(@Nullable RenderHint @NonNull... values) {
            return new RenderHints(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull RenderHint resolve(int value) {
            switch (value) {
            case 1: return Antialiasing;
            case 2: return TextAntialiasing;
            case 4: return SmoothPixmapTransform;
            case 8: return VerticalSubpixelPositioning;
            case 64: return LosslessImageRendering;
            case 128: return NonCosmeticBrushPatterns;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link RenderHint}
     */
    public static final class RenderHints extends QFlags implements Comparable {
        private static final long serialVersionUID = 0x1c746c94314d5d3aL;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new RenderHints where the flags in args are set.
         * @param args enum entries
         */
        public RenderHints(@Nullable RenderHint @NonNull... args){
            super(args);
        }

        /**
         * Creates a new RenderHints with given value.
         * @param value
         */
        public RenderHints(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new RenderHints
         */
        @Override
        public final @NonNull RenderHints combined(@StrictNonNull RenderHint e){
            return new RenderHints(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        public final @NonNull RenderHints setFlag(@Nullable RenderHint e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        public final @NonNull RenderHints setFlag(@Nullable RenderHint e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this RenderHints.
         * @return array of enum entries
         */
        @Override
        public final @NonNull RenderHint @NonNull[] flags(){
            return super.flags(RenderHint.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull RenderHints clone(){
            return new RenderHints(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull RenderHints other){
            return Integer.compare(value(), other.value());
        }
    }
    

    /**
     * 
This class is used in conjunction with the QPainter::drawPixmapFragments() function to specify how a pixmap, or sub-rect of a pixmap, is drawn
     * 
Java wrapper for Qt class QPainter::PixmapFragment
     */
    public static class PixmapFragment extends QtObject
        implements java.lang.Cloneable
    {
        static {
            QtJambi_LibraryUtilities.initialize();
        }
        
        
        /**
         * 
See QPainter::PixmapFragment::PixmapFragment()
         */
        public PixmapFragment(){
            super((QPrivateConstructor)null);
            initialize_native(this);
        }
        
        private native static void initialize_native(PixmapFragment instance);
        
        /**
         * 
See QPainter::PixmapFragment::PixmapFragment(QPainter::PixmapFragment)
         */
        public PixmapFragment(io.qt.gui.QPainter.@NonNull PixmapFragment other){
            super((QPrivateConstructor)null);
            initialize_native(this, other);
        }
        
        private native static void initialize_native(PixmapFragment instance, io.qt.gui.QPainter.PixmapFragment other);
        
        /**
         * 
See QPainter::PixmapFragment::PixmapFragment{qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal}
         */
        public PixmapFragment(double x, double y, double sourceLeft, double sourceTop, double width, double height, double scaleX, double scaleY, double rotation, double opacity){
            super((QPrivateConstructor)null);
            initialize_native(this, x, y, sourceLeft, sourceTop, width, height, scaleX, scaleY, rotation, opacity);
        }
        
        private native static void initialize_native(PixmapFragment instance, double x, double y, double sourceLeft, double sourceTop, double width, double height, double scaleX, double scaleY, double rotation, double opacity);
        
        /**
         * 
See QPainter::PixmapFragment::create(QPointF,QRectF,qreal,qreal,qreal,qreal)
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRectF sourceRect, double scaleX, double scaleY, double rotation, double opacity){
            return create_native_cref_QPointF_cref_QRectF_qreal_qreal_qreal_qreal(QtJambi_LibraryUtilities.internal.checkedNativeId(pos), QtJambi_LibraryUtilities.internal.checkedNativeId(sourceRect), scaleX, scaleY, rotation, opacity);
        }
        
        private native static io.qt.gui.QPainter.PixmapFragment create_native_cref_QPointF_cref_QRectF_qreal_qreal_qreal_qreal(long pos, long sourceRect, double scaleX, double scaleY, double rotation, double opacity);
        
        /**
         * 
The height of the source rectangle and is used to calculate the height of the target rectangle
         * 
See QPainter::PixmapFragment::height
         */
        @QtUninvokable
        public final void setHeight(double height){
            setHeight_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), height);
        }
        
        @QtUninvokable
        private native void setHeight_native_qreal(long __this__nativeId, double height);
        
        /**
         * 
The height of the source rectangle and is used to calculate the height of the target rectangle
         * 
See QPainter::PixmapFragment::height
         */
        @QtUninvokable
        public final double height(){
            return height_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double height_native(long __this__nativeId);
        
        /**
         * 
The opacity of the target rectangle, where 0.0 is fully transparent and 1.0 is fully opaque
         * 
See QPainter::PixmapFragment::opacity
         */
        @QtUninvokable
        public final void setOpacity(double opacity){
            setOpacity_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), opacity);
        }
        
        @QtUninvokable
        private native void setOpacity_native_qreal(long __this__nativeId, double opacity);
        
        /**
         * 
The opacity of the target rectangle, where 0.0 is fully transparent and 1.0 is fully opaque
         * 
See QPainter::PixmapFragment::opacity
         */
        @QtUninvokable
        public final double opacity(){
            return opacity_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double opacity_native(long __this__nativeId);
        
        /**
         * 
The rotation of the target rectangle in degrees. The target rectangle is rotated after it has been scaled
         * 
See QPainter::PixmapFragment::rotation
         */
        @QtUninvokable
        public final void setRotation(double rotation){
            setRotation_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), rotation);
        }
        
        @QtUninvokable
        private native void setRotation_native_qreal(long __this__nativeId, double rotation);
        
        /**
         * 
The rotation of the target rectangle in degrees. The target rectangle is rotated after it has been scaled
         * 
See QPainter::PixmapFragment::rotation
         */
        @QtUninvokable
        public final double rotation(){
            return rotation_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double rotation_native(long __this__nativeId);
        
        /**
         * 
The horizontal scale of the target rectangle
         * 
See QPainter::PixmapFragment::scaleX
         */
        @QtUninvokable
        public final void setScaleX(double scaleX){
            setScaleX_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), scaleX);
        }
        
        @QtUninvokable
        private native void setScaleX_native_qreal(long __this__nativeId, double scaleX);
        
        /**
         * 
The horizontal scale of the target rectangle
         * 
See QPainter::PixmapFragment::scaleX
         */
        @QtUninvokable
        public final double scaleX(){
            return scaleX_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double scaleX_native(long __this__nativeId);
        
        /**
         * 
The vertical scale of the target rectangle
         * 
See QPainter::PixmapFragment::scaleY
         */
        @QtUninvokable
        public final void setScaleY(double scaleY){
            setScaleY_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), scaleY);
        }
        
        @QtUninvokable
        private native void setScaleY_native_qreal(long __this__nativeId, double scaleY);
        
        /**
         * 
The vertical scale of the target rectangle
         * 
See QPainter::PixmapFragment::scaleY
         */
        @QtUninvokable
        public final double scaleY(){
            return scaleY_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double scaleY_native(long __this__nativeId);
        
        /**
         * 
The left coordinate of the source rectangle
         * 
See QPainter::PixmapFragment::sourceLeft
         */
        @QtUninvokable
        public final void setSourceLeft(double sourceLeft){
            setSourceLeft_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), sourceLeft);
        }
        
        @QtUninvokable
        private native void setSourceLeft_native_qreal(long __this__nativeId, double sourceLeft);
        
        /**
         * 
The left coordinate of the source rectangle
         * 
See QPainter::PixmapFragment::sourceLeft
         */
        @QtUninvokable
        public final double sourceLeft(){
            return sourceLeft_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double sourceLeft_native(long __this__nativeId);
        
        /**
         * 
The top coordinate of the source rectangle
         * 
See QPainter::PixmapFragment::sourceTop
         */
        @QtUninvokable
        public final void setSourceTop(double sourceTop){
            setSourceTop_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), sourceTop);
        }
        
        @QtUninvokable
        private native void setSourceTop_native_qreal(long __this__nativeId, double sourceTop);
        
        /**
         * 
The top coordinate of the source rectangle
         * 
See QPainter::PixmapFragment::sourceTop
         */
        @QtUninvokable
        public final double sourceTop(){
            return sourceTop_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double sourceTop_native(long __this__nativeId);
        
        /**
         * 
The width of the source rectangle and is used to calculate the width of the target rectangle
         * 
See QPainter::PixmapFragment::width
         */
        @QtUninvokable
        public final void setWidth(double width){
            setWidth_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), width);
        }
        
        @QtUninvokable
        private native void setWidth_native_qreal(long __this__nativeId, double width);
        
        /**
         * 
The width of the source rectangle and is used to calculate the width of the target rectangle
         * 
See QPainter::PixmapFragment::width
         */
        @QtUninvokable
        public final double width(){
            return width_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double width_native(long __this__nativeId);
        
        /**
         * 
The x coordinate of center point in the target rectangle
         * 
See QPainter::PixmapFragment::x
         */
        @QtUninvokable
        public final void setX(double x){
            setX_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), x);
        }
        
        @QtUninvokable
        private native void setX_native_qreal(long __this__nativeId, double x);
        
        /**
         * 
The x coordinate of center point in the target rectangle
         * 
See QPainter::PixmapFragment::x
         */
        @QtUninvokable
        public final double x(){
            return x_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double x_native(long __this__nativeId);
        
        /**
         * 
The y coordinate of the center point in the target rectangle
         * 
See QPainter::PixmapFragment::y
         */
        @QtUninvokable
        public final void setY(double y){
            setY_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), y);
        }
        
        @QtUninvokable
        private native void setY_native_qreal(long __this__nativeId, double y);
        
        /**
         * 
The y coordinate of the center point in the target rectangle
         * 
See QPainter::PixmapFragment::y
         */
        @QtUninvokable
        public final double y(){
            return y_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native double y_native(long __this__nativeId);
        
        /**
         * Constructor for internal use only.
         * @param p expected to be null.
         * @hidden
         */
        @NativeAccess
        protected PixmapFragment(QPrivateConstructor p) { super(p); } 
        
        
        /**
         * 
Creates and returns a copy of this object.
        
See QPainter::PixmapFragment::PixmapFragment(QPainter::PixmapFragment)
         */
        @QtUninvokable
        @Override
        public PixmapFragment clone() {
            return clone_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        private static native PixmapFragment clone_native(long __this_nativeId);
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRectF, double, double, double, double)}
         *  with opacity = 1.
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRectF sourceRect, double scaleX, double scaleY, double rotation) {
            return create(pos, sourceRect, scaleX, scaleY, rotation, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRectF, double, double, double, double)}
         * 
with: 

         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRectF sourceRect, double scaleX, double scaleY) {
            return create(pos, sourceRect, scaleX, scaleY, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRectF, double, double, double, double)}
         * 
with: 

         * 
scaleY = 1
         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRectF sourceRect, double scaleX) {
            return create(pos, sourceRect, scaleX, (double)1, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRectF, double, double, double, double)}
         * 
with: 

         * 
scaleX = 1
         * 
scaleY = 1
         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRectF sourceRect) {
            return create(pos, sourceRect, (double)1, (double)1, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPoint, io.qt.core.QRectF, double, double, double, double)}
         *  with opacity = 1.
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRectF sourceRect, double scaleX, double scaleY, double rotation) {
            return create(pos, sourceRect, scaleX, scaleY, rotation, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPoint, io.qt.core.QRectF, double, double, double, double)}
         * 
with: 

         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRectF sourceRect, double scaleX, double scaleY) {
            return create(pos, sourceRect, scaleX, scaleY, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPoint, io.qt.core.QRectF, double, double, double, double)}
         * 
with: 

         * 
scaleY = 1
         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRectF sourceRect, double scaleX) {
            return create(pos, sourceRect, scaleX, (double)1, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPoint, io.qt.core.QRectF, double, double, double, double)}
         * 
with: 

         * 
scaleX = 1
         * 
scaleY = 1
         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRectF sourceRect) {
            return create(pos, sourceRect, (double)1, (double)1, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRectF, double, double, double, double)}.
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRectF sourceRect, double scaleX, double scaleY, double rotation, double opacity) {
            return create(new io.qt.core.QPointF(pos), sourceRect, scaleX, scaleY, rotation, opacity);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRect, double, double, double, double)}
         *  with opacity = 1.
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRect sourceRect, double scaleX, double scaleY, double rotation) {
            return create(pos, sourceRect, scaleX, scaleY, rotation, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRect, double, double, double, double)}
         * 
with: 

         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRect sourceRect, double scaleX, double scaleY) {
            return create(pos, sourceRect, scaleX, scaleY, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRect, double, double, double, double)}
         * 
with: 

         * 
scaleY = 1
         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRect sourceRect, double scaleX) {
            return create(pos, sourceRect, scaleX, (double)1, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRect, double, double, double, double)}
         * 
with: 

         * 
scaleX = 1
         * 
scaleY = 1
         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRect sourceRect) {
            return create(pos, sourceRect, (double)1, (double)1, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRectF, double, double, double, double)}.
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPointF pos, io.qt.core.@NonNull QRect sourceRect, double scaleX, double scaleY, double rotation, double opacity) {
            return create(pos, new io.qt.core.QRectF(sourceRect), scaleX, scaleY, rotation, opacity);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPoint, io.qt.core.QRect, double, double, double, double)}
         *  with opacity = 1.
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRect sourceRect, double scaleX, double scaleY, double rotation) {
            return create(pos, sourceRect, scaleX, scaleY, rotation, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPoint, io.qt.core.QRect, double, double, double, double)}
         * 
with: 

         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRect sourceRect, double scaleX, double scaleY) {
            return create(pos, sourceRect, scaleX, scaleY, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPoint, io.qt.core.QRect, double, double, double, double)}
         * 
with: 

         * 
scaleY = 1
         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRect sourceRect, double scaleX) {
            return create(pos, sourceRect, scaleX, (double)1, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPoint, io.qt.core.QRect, double, double, double, double)}
         * 
with: 

         * 
scaleX = 1
         * 
scaleY = 1
         * 
rotation = 0
         * 
opacity = 1
         * 
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRect sourceRect) {
            return create(pos, sourceRect, (double)1, (double)1, (double)0, (double)1);
        }
        
        /**
         * 
Overloaded function for {@link #create(io.qt.core.QPointF, io.qt.core.QRectF, double, double, double, double)}.
         */
        public static io.qt.gui.QPainter.@NonNull PixmapFragment create(io.qt.core.@NonNull QPoint pos, io.qt.core.@NonNull QRect sourceRect, double scaleX, double scaleY, double rotation, double opacity) {
            return create(new io.qt.core.QPointF(pos), new io.qt.core.QRectF(sourceRect), scaleX, scaleY, rotation, opacity);
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #height()} instead.
         */
        @QtUninvokable
        public final double getHeight() {
            return height();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #opacity()} instead.
         */
        @QtUninvokable
        public final double getOpacity() {
            return opacity();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #rotation()} instead.
         */
        @QtUninvokable
        public final double getRotation() {
            return rotation();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #scaleX()} instead.
         */
        @QtUninvokable
        public final double getScaleX() {
            return scaleX();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #scaleY()} instead.
         */
        @QtUninvokable
        public final double getScaleY() {
            return scaleY();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #sourceLeft()} instead.
         */
        @QtUninvokable
        public final double getSourceLeft() {
            return sourceLeft();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #sourceTop()} instead.
         */
        @QtUninvokable
        public final double getSourceTop() {
            return sourceTop();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #width()} instead.
         */
        @QtUninvokable
        public final double getWidth() {
            return width();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #x()} instead.
         */
        @QtUninvokable
        public final double getX() {
            return x();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #y()} instead.
         */
        @QtUninvokable
        public final double getY() {
            return y();
        }
    }

    
    /**
     * 
See QPainter::QPainter()
     */
    public QPainter(){
        super((QPrivateConstructor)null);
        initialize_native(this);
    }
    
    private native static void initialize_native(QPainter instance);
    
    /**
     * 
See QPainter::QPainter(QPaintDevice*)
     */
    public QPainter(io.qt.gui.@Nullable QPaintDevice arg__1){
        super((QPrivateConstructor)null);
        initialize(arg__1, true);
        initialize_native(this, arg__1);
        QtJambi_LibraryUtilities.internal.registerDependentObject(this, arg__1);
    }
    
    private native static void initialize_native(QPainter instance, io.qt.gui.QPaintDevice arg__1);
    
    /**
     * 
See QPainter::background()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QBrush background(){
        return background_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QBrush background_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::backgroundMode()const
     */
    @QtUninvokable
    public final io.qt.core.Qt.@NonNull BGMode backgroundMode(){
        return io.qt.core.Qt.BGMode.resolve(backgroundMode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int backgroundMode_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::begin(QPaintDevice*)
     */
    @QtUninvokable
    public final boolean begin(io.qt.gui.@Nullable QPaintDevice arg__1){
        initialize(arg__1, false);
        boolean __qt_return_value = begin_native_QPaintDevice_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1));
        if(__qt_return_value)
            QtJambi_LibraryUtilities.internal.registerDependentObject(this, arg__1);
        return __qt_return_value;
    }
    
    @QtUninvokable
    private native boolean begin_native_QPaintDevice_ptr(long __this__nativeId, long arg__1);
    
    /**
     * 
See QPainter::beginNativePainting()
     */
    @QtUninvokable
    public final void beginNativePainting(){
        beginNativePainting_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void beginNativePainting_native(long __this__nativeId);
    
    /**
     * 
See QPainter::boundingRect(QRect,int,QString)
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRect boundingRect(io.qt.core.@NonNull QRect rect, int flags, java.lang.@NonNull String text){
        return boundingRect_native_cref_QRect_int_cref_QString(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect), flags, text);
    }
    
    @QtUninvokable
    private native io.qt.core.QRect boundingRect_native_cref_QRect_int_cref_QString(long __this__nativeId, long rect, int flags, java.lang.String text);
    
    /**
     * 
See QPainter::boundingRect(QRectF,QString,QTextOption)
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRectF boundingRect(io.qt.core.@NonNull QRectF rect, java.lang.@NonNull String text, io.qt.gui.@NonNull QTextOption o){
        return boundingRect_native_cref_QRectF_cref_QString_cref_QTextOption(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect), text, QtJambi_LibraryUtilities.internal.checkedNativeId(o));
    }
    
    @QtUninvokable
    private native io.qt.core.QRectF boundingRect_native_cref_QRectF_cref_QString_cref_QTextOption(long __this__nativeId, long rect, java.lang.String text, long o);
    
    /**
     * 
See QPainter::boundingRect(QRectF,int,QString)
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRectF boundingRect(io.qt.core.@NonNull QRectF rect, int flags, java.lang.@NonNull String text){
        return boundingRect_native_cref_QRectF_int_cref_QString(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect), flags, text);
    }
    
    @QtUninvokable
    private native io.qt.core.QRectF boundingRect_native_cref_QRectF_int_cref_QString(long __this__nativeId, long rect, int flags, java.lang.String text);
    
    /**
     * 
See QPainter::boundingRect(int,int,int,int,int,QString)
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRect boundingRect(int x, int y, int w, int h, int flags, java.lang.@NonNull String text){
        return boundingRect_native_int_int_int_int_int_cref_QString(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, flags, text);
    }
    
    @QtUninvokable
    private native io.qt.core.QRect boundingRect_native_int_int_int_int_int_cref_QString(long __this__nativeId, int x, int y, int w, int h, int flags, java.lang.String text);
    
    /**
     * 
See QPainter::brush()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QBrush brush(){
        return brush_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QBrush brush_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::brushOrigin()const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QPoint brushOrigin(){
        return brushOrigin_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QPoint brushOrigin_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::clipBoundingRect()const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRectF clipBoundingRect(){
        return clipBoundingRect_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QRectF clipBoundingRect_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::clipPath()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QPainterPath clipPath(){
        return clipPath_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QPainterPath clipPath_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::clipRegion()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QRegion clipRegion(){
        return clipRegion_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QRegion clipRegion_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::combinedTransform()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QTransform combinedTransform(){
        return combinedTransform_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QTransform combinedTransform_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::compositionMode()const
     */
    @QtUninvokable
    public final io.qt.gui.QPainter.@NonNull CompositionMode compositionMode(){
        return io.qt.gui.QPainter.CompositionMode.resolve(compositionMode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int compositionMode_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::device()const
     */
    @QtUninvokable
    public final io.qt.gui.@Nullable QPaintDevice device(){
        return device_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QPaintDevice device_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::deviceTransform()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QTransform deviceTransform(){
        return deviceTransform_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QTransform deviceTransform_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::drawArc(QRect,int,int)
     */
    @QtUninvokable
    public final void drawArc(io.qt.core.@NonNull QRect arg__1, int a, int alen){
        drawArc_native_cref_QRect_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), a, alen);
    }
    
    @QtUninvokable
    private native void drawArc_native_cref_QRect_int_int(long __this__nativeId, long arg__1, int a, int alen);
    
    /**
     * 
See QPainter::drawArc(QRectF,int,int)
     */
    @QtUninvokable
    public final void drawArc(io.qt.core.@NonNull QRectF rect, int a, int alen){
        drawArc_native_cref_QRectF_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect), a, alen);
    }
    
    @QtUninvokable
    private native void drawArc_native_cref_QRectF_int_int(long __this__nativeId, long rect, int a, int alen);
    
    /**
     * 
See QPainter::drawArc(int,int,int,int,int,int)
     */
    @QtUninvokable
    public final void drawArc(int x, int y, int w, int h, int a, int alen){
        drawArc_native_int_int_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, a, alen);
    }
    
    @QtUninvokable
    private native void drawArc_native_int_int_int_int_int_int(long __this__nativeId, int x, int y, int w, int h, int a, int alen);
    
    /**
     * 
See QPainter::drawChord(QRect,int,int)
     */
    @QtUninvokable
    public final void drawChord(io.qt.core.@NonNull QRect arg__1, int a, int alen){
        drawChord_native_cref_QRect_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), a, alen);
    }
    
    @QtUninvokable
    private native void drawChord_native_cref_QRect_int_int(long __this__nativeId, long arg__1, int a, int alen);
    
    /**
     * 
See QPainter::drawChord(QRectF,int,int)
     */
    @QtUninvokable
    public final void drawChord(io.qt.core.@NonNull QRectF rect, int a, int alen){
        drawChord_native_cref_QRectF_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect), a, alen);
    }
    
    @QtUninvokable
    private native void drawChord_native_cref_QRectF_int_int(long __this__nativeId, long rect, int a, int alen);
    
    /**
     * 
See QPainter::drawChord(int,int,int,int,int,int)
     */
    @QtUninvokable
    public final void drawChord(int x, int y, int w, int h, int a, int alen){
        drawChord_native_int_int_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, a, alen);
    }
    
    @QtUninvokable
    private native void drawChord_native_int_int_int_int_int_int(long __this__nativeId, int x, int y, int w, int h, int a, int alen);
    
    /**
     * 
See QPainter::drawConvexPolygon(QPolygon)
     */
    @QtUninvokable
    public final void drawConvexPolygon(io.qt.gui.@NonNull QPolygon polygon){
        drawConvexPolygon_native_cref_QPolygon(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(polygon));
    }
    
    @QtUninvokable
    private native void drawConvexPolygon_native_cref_QPolygon(long __this__nativeId, long polygon);
    
    /**
     * 
See QPainter::drawConvexPolygon(QPolygonF)
     */
    @QtUninvokable
    public final void drawConvexPolygon(io.qt.gui.@NonNull QPolygonF polygon){
        drawConvexPolygon_native_cref_QPolygonF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(polygon));
    }
    
    @QtUninvokable
    private native void drawConvexPolygon_native_cref_QPolygonF(long __this__nativeId, long polygon);
    
    /**
     * 
See QPainter::drawConvexPolygon(const QPoint*,int)
     */
    @QtUninvokable
    public final void drawConvexPolygon(io.qt.core.@NonNull QPoint... points){
        drawConvexPolygon_native_const_QPoint_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), points);
    }
    
    @QtUninvokable
    private native void drawConvexPolygon_native_const_QPoint_ptr_int(long __this__nativeId, io.qt.core.QPoint[] points);
    
    /**
     * 
See QPainter::drawConvexPolygon(const QPointF*,int)
     */
    @QtUninvokable
    public final void drawConvexPolygon(io.qt.core.@NonNull QPointF... points){
        drawConvexPolygon_native_const_QPointF_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), points);
    }
    
    @QtUninvokable
    private native void drawConvexPolygon_native_const_QPointF_ptr_int(long __this__nativeId, io.qt.core.QPointF[] points);
    
    /**
     * 
See QPainter::drawEllipse(QPoint,int,int)
     */
    @QtUninvokable
    public final void drawEllipse(io.qt.core.@NonNull QPoint center, int rx, int ry){
        drawEllipse_native_cref_QPoint_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(center), rx, ry);
    }
    
    @QtUninvokable
    private native void drawEllipse_native_cref_QPoint_int_int(long __this__nativeId, long center, int rx, int ry);
    
    /**
     * 
See QPainter::drawEllipse(QPointF,qreal,qreal)
     */
    @QtUninvokable
    public final void drawEllipse(io.qt.core.@NonNull QPointF center, double rx, double ry){
        drawEllipse_native_cref_QPointF_qreal_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(center), rx, ry);
    }
    
    @QtUninvokable
    private native void drawEllipse_native_cref_QPointF_qreal_qreal(long __this__nativeId, long center, double rx, double ry);
    
    /**
     * 
See QPainter::drawEllipse(QRect)
     */
    @QtUninvokable
    public final void drawEllipse(io.qt.core.@NonNull QRect r){
        drawEllipse_native_cref_QRect(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r));
    }
    
    @QtUninvokable
    private native void drawEllipse_native_cref_QRect(long __this__nativeId, long r);
    
    /**
     * 
See QPainter::drawEllipse(QRectF)
     */
    @QtUninvokable
    public final void drawEllipse(io.qt.core.@NonNull QRectF r){
        drawEllipse_native_cref_QRectF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r));
    }
    
    @QtUninvokable
    private native void drawEllipse_native_cref_QRectF(long __this__nativeId, long r);
    
    /**
     * 
See QPainter::drawEllipse(int,int,int,int)
     */
    @QtUninvokable
    public final void drawEllipse(int x, int y, int w, int h){
        drawEllipse_native_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h);
    }
    
    @QtUninvokable
    private native void drawEllipse_native_int_int_int_int(long __this__nativeId, int x, int y, int w, int h);
    
    /**
     * 
See QPainter::drawGlyphRun(QPointF,QGlyphRun)
     */
    @QtUninvokable
    public final void drawGlyphRun(io.qt.core.@NonNull QPointF position, io.qt.gui.@NonNull QGlyphRun glyphRun){
        drawGlyphRun_native_cref_QPointF_cref_QGlyphRun(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(position), QtJambi_LibraryUtilities.internal.checkedNativeId(glyphRun));
    }
    
    @QtUninvokable
    private native void drawGlyphRun_native_cref_QPointF_cref_QGlyphRun(long __this__nativeId, long position, long glyphRun);
    
    /**
     * 
See QPainter::drawImage(QPoint,QImage)
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QPoint p, io.qt.gui.@NonNull QImage image){
        drawImage_native_cref_QPoint_cref_QImage(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(image));
    }
    
    @QtUninvokable
    private native void drawImage_native_cref_QPoint_cref_QImage(long __this__nativeId, long p, long image);
    
    /**
     * 
See QPainter::drawImage(QPoint,QImage,QRect,Qt::ImageConversionFlags)
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QPoint p, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRect sr, io.qt.core.Qt.@NonNull ImageConversionFlags flags){
        drawImage_native_cref_QPoint_cref_QImage_cref_QRect_Qt_ImageConversionFlags(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(image), QtJambi_LibraryUtilities.internal.checkedNativeId(sr), flags.value());
    }
    
    @QtUninvokable
    private native void drawImage_native_cref_QPoint_cref_QImage_cref_QRect_Qt_ImageConversionFlags(long __this__nativeId, long p, long image, long sr, int flags);
    
    /**
     * 
See QPainter::drawImage(QPointF,QImage)
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QPointF p, io.qt.gui.@NonNull QImage image){
        drawImage_native_cref_QPointF_cref_QImage(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(image));
    }
    
    @QtUninvokable
    private native void drawImage_native_cref_QPointF_cref_QImage(long __this__nativeId, long p, long image);
    
    /**
     * 
See QPainter::drawImage(QPointF,QImage,QRectF,Qt::ImageConversionFlags)
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QPointF p, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRectF sr, io.qt.core.Qt.@NonNull ImageConversionFlags flags){
        drawImage_native_cref_QPointF_cref_QImage_cref_QRectF_Qt_ImageConversionFlags(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(image), QtJambi_LibraryUtilities.internal.checkedNativeId(sr), flags.value());
    }
    
    @QtUninvokable
    private native void drawImage_native_cref_QPointF_cref_QImage_cref_QRectF_Qt_ImageConversionFlags(long __this__nativeId, long p, long image, long sr, int flags);
    
    /**
     * 
See QPainter::drawImage(QRect,QImage)
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QRect r, io.qt.gui.@NonNull QImage image){
        drawImage_native_cref_QRect_cref_QImage(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), QtJambi_LibraryUtilities.internal.checkedNativeId(image));
    }
    
    @QtUninvokable
    private native void drawImage_native_cref_QRect_cref_QImage(long __this__nativeId, long r, long image);
    
    /**
     * 
See QPainter::drawImage(QRect,QImage,QRect,Qt::ImageConversionFlags)
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QRect targetRect, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRect sourceRect, io.qt.core.Qt.@NonNull ImageConversionFlags flags){
        drawImage_native_cref_QRect_cref_QImage_cref_QRect_Qt_ImageConversionFlags(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(targetRect), QtJambi_LibraryUtilities.internal.checkedNativeId(image), QtJambi_LibraryUtilities.internal.checkedNativeId(sourceRect), flags.value());
    }
    
    @QtUninvokable
    private native void drawImage_native_cref_QRect_cref_QImage_cref_QRect_Qt_ImageConversionFlags(long __this__nativeId, long targetRect, long image, long sourceRect, int flags);
    
    /**
     * 
See QPainter::drawImage(QRectF,QImage)
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QRectF r, io.qt.gui.@NonNull QImage image){
        drawImage_native_cref_QRectF_cref_QImage(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), QtJambi_LibraryUtilities.internal.checkedNativeId(image));
    }
    
    @QtUninvokable
    private native void drawImage_native_cref_QRectF_cref_QImage(long __this__nativeId, long r, long image);
    
    /**
     * 
See QPainter::drawImage(QRectF,QImage,QRectF,Qt::ImageConversionFlags)
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QRectF targetRect, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRectF sourceRect, io.qt.core.Qt.@NonNull ImageConversionFlags flags){
        drawImage_native_cref_QRectF_cref_QImage_cref_QRectF_Qt_ImageConversionFlags(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(targetRect), QtJambi_LibraryUtilities.internal.checkedNativeId(image), QtJambi_LibraryUtilities.internal.checkedNativeId(sourceRect), flags.value());
    }
    
    @QtUninvokable
    private native void drawImage_native_cref_QRectF_cref_QImage_cref_QRectF_Qt_ImageConversionFlags(long __this__nativeId, long targetRect, long image, long sourceRect, int flags);
    
    /**
     * 
See QPainter::drawImage(int,int,QImage,int,int,int,int,Qt::ImageConversionFlags)
     */
    @QtUninvokable
    public final void drawImage(int x, int y, io.qt.gui.@NonNull QImage image, int sx, int sy, int sw, int sh, io.qt.core.Qt.@NonNull ImageConversionFlags flags){
        drawImage_native_int_int_cref_QImage_int_int_int_int_Qt_ImageConversionFlags(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, QtJambi_LibraryUtilities.internal.checkedNativeId(image), sx, sy, sw, sh, flags.value());
    }
    
    @QtUninvokable
    private native void drawImage_native_int_int_cref_QImage_int_int_int_int_Qt_ImageConversionFlags(long __this__nativeId, int x, int y, long image, int sx, int sy, int sw, int sh, int flags);
    
    /**
     * 
See QPainter::drawLine(QLine)
     */
    @QtUninvokable
    public final void drawLine(io.qt.core.@NonNull QLine line){
        drawLine_native_cref_QLine(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(line));
    }
    
    @QtUninvokable
    private native void drawLine_native_cref_QLine(long __this__nativeId, long line);
    
    /**
     * 
See QPainter::drawLine(QLineF)
     */
    @QtUninvokable
    public final void drawLine(io.qt.core.@NonNull QLineF line){
        drawLine_native_cref_QLineF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(line));
    }
    
    @QtUninvokable
    private native void drawLine_native_cref_QLineF(long __this__nativeId, long line);
    
    /**
     * 
See QPainter::drawLine(QPoint,QPoint)
     */
    @QtUninvokable
    public final void drawLine(io.qt.core.@NonNull QPoint p1, io.qt.core.@NonNull QPoint p2){
        drawLine_native_cref_QPoint_cref_QPoint(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p1), QtJambi_LibraryUtilities.internal.checkedNativeId(p2));
    }
    
    @QtUninvokable
    private native void drawLine_native_cref_QPoint_cref_QPoint(long __this__nativeId, long p1, long p2);
    
    /**
     * 
See QPainter::drawLine(QPointF,QPointF)
     */
    @QtUninvokable
    public final void drawLine(io.qt.core.@NonNull QPointF p1, io.qt.core.@NonNull QPointF p2){
        drawLine_native_cref_QPointF_cref_QPointF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p1), QtJambi_LibraryUtilities.internal.checkedNativeId(p2));
    }
    
    @QtUninvokable
    private native void drawLine_native_cref_QPointF_cref_QPointF(long __this__nativeId, long p1, long p2);
    
    /**
     * 
See QPainter::drawLine(int,int,int,int)
     */
    @QtUninvokable
    public final void drawLine(int x1, int y1, int x2, int y2){
        drawLine_native_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x1, y1, x2, y2);
    }
    
    @QtUninvokable
    private native void drawLine_native_int_int_int_int(long __this__nativeId, int x1, int y1, int x2, int y2);
    
    /**
     * 
See QPainter::drawLines(QList<QLine>)
     */
    @QtUninvokable
    public final void drawLines(java.util.@NonNull Collection lines){
        drawLines_native_cref_QList(QtJambi_LibraryUtilities.internal.nativeId(this), lines);
    }
    
    @QtUninvokable
    private native void drawLines_native_cref_QList(long __this__nativeId, java.util.Collection lines);
    
    /**
     * 
See QPainter::drawLines(QList<QLineF>)
     */
    @QtUninvokable
    public final void drawLinesF(java.util.@NonNull Collection lines){
        drawLinesF_native_cref_QList(QtJambi_LibraryUtilities.internal.nativeId(this), lines);
    }
    
    @QtUninvokable
    private native void drawLinesF_native_cref_QList(long __this__nativeId, java.util.Collection lines);
    
    /**
     * 
See QPainter::drawLines(QList<QPoint>)
     */
    @QtUninvokable
    public final void drawLinesFromPoints(java.util.@NonNull Collection pointPairs){
        drawLinesFromPoints_native_cref_QList(QtJambi_LibraryUtilities.internal.nativeId(this), pointPairs);
    }
    
    @QtUninvokable
    private native void drawLinesFromPoints_native_cref_QList(long __this__nativeId, java.util.Collection pointPairs);
    
    /**
     * 
See QPainter::drawLines(QList<QPointF>)
     */
    @QtUninvokable
    public final void drawLinesFromPointsF(java.util.@NonNull Collection pointPairs){
        drawLinesFromPointsF_native_cref_QList(QtJambi_LibraryUtilities.internal.nativeId(this), pointPairs);
    }
    
    @QtUninvokable
    private native void drawLinesFromPointsF_native_cref_QList(long __this__nativeId, java.util.Collection pointPairs);
    
    /**
     * 
See QPainter::drawLines(const QLine*,int)
     */
    @QtUninvokable
    public final void drawLines(io.qt.core.@NonNull QLine... lines){
        drawLines_native_const_QLine_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), lines);
    }
    
    @QtUninvokable
    private native void drawLines_native_const_QLine_ptr_int(long __this__nativeId, io.qt.core.QLine[] lines);
    
    /**
     * 
See QPainter::drawLines(const QLineF*,int)
     */
    @QtUninvokable
    public final void drawLines(io.qt.core.@NonNull QLineF... lines){
        drawLines_native_const_QLineF_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), lines);
    }
    
    @QtUninvokable
    private native void drawLines_native_const_QLineF_ptr_int(long __this__nativeId, io.qt.core.QLineF[] lines);
    
    /**
     * 
See QPainter::drawLines(const QPoint*,int)
     */
    @QtUninvokable
    public final void drawLines(io.qt.core.@NonNull QPoint... pointPairs){
        drawLines_native_const_QPoint_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), pointPairs);
    }
    
    @QtUninvokable
    private native void drawLines_native_const_QPoint_ptr_int(long __this__nativeId, io.qt.core.QPoint[] pointPairs);
    
    /**
     * 
See QPainter::drawLines(const QPointF*,int)
     */
    @QtUninvokable
    public final void drawLines(io.qt.core.@NonNull QPointF... pointPairs){
        drawLines_native_const_QPointF_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), pointPairs);
    }
    
    @QtUninvokable
    private native void drawLines_native_const_QPointF_ptr_int(long __this__nativeId, io.qt.core.QPointF[] pointPairs);
    
    /**
     * 
See QPainter::drawPath(QPainterPath)
     */
    @QtUninvokable
    public final void drawPath(io.qt.gui.@NonNull QPainterPath path){
        drawPath_native_cref_QPainterPath(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(path));
    }
    
    @QtUninvokable
    private native void drawPath_native_cref_QPainterPath(long __this__nativeId, long path);
    
    /**
     * 
See QPainter::drawPicture(QPoint,QPicture)
     */
    @QtUninvokable
    public final void drawPicture(io.qt.core.@NonNull QPoint p, io.qt.gui.@NonNull QPicture picture){
        drawPicture_native_cref_QPoint_cref_QPicture(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(picture));
    }
    
    @QtUninvokable
    private native void drawPicture_native_cref_QPoint_cref_QPicture(long __this__nativeId, long p, long picture);
    
    /**
     * 
See QPainter::drawPicture(QPointF,QPicture)
     */
    @QtUninvokable
    public final void drawPicture(io.qt.core.@NonNull QPointF p, io.qt.gui.@NonNull QPicture picture){
        drawPicture_native_cref_QPointF_cref_QPicture(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(picture));
    }
    
    @QtUninvokable
    private native void drawPicture_native_cref_QPointF_cref_QPicture(long __this__nativeId, long p, long picture);
    
    /**
     * 
See QPainter::drawPicture(int,int,QPicture)
     */
    @QtUninvokable
    public final void drawPicture(int x, int y, io.qt.gui.@NonNull QPicture picture){
        drawPicture_native_int_int_cref_QPicture(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, QtJambi_LibraryUtilities.internal.checkedNativeId(picture));
    }
    
    @QtUninvokable
    private native void drawPicture_native_int_int_cref_QPicture(long __this__nativeId, int x, int y, long picture);
    
    /**
     * 
See QPainter::drawPie(QRect,int,int)
     */
    @QtUninvokable
    public final void drawPie(io.qt.core.@NonNull QRect arg__1, int a, int alen){
        drawPie_native_cref_QRect_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), a, alen);
    }
    
    @QtUninvokable
    private native void drawPie_native_cref_QRect_int_int(long __this__nativeId, long arg__1, int a, int alen);
    
    /**
     * 
See QPainter::drawPie(QRectF,int,int)
     */
    @QtUninvokable
    public final void drawPie(io.qt.core.@NonNull QRectF rect, int a, int alen){
        drawPie_native_cref_QRectF_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect), a, alen);
    }
    
    @QtUninvokable
    private native void drawPie_native_cref_QRectF_int_int(long __this__nativeId, long rect, int a, int alen);
    
    /**
     * 
See QPainter::drawPie(int,int,int,int,int,int)
     */
    @QtUninvokable
    public final void drawPie(int x, int y, int w, int h, int a, int alen){
        drawPie_native_int_int_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, a, alen);
    }
    
    @QtUninvokable
    private native void drawPie_native_int_int_int_int_int_int(long __this__nativeId, int x, int y, int w, int h, int a, int alen);
    
    /**
     * 
See QPainter::drawPixmap(QPoint,QPixmap)
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QPoint p, io.qt.gui.@NonNull QPixmap pm){
        drawPixmap_native_cref_QPoint_cref_QPixmap(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(pm));
    }
    
    @QtUninvokable
    private native void drawPixmap_native_cref_QPoint_cref_QPixmap(long __this__nativeId, long p, long pm);
    
    /**
     * 
See QPainter::drawPixmap(QPoint,QPixmap,QRect)
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QPoint p, io.qt.gui.@NonNull QPixmap pm, io.qt.core.@NonNull QRect sr){
        drawPixmap_native_cref_QPoint_cref_QPixmap_cref_QRect(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(pm), QtJambi_LibraryUtilities.internal.checkedNativeId(sr));
    }
    
    @QtUninvokable
    private native void drawPixmap_native_cref_QPoint_cref_QPixmap_cref_QRect(long __this__nativeId, long p, long pm, long sr);
    
    /**
     * 
See QPainter::drawPixmap(QPointF,QPixmap)
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QPointF p, io.qt.gui.@NonNull QPixmap pm){
        drawPixmap_native_cref_QPointF_cref_QPixmap(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(pm));
    }
    
    @QtUninvokable
    private native void drawPixmap_native_cref_QPointF_cref_QPixmap(long __this__nativeId, long p, long pm);
    
    /**
     * 
See QPainter::drawPixmap(QPointF,QPixmap,QRectF)
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QPointF p, io.qt.gui.@NonNull QPixmap pm, io.qt.core.@NonNull QRectF sr){
        drawPixmap_native_cref_QPointF_cref_QPixmap_cref_QRectF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(pm), QtJambi_LibraryUtilities.internal.checkedNativeId(sr));
    }
    
    @QtUninvokable
    private native void drawPixmap_native_cref_QPointF_cref_QPixmap_cref_QRectF(long __this__nativeId, long p, long pm, long sr);
    
    /**
     * 
See QPainter::drawPixmap(QRect,QPixmap)
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QRect r, io.qt.gui.@NonNull QPixmap pm){
        drawPixmap_native_cref_QRect_cref_QPixmap(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), QtJambi_LibraryUtilities.internal.checkedNativeId(pm));
    }
    
    @QtUninvokable
    private native void drawPixmap_native_cref_QRect_cref_QPixmap(long __this__nativeId, long r, long pm);
    
    /**
     * 
See QPainter::drawPixmap(QRect,QPixmap,QRect)
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QRect targetRect, io.qt.gui.@NonNull QPixmap pixmap, io.qt.core.@NonNull QRect sourceRect){
        drawPixmap_native_cref_QRect_cref_QPixmap_cref_QRect(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(targetRect), QtJambi_LibraryUtilities.internal.checkedNativeId(pixmap), QtJambi_LibraryUtilities.internal.checkedNativeId(sourceRect));
    }
    
    @QtUninvokable
    private native void drawPixmap_native_cref_QRect_cref_QPixmap_cref_QRect(long __this__nativeId, long targetRect, long pixmap, long sourceRect);
    
    /**
     * 
See QPainter::drawPixmap(QRectF,QPixmap,QRectF)
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QRectF targetRect, io.qt.gui.@NonNull QPixmap pixmap, io.qt.core.@NonNull QRectF sourceRect){
        drawPixmap_native_cref_QRectF_cref_QPixmap_cref_QRectF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(targetRect), QtJambi_LibraryUtilities.internal.checkedNativeId(pixmap), QtJambi_LibraryUtilities.internal.checkedNativeId(sourceRect));
    }
    
    @QtUninvokable
    private native void drawPixmap_native_cref_QRectF_cref_QPixmap_cref_QRectF(long __this__nativeId, long targetRect, long pixmap, long sourceRect);
    
    /**
     * 
See QPainter::drawPixmap(int,int,QPixmap)
     */
    @QtUninvokable
    public final void drawPixmap(int x, int y, io.qt.gui.@NonNull QPixmap pm){
        drawPixmap_native_int_int_cref_QPixmap(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, QtJambi_LibraryUtilities.internal.checkedNativeId(pm));
    }
    
    @QtUninvokable
    private native void drawPixmap_native_int_int_cref_QPixmap(long __this__nativeId, int x, int y, long pm);
    
    /**
     * 
See QPainter::drawPixmap(int,int,QPixmap,int,int,int,int)
     */
    @QtUninvokable
    public final void drawPixmap(int x, int y, io.qt.gui.@NonNull QPixmap pm, int sx, int sy, int sw, int sh){
        drawPixmap_native_int_int_cref_QPixmap_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, QtJambi_LibraryUtilities.internal.checkedNativeId(pm), sx, sy, sw, sh);
    }
    
    @QtUninvokable
    private native void drawPixmap_native_int_int_cref_QPixmap_int_int_int_int(long __this__nativeId, int x, int y, long pm, int sx, int sy, int sw, int sh);
    
    /**
     * 
See QPainter::drawPixmap(int,int,int,int,QPixmap)
     */
    @QtUninvokable
    public final void drawPixmap(int x, int y, int w, int h, io.qt.gui.@NonNull QPixmap pm){
        drawPixmap_native_int_int_int_int_cref_QPixmap(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, QtJambi_LibraryUtilities.internal.checkedNativeId(pm));
    }
    
    @QtUninvokable
    private native void drawPixmap_native_int_int_int_int_cref_QPixmap(long __this__nativeId, int x, int y, int w, int h, long pm);
    
    /**
     * 
See QPainter::drawPixmap(int,int,int,int,QPixmap,int,int,int,int)
     */
    @QtUninvokable
    public final void drawPixmap(int x, int y, int w, int h, io.qt.gui.@NonNull QPixmap pm, int sx, int sy, int sw, int sh){
        drawPixmap_native_int_int_int_int_cref_QPixmap_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, QtJambi_LibraryUtilities.internal.checkedNativeId(pm), sx, sy, sw, sh);
    }
    
    @QtUninvokable
    private native void drawPixmap_native_int_int_int_int_cref_QPixmap_int_int_int_int(long __this__nativeId, int x, int y, int w, int h, long pm, int sx, int sy, int sw, int sh);
    
    /**
     * 
See QPainter::drawPixmapFragments(const QPainter::PixmapFragment*,int,QPixmap,QPainter::PixmapFragmentHints)
     */
    @QtUninvokable
    public final void drawPixmapFragments(io.qt.gui.QPainter.@NonNull PixmapFragment[] fragments, io.qt.gui.@NonNull QPixmap pixmap, io.qt.gui.QPainter.@NonNull PixmapFragmentHints hints){
        drawPixmapFragments_native_const_QPainter_PixmapFragment_ptr_int_cref_QPixmap_QPainter_PixmapFragmentHints(QtJambi_LibraryUtilities.internal.nativeId(this), fragments, QtJambi_LibraryUtilities.internal.checkedNativeId(pixmap), hints.value());
    }
    
    @QtUninvokable
    private native void drawPixmapFragments_native_const_QPainter_PixmapFragment_ptr_int_cref_QPixmap_QPainter_PixmapFragmentHints(long __this__nativeId, io.qt.gui.QPainter.PixmapFragment[] fragments, long pixmap, int hints);
    
    /**
     * 
See QPainter::drawPoint(QPoint)
     */
    @QtUninvokable
    public final void drawPoint(io.qt.core.@NonNull QPoint p){
        drawPoint_native_cref_QPoint(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p));
    }
    
    @QtUninvokable
    private native void drawPoint_native_cref_QPoint(long __this__nativeId, long p);
    
    /**
     * 
See QPainter::drawPoint(QPointF)
     */
    @QtUninvokable
    public final void drawPoint(io.qt.core.@NonNull QPointF pt){
        drawPoint_native_cref_QPointF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(pt));
    }
    
    @QtUninvokable
    private native void drawPoint_native_cref_QPointF(long __this__nativeId, long pt);
    
    /**
     * 
See QPainter::drawPoint(int,int)
     */
    @QtUninvokable
    public final void drawPoint(int x, int y){
        drawPoint_native_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void drawPoint_native_int_int(long __this__nativeId, int x, int y);
    
    /**
     * 
See QPainter::drawPoints(QPolygon)
     */
    @QtUninvokable
    public final void drawPoints(io.qt.gui.@NonNull QPolygon points){
        drawPoints_native_cref_QPolygon(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(points));
    }
    
    @QtUninvokable
    private native void drawPoints_native_cref_QPolygon(long __this__nativeId, long points);
    
    /**
     * 
See QPainter::drawPoints(QPolygonF)
     */
    @QtUninvokable
    public final void drawPoints(io.qt.gui.@NonNull QPolygonF points){
        drawPoints_native_cref_QPolygonF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(points));
    }
    
    @QtUninvokable
    private native void drawPoints_native_cref_QPolygonF(long __this__nativeId, long points);
    
    /**
     * 
See QPainter::drawPoints(const QPoint*,int)
     */
    @QtUninvokable
    public final void drawPoints(io.qt.core.@NonNull QPoint... points){
        drawPoints_native_const_QPoint_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), points);
    }
    
    @QtUninvokable
    private native void drawPoints_native_const_QPoint_ptr_int(long __this__nativeId, io.qt.core.QPoint[] points);
    
    /**
     * 
See QPainter::drawPoints(const QPointF*,int)
     */
    @QtUninvokable
    public final void drawPoints(io.qt.core.@NonNull QPointF... points){
        drawPoints_native_const_QPointF_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), points);
    }
    
    @QtUninvokable
    private native void drawPoints_native_const_QPointF_ptr_int(long __this__nativeId, io.qt.core.QPointF[] points);
    
    /**
     * 
See QPainter::drawPolygon(QPolygon,Qt::FillRule)
     */
    @QtUninvokable
    public final void drawPolygon(io.qt.gui.@NonNull QPolygon polygon, io.qt.core.Qt.@NonNull FillRule fillRule){
        drawPolygon_native_cref_QPolygon_Qt_FillRule(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(polygon), fillRule.value());
    }
    
    @QtUninvokable
    private native void drawPolygon_native_cref_QPolygon_Qt_FillRule(long __this__nativeId, long polygon, int fillRule);
    
    /**
     * 
See QPainter::drawPolygon(QPolygonF,Qt::FillRule)
     */
    @QtUninvokable
    public final void drawPolygon(io.qt.gui.@NonNull QPolygonF polygon, io.qt.core.Qt.@NonNull FillRule fillRule){
        drawPolygon_native_cref_QPolygonF_Qt_FillRule(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(polygon), fillRule.value());
    }
    
    @QtUninvokable
    private native void drawPolygon_native_cref_QPolygonF_Qt_FillRule(long __this__nativeId, long polygon, int fillRule);
    
    /**
     * 
See QPainter::drawPolygon(const QPoint*,int,Qt::FillRule)
     */
    @QtUninvokable
    public final void drawPolygon(io.qt.core.@NonNull QPoint[] points, io.qt.core.Qt.@NonNull FillRule fillRule){
        drawPolygon_native_const_QPoint_ptr_int_Qt_FillRule(QtJambi_LibraryUtilities.internal.nativeId(this), points, fillRule.value());
    }
    
    @QtUninvokable
    private native void drawPolygon_native_const_QPoint_ptr_int_Qt_FillRule(long __this__nativeId, io.qt.core.QPoint[] points, int fillRule);
    
    /**
     * 
See QPainter::drawPolygon(const QPointF*,int,Qt::FillRule)
     */
    @QtUninvokable
    public final void drawPolygon(io.qt.core.@NonNull QPointF[] points, io.qt.core.Qt.@NonNull FillRule fillRule){
        drawPolygon_native_const_QPointF_ptr_int_Qt_FillRule(QtJambi_LibraryUtilities.internal.nativeId(this), points, fillRule.value());
    }
    
    @QtUninvokable
    private native void drawPolygon_native_const_QPointF_ptr_int_Qt_FillRule(long __this__nativeId, io.qt.core.QPointF[] points, int fillRule);
    
    /**
     * 
See QPainter::drawPolyline(QPolygon)
     */
    @QtUninvokable
    public final void drawPolyline(io.qt.gui.@NonNull QPolygon polygon){
        drawPolyline_native_cref_QPolygon(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(polygon));
    }
    
    @QtUninvokable
    private native void drawPolyline_native_cref_QPolygon(long __this__nativeId, long polygon);
    
    /**
     * 
See QPainter::drawPolyline(QPolygonF)
     */
    @QtUninvokable
    public final void drawPolyline(io.qt.gui.@NonNull QPolygonF polyline){
        drawPolyline_native_cref_QPolygonF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(polyline));
    }
    
    @QtUninvokable
    private native void drawPolyline_native_cref_QPolygonF(long __this__nativeId, long polyline);
    
    /**
     * 
See QPainter::drawPolyline(const QPoint*,int)
     */
    @QtUninvokable
    public final void drawPolyline(io.qt.core.@NonNull QPoint... points){
        drawPolyline_native_const_QPoint_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), points);
    }
    
    @QtUninvokable
    private native void drawPolyline_native_const_QPoint_ptr_int(long __this__nativeId, io.qt.core.QPoint[] points);
    
    /**
     * 
See QPainter::drawPolyline(const QPointF*,int)
     */
    @QtUninvokable
    public final void drawPolyline(io.qt.core.@NonNull QPointF... points){
        drawPolyline_native_const_QPointF_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), points);
    }
    
    @QtUninvokable
    private native void drawPolyline_native_const_QPointF_ptr_int(long __this__nativeId, io.qt.core.QPointF[] points);
    
    /**
     * 
See QPainter::drawRect(QRect)
     */
    @QtUninvokable
    public final void drawRect(io.qt.core.@NonNull QRect rect){
        drawRect_native_cref_QRect(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect));
    }
    
    @QtUninvokable
    private native void drawRect_native_cref_QRect(long __this__nativeId, long rect);
    
    /**
     * 
See QPainter::drawRect(QRectF)
     */
    @QtUninvokable
    public final void drawRect(io.qt.core.@NonNull QRectF rect){
        drawRect_native_cref_QRectF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect));
    }
    
    @QtUninvokable
    private native void drawRect_native_cref_QRectF(long __this__nativeId, long rect);
    
    /**
     * 
See QPainter::drawRect(int,int,int,int)
     */
    @QtUninvokable
    public final void drawRect(int x1, int y1, int w, int h){
        drawRect_native_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x1, y1, w, h);
    }
    
    @QtUninvokable
    private native void drawRect_native_int_int_int_int(long __this__nativeId, int x1, int y1, int w, int h);
    
    /**
     * 
See QPainter::drawRects(QList<QRect>)
     */
    @QtUninvokable
    public final void drawRects(java.util.@NonNull Collection rectangles){
        drawRects_native_cref_QList(QtJambi_LibraryUtilities.internal.nativeId(this), rectangles);
    }
    
    @QtUninvokable
    private native void drawRects_native_cref_QList(long __this__nativeId, java.util.Collection rectangles);
    
    /**
     * 
See QPainter::drawRects(QList<QRectF>)
     */
    @QtUninvokable
    public final void drawRectsF(java.util.@NonNull Collection rectangles){
        drawRectsF_native_cref_QList(QtJambi_LibraryUtilities.internal.nativeId(this), rectangles);
    }
    
    @QtUninvokable
    private native void drawRectsF_native_cref_QList(long __this__nativeId, java.util.Collection rectangles);
    
    /**
     * 
See QPainter::drawRects(const QRect*,int)
     */
    @QtUninvokable
    public final void drawRects(io.qt.core.@NonNull QRect... rects){
        drawRects_native_const_QRect_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), rects);
    }
    
    @QtUninvokable
    private native void drawRects_native_const_QRect_ptr_int(long __this__nativeId, io.qt.core.QRect[] rects);
    
    /**
     * 
See QPainter::drawRects(const QRectF*,int)
     */
    @QtUninvokable
    public final void drawRects(io.qt.core.@NonNull QRectF... rects){
        drawRects_native_const_QRectF_ptr_int(QtJambi_LibraryUtilities.internal.nativeId(this), rects);
    }
    
    @QtUninvokable
    private native void drawRects_native_const_QRectF_ptr_int(long __this__nativeId, io.qt.core.QRectF[] rects);
    
    /**
     * 
See QPainter::drawRoundedRect(QRect,qreal,qreal,Qt::SizeMode)
     */
    @QtUninvokable
    public final void drawRoundedRect(io.qt.core.@NonNull QRect rect, double xRadius, double yRadius, io.qt.core.Qt.@NonNull SizeMode mode){
        drawRoundedRect_native_cref_QRect_qreal_qreal_Qt_SizeMode(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect), xRadius, yRadius, mode.value());
    }
    
    @QtUninvokable
    private native void drawRoundedRect_native_cref_QRect_qreal_qreal_Qt_SizeMode(long __this__nativeId, long rect, double xRadius, double yRadius, int mode);
    
    /**
     * 
See QPainter::drawRoundedRect(QRectF,qreal,qreal,Qt::SizeMode)
     */
    @QtUninvokable
    public final void drawRoundedRect(io.qt.core.@NonNull QRectF rect, double xRadius, double yRadius, io.qt.core.Qt.@NonNull SizeMode mode){
        drawRoundedRect_native_cref_QRectF_qreal_qreal_Qt_SizeMode(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect), xRadius, yRadius, mode.value());
    }
    
    @QtUninvokable
    private native void drawRoundedRect_native_cref_QRectF_qreal_qreal_Qt_SizeMode(long __this__nativeId, long rect, double xRadius, double yRadius, int mode);
    
    /**
     * 
See QPainter::drawRoundedRect(int,int,int,int,qreal,qreal,Qt::SizeMode)
     */
    @QtUninvokable
    public final void drawRoundedRect(int x, int y, int w, int h, double xRadius, double yRadius, io.qt.core.Qt.@NonNull SizeMode mode){
        drawRoundedRect_native_int_int_int_int_qreal_qreal_Qt_SizeMode(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, xRadius, yRadius, mode.value());
    }
    
    @QtUninvokable
    private native void drawRoundedRect_native_int_int_int_int_qreal_qreal_Qt_SizeMode(long __this__nativeId, int x, int y, int w, int h, double xRadius, double yRadius, int mode);
    
    /**
     * 
See QPainter::drawStaticText(QPoint,QStaticText)
     */
    @QtUninvokable
    public final void drawStaticText(io.qt.core.@NonNull QPoint topLeftPosition, io.qt.gui.@NonNull QStaticText staticText){
        drawStaticText_native_cref_QPoint_cref_QStaticText(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(topLeftPosition), QtJambi_LibraryUtilities.internal.checkedNativeId(staticText));
    }
    
    @QtUninvokable
    private native void drawStaticText_native_cref_QPoint_cref_QStaticText(long __this__nativeId, long topLeftPosition, long staticText);
    
    /**
     * 
See QPainter::drawStaticText(QPointF,QStaticText)
     */
    @QtUninvokable
    public final void drawStaticText(io.qt.core.@NonNull QPointF topLeftPosition, io.qt.gui.@NonNull QStaticText staticText){
        drawStaticText_native_cref_QPointF_cref_QStaticText(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(topLeftPosition), QtJambi_LibraryUtilities.internal.checkedNativeId(staticText));
    }
    
    @QtUninvokable
    private native void drawStaticText_native_cref_QPointF_cref_QStaticText(long __this__nativeId, long topLeftPosition, long staticText);
    
    /**
     * 
See QPainter::drawStaticText(int,int,QStaticText)
     */
    @QtUninvokable
    public final void drawStaticText(int left, int top, io.qt.gui.@NonNull QStaticText staticText){
        drawStaticText_native_int_int_cref_QStaticText(QtJambi_LibraryUtilities.internal.nativeId(this), left, top, QtJambi_LibraryUtilities.internal.checkedNativeId(staticText));
    }
    
    @QtUninvokable
    private native void drawStaticText_native_int_int_cref_QStaticText(long __this__nativeId, int left, int top, long staticText);
    
    /**
     * 
See QPainter::drawText(QPoint,QString)
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QPoint p, java.lang.@NonNull String s){
        drawText_native_cref_QPoint_cref_QString(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), s);
    }
    
    @QtUninvokable
    private native void drawText_native_cref_QPoint_cref_QString(long __this__nativeId, long p, java.lang.String s);
    
    /**
     * 
See QPainter::drawText(QPointF,QString)
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QPointF p, java.lang.@NonNull String s){
        drawText_native_cref_QPointF_cref_QString(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), s);
    }
    
    @QtUninvokable
    private native void drawText_native_cref_QPointF_cref_QString(long __this__nativeId, long p, java.lang.String s);
    
    /**
     * 
See QPainter::drawText(QRect,int,QString,QRect*)
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRect r, int flags, java.lang.@NonNull String text, io.qt.core.@Nullable QRect br){
        drawText_native_cref_QRect_int_cref_QString_QRect_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), flags, text, QtJambi_LibraryUtilities.internal.checkedNativeId(br));
    }
    
    @QtUninvokable
    private native void drawText_native_cref_QRect_int_cref_QString_QRect_ptr(long __this__nativeId, long r, int flags, java.lang.String text, long br);
    
    /**
     * 
See QPainter::drawText(QRectF,QString,QTextOption)
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRectF r, java.lang.@NonNull String text, io.qt.gui.@NonNull QTextOption o){
        drawText_native_cref_QRectF_cref_QString_cref_QTextOption(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), text, QtJambi_LibraryUtilities.internal.checkedNativeId(o));
    }
    
    @QtUninvokable
    private native void drawText_native_cref_QRectF_cref_QString_cref_QTextOption(long __this__nativeId, long r, java.lang.String text, long o);
    
    /**
     * 
See QPainter::drawText(QRectF,int,QString,QRectF*)
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRectF r, int flags, java.lang.@NonNull String text, io.qt.core.@Nullable QRectF br){
        drawText_native_cref_QRectF_int_cref_QString_QRectF_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), flags, text, QtJambi_LibraryUtilities.internal.checkedNativeId(br));
    }
    
    @QtUninvokable
    private native void drawText_native_cref_QRectF_int_cref_QString_QRectF_ptr(long __this__nativeId, long r, int flags, java.lang.String text, long br);
    
    /**
     * 
See QPainter::drawText(int,int,QString)
     */
    @QtUninvokable
    public final void drawText(int x, int y, java.lang.@NonNull String s){
        drawText_native_int_int_cref_QString(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, s);
    }
    
    @QtUninvokable
    private native void drawText_native_int_int_cref_QString(long __this__nativeId, int x, int y, java.lang.String s);
    
    /**
     * 
See QPainter::drawText(int,int,int,int,int,QString,QRect*)
     */
    @QtUninvokable
    public final void drawText(int x, int y, int w, int h, int flags, java.lang.@NonNull String text, io.qt.core.@Nullable QRect br){
        drawText_native_int_int_int_int_int_cref_QString_QRect_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, flags, text, QtJambi_LibraryUtilities.internal.checkedNativeId(br));
    }
    
    @QtUninvokable
    private native void drawText_native_int_int_int_int_int_cref_QString_QRect_ptr(long __this__nativeId, int x, int y, int w, int h, int flags, java.lang.String text, long br);
    
    /**
     * 
See QPainter::drawTextItem(QPoint,QTextItem)
     */
    @QtUninvokable
    public final void drawTextItem(io.qt.core.@NonNull QPoint p, io.qt.gui.@StrictNonNull QTextItem ti){
        java.util.Objects.requireNonNull(ti, "Argument 'ti': null not expected.");
        drawTextItem_native_cref_QPoint_cref_QTextItem(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(ti));
    }
    
    @QtUninvokable
    private native void drawTextItem_native_cref_QPoint_cref_QTextItem(long __this__nativeId, long p, long ti);
    
    /**
     * 
See QPainter::drawTextItem(QPointF,QTextItem)
     */
    @QtUninvokable
    public final void drawTextItem(io.qt.core.@NonNull QPointF p, io.qt.gui.@StrictNonNull QTextItem ti){
        java.util.Objects.requireNonNull(ti, "Argument 'ti': null not expected.");
        drawTextItem_native_cref_QPointF_cref_QTextItem(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(p), QtJambi_LibraryUtilities.internal.checkedNativeId(ti));
    }
    
    @QtUninvokable
    private native void drawTextItem_native_cref_QPointF_cref_QTextItem(long __this__nativeId, long p, long ti);
    
    /**
     * 
See QPainter::drawTextItem(int,int,QTextItem)
     */
    @QtUninvokable
    public final void drawTextItem(int x, int y, io.qt.gui.@StrictNonNull QTextItem ti){
        java.util.Objects.requireNonNull(ti, "Argument 'ti': null not expected.");
        drawTextItem_native_int_int_cref_QTextItem(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, QtJambi_LibraryUtilities.internal.checkedNativeId(ti));
    }
    
    @QtUninvokable
    private native void drawTextItem_native_int_int_cref_QTextItem(long __this__nativeId, int x, int y, long ti);
    
    /**
     * 
See QPainter::drawTiledPixmap(QRect,QPixmap,QPoint)
     */
    @QtUninvokable
    public final void drawTiledPixmap(io.qt.core.@NonNull QRect arg__1, io.qt.gui.@NonNull QPixmap arg__2, io.qt.core.@NonNull QPoint arg__3){
        drawTiledPixmap_native_cref_QRect_cref_QPixmap_cref_QPoint(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__2), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__3));
    }
    
    @QtUninvokable
    private native void drawTiledPixmap_native_cref_QRect_cref_QPixmap_cref_QPoint(long __this__nativeId, long arg__1, long arg__2, long arg__3);
    
    /**
     * 
See QPainter::drawTiledPixmap(QRectF,QPixmap,QPointF)
     */
    @QtUninvokable
    public final void drawTiledPixmap(io.qt.core.@NonNull QRectF rect, io.qt.gui.@NonNull QPixmap pm, io.qt.core.@NonNull QPointF offset){
        drawTiledPixmap_native_cref_QRectF_cref_QPixmap_cref_QPointF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(rect), QtJambi_LibraryUtilities.internal.checkedNativeId(pm), QtJambi_LibraryUtilities.internal.checkedNativeId(offset));
    }
    
    @QtUninvokable
    private native void drawTiledPixmap_native_cref_QRectF_cref_QPixmap_cref_QPointF(long __this__nativeId, long rect, long pm, long offset);
    
    /**
     * 
See QPainter::drawTiledPixmap(int,int,int,int,QPixmap,int,int)
     */
    @QtUninvokable
    public final void drawTiledPixmap(int x, int y, int w, int h, io.qt.gui.@NonNull QPixmap arg__5, int sx, int sy){
        drawTiledPixmap_native_int_int_int_int_cref_QPixmap_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, QtJambi_LibraryUtilities.internal.checkedNativeId(arg__5), sx, sy);
    }
    
    @QtUninvokable
    private native void drawTiledPixmap_native_int_int_int_int_cref_QPixmap_int_int(long __this__nativeId, int x, int y, int w, int h, long arg__5, int sx, int sy);
    
    /**
     * 
See QPainter::end()
     */
    @QtUninvokable
    public final boolean end(){
        QPaintDevice device = device();
        boolean __qt_return_value = end_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        if(__qt_return_value && device!=null){
            QtJambi_LibraryUtilities.internal.unregisterDependentObject(this, device);
        }
        return __qt_return_value;
    }
    
    @QtUninvokable
    private native boolean end_native(long __this__nativeId);
    
    /**
     * 
See QPainter::endNativePainting()
     */
    @QtUninvokable
    public final void endNativePainting(){
        endNativePainting_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void endNativePainting_native(long __this__nativeId);
    
    /**
     * 
See QPainter::eraseRect(QRect)
     */
    @QtUninvokable
    public final void eraseRect(io.qt.core.@NonNull QRect arg__1){
        eraseRect_native_cref_QRect(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1));
    }
    
    @QtUninvokable
    private native void eraseRect_native_cref_QRect(long __this__nativeId, long arg__1);
    
    /**
     * 
See QPainter::eraseRect(QRectF)
     */
    @QtUninvokable
    public final void eraseRect(io.qt.core.@NonNull QRectF arg__1){
        eraseRect_native_cref_QRectF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1));
    }
    
    @QtUninvokable
    private native void eraseRect_native_cref_QRectF(long __this__nativeId, long arg__1);
    
    /**
     * 
See QPainter::eraseRect(int,int,int,int)
     */
    @QtUninvokable
    public final void eraseRect(int x, int y, int w, int h){
        eraseRect_native_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h);
    }
    
    @QtUninvokable
    private native void eraseRect_native_int_int_int_int(long __this__nativeId, int x, int y, int w, int h);
    
    /**
     * 
See QPainter::fillPath(QPainterPath,QBrush)
     */
    @QtUninvokable
    public final void fillPath(io.qt.gui.@NonNull QPainterPath path, io.qt.gui.@NonNull QBrush brush){
        fillPath_native_cref_QPainterPath_cref_QBrush(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(path), QtJambi_LibraryUtilities.internal.checkedNativeId(brush));
    }
    
    @QtUninvokable
    private native void fillPath_native_cref_QPainterPath_cref_QBrush(long __this__nativeId, long path, long brush);
    
    /**
     * 
See QPainter::fillRect(QRect,QBrush)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect arg__1, io.qt.gui.@NonNull QBrush arg__2){
        fillRect_native_cref_QRect_cref_QBrush(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__2));
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRect_cref_QBrush(long __this__nativeId, long arg__1, long arg__2);
    
    /**
     * 
See QPainter::fillRect(QRect,QColor)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect arg__1, io.qt.gui.@NonNull QColor color){
        fillRect_native_cref_QRect_cref_QColor(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), QtJambi_LibraryUtilities.internal.checkedNativeId(color));
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRect_cref_QColor(long __this__nativeId, long arg__1, long color);
    
    /**
     * 
See QPainter::fillRect(QRect,QGradient::Preset)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect r, io.qt.gui.QGradient.@NonNull Preset preset){
        fillRect_native_cref_QRect_QGradient_Preset(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), preset.value());
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRect_QGradient_Preset(long __this__nativeId, long r, int preset);
    
    /**
     * 
See QPainter::fillRect(QRect,Qt::BrushStyle)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect r, io.qt.core.Qt.@NonNull BrushStyle style){
        fillRect_native_cref_QRect_Qt_BrushStyle(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), style.value());
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRect_Qt_BrushStyle(long __this__nativeId, long r, int style);
    
    /**
     * 
See QPainter::fillRect(QRect,Qt::GlobalColor)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect r, io.qt.core.Qt.@NonNull GlobalColor c){
        fillRect_native_cref_QRect_Qt_GlobalColor(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), c.value());
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRect_Qt_GlobalColor(long __this__nativeId, long r, int c);
    
    /**
     * 
See QPainter::fillRect(QRectF,QBrush)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRectF arg__1, io.qt.gui.@NonNull QBrush arg__2){
        fillRect_native_cref_QRectF_cref_QBrush(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__2));
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRectF_cref_QBrush(long __this__nativeId, long arg__1, long arg__2);
    
    /**
     * 
See QPainter::fillRect(QRectF,QColor)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRectF arg__1, io.qt.gui.@NonNull QColor color){
        fillRect_native_cref_QRectF_cref_QColor(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), QtJambi_LibraryUtilities.internal.checkedNativeId(color));
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRectF_cref_QColor(long __this__nativeId, long arg__1, long color);
    
    /**
     * 
See QPainter::fillRect(QRectF,QGradient::Preset)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRectF r, io.qt.gui.QGradient.@NonNull Preset preset){
        fillRect_native_cref_QRectF_QGradient_Preset(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), preset.value());
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRectF_QGradient_Preset(long __this__nativeId, long r, int preset);
    
    /**
     * 
See QPainter::fillRect(QRectF,Qt::BrushStyle)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRectF r, io.qt.core.Qt.@NonNull BrushStyle style){
        fillRect_native_cref_QRectF_Qt_BrushStyle(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), style.value());
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRectF_Qt_BrushStyle(long __this__nativeId, long r, int style);
    
    /**
     * 
See QPainter::fillRect(QRectF,Qt::GlobalColor)
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRectF r, io.qt.core.Qt.@NonNull GlobalColor c){
        fillRect_native_cref_QRectF_Qt_GlobalColor(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(r), c.value());
    }
    
    @QtUninvokable
    private native void fillRect_native_cref_QRectF_Qt_GlobalColor(long __this__nativeId, long r, int c);
    
    /**
     * 
See QPainter::fillRect(int,int,int,int,QBrush)
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, io.qt.gui.@NonNull QBrush arg__5){
        fillRect_native_int_int_int_int_cref_QBrush(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, QtJambi_LibraryUtilities.internal.checkedNativeId(arg__5));
    }
    
    @QtUninvokable
    private native void fillRect_native_int_int_int_int_cref_QBrush(long __this__nativeId, int x, int y, int w, int h, long arg__5);
    
    /**
     * 
See QPainter::fillRect(int,int,int,int,QColor)
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, io.qt.gui.@NonNull QColor color){
        fillRect_native_int_int_int_int_cref_QColor(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, QtJambi_LibraryUtilities.internal.checkedNativeId(color));
    }
    
    @QtUninvokable
    private native void fillRect_native_int_int_int_int_cref_QColor(long __this__nativeId, int x, int y, int w, int h, long color);
    
    /**
     * 
See QPainter::fillRect(int,int,int,int,QGradient::Preset)
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, io.qt.gui.QGradient.@NonNull Preset preset){
        fillRect_native_int_int_int_int_QGradient_Preset(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, preset.value());
    }
    
    @QtUninvokable
    private native void fillRect_native_int_int_int_int_QGradient_Preset(long __this__nativeId, int x, int y, int w, int h, int preset);
    
    /**
     * 
See QPainter::fillRect(int,int,int,int,Qt::BrushStyle)
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, io.qt.core.Qt.@NonNull BrushStyle style){
        fillRect_native_int_int_int_int_Qt_BrushStyle(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, style.value());
    }
    
    @QtUninvokable
    private native void fillRect_native_int_int_int_int_Qt_BrushStyle(long __this__nativeId, int x, int y, int w, int h, int style);
    
    /**
     * 
See QPainter::fillRect(int,int,int,int,Qt::GlobalColor)
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, io.qt.core.Qt.@NonNull GlobalColor c){
        fillRect_native_int_int_int_int_Qt_GlobalColor(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, c.value());
    }
    
    @QtUninvokable
    private native void fillRect_native_int_int_int_int_Qt_GlobalColor(long __this__nativeId, int x, int y, int w, int h, int c);
    
    /**
     * 
See QPainter::font()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QFont font(){
        return font_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QFont font_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::fontInfo()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QFontInfo fontInfo(){
        return fontInfo_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QFontInfo fontInfo_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::fontMetrics()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QFontMetrics fontMetrics(){
        return fontMetrics_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QFontMetrics fontMetrics_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::hasClipping()const
     */
    @QtUninvokable
    public final boolean hasClipping(){
        return hasClipping_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean hasClipping_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::isActive()const
     */
    @QtUninvokable
    public final boolean isActive(){
        return isActive_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isActive_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::layoutDirection()const
     */
    @QtUninvokable
    public final io.qt.core.Qt.@NonNull LayoutDirection layoutDirection(){
        return io.qt.core.Qt.LayoutDirection.resolve(layoutDirection_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int layoutDirection_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::opacity()const
     */
    @QtUninvokable
    public final double opacity(){
        return opacity_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native double opacity_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::paintEngine()const
     */
    @QtUninvokable
    public final io.qt.gui.@Nullable QPaintEngine paintEngine(){
        return paintEngine_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QPaintEngine paintEngine_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::pen()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QPen pen(){
        return pen_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QPen pen_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::renderHints()const
     */
    @QtUninvokable
    public final io.qt.gui.QPainter.@NonNull RenderHints renderHints(){
        return new io.qt.gui.QPainter.RenderHints(renderHints_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int renderHints_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::resetTransform()
     */
    @QtUninvokable
    public final void resetTransform(){
        resetTransform_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void resetTransform_native(long __this__nativeId);
    
    /**
     * 
See QPainter::restore()
     */
    @QtUninvokable
    public final void restore(){
        restore_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void restore_native(long __this__nativeId);
    
    /**
     * 
See QPainter::rotate(qreal)
     */
    @QtUninvokable
    public final void rotate(double a){
        rotate_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), a);
    }
    
    @QtUninvokable
    private native void rotate_native_qreal(long __this__nativeId, double a);
    
    /**
     * 
See QPainter::save()
     */
    @QtUninvokable
    public final void save(){
        save_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void save_native(long __this__nativeId);
    
    /**
     * 
See QPainter::scale(qreal,qreal)
     */
    @QtUninvokable
    public final void scale(double sx, double sy){
        scale_native_qreal_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), sx, sy);
    }
    
    @QtUninvokable
    private native void scale_native_qreal_qreal(long __this__nativeId, double sx, double sy);
    
    /**
     * 
See QPainter::setBackground(QBrush)
     */
    @QtUninvokable
    public final void setBackground(io.qt.gui.@NonNull QBrush bg){
        setBackground_native_cref_QBrush(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(bg));
    }
    
    @QtUninvokable
    private native void setBackground_native_cref_QBrush(long __this__nativeId, long bg);
    
    /**
     * 
See QPainter::setBackgroundMode(Qt::BGMode)
     */
    @QtUninvokable
    public final void setBackgroundMode(io.qt.core.Qt.@NonNull BGMode mode){
        setBackgroundMode_native_Qt_BGMode(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    @QtUninvokable
    private native void setBackgroundMode_native_Qt_BGMode(long __this__nativeId, int mode);
    
    /**
     * 
See QPainter::setBrush(QBrush)
     */
    @QtUninvokable
    public final void setBrush(io.qt.gui.@NonNull QBrush brush){
        setBrush_native_cref_QBrush(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(brush));
    }
    
    @QtUninvokable
    private native void setBrush_native_cref_QBrush(long __this__nativeId, long brush);
    
    /**
     * 
See QPainter::setBrush(Qt::BrushStyle)
     */
    @QtUninvokable
    public final void setBrush(io.qt.core.Qt.@NonNull BrushStyle style){
        setBrush_native_Qt_BrushStyle(QtJambi_LibraryUtilities.internal.nativeId(this), style.value());
    }
    
    @QtUninvokable
    private native void setBrush_native_Qt_BrushStyle(long __this__nativeId, int style);
    
    /**
     * 
See QPainter::setBrushOrigin(QPoint)
     */
    @QtUninvokable
    public final void setBrushOrigin(io.qt.core.@NonNull QPoint arg__1){
        setBrushOrigin_native_cref_QPoint(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1));
    }
    
    @QtUninvokable
    private native void setBrushOrigin_native_cref_QPoint(long __this__nativeId, long arg__1);
    
    /**
     * 
See QPainter::setBrushOrigin(QPointF)
     */
    @QtUninvokable
    public final void setBrushOrigin(io.qt.core.@NonNull QPointF arg__1){
        setBrushOrigin_native_cref_QPointF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1));
    }
    
    @QtUninvokable
    private native void setBrushOrigin_native_cref_QPointF(long __this__nativeId, long arg__1);
    
    /**
     * 
See QPainter::setBrushOrigin(int,int)
     */
    @QtUninvokable
    public final void setBrushOrigin(int x, int y){
        setBrushOrigin_native_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void setBrushOrigin_native_int_int(long __this__nativeId, int x, int y);
    
    /**
     * 
See QPainter::setClipPath(QPainterPath,Qt::ClipOperation)
     */
    @QtUninvokable
    public final void setClipPath(io.qt.gui.@NonNull QPainterPath path, io.qt.core.Qt.@NonNull ClipOperation op){
        setClipPath_native_cref_QPainterPath_Qt_ClipOperation(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(path), op.value());
    }
    
    @QtUninvokable
    private native void setClipPath_native_cref_QPainterPath_Qt_ClipOperation(long __this__nativeId, long path, int op);
    
    /**
     * 
See QPainter::setClipRect(QRect,Qt::ClipOperation)
     */
    @QtUninvokable
    public final void setClipRect(io.qt.core.@NonNull QRect arg__1, io.qt.core.Qt.@NonNull ClipOperation op){
        setClipRect_native_cref_QRect_Qt_ClipOperation(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), op.value());
    }
    
    @QtUninvokable
    private native void setClipRect_native_cref_QRect_Qt_ClipOperation(long __this__nativeId, long arg__1, int op);
    
    /**
     * 
See QPainter::setClipRect(QRectF,Qt::ClipOperation)
     */
    @QtUninvokable
    public final void setClipRect(io.qt.core.@NonNull QRectF arg__1, io.qt.core.Qt.@NonNull ClipOperation op){
        setClipRect_native_cref_QRectF_Qt_ClipOperation(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), op.value());
    }
    
    @QtUninvokable
    private native void setClipRect_native_cref_QRectF_Qt_ClipOperation(long __this__nativeId, long arg__1, int op);
    
    /**
     * 
See QPainter::setClipRect(int,int,int,int,Qt::ClipOperation)
     */
    @QtUninvokable
    public final void setClipRect(int x, int y, int w, int h, io.qt.core.Qt.@NonNull ClipOperation op){
        setClipRect_native_int_int_int_int_Qt_ClipOperation(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h, op.value());
    }
    
    @QtUninvokable
    private native void setClipRect_native_int_int_int_int_Qt_ClipOperation(long __this__nativeId, int x, int y, int w, int h, int op);
    
    /**
     * 
See QPainter::setClipRegion(QRegion,Qt::ClipOperation)
     */
    @QtUninvokable
    public final void setClipRegion(io.qt.gui.@NonNull QRegion arg__1, io.qt.core.Qt.@NonNull ClipOperation op){
        setClipRegion_native_cref_QRegion_Qt_ClipOperation(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1), op.value());
    }
    
    @QtUninvokable
    private native void setClipRegion_native_cref_QRegion_Qt_ClipOperation(long __this__nativeId, long arg__1, int op);
    
    /**
     * 
See QPainter::setClipping(bool)
     */
    @QtUninvokable
    public final void setClipping(boolean enable){
        setClipping_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), enable);
    }
    
    @QtUninvokable
    private native void setClipping_native_bool(long __this__nativeId, boolean enable);
    
    /**
     * 
See QPainter::setCompositionMode(QPainter::CompositionMode)
     */
    @QtUninvokable
    public final void setCompositionMode(io.qt.gui.QPainter.@NonNull CompositionMode mode){
        setCompositionMode_native_QPainter_CompositionMode(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    @QtUninvokable
    private native void setCompositionMode_native_QPainter_CompositionMode(long __this__nativeId, int mode);
    
    /**
     * 
See QPainter::setFont(QFont)
     */
    @QtUninvokable
    public final void setFont(io.qt.gui.@NonNull QFont f){
        setFont_native_cref_QFont(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(f));
    }
    
    @QtUninvokable
    private native void setFont_native_cref_QFont(long __this__nativeId, long f);
    
    /**
     * 
See QPainter::setLayoutDirection(Qt::LayoutDirection)
     */
    @QtUninvokable
    public final void setLayoutDirection(io.qt.core.Qt.@NonNull LayoutDirection direction){
        setLayoutDirection_native_Qt_LayoutDirection(QtJambi_LibraryUtilities.internal.nativeId(this), direction.value());
    }
    
    @QtUninvokable
    private native void setLayoutDirection_native_Qt_LayoutDirection(long __this__nativeId, int direction);
    
    /**
     * 
See QPainter::setOpacity(qreal)
     */
    @QtUninvokable
    public final void setOpacity(double opacity){
        setOpacity_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), opacity);
    }
    
    @QtUninvokable
    private native void setOpacity_native_qreal(long __this__nativeId, double opacity);
    
    /**
     * 
See QPainter::setPen(QColor)
     */
    @QtUninvokable
    public final void setPen(io.qt.gui.@NonNull QColor color){
        setPen_native_cref_QColor(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(color));
    }
    
    @QtUninvokable
    private native void setPen_native_cref_QColor(long __this__nativeId, long color);
    
    /**
     * 
See QPainter::setPen(QPen)
     */
    @QtUninvokable
    public final void setPen(io.qt.gui.@NonNull QPen pen){
        setPen_native_cref_QPen(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(pen));
    }
    
    @QtUninvokable
    private native void setPen_native_cref_QPen(long __this__nativeId, long pen);
    
    /**
     * 
See QPainter::setPen(Qt::PenStyle)
     */
    @QtUninvokable
    public final void setPen(io.qt.core.Qt.@NonNull PenStyle style){
        setPen_native_Qt_PenStyle(QtJambi_LibraryUtilities.internal.nativeId(this), style.value());
    }
    
    @QtUninvokable
    private native void setPen_native_Qt_PenStyle(long __this__nativeId, int style);
    
    /**
     * 
See QPainter::setRenderHint(QPainter::RenderHint,bool)
     */
    @QtUninvokable
    public final void setRenderHint(io.qt.gui.QPainter.@NonNull RenderHint hint, boolean on){
        setRenderHint_native_QPainter_RenderHint_bool(QtJambi_LibraryUtilities.internal.nativeId(this), hint.value(), on);
    }
    
    @QtUninvokable
    private native void setRenderHint_native_QPainter_RenderHint_bool(long __this__nativeId, int hint, boolean on);
    
    /**
     * 
See QPainter::setRenderHints(QPainter::RenderHints,bool)
     */
    @QtUninvokable
    public final void setRenderHints(io.qt.gui.QPainter.@NonNull RenderHints hints, boolean on){
        setRenderHints_native_QPainter_RenderHints_bool(QtJambi_LibraryUtilities.internal.nativeId(this), hints.value(), on);
    }
    
    @QtUninvokable
    private native void setRenderHints_native_QPainter_RenderHints_bool(long __this__nativeId, int hints, boolean on);
    
    /**
     * 
See QPainter::setTransform(QTransform,bool)
     */
    @QtUninvokable
    public final void setTransform(io.qt.gui.@NonNull QTransform transform, boolean combine){
        setTransform_native_cref_QTransform_bool(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(transform), combine);
    }
    
    @QtUninvokable
    private native void setTransform_native_cref_QTransform_bool(long __this__nativeId, long transform, boolean combine);
    
    /**
     * 
See QPainter::setViewTransformEnabled(bool)
     */
    @QtUninvokable
    public final void setViewTransformEnabled(boolean enable){
        setViewTransformEnabled_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), enable);
    }
    
    @QtUninvokable
    private native void setViewTransformEnabled_native_bool(long __this__nativeId, boolean enable);
    
    /**
     * 
See QPainter::setViewport(QRect)
     */
    @QtUninvokable
    public final void setViewport(io.qt.core.@NonNull QRect viewport){
        setViewport_native_cref_QRect(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(viewport));
    }
    
    @QtUninvokable
    private native void setViewport_native_cref_QRect(long __this__nativeId, long viewport);
    
    /**
     * 
See QPainter::setViewport(int,int,int,int)
     */
    @QtUninvokable
    public final void setViewport(int x, int y, int w, int h){
        setViewport_native_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h);
    }
    
    @QtUninvokable
    private native void setViewport_native_int_int_int_int(long __this__nativeId, int x, int y, int w, int h);
    
    /**
     * 
See QPainter::setWindow(QRect)
     */
    @QtUninvokable
    public final void setWindow(io.qt.core.@NonNull QRect window){
        setWindow_native_cref_QRect(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(window));
    }
    
    @QtUninvokable
    private native void setWindow_native_cref_QRect(long __this__nativeId, long window);
    
    /**
     * 
See QPainter::setWindow(int,int,int,int)
     */
    @QtUninvokable
    public final void setWindow(int x, int y, int w, int h){
        setWindow_native_int_int_int_int(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, w, h);
    }
    
    @QtUninvokable
    private native void setWindow_native_int_int_int_int(long __this__nativeId, int x, int y, int w, int h);
    
    /**
     * 
See QPainter::setWorldMatrixEnabled(bool)
     */
    @QtUninvokable
    public final void setWorldMatrixEnabled(boolean enabled){
        setWorldMatrixEnabled_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), enabled);
    }
    
    @QtUninvokable
    private native void setWorldMatrixEnabled_native_bool(long __this__nativeId, boolean enabled);
    
    /**
     * 
See QPainter::setWorldTransform(QTransform,bool)
     */
    @QtUninvokable
    public final void setWorldTransform(io.qt.gui.@NonNull QTransform matrix, boolean combine){
        setWorldTransform_native_cref_QTransform_bool(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(matrix), combine);
    }
    
    @QtUninvokable
    private native void setWorldTransform_native_cref_QTransform_bool(long __this__nativeId, long matrix, boolean combine);
    
    /**
     * 
See QPainter::shear(qreal,qreal)
     */
    @QtUninvokable
    public final void shear(double sh, double sv){
        shear_native_qreal_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), sh, sv);
    }
    
    @QtUninvokable
    private native void shear_native_qreal_qreal(long __this__nativeId, double sh, double sv);
    
    /**
     * 
See QPainter::strokePath(QPainterPath,QPen)
     */
    @QtUninvokable
    public final void strokePath(io.qt.gui.@NonNull QPainterPath path, io.qt.gui.@NonNull QPen pen){
        strokePath_native_cref_QPainterPath_cref_QPen(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(path), QtJambi_LibraryUtilities.internal.checkedNativeId(pen));
    }
    
    @QtUninvokable
    private native void strokePath_native_cref_QPainterPath_cref_QPen(long __this__nativeId, long path, long pen);
    
    /**
     * 
See QPainter::testRenderHint(QPainter::RenderHint)const
     */
    @QtUninvokable
    public final boolean testRenderHint(io.qt.gui.QPainter.@NonNull RenderHint hint){
        return testRenderHint_native_QPainter_RenderHint_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), hint.value());
    }
    
    @QtUninvokable
    private native boolean testRenderHint_native_QPainter_RenderHint_constfct(long __this__nativeId, int hint);
    
    /**
     * 
See QPainter::transform()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QTransform transform(){
        return transform_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QTransform transform_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::translate(QPoint)
     */
    @QtUninvokable
    public final void translate(io.qt.core.@NonNull QPoint offset){
        translate_native_cref_QPoint(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(offset));
    }
    
    @QtUninvokable
    private native void translate_native_cref_QPoint(long __this__nativeId, long offset);
    
    /**
     * 
See QPainter::translate(QPointF)
     */
    @QtUninvokable
    public final void translate(io.qt.core.@NonNull QPointF offset){
        translate_native_cref_QPointF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(offset));
    }
    
    @QtUninvokable
    private native void translate_native_cref_QPointF(long __this__nativeId, long offset);
    
    /**
     * 
See QPainter::translate(qreal,qreal)
     */
    @QtUninvokable
    public final void translate(double dx, double dy){
        translate_native_qreal_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), dx, dy);
    }
    
    @QtUninvokable
    private native void translate_native_qreal_qreal(long __this__nativeId, double dx, double dy);
    
    /**
     * 
See QPainter::viewTransformEnabled()const
     */
    @QtUninvokable
    public final boolean viewTransformEnabled(){
        return viewTransformEnabled_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean viewTransformEnabled_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::viewport()const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRect viewport(){
        return viewport_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QRect viewport_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::window()const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRect window(){
        return window_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QRect window_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::worldMatrixEnabled()const
     */
    @QtUninvokable
    public final boolean worldMatrixEnabled(){
        return worldMatrixEnabled_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean worldMatrixEnabled_native_constfct(long __this__nativeId);
    
    /**
     * 
See QPainter::worldTransform()const
     */
    @QtUninvokable
    public final io.qt.gui.@NonNull QTransform worldTransform(){
        return worldTransform_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QTransform worldTransform_native_constfct(long __this__nativeId);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QPainter(QPrivateConstructor p) { super(p); } 
    
    @QtUninvokable
    private static void beginPaint(QPaintDevice paintedWidget){
        __paintedDevices.put(paintedWidget, java.util.Collections.emptyList());
    }
    
    @QtUninvokable
    private static void endPaint(QPaintDevice paintedWidget){
        java.util.List painters = __paintedDevices.remove(paintedWidget);
        if(painters!=null){
            for(QPainter painter : painters){
                if(!painter.isDisposed() && painter.isActive()){
                    painter.end();
                    painter.dispose();
                }
            }
        }
    }
    
    @QtUninvokable
    private void initialize(QPaintDevice device, boolean inConstructor){
        if(device instanceof io.qt.core.QObject){
            io.qt.core.QObject object = (io.qt.core.QObject)device;
            if(object.isWidgetType() || device instanceof QPaintDeviceWindow) {
                java.util.List painters = __paintedDevices.get(device);
                if(painters==null){
                    if(inConstructor) {
                        if(QPaintDevice.Impl.sharedPainter(device)!=null)
                            return;
                        QPaintDevice rpd = QPaintDevice.Impl.redirected(device, null);
                        if(rpd!=null && rpd.paintEngine()!=null)
                            return;
                        throw new QPaintingOutsidePaintEventException();
                    }
                }else if(painters.size()==0){
                    threadCheck((io.qt.core.QObject)device);
                    painters = java.util.Collections.singletonList(this);
                    __paintedDevices.put(device, painters);
                }else{
                    threadCheck((io.qt.core.QObject)device);
                    if(painters.size()==1){
                        painters = new java.util.LinkedList<>(painters);
                        __paintedDevices.put(device, painters);
                    }
                    painters.add(this);
                }
            }else {
                threadCheck((io.qt.core.QObject)device);
            }
        }else if(device==null){
            java.util.Objects.requireNonNull(device, "Argument 'QPaintDevice': null not expected.");
        }
    }
    
    @QtUninvokable
    private static native void threadCheck(io.qt.core.QObject object);
    
    private static java.util.Map> __paintedDevices = new java.util.HashMap<>();
    
    /**
     * 
Overloaded function for {@link #boundingRect(io.qt.core.QRectF, java.lang.String, io.qt.gui.QTextOption)}
     *  with o = new io.qt.gui.QTextOption().
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRectF boundingRect(io.qt.core.@NonNull QRectF rect, java.lang.@NonNull String text) {
        return boundingRect(rect, text, new io.qt.gui.QTextOption());
    }
    
    /**
     * 
Overloaded function for {@link #boundingRect(io.qt.core.QRect, java.lang.String, io.qt.gui.QTextOption)}
     *  with o = new io.qt.gui.QTextOption().
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRectF boundingRect(io.qt.core.@NonNull QRect rect, java.lang.@NonNull String text) {
        return boundingRect(rect, text, new io.qt.gui.QTextOption());
    }
    
    /**
     * 
Overloaded function for {@link #boundingRect(io.qt.core.QRectF, java.lang.String, io.qt.gui.QTextOption)}.
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRectF boundingRect(io.qt.core.@NonNull QRect rect, java.lang.@NonNull String text, io.qt.gui.@NonNull QTextOption o) {
        return boundingRect(new io.qt.core.QRectF(rect), text, o);
    }
    
    /**
     * 
Overloaded function for {@link #boundingRect(io.qt.core.QRectF, java.lang.String, io.qt.gui.QTextOption)}.
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRectF boundingRect(io.qt.core.@NonNull QRectF rect, java.lang.@NonNull String text, io.qt.core.Qt.@NonNull Alignment o) {
        return boundingRect(rect, text, new io.qt.gui.QTextOption(o));
    }
    
    /**
     * 
Overloaded function for {@link #boundingRect(io.qt.core.QRectF, java.lang.String, io.qt.gui.QTextOption)}.
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QRectF boundingRect(io.qt.core.@NonNull QRect rect, java.lang.@NonNull String text, io.qt.core.Qt.@NonNull Alignment o) {
        return boundingRect(new io.qt.core.QRectF(rect), text, new io.qt.gui.QTextOption(o));
    }
    
    /**
     * 
Overloaded function for {@link #drawEllipse(io.qt.core.QPointF, double, double)}.
     */
    @QtUninvokable
    public final void drawEllipse(io.qt.core.@NonNull QPoint center, double rx, double ry) {
        drawEllipse(new io.qt.core.QPointF(center), rx, ry);
    }
    
    /**
     * 
Overloaded function for {@link #drawGlyphRun(io.qt.core.QPointF, io.qt.gui.QGlyphRun)}.
     */
    @QtUninvokable
    public final void drawGlyphRun(io.qt.core.@NonNull QPoint position, io.qt.gui.@NonNull QGlyphRun glyphRun) {
        drawGlyphRun(new io.qt.core.QPointF(position), glyphRun);
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(io.qt.core.QPoint, io.qt.gui.QImage, io.qt.core.QRect, io.qt.core.Qt.ImageConversionFlags)}
     *  with flags = new io.qt.core.Qt.ImageConversionFlags(0).
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QPoint p, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRect sr) {
        drawImage(p, image, sr, new io.qt.core.Qt.ImageConversionFlags(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(io.qt.core.QPoint, io.qt.gui.QImage, io.qt.core.QRect, io.qt.core.Qt.ImageConversionFlags)}.
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QPoint p, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRect sr, io.qt.core.Qt.@NonNull ImageConversionFlag @NonNull... flags) {
        drawImage(p, image, sr, new io.qt.core.Qt.ImageConversionFlags(flags));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(io.qt.core.QPointF, io.qt.gui.QImage, io.qt.core.QRectF, io.qt.core.Qt.ImageConversionFlags)}
     *  with flags = new io.qt.core.Qt.ImageConversionFlags(0).
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QPointF p, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRectF sr) {
        drawImage(p, image, sr, new io.qt.core.Qt.ImageConversionFlags(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(io.qt.core.QPointF, io.qt.gui.QImage, io.qt.core.QRectF, io.qt.core.Qt.ImageConversionFlags)}.
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QPointF p, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRectF sr, io.qt.core.Qt.@NonNull ImageConversionFlag @NonNull... flags) {
        drawImage(p, image, sr, new io.qt.core.Qt.ImageConversionFlags(flags));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(io.qt.core.QRect, io.qt.gui.QImage, io.qt.core.QRect, io.qt.core.Qt.ImageConversionFlags)}
     *  with flags = new io.qt.core.Qt.ImageConversionFlags(0).
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QRect targetRect, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRect sourceRect) {
        drawImage(targetRect, image, sourceRect, new io.qt.core.Qt.ImageConversionFlags(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(io.qt.core.QRect, io.qt.gui.QImage, io.qt.core.QRect, io.qt.core.Qt.ImageConversionFlags)}.
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QRect targetRect, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRect sourceRect, io.qt.core.Qt.@NonNull ImageConversionFlag @NonNull... flags) {
        drawImage(targetRect, image, sourceRect, new io.qt.core.Qt.ImageConversionFlags(flags));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(io.qt.core.QRectF, io.qt.gui.QImage, io.qt.core.QRectF, io.qt.core.Qt.ImageConversionFlags)}
     *  with flags = new io.qt.core.Qt.ImageConversionFlags(0).
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QRectF targetRect, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRectF sourceRect) {
        drawImage(targetRect, image, sourceRect, new io.qt.core.Qt.ImageConversionFlags(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(io.qt.core.QRectF, io.qt.gui.QImage, io.qt.core.QRectF, io.qt.core.Qt.ImageConversionFlags)}.
     */
    @QtUninvokable
    public final void drawImage(io.qt.core.@NonNull QRectF targetRect, io.qt.gui.@NonNull QImage image, io.qt.core.@NonNull QRectF sourceRect, io.qt.core.Qt.@NonNull ImageConversionFlag @NonNull... flags) {
        drawImage(targetRect, image, sourceRect, new io.qt.core.Qt.ImageConversionFlags(flags));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(int, int, io.qt.gui.QImage, int, int, int, int, io.qt.core.Qt.ImageConversionFlags)}
     *  with flags = new io.qt.core.Qt.ImageConversionFlags(0).
     */
    @QtUninvokable
    public final void drawImage(int x, int y, io.qt.gui.@NonNull QImage image, int sx, int sy, int sw, int sh) {
        drawImage(x, y, image, sx, sy, sw, sh, new io.qt.core.Qt.ImageConversionFlags(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(int, int, io.qt.gui.QImage, int, int, int, int, io.qt.core.Qt.ImageConversionFlags)}
     * 
with: 

     * 
sh = -1
     * 
flags = new io.qt.core.Qt.ImageConversionFlags(0)
     * 
     */
    @QtUninvokable
    public final void drawImage(int x, int y, io.qt.gui.@NonNull QImage image, int sx, int sy, int sw) {
        drawImage(x, y, image, sx, sy, sw, (int)-1, new io.qt.core.Qt.ImageConversionFlags(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(int, int, io.qt.gui.QImage, int, int, int, int, io.qt.core.Qt.ImageConversionFlags)}
     * 
with: 

     * 
sw = -1
     * 
sh = -1
     * 
flags = new io.qt.core.Qt.ImageConversionFlags(0)
     * 
     */
    @QtUninvokable
    public final void drawImage(int x, int y, io.qt.gui.@NonNull QImage image, int sx, int sy) {
        drawImage(x, y, image, sx, sy, (int)-1, (int)-1, new io.qt.core.Qt.ImageConversionFlags(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(int, int, io.qt.gui.QImage, int, int, int, int, io.qt.core.Qt.ImageConversionFlags)}
     * 
with: 

     * 
sy = 0
     * 
sw = -1
     * 
sh = -1
     * 
flags = new io.qt.core.Qt.ImageConversionFlags(0)
     * 
     */
    @QtUninvokable
    public final void drawImage(int x, int y, io.qt.gui.@NonNull QImage image, int sx) {
        drawImage(x, y, image, sx, (int)0, (int)-1, (int)-1, new io.qt.core.Qt.ImageConversionFlags(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(int, int, io.qt.gui.QImage, int, int, int, int, io.qt.core.Qt.ImageConversionFlags)}
     * 
with: 

     * 
sx = 0
     * 
sy = 0
     * 
sw = -1
     * 
sh = -1
     * 
flags = new io.qt.core.Qt.ImageConversionFlags(0)
     * 
     */
    @QtUninvokable
    public final void drawImage(int x, int y, io.qt.gui.@NonNull QImage image) {
        drawImage(x, y, image, (int)0, (int)0, (int)-1, (int)-1, new io.qt.core.Qt.ImageConversionFlags(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawImage(int, int, io.qt.gui.QImage, int, int, int, int, io.qt.core.Qt.ImageConversionFlags)}.
     */
    @QtUninvokable
    public final void drawImage(int x, int y, io.qt.gui.@NonNull QImage image, int sx, int sy, int sw, int sh, io.qt.core.Qt.@NonNull ImageConversionFlag @NonNull... flags) {
        drawImage(x, y, image, sx, sy, sw, sh, new io.qt.core.Qt.ImageConversionFlags(flags));
    }
    
    /**
     * 
Overloaded function for {@link #drawLine(io.qt.core.QPointF, io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void drawLine(io.qt.core.@NonNull QPoint p1, io.qt.core.@NonNull QPointF p2) {
        drawLine(new io.qt.core.QPointF(p1), p2);
    }
    
    /**
     * 
Overloaded function for {@link #drawLine(io.qt.core.QPointF, io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void drawLine(io.qt.core.@NonNull QPointF p1, io.qt.core.@NonNull QPoint p2) {
        drawLine(p1, new io.qt.core.QPointF(p2));
    }
    
    /**
     * 
Overloaded function for {@link #drawPixmap(io.qt.core.QPointF, io.qt.gui.QPixmap, io.qt.core.QRectF)}.
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QPoint p, io.qt.gui.@NonNull QPixmap pm, io.qt.core.@NonNull QRectF sr) {
        drawPixmap(new io.qt.core.QPointF(p), pm, sr);
    }
    
    /**
     * 
Overloaded function for {@link #drawPixmap(io.qt.core.QPointF, io.qt.gui.QPixmap, io.qt.core.QRectF)}.
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QPointF p, io.qt.gui.@NonNull QPixmap pm, io.qt.core.@NonNull QRect sr) {
        drawPixmap(p, pm, new io.qt.core.QRectF(sr));
    }
    
    /**
     * 
Overloaded function for {@link #drawPixmap(io.qt.core.QRectF, io.qt.gui.QPixmap, io.qt.core.QRectF)}.
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QRect targetRect, io.qt.gui.@NonNull QPixmap pixmap, io.qt.core.@NonNull QRectF sourceRect) {
        drawPixmap(new io.qt.core.QRectF(targetRect), pixmap, sourceRect);
    }
    
    /**
     * 
Overloaded function for {@link #drawPixmap(io.qt.core.QRectF, io.qt.gui.QPixmap, io.qt.core.QRectF)}.
     */
    @QtUninvokable
    public final void drawPixmap(io.qt.core.@NonNull QRectF targetRect, io.qt.gui.@NonNull QPixmap pixmap, io.qt.core.@NonNull QRect sourceRect) {
        drawPixmap(targetRect, pixmap, new io.qt.core.QRectF(sourceRect));
    }
    
    /**
     * 
Overloaded function for {@link #drawPixmapFragments(io.qt.gui.QPainter.PixmapFragment[], io.qt.gui.QPixmap, io.qt.gui.QPainter.PixmapFragmentHints)}
     *  with hints = new io.qt.gui.QPainter.PixmapFragmentHints(0).
     */
    @QtUninvokable
    public final void drawPixmapFragments(io.qt.gui.QPainter.@NonNull PixmapFragment[] fragments, io.qt.gui.@NonNull QPixmap pixmap) {
        drawPixmapFragments(fragments, pixmap, new io.qt.gui.QPainter.PixmapFragmentHints(0));
    }
    
    /**
     * 
Overloaded function for {@link #drawPixmapFragments(io.qt.gui.QPainter.PixmapFragment[], io.qt.gui.QPixmap, io.qt.gui.QPainter.PixmapFragmentHints)}.
     */
    @QtUninvokable
    public final void drawPixmapFragments(io.qt.gui.QPainter.@NonNull PixmapFragment[] fragments, io.qt.gui.@NonNull QPixmap pixmap, io.qt.gui.QPainter.@NonNull PixmapFragmentHint @NonNull... hints) {
        drawPixmapFragments(fragments, pixmap, new io.qt.gui.QPainter.PixmapFragmentHints(hints));
    }
    
    /**
     * 
Overloaded function for {@link #drawPolygon(io.qt.gui.QPolygon, io.qt.core.Qt.FillRule)}
     *  with fillRule = io.qt.core.Qt.FillRule.OddEvenFill.
     */
    @QtUninvokable
    public final void drawPolygon(io.qt.gui.@NonNull QPolygon polygon) {
        drawPolygon(polygon, io.qt.core.Qt.FillRule.OddEvenFill);
    }
    
    /**
     * 
Overloaded function for {@link #drawPolygon(io.qt.gui.QPolygonF, io.qt.core.Qt.FillRule)}
     *  with fillRule = io.qt.core.Qt.FillRule.OddEvenFill.
     */
    @QtUninvokable
    public final void drawPolygon(io.qt.gui.@NonNull QPolygonF polygon) {
        drawPolygon(polygon, io.qt.core.Qt.FillRule.OddEvenFill);
    }
    
    /**
     * 
Overloaded function for {@link #drawPolygon(io.qt.core.QPoint[], io.qt.core.Qt.FillRule)}
     *  with fillRule = io.qt.core.Qt.FillRule.OddEvenFill.
     */
    @QtUninvokable
    public final void drawPolygon(io.qt.core.@NonNull QPoint... points) {
        drawPolygon(points, io.qt.core.Qt.FillRule.OddEvenFill);
    }
    
    /**
     * 
Overloaded function for {@link #drawPolygon(io.qt.core.QPointF[], io.qt.core.Qt.FillRule)}
     *  with fillRule = io.qt.core.Qt.FillRule.OddEvenFill.
     */
    @QtUninvokable
    public final void drawPolygon(io.qt.core.@NonNull QPointF... points) {
        drawPolygon(points, io.qt.core.Qt.FillRule.OddEvenFill);
    }
    
    /**
     * 
Overloaded function for {@link #drawRoundedRect(io.qt.core.QRect, double, double, io.qt.core.Qt.SizeMode)}
     *  with mode = io.qt.core.Qt.SizeMode.AbsoluteSize.
     */
    @QtUninvokable
    public final void drawRoundedRect(io.qt.core.@NonNull QRect rect, double xRadius, double yRadius) {
        drawRoundedRect(rect, xRadius, yRadius, io.qt.core.Qt.SizeMode.AbsoluteSize);
    }
    
    /**
     * 
Overloaded function for {@link #drawRoundedRect(io.qt.core.QRectF, double, double, io.qt.core.Qt.SizeMode)}
     *  with mode = io.qt.core.Qt.SizeMode.AbsoluteSize.
     */
    @QtUninvokable
    public final void drawRoundedRect(io.qt.core.@NonNull QRectF rect, double xRadius, double yRadius) {
        drawRoundedRect(rect, xRadius, yRadius, io.qt.core.Qt.SizeMode.AbsoluteSize);
    }
    
    /**
     * 
Overloaded function for {@link #drawRoundedRect(int, int, int, int, double, double, io.qt.core.Qt.SizeMode)}
     *  with mode = io.qt.core.Qt.SizeMode.AbsoluteSize.
     */
    @QtUninvokable
    public final void drawRoundedRect(int x, int y, int w, int h, double xRadius, double yRadius) {
        drawRoundedRect(x, y, w, h, xRadius, yRadius, io.qt.core.Qt.SizeMode.AbsoluteSize);
    }
    
    /**
     * 
Overloaded function for {@link #drawText(io.qt.core.QRect, int, java.lang.String, io.qt.core.QRect)}
     *  with br = null.
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRect r, int flags, java.lang.@NonNull String text) {
        drawText(r, flags, text, (io.qt.core.QRect)null);
    }
    
    /**
     * 
Overloaded function for {@link #drawText(io.qt.core.QRectF, java.lang.String, io.qt.gui.QTextOption)}
     *  with o = new io.qt.gui.QTextOption().
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRectF r, java.lang.@NonNull String text) {
        drawText(r, text, new io.qt.gui.QTextOption());
    }
    
    /**
     * 
Overloaded function for {@link #drawText(io.qt.core.QRect, java.lang.String, io.qt.gui.QTextOption)}
     *  with o = new io.qt.gui.QTextOption().
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRect r, java.lang.@NonNull String text) {
        drawText(r, text, new io.qt.gui.QTextOption());
    }
    
    /**
     * 
Overloaded function for {@link #drawText(io.qt.core.QRectF, java.lang.String, io.qt.gui.QTextOption)}.
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRect r, java.lang.@NonNull String text, io.qt.gui.@NonNull QTextOption o) {
        drawText(new io.qt.core.QRectF(r), text, o);
    }
    
    /**
     * 
Overloaded function for {@link #drawText(io.qt.core.QRectF, java.lang.String, io.qt.gui.QTextOption)}.
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRectF r, java.lang.@NonNull String text, io.qt.core.Qt.@NonNull Alignment o) {
        drawText(r, text, new io.qt.gui.QTextOption(o));
    }
    
    /**
     * 
Overloaded function for {@link #drawText(io.qt.core.QRectF, java.lang.String, io.qt.gui.QTextOption)}.
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRect r, java.lang.@NonNull String text, io.qt.core.Qt.@NonNull Alignment o) {
        drawText(new io.qt.core.QRectF(r), text, new io.qt.gui.QTextOption(o));
    }
    
    /**
     * 
Overloaded function for {@link #drawText(io.qt.core.QRectF, int, java.lang.String, io.qt.core.QRectF)}
     *  with br = null.
     */
    @QtUninvokable
    public final void drawText(io.qt.core.@NonNull QRectF r, int flags, java.lang.@NonNull String text) {
        drawText(r, flags, text, (io.qt.core.QRectF)null);
    }
    
    /**
     * 
Overloaded function for {@link #drawText(int, int, int, int, int, java.lang.String, io.qt.core.QRect)}
     *  with br = null.
     */
    @QtUninvokable
    public final void drawText(int x, int y, int w, int h, int flags, java.lang.@NonNull String text) {
        drawText(x, y, w, h, flags, text, (io.qt.core.QRect)null);
    }
    
    /**
     * 
Overloaded function for {@link #drawTiledPixmap(io.qt.core.QRect, io.qt.gui.QPixmap, io.qt.core.QPoint)}
     *  with arg__3 = new io.qt.core.QPoint().
     */
    @QtUninvokable
    public final void drawTiledPixmap(io.qt.core.@NonNull QRect arg__1, io.qt.gui.@NonNull QPixmap arg__2) {
        drawTiledPixmap(arg__1, arg__2, new io.qt.core.QPoint());
    }
    
    /**
     * 
Overloaded function for {@link #drawTiledPixmap(io.qt.core.QRectF, io.qt.gui.QPixmap, io.qt.core.QPointF)}
     *  with offset = new io.qt.core.QPointF().
     */
    @QtUninvokable
    public final void drawTiledPixmap(io.qt.core.@NonNull QRectF rect, io.qt.gui.@NonNull QPixmap pm) {
        drawTiledPixmap(rect, pm, new io.qt.core.QPointF());
    }
    
    /**
     * 
Overloaded function for {@link #drawTiledPixmap(int, int, int, int, io.qt.gui.QPixmap, int, int)}
     *  with sy = 0.
     */
    @QtUninvokable
    public final void drawTiledPixmap(int x, int y, int w, int h, io.qt.gui.@NonNull QPixmap arg__5, int sx) {
        drawTiledPixmap(x, y, w, h, arg__5, sx, (int)0);
    }
    
    /**
     * 
Overloaded function for {@link #drawTiledPixmap(int, int, int, int, io.qt.gui.QPixmap, int, int)}
     * 
with: 

     * 
sx = 0
     * 
sy = 0
     * 
     */
    @QtUninvokable
    public final void drawTiledPixmap(int x, int y, int w, int h, io.qt.gui.@NonNull QPixmap arg__5) {
        drawTiledPixmap(x, y, w, h, arg__5, (int)0, (int)0);
    }
    
    /**
     * 
Overloaded function for {@link #fillPath(io.qt.gui.QPainterPath, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillPath(io.qt.gui.@NonNull QPainterPath path, io.qt.core.Qt.@NonNull BrushStyle brush) {
        fillPath(path, new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #fillPath(io.qt.gui.QPainterPath, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillPath(io.qt.gui.@NonNull QPainterPath path, io.qt.gui.@NonNull QColor brush) {
        fillPath(path, new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #fillPath(io.qt.gui.QPainterPath, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillPath(io.qt.gui.@NonNull QPainterPath path, io.qt.core.Qt.@NonNull GlobalColor brush) {
        fillPath(path, new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #fillPath(io.qt.gui.QPainterPath, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillPath(io.qt.gui.@NonNull QPainterPath path, io.qt.gui.@NonNull QPixmap brush) {
        fillPath(path, new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #fillPath(io.qt.gui.QPainterPath, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillPath(io.qt.gui.@NonNull QPainterPath path, io.qt.gui.@NonNull QImage brush) {
        fillPath(path, new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #fillPath(io.qt.gui.QPainterPath, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillPath(io.qt.gui.@NonNull QPainterPath path, io.qt.gui.@NonNull QGradient brush) {
        fillPath(path, new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(io.qt.core.QRect, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect arg__1, io.qt.gui.@NonNull QPixmap arg__2) {
        fillRect(arg__1, new io.qt.gui.QBrush(arg__2));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(io.qt.core.QRect, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect arg__1, io.qt.gui.@NonNull QImage arg__2) {
        fillRect(arg__1, new io.qt.gui.QBrush(arg__2));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(io.qt.core.QRect, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect arg__1, io.qt.gui.@NonNull QGradient arg__2) {
        fillRect(arg__1, new io.qt.gui.QBrush(arg__2));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(io.qt.core.QRect, io.qt.gui.QColor)}.
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect arg__1, io.qt.gui.@NonNull QRgba64 color) {
        fillRect(arg__1, new io.qt.gui.QColor(color));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(io.qt.core.QRect, io.qt.gui.QColor)}.
     */
    @QtUninvokable
    public final void fillRect(io.qt.core.@NonNull QRect arg__1, java.lang.@NonNull String color) {
        fillRect(arg__1, new io.qt.gui.QColor(color));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(int, int, int, int, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, io.qt.gui.@NonNull QPixmap arg__5) {
        fillRect(x, y, w, h, new io.qt.gui.QBrush(arg__5));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(int, int, int, int, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, io.qt.gui.@NonNull QImage arg__5) {
        fillRect(x, y, w, h, new io.qt.gui.QBrush(arg__5));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(int, int, int, int, io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, io.qt.gui.@NonNull QGradient arg__5) {
        fillRect(x, y, w, h, new io.qt.gui.QBrush(arg__5));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(int, int, int, int, io.qt.gui.QColor)}.
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, io.qt.gui.@NonNull QRgba64 color) {
        fillRect(x, y, w, h, new io.qt.gui.QColor(color));
    }
    
    /**
     * 
Overloaded function for {@link #fillRect(int, int, int, int, io.qt.gui.QColor)}.
     */
    @QtUninvokable
    public final void fillRect(int x, int y, int w, int h, java.lang.@NonNull String color) {
        fillRect(x, y, w, h, new io.qt.gui.QColor(color));
    }
    
    /**
     * 
Overloaded function for {@link #setBackground(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBackground(io.qt.core.Qt.@NonNull BrushStyle bg) {
        setBackground(new io.qt.gui.QBrush(bg));
    }
    
    /**
     * 
Overloaded function for {@link #setBackground(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBackground(io.qt.gui.@NonNull QColor bg) {
        setBackground(new io.qt.gui.QBrush(bg));
    }
    
    /**
     * 
Overloaded function for {@link #setBackground(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBackground(io.qt.core.Qt.@NonNull GlobalColor bg) {
        setBackground(new io.qt.gui.QBrush(bg));
    }
    
    /**
     * 
Overloaded function for {@link #setBackground(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBackground(io.qt.gui.@NonNull QPixmap bg) {
        setBackground(new io.qt.gui.QBrush(bg));
    }
    
    /**
     * 
Overloaded function for {@link #setBackground(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBackground(io.qt.gui.@NonNull QImage bg) {
        setBackground(new io.qt.gui.QBrush(bg));
    }
    
    /**
     * 
Overloaded function for {@link #setBackground(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBackground(io.qt.gui.@NonNull QGradient bg) {
        setBackground(new io.qt.gui.QBrush(bg));
    }
    
    /**
     * 
Overloaded function for {@link #setBrush(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBrush(io.qt.gui.@NonNull QColor brush) {
        setBrush(new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #setBrush(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBrush(io.qt.core.Qt.@NonNull GlobalColor brush) {
        setBrush(new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #setBrush(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBrush(io.qt.gui.@NonNull QPixmap brush) {
        setBrush(new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #setBrush(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBrush(io.qt.gui.@NonNull QImage brush) {
        setBrush(new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #setBrush(io.qt.gui.QBrush)}.
     */
    @QtUninvokable
    public final void setBrush(io.qt.gui.@NonNull QGradient brush) {
        setBrush(new io.qt.gui.QBrush(brush));
    }
    
    /**
     * 
Overloaded function for {@link #setClipPath(io.qt.gui.QPainterPath, io.qt.core.Qt.ClipOperation)}
     *  with op = io.qt.core.Qt.ClipOperation.ReplaceClip.
     */
    @QtUninvokable
    public final void setClipPath(io.qt.gui.@NonNull QPainterPath path) {
        setClipPath(path, io.qt.core.Qt.ClipOperation.ReplaceClip);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRect(io.qt.core.QRect, io.qt.core.Qt.ClipOperation)}
     *  with op = io.qt.core.Qt.ClipOperation.ReplaceClip.
     */
    @QtUninvokable
    public final void setClipRect(io.qt.core.@NonNull QRect arg__1) {
        setClipRect(arg__1, io.qt.core.Qt.ClipOperation.ReplaceClip);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRect(io.qt.core.QRectF, io.qt.core.Qt.ClipOperation)}
     *  with op = io.qt.core.Qt.ClipOperation.ReplaceClip.
     */
    @QtUninvokable
    public final void setClipRect(io.qt.core.@NonNull QRectF arg__1) {
        setClipRect(arg__1, io.qt.core.Qt.ClipOperation.ReplaceClip);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRect(int, int, int, int, io.qt.core.Qt.ClipOperation)}
     *  with op = io.qt.core.Qt.ClipOperation.ReplaceClip.
     */
    @QtUninvokable
    public final void setClipRect(int x, int y, int w, int h) {
        setClipRect(x, y, w, h, io.qt.core.Qt.ClipOperation.ReplaceClip);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRegion(io.qt.gui.QRegion, io.qt.core.Qt.ClipOperation)}
     *  with op = io.qt.core.Qt.ClipOperation.ReplaceClip.
     */
    @QtUninvokable
    public final void setClipRegion(io.qt.gui.@NonNull QRegion arg__1) {
        setClipRegion(arg__1, io.qt.core.Qt.ClipOperation.ReplaceClip);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRegion(io.qt.core.QRect, io.qt.core.Qt.ClipOperation)}
     *  with op = io.qt.core.Qt.ClipOperation.ReplaceClip.
     */
    @QtUninvokable
    public final void setClipRegion(io.qt.core.@NonNull QRect arg__1) {
        setClipRegion(arg__1, io.qt.core.Qt.ClipOperation.ReplaceClip);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRegion(io.qt.gui.QRegion, io.qt.core.Qt.ClipOperation)}.
     */
    @QtUninvokable
    public final void setClipRegion(io.qt.core.@NonNull QRect arg__1, io.qt.core.Qt.@NonNull ClipOperation op) {
        setClipRegion(new io.qt.gui.QRegion(arg__1), op);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRegion(io.qt.gui.QPolygon, io.qt.core.Qt.ClipOperation)}
     *  with op = io.qt.core.Qt.ClipOperation.ReplaceClip.
     */
    @QtUninvokable
    public final void setClipRegion(io.qt.gui.@NonNull QPolygon arg__1) {
        setClipRegion(arg__1, io.qt.core.Qt.ClipOperation.ReplaceClip);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRegion(io.qt.gui.QRegion, io.qt.core.Qt.ClipOperation)}.
     */
    @QtUninvokable
    public final void setClipRegion(io.qt.gui.@NonNull QPolygon arg__1, io.qt.core.Qt.@NonNull ClipOperation op) {
        setClipRegion(new io.qt.gui.QRegion(arg__1), op);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRegion(io.qt.gui.QBitmap, io.qt.core.Qt.ClipOperation)}
     *  with op = io.qt.core.Qt.ClipOperation.ReplaceClip.
     */
    @QtUninvokable
    public final void setClipRegion(io.qt.gui.@NonNull QBitmap arg__1) {
        setClipRegion(arg__1, io.qt.core.Qt.ClipOperation.ReplaceClip);
    }
    
    /**
     * 
Overloaded function for {@link #setClipRegion(io.qt.gui.QRegion, io.qt.core.Qt.ClipOperation)}.
     */
    @QtUninvokable
    public final void setClipRegion(io.qt.gui.@NonNull QBitmap arg__1, io.qt.core.Qt.@NonNull ClipOperation op) {
        setClipRegion(new io.qt.gui.QRegion(arg__1), op);
    }
    
    /**
     * 
Overloaded function for {@link #setFont(io.qt.gui.QFont)}.
     */
    @QtUninvokable
    public final void setFont(java.lang.@NonNull String f) {
        setFont(new io.qt.gui.QFont(f));
    }
    
    /**
     * 
Overloaded function for {@link #setPen(io.qt.gui.QColor)}.
     */
    @QtUninvokable
    public final void setPen(io.qt.core.Qt.@NonNull GlobalColor color) {
        setPen(new io.qt.gui.QColor(color));
    }
    
    /**
     * 
Overloaded function for {@link #setPen(io.qt.gui.QColor)}.
     */
    @QtUninvokable
    public final void setPen(io.qt.gui.@NonNull QRgba64 color) {
        setPen(new io.qt.gui.QColor(color));
    }
    
    /**
     * 
Overloaded function for {@link #setPen(io.qt.gui.QColor)}.
     */
    @QtUninvokable
    public final void setPen(java.lang.@NonNull String color) {
        setPen(new io.qt.gui.QColor(color));
    }
    
    /**
     * 
Overloaded function for {@link #setRenderHint(io.qt.gui.QPainter.RenderHint, boolean)}
     *  with on = true.
     */
    @QtUninvokable
    public final void setRenderHint(io.qt.gui.QPainter.@NonNull RenderHint hint) {
        setRenderHint(hint, (boolean)true);
    }
    
    /**
     * 
Overloaded function for {@link #setRenderHints(io.qt.gui.QPainter.RenderHints, boolean)}
     *  with on = true.
     */
    @QtUninvokable
    public final void setRenderHints(io.qt.gui.QPainter.@NonNull RenderHints hints) {
        setRenderHints(hints, (boolean)true);
    }
    
    /**
     * 
Overloaded function for {@link #setTransform(io.qt.gui.QTransform, boolean)}
     *  with combine = false.
     */
    @QtUninvokable
    public final void setTransform(io.qt.gui.@NonNull QTransform transform) {
        setTransform(transform, (boolean)false);
    }
    
    /**
     * 
Overloaded function for {@link #setWorldTransform(io.qt.gui.QTransform, boolean)}
     *  with combine = false.
     */
    @QtUninvokable
    public final void setWorldTransform(io.qt.gui.@NonNull QTransform matrix) {
        setWorldTransform(matrix, (boolean)false);
    }
    
    /**
     * 
Overloaded function for {@link #strokePath(io.qt.gui.QPainterPath, io.qt.gui.QPen)}.
     */
    @QtUninvokable
    public final void strokePath(io.qt.gui.@NonNull QPainterPath path, io.qt.core.Qt.@NonNull PenStyle pen) {
        strokePath(path, new io.qt.gui.QPen(pen));
    }
    
    /**
     * 
Overloaded function for {@link #strokePath(io.qt.gui.QPainterPath, io.qt.gui.QPen)}.
     */
    @QtUninvokable
    public final void strokePath(io.qt.gui.@NonNull QPainterPath path, io.qt.gui.@NonNull QColor pen) {
        strokePath(path, new io.qt.gui.QPen(pen));
    }
}