src/Qtx/QtxListResourceEdit.cxx

   1 // Copyright (C) 2005  OPEN CASCADE, CEA/DEN, EDF R&D, PRINCIPIA R&D
   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.
   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/
  18 //
  19 // File:      QtxListResourceEdit.cxx
  20 // Author:    Sergey TELKOV
  21
  22 #include "QtxListResourceEdit.h"
  23
  24 #include <qhbox.h>
  25 #include <qvbox.h>
  26 #include <qlabel.h>
  27 #include <qlayout.h>
  28 #include <qlistbox.h>
  29 #include <qcombobox.h>
  30 #include <qlineedit.h>
  31 #include <qcheckbox.h>
  32 #include <qtabwidget.h>
  33 #include <qvalidator.h>
  34 #include <qobjectlist.h>
  35 #include <qcolordialog.h>
  36 #include <qwidgetstack.h>
  37 #include <qtoolbutton.h>
  38 #include <qfontdialog.h>
  39 #include <qfontdatabase.h>
  40 #include <qfileinfo.h>
  41 #include <qfiledialog.h>
  42
  43 #include "QtxIntSpinBox.h"
  44 #include "QtxDblSpinBox.h"
  45 #include "QtxComboBox.h"
  46 #include "QtxDirListEditor.h"
  47
  48 /*
  49   Class: QtxListResourceEdit
  50   Descr: GUI implementation of QtxResourceEdit - manager of resources
  51 */
  52
  53 QtxListResourceEdit::QtxListResourceEdit( QtxResourceMgr* mgr, QWidget* parent )
  54 : QFrame( parent ),
  55 QtxResourceEdit( mgr )
  56 {
  57   QVBoxLayout* main = new QVBoxLayout( this, 0, 5 );
  58   QGroupBox* base = new QGroupBox( 1, Qt::Vertical, "", this );
  59   base->setFrameStyle( QFrame::NoFrame );
  60   base->setInsideMargin( 0 );
  61   main->addWidget( base );
  62
  63   myList  = new QListBox( base );
  64   myStack = new QWidgetStack( base );
  65
  66   myList->setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Expanding ) );
  67   myStack->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
  68
  69   myList->setSelectionMode( QListBox::Single );
  70
  71   connect( myList, SIGNAL( selectionChanged() ), this, SLOT( onSelectionChanged() ) );
  72
  73   setFocusProxy( myList );
  74
  75   updateState();
  76 }
  77
  78 QtxListResourceEdit::~QtxListResourceEdit()
  79 {
  80 }
  81
  82 void QtxListResourceEdit::setItemProperty( const int id, const QString& prop, const QVariant& val )
  83 {
  84   Item* i = item( id );
  85   if ( !i )
  86     return;
  87
  88   bool prev = i->isEmpty();
  89
  90   QtxResourceEdit::setItemProperty( id, prop, val );
  91
  92   bool next = i->isEmpty();
  93
  94   if ( prev != next )
  95     updateVisible();
  96 }
  97
  98 void QtxListResourceEdit::onSelectionChanged()
  99 {
 100   QString title = myList->text( myList->index( myList->selectedItem() ) );
 101   if ( title.isEmpty() )
 102     return;
 103
 104   Item* i = 0;
 105   QPtrList<Item> lst;
 106   childItems( lst );
 107   for ( QPtrListIterator<Item> it( lst ); it.current() && !i; ++it )
 108   {
 109     if ( it.current()->title() == title )
 110       i = it.current();
 111   }
 112
 113   if ( i )
 114     myStack->raiseWidget( i->id() );
 115 }
 116
 117 void QtxListResourceEdit::itemAdded( QtxResourceEdit::Item* i )
 118 {
 119   if ( !i )
 120     return;
 121
 122   QPtrList<Item> items;
 123   childItems( items );
 124
 125   if ( items.contains( i ) || items.contains( i->parentItem() ) )
 126     updateVisible();
 127 }
 128
 129 QtxResourceEdit::Item* QtxListResourceEdit::createItem( const QString& title, const int )
 130 {
 131   Item* i = item( title, -1 );
 132   if ( i )
 133     return i;
 134
 135   Category* category = new Category( this, myStack );
 136   myStack->addWidget( category, category->id() );
 137
 138   updateVisible();
 139
 140   if ( !myList->selectedItem() )
 141     myList->setSelected( 0, true );
 142
 143   updateState();
 144
 145   return category;
 146 }
 147
 148 void QtxListResourceEdit::changedResources( const QMap<Item*, QString>& map )
 149 {
 150   QMap<int, QString> idMap;
 151   for ( QMap<Item*, QString>::ConstIterator it = map.begin(); it != map.end(); ++it )
 152   {
 153     idMap.insert( it.key()->id(), it.data() );
 154
 155     emit resourceChanged( it.key()->id() );
 156
 157     QString sec, param;
 158     it.key()->resource( sec, param );
 159     emit resourceChanged( sec, param );
 160   }
 161
 162   emit resourcesChanged( idMap );
 163 }
 164
 165 void QtxListResourceEdit::updateState()
 166 {
 167   if ( myList->selectedItem() &&  myStack->visibleWidget() )
 168     myStack->show();
 169   else
 170     myStack->hide();
 171
 172   myList->setShown( myList->count() > 1 );
 173 }
 174
 175 void QtxListResourceEdit::updateVisible()
 176 {
 177   QPtrList<Item> items;
 178   childItems( items );
 179
 180   QString name = myList->text( myList->index( myList->selectedItem() ) );
 181
 182   myList->clear();
 183   for ( QPtrListIterator<Item> it( items ); it.current(); ++it )
 184   {
 185     if ( it.current()->isEmpty() )
 186       continue;
 187
 188     myList->insertItem( it.current()->title() );
 189   }
 190
 191   int idx = -1;
 192   for ( int i = 0; i < (int)myList->count() && idx == -1; i++ )
 193   {
 194     if ( myList->text( i ) == name )
 195       idx = i;
 196   }
 197
 198   myList->setSelected( QMAX( idx, 0 ), true );
 199
 200   updateState();
 201 }
 202
 203 /*
 204   Class: QtxListResourceEdit::Category
 205   Descr: GUI implementation of preferences category.
 206 */
 207
 208 QtxListResourceEdit::Category::Category( QtxListResourceEdit* edit, QWidget* parent )
 209 : QFrame( parent ),
 210 Item( edit )
 211 {
 212   QVBoxLayout* main = new QVBoxLayout( this );
 213   QGroupBox* base = new QGroupBox( 1, Qt::Horizontal, "", this );
 214   base->setFrameStyle( QFrame::NoFrame );
 215   base->setInsideMargin( 0 );
 216   main->addWidget( base, 1 );
 217
 218   myTabs = new QTabWidget( base );
 219   myInfo = new QLabel( base );
 220
 221   myInfo->setAlignment( Qt::AlignCenter );
 222   myInfo->setFrameStyle( QFrame::WinPanel | QFrame::Raised );
 223   myInfo->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
 224
 225   updateState();
 226 }
 227
 228 QtxListResourceEdit::Category::~Category()
 229 {
 230 }
 231
 232 bool QtxListResourceEdit::Category::isEmpty() const
 233 {
 234   return Item::isEmpty() && myInfo->text().isEmpty();
 235 }
 236
 237 int QtxListResourceEdit::Category::type() const
 238 {
 239   return -1;
 240 }
 241
 242 void QtxListResourceEdit::Category::store()
 243 {
 244 }
 245
 246 void QtxListResourceEdit::Category::retrieve()
 247 {
 248 }
 249
 250 QVariant QtxListResourceEdit::Category::property( const QString& prop ) const
 251 {
 252   QVariant var;
 253   if ( prop == QString( "information" ) || prop == QString( "info" ) )
 254     var = myInfo->text();
 255   return var;
 256 }
 257
 258 void QtxListResourceEdit::Category::setProperty( const QString& name, const QVariant& var )
 259 {
 260   QVariant prop = var;
 261   if ( !prop.cast( QVariant::String ) )
 262     return;
 263
 264   if ( name == QString( "information" ) || name == QString( "info" ) )
 265     myInfo->setText( prop.toString() );
 266
 267   updateState();
 268 }
 269
 270 QtxResourceEdit::Item* QtxListResourceEdit::Category::createItem( const QString& title, const int )
 271 {
 272   Item* i = item( title, id() );
 273   if ( i )
 274     return i;
 275
 276   Tab* tab = new Tab( resourceEdit(), this, this );
 277   myTabs->addTab( tab, title );
 278
 279   updateState();
 280
 281   return tab;
 282 }
 283
 284 void QtxListResourceEdit::Category::updateState()
 285 {
 286   if ( myTabs->count() )
 287     myTabs->show();
 288   else
 289     myTabs->hide();
 290
 291   if ( !myTabs->count() && !myInfo->text().isEmpty() )
 292     myInfo->show();
 293   else
 294     myInfo->hide();
 295 }
 296
 297 /*
 298   Class: QtxListResourceEdit::Tab
 299   Descr: GUI implementation of resources tab.
 300 */
 301
 302 QtxListResourceEdit::Tab::Tab( QtxResourceEdit* edit, Item* pItem, QWidget* parent )
 303 : QFrame( parent ),
 304 Item( edit, pItem )
 305 {
 306   QVBoxLayout* main = new QVBoxLayout( this );
 307   QVBox* vbox = new QVBox( this );
 308   vbox->setMargin( 5 );
 309   myMainFrame = vbox;
 310   main->addWidget( myMainFrame );
 311   main->addStretch( 1 );
 312 }
 313
 314 QtxListResourceEdit::Tab::~Tab()
 315 {
 316 }
 317
 318 int QtxListResourceEdit::Tab::type() const
 319 {
 320   return -1;
 321 }
 322
 323 void QtxListResourceEdit::Tab::store()
 324 {
 325 }
 326
 327 void QtxListResourceEdit::Tab::retrieve()
 328 {
 329 }
 330
 331 void QtxListResourceEdit::Tab::polish()
 332 {
 333   QFrame::polish();
 334
 335   adjustLabels();
 336 }
 337
 338 QtxResourceEdit::Item* QtxListResourceEdit::Tab::createItem( const QString& title, const int )
 339 {
 340   Item* i = item( title, id() );
 341   if ( i )
 342     return i;
 343
 344   Group* group = new Group( title, resourceEdit(), this, myMainFrame );
 345
 346   return group;
 347 }
 348
 349 void QtxListResourceEdit::Tab::adjustLabels()
 350 {
 351   QObjectList* labels = queryList( "QLabel" );
 352   if ( labels )
 353   {
 354     int w = 0;
 355     for ( QObjectListIt it1( *labels ); it1.current(); ++it1 )
 356     {
 357       if ( it1.current()->isWidgetType() )
 358       {
 359         QWidget* wid = (QWidget*)it1.current();
 360         w = QMAX( w, wid->sizeHint().width() );
 361       }
 362     }
 363     for ( QObjectListIt it2( *labels ); it2.current(); ++it2 )
 364     {
 365       if ( it2.current()->isWidgetType() )
 366       {
 367         QWidget* wid = (QWidget*)it2.current();
 368         wid->setMinimumWidth( w );
 369       }
 370     }
 371     delete labels;
 372   }
 373 }
 374
 375 /*
 376   Class: QtxListResourceEdit::Group
 377   Descr: GUI implementation of resources group.
 378 */
 379
 380 QtxListResourceEdit::Group::Group( const QString& title, QtxResourceEdit* edit, Item* pItem, QWidget* parent )
 381 : QGroupBox( 2, Qt::Horizontal, title, parent ),
 382 Item( edit, pItem )
 383 {
 384 }
 385
 386 QtxListResourceEdit::Group::~Group()
 387 {
 388 }
 389
 390 int QtxListResourceEdit::Group::type() const
 391 {
 392   return -1;
 393 }
 394
 395 void QtxListResourceEdit::Group::store()
 396 {
 397 }
 398
 399 void QtxListResourceEdit::Group::retrieve()
 400 {
 401 }
 402
 403 QVariant QtxListResourceEdit::Group::property( const QString& prop ) const
 404 {
 405   QVariant var;
 406   if ( prop == "columns" )
 407     var = QVariant( columns() );
 408   else if ( prop == "orientation" )
 409     var = QVariant( orientation() );
 410   else if ( prop == "frame" )
 411     var = QVariant( frameStyle() != QFrame::NoFrame );
 412   return var;
 413 }
 414
 415 void QtxListResourceEdit::Group::setProperty( const QString& name, const QVariant& var )
 416 {
 417   QVariant prop = var;
 418   if ( !prop.cast( QVariant::Int ) )
 419     return;
 420
 421   if ( name == QString( "columns" ) && prop.cast( QVariant::Int ) && prop.toInt() > 0 )
 422     setColumns( prop.toInt() );
 423   else if ( name == QString( "orientation" ) && prop.cast( QVariant::Int ) )
 424   {
 425     int o = prop.toInt();
 426     if ( o == Qt::Horizontal || o == Qt::Vertical )
 427       setOrientation( (Orientation)o );
 428   }
 429   else if ( name == "frame" && prop.cast( QVariant::Bool ) )
 430   {
 431     setInsideMargin( prop.toBool() ? 5 : 0 );
 432     QGroupBox::setTitle( prop.toBool() ? Item::title() : QString::null );
 433     setFrameStyle( prop.toBool() ? QFrame::Box | QFrame::Sunken : QFrame::NoFrame );
 434   }
 435 }
 436
 437 void QtxListResourceEdit::Group::setTitle( const QString& title )
 438 {
 439   Item::setTitle( title );
 440   QGroupBox::setTitle( title );
 441 }
 442
 443 QtxResourceEdit::Item* QtxListResourceEdit::Group::createItem( const QString& title, const int type )
 444 {
 445   Item* item = 0;
 446
 447   switch ( type )
 448   {
 449   case Color:
 450     item = new ColorItem( title, resourceEdit(), this, this );
 451     break;
 452   case Bool:
 453     item = new StateItem( title, resourceEdit(), this, this );
 454     break;
 455   case String:
 456     item = new StringItem( title, resourceEdit(), this, this );
 457     break;
 458   case Selector:
 459     item = new SelectItem( title, resourceEdit(), this, this );
 460     break;
 461   case DblSpin:
 462     item = new DoubleSpinItem( title, resourceEdit(), this, this );
 463     break;
 464   case IntSpin:
 465     item = new IntegerSpinItem( title, resourceEdit(), this, this );
 466     break;
 467   case Double:
 468     item = new DoubleEditItem( title, resourceEdit(), this, this );
 469     break;
 470   case Integer:
 471     item = new IntegerEditItem( title, resourceEdit(), this, this );
 472     break;
 473   case Space:
 474     item = new Spacer( resourceEdit(), this, this );
 475     break;
 476   case GroupBox:
 477     item = new Group( title, resourceEdit(), this, this );
 478     break;
 479   case Font:
 480     item = new FontItem( title, resourceEdit(), this, this );
 481     break;
 482   case DirList:
 483     item = new DirListItem( title, resourceEdit(), this, this );
 484     break;
 485   case File:
 486     item = new FileItem( title, resourceEdit(), this, this );
 487     break;
 488   }
 489
 490   return item;
 491 }
 492
 493 /*
 494   Class: QtxListResourceEdit::PrefItem
 495   Descr: Base class for preferences items.
 496 */
 497
 498 QtxListResourceEdit::PrefItem::PrefItem( const int type, QtxResourceEdit* edit, Item* pi, QWidget* parent )
 499 : QHBox( parent ),
 500 Item( edit, pi ),
 501 myType( type )
 502 {
 503   setSpacing( 5 );
 504 }
 505
 506 QtxListResourceEdit::PrefItem::~PrefItem()
 507 {
 508 }
 509
 510 int QtxListResourceEdit::PrefItem::type() const
 511 {
 512   return myType;
 513 }
 514
 515 QtxResourceEdit::Item* QtxListResourceEdit::PrefItem::createItem( const QString&, const int )
 516 {
 517   return 0;
 518 }
 519
 520 /*
 521   Class: QtxListResourceEdit::Spacer
 522   Descr: GUI implementation of resources spacer.
 523 */
 524
 525 QtxListResourceEdit::Spacer::Spacer( QtxResourceEdit* edit, Item* pItem, QWidget* parent )
 526 : PrefItem( Space, edit, pItem, parent )
 527 {
 528   setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 529 }
 530
 531 QtxListResourceEdit::Spacer::~Spacer()
 532 {
 533 }
 534
 535 void QtxListResourceEdit::Spacer::store()
 536 {
 537 }
 538
 539 void QtxListResourceEdit::Spacer::retrieve()
 540 {
 541 }
 542
 543 /*
 544   Class: QtxListResourceEdit::SelectItem
 545   Descr: GUI implementation of resources list item.
 546 */
 547
 548 QtxListResourceEdit::SelectItem::SelectItem( const QString& title, QtxResourceEdit* edit,
 549                                              Item* pItem, QWidget* parent )
 550 : PrefItem( Selector, edit, pItem, parent )
 551 {
 552   new QLabel( title, this );
 553   myList = new QComboBox( false, this );
 554   myList->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 555 }
 556
 557 QtxListResourceEdit::SelectItem::~SelectItem()
 558 {
 559 }
 560
 561 void QtxListResourceEdit::SelectItem::store()
 562 {
 563   int idx = myList->currentItem();
 564   if ( myIndex.contains( idx ) )
 565     setInteger( myIndex[idx] );
 566 }
 567
 568 void QtxListResourceEdit::SelectItem::retrieve()
 569 {
 570   int id = getInteger( -1 );
 571
 572   int idx = -1;
 573   for ( QMap<int, int>::ConstIterator it = myIndex.begin(); it != myIndex.end() && idx == -1; ++it )
 574   {
 575     if ( it.data() == id )
 576       idx = it.key();
 577   }
 578
 579   myList->setCurrentItem( idx );
 580 }
 581
 582 QVariant QtxListResourceEdit::SelectItem::property( const QString& name ) const
 583 {
 584   QVariant val;
 585   if ( name == QString( "strings" ) )
 586   {
 587     QStringList lst;
 588     for ( int i = 0; i < (int)myList->count(); i++ )
 589       lst.append( myList->text( i ) );
 590     val = QVariant( lst );
 591   }
 592   else if ( name == QString( "indexes" ) )
 593   {
 594     QValueList<QVariant> lst;
 595     for ( int i = 0; i < (int)myList->count(); i++ )
 596       lst.append( myIndex.contains( i ) ? myIndex[i] : 0 );
 597     val = QVariant( lst );
 598   }
 599   return val;
 600 }
 601
 602 void QtxListResourceEdit::SelectItem::setProperty( const QString& name, const QVariant& val )
 603 {
 604   if ( name == QString( "strings" ) )
 605     setStrings( val );
 606   else if ( name == QString( "indexes" ) )
 607     setIndexes( val );
 608 }
 609
 610 void QtxListResourceEdit::SelectItem::setStrings( const QVariant& var )
 611 {
 612   if ( var.type() != QVariant::StringList )
 613     return;
 614
 615   setStrings( var.toStringList() );
 616 }
 617
 618 void QtxListResourceEdit::SelectItem::setIndexes( const QVariant& var )
 619 {
 620   if ( var.type() != QVariant::List )
 621     return;
 622
 623   QValueList<QVariant> varList = var.toList();
 624   QValueList<int> lst;
 625   for ( QValueList<QVariant>::const_iterator it = varList.begin(); it != varList.end(); ++it )
 626   {
 627     if ( (*it).canCast( QVariant::Int ) )
 628       lst.append( (*it).toInt() );
 629   }
 630   setIndexes( lst );
 631 }
 632
 633 void QtxListResourceEdit::SelectItem::setStrings( const QStringList& lst )
 634 {
 635   myList->clear();
 636   myList->insertStringList( lst );
 637 }
 638
 639 void QtxListResourceEdit::SelectItem::setIndexes( const QValueList<int>& lst )
 640 {
 641   myIndex.clear();
 642
 643   int idx = 0;
 644   for ( QValueList<int>::const_iterator it = lst.begin(); it != lst.end(); ++it, idx++ )
 645     myIndex.insert( idx, *it );
 646 }
 647
 648 /*
 649   Class: QtxListResourceEdit::StateItem
 650   Descr: GUI implementation of resources bool item.
 651 */
 652
 653 QtxListResourceEdit::StateItem::StateItem( const QString& title, QtxResourceEdit* edit,
 654                                            Item* pItem, QWidget* parent )
 655 : PrefItem( Bool, edit, pItem, parent )
 656 {
 657   myState = new QCheckBox( title, this );
 658   myState->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 659 }
 660
 661 QtxListResourceEdit::StateItem::~StateItem()
 662 {
 663 }
 664
 665 void QtxListResourceEdit::StateItem::store()
 666 {
 667   setBoolean( myState->isChecked() );
 668 }
 669
 670 void QtxListResourceEdit::StateItem::retrieve()
 671 {
 672   myState->setChecked( getBoolean() );
 673 }
 674
 675 /*
 676   Class: QtxListResourceEdit::StringItem
 677   Descr: GUI implementation of resources string item.
 678 */
 679
 680 QtxListResourceEdit::StringItem::StringItem( const QString& title, QtxResourceEdit* edit,
 681                                              Item* pItem, QWidget* parent )
 682 : PrefItem( String, edit, pItem, parent )
 683 {
 684   new QLabel( title, this );
 685   myString = new QLineEdit( this );
 686   myString->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 687 }
 688
 689 QtxListResourceEdit::StringItem::~StringItem()
 690 {
 691 }
 692
 693 void QtxListResourceEdit::StringItem::store()
 694 {
 695   setString( myString->text() );
 696 }
 697
 698 void QtxListResourceEdit::StringItem::retrieve()
 699 {
 700   myString->setText( getString() );
 701 }
 702
 703 /*
 704   Class: QtxListResourceEdit::IntegerEditItem
 705   Descr: GUI implementation of resources integer item.
 706 */
 707
 708 QtxListResourceEdit::IntegerEditItem::IntegerEditItem( const QString& title, QtxResourceEdit* edit, Item* pItem, QWidget* parent )
 709 : PrefItem( Integer, edit, pItem, parent )
 710 {
 711   new QLabel( title, this );
 712   myInteger = new QLineEdit( this );
 713   myInteger->setValidator( new QIntValidator( myInteger ) );
 714   myInteger->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 715 }
 716
 717 QtxListResourceEdit::IntegerEditItem::~IntegerEditItem()
 718 {
 719 }
 720
 721 void QtxListResourceEdit::IntegerEditItem::store()
 722 {
 723   setString( myInteger->text() );
 724 }
 725
 726 void QtxListResourceEdit::IntegerEditItem::retrieve()
 727 {
 728   myInteger->setText( getString() );
 729 }
 730
 731 /*
 732   Class: QtxListResourceEdit::IntegerSpinItem
 733   Descr: GUI implementation of resources integer item.
 734 */
 735
 736 QtxListResourceEdit::IntegerSpinItem::IntegerSpinItem( const QString& title, QtxResourceEdit* edit, Item* pItem, QWidget* parent )
 737 : PrefItem( IntSpin, edit, pItem, parent )
 738 {
 739   new QLabel( title, this );
 740   myInteger = new QtxIntSpinBox( this );
 741   myInteger->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 742 }
 743
 744 QtxListResourceEdit::IntegerSpinItem::~IntegerSpinItem()
 745 {
 746 }
 747
 748 void QtxListResourceEdit::IntegerSpinItem::store()
 749 {
 750   setInteger( myInteger->value() );
 751 }
 752
 753 void QtxListResourceEdit::IntegerSpinItem::retrieve()
 754 {
 755   myInteger->setValue( getInteger() );
 756 }
 757
 758 QVariant QtxListResourceEdit::IntegerSpinItem::property( const QString& name ) const
 759 {
 760   QVariant var;
 761   if ( name == QString( "minimum" ) || name == QString( "min" ) )
 762     var = QVariant( myInteger->minValue() );
 763   else if ( name == QString( "maximum" ) || name == QString( "max" ) )
 764     var = QVariant( myInteger->maxValue() );
 765   else if ( name == QString( "step" ) )
 766     var = QVariant( myInteger->lineStep() );
 767   else if ( name == QString( "special" ) )
 768     var = QVariant( myInteger->specialValueText() );
 769   else if ( name == QString( "prefix" ) )
 770     var = QVariant( myInteger->prefix() );
 771   else if ( name == QString( "suffix" ) )
 772     var = QVariant( myInteger->suffix() );
 773   return var;
 774 }
 775
 776 void QtxListResourceEdit::IntegerSpinItem::setProperty( const QString& name, const QVariant& var )
 777 {
 778   QVariant prop = var;
 779
 780   if ( ( name == QString( "minimum" ) || name == QString( "min" ) ) && prop.cast( QVariant::Int ) )
 781     myInteger->setMinValue( prop.toInt() );
 782   else if ( ( name == QString( "maximum" ) || name == QString( "max" ) ) && prop.cast( QVariant::Int ) )
 783     myInteger->setMaxValue( prop.toInt() );
 784   else if ( name == QString( "step" ) && prop.cast( QVariant::Int ) && prop.toInt() > 0 )
 785     myInteger->setLineStep( prop.toInt() );
 786   else if ( name == QString( "special" ) && prop.cast( QVariant::String ) )
 787     myInteger->setSpecialValueText( prop.toString() );
 788   else if ( name == QString( "prefix" ) && prop.cast( QVariant::String ) )
 789     myInteger->setPrefix( prop.toString() );
 790   else if ( name == QString( "suffix" ) && prop.cast( QVariant::String ) )
 791     myInteger->setSuffix( prop.toString() );
 792 }
 793
 794 /*
 795   Class: QtxListResourceEdit::DoubleEditItem
 796   Descr: GUI implementation of resources string item.
 797 */
 798
 799 QtxListResourceEdit::DoubleEditItem::DoubleEditItem( const QString& title, QtxResourceEdit* edit,
 800                                                      Item* pItem, QWidget* parent )
 801 : PrefItem( Double, edit, pItem, parent )
 802 {
 803   new QLabel( title, this );
 804   myDouble = new QLineEdit( this );
 805   myDouble->setValidator( new QDoubleValidator( myDouble ) );
 806   myDouble->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 807 }
 808
 809 QtxListResourceEdit::DoubleEditItem::~DoubleEditItem()
 810 {
 811 }
 812
 813 void QtxListResourceEdit::DoubleEditItem::store()
 814 {
 815   setString( myDouble->text() );
 816 }
 817
 818 void QtxListResourceEdit::DoubleEditItem::retrieve()
 819 {
 820   myDouble->setText( getString() );
 821 }
 822
 823 /*
 824   Class: QtxListResourceEdit::DoubleSpinItem
 825   Descr: GUI implementation of resources double item.
 826 */
 827
 828 QtxListResourceEdit::DoubleSpinItem::DoubleSpinItem( const QString& title, QtxResourceEdit* edit,
 829                                                      Item* pItem, QWidget* parent )
 830 : PrefItem( DblSpin, edit, pItem, parent )
 831 {
 832   new QLabel( title, this );
 833   myDouble = new QtxDblSpinBox( this );
 834   myDouble->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 835 }
 836
 837 QtxListResourceEdit::DoubleSpinItem::~DoubleSpinItem()
 838 {
 839 }
 840
 841 void QtxListResourceEdit::DoubleSpinItem::store()
 842 {
 843   setDouble( myDouble->value() );
 844 }
 845
 846 void QtxListResourceEdit::DoubleSpinItem::retrieve()
 847 {
 848   myDouble->setValue( getDouble() );
 849 }
 850
 851 QVariant QtxListResourceEdit::DoubleSpinItem::property( const QString& name ) const
 852 {
 853   QVariant var;
 854   if ( name == QString( "minimum" ) || name == QString( "min" ) )
 855     var = QVariant( myDouble->minValue() );
 856   else if ( name == QString( "maximum" ) || name == QString( "max" ) )
 857     var = QVariant( myDouble->maxValue() );
 858   else if ( name == QString( "precision" ) )
 859     var = QVariant( myDouble->precision() );
 860   else if ( name == QString( "step" ) )
 861     var = QVariant( myDouble->lineStep() );
 862   else if ( name == QString( "special" ) )
 863     var = QVariant( myDouble->specialValueText() );
 864   else if ( name == QString( "prefix" ) )
 865     var = QVariant( myDouble->prefix() );
 866   else if ( name == QString( "suffix" ) )
 867     var = QVariant( myDouble->suffix() );
 868   return var;
 869 }
 870
 871 void QtxListResourceEdit::DoubleSpinItem::setProperty( const QString& name, const QVariant& var )
 872 {
 873   QVariant prop = var;
 874
 875   if ( ( name == QString( "minimum" ) || name == QString( "min" ) ) && prop.cast( QVariant::Double ) )
 876     myDouble->setMinValue( prop.toDouble() );
 877   else if ( ( name == QString( "maximum" ) || name == QString( "max" ) ) && prop.cast( QVariant::Double ) )
 878     myDouble->setMaxValue( prop.toDouble() );
 879   else if ( name == QString( "step" ) && prop.cast( QVariant::Double ) && prop.toDouble() > 0 )
 880     myDouble->setLineStep( prop.toDouble() );
 881   else if ( name == QString( "precision" ) && prop.cast( QVariant::Int ) && prop.toInt() > 0 )
 882     myDouble->setPrecision( prop.toInt() );
 883   else if ( name == QString( "special" ) && prop.cast( QVariant::String ) )
 884     myDouble->setSpecialValueText( prop.toString() );
 885   else if ( name == QString( "prefix" ) && prop.cast( QVariant::String ) )
 886     myDouble->setPrefix( prop.toString() );
 887   else if ( name == QString( "suffix" ) && prop.cast( QVariant::String ) )
 888     myDouble->setSuffix( prop.toString() );
 889 }
 890
 891 /*
 892   Class: QtxListResourceEdit::ColorItem
 893   Descr: GUI implementation of resources color item.
 894 */
 895
 896 QtxListResourceEdit::ColorItem::ColorItem( const QString& title, QtxResourceEdit* edit,
 897                                            Item* pItem, QWidget* parent )
 898 : PrefItem( Color, edit, pItem, parent )
 899 {
 900   class ColorSelector : public QLabel
 901   {
 902   public:
 903     ColorSelector( QWidget* parent = 0 ) : QLabel( parent )
 904     {
 905       setFrameStyle( WinPanel | Raised );
 906     }
 907     virtual ~ColorSelector() {}
 908     virtual QSize minimumSizeHint() const
 909     {
 910       return QLabel::minimumSizeHint() + QSize( 0, 2 );
 911     }
 912
 913   protected:
 914     virtual void mousePressEvent( QMouseEvent* e )
 915     {
 916       if ( e->button() == LeftButton )
 917       {
 918         setFrameStyle( WinPanel | Sunken );
 919         QColor c = QColorDialog::getColor( paletteBackgroundColor(), this );
 920         if ( c.isValid() )
 921           setPaletteBackgroundColor( c );
 922
 923         setFrameStyle( WinPanel | Raised );
 924       }
 925     }
 926   };
 927
 928   new QLabel( title, this );
 929   myColor = new ColorSelector( this );
 930   myColor->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 931 }
 932
 933 QtxListResourceEdit::ColorItem::~ColorItem()
 934 {
 935 }
 936
 937 void QtxListResourceEdit::ColorItem::store()
 938 {
 939   setColor( myColor->paletteBackgroundColor() );
 940 }
 941
 942 void QtxListResourceEdit::ColorItem::retrieve()
 943 {
 944   myColor->setPaletteBackgroundColor( getColor() );
 945 }
 946
 947
 948 /*
 949   Class: QtxListResourceEdit::FontItem
 950   Descr: GUI implementation of resources font item.
 951 */
 952 QtxListResourceEdit::FontItem::FontItem( const QString& title, QtxResourceEdit* edit,
 953                                          Item* pItem, QWidget* parent )
 954 : PrefItem( Font, edit, pItem, parent )
 955 {
 956   new QLabel( title, this );
 957   myFamilies = new QtxComboBox( false, this );
 958   mySizes = new QtxComboBox( true, this );
 959   mySizes->setInsertionPolicy( QComboBox::NoInsertion );
 960   myBold = new QCheckBox( tr( "Bold" ), this );
 961   myItalic = new QCheckBox( tr( "Italic" ), this );
 962   myUnderline = new QCheckBox( tr( "Underline" ), this );
 963   myPreview = new QToolButton( this );
 964   myPreview->setText( "..." );
 965
 966   myFamilies->setSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::Preferred );
 967   mySizes->setSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::Preferred );
 968
 969   connect( myFamilies, SIGNAL( activated( int ) ), this, SLOT( onActivateFamily( int ) ) );
 970   connect( myPreview, SIGNAL( clicked() ), this, SLOT( onPreview() ) );
 971
 972   setProperty( "system", ( bool )true );
 973   setProperty( "widget_flags", ( int )All );
 974 }
 975
 976 QtxListResourceEdit::FontItem::~FontItem()
 977 {
 978 }
 979
 980 void QtxListResourceEdit::FontItem::store()
 981 {
 982   QFont f( family(), size() );
 983   bool bold, italic, underline;
 984   params( bold, italic, underline );
 985   f.setBold( bold );
 986   f.setItalic( italic );
 987   f.setUnderline( underline );
 988   Item::setFont( f );
 989 }
 990
 991 void QtxListResourceEdit::FontItem::retrieve()
 992 {
 993   QFont f = getFont();
 994   setFamily( f.family() );
 995   setSize( f.pointSize() );
 996   setParams( f.bold(), f.italic(), f.underline() );
 997 }
 998
 999 QVariant QtxListResourceEdit::FontItem::property( const QString& name ) const
