visualization/qtquick_qml/baseviewer/main.cxx

Refer to Basic Viewer Example.

BaseViewerApplication.hxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2021, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************


#ifndef BaseViewerApplication_HeaderFile
#define BaseViewerApplication_HeaderFile

#include <cadex/ModelData_Model.hxx>
#include <cadex/ModelPrs_Scene.hxx>
#include <cadex/ModelPrs_SceneNode.hxx>
#include <cadex/ModelPrs_SceneNodeFactoryParameters.hxx>
#include <cadex/STEP_ReaderParameters.hxx>

#include <QtCore/QObject>

class QQuickWindow;
class QQmlEngine;
class QVariant;

namespace cadex {
class ModelPrsQtQuick_ViewPort;
}

class BaseViewerApplication : public QObject
{
    Q_OBJECT

public:
    BaseViewerApplication();

    bool Initialize (const QUrl& theUrl, const QString& theViewPortName);

    bool event (QEvent* theEvent) override;

    virtual void CreateSceneNodes();

signals:
    void initialized();

protected slots:
    void onImportFile (const QVariant& theUrl);

protected:
    void Import (const QString& theFilename);

    virtual void Clear();

    void ShowMessageBox (const QString& theMessage);

private:
    QQuickWindow* CreateMainWindow (const QUrl& theUrl);

    void onImportCompleted (QEvent* theEvent);

protected:
    cadex::ModelData_Model                      myModel;
    cadex::ModelPrs_Scene                       myScene;
    cadex::ModelPrs_SceneNode                   myRoot;
    cadex::ModelPrs_SceneNodeFactoryParameters  myFactoryParameters = {cadex::ModelData_RM_BRep, false};
    cadex::STEP_ReaderParameters                myReaderParameters;

    QQuickWindow*                       myMainWindow = nullptr;
    cadex::ModelPrsQtQuick_ViewPort*    myViewPort = nullptr;
};

#endif // BaseViewerApplication_HeaderFile

BaseViewerApplication.cxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2021, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************


#include "BaseViewerApplication.hxx"
#include "ImportRunnable.hxx"
#include "CustomEvents.hxx"

#include <cadex/ModelPrs_Scene.hxx>
#include <cadex/ModelPrs_SceneNodeFactory.hxx>
#include <cadex/ModelPrsQtQuick_ViewPort.hxx>

#include <QtCore/QFileInfo>
#include <QtCore/QThreadPool>
#include <QtGui/QOpenGLContext>
#include <QtQml/QQmlApplicationEngine>
#include <QtQuick/QQuickWindow>
#include <QtWidgets/QApplication>
#include <QtWidgets/QMessageBox>

using namespace cadex;

#if __ANDROID__
#include <QtAndroidExtras/QtAndroid>
#endif

#if __ANDROID__ && __ANDROID_DEBUG
#include <android/log.h>

namespace {
void QMessageToAndroidLogRedirector (QtMsgType theType, const QMessageLogContext& /*theContext*/, const QString& theMsg)
{
    QString aText;
    switch (theType) {
    case QtDebugMsg:    aText += "qDebug(): "; break;
    case QtWarningMsg:  aText += "qWarning(): "; break;
    case QtCriticalMsg: aText += "qCritical(): "; break;
    case QtFatalMsg:    aText += "qFatal(): "; break;
    case QtInfoMsg:     aText += "qInfo(): "; break;
    default: break;
    }
    aText += theMsg;
    for (const QString& line : aText.split ('\n')) {
        __android_log_print (ANDROID_LOG_DEBUG, "baseviewer", "%s", qPrintable (line));
    }
}
}
#endif

BaseViewerApplication::BaseViewerApplication()
    : myRoot (ModelPrs_SceneNode::initialized())
{
    myScene.AddRoot (myRoot);
}

namespace {
#if !__ANDROID__
QPair<int, int> OpenGlVersion()
{
    auto aVersion = qMakePair (-1, -1);

    QOpenGLContext aTestOpenGLContext;
    aTestOpenGLContext.create();

    if (aTestOpenGLContext.isValid()) {
        aVersion = aTestOpenGLContext.format().version();
    }
    return aVersion;
}
#endif
} // end of unnamed namespace

