Calqlatr

Une calculatrice conçue pour les appareils en mode paysage et portrait. Elle utilise Qt Quick des composants personnalisés et des mises en page réactives pour l'interface utilisateur, et JavaScript pour la logique de l'application.

L'interface utilisateur de l'exemple de calculatrice

Calqlatr fait la démonstration de diverses fonctionnalités QML et Qt Quick telles que l'affichage de composants personnalisés et l'utilisation de mises en page réactives. La logique d'application est mise en œuvre en JavaScript et l'interface utilisateur en QML.

Exécution de l'exemple

Pour exécuter l'exemple à partir de Qt CreatorOuvrez le mode Welcome et sélectionnez l'exemple à partir de Examples. Pour plus d'informations, voir Qt Creator: Tutoriel : Construire et exécuter. Après avoir exécuté l'exemple, vous devriez pouvoir utiliser l'application comme une calculatrice standard.

Affichage de composants personnalisés

L'application Calqlatr utilise des types personnalisés. Ceux-ci sont définis dans leur propre fichier .qml :

  • BackspaceButton.qml
  • CalculatorButton.qml
  • Display.qml
  • NumberPad.qml

Pour utiliser ces types personnalisés dans Main.qml, ajoutez une instruction d'importation pour le dossier content où se trouvent les types :

import "content"

Par exemple, le type NumberPad est utilisé dans Main.qml pour créer le pavé numérique de la calculatrice. Il est imbriqué dans un type Item, le type de base pour tous les éléments visuels dans Qt Quick:

        NumberPad {
            id: numberPad
            Layout.margins: root.margin
        }

Les composants personnalisés sont des types QML qui peuvent être définis dans n'importe quel fichier QML. Ils se comportent de la même manière que les composants définis dans leur propre fichier .qml, comme NumberPad.qml. Dans NumberPad.qml, les composants DigitButton et OperatorButton sont définis. De nouvelles propriétés peuvent être ajoutées ou des propriétés existantes peuvent être modifiées dans ces composants. Ici, le gestionnaire onReleased est remplacé pour les deux composants personnalisés.

    component DigitButton: CalculatorButton {
        onReleased: {
            root.digitPressed(text);
            updateDimmed();
        }
    }

    component OperatorButton: CalculatorButton {
        onReleased: {
            root.operatorPressed(text);
            updateDimmed();
        }
        textColor: controller.qtGreenColor
        implicitWidth: 48
        dimmable: true
    }

En outre, utilisez le type CalculatorButton pour les différents boutons sur NumberPad. CalculatorButton.qml définit les propriétés de base d'un bouton, que vous modifiez pour chaque instance sur NumberPad.qml. Pour les boutons de chiffre et d'opérateur, quelques propriétés supplémentaires sont ajoutées, telles que les propriétés text, width et dimmable. Utilisez dimmable pour désactiver visuellement les boutons (atténués) lorsque le moteur de la calculatrice n'accepte pas de saisie à partir de ce bouton.

                DigitButton {
                    text: "e"
                    dimmable: true
                    implicitWidth: 48
                }

Le répertoire content contient un autre fichier appelé BackSpaceButton.qml, qui est un cas particulier de CalculatorButton, dans lequel nous souhaitons afficher une image sur le bouton plutôt que d'utiliser du texte. Ce bouton est identique au bouton OperatorButton, mais il contient un icon au lieu d'un text.

Mises en page réactives

Dans cet exemple, les mises en page réactives organisent les différents composants de l'interface utilisateur pour les modes portrait et paysage. Elle permet également de basculer entre ces deux modes. Vous pouvez le constater dans Main.qml, qui définit un ColumnLayout pour le mode portrait et un RowLayout pour le mode paysage.

        ColumnLayout {
            id: portraitMode
            anchors.fill: parent
            visible: true

            LayoutItemProxy {
                target: display
                Layout.minimumHeight: display.minHeight
            }
            LayoutItemProxy {
                target: numberPad
                Layout.alignment: Qt.AlignHCenter
            }
        }

        RowLayout {
            id: landscapeMode
            anchors.fill: parent
            visible: false

            LayoutItemProxy {
                target: display
            }
            LayoutItemProxy {
                target: numberPad
                Layout.alignment: Qt.AlignVCenter
            }
        }

Le ColumnLayout représente la disposition en mode portrait de l'application, et le RowLayout représente la disposition en mode paysage. La propriété visible gère la disposition utilisée à un moment donné. La propriété id des composants NumberPad et Display est utilisée pour définir la propriété target des types LayoutItemProxy. Cela permet aux deux présentations d'utiliser les mêmes éléments de contenu. En outre, les propriétés peuvent être transférées de l'élément LayoutItemProxy à l'élément target lui-même. Par exemple, lorsque l'élément NumberPad est instancié, les deux présentations ont besoin d'un élément Layout.alignment différent.

Le passage d'une présentation à l'autre s'effectue dans le gestionnaire de signal de la propriété isPortraitMode en définissant leurs visibilités :

        onIsPortraitModeChanged: {
            if (isPortraitMode) {
                portraitMode.visible = true;
                landscapeMode.visible = false;
            } else {
                portraitMode.visible = false;
                landscapeMode.visible = true;
            }
        }

Cela est possible parce que QML crée des gestionnaires de signaux pour toutes les propriétés auto-déclarées, dans ce cas le gestionnaire on<Property>Changed, où <property> est la propriété isPortraitMode.

