src/Style/Style_Salome.cxx

   1 // Copyright (C) 2007-2019  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 // File   : Style_Salome.cxx
  21 // Author : Natalia Ermolaeva, Open CASCADE S.A.S.
  22 //
  23 #include "Style_Salome.h"
  24 #include "Style_Tools.h"
  25 #include "Style_Model.h"
  26
  27 #include <QApplication>
  28 #include <QPainter>
  29 #include <QMap>
  30 #include <QPainterPath>
  31 #include <QWidget>
  32 #include <QComboBox>
  33 #include <QStyleOptionFrame>
  34 #include <QStyleOptionComplex>
  35 #include <QStyleOptionSpinBox>
  36 #include <QStyleOptionButton>
  37 #include <QStyleOptionTab>
  38 #include <QStyleOptionToolButton>
  39 #include <QStyleOptionFocusRect>
  40 #include <QStyleOption>
  41 #include <QSize>
  42 #include <QToolBar>
  43 #include <QMenuBar>
  44 #include <QToolButton>
  45 #include <QTabWidget>
  46 #include <QTabBar>
  47 #include <QToolTip>
  48 #include <QDockWidget>
  49 #include <QTextEdit>
  50 #include <QTreeView>
  51 #include <QListView>
  52 #include <QHeaderView>
  53 #include <QRadioButton>
  54 #include <QCheckBox>
  55 #include <QPushButton>
  56 #include <QAbstractSpinBox>
  57 #include <QLineEdit>
  58 #include <QScrollBar>
  59 #include <QSlider>
  60 #include <QMainWindow>
  61 #include <QPixmapCache>
  62 #include <QTileRules>
  63
  64 #define SHADOW          1
  65 #define LINE_GR_MARGIN  10
  66 #define HIGH_WDG_MARGIN 10
  67
  68 #define BUT_PERCENT_COL 125
  69 #define BUT_PERCENT_ON  115
  70
  71 #define DELTA_H_TAB     1
  72 #define DELTA_SLIDER    3
  73
  74 static const char* const hole_xpm[] = {
  75 "3 3 3 1",
  76 ". c None",
  77 "a c #999999",
  78 "b c #FFFFFF",
  79 "aa.",
  80 "aab",
  81 ".bb"
  82 };
  83
  84 static const char* const cross_xpm[] = {
  85 "12 12 4 1",
  86 ". c None",
  87 "a c #000000",
  88 "b c #FFFFFF",
  89 "c c #666666",
  90 "............",
  91 "............",
  92 "............",
  93 ".aaaa..aaaa.",
  94 "..abbaabba..",
  95 "...abbbba...",
  96 "....abba....",
  97 "...abbbba...",
  98 "..abbaabba..",
  99 ".aaaa..aaaa.",
 100 "............",
 101 "............"
 102 };
 103
 104 static const char* const maximize_xpm[] = {
 105 "12 12 4 1",
 106 ". c None",
 107 "a c #000000",
 108 "b c #FFFFFF",
 109 "c c #666666",
 110 "............",
 111 ".aaaaaaaaaa.",
 112 ".acccccccca.",
 113 ".acccccccca.",
 114 ".abbbbbbbba.",
 115 ".abbbbbbbba.",
 116 ".abbbbbbbba.",
 117 ".abbbbbbbba.",
 118 ".abbbbbbbba.",
 119 ".abbbbbbbba.",
 120 ".aaaaaaaaaa.",
 121 "............"
 122 };
 123
 124 static const char* const normal_xpm[] = {
 125 "12 12 4 1",
 126 ". c None",
 127 "a c #000000",
 128 "b c #FFFFFF",
 129 "c c #666666",
 130 "............",
 131 "...aaaaaaaa.",
 132 "...acccccca.",
 133 "...abbbbbba.",
 134 "...aaaaaaba.",
 135 ".aaaaaaaaba.",
 136 ".accccccaba.",
 137 ".abbbbbbaaa.",
 138 ".abbbbbba...",
 139 ".abbbbbba...",
 140 ".aaaaaaaa...",
 141 "............"
 142 };
 143
 144 static const char* const minimize_xpm[] = {
 145 "12 12 4 1",
 146 ". c None",
 147 "a c #000000",
 148 "b c #FFFFFF",
 149 "c c #666666",
 150 "............",
 151 "............",
 152 "............",
 153 "............",
 154 "............",
 155 "............",
 156 "............",
 157 "............",
 158 "aaaaaaaaaaaa",
 159 "abbbbbbbbbba",
 160 "aaaaaaaaaaaa",
 161 "............"
 162 };
 163
 164 ///////////////////////////////////////////////////////////
 165 // FOR debug purposes only!!!
 166 //
 167 int DEBUG_LEVEL = 0;
 168
 169 static bool checkDebugLevel( int level )
 170 {
 171   return DEBUG_LEVEL == level || DEBUG_LEVEL == -1;
 172 }
 173 //
 174 ///////////////////////////////////////////////////////////
 175
 176 Style_Model* Style_Salome::myModel = 0;
 177
 178 /*!
 179   \class Style_Salome
 180   \brief SALOME style class.
 181
 182   To set SALOME style to the application, use static function Style_Salome::apply().
 183   Static function restore() can be used then to restore initial application style.
 184
 185   The usual way to use SALOME style is as following:
 186   \code
 187   Style_Salome::initialize( resourceMgr() );     // initialize SALOME style from resources
 188   if ( needSalomeStyle ) Style_Salome::apply();  // set SALOME style to the application
 189   \endcode
 190
 191   Style_PrefDlg class can be then used to change style properties, select one of the
 192   predefined style themes or even create user themes:
 193   \code
 194   Style_PrefDlg dlg( desktop() );
 195   dlg.exec();
 196   \endcode
 197 */
 198
 199 /*!
 200   \brief Constructor
 201
 202   Use Style_Salome::apply() static function to set SALOME style to the application.
 203 */
 204 Style_Salome::Style_Salome() : BaseStyle()
 205 {
 206   // initialize SALOME style resources
 207   Q_INIT_RESOURCE( Style );
 208 }
 209
 210 /*!
 211   \brief Destructor
 212 */
 213 Style_Salome::~Style_Salome()
 214 {
 215 }
 216
 217
 218 /*!
 219   \brief Initialize SALOME style.
 220
 221   This method should be called at the very beginning of the application
 222   which uses SALOME style.
 223   The method initializes style properties from the current settings.
 224
 225   If the parameter \a resMgr is not 0, the style is initialized from the
 226   resources manager.
 227
 228   The parameter \a section allows customizing of the resources file section
 229   used to store style's properties. By default "Theme" section name is used.
 230
 231   \param resMgr resources manager
 232   \param section resources file section name
 233   \sa apply(), restore()
 234 */
 235 void Style_Salome::initialize( QtxResourceMgr* resMgr, const QString& section )
 236 {
 237   model()->fromResources( resMgr, section );
 238 }
 239
 240 /*!
 241   \brief Set SALOME style to the application
 242   \sa initialize(), restore()
 243 */
 244 void Style_Salome::apply()
 245 {
 246   // application object is not created yet
 247   if ( !QApplication::instance() )
 248     return;
 249
 250   // update model (from the resources manager if needed)
 251   model()->update();
 252
 253   // check if SALOME style is already set to the application
 254   if ( !isActive() ) {
 255     // set SALOME style
 256     QApplication::style()->setParent( 0 );           // avoid deleting original application style
 257     QApplication::setStyle( new Style_Salome() );    // set style
 258     QApplication::setDesktopSettingsAware(false);    // prevent the style changing from another tools
 259   }
 260   update();                                          // update style
 261 }
 262
 263 /*!
 264   \brief Restore original style to the application
 265   \sa initialize(), apply()
 266 */
 267 void Style_Salome::restore()
 268 {
 269   // application object is not created yet
 270   if ( !QApplication::instance() )
 271     return;
 272   // check if SALOME style is set to the application
 273   if ( !isActive() )
 274     return;
 275
 276   QApplication::setDesktopSettingsAware(true);
 277
 278   // restore previous style
 279   model()->restore();
 280 }
 281
 282 /*!
 283   \brief Check if the SALOME style is currently set to application.
 284   \return \c true if SALOME style is set to the applcation or \c false otherwise
 285 */
 286 bool Style_Salome::isActive()
 287 {
 288   return QApplication::instance() != 0 && qobject_cast<Style_Salome*>( QApplication::style() ) != 0;
 289 }
 290
 291 /*!
 292   \brief Update style from resources.
 293 */
 294 void Style_Salome::update()
 295 {
 296   // application object is not created yet
 297   if ( !QApplication::instance() )
 298     return;
 299   // check if SALOME style is set to the application
 300   if ( Style_Salome* style = qobject_cast<Style_Salome*>( QApplication::style() ) )
 301     style->polish( qobject_cast<QApplication*>( QApplication::instance() ) );
 302 }
 303
 304 /*!
 305   \brief Get style model
 306   \return style model
 307 */
 308 Style_Model* Style_Salome::model()
 309 {
 310   if ( !myModel )
 311     myModel = new Style_Model();
 312   return myModel;
 313 }
 314
 315 /*!
 316   \brief Initialize the appearance of the application.
 317
 318   Performs late initialization of the given application object.
 319
 320   \param app application object
 321 */
 322 void Style_Salome::polish ( QApplication* app )
 323 {
 324   BaseStyle::polish( app );
 325
 326   if ( checkDebugLevel(1) ) {
 327     return;
 328   }
 329
 330   updatePaletteColors();
 331   app->setFont( model()->applicationFont() );
 332   updateAllWidgets( app );
 333 }
 334
 335 /*!
 336   \brief Initializes the appearance of the given widget.
 337
 338   This function is called for every widget at some point after
 339   it has been fully created but just before it is shown for the very first time.
 340
 341   \param w widget object
 342 */
 343 void Style_Salome::polish ( QWidget* w )
 344 {
 345   if ( checkDebugLevel(2) ) {
 346     BaseStyle::polish( w );
 347     return;
 348   }
 349
 350   if ( w && hasHover() ) {
 351     if ( qobject_cast<QPushButton*>(w) || qobject_cast<QToolButton*>(w)      ||
 352          qobject_cast<QCheckBox*>(w)   || qobject_cast<QRadioButton*>(w)     ||
 353          qobject_cast<QComboBox*>(w)   || qobject_cast<QAbstractSpinBox*>(w) ||
 354          qobject_cast<QLineEdit*>(w)   || qobject_cast<QScrollBar*>(w)       ||
 355          qobject_cast<QTabBar*>(w)     || qobject_cast<QSlider*>(w)          ||
 356          qobject_cast<QMenuBar*>(w)    || qobject_cast<QDockWidget*>(w) )
 357       w->setAttribute( Qt::WA_Hover );
 358   }
 359     BaseStyle::polish( w );
 360 }
 361
 362 /*!
 363   \brief Uninitialize the given widget's appearance.
 364
 365   This function is the counterpart to polish().
 366   It is called for every polished widget whenever the style
 367   is dynamically changed; the former style has to unpolish
 368   its settings before the new style can polish them again.
 369
 370   \param w widget object
 371 */
 372 void Style_Salome::unpolish( QWidget* w )
 373 {
 374   if ( checkDebugLevel(3) ) {
 375     BaseStyle::unpolish( w );
 376     return;
 377   }
 378
 379   if ( w && hasHover() ) {
 380     if ( qobject_cast<QPushButton*>(w) || qobject_cast<QToolButton*>(w)||
 381          qobject_cast<QCheckBox*>(w) || qobject_cast<QRadioButton*>(w) ||
 382          qobject_cast<QComboBox*>(w) || qobject_cast<QAbstractSpinBox*>(w) ||
 383          qobject_cast<QLineEdit*>(w) || qobject_cast<QScrollBar*>(w) ||
 384          qobject_cast<QTabBar*>(w) || qobject_cast<QSlider*>(w) ||
 385          qobject_cast<QMenuBar*>(w) || qobject_cast<QDockWidget*>(w) )
 386       w->setAttribute( Qt::WA_Hover, false );
 387   }
 388   BaseStyle::unpolish( w );
 389 }
 390
 391 /*!
 392   \brief Draws the given control using the provided painter \p with the style options specified by \a opt.
 393   \param cc complex control type
 394   \param opt style option
 395   \param p painter
 396   \param w widget
 397 */
 398 void Style_Salome::drawComplexControl( ComplexControl cc, const QStyleOptionComplex* opt,
 399                                        QPainter* p, const QWidget* w ) const
 400 {
 401   if ( checkDebugLevel(4) ) {
 402     BaseStyle::drawComplexControl( cc, opt, p, w );
 403     return;
 404   }
 405
 406   const QPalette& pal = w->palette();
 407   switch( cc ) {
 408     case CC_SpinBox:
 409       if (const QStyleOptionSpinBox *spin = qstyleoption_cast<const QStyleOptionSpinBox *>(opt)) {
 410         bool hover = hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver);
 411         QRect optr = opt->rect, arUp =   subControlRect( cc, spin, SC_SpinBoxUp, w );
 412         if (spin->buttonSymbols != QAbstractSpinBox::NoButtons)
 413           optr.setWidth( arUp.x()-optr.x()+1 );
 414         double aRad = model()->widgetRounding( Style_Model::EditRadius );
 415         bool antialized = model()->antialiasing();
 416         QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
 417         QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
 418         if ( hover )
 419           drawHoverRect(p, optr, opt->palette.color( QPalette::Window ), aRad, Style_Tools::Left, true);
 420         else
 421           Style_Tools::shadowRect( p, optr, aRad, LINE_GR_MARGIN, SHADOW, Style_Tools::Left,
 422                                    model()->color( Style_Model::FieldLight ), // Style_Model::fld_light_clr,
 423                                    model()->color( Style_Model::FieldDark ),  // Style_Model::fld_dark_clr,
 424                                    aBrdTopCol, aBrdBotCol, antialized, false );
 425         QRect aBtnRect = QRect( QPoint( arUp.x(), optr.y() ), QPoint( arUp.right(), optr.bottom() ) );
 426         QColor aBtnCol = opt->palette.color( QPalette::Button );
 427         bool aStateOn = opt->state & ( State_Sunken | State_On );
 428         if ( hover )
 429           drawHoverRect(p, aBtnRect, opt->palette.color( QPalette::Window ), aRad, Style_Tools::Right, true);
 430         else
 431           Style_Tools::shadowRect( p, aBtnRect, aRad, 0.0, SHADOW, Style_Tools::Right,
 432                                   aBtnCol.light( BUT_PERCENT_COL ), aBtnCol.dark( BUT_PERCENT_COL ),
 433                                   aBrdTopCol, aBrdBotCol, antialized, true, aStateOn );
 434         QStyleOptionSpinBox copy;
 435         PrimitiveElement pe;
 436         if (spin->subControls & SC_SpinBoxUp) {
 437           copy.subControls = SC_SpinBoxUp;
 438           QPalette pal2 = spin->palette;
 439           if (!(spin->stepEnabled & QAbstractSpinBox::StepUpEnabled) ||
 440               !(spin->state & State_Enabled)) {
 441             pal2.setCurrentColorGroup(QPalette::Disabled);
 442             copy.state &= ~State_Enabled;
 443           }
 444           else
 445             copy.state |= State_Enabled;
 446           copy.palette = pal2;
 447           if ( spin->activeSubControls == SC_SpinBoxUp && ( spin->state & State_Sunken ) ) {
 448             copy.state |= State_On;
 449             copy.state |= State_Sunken;
 450           } else {
 451             copy.state |= State_Raised;
 452             copy.state &= ~State_Sunken;
 453           }
 454           pe = (spin->buttonSymbols == QAbstractSpinBox::PlusMinus ? PE_IndicatorSpinPlus
 455                : PE_IndicatorSpinUp);
 456           copy.rect = aBtnRect;
 457           drawPrimitive(pe, &copy, p, w);
 458         }
 459         if (spin->subControls & SC_SpinBoxDown) {
 460           copy.subControls = SC_SpinBoxDown;
 461           copy.state = spin->state;
 462           QPalette pal2 = spin->palette;
 463           if (!(spin->stepEnabled & QAbstractSpinBox::StepDownEnabled) ||
 464                !(spin->state & State_Enabled)) {
 465             pal2.setCurrentColorGroup(QPalette::Disabled);
 466             copy.state &= ~State_Enabled;
 467           }
 468           else
 469             copy.state |= State_Enabled;
 470           copy.palette = pal2;
 471           if (spin->activeSubControls == SC_SpinBoxDown && (spin->state & State_Sunken)) {
 472              copy.state |= State_On;
 473              copy.state |= State_Sunken;
 474           } else {
 475             copy.state |= State_Raised;
 476             copy.state &= ~State_Sunken;
 477           }
 478           pe = (spin->buttonSymbols == QAbstractSpinBox::PlusMinus ? PE_IndicatorSpinMinus
 479                : PE_IndicatorSpinDown);
 480           copy.rect = aBtnRect;
 481           drawPrimitive(pe, &copy, p, w);
 482         }
 483         break;
 484      }
 485      case CC_ComboBox: {
 486       if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
 487         bool hover = hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver);
 488         QRect optr = opt->rect,
 489               ar = subControlRect( cc, cmb, SC_ComboBoxArrow, w );
 490         optr.setY( ar.y() );
 491         optr.setHeight( ar.height() );
 492         optr.setWidth( ar.x()-optr.x()+1 );
 493         bool antialized = model()->antialiasing();
 494         double aRad = model()->widgetRounding( Style_Model::EditRadius );
 495         QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
 496         QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
 497         if ( hover )
 498           drawHoverRect(p, optr, opt->palette.color( QPalette::Window ), aRad, Style_Tools::Left, true);
 499         else
 500           Style_Tools::shadowRect( p, optr, aRad, LINE_GR_MARGIN, SHADOW, Style_Tools::Left,
 501                                    model()->color( Style_Model::FieldLight ), // Style_Model::fld_light_clr,
 502                                    model()->color( Style_Model::FieldDark ),  // Style_Model::fld_dark_clr,
 503                                    aBrdTopCol, aBrdBotCol, antialized, false );
 504         if (cmb->subControls & SC_ComboBoxArrow) {
 505           State flags = State_None;
 506           QColor aBtnCol = opt->palette.color( QPalette::Button );
 507           bool aStateOn = opt->state & ( State_Sunken | State_On );
 508           if ( hover )
 509             drawHoverRect(p, ar, opt->palette.color( QPalette::Window ), aRad, Style_Tools::Right, true);
 510           else
 511             Style_Tools::shadowRect( p, ar, aRad, 0.0, SHADOW, Style_Tools::Right,
 512                                      aBtnCol.light( BUT_PERCENT_COL ), aBtnCol.dark( BUT_PERCENT_COL ),
 513                                      aBrdTopCol, aBrdBotCol, antialized, true, aStateOn );
 514           if (opt->state & State_Enabled)
 515             flags |= State_Enabled;
 516           if (cmb->activeSubControls == SC_ComboBoxArrow)
 517             flags |= State_Sunken;
 518           QStyleOption arrowOpt(0);
 519           arrowOpt.rect = ar;
 520           arrowOpt.palette = cmb->palette;
 521           arrowOpt.state = flags;
 522           drawPrimitive(PE_IndicatorArrowDown, &arrowOpt, p, w);
 523         }
 524         if (cmb->subControls & SC_ComboBoxEditField) {
 525           bool hi = cmb->state & State_HasFocus && !cmb->editable;
 526           if( hi ) {
 527             Style_Tools::shadowRect( p, optr, aRad, 0.0, SHADOW, Style_Tools::Left,
 528                                      pal.color( QPalette::Highlight ),
 529                                      pal.color( QPalette::Highlight ), aBrdTopCol, aBrdBotCol,
 530                                      antialized, false );
 531             p->setPen(cmb->palette.highlightedText().color());
 532           }
 533           else
 534             p->setPen(cmb->palette.text().color());
 535         }
 536         break;
 537       }
 538     }
 539     case CC_Slider: {
 540         if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
 541             QRect groove = subControlRect(CC_Slider, slider, SC_SliderGroove, w);
 542             QRect handle = subControlRect(CC_Slider, slider, SC_SliderHandle, w);
 543
 544             if( hasHover() && (slider->state & State_Enabled) &&
 545                          (slider->state & State_MouseOver) ) {
 546               QRect moderated = w->rect();
 547                 drawHoverRect(p, moderated, opt->palette.color( QPalette::Window ),
 548                               model()->widgetRounding( Style_Model::ButtonRadius ), Style_Tools::All, false);
 549             }
 550
 551             if ((slider->subControls & SC_SliderGroove) && groove.isValid()) {
 552               QStyleOptionSlider tmpSlider = *slider;
 553               tmpSlider.subControls = SC_SliderGroove;
 554               BaseStyle::drawComplexControl(cc, &tmpSlider, p, w);
 555             }
 556             if (slider->subControls & SC_SliderTickmarks) {
 557               QStyleOptionSlider tmpSlider = *slider;
 558               tmpSlider.subControls = SC_SliderTickmarks;
 559               QCommonStyle::drawComplexControl(cc, &tmpSlider, p, w);
 560             }
 561             if (slider->subControls & SC_SliderHandle) {
 562               if (slider->state & State_HasFocus) {
 563                 QStyleOptionFocusRect fropt;
 564                 fropt.QStyleOption::operator=(*slider);
 565                 fropt.rect = subElementRect(SE_SliderFocusRect, slider, w);
 566                 drawPrimitive(PE_FrameFocusRect, &fropt, p, w);
 567               }
 568               int x = handle.x(), y = handle.y(), wi = handle.width(), he = handle.height();
 569               bool horiz = slider->orientation == Qt::Horizontal;
 570               bool tickAbove = slider->tickPosition == QSlider::TicksAbove;
 571               bool tickBelow = slider->tickPosition == QSlider::TicksBelow;
 572               QColor aBtnCol = model()->color( Style_Model::Slider );          // Style_Model::slider_clr
 573               QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
 574               QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
 575               // rect was changed on +/-DELTA_SLIDER value for correct painting Antialised border of slider
 576               int aDelta = DELTA_SLIDER-1;
 577               QRect slRect = QRect(x+aDelta, y+aDelta, wi-aDelta, he-aDelta);
 578               int aXAdd = (int)(slRect.width()/6), aYAdd = (int)(slRect.height()/6);
 579               Style_Tools::SliderType type = Style_Tools::SlNone;
 580               if ((tickAbove && tickBelow) || (!tickAbove && !tickBelow))
 581                 type = Style_Tools::SlNone;
 582               else {
 583                 if (horiz)
 584                   if (tickAbove) {
 585                     type = Style_Tools::SlUp;
 586                     slRect.setTop( slRect.top()-aYAdd );
 587                   }
 588                   else {
 589                     type = Style_Tools::SlDown;
 590                     slRect.setBottom( slRect.bottom()+aYAdd );
 591                   }
 592                 else
 593                   if (tickAbove) {
 594                     type = Style_Tools::SlLeft;
 595                     slRect.setLeft( slRect.left()-aXAdd );
 596                   }
 597                   else {
 598                     type = Style_Tools::SlRight;
 599                     slRect.setRight( slRect.right()+aXAdd );
 600                  }
 601               }
 602               Style_Tools::drawSlider( p, slRect, model()->widgetRounding( Style_Model::SliderRadius ), type,
 603                                        aBtnCol.light( BUT_PERCENT_COL ),
 604                                        aBtnCol.dark( BUT_PERCENT_COL ), aBrdTopCol, aBrdBotCol );
 605               QRect aHRect = handle;
 606               int aXRect = (int)(aHRect.width()/5),
 607                   aYRect = (int)(aHRect.height()/5);
 608               aHRect = QRect( aHRect.x()+aXRect, aHRect.y()+aYRect,
 609                               aHRect.width()-2*aXRect, aHRect.height()-2*aYRect );
 610               drawHandle( p, aHRect, horiz );
 611             }
 612             break;
 613         }
 614     }
 615     case CC_ToolButton: {
 616       if (const QStyleOptionToolButton *toolbutton
 617            = qstyleoption_cast<const QStyleOptionToolButton *>(opt)) {
 618         QRect button, menuArea;
 619         button = subControlRect(cc, toolbutton, SC_ToolButton, w);
 620         menuArea = subControlRect(cc, toolbutton, SC_ToolButtonMenu, w);
 621
 622         if (w && ( qobject_cast<QToolBar *>(w->parentWidget() ) ||
 623                    ( toolbutton->state & State_AutoRaise && !( toolbutton->state & State_MouseOver ) ) )
 624             ) {
 625           BaseStyle::drawComplexControl( cc, opt, p, w );
 626           return;
 627         }
 628         int aMinDelta = (int)model()->widgetRounding( Style_Model::ButtonRadius );
 629         if ( !toolbutton->icon.isNull() )
 630           aMinDelta = Style_Tools::getMinDelta( toolbutton->rect, toolbutton->iconSize, aMinDelta );
 631         bool aStateOn = opt->state & ( State_Sunken | State_On );
 632         QColor aBtnCol = opt->palette.color( QPalette::Button ),
 633                top    = aBtnCol.light( BUT_PERCENT_COL ),
 634                bottom = aBtnCol.dark( BUT_PERCENT_COL );
 635         bool isMenuBtn = toolbutton->features == QStyleOptionToolButton::Menu;
 636         bool antialized = model()->antialiasing();
 637         bool isAutoRaising = model()->widgetEffect() == Style_Model::AutoRaiseEffect;
 638         bool isHighWdg     = model()->widgetEffect() == Style_Model::HighlightEffect;
 639         bool hover = hasHover() && (opt->state & State_Enabled) && ( opt->state & State_MouseOver );
 640         QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
 641         QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
 642         QRect aRect = button;
 643         int aType = isMenuBtn ? Style_Tools::Left : Style_Tools::All;
 644         if ( toolbutton->subControls & SC_ToolButton ) {
 645           if ( isAutoRaising && hover && !aStateOn )
 646             Style_Tools::shadowRect( p, aRect, aMinDelta, -1, SHADOW, aType, bottom, top, aBrdTopCol,
 647                                      aBrdBotCol, antialized, true, aStateOn );
 648           else if ( isHighWdg && hover && !aStateOn )
 649             drawHoverRect( p, aRect, opt->palette.color( QPalette::Window ), aMinDelta, aType, true );
 650           else
 651             Style_Tools::shadowRect( p, aRect, aMinDelta, -1, SHADOW, aType, top, bottom,
 652                                      aBrdTopCol, aBrdBotCol, antialized, true, aStateOn );
 653         }
 654         if (toolbutton->subControls & SC_ToolButtonMenu) {
 655           p->save();
 656           if ( aMinDelta > menuArea.height()/2 )
 657             aMinDelta = menuArea.height()/2;
 658           if ( aMinDelta > menuArea.width()/2 )
 659             aMinDelta = menuArea.width()/2;
 660           aRect = menuArea;
 661           aType = isMenuBtn ? Style_Tools::Right : Style_Tools::All;
 662           if ( isAutoRaising && hover && !aStateOn )
 663             Style_Tools::shadowRect( p, aRect, aMinDelta, -1, SHADOW, aType, bottom, top,
 664                                      aBrdTopCol, aBrdBotCol, antialized, true, aStateOn );
 665           else if ( isHighWdg && hover && !aStateOn )
 666             drawHoverRect( p, aRect, opt->palette.color( QPalette::Window ), aMinDelta, aType, true );
 667           else
 668             Style_Tools::shadowRect( p, aRect, aMinDelta, -1, SHADOW, aType, top, bottom,
 669                                      aBrdTopCol, aBrdBotCol, antialized, true, aStateOn );
 670           QStyleOption tool(0);
 671           tool.palette = toolbutton->palette;
 672           tool.rect = menuArea;
 673           State bflags = toolbutton->state;
 674           if (bflags & State_AutoRaise) {
 675               if (!(bflags & State_MouseOver)) {
 676                   bflags &= ~State_Raised;
 677               }
 678           }
 679           State mflags = bflags;
 680             if (toolbutton->activeSubControls & SC_ToolButton)
 681                 bflags |= State_Sunken;
 682             if (toolbutton->activeSubControls & SC_ToolButtonMenu)
 683                 mflags |= State_Sunken;
 684           tool.state = mflags;
 685           drawPrimitive(PE_IndicatorArrowDown, &tool, p, w);
 686           p->restore();
 687         }
 688
 689         if (toolbutton->state & State_HasFocus) {
 690           QStyleOptionFocusRect fr;
 691           fr.QStyleOption::operator=(*toolbutton);
 692           fr.rect.adjust(3, 3, -3, -3);
 693           if (toolbutton->features & QStyleOptionToolButton::Menu)
 694             fr.rect.adjust(0, 0, -pixelMetric(QStyle::PM_MenuButtonIndicator, toolbutton, w), 0);
 695           Style_Tools::drawFocus( p, fr.rect, aMinDelta-1,  isMenuBtn ? Style_Tools::Left :
 696                                   Style_Tools::All, aBrdBotCol );
 697         }
 698         QStyleOptionToolButton label = *toolbutton;
 699         int fw = pixelMetric( PM_DefaultFrameWidth, opt, w );
 700         label.rect = button.adjusted( fw, fw, -fw, -fw );
 701         drawControl( CE_ToolButtonLabel, &label, p, w );
 702
 703         break;
 704       }
 705     }
 706     case CC_TitleBar: {
 707       BaseStyle::drawComplexControl( cc, opt, p, w );
 708       break;
 709     }
 710     case CC_GroupBox:
 711       if (const QStyleOptionGroupBox *groupBox = qstyleoption_cast<const
 712                                                  QStyleOptionGroupBox *>(opt)) {
 713         // Draw frame
 714         QRect textRect = subControlRect( cc, opt, SC_GroupBoxLabel, w );
 715         QRect checkBoxRect = subControlRect( cc, opt, SC_GroupBoxCheckBox, w);
 716         if (groupBox->subControls & QStyle::SC_GroupBoxFrame) {
 717           QRect aRect = subControlRect( cc, opt, SC_GroupBoxFrame, w);
 718           QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop );    // Style_Model::border_tab_top_clr
 719           QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom ); // Style_Model::border_tab_bot_clr
 720           Style_Tools::shadowRect( p, aRect, model()->widgetRounding( Style_Model::FrameRadius ), 0.,
 721                                    SHADOW, Style_Tools::All,
 722                                    model()->color( Style_Model::FieldLight ), // Style_Model::fld_light_clr
 723                                    model()->color( Style_Model::FieldDark ),  // Style_Model::fld_dark_clr
 724                                    aBrdTopCol, aBrdBotCol, false, false, false, false);
 725         }
 726         // Draw title
 727         if ((groupBox->subControls & QStyle::SC_GroupBoxLabel) && !groupBox->text.isEmpty()) {
 728           QColor textColor = groupBox->textColor;
 729           if (textColor.isValid())
 730             p->setPen(textColor);
 731           int alignment = int(groupBox->textAlignment);
 732           if (!styleHint(QStyle::SH_UnderlineShortcut, opt, w))
 733             alignment |= Qt::TextHideMnemonic;
 734           QColor aColor = opt->palette.color( QPalette::Window );
 735           Style_Tools::arrowRect( p, textRect, opt->palette.color( QPalette::Dark ),
 736                                  aColor.dark(BUT_PERCENT_COL), aColor );
 737           drawItemText(p, textRect,  Qt::TextShowMnemonic | Qt::AlignHCenter | alignment,
 738                        pal, groupBox->state & State_Enabled, groupBox->text,
 739                        textColor.isValid() ? QPalette::NoRole : QPalette::WindowText);
 740           if (groupBox->state & State_HasFocus) {
 741             QStyleOptionFocusRect fropt;
 742             fropt.QStyleOption::operator=(*groupBox);
 743             fropt.rect = textRect;
 744             drawPrimitive(PE_FrameFocusRect, &fropt, p, w);
 745           }
 746         }
 747         // Draw checkbox
 748         if (groupBox->subControls & SC_GroupBoxCheckBox) {
 749             QStyleOptionButton box;
 750           box.QStyleOption::operator=(*groupBox);
 751           box.rect = checkBoxRect;
 752           drawPrimitive(PE_IndicatorCheckBox, &box, p, w);
 753         }
 754         break;
 755       }
 756     case CC_Dial: {
 757       BaseStyle::drawComplexControl( cc, opt, p, w );
 758       break;
 759     }
 760     default:
 761       BaseStyle::drawComplexControl( cc, opt, p, w );
 762   }
 763 }
 764
 765 /*!
 766   \brief Draws the given element with the provided painter \p with the style options specified by \a opt.
 767   \param ce control element type
 768   \param opt style option
 769   \param p painter
 770   \param w widget
 771 */
 772 void Style_Salome::drawControl( ControlElement ce, const QStyleOption* opt,
 773                                QPainter* p, const QWidget* w ) const
 774 {
 775   if ( checkDebugLevel(5) ) {
 776     BaseStyle::drawControl( ce, opt, p, w );
 777     return;
 778   }
 779
 780   switch ( ce ) {
 781     case CE_PushButton:
 782       if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
 783         drawControl(CE_PushButtonBevel, btn, p, w);
 784         QStyleOptionButton subopt = *btn;
 785         subopt.rect = subElementRect(SE_PushButtonContents, btn, w);
 786         drawControl(CE_PushButtonLabel, &subopt, p, w);
 787         if (btn->state & State_HasFocus) {
 788           QRect aRect = subElementRect( SE_PushButtonFocusRect, btn, w );
 789           Style_Tools::drawFocus( p, aRect, model()->widgetRounding( Style_Model::ButtonRadius ),
 790                                   Style_Tools::All, model()->color( Style_Model::BorderBottom ) );
 791         }
 792         break;
 793       }
 794     case CE_PushButtonBevel:
 795       if ( const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt) ) {
 796         double aRad = model()->widgetRounding( Style_Model::ButtonRadius );
 797         bool aStateOn = opt->state & ( State_Sunken | State_On );
 798         bool isAutoRaising = model()->widgetEffect() == Style_Model::AutoRaiseEffect;
 799         bool isHighWdg     = model()->widgetEffect() == Style_Model::HighlightEffect;
 800         bool enabled = opt->state & State_Enabled;
 801         bool hover = hasHover() && enabled && ( opt->state & State_MouseOver );
 802
 803         QColor aBtnCol = opt->palette.color( QPalette::Button );
 804         QColor top = aBtnCol.light( BUT_PERCENT_COL ),
 805                bottom = aBtnCol.dark( BUT_PERCENT_COL );
 806         QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
 807         QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
 808         QRect r = opt->rect;
 809         bool antialized = model()->antialiasing();
 810         if ( isAutoRaising && hover && !aStateOn )
 811           Style_Tools::shadowRect( p, r, aRad, -1, SHADOW, Style_Tools::All, bottom, top,
 812                                    aBrdTopCol, aBrdBotCol, antialized, true, aStateOn );
 813         else if ( isHighWdg && hover && !aStateOn )
 814           drawHoverRect( p, r, opt->palette.color( QPalette::Window ), aRad, Style_Tools::All, true );
 815         else
 816           Style_Tools::shadowRect( p, r, aRad, -1, SHADOW, Style_Tools::All, top, bottom,
 817                                    aBrdTopCol, aBrdBotCol, antialized, true, aStateOn );
 818         if (btn->features & QStyleOptionButton::HasMenu) {
 819           int mbi = pixelMetric(PM_MenuButtonIndicator, btn, w);
 820           QStyleOptionButton newBtn = *btn;
 821           newBtn.rect = QRect(r.right() - mbi-2, r.height()/2 - mbi/2, mbi, mbi);
 822           drawPrimitive(PE_IndicatorArrowDown, &newBtn, p, w);
 823         }
 824         break;
 825       }
 826       case CE_DockWidgetTitle:
 827         if (const QStyleOptionDockWidget *dwOpt = qstyleoption_cast<const QStyleOptionDockWidget *>(opt)) {
 828           bool floating = false;
 829           int menuOffset = 0; //used to center text when floated
 830           QColor inactiveCaptionTextColor = opt->palette.color( QPalette::HighlightedText );
 831           const QDockWidget *dockWidget = qobject_cast<const QDockWidget *>(w);
 832           //Titlebar gradient
 833           if (dockWidget) {
 834             if ( dockWidget->isFloating() && dwOpt->movable) {
 835               floating = true;
 836               QColor top = opt->palette.color( QPalette::Highlight ).light();
 837               QColor bottom = opt->palette.color( QPalette::Highlight );
 838               menuOffset = 2;
 839               QBrush fillBrush(bottom);
 840               if (top != bottom) {
 841                 QPoint p1(dwOpt->rect.x(), dwOpt->rect.y());
 842                 QPoint p2(dwOpt->rect.x(), dwOpt->rect.bottom() );
 843                 QLinearGradient lg(p1, p2);
 844                 lg.setColorAt(0, top);
 845                 lg.setColorAt(1, bottom);
 846                 fillBrush = lg;
 847               }
 848               p->fillRect(dwOpt->rect.adjusted(0, 0, 0, -3), fillBrush);
 849             }
 850             else {
 851               QRect r = dwOpt->rect.adjusted(0, 0, -1, -1);
 852               QColor bottom = opt->palette.color( QPalette::Window ),
 853                      top =    bottom.dark( BUT_PERCENT_COL );
 854               QRect aRect = dwOpt->rect;
 855               QLinearGradient gr( aRect.x(), aRect.y(), aRect.x(), aRect.y()+aRect.height() );
 856               gr.setColorAt( 0.0, top );
 857               gr.setColorAt( 0.4, bottom );
 858               gr.setColorAt( 0.6, bottom );
 859               gr.setColorAt( 1.0, top );
 860               p->fillRect( r, gr );
 861
 862               QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop );     // Style_Model::border_tab_top_clr
 863               QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom );  // Style_Model::border_tab_bot_clr
 864               p->setPen( aBrdTopCol );
 865               p->drawLine( r.x(), r.bottom(), r.x(), r.y() );
 866               p->drawLine( r.x(), r.y(), r.right(), r.y() );
 867               p->setPen( aBrdBotCol );
 868               p->drawLine( r.x(), r.bottom(), r.right(), r.bottom() );
 869               p->drawLine( r.right(), r.bottom(), r.right(), r.y() );
 870             }
 871           }
 872           p->setPen(dwOpt->palette.color(QPalette::Light));
 873
 874           QString aTitle = dwOpt->title;
 875           if (!aTitle.isEmpty()) {
 876             int aMargin  = pixelMetric(QStyle::PM_DockWidgetTitleMargin, dwOpt, w);
 877             const int indent = p->fontMetrics().descent();
 878             QRect r = dwOpt->rect.adjusted(indent + 1, - menuOffset, -indent - 1, -1);
 879             QPixmap aPxm = standardPixmap( SP_DockWidgetCloseButton, opt, w);
 880             int aWidth = r.width() - aPxm.width()-2/*button margins*/;
 881             aPxm = standardPixmap( SP_TitleBarNormalButton, opt, w);
 882             aWidth = aWidth - aPxm.width()-2/*button margins*/;
 883             r = QRect( r.x(), r.y(), aWidth-aMargin-2/*buttons separator*/-2/*margin from text*/, r.height() );
 884
 885             QFont oldFont = p->font();
 886             QFont font = oldFont;
 887             if (floating) {
 888               font.setBold(true);
 889               p->setFont(font);
 890             }
 891             aTitle = titleText( aTitle, r.width(), r.height(), font );
 892
 893             QPalette palette = dwOpt->palette;
 894             palette.setColor(QPalette::Window, inactiveCaptionTextColor);
 895             bool active = dwOpt->state & State_Active;
 896             //const int indent = p->fontMetrics().descent();
 897             drawItemText(p, r, Qt::AlignLeft | Qt::AlignVCenter, palette,
 898                          dwOpt->state & State_Enabled, aTitle,
 899                          floating ? (active ? QPalette::BrightText : QPalette::Window) : QPalette::WindowText);
 900             p->setFont(oldFont);
 901           }
 902           break;
 903         }
 904     case CE_Splitter: {
 905       BaseStyle::drawControl( ce, opt, p, w );
 906       QRect r = opt->rect;
 907       bool horiz = r.width() > r.height();
 908       int aLen = model()->splitHandleLength();
 909       if ( horiz )
 910         r = QRect( r.x() +(int)((r.width()-aLen)/2), r.y(), aLen, r.height());
 911       else
 912         r = QRect( r.x(), r.y() +(int)((r.height()-aLen)/2), r.width(), aLen);
 913       drawHandle( p, r, horiz, true );
 914       break;
 915     }
 916     case CE_TabBarTabShape:
 917       if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(opt)) {
 918         if (tab->shape == QTabBar::RoundedNorth || tab->shape == QTabBar::RoundedEast ||
 919             tab->shape == QTabBar::RoundedSouth || tab->shape == QTabBar::RoundedWest) {
 920           p->save();
 921           QRect tabRect = opt->rect;
 922           // line under selected tab bar object
 923           bool isSelected = opt->state & State_Selected;
 924           bool isLast = tab->position == QStyleOptionTab::End ||
 925                         tab->position == QStyleOptionTab::OnlyOneTab;
 926           QColor aColor = opt->palette.color( QPalette::Window ),
 927                  aDarkColor = aColor.dark( BUT_PERCENT_ON );
 928           QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop );     // Style_Model::border_tab_top_clr
 929           QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom );  // Style_Model::border_tab_bot_clr
 930
 931           bool isHover = hasHover() && (opt->state & State_Enabled) &&
 932                                        (opt->state & State_MouseOver);
 933           if ( isHover && !isSelected && model()->widgetEffect() == Style_Model::HighlightEffect ) {
 934             aColor     = model()->color( Style_Model::HighlightWidget ); // Style_Model::high_wdg_clr
 935             aDarkColor = model()->color( Style_Model::HighlightBorder ); // Style_Model::high_brd_wdg_clr
 936           }
 937           Style_Tools::tabRect( p, tabRect, (int)tab->shape,
 938                                 model()->widgetRounding( Style_Model::FrameRadius ),
 939                                 DELTA_H_TAB, aColor, aDarkColor,
 940                                 aBrdTopCol, aBrdBotCol, isSelected, isLast, isHover );
 941           p->restore();
 942         } else
 943            QCommonStyle::drawControl( ce, opt, p, w );
 944         break;
 945       }
 946     case CE_TabBarTabLabel:
 947       if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(opt)) {
 948         if ( tab->position == QStyleOptionTab::End ||
 949              tab->position == QStyleOptionTab::OnlyOneTab ) {
 950           QRect oldRect = opt->rect;
 951           int aDelta = 0;
 952           if ( tab->shape == QTabBar::RoundedNorth || tab->shape == QTabBar::RoundedSouth ) {
 953             aDelta = (int)(opt->rect.height()*DELTA_H_TAB/2);
 954             oldRect = QRect( oldRect.topLeft(), QPoint( oldRect.right()-aDelta, oldRect.bottom() ) );
 955           }
 956           else {
 957             aDelta = (int)(opt->rect.width()*DELTA_H_TAB/2);
 958             oldRect = QRect( oldRect.topLeft(), QPoint( oldRect.right(), oldRect.bottom()-aDelta ) );
 959           }
 960           QStyleOptionTab* copyTab = (QStyleOptionTab*)tab;
 961           copyTab->rect = oldRect;
 962           BaseStyle::drawControl( ce, copyTab, p, w );
 963         }
 964         else
 965           BaseStyle::drawControl( ce, opt, p, w );
 966         break;
 967       }
 968     case CE_MenuBarItem:
 969       if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(opt)) {
 970         if ( w )
 971           drawBackground( p, w->rect(), opt->palette.color( QPalette::Window ), true, true, true );
 972         bool active = mbi->state & State_Selected;
 973         bool hasFocus = mbi->state & State_HasFocus;
 974         bool down = mbi->state & State_Sunken;
 975         QStyleOptionMenuItem newMbi = *mbi;
 976         if (active || hasFocus) {
 977           QBrush b( opt->palette.color( QPalette::Window ) );
 978           if (active && down)
 979             p->setBrushOrigin(p->brushOrigin() + QPoint(1, 1));
 980           if ( active && hasFocus) {
 981             bool aStateOn = opt->state & (State_Sunken | State_On);
 982             QColor aBtnCol = opt->palette.color( QPalette::Window ),
 983                    top =    aBtnCol.light( BUT_PERCENT_ON ),
 984                    bottom = aBtnCol.dark( BUT_PERCENT_ON );
 985             QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
 986             QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
 987             bool aHighWdg = model()->widgetEffect() == Style_Model::HighlightEffect;
 988             if ( !aStateOn && aHighWdg && (opt->state & State_Enabled) &&
 989                  (opt->state & State_Selected) )
 990               drawHoverRect(p, opt->rect, opt->palette.color( QPalette::Window ), 0, Style_Tools::All, true);
 991             else {
 992               Style_Tools::shadowRect( p, opt->rect, 0, 0., SHADOW, Style_Tools::All, top, bottom,
 993                                    aBrdTopCol, aBrdBotCol,
 994                                    model()->antialiasing(), true, aStateOn );
 995             }
 996           }
 997           if (active && down) {
 998             newMbi.rect.translate(pixelMetric(PM_ButtonShiftHorizontal, mbi, w),
 999                                   pixelMetric(PM_ButtonShiftVertical, mbi, w));
1000             p->setBrushOrigin(p->brushOrigin() - QPoint(1, 1));
1001           }
1002         }
1003         QCommonStyle::drawControl(ce, &newMbi, p, w);
1004         break;
1005       }
1006     case CE_MenuBarEmptyArea:
1007       drawBackground( p, opt->rect, opt->palette.color( QPalette::Window ), true, true, true );
1008       break;
1009     case CE_ProgressBarGroove: {
1010       QColor aBgColor = opt->palette.color( QPalette::Window ),
1011         top =    aBgColor.light( BUT_PERCENT_ON ),
1012         bottom = aBgColor.dark( BUT_PERCENT_ON );
1013       QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
1014       QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
1015       Style_Tools::shadowRect( p, opt->rect, model()->widgetRounding( Style_Model::EditRadius ), -1,
1016                                SHADOW, Style_Tools::All, top, bottom, aBrdTopCol, aBrdBotCol,
1017                                model()->antialiasing(), true );
1018       break;
1019       }
1020     case CE_ProgressBarLabel:
1021       if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(opt)) {
1022         // implementation from qplastiquestyle
1023         // The busy indicator doesn't draw a label
1024         if (bar->minimum == 0 && bar->maximum == 0)
1025           return;
1026         p->save();
1027         QRect rect = bar->rect;
1028         QRect leftRect;
1029         p->setPen(bar->palette.text().color());
1030
1031         bool vertical = false;
1032         bool inverted = false;
1033         bool bottomToTop = false;
1034         // Get extra style options if version 2
1035         if (const QStyleOptionProgressBarV2 *bar2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(opt)) {
1036           vertical = (bar2->orientation == Qt::Vertical);
1037           inverted = bar2->invertedAppearance;
1038           bottomToTop = bar2->bottomToTop;
1039         }
1040         if (vertical) {
1041           rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // flip width and height
1042           QMatrix m;
1043           if (bottomToTop) {
1044             m.translate(0.0, rect.width());
1045             m.rotate(-90);
1046           } else {
1047             m.translate(rect.height(), 0.0);
1048             m.rotate(90);
1049           }
1050           p->setMatrix(m);
1051         }
1052         int progressIndicatorPos = int(((bar->progress - bar->minimum) / double(bar->maximum - bar->minimum)) * rect.width());
1053         bool flip = (!vertical && (((bar->direction == Qt::RightToLeft) && !inverted)
1054                     || ((bar->direction == Qt::LeftToRight) && inverted))) || (vertical && ((!inverted && !bottomToTop) || (inverted && bottomToTop)));
1055         if (flip) {
1056           int indicatorPos = rect.width() - progressIndicatorPos;
1057           if (indicatorPos >= 0 && indicatorPos <= rect.width()) {
1058             p->setPen(bar->palette.base().color());
1059             leftRect = QRect(rect.left(), rect.top(), indicatorPos, rect.height());
1060           } else if (indicatorPos > rect.width()) {
1061             p->setPen(bar->palette.text().color());
1062           } else {
1063             p->setPen(bar->palette.base().color());
1064           }
1065         } else {
1066           if (progressIndicatorPos >= 0 && progressIndicatorPos <= rect.width()) {
1067             leftRect = QRect(rect.left(), rect.top(), progressIndicatorPos, rect.height());
1068           } else if (progressIndicatorPos > rect.width()) {
1069             p->setPen(bar->palette.base().color());
1070           } else {
1071             p->setPen(bar->palette.text().color());
1072           }
1073         }
1074
1075         p->drawText(rect, bar->text, QTextOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter));
1076         if (!leftRect.isNull()) {
1077           p->setPen(flip ? bar->palette.text().color() : bar->palette.base().color());
1078           p->setClipRect(leftRect, Qt::IntersectClip);
1079           p->drawText(rect, bar->text, QTextOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter));
1080         }
1081         p->restore();
1082       }
1083       break;
1084     case CE_ProgressBarContents:
1085       if (const QStyleOptionProgressBar *pb = qstyleoption_cast<const QStyleOptionProgressBar *>(opt)) {
1086         QRect rect = pb->rect;
1087         bool vertical = false;
1088         bool inverted = false;
1089         // Get extra style options if version 2
1090         const QStyleOptionProgressBarV2 *pb2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(opt);
1091         if (pb2) {
1092           vertical = (pb2->orientation == Qt::Vertical);
1093           inverted = pb2->invertedAppearance;
1094         }
1095         QMatrix m;
1096         if (vertical) {
1097           rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // flip width and height
1098           m.translate(rect.height(), 0.0);
1099           m.rotate(90);
1100         }
1101         QPalette pal2 = pb->palette;
1102         // Correct the highlight color if it is the same as the background
1103         if (pal2.highlight() == pal2.background())
1104             pal2.setColor(QPalette::Highlight, pb->palette.color(QPalette::Active,
1105                                                                  QPalette::Highlight));
1106         bool reverse = ((!vertical && (pb->direction == Qt::RightToLeft)) || vertical);
1107         if (inverted)
1108           reverse = !reverse;
1109         int fw = 2;
1110         int width = rect.width() - 2 * fw;
1111         if (pb->minimum == 0 && pb->maximum == 0) {
1112           // draw busy indicator
1113           int x = (pb->progress - pb->minimum) % (width * 2);
1114           if (x > width)
1115             x = 2 * width - x;
1116           x = reverse ? rect.right() - x : x + rect.x();
1117           p->setPen(QPen(pal2.highlight().color(), 4));
1118           p->drawLine(x, rect.y() + 1, x, rect.height() - fw);
1119         } else {
1120           const int unit_width = pixelMetric(PM_ProgressBarChunkWidth, pb, w);
1121           int u;
1122           if (unit_width > 1)
1123             u = (rect.width() + unit_width / 3) / unit_width;
1124           else
1125             u = width / unit_width;
1126
1127           int p_v = pb->progress - pb->minimum;
1128           int t_s = pb->maximum - pb->minimum ? pb->maximum - pb->minimum : 1;
1129
1130           if (u > 0 && p_v >= INT_MAX / u && t_s >= u) {
1131             // scale down to something usable.
1132             p_v /= u;
1133             t_s /= u;
1134           }
1135
1136           // nu < tnu, if last chunk is only a partial chunk
1137           int tnu, nu;
1138           tnu = nu = p_v * u / t_s;
1139
1140           if (nu * unit_width > width)
1141             --nu;
1142
1143           // Draw nu units out of a possible u of unit_width
1144           // width, each a rectangle bordered by background
1145           // color, all in a sunken panel with a percentage text
1146           // display at the end.
1147           int x = 0;
1148           int x0 = reverse ? rect.right() - ((unit_width > 1) ? unit_width : fw)
1149                            : rect.x() + fw;
1150           QStyleOptionProgressBarV2 pbBits = *pb;
1151           pbBits.rect = rect;
1152           pbBits.palette = pal2;
1153           int myY = pbBits.rect.y();
1154           int myHeight = pbBits.rect.height();
1155           pbBits.state = State_None;
1156           QRect aRect;
1157           QColor aColor = model()->color( Style_Model::ProgressBar );    // Style_Model::prbar_clr
1158           QColor top    = aColor.light( BUT_PERCENT_COL );
1159           QColor bottom = aColor.dark( BUT_PERCENT_COL );
1160           int aType;
1161           for (int i = 0; i <= nu; ++i) {
1162             aType = Style_Tools::None;
1163             if ( i < nu ) { // not last element
1164               aRect = QRect(x0 + x, myY, unit_width, myHeight);
1165               if ( i == 0 ) {
1166                 if ( reverse )
1167                   aRect.setRight( aRect.right()-fw );
1168                 if ( vertical )
1169                   aType = reverse ? Style_Tools::BottomLeft | Style_Tools::BottomRight
1170                                   : Style_Tools::TopLeft | Style_Tools::TopRight;
1171                 else
1172                   aType = reverse ? Style_Tools::Right : Style_Tools::Left;
1173               }
1174             }
1175             else { // last element if it's necessary
1176               if ( nu >= tnu )
1177                 break;
1178               int pixels_left = width - (nu * unit_width);
1179               int offset = reverse ? x0 + x + unit_width-pixels_left : x0 + x;
1180               aRect = QRect(offset, myY, pixels_left, myHeight);
1181               if ( vertical )
1182                 aType = reverse ? Style_Tools::TopLeft | Style_Tools::TopRight
1183                                 : Style_Tools::BottomLeft | Style_Tools::BottomRight;
1184               else
1185                 aType = reverse ? Style_Tools::Left : Style_Tools::Right;
1186             }
1187             // display
1188             aRect = m.mapRect(aRect);
1189             if ( vertical )
1190               aRect = QRect(aRect.x(), aRect.y()+fw, aRect.width(), aRect.height());
1191
1192             if ( !vertical )
1193               aRect = QRect(aRect.x()+1, aRect.y()+2, aRect.width()-1,
1194                             aRect.height()-4);
1195             else
1196               aRect = QRect(aRect.x()+1, aRect.y()-1, aRect.width()-5, aRect.height()-1);
1197             QColor aTopClr = aColor, aBotClr = aColor;
1198             if ( unit_width > 1 ) {
1199               aTopClr = aColor.light();
1200               aBotClr = aColor.dark();
1201             }
1202             Style_Tools::shadowRect( p, aRect, model()->widgetRounding( Style_Model::EditRadius ), -1, 0,
1203                                      aType, top, bottom, aTopClr, aBotClr, false, true );
1204             x += reverse ? -unit_width : unit_width;
1205           }
1206         }
1207       }
1208       break;
1209     case CE_MenuItem:
1210       if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(opt)) {
1211         const int windowsItemFrame    =  2; // definitions from qwindowstyle.cpp file
1212         const int windowsItemHMargin  =  3;
1213         const int windowsItemVMargin  =  2;
1214         const int windowsRightBorder  = 15;
1215         const int windowsArrowHMargin =  6;
1216         int x, y, width, h;
1217         menuitem->rect.getRect(&x, &y, &width, &h);
1218         int tab = menuitem->tabWidth;
1219         bool dis = !(menuitem->state & State_Enabled);
1220         bool checked = menuitem->checkType != QStyleOptionMenuItem::NotCheckable
1221                        ? menuitem->checked : false;
1222         bool act = menuitem->state & State_Selected;
1223
1224         // windows always has a check column, regardless whether we have an icon or not
1225         int checkcol = qMax(menuitem->maxIconWidth, 20);
1226
1227         QColor aBgColor = opt->palette.color( QPalette::Window );
1228         double aMargin = LINE_GR_MARGIN;
1229         QLinearGradient gr(x,y,menuitem->rect.right(),y);
1230         gr.setColorAt( 0.0, aBgColor );
1231         gr.setColorAt( aMargin/width, model()->color( Style_Model::FieldLight ) ); // Style_Model::fld_light_clr
1232         gr.setColorAt( 1.0, model()->color( Style_Model::FieldLight ) );
1233         QBrush fill;
1234         if ( act )
1235           fill = menuitem->palette.brush( QPalette::Highlight );
1236         else
1237           fill = QBrush( gr );
1238         p->fillRect(menuitem->rect, fill);
1239         if (menuitem->menuItemType == QStyleOptionMenuItem::Separator){
1240           int yoff = y-1 + h / 2;
1241           QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop );    // Style_Model::border_tab_top_clr
1242           QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom ); // Style_Model::border_tab_bot_clr
1243           p->setPen( aBrdBotCol );
1244           p->drawLine(x + 2, yoff, x + width - 4, yoff);
1245           p->setPen( aBrdTopCol );
1246           p->drawLine(x + 2, yoff + 1, x + width - 4, yoff + 1);
1247           return;
1248         }
1249         QRect vCheckRect = visualRect(opt->direction, menuitem->rect, QRect(menuitem->rect.x(),
1250                                       menuitem->rect.y(), checkcol, menuitem->rect.height()));
1251         if (checked) {
1252           if (act && !dis)
1253             qDrawShadePanel(p, vCheckRect, menuitem->palette, true, 1, new QBrush(aBgColor));
1254           else {
1255             QColor aCol = aBgColor;
1256             aCol.setAlpha( 80 );
1257             QBrush fill(aCol);
1258             qDrawShadePanel(p, vCheckRect, menuitem->palette, true, 1, &fill);
1259           }
1260         } else if (!act)
1261           p->fillRect(vCheckRect, QBrush( gr ) );
1262         // On Windows Style, if we have a checkable item and an icon we
1263         // draw the icon recessed to indicate an item is checked. If we
1264         // have no icon, we draw a checkmark instead.
1265         if (!menuitem->icon.isNull()) {
1266           QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal;
1267           if (act && !dis)
1268             mode = QIcon::Active;
1269           QPixmap pixmap;
1270           if (checked)
1271             pixmap = menuitem->icon.pixmap(pixelMetric(PM_SmallIconSize), mode, QIcon::On);
1272           else
1273             pixmap = menuitem->icon.pixmap(pixelMetric(PM_SmallIconSize), mode);
1274           int pixw = pixmap.width();
1275           int pixh = pixmap.height();
1276           if (act && !dis && !checked)
1277             qDrawShadePanel(p, vCheckRect,  menuitem->palette, false, 1,
1278                             new QBrush(aBgColor));
1279           QRect pmr(0, 0, pixw, pixh);
1280           pmr.moveCenter(vCheckRect.center());
1281           p->setPen(menuitem->palette.text().color());
1282           p->drawPixmap(pmr.topLeft(), pixmap);
1283         } else if (checked) {
1284           QStyleOptionMenuItem newMi = *menuitem;
1285           newMi.state = State_None;
1286           if (!dis)
1287             newMi.state |= State_Enabled;
1288           if (act)
1289             newMi.state |= State_On;
1290           newMi.rect = visualRect(opt->direction, menuitem->rect,
1291           QRect(menuitem->rect.x() + windowsItemFrame, menuitem->rect.y() + windowsItemFrame,
1292                 checkcol - 2 * windowsItemFrame, menuitem->rect.height() - 2*windowsItemFrame));
1293           drawPrimitive(PE_IndicatorMenuCheckMark, &newMi, p, w);
1294         }
1295         p->setPen(act ? menuitem->palette.highlightedText().color() :
1296                         menuitem->palette.buttonText().color());
1297         QColor discol;
1298         if (dis) {
1299           discol = menuitem->palette.text().color();
1300           p->setPen(discol);
1301         }
1302         int xm = windowsItemFrame + checkcol + windowsItemHMargin;
1303         int xpos = menuitem->rect.x() + xm;
1304         QRect textRect(xpos, y + windowsItemVMargin, width - xm - windowsRightBorder - tab + 1,
1305                        h - 2 * windowsItemVMargin);
1306         QRect vTextRect = visualRect(opt->direction, menuitem->rect, textRect);
1307         QString s = menuitem->text;
1308         if (!s.isEmpty()) {                     // draw text
1309           p->save();
1310           int t = s.indexOf(QLatin1Char('\t'));
1311           int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip |
1312                            Qt::TextSingleLine;
1313           if (!styleHint(SH_UnderlineShortcut, menuitem, w))
1314             text_flags |= Qt::TextHideMnemonic;
1315           text_flags |= Qt::AlignLeft;
1316           if (t >= 0) {
1317             QRect vShortcutRect = visualRect(opt->direction, menuitem->rect,
1318             QRect(textRect.topRight(), QPoint(menuitem->rect.right(), textRect.bottom())));
1319             if (dis && !act) {
1320                p->setPen(menuitem->palette.light().color());
1321                p->drawText(vShortcutRect.adjusted(1,1,1,1), text_flags, s.mid(t + 1));
1322                p->setPen(discol);
1323              }
1324              p->drawText(vShortcutRect, text_flags, s.mid(t + 1));
1325              s = s.left(t);
1326           }
1327           QFont font = menuitem->font;
1328           if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem)
1329             font.setBold(true);
1330             p->setFont(font);
1331             if (dis && !act) {
1332               p->setPen(menuitem->palette.light().color());
1333               p->drawText(vTextRect.adjusted(1,1,1,1), text_flags, s.left(t));
1334               p->setPen(discol);
1335             }
1336             p->drawText(vTextRect, text_flags, s.left(t));
1337             p->restore();
1338           }
1339           if (menuitem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow
1340             int dim = (h - 2 * windowsItemFrame) / 2;
1341             PrimitiveElement arrow;
1342             arrow = (opt->direction == Qt::RightToLeft) ? PE_IndicatorArrowLeft :
1343                      PE_IndicatorArrowRight;
1344             xpos = x + width - windowsArrowHMargin - windowsItemFrame - dim;
1345             QRect  vSubMenuRect = visualRect(opt->direction, menuitem->rect,
1346                                              QRect(xpos, y + h / 2 - dim / 2, dim, dim));
1347             QStyleOptionMenuItem newMI = *menuitem;
1348             newMI.rect = vSubMenuRect;
1349             newMI.state = dis ? State_None : State_Enabled;
1350             if (act)
1351               newMI.palette.setColor(QPalette::ButtonText,
1352                                      newMI.palette.highlightedText().color());
1353             drawPrimitive(arrow, &newMI, p, w);
1354           }
1355         }
1356       break;
1357       /*
1358     case CE_ToolBoxTab:
1359       QCommonStyle::drawControl( ce, opt, p, w );
1360       break;
1361       */
1362     case CE_HeaderSection: {
1363       bool aStateOn = opt->state & State_On;
1364       QColor aColor = model()->color( Style_Model::Header );    // Style_Model::header_clr
1365       QColor  top =    aColor.light( BUT_PERCENT_COL ),
1366              bottom =  aColor.dark( BUT_PERCENT_COL );
1367       QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
1368       QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
1369       Style_Tools::shadowRect( p, opt->rect, 0, -1, 0, Style_Tools::All, top, bottom, aBrdTopCol,
1370                        aBrdBotCol, model()->antialiasing(), true, aStateOn );
1371       break;
1372     }
1373     case CE_ComboBoxLabel:
1374       if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
1375         QRect editRect = subControlRect(CC_ComboBox, cb, SC_ComboBoxEditField, w);
1376         p->save();
1377         p->setClipRect(editRect);
1378         if (!cb->currentIcon.isNull()) {
1379           QIcon::Mode mode = cb->state & State_Enabled ? QIcon::Normal
1380                                                        : QIcon::Disabled;
1381           QPixmap pixmap = cb->currentIcon.pixmap(cb->iconSize, mode);
1382           QRect iconRect(editRect);
1383           iconRect.setWidth(cb->iconSize.width() + 4);
1384           QRect alignRect = editRect;
1385           if ( cb->editable ) {
1386             int aHalfRect = (int)Style_Tools::getMaxRect( iconRect,
1387                                (int)model()->widgetRounding( Style_Model::EditRadius )/2 );
1388             alignRect.setLeft( alignRect.left() + aHalfRect );
1389             alignRect.setRight( alignRect.right() - aHalfRect );
1390           }
1391           iconRect = alignedRect(QApplication::layoutDirection(),
1392                                  Qt::AlignLeft | Qt::AlignVCenter,
1393                                  iconRect.size(), alignRect);
1394
1395           // Here's absent filling of pixmap on basic color for editable comboBox
1396           drawItemPixmap(p, iconRect, Qt::AlignCenter, pixmap);
1397
1398           if (cb->direction == Qt::RightToLeft)
1399             editRect.translate(-4 - cb->iconSize.width(), 0);
1400           else
1401             editRect.translate(cb->iconSize.width() + 4, 0);
1402         }
1403         if (!cb->currentText.isEmpty() && !cb->editable) {
1404           drawItemText(p, editRect.adjusted(1, 0, -1, 0), Qt::AlignLeft | Qt::AlignVCenter, cb->palette,
1405                        cb->state & State_Enabled, cb->currentText);
1406         }
1407         p->restore();
1408       }
1409       break;
1410     case CE_ScrollBarSubLine:
1411     case CE_ScrollBarAddLine: {
1412         bool aStateOn = opt->state & ( State_Sunken | State_On );
1413         QColor aBtnCol = opt->palette.color( QPalette::Button );
1414         QColor top =    aBtnCol.light( BUT_PERCENT_COL ),
1415                bottom = aBtnCol.dark( BUT_PERCENT_COL );
1416         QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
1417         QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
1418         Style_Tools::shadowRect( p, opt->rect, 0, -1, 0, Style_Tools::All, top, bottom, aBrdTopCol,
1419                                  aBrdBotCol, false, true, aStateOn, true );
1420       PrimitiveElement arrow;
1421       if (opt->state & State_Horizontal) {
1422         if (ce == CE_ScrollBarAddLine)
1423           arrow = opt->direction == Qt::LeftToRight ? PE_IndicatorArrowRight : PE_IndicatorArrowLeft;
1424         else
1425           arrow = opt->direction == Qt::LeftToRight ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;
1426       } else {
1427         if (ce == CE_ScrollBarAddLine)
1428           arrow = PE_IndicatorArrowDown;
1429         else
1430           arrow = PE_IndicatorArrowUp;
1431       }
1432       drawPrimitive(arrow, opt, p, w);
1433       break;
1434     }
1435     case CE_ScrollBarSlider:
1436       if (const QStyleOptionSlider *scrollbar = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
1437         p->save();
1438         p->setRenderHint( QPainter::Antialiasing, true );
1439         bool enabled = opt->state & State_Enabled;
1440         bool horiz = scrollbar->orientation == Qt::Horizontal;
1441         double aRad = model()->widgetRounding( Style_Model::ButtonRadius );
1442         if ( hasHover() && enabled && (opt->state & State_MouseOver) )
1443          drawHoverRect(p, opt->rect, opt->palette.color( QPalette::Window ), aRad, Style_Tools::All, false);
1444         else {
1445         QColor aColor = model()->color( Style_Model::Slider );      // Style_Model::slider_clr
1446           if ( !enabled )
1447             aColor = opt->palette.button().color();
1448           QColor top =    aColor.light( BUT_PERCENT_ON ),
1449                  bottom = aColor.dark( BUT_PERCENT_ON );
1450           QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
1451           QRect r = opt->rect;
1452           QPainterPath path = Style_Tools::roundRect( r, aRad,
1453                                                       Style_Tools::All );
1454           QLinearGradient gr;
1455           if (horiz)
1456             gr = QLinearGradient(r.x(), r.y(), r.x(), r.bottom());
1457           else
1458             gr = QLinearGradient(r.x(), r.y(), r.right(), r.y());
1459           gr.setColorAt( 0.0, bottom );
1460           gr.setColorAt( 0.5, top );
1461           gr.setColorAt( 1.0, bottom );
1462
1463           p->fillPath( path, gr );
1464           p->strokePath( path, aBrdTopCol );
1465       }
1466       p->setRenderHint( QPainter::Antialiasing, false );
1467       // draw handle
1468       QRect aRect = opt->rect;
1469       int aWidth = aRect.width(), aHeight = aRect.height();
1470       if ( aWidth > aHeight + aRad )
1471         aRect = QRect( aRect.x() + (int)((aWidth-aHeight)/2),
1472                        aRect.y(), aHeight, aHeight );
1473       else if ( aHeight > aWidth + aRad )
1474         aRect = QRect( aRect.x(), aRect.y() + (int)((aHeight-aWidth)/2),
1475                        aWidth, aWidth );
1476       else {
1477         int aRad2 = (int)(aRad/3);
1478         aRect = QRect( aRect.x()+aRad2, aRect.y()+aRad2, aRect.width()-2*aRad2, aRect.height()-2*aRad2  );
1479       }
1480       drawHandle( p, aRect, horiz, true );
1481
1482       p->restore();
1483       break;
1484     }
1485   case CE_ToolBar: {
1486     QRect r = w->rect();
1487     bool horiz = opt->state & State_Horizontal;
1488     drawBackground( p, r, opt->palette.color( QPalette::Window ), true, true, horiz );
1489     p->setRenderHint( QPainter::Antialiasing, false );
1490     drawBorder( p, r, horiz );
1491     break;
1492   }
1493   default:
1494     BaseStyle::drawControl( ce, opt, p, w );
1495     break;
1496   }
1497 }
1498
1499 /*!
1500   \brief Draws the given primitive element with the provided painter \p using the style options specified by \a opt.
1501   \param pe primitive type
1502   \param opt style option
1503   \param p painter
1504   \param w widget (optional)
1505 */
1506 void Style_Salome::drawPrimitive( PrimitiveElement pe, const QStyleOption* opt,
1507                                   QPainter* p, const QWidget* w ) const
1508 {
1509   if ( checkDebugLevel(6) ) {
1510     BaseStyle::drawPrimitive( pe, opt, p, w );
1511     return;
1512   }
1513
1514   const QPalette& pal = opt->palette;
1515   bool doRestore = false;
1516   switch ( pe ) {
1517     case PE_FrameMenu:
1518       if (qstyleoption_cast<const QStyleOptionFrame *>(opt)) {
1519         QColor aBtnCol = opt->palette.color( QPalette::Window ),
1520                top =    aBtnCol.light( BUT_PERCENT_ON ),
1521                bottom = aBtnCol.dark( BUT_PERCENT_ON );
1522         QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
1523         QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
1524         Style_Tools::shadowRect( p, opt->rect, 0, 0., SHADOW, Style_Tools::All, top,
1525                                  bottom, aBrdTopCol, aBrdBotCol, false, false, false, false );
1526         break;
1527       }
1528     case PE_PanelButtonTool : {
1529       if ( w && ( opt->state & State_Enabled ) &&
1530            ( ( qobject_cast<QToolBar*>( w->parentWidget() ) ) ||
1531              ( w->inherits("QDockWidgetTitleButton") ) ||
1532              ( w->inherits("QtxWorkstackAreaTitleButton") ) ) ) {
1533         bool aStateOn = opt->state & (State_Sunken | State_On);
1534         bool aHighWdg = model()->widgetEffect() == Style_Model::HighlightEffect;
1535         if ( !aStateOn && aHighWdg && (opt->state & State_Enabled) &&
1536              (opt->state & State_MouseOver) )
1537           drawHoverRect(p, opt->rect, opt->palette.color( QPalette::Window ), 0, Style_Tools::All, true);
1538         else {
1539           QColor aBtnCol = opt->palette.color( QPalette::Window );
1540           QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop );    // Style_Model::border_tab_top_clr
1541           QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom ); // Style_Model::border_tab_bot_clr
1542           QColor top =    aBtnCol.light( BUT_PERCENT_COL ),
1543                  bottom = aBtnCol.dark( BUT_PERCENT_COL );
1544           Style_Tools::shadowRect( p, opt->rect, 0.0, 0, SHADOW, Style_Tools::All, top, bottom,
1545            aBrdTopCol, aBrdBotCol, model()->antialiasing(), true, aStateOn );
1546         }
1547         break;
1548       }
1549       else
1550         BaseStyle::drawPrimitive( pe, opt, p, w );
1551     }
1552     break;
1553     case PE_FrameFocusRect: {
1554       if (w && qobject_cast<QTabBar*>((QWidget*)w)) {
1555         QTabBar* tabBar = qobject_cast<QTabBar*>((QWidget*)w);
1556         QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop );    // Style_Model::border_tab_top_clr
1557         QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom ); // Style_Model::border_tab_bot_clr
1558         bool isHover = hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver);
1559         Style_Tools::tabRect( p, opt->rect, (int)tabBar->shape(),
1560                               model()->widgetRounding( Style_Model::FrameRadius ), DELTA_H_TAB,
1561                               pal.color( QPalette::Window ),
1562                               model()->color( Style_Model::BorderTop ), // Style_Model::border_bot_clr
1563                               aBrdTopCol, aBrdBotCol, false, false, isHover, true );
1564       }
1565       else {
1566         BaseStyle::drawPrimitive( pe, opt, p, w );
1567       }
1568       break;
1569     }
1570     case PE_IndicatorArrowRight:
1571     case PE_IndicatorArrowLeft:
1572     case PE_IndicatorArrowUp:
1573     case PE_IndicatorArrowDown:
1574     case PE_IndicatorSpinUp:
1575     case PE_IndicatorSpinDown:
1576     case PE_IndicatorSpinPlus:
1577     case PE_IndicatorSpinMinus: {
1578       QRect rect = opt->rect;
1579       QColor pen, brush;
1580       if ( opt->state & State_Enabled ) {
1581         pen = model()->color( Style_Model::Pointer );    // Style_Model::pointer_clr
1582         brush = opt->palette.color( QPalette::Button );
1583         if ( ( opt->state & State_Sunken ) && (opt->state & State_Enabled ) )
1584           rect.moveTo( rect.x()+1, rect.y()+1 );
1585       } else {
1586         pen = opt->palette.mid().color();
1587         brush = pen;
1588       }
1589       if ( pe == PE_IndicatorSpinPlus || pe == PE_IndicatorSpinMinus )
1590         Style_Tools::drawSign( pe, p, rect, pen, brush );
1591       else
1592         Style_Tools::drawArrow( pe, p, rect, pen, brush );
1593       break;
1594     }
1595     case PE_IndicatorCheckBox: {
1596       if ( hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver) )
1597         drawHoverRect(p, w->rect(), opt->palette.color( QPalette::Window ),
1598                       model()->widgetRounding( Style_Model::EditRadius ),
1599                       Style_Tools::All, false);
1600       QBrush fill;
1601       if (opt->state & State_NoChange)
1602         fill = QBrush( opt->palette.color( QPalette::Base ), Qt::Dense4Pattern);
1603       else if (opt->state & ( State_Sunken | ~State_Enabled ) )
1604         fill = opt->palette.color( QPalette::Window );
1605       else if (opt->state & State_Enabled) {
1606         if (!(opt->state & State_Off) )
1607           fill = QBrush( model()->color( Style_Model::Checked ) ); // Style_Model::checked_clr
1608         else
1609           fill = QBrush( opt->palette.color( QPalette::Base ) );
1610       }
1611       else
1612         fill = opt->palette.color( QPalette::Window );
1613       p->save();
1614       doRestore = true;
1615       QColor color = fill.color();
1616       QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
1617       QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
1618       if ( model()->antialiasing() )
1619         p->setRenderHint( QPainter::Antialiasing, true );
1620
1621      // make sure the indicator is square
1622       QRect ir = opt->rect;
1623       if (opt->rect.width() < opt->rect.height()) {
1624         ir.setTop(opt->rect.top() + (opt->rect.height() - opt->rect.width()) / 2);
1625         ir.setHeight(opt->rect.width());
1626       } else if (opt->rect.height() < opt->rect.width()) {
1627         ir.setLeft(opt->rect.left() + (opt->rect.width() - opt->rect.height()) / 2);
1628         ir.setWidth(opt->rect.height());
1629       }
1630
1631       Style_Tools::shadowCheck( p, ir, 2., Style_Tools::All,
1632                                 color, color.dark( BUT_PERCENT_ON ), aBrdTopCol, aBrdBotCol );
1633       if ( model()->antialiasing() )
1634         p->setRenderHint( QPainter::Antialiasing, false );
1635       if (opt->state & State_NoChange)
1636         p->setPen(opt->palette.dark().color());
1637       else
1638         p->setPen(opt->palette.text().color());
1639      } // Fall through!
1640     case PE_IndicatorViewItemCheck:
1641     {
1642       if (!doRestore) {
1643         p->save();
1644         doRestore = true;
1645       }
1646       const QStyleOptionViewItem *itemViewOpt = qstyleoption_cast<const QStyleOptionViewItem *>(opt);
1647       p->setPen(itemViewOpt && itemViewOpt->showDecorationSelected
1648                 && opt->state & State_Selected ? opt->palette.highlightedText().color()
1649                 : opt->palette.text().color());
1650       if (opt->state & State_NoChange)
1651         p->setBrush( opt->palette.color( QPalette::Button ) );
1652       p->drawRect(opt->rect.x() + 1, opt->rect.y() + 1, 11, 11);
1653       if (!(opt->state & State_Off)) {
1654         QLineF lines[11];
1655         int i, xx, yy;
1656         xx = opt->rect.x() + 4;
1657         yy = opt->rect.y() + 5;
1658         for (i = 0; i < 3; ++i) {
1659           lines[i] = QLineF(xx, yy, xx, yy + 2);
1660           ++xx;
1661           ++yy;
1662         }
1663         yy -= 2;
1664         for (i = 3; i < 11; ++i) {
1665           lines[i] = QLineF(xx, yy, xx, yy+2);
1666           ++xx;
1667           --yy;
1668         }
1669         QColor aColor = model()->color( Style_Model::Pointer ); // Style_Model::pointer_clr
1670         if ( !(opt->state & State_Enabled ) )
1671           aColor = opt->palette.mid().color();
1672         if ( opt->state & State_Selected && itemViewOpt && itemViewOpt->showDecorationSelected )
1673           aColor = opt->palette.highlightedText().color();
1674
1675         p->setPen( QPen( aColor ) );
1676         p->drawLines(lines, 11);
1677       }
1678
1679       if (doRestore)
1680           p->restore();
1681       break;
1682     }
1683     case PE_IndicatorRadioButton: {
1684       if ( hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver) )
1685         drawHoverRect(p, w->rect(), opt->palette.color( QPalette::Window ),
1686                       model()->widgetRounding( Style_Model::ButtonRadius ),
1687                       Style_Tools::All, false);
1688 #define PTSARRLEN(x) sizeof(x)/(sizeof(QPoint))
1689       static const QPoint pts_border[] = {              // border line
1690         QPoint(1, 9),  QPoint(1, 8),  QPoint(0, 7),  QPoint(0, 4),  QPoint(1, 3),  QPoint(1, 2),
1691         QPoint(2, 1),  QPoint(3, 1),  QPoint(4, 0),  QPoint(7, 0),  QPoint(8, 1),  QPoint(9, 1),
1692         QPoint(10, 2), QPoint(10, 3), QPoint(11, 4), QPoint(11, 7), QPoint(10, 8), QPoint(10, 9),
1693         QPoint(9, 10), QPoint(8, 10), QPoint(7, 11), QPoint(4, 11), QPoint(3, 10), QPoint(2, 10)
1694       };
1695      // make sure the indicator is square
1696       QRect ir = opt->rect;
1697       if (opt->rect.width() < opt->rect.height()) {
1698         ir.setTop(opt->rect.top() + (opt->rect.height() - opt->rect.width()) / 2);
1699         ir.setHeight(opt->rect.width());
1700       } else if (opt->rect.height() < opt->rect.width()) {
1701         ir.setLeft(opt->rect.left() + (opt->rect.width() - opt->rect.height()) / 2);
1702         ir.setWidth(opt->rect.height());
1703       }
1704       p->save();
1705       bool down = opt->state & State_Sunken;
1706       bool enabled = opt->state & State_Enabled;
1707       bool on = opt->state & State_On;
1708       QPolygon a;
1709       p->translate(ir.x(), ir.y());
1710
1711       if ( down || !enabled ) {
1712         QColor fillColor = opt->palette.color( QPalette::Window );
1713         p->setPen( fillColor );
1714         p->setBrush( fillColor );
1715       }
1716       else {
1717         QColor fillColor =  opt->palette.color( QPalette::Base );
1718         if ( enabled && on )
1719           fillColor = model()->color( Style_Model::Checked ); // Style_Model::checked_clr
1720         QLinearGradient gr( 3, 3, 8, 8 );
1721         gr.setColorAt( 0.0, fillColor.dark( BUT_PERCENT_ON ) );
1722         gr.setColorAt( 1.0, fillColor );
1723         p->setPen( fillColor.dark( BUT_PERCENT_ON ) );
1724         p->setBrush( gr );
1725       }
1726       p->drawPolygon(pts_border, PTSARRLEN(pts_border));
1727       int aSize = PTSARRLEN(pts_border),
1728           aHalfSize = (int)aSize/2;
1729       if ( model()->antialiasing() )
1730         p->setRenderHint( QPainter::Antialiasing, true );
1731       p->setPen( model()->color( Style_Model::BorderTop) );     // Style_Model::border_top_clr
1732       p->drawPolyline(pts_border, aHalfSize);
1733       p->setPen( model()->color( Style_Model::BorderBottom ) ); // Style_Model::border_bot_clr
1734       QPolygon aPolygon;
1735       for ( int i = aHalfSize; i < aSize; i++ )
1736         aPolygon << pts_border[i];
1737       p->drawPolyline( aPolygon );
1738       if ( model()->antialiasing() )
1739         p->setRenderHint( QPainter::Antialiasing, false );
1740
1741       if (on) {
1742         QColor aPointerCol = model()->color( Style_Model::Pointer ); // Style_Model::pointer_clr
1743         if ( !enabled )
1744           aPointerCol = opt->palette.mid().color();
1745         p->setPen( Qt::NoPen );
1746         p->setBrush( aPointerCol );
1747         p->drawRect( 5, 4, 2, 4 );
1748         p->drawRect( 4, 5, 4, 2 );
1749       }
1750
1751       p->translate(-ir.x(), -ir.y()); // restore translate
1752       p->restore();
1753       break;
1754     }
1755     case PE_FrameDockWidget:
1756       if ( qstyleoption_cast<const QStyleOptionFrame *>(opt))
1757         QCommonStyle::drawPrimitive( pe, opt, p, w );
1758       break;
1759     case PE_FrameLineEdit:
1760     case PE_PanelLineEdit: {
1761       if ( w ) {
1762         if ( qobject_cast<const QComboBox*>( w->parentWidget() ) ||
1763              qobject_cast<const QAbstractSpinBox*>( w->parentWidget() ) )
1764           break;
1765       }
1766       if ( pe == PE_FrameLineEdit ) {
1767         QColor aBrdTopCol = model()->color( Style_Model::BorderTop );    // Style_Model::border_top_clr
1768         QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
1769         bool hover = hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver);
1770         double aRad = model()->widgetRounding( Style_Model::EditRadius );
1771         if ( hover )
1772           drawHoverRect(p, opt->rect, opt->palette.color( QPalette::Window ), aRad, Style_Tools::All, true);
1773         else {
1774           Style_Tools::shadowRect( p, opt->rect, aRad, LINE_GR_MARGIN, SHADOW,
1775                                    Style_Tools::All, opt->palette.color( QPalette::Base ), // getColor( Style_Model::fld_light_clr ),
1776                                    model()->color( Style_Model::FieldDark ), aBrdTopCol, aBrdBotCol,
1777                                    model()->antialiasing(), false );
1778         }
1779       }
1780       else {
1781         if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(opt)) {
1782           QRect rect = panel->rect.adjusted( panel->lineWidth,  panel->lineWidth,
1783                                              -panel->lineWidth, -panel->lineWidth);
1784           if ( w->inherits("QLineEdit") && panel->lineWidth > 0 ) {
1785             drawPrimitive( PE_FrameLineEdit, panel, p, w );
1786           }
1787           else {
1788             QColor c = panel->palette.color(QPalette::Base); c.setAlpha(255);
1789             p->fillRect( rect, c ); // panel->palette.brush(QPalette::Base)
1790           }
1791         }
1792       }
1793       break;
1794     }
1795     case PE_FrameTabWidget: {
1796       if (w && qobject_cast<QTabWidget*>((QWidget*)w)) {
1797         QTabWidget* tabW = qobject_cast<QTabWidget*>((QWidget*)w);
1798         int aRoundType = Style_Tools::BottomRight;
1799         QTabWidget::TabPosition aTabPos = tabW->tabPosition();
1800         if ( aTabPos != QTabWidget::North && aTabPos != QTabWidget::West )
1801           aRoundType = aRoundType | Style_Tools::TopLeft;
1802         if ( aTabPos != QTabWidget::South )
1803           aRoundType = aRoundType | Style_Tools::BottomLeft;
1804         if ( aTabPos != QTabWidget::East )
1805           aRoundType = aRoundType | Style_Tools::TopRight;
1806         QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop );    // Style_Model::border_tab_top_clr
1807         QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom ); // Style_Model::border_tab_bot_clr
1808         Style_Tools::shadowRect( p, opt->rect, model()->widgetRounding( Style_Model::FrameRadius ),
1809                                  0., SHADOW, aRoundType,
1810                                  model()->color( Style_Model::FieldLight ),
1811                                  opt->palette.color( QPalette::Dark ),
1812                                  aBrdTopCol, aBrdBotCol, false, false, false, false );
1813         break;
1814       }
1815     }
1816     case PE_IndicatorToolBarHandle: {
1817       p->save();
1818       QRect r = opt->rect;
1819       bool horiz = opt->state & State_Horizontal;
1820       QLinearGradient gr( r.x(), r.y(), horiz ? r.x() : r.right(), horiz ? r.bottom() : r.y() );
1821       QColor aBgCol = opt->palette.color( QPalette::Window );
1822       gr.setColorAt( 0.0, aBgCol.light( BUT_PERCENT_ON ) );
1823       gr.setColorAt( 1.0, aBgCol );
1824       p->fillRect( r, gr );
1825       drawHandle( p, r, horiz, false );
1826       p->restore();
1827       break;
1828     }
1829     case PE_Widget: {
1830       BaseStyle::drawPrimitive( pe, opt, p, w );
1831
1832       if ( !w )
1833         break;
1834       if( w->parent() && !qobject_cast<QMenuBar*>((QWidget*)w) )
1835          break;
1836       drawBackground( p, w->rect(), opt->palette.color( QPalette::Window ), false );
1837       break;
1838     }
1839     case PE_FrameTabBarBase:
1840       // for a tabbar that isn't part of a tab widget(dockWidgets for example).
1841       if (const QStyleOptionTabBarBase *tbb
1842           = qstyleoption_cast<const QStyleOptionTabBarBase *>(opt)) {
1843         if (tbb->shape != QTabBar::RoundedNorth && tbb->shape != QTabBar::RoundedEast &&
1844             tbb->shape != QTabBar::RoundedSouth && tbb->shape != QTabBar::RoundedWest) {
1845           BaseStyle::drawPrimitive( pe, opt, p, w );
1846           break;
1847         }
1848         QRect aSelRect = tbb->selectedTabRect;
1849         // line under selected tab bar object
1850         bool isSelected = opt->state & State_Selected;
1851         QTabBar* tabBar = qobject_cast<QTabBar*>((QWidget*)w);
1852         bool isLast = false;
1853         if ( tabBar )
1854           isLast = tabBar->currentIndex() == tabBar->count() -1;
1855         QColor aColor = opt->palette.color( QPalette::Window );
1856         bool isHover = hasHover() && (opt->state & State_Enabled) &&
1857                                      (opt->state & State_MouseOver);
1858         QPainterPath aSelPath = Style_Tools::tabRect( p, aSelRect, (int)tbb->shape,
1859                                                       model()->widgetRounding( Style_Model::FrameRadius ),
1860                                                       DELTA_H_TAB, aColor, aColor,
1861                             aColor, aColor, isSelected, isLast, isHover, false, false );
1862         if ( !aSelPath.isEmpty() )
1863           aSelRect = aSelPath.controlPointRect().toRect();
1864         QStyleOptionTabBarBase* copyOpt = (QStyleOptionTabBarBase*)tbb;
1865         copyOpt->selectedTabRect = aSelRect;
1866         QCommonStyle::drawPrimitive( pe, copyOpt, p, w );
1867         break;
1868       }
1869     case PE_IndicatorBranch: {
1870         // This is _way_ too similar to the common style.
1871         static const int decoration_size = 9;
1872         int mid_h = opt->rect.x() + opt->rect.width() / 2;
1873         int mid_v = opt->rect.y() + opt->rect.height() / 2;
1874         int bef_h = mid_h;
1875         int bef_v = mid_v;
1876         int aft_h = mid_h;
1877         int aft_v = mid_v;
1878         if (opt->state & State_Children) {
1879             int delta = decoration_size / 2;
1880             bef_h -= delta;
1881             bef_v -= delta;
1882             aft_h += delta;
1883             aft_v += delta;
1884             p->drawLine(bef_h + 2, bef_v + 4, bef_h + 6, bef_v + 4);
1885             if (!(opt->state & State_Open))
1886                 p->drawLine(bef_h + 4, bef_v + 2, bef_h + 4, bef_v + 6);
1887             QPen oldPen = p->pen();
1888             p->setPen(opt->palette.dark().color());
1889             p->drawRect(bef_h, bef_v, decoration_size - 1, decoration_size - 1);
1890             p->setPen(oldPen);
1891         }
1892         QBrush brush(opt->palette.dark().color(), Qt::Dense4Pattern);
1893         if (opt->state & State_Item) {
1894             if (opt->direction == Qt::RightToLeft)
1895                 p->fillRect(opt->rect.left(), mid_v, bef_h - opt->rect.left(), 1, brush);
1896             else
1897                 p->fillRect(aft_h, mid_v, opt->rect.right() - aft_h + 1, 1, brush);
1898         }
1899         if (opt->state & State_Sibling)
1900             p->fillRect(mid_h, aft_v, 1, opt->rect.bottom() - aft_v + 1, brush);
1901         if (opt->state & (State_Open | State_Children | State_Item | State_Sibling))
1902             p->fillRect(mid_h, opt->rect.y(), 1, bef_v - opt->rect.y(), brush);
1903         break;
1904       }
1905     case PE_IndicatorDockWidgetResizeHandle: {
1906       QRect r = opt->rect;
1907       drawBorder( p, r, opt->state & State_Horizontal );
1908       bool hover = hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver);
1909       if ( hover )
1910           drawHoverRect(p, r, opt->palette.color( QPalette::Window ), 0, Style_Tools::All, false);
1911       bool horiz = r.width() > r.height();
1912       int aLen = model()->splitHandleLength();
1913       if ( horiz )
1914         r = QRect( r.x() +(int)((r.width()-aLen)/2), r.y(), aLen, r.height());
1915       else
1916         r = QRect( r.x(), r.y() +(int)((r.height()-aLen)/2), r.width(), aLen);
1917       drawHandle( p, r, horiz, true );
1918       break;
1919     }
1920     case PE_Frame: {
1921       QWidget* aWdg = (QWidget*)w;
1922       if ( qobject_cast<QTextEdit*>(aWdg) || qobject_cast<QTreeView*>(aWdg) ||
1923            qobject_cast<QListView*>(aWdg) ) {
1924         QRect r = opt->rect;
1925         if ( qobject_cast<QTreeView*>(aWdg) ) {
1926           QTreeView* trView = qobject_cast<QTreeView*>(aWdg);
1927           QHeaderView* aHeader = trView->header();
1928           if ( aHeader && aHeader->isVisible() ) {
1929             int aHeight = aHeader->contentsRect().height();
1930             r = QRect( r.x(), r.y()+aHeight, r.width(), r.height()-aHeight );
1931           }
1932         }
1933         QPalette aPal = aWdg->palette();
1934         double aMarg = LINE_GR_MARGIN;
1935         QColor base = model()->color( Style_Model::Base ), // Style_Model::pal_base_clr
1936           light = base,
1937           light_alt = base.dark(110),//AlternateBase color
1938           dark  = model()->color( Style_Model::FieldDark ); // Style_Model::fld_dark_clr
1939         //light.setAlpha( 0 ); // VSR commented: IPAL19262
1940         QLinearGradient gr_h(r.x(), r.y(), r.right(), r.y());
1941         gr_h.setColorAt( 0.0, dark );
1942         gr_h.setColorAt( aMarg / r.width(), light );
1943         gr_h.setColorAt( 1.0, light );
1944         QLinearGradient gr_v(r.x(), r.y(), r.x(), r.bottom() );
1945         gr_v.setColorAt( 0.0, dark );
1946         gr_v.setColorAt( aMarg / r.height(), light );
1947         gr_v.setColorAt( 1.0, light );
1948         // draw frame
1949         p->fillRect( r, base );
1950         p->fillRect( r, gr_h );
1951         p->fillRect( r, gr_v );
1952         aPal.setBrush( QPalette::Base, QBrush( light ) );
1953
1954         QLinearGradient gr_alt(r.x(), r.y(), r.right(), r.y());
1955         gr_alt.setColorAt( 0.0, dark );
1956         gr_alt.setColorAt( (aMarg)*2/3/r.width(), light_alt );
1957         gr_alt.setColorAt( 1.0, light_alt );
1958         aPal.setBrush( QPalette::AlternateBase, QBrush( gr_alt ) );
1959         aWdg->setPalette( aPal );
1960       }
1961       BaseStyle::drawPrimitive( pe, opt, p, w );
1962       break;
1963     }
1964     default:
1965       BaseStyle::drawPrimitive( pe, opt, p, w );
1966   }
1967 }
1968
1969 /*!
1970   \brief Returns the value of the given pixel \a metric.
1971   \param metric metric type
1972   \param opt style option
1973   \param w widget
1974   \return metric value
1975 */
1976 int Style_Salome::pixelMetric( PixelMetric metric, const QStyleOption* opt,
1977                                const QWidget* w ) const
1978 {
1979   if ( checkDebugLevel(7) ) {
1980     return BaseStyle::pixelMetric( metric, opt, w );
1981   }
1982   int aRes = BaseStyle::pixelMetric( metric, opt, w );
1983   switch( metric ) {
1984     case PM_SliderLength: {
1985       aRes += (int)((double)model()->sliderSize()/2);
1986       break;
1987     }
1988     case PM_DockWidgetFrameWidth:
1989       aRes = 1;
1990     break;
1991     case PM_DockWidgetSeparatorExtent:
1992       aRes = 8;
1993     break;
1994     case PM_DockWidgetTitleMargin:
1995       aRes = 2;
1996     break;
1997     case PM_SplitterWidth:
1998       aRes = 6;
1999     break;
2000     default:
2001     break;
2002   }
2003   return aRes;
2004 }
2005
2006 /*!
2007   \brief Returns the size of the element described by the specified option \a opt
2008   and type \a ct, based on the provided \a contentsSize.
2009   \param ct contents type
2010   \param opt style option
2011   \param contentsSize contents size
2012   \param w widget (optional)
2013   \return size of the element
2014 */
2015 QSize Style_Salome::sizeFromContents( ContentsType ct, const QStyleOption* opt,
2016                                       const QSize& contentsSize, const QWidget* w ) const
2017 {
2018   if ( checkDebugLevel(8) ) {
2019     return BaseStyle::sizeFromContents( ct, opt,contentsSize, w );
2020   }
2021   QSize sz = BaseStyle::sizeFromContents( ct, opt, contentsSize, w );
2022   switch (ct) {
2023     case CT_TabBarTab:
2024       if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(opt)) {
2025         if ( tab->position == QStyleOptionTab::End ||
2026              tab->position == QStyleOptionTab::OnlyOneTab ) {
2027           if ( tab->shape == QTabBar::RoundedNorth || tab->shape == QTabBar::RoundedSouth ) {
2028             int aDelta = (int)(opt->rect.height()*DELTA_H_TAB/2);
2029             sz.setWidth( sz.width() + aDelta );
2030           }
2031           if ( tab->shape == QTabBar::RoundedEast || tab->shape == QTabBar::RoundedWest ) {
2032             int aDelta = (int)(opt->rect.width()*DELTA_H_TAB/2);
2033             sz.setHeight( sz.height() + aDelta );
2034           }
2035         }
2036         break;
2037       }
2038       break;
2039       case CT_Slider: {
2040         int aValue = model()->sliderSize();
2041         sz.setWidth( sz.width() + aValue );
2042         sz.setHeight( sz.height() + aValue );
2043         break;
2044       }
2045       case CT_ComboBox:
2046         if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
2047           QRect res = QRect( 0, 0, sz.width(), sz.height() );
2048           int aHalfRect = (int)Style_Tools::getMaxRect( res,
2049                              (int)model()->widgetRounding( Style_Model::EditRadius )/2 ); // left value
2050
2051           QRect old_arrow = BaseStyle::subControlRect( CC_ComboBox, cmb,
2052                                                            SC_ComboBoxArrow, w );
2053           int aDelta = res.height() - old_arrow.width(); // right value
2054           if ( cmb->editable )
2055             aDelta += aHalfRect; // for right of line edit internal
2056           sz.setWidth( res.width() + aDelta + aHalfRect );
2057         }
2058         break;
2059       default:
2060       break;
2061   }
2062   return sz;
2063 }
2064
2065 /*!
2066   \brief Returns a pixmap for the given \a standardPixmap.
2067   \param stPixmap standard pixmap type
2068   \param opt style option
2069   \param w widget (optional)
2070   \return standard pixmap
2071 */
2072 QPixmap Style_Salome::standardPixmap(StandardPixmap stPixmap, const QStyleOption *opt,
2073                                      const QWidget *w) const
2074 {
2075   if ( checkDebugLevel(9) ) {
2076     return BaseStyle::standardPixmap( stPixmap, opt, w );
2077   }
2078
2079   switch ( stPixmap )
2080   {
2081   case SP_DockWidgetCloseButton:
2082   case SP_TitleBarCloseButton:
2083     return QPixmap( cross_xpm );
2084   case SP_TitleBarMaxButton:
2085     return QPixmap( maximize_xpm );
2086   case SP_TitleBarNormalButton:
2087     return QPixmap( normal_xpm );
2088   case SP_TitleBarMinButton:
2089     return QPixmap( minimize_xpm );
2090   default:
2091     return BaseStyle::standardPixmap( stPixmap, opt, w );
2092   }
2093 }
2094
2095 /*!
2096   \brief Returns an icon for the given \a standardIcon.
2097   \param standardIcon standard icon type
2098   \param opt style option
2099   \param w widget (optional)
2100   \return standard icon
2101 */
2102 QIcon Style_Salome::standardIconImplementation( StandardPixmap standardIcon,
2103                                                 const QStyleOption* opt,
2104                                                 const QWidget* w ) const
2105 {
2106   if ( checkDebugLevel(10) ) {
2107     return QCommonStyle::standardIcon( standardIcon, opt, w );
2108   }
2109
2110   switch ( standardIcon )
2111   {
2112   case SP_MessageBoxInformation:
2113     return QPixmap( ":/images/information.png" );
2114   case SP_MessageBoxWarning:
2115     return QPixmap( ":/images/warning.png" );
2116   case SP_MessageBoxCritical:
2117     return QPixmap( ":/images/critical.png" );
2118   case SP_MessageBoxQuestion:
2119     return QPixmap( ":/images/question.png" );
2120   default:
2121     break;
2122   }
2123   return BaseStyle::standardIcon( standardIcon, opt, w );
2124 }
2125
2126 /*!
2127   \brief Returns an integer representing the specified style \a hint for the
2128   given widget \a w described by the provided style option \a opt.
2129   \param hint hint type
2130   \param opt style option
2131   \param w widget (optional)
2132   \param returnData (currently not used)
2133   \return style hint value
2134 */
2135 int Style_Salome::styleHint( StyleHint hint, const QStyleOption* opt, const QWidget* w,
2136                             QStyleHintReturn* returnData ) const
2137 {
2138   if ( checkDebugLevel(11) ) {
2139     return BaseStyle::styleHint( hint, opt, w, returnData );
2140   }
2141   int aRes = BaseStyle::styleHint( hint, opt, w, returnData );
2142   switch( hint ) {
2143     case SH_Table_GridLineColor: {
2144       if ( opt )
2145         aRes = model()->color( Style_Model::GridLine ).rgb(); // Style_Model::tbl_grline_clr
2146       else
2147         return aRes;
2148       break;
2149     }
2150     default:
2151       break;
2152   }
2153   return aRes;
2154 }
2155
2156 /*!
2157   \brief Get the rectangle containing the specified subcontrol \a sc of the given
2158   complex control \a cc (with the style specified by option \a opt).
2159   The rectangle is defined in screen coordinates.
2160   \param cc complex control type
2161   \param opt style option
2162   \param sc subcontrol type
2163   \param wid widget (optional)
2164   \return subcontrol rectangle
2165 */
2166 QRect Style_Salome::subControlRect( ComplexControl cc, const QStyleOptionComplex* opt,
2167                                     SubControl sc, const QWidget* wid ) const
2168 {
2169   if ( checkDebugLevel(12) ) {
2170     return BaseStyle::subControlRect( cc, opt, sc, wid );
2171   }
2172   QRect res = BaseStyle::subControlRect( cc, opt, sc, wid );
2173   switch ( cc ) {
2174     case CC_SpinBox: {
2175       int x = res.x(), w = res.width(), h = res.height();
2176       if ( sc==SC_SpinBoxUp || sc==SC_SpinBoxDown ) {
2177         QRect frame_r = BaseStyle::subControlRect( cc, opt, SC_SpinBoxFrame, wid );
2178         h = frame_r.height();
2179         res.setX( x+w-h );
2180         res.setWidth( h );
2181       }
2182       else if ( sc==QStyle::SC_SpinBoxEditField ) {
2183         res.setWidth( w-h );
2184         res.setTopLeft( QPoint( res.x(), res.y()-SHADOW ) );
2185       }
2186       break;
2187     }
2188     case CC_ComboBox: {
2189       if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
2190         res = cb->rect;
2191         int aHalfRect = (int)Style_Tools::getMaxRect( res, (int)model()->widgetRounding( Style_Model::EditRadius )/2 );
2192         int x = res.x(), w = res.width(), h = res.height();
2193         switch( sc ) {
2194           case SC_ComboBoxEditField: {
2195             res.setWidth( w-h );
2196             int aX = res.x();
2197             if ( !cb->editable )
2198               aX += aHalfRect;
2199             res.setTopLeft( QPoint( aX, res.y()-SHADOW ) );
2200             break;
2201           }
2202           case SC_ComboBoxArrow: {
2203             res.setX( x+w-h );
2204             res.setWidth( h );
2205             break;
2206           }
2207         }
2208       }
2209       break;
2210     }
2211     case CC_ScrollBar:
2212       if (const QStyleOptionSlider *scrollbar = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
2213         QRect slider_r = BaseStyle::subControlRect( cc, opt, SC_ScrollBarSlider, wid );
2214         int aRect = Style_Tools::getMaxRect( slider_r, (int)model()->widgetRounding( Style_Model::ButtonRadius ) );
2215         switch( sc ) {
2216           case SC_ScrollBarSubPage:            // between top/left button and slider
2217             if (scrollbar->orientation == Qt::Horizontal)
2218               res.setRight( res.right()+aRect+1 );
2219             else
2220               res.setBottom( res.bottom()+aRect+1 );
2221             break;
2222           case SC_ScrollBarAddPage:            // between bottom/right button and slider
2223             if (scrollbar->orientation == Qt::Horizontal)
2224               res.setLeft( res.left() - aRect - 1 );
2225             else
2226               res.setTop( res.top() - aRect - 1);
2227           break;
2228           default:
2229             break;
2230         }
2231         break;
2232       }
2233     case CC_Slider: {
2234       if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
2235         switch ( sc ) {
2236           case SC_SliderGroove: {
2237             if ( slider->orientation == Qt::Horizontal ) {
2238               res.setLeft( res.left()+DELTA_SLIDER );
2239               res.setRight( res.right()-DELTA_SLIDER );
2240             }
2241             else {
2242               res.setTop( res.top()+DELTA_SLIDER );
2243               res.setBottom( res.bottom()-DELTA_SLIDER );
2244             }
2245             break;
2246           }
2247         }
2248       }
2249     }
2250   }
2251   return res;
2252 }
2253
2254 /*!
2255   \brief Returns the sub-area for the given element \a se as described
2256   in the provided style option \a opt.
2257   The returned rectangle is defined in screen coordinates.
2258   \param se subelement type
2259   \param opt style option
2260   \param wid widget (optional)
2261   \return subelement rectangle
2262 */
2263 QRect Style_Salome::subElementRect( SubElement se, const QStyleOption* opt,
2264                                    const QWidget* wid ) const
2265 {
2266   if ( checkDebugLevel(13) ) {
2267     return BaseStyle::subElementRect( se, opt, wid );
2268   }
2269
2270   QRect res = BaseStyle::subElementRect( se, opt, wid );
2271   int aHalfRect = (int)Style_Tools::getMaxRect( res, (int)model()->widgetRounding( Style_Model::EditRadius )/2 );
2272   int w = res.width(), h = res.height();
2273   switch ( se ) {
2274     case SE_ComboBoxFocusRect: {
2275
2276       QRect old_r = BaseStyle::subControlRect( CC_ComboBox,
2277                      qstyleoption_cast<const QStyleOptionComplex*>( opt ),
2278                      SC_ComboBoxArrow, wid );
2279       int old_w = old_r.width();
2280       res.setWidth( w-h+old_w-2 );
2281       break;
2282     }
2283     case SE_LineEditContents: {
2284       res.setTopLeft( QPoint( res.x()+aHalfRect, res.y()-SHADOW ) );
2285       res.setTopRight( QPoint( res.right()-aHalfRect, res.y() ) );
2286       break;
2287     }
2288     case SE_ProgressBarLabel:
2289     case SE_ProgressBarContents:
2290     case SE_ProgressBarGroove:
2291       return opt->rect;
2292   }
2293   if( qobject_cast<const QRadioButton*>(wid) ||
2294       qobject_cast<const QCheckBox*>(wid) ) {
2295       if( hasHover() )
2296         res = res.adjusted(0, 0, 2, 0);
2297   }
2298   return res;
2299 }
2300
2301 /*!
2302   \brief Update palette colors from style model
2303 */
2304 void Style_Salome::updatePaletteColors()
2305 {
2306   QPalette pal = QApplication::palette();
2307   // colors
2308   for ( int i = (int)QPalette::Active; i <= (int)QPalette::Inactive; i++ ) {
2309     for ( int j = (int)Style_Model::WindowText; j < (int)Style_Model::NColorRoles; j++ ) {
2310       if ( j == QPalette::NoRole ) continue;
2311       pal.setColor( (QPalette::ColorGroup)i, (QPalette::ColorRole)j,
2312                     model()->color( (Style_Model::ColorRole)j, (QPalette::ColorGroup)i ) );
2313     }
2314   }
2315   QPixmapCache::clear();
2316   QApplication::setPalette( pal );
2317 }
2318
2319 /*!
2320   \brief Update all widgets with the current style properties.
2321   \param app application object
2322 */
2323 void Style_Salome::updateAllWidgets( QApplication* app )
2324 {
2325   if ( !app )
2326     return;
2327
2328   QWidgetList all = app->allWidgets();
2329   QWidget* w;
2330   for (QWidgetList::ConstIterator it2 = all.constBegin(); it2 != all.constEnd(); ++it2) {
2331     w = *it2;
2332     if (w->windowType() != Qt::Desktop && w->testAttribute(Qt::WA_WState_Polished)
2333         && !w->testAttribute(Qt::WA_SetStyle)) {
2334       QEvent e(QEvent::StyleChange);
2335       QApplication::sendEvent(w, &e);
2336       polish( w );
2337       w->update();
2338     }
2339   }
2340 }
2341
2342 /*!
2343   \brief Check if any widget effect is currently used
2344   \return \c true if any widget effect is currently used
2345 */
2346 bool Style_Salome::hasHover() const
2347 {
2348   return model()->widgetEffect() != Style_Model::NoEffect;
2349 }
2350
2351 /*!
2352   \brief Draw rectangle for the hovered widget
2353   \param p painter
2354   \param r rectangle
2355   \param bgCol background color
2356   \param rad corners rounding radius
2357   \param type shadow type
2358   \param border if \c true border is colored with specific color
2359 */
2360 void Style_Salome::drawHoverRect( QPainter* p, const QRect& r, const QColor& bgCol, const double rad,
2361                                   const int type, const bool border ) const
2362 {
2363   if ( !hasHover() )
2364     return;
2365   bool isAutoRaising = model()->widgetEffect() == Style_Model::AutoRaiseEffect;
2366   bool isHighWdg     = model()->widgetEffect() == Style_Model::HighlightEffect;
2367   QColor aBorder = model()->color( Style_Model::BorderTop ), // Style_Model::border_bot_clr
2368          aCol, aBrdCol;
2369   double aMargin = HIGH_WDG_MARGIN;
2370   if  ( isAutoRaising ) {
2371     aCol = bgCol;
2372     aBrdCol = aCol.dark(BUT_PERCENT_ON);
2373     if ( !border )
2374       aBorder = aCol;
2375     aMargin = 0;
2376   }
2377   else if ( isHighWdg ) {
2378     aCol    = model()->color( Style_Model::HighlightWidget ); // Style_Model::high_wdg_clr
2379     aBrdCol = model()->color( Style_Model::HighlightBorder ); // Style_Model::high_brd_wdg_clr
2380     if ( !border )
2381       aBorder = aBrdCol;
2382   }
2383   Style_Tools::highlightRect( p, r, rad, type, aMargin, aCol, aBrdCol, aBorder );
2384 }
2385
2386 /*!
2387   \brief Draw widget handle
2388   \param p painter
2389   \param r rectangle
2390   \param horiz if \c true draw horizontal handle, otherwise draw vertical handle
2391   \param isRect if \c true surrounding rectangle is also drawn
2392 */
2393 void Style_Salome::drawHandle( QPainter* p, const QRect& r, bool horiz, bool isRect ) const
2394 {
2395   QPixmap hole( (const char**)hole_xpm );
2396   int i, j;
2397   double d_hor = model()->handleDelta( Qt::Horizontal );
2398   double d_ver = model()->handleDelta( Qt::Vertical );
2399   if ( !d_hor || !d_ver || !r.width() || !r.height() )
2400     return;
2401   int c_hor = (int)(r.width()/d_hor)-1;
2402   int c_ver = (int)(r.height()/d_ver)-1;
2403   if ( c_hor+1 <= 0 || c_ver+1 <= 0 )
2404     return;
2405   // correction for delta value
2406   d_hor = r.width()/(c_hor+1);
2407   d_ver = r.height()/(c_ver+1);
2408
2409   double dd_hor = 0, dd_ver = 0;
2410   if ( horiz ) {
2411     for ( i = 0; i < c_hor; i++ ) {
2412       for ( j = 0; j < c_ver; j++ ) {
2413           p->drawPixmap( (int)( r.x() + dd_hor + ( i + 1 ) * d_hor  - 1 ),
2414                          (int)( r.y() + dd_ver + ( j + 1 ) * d_ver - 1 ), hole );
2415       }
2416       if ( !isRect ) {
2417         dd_ver += (int(d_ver)/2) + (int(d_ver)%2);
2418         c_ver = c_ver - 1;
2419       }
2420     }
2421   }
2422   else {
2423     for ( j = 0; j < c_ver; j++ ) {
2424       for ( i = 0; i < c_hor; i++ ) {
2425           p->drawPixmap( (int)( r.x() + dd_hor + ( i + 1 ) * d_hor  - 1 ),
2426                          (int)( r.y() + dd_ver + ( j + 1 ) * d_ver - 1 ), hole );
2427       }
2428       if ( !isRect ) {
2429         dd_hor += (int(d_hor)/2) + (int(d_hor)%2);
2430         c_hor = c_hor - 1;
2431       }
2432     }
2433   }
2434 }
2435
2436 /*!
2437   \brief Draw background.
2438   \param p painter
2439   \param r rectangle
2440   \param bgCol background color
2441   \param fill 'fill rectangle' flag
2442   \param grad 'draw gradient' flag
2443   \param horix 'draw horizontal item' flag (usefull for gradient background)
2444 */
2445 void Style_Salome::drawBackground( QPainter* p, const QRect& r, const QColor& bgCol,
2446                                    const bool fill, const bool grad, const bool horiz ) const
2447 {
2448   if ( fill ) {
2449     if ( !grad )
2450       p->fillRect( r, bgCol );
2451     else {
2452       QLinearGradient gr( r.x(), r.y(), horiz ? r.x() : r.right(), horiz ? r.bottom() : r.y() );
2453       gr.setColorAt( 0.0, bgCol.light( BUT_PERCENT_ON ) );
2454       gr.setColorAt( 1.0, bgCol );
2455       p->fillRect( r, gr );
2456     }
2457   }
2458
2459   int x = r.x(), y = r.y(), left = r.left(), top = r.top();
2460   int w = r.width(), h = r.height();
2461
2462   QVector<QLine> lines;
2463
2464   switch ( model()->linesType() ) {
2465   case Style_Model::Horizontal:
2466     {
2467       const int d = 3;
2468       for ( int i = 0; i <= h; i += d )
2469         lines.append( QLine( x, y+i, w, r.y()+i ) );
2470     }
2471     break;
2472   case Style_Model::Inclined:
2473     {
2474       const int d = 5;
2475       w = w/d*d;
2476       h = h/d*d;
2477       for ( int i = 0; i <= w; i += d )
2478         lines.append( QLine( x+i, y, x, y+i ) );
2479       for ( int i = 0; i < h; i += d )
2480         lines.append( QLine( left+w-i, top+h, left+w, top+h-i ) );
2481     }
2482     break;
2483   default:
2484     break;
2485   }
2486
2487   if ( !lines.isEmpty() ) {
2488     QColor c = model()->color( Style_Model::Lines );
2489     int anAlpha = (int)( 255*( 1 - model()->linesTransparency()/100 ) );
2490     c.setAlpha( anAlpha );
2491     p->setPen( c );
2492     p->setRenderHint( QPainter::Antialiasing );
2493     p->drawLines( lines );
2494   }
2495 }
2496
2497 /*!
2498   \brief Draw border
2499   \param p painter
2500   \param r rectangle
2501   \param horiz 'draw horizontal item' flag
2502 */
2503 void Style_Salome::drawBorder( QPainter* p, const QRect& r, bool horiz ) const
2504 {
2505   QPen oldPen = p->pen();
2506   QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop );    // Style_Model::border_tab_top_clr
2507   QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom ); // Style_Model::border_tab_bot_clr
2508   p->setPen( aBrdTopCol );
2509   if (horiz) {
2510     p->drawLine(r.left(),  r.top(), r.right(), r.top());
2511     p->setPen(aBrdBotCol);
2512     p->drawLine(r.left(), r.bottom(), r.right(), r.bottom());
2513   }
2514   else {
2515     p->drawLine(r.left(), r.top(), r.left(), r.bottom());
2516     p->setPen(aBrdBotCol);
2517     p->drawLine(r.right(), r.top(), r.right(), r.bottom());
2518   }
2519   p->setPen(oldPen);
2520 }
2521
2522 /*!
2523   \brief Get corrected title text
2524   \param txt original text
2525   \param W possible width
2526   \param H possible height
2527   \param f used font
2528   \return corrected title text
2529 */
2530 QString Style_Salome::titleText( const QString& txt, const int W, const int H, QFont& f ) const
2531 {
2532   QString res = txt.trimmed();
2533
2534   QFontMetrics fm( f );
2535   while( fm.height() > H && f.pointSize()>1 )
2536   {
2537     f.setPointSize( f.pointSize()-1 );
2538     fm = QFontMetrics( f );
2539   }
2540
2541   if ( fm.width( res ) > W )
2542   {
2543     QString end( "..." );
2544     while ( !res.isEmpty() && fm.width( res + end ) > W )
2545       res.remove( res.length() - 1, 1 );
2546
2547     if ( !res.isEmpty() )
2548       res += end;
2549   }
2550
2551   return res;
2552 }