bool BaseViewerApplication::Initialize (const QUrl& theUrl, const QString& theViewPortName)
{
#if __ANDROID__ && __ANDROID_DEBUG
    // Register custom message handler.
    qInstallMessageHandler (QMessageToAndroidLogRedirector);
#endif

#if !__ANDROID__
    auto anOpenGlVersion        = OpenGlVersion();
    auto aRequiredOpenGlVersion = qMakePair (2, 1);

    // Check OpenGl version.
    if (anOpenGlVersion < aRequiredOpenGlVersion) {
        QMessageBox::critical (nullptr,
                               QCoreApplication::applicationName(),
                               tr ("%1 requires graphic card with drivers supporting OpenGL %2.%3 or later.\n"
                                   "Detected driver supports OpenGL %4.%5.\n"
                                   "Please make sure you don't run %1 inside virtual machine "
                                   "and your graphic card driver is upgraded to the latest version "
                                   "Visit your graphic card manufacturer web-site to download the latest drivers.")
                               .arg (QCoreApplication::applicationName())
                               .arg (aRequiredOpenGlVersion.first).arg (aRequiredOpenGlVersion.second)
                               .arg (anOpenGlVersion.first).arg (anOpenGlVersion.second)
                               );
        return false;
    }
#endif

    // Register types for qml.
    ModelPrsQtQuick_ViewPort::RegisterQtTypes();

    myMainWindow = CreateMainWindow (theUrl);

    Q_ASSERT (myMainWindow);

#if __ANDROID__
    // Request read permission on Android.
    if (!QtAndroid::shouldShowRequestPermissionRationale("android.permission.READ_EXTERNAL_STORAGE")) {
        QtAndroid::requestPermissions({{ "android.permission.READ_EXTERNAL_STORAGE" }},
        [] (const QtAndroid::PermissionResultMap & theResult) {
            if (theResult["android.permission.READ_EXTERNAL_STORAGE"] == QtAndroid::PermissionResult::Denied) {
                qWarning ("User refused request to allow access to sdcard for reading.");
            }
        });
    }
#endif

    // Connect slot to signal about clicked "Import" button.
    connect (myMainWindow, SIGNAL (importFile (const QVariant&)),
             this,         SLOT (onImportFile (const QVariant&)));

    // Search ModelPrsQtQuick_ViewPort among window's qt objects and attach View Port to Scene.
    myViewPort = myMainWindow->findChild<ModelPrsQtQuick_ViewPort*> (theViewPortName);
    Q_ASSERT (myViewPort);
    auto aRes = myViewPort->AttachToScene (myScene);

    myMainWindow->showNormal();

    emit initialized();

    // Import model from the program arguments (when was specified).
    auto anArguments = QApplication::instance()->arguments();
    if (anArguments.size() > 1) {
        auto anArgument = anArguments.at (1);
        Import (anArgument);
    }

    return aRes;
}

QQuickWindow* BaseViewerApplication::CreateMainWindow (const QUrl& theUrl)
{
    auto anEngine = new QQmlApplicationEngine (this);

    QQmlComponent aComponent (anEngine);
    aComponent.loadUrl (theUrl);

    QObject* aQmlApp = nullptr;

    if (!aComponent.isReady()) {
        // For easy debugging redirect it to output.
        qDebug() << aComponent.errorString();
        QCoreApplication::postEvent (QCoreApplication::instance(), new QEvent (QEvent::Quit));
        return nullptr;
    }

    aQmlApp = aComponent.create();
    aQmlApp->setParent (this);
    return qobject_cast<QQuickWindow*> (aQmlApp);
}

void BaseViewerApplication::onImportFile (const QVariant& theUrl)
{
    if (!(theUrl.isValid() || !theUrl.canConvert<QUrl>())) {
        qWarning() << "BaseViewerApplication::OnImport: Invalid argument [" << theUrl << "]";
        return;
    }

    auto aFilename = theUrl.toUrl().toLocalFile();
    Import (aFilename);
}

void BaseViewerApplication::Import (const QString& theFilename)
{
    QFileInfo aFileInfo (theFilename);
    if (!aFileInfo.exists() || !aFileInfo.isFile() || !aFileInfo.isReadable()) {
        return;
    }

    Clear();

    auto aRunnable = new ImportRunnable (theFilename, myScene, myModel, myReaderParameters, this);
    QThreadPool::globalInstance()->start (aRunnable);

    myMainWindow->setProperty ("loading", true);
    myMainWindow->setTitle (QString ("CAD Exchanger [%1]").arg (theFilename));
}

