include/symbolMapper/symbolDesc.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2005 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: symbolDesc.h,v $ $Revision: 1.21 $ $State: Exp $
*******************************************************************************/


#ifndef SYMBOLDESC_H
#define SYMBOLDESC_H

#include "symbolMapper/descriptor.h"
#include "symbology/symbol.h"

#include <QtCore/QString>
#include <QtGui/QColor>

class DtSymbol;
class DtSymbolDrawer;
class DtEntityMapperKey;

#include "symbolMapper/symbolMapperDefines.h"
class DT_DLL_symbolMapper DtSymbolDescriptor : public DtDescriptor
{

public:

   DtSymbolDescriptor():
      DtDescriptor(),
      myTransparencyLevel(0),
      myColor(QRgb(0)),
      myOptionalColorParameter(0),
      myWriteOut(true),
      myOptionalData(false)
   {
      myKeyword = "symbol-map";
   };

   virtual ~DtSymbolDescriptor()
   {
   };

   DtSymbolDescriptor(const DtSymbolDescriptor& orig):
      DtDescriptor(orig),
      myColor(orig.myColor),
      myWriteOut(orig.myWriteOut),
      myTransparencyLevel(orig.myTransparencyLevel),
      myOptionalColorParameter(orig.myOptionalColorParameter),
      myOptionalData(orig.myOptionalData)
   {
   };

   virtual DtSymbolDescriptor& operator=(const DtSymbolDescriptor& rhs)
   {
      if (this == &rhs)
         return *this;

      DtDescriptor::operator=(rhs);

      myColor = rhs.myColor;
      myWriteOut = rhs.myWriteOut;
      myTransparencyLevel = rhs.myTransparencyLevel;
      myOptionalColorParameter = rhs.myOptionalColorParameter;
      myOptionalData = rhs.myOptionalData;

      return *this;
   };

   virtual bool operator==(const DtSymbolDescriptor& rhs) const
   {
      if (DtDescriptor::operator==(rhs))
      {
         return ((myColor == rhs.myColor) &&
                 (myWriteOut == rhs.myWriteOut) &&
                 (myTransparencyLevel == rhs.myTransparencyLevel) &&
                 (myOptionalColorParameter == rhs.myOptionalColorParameter) &&
                 (myOptionalData == rhs.myOptionalData));
      }

      return false;
   }

   virtual bool operator!=(const DtSymbolDescriptor& rhs) const
   {
      return !(*this == rhs);
   }

   virtual QString secondaryInfo() const
   {
      return "";
   }

   virtual DtSymbol* createSymbol(DtSymbolDrawer& drawer, const DtEntityMapperKey& key) const = 0;

   void setColor(const QColor& color);
   const QColor& color() const;

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

   void setOptionalColorParameter(int);
   int optionalColorParameter() const;

   void setWriteOut(bool);
   bool writeOut() const;

   virtual DtSymbolDescriptor* clone() = 0;

   virtual QString descriptorInformation() const
   {
      QString s;

      if (myOptionalData)
      {
         s += "(list ";
         s += QString::number(myColor.red());
         s += " ";
         s += QString::number(myColor.green());
         s += " ";
         s += QString::number(myColor.blue());
         s += " ";
         s += QString::number(myTransparencyLevel);
         s += " ";
         s += QString::number(myOptionalColorParameter);
         s += ")";
      }

      return s;
   }

protected:
   virtual void setupOptionSymbolInformation(DtSymbol* mainSymbol) const;

protected:
   QColor  myColor;
   int     myTransparencyLevel;
   int     myOptionalColorParameter;
   bool    myOptionalData;
   bool    myWriteOut;
};

inline void DtSymbolDescriptor::setColor(const QColor& color)
{
   myOptionalData = true;
   myColor = color;
}

inline const QColor& DtSymbolDescriptor::color() const
{
   return myColor;
}

inline void DtSymbolDescriptor::setTransparencyLevel(int i)
{
   myOptionalData = true;
   myTransparencyLevel = i;
}

inline int DtSymbolDescriptor::transparencyLevel() const
{
   return myTransparencyLevel;
}

inline void DtSymbolDescriptor::setOptionalColorParameter(int i)
{
   myOptionalData = true;
   myOptionalColorParameter = i;
}

inline int DtSymbolDescriptor::optionalColorParameter() const
{
   return myOptionalColorParameter;
}

inline void DtSymbolDescriptor::setupOptionSymbolInformation(DtSymbol* mainSymbol) const
{
   mainSymbol->setTransparencyLevel(myTransparencyLevel);

   if ((myColor.rgb() & RGB_MASK) != 0)
   {
      mainSymbol->setColor(myColor);
   }
}

inline void DtSymbolDescriptor::setWriteOut(bool b)
{
   myWriteOut = b;
}

inline bool DtSymbolDescriptor::writeOut() const
{
   return myWriteOut;
}

#endif