Struct rute::auto::painter::Painter

source ·

pub struct Painter<'a> { /* private fields */ }

Expand description

Notice these docs are heavy WIP and not very relevent yet

QPainter provides highly optimized functions to do most of the drawing GUI programs require. It can draw everything from simple lines to complex shapes like pies and chords. It can also draw aligned text and pixmaps. Normally, it draws in a coordinate system, but it can also do view and world transformation. QPainter can operate on any object that inherits the QPaintDevice class.

The common use of QPainter is inside a widget’s paint event: Construct and customize (e.g. set the pen or the brush) the painter. Then draw. Remember to destroy the QPainter object after drawing. For example:

The core functionality of QPainter is drawing, but the class also provide several functions that allows you to customize QPainter’s settings and its rendering quality, and others that enable clipping. In addition you can control how different shapes are merged together by specifying the painter’s composition mode.

The isActive() function indicates whether the painter is active. A painter is activated by the begin() function and the constructor that takes a QPaintDevice argument. The end() function, and the destructor, deactivates it.

Together with the QPaintDevice and QPaintEngine classes, QPainter form the basis for Qt’s paint system. QPainter is the class used to perform drawing operations. QPaintDevice represents a device that can be painted on using a QPainter. QPaintEngine provides the interface that the painter uses to draw onto different types of devices. If the painter is active, device() returns the paint device on which the painter paints, and paintEngine() returns the paint engine that the painter is currently operating on. For more information, see the Paint System

Sometimes it is desirable to make someone else paint on an unusual QPaintDevice. QPainter supports a static function to do this, setRedirected().

Warning: When the paintdevice is a widget, QPainter can only be used inside a paintEvent() function or in a function called by paintEvent().

Settings

There are several settings that you can customize to make QPainter draw according to your preferences:

font() is the font used for drawing text. If the painter isActive(), you can retrieve information about the currently set font, and its metrics, using the fontInfo() and fontMetrics() functions respectively.
brush() defines the color or pattern that is used for filling shapes.
pen() defines the color or stipple that is used for drawing lines or boundaries.
backgroundMode() defines whether there is a background() or not, i.e it is either Qt::OpaqueMode or Qt::TransparentMode.
background() only applies when backgroundMode() is Qt::OpaqueMode and pen() is a stipple. In that case, it describes the color of the background pixels in the stipple.
brushOrigin() defines the origin of the tiled brushes, normally the origin of widget’s background.
viewport(), window(), worldTransform() make up the painter’s coordinate transformation system. For more information, see the Coordinate Transformations section and the Coordinate System documentation.
hasClipping() tells whether the painter clips at all. (The paint device clips, too.) If the painter clips, it clips to clipRegion().
layoutDirection() defines the layout direction used by the painter when drawing text.
worldMatrixEnabled() tells whether world transformation is enabled.
viewTransformEnabled() tells whether view transformation is enabled.

Note that some of these settings mirror settings in some paint devices, e.g. QWidget::font(). The QPainter::begin() function (or equivalently the QPainter constructor) copies these attributes from the paint device.

You can at any time save the QPainter’s state by calling the save() function which saves all the available settings on an internal stack. The restore() function pops them back.

Drawing

QPainter provides functions to draw most primitives: drawPoint(), drawPoints(), drawLine(), drawRect(), drawRoundedRect(), drawEllipse(), drawArc(), drawPie(), drawChord(), drawPolyline(), drawPolygon(), drawConvexPolygon() and drawCubicBezier(). The two convenience functions, drawRects() and drawLines(), draw the given number of rectangles or lines in the given array of QRects or QLines using the current pen and brush.

The QPainter class also provides the fillRect() function which fills the given QRect, with the given QBrush, and the eraseRect() function that erases the area inside the given rectangle.

All of these functions have both integer and floating point versions.

Basic Drawing Example The Basic Drawing example shows how to display basic graphics primitives in a variety of styles using the QPainter class.

If you need to draw a complex shape, especially if you need to do so repeatedly, consider creating a QPainterPath and drawing it using drawPath().

Painter Paths example The QPainterPath class provides a container for painting operations, enabling graphical shapes to be constructed and reused. The Painter Paths example shows how painter paths can be used to build complex shapes for rendering.

QPainter also provides the fillPath() function which fills the given QPainterPath with the given QBrush, and the strokePath() function that draws the outline of the given path (i.e. strokes the path).