Une mise en page réactive est également utilisée dans NumberPad.qml lors de la définition de la mise en page portrait et paysage pour le site NumberPad lui-même.

        RowLayout {
            spacing: controller.spacing

            GridLayout {
                id: scientificGrid
                columns: 3
                columnSpacing: controller.spacing
                rowSpacing: controller.spacing
                visible: !isPortraitMode

                OperatorButton { text: "x²" }
                OperatorButton { text: "⅟x" }
                OperatorButton { text: "√" }
                OperatorButton { text: "x³" }
                OperatorButton { text: "sin" }
                OperatorButton { text: "|x|" }
                OperatorButton { text: "log" }
                OperatorButton { text: "cos" }
                DigitButton {
                    text: "e"
                    dimmable: true
                    implicitWidth: 48
                }
                OperatorButton { text: "ln" }
                OperatorButton { text: "tan" }
                DigitButton {
                    text: "π"
                    dimmable: true
                    implicitWidth: 48
                }
            }

            GridLayout {
                id: mainGrid
                columns: 5
                columnSpacing: controller.spacing
                rowSpacing: controller.spacing

                BackspaceButton {}
                DigitButton { text: "7" }
                DigitButton { text: "8" }
                DigitButton { text: "9" }
                OperatorButton {
                    text: "÷"
                    implicitWidth: 38
                }

                OperatorButton {
                    text: "AC"
                    textColor: controller.backspaceRedColor
                    accentColor: controller.backspaceRedColor
                }
                DigitButton { text: "4" }
                DigitButton { text: "5" }
                DigitButton { text: "6" }
                OperatorButton {
                    text: "×"
                    implicitWidth: 38
                }

                OperatorButton {
                    text: "="
                    implicitHeight: 81
                    Layout.rowSpan: 2
                }
                DigitButton { text: "1" }
                DigitButton { text: "2" }
                DigitButton { text: "3" }
                OperatorButton {
                    text: "−"
                    implicitWidth: 38
                }

                OperatorButton {
                    text: "±"
                    implicitWidth: 38
                }
                DigitButton { text: "0" }
                DigitButton {
                    text: "."
                    dimmable: true
                }
                OperatorButton {
                    text: "+"
                    implicitWidth: 38
                }
            }
        } // RowLayout

Dans ce cas, deux éléments LayoutItemProxy sont créés. Leurs propriétés target sont définies comme suit : scientificGrid, un type Grid contenant tous les boutons scientifiques, et mainGrid, un autre type Grid contenant tous les boutons standard.

Animation des couleurs de texte des boutons

Dans CalculatorButton.qml, les couleurs du texte des boutons du pavé numérique sont également animées.

        ...
        color: getTextColor()
        Behavior on color {
            ColorAnimation {
                duration: 120
                easing.type: Easing.OutElastic
            }
        }

Les changements de couleur sont animés en définissant une propriété Behavior sur la propriété color. Lorsqu'un bouton est défini sur dimmed = true, il apparaît plus sombre. Lorsqu'un bouton est pressé, il s'allume en vert. Pour modifier dynamiquement la propriété dimmed de tous les boutons du site NumberPad, le signal buttonPressed appelle la fonction updateDimmed() du site NumberPad.

    function updateDimmed() {
        for (let i = 0; i < mainGrid.children.length; i++) {
            mainGrid.children[i].dimmed = root.isButtonDisabled(mainGrid.children[i].text);
        }
        for (let j = 0; j < scientificGrid.children.length; j++) {
            scientificGrid.children[j].dimmed = root.isButtonDisabled(
                        scientificGrid.children[j].text);
        }
    }

Effectuer des calculs

Le fichier calculator.js définit le moteur de la calculatrice. Il contient des variables pour stocker l'état de la calculatrice et des fonctions qui sont appelées lorsque l'utilisateur appuie sur les boutons de chiffres et d'opérateurs. Pour utiliser le moteur, importez calculator.js dans le fichier Main.qml en utilisant l'alias CalcEngine:

import "content/calculator.js" as CalcEngine

Par défaut, l'importation d'un fichier JavaScript à partir de QML crée une nouvelle instance de ce fichier, et tout état qu'il contient est unique à cette instance. L'utilisation de .pragma library permet à l'état d'être partagé par tous les utilisateurs du script.

.pragma library

Lorsque les utilisateurs appuient sur un chiffre, le texte du chiffre apparaît à l'écran. Lorsqu'il appuie sur un opérateur, le calcul approprié est effectué et le résultat peut être affiché à l'aide de l'opérateur égal (=). L'opérateur d'effacement total (AC) réinitialise le moteur de la calculatrice.

Fichiers source

Test de l'interface graphique Squish

Cette application est livrée avec des tests Squish GUI destinés à Qt Test pour Android. Les tests sont réalisés avec Squish for Qt et sont écrits en Python. Ils se trouvent dans le répertoire de test de l'application.

Lorsque vous utilisez Squish pour Qt pour Android, assurez-vous d'utiliser le crochet intégré à Qt et de transférer le port Squish avec adb. Si vous obtenez l'erreur "Cannot load library" lorsque dlopen échoue, désactivez QT_USE_TARGET_ANDROID_BUILD_DIR dans la configuration CMake, ou effacez-la de Projects->Build Settings->CMake->Current Configuration dans Qt Creator.

Si vous n'avez pas de licence Squish, vous pouvez obtenir une version d'essai gratuite.

Exemple de projet @ code.qt.io

Voir aussi Applications QML.

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.