src/qanStyle.cpp

   1 /*
   2 Qanava - Graph drawing library for QT
   3 Copyright (C) 2006 Benoit AUTHEMAN
   4
   5 This library is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU Lesser General Public
   7 License as published by the Free Software Foundation; either
   8 version 2.1 of the License, or (at your option) any later version.
   9
  10 This library 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 GNU
  13 Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public
  16 License along with this library; 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        qanStyle.cpp
  24 // \author      Benoit Autheman (benoit@libqanava.org)
  25 // \date        2005 January 03
  26 //-----------------------------------------------------------------------------
  27
  28
  29 // Qanava headers
  30 #include "./qanStyle.h"
  31
  32
  33 // QT headers
  34 #include <QColor>
  35 #include <QVariant>
  36 #include <QFont>
  37 #include <QSet>
  38
  39
  40 namespace qan { // ::qan
  41
  42
  43 /* Style Manager Constructor/Destructor *///-----------------------------------
  44 Style::Manager::Manager( ) :
  45         _empty( new Style( "empty" ) )
  46 {
  47
  48 }
  49
  50 Style::Manager::~Manager( )
  51 {
  52         if ( _empty != 0 )
  53                 delete _empty;
  54         clear( );
  55 }
  56 //-----------------------------------------------------------------------------
  57
  58
  59
  60 /* Style Management *///-------------------------------------------------------
  61 void    Style::Manager::clear( )
  62 {
  63         QSet< Style* >  styles = QSet< Style* >::fromList( _objectStyleMap.values( ) );
  64         foreach ( Style* style, styles )
  65                 delete style;
  66         _objectStyleMap.clear( );
  67         _typeStyleMap.clear( );
  68         clearImages( );
  69 }
  70
  71 void    Style::Manager::setStyle( void* object, Style& style )
  72 {
  73         if ( !_objectStyleMap.contains( object ) )
  74                 _objectStyleMap.insert( object, &style );
  75 }
  76
  77 Style*  Style::Manager::getStyle( void* object )
  78 {
  79         return _objectStyleMap.value( object, 0 );
  80 }
  81
  82 const Style*    Style::Manager::getStyle( const void* object ) const
  83 {
  84         return _objectStyleMap.value( const_cast< void* >( object ), 0 );
  85 }
  86
  87 void    Style::Manager::setStyle( int type, Style& style )
  88 {
  89         // Set the style if the type don't already have a style
  90         if ( !_typeStyleMap.contains( type )  )
  91                 _typeStyleMap.insert( type, &style );
  92 }
  93
  94 Style*  Style::Manager::getStyle( int type )
  95 {
  96         return _typeStyleMap.value( type, 0 );
  97 }
  98
  99 const Style*    Style::Manager::getStyle( int type ) const
 100 {
 101         return _typeStyleMap.value( type, 0 );
 102 }
 103 //-----------------------------------------------------------------------------
 104
 105
 106 /* Image Caching Management *///-----------------------------------------------
 107 /*!
 108         \return A cached image loaded from the given filename. If fileName is invalid, the returned image can be queried for isNull().
 109  */
 110 QImage          Style::Manager::getImage( QString fileName )
 111 {
 112         NameImageMap::iterator imageIter = _nameImageMap.find( fileName );
 113         if ( imageIter != _nameImageMap.end( ) )
 114                 return imageIter.value( );
 115         else
 116         {
 117                 QImage image( fileName );
 118                 if ( image.isNull( ) )
 119                         return image;
 120                 else
 121                 {
 122                         _nameImageMap.insert( fileName, image );
 123                         return image;
 124                 }
 125         }
 126
 127         return QImage();
 128 }
 129
 130 void    Style::Manager::clearImages( )
 131 {
 132         _nameImageMap.clear( );
 133 }
 134 //-----------------------------------------------------------------------------
 135
 136
 137
 138 /* Attribute Management *///---------------------------------------------------
 139 void    Style::add( QString name, QVariant variant )
 140 {
 141         _nameValueMap.insert( name, variant );
 142         reset( );       // Force coherent Interview update whitout using (begin/end)Insert()
 143         emit modified( );
 144 }
 145
 146 void    Style::remove( QString name )
 147 {
 148         _nameValueMap.remove( name );
 149         _imageNames.removeAll( name );
 150         reset( );       // Force coherent Interview update whitout using (begin/end)Insert()
 151         emit modified( );
 152 }
 153
 154 /*!
 155         \return true if the attribute has been renamed, false otherwise (for example, the name was already used by another attribute).
 156  */
 157 bool    Style::rename( QString name, QString newName )
 158 {
 159         if ( has( newName ) )
 160                 return false;
 161
 162         QVariant value = get( name );
 163         remove( name );
 164         add( newName, value );
 165         reset( );       // Force coherent Interview update
 166         return true;
 167 }
 168
 169 /*!
 170         \return true if a QVariant is registered under the given name, false otherwise.
 171  */
 172 bool            Style::has( QString name ) const
 173 {
 174         NameValueMap::const_iterator nameIter = _nameValueMap.find( name );
 175         return ( nameIter != _nameValueMap.end( ) );
 176 }
 177
 178 /*!
 179         \return A QVariant registered under a given name, or an invalid QVariant if the name is unknown.
 180  */
 181 QVariant        Style::get( QString name )
 182 {
 183         return _nameValueMap.value( name, QVariant( ) );
 184 }
 185
 186 /*!
 187         \return A const QVariant registered under a given name, or an invalid QVariant if the name is unknown.
 188  */
 189 const QVariant  Style::get( QString name ) const
 190 {
 191         /*QVariant result;
 192         NameValueMap::const_iterator nameIter = _nameValueMap.find( name );
 193         if ( nameIter != _nameValueMap.end( ) )
 194                 result = nameIter->second;
 195         return result;*/
 196         return _nameValueMap.value( name, QVariant( ) );
 197 }
 198
 199 void            Style::addColor( QString name, int r, int g, int b )
 200 {
 201         QVariant value;
 202         value = QColor( r, g, b ); // QVariant does not support QColor in its ctor (non gui only types)
 203         add( name, value );
 204 }
 205
 206 /*!
 207         \return The color registered with name, an invalid Qcolor otherwise.
 208  */
 209 QColor          Style::getColor( QString name ) const
 210 {
 211         QColor color;
 212         const QVariant& value = get( name );
 213         if ( value.isValid( ) )
 214                 color = value.value< QColor >( );
 215         return color;
 216 }
 217
 218 void            Style::addIcon( QString name, QIcon& icon )
 219 {
 220         QVariant value;
 221         value = icon; // QVariant does not support gui types in its ctor
 222         add( name, value );
 223 }
 224
 225 QIcon           Style::getIcon( QString name ) const
 226 {
 227         QIcon icon;
 228         const QVariant& value = get( name );
 229         if ( value.isValid( ) )
 230                 icon = value.value< QIcon >( );
 231         return icon;
 232 }
 233
 234 void            Style::addImage( QString name, QImage image )
 235 {
 236         QVariant value;
 237         value = image; // QVariant does not support gui types in its ctor
 238         add( name, value );
 239 }
 240
 241 void            Style::addImageName( QString name, QString fileName )
 242 {
 243         add( name, QVariant( fileName ) );
 244         _imageNames.push_back( name );
 245 }
 246 bool            Style::hasImageName( QString name ) const
 247 {
 248         return ( _imageNames.contains( name ) );
 249 }
 250
 251 QString         Style::getImageName( QString name ) const
 252 {
 253         if ( hasImageName( name ) ) // Check if name is an image name type
 254         {
 255                 QVariant imageName = get( name );
 256                 if ( imageName.type( ) == QVariant::String )
 257                         return imageName.toString( );
 258         }
 259         return QString( );
 260 }
 261 //-----------------------------------------------------------------------------
 262
 263
 264
 265 /* Qt Model Interface *///-----------------------------------------------------
 266 QVariant        Style::data( const QModelIndex& index, int role ) const
 267 {
 268         if ( !index.isValid( ) )
 269                 return QVariant( "index invalid" );
 270
 271         QVariant d;
 272
 273         if ( ( role == Qt::FontRole ) && ( index.column( ) == 0 ) )
 274         {
 275                 QFont font;
 276                 font.setWeight( QFont::Bold );
 277                 d = font;
 278         }
 279
 280         if ( role == Qt::DisplayRole )
 281         {
 282                 if ( index.column( ) == 0 )
 283                 {
 284                         if ( index.row( ) == 0 )
 285                                 d =     QString( "name" );
 286                         else
 287                                 d = _nameValueMap.keys( ).at( index.row( ) - 1 );
 288                 }
 289                 else if ( index.column( ) == 1 )
 290                 {
 291                         if ( index.row( ) == 0 )
 292                                 d =     getName( );
 293                         else
 294                                 d = _nameValueMap.values( ).at( index.row( ) - 1 );
 295                 }
 296         }
 297
 298         return d;
 299 }
 300
 301 bool                    Style::setData( const QModelIndex& index, const QVariant& value, int role )
 302 {
 303         if ( index.row( ) == 1 )
 304                 return QAbstractListModel::setData( index, value, role );
 305
 306         if ( role == Qt::EditRole && index.column( ) == 1 )     // Edit values
 307         {
 308                 QString         k = _nameValueMap.keys( ).at( index.row( ) - 1 );
 309                 QVariant        v = _nameValueMap.values( ).at( index.row( ) - 1 );
 310                 if ( v.type( ) == value.type( ) )
 311                 {
 312                         v = value;
 313                         _nameValueMap.insert( k, v );
 314                         emit dataChanged( index, index );
 315                         emit modified( );
 316                         return true;
 317                 }
 318         }
 319         if ( role == Qt::EditRole && index.column( ) == 0 )     // Edit names
 320         {
 321                 if ( value.type( ) == QVariant::String )
 322                 {
 323                         QString k = _nameValueMap.keys( ).at( index.row( ) - 1 );
 324                         if ( rename( k, value.toString( ) ) )                   // Rename old name with the editor content and eventually validate the input
 325                         {
 326                                 emit dataChanged( index, index );
 327                                 emit modified( );
 328                                 return true;
 329                         }
 330                 }
 331         }
 332         return QAbstractListModel::setData( index, value, role );
 333 }
 334
 335 Qt::ItemFlags   Style::flags( const QModelIndex &index ) const
 336 {
 337         if ( !index.isValid( ) )
 338                 return Qt::ItemIsEnabled;
 339
 340         if ( index.row( ) == 0 )
 341                 return Qt::ItemIsEnabled | Qt::ItemIsSelectable;   // First row (style name) is not editable
 342         else
 343                 return Qt::ItemIsEnabled | Qt::ItemIsEditable;  // Other rows are editable in both the name and value columns
 344
 345         return Qt::ItemIsEnabled;
 346 }
 347
 348 QVariant        Style::headerData( int section, Qt::Orientation orientation, int role ) const
 349 {
 350         if ( orientation == Qt::Horizontal && role == Qt::DisplayRole )
 351         {
 352                 if ( section == 0 )
 353                         return QString( "Property" );
 354                 else if ( section == 1 )
 355                         return QString( "Value" );
 356         }
 357         return QVariant( );
 358 }
 359
 360 int     Style::rowCount( const QModelIndex& parent ) const
 361 {
 362         return 1 + size( );
 363 }
 364
 365 int     Style::columnCount( const QModelIndex& parent ) const
 366 {
 367         return 2;
 368 }
 369 //-----------------------------------------------------------------------------
 370
 371
 372 } // ::qan
 373