LenIT Tool Documentations

You've loaded an old revision of the document! If you save it, you will create a new version with this data.

**QML Module Concept**

Unser Tool ist frontendseitig modular aufgebaut (verschiedene Viewer).
Jedes Modul löst ein Visualisierungs- oder Analyseproblem
oder ermöglicht die Bearbeitung von Datenmanipulationen etc.
Solche Module sind beispielsweise der "TableViewer", der "PlotViewer", etc.
Dadurch ist es möglich unterschiedliche Modulkombinationen dem Kunden anbieten zu können.

Hinweis2: Ein beispielhaftes Modul ist mit "ModuleExamplicTemplate" im Source zu finden. Es dient als
    Vorlage um sich zu orientieren, wenn man eigene Module entwickeln möchte.

Die Module werden QML seitig (also seitig der UI) über eine jeweils seperate QML je Modul gepflegt und
in die main.qml eingebunden. Beispielsweise enthält die QML_For_Module_TableViewer.qml die UI-Komponenten
der für das TableViewer Modul. Auch jedes neue Modul benötig eine entsprechende eigene QML, welche
als Namenskonvention wie folgt zu benennen ist QML_For_Module_<Name des Moduls>.qml .

In der main.qml sind lediglich die QML-Dateien der Module einzubinden. UI-Code für ein bestimmtes Modul,
gehört nicht in die main.qml, sondern immer in die QML des entsprechenden Moduls.

----

----
**Beteiligte Klassen und QML-Files**

Um dieses Modul Konzept zu ermöglichen, bedarf es eines dedizierten Zusammenspiels aus C++ Klassen und
QML-Dateien, welche folgend erläutert werden. Nehmen wir dafür an, wir möchten ein Modul <module> erstellen
und dem Tool hinzufügen. Da Klassen immer auch header Dateien benötigen, lasse ich in der Beschreibung im
Folgenden header Dateien einfach weg, da es klar ist, das diese auch zu implementieren sind. Beteiligte Klassen
und QML-Files für unser <module>-Beispiel wären dann:

IUI/sources

* IsModule.cpp
  * ContainerUI.cpp
  * <module>.cpp
  * GuiState.cpp

resources

* QML_For_<module>.qml
  * qml.rc
  * main.qml

Die Klassen/QML welche <module> beinhalten, sind neu zu erstellen und implementieren die Funktionalität unseres Modules.
Alle anderen genannten beteiligten Dateien sind bereits vorhanden, und von diesen wird im Weiteren entweder einfach abgeleitet,
oder es gibt notwendige Anpassungen in diesen Dateien, wie folgt detailiert erläutert

----

----
**Detailierte Beschreibung des Zusammenspiels zuvor genannter Dateien, um ein neues Modul dem Tool hinzuzufügen**

* IsModule.cpp ist ein abstraktes Interface von welchem abgeleitet wird um ein Modul als solches zu kennzeichnen.

Es enthält die Methode "updateModule()", welche jedes Modul das von IsModule abgeleitet wird, zu
  implementieren hat. Diese Methode wird im späteren in einem Modul immer dann aufgerufen, wenn der
  Zustand eines Moduls aktualisiert werden muss, z.B. wenn ein Datensatz geladen wird.

* ContainerUI.cpp ist eine Klasse welche verwendet wird um alle Module zu managen, und zu verwalten (auch die internationalisierung der Sprachen, das Laden von Daten, und die Lizenzverwaltung ist hier implementiert.)

Es enthält die Klassen-Methode "void registryModule(IsModule *pointer_on_an_Is_Module_Object)", welche
   verwendet wird um eine Klasse welche von "IsModule" abgeleitet wurde, tool-weit als eine Modul zu registrieren.
   Zudem gib es hier eine Liste als Klassen-Member mit Zeigern auf alle registrierten Module des Tools,
   "ContainerUI::mIsRegistryAsAModuleListVector".
   
   
* <module>.cpp implementiert das neue Modul, beispielsweise als QQuickPaintedItem oder Ähnliches.
  
  
  Dabei ist <module>.cpp von der Klasse "IsModule.cpp" abzuleiten, nur adurch wird es als Modul im Rahmen
  unseres Modulkonzeptes nutzbar. In dem Konstruktor von <module>.cpp is das Modul nun noch zu
  registrieren durch den aufruf von "ContainerUI::registryModule(this)". Dadurch wird das Modul in der
  Modulliste von ContainerUI per Zeiger hinterlegt. Zudem muss das Modul im Konstructor noch benannt werden,
  durch this->mStringTypeName="Module Viewer >";.  Nun ist noch die geerbte Mehtode "updateModule()"
  zu implementieren.
  
  
