include/symbolMapper/baseSymbolMapper.h

Go to the documentation of this file.

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


#ifndef BASESYMBOLMAPPER_H
#define BASESYMBOLMAPPER_H

#include "symbolMapper/symbolDesc.h"
#include "symbolMapper/mapReader.h"
#include "symbology/symbol.h"
#include "symbolDrawerInterface/nullDrawer.h"
#include "symbolDrawer/ttsDrawer.h"
#include "symbolMapper/baseMapper.h"
#include "ngutil/orderedKeyList.h"
#include "geometry/point.h"

#include <QtCore/QObject>
#include <QtCore/QHash>
#include <QtGui/QColor>
#include <QtGui/QPixmap>

class DtSymbol;
class DtObjectType;
class DtSymbolDrawer;
class DtDrawerColl;
class DtModelData;
class DtBaseSymbolMapper;
class DtCompassModelData;
class DtDrawerKey;
class DtEntityMapperKey;
class DtCompositeSymbol;
class DtTTSSymbol;
class DtTerrainModelData;
class DtNameLabelSymbol;
class DtEnvironmentalModelData;

typedef DtSymbol* (*DtSymbolCreatorCallback)(const DtBaseSymbolMapper* mapper, const DtModelData& data, void* usr);
typedef void (*DtPostSymbolCreateCallbackFcn)(DtSymbol*, const DtModelData&, const DtBaseSymbolMapper*, void* usr);

#include "symbolMapper/symbolMapperDefines.h"

const int DtCacheMainSymbolAsBitmap = 0x00000001;
const int DtCacheNameLabelAsBitmap = 0x00000002;
const int DtCacheLabelLabelAsBitmap = 0x00000004;

class DT_DLL_symbolMapper DtCreateCallbackInfo
{
public:
   DtCreateCallbackInfo(DtSymbolCreatorCallback fcn, void *usr);
   DtCreateCallbackInfo(const DtCreateCallbackInfo& orig) :
      myCallback(orig.myCallback),
      myUserData(orig.myUserData)
   {
   }

   virtual ~DtCreateCallbackInfo();
   
   virtual DtSymbolCreatorCallback callback();
   virtual void* usertoLatin1();

protected:
   DtSymbolCreatorCallback myCallback;
   void* myUserData;
};

typedef QHash<int, DtCreateCallbackInfo> DtSymbolCreators;

class DT_DLL_symbolMapper DtPostCreateCallbackInfo
{
public:
   DtPostCreateCallbackInfo(int iType, DtPostSymbolCreateCallbackFcn fcn, void *usr);
   DtPostCreateCallbackInfo(const DtPostCreateCallbackInfo& orig) :
      myCallback(orig.myCallback),
      myUserData(orig.myUserData),
      myType(orig.myType)
   {
   }

   virtual ~DtPostCreateCallbackInfo();
   
   virtual DtPostSymbolCreateCallbackFcn callback();
   virtual void* usertoLatin1();
   virtual int type();

protected:
   DtPostSymbolCreateCallbackFcn myCallback;
   void* myUserData;
   int myType;
};

class DT_DLL_symbolMapper DtMapReaderCallbackInfo
{
public:
   DtMapReaderCallbackInfo(DtMapReaderCreatorFcn fcn);
   DtMapReaderCallbackInfo(const DtMapReaderCallbackInfo& orig) :
   myCallback(orig.myCallback) {};

   virtual ~DtMapReaderCallbackInfo();

   virtual DtMapReaderCreatorFcn callback();
   virtual void setCallback(DtMapReaderCreatorFcn fcn);

protected:
   DtMapReaderCreatorFcn myCallback;
};

typedef QHash<QString, DtMapReaderCallbackInfo> DtMapReaders;

class DT_DLL_symbolMapper DtObjectColor : public DtEntityMapperKey
{
public:
   DtObjectColor() : myColor(255, 0, 0) {};
   DtObjectColor(const DtEntityMapperKey& key) : DtEntityMapperKey(key), myColor(255, 0, 0) {};
   DtObjectColor(const DtObjectColor& c) : DtEntityMapperKey(c), myColor(c.myColor) {};
   
   QColor   myColor;
};

class DT_DLL_symbolMapper DtBaseSymbolMapper : public DtBaseMapper
{
   Q_OBJECT

public:
   DtBaseSymbolMapper();

   DtBaseSymbolMapper(DtBaseSymbolMapper*);
   
   virtual ~DtBaseSymbolMapper();
   
   virtual DtSymbol* createSymbol(const DtModelData& d);

   virtual void setDrawerColl(DtDrawerColl* dc);
   virtual DtDrawerColl* drawerColl() const;

   virtual bool init();

   virtual bool load(const char* filename, bool replace = false);

   virtual bool save(const char* filename);

   virtual bool addSymbolToList(DtDescriptor* sd, bool replace = false);
   virtual bool addSymbolToList(DtSymbolDescriptor* sd, bool replace = false);

   virtual DtSymbolDescriptor* getStringKeyedSymbolDesc(const QString& key) const;
   virtual void addStringKeyedSymbolToList(DtSymbolDescriptor* desc);

   virtual void getSymbolDescriptors(DtSDList* list) const;

   virtual DtSymbolDescriptor* fullLookup(const QString& key) const;

