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