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