1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 // File : Style_Salome.cxx
21 // Author : Natalia Ermolaeva, Open CASCADE S.A.S.
23 #include "Style_Salome.h"
24 #include "Style_Tools.h"
25 #include "Style_Model.h"
27 #include <QApplication>
30 #include <QPainterPath>
33 #include <QStyleOptionFrame>
34 #include <QStyleOptionComplex>
35 #include <QStyleOptionSpinBox>
36 #include <QStyleOptionButton>
37 #include <QStyleOptionTab>
38 #include <QStyleOptionToolButton>
39 #include <QStyleOptionFocusRect>
40 #include <QStyleOption>
44 #include <QToolButton>
48 #include <QDockWidget>
52 #include <QHeaderView>
53 #include <QRadioButton>
55 #include <QPushButton>
56 #include <QAbstractSpinBox>
60 #include <QMainWindow>
61 #include <QPixmapCache>
65 #define LINE_GR_MARGIN 10
66 #define HIGH_WDG_MARGIN 10
68 #define BUT_PERCENT_COL 125
69 #define BUT_PERCENT_ON 115
72 #define DELTA_SLIDER 3
74 static const char* const hole_xpm[] = {
84 static const char* const cross_xpm[] = {
104 static const char* const maximize_xpm[] = {
124 static const char* const normal_xpm[] = {
144 static const char* const minimize_xpm[] = {
164 ///////////////////////////////////////////////////////////
165 // FOR debug purposes only!!!
169 static bool checkDebugLevel( int level )
171 return DEBUG_LEVEL == level || DEBUG_LEVEL == -1;
174 ///////////////////////////////////////////////////////////
176 Style_Model* Style_Salome::myModel = 0;
180 \brief SALOME style class.
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.
185 The usual way to use SALOME style is as following:
187 Style_Salome::initialize( resourceMgr() ); // initialize SALOME style from resources
188 if ( needSalomeStyle ) Style_Salome::apply(); // set SALOME style to the application
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:
194 Style_PrefDlg dlg( desktop() );
202 Use Style_Salome::apply() static function to set SALOME style to the application.
204 Style_Salome::Style_Salome() : BaseStyle()
206 // initialize SALOME style resources
207 Q_INIT_RESOURCE( Style );
213 Style_Salome::~Style_Salome()
219 \brief Initialize SALOME style.
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.
225 If the parameter \a resMgr is not 0, the style is initialized from the
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.
231 \param resMgr resources manager
232 \param section resources file section name
233 \sa apply(), restore()
235 void Style_Salome::initialize( QtxResourceMgr* resMgr, const QString& section )
237 model()->fromResources( resMgr, section );
241 \brief Set SALOME style to the application
242 \sa initialize(), restore()
244 void Style_Salome::apply()
246 // application object is not created yet
247 if ( !QApplication::instance() )
250 // update model (from the resources manager if needed)
253 // check if SALOME style is already set to the application
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
260 update(); // update style
264 \brief Restore original style to the application
265 \sa initialize(), apply()
267 void Style_Salome::restore()
269 // application object is not created yet
270 if ( !QApplication::instance() )
272 // check if SALOME style is set to the application
276 QApplication::setDesktopSettingsAware(true);
278 // restore previous style
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
286 bool Style_Salome::isActive()
288 return QApplication::instance() != 0 && qobject_cast<Style_Salome*>( QApplication::style() ) != 0;
292 \brief Update style from resources.
294 void Style_Salome::update()
296 // application object is not created yet
297 if ( !QApplication::instance() )
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() ) );
305 \brief Get style model
308 Style_Model* Style_Salome::model()
311 myModel = new Style_Model();
316 \brief Initialize the appearance of the application.
318 Performs late initialization of the given application object.
320 \param app application object
322 void Style_Salome::polish ( QApplication* app )
324 BaseStyle::polish( app );
326 if ( checkDebugLevel(1) ) {
330 updatePaletteColors();
331 app->setFont( model()->applicationFont() );
332 updateAllWidgets( app );
336 \brief Initializes the appearance of the given widget.
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.
341 \param w widget object
343 void Style_Salome::polish ( QWidget* w )
345 if ( checkDebugLevel(2) ) {
346 BaseStyle::polish( w );
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 );
359 BaseStyle::polish( w );
363 \brief Uninitialize the given widget's appearance.
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.
370 \param w widget object
372 void Style_Salome::unpolish( QWidget* w )
374 if ( checkDebugLevel(3) ) {
375 BaseStyle::unpolish( w );
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 );
388 BaseStyle::unpolish( w );
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
398 void Style_Salome::drawComplexControl( ComplexControl cc, const QStyleOptionComplex* opt,
399 QPainter* p, const QWidget* w ) const
401 if ( checkDebugLevel(4) ) {
402 BaseStyle::drawComplexControl( cc, opt, p, w );
406 const QPalette& pal = w->palette();
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
419 drawHoverRect(p, optr, opt->palette.color( QPalette::Window ), aRad, Style_Tools::Left, true);
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 );
429 drawHoverRect(p, aBtnRect, opt->palette.color( QPalette::Window ), aRad, Style_Tools::Right, true);
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;
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;
445 copy.state |= State_Enabled;
447 if ( spin->activeSubControls == SC_SpinBoxUp && ( spin->state & State_Sunken ) ) {
448 copy.state |= State_On;
449 copy.state |= State_Sunken;
451 copy.state |= State_Raised;
452 copy.state &= ~State_Sunken;
454 pe = (spin->buttonSymbols == QAbstractSpinBox::PlusMinus ? PE_IndicatorSpinPlus
455 : PE_IndicatorSpinUp);
456 copy.rect = aBtnRect;
457 drawPrimitive(pe, ©, p, w);
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;
469 copy.state |= State_Enabled;
471 if (spin->activeSubControls == SC_SpinBoxDown && (spin->state & State_Sunken)) {
472 copy.state |= State_On;
473 copy.state |= State_Sunken;
475 copy.state |= State_Raised;
476 copy.state &= ~State_Sunken;
478 pe = (spin->buttonSymbols == QAbstractSpinBox::PlusMinus ? PE_IndicatorSpinMinus
479 : PE_IndicatorSpinDown);
480 copy.rect = aBtnRect;
481 drawPrimitive(pe, ©, p, w);
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 );
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
498 drawHoverRect(p, optr, opt->palette.color( QPalette::Window ), aRad, Style_Tools::Left, true);
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 );
509 drawHoverRect(p, ar, opt->palette.color( QPalette::Window ), aRad, Style_Tools::Right, true);
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);
520 arrowOpt.palette = cmb->palette;
521 arrowOpt.state = flags;
522 drawPrimitive(PE_IndicatorArrowDown, &arrowOpt, p, w);
524 if (cmb->subControls & SC_ComboBoxEditField) {
525 bool hi = cmb->state & State_HasFocus && !cmb->editable;
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,
531 p->setPen(cmb->palette.highlightedText().color());
534 p->setPen(cmb->palette.text().color());
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);
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);
551 if ((slider->subControls & SC_SliderGroove) && groove.isValid()) {
552 QStyleOptionSlider tmpSlider = *slider;
553 tmpSlider.subControls = SC_SliderGroove;
554 BaseStyle::drawComplexControl(cc, &tmpSlider, p, w);
556 if (slider->subControls & SC_SliderTickmarks) {
557 QStyleOptionSlider tmpSlider = *slider;
558 tmpSlider.subControls = SC_SliderTickmarks;
559 QCommonStyle::drawComplexControl(cc, &tmpSlider, p, w);
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);
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;
585 type = Style_Tools::SlUp;
586 slRect.setTop( slRect.top()-aYAdd );
589 type = Style_Tools::SlDown;
590 slRect.setBottom( slRect.bottom()+aYAdd );
594 type = Style_Tools::SlLeft;
595 slRect.setLeft( slRect.left()-aXAdd );
598 type = Style_Tools::SlRight;
599 slRect.setRight( slRect.right()+aXAdd );
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 );
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);
622 if (w && ( qobject_cast<QToolBar *>(w->parentWidget() ) ||
623 ( toolbutton->state & State_AutoRaise && !( toolbutton->state & State_MouseOver ) ) )
625 BaseStyle::drawComplexControl( cc, opt, p, w );
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 );
651 Style_Tools::shadowRect( p, aRect, aMinDelta, -1, SHADOW, aType, top, bottom,
652 aBrdTopCol, aBrdBotCol, antialized, true, aStateOn );
654 if (toolbutton->subControls & SC_ToolButtonMenu) {
656 if ( aMinDelta > menuArea.height()/2 )
657 aMinDelta = menuArea.height()/2;
658 if ( aMinDelta > menuArea.width()/2 )
659 aMinDelta = menuArea.width()/2;
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 );
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;
679 State mflags = bflags;
680 if (toolbutton->activeSubControls & SC_ToolButton)
681 bflags |= State_Sunken;
682 if (toolbutton->activeSubControls & SC_ToolButtonMenu)
683 mflags |= State_Sunken;
685 drawPrimitive(PE_IndicatorArrowDown, &tool, p, w);
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 );
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 );
707 BaseStyle::drawComplexControl( cc, opt, p, w );
711 if (const QStyleOptionGroupBox *groupBox = qstyleoption_cast<const
712 QStyleOptionGroupBox *>(opt)) {
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);
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);
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);
757 BaseStyle::drawComplexControl( cc, opt, p, w );
761 BaseStyle::drawComplexControl( cc, opt, p, w );
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
772 void Style_Salome::drawControl( ControlElement ce, const QStyleOption* opt,
773 QPainter* p, const QWidget* w ) const
775 if ( checkDebugLevel(5) ) {
776 BaseStyle::drawControl( ce, opt, p, w );
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 ) );
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 );
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
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 );
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);
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);
834 if ( dockWidget->isFloating() && dwOpt->movable) {
836 QColor top = opt->palette.color( QPalette::Highlight ).light();
837 QColor bottom = opt->palette.color( QPalette::Highlight );
839 QBrush fillBrush(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);
848 p->fillRect(dwOpt->rect.adjusted(0, 0, 0, -3), fillBrush);
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 );
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() );
872 p->setPen(dwOpt->palette.color(QPalette::Light));
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() );
885 QFont oldFont = p->font();
886 QFont font = oldFont;
891 aTitle = titleText( aTitle, r.width(), r.height(), font );
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);
905 BaseStyle::drawControl( ce, opt, p, w );
907 bool horiz = r.width() > r.height();
908 int aLen = model()->splitHandleLength();
910 r = QRect( r.x() +(int)((r.width()-aLen)/2), r.y(), aLen, r.height());
912 r = QRect( r.x(), r.y() +(int)((r.height()-aLen)/2), r.width(), aLen);
913 drawHandle( p, r, horiz, true );
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) {
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
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
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 );
943 QCommonStyle::drawControl( ce, opt, p, w );
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;
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() ) );
957 aDelta = (int)(opt->rect.width()*DELTA_H_TAB/2);
958 oldRect = QRect( oldRect.topLeft(), QPoint( oldRect.right(), oldRect.bottom()-aDelta ) );
960 QStyleOptionTab* copyTab = (QStyleOptionTab*)tab;
961 copyTab->rect = oldRect;
962 BaseStyle::drawControl( ce, copyTab, p, w );
965 BaseStyle::drawControl( ce, opt, p, w );
969 if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(opt)) {
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 ) );
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);
992 Style_Tools::shadowRect( p, opt->rect, 0, 0., SHADOW, Style_Tools::All, top, bottom,
993 aBrdTopCol, aBrdBotCol,
994 model()->antialiasing(), true, aStateOn );
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));
1003 QCommonStyle::drawControl(ce, &newMbi, p, w);
1006 case CE_MenuBarEmptyArea:
1007 drawBackground( p, opt->rect, opt->palette.color( QPalette::Window ), true, true, true );
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 );
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)
1027 QRect rect = bar->rect;
1029 p->setPen(bar->palette.text().color());
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;
1041 rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // flip width and height
1044 m.translate(0.0, rect.width());
1047 m.translate(rect.height(), 0.0);
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)));
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());
1063 p->setPen(bar->palette.base().color());
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());
1071 p->setPen(bar->palette.text().color());
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));
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);
1092 vertical = (pb2->orientation == Qt::Vertical);
1093 inverted = pb2->invertedAppearance;
1097 rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // flip width and height
1098 m.translate(rect.height(), 0.0);
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);
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);
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);
1120 const int unit_width = pixelMetric(PM_ProgressBarChunkWidth, pb, w);
1123 u = (rect.width() + unit_width / 3) / unit_width;
1125 u = width / unit_width;
1127 int p_v = pb->progress - pb->minimum;
1128 int t_s = pb->maximum - pb->minimum ? pb->maximum - pb->minimum : 1;
1130 if (u > 0 && p_v >= INT_MAX / u && t_s >= u) {
1131 // scale down to something usable.
1136 // nu < tnu, if last chunk is only a partial chunk
1138 tnu = nu = p_v * u / t_s;
1140 if (nu * unit_width > width)
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.
1148 int x0 = reverse ? rect.right() - ((unit_width > 1) ? unit_width : fw)
1150 QStyleOptionProgressBarV2 pbBits = *pb;
1152 pbBits.palette = pal2;
1153 int myY = pbBits.rect.y();
1154 int myHeight = pbBits.rect.height();
1155 pbBits.state = State_None;
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 );
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);
1167 aRect.setRight( aRect.right()-fw );
1169 aType = reverse ? Style_Tools::BottomLeft | Style_Tools::BottomRight
1170 : Style_Tools::TopLeft | Style_Tools::TopRight;
1172 aType = reverse ? Style_Tools::Right : Style_Tools::Left;
1175 else { // last element if it's necessary
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);
1182 aType = reverse ? Style_Tools::TopLeft | Style_Tools::TopRight
1183 : Style_Tools::BottomLeft | Style_Tools::BottomRight;
1185 aType = reverse ? Style_Tools::Left : Style_Tools::Right;
1188 aRect = m.mapRect(aRect);
1190 aRect = QRect(aRect.x(), aRect.y()+fw, aRect.width(), aRect.height());
1193 aRect = QRect(aRect.x()+1, aRect.y()+2, aRect.width()-1,
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();
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;
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;
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;
1224 // windows always has a check column, regardless whether we have an icon or not
1225 int checkcol = qMax(menuitem->maxIconWidth, 20);
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 ) );
1235 fill = menuitem->palette.brush( QPalette::Highlight );
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);
1249 QRect vCheckRect = visualRect(opt->direction, menuitem->rect, QRect(menuitem->rect.x(),
1250 menuitem->rect.y(), checkcol, menuitem->rect.height()));
1253 qDrawShadePanel(p, vCheckRect, menuitem->palette, true, 1, new QBrush(aBgColor));
1255 QColor aCol = aBgColor;
1256 aCol.setAlpha( 80 );
1258 qDrawShadePanel(p, vCheckRect, menuitem->palette, true, 1, &fill);
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;
1268 mode = QIcon::Active;
1271 pixmap = menuitem->icon.pixmap(pixelMetric(PM_SmallIconSize), mode, QIcon::On);
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;
1287 newMi.state |= State_Enabled;
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);
1295 p->setPen(act ? menuitem->palette.highlightedText().color() :
1296 menuitem->palette.buttonText().color());
1299 discol = menuitem->palette.text().color();
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
1310 int t = s.indexOf(QLatin1Char('\t'));
1311 int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip |
1313 if (!styleHint(SH_UnderlineShortcut, menuitem, w))
1314 text_flags |= Qt::TextHideMnemonic;
1315 text_flags |= Qt::AlignLeft;
1317 QRect vShortcutRect = visualRect(opt->direction, menuitem->rect,
1318 QRect(textRect.topRight(), QPoint(menuitem->rect.right(), textRect.bottom())));
1320 p->setPen(menuitem->palette.light().color());
1321 p->drawText(vShortcutRect.adjusted(1,1,1,1), text_flags, s.mid(t + 1));
1324 p->drawText(vShortcutRect, text_flags, s.mid(t + 1));
1327 QFont font = menuitem->font;
1328 if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem)
1332 p->setPen(menuitem->palette.light().color());
1333 p->drawText(vTextRect.adjusted(1,1,1,1), text_flags, s.left(t));
1336 p->drawText(vTextRect, text_flags, s.left(t));
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;
1351 newMI.palette.setColor(QPalette::ButtonText,
1352 newMI.palette.highlightedText().color());
1353 drawPrimitive(arrow, &newMI, p, w);
1359 QCommonStyle::drawControl( ce, opt, p, w );
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 );
1373 case CE_ComboBoxLabel:
1374 if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
1375 QRect editRect = subControlRect(CC_ComboBox, cb, SC_ComboBoxEditField, w);
1377 p->setClipRect(editRect);
1378 if (!cb->currentIcon.isNull()) {
1379 QIcon::Mode mode = cb->state & State_Enabled ? QIcon::Normal
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 );
1391 iconRect = alignedRect(QApplication::layoutDirection(),
1392 Qt::AlignLeft | Qt::AlignVCenter,
1393 iconRect.size(), alignRect);
1395 // Here's absent filling of pixmap on basic color for editable comboBox
1396 drawItemPixmap(p, iconRect, Qt::AlignCenter, pixmap);
1398 if (cb->direction == Qt::RightToLeft)
1399 editRect.translate(-4 - cb->iconSize.width(), 0);
1401 editRect.translate(cb->iconSize.width() + 4, 0);
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);
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;
1425 arrow = opt->direction == Qt::LeftToRight ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;
1427 if (ce == CE_ScrollBarAddLine)
1428 arrow = PE_IndicatorArrowDown;
1430 arrow = PE_IndicatorArrowUp;
1432 drawPrimitive(arrow, opt, p, w);
1435 case CE_ScrollBarSlider:
1436 if (const QStyleOptionSlider *scrollbar = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
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);
1445 QColor aColor = model()->color( Style_Model::Slider ); // Style_Model::slider_clr
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,
1456 gr = QLinearGradient(r.x(), r.y(), r.x(), r.bottom());
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 );
1463 p->fillPath( path, gr );
1464 p->strokePath( path, aBrdTopCol );
1466 p->setRenderHint( QPainter::Antialiasing, false );
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),
1477 int aRad2 = (int)(aRad/3);
1478 aRect = QRect( aRect.x()+aRad2, aRect.y()+aRad2, aRect.width()-2*aRad2, aRect.height()-2*aRad2 );
1480 drawHandle( p, aRect, horiz, true );
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 );
1494 BaseStyle::drawControl( ce, opt, p, w );
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
1504 \param w widget (optional)
1506 void Style_Salome::drawPrimitive( PrimitiveElement pe, const QStyleOption* opt,
1507 QPainter* p, const QWidget* w ) const
1509 if ( checkDebugLevel(6) ) {
1510 BaseStyle::drawPrimitive( pe, opt, p, w );
1514 const QPalette& pal = opt->palette;
1515 bool doRestore = false;
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 );
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);
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 );
1550 BaseStyle::drawPrimitive( pe, opt, p, w );
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 );
1566 BaseStyle::drawPrimitive( pe, opt, p, w );
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;
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 );
1586 pen = opt->palette.mid().color();
1589 if ( pe == PE_IndicatorSpinPlus || pe == PE_IndicatorSpinMinus )
1590 Style_Tools::drawSign( pe, p, rect, pen, brush );
1592 Style_Tools::drawArrow( pe, p, rect, pen, brush );
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);
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
1609 fill = QBrush( opt->palette.color( QPalette::Base ) );
1612 fill = opt->palette.color( QPalette::Window );
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 );
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());
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());
1638 p->setPen(opt->palette.text().color());
1640 case PE_IndicatorViewItemCheck:
1641 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
1642 case PE_Q3CheckListIndicator:
1649 const QStyleOptionViewItem *itemViewOpt = qstyleoption_cast<const QStyleOptionViewItem *>(opt);
1650 p->setPen(itemViewOpt && itemViewOpt->showDecorationSelected
1651 && opt->state & State_Selected ? opt->palette.highlightedText().color()
1652 : opt->palette.text().color());
1653 if (opt->state & State_NoChange)
1654 p->setBrush( opt->palette.color( QPalette::Button ) );
1655 p->drawRect(opt->rect.x() + 1, opt->rect.y() + 1, 11, 11);
1656 if (!(opt->state & State_Off)) {
1659 xx = opt->rect.x() + 4;
1660 yy = opt->rect.y() + 5;
1661 for (i = 0; i < 3; ++i) {
1662 lines[i] = QLineF(xx, yy, xx, yy + 2);
1667 for (i = 3; i < 11; ++i) {
1668 lines[i] = QLineF(xx, yy, xx, yy+2);
1672 QColor aColor = model()->color( Style_Model::Pointer ); // Style_Model::pointer_clr
1673 if ( !(opt->state & State_Enabled ) )
1674 aColor = opt->palette.mid().color();
1675 if ( opt->state & State_Selected && itemViewOpt && itemViewOpt->showDecorationSelected )
1676 aColor = opt->palette.highlightedText().color();
1678 p->setPen( QPen( aColor ) );
1679 p->drawLines(lines, 11);
1686 case PE_IndicatorRadioButton: {
1687 if ( hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver) )
1688 drawHoverRect(p, w->rect(), opt->palette.color( QPalette::Window ),
1689 model()->widgetRounding( Style_Model::ButtonRadius ),
1690 Style_Tools::All, false);
1691 #define PTSARRLEN(x) sizeof(x)/(sizeof(QPoint))
1692 static const QPoint pts_border[] = { // border line
1693 QPoint(1, 9), QPoint(1, 8), QPoint(0, 7), QPoint(0, 4), QPoint(1, 3), QPoint(1, 2),
1694 QPoint(2, 1), QPoint(3, 1), QPoint(4, 0), QPoint(7, 0), QPoint(8, 1), QPoint(9, 1),
1695 QPoint(10, 2), QPoint(10, 3), QPoint(11, 4), QPoint(11, 7), QPoint(10, 8), QPoint(10, 9),
1696 QPoint(9, 10), QPoint(8, 10), QPoint(7, 11), QPoint(4, 11), QPoint(3, 10), QPoint(2, 10)
1698 // make sure the indicator is square
1699 QRect ir = opt->rect;
1700 if (opt->rect.width() < opt->rect.height()) {
1701 ir.setTop(opt->rect.top() + (opt->rect.height() - opt->rect.width()) / 2);
1702 ir.setHeight(opt->rect.width());
1703 } else if (opt->rect.height() < opt->rect.width()) {
1704 ir.setLeft(opt->rect.left() + (opt->rect.width() - opt->rect.height()) / 2);
1705 ir.setWidth(opt->rect.height());
1708 bool down = opt->state & State_Sunken;
1709 bool enabled = opt->state & State_Enabled;
1710 bool on = opt->state & State_On;
1712 p->translate(ir.x(), ir.y());
1714 if ( down || !enabled ) {
1715 QColor fillColor = opt->palette.color( QPalette::Window );
1716 p->setPen( fillColor );
1717 p->setBrush( fillColor );
1720 QColor fillColor = opt->palette.color( QPalette::Base );
1721 if ( enabled && on )
1722 fillColor = model()->color( Style_Model::Checked ); // Style_Model::checked_clr
1723 QLinearGradient gr( 3, 3, 8, 8 );
1724 gr.setColorAt( 0.0, fillColor.dark( BUT_PERCENT_ON ) );
1725 gr.setColorAt( 1.0, fillColor );
1726 p->setPen( fillColor.dark( BUT_PERCENT_ON ) );
1729 p->drawPolygon(pts_border, PTSARRLEN(pts_border));
1730 int aSize = PTSARRLEN(pts_border),
1731 aHalfSize = (int)aSize/2;
1732 if ( model()->antialiasing() )
1733 p->setRenderHint( QPainter::Antialiasing, true );
1734 p->setPen( model()->color( Style_Model::BorderTop) ); // Style_Model::border_top_clr
1735 p->drawPolyline(pts_border, aHalfSize);
1736 p->setPen( model()->color( Style_Model::BorderBottom ) ); // Style_Model::border_bot_clr
1738 for ( int i = aHalfSize; i < aSize; i++ )
1739 aPolygon << pts_border[i];
1740 p->drawPolyline( aPolygon );
1741 if ( model()->antialiasing() )
1742 p->setRenderHint( QPainter::Antialiasing, false );
1745 QColor aPointerCol = model()->color( Style_Model::Pointer ); // Style_Model::pointer_clr
1747 aPointerCol = opt->palette.mid().color();
1748 p->setPen( Qt::NoPen );
1749 p->setBrush( aPointerCol );
1750 p->drawRect( 5, 4, 2, 4 );
1751 p->drawRect( 4, 5, 4, 2 );
1754 p->translate(-ir.x(), -ir.y()); // restore translate
1758 case PE_FrameDockWidget:
1759 if ( qstyleoption_cast<const QStyleOptionFrame *>(opt))
1760 QCommonStyle::drawPrimitive( pe, opt, p, w );
1762 case PE_FrameLineEdit:
1763 case PE_PanelLineEdit: {
1765 if ( qobject_cast<const QComboBox*>( w->parentWidget() ) ||
1766 qobject_cast<const QAbstractSpinBox*>( w->parentWidget() ) )
1769 if ( pe == PE_FrameLineEdit ) {
1770 QColor aBrdTopCol = model()->color( Style_Model::BorderTop ); // Style_Model::border_top_clr
1771 QColor aBrdBotCol = model()->color( Style_Model::BorderBottom ); // Style_Model::border_bot_clr
1772 bool hover = hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver);
1773 double aRad = model()->widgetRounding( Style_Model::EditRadius );
1775 drawHoverRect(p, opt->rect, opt->palette.color( QPalette::Window ), aRad, Style_Tools::All, true);
1777 Style_Tools::shadowRect( p, opt->rect, aRad, LINE_GR_MARGIN, SHADOW,
1778 Style_Tools::All, opt->palette.color( QPalette::Base ), // getColor( Style_Model::fld_light_clr ),
1779 model()->color( Style_Model::FieldDark ), aBrdTopCol, aBrdBotCol,
1780 model()->antialiasing(), false );
1784 if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(opt)) {
1785 QRect rect = panel->rect.adjusted( panel->lineWidth, panel->lineWidth,
1786 -panel->lineWidth, -panel->lineWidth);
1787 if ( w->inherits("QLineEdit") && panel->lineWidth > 0 ) {
1788 drawPrimitive( PE_FrameLineEdit, panel, p, w );
1791 QColor c = panel->palette.color(QPalette::Base); c.setAlpha(255);
1792 p->fillRect( rect, c ); // panel->palette.brush(QPalette::Base)
1798 case PE_FrameTabWidget: {
1799 if (w && qobject_cast<QTabWidget*>((QWidget*)w)) {
1800 QTabWidget* tabW = qobject_cast<QTabWidget*>((QWidget*)w);
1801 int aRoundType = Style_Tools::BottomRight;
1802 QTabWidget::TabPosition aTabPos = tabW->tabPosition();
1803 if ( aTabPos != QTabWidget::North && aTabPos != QTabWidget::West )
1804 aRoundType = aRoundType | Style_Tools::TopLeft;
1805 if ( aTabPos != QTabWidget::South )
1806 aRoundType = aRoundType | Style_Tools::BottomLeft;
1807 if ( aTabPos != QTabWidget::East )
1808 aRoundType = aRoundType | Style_Tools::TopRight;
1809 QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop ); // Style_Model::border_tab_top_clr
1810 QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom ); // Style_Model::border_tab_bot_clr
1811 Style_Tools::shadowRect( p, opt->rect, model()->widgetRounding( Style_Model::FrameRadius ),
1812 0., SHADOW, aRoundType,
1813 model()->color( Style_Model::FieldLight ),
1814 opt->palette.color( QPalette::Dark ),
1815 aBrdTopCol, aBrdBotCol, false, false, false, false );
1819 case PE_IndicatorToolBarHandle: {
1821 QRect r = opt->rect;
1822 bool horiz = opt->state & State_Horizontal;
1823 QLinearGradient gr( r.x(), r.y(), horiz ? r.x() : r.right(), horiz ? r.bottom() : r.y() );
1824 QColor aBgCol = opt->palette.color( QPalette::Window );
1825 gr.setColorAt( 0.0, aBgCol.light( BUT_PERCENT_ON ) );
1826 gr.setColorAt( 1.0, aBgCol );
1827 p->fillRect( r, gr );
1828 drawHandle( p, r, horiz, false );
1833 BaseStyle::drawPrimitive( pe, opt, p, w );
1837 if( w->parent() && !qobject_cast<QMenuBar*>((QWidget*)w) )
1839 drawBackground( p, w->rect(), opt->palette.color( QPalette::Window ), false );
1842 case PE_FrameTabBarBase:
1843 // for a tabbar that isn't part of a tab widget(dockWidgets for example).
1844 if (const QStyleOptionTabBarBase *tbb
1845 = qstyleoption_cast<const QStyleOptionTabBarBase *>(opt)) {
1846 if (tbb->shape != QTabBar::RoundedNorth && tbb->shape != QTabBar::RoundedEast &&
1847 tbb->shape != QTabBar::RoundedSouth && tbb->shape != QTabBar::RoundedWest) {
1848 BaseStyle::drawPrimitive( pe, opt, p, w );
1851 QRect aSelRect = tbb->selectedTabRect;
1852 // line under selected tab bar object
1853 bool isSelected = opt->state & State_Selected;
1854 QTabBar* tabBar = qobject_cast<QTabBar*>((QWidget*)w);
1855 bool isLast = false;
1857 isLast = tabBar->currentIndex() == tabBar->count() -1;
1858 QColor aColor = opt->palette.color( QPalette::Window );
1859 bool isHover = hasHover() && (opt->state & State_Enabled) &&
1860 (opt->state & State_MouseOver);
1861 QPainterPath aSelPath = Style_Tools::tabRect( p, aSelRect, (int)tbb->shape,
1862 model()->widgetRounding( Style_Model::FrameRadius ),
1863 DELTA_H_TAB, aColor, aColor,
1864 aColor, aColor, isSelected, isLast, isHover, false, false );
1865 if ( !aSelPath.isEmpty() )
1866 aSelRect = aSelPath.controlPointRect().toRect();
1867 QStyleOptionTabBarBase* copyOpt = (QStyleOptionTabBarBase*)tbb;
1868 copyOpt->selectedTabRect = aSelRect;
1869 QCommonStyle::drawPrimitive( pe, copyOpt, p, w );
1872 case PE_IndicatorBranch: {
1873 // This is _way_ too similar to the common style.
1874 static const int decoration_size = 9;
1875 int mid_h = opt->rect.x() + opt->rect.width() / 2;
1876 int mid_v = opt->rect.y() + opt->rect.height() / 2;
1881 if (opt->state & State_Children) {
1882 int delta = decoration_size / 2;
1887 p->drawLine(bef_h + 2, bef_v + 4, bef_h + 6, bef_v + 4);
1888 if (!(opt->state & State_Open))
1889 p->drawLine(bef_h + 4, bef_v + 2, bef_h + 4, bef_v + 6);
1890 QPen oldPen = p->pen();
1891 p->setPen(opt->palette.dark().color());
1892 p->drawRect(bef_h, bef_v, decoration_size - 1, decoration_size - 1);
1895 QBrush brush(opt->palette.dark().color(), Qt::Dense4Pattern);
1896 if (opt->state & State_Item) {
1897 if (opt->direction == Qt::RightToLeft)
1898 p->fillRect(opt->rect.left(), mid_v, bef_h - opt->rect.left(), 1, brush);
1900 p->fillRect(aft_h, mid_v, opt->rect.right() - aft_h + 1, 1, brush);
1902 if (opt->state & State_Sibling)
1903 p->fillRect(mid_h, aft_v, 1, opt->rect.bottom() - aft_v + 1, brush);
1904 if (opt->state & (State_Open | State_Children | State_Item | State_Sibling))
1905 p->fillRect(mid_h, opt->rect.y(), 1, bef_v - opt->rect.y(), brush);
1908 case PE_IndicatorDockWidgetResizeHandle: {
1909 QRect r = opt->rect;
1910 drawBorder( p, r, opt->state & State_Horizontal );
1911 bool hover = hasHover() && (opt->state & State_Enabled) && (opt->state & State_MouseOver);
1913 drawHoverRect(p, r, opt->palette.color( QPalette::Window ), 0, Style_Tools::All, false);
1914 bool horiz = r.width() > r.height();
1915 int aLen = model()->splitHandleLength();
1917 r = QRect( r.x() +(int)((r.width()-aLen)/2), r.y(), aLen, r.height());
1919 r = QRect( r.x(), r.y() +(int)((r.height()-aLen)/2), r.width(), aLen);
1920 drawHandle( p, r, horiz, true );
1924 QWidget* aWdg = (QWidget*)w;
1925 if ( qobject_cast<QTextEdit*>(aWdg) || qobject_cast<QTreeView*>(aWdg) ||
1926 qobject_cast<QListView*>(aWdg) ) {
1927 QRect r = opt->rect;
1928 if ( qobject_cast<QTreeView*>(aWdg) ) {
1929 QTreeView* trView = qobject_cast<QTreeView*>(aWdg);
1930 QHeaderView* aHeader = trView->header();
1931 if ( aHeader && aHeader->isVisible() ) {
1932 int aHeight = aHeader->contentsRect().height();
1933 r = QRect( r.x(), r.y()+aHeight, r.width(), r.height()-aHeight );
1936 QPalette aPal = aWdg->palette();
1937 double aMarg = LINE_GR_MARGIN;
1938 QColor base = model()->color( Style_Model::Base ), // Style_Model::pal_base_clr
1940 light_alt = base.dark(110),//AlternateBase color
1941 dark = model()->color( Style_Model::FieldDark ); // Style_Model::fld_dark_clr
1942 //light.setAlpha( 0 ); // VSR commented: IPAL19262
1943 QLinearGradient gr_h(r.x(), r.y(), r.right(), r.y());
1944 gr_h.setColorAt( 0.0, dark );
1945 gr_h.setColorAt( aMarg / r.width(), light );
1946 gr_h.setColorAt( 1.0, light );
1947 QLinearGradient gr_v(r.x(), r.y(), r.x(), r.bottom() );
1948 gr_v.setColorAt( 0.0, dark );
1949 gr_v.setColorAt( aMarg / r.height(), light );
1950 gr_v.setColorAt( 1.0, light );
1952 p->fillRect( r, base );
1953 p->fillRect( r, gr_h );
1954 p->fillRect( r, gr_v );
1955 aPal.setBrush( QPalette::Base, QBrush( light ) );
1957 QLinearGradient gr_alt(r.x(), r.y(), r.right(), r.y());
1958 gr_alt.setColorAt( 0.0, dark );
1959 gr_alt.setColorAt( (aMarg)*2/3/r.width(), light_alt );
1960 gr_alt.setColorAt( 1.0, light_alt );
1961 aPal.setBrush( QPalette::AlternateBase, QBrush( gr_alt ) );
1962 aWdg->setPalette( aPal );
1964 BaseStyle::drawPrimitive( pe, opt, p, w );
1968 BaseStyle::drawPrimitive( pe, opt, p, w );
1973 \brief Returns the value of the given pixel \a metric.
1974 \param metric metric type
1975 \param opt style option
1977 \return metric value
1979 int Style_Salome::pixelMetric( PixelMetric metric, const QStyleOption* opt,
1980 const QWidget* w ) const
1982 if ( checkDebugLevel(7) ) {
1983 return BaseStyle::pixelMetric( metric, opt, w );
1985 int aRes = BaseStyle::pixelMetric( metric, opt, w );
1987 case PM_SliderLength: {
1988 aRes += (int)((double)model()->sliderSize()/2);
1991 case PM_DockWidgetFrameWidth:
1994 case PM_DockWidgetSeparatorExtent:
1997 case PM_DockWidgetTitleMargin:
2000 case PM_SplitterWidth:
2010 \brief Returns the size of the element described by the specified option \a opt
2011 and type \a ct, based on the provided \a contentsSize.
2012 \param ct contents type
2013 \param opt style option
2014 \param contentsSize contents size
2015 \param w widget (optional)
2016 \return size of the element
2018 QSize Style_Salome::sizeFromContents( ContentsType ct, const QStyleOption* opt,
2019 const QSize& contentsSize, const QWidget* w ) const
2021 if ( checkDebugLevel(8) ) {
2022 return BaseStyle::sizeFromContents( ct, opt,contentsSize, w );
2024 QSize sz = BaseStyle::sizeFromContents( ct, opt, contentsSize, w );
2027 if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(opt)) {
2028 if ( tab->position == QStyleOptionTab::End ||
2029 tab->position == QStyleOptionTab::OnlyOneTab ) {
2030 if ( tab->shape == QTabBar::RoundedNorth || tab->shape == QTabBar::RoundedSouth ) {
2031 int aDelta = (int)(opt->rect.height()*DELTA_H_TAB/2);
2032 sz.setWidth( sz.width() + aDelta );
2034 if ( tab->shape == QTabBar::RoundedEast || tab->shape == QTabBar::RoundedWest ) {
2035 int aDelta = (int)(opt->rect.width()*DELTA_H_TAB/2);
2036 sz.setHeight( sz.height() + aDelta );
2043 int aValue = model()->sliderSize();
2044 sz.setWidth( sz.width() + aValue );
2045 sz.setHeight( sz.height() + aValue );
2049 if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
2050 QRect res = QRect( 0, 0, sz.width(), sz.height() );
2051 int aHalfRect = (int)Style_Tools::getMaxRect( res,
2052 (int)model()->widgetRounding( Style_Model::EditRadius )/2 ); // left value
2054 QRect old_arrow = BaseStyle::subControlRect( CC_ComboBox, cmb,
2055 SC_ComboBoxArrow, w );
2056 int aDelta = res.height() - old_arrow.width(); // right value
2057 if ( cmb->editable )
2058 aDelta += aHalfRect; // for right of line edit internal
2059 sz.setWidth( res.width() + aDelta + aHalfRect );
2069 \brief Returns a pixmap for the given \a standardPixmap.
2070 \param stPixmap standard pixmap type
2071 \param opt style option
2072 \param w widget (optional)
2073 \return standard pixmap
2075 QPixmap Style_Salome::standardPixmap(StandardPixmap stPixmap, const QStyleOption *opt,
2076 const QWidget *w) const
2078 if ( checkDebugLevel(9) ) {
2079 return BaseStyle::standardPixmap( stPixmap, opt, w );
2084 case SP_DockWidgetCloseButton:
2085 case SP_TitleBarCloseButton:
2086 return QPixmap( cross_xpm );
2087 case SP_TitleBarMaxButton:
2088 return QPixmap( maximize_xpm );
2089 case SP_TitleBarNormalButton:
2090 return QPixmap( normal_xpm );
2091 case SP_TitleBarMinButton:
2092 return QPixmap( minimize_xpm );
2094 return BaseStyle::standardPixmap( stPixmap, opt, w );
2099 \brief Returns an icon for the given \a standardIcon.
2100 \param standardIcon standard icon type
2101 \param opt style option
2102 \param w widget (optional)
2103 \return standard icon
2105 QIcon Style_Salome::standardIconImplementation( StandardPixmap standardIcon,
2106 const QStyleOption* opt,
2107 const QWidget* w ) const
2109 if ( checkDebugLevel(10) ) {
2110 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
2111 return BaseStyle::standardIconImplementation( standardIcon, opt, w );
2113 return QCommonStyle::standardIcon( standardIcon, opt, w );
2117 switch ( standardIcon )
2119 case SP_MessageBoxInformation:
2120 return QPixmap( ":/images/information.png" );
2121 case SP_MessageBoxWarning:
2122 return QPixmap( ":/images/warning.png" );
2123 case SP_MessageBoxCritical:
2124 return QPixmap( ":/images/critical.png" );
2125 case SP_MessageBoxQuestion:
2126 return QPixmap( ":/images/question.png" );
2130 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
2131 return BaseStyle::standardIconImplementation( standardIcon, opt, w );
2133 return BaseStyle::standardIcon( standardIcon, opt, w );
2138 \brief Returns an integer representing the specified style \a hint for the
2139 given widget \a w described by the provided style option \a opt.
2140 \param hint hint type
2141 \param opt style option
2142 \param w widget (optional)
2143 \param returnData (currently not used)
2144 \return style hint value
2146 int Style_Salome::styleHint( StyleHint hint, const QStyleOption* opt, const QWidget* w,
2147 QStyleHintReturn* returnData ) const
2149 if ( checkDebugLevel(11) ) {
2150 return BaseStyle::styleHint( hint, opt, w, returnData );
2152 int aRes = BaseStyle::styleHint( hint, opt, w, returnData );
2154 case SH_Table_GridLineColor: {
2156 aRes = model()->color( Style_Model::GridLine ).rgb(); // Style_Model::tbl_grline_clr
2168 \brief Get the rectangle containing the specified subcontrol \a sc of the given
2169 complex control \a cc (with the style specified by option \a opt).
2170 The rectangle is defined in screen coordinates.
2171 \param cc complex control type
2172 \param opt style option
2173 \param sc subcontrol type
2174 \param wid widget (optional)
2175 \return subcontrol rectangle
2177 QRect Style_Salome::subControlRect( ComplexControl cc, const QStyleOptionComplex* opt,
2178 SubControl sc, const QWidget* wid ) const
2180 if ( checkDebugLevel(12) ) {
2181 return BaseStyle::subControlRect( cc, opt, sc, wid );
2183 QRect res = BaseStyle::subControlRect( cc, opt, sc, wid );
2186 int x = res.x(), w = res.width(), h = res.height();
2187 if ( sc==SC_SpinBoxUp || sc==SC_SpinBoxDown ) {
2188 QRect frame_r = BaseStyle::subControlRect( cc, opt, SC_SpinBoxFrame, wid );
2189 h = frame_r.height();
2193 else if ( sc==QStyle::SC_SpinBoxEditField ) {
2194 res.setWidth( w-h );
2195 res.setTopLeft( QPoint( res.x(), res.y()-SHADOW ) );
2200 if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
2202 int aHalfRect = (int)Style_Tools::getMaxRect( res, (int)model()->widgetRounding( Style_Model::EditRadius )/2 );
2203 int x = res.x(), w = res.width(), h = res.height();
2205 case SC_ComboBoxEditField: {
2206 res.setWidth( w-h );
2208 if ( !cb->editable )
2210 res.setTopLeft( QPoint( aX, res.y()-SHADOW ) );
2213 case SC_ComboBoxArrow: {
2223 if (const QStyleOptionSlider *scrollbar = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
2224 QRect slider_r = BaseStyle::subControlRect( cc, opt, SC_ScrollBarSlider, wid );
2225 int aRect = Style_Tools::getMaxRect( slider_r, (int)model()->widgetRounding( Style_Model::ButtonRadius ) );
2227 case SC_ScrollBarSubPage: // between top/left button and slider
2228 if (scrollbar->orientation == Qt::Horizontal)
2229 res.setRight( res.right()+aRect+1 );
2231 res.setBottom( res.bottom()+aRect+1 );
2233 case SC_ScrollBarAddPage: // between bottom/right button and slider
2234 if (scrollbar->orientation == Qt::Horizontal)
2235 res.setLeft( res.left() - aRect - 1 );
2237 res.setTop( res.top() - aRect - 1);
2245 if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
2247 case SC_SliderGroove: {
2248 if ( slider->orientation == Qt::Horizontal ) {
2249 res.setLeft( res.left()+DELTA_SLIDER );
2250 res.setRight( res.right()-DELTA_SLIDER );
2253 res.setTop( res.top()+DELTA_SLIDER );
2254 res.setBottom( res.bottom()-DELTA_SLIDER );
2266 \brief Returns the sub-area for the given element \a se as described
2267 in the provided style option \a opt.
2268 The returned rectangle is defined in screen coordinates.
2269 \param se subelement type
2270 \param opt style option
2271 \param wid widget (optional)
2272 \return subelement rectangle
2274 QRect Style_Salome::subElementRect( SubElement se, const QStyleOption* opt,
2275 const QWidget* wid ) const
2277 if ( checkDebugLevel(13) ) {
2278 return BaseStyle::subElementRect( se, opt, wid );
2281 QRect res = BaseStyle::subElementRect( se, opt, wid );
2282 int aHalfRect = (int)Style_Tools::getMaxRect( res, (int)model()->widgetRounding( Style_Model::EditRadius )/2 );
2283 int w = res.width(), h = res.height();
2285 case SE_ComboBoxFocusRect: {
2287 QRect old_r = BaseStyle::subControlRect( CC_ComboBox,
2288 qstyleoption_cast<const QStyleOptionComplex*>( opt ),
2289 SC_ComboBoxArrow, wid );
2290 int old_w = old_r.width();
2291 res.setWidth( w-h+old_w-2 );
2294 case SE_LineEditContents: {
2295 res.setTopLeft( QPoint( res.x()+aHalfRect, res.y()-SHADOW ) );
2296 res.setTopRight( QPoint( res.right()-aHalfRect, res.y() ) );
2299 case SE_ProgressBarLabel:
2300 case SE_ProgressBarContents:
2301 case SE_ProgressBarGroove:
2304 if( qobject_cast<const QRadioButton*>(wid) ||
2305 qobject_cast<const QCheckBox*>(wid) ) {
2307 res = res.adjusted(0, 0, 2, 0);
2313 \brief Update palette colors from style model
2315 void Style_Salome::updatePaletteColors()
2317 QPalette pal = QApplication::palette();
2319 for ( int i = (int)QPalette::Active; i <= (int)QPalette::Inactive; i++ ) {
2320 for ( int j = (int)Style_Model::WindowText; j < (int)Style_Model::NColorRoles; j++ ) {
2321 if ( j == QPalette::NoRole ) continue;
2322 pal.setColor( (QPalette::ColorGroup)i, (QPalette::ColorRole)j,
2323 model()->color( (Style_Model::ColorRole)j, (QPalette::ColorGroup)i ) );
2326 QPixmapCache::clear();
2327 QApplication::setPalette( pal );
2331 \brief Update all widgets with the current style properties.
2332 \param app application object
2334 void Style_Salome::updateAllWidgets( QApplication* app )
2339 QWidgetList all = app->allWidgets();
2341 for (QWidgetList::ConstIterator it2 = all.constBegin(); it2 != all.constEnd(); ++it2) {
2343 if (w->windowType() != Qt::Desktop && w->testAttribute(Qt::WA_WState_Polished)
2344 && !w->testAttribute(Qt::WA_SetStyle)) {
2345 QEvent e(QEvent::StyleChange);
2346 QApplication::sendEvent(w, &e);
2354 \brief Check if any widget effect is currently used
2355 \return \c true if any widget effect is currently used
2357 bool Style_Salome::hasHover() const
2359 return model()->widgetEffect() != Style_Model::NoEffect;
2363 \brief Draw rectangle for the hovered widget
2366 \param bgCol background color
2367 \param rad corners rounding radius
2368 \param type shadow type
2369 \param border if \c true border is colored with specific color
2371 void Style_Salome::drawHoverRect( QPainter* p, const QRect& r, const QColor& bgCol, const double rad,
2372 const int type, const bool border ) const
2376 bool isAutoRaising = model()->widgetEffect() == Style_Model::AutoRaiseEffect;
2377 bool isHighWdg = model()->widgetEffect() == Style_Model::HighlightEffect;
2378 QColor aBorder = model()->color( Style_Model::BorderTop ), // Style_Model::border_bot_clr
2380 double aMargin = HIGH_WDG_MARGIN;
2381 if ( isAutoRaising ) {
2383 aBrdCol = aCol.dark(BUT_PERCENT_ON);
2388 else if ( isHighWdg ) {
2389 aCol = model()->color( Style_Model::HighlightWidget ); // Style_Model::high_wdg_clr
2390 aBrdCol = model()->color( Style_Model::HighlightBorder ); // Style_Model::high_brd_wdg_clr
2394 Style_Tools::highlightRect( p, r, rad, type, aMargin, aCol, aBrdCol, aBorder );
2398 \brief Draw widget handle
2401 \param horiz if \c true draw horizontal handle, otherwise draw vertical handle
2402 \param isRect if \c true surrounding rectangle is also drawn
2404 void Style_Salome::drawHandle( QPainter* p, const QRect& r, bool horiz, bool isRect ) const
2406 QPixmap hole( (const char**)hole_xpm );
2408 double d_hor = model()->handleDelta( Qt::Horizontal );
2409 double d_ver = model()->handleDelta( Qt::Vertical );
2410 if ( !d_hor || !d_ver || !r.width() || !r.height() )
2412 int c_hor = (int)(r.width()/d_hor)-1;
2413 int c_ver = (int)(r.height()/d_ver)-1;
2414 if ( c_hor+1 <= 0 || c_ver+1 <= 0 )
2416 // correction for delta value
2417 d_hor = r.width()/(c_hor+1);
2418 d_ver = r.height()/(c_ver+1);
2420 double dd_hor = 0, dd_ver = 0;
2422 for ( i = 0; i < c_hor; i++ ) {
2423 for ( j = 0; j < c_ver; j++ ) {
2424 p->drawPixmap( (int)( r.x() + dd_hor + ( i + 1 ) * d_hor - 1 ),
2425 (int)( r.y() + dd_ver + ( j + 1 ) * d_ver - 1 ), hole );
2428 dd_ver += (int(d_ver)/2) + (int(d_ver)%2);
2434 for ( j = 0; j < c_ver; j++ ) {
2435 for ( i = 0; i < c_hor; i++ ) {
2436 p->drawPixmap( (int)( r.x() + dd_hor + ( i + 1 ) * d_hor - 1 ),
2437 (int)( r.y() + dd_ver + ( j + 1 ) * d_ver - 1 ), hole );
2440 dd_hor += (int(d_hor)/2) + (int(d_hor)%2);
2448 \brief Draw background.
2451 \param bgCol background color
2452 \param fill 'fill rectangle' flag
2453 \param grad 'draw gradient' flag
2454 \param horix 'draw horizontal item' flag (usefull for gradient background)
2456 void Style_Salome::drawBackground( QPainter* p, const QRect& r, const QColor& bgCol,
2457 const bool fill, const bool grad, const bool horiz ) const
2461 p->fillRect( r, bgCol );
2463 QLinearGradient gr( r.x(), r.y(), horiz ? r.x() : r.right(), horiz ? r.bottom() : r.y() );
2464 gr.setColorAt( 0.0, bgCol.light( BUT_PERCENT_ON ) );
2465 gr.setColorAt( 1.0, bgCol );
2466 p->fillRect( r, gr );
2470 int x = r.x(), y = r.y(), left = r.left(), top = r.top();
2471 int w = r.width(), h = r.height();
2473 QVector<QLine> lines;
2475 switch ( model()->linesType() ) {
2476 case Style_Model::Horizontal:
2479 for ( int i = 0; i <= h; i += d )
2480 lines.append( QLine( x, y+i, w, r.y()+i ) );
2483 case Style_Model::Inclined:
2488 for ( int i = 0; i <= w; i += d )
2489 lines.append( QLine( x+i, y, x, y+i ) );
2490 for ( int i = 0; i < h; i += d )
2491 lines.append( QLine( left+w-i, top+h, left+w, top+h-i ) );
2498 if ( !lines.isEmpty() ) {
2499 QColor c = model()->color( Style_Model::Lines );
2500 int anAlpha = (int)( 255*( 1 - model()->linesTransparency()/100 ) );
2501 c.setAlpha( anAlpha );
2503 p->setRenderHint( QPainter::Antialiasing );
2504 p->drawLines( lines );
2512 \param horiz 'draw horizontal item' flag
2514 void Style_Salome::drawBorder( QPainter* p, const QRect& r, bool horiz ) const
2516 QPen oldPen = p->pen();
2517 QColor aBrdTopCol = model()->color( Style_Model::TabBorderTop ); // Style_Model::border_tab_top_clr
2518 QColor aBrdBotCol = model()->color( Style_Model::TabBorderBottom ); // Style_Model::border_tab_bot_clr
2519 p->setPen( aBrdTopCol );
2521 p->drawLine(r.left(), r.top(), r.right(), r.top());
2522 p->setPen(aBrdBotCol);
2523 p->drawLine(r.left(), r.bottom(), r.right(), r.bottom());
2526 p->drawLine(r.left(), r.top(), r.left(), r.bottom());
2527 p->setPen(aBrdBotCol);
2528 p->drawLine(r.right(), r.top(), r.right(), r.bottom());
2534 \brief Get corrected title text
2535 \param txt original text
2536 \param W possible width
2537 \param H possible height
2539 \return corrected title text
2541 QString Style_Salome::titleText( const QString& txt, const int W, const int H, QFont& f ) const
2543 QString res = txt.trimmed();
2545 QFontMetrics fm( f );
2546 while( fm.height() > H && f.pointSize()>1 )
2548 f.setPointSize( f.pointSize()-1 );
2549 fm = QFontMetrics( f );
2552 if ( fm.width( res ) > W )
2554 QString end( "..." );
2555 while ( !res.isEmpty() && fm.width( res + end ) > W )
2556 res.remove( res.length() - 1, 1 );
2558 if ( !res.isEmpty() )