void BaseViewerApplication::Clear()
{
    myModel.Clear();
    myRoot.RemoveChildrenNodes();
    myScene.Update();
}

void BaseViewerApplication::CreateSceneNodes()
{
    ModelPrs_SceneNodeFactory aFactory (myFactoryParameters);
    auto aRoot = aFactory.Create (myModel);
    myRoot.AddChildNode (aRoot);
}

bool BaseViewerApplication::event (QEvent* theEvent)
{
    auto anEventType = static_cast<ImportResult> (theEvent->type());

    if (ImportResult::Error != anEventType && anEventType != ImportResult::Success) {
        return QObject::event (theEvent);
    }

    onImportCompleted (theEvent);
    return true;
}

void BaseViewerApplication::onImportCompleted (QEvent* theEvent)
{
    auto anEventType = static_cast<ImportResult> (theEvent->type());

    switch (anEventType) {
    case ImportResult::Success: {
        myMainWindow->setProperty ("loading", false);
        myViewPort->animatedFitAll();
        break;
    }
    case ImportResult::Error: {
        Q_ASSERT (dynamic_cast<ErrorEvent*> (theEvent));
        auto anEvent = static_cast<ErrorEvent*> (theEvent);

        myMainWindow->setProperty ("loading", false);
        ShowMessageBox (anEvent->Message());
        break;
    }
    }
}

void BaseViewerApplication::ShowMessageBox (const QString& theMessage)
{
    if (auto aDialog = myMainWindow->findChild<QObject*> ("dialog")) {
        aDialog->setProperty ("message", theMessage);
        QMetaObject::invokeMethod (aDialog, "open");
    }
}

CustomEvents.hxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2021, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************


#ifndef CustomEvents_HeaderFile
#define CustomEvents_HeaderFile

#include <QtCore/QEvent>
#include <QtCore/QString>

enum ImportResult {
    Success = QEvent::User + 1,
    Error
};

class ErrorEvent : public QEvent
{
public:
    ErrorEvent (const QString& myMessage);

    const QString& Message() const;

private:
    QString myMessage;
};

#endif // CustomEvents_HeaderFile

CustomEvents.cxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2021, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************


#include "CustomEvents.hxx"

ErrorEvent::ErrorEvent (const QString& theMessage)
    : QEvent (static_cast<QEvent::Type> (ImportResult::Error)),
      myMessage (theMessage)
{
}

const QString& ErrorEvent::Message() const
{
    return myMessage;
}

ImportRunnable.hxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2021, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************


#ifndef ImportRunnable_HeaderFile
#define ImportRunnable_HeaderFile

#include "BaseViewerApplication.hxx"

#include <cadex/STEP_ReaderParameters.hxx>

#include <QtCore/QRunnable>

namespace cadex {
class ModelData_Model;
class ModelPrs_Scene;
}

class ImportRunnable : public QRunnable
{
public:
    ImportRunnable (const QString&                theFilename,
                    cadex::ModelPrs_Scene&        theScene,
                    cadex::ModelData_Model&       theModel,
                    cadex::STEP_ReaderParameters& theParameters,
                    BaseViewerApplication*        theParent);

    void run() override;

private:
    void Read();
    void DisplayModel();

private:
    QString                       myFilename;
    cadex::ModelData_Model&       myModel;
    cadex::ModelPrs_Scene&        myScene;
    cadex::STEP_ReaderParameters& myParameters;
    BaseViewerApplication*        myParent;
};

#endif // ImportRunnable_HeaderFile

ImportRunnable.cxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2021, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************


#include "ImportRunnable.hxx"
#include "CustomEvents.hxx"

#include <cadex/ModelData_Model.hxx>
#include <cadex/ModelPrs_Scene.hxx>
#include <cadex/ModelPrs_SceneNode.hxx>
#include <cadex/ModelPrs_SceneNodeFactory.hxx>
#include <cadex/ModelPrs_SceneNodeFactoryParameters.hxx>
#include <cadex/STEP_Reader.hxx>

#include <QtCore/QCoreApplication>
#include <QtCore/QFileInfo>

using namespace cadex;

ImportRunnable::ImportRunnable (const QString&                theFilename,
                                ModelPrs_Scene&               theScene,
                                ModelData_Model&              theModel,
                                cadex::STEP_ReaderParameters& theParameters,
                                BaseViewerApplication*        theParent) :
    myFilename (theFilename),
    myModel (theModel),
    myScene (theScene),
    myParameters (theParameters),
    myParent (theParent)
{

}