See also the Vector Deformation example which shows how to use advanced vector techniques to draw text using a QPainterPath, the Gradients example which shows the different types of gradients that are available in Qt, and the Path Stroking example which shows Qt’s built-in dash patterns and shows how custom patterns can be used to extend the range of available patterns.

Text drawing is done using drawText(). When you need fine-grained positioning, boundingRect() tells you where a given drawText() command will draw.

Drawing Pixmaps and Images

There are functions to draw pixmaps/images, namely drawPixmap(), drawImage() and drawTiledPixmap(). Both drawPixmap() and drawImage() produce the same result, except that drawPixmap() is faster on-screen while drawImage() may be faster on a QPrinter or other devices.

There is a drawPicture() function that draws the contents of an entire QPicture. The drawPicture() function is the only function that disregards all the painter’s settings as QPicture has its own settings.

Drawing High Resolution Versions of Pixmaps and Images

High resolution versions of pixmaps have a device pixel ratio value larger than 1 (see QImageReader, QPixmap::devicePixelRatio()). Should it match the value of the underlying QPaintDevice, it is drawn directly onto the device with no additional transformation applied.

This is for example the case when drawing a QPixmap of 64x64 pixels size with a device pixel ratio of 2 onto a high DPI screen which also has a device pixel ratio of 2. Note that the pixmap is then effectively 32x32 pixels in user space . Code paths in Qt that calculate layout geometry based on the pixmap size will use this size. The net effect of this is that the pixmap is displayed as high DPI pixmap rather than a large pixmap.

Rendering Quality

To get the optimal rendering result using QPainter, you should use the platform independent QImage as paint device; i.e. using QImage will ensure that the result has an identical pixel representation on any platform.

The QPainter class also provides a means of controlling the rendering quality through its RenderHint enum and the support for floating point precision: All the functions for drawing primitives has a floating point version. These are often used in combination with the QPainter::Antialiasing render hint.

Concentric Circles Example The Concentric Circles example shows the improved rendering quality that can be obtained using floating point precision and anti-aliasing when drawing custom widgets. The application’s main window displays several widgets which are drawn using the various combinations of precision and anti-aliasing.

The RenderHint enum specifies flags to QPainter that may or may not be respected by any given engine. QPainter::Antialiasing indicates that the engine should antialias edges of primitives if possible, QPainter::TextAntialiasing indicates that the engine should antialias text if possible, and the QPainter::SmoothPixmapTransform indicates that the engine should use a smooth pixmap transformation algorithm.

The renderHints() function returns a flag that specifies the rendering hints that are set for this painter. Use the setRenderHint() function to set or clear the currently set RenderHints.

Coordinate Transformations

Normally, the QPainter operates on the device’s own coordinate system (usually pixels), but QPainter has good support for coordinate transformations.

nop
rotate()
scale()
translate()

The most commonly used transformations are scaling, rotation, translation and shearing. Use the scale() function to scale the coordinate system by a given offset, the rotate() function to rotate it clockwise and translate() to translate it (i.e. adding a given offset to the points). You can also twist the coordinate system around the origin using the shear() function. See the Affine Transformations example for a visualization of a sheared coordinate system.

Clipping

QPainter can clip any drawing operation to a rectangle, a region, or a vector path. The current clip is available using the functions clipRegion() and clipPath(). Whether paths or regions are preferred (faster) depends on the underlying paintEngine(). For example, the QImage paint engine prefers paths while the X11 paint engine prefers regions. Setting a clip is done in the painters logical coordinates.

After QPainter’s clipping, the paint device may also clip. For example, most widgets clip away the pixels used by child widgets, and most printers clip away an area near the edges of the paper. This additional clipping is not reflected by the return value of clipRegion() or hasClipping().

Composition Modes

QPainter provides the CompositionMode enum which defines the Porter-Duff rules for digital image compositing; it describes a model for combining the pixels in one image, the source, with the pixels in another image, the destination.

The two most common forms of composition are Source and SourceOver . Source is used to draw opaque objects onto a paint device. In this mode, each pixel in the source replaces the corresponding pixel in the destination. In SourceOver composition mode, the source object is transparent and is drawn on top of the destination.

Note that composition transformation operates pixelwise. For that reason, there is a difference between using the graphic primitive itself and its bounding rectangle: The bounding rect contains pixels with alpha == 0 (i.e the pixels surrounding the primitive). These pixels will overwrite the other image’s pixels, affectively clearing those, while the primitive only overwrites its own area.

Composition Modes Example The Composition Modes example, available in Qt’s examples directory, allows you to experiment with the various composition modes and see the results immediately.

