include/tmqt/tmApplication.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2004 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: tmApplication.h,v $ $Revision: 1.148 $ $State: Exp $
*******************************************************************************/


#ifndef TACTICALMAPAPPLICATION_H
#define TACTICALMAPAPPLICATION_H

#include "tmqt/tmqtDefines.h"
#include "symbolMapper/modelDataDict.h"
#include "tmqt/tmAppOptions.h"

#include <geometry/point.h>
#include <QtCore/QList>
#include <map>
#include <string>

class QAction;
class QTimerEvent;
class DtFeatureActionManager;
class DtTMFactory;
class DtTMMiniMap;
class DtModelData;
class DtBaseWindow;
class DtTMAppOptions;
class DtBaseSymbolMapper;
class DtPopupMenu;
class DtToolbarFactoryManager;
class DtTMMapArea;
class DtDrawerColl;
class DtTMDisplayOptions;
class DtSymbol;
class DtViewDriver;
class DtEventController;
class DtTerrainDatabase;
class DtPaperMapDatabase;
class DtUnitDisplayManager;
class DtUnitConverterFactory;
class DtRecursiveTimer;
class DtCoordinateSystemCollection;
class QSplashScreen;
class QProgressBar;
class DtTMPluginManager;
class DtTMPlugin;
class DtEventSignaller;
class DtEnvironmentalModelData;
class DtTMArea;
class QDockWidget;
class DtArchiver;
class DtMsgItem;
class DtMsgGuiPrinter;

#include <QtGui/QApplication>
#include <QtCore/QDateTime>
#include <QtCore/QTextStream>

#include "tmqt/eventSignaller.h"

typedef QList<DtBaseWindow*> DtWindowList;
typedef QList<DtTMArea*> DtAreaList;

const int DtWindow_NoAction       = 0;
const int DtMenu_Hide             = 0x00000001;
const int DtMenu_DoNotCreate      = 0x00000002;
const int DtToolbars_Hide         = 0x00000004;
const int DtToolbars_DoNotCreate  = 0x00000008;

class DT_DLL_tmqt DtTMApplication : public QObject
{   
   Q_OBJECT

public:
   
   static DtTMApplication* app();
   
   DtTMApplication();
   
   DtTMApplication(int& argc, char** argv);
   
   virtual ~DtTMApplication();
   
   virtual bool init(DtTMFactory* f, bool bShowSplashScreen = true);

   virtual void initializeQApplicationObject();

   virtual DtBaseWindow* createWindow(QWidget* parent, int mode = DtMenu_Hide,
      const Qt::WindowFlags& flags = 0);

   virtual QVector<DtModelKey> selectedModelKeys() const;

public:
   virtual const DtTMFactory* factory() const;
   virtual DtTMFactory* factory();
   
   virtual void setFactory(DtTMFactory* f);
   
   virtual bool initConnections();

   virtual DtTMMiniMap* globalMiniMap() const;
   
   virtual DtModelDataDict& ModelDataDict();
   
   virtual DtModelDataIter* ModelDataIter() const;
   
   virtual DtBaseWindow* createNewWindow(QWidget* parent = NULL,
      int mode = DtWindow_NoAction, 
      const Qt::WindowFlags& f = 0);
   
   virtual DtBaseWindow* activeWindow() const;
   
   DtTMAppOptions* options() const; 
   DtTMDisplayOptions* displayOptions() const;
   
   virtual DtDrawerColl* drawerColl();
   
   virtual const QString& filenameInUse();
   virtual void setFilenameInUse(const QString& filename);
   
   virtual DtBaseSymbolMapper* baseSymbolMapper() const;

   DtArchiver* archiver();

   virtual DtBaseWindow* mainWindowFromObject(QObject* o, DtBaseWindow* defaultWindow) const;

   virtual void addWindow(const DtBaseWindow* w);
   
   virtual void addManagedArea(DtTMArea*);

