src/Qtx/QtxPreferenceMgr.cxx

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