Limitations

If you are using coordinates with Qt’s raster-based paint engine, it is important to note that, while coordinates greater than +/- 2 ^15 can be used, any painting performed with coordinates outside this range is not guaranteed to be shown; the drawing may be clipped. This is due to the use of short int in the implementation.

The outlines generated by Qt’s stroker are only an approximation when dealing with curved shapes. It is in most cases impossible to represent the outline of a bezier curve segment using another bezier curve segment, and so Qt approximates the curve outlines by using several smaller curves. For performance reasons there is a limit to how many curves Qt uses for these outlines, and thus when using large pen widths or scales the outline error increases. To generate outlines with smaller errors it is possible to use the QPainterPathStroker class, which has the setCurveThreshold member function which let’s the user specify the error tolerance. Another workaround is to convert the paths to polygons first and then draw the polygons instead.

Performance

QPainter is a rich framework that allows developers to do a great variety of graphical operations, such as gradients, composition modes and vector graphics. And QPainter can do this across a variety of different hardware and software stacks. Naturally the underlying combination of hardware and software has some implications for performance, and ensuring that every single operation is fast in combination with all the various combinations of composition modes, brushes, clipping, transformation, etc, is close to an impossible task because of the number of permutations. As a compromise we have selected a subset of the QPainter API and backends, where performance is guaranteed to be as good as we can sensibly get it for the given combination of hardware and software.

The backends we focus on as high-performance engines are:

Raster - This backend implements all rendering in pure software and is always used to render into QImages. For optimal performance only use the format types QImage::Format_ARGB32_Premultiplied, QImage::Format_RGB32 or QImage::Format_RGB16. Any other format, including QImage::Format_ARGB32, has significantly worse performance. This engine is used by default for QWidget and QPixmap.
OpenGL 2.0 (ES) - This backend is the primary backend for hardware accelerated graphics. It can be run on desktop machines and embedded devices supporting the OpenGL 2.0 or OpenGL/ES 2.0 specification. This includes most graphics chips produced in the last couple of years. The engine can be enabled by using QPainter onto a QOpenGLWidget.

These operations are:

Simple transformations, meaning translation and scaling, pluss 0, 90, 180, 270 degree rotations.
drawPixmap() in combination with simple transformations and opacity with non-smooth transformation mode ( QPainter::SmoothPixmapTransform not enabled as a render hint).
Rectangle fills with solid color, two-color linear gradients and simple transforms.
Rectangular clipping with simple transformations and intersect clip.
Composition Modes QPainter::CompositionMode_Source and QPainter::CompositionMode_SourceOver
Rounded rectangle filling using solid color and two-color linear gradients fills.
3x3 patched pixmaps, via qDrawBorderPixmap.

This list gives an indication of which features to safely use in an application where performance is critical. For certain setups, other operations may be fast too, but before making extensive use of them, it is recommended to benchmark and verify them on the system where the software will run in the end. There are also cases where expensive operations are ok to use, for instance when the result is cached in a QPixmap.

See also: PaintDevice PaintEngine {Qt SVG} {Basic Drawing Example} {Drawing Utility Functions}

Licence

The documentation is an adoption of the original Qt Documentation and provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation.

Struct rute::auto::painter::Painter

Implementations

impl<'a> Painter<'a>

pub fn new() -> Painter<'a>

pub fn device(&self) -> Option<PaintDevice<'_>>

pub fn begin<P: PaintDeviceTrait<'a>>(&self, arg0: &P) -> bool

pub fn end(&self) -> bool

pub fn is_active(&self) -> bool

pub fn init_from<P: PaintDeviceTrait<'a>>(&self, device: &P) -> &Self

pub fn set_composition_mode(&self, mode: CompositionMode) -> &Self

pub fn composition_mode(&self) -> CompositionMode

pub fn font(&self) -> Option<Font<'_>>

pub fn set_font<F: FontTrait<'a>>(&self, f: &F) -> &Self

pub fn set_pen<C: ColorTrait<'a>>(&self, color: &C) -> &Self

pub fn set_pen_2<P: PenTrait<'a>>(&self, pen: &P) -> &Self

pub fn set_pen_3(&self, style: PenStyle) -> &Self

pub fn pen(&self) -> Option<Pen<'_>>

pub fn set_brush<B: BrushTrait<'a>>(&self, brush: &B) -> &Self

pub fn set_brush_2(&self, style: BrushStyle) -> &Self

pub fn brush(&self) -> Option<Brush<'_>>