void ImportRunnable::Read()
{
    STEP_Reader aReader;
    aReader.Parameters() = myParameters;
    if (!aReader.ReadFile (myFilename.toStdString().data()) || !aReader.Transfer (myModel)) {
        QCoreApplication::postEvent (myParent, new ErrorEvent ("Failed to read the file " + myFilename));
        return;
    }
}

void ImportRunnable::DisplayModel()
{
    myParent->CreateSceneNodes();

    myScene.Update();
    myScene.Wait();
}

void ImportRunnable::run()
{
    Read();
    DisplayModel();

    QCoreApplication::postEvent (myParent, new QEvent (static_cast<QEvent::Type> (ImportResult::Success)));
}

BaseWindow.qml

import QtQuick 2.7
import QtQuick.Controls 2.3
import Qt.labs.platform 1.0 as Platform
import CadEx 1.2

ApplicationWindow {
    title: qsTr ("CAD Exchanger")
    minimumWidth: 1000
    minimumHeight: 600
    width: 1000
    height: 600

    property alias loading: busyIndicator.running
    property alias menuBarItem: menuBarItem
    property alias fileMenuItem: fileMenuItem

    signal menuCompleted
    signal importFile (var url);

    menuBar: MenuBar {
        id: menuBarItem
        enabled: !loading

        Menu {
            id: fileMenuItem
            title: qsTr("&File")
            MenuItem {
                text: qsTr("&Import...")
                onTriggered: {
                    fileDialog.open()
                }
            }
            MenuSeparator { }
            MenuItem {
                text: qsTr("&Quit")
                onTriggered: {
                    Qt.quit();
                }
            }
        }

        Component.onCompleted: {
            menuCompleted();
        }
    }

    Platform.FileDialog {
        id: fileDialog
        title: qsTr ("Please choose a STEP file")
        fileMode: Platform.FileDialog.OpenFile
        options: Platform.FileDialog.DontResolveSymlinks | Platform.FileDialog.DontUseCustomDirectoryIcons
        folder: Platform.StandardPaths.writableLocation (Platform.StandardPaths.HomeLocation)
        nameFilters: [ "STEP files (*.stp *.step)" ]
        onAccepted: {
            importFile (file);
        }
    }

    Dialog {
        id: dialog
        objectName: "dialog"
        title: qsTr ("Error")
        parent: ApplicationWindow.overlay
        x: (parent.width - width) / 2
        y: (parent.height - height) / 2
        width: 300
        standardButtons: Dialog.Ok
        visible: false
        closePolicy: Popup.CloseOnEscape
        dim: true

        property string message

        Label {
            anchors.left: parent.left
            anchors.right: parent.right
            text: dialog.message
        }
    }

    BusyIndicator {
        id: busyIndicator
        running: false
        visible: running
        anchors.bottom: parent.bottom
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.bottomMargin: 20
        width: 80
        height: 80
        parent: ApplicationWindow.overlay
    }
}

BaseViewerWindow.qml

import CadEx 1.2

BaseWindow {
    property var viewPort: viewPortItem

    ModelPrsQtQuick_ViewPort {
        id: viewPortItem
        objectName: "viewPort"
        anchors.fill: parent
        highlightEnabled: true
    }
}

main.cxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2021, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************


#include "BaseViewerApplication.hxx"
#include <cadex/LicenseManager_Activate.h>
#include <QtCore/QUrl>
#include <QtWidgets/QApplication>

#include "../../../cadex_license.cxx"

using namespace cadex;

int main (int argc, char *argv[])
{
    auto aKey = LicenseKey::Value();

    // Activate the license (aKey must be defined in cadex_license.cxx).
    if (!CADExLicense_Activate (aKey)) {
        qCritical ("Failed to activate CAD Exchanger license.");
        return 1;
    }

    // Set dpi scaling before creating an application.
    QCoreApplication::setAttribute (Qt::AA_EnableHighDpiScaling);

    // Create QApplication because Qt.labs.platform module requires Qt Widgets library.
    // For more information see https://doc.qt.io/qt-5.12/qml-qt-labs-platform-filedialog.html#availability
    QApplication app (argc, argv);

    BaseViewerApplication anApp;
    if (anApp.Initialize (QUrl ("qrc:/qml/BaseViewerWindow.qml"), "viewPort")) {
        return app.exec();
    }

    return 0;
}