Initial commit

2026-04-29 07:19:21 +03:00
commit 9a8cdfa08a
5964 changed files with 1194660 additions and 0 deletions
@@ -0,0 +1,192 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
+
+import QtQuick
+import "TraceUtils.js" as TraceUtils
+import QtQuick.VirtualKeyboard
+
+/*!
+    \qmltype TraceCanvas
+    \inqmlmodule QtQuick.VirtualKeyboard.Styles
+    \brief A specialized Canvas type for rendering Trace objects.
+    \ingroup qmlclass
+    \ingroup qtvirtualkeyboard-styles-qml
+    \inherits Canvas
+    \since QtQuick.VirtualKeyboard 2.0
+
+    This type provides capabilities for rendering Trace objects on the screen.
+
+    To make the Trace rendering available in the keyboard, this type must be
+    declared as the \l {KeyboardStyle::traceCanvasDelegate}
+    {KeyboardStyle.traceCanvasDelegate} component.
+
+    \code
+        traceCanvasDelegate: TraceCanvas {
+        }
+    \endcode
+
+    Custom drawing attributes can be initialized in the Canvas.available
+    signal. For example:
+
+    \code
+        onAvailableChanged: {
+            if (!available)
+                return;
+            var ctx = getContext("2d")
+            ctx.lineWidth = 8 * scaleHint
+            ctx.lineCap = "round"
+            ctx.strokeStyle = Qt.rgba(0xFF, 0xFF, 0xFF)
+            ctx.fillStyle = ctx.strokeStyle
+        }
+    \endcode
+
+    The type offers built-in options for Trace rendering. Currently
+    the following rendering options are available:
+
+    \list
+        \li \c renderSmoothedLine Renders smoothed line with round corners (the default)
+    \endlist
+
+    The rendering function can be changed with the renderFunction property.
+
+    \code
+        renderFunction: renderSmoothedLine
+    \endcode
+
+    Custom rendering function is also supported. Consider the following example:
+
+    \code
+        renderFunction: renderCustomLine
+
+        function renderCustomLine() {
+            getContext("2d")
+            var points = trace.points()
+
+            ...
+        }
+    \endcode
+*/
+
+Canvas {
+    id: canvas
+
+    /*! Provides access to \l Trace object.
+    */
+    property Trace trace
+
+    /*! Enables auto destruction mode.
+
+        If enabled, this item will be destroyed when the \c trace object is
+        destroyed.
+
+        The default value is false. In this case the canvas can be reused after
+        onRecycle signal is triggered.
+    */
+    property bool autoDestroy
+
+    /*! Specifies the approximate delay in milliseconds, counted from the beginning of the
+        auto destruction, before the object is to be destroyed or recycled.
+
+        This delay makes it possible, for example, to animate the item before destruction.
+
+        The default value is 0.
+    */
+    property int autoDestroyDelay
+
+    /*! This property defines the rendering function.
+
+        The default value is \c renderSmoothedLine
+    */
+    property var renderFunction: renderSmoothedLine
+
+    property int __renderPos
+
+    property bool __renderingEnabled
+
+    /*! Renders smoothed line with round corners.
+
+        This function is incremental and renders only the new part added to the Trace.
+
+        This function does not alter any of the canvas attributes (i.e. they can be set elsewhere.)
+    */
+    function renderSmoothedLine() {
+        __renderPos = TraceUtils.renderSmoothedLine(getContext("2d"), trace, __renderPos)
+    }
+
+    /*! Clears screen and resets the rendering.
+
+        \since 6.1
+    */
+    function renderClear() {
+        var ctx = getContext("2d")
+        ctx.clearRect(0, 0, width, height)
+        __renderPos = 0
+    }
+
+    /*! Recycles trace canvas by clearing all drawings and resetting the variables.
+
+        The function triggers onRecycle signal after completed (before the return).
+
+        The function returns true when recycling is successful.
+
+        \since 6.1
+    */
+    function recycle() {
+        if (!available) {
+            destroy()
+            return false
+        }
+
+        trace = null
+        recycleTimer.stop()
+        opacity = Qt.binding(function() {
+            return trace ? trace.opacity : 1.0
+        })
+        requestAnimationFrame(renderClear)
+        onRecycle(canvas)
+
+        return true
+    }
+
+    /*! Emitted when the \a traceCanvas is recycled.
+
+        \since 6.1
+    */
+    signal onRecycle(var traceCanvas)
+
+    Timer {
+        id: recycleTimer
+        interval: canvas.autoDestroyDelay
+        onTriggered: canvas.recycle()
+    }
+
+    onTraceChanged: {
+        if (trace === null) {
+            if (autoDestroy || !available)
+                destroy(autoDestroyDelay)
+            else
+                recycleTimer.restart()
+        }
+    }
+
+    onAvailableChanged: {
+        __renderingEnabled = available
+        if (__renderingEnabled)
+            requestAnimationFrame(renderFunction)
+    }
+
+    Connections {
+        target: canvas.__renderingEnabled && trace ? trace : null
+        function onLengthChanged() { if (renderFunction) canvas.requestAnimationFrame(renderFunction) }
+        function onFinalChanged() { if (renderFunction) canvas.requestAnimationFrame(renderFunction) }
+    }
+
+    opacity: trace ? trace.opacity : 1.0
+
+    Behavior on opacity {
+        NumberAnimation {
+            duration: 1500
+            easing.type: Easing.InOutQuad
+        }
+    }
+}