viewDriver.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2001 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: viewDriver.h,v $ $Revision: 1.58 $ $State: Exp $
*******************************************************************************/


#ifndef VIEWDRIVER_H
#define VIEWDRIVER_H

#include "symbolMapper/modelKey.h"
#include "symbolMapper/modelData.h"
#include "symbology/symbolDisplayOptions.h"
#include "symbolMapper/modelDataDict.h"

#include <QtCore/QObject>

class DtTMArea;
class DtTMFactory;
class DtBaseSymbolMapper;
class DtSymbol;
class DtSymbolList;
class DtTMSymbolUpdater;

class DtTMViewportExtents;
class DtViewportExtents;

class DtTMDisplayOptions;

#include "tmqt/tmqtDefines.h"
class DT_DLL_tmqt DtViewDriver : public QObject
{
   Q_OBJECT

public:
   typedef QHash<QString, QVector<DtSymbol*> > DtViewDriverMappedSymbol;

   //Constructor
   DtViewDriver();
   
   //Destructor
   virtual ~DtViewDriver();
   
   DtViewDriver(const DtViewDriver& orig);

   virtual DtViewDriver& operator=(const DtViewDriver& orig);

   virtual void init(const DtTMFactory* f, DtTMArea* area);
   
   //Check if this symbol is in the database
   virtual bool symbolExists(const DtModelKey& symbol) const;
   
   //Returns the symbol using a key. If it doesn't
   //exists, return null;
   virtual DtSymbol* getSymbol(const DtModelKey& symbol) const;

   //Symbol Updater resets the symbol locations
   virtual void setSymbolUpdater(DtTMSymbolUpdater* updater);
   
   //Symbol Updater resets the symbol locations
   virtual DtTMSymbolUpdater* getSymbolUpdater();

   //Symbol mapper creates new Symbols out of keys
   virtual void setSymbolMapper(DtBaseSymbolMapper* mapper);
   
   //Symbol mapper creates new Symbols out of keys
   virtual DtBaseSymbolMapper* getSymbolMapper();

   //Contains information on the database/window conversion
   virtual const DtTMViewportExtents* getViewportExtents();

   //Pass the symbol list aroind
   virtual DtSymbolList* getSymbolList();

   virtual const DtModelKey* getModelKey(DtSymbol* s) const;

   //The viewport extents alternate between screen and db coordinates
   virtual void setViewportExtents(DtTMViewportExtents* ve);

   virtual void setPersistentModelData(const QStringList* s);

   virtual DtSymbol* createSymbol(const DtModelData& data);

   virtual void clear();

   virtual DtTMArea* area();

   virtual void getVisibleModelData(DtModelDataDict& iter);

   virtual void setHideOffScreenSymbols(bool);
   virtual bool hideOffScreenSymbols() const;

   bool hasTerrainLoaded() const;
   void setHasTerrainLoaded(bool);

   void addAllowedCreationType(DtModelDataType);
   void removeAllowedCreationType(DtModelDataType);
   bool allowCreationOf(DtModelDataType) const;
   const QVector<DtModelDataType>& allowedCreationTypes() const;
   void allowAllCreationTypes();

public:

   static DtViewDriver* create();

signals:
   //Sent whenever the window is resized or moved or whatever
   //changes the display area 
   void viewModified(); 

   void symbolRemoved(const DtModelKey& key);
   
   void symbolAboutToBeRemoved(const DtModelKey& key);

   void symbolAdded(const DtModelKey& key);
   void symbolAdded(DtSymbol* symbol, const DtModelKey& key);
   
public slots:
   
   virtual DtSymbol* addSymbol(const DtModelData& data, bool force = false);
   virtual DtSymbol* addSymbol(const DtModelData& data, DtSymbol* symbol);

   virtual void removeSymbol(const DtModelData& data, bool force = false, bool keepSymbolSettings = true);
   virtual void removeSymbol(const DtModelKey& key, bool force = false, bool keepSymbolSettings = true);
   virtual void removeSymbolFromModelData(const DtModelKey& key);
   
   virtual void modifySymbol(const DtModelData& data);

   //virtual void removeSymbol(const DtModelKey& modelKey);

   virtual bool updateAllSymbols(DtModelDataIter* ModelDataIter);

   virtual bool updateAllSymbols();

   virtual void setDisplayOptions(const DtTMDisplayOptions* o);
   virtual void updateDisplayOptions();

   virtual void removeSymbol(const DtSymbol* s);

protected:
   
   virtual DtSymbol* internalAddSymbol(const DtModelData& data, bool force = false);
   virtual DtSymbol* internalRemoveSymbol(const DtModelData& data, bool force = false, bool keepSymbolSettings = true);
   virtual DtSymbol* internalRemoveSymbol(const DtModelKey& key, bool force = false, bool keepSymbolSettings = true);

   virtual DtSymbol* internalModifySymbol(const DtModelData& data);

   virtual bool checkDBOverlap(const DtModelData& data) const;

protected:

   QHash<DtModelKey, DtSymbol*> myKeyToSymbolDict;
   QHash<DtModelKey, DtSymbolDisplayOptions*> myKeyToDisplayOptionsDict;
   QHash<DtSymbol*, DtModelKey> mySymbolToKeyDict;
   
   //The following items are passed into this class
   //Thus they are not owned or deleted, but the class
   //should be destroyed before these items are
   const QStringList* myPersistentModelData;
   DtSymbolList* mySymbolList;
   DtBaseSymbolMapper* mySymbolMapper;
   DtTMSymbolUpdater* mySymbolUpdater;
   DtTMViewportExtents* myViewportExtents;
   const DtTMDisplayOptions* myTMDisplayOptions;

   DtTMArea* myArea;

   bool  myHideOffScreenSymbols;
   bool  myHasTerrainLoaded;

   QVector<DtModelDataType>   myAllowedCreationTypes;
};

inline bool DtViewDriver::hasTerrainLoaded() const
{
   return myHasTerrainLoaded;
}

inline void DtViewDriver::setHasTerrainLoaded(bool b)
{
   myHasTerrainLoaded = b;
}

inline void DtViewDriver::addAllowedCreationType(DtModelDataType t)
{
   if (myAllowedCreationTypes.indexOf(t) == -1)
   {
      myAllowedCreationTypes.push_back(t);
   }
}

inline void DtViewDriver::removeAllowedCreationType(DtModelDataType t)
{
   int iIndex = myAllowedCreationTypes.indexOf(t);

   if (iIndex != -1)
   {
      myAllowedCreationTypes.remove(iIndex);
   }
}

inline const QVector<DtModelDataType>& DtViewDriver::allowedCreationTypes() const
{
   return myAllowedCreationTypes;
}

inline void DtViewDriver::allowAllCreationTypes()
{
   myAllowedCreationTypes.clear();
}

inline bool DtViewDriver::allowCreationOf(DtModelDataType t) const
{
   if (myAllowedCreationTypes.count() && (myAllowedCreationTypes.indexOf(t) == -1))
   {
      return false;
   }

   return true;
}

#endif //VIEWDRIVER_H