qoccapplication.cpp

Go to the documentation of this file.

/************************************************************************************
**
** This file is part of the QtOPENCASCADE Toolkit.
**
** Copyright (C) 2006, 2007, 2008 QtOCC Team Members
**               Peter Dolbey, Marc Britten, Stephane Routelous
**               Stefan Boeykens, Pawel Dobrolowski, Walter Steffe
**               Álvaro Castro Castilla, Dirk Burski, Fotis Sioutis
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
**
***********************************************************************************/

/*
\class  QoccApplication
\brief  This class provides an application extension for the QtOPENCASCADE Toolkit.
\author Peter C. Dolbey
*/
#include <QtCore/QDataStream>
#include <QtCore/QEvent>
#include <QtGui/QCursor>
#include <QtCore/QWaitCondition>
#include <QtCore/QMutex>
#include <QtCore/QThread>

#include "qoccdocument.h"
#include "qoccinternal.h"
#include "qoccapplication.h"


QoccApplication::QoccApplication(int &argc, char **argv, int _internal ) :
        QApplication (argc, argv, _internal),
        mySplash (NULL),
        myNextID (0)
{

#if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
        setAttribute(Qt::AA_NativeWindows);
#endif

        // Initialise the GEOM framework
        myEngine = new GEOMImpl_Gen();
        myEngine->SetUndoLimit(20);
        UnitsAPI::SetLocalSystem(UnitsAPI_DEFAULT);

}

QoccApplication::~QoccApplication()
{
        if ( mySplash ) { delete mySplash; }
        if ( myEngine ) { delete myEngine; }
}

QoccDocument* QoccApplication::createDocument( )
{
        Handle_TDocStd_Document aDoc;
        QoccDocument*           qDoc = NULL;
        
        aDoc = myEngine->GetDocument( ++myNextID );
        if ( !aDoc.IsNull() )
        {
                aDoc->SetUndoLimit(20);
                qDoc = new QoccDocument( aDoc, myNextID );
        }
        return qDoc;
}


void QoccApplication::splashScreen ( const QPixmap &pixmap )
{
        QPixmap* p = (QPixmap*) &pixmap;
        if ( p->isNull() )
        {
                p = new QPixmap( ":/images/images/QoccSplash.png" );
        }
        mySplash = new QSplashScreen( *p, Qt::WindowStaysOnTopHint );
        if ( mySplash )
        {
                mySplash->show();
                splashMessage( tr( "Initializing Application..." ), Qt::AlignRight | Qt::AlignTop );
        }
}

void QoccApplication::splashMessage(const QString &message, int alignment, const QColor &color)
{
        if ( mySplash )
        {
                mySplash->showMessage( message, alignment, color );
        }
}

void QoccApplication::splashFinish ( QWidget* widget, long millisecs )
{
        if ( mySplash )
        {
                msleep ( millisecs );
                mySplash->finish( widget );
                delete mySplash;
                mySplash = NULL;
        }
}

void QoccApplication::msleep(unsigned long millisecs)
{
        QMutex mutex;
        QWaitCondition waitCondition;
        mutex.lock();
        waitCondition.wait( &mutex, millisecs );
        mutex.unlock();
}

void QoccApplication::Undo( QoccDocument* aDoc )
{
        myEngine->Undo( aDoc->id() );
}

void QoccApplication::Redo( QoccDocument* aDoc )
{
        myEngine->Redo( aDoc->id() );
}

bool QoccApplication::SaveDocument( QoccDocument* aDoc )
{
        if (!aDoc->getDocument()->IsSaved())
        {
                return false;
        }
        else
        {
                myEngine->GetApplication()->Save(aDoc->getDocument());
                return true;
        }
}

bool QoccApplication::SaveDocumentAs( QoccDocument* aDoc, char* theFormat, char* theFileName )
{
        if              (theFormat == "cbf")
                aDoc->getDocument()->ChangeStorageFormat("GEOM_BIN");
        else if (theFormat == "sta")
                aDoc->getDocument()->ChangeStorageFormat("GEOM_ASCII");
        else if (theFormat == "xml")
                aDoc->getDocument()->ChangeStorageFormat("GEOM_XML");
        else
        {
                //cprompt << "Not valid Save Format Specified" << endl;
                return false;
        }

        try {
                myEngine->Save(aDoc->id(), theFileName );
                return true;
        }
        catch(...) {
                //cprompt << "Error! The file wasn't saved." << endl;
                return false;
        }
}

QoccDocument* QoccApplication::LoadDocument( char* theFileName )
{
        Handle_TDocStd_Document aDoc;
        QoccDocument*           qDoc = NULL;

        if (myEngine->Load( ++myNextID, theFileName ))
        {
                aDoc = myEngine->GetDocument( myNextID );

                qDoc = new QoccDocument( aDoc, myNextID );

                if ( !aDoc.IsNull() )
                {
                        aDoc->SetUndoLimit(20);
                        qDoc->UpdatePresentations(aDoc->Main());
                }
                return qDoc;
        }
        return NULL;
}

bool QoccApplication::ResetDocument( QoccDocument* aDoc )
{
        Handle_TDocStd_Document aNewDoc;

        myEngine->Close(aDoc->id());

        aNewDoc = myEngine->GetDocument( ++myNextID );

        if ( !aNewDoc.IsNull() )
        {
                aNewDoc->SetUndoLimit(20);
                aDoc->SetDocumentAndID(aNewDoc, myNextID);
                return true;
        }
        return false;
}

---