QML

For other uses, see QML (disambiguation).

QML
Influenced by
Paradigm	Multi-paradigm: declarative, reactive, scripting
Developer	Qt Project
First appeared	2009 (2009)
Stable release	5.5.0^[1] / July 1, 2015 (2015-07-01)
Typing discipline	dynamic, strong
Website	qt-project.org/doc/qt-5/qmlapplications.html
XAML, JSON, JavaScript, Qt
Influenced
Qt

QML
Filename extension	`.qml`
Type of format	Scripting language

QML (Qt Meta Language or Qt Modeling Language^[2]) is a user interface markup language. It is a JSON-like declarative language for designing user interface–centric applications. Inline JavaScript code handles imperative aspects. It is part of Qt Quick, the UI creation kit developed by Nokia within the Qt framework. QML is mainly used for mobile applications where touch input, fluid animations (60 FPS) and user experience are crucial. QML documents describe an object tree of elements. QML elements^[3] shipped with Qt are a sophisticated set of building blocks, graphical (e.g., rectangle, image) and behavioral (e.g., state, transition, animation). These elements can be combined to build components ranging in complexity from simple buttons and sliders, to complete internet-enabled programs.

QML elements can be augmented by standard JavaScript both inline and via included .js files. Elements can also be seamlessly integrated and extended by C++ components using the Qt framework.

QML is the language; its JavaScript runtime is the V4 engine and Qt Quick is the scenegraph-based UI framework. These are all part of the Qt Declarative module, but the technology is no longer called Qt Declarative.

Adoption

Syntax, semantics

Basic syntax

Example:

import QtQuick 2.0

 Rectangle {
     id: canvas
     width: 250
     height: 200
     color: "blue"

     Image {
         id: logo
         source: "pics/logo.png"
         anchors.centerIn: parent
         x: canvas.height / 5
     }
 }

Objects are specified by their type, followed by a pair of braces. Object types always begin with a capital letter. In the example above, there are two objects, a Rectangle; and its child, an Image. Between the braces, one can specify information about the object, such as its properties. Properties are specified as property: value. In the example above, we can see the Image has a property named source, which has been assigned the value "pics/logo.png". The property and its value are separated by a colon.

The id property

Each object can be given a special unique property called an id. Assigning an id enables the object to be referred to by other objects and scripts. The first Rectangle element below has an id, "myRect". The second Rectangle element defines its own width by referring to myRect.width, which means it will have the same width value as the first Rectangle element.

 Item {
     Rectangle {
         id: myRect
         width: 120
         height: 100
     }
     Rectangle {
         width: myRect.width
         height: 200
     }
 }

Note that an id must begin with a lower-case letter or an underscore, and cannot contain characters other than letters, numbers and underscores.

Property bindings

A property binding specifies the value of a property in a declarative way. The property value is automatically updated if the other properties or data values change, following the reactive programming paradigm.

Property bindings are created implicitly in QML whenever a property is assigned a JavaScript expression. The following QML uses two property bindings to connect the size of the rectangle to that of otherItem.

 Rectangle {
     width: otherItem.width
     height: otherItem.height
 }

QML extends a standards-compliant JavaScript engine, so any valid JavaScript expression can be used as a property binding. Bindings can access object properties, make function calls, and even use built-in JavaScript objects like Date and Math.

Example:

 Rectangle {
     function calculateMyHeight() {
         return Math.max(otherItem.height, thirdItem.height);
     }
     anchors.centerIn: parent
     width: Math.min(otherItem.width, 10)
     height: calculateMyHeight()
     color: { if (width > 10) "blue"; else "red" }
 }

States

States are a mechanism to combine changes to properties in a semantic unit. A button for example has a pressed- and a non-pressed state, an address book application could have a read-only and an edit state for contacts. Every element has an "implicit" base state. Every other state is described by listing the properties and values of those elements which differ from the base state.

Example: In the default state, myRect is positioned at 0,0. In the "moved" state, it is positioned at 50,50. Clicking within the mouse area changes the state from the default state to the "moved" state, thus moving the rectangle.

 import QtQuick 2.0

 Item {
     id: myItem
     width: 200; height: 200

     Rectangle {
         id: myRect
         width: 100; height: 100
         color: "red"
     }
     states: [
         State {
             name: "moved"
             PropertyChanges {
                 target: myRect
                 x: 50
                 y: 50
             }
         }
     ]
     MouseArea {
         anchors.fill: parent
         onClicked: myItem.state = 'moved'
     }
 }

State changes can be animated using Transitions.

For example, adding this code to the above Item element animates the transition to the "moved" state:

 transitions: [
     Transition {
         from: "*"
         to: "moved"
         NumberAnimation { properties: "x,y"; duration: 500 }
     }
  ]

Animation

Animations in QML are done by animating properties of objects. Properties of type real, int, color, rect, point, size, and vector3d can all be animated.

QML supports three main forms of animation: basic property animation, transitions, and property behaviors.

The simplest form of animation is a PropertyAnimation, which can animate all of the property types listed above. A property animation can be specified as a value source using the Animation on property syntax. This is especially useful for repeating animations.

The following example creates a bouncing effect:

 Rectangle {
     id: rect
     width: 120; height: 200

     Image {
         id: img
         source: "pics/qt.png"
         x: 60 - img.width/2
         y: 0

         SequentialAnimation on y {
             loops: Animation.Infinite
             NumberAnimation { to: 200 - img.height; easing.type: Easing.OutBounce; duration: 2000 }
             PauseAnimation { duration: 1000 }
             NumberAnimation { to: 0; easing.type: Easing.OutQuad; duration: 1000 }
         }
     }
 }

Qt/C++ integration

QML does not need Qt/C++ knowledge to use, but it can be easily extended via Qt.

Familiar concepts

QML provides direct access to the following concepts from Qt:

QAction – the action type
QObject signals and slots – available as functions to call in JavaScript
QObject properties – available as variables in JavaScript
QWidget – QDeclarativeView is a QML-displaying widget
Q*Model – used directly in data binding (e.g. QAbstractItemModel)

Qt signal handlers

Signal handlers allow actions to be taken in response to an event. For instance, the MouseArea element has signal handlers to handle mouse press, release and click:

 MouseArea {
     onPressed: console.log("mouse button pressed")
 }

All signal handlers begin with "on".

Development tools

Because QML and JavaScript are very similar, almost all code editors supporting JavaScript will work. However full support for syntax highlighting, code completion, integrated help, and a WYSIWYG editor are available in the free cross-platform IDE Qt Creator since version 2.1. The version of Creator which ships with commercial versions of Qt has more features in the WYSIWYG editor.

The qml executable can be used to run a QML file as a script. However packaging an application for deployment generally involves writing a simple C++ launcher and packaging the necessary QML files as resources.

References

↑ "Qt 5.5 Released". July 1, 2015.
↑ "Henrik Hartz (Product Manager for Qt Software at Nokia) comment on the name". 24 August 2009. Retrieved 2013-05-29.
↑ "Qt 4.7: QML Elements". Doc.qt.nokia.com. Retrieved 2010-09-22.

External links

How-tos

Qt

Technologies	Meta-object System QML QtScript Qt Quick Signals and slots

Tools	qmake Qt Creator Qt Linguist

Bindings	PHP-Qt PyQt PySide QtRuby Qt Jambi hbQT

Related topics	Digia KDE Mer MeeGo Qt Company Qt Project

This article is issued from Wikipedia - version of the Sunday, January 03, 2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.