   virtual bool hasWindows() const;

   virtual DtWindowList* windowList();
   
   virtual int fastestFrameRate();
   
   virtual bool exec();
   
   virtual void startTickTimer(int mSec, bool allowFutureOverride = true);
   virtual void setAllowTickTimerOverride(bool b);
   virtual bool allowTickTimerOverride();
   
   virtual void adjustTickTimerToMeet(int mSec);
   
   virtual int tickTimerRate();
   
   virtual void setSuspendTicking(bool b);
   virtual bool suspendTicking();
   
   virtual void setInTick(bool b);
   
   virtual DtModelData* dataWithName(const QString& name, const QVector<int>* except = NULL);

   virtual DtModelData* findLocalDataFor(const DtModelKey& key);
   
   virtual const DtModelKey* findLocalModelKey(DtSymbol* s);
   
   virtual DtModelData* findModelData(DtSymbol* s);
   
   virtual DtViewDriver* viewDriverFor(DtSymbol* s);
   
   virtual DtViewDriver* viewDriverFor(const DtModelKey& key);
   
   virtual DtPopupMenu* menuFromAction(QAction*);

   virtual void markForUpdate(DtModelDataIter* iter);
   
   virtual void modelDataChanged(const DtModelData& data, int iChangedFlags);
   
   virtual DtModelData* checkForDuplicateName(const DtModelData* checker, QString name, const QVector<int>* except = NULL);
   
   virtual void setDuplicateNameCheck(bool b);
   virtual bool duplicateNameCheck() const;

   virtual DtEventSignaller* eventSignaller();

   virtual DtEventController& eventController();
   virtual const DtEventController& eventController() const;
   
   virtual const DtTerrainDatabase* terrainDatabase() const;
   virtual DtTerrainDatabase* terrainDatabase();

   virtual const DtPaperMapDatabase* paperMapDatabase() const;
   virtual DtPaperMapDatabase* paperMapDatabase();
   
   virtual bool fullScreenMode() const;
   
   virtual bool isConcave(QVector<DtPoint>* pointList);

   virtual void addSymbol(const DtModelData&, bool force = true);
   virtual void addSymbol(const DtModelData&, DtSymbol*);

   virtual void removeSymbol(const DtModelData&, bool removeFromDict = false);

   virtual void clear();

   virtual void symbolMapChanged();

   virtual bool needsTerrainDatabase() const;

   virtual bool terrainLoaded() const;
   virtual DtCoordinateSystemCollection* coordinateSystemCollection() const;
   virtual DtUnitDisplayManager* unitDisplayManager() const;
   virtual DtUnitConverterFactory* unitConverterFactory() const;

   virtual bool allowTerrainProfileTracking() const;

   virtual void setUpdateOnTick(bool b, bool updateMini = false);

   virtual void setPrintMode(bool b);
   virtual bool printMode() const;

   virtual QString dataFolder();

   virtual QString makeRelativeTo(QString filename, QString path);

   virtual QString relativePath();
   
   int settingsVersion() const;

   virtual QString appName() const;
   virtual QString appVersion() const;
   virtual QString pluginVersion() const;
   virtual QString buildDate() const;

   virtual DtString pluginName() const;

   virtual void setSplashScreenMessage(const QString&);

   virtual bool startSplashScreenProgress(const QString& title, int iTotalSteps);
   virtual void updateSplashScreenProgress(int);
   virtual void endSplashScreenProgress();

   virtual bool splashScreenIsActive() const;

   bool applicationInitialized() const;

   virtual void attachEventController(DtEventController*);

   QList<DtEventController*>& attachedEventControllers();

   virtual void tickEventControllers();
   virtual void clearCurrentEvents();

   virtual void setSplashScreenImage(const QString&);

   virtual DtTMMapArea* mapContainsData(const DtModelData* data) const;

   virtual bool eventFilter(QObject *o, QEvent* e);
   virtual bool event(QEvent* e);

