src/Qtx/QtxListResourceEdit.cxx

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