Shape QML Type

Renders a path. More...

• List of all members, including inherited members

Properties

• asynchronous : bool
• boundingRect : rect (since 6.6)
• containsMode : enumeration (since QtQuick.Shapes 1.11)
• data : list<Object>
• fillMode : enumeration (since QtQuick.Shapes 6.7)
• horizontalAlignment : enumeration (since 6.7)
• preferredRendererType : enumeration (since 6.6)
• rendererType : enumeration
• status : enumeration
• vendorExtensionsEnabled : bool
• verticalAlignment : enumeration (since 6.7)

Detailed Description

Renders a path by triangulating geometry from a QPainterPath.

This approach is different from rendering shapes via QQuickPaintedItem or the 2D Canvas because the path never gets rasterized in software. Therefore Shape is suitable for creating shapes spreading over larger areas of the screen, avoiding the performance penalty for texture uploads or framebuffer blits. In addition, the declarative API allows manipulating, binding to, and even animating the path element properties like starting and ending position, the control points, and so on.

The types for specifying path elements are shared between PathView and Shape. However, not all Shape implementations support all path element types, while some may not make sense for PathView. Shape's currently supported subset is: PathMove, PathLine, PathQuad, PathCubic, PathArc, PathText and PathSvg.

See Path for a detailed overview of the supported path elements.

 Shape {
     width: 200
     height: 150
     anchors.centerIn: parent
     ShapePath {
         strokeWidth: 4
         strokeColor: "red"
         fillGradient: LinearGradient {
             x1: 20; y1: 20
             x2: 180; y2: 130
             GradientStop { position: 0; color: "blue" }
             GradientStop { position: 0.2; color: "green" }
             GradientStop { position: 0.4; color: "red" }
             GradientStop { position: 0.6; color: "yellow" }
             GradientStop { position: 1; color: "cyan" }
         }
         strokeStyle: ShapePath.DashLine
         dashPattern: [ 1, 4 ]
         startX: 20; startY: 20
         PathLine { x: 180; y: 130 }
         PathLine { x: 20; y: 130 }
         PathLine { x: 20; y: 20 }
     }
 }

Like Item, Shape also allows any visual or non-visual objects to be declared as children. ShapePath objects are handled specially. This is useful since it allows adding visual items, like Rectangle or Image, and non-visual objects, like Timer directly as children of Shape.

The following list summarizes the available Shape rendering approaches:

• When Qt Quick is running with the default, hardware-accelerated backend (RHI), the generic shape renderer will be used. This converts the shapes into triangles which are passed to the renderer.
• The software backend is fully supported. The path is rendered via QPainter::strokePath() and QPainter::fillPath() in this case.
• The OpenVG backend is not currently supported.

When using Shape, it is important to be aware of potential performance implications:

• When the application is running with the generic, triangulation-based Shape implementation, the geometry generation happens entirely on the CPU. This is potentially expensive. Changing the set of path elements, changing the properties of these elements, or changing certain properties of the Shape itself all lead to retriangulation of the affected paths on every change. Therefore, applying animation to such properties can affect performance on less powerful systems.
• However, the data-driven, declarative nature of the Shape API often means better cacheability for the underlying CPU and GPU resources. A property change in one ShapePath will only lead to reprocessing the affected ShapePath, leaving other parts of the Shape unchanged. Therefore, a frequently changing property can still result in a lower overall system load than with imperative painting approaches (for example, QPainter).
• At the same time, attention must be paid to the number of Shape elements in the scene. The way such a Shape item is represented in the scene graph is different from an ordinary geometry-based item, and incurs a certain cost when it comes to OpenGL state changes.
• As a general rule, scenes should avoid using separate Shape items when it is not absolutely necessary. Prefer using one Shape item with multiple ShapePath elements over multiple Shape items.

See also Qt Quick Examples - Shapes, Weather Forecast Example, Path, PathMove, PathLine, PathQuad, PathCubic, PathArc, and PathSvg.

Property Documentation