[Development] QML import versions

[Nurmi J-P]

Hi all,

I'd like to propose that all QML imports that are part of the Qt Essentials start following the respective Qt version number.

Let's take a look at the version history of some of the QtQml and QtQuick imports.

### Qt 5.0

- QtQml 2.0
- QtQuick 2.0
- QtQuick.Particles 2.0

In the beginning, everything was cute, fluffy, and consistent.

### Qt 5.1

A big pile of new stuff was introduced in Qt 5.1. The versioning of some modules started from 1.0, whereas QtQml.Models adapted the version from the QtQml "parent" import.

- QtQml 2.1 (++)
- QtQml.Models 2.1 (new)
- QtQuick 2.1 (++)
- QtQuick.Particles 2.0
- QtQuick.Controls 1.0 (new)
- QtQuick.Layouts 1.0 (new)
- QtQuick.Dialogs 1.0 (new)

### Qt 5.2

QtQml.Models goes already goes out of sync with QtQml.

- QtQml 2.2 (++)
- QtQml.Models 2.1
- QtQuick 2.2 (++)
- QtQuick.Particles 2.0
- QtQuick.Controls 1.1 (++)
- QtQuick.Layouts 1.1 (++)
- QtQuick.Dialogs 1.1 (++)

### Qt 5.3

QtQml goes out of sync with QtQuick and the minor version of Qt. QtQuick.Layouts goes out of sync with QtQuick.Controls & QtQuick.Dialogs siblings.

- QtQml 2.2
- QtQml.Models 2.1
- QtQuick 2.3 (++)
- QtQuick.Particles 2.0
- QtQuick.Controls 1.2 (++)
- QtQuick.Layouts 1.1
- QtQuick.Dialogs 1.2 (++)

### Qt 5.4

At this point QtQuick.Controls, QtQuick.Layouts, and QtQuick.Dialogs all have different versions.

- QtQml 2.2
- QtQml.Models 2.1
- QtQuick 2.4 (++)
- QtQuick.Particles 2.0
- QtQuick.Controls 1.3 (++)
- QtQuick.Layouts 1.1
- QtQuick.Dialogs 1.2

### Qt 5.5

QtQml.Models catches up and is back in sync with the QtQml "parent" import.

- QtQml 2.2
- QtQml.Models 2.2 (++)
- QtQuick 2.5 (++)
- QtQuick.Particles 2.0
- QtQuick.Controls 1.4 (++)
- QtQuick.Layouts 1.2 (++)
- QtQuick.Dialogs 1.2

### Qt 5.6

This time QtQml.Models surpasses the QtQml parent import version.

- QtQml 2.2
- QtQml.Models 2.3 (++)
- QtQuick 2.6 (++)
- QtQuick.Particles 2.0
- QtQuick.Controls 1.5 (++)
- QtQuick.Layouts 1.3 (++)
- QtQuick.Dialogs 1.2

Everyone can judge by themselves how coherent this looks like. :) A while ago the Qt Creator team needed help (QTCREATORBUG-14575) figuring out the available import versions in different Qt releases. I had lost track a long ago, so I actually had to read git log to find out. Now imagine a poor new user that installs Qt. It might not always be the latest available version, but specified by the project. How are they supposed to navigate in this jungle of QML versions?

What makes the situation even more cumbersome, to ourselves who develop these modules, is that there's no convention on how new properties are revisioned. Some classes are using a running revision number that gets incremented whenever new members are added, whereas others match it with the minor version of the module or Qt.

- QQuickImage
  - rev 1 in QtQuick 2.3
  - rev 2 in QtQuick 2.5

- QQuickMouseArea
  - rev 1 in QtQuick 2.4
  - rev 2 in QtQuick 2.5

- QQuickText
  - rev 2 in QtQuick 2.2
  - rev 3 in QtQuick 2.3
  - rev 6 in QtQuick 2.6

Now, mix meta revisions with inheritance and it gets interesting...

Therefore, I'm throwing in this proposal to
1) make all Qt Essentials QML modules follow the Qt version number, and
2) revision new properties using the minor version of Qt.

Then Qt users have some clue what to import and what Qt version their app depends on, and Qt developers can instantly see when certain properties and methods were introduced while browsing the header files.

Is this something that would be possible to implement already in Qt 5, or is this Qt 6 material? Does someone strongly oppose the idea? How often do we release new major versions of QML modules? I don't see why QML modules couldn't follow the same practices than the rest of Qt follows. Ironically, we've been working on this thing called Qt Quick Controls 2.0... :P
 
--
J-P Nurmi