include/symbology/symbol.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2002 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: symbol.h,v $ $Revision: 1.90 $ $State: Exp $
*******************************************************************************/


#ifndef DtSymbol_H_
#define DtSymbol_H_

#include "symbolDrawerInterface/nullDrawer.h"
#include "symbology/showHideContext.h"
#include "drawerNative/displayPoint.h"

#include <QtCore/QSize>
#include <QtCore/QRect>
#include <QtCore/QObject>
#include <QtCore/QSize>
#include <QtCore/QString>
#include <QtCore/QList>
#include <QtCore/QVector>
#include <QtGui/QColor>
#include <QtGui/QPolygon>

#include <symbolDrawerInterface/symbolDrawer.h>

class DtPaintDevice;

class DtSymbol;
class DtStaticAnimData;
class QImage;
class QPixmap;
class DtSymbolDisplayOptions;

class QTimer;

enum DtSymbolGeometry{
      DtSymbol_Point = 0, 
      DtSymbol_Line, 
      DtSymbol_Area,
      DtSymbol_Composite
};

typedef DtSymbol* (*DtSymbolCreatorFcn)(DtSymbolDrawer& drawer);

#include "symbology/symbologyDefines.h"
class DT_DLL_symbology DtSymbol : public QObject
{
   Q_OBJECT

public:

   typedef enum
   {
      DtSymbol_BoundingSphere = 0,   
      DtSymbol_BoundingBox    = 1,   
      DtSymbol_SpherePieces   = 2,   
      DtSymbol_BoxPieces      = 3,   
      DtSymbol_Exact          = 4    
   } DtSymbol_OverlapTest;

   typedef enum
   {
      DtSymbol_DrawAsEntered  = 0,
      DtSymbol_DrawFirst      = 1,   
      DtSymbol_DrawLast       = 2,   
   } DtSymbol_DrawOrder;

   typedef enum
   {
      DtSymbol_Always = 0,          
      DtSymbol_Never = 1,           
      DtSymbol_OnlyIfCloned = 2     
   } DtSymbolCompositeDrawOptions;

public:

   virtual ~DtSymbol();

   DtSymbol(const DtSymbol& orig);

   DtSymbol& operator=(const DtSymbol& orig);
 
   DtSymbol( DtSymbolDrawer & drawer );

   virtual void copyDataFrom(const DtSymbol* symbol);

   virtual DtSymbol* clone() const;

   virtual void setName(const QString& name);
   virtual const QString& name()const;

   virtual void setHighlight(const bool highlight);
   virtual bool highlight() const;
   virtual bool selected() const;

   virtual const DtDisplayPoint centerPoint() const;

   virtual const DtDisplayPoint topLeftPoint() const;

   virtual bool setLocationData(const QPolygon*);

   virtual const QPolygon* getLocationData() const;


   virtual void setOrigin(const QPoint & center);

   virtual void setOrigin( int x, int y );

   virtual const QPoint origin() const;

   virtual void shift(QPoint p);

   virtual void draw(QPainter& paint) const;
   virtual void drawHidden(QPainter& paint) const;
   virtual const DtSymbolDrawer& drawer() const;

   virtual QSize bbox() const;
   virtual QRect brect() const;

   virtual QRect selBbox() const;

   virtual void clearOffsetToParent();
   virtual void setOffsetToParent(const QPoint& offsetToParent);
   virtual const QPoint* offsetToParent() const;


   virtual bool show(DtShowHideContext module);
   virtual bool hide(DtShowHideContext module);

   virtual void show();

   virtual void hide();

   virtual void addIgnoreContext(DtShowHideContext);
   virtual void removeIgnoreContext(DtShowHideContext);
   const QVector<DtShowHideContext>& ignoreContexts() const;

   virtual void wasHidden(DtSymbol*);

   virtual void wasShown(DtSymbol*);

   virtual bool isShown() const;

   virtual DtSymbol* parent() const;
   virtual void setParent(DtSymbol* dad);


   virtual bool isComposite() {return false;}
  
   virtual DtSymbolGeometry geometry() const;
   virtual void setGeometry(DtSymbolGeometry geom);


   virtual void setCategoryTag(const QString& name);
   virtual const QString& categoryTag()const;


   virtual bool select(const QPoint& aPoint);

   virtual bool select(const QPoint& aPoint,
      const QSize& rectangleSize);

   virtual void setSelectable(bool value);
   virtual bool isSelectable() const;

   virtual void setEditable(bool b);
   virtual bool editable() const;

   virtual void setAllowEditOnSelection(bool b);
   virtual bool allowEditOnSelection() const;

   virtual void setInternalSelectable(bool value);
   virtual bool isInternalSelectable() const;

   virtual void setAddToDrawOrder(bool b);
   virtual bool addToDrawOrder() const;

//----  Overlap Options

   virtual bool overlapsSymbol(const DtSymbol & aSymbol, 
      const DtSymbol_OverlapTest aTest = DtSymbol_BoxPieces,
      const float aTolerance = 0) const;

   virtual bool overlapsAreaSymbol(const DtSymbol & aSymbol, 
      const DtSymbol_OverlapTest aTest = DtSymbol_BoxPieces,
      const float aTolerance = 0) const;

   virtual bool overlapsLineSymbol(DtSymbol & aSymbol, 
      const float aTolerance = 0) const;                                  


   virtual bool isOriginal() const;

   virtual DtStaticAnimData* staticAnimData() const;

   virtual void setDrawOnComposite(DtSymbolCompositeDrawOptions opt);
   virtual bool drawOnComposite() const;
   virtual DtSymbolCompositeDrawOptions drawOnCompositeValue() const;

   virtual bool drawFirst() const;
   virtual void setDrawFirst(bool b);