pub fn set_background_mode(&self, mode: BGMode) -> &Self

pub fn background_mode(&self) -> BGMode

pub fn brush_origin(&self) -> Point<'_>

pub fn set_brush_origin(&self, x: i32, y: i32) -> &Self

pub fn set_brush_origin_2<P: PointTrait<'a>>(&self, arg0: &P) -> &Self

pub fn set_brush_origin_3<P: PointFTrait<'a>>(&self, arg0: &P) -> &Self

pub fn set_background<B: BrushTrait<'a>>(&self, bg: &B) -> &Self

pub fn background(&self) -> Option<Brush<'_>>

pub fn opacity(&self) -> f32

pub fn set_opacity(&self, opacity: f32) -> &Self

pub fn clip_region(&self) -> Region<'_>

pub fn set_clip_rect<R: RectFTrait<'a>>( &self, arg0: &R, op: ClipOperation) -> &Self

pub fn set_clip_rect_2<R: RectTrait<'a>>( &self, arg0: &R, op: ClipOperation) -> &Self

pub fn set_clip_rect_3( &self, x: i32, y: i32, w: i32, h: i32, op: ClipOperation) -> &Self

pub fn set_clip_region<R: RegionTrait<'a>>( &self, arg0: &R, op: ClipOperation) -> &Self

pub fn set_clipping(&self, enable: bool) -> &Self

pub fn has_clipping(&self) -> bool

pub fn clip_bounding_rect(&self) -> RectF<'_>

pub fn save(&self) -> &Self

pub fn restore(&self) -> &Self

pub fn set_transform<T: TransformTrait<'a>>( &self, transform: &T, combine: bool) -> &Self

pub fn device_transform(&self) -> Option<Transform<'_>>

pub fn reset_transform(&self) -> &Self

pub fn set_world_transform<T: TransformTrait<'a>>( &self, matrix: &T, combine: bool) -> &Self

pub fn world_transform(&self) -> Option<Transform<'_>>

pub fn combined_transform(&self) -> Transform<'_>

pub fn scale(&self, sx: f32, sy: f32) -> &Self

pub fn shear(&self, sh: f32, sv: f32) -> &Self

pub fn rotate(&self, a: f32) -> &Self

pub fn window(&self) -> Rect<'_>

pub fn set_window<R: RectTrait<'a>>(&self, window: &R) -> &Self

pub fn set_window_2(&self, x: i32, y: i32, w: i32, h: i32) -> &Self

pub fn viewport(&self) -> Rect<'_>

pub fn set_viewport<R: RectTrait<'a>>(&self, viewport: &R) -> &Self

pub fn set_viewport_2(&self, x: i32, y: i32, w: i32, h: i32) -> &Self

pub fn set_view_transform_enabled(&self, enable: bool) -> &Self

pub fn view_transform_enabled(&self) -> bool

pub fn draw_point<P: PointFTrait<'a>>(&self, pt: &P) -> &Self

pub fn draw_point_2<P: PointTrait<'a>>(&self, p: &P) -> &Self

pub fn draw_point_3(&self, x: i32, y: i32) -> &Self

pub fn draw_points<P: PointFTrait<'a>>( &self, points: &P, point_count: i32) -> &Self

pub fn draw_points_2<P: PolygonFTrait<'a>>(&self, points: &P) -> &Self

pub fn draw_points_3<P: PointTrait<'a>>( &self, points: &P, point_count: i32) -> &Self

pub fn draw_points_4<P: PolygonTrait<'a>>(&self, points: &P) -> &Self

pub fn draw_line<L: LineFTrait<'a>>(&self, line: &L) -> &Self

pub fn draw_line_2<L: LineTrait<'a>>(&self, line: &L) -> &Self

pub fn draw_line_3(&self, x1: i32, y1: i32, x2: i32, y2: i32) -> &Self

pub fn draw_line_4<P: PointTrait<'a>>(&self, p1: &P, p2: &P) -> &Self

pub fn draw_line_5<P: PointFTrait<'a>>(&self, p1: &P, p2: &P) -> &Self

pub fn draw_lines<L: LineFTrait<'a>>(&self, lines: &L, line_count: i32) -> &Self

pub fn draw_lines_3<P: PointFTrait<'a>>( &self, point_pairs: &P, line_count: i32) -> &Self

pub fn draw_lines_7<P: PointTrait<'a>>( &self, point_pairs: &P, line_count: i32) -> &Self

pub fn draw_rect<R: RectFTrait<'a>>(&self, rect: &R) -> &Self

