# Registering a QML Type as a Singleton object

In addition to C ++ classes in QML, Singleton can also use QML types, which are separate QML files.

This is also used by **qmlRegisterSingletonType** , but in order for this type to work as a singleton of the object, it is necessary to register the pragma **Singleton** in the QML file itself.

Let’s make a small application that will also output several messages, while messages will be picked up through the Singleton QML Type method.

<figure><img src="https://evileg.com/media/uploads/2017/07/05/singletonqml.png" alt=""><figcaption></figcaption></figure>

***

### Project structure

* **SingletonQML.pro** – project profile
* **main.cpp** – File with main function
* **main.qml** – Main QML file
* **Util.qml** – Singleton QML

The project profile will be created by default and will not be changed.

### main.cpp

As the Singleton object use the file Util.qml. To make it a Singleton, it must be registered with qmlRegisterSingletonType, and also specify the pragma Singleton directive in it. First, we will register it.

```cpp
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QtQml> // We connect to use the qmlRegisterSingletonType function
 
int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);
 
    // We register the qml file by specifying its path.
    qmlRegisterSingletonType(QUrl("qrc:/Util.qml"), "Util", 1, 0, "Util");
 
    QQmlApplicationEngine engine;
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
    if (engine.rootObjects().isEmpty())
        return -1;
 
    return app.exec();
}
```

### Util.qml

In this file, be sure to specify the directive **pragma Singleton.**

```qml
pragma Singleton // We indicate that this QML Type is a singleton
import QtQuick 2.0
 
Item {
    function getMessage(messageNumber)
    {
        switch(messageNumber)
        {
        case 1:
            return "First Message"
        case 2:
            return "Second Message"
        case 3:
            return "Third Message"
        default:
            return "Nothing found"
        }
    }
}
```

### main.qml

And now we use the singleton object to output text using this function.

```qml
import QtQuick 2.5
import QtQuick.Window 2.2
import QtQuick.Controls 1.4
 
import Util 1.0 // Thus, the import of QML singleton
 
 
Window {
    visible: true
    width: 640
    height: 480
    title: qsTr("Singleton Class")
 
    ListView {
        anchors.fill: parent
        delegate: Item {
            height: 48
            width: parent.width
            Text {
                anchors.fill: parent
                text: model.text
 
                verticalAlignment: Text.AlignVCenter
                horizontalAlignment: Text.AlignHCenter
            }
        }
 
        model: listModel
    }
 
    ListModel {
        id: listModel
 
        Component.onCompleted: {
            // The appeal to the singleton method looks like a call to the static method
            listModel.append({'text': Util.getMessage(1)})
            listModel.append({'text': Util.getMessage(2)})
            listModel.append({'text': Util.getMessage(3)})
            listModel.append({'text': Util.getMessage(4)})
        }
    }
}
```

### Conclusion

In this way, you can use singleton QML objects to emulate the use of static methods, and this is the right approach for working with similar functionality.