   virtual QString resolveFile(const QString&) const;

   virtual DtTMPluginManager* pluginManager() const;

   virtual void mergeFeatureActionManager(const DtFeatureActionManager&);

   virtual void mergeToolbarManager(const DtToolbarFactoryManager&);
   
   virtual void revertToolbars();

public:
   virtual DtEnvironmentalModelData* createObject(const QString& object, QVector<DtPoint>& points,
      const QString& name = QString::null);

public:
   virtual bool canPaste() const;
   virtual void setPasteData(const QByteArray&);
   virtual void clearPasteData();
   const QByteArray& pasteData() const;

#ifdef WIN32
   virtual void startPerformanceCounter(const std::string&);
   virtual void endPerformanceCounter(const std::string&);
   virtual void outputPerformanceCounters();
   bool markTime() const;
#endif

public:
   static DtTMApplication* create(int argc, char** argv);

signals:
   
   void filenameInUseChanged(const QString& s);
   void symbolMapChangedSignal();
   void pluginLoaded(const DtTMPlugin*);
   void pasteAvailable();
   void pasteUnavailable();

public slots:
   virtual void removeAttachedEventController(QObject*);
   
   
   virtual DtBaseWindow* fileNewWindow(bool show = true);
   
   virtual void fileExit();
   
   virtual void removeWindow(const DtBaseWindow* w);
   virtual void windowDestroyed(QObject* w);
   
   virtual void modelDataAdded(const DtModelKey& key);
   
   virtual void modelDataRemoved(const DtModelKey& key);
   
   virtual void setDisplayFrameRate(int iFramesPerSecond);
   
   virtual int displayFrameRate() const;
   
   virtual void tick();
   virtual void tickInternal();
   
   virtual void setFullScreenMode(bool b);
   
   virtual void saveSettingsFile();
   virtual void saveSettings(QTextStream& stream);

   virtual void readSettingsFile(DtBaseWindow* w, bool windowOnly = false);
   virtual void readSettings(DtBaseWindow* w, QTextStream& stream, bool windowOnly = false);

   virtual void splashScreenDestroyed();

   virtual void removeManagedArea(QObject*);

   virtual void removeFromUpdate(const DtModelData& data);

   virtual void markForUpdate(const DtModelData&);
   virtual void markForUpdate(const DtModelKey&);

   virtual void showSplashScreen();

   virtual void closeSplashScreen();
   virtual void showSplashScreen(bool show);

   virtual void processMsgItem(const DtMsgItem& item);

   virtual bool shouldTick();

   static void addUserDataFor(const DtEntityMapperKey&, DtArchivableObjectCreator);
   static void removeUserDataFor(const DtEntityMapperKey&);
   
public slots:
   virtual void addToUpdate(const DtModelData& data);
   virtual void addToRemoval(const DtModelData& data);

protected:
   virtual void postAppInit();

   virtual DtTMPluginManager* createPluginManager(DtTMFactory*);
   virtual void initPlugins(DtTMFactory* f);
   virtual bool readOptions(DtTMFactory* f);

   virtual bool setupOptions();

   virtual bool processOptions(DtTMFactory* f);
   
   virtual bool initGlobalMiniMap();
   
   virtual bool initUnitConverterFactory(DtTMFactory* f);

   virtual bool initUnitDisplayManager(DtTMFactory* f);

   virtual bool initMenuSystem();
   
   virtual void setupApplicationFromSettings();

   virtual bool setupFromOptions();

   virtual bool setupMapReaders();

   virtual bool initSymbolMapper(DtTMFactory* f);

   virtual void setupWindowFromSettings(DtBaseWindow* w, bool show);

   virtual bool createCoordinateSystemCollection(const DtTMFactory* f);

   virtual bool shouldClear(const DtModelData* data);

   virtual void initGlobalMiniMapConnections();

   virtual const QString& splashScreenImage() const;