pub fn draw_rect_2(&self, x1: i32, y1: i32, w: i32, h: i32) -> &Self

pub fn draw_rect_3<R: RectTrait<'a>>(&self, rect: &R) -> &Self

pub fn draw_rects<R: RectFTrait<'a>>(&self, rects: &R, rect_count: i32) -> &Self

pub fn draw_rects_3<R: RectTrait<'a>>(&self, rects: &R, rect_count: i32) -> &Self

pub fn draw_ellipse<R: RectFTrait<'a>>(&self, r: &R) -> &Self

pub fn draw_ellipse_2<R: RectTrait<'a>>(&self, r: &R) -> &Self

pub fn draw_ellipse_3(&self, x: i32, y: i32, w: i32, h: i32) -> &Self

pub fn set_clip_rect<R: RectFTrait<'a>>(
&self,
arg0: &R,
op: ClipOperation
) -> &Self

pub fn set_clip_rect_2<R: RectTrait<'a>>(
&self,
arg0: &R,
op: ClipOperation
) -> &Self

pub fn set_clip_rect_3(
&self,
x: i32,
y: i32,
w: i32,
h: i32,
op: ClipOperation
) -> &Self

pub fn set_clip_region<R: RegionTrait<'a>>(
&self,
arg0: &R,
op: ClipOperation
) -> &Self

pub fn set_transform<T: TransformTrait<'a>>(
&self,
transform: &T,
combine: bool
) -> &Self

pub fn set_world_transform<T: TransformTrait<'a>>(
&self,
matrix: &T,
combine: bool
) -> &Self

pub fn draw_points<P: PointFTrait<'a>>(
&self,
points: &P,
point_count: i32
) -> &Self

pub fn draw_points_3<P: PointTrait<'a>>(
&self,
points: &P,
point_count: i32
) -> &Self

pub fn draw_lines_3<P: PointFTrait<'a>>(
&self,
point_pairs: &P,
line_count: i32
) -> &Self

pub fn draw_lines_7<P: PointTrait<'a>>(
&self,
point_pairs: &P,
line_count: i32
) -> &Self

pub fn draw_ellipse_4<P: PointFTrait<'a>>(
&self,
center: &P,
rx: f32,
ry: f32
) -> &Self

pub fn draw_ellipse_5<P: PointTrait<'a>>(
&self,
center: &P,
rx: i32,
ry: i32
) -> &Self

pub fn draw_polyline<P: PointFTrait<'a>>(
&self,
points: &P,
point_count: i32
) -> &Self

pub fn draw_polyline_3<P: PointTrait<'a>>(
&self,
points: &P,
point_count: i32
) -> &Self

pub fn draw_polygon<P: PointFTrait<'a>>(
&self,
points: &P,
point_count: i32,
fill_rule: FillRule
) -> &Self

pub fn draw_polygon_2<P: PolygonFTrait<'a>>(
&self,
polygon: &P,
fill_rule: FillRule
) -> &Self

pub fn draw_polygon_3<P: PointTrait<'a>>(
&self,
points: &P,
point_count: i32,
fill_rule: FillRule
) -> &Self

pub fn draw_polygon_4<P: PolygonTrait<'a>>(
&self,
polygon: &P,
fill_rule: FillRule
) -> &Self

pub fn draw_convex_polygon<P: PointFTrait<'a>>(
&self,
points: &P,
point_count: i32
) -> &Self

pub fn draw_convex_polygon_3<P: PointTrait<'a>>(
&self,
points: &P,
point_count: i32
) -> &Self

pub fn draw_rounded_rect<R: RectFTrait<'a>>(
&self,
rect: &R,
x_radius: f32,
y_radius: f32,
mode: SizeMode
) -> &Self

pub fn draw_rounded_rect_2(
&self,
x: i32,
y: i32,
w: i32,
h: i32,
x_radius: f32,
y_radius: f32,
mode: SizeMode
) -> &Self

pub fn draw_rounded_rect_3<R: RectTrait<'a>>(
&self,
rect: &R,
x_radius: f32,
y_radius: f32,
mode: SizeMode
) -> &Self

pub fn draw_round_rect<R: RectFTrait<'a>>(
&self,
r: &R,
xround: i32,
yround: i32
) -> &Self

pub fn draw_round_rect_2(
&self,
x: i32,
y: i32,
w: i32,
h: i32,
arg0: i32,
arg1: i32
) -> &Self

pub fn draw_round_rect_3<R: RectTrait<'a>>(
&self,
r: &R,
xround: i32,
yround: i32
) -> &Self

