src/can/canAdvStyle.h

   1 /*
   2 Qanava - Graph drawing library for QT
   3 Copyright (C) 2005 Benoit AUTHEMAN
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18 */
  19
  20 //-----------------------------------------------------------------------------
  21 // This file is a part of the Qarte software.
  22 //
  23 // \file        qisStyle.h
  24 // \author      Benoit Autheman (benoit@faktiss.net)
  25 // \date        2005 January 03
  26 //-----------------------------------------------------------------------------
  27
  28
  29 #ifndef qan_can_Style_h
  30 #define qan_can_Style_h
  31
  32
  33 // UTL headers
  34 #include "../utl/utlManager.h"
  35
  36
  37 // Std headers
  38 #include <string>
  39 #include <map>
  40
  41
  42 //-----------------------------------------------------------------------------
  43 namespace qan // ::qan
  44 {
  45         namespace can // ::qan::can
  46         {
  47                 //! Specify graphic and other attributes for a specific primitive (usually a Canvas Item).
  48                 /*!
  49                         \nosubgrouping
  50                 */
  51                 class AdvStyle
  52                 {
  53                 public:
  54
  55                         //! Manage styles for a set of objects (usually Canvas Item items).
  56                         /*!
  57                         Definition of styles for la::Node objects:
  58 \code
  59 // na, nb and nc are la::Node objects registered in a la::Graph object called graph
  60 can::AdvStyle::Manager styleManager;
  61
  62 can::AdvStyle* blueNode = new can::AdvStyle( "bluenode" );
  63 blueNode->addImage( "backimage", "images/gradblue.png" );
  64 blueNode->addColor( "bordercolor", 0, 0, 0 );
  65 styleManager.setStyle( &na, *blueNode );
  66
  67 can::AdvStyle* greenNode = new can::AdvStyle( "greennode" );
  68 greenNode->addImage( "backimage", "images/gradgreen.png" );
  69 greenNode->addColor( "bordercolor", 50, 100, 200 );
  70 styleManager.setStyle( &nb, *greenNode );
  71
  72 can::AdvStyle* iconNode = new can::AdvStyle( "iconnode" );
  73 iconNode->addImage( "backimage", "images/gradblue.png" );
  74 iconNode->addImage( "icon", "images/icon.png" );
  75 iconNode->addColor( "bordercolor", 0, 255, 0 );
  76 styleManager.setStyle( &nc, *iconNode );
  77
  78 can::GraphPositionner* positionner = new can::GraphPositionner( *canvas, *graph );
  79 positionner->feed( styleManager );
  80 \endcode
  81
  82                                 \sa can::AdvStyle and can::Positionner
  83                                 \nosubgrouping
  84                         */
  85                         class Manager : public qan::utl::Manager< AdvStyle >
  86                         {
  87                         public:
  88
  89                                 Manager( ) { }
  90
  91                                 /*! \name Style Management *///--------------------------------
  92                                 //@{
  93                         public:
  94
  95                                 //! Set the style for a specific object.
  96                                 void                            setStyle( void* object, AdvStyle& style );
  97
  98                                 //! Set the style for a specific node type.
  99                                 void                            setStyle( int type, AdvStyle& style );
 100
 101                                 //! Get the style for a specific object.
 102                                 AdvStyle*                       getStyle( void* object );
 103
 104                                 //! Get the style for a specific node type.
 105                                 AdvStyle*                       getStyle( int type );
 106
 107                         protected:
 108
 109                                 //! Map style to their target object.
 110                                 typedef std::map< void*, AdvStyle* >    ObjectStyleMap;
 111
 112                                 //! Map style to their target object.
 113                                 typedef std::map< int, AdvStyle* >      TypeStyleMap;
 114
 115                                 //! .
 116                                 ObjectStyleMap          _objectStyleMap;
 117
 118                                 //! .
 119                                 TypeStyleMap            _typeStyleMap;
 120                                 //@}
 121                                 //-------------------------------------------------------------
 122                         };
 123
 124
 125                         class Color;
 126
 127                         //! Models a Style attribute (either a color, a numeric value or an image name).
 128                         /*!
 129                                 \nosubgrouping
 130                         */
 131                         class Attribute
 132                         {
 133                         public:
 134
 135                                 //! Define the attribute concrete type.
 136                                 enum Type
 137                                 {
 138                                         NONE            = 0,
 139
 140                                         COLOR           = 1,
 141
 142                                         VALUE           = 2,
 143
 144                                         IMAGE           = 4
 145                                 };
 146
 147                                 //! Manage a set of attributes for a specific style.
 148                                 /*!
 149                                         \nosubgrouping
 150                                 */
 151                                 class Manager : public qan::utl::Manager< Attribute >
 152                                 {
 153                                         /*! \name Manager Attribute Access *///--------------------
 154                                         //@{
 155                                 public:
 156
 157                                         bool                            hasColor( const std::string& name ) const;
 158
 159                                         const Color                     getColor( const std::string& name ) const;
 160
 161                                         bool                            hasImage( const std::string& name ) const;
 162
 163                                         const std::string       getImage( const std::string& name ) const;
 164
 165                                         bool                            hasValue( const std::string& name ) const;
 166
 167                                         double                          getValue( const std::string& name ) const;
 168
 169                                 protected:
 170
 171                                         const Attribute*        getAttribute( const std::string& name ) const;
 172                                         //@}
 173                                         //---------------------------------------------------------
 174                                 };
 175
 176                                 Attribute( Type type, const std::string& name ) :
 177                                         _type( type ),
 178                                         _name( name ) { }
 179
 180                                 Attribute( const Attribute& attribute ) : _type( attribute._type ), _name( attribute._name ) { }
 181
 182                                 //! Get the attribute type.
 183                                 /*! \return the attribute type.                         */
 184                                 Type                            getType( ) const { return _type; }
 185
 186                                 //! Get the attribute name.
 187                                 /*! \return the attribute name.                         */
 188                                 const std::string&      getName( ) const { return _name; }
 189
 190                         protected:
 191
 192                                 //! Attribute type.
 193                                 Type                    _type;
 194
 195                                 //! Attribute name.
 196                                 std::string             _name;
 197                         };
 198
 199
 200                         //! Model an RGB color attribute.
 201                         /*!
 202                                 \nosubgrouping
 203                         */
 204                         class Color : public Attribute
 205                         {
 206                         public:
 207
 208                                 Color( const std::string& name, int r, int g, int b ) :
 209                                         Attribute( COLOR, name ), _r( r ), _g( g ), _b( b ) { }
 210
 211                                 Color( const Color& color ) : Attribute( color ),
 212                                         _r( color._r ), _g( color._g ), _b( color._b ) { }
 213
 214                                 void    setRgb( int r, int g, int b ) { _r = r; _g = g; _b = b; }
 215
 216                                 int             getR( ) const { return _r; }
 217
 218                                 int             getG( ) const { return _g; }
 219
 220                                 int             getB( ) const { return _b; }
 221
 222                         protected:
 223
 224                                 int             _r;
 225
 226                                 int             _g;
 227
 228                                 int             _b;
 229                         };
 230
 231                         //! Model a numeric (integer or float) attribute.
 232                         /*!
 233                                 \nosubgrouping
 234                         */
 235                         class Value : public Attribute
 236                         {
 237                         public:
 238
 239                                 Value( const std::string& name, int i, double d = 0.0 ) :
 240                                         Attribute( VALUE, name ), _i( i ), _d( d ) { }
 241
 242                                 Value( const Value& value ) : Attribute( value ),  _i( value._i ), _d( value._d ) { }
 243
 244                                 int             getInt( ) const { return _i; }
 245
 246                                 void    setInt( int i ) { _i = i; }
 247
 248                                 double  getDouble( ) const { return _d; }
 249
 250                                 void    setDouble( double d ) { _d = d; }
 251
 252                         protected:
 253
 254                                 int             _i;
 255
 256                                 double  _d;
 257                         };
 258
 259                         //! Model an image name attribute (just the image name is stored not the image's content).
 260                         /*!
 261                                 \nosubgrouping
 262                         */
 263                         class Image : public Attribute
 264                         {
 265                         public:
 266
 267                                 Image( const std::string& name, const std::string& fileName ) :
 268                                         Attribute( IMAGE, name ), _fileName( fileName ) { }
 269
 270                                         Image( const Image& image ) : Attribute( image ), _fileName( image._fileName ) { }
 271
 272                                 const std::string&      getFileName( ) const { return _fileName; }
 273
 274                         protected:
 275
 276                                 std::string                     _fileName;
 277                         };
 278
 279                         /*! \name Style Constructor/Destructor *///------------------------
 280                         //@{
 281                 public:
 282
 283                         //! Style constructor with name initialisation.
 284                         AdvStyle( const std::string& name ) : _name( name ) { }
 285
 286                         //! Style virtual destructor.
 287                         virtual ~AdvStyle( ) { }
 288                         //@}
 289                         //-----------------------------------------------------------------
 290
 291
 292
 293                         /*! \name Name Management *///-------------------------------------
 294                         //@{
 295                 public:
 296
 297                         //! Get the style name.
 298                         const   std::string&    getName( ) const { return _name; }
 299
 300                 protected:
 301
 302                         //! Style name.
 303                         std::string                             _name;
 304                         //@}
 305                         //-----------------------------------------------------------------
 306
 307
 308
 309                         /*! \name Attribute Management *///--------------------------------
 310                         //@{
 311                 public:
 312
 313                         //! Get the style attribute manager.
 314                         Attribute::Manager&     getAttributeManager( ) { return _attributeManager; }
 315
 316                         //! .
 317                         void                            addColor( const std::string& name, int r, int g, int b );
 318
 319                         //! Test if there is a color of a given name in this style attribute manager.
 320                         bool                            hasColor( const std::string& name ) const;
 321
 322                         //! Get a color under a QT compatible text form (#RRGGBB).
 323                         std::string                     getColor( const std::string& name ) const;
 324
 325                         //! .
 326                         void                            addImage( const std::string& name, const std::string& fileName );
 327
 328                         //! .
 329                         bool                            hasImage( const std::string& name ) const;
 330
 331                         //! .
 332                         std::string                     getImage( const std::string& name ) const;
 333
 334                         //! .
 335                         void                            addValue( const std::string& name, double value );
 336
 337                         //! .
 338                         bool                            hasValue( const std::string& name ) const;
 339
 340                         //! .
 341                         double                          getValue( const std::string& name ) const;
 342
 343                 protected:
 344
 345                         //! Style attribute manager.
 346                         Attribute::Manager      _attributeManager;
 347                         //@}
 348                         //-----------------------------------------------------------------
 349
 350
 351
 352                         /*! \name Model Signals Management *///----------------------------
 353                         //@{
 354                 public:
 355
 356 #ifndef QANAVA_NOBOOST
 357                         //! .
 358                         boost::signal0< void >  modified;
 359 #else
 360                         void                                    modified( ) { }
 361 #endif
 362 #ifndef QANAVA_NOBOOST
 363                         //! .
 364                         boost::signal0< void >  destroyed;
 365 #else
 366                         void                                    destroyed( ) { }
 367 #endif
 368                         //@}
 369                         //-----------------------------------------------------------------
 370                 };
 371         } // ::qan::can
 372 } // ::qan
 373 //-----------------------------------------------------------------------------
 374
 375
 376 #endif // qab_can_Style_h
 377
 378