   virtual bool drawLast() const;
   virtual void setDrawLast(bool b);

   virtual bool selectAdditionalSymbols(QList<DtSymbol*>& additionalSymbols);

   virtual bool forceUpdate() const;

   virtual void setColor(const QColor& color);

   virtual void clearColor();

   virtual bool adjustPoints(QPolygon& pnts, bool constrain);

   virtual void setDragClone(DtSymbol* clone);
   virtual DtSymbol* dragClone() const;

   virtual void setScaleBy(double factor);
   virtual double scaleBy() const;

   virtual bool isScalable() const;

   virtual void enableVisibilityChange(bool b);

   virtual void scheduleDisplayComplete(int);

   virtual void setShouldSelect(bool);
   virtual bool shouldSelect() const;

   virtual void setTransparencyLevel(int);
   virtual int transparencyLevel() const;

   virtual bool needsTransparentRedraw() const;
   virtual QPixmap* transparentImage() const;
   virtual QPixmap* cacheTransparentImage(const QPixmap& pixmap);
   virtual QPixmap* cacheTransparentImage(const QImage& image);
   virtual bool transparentCacheChanged() const;
   virtual void cacheTransparentVariables();

   virtual bool wantsTransparentDraw() const;

   bool operator==(const DtSymbol& orig) const;
   bool operator!=(const DtSymbol& orig) const;

   virtual DtSymbolDrawer* symbolDrawer();
   virtual DtSymbolDrawer* setDrawer(const DtSymbolDrawer&);

   virtual DtSymbolDrawer& backupDrawer() const;
   virtual void setBackupDrawer(DtSymbolDrawer*);

   static DtNullDrawer* nullDrawer();

   virtual bool removeIfOffScreen() const;

   void setRemoveIfOffScreen(bool b);

   virtual void setSymbolDisplayOptions(DtSymbolDisplayOptions*);
   virtual const DtSymbolDisplayOptions* symbolDisplayOptions() const;
   virtual DtSymbolDisplayOptions* symbolDisplayOptions();
   virtual int displayOptionsCache() const;

   void setAdjustPoints(bool);
   bool adjustPoints() const;

   const QVector<DtShowHideContext>& hiddenByModules() const;
   bool hiddenByModule(DtShowHideContext module) const;

   virtual void blockSignals(bool);

   virtual bool originIsCenterOfMass() const;

   virtual void setCacheSymbolAsBitmap(bool);
   bool cacheSymbolAsBitmap() const;
   
   virtual const QString& bitmapSymbolCacheKey() const;

   virtual void reset();

   virtual bool editMode();
   virtual void setEditMode(bool onOff);

public slots:

   virtual void invalidateStaticAnimData();

   virtual void displayComplete();

   virtual void clearDragClone(QObject*);

signals:
   void originalSymbolDestroyed();

   void destroyed(const DtSymbol *);

   void originChanged(const DtSymbol*);

   void visibilityChanged(const DtSymbol*);

   void displayComplete(const DtSymbol*);

protected:
   bool overlapsBoundingSphere(const DtSymbol & aSymbol, 
                              const float aTolerance) const;   

   bool overlapsBoundingBox(const DtSymbol & aSymbol, 
                              const float aTolerance) const;   
   
protected:
   static DtNullDrawer theNullDrawer;

   DtSymbolDrawer*   mySymbolDrawer;
   DtSymbolDrawer*   myBackupDrawer;
   QPoint            myOrigin;
   bool              myActiveOffsetToParent;
   QPoint            myOffsetToParent;
   bool myHighlight;
   bool myIsShown;
   bool myIsSelectable;
   bool myEditable;
   bool myInternalSelectable;
   QString myName;
   QString myCategoryTag;
   DtSymbolGeometry myGeometry;

   //Note: deleting a child does not delete the parent!
   DtSymbol* myParent;

   DtSymbol* myDragClone;

   bool              myIsOriginal;
   bool              myAllowEditOnSelection;
   bool              myAddToDrawOrder;

   double            myScaleFactor;

   mutable DtStaticAnimData* myStaticAnimData;

   bool              myEmitVisibilityChange;

   DtSymbol_DrawOrder   myDrawOrder;
   QTimer            *myTimer;

   DtSymbolCompositeDrawOptions  myDrawOnComposite;

   bool              myShouldSelect;

   int               myTransparencyLevel;
   QPixmap*          myTransparentImage;
   DtSymbol*         myTransparentCachedSymbol;

   DtSymbolDisplayOptions  *mySymbolDisplayOptions;

   bool              myAdjustPoints;
   QVector<DtShowHideContext>    myHiddenByModules;
   QVector<DtShowHideContext>    myIgnoreContexts;

   bool              myRemoveIfOffscreen;
   bool              myCacheSymbolAsBitmap;
   bool              myEditMode;
   mutable QString   mySymbolBitmapCacheKey;
};

inline bool DtSymbol::cacheSymbolAsBitmap() const
{
   return myCacheSymbolAsBitmap;
}

inline void DtSymbol::setAdjustPoints(bool b)
{
   myAdjustPoints = b;
}

inline bool DtSymbol::adjustPoints() const
{
   return myAdjustPoints;
}

inline const QVector<DtShowHideContext>& DtSymbol::hiddenByModules() const
{
   return myHiddenByModules;
}

inline const QVector<DtShowHideContext>& DtSymbol::ignoreContexts() const
{
   return myIgnoreContexts;
}

inline bool DtSymbol::hiddenByModule(DtShowHideContext module) const
{
   return (myHiddenByModules.indexOf(module) != -1);
}

inline void DtSymbol::setRemoveIfOffScreen(bool b)
{
   myRemoveIfOffscreen = b;
}

#include "symbology/symbolList.h"

#endif