   virtual DtSymbolDrawer* lookupDrawer(const DtDrawerKey& key, DtSymbolDescriptor* symDesc);
   virtual DtSymbolDrawer* lookupDrawer(DtSymbolDescriptor* symDesc);

   virtual DtTTSDrawer& labelDrawer();
   virtual QColor labelColor() const;

   virtual void removeEntries(const DtBaseSymbolMapper& mapper);
   virtual void removeAllEntries(const DtSDList& mapper);

   virtual void removeEntry(DtSymbolDescriptor* sd);

   virtual const DtSDList& entities() const;

   virtual int defaultTransparencyFor(const DtEntityMapperKey& key) const;

   virtual void postLoadCleanup();

   virtual QPixmap getIcon(const DtModelData* d);
   virtual void setIconSize(const QSize size);
   virtual QSize iconSize() const;

   virtual QPixmap finalizeSymbolPixmap(const DtSymbol*) const;

   const QString& filename() const;

   virtual void clear();

public:
   virtual void addSymbolCreateCallback(int type, DtSymbolCreatorCallback fcn, void* usr = NULL);
   virtual void removeSymbolCreateCallback(int type);

   virtual DtSymbolDescriptor* getSymbolDesc(const DtEntityMapperKey& key) const;
   virtual DtSymbolDescriptor* getSymbolDesc(const DtModelData& data) const;

   virtual DtCompositeSymbol* createSymbolOfType(const DtEntityMapperKey& type,
      int force, DtSymbolCreatorFcn fcn);

   virtual void addPostCreateCallback(int iType, DtPostSymbolCreateCallbackFcn fcn, void* usr);

   virtual void removePostCreateCallback(int iType, DtPostSymbolCreateCallbackFcn fcn, void* usr);

   virtual void removeAllPostCreateCallbacks();

   virtual DtSymbol* createMainSymbol(const DtEntityMapperKey& emk, int force);

public:

   static DtBaseSymbolMapper* create();

   static void addReader(QString extension, DtMapReaderCreatorFcn fcn);
  
   static void cleanupReaders();

public:
   virtual DtMapReader* createReader(QString extension);

   virtual QColor defaultColorFor(const DtEntityMapperKey& key) const;
   virtual QColor defaultColorFor(const DtModelData& data) const;

   virtual DtTTSSymbol* createLabelSymbol();

   //Since the base mapper loads the map readers, it also needs
   //the media mappers so that it can pass it to it.
   //Ideally however, I would not have the symbol mapper create the map
   //reader. They should be separate.
   virtual void setMediaMapper(DtBaseMapper* map);

   virtual void addColor(const DtEntityMapperKey&, const QColor&);

   virtual void addNameLabel(DtNameLabelSymbol* symbol);
   virtual void addLabelLabel(DtNameLabelSymbol* symbol);

   virtual void chainSymbolMapper(DtBaseSymbolMapper*);

   virtual void clearCache();

   virtual void setDeleteChainedMappers(bool);
   virtual bool deleteChainedMappers() const;

   virtual void setCacheSymbolOptions(int);
   int cacheSymbolOptions() const;
   virtual DtSymbol* createSymbolFromDescription(DtSymbolDescriptor* symDesc, const DtEntityMapperKey& key);

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

public slots:
   virtual void setLabelColor(const QColor& color);
   virtual void setUsingAnimation(bool b);
   virtual void removeChainedMapper(QObject*);

signals:
   void labelColorChanged(const QColor& color);

protected:

   virtual void modifySymbol(DtSymbol* symbol, DtSymbolDescriptor* symDesc, int force, const DtEntityMapperKey& emk);

   virtual void removeEntry(DtSymbolDescriptor* sd, DtSDList& list);
   
   virtual void invokePostCreateCallbacks(DtSymbol*, const DtModelData&);

   virtual bool addEntry(DtSymbolDescriptor* sd, DtSDList& list, bool replace);

private:
   DtBaseSymbolMapper(const DtBaseSymbolMapper& orig);   
   DtBaseSymbolMapper& operator=(const DtBaseSymbolMapper orig);

protected:
   DtSymbolCreators myCreators;
   DtDrawerColl* myDrawerCollection;
   DtSDList myEntitySDList;
   DtSDList myOrderedList;
   QHash<QString, DtSymbolDescriptor*> myStringKeyedSDList;

   DtNullDrawer myNullDrawer;
   DtTTSDrawer myLabelDrawer;

   DtBaseMapper* myMediaMapper; 
   DtOrderedKeyList<DtObjectColor*>   myColors;

   QColor myLabelColor;

   bool myUsingAnimation;

   static DtMapReaders* myMapReaders;

   QSize myIconSize;
   QHash<QString, QPixmap*> myIconCache;

   QList<DtPostCreateCallbackInfo> myPostCreateCallbacks;

   static const QSize theDefaultIconSize;

   QString myFilename;

   DtPtrQList<DtBaseSymbolMapper*> myChainedMappers;

   bool  myDeleteChainedMappers;
   QString myComment;

   int myCacheSymbolOptions;

   DtBaseSymbolMapper*  myParent;
};

inline const QString& DtBaseSymbolMapper::filename() const
{
   return myFilename;
}

inline int DtBaseSymbolMapper::cacheSymbolOptions() const
{
   return myCacheSymbolOptions;
}

#endif