   virtual DtTMPlugin* loadPlugin(const QString&);

   virtual void applicationReady();

   virtual bool loadTranslationFiles(const QString& lang);

   virtual bool loadSymbolMapFilesAtStartup() const;

   virtual DtString initialLogFile() const;
   virtual bool useConsole() const;

   virtual void setEnableGuiPrinter(bool enable, int level);

   virtual void timerEvent(QTimerEvent *e);

   virtual void initUserData();

   virtual void addUserDataFor(DtEnvironmentalModelData*);

   virtual void setupLanguage();

protected:
   
   static DtTMApplication* theApplication;
   
   DtTMFactory* myFactory;
   
   //The global minimap
   DtTMMiniMap* myTMGlobalMiniMap;
   
   DtBaseSymbolMapper* myMapper;

   DtModelDataDict* myModelDataDict;
   DtModelDataIter* myModelDataIter;
   
   DtTMAppOptions* myOptions;
   
   int myArgc;
   char** myArgv;
   
   QString myFilenameInUse;
   
   DtWindowList   myWindows;
   DtAreaList    *myManagedAreas;
   
   bool mySuspendTicking;
   bool myInTick;
   
   int myTickTimerRate;
   bool myAllowTickTimerOverride;
   
   bool myDuplicateNameCheck;

   DtEventController* myEventController;
   
   bool myFullScreenMode;
   bool myLoadedSettings;
   bool myPrintMode;
   DtArchiver* myArchiver;

   DtDrawerColl* myDrawerColl;
   DtCoordinateSystemCollection* myCoordinateSystemCollection;

   QList<QObject*> myInactiveWindows;

   int mySettingsVersion;
   int myTimerId;

   QSplashScreen* mySplashScreen;
   QProgressBar*  mySplashProgress;

   DtTMPluginManager* myPluginManager;

   DtEventSignaller   myEventSignaller;

   QString        mySplashScreenMessage;
   QString        mySplashScreenImage;
   bool           myApplicationInitialized;
   bool           myNeedsPostAppInit;
   QList<DtEventController*>*   myAttachedEventControllers;

   QHash<DtModelKey, DtModelData*> myUpdateData;
   QHash<DtModelKey, DtModelData*> myRemoveData;

   bool           myResetPruneStatus;
   bool           myStashPrune;
   bool           myMarkTime;

   QByteArray        myPasteBuffer;

   int               myTickCount;
   std::map<std::string, double> myTickTimes;

   DtUnitConverterFactory* myUnitConverterFactory;
   DtUnitDisplayManager* myUnitDisplayManager;

#ifdef WIN32
   std::map<std::string, __int64> myPerformanceCounters;
#endif
  
   DtMsgGuiPrinter* myGuiPrinter;

   DtRecursiveTimer* myRecursiveTimer;

   static QHash<QString, DtArchivableObjectCreator> theUserData;
};

inline DtEventSignaller* DtTMApplication::eventSignaller()
{
   return &myEventSignaller;
}

inline QList<DtEventController*>& DtTMApplication::attachedEventControllers()
{
   return *myAttachedEventControllers;
}

inline int DtTMApplication::settingsVersion() const
{
   return mySettingsVersion;
}

inline bool DtTMApplication::applicationInitialized() const
{
   return myApplicationInitialized;
}

inline bool DtTMApplication::canPaste() const
{
   return (myPasteBuffer.length() != 0);
}

inline const QByteArray& DtTMApplication::pasteData() const
{
   return myPasteBuffer;
}

#ifdef WIN32
inline bool DtTMApplication::markTime() const
{
   return myMarkTime;
}
#endif

inline DtTMAppOptions* DtTMApplication::options() const
{
   return myOptions;
}

inline DtTMDisplayOptions* DtTMApplication::displayOptions() const
{
   return myOptions->displayOptions();
}

inline DtArchiver* DtTMApplication::archiver()
{
   return myArchiver;
}

#endif