* GuiState.cpp verwaltet den Zustand des Tools.

Hier ist das neue Modul für die Nutzung in qml bekannt zumachen, innerhalb der exec()-Methode.
   Dafür füg man dort hinzu:
   qmlRegisterType<module>("mpv.module", 1, 0, "module");
   
   
* QML_For_<module>.qml ist als neue qml für das neue Modul anzulegen, dort wo auch die main.qml liegt.

In dieser QML werden alle relevanten UI Funktionen implementiert. das neue Modul wird in seiner
  QML bekannt gemacht durch "import mpv.<module> 1.0".
  
  Nach dem initialen "Item{" oder ähnliches
  ist zwingend das folgende in die qml zu schreiben:
  
   property int thisIntQML_Modules_Visible_Variable : 0
   property int thisIntQML_Module_Index_Variable : -1
        Connections {
            target: appWindow
            onSQML_Modules_Visible_Changed_Signal: {
                if(thisIntQML_Modules_Visible_Variable==thisIntQML_Module_Index_Variable){
                    visible = true;
                }
                else{visible = false;}
            }
        }

Dadurch wird das Modul mit dem Reiter-Button system verbunden, welches einen button erzeugt um das Modul
   sichtbar werden zu lassen im Tool.
   Zudem muss das modul min einmal in seiner qml instanziiert werden  z.B. durch "<module>{}" damit einmal der
   Konstruktor aufgerufen wird und das Modul so registriert ist.

* qml.rc führt alle Resourcen des tools auf. Hier muss die qml-Datei des Moduls hinzugefügt werden damit 
    sie im weiteren dem Tool zur Nutzung bekannt ist, durch hinzufügen von:  <file><module>.qml</file>

* main.qml erstellt alle Module, so dass sie zur Laufzeit nutzbar sind. Hier ist hinzuzufügen:
    
    QML_For_Module_<module>{
        id: qmlModule<module>Viewer
        z: 200
        visible: false;
        thisIntQML_Modules_Visible_Variable : intQML_Modules_Visible_Variable
        thisIntQML_Module_Index_Variable : containerUI.getModuleIndex("Module Viewer >");
    }

Dadurch wird das Modul zur Laufzeit erstellt und kann im Tool genutzt werden. Bitte darauf achten das
    der String "Module Viewer >" exakt der gleiche ist, wie er im Konstructor von <module>.cpp bei
    this->mStringTypeName  genannt wurde (sonst funktioniert es nicht).

Nun ist das Modul angemeldet, eingebunden und kann genutzt werden. Wann immer Module aktualisiert werden
    müssen, kann an jeder beliebigen Stelle im qml einfach "containerUI.updateAllModules();" aufgerufen werden,
    wodurch für jedes registrierte Modul seine jeweils eigene "updateModule()" Methode aufgerufen wird.
    
    Hier erschließt sich auch der Sinn des Modulkonzeptes: durch einfaches ein und auskommentieren der
    Module in der main.qml können unterschiedliche Modulkonfigurationen, also verschiedene Toolversionen,
    erzeugt werden; und so wird ein kundenspezifisches Pricing ermöglicht.

----

Hinweis: Hin und wieder kann es notwendig sein von qml Objkten bestimmte Eigenschaften aud dem c++ code selbst
    heraus zu setzen, anstatt über die qml Files selbser. Dafür gib es GuiState die Klassenfunktion
    "Object Object= static QObject * m_getQMLObjectAsQObject(QString QML_Object_String);" welche das
    QObject aus dem qml zurückgibt, das als Objektname 'objectName: "QML_Object_String" ' besitzt.
    Die Eigenschaften können dann leicht wie folgt gesetzt werden:
    
    if(QML_Object) {
        QML_Object->setProperty("visible", true);
        QML_Object->setProperty("enabled", true);
    }

Hinweis2: Ein beispielhaftes Modul ist mit "ModuleExamplicTemplate" im Source zu finden. Es dient als
    Vorlage um sich zu orientieren, wenn man eigene Module entwickeln möchte.

Edit summary

LenIT Tool Documentations

User Tools

Site Tools

Page Tools