1000 {
1001   if( name=="system" )
1002     return myIsSystem;
1003
1004   else if( name=="widget_flags" )
1005     return ( int )myFlags;
1006
1007   if( myIsSystem )
1008   {
1009     if( name=="families" )
1010     {
1011       QFontDatabase fdb;
1012       return fdb.families();
1013     }
1014
1015     else if( name=="default_family" )
1016     {
1017       QFontDatabase fdb;
1018       QStringList fam = fdb.families();
1019       if( fam.count()>0 )
1020         return fam.first();
1021       else
1022         return QString::null;
1023     }
1024
1025     else
1026     {
1027       QStringList parts = QStringList::split( ":", name );
1028       if( parts.count()==2 )
1029       {
1030         if( parts[1]=="default_bold" || parts[1]=="default_italic" || parts[1]=="default_underline" )
1031           return false;
1032
1033         else if( parts[1]=="sizes" )
1034         {
1035           QFontDatabase fdb;
1036           QValueList<int> sizes = fdb.pointSizes( parts[0] );
1037           QValueList<QVariant> vsizes;
1038           QValueList<int>::const_iterator anIt = sizes.begin(),
1039                                           aLast = sizes.end();
1040           for( ; anIt!=aLast; anIt++ )
1041             vsizes.append( *anIt );
1042
1043           return vsizes;
1044         }
1045
1046         else if( parts[1]=="default_size" )
1047         {
1048           if( parts[0].isEmpty() )
1049             return 0;
1050
1051           QFontDatabase fdb;
1052           QValueList<int> sizes = fdb.pointSizes( parts[0] );
1053           if( sizes.count()>0 )
1054             return sizes.first();
1055           else
1056             return 0;
1057         }
1058       }
1059     }
1060   }
1061
1062   else if( myProperties.contains( name ) )
1063     return myProperties[ name ];
1064
1065   return QVariant();
1066 }
1067
1068 void QtxListResourceEdit::FontItem::setProperty( const QString& name, const QVariant& value )
1069 {
1070   if( name=="system" )
1071   {
1072     if( !value.canCast( QVariant::Bool ) )
1073       return;
1074
1075     bool isSystem = value.toBool();
1076     if( myIsSystem==isSystem )
1077       return;
1078
1079     myIsSystem = isSystem;
1080
1081     QVariant families = property( "families" );
1082     QString fam = family();
1083
1084     myFamilies->clear();
1085     if( families.canCast( QVariant::StringList ) )
1086     {
1087       QStringList list = families.toStringList();
1088       myFamilies->insertStringList( list );
1089     }
1090
1091     setFamily( fam );
1092     setSize( -1 ); //set default size
1093   }
1094
1095   else if( name=="widget_flags" )
1096   {
1097     if( !value.canCast( QVariant::Int ) )
1098       return;
1099
1100     int wf = value.toInt();
1101
1102     myFlags = wf;
1103     myFamilies ->setShown( wf & Family );
1104     mySizes    ->setShown( wf & Size );
1105     mySizes->lineEdit()->setReadOnly( ( wf & UserSize )==0 );
1106     myBold     ->setShown( wf & Bold );
1107     myItalic   ->setShown( wf & Italic );
1108     myUnderline->setShown( wf & Underline );
1109     bool isSystem = property( "system" ).canCast( QVariant::Bool ) ? property( "system" ).toBool() : false;
1110     myPreview->setShown( ( wf & Preview ) && isSystem );
1111
1112     internalUpdate();
1113   }
1114
1115   else
1116     myProperties[ name ] = value;
1117 }
1118
1119 void QtxListResourceEdit::FontItem::setFamily( const QString& f )
1120 {
1121   QString curtext;
1122   if( myFamilies->isShown() )
1123   {
1124     if( myFamilies->listBox()->findItem( f, Qt::ExactMatch ) )
1125       curtext = f;
1126   }
1127   else
1128   {
1129     QVariant deffam = property( "default_family" );
1130     if( deffam.canCast( QVariant::String ) )
1131       curtext = deffam.toString();
1132   }
1133
1134   int idx = -1;
1135   for ( int i = 0; i < (int)myFamilies->count() && idx < 0; i++ )
1136   {
1137     if ( myFamilies->text( i ) == curtext )
1138       idx = i;
1139   }
1140
1141   if ( idx >= 0 )
1142     myFamilies->setCurrentItem( idx );
1143
1144   onActivateFamily( idx );
1145 }
1146
1147 QString QtxListResourceEdit::FontItem::family() const
1148 {
1149   return myFamilies->currentText();
1150 }
1151
1152 void QtxListResourceEdit::FontItem::setSize( const int s )
1153 {
1154   int cursize = -1;
1155   if( mySizes->isShown() && s>0 )
1156   {
1157     if( ( myFlags & UserSize ) || mySizes->listBox()->findItem( QString( "%1" ).arg( s ), Qt::ExactMatch ) )
1158       cursize = s;
1159   }
1160   else
1161   {
1162     QVariant defsize = property( QString( "%1:default_size" ).arg( family() ) );
1163     if( defsize.canCast( QVariant::Int ) )
1164       cursize = defsize.toInt();
1165   }
1166
1167   mySizes->setCurrentText( cursize>0 ? QString( "%1" ).arg( cursize ) : "" );
1168 }
1169
1170 int QtxListResourceEdit::FontItem::size() const
1171 {
1172   QString s = mySizes->currentText();
1173   bool ok;
1174   int pSize = s.toInt( &ok );
1175   return ( ok ? pSize : 0 );
1176 }
1177
1178 void QtxListResourceEdit::FontItem::setParams( const bool bold, const bool italic, const bool underline )
1179 {
1180   bool curbold = false, curitalic = false, curunderline = false;
1181   if( myBold->isShown() )
1182     curbold = bold;
1183   else
1184   {
1185     QVariant def = property( QString( "%1:default_bold" ).arg( family() ) );
1186     if( def.canCast( QVariant::Bool ) )
1187       curbold = def.toBool();
1188   }
1189   if( myItalic->isShown() )
1190     curitalic = italic;
1191   else
1192   {
1193     QVariant def = property( QString( "%1:default_italic" ).arg( family() ) );
1194     if( def.canCast( QVariant::Bool ) )
1195       curitalic = def.toBool();
1196   }
1197   if( myUnderline->isShown() )
1198     curunderline = underline;
1199   else
1200   {
1201     QVariant def = property( QString( "%1:default_underline" ).arg( family() ) );
1202     if( def.canCast( QVariant::Bool ) )
1203       curunderline = def.toBool();
1204   }
1205   myBold->setChecked( curbold );
1206   myItalic->setChecked( curitalic );
1207   myUnderline->setChecked( curunderline );
1208 }
1209
1210 void QtxListResourceEdit::FontItem::params( bool& bold, bool& italic, bool& underline )
1211 {
1212   bold = myBold->isChecked();
1213   italic = myItalic->isChecked();
1214   underline = myUnderline->isChecked();
1215 }
1216
1217 void QtxListResourceEdit::FontItem::internalUpdate()
1218 {
1219   //update internal selection of font properties
1220   setFamily( family() );
1221   setSize( size() );
1222   bool b1, b2, b3;
1223   params( b1, b2, b3 );
1224   setParams( b1, b2, b3 );
1225 }
1226
1227 void QtxListResourceEdit::FontItem::onActivateFamily( int )
1228 {
1229   QVariant sizes = property( QString( "%1:sizes" ).arg( family() ) );
1230
1231   int s = size();
1232   mySizes->clear();
1233   if( sizes.canCast( QVariant::List ) )
1234   {
1235     QValueList<QVariant> list = sizes.toList();
1236     QStringList sizeItems;
1237     QValueList<QVariant>::const_iterator anIt = list.begin(),
1238                                          aLast = list.end();
1239     for( ; anIt!=aLast; anIt++ )
1240       if( (*anIt).canCast( QVariant::Int ) && (*anIt).toInt()>0 )
1241         sizeItems.append( QString( "%1" ).arg( (*anIt).toInt() ) );
1242     mySizes->insertStringList( sizeItems );
1243   }
1244   setSize( s );
1245 }
1246
1247 void QtxListResourceEdit::FontItem::onPreview()
1248 {
1249   QFont f( family(), size() );
1250   bool bold, italic, underline;
1251   params( bold, italic, underline );
1252   f.setBold( bold );
1253   f.setItalic( italic );
1254   f.setUnderline( underline );
1255
1256   bool ok;
1257   f = QFontDialog::getFont( &ok, f );
1258
1259   if( ok )
1260   {
1261     setFamily( f.family() );
1262     setSize( f.pointSize() );
1263     setParams( f.bold(), f.italic(), f.underline() );
1264   }
1265 }
1266
1267
1268
1269
1270
1271 /*
1272   Class: QtxListResourceEdit::DirListItem
1273   Descr:
1274 */
1275 QtxListResourceEdit::DirListItem::DirListItem( const QString& title, QtxResourceEdit* edit, Item* pItem, QWidget* parent )
1276 : PrefItem( Font, edit, pItem, parent )
1277 {
1278   myDirListEditor = new QtxDirListEditor( this );
1279 }
1280
1281 QtxListResourceEdit::DirListItem::~DirListItem()
1282 {
1283 }
1284
1285 void QtxListResourceEdit::DirListItem::store()
1286 {
1287   QStringList list;
1288   myDirListEditor->getPathList(list);
1289   setString( QString(list.join(";")) );
1290 }
1291
1292 void QtxListResourceEdit::DirListItem::retrieve()
1293 {
1294   myDirListEditor->setPathList(QStringList::split(";", getString()));
1295 }
1296
1297
1298
1299 /*
1300   Class: QtxListResourceEdit::FileItem
1301   Descr: GUI implementation of resources file item.
1302 */
1303 QtxListResourceEdit::FileItem::FileItem( const QString& title, QtxResourceEdit* edit,
1304                                          Item* pItem, QWidget* parent )
1305 : PrefItem( Font, edit, pItem, parent ),
1306   myFlags( QFileInfo::ReadUser ),
1307   myIsExisting( true ),
1308   myIsReadOnly ( true ),
1309   myFileDlg( 0 )
1310 {
1311   new QLabel( title, this );
1312   myFile = new QLineEdit( this );
1313   myFile->setValidator( new FileValidator( this, myFile ) );
1314   myFile->setReadOnly( myIsReadOnly );
1315   myOpenFile = new QToolButton( this );
1316   myOpenFile->setText( "..." );
1317   connect( myOpenFile, SIGNAL( clicked() ), this, SLOT( onOpenFile() ) );
1318 }
1319
1320 QtxListResourceEdit::FileItem::~FileItem()
1321 {
1322   if( myFileDlg )
1323     delete myFileDlg;
1324 }
1325
1326 void QtxListResourceEdit::FileItem::store()
1327 {
1328   setString( myFile->text() );
1329 }
1330
1331 void QtxListResourceEdit::FileItem::retrieve()
1332 {
1333   myFile->setText( getString() );
1334 }
1335
1336 QVariant QtxListResourceEdit::FileItem::property( const QString& name ) const
1337 {
1338   if( name=="filter" )
1339     return myFilter;
1340   else if( name=="existing" )
1341     return myIsExisting;
1342   else if( name=="flags" )
1343     return myFlags;
1344   else if( name=="readOnly")
1345     return myIsReadOnly;
1346
1347   return QVariant();
1348 }
1349
1350 void QtxListResourceEdit::FileItem::setProperty( const QString& name, const QVariant& value )
1351 {
1352   if( name=="filter" )
1353   {
1354     if( value.canCast( QVariant::String ) )
1355     {
1356       myFilter.clear();
1357       myFilter.append( value.toString() );
1358     }
1359     else if( value.canCast( QVariant::StringList ) )
1360       myFilter = value.toStringList();
1361   }
1362   else if( name=="existing" && value.canCast( QVariant::Bool ) )
1363     myIsExisting = value.toBool();
1364
1365   else if( name=="flags" && value.canCast( QVariant::UInt ) )
1366     myFlags = value.toUInt();
1367
1368   else if( name=="readOnly" && value.canCast( QVariant::Bool) ) {
1369     myIsReadOnly = value.toBool();
1370     myFile->setReadOnly( myIsReadOnly );
1371   }
1372 }
1373
1374 void QtxListResourceEdit::FileItem::onOpenFile()
1375 {
1376   if( !myFileDlg )
1377   {
1378     myFileDlg = new QFileDialog( "." );
1379     connect( myFileDlg, SIGNAL( fileHighlighted( const QString& ) ), this, SLOT( onFileSelected( const QString& ) ) );
1380   }
1381
1382   myFileDlg->setCaption( title() );
1383   myFileDlg->setFilters( myFilter );
1384   myFileDlg->setMode( myIsExisting ? QFileDialog::ExistingFile : QFileDialog::AnyFile );
1385
1386   if( myFileDlg->exec()==QDialog::Accepted )
1387   {
1388     myFile->setText( myFileDlg->selectedFile() );
1389   }
1390 }
1391
1392 bool QtxListResourceEdit::FileItem::isFileCorrect( const QString& f ) const
1393 {
1394   bool res = false;
1395   QFileInfo info( f );
1396   if( !myIsExisting || info.exists() )
1397     res = info.isFile() && info.permission( myFlags );
1398
1399   return res;
1400 }
1401
1402 void QtxListResourceEdit::FileItem::onFileSelected( const QString& f )
1403 {
1404   if( myFileDlg && !isFileCorrect( f ) )
1405     myFileDlg->setSelection( "" );
1406 }
1407
1408
1409
1410 QtxListResourceEdit::FileItem::FileValidator::FileValidator( FileItem* item, QObject* parent )
1411 : QValidator( parent ),
1412   myItem( item )
1413 {
1414 }
1415
1416 QtxListResourceEdit::FileItem::FileValidator::~FileValidator()
1417 {
1418 }
1419
1420 QValidator::State QtxListResourceEdit::FileItem::FileValidator::validate( QString& f, int& ) const
1421 {
1422   if( myItem && myItem->isFileCorrect( f ) )
1423     return QValidator::Acceptable;
1424   else
1425     return QValidator::Intermediate;
1426 }