src/Qtx/QtxPreferenceMgr.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 // File:      QtxPreferenceMgr.cxx
  23 // Author:    Sergey TELKOV
  24 //
  25 #include "QtxPreferenceMgr.h"
  26
  27 #include "QtxResourceMgr.h"
  28
  29 #include <QEvent>
  30 #include <QApplication>
  31
  32 /*!
  33   \class QtxPreferenceItem::Updater
  34   \brief Preference item updater.
  35   \internal
  36 */
  37
  38 class QtxPreferenceItem::Updater : public QObject
  39 {
  40   Updater();
  41 public:
  42   ~Updater();
  43
  44   static Updater*           instance();
  45
  46   void                      updateItem( QtxPreferenceItem* );
  47   void                      removeItem( QtxPreferenceItem* );
  48
  49 protected:
  50   virtual void              customEvent( QEvent* );
  51
  52 private:
  53   QList<QtxPreferenceItem*> myItems;
  54   static Updater*           _Updater;
  55 };
  56
  57 QtxPreferenceItem::Updater* QtxPreferenceItem::Updater::_Updater = 0;
  58
  59 /*!
  60   \brief Constructor.
  61   \internal
  62 */
  63 QtxPreferenceItem::Updater::Updater()
  64 {
  65 }
  66
  67 /*!
  68   \brief Destructor.
  69   \internal
  70 */
  71 QtxPreferenceItem::Updater::~Updater()
  72 {
  73 }
  74
  75 /*!
  76   \brief Get the only updater instance.
  77   \internal
  78   \return the only updater instance
  79 */
  80 QtxPreferenceItem::Updater* QtxPreferenceItem::Updater::instance()
  81 {
  82   if ( !_Updater )
  83     _Updater = new Updater();
  84   return _Updater;
  85 }
  86
  87 /*!
  88   \brief Update the preference item.
  89   \internal
  90   \param item preference item to be updated
  91 */
  92 void QtxPreferenceItem::Updater::updateItem( QtxPreferenceItem* item )
  93 {
  94   if ( !item || myItems.contains( item ) )
  95     return;
  96
  97   myItems.append( item );
  98   QApplication::postEvent( this, new QEvent( QEvent::User ) );
  99 }
 100
 101 /*!
 102   \brief Called when preference item is removed.
 103   \internal
 104   \param item preference item being removed
 105 */
 106 void QtxPreferenceItem::Updater::removeItem( QtxPreferenceItem* item )
 107 {
 108   myItems.removeAll( item );
 109 }
 110
 111 /*!
 112   \brief Custom events provessing. Updates all the items.
 113   \internal
 114   \param e custom event (not used)
 115 */
 116 void QtxPreferenceItem::Updater::customEvent( QEvent* /*e*/ )
 117 {
 118   QList<QtxPreferenceItem*> lst = myItems;
 119   for ( QList<QtxPreferenceItem*>::const_iterator it = lst.begin(); it != lst.end(); ++it )
 120     (*it)->updateContents();
 121 }
 122
 123 /*!
 124   \class QtxPreferenceItem
 125   \brief Base class for implementing of all the preference items.
 126
 127   To implement any specific preference item, cubclass from the
 128   QtxPreferenceItem and redefine store() and retrieve() methods.
 129 */
 130
 131 /*!
 132   \brief Constructor.
 133   \param parent parent preference item
 134 */
 135 QtxPreferenceItem::QtxPreferenceItem( QtxPreferenceItem* parent )
 136 : myParent( 0 ),
 137 myEval( true )
 138 {
 139   myId = generateId();
 140
 141   if ( parent )
 142     parent->insertItem( this );
 143 }
 144
 145 /*!
 146   \brief Constructor.
 147   \param title item title
 148   \param parent parent preference item
 149 */
 150 QtxPreferenceItem::QtxPreferenceItem( const QString& title, QtxPreferenceItem* parent )
 151 : myParent( 0 ),
 152   myTitle( title )
 153 {
 154   myId = generateId();
 155
 156   if ( parent )
 157     parent->insertItem( this );
 158 }
 159
 160 /*!
 161   \brief Constructor.
 162   \param title item title
 163   \param sect resource file section to be associated with the item
 164   \param param resource file parameter to be associated with the item
 165   \param parent parent preference item
 166 */
 167 QtxPreferenceItem::QtxPreferenceItem( const QString& title, const QString& sect,
 168                                       const QString& param, QtxPreferenceItem* parent )
 169 : myParent( 0 ),
 170   myTitle( title ),
 171   mySection( sect ),
 172   myParameter( param )
 173 {
 174   myId = generateId();
 175
 176   if ( parent )
 177     parent->insertItem( this );
 178 }
 179
 180 /*!
 181   \brief Destructor.
 182 */
 183 QtxPreferenceItem::~QtxPreferenceItem()
 184 {
 185   ItemList list = myChildren;
 186   myChildren.clear();
 187   qDeleteAll( list );
 188
 189   if ( myParent )
 190     myParent->removeItem( this );
 191
 192   Updater::instance()->removeItem( this );
 193 }
 194
 195 /*!
 196   \brief Get unique item identifier.
 197   \return item ID
 198 */
 199 int QtxPreferenceItem::id() const
 200 {
 201   return myId;
 202 }
 203
 204 /*!
 205   \brief Get unique item type identifier.
 206   \return item type ID
 207 */
 208 int QtxPreferenceItem::rtti() const
 209 {
 210   return QtxPreferenceItem::RTTI();
 211 }
 212
 213 /*!
 214   \brief Specify unique item class identifier.
 215   \return item class ID
 216 */
 217 int QtxPreferenceItem::RTTI()
 218 {
 219   return 1;
 220 }
 221
 222 /*!
 223   \brief Get root preference item.
 224   \return root item
 225 */
 226 QtxPreferenceItem* QtxPreferenceItem::rootItem() const
 227 {
 228   QtxPreferenceItem* item = (QtxPreferenceItem*)this;
 229   while ( item->parentItem() )
 230     item = item->parentItem();
 231   return item;
 232 }
 233
 234 /*!
 235   \brief Get parent preference item.
 236   \return parent item
 237 */
 238 QtxPreferenceItem* QtxPreferenceItem::parentItem() const
 239 {
 240   return myParent;
 241 }
 242
 243 /*!
 244   \brief Append child preference item.
 245
 246   Removes (if necessary) the item from the previous parent.
 247
 248   \param item item to be added
 249   \sa removeItem()
 250 */
 251 void QtxPreferenceItem::appendItem( QtxPreferenceItem* item )
 252 {
 253   insertItem( item, 0 );
 254 }
 255
 256 /*!
 257   \brief Insert child preference item before specified item.
 258   If the before item is 0 then new item is appended.
 259
 260   Removes (if necessary) the item from the previous parent.
 261
 262   \param item item to be added
 263   \param before item before which is inserted new \aitem
 264   \sa removeItem()
 265 */
 266 void QtxPreferenceItem::insertItem( QtxPreferenceItem* item, QtxPreferenceItem* before )
 267 {
 268   if ( !item )
 269     return;
 270
 271   if ( myChildren.contains( item ) && item == before )
 272     return;
 273
 274   if ( myChildren.contains( item ) )
 275     myChildren.removeAll( item );
 276
 277   int idx = myChildren.indexOf( before );
 278   if ( idx < 0 )
 279     idx = myChildren.count();
 280
 281   if ( item->parentItem() && item->parentItem() != this )
 282     item->parentItem()->removeItem( item );
 283
 284   item->myParent = this;
 285   myChildren.insert( idx, item );
 286
 287   itemAdded( item );
 288 }
 289
 290 /*!
 291   \brief Remove child preference item.
 292   \param item item to be removed
 293   \sa insertItem()
 294 */
 295 void QtxPreferenceItem::removeItem( QtxPreferenceItem* item )
 296 {
 297   if ( !item || !myChildren.contains( item ) )
 298     return;
 299
 300   item->myParent = 0;
 301   myChildren.removeAll( item );
 302
 303   itemRemoved( item );
 304 }
 305
 306 /*!
 307   \brief Get all child preference items.
 308   \param rec recursion boolean flag
 309   \return list of child items
 310 */
 311 QList<QtxPreferenceItem*> QtxPreferenceItem::childItems( const bool rec ) const
 312 {
 313   QList<QtxPreferenceItem*> lst = myChildren;
 314   if ( rec )
 315   {
 316     for ( ItemList::const_iterator it = myChildren.begin(); it != myChildren.end(); ++it )
 317       lst += (*it)->childItems( rec );
 318   }
 319
 320   return lst;
 321 }
 322
 323 /*!
 324   \brief Get preference item depth.
 325   \return item depth
 326 */
 327 int QtxPreferenceItem::depth() const
 328 {
 329   return parentItem() ? parentItem()->depth() + 1 : 0;
 330 }
 331
 332 /*!
 333   \brief Get child preference items number.
 334   \return number of child items
 335   \sa isEmpty()
 336 */
 337 int QtxPreferenceItem::count() const
 338 {
 339   return myChildren.count();
 340 }
 341
 342 /*!
 343   \brief Check if the item has children.
 344   \return \c true if item does not have children
 345   \sa count()
 346 */
 347 bool QtxPreferenceItem::isEmpty() const
 348 {
 349   return myChildren.isEmpty();
 350 }
 351
 352 /*!
 353   \brief Get preference item icon.
 354   \return item icon
 355   \sa setIcon()
 356 */
 357 QIcon QtxPreferenceItem::icon() const
 358 {
 359   return myIcon;
 360 }
 361
 362 /*!
 363   \brief Get preference item title.
 364   \return item title
 365   \sa setTitle()
 366 */
 367 QString QtxPreferenceItem::title() const
 368 {
 369   return myTitle;
 370 }
 371
 372 /*!
 373   \brief Get resource file settings associated to the preference item.
 374   \param sec used to return resource file section name
 375   \param param used to return resource file parameter name
 376   \sa setResource()
 377 */
 378 void QtxPreferenceItem::resource( QString& sec, QString& param ) const
 379 {
 380   sec = mySection;
 381   param = myParameter;
 382 }
 383
 384 /*!
 385   \brief Set prefence item icon.
 386   \param ico new item icon
 387   \sa icon()
 388 */
 389 void QtxPreferenceItem::setIcon( const QIcon& ico )
 390 {
 391   if ( myIcon.serialNumber() == ico.serialNumber() )
 392     return;
 393
 394   myIcon = ico;
 395   sendItemChanges();
 396 }
 397
 398 /*!
 399   \brief Set preference item title .
 400   \param title new item title
 401   \sa title()
 402 */
 403 void QtxPreferenceItem::setTitle( const QString& title )
 404 {
 405   if ( myTitle == title )
 406     return;
 407
 408   myTitle = title;
 409   sendItemChanges();
 410 }
 411
 412 /*!
 413   \brief Assign resource file settings to the preference item.
 414   \param sec resource file section name
 415   \param param resource file parameter name
 416   \sa resource()
 417 */
 418 void QtxPreferenceItem::setResource( const QString& sec, const QString& param )
 419 {
 420   mySection = sec;
 421   myParameter = param;
 422 }
 423
 424 /*!
 425   \brief Update preference item.
 426 */
 427 void QtxPreferenceItem::updateContents()
 428 {
 429   Updater::instance()->removeItem( this );
 430 }
 431
 432 /*!
 433   \brief Get preference item option value.
 434   \param name option name
 435   \return property value or null QVariant if option is not set
 436   \sa setOption()
 437 */
 438 QVariant QtxPreferenceItem::option( const QString& name ) const
 439 {
 440   return optionValue( name.toLower() );
 441 }
 442
 443 /*!
 444   \brief Set preference item option value.
 445   \param name option name
 446   \param val new property value
 447   \sa option()
 448 */
 449 void QtxPreferenceItem::setOption( const QString& name, const QVariant& val )
 450 {
 451   QVariant old = optionValue( name.toLower() );
 452   setOptionValue( name.toLower(), val );
 453   if ( old != optionValue( name.toLower() ) )
 454     sendItemChanges();
 455 }
 456
 457 bool QtxPreferenceItem::isEvaluateValues() const
 458 {
 459   return myEval;
 460 }
 461
 462 void QtxPreferenceItem::setEvaluateValues( const bool on )
 463 {
 464   myEval = on;
 465 }
 466
 467 /*!
 468   \fn void QtxPreferenceItem::store();
 469   \brief Save preference item (for example, to the resource file).
 470
 471   This method should be implemented in the subclasses.
 472
 473   \sa retrieve()
 474 */
 475
 476 /*!
 477   \fn virtual void QtxPreferenceItem::retrieve();
 478   \brief Restore preference item (for example, from the resource file).
 479
 480   This method should be implemented in the subclasses.
 481
 482   \sa store()
 483 */
 484
 485 /*!
 486   \brief Get the value of the associated resource file setting.
 487   \return associated resource file setting value
 488   \sa setResourceValue()
 489 */
 490 QString QtxPreferenceItem::resourceValue() const
 491 {
 492   return getString();
 493 }
 494
 495 /*!
 496   \brief Get the value of the associated resource file setting.
 497   \param val new associated resource file setting value
 498   \sa resourceValue()
 499 */
 500 void QtxPreferenceItem::setResourceValue( const QString& val )
 501 {
 502   setString( val );
 503 }
 504
 505 /*!
 506   \brief Get the resources manager.
 507   \return resource manager pointer or 0 if it is not defined
 508 */
 509 QtxResourceMgr* QtxPreferenceItem::resourceMgr() const
 510 {
 511   QtxPreferenceMgr* mgr = preferenceMgr();
 512   return mgr ? mgr->resourceMgr() : 0;
 513 }
 514
 515 /*!
 516   \brief Get the parent preferences manager.
 517   \return preferences manager or 0 if it is not defined
 518 */
 519 QtxPreferenceMgr* QtxPreferenceItem::preferenceMgr() const
 520 {
 521   return parentItem() ? parentItem()->preferenceMgr() : 0;
 522 }
 523
 524 /*!
 525   \brief Find the item by the specified identifier.
 526   \param id child item ID
 527   \param rec if \c true recursive search is done
 528   \return child item or 0 if it is not found
 529 */
 530 QtxPreferenceItem* QtxPreferenceItem::findItem( const int id, const bool rec ) const
 531 {
 532   QtxPreferenceItem* item = 0;
 533   for ( ItemList::const_iterator it = myChildren.begin(); it != myChildren.end() && !item; ++it )
 534   {
 535     QtxPreferenceItem* i = *it;
 536     if ( i->id() == id )
 537       item = i;
 538     else if ( rec )
 539       item = i->findItem( id, rec );
 540   }
 541   return item;
 542 }
 543
 544 /*!
 545   \brief Find the item by the specified title.
 546   \param title child item title
 547   \param rec if \c true recursive search is done
 548   \return child item or 0 if it is not found
 549 */
 550 QtxPreferenceItem* QtxPreferenceItem::findItem( const QString& title, const bool rec ) const
 551 {
 552   QtxPreferenceItem* item = 0;
 553   for ( ItemList::const_iterator it = myChildren.begin(); it != myChildren.end() && !item; ++it )
 554   {
 555     QtxPreferenceItem* i = *it;
 556     if ( i->title() == title )
 557       item = i;
 558     else if ( rec )
 559       item = i->findItem( title, rec );
 560   }
 561   return item;
 562 }
 563
 564 /*!
 565   \brief Find the item by the specified title and identifier.
 566   \param title child item title
 567   \param id child item ID
 568   \param rec if \c true recursive search is done
 569   \return child item or 0 if it is not found
 570 */
 571 QtxPreferenceItem* QtxPreferenceItem::findItem( const QString& title, const int id, const bool rec ) const
 572 {
 573   QtxPreferenceItem* item = 0;
 574   for ( ItemList::const_iterator it = myChildren.begin(); it != myChildren.end() && !item; ++it )
 575   {
 576     QtxPreferenceItem* i = *it;
 577     if ( i->title() == title && i->id() == id )
 578       item = i;
 579     else if ( rec )
 580       item = i->findItem( title, id, rec );
 581   }
 582   return item;
 583 }
 584
 585 void QtxPreferenceItem::activate()
 586 {
 587 }
 588
 589 void QtxPreferenceItem::ensureVisible()
 590 {
 591   if ( parentItem() )
 592     parentItem()->ensureVisible( this );
 593 }
 594
 595 /*!
 596   \brief Get integer resources value corresponding to the item.
 597   \param val default value (returned if there is no such resource)
 598   \return integer value of the associated resource
 599   \sa setInteger()
 600 */
 601 int QtxPreferenceItem::getInteger( const int val ) const
 602 {
 603   QtxResourceMgr* resMgr = resourceMgr();
 604   return resMgr ? resMgr->integerValue( mySection, myParameter, val ) : val;
 605 }
 606
 607 /*!
 608   \brief Get double resources value corresponding to the item.
 609   \param val default value (returned if there is no such resource)
 610   \return double value of the associated resource
 611   \sa setDouble()
 612 */
 613 double QtxPreferenceItem::getDouble( const double val ) const
 614 {
 615   QtxResourceMgr* resMgr = resourceMgr();
 616   return resMgr ? resMgr->doubleValue( mySection, myParameter, val ) : val;
 617 }
 618
 619 /*!
 620   \brief Get boolean resources value corresponding to the item.
 621   \param val default value (returned if there is no such resource)
 622   \return boolean value of the associated resource
 623   \sa setBoolean()
 624 */
 625 bool QtxPreferenceItem::getBoolean( const bool val ) const
 626 {
 627   QtxResourceMgr* resMgr = resourceMgr();
 628   return resMgr ? resMgr->booleanValue( mySection, myParameter, val ) : val;
 629 }
 630
 631 /*!
 632   \brief Get string resources value corresponding to the item.
 633   \param val default value (returned if there is no such resource)
 634   \return string value of the associated resource
 635   \sa setString()
 636 */
 637 QString QtxPreferenceItem::getString( const QString& val ) const
 638 {
 639   QString res = val;
 640   QtxResourceMgr* resMgr = resourceMgr();
 641   if ( resMgr )
 642     resMgr->value( mySection, myParameter, res, isEvaluateValues() );
 643   return res;
 644 }
 645
 646 /*!
 647   \brief Get color resources value corresponding to the item.
 648   \param val default value (returned if there is no such resource)
 649   \return color value of the associated resource
 650   \sa setColor()
 651 */
 652 QColor QtxPreferenceItem::getColor( const QColor& val ) const
 653 {
 654   QtxResourceMgr* resMgr = resourceMgr();
 655   return resMgr ? resMgr->colorValue( mySection, myParameter, val ) : val;
 656 }
 657
 658 /*!
 659   \brief Get font resources value corresponding to the item.
 660   \param val default value (returned if there is no such resource)
 661   \return font value of the associated resource
 662   \sa setFont()
 663 */
 664 QFont QtxPreferenceItem::getFont( const QFont& val ) const
 665 {
 666   QtxResourceMgr* resMgr = resourceMgr();
 667   return resMgr ? resMgr->fontValue( mySection, myParameter, val ) : val;
 668 }
 669
 670 /*!
 671   \brief Set integer resources value corresponding to the item.
 672   \param val new value
 673   \sa getInteger()
 674 */
 675 void QtxPreferenceItem::setInteger( const int val )
 676 {
 677   QtxResourceMgr* resMgr = resourceMgr();
 678   if ( resMgr )
 679     resMgr->setValue( mySection, myParameter, val );
 680 }
 681
 682 /*!
 683   \brief Set double resources value corresponding to the item.
 684   \param val new value
 685   \sa getDouble()
 686 */
 687 void QtxPreferenceItem::setDouble( const double val )
 688 {
 689   QtxResourceMgr* resMgr = resourceMgr();
 690   if ( resMgr )
 691     resMgr->setValue( mySection, myParameter, val );
 692 }
 693
 694 /*!
 695   \brief Set boolean resources value corresponding to the item.
 696   \param val new value
 697   \sa getBoolean()
 698 */
 699 void QtxPreferenceItem::setBoolean( const bool val )
 700 {
 701   QtxResourceMgr* resMgr = resourceMgr();
 702   if ( resMgr )
 703     resMgr->setValue( mySection, myParameter, val );
 704 }
 705
 706 /*!
 707   \brief Set string resources value corresponding to the item.
 708   \param val new value
 709   \sa getString()
 710 */
 711 void QtxPreferenceItem::setString( const QString& val )
 712 {
 713   QtxResourceMgr* resMgr = resourceMgr();
 714   if ( resMgr )
 715     resMgr->setValue( mySection, myParameter, val );
 716 }
 717
 718 /*!
 719   \brief Set color resources value corresponding to the item.
 720   \param val new value
 721   \sa getColor()
 722 */
 723 void QtxPreferenceItem::setColor( const QColor& val )
 724 {
 725   QtxResourceMgr* resMgr = resourceMgr();
 726   if ( resMgr )
 727     resMgr->setValue( mySection, myParameter, val );
 728 }
 729
 730 /*!
 731   \brief Set font resources value corresponding to the item.
 732   \param val new value
 733   \sa getFont()
 734 */
 735 void QtxPreferenceItem::setFont( const QFont& val )
 736 {
 737   QtxResourceMgr* resMgr = resourceMgr();
 738   if ( resMgr )
 739     resMgr->setValue( mySection, myParameter, val );
 740 }
 741
 742 /*!
 743   \brief Callback function which is called when the child
 744   preference item is added.
 745
 746   This function can be reimplemented in the subclasses to customize
 747   child item addition operation. Base implementation does nothing.
 748
 749   \param item child item being added
 750   \sa itemRemoved(), itemChanged()
 751 */
 752 void QtxPreferenceItem::itemAdded( QtxPreferenceItem* /*item*/ )
 753 {
 754 }
 755
 756 /*!
 757   \brief Callback function which is called when the child
 758   preference item is removed.
 759
 760   This function can be reimplemented in the subclasses to customize
 761   child item removal operation. Base implementation does nothing.
 762
 763   \param item child item being removed
 764   \sa itemAdded(), itemChanged()
 765 */
 766 void QtxPreferenceItem::itemRemoved( QtxPreferenceItem* /*item*/ )
 767 {
 768 }
 769
 770 /*!
 771   \brief Callback function which is called when the child
 772   preference item is modified.
 773
 774   This function can be reimplemented in the subclasses to customize
 775   child item modifying operation. Base implementation does nothing.
 776
 777   \param item child item being modified
 778   \sa itemAdded(), itemRemoved()
 779 */
 780 void QtxPreferenceItem::itemChanged( QtxPreferenceItem* )
 781 {
 782 }
 783
 784 void QtxPreferenceItem::ensureVisible( QtxPreferenceItem* )
 785 {
 786   ensureVisible();
 787 }
 788
 789 /*!
 790   \brief Initiate item updating.
 791 */
 792 void QtxPreferenceItem::triggerUpdate()
 793 {
 794   Updater::instance()->updateItem( this );
 795 }
 796
 797 /*!
 798   \brief Get preference item option value.
 799
 800   This function can be reimplemented in the subclasses.
 801   Base implementation does nothing.
 802
 803   \param name option name
 804   \return property value or null QVariant if option is not set
 805   \sa setOptionValue()
 806 */
 807 QVariant QtxPreferenceItem::optionValue( const QString& name ) const
 808 {
 809   QVariant val;
 810   if ( name == "eval" || name == "evaluation" || name == "subst" || name == "substitution" )
 811     val = isEvaluateValues();
 812   else if ( name == "title" )
 813     val = title();
 814   return val;
 815 }
 816
 817 /*!
 818   \brief Set preference item option value.
 819
 820   This function can be reimplemented in the subclasses.
 821   Base implementation does nothing.
 822
 823   \param name option name
 824   \param val new property value
 825   \sa optionValue()
 826 */
 827 void QtxPreferenceItem::setOptionValue( const QString& name, const QVariant& val )
 828 {
 829   if ( name == "eval" || name == "evaluation" || name == "subst" || name == "substitution" )
 830   {
 831     if ( val.canConvert( QVariant::Bool ) )
 832       setEvaluateValues( val.toBool() );
 833   }
 834   else if ( name == "title" )
 835   {
 836     if ( val.canConvert( QVariant::String ) )
 837       setTitle( val.toString() );
 838   }
 839 }
 840
 841 /*!
 842   \brief Initiate item changing call back operation.
 843 */
 844 void QtxPreferenceItem::sendItemChanges()
 845 {
 846   if ( parentItem() )
 847     parentItem()->itemChanged( this );
 848 }
 849
 850 /*!
 851   \brief Generate unique preference item identifier.
 852   \return unique item ID
 853 */
 854 int QtxPreferenceItem::generateId()
 855 {
 856   static int _id = 0;
 857   return _id++;
 858 }
 859
 860 /*!
 861   \class QtxPreferenceMgr
 862   \brief Class for managing preferences items.
 863 */
 864
 865 /*!
 866   \brief Constructor.
 867   \param mgr resources manager
 868 */
 869 QtxPreferenceMgr::QtxPreferenceMgr( QtxResourceMgr* mgr )
 870 : QtxPreferenceItem( 0 ),
 871   myResMgr( mgr )
 872 {
 873 }
 874
 875 /*!
 876   \brief Destructor.
 877 */
 878 QtxPreferenceMgr::~QtxPreferenceMgr()
 879 {
 880 }
 881
 882 /*!
 883   \brief Get the resources manager.
 884   \return resource manager pointer or 0 if it is not defined
 885 */
 886 QtxResourceMgr* QtxPreferenceMgr::resourceMgr() const
 887 {
 888   return myResMgr;
 889 }
 890
 891 /*!
 892   \brief Get the parent preferences manager.
 893   \return pointer to itself
 894 */
 895 QtxPreferenceMgr* QtxPreferenceMgr::preferenceMgr() const
 896 {
 897   return (QtxPreferenceMgr*)this;
 898 }
 899
 900 /*!
 901   \brief Get preference item option value.
 902   \param id preference item ID
 903   \param propName option name
 904   \return property value or null QVariant if option is not set
 905   \sa setOption()
 906 */
 907 QVariant QtxPreferenceMgr::option( const int id, const QString& propName ) const
 908 {
 909   QVariant propValue;
 910   QtxPreferenceItem* i = findItem( id, true );
 911   if ( i )
 912     propValue = i->option( propName );
 913   return propValue;
 914 }
 915
 916 /*!
 917   \brief Set preference item option value.
 918   \param id preference item ID
 919   \param propName option name
 920   \param propValue new property value
 921   \sa option()
 922 */
 923 void QtxPreferenceMgr::setOption( const int id, const QString& propName, const QVariant& propValue )
 924 {
 925   QtxPreferenceItem* i = findItem( id, true );
 926   if ( i )
 927     i->setOption( propName, propValue );
 928 }
 929
 930 /*!
 931   \brief Store all preferences item to the resource manager.
 932   \sa retrieve()
 933 */
 934 void QtxPreferenceMgr::store()
 935 {
 936   ResourceMap before;
 937   resourceValues( before );
 938
 939   QList<QtxPreferenceItem*> items = childItems( true );
 940   for ( QList<QtxPreferenceItem*>::iterator it = items.begin(); it != items.end(); ++it )
 941     (*it)->store();
 942
 943   ResourceMap after;
 944   resourceValues( after );
 945
 946   ResourceMap changed;
 947   differentValues( before, after, changed );
 948
 949   changedResources( changed );
 950 }
 951
 952 /*!
 953   \brief Retrieve all preference items from the resource manager.
 954   \sa store()
 955 */
 956 void QtxPreferenceMgr::retrieve()
 957 {
 958   QList<QtxPreferenceItem*> items = childItems( true );
 959   for ( QList<QtxPreferenceItem*>::iterator it = items.begin(); it != items.end(); ++it )
 960     (*it)->retrieve();
 961 }
 962
 963 /*!
 964   \brief Dumps all values to the backup container.
 965   \sa fromBackup()
 966 */
 967 void QtxPreferenceMgr::toBackup()
 968 {
 969   myBackup.clear();
 970   resourceValues( myBackup );
 971 }
 972
 973 /*!
 974   \brief Restore all values from the backup container.
 975   \sa toBackup()
 976 */
 977 void QtxPreferenceMgr::fromBackup()
 978 {
 979   ResourceMap before;
 980   resourceValues( before );
 981
 982   setResourceValues( myBackup );
 983
 984   ResourceMap after;
 985   resourceValues( after );
 986
 987   ResourceMap changed;
 988   differentValues( before, after, changed );
 989
 990   changedResources( changed );
 991 }
 992
 993 /*!
 994   \brief Update preferences manager.
 995
 996   Base implementation does nothing.
 997 */
 998 void QtxPreferenceMgr::update()
 999 {
1000 }
1001
1002 /*!
1003   \brief Get all resources items values.
1004   \param map used as container filled with the resources values (<ID>:<value>)
1005   \sa setResourceValues()
1006 */
1007 void QtxPreferenceMgr::resourceValues( QMap<int, QString>& map ) const
1008 {
1009   QString sect, name;
1010   QtxResourceMgr* resMgr = resourceMgr();
1011   QList<QtxPreferenceItem*> items = childItems( true );
1012   for ( QList<QtxPreferenceItem*>::const_iterator it = items.begin(); it != items.end(); ++it )
1013   {
1014     QtxPreferenceItem* item = *it;
1015     item->resource( sect, name );
1016     if ( resMgr->hasValue( sect, name ) )
1017       map.insert( item->id(), item->resourceValue() );
1018   }
1019 }
1020
1021 /*!
1022   \brief Get all resources items values.
1023   \param map used as container filled with the resources values
1024   (<item>:<value>)
1025   \sa setResourceValues()
1026 */
1027 void QtxPreferenceMgr::resourceValues( ResourceMap& map ) const
1028 {
1029   QString sect, name;
1030   QtxResourceMgr* resMgr = resourceMgr();
1031   QList<QtxPreferenceItem*> items = childItems( true );
1032   for ( QList<QtxPreferenceItem*>::const_iterator it = items.begin(); it != items.end(); ++it )
1033   {
1034     QtxPreferenceItem* item = *it;
1035     item->resource( sect, name );
1036     if ( resMgr->hasValue( sect, name ) )
1037       map.insert( item, item->resourceValue() );
1038   }
1039 }
1040
1041 /*!
1042   \brief Set all resources items values.
1043   \param map map with resources values (<ID>:<value>)
1044   \sa resourceValues()
1045 */
1046 void QtxPreferenceMgr::setResourceValues( QMap<int, QString>& map ) const
1047 {
1048   for ( QMap<int, QString>::const_iterator it = map.begin(); it != map.end(); ++it )
1049   {
1050     QtxPreferenceItem* i = findItem( it.key(), true );
1051     if ( i )
1052       i->setResourceValue( it.value() );
1053   }
1054 }
1055
1056 /*!
1057   \brief Set all resources items values.
1058   \param map map with resources values (<item>:<value>)
1059   \sa resourceValues()
1060 */
1061 void QtxPreferenceMgr::setResourceValues( ResourceMap& map ) const
1062 {
1063   for ( ResourceMap::const_iterator it = map.begin(); it != map.end(); ++it )
1064     it.key()->setResourceValue( it.value() );
1065 }
1066
1067 /*!
1068   \brief Compare two maps of resources values to find differences.
1069   \param map1 first map
1070   \param map2 second map
1071   \param resMap map to be filled with different values
1072   \param fromFirst if \c true, then \a resMap will be filled with the values
1073   from \a map1, otherwise - from \a map2
1074 */
1075 void QtxPreferenceMgr::differentValues( const QMap<int, QString>& map1, const QMap<int, QString>& map2,
1076                                         QMap<int, QString>& resMap, const bool fromFirst ) const
1077 {
1078   resMap.clear();
1079   const QMap<int, QString>& later = fromFirst ? map1 : map2;
1080   const QMap<int, QString>& early = fromFirst ? map2 : map1;
1081
1082   for ( QMap<int, QString>::const_iterator it = later.begin(); it != later.end(); ++it )
1083   {
1084     if ( !early.contains( it.key() ) || early[it.key()] != it.value() )
1085       resMap.insert( it.key(), it.value() );
1086   }
1087 }
1088
1089 /*!
1090   \brief Compare two maps of resources values to find differences.
1091   \param map1 first map
1092   \param map2 second map
1093   \param resMap map to be filled with different values
1094   \param fromFirst if \c true, then \a resMap will be filled with the values
1095   from \a map1, otherwise - from \a map2
1096 */
1097 void QtxPreferenceMgr::differentValues( const ResourceMap& map1, const ResourceMap& map2,
1098                                         ResourceMap& resMap, const bool fromFirst ) const
1099 {
1100   resMap.clear();
1101   const ResourceMap& later = fromFirst ? map1 : map2;
1102   const ResourceMap& early = fromFirst ? map2 : map1;
1103
1104   for ( ResourceMap::const_iterator it = later.begin(); it != later.end(); ++it )
1105   {
1106     if ( !early.contains( it.key() ) || early[it.key()] != it.value() )
1107       resMap.insert( it.key(), it.value() );
1108   }
1109 }
1110
1111 /*!
1112   \brief Perform custom activity on resource changing.
1113
1114   This method is called from store() and fromBackup() methods.
1115   Base implementation does nothing.
1116
1117   \sa store(), fromBackup()
1118 */
1119 void QtxPreferenceMgr::changedResources( const ResourceMap& )
1120 {
1121 }