E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeVisual.h

Go to the documentation of this file.

/************************************************************************************
TerraLib - a library for developing GIS applications.
Copyright © 2001-2007 INPE and Tecgraf/PUC-Rio.

This code is part of the TerraLib library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

You should have received a copy of the GNU Lesser General Public
License along with this library.

The authors reassure the license terms regarding the warranties.
They specifically disclaim any warranties, including, but not limited to,
the implied warranties of merchantability and fitness for a particular purpose.
The library provided hereunder is on an "as is" basis, and the authors have no
obligation to provide maintenance, support, updates, enhancements, or modifications.
In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
indirect, special, incidental, or consequential damages arising out of the use
of this library and its documentation.
*************************************************************************************/
#ifndef  __TERRALIB_INTERNAL_VISUAL_H
#define  __TERRALIB_INTERNAL_VISUAL_H

#include "TeDefines.h"
#include "TeDataTypes.h"
#include "TeAbstractFactory.h"

class TeRasterTransform;

#include <string>
#include <map>

using namespace std;


struct TL_DLL TeColor
{
           int red_;

           int green_;           
           
           int blue_; 
           
           string name_;
           
           TeColor () : red_(0),green_(0),blue_(0), name_("") {}

           TeColor (int r, int g, int b, const string& name="") : red_(r),green_(g),blue_(b), name_(name) {}

           void init (int r, int g, int b, const string& name="") {red_=r,green_=g,blue_=b;name_=name; }


           bool operator== (const TeColor& color)
           {
                      return (red_==color.red_ && green_==color.green_ && blue_==color.blue_);
           }

           TeColor& operator= ( const TeColor& color )
           {
                      if ( this != &color )
                      {          
                                 red_ = color.red_;
                                 green_ = color.green_;
                                 blue_ = color.blue_;
                                 name_ = color.name_;
                      }
                      return *this;
           }
};


class TL_DLL TeBaseVisualParams
{
public:
           TeBaseVisualParams(TeGeomRep rep = TePOLYGONS, const string& visualType = "tevisual"); 

           TeBaseVisualParams(const TeBaseVisualParams& other);

           virtual ~TeBaseVisualParams() {}

           virtual TeBaseVisualParams& operator=(const TeBaseVisualParams& visParams);

           virtual bool operator== (const TeBaseVisualParams& visParams);

           virtual void clear();

           virtual void setBasic (TeBaseVisualParams &visParams);

           string getProductId() { return visualType_; }

    int                          symbId_;                         
           TeColor               color_;                                     
           int                              transparency_;                   
           int                              width_;                                     
           
           int                              contourSymbId_;                             
           TeColor               contourColor_;                              
           int                              contourTransparency_; 
           int                              contourWidth_;                              

           int                              sizeValue_;           
           int                              ptAngle_;                                   
           
           // Text attributes
           string                family_;   
           bool                  bold_;                           
           bool                  italic_;   
           double                alignmentVert_;                  
           double                alignmentHoriz_;      
           int                              tabSize_;             
           int                              lineSpace_;           
           bool                  fixedSize_;                                 

           string                visualType_;
           TeGeomRep   geomRep_;                                  
};

class TL_DLL TeVisual
{
public :
           
           TeVisual(TeGeomRep rep = TePOLYGONS);

           virtual ~TeVisual() {}

           TeVisual(const TeVisual& other);

           virtual TeVisual& operator=(const TeVisual& vis);

           virtual bool operator== (const TeVisual& vis);

           virtual void clear();

           virtual void setBasic (TeVisual &vis);

           virtual void color(const TeColor& color) 
           {          params_.color_ = color;}

           virtual TeColor& color() 
           { return params_.color_; }

           virtual void style(int s) 
           { params_.symbId_ = s; }

           virtual int           style() 
           { return params_.symbId_; }

           virtual void transparency(int t)
           { params_.transparency_ = t; }

           virtual int transparency()
           { return params_.transparency_; }

           virtual void contourColor(const TeColor& color) 
           { params_.contourColor_ = color;}

           virtual TeColor& contourColor() 
           { return params_.contourColor_; }

           virtual void contourTransparency(int t) 
           { params_.contourTransparency_ = t;}

           virtual int           contourTransparency() 
           { return params_.contourTransparency_; }

           virtual void contourWidth(int w) 
           { params_.contourWidth_ = w; }

           virtual int           contourWidth()  
           { return params_.contourWidth_; }

           virtual void contourStyle(int s) 
           { params_.contourSymbId_ = s; }

           virtual int           contourStyle() 
           { return params_.contourSymbId_; }

           virtual void width(int w) 
           { params_.width_ = w; }

           virtual int            width ()  
           { return params_.width_; }

           virtual void size (int s)  
           { params_.sizeValue_ = s; }

           virtual int           size ()  
           { return params_.sizeValue_; }

           virtual void family (string f) 
           { params_.family_ = f; }

           virtual string family () 
           { return params_.family_ ; }

           virtual void bold (bool b) 
           { params_.bold_ = b; }

           virtual bool bold () 
           { return params_.bold_; }

           virtual void italic (bool i) 
           { params_.italic_ = i; }

           virtual bool italic () 
           { return params_.italic_; }

           virtual void fixedSize (bool i) 
           { params_.fixedSize_ = i; }

           virtual bool fixedSize () 
           { return params_.fixedSize_; }

           virtual void alignmentVert(double a) 
           { params_.alignmentVert_ = a; }

           virtual double alignmentVert() 
           { return params_.alignmentVert_; }

           virtual void alignmentHoriz(double a) 
           { params_.alignmentHoriz_ = a; }

           virtual double alignmentHoriz() 
           { return params_.alignmentHoriz_; }

           virtual void tabSize (int s) 
           { params_.tabSize_ = s; }

           virtual int           tabSize () 
           { return params_.tabSize_; }

           virtual void lineSpace (int s) 
           { params_.lineSpace_ = s; }

           virtual int           lineSpace () 
           { return params_.lineSpace_; }

           virtual int   ptAngle() 
           {return params_.ptAngle_; }

           virtual void  ptAngle(int p) 
           {params_.ptAngle_ = p;}

           virtual TeVisual* copy()
           {
                      TeVisual* retval = new TeVisual();
                      *retval = *this;
                      return retval;
           }

           static TeVisual* DefaultObject()  
           { return new TeVisual(); }

protected:
           TeBaseVisualParams    params_;
};


class TL_DLL TeVisualFactory : public TeAbstractFactory<TeVisual, TeBaseVisualParams, string>
{
public:
           TeVisualFactory(const string& facName) : TeAbstractFactory<TeVisual, TeBaseVisualParams, string>(facName)
           {}
                      virtual TeVisual* build ()
           {          return new TeVisual(); }
};

typedef TeRasterTransform TeRasterVisual;

#endif