pub fn draw_tiled_pixmap<P: PixmapTrait<'a>, Q: PointFTrait<'a>, R: RectFTrait<'a>>(
&self,
rect: &R,
pm: &P,
offset: &Q
) -> &Self

pub fn draw_tiled_pixmap_2<P: PixmapTrait<'a>>(
&self,
x: i32,
y: i32,
w: i32,
h: i32,
arg0: &P,
sx: i32,
sy: i32
) -> &Self

pub fn draw_tiled_pixmap_3<P: PixmapTrait<'a>, Q: PointTrait<'a>, R: RectTrait<'a>>(
&self,
arg0: &R,
arg1: &P,
arg2: &Q
) -> &Self

pub fn draw_pixmap<P: PixmapTrait<'a>, R: RectFTrait<'a>>(
&self,
target_rect: &R,
pixmap: &P,
source_rect: &R
) -> &Self

pub fn draw_pixmap_2<P: PixmapTrait<'a>, R: RectTrait<'a>>(
&self,
target_rect: &R,
pixmap: &P,
source_rect: &R
) -> &Self

pub fn draw_pixmap_3<P: PixmapTrait<'a>>(
&self,
x: i32,
y: i32,
w: i32,
h: i32,
pm: &P,
sx: i32,
sy: i32,
sw: i32,
sh: i32
) -> &Self

pub fn draw_pixmap_4<P: PixmapTrait<'a>>(
&self,
x: i32,
y: i32,
pm: &P,
sx: i32,
sy: i32,
sw: i32,
sh: i32
) -> &Self

pub fn draw_pixmap_5<Q: PixmapTrait<'a>, P: PointFTrait<'a>, R: RectFTrait<'a>>(
&self,
p: &P,
pm: &Q,
sr: &R
) -> &Self

pub fn draw_pixmap_6<Q: PixmapTrait<'a>, P: PointTrait<'a>, R: RectTrait<'a>>(
&self,
p: &P,
pm: &Q,
sr: &R
) -> &Self

pub fn draw_pixmap_7<Q: PixmapTrait<'a>, P: PointFTrait<'a>>(
&self,
p: &P,
pm: &Q
) -> &Self

pub fn draw_pixmap_8<Q: PixmapTrait<'a>, P: PointTrait<'a>>(
&self,
p: &P,
pm: &Q
) -> &Self

pub fn draw_pixmap_10<P: PixmapTrait<'a>, R: RectTrait<'a>>(
&self,
r: &R,
pm: &P
) -> &Self

pub fn draw_pixmap_11<P: PixmapTrait<'a>>(
&self,
x: i32,
y: i32,
w: i32,
h: i32,
pm: &P
) -> &Self

pub fn draw_image<I: ImageTrait<'a>, R: RectFTrait<'a>>(
&self,
target_rect: &R,
image: &I,
source_rect: &R,
flags: ImageConversionFlags
) -> &Self

pub fn draw_image_2<I: ImageTrait<'a>, R: RectTrait<'a>>(
&self,
target_rect: &R,
image: &I,
source_rect: &R,
flags: ImageConversionFlags
) -> &Self

pub fn draw_image_3<I: ImageTrait<'a>, P: PointFTrait<'a>, R: RectFTrait<'a>>(
&self,
p: &P,
image: &I,
sr: &R,
flags: ImageConversionFlags
) -> &Self

pub fn draw_image_4<I: ImageTrait<'a>, P: PointTrait<'a>, R: RectTrait<'a>>(
&self,
p: &P,
image: &I,
sr: &R,
flags: ImageConversionFlags
) -> &Self

pub fn draw_image_5<I: ImageTrait<'a>, R: RectFTrait<'a>>(
&self,
r: &R,
image: &I
) -> &Self

pub fn draw_image_6<I: ImageTrait<'a>, R: RectTrait<'a>>(
&self,
r: &R,
image: &I
) -> &Self

pub fn draw_image_7<I: ImageTrait<'a>, P: PointFTrait<'a>>(
&self,
p: &P,
image: &I
) -> &Self

pub fn draw_image_8<I: ImageTrait<'a>, P: PointTrait<'a>>(
&self,
p: &P,
image: &I
) -> &Self

pub fn draw_image_9<I: ImageTrait<'a>>(
&self,
x: i32,
y: i32,
image: &I,
sx: i32,
sy: i32,
sw: i32,
sh: i32,
flags: ImageConversionFlags
) -> &Self