Qt 4.8
Public Functions | Static Public Functions | Protected Slots | List of all members
QGtkStyle Class Reference

The QGtkStyle class provides a widget style rendered by GTK+. More...

#include <qgtkstyle.h>

Inheritance diagram for QGtkStyle:
QCleanlooksStyle QWindowsStyle QCommonStyle QStyle QObject

Public Functions

void drawComplexControl (ComplexControl control, const QStyleOptionComplex *option, QPainter *painter, const QWidget *widget) const
 Reimplemented Function More...
 
void drawControl (ControlElement control, const QStyleOption *option, QPainter *painter, const QWidget *widget) const
 Reimplemented Function More...
 
void drawItemPixmap (QPainter *painter, const QRect &rect, int alignment, const QPixmap &pixmap) const
 Reimplemented Function More...
 
void drawItemText (QPainter *painter, const QRect &rect, int alignment, const QPalette &pal, bool enabled, const QString &text, QPalette::ColorRole textRole) const
 Reimplemented Function More...
 
void drawPrimitive (PrimitiveElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const
 Reimplemented Function More...
 
QPixmap generatedIconPixmap (QIcon::Mode iconMode, const QPixmap &pixmap, const QStyleOption *opt) const
 Reimplemented Function More...
 
QStyle::SubControl hitTestComplexControl (ComplexControl cc, const QStyleOptionComplex *opt, const QPoint &pt, const QWidget *w) const
 Reimplemented Function More...
 
QRect itemPixmapRect (const QRect &r, int flags, const QPixmap &pixmap) const
 Reimplemented Function More...
 
int pixelMetric (PixelMetric metric, const QStyleOption *option=0, const QWidget *widget=0) const
 Reimplemented Function More...
 
void polish (QWidget *widget)
 Reimplemented Function More...
 
void polish (QApplication *app)
 Reimplemented Function More...
 
void polish (QPalette &palette)
 Reimplemented Function More...
 
 QGtkStyle ()
 Constructs a QGtkStyle object. More...
 
 QGtkStyle (QGtkStylePrivate &dd)
 Constructs a QGtkStyle object. More...
 
QSize sizeFromContents (ContentsType type, const QStyleOption *option, const QSize &size, const QWidget *widget) const
 Reimplemented Function More...
 
QPalette standardPalette () const
 Reimplemented Function More...
 
QPixmap standardPixmap (StandardPixmap sp, const QStyleOption *option, const QWidget *widget) const
 Reimplemented Function More...
 
int styleHint (StyleHint hint, const QStyleOption *option, const QWidget *widget, QStyleHintReturn *returnData) const
 Reimplemented Function More...
 
QRect subControlRect (ComplexControl control, const QStyleOptionComplex *option, SubControl subControl, const QWidget *widget) const
 Reimplemented Function More...
 
QRect subElementRect (SubElement sr, const QStyleOption *opt, const QWidget *w) const
 Reimplemented Function More...
 
void unpolish (QWidget *widget)
 Reimplemented Function More...
 
void unpolish (QApplication *app)
 Reimplemented Function More...
 
 ~QGtkStyle ()
 Destroys the QGtkStyle object. More...
 
- Public Functions inherited from QCleanlooksStyle
 QCleanlooksStyle ()
 Constructs a QCleanlooksStyle object. More...
 
 ~QCleanlooksStyle ()
 Destroys the QCleanlooksStyle object. More...
 
- Public Functions inherited from QWindowsStyle
void drawComplexControl (ComplexControl cc, const QStyleOptionComplex *opt, QPainter *p, const QWidget *w=0) const
 Reimplemented Function More...
 
void drawControl (ControlElement element, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const
 Reimplemented Function More...
 
void drawPrimitive (PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const
 Reimplemented Function More...
 
int pixelMetric (PixelMetric pm, const QStyleOption *option=0, const QWidget *widget=0) const
 Reimplemented Function More...
 
void polish (QApplication *)
 Reimplemented Function More...
 
void polish (QWidget *)
 Reimplemented Function More...
 
void polish (QPalette &)
 Reimplemented Function More...
 
 QWindowsStyle ()
 Constructs a QWindowsStyle object. More...
 
QSize sizeFromContents (ContentsType ct, const QStyleOption *opt, const QSize &contentsSize, const QWidget *widget=0) const
 Reimplemented Function More...
 
QPixmap standardPixmap (StandardPixmap standardPixmap, const QStyleOption *opt, const QWidget *widget=0) const
 Reimplemented Function More...
 
int styleHint (StyleHint hint, const QStyleOption *opt=0, const QWidget *widget=0, QStyleHintReturn *returnData=0) const
 Reimplemented Function More...
 
QRect subElementRect (SubElement r, const QStyleOption *opt, const QWidget *widget=0) const
 Reimplemented Function More...
 
void unpolish (QApplication *)
 Reimplemented Function More...
 
void unpolish (QWidget *)
 Reimplemented Function More...
 
 ~QWindowsStyle ()
 Destroys the QWindowsStyle object. More...
 
- Public Functions inherited from QCommonStyle
 QCommonStyle ()
 Constructs a QCommonStyle. More...
 
 ~QCommonStyle ()
 Destroys the style. More...
 
- Public Functions inherited from QStyle
int combinedLayoutSpacing (QSizePolicy::ControlTypes controls1, QSizePolicy::ControlTypes controls2, Qt::Orientation orientation, QStyleOption *option=0, QWidget *widget=0) const
 Returns the spacing that should be used between controls1 and controls2 in a layout. More...
 
virtual QRect itemTextRect (const QFontMetrics &fm, const QRect &r, int flags, bool enabled, const QString &text) const
 Returns the area within the given rectangle in which to draw the provided text according to the specified font metrics and alignment. More...
 
int layoutSpacing (QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption *option=0, const QWidget *widget=0) const
 Returns the spacing that should be used between control1 and control2 in a layout. More...
 
const QStyle * proxy () const
 
 QStyle ()
 Constructs a style object. More...
 
QIcon standardIcon (StandardPixmap standardIcon, const QStyleOption *option=0, const QWidget *widget=0) const
 Returns an icon for the given standardIcon. More...
 
virtual ~QStyle ()
 Destroys the style object. More...
 
- Public Functions inherited from QObject
bool blockSignals (bool b)
 If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...
 
const QObjectList & children () const
 Returns a list of child objects. More...
 
bool connect (const QObject *sender, const char *signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const
 
bool disconnect (const char *signal=0, const QObject *receiver=0, const char *member=0)
 
bool disconnect (const QObject *receiver, const char *member=0)
 
void dumpObjectInfo ()
 Dumps information about signal connections, etc. More...
 
void dumpObjectTree ()
 Dumps a tree of children to the debug output. More...
 
QList< QByteArray > dynamicPropertyNames () const
 Returns the names of all properties that were dynamically added to the object using setProperty(). More...
 
virtual bool event (QEvent *)
 This virtual function receives events to an object and should return true if the event e was recognized and processed. More...
 
template<typename T >
T findChild (const QString &aName=QString()) const
 Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...
 
template<typename T >
QList< T > findChildren (const QString &aName=QString()) const
 Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...
 
template<typename T >
QList< T > findChildren (const QRegExp &re) const
 
bool inherits (const char *classname) const
 Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...
 
void installEventFilter (QObject *)
 Installs an event filter filterObj on this object. More...
 
bool isWidgetType () const
 Returns true if the object is a widget; otherwise returns false. More...
 
void killTimer (int id)
 Kills the timer with timer identifier, id. More...
 
virtual const QMetaObject * metaObject () const
 Returns a pointer to the meta-object of this object. More...
 
void moveToThread (QThread *thread)
 Changes the thread affinity for this object and its children. More...
 
QString objectName () const
 
QObject * parent () const
 Returns a pointer to the parent object. More...
 
QVariant property (const char *name) const
 Returns the value of the object's name property. More...
 
Q_INVOKABLE QObject (QObject *parent=0)
 Constructs an object with parent object parent. More...
 
void removeEventFilter (QObject *)
 Removes an event filter object obj from this object. More...
 
void setObjectName (const QString &name)
 
void setParent (QObject *)
 Makes the object a child of parent. More...
 
bool setProperty (const char *name, const QVariant &value)
 Sets the value of the object's name property to value. More...
 
void setUserData (uint id, QObjectUserData *data)
 
bool signalsBlocked () const
 Returns true if signals are blocked; otherwise returns false. More...
 
int startTimer (int interval)
 Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...
 
QThread * thread () const
 Returns the thread in which the object lives. More...
 
QObjectUserData * userData (uint id) const
 
virtual ~QObject ()
 Destroys the object, deleting all its child objects. More...
 

Static Public Functions

static bool getGConfBool (const QString &key, bool fallback=0)
 Returns the configuration boolean for key. More...
 
static QString getGConfString (const QString &key, const QString &fallback=QString())
 Returns the configuration string for value. More...
 
- Static Public Functions inherited from QStyle
static QRect alignedRect (Qt::LayoutDirection direction, Qt::Alignment alignment, const QSize &size, const QRect &rectangle)
 Returns a new rectangle of the specified size that is aligned to the given rectangle according to the specified alignment and direction. More...
 
static int sliderPositionFromValue (int min, int max, int val, int space, bool upsideDown=false)
 Converts the given logicalValue to a pixel position. More...
 
static int sliderValueFromPosition (int min, int max, int pos, int space, bool upsideDown=false)
 Converts the given pixel position to a logical value. More...
 
static Qt::Alignment visualAlignment (Qt::LayoutDirection direction, Qt::Alignment alignment)
 Transforms an alignment of Qt::AlignLeft or Qt::AlignRight without Qt::AlignAbsolute into Qt::AlignLeft or Qt::AlignRight with Qt::AlignAbsolute according to the layout direction. More...
 
static QPoint visualPos (Qt::LayoutDirection direction, const QRect &boundingRect, const QPoint &logicalPos)
 Returns the given logicalPosition converted to screen coordinates based on the specified direction. More...
 
static QRect visualRect (Qt::LayoutDirection direction, const QRect &boundingRect, const QRect &logicalRect)
 Returns the given logicalRectangle converted to screen coordinates based on the specified direction. More...
 
- Static Public Functions inherited from QObject
static bool connect (const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
 Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...
 
static bool connect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)
 
static bool disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *member)
 Disconnects signal in object sender from method in object receiver. More...
 
static bool disconnect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &member)
 
static uint registerUserData ()
 
static QString tr (const char *sourceText, const char *comment=0, int n=-1)
 
static QString trUtf8 (const char *sourceText, const char *comment=0, int n=-1)
 

Protected Slots

QIcon standardIconImplementation (StandardPixmap standardIcon, const QStyleOption *option, const QWidget *widget=0) const
 
- Protected Slots inherited from QCleanlooksStyle
QIcon standardIconImplementation (StandardPixmap standardIcon, const QStyleOption *option, const QWidget *widget=0) const
 
- Protected Slots inherited from QWindowsStyle
QIcon standardIconImplementation (StandardPixmap standardIcon, const QStyleOption *option, const QWidget *widget=0) const
 
- Protected Slots inherited from QCommonStyle
QIcon standardIconImplementation (StandardPixmap standardIcon, const QStyleOption *opt=0, const QWidget *widget=0) const
 
- Protected Slots inherited from QStyle
int layoutSpacingImplementation (QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption *option=0, const QWidget *widget=0) const
 This slot is called by layoutSpacing() to determine the spacing that should be used between control1 and control2 in a layout. More...
 
QIcon standardIconImplementation (StandardPixmap standardIcon, const QStyleOption *opt=0, const QWidget *widget=0) const
 Returns an icon for the given standardIcon. More...
 

Additional Inherited Members

- Public Types inherited from QStyle
enum  ComplexControl {
  CC_SpinBox, CC_ComboBox, CC_ScrollBar, CC_Slider,
  CC_ToolButton, CC_TitleBar, CC_Q3ListView, CC_Dial,
  CC_GroupBox, CC_MdiControls, CC_CustomBase = 0xf0000000
}
 This enum describes the available complex controls. More...
 
enum  ContentsType {
  CT_PushButton, CT_CheckBox, CT_RadioButton, CT_ToolButton,
  CT_ComboBox, CT_Splitter, CT_Q3DockWindow, CT_ProgressBar,
  CT_MenuItem, CT_MenuBarItem, CT_MenuBar, CT_Menu,
  CT_TabBarTab, CT_Slider, CT_ScrollBar, CT_Q3Header,
  CT_LineEdit, CT_SpinBox, CT_SizeGrip, CT_TabWidget,
  CT_DialogButtons, CT_HeaderSection, CT_GroupBox, CT_MdiControls,
  CT_ItemViewItem, CT_CustomBase = 0xf0000000
}
 This enum describes the available contents types. More...
 
enum  ControlElement {
  CE_PushButton, CE_PushButtonBevel, CE_PushButtonLabel, CE_CheckBox,
  CE_CheckBoxLabel, CE_RadioButton, CE_RadioButtonLabel, CE_TabBarTab,
  CE_TabBarTabShape, CE_TabBarTabLabel, CE_ProgressBar, CE_ProgressBarGroove,
  CE_ProgressBarContents, CE_ProgressBarLabel, CE_MenuItem, CE_MenuScroller,
  CE_MenuVMargin, CE_MenuHMargin, CE_MenuTearoff, CE_MenuEmptyArea,
  CE_MenuBarItem, CE_MenuBarEmptyArea, CE_ToolButtonLabel, CE_Header,
  CE_HeaderSection, CE_HeaderLabel, CE_Q3DockWindowEmptyArea, CE_ToolBoxTab,
  CE_SizeGrip, CE_Splitter, CE_RubberBand, CE_DockWidgetTitle,
  CE_ScrollBarAddLine, CE_ScrollBarSubLine, CE_ScrollBarAddPage, CE_ScrollBarSubPage,
  CE_ScrollBarSlider, CE_ScrollBarFirst, CE_ScrollBarLast, CE_FocusFrame,
  CE_ComboBoxLabel, CE_ToolBar, CE_ToolBoxTabShape, CE_ToolBoxTabLabel,
  CE_HeaderEmptyArea, CE_ColumnViewGrip, CE_ItemViewItem, CE_ShapedFrame,
  CE_CustomBase = 0xf0000000
}
 This enum represents a control element. More...
 
enum  PixelMetric {
  PM_ButtonMargin, PM_ButtonDefaultIndicator, PM_MenuButtonIndicator, PM_ButtonShiftHorizontal,
  PM_ButtonShiftVertical, PM_DefaultFrameWidth, PM_SpinBoxFrameWidth, PM_ComboBoxFrameWidth,
  PM_MaximumDragDistance, PM_ScrollBarExtent, PM_ScrollBarSliderMin, PM_SliderThickness,
  PM_SliderControlThickness, PM_SliderLength, PM_SliderTickmarkOffset, PM_SliderSpaceAvailable,
  PM_DockWidgetSeparatorExtent, PM_DockWidgetHandleExtent, PM_DockWidgetFrameWidth, PM_TabBarTabOverlap,
  PM_TabBarTabHSpace, PM_TabBarTabVSpace, PM_TabBarBaseHeight, PM_TabBarBaseOverlap,
  PM_ProgressBarChunkWidth, PM_SplitterWidth, PM_TitleBarHeight, PM_MenuScrollerHeight,
  PM_MenuHMargin, PM_MenuVMargin, PM_MenuPanelWidth, PM_MenuTearoffHeight,
  PM_MenuDesktopFrameWidth, PM_MenuBarPanelWidth, PM_MenuBarItemSpacing, PM_MenuBarVMargin,
  PM_MenuBarHMargin, PM_IndicatorWidth, PM_IndicatorHeight, PM_ExclusiveIndicatorWidth,
  PM_ExclusiveIndicatorHeight, PM_CheckListButtonSize, PM_CheckListControllerSize, PM_DialogButtonsSeparator,
  PM_DialogButtonsButtonWidth, PM_DialogButtonsButtonHeight, PM_MdiSubWindowFrameWidth, PM_MDIFrameWidth = PM_MdiSubWindowFrameWidth,
  PM_MdiSubWindowMinimizedWidth, PM_MDIMinimizedWidth = PM_MdiSubWindowMinimizedWidth, PM_HeaderMargin, PM_HeaderMarkSize,
  PM_HeaderGripMargin, PM_TabBarTabShiftHorizontal, PM_TabBarTabShiftVertical, PM_TabBarScrollButtonWidth,
  PM_ToolBarFrameWidth, PM_ToolBarHandleExtent, PM_ToolBarItemSpacing, PM_ToolBarItemMargin,
  PM_ToolBarSeparatorExtent, PM_ToolBarExtensionExtent, PM_SpinBoxSliderHeight, PM_DefaultTopLevelMargin,
  PM_DefaultChildMargin, PM_DefaultLayoutSpacing, PM_ToolBarIconSize, PM_ListViewIconSize,
  PM_IconViewIconSize, PM_SmallIconSize, PM_LargeIconSize, PM_FocusFrameVMargin,
  PM_FocusFrameHMargin, PM_ToolTipLabelFrameWidth, PM_CheckBoxLabelSpacing, PM_TabBarIconSize,
  PM_SizeGripSize, PM_DockWidgetTitleMargin, PM_MessageBoxIconSize, PM_ButtonIconSize,
  PM_DockWidgetTitleBarButtonMargin, PM_RadioButtonLabelSpacing, PM_LayoutLeftMargin, PM_LayoutTopMargin,
  PM_LayoutRightMargin, PM_LayoutBottomMargin, PM_LayoutHorizontalSpacing, PM_LayoutVerticalSpacing,
  PM_TabBar_ScrollButtonOverlap, PM_TextCursorWidth, PM_TabCloseIndicatorWidth, PM_TabCloseIndicatorHeight,
  PM_ScrollView_ScrollBarSpacing, PM_SubMenuOverlap, PM_CustomBase = 0xf0000000
}
 This enum describes the various available pixel metrics. More...
 
enum  PrimitiveElement {
  PE_Q3CheckListController, PE_Q3CheckListExclusiveIndicator, PE_Q3CheckListIndicator, PE_Q3DockWindowSeparator,
  PE_Q3Separator, PE_Frame, PE_FrameDefaultButton, PE_FrameDockWidget,
  PE_FrameFocusRect, PE_FrameGroupBox, PE_FrameLineEdit, PE_FrameMenu,
  PE_FrameStatusBar, PE_FrameStatusBarItem = PE_FrameStatusBar, PE_FrameTabWidget, PE_FrameWindow,
  PE_FrameButtonBevel, PE_FrameButtonTool, PE_FrameTabBarBase, PE_PanelButtonCommand,
  PE_PanelButtonBevel, PE_PanelButtonTool, PE_PanelMenuBar, PE_PanelToolBar,
  PE_PanelLineEdit, PE_IndicatorArrowDown, PE_IndicatorArrowLeft, PE_IndicatorArrowRight,
  PE_IndicatorArrowUp, PE_IndicatorBranch, PE_IndicatorButtonDropDown, PE_IndicatorViewItemCheck,
  PE_IndicatorItemViewItemCheck = PE_IndicatorViewItemCheck, PE_IndicatorCheckBox, PE_IndicatorDockWidgetResizeHandle, PE_IndicatorHeaderArrow,
  PE_IndicatorMenuCheckMark, PE_IndicatorProgressChunk, PE_IndicatorRadioButton, PE_IndicatorSpinDown,
  PE_IndicatorSpinMinus, PE_IndicatorSpinPlus, PE_IndicatorSpinUp, PE_IndicatorToolBarHandle,
  PE_IndicatorToolBarSeparator, PE_PanelTipLabel, PE_IndicatorTabTear, PE_PanelScrollAreaCorner,
  PE_Widget, PE_IndicatorColumnViewArrow, PE_IndicatorItemViewItemDrop, PE_PanelItemViewItem,
  PE_PanelItemViewRow, PE_PanelStatusBar, PE_IndicatorTabClose, PE_PanelMenu,
  PE_CustomBase = 0xf000000
}
 This enum describes the various primitive elements. More...
 
enum  RequestSoftwareInputPanel { RSIP_OnMouseClickAndAlreadyFocused, RSIP_OnMouseClick }
 This enum describes under what circumstances a software input panel will be requested by input capable widgets. More...
 
enum  StandardPixmap {
  SP_TitleBarMenuButton, SP_TitleBarMinButton, SP_TitleBarMaxButton, SP_TitleBarCloseButton,
  SP_TitleBarNormalButton, SP_TitleBarShadeButton, SP_TitleBarUnshadeButton, SP_TitleBarContextHelpButton,
  SP_DockWidgetCloseButton, SP_MessageBoxInformation, SP_MessageBoxWarning, SP_MessageBoxCritical,
  SP_MessageBoxQuestion, SP_DesktopIcon, SP_TrashIcon, SP_ComputerIcon,
  SP_DriveFDIcon, SP_DriveHDIcon, SP_DriveCDIcon, SP_DriveDVDIcon,
  SP_DriveNetIcon, SP_DirOpenIcon, SP_DirClosedIcon, SP_DirLinkIcon,
  SP_FileIcon, SP_FileLinkIcon, SP_ToolBarHorizontalExtensionButton, SP_ToolBarVerticalExtensionButton,
  SP_FileDialogStart, SP_FileDialogEnd, SP_FileDialogToParent, SP_FileDialogNewFolder,
  SP_FileDialogDetailedView, SP_FileDialogInfoView, SP_FileDialogContentsView, SP_FileDialogListView,
  SP_FileDialogBack, SP_DirIcon, SP_DialogOkButton, SP_DialogCancelButton,
  SP_DialogHelpButton, SP_DialogOpenButton, SP_DialogSaveButton, SP_DialogCloseButton,
  SP_DialogApplyButton, SP_DialogResetButton, SP_DialogDiscardButton, SP_DialogYesButton,
  SP_DialogNoButton, SP_ArrowUp, SP_ArrowDown, SP_ArrowLeft,
  SP_ArrowRight, SP_ArrowBack, SP_ArrowForward, SP_DirHomeIcon,
  SP_CommandLink, SP_VistaShield, SP_BrowserReload, SP_BrowserStop,
  SP_MediaPlay, SP_MediaStop, SP_MediaPause, SP_MediaSkipForward,
  SP_MediaSkipBackward, SP_MediaSeekForward, SP_MediaSeekBackward, SP_MediaVolume,
  SP_MediaVolumeMuted, SP_CustomBase = 0xf0000000
}
 This enum describes the available standard pixmaps. More...
 
enum  StateFlag {
  State_None = 0x00000000, State_Enabled = 0x00000001, State_Raised = 0x00000002, State_Sunken = 0x00000004,
  State_Off = 0x00000008, State_NoChange = 0x00000010, State_On = 0x00000020, State_DownArrow = 0x00000040,
  State_Horizontal = 0x00000080, State_HasFocus = 0x00000100, State_Top = 0x00000200, State_Bottom = 0x00000400,
  State_FocusAtBorder = 0x00000800, State_AutoRaise = 0x00001000, State_MouseOver = 0x00002000, State_UpArrow = 0x00004000,
  State_Selected = 0x00008000, State_Active = 0x00010000, State_Window = 0x00020000, State_Open = 0x00040000,
  State_Children = 0x00080000, State_Item = 0x00100000, State_Sibling = 0x00200000, State_Editing = 0x00400000,
  State_KeyboardFocusChange = 0x00800000, State_ReadOnly = 0x02000000, State_Small = 0x04000000, State_Mini = 0x08000000
}
 This enum describes flags that are used when drawing primitive elements. More...
 
enum  StyleHint {
  SH_EtchDisabledText, SH_DitherDisabledText, SH_ScrollBar_MiddleClickAbsolutePosition, SH_ScrollBar_ScrollWhenPointerLeavesControl,
  SH_TabBar_SelectMouseType, SH_TabBar_Alignment, SH_Header_ArrowAlignment, SH_Slider_SnapToValue,
  SH_Slider_SloppyKeyEvents, SH_ProgressDialog_CenterCancelButton, SH_ProgressDialog_TextLabelAlignment, SH_PrintDialog_RightAlignButtons,
  SH_MainWindow_SpaceBelowMenuBar, SH_FontDialog_SelectAssociatedText, SH_Menu_AllowActiveAndDisabled, SH_Menu_SpaceActivatesItem,
  SH_Menu_SubMenuPopupDelay, SH_ScrollView_FrameOnlyAroundContents, SH_MenuBar_AltKeyNavigation, SH_ComboBox_ListMouseTracking,
  SH_Menu_MouseTracking, SH_MenuBar_MouseTracking, SH_ItemView_ChangeHighlightOnFocus, SH_Widget_ShareActivation,
  SH_Workspace_FillSpaceOnMaximize, SH_ComboBox_Popup, SH_TitleBar_NoBorder, SH_Slider_StopMouseOverSlider,
  SH_ScrollBar_StopMouseOverSlider = SH_Slider_StopMouseOverSlider, SH_BlinkCursorWhenTextSelected, SH_RichText_FullWidthSelection, SH_Menu_Scrollable,
  SH_GroupBox_TextLabelVerticalAlignment, SH_GroupBox_TextLabelColor, SH_Menu_SloppySubMenus, SH_Table_GridLineColor,
  SH_LineEdit_PasswordCharacter, SH_DialogButtons_DefaultButton, SH_ToolBox_SelectedPageTitleBold, SH_TabBar_PreferNoArrows,
  SH_ScrollBar_LeftClickAbsolutePosition, SH_Q3ListViewExpand_SelectMouseType, SH_UnderlineShortcut, SH_SpinBox_AnimateButton,
  SH_SpinBox_KeyPressAutoRepeatRate, SH_SpinBox_ClickAutoRepeatRate, SH_Menu_FillScreenWithScroll, SH_ToolTipLabel_Opacity,
  SH_DrawMenuBarSeparator, SH_TitleBar_ModifyNotification, SH_Button_FocusPolicy, SH_MenuBar_DismissOnSecondClick,
  SH_MessageBox_UseBorderForButtonSpacing, SH_TitleBar_AutoRaise, SH_ToolButton_PopupDelay, SH_FocusFrame_Mask,
  SH_RubberBand_Mask, SH_WindowFrame_Mask, SH_SpinControls_DisableOnBounds, SH_Dial_BackgroundRole,
  SH_ComboBox_LayoutDirection, SH_ItemView_EllipsisLocation, SH_ItemView_ShowDecorationSelected, SH_ItemView_ActivateItemOnSingleClick,
  SH_ScrollBar_ContextMenu, SH_ScrollBar_RollBetweenButtons, SH_Slider_AbsoluteSetButtons, SH_Slider_PageSetButtons,
  SH_Menu_KeyboardSearch, SH_TabBar_ElideMode, SH_DialogButtonLayout, SH_ComboBox_PopupFrameStyle,
  SH_MessageBox_TextInteractionFlags, SH_DialogButtonBox_ButtonsHaveIcons, SH_SpellCheckUnderlineStyle, SH_MessageBox_CenterButtons,
  SH_Menu_SelectionWrap, SH_ItemView_MovementWithoutUpdatingSelection, SH_ToolTip_Mask, SH_FocusFrame_AboveWidget,
  SH_TextControl_FocusIndicatorTextCharFormat, SH_WizardStyle, SH_ItemView_ArrowKeysNavigateIntoChildren, SH_Menu_Mask,
  SH_Menu_FlashTriggeredItem, SH_Menu_FadeOutOnHide, SH_SpinBox_ClickAutoRepeatThreshold, SH_ItemView_PaintAlternatingRowColorsForEmptyArea,
  SH_FormLayoutWrapPolicy, SH_TabWidget_DefaultTabPosition, SH_ToolBar_Movable, SH_FormLayoutFieldGrowthPolicy,
  SH_FormLayoutFormAlignment, SH_FormLayoutLabelAlignment, SH_ItemView_DrawDelegateFrame, SH_TabBar_CloseButtonPosition,
  SH_DockWidget_ButtonsHaveFrame, SH_ToolButtonStyle, SH_RequestSoftwareInputPanel, SH_CustomBase = 0xf0000000
}
 This enum describes the available style hints. More...
 
enum  SubControl {
  SC_None = 0x00000000, SC_ScrollBarAddLine = 0x00000001, SC_ScrollBarSubLine = 0x00000002, SC_ScrollBarAddPage = 0x00000004,
  SC_ScrollBarSubPage = 0x00000008, SC_ScrollBarFirst = 0x00000010, SC_ScrollBarLast = 0x00000020, SC_ScrollBarSlider = 0x00000040,
  SC_ScrollBarGroove = 0x00000080, SC_SpinBoxUp = 0x00000001, SC_SpinBoxDown = 0x00000002, SC_SpinBoxFrame = 0x00000004,
  SC_SpinBoxEditField = 0x00000008, SC_ComboBoxFrame = 0x00000001, SC_ComboBoxEditField = 0x00000002, SC_ComboBoxArrow = 0x00000004,
  SC_ComboBoxListBoxPopup = 0x00000008, SC_SliderGroove = 0x00000001, SC_SliderHandle = 0x00000002, SC_SliderTickmarks = 0x00000004,
  SC_ToolButton = 0x00000001, SC_ToolButtonMenu = 0x00000002, SC_TitleBarSysMenu = 0x00000001, SC_TitleBarMinButton = 0x00000002,
  SC_TitleBarMaxButton = 0x00000004, SC_TitleBarCloseButton = 0x00000008, SC_TitleBarNormalButton = 0x00000010, SC_TitleBarShadeButton = 0x00000020,
  SC_TitleBarUnshadeButton = 0x00000040, SC_TitleBarContextHelpButton = 0x00000080, SC_TitleBarLabel = 0x00000100, SC_Q3ListView = 0x00000001,
  SC_Q3ListViewBranch = 0x00000002, SC_Q3ListViewExpand = 0x00000004, SC_DialGroove = 0x00000001, SC_DialHandle = 0x00000002,
  SC_DialTickmarks = 0x00000004, SC_GroupBoxCheckBox = 0x00000001, SC_GroupBoxLabel = 0x00000002, SC_GroupBoxContents = 0x00000004,
  SC_GroupBoxFrame = 0x00000008, SC_MdiMinButton = 0x00000001, SC_MdiNormalButton = 0x00000002, SC_MdiCloseButton = 0x00000004,
  SC_CustomBase = 0xf0000000, SC_All = 0xffffffff
}
 This enum describes the available sub controls. More...
 
enum  SubElement {
  SE_PushButtonContents, SE_PushButtonFocusRect, SE_CheckBoxIndicator, SE_CheckBoxContents,
  SE_CheckBoxFocusRect, SE_CheckBoxClickRect, SE_RadioButtonIndicator, SE_RadioButtonContents,
  SE_RadioButtonFocusRect, SE_RadioButtonClickRect, SE_ComboBoxFocusRect, SE_SliderFocusRect,
  SE_Q3DockWindowHandleRect, SE_ProgressBarGroove, SE_ProgressBarContents, SE_ProgressBarLabel,
  SE_DialogButtonAccept, SE_DialogButtonReject, SE_DialogButtonApply, SE_DialogButtonHelp,
  SE_DialogButtonAll, SE_DialogButtonAbort, SE_DialogButtonIgnore, SE_DialogButtonRetry,
  SE_DialogButtonCustom, SE_ToolBoxTabContents, SE_HeaderLabel, SE_HeaderArrow,
  SE_TabWidgetTabBar, SE_TabWidgetTabPane, SE_TabWidgetTabContents, SE_TabWidgetLeftCorner,
  SE_TabWidgetRightCorner, SE_ViewItemCheckIndicator, SE_ItemViewItemCheckIndicator = SE_ViewItemCheckIndicator, SE_TabBarTearIndicator,
  SE_TreeViewDisclosureItem, SE_LineEditContents, SE_FrameContents, SE_DockWidgetCloseButton,
  SE_DockWidgetFloatButton, SE_DockWidgetTitleBarText, SE_DockWidgetIcon, SE_CheckBoxLayoutItem,
  SE_ComboBoxLayoutItem, SE_DateTimeEditLayoutItem, SE_DialogButtonBoxLayoutItem, SE_LabelLayoutItem,
  SE_ProgressBarLayoutItem, SE_PushButtonLayoutItem, SE_RadioButtonLayoutItem, SE_SliderLayoutItem,
  SE_SpinBoxLayoutItem, SE_ToolButtonLayoutItem, SE_FrameLayoutItem, SE_GroupBoxLayoutItem,
  SE_TabWidgetLayoutItem, SE_ItemViewItemDecoration, SE_ItemViewItemText, SE_ItemViewItemFocusRect,
  SE_TabBarTabLeftButton, SE_TabBarTabRightButton, SE_TabBarTabText, SE_ShapedFrameContents,
  SE_ToolBarHandle, SE_CustomBase = 0xf0000000
}
 This enum represents a sub-area of a widget. More...
 
- Public Slots inherited from QObject
void deleteLater ()
 Schedules this object for deletion. More...
 
- Signals inherited from QObject
void destroyed (QObject *=0)
 This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...
 
- Static Public Variables inherited from QObject
static const QMetaObject staticMetaObject
 This variable stores the meta-object for the class. More...
 
- Protected Functions inherited from QCleanlooksStyle
 QCleanlooksStyle (QCleanlooksStylePrivate &dd)
 Constructs a QCleanlooksStyle object. More...
 
- Protected Functions inherited from QWindowsStyle
bool eventFilter (QObject *o, QEvent *e)
 Reimplemented Function More...
 
 QWindowsStyle (QWindowsStylePrivate &dd)
 Constructs a QWindowsStyle object. More...
 
void timerEvent (QTimerEvent *event)
 Reimplemented Function More...
 
- Protected Functions inherited from QCommonStyle
 QCommonStyle (QCommonStylePrivate &dd)
 
- Protected Functions inherited from QStyle
 QStyle (QStylePrivate &dd)
 Constructs a style object. More...
 
- Protected Functions inherited from QObject
virtual void childEvent (QChildEvent *)
 This event handler can be reimplemented in a subclass to receive child events. More...
 
virtual void connectNotify (const char *signal)
 This virtual function is called when something has been connected to signal in this object. More...
 
virtual void customEvent (QEvent *)
 This event handler can be reimplemented in a subclass to receive custom events. More...
 
virtual void disconnectNotify (const char *signal)
 This virtual function is called when something has been disconnected from signal in this object. More...
 
 QObject (QObjectPrivate &dd, QObject *parent=0)
 
int receivers (const char *signal) const
 Returns the number of receivers connected to the signal. More...
 
QObject * sender () const
 Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...
 
int senderSignalIndex () const
 
- Protected Variables inherited from QObject
QScopedPointer< QObjectData > d_ptr
 
- Static Protected Variables inherited from QObject
static const QMetaObject staticQtMetaObject
 
- Related Functions inherited from QObject
T qFindChildqFindChildren (const QObject *obj, const QString &name)()
 
QList< T > qFindChildrenqFindChildren (const QObject *obj, const QString &name)()
 
QList< T > qFindChildrenqFindChildren (const QObject *obj, const QRegExp &regExp)()
 
T * qobject_cast (QObject *object)
 
 QObjectList
 
void * qt_find_obj_child (QObject *parent, const char *type, const QString &name)
 Returns a pointer to the object named name that inherits type and with a given parent. More...
 

Detailed Description

The QGtkStyle class provides a widget style rendered by GTK+.

Since
4.5

The QGtkStyle style provides a look and feel that integrates well into GTK-based desktop environments such as the XFCe and GNOME.

It does this by making use of the GTK+ theme engine, ensuring that Qt applications look and feel native on these platforms.

Note: The style requires GTK+ version 2.10 or later. The Qt3-based "Qt" GTK+ theme engine will not work with QGtkStyle.

See also
{Cleanlooks Style Widget Gallery}, QWindowsXPStyle, QMacStyle, QWindowsStyle, QCDEStyle, QMotifStyle, QPlastiqueStyle, QCleanlooksStyle

Definition at line 61 of file qgtkstyle.h.

Constructors and Destructors

◆ QGtkStyle() [1/2]

QGtkStyle::QGtkStyle ( )

Constructs a QGtkStyle object.

Definition at line 192 of file qgtkstyle.cpp.

193  : QCleanlooksStyle(*new QGtkStylePrivate)
194 {
195  Q_D(QGtkStyle);
196  d->init();
197 }
d
double d
Definition: qnumeric_p.h:62
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QCleanlooksStyle::QCleanlooksStyle
QCleanlooksStyle()
Constructs a QCleanlooksStyle object.
Definition: qcleanlooksstyle.cpp:610
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ QGtkStyle() [2/2]

QGtkStyle::QGtkStyle ( QGtkStylePrivate &  dd)

Constructs a QGtkStyle object.

Warning
This function is not part of the public interface.

Definition at line 207 of file qgtkstyle.cpp.

208  : QCleanlooksStyle(dd)
209 {
210  Q_D(QGtkStyle);
211  d->init();
212 }
d
double d
Definition: qnumeric_p.h:62
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QCleanlooksStyle::QCleanlooksStyle
QCleanlooksStyle()
Constructs a QCleanlooksStyle object.
Definition: qcleanlooksstyle.cpp:610
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ ~QGtkStyle()

QGtkStyle::~QGtkStyle ( )

Destroys the QGtkStyle object.

Definition at line 218 of file qgtkstyle.cpp.

219 {
220 }

Functions

◆ drawComplexControl()

void QGtkStyle::drawComplexControl ( ComplexControl  control,
const QStyleOptionComplex *  option,
QPainter *  painter,
const QWidget *  widget 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 1265 of file qgtkstyle.cpp.

1268 {
1269  Q_D(const QGtkStyle);
1270 
1271  if (!d->isThemeAvailable()) {
1272  QCleanlooksStyle::drawComplexControl(control, option, painter, widget);
1273  return;
1274  }
1275 
1276  GtkStyle* style = d->gtkStyle();
1277  QGtkPainter gtkPainter(painter);
1278  QColor button = option->palette.button().color();
1279  QColor dark;
1280  QColor grooveColor;
1281  QColor darkOutline;
1282  dark.setHsv(button.hue(),
1283  qMin(255, (int)(button.saturation()*1.9)),
1284  qMin(255, (int)(button.value()*0.7)));
1285  grooveColor.setHsv(button.hue(),
1286  qMin(255, (int)(button.saturation()*2.6)),
1287  qMin(255, (int)(button.value()*0.9)));
1288  darkOutline.setHsv(button.hue(),
1289  qMin(255, (int)(button.saturation()*3.0)),
1290  qMin(255, (int)(button.value()*0.6)));
1291 
1292  QColor alphaCornerColor;
1293 
1294  if (widget)
1295  alphaCornerColor = mergedColors(option->palette.color(widget->backgroundRole()), darkOutline);
1296  else
1297  alphaCornerColor = mergedColors(option->palette.background().color(), darkOutline);
1298 
1299  switch (control) {
1300 
1301  case CC_TitleBar:
1302  if (const QStyleOptionTitleBar *tb = qstyleoption_cast<const QStyleOptionTitleBar *>(option)) {
1303  // Since this is drawn by metacity and not Gtk we
1304  // have to rely on Cleanlooks for a fallback
1305  QStyleOptionTitleBar copyOpt = *tb;
1306  QPalette pal = copyOpt.palette;
1307  // Bg color is closer to the window selection than
1308  // the base selection color
1309  GdkColor gdkBg = style->bg[GTK_STATE_SELECTED];
1310  QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
1311  pal.setBrush(QPalette::Active, QPalette::Highlight, bgColor);
1312  copyOpt.palette = pal;
1313  QCleanlooksStyle::drawComplexControl(control, &copyOpt, painter, widget);
1314  }
1315  break;
1316 
1317 #ifndef QT_NO_GROUPBOX
1318 
1319  case CC_GroupBox:
1320  painter->save();
1321 
1322  if (const QStyleOptionGroupBox *groupBox = qstyleoption_cast<const QStyleOptionGroupBox *>(option)) {
1323  QRect textRect = proxy()->subControlRect(CC_GroupBox, groupBox, SC_GroupBoxLabel, widget);
1324  QRect checkBoxRect = proxy()->subControlRect(CC_GroupBox, groupBox, SC_GroupBoxCheckBox, widget);
1325  // Draw title
1326 
1327  if ((groupBox->subControls & QStyle::SC_GroupBoxLabel) && !groupBox->text.isEmpty()) {
1328  // Draw prelight background
1329  GtkWidget *gtkCheckButton = d->gtkWidget("GtkCheckButton");
1330 
1331  if (option->state & State_MouseOver) {
1332  QRect bgRect = textRect | checkBoxRect;
1333  gtkPainter.paintFlatBox(gtkCheckButton, "checkbutton", bgRect.adjusted(0, 0, 0, -2),
1334  GTK_STATE_PRELIGHT, GTK_SHADOW_ETCHED_OUT, gtkCheckButton->style);
1335  }
1336 
1337  if (!groupBox->text.isEmpty()) {
1338  int alignment = int(groupBox->textAlignment);
1339  if (!proxy()->styleHint(QStyle::SH_UnderlineShortcut, option, widget))
1340  alignment |= Qt::TextHideMnemonic;
1341  QColor textColor = groupBox->textColor; // Note: custom textColor is currently ignored
1342  int labelState = GTK_STATE_INSENSITIVE;
1343 
1344  if (option->state & State_Enabled)
1345  labelState = (option->state & State_MouseOver) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
1346 
1347  GdkColor gdkText = gtkCheckButton->style->fg[labelState];
1348  textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
1349  painter->setPen(textColor);
1350  QFont font = painter->font();
1351  font.setBold(true);
1352  painter->setFont(font);
1353  painter->drawText(textRect, Qt::TextShowMnemonic | Qt::AlignLeft| alignment, groupBox->text);
1354 
1355  if (option->state & State_HasFocus)
1356  gtkPainter.paintFocus( NULL, "tab", textRect.adjusted(-4, -1, 0, -3), GTK_STATE_ACTIVE, style);
1357  }
1358  }
1359 
1360  if (groupBox->subControls & SC_GroupBoxCheckBox) {
1361  QStyleOptionButton box;
1362  box.QStyleOption::operator=(*groupBox);
1363  box.rect = checkBoxRect;
1364  proxy()->drawPrimitive(PE_IndicatorCheckBox, &box, painter, widget);
1365  }
1366  }
1367 
1368  painter->restore();
1369  break;
1370 #endif // QT_NO_GROUPBOX
1371 
1372 #ifndef QT_NO_COMBOBOX
1373 
1374  case CC_ComboBox:
1375  // See: http://live.gnome.org/GnomeArt/Tutorials/GtkThemes/GtkComboBox
1376  // and http://live.gnome.org/GnomeArt/Tutorials/GtkThemes/GtkComboBoxEntry
1377  if (const QStyleOptionComboBox *comboBox = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
1378  bool sunken = comboBox->state & State_On; // play dead, if combobox has no items
1379  BEGIN_STYLE_PIXMAPCACHE(QString::fromLatin1("cb-%0-%1").arg(sunken).arg(comboBox->editable));
1380  QGtkPainter gtkCachedPainter(p);
1381  gtkCachedPainter.setUsePixmapCache(false); // cached externally
1382 
1383  bool isEnabled = (comboBox->state & State_Enabled);
1384  bool focus = isEnabled && (comboBox->state & State_HasFocus);
1385  GtkStateType state = gtkPainter.gtkState(option);
1386  int appears_as_list = !proxy()->styleHint(QStyle::SH_ComboBox_Popup, comboBox, widget);
1387  QStyleOptionComboBox comboBoxCopy = *comboBox;
1388  comboBoxCopy.rect = option->rect;
1389 
1390  bool reverse = (option->direction == Qt::RightToLeft);
1391  QRect rect = option->rect;
1392  QRect arrowButtonRect = proxy()->subControlRect(CC_ComboBox, &comboBoxCopy,
1393  SC_ComboBoxArrow, widget);
1394 
1395  GtkShadowType shadow = (option->state & State_Sunken || option->state & State_On ) ?
1396  GTK_SHADOW_IN : GTK_SHADOW_OUT;
1397  const QHashableLatin1Literal comboBoxPath = comboBox->editable ? QHashableLatin1Literal("GtkComboBoxEntry") : QHashableLatin1Literal("GtkComboBox");
1398 
1399  // We use the gtk widget to position arrows and separators for us
1400  GtkWidget *gtkCombo = d->gtkWidget(comboBoxPath);
1401  GtkAllocation geometry = {0, 0, option->rect.width(), option->rect.height()};
1402  d->gtk_widget_set_direction(gtkCombo, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
1403  d->gtk_widget_size_allocate(gtkCombo, &geometry);
1404 
1405  QHashableLatin1Literal buttonPath = comboBox->editable ? QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton")
1406  : QHashableLatin1Literal("GtkComboBox.GtkToggleButton");
1407  GtkWidget *gtkToggleButton = d->gtkWidget(buttonPath);
1408  d->gtk_widget_set_direction(gtkToggleButton, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
1409  if (gtkToggleButton && (appears_as_list || comboBox->editable)) {
1410  if (focus)
1411  GTK_WIDGET_SET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS);
1412  // Draw the combo box as a line edit with a button next to it
1413  if (comboBox->editable || appears_as_list) {
1414  GtkStateType frameState = (state == GTK_STATE_PRELIGHT) ? GTK_STATE_NORMAL : state;
1415  QHashableLatin1Literal entryPath = comboBox->editable ? QHashableLatin1Literal("GtkComboBoxEntry.GtkEntry") : QHashableLatin1Literal("GtkComboBox.GtkFrame");
1416  GtkWidget *gtkEntry = d->gtkWidget(entryPath);
1417  d->gtk_widget_set_direction(gtkEntry, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
1418  QRect frameRect = option->rect;
1419 
1420  if (reverse)
1421  frameRect.setLeft(arrowButtonRect.right());
1422  else
1423  frameRect.setRight(arrowButtonRect.left());
1424 
1425  // Fill the line edit background
1426  // We could have used flat_box with "entry_bg" but that is probably not worth the overhead
1427  uint resolve_mask = option->palette.resolve();
1428  int xt = gtkEntry->style->xthickness;
1429  int yt = gtkEntry->style->ythickness;
1430  QRect contentRect = frameRect.adjusted(xt, yt, -xt, -yt);
1431  // Required for inner blue highlight with clearlooks
1432  if (focus)
1433  GTK_WIDGET_SET_FLAGS(gtkEntry, GTK_HAS_FOCUS);
1434 
1435  if (widget && widget->testAttribute(Qt::WA_SetPalette) &&
1436  resolve_mask & (1 << QPalette::Base)) // Palette overridden by user
1437  p->fillRect(contentRect, option->palette.base().color());
1438  else {
1439  gtkCachedPainter.paintFlatBox(gtkEntry, "entry_bg", contentRect,
1440  option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE,
1441  GTK_SHADOW_NONE, gtkEntry->style, entryPath.toString() + QString::number(focus));
1442  }
1443 
1444  gtkCachedPainter.paintShadow(gtkEntry, comboBox->editable ? "entry" : "frame", frameRect, frameState,
1445  GTK_SHADOW_IN, gtkEntry->style, entryPath.toString() +
1446  QString::number(focus) + QString::number(comboBox->editable) +
1447  QString::number(option->direction));
1448  if (focus)
1449  GTK_WIDGET_UNSET_FLAGS(gtkEntry, GTK_HAS_FOCUS);
1450  }
1451 
1452  GtkStateType buttonState = GTK_STATE_NORMAL;
1453 
1454  if (!(option->state & State_Enabled))
1455  buttonState = GTK_STATE_INSENSITIVE;
1456  else if (option->state & State_Sunken || option->state & State_On)
1457  buttonState = GTK_STATE_ACTIVE;
1458  else if (option->state & State_MouseOver && comboBox->activeSubControls & SC_ComboBoxArrow)
1459  buttonState = GTK_STATE_PRELIGHT;
1460 
1461  Q_ASSERT(gtkToggleButton);
1462  gtkCachedPainter.paintBox( gtkToggleButton, "button", arrowButtonRect, buttonState,
1463  shadow, gtkToggleButton->style, buttonPath.toString() +
1464  QString::number(focus) + QString::number(option->direction));
1465  if (focus)
1466  GTK_WIDGET_UNSET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS);
1467  } else {
1468  // Draw combo box as a button
1469  QRect buttonRect = option->rect;
1470 
1471  if (focus) // Clearlooks actually check the widget for the default state
1472  GTK_WIDGET_SET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS);
1473  gtkCachedPainter.paintBox(gtkToggleButton, "button",
1474  buttonRect, state,
1475  shadow, gtkToggleButton->style,
1476  buttonPath.toString() + QString::number(focus));
1477  if (focus)
1478  GTK_WIDGET_UNSET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS);
1479 
1480 
1481  // Draw the separator between label and arrows
1482  QHashableLatin1Literal vSeparatorPath = comboBox->editable
1483  ? QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton.GtkHBox.GtkVSeparator")
1484  : QHashableLatin1Literal("GtkComboBox.GtkToggleButton.GtkHBox.GtkVSeparator");
1485 
1486  if (GtkWidget *gtkVSeparator = d->gtkWidget(vSeparatorPath)) {
1487  QRect vLineRect(gtkVSeparator->allocation.x,
1488  gtkVSeparator->allocation.y,
1489  gtkVSeparator->allocation.width,
1490  gtkVSeparator->allocation.height);
1491 
1492  gtkCachedPainter.paintVline( gtkVSeparator, "vseparator",
1493  vLineRect, state, gtkVSeparator->style,
1494  0, vLineRect.height(), 0, vSeparatorPath.toString());
1495 
1496 
1497  gint interiorFocus = true;
1498  d->gtk_widget_style_get(gtkToggleButton, "interior-focus", &interiorFocus, NULL);
1499  int xt = interiorFocus ? gtkToggleButton->style->xthickness : 0;
1500  int yt = interiorFocus ? gtkToggleButton->style->ythickness : 0;
1501  if (focus && ((option->state & State_KeyboardFocusChange) || styleHint(SH_UnderlineShortcut, option, widget)))
1502  gtkCachedPainter.paintFocus(gtkToggleButton, "button",
1503  option->rect.adjusted(xt, yt, -xt, -yt),
1504  option->state & State_Sunken ? GTK_STATE_ACTIVE : GTK_STATE_NORMAL,
1505  gtkToggleButton->style);
1506  }
1507  }
1508 
1509  if (comboBox->subControls & SC_ComboBoxArrow) {
1510  if (!isEnabled)
1511  state = GTK_STATE_INSENSITIVE;
1512  else if (sunken)
1513  state = GTK_STATE_ACTIVE;
1514  else if (option->state & State_MouseOver)
1515  state = GTK_STATE_PRELIGHT;
1516  else
1517  state = GTK_STATE_NORMAL;
1518 
1519  QHashableLatin1Literal arrowPath("");
1520  if (comboBox->editable) {
1521  if (appears_as_list)
1522  arrowPath = QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton.GtkArrow");
1523  else
1524  arrowPath = QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton.GtkHBox.GtkArrow");
1525  } else {
1526  if (appears_as_list)
1527  arrowPath = QHashableLatin1Literal("GtkComboBox.GtkToggleButton.GtkArrow");
1528  else
1529  arrowPath = QHashableLatin1Literal("GtkComboBox.GtkToggleButton.GtkHBox.GtkArrow");
1530  }
1531 
1532  GtkWidget *gtkArrow = d->gtkWidget(arrowPath);
1533  gfloat scale = 0.7;
1534  gint minSize = 15;
1535  QRect arrowWidgetRect;
1536 
1537  if (gtkArrow && !d->gtk_check_version(2, 12, 0)) {
1538  d->gtk_widget_style_get(gtkArrow, "arrow-scaling", &scale, NULL);
1539  d->gtk_widget_style_get(gtkCombo, "arrow-size", &minSize, NULL);
1540  }
1541  if (gtkArrow) {
1542  arrowWidgetRect = QRect(gtkArrow->allocation.x, gtkArrow->allocation.y,
1543  gtkArrow->allocation.width, gtkArrow->allocation.height);
1544  style = gtkArrow->style;
1545  }
1546 
1547  // Note that for some reason the arrow-size is not properly respected with Hildon
1548  // Hence we enforce the minimum "arrow-size" ourselves
1549  int arrowSize = qMax(qMin(rect.height() - gtkCombo->style->ythickness * 2, minSize),
1550  qMin(arrowWidgetRect.width(), arrowWidgetRect.height()));
1551  QRect arrowRect(0, 0, static_cast<int>(arrowSize * scale), static_cast<int>(arrowSize * scale));
1552 
1553  arrowRect.moveCenter(arrowWidgetRect.center());
1554 
1555  if (sunken) {
1556  int xoff, yoff;
1557  const QHashableLatin1Literal toggleButtonPath = comboBox->editable
1558  ? QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton")
1559  : QHashableLatin1Literal("GtkComboBox.GtkToggleButton");
1560 
1561  GtkWidget *gtkButton = d->gtkWidget(toggleButtonPath);
1562  d->gtk_widget_style_get(gtkButton, "child-displacement-x", &xoff, NULL);
1563  d->gtk_widget_style_get(gtkButton, "child-displacement-y", &yoff, NULL);
1564  arrowRect = arrowRect.adjusted(xoff, yoff, xoff, yoff);
1565  }
1566 
1567  // Some styles such as Nimbus paint outside the arrowRect
1568  // hence we have provide the whole widget as the cliprect
1569  if (gtkArrow) {
1570  gtkCachedPainter.setClipRect(option->rect);
1571  gtkCachedPainter.paintArrow( gtkArrow, "arrow", arrowRect,
1572  GTK_ARROW_DOWN, state, GTK_SHADOW_NONE, TRUE,
1573  style, arrowPath.toString() + QString::number(option->direction));
1574  }
1575  }
1576  END_STYLE_PIXMAPCACHE;
1577  }
1578  break;
1579 #endif // QT_NO_COMBOBOX
1580 #ifndef QT_NO_TOOLBUTTON
1581 
1582  case CC_ToolButton:
1583  if (const QStyleOptionToolButton *toolbutton
1584  = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {
1585  QRect button, menuarea;
1586  button = proxy()->subControlRect(control, toolbutton, SC_ToolButton, widget);
1587  menuarea = proxy()->subControlRect(control, toolbutton, SC_ToolButtonMenu, widget);
1588  State bflags = toolbutton->state & ~(State_Sunken | State_MouseOver);
1589 
1590  if (bflags & State_AutoRaise)
1591  if (!(bflags & State_MouseOver))
1592  bflags &= ~State_Raised;
1593 
1594  State mflags = bflags;
1595 
1596  if (toolbutton->state & State_Sunken) {
1597  if (toolbutton->activeSubControls & SC_ToolButton)
1598  bflags |= State_Sunken;
1599  if (toolbutton->activeSubControls & SC_ToolButtonMenu)
1600  mflags |= State_Sunken;
1601  } else if (toolbutton->state & State_MouseOver) {
1602  if (toolbutton->activeSubControls & SC_ToolButton)
1603  bflags |= State_MouseOver;
1604  if (toolbutton->activeSubControls & SC_ToolButtonMenu)
1605  mflags |= State_MouseOver;
1606  }
1607 
1608  QStyleOption tool(0);
1609 
1610  tool.palette = toolbutton->palette;
1611 
1612  if (toolbutton->subControls & SC_ToolButton) {
1613  if (bflags & (State_Sunken | State_On | State_Raised | State_MouseOver)) {
1614  tool.rect = button;
1615  tool.state = bflags;
1616  proxy()->drawPrimitive(PE_PanelButtonTool, &tool, painter, widget);
1617  }
1618  }
1619 
1620  bool drawMenuArrow = toolbutton->features & QStyleOptionToolButton::HasMenu &&
1621  !(toolbutton->features & QStyleOptionToolButton::MenuButtonPopup);
1622  int popupArrowSize = drawMenuArrow ? 7 : 0;
1623 
1624  if (toolbutton->state & State_HasFocus) {
1625  QStyleOptionFocusRect fr;
1626  fr.QStyleOption::operator=(*toolbutton);
1627  fr.rect = proxy()->subControlRect(CC_ToolButton, toolbutton, SC_ToolButton, widget);
1628  fr.rect.adjust(1, 1, -1, -1);
1629  proxy()->drawPrimitive(PE_FrameFocusRect, &fr, painter, widget);
1630  }
1631 
1632  QStyleOptionToolButton label = *toolbutton;
1633  label.state = bflags;
1634  GtkWidget *gtkButton = d->gtkWidget("GtkToolButton.GtkButton");
1635  QPalette pal = toolbutton->palette;
1636  if (option->state & State_Enabled &&
1637  option->state & State_MouseOver && !(widget && widget->testAttribute(Qt::WA_SetPalette))) {
1638  GdkColor gdkText = gtkButton->style->fg[GTK_STATE_PRELIGHT];
1639  QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
1640  pal.setBrush(QPalette::All, QPalette::ButtonText, textColor);
1641  label.palette = pal;
1642  }
1643  label.rect = button.adjusted(style->xthickness, style->ythickness,
1644  -style->xthickness - popupArrowSize, -style->ythickness);
1645  proxy()->drawControl(CE_ToolButtonLabel, &label, painter, widget);
1646 
1647  if (toolbutton->subControls & SC_ToolButtonMenu) {
1648  tool.rect = menuarea;
1649  tool.state = mflags;
1650  if ((mflags & State_Enabled && (mflags & (State_Sunken | State_Raised | State_MouseOver))) || !(mflags & State_AutoRaise))
1651  proxy()->drawPrimitive(PE_IndicatorButtonDropDown, &tool, painter, widget);
1652 
1653  proxy()->drawPrimitive(PE_IndicatorArrowDown, &tool, painter, widget);
1654 
1655  } else if (drawMenuArrow) {
1656  QRect ir = toolbutton->rect;
1657  QStyleOptionToolButton newBtn = *toolbutton;
1658  newBtn.rect = QRect(ir.right() - popupArrowSize - style->xthickness - 3, ir.height()/2 - 1, popupArrowSize, popupArrowSize);
1659  proxy()->drawPrimitive(PE_IndicatorArrowDown, &newBtn, painter, widget);
1660  }
1661  }
1662  break;
1663 
1664 #endif // QT_NO_TOOLBUTTON
1665 #ifndef QT_NO_SCROLLBAR
1666 
1667  case CC_ScrollBar:
1668  if (const QStyleOptionSlider *scrollBar = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
1669  GtkWidget *gtkHScrollBar = d->gtkWidget("GtkHScrollbar");
1670  GtkWidget *gtkVScrollBar = d->gtkWidget("GtkVScrollbar");
1671 
1672  // Fill background in case the scrollbar is partially transparent
1673  painter->fillRect(option->rect, option->palette.background());
1674 
1675  QRect rect = scrollBar->rect;
1676  QRect scrollBarSubLine = proxy()->subControlRect(control, scrollBar, SC_ScrollBarSubLine, widget);
1677  QRect scrollBarAddLine = proxy()->subControlRect(control, scrollBar, SC_ScrollBarAddLine, widget);
1678  QRect scrollBarSlider = proxy()->subControlRect(control, scrollBar, SC_ScrollBarSlider, widget);
1679  QRect grooveRect = proxy()->subControlRect(control, scrollBar, SC_ScrollBarGroove, widget);
1680  bool horizontal = scrollBar->orientation == Qt::Horizontal;
1681  GtkWidget * scrollbarWidget = horizontal ? gtkHScrollBar : gtkVScrollBar;
1682  style = scrollbarWidget->style;
1683  gboolean trough_under_steppers = true;
1684  gboolean trough_side_details = false;
1685  gboolean activate_slider = false;
1686  gboolean stepper_size = 14;
1687  gint trough_border = 1;
1688  if (!d->gtk_check_version(2, 10, 0)) {
1689  d->gtk_widget_style_get((GtkWidget*)(scrollbarWidget),
1690  "trough-border", &trough_border,
1691  "trough-side-details", &trough_side_details,
1692  "trough-under-steppers", &trough_under_steppers,
1693  "activate-slider", &activate_slider,
1694  "stepper-size", &stepper_size, NULL);
1695  }
1696  if (trough_under_steppers) {
1697  scrollBarAddLine.adjust(trough_border, trough_border, -trough_border, -trough_border);
1698  scrollBarSubLine.adjust(trough_border, trough_border, -trough_border, -trough_border);
1699  scrollBarSlider.adjust(horizontal ? -trough_border : 0, horizontal ? 0 : -trough_border,
1700  horizontal ? trough_border : 0, horizontal ? 0 : trough_border);
1701  }
1702 
1703  // Some styles check the position of scrollbars in order to determine
1704  // if lines should be painted when the scrollbar is in max or min positions.
1705  int maximum = 2;
1706  int fakePos = 0;
1707  bool reverse = (option->direction == Qt::RightToLeft);
1708  if (scrollBar->minimum == scrollBar->maximum)
1709  maximum = 0;
1710  if (scrollBar->sliderPosition == scrollBar->maximum)
1711  fakePos = maximum;
1712  else if (scrollBar->sliderPosition > scrollBar->minimum)
1713  fakePos = maximum - 1;
1714 
1715 
1716  GtkRange *range = (GtkRange*)(horizontal ? gtkHScrollBar : gtkVScrollBar);
1717  GtkAdjustment *adjustment = 0;
1718 
1719  if (d->gtk_adjustment_configure)
1720  adjustment = d->gtk_range_get_adjustment(range);
1721  if (adjustment) {
1722  d->gtk_adjustment_configure(adjustment, fakePos, 0, maximum, 0, 0, 0);
1723  } else {
1724  adjustment = (GtkAdjustment*)d->gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0);
1725  d->gtk_range_set_adjustment(range, adjustment);
1726  }
1727 
1728  if (scrollBar->subControls & SC_ScrollBarGroove) {
1729  GtkStateType state = GTK_STATE_ACTIVE;
1730 
1731  if (!(option->state & State_Enabled))
1732  state = GTK_STATE_INSENSITIVE;
1733 
1734  if (trough_under_steppers)
1735  grooveRect = option->rect;
1736 
1737  gtkPainter.paintBox( scrollbarWidget, "trough", grooveRect, state, GTK_SHADOW_IN, style);
1738  }
1739 
1740  //paint slider
1741  if (scrollBar->subControls & SC_ScrollBarSlider) {
1742  GtkStateType state = GTK_STATE_NORMAL;
1743 
1744  if (!(option->state & State_Enabled))
1745  state = GTK_STATE_INSENSITIVE;
1746  else if (activate_slider &&
1747  option->state & State_Sunken && (scrollBar->activeSubControls & SC_ScrollBarSlider))
1748  state = GTK_STATE_ACTIVE;
1749  else if (option->state & State_MouseOver && (scrollBar->activeSubControls & SC_ScrollBarSlider))
1750  state = GTK_STATE_PRELIGHT;
1751 
1752  GtkShadowType shadow = GTK_SHADOW_OUT;
1753 
1754  if (trough_under_steppers) {
1755  if (!horizontal)
1756  scrollBarSlider.adjust(trough_border, 0, -trough_border, 0);
1757  else
1758  scrollBarSlider.adjust(0, trough_border, 0, -trough_border);
1759  }
1760 
1761  gtkPainter.paintSlider( scrollbarWidget, "slider", scrollBarSlider, state, shadow, style,
1762 
1763  horizontal ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL, QString(QLS("%0%1")).arg(fakePos).arg(maximum));
1764  }
1765 
1766  if (scrollBar->subControls & SC_ScrollBarAddLine) {
1767  gtkVScrollBar->allocation.y = scrollBarAddLine.top();
1768  gtkVScrollBar->allocation.height = scrollBarAddLine.height() - rect.height() + 6;
1769  gtkHScrollBar->allocation.x = scrollBarAddLine.right();
1770  gtkHScrollBar->allocation.width = scrollBarAddLine.width() - rect.width();
1771 
1772  GtkShadowType shadow = GTK_SHADOW_OUT;
1773  GtkStateType state = GTK_STATE_NORMAL;
1774 
1775  if (!(option->state & State_Enabled) || (fakePos == maximum))
1776  state = GTK_STATE_INSENSITIVE;
1777  else if (option->state & State_Sunken && (scrollBar->activeSubControls & SC_ScrollBarAddLine)) {
1778  state = GTK_STATE_ACTIVE;
1779  shadow = GTK_SHADOW_IN;
1780 
1781  } else if (option->state & State_MouseOver && (scrollBar->activeSubControls & SC_ScrollBarAddLine))
1782  state = GTK_STATE_PRELIGHT;
1783 
1784  gtkPainter.paintBox( scrollbarWidget,
1785  horizontal ? "hscrollbar" : "vscrollbar", scrollBarAddLine,
1786  state, shadow, style, QLS("add"));
1787 
1788  gtkPainter.paintArrow( scrollbarWidget, horizontal ? "hscrollbar" : "vscrollbar", scrollBarAddLine.adjusted(4, 4, -4, -4),
1789  horizontal ? (reverse ? GTK_ARROW_LEFT : GTK_ARROW_RIGHT) :
1790  GTK_ARROW_DOWN, state, GTK_SHADOW_NONE, FALSE, style);
1791  }
1792 
1793  if (scrollBar->subControls & SC_ScrollBarSubLine) {
1794  gtkVScrollBar->allocation.y = 0;
1795  gtkVScrollBar->allocation.height = scrollBarSubLine.height();
1796  gtkHScrollBar->allocation.x = 0;
1797  gtkHScrollBar->allocation.width = scrollBarSubLine.width();
1798 
1799  GtkShadowType shadow = GTK_SHADOW_OUT;
1800  GtkStateType state = GTK_STATE_NORMAL;
1801 
1802  if (!(option->state & State_Enabled) || (fakePos == 0))
1803  state = GTK_STATE_INSENSITIVE;
1804  else if (option->state & State_Sunken && (scrollBar->activeSubControls & SC_ScrollBarSubLine)) {
1805  shadow = GTK_SHADOW_IN;
1806  state = GTK_STATE_ACTIVE;
1807 
1808  } else if (option->state & State_MouseOver && (scrollBar->activeSubControls & SC_ScrollBarSubLine))
1809  state = GTK_STATE_PRELIGHT;
1810 
1811  gtkPainter.paintBox(scrollbarWidget, horizontal ? "hscrollbar" : "vscrollbar", scrollBarSubLine,
1812  state, shadow, style, QLS("sub"));
1813 
1814  gtkPainter.paintArrow(scrollbarWidget, horizontal ? "hscrollbar" : "vscrollbar", scrollBarSubLine.adjusted(4, 4, -4, -4),
1815  horizontal ? (reverse ? GTK_ARROW_RIGHT : GTK_ARROW_LEFT) :
1816  GTK_ARROW_UP, state, GTK_SHADOW_NONE, FALSE, style);
1817  }
1818  }
1819  break;
1820 
1821 #endif //QT_NO_SCROLLBAR
1822 #ifndef QT_NO_SPINBOX
1823 
1824  case CC_SpinBox:
1825  if (const QStyleOptionSpinBox *spinBox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
1826 
1827  GtkWidget *gtkSpinButton = spinBox->buttonSymbols == QAbstractSpinBox::NoButtons
1828  ? d->gtkWidget("GtkEntry")
1829  : d->gtkWidget("GtkSpinButton");
1830  bool isEnabled = (spinBox->state & State_Enabled);
1831  bool hover = isEnabled && (spinBox->state & State_MouseOver);
1832  bool sunken = (spinBox->state & State_Sunken);
1833  bool upIsActive = (spinBox->activeSubControls == SC_SpinBoxUp);
1834  bool downIsActive = (spinBox->activeSubControls == SC_SpinBoxDown);
1835  bool reverse = (spinBox->direction == Qt::RightToLeft);
1836 
1837  QRect editArea = option->rect;
1838  QRect editRect = proxy()->subControlRect(CC_SpinBox, option, SC_SpinBoxEditField, widget);
1839  QRect upRect, downRect, buttonRect;
1840  if (spinBox->buttonSymbols != QAbstractSpinBox::NoButtons) {
1841  upRect = proxy()->subControlRect(CC_SpinBox, option, SC_SpinBoxUp, widget);
1842  downRect = proxy()->subControlRect(CC_SpinBox, option, SC_SpinBoxDown, widget);
1843 
1844  //### Move this to subControlRect
1845  upRect.setTop(option->rect.top());
1846 
1847  if (reverse)
1848  upRect.setLeft(option->rect.left());
1849  else
1850  upRect.setRight(option->rect.right());
1851 
1852  downRect.setBottom(option->rect.bottom());
1853 
1854  if (reverse)
1855  downRect.setLeft(option->rect.left());
1856  else
1857  downRect.setRight(option->rect.right());
1858 
1859  buttonRect = upRect | downRect;
1860 
1861  if (reverse)
1862  editArea.setLeft(upRect.right());
1863  else
1864  editArea.setRight(upRect.left());
1865  }
1866  if (spinBox->frame) {
1867  GtkStateType state = gtkPainter.gtkState(option);
1868 
1869  if (!(option->state & State_Enabled))
1870  state = GTK_STATE_INSENSITIVE;
1871  else if (option->state & State_HasFocus)
1872  state = GTK_STATE_NORMAL;
1873  else if (state == GTK_STATE_PRELIGHT)
1874  state = GTK_STATE_NORMAL;
1875 
1876  style = gtkPainter.getStyle(gtkSpinButton);
1877 
1878 
1879  QString key;
1880 
1881  if (option->state & State_HasFocus) {
1882  key += QLatin1Char('f');
1883  GTK_WIDGET_SET_FLAGS(gtkSpinButton, GTK_HAS_FOCUS);
1884  }
1885 
1886  uint resolve_mask = option->palette.resolve();
1887 
1888  if (resolve_mask & (1 << QPalette::Base)) // Palette overridden by user
1889  painter->fillRect(editRect, option->palette.base().color());
1890  else
1891  gtkPainter.paintFlatBox(gtkSpinButton, "entry_bg", editArea.adjusted(style->xthickness, style->ythickness,
1892  -style->xthickness, -style->ythickness),
1893  option->state & State_Enabled ?
1894  GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, GTK_SHADOW_NONE, style, key);
1895 
1896  gtkPainter.paintShadow(gtkSpinButton, "entry", editArea, state, GTK_SHADOW_IN, gtkSpinButton->style, key);
1897  if (spinBox->buttonSymbols != QAbstractSpinBox::NoButtons) {
1898  gtkPainter.paintBox(gtkSpinButton, "spinbutton", buttonRect, state, GTK_SHADOW_IN, style, key);
1899 
1900  upRect.setSize(downRect.size());
1901  if (!(option->state & State_Enabled))
1902  gtkPainter.paintBox( gtkSpinButton, "spinbutton_up", upRect, GTK_STATE_INSENSITIVE, GTK_SHADOW_IN, style, key);
1903  else if (upIsActive && sunken)
1904  gtkPainter.paintBox( gtkSpinButton, "spinbutton_up", upRect, GTK_STATE_ACTIVE, GTK_SHADOW_IN, style, key);
1905  else if (upIsActive && hover)
1906  gtkPainter.paintBox( gtkSpinButton, "spinbutton_up", upRect, GTK_STATE_PRELIGHT, GTK_SHADOW_OUT, style, key);
1907  else
1908  gtkPainter.paintBox( gtkSpinButton, "spinbutton_up", upRect, GTK_STATE_NORMAL, GTK_SHADOW_OUT, style, key);
1909 
1910  if (!(option->state & State_Enabled))
1911  gtkPainter.paintBox( gtkSpinButton, "spinbutton_down", downRect, GTK_STATE_INSENSITIVE, GTK_SHADOW_IN, style, key);
1912  else if (downIsActive && sunken)
1913  gtkPainter.paintBox( gtkSpinButton, "spinbutton_down", downRect, GTK_STATE_ACTIVE, GTK_SHADOW_IN, style, key);
1914  else if (downIsActive && hover)
1915  gtkPainter.paintBox( gtkSpinButton, "spinbutton_down", downRect, GTK_STATE_PRELIGHT, GTK_SHADOW_OUT, style, key);
1916  else
1917  gtkPainter.paintBox( gtkSpinButton, "spinbutton_down", downRect, GTK_STATE_NORMAL, GTK_SHADOW_OUT, style, key);
1918 
1919  if (option->state & State_HasFocus)
1920  GTK_WIDGET_UNSET_FLAGS(gtkSpinButton, GTK_HAS_FOCUS);
1921  }
1922  }
1923 
1924  if (spinBox->buttonSymbols == QAbstractSpinBox::PlusMinus) {
1925  int centerX = upRect.center().x();
1926  int centerY = upRect.center().y();
1927  // plus/minus
1928 
1929  if (spinBox->activeSubControls == SC_SpinBoxUp && sunken) {
1930  painter->drawLine(1 + centerX - 2, 1 + centerY, 1 + centerX + 2, 1 + centerY);
1931  painter->drawLine(1 + centerX, 1 + centerY - 2, 1 + centerX, 1 + centerY + 2);
1932 
1933  } else {
1934  painter->drawLine(centerX - 2, centerY, centerX + 2, centerY);
1935  painter->drawLine(centerX, centerY - 2, centerX, centerY + 2);
1936  }
1937  centerX = downRect.center().x();
1938  centerY = downRect.center().y();
1939 
1940  if (spinBox->activeSubControls == SC_SpinBoxDown && sunken) {
1941  painter->drawLine(1 + centerX - 2, 1 + centerY, 1 + centerX + 2, 1 + centerY);
1942  } else {
1943  painter->drawLine(centerX - 2, centerY, centerX + 2, centerY);
1944  }
1945 
1946  } else if (spinBox->buttonSymbols == QAbstractSpinBox::UpDownArrows) {
1947  int size = d->getSpinboxArrowSize();
1948  int w = size / 2 - 1;
1949  w -= w % 2 - 1; // force odd
1950  int h = (w + 1)/2;
1951  QRect arrowRect(0, 0, w, h);
1952  arrowRect.moveCenter(upRect.center());
1953  // arrows
1954  GtkStateType state = GTK_STATE_NORMAL;
1955 
1956  if (!(option->state & State_Enabled) || !(spinBox->stepEnabled & QAbstractSpinBox::StepUpEnabled))
1957  state = GTK_STATE_INSENSITIVE;
1958 
1959  gtkPainter.paintArrow( gtkSpinButton, "spinbutton", arrowRect, GTK_ARROW_UP, state,
1960  GTK_SHADOW_NONE, FALSE, style);
1961 
1962  arrowRect.moveCenter(downRect.center());
1963 
1964  if (!(option->state & State_Enabled) || !(spinBox->stepEnabled & QAbstractSpinBox::StepDownEnabled))
1965  state = GTK_STATE_INSENSITIVE;
1966 
1967  gtkPainter.paintArrow( gtkSpinButton, "spinbutton", arrowRect, GTK_ARROW_DOWN, state,
1968  GTK_SHADOW_NONE, FALSE, style);
1969  }
1970  }
1971  break;
1972 
1973 #endif // QT_NO_SPINBOX
1974 
1975 #ifndef QT_NO_SLIDER
1976 
1977  case CC_Slider:
1978  if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
1979  GtkWidget *hScaleWidget = d->gtkWidget("GtkHScale");
1980  GtkWidget *vScaleWidget = d->gtkWidget("GtkVScale");
1981 
1982  QRect groove = proxy()->subControlRect(CC_Slider, option, SC_SliderGroove, widget);
1983  QRect handle = proxy()->subControlRect(CC_Slider, option, SC_SliderHandle, widget);
1984 
1985  bool horizontal = slider->orientation == Qt::Horizontal;
1986  bool ticksAbove = slider->tickPosition & QSlider::TicksAbove;
1987  bool ticksBelow = slider->tickPosition & QSlider::TicksBelow;
1988 
1989  QBrush oldBrush = painter->brush();
1990  QPen oldPen = painter->pen();
1991 
1992  QColor shadowAlpha(Qt::black);
1993  shadowAlpha.setAlpha(10);
1994  QColor highlightAlpha(Qt::white);
1995  highlightAlpha.setAlpha(80);
1996 
1997  QGtkStylePrivate::gtk_widget_set_direction(hScaleWidget, slider->upsideDown ?
1998  GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
1999  GtkWidget *scaleWidget = horizontal ? hScaleWidget : vScaleWidget;
2000  style = scaleWidget->style;
2001 
2002  if ((option->subControls & SC_SliderGroove) && groove.isValid()) {
2003 
2004  GtkRange *range = (GtkRange*)scaleWidget;
2005  GtkAdjustment *adjustment = 0;
2006  if (d->gtk_adjustment_configure)
2007  adjustment = d->gtk_range_get_adjustment(range);
2008  if (adjustment) {
2009  d->gtk_adjustment_configure(adjustment,
2010  slider->sliderPosition,
2011  slider->minimum,
2012  slider->maximum,
2013  slider->singleStep,
2014  slider->singleStep,
2015  slider->pageStep);
2016  } else {
2017  adjustment = (GtkAdjustment*)d->gtk_adjustment_new(slider->sliderPosition,
2018  slider->minimum,
2019  slider->maximum,
2020  slider->singleStep,
2021  slider->singleStep,
2022  slider->pageStep);
2023  d->gtk_range_set_adjustment(range, adjustment);
2024  }
2025 
2026  int outerSize;
2027  d->gtk_range_set_inverted(range, !horizontal);
2028  d->gtk_widget_style_get(scaleWidget, "trough-border", &outerSize, NULL);
2029  outerSize++;
2030 
2031  GtkStateType state = gtkPainter.gtkState(option);
2032  int focusFrameMargin = 2;
2033  QRect grooveRect = option->rect.adjusted(focusFrameMargin, outerSize + focusFrameMargin,
2034  -focusFrameMargin, -outerSize - focusFrameMargin);
2035 
2036  gboolean trough_side_details = false; // Indicates if the upper or lower scale background differs
2037  if (!d->gtk_check_version(2, 10, 0))
2038  d->gtk_widget_style_get((GtkWidget*)(scaleWidget), "trough-side-details", &trough_side_details, NULL);
2039 
2040  if (!trough_side_details) {
2041  gtkPainter.paintBox( scaleWidget, "trough", grooveRect, state,
2042  GTK_SHADOW_IN, style, QString(QLS("p%0")).arg(slider->sliderPosition));
2043  } else {
2044  QRect upperGroove = grooveRect;
2045  QRect lowerGroove = grooveRect;
2046 
2047  if (horizontal) {
2048  if (slider->upsideDown) {
2049  lowerGroove.setLeft(handle.center().x());
2050  upperGroove.setRight(handle.center().x());
2051  } else {
2052  upperGroove.setLeft(handle.center().x());
2053  lowerGroove.setRight(handle.center().x());
2054  }
2055  } else {
2056  if (!slider->upsideDown) {
2057  lowerGroove.setBottom(handle.center().y());
2058  upperGroove.setTop(handle.center().y());
2059  } else {
2060  upperGroove.setBottom(handle.center().y());
2061  lowerGroove.setTop(handle.center().y());
2062  }
2063  }
2064 
2065  gtkPainter.paintBox( scaleWidget, "trough-upper", upperGroove, state,
2066  GTK_SHADOW_IN, style, QString(QLS("p%0")).arg(slider->sliderPosition));
2067  gtkPainter.paintBox( scaleWidget, "trough-lower", lowerGroove, state,
2068  GTK_SHADOW_IN, style, QString(QLS("p%0")).arg(slider->sliderPosition));
2069  }
2070  }
2071 
2072  if (option->subControls & SC_SliderTickmarks) {
2073  painter->setPen(darkOutline);
2074  int tickSize = proxy()->pixelMetric(PM_SliderTickmarkOffset, option, widget);
2075  int available = proxy()->pixelMetric(PM_SliderSpaceAvailable, slider, widget);
2076  int interval = slider->tickInterval;
2077 
2078  if (interval <= 0) {
2079  interval = slider->singleStep;
2080 
2081  if (QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, interval,
2082  available)
2083  - QStyle::sliderPositionFromValue(slider->minimum, slider->maximum,
2084  0, available) < 3)
2085  interval = slider->pageStep;
2086  }
2087 
2088  if (interval <= 0)
2089  interval = 1;
2090 
2091  int v = slider->minimum;
2092  int len = proxy()->pixelMetric(PM_SliderLength, slider, widget);
2093  while (v <= slider->maximum + 1) {
2094  if (v == slider->maximum + 1 && interval == 1)
2095  break;
2096  const int v_ = qMin(v, slider->maximum);
2097  int pos = sliderPositionFromValue(slider->minimum, slider->maximum,
2098  v_, (horizontal
2099  ? slider->rect.width()
2100  : slider->rect.height()) - len,
2101  slider->upsideDown) + len / 2;
2102  int extra = 2 - ((v_ == slider->minimum || v_ == slider->maximum) ? 1 : 0);
2103  if (horizontal) {
2104  if (ticksAbove)
2105  painter->drawLine(pos, slider->rect.top() + extra,
2106  pos, slider->rect.top() + tickSize);
2107  if (ticksBelow)
2108  painter->drawLine(pos, slider->rect.bottom() - extra,
2109  pos, slider->rect.bottom() - tickSize);
2110 
2111  } else {
2112  if (ticksAbove)
2113  painter->drawLine(slider->rect.left() + extra, pos,
2114  slider->rect.left() + tickSize, pos);
2115  if (ticksBelow)
2116  painter->drawLine(slider->rect.right() - extra, pos,
2117  slider->rect.right() - tickSize, pos);
2118  }
2119 
2120  // In the case where maximum is max int
2121  int nextInterval = v + interval;
2122  if (nextInterval < v)
2123  break;
2124  v = nextInterval;
2125  }
2126  }
2127 
2128  // Draw slider handle
2129  if (option->subControls & SC_SliderHandle) {
2130  GtkShadowType shadow = GTK_SHADOW_OUT;
2131  GtkStateType state = GTK_STATE_NORMAL;
2132 
2133  if (!(option->state & State_Enabled))
2134  state = GTK_STATE_INSENSITIVE;
2135  else if (option->state & State_MouseOver && option->activeSubControls & SC_SliderHandle)
2136  state = GTK_STATE_PRELIGHT;
2137 
2138  bool horizontal = option->state & State_Horizontal;
2139 
2140  if (slider->state & State_HasFocus) {
2141  QStyleOptionFocusRect fropt;
2142  fropt.QStyleOption::operator=(*slider);
2143  fropt.rect = slider->rect.adjusted(-1, -1 ,1, 1);
2144 
2145  if (horizontal) {
2146  fropt.rect.setTop(handle.top() - 3);
2147  fropt.rect.setBottom(handle.bottom() + 4);
2148 
2149  } else {
2150  fropt.rect.setLeft(handle.left() - 3);
2151  fropt.rect.setRight(handle.right() + 3);
2152  }
2153  proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, painter, widget);
2154  }
2155  gtkPainter.paintSlider( scaleWidget, horizontal ? "hscale" : "vscale", handle, state, shadow, style,
2156 
2157  horizontal ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL);
2158  }
2159  painter->setBrush(oldBrush);
2160  painter->setPen(oldPen);
2161  }
2162  break;
2163 
2164 #endif // QT_NO_SLIDER
2165 
2166  default:
2167  QCleanlooksStyle::drawComplexControl(control, option, painter, widget);
2168 
2169  break;
2170  }
2171 }
QString::number
static QString number(int, int base=10)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: qstring.cpp:6448
BEGIN_STYLE_PIXMAPCACHE
#define BEGIN_STYLE_PIXMAPCACHE(a)
Definition: qstyle_p.h:76
QColor
The QColor class provides colors based on RGB, HSV or CMYK values.
Definition: qcolor.h:67
d
double d
Definition: qnumeric_p.h:62
QRect::adjusted
QRect adjusted(int x1, int y1, int x2, int y2) const
Returns a new rectangle with dx1, dy1, dx2 and dy2 added respectively to the existing coordinates of ...
Definition: qrect.h:431
QPalette::base
const QBrush & base() const
Returns the base brush of the current color group.
Definition: qpalette.h:130
QRect::setBottom
void setBottom(int pos)
Sets the bottom edge of the rectangle to the given y coordinate.
Definition: qrect.h:267
qMin
Q_DECL_CONSTEXPR const T & qMin(const T &a, const T &b)
Definition: qglobal.h:1215
QBrush::color
const QColor & color() const
Returns the brush color.
Definition: qbrush.h:183
QColor::hue
ushort hue
Returns the hue color component of this color.
Definition: qcolor.h:250
QGtkStylePrivate::gtk_widget_set_direction
static Ptr_gtk_widget_set_direction gtk_widget_set_direction
Definition: qgtkstyle_p.h:432
QStyleOption::state
QStyle::State state
the style flags that are used when drawing the control
Definition: qstyleoption.h:88
QStyle::subControlRect
virtual QRect subControlRect(ComplexControl cc, const QStyleOptionComplex *opt, SubControl sc, const QWidget *widget=0) const =0
Returns the rectangle containing the specified subControl of the given complex control (with the styl...
QPalette::background
const QBrush & background() const
Use window() instead.
Definition: qpalette.h:134
QStyle::pixelMetric
virtual int pixelMetric(PixelMetric metric, const QStyleOption *option=0, const QWidget *widget=0) const =0
Returns the value of the given pixel metric.
reverse
static C reverse(const C &l)
Definition: qdatetimeedit.cpp:928
QStyleOptionTitleBar
The QStyleOptionTitleBar class is used to describe the parameters for drawing a title bar...
Definition: qstyleoption.h:816
QPainter::restore
void restore()
Restores the current painter state (pops a saved state off the stack).
Definition: qpainter.cpp:1620
QStyle::styleHint
virtual int styleHint(StyleHint stylehint, const QStyleOption *opt=0, const QWidget *widget=0, QStyleHintReturn *returnData=0) const =0
Returns an integer representing the specified style hint for the given widget described by the provid...
QRect::left
int left() const
Returns the x-coordinate of the rectangle&#39;s left edge.
Definition: qrect.h:240
END_STYLE_PIXMAPCACHE
#define END_STYLE_PIXMAPCACHE
Definition: qstyle_p.h:96
QRect::width
int width() const
Returns the width of the rectangle.
Definition: qrect.h:303
QWidget::backgroundRole
QPalette::ColorRole backgroundRole() const
Returns the background role of the widget.
Definition: qwidget.cpp:4677
QStyleOptionComplex::activeSubControls
QStyle::SubControls activeSubControls
This variable holds a bitwise OR of the sub-controls that are active for the complex control...
Definition: qstyleoption.h:694
QPainter::drawLine
void drawLine(const QLineF &line)
Draws a line defined by line.
Definition: qpainter.h:573
QRect::height
int height() const
Returns the height of the rectangle.
Definition: qrect.h:306
QRect::bottom
int bottom() const
Returns the y-coordinate of the rectangle&#39;s bottom edge.
Definition: qrect.h:249
QString
The QString class provides a Unicode character string.
Definition: qstring.h:83
Q_ASSERT
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QPalette::color
const QColor & color(ColorGroup cg, ColorRole cr) const
Returns the color in the specified color group, used for the given color role.
Definition: qpalette.h:107
QPen
The QPen class defines how a QPainter should draw lines and outlines of shapes.
Definition: qpen.h:64
QStyle::sliderPositionFromValue
static int sliderPositionFromValue(int min, int max, int val, int space, bool upsideDown=false)
Converts the given logicalValue to a pixel position.
Definition: qstyle.cpp:2176
QStyleOptionToolButton
The QStyleOptionToolButton class is used to describe the parameters for drawing a tool button...
Definition: qstyleoption.h:768
QPainter::save
void save()
Saves the current painter state (pushes the state onto a stack).
Definition: qpainter.cpp:1590
qMax
Q_DECL_CONSTEXPR const T & qMax(const T &a, const T &b)
Definition: qglobal.h:1217
QColor::setHsv
void setHsv(int h, int s, int v, int a=255)
Sets a HSV color value; h is the hue, s is the saturation, v is the value and a is the alpha componen...
Definition: qcolor.cpp:734
QPainter::drawText
void drawText(const QPointF &p, const QString &s)
Draws the given text with the currently defined text direction, beginning at the given position...
Definition: qpainter.cpp:6231
QPainter::pen
const QPen & pen() const
Returns the painter&#39;s current pen.
Definition: qpainter.cpp:4152
QColor::value
ushort value
Returns the value color component of this color.
Definition: qcolor.h:252
QPalette::setBrush
void setBrush(ColorRole cr, const QBrush &brush)
Sets the brush for the given color role to the specified brush for all groups in the palette...
Definition: qpalette.h:206
QFont::setBold
void setBold(bool)
If enable is true sets the font&#39;s weight to QFont::Bold ; otherwise sets the weight to QFont::Normal...
Definition: qfont.h:352
QStyleOption
The QStyleOption class stores the parameters used by QStyle functions.
Definition: qstyleoption.h:67
QWidget::testAttribute
bool testAttribute(Qt::WidgetAttribute) const
Returns true if attribute attribute is set on this widget; otherwise returns false.
Definition: qwidget.h:1041
QColor::saturation
ushort saturation
Returns the saturation color component of this color.
Definition: qcolor.h:251
QLS
#define QLS(x)
Definition: qgtkstyle_p.h:77
QStyleOptionSpinBox
The QStyleOptionSpinBox class is used to describe the parameters necessary for drawing a spin box...
Definition: qstyleoption.h:729
QRect::setTop
void setTop(int pos)
Sets the top edge of the rectangle to the given y coordinate.
Definition: qrect.h:261
QPainter::font
const QFont & font() const
Returns the currently set font used for drawing text.
Definition: qpainter.cpp:4312
QRect::size
QSize size() const
Returns the size of the rectangle.
Definition: qrect.h:309
QRect::adjust
void adjust(int x1, int y1, int x2, int y2)
Adds dx1, dy1, dx2 and dy2 respectively to the existing coordinates of the rectangle.
Definition: qrect.h:434
QRect::setRight
void setRight(int pos)
Sets the right edge of the rectangle to the given x coordinate.
Definition: qrect.h:264
QStyle::drawPrimitive
virtual void drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const =0
Draws the given primitive element with the provided painter using the style options specified by opti...
QStyleOptionFocusRect
The QStyleOptionFocusRect class is used to describe the parameters for drawing a focus rectangle with...
Definition: qstyleoption.h:103
QRect::setSize
void setSize(const QSize &s)
Sets the size of the rectangle to the given size.
Definition: qrect.h:448
uint
unsigned int uint
Definition: qglobal.h:996
FALSE
#define FALSE
Synonym for false.
Definition: qglobal.h:1019
State
The State element defines configurations of objects and properties.
TRUE
#define TRUE
Synonym for true.
Definition: qglobal.h:1018
QPainter::brush
const QBrush & brush() const
Returns the painter&#39;s current brush.
Definition: qpainter.cpp:4232
QStyleOption::palette
QPalette palette
the palette that should be used when painting the control
Definition: qstyleoption.h:92
QBrush
The QBrush class defines the fill pattern of shapes drawn by QPainter.
Definition: qbrush.h:76
QRect::center
QPoint center() const
Returns the center point of the rectangle.
Definition: qrect.h:300
QRect::top
int top() const
Returns the y-coordinate of the rectangle&#39;s top edge.
Definition: qrect.h:243
QRect::right
int right() const
Returns the x-coordinate of the rectangle&#39;s right edge.
Definition: qrect.h:246
mergedColors
static QColor mergedColors(const QColor &colorA, const QColor &colorB, int factor=50)
Definition: qgtkstyle.cpp:149
QRect::setLeft
void setLeft(int pos)
Sets the left edge of the rectangle to the given x coordinate.
Definition: qrect.h:258
QFont
The QFont class specifies a font used for drawing text.
Definition: qfont.h:64
QString::fromLatin1
static QString fromLatin1(const char *, int size=-1)
Returns a QString initialized with the first size characters of the Latin-1 string str...
Definition: qstring.cpp:4188
key
int key
Definition: qkeysequence.cpp:395
QPainter::setBrush
void setBrush(const QBrush &brush)
Sets the painter&#39;s brush to the given brush.
Definition: qpainter.cpp:4171
QStyle::drawControl
virtual void drawControl(ControlElement element, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const =0
Draws the given element with the provided painter with the style options specified by option...
QStyleOptionGroupBox
The QStyleOptionGroupBox class describes the parameters for drawing a group box.
Definition: qstyleoption.h:834
QStyleOptionComboBox
The QStyleOptionComboBox class is used to describe the parameter for drawing a combobox.
Definition: qstyleoption.h:796
QPainter::setPen
void setPen(const QColor &color)
Sets the painter&#39;s pen to have style Qt::SolidLine, width 0 and the specified color.
Definition: qpainter.cpp:4047
QStyleOption::direction
Qt::LayoutDirection direction
the text layout direction that should be used when drawing text in the control
Definition: qstyleoption.h:89
QRect
The QRect class defines a rectangle in the plane using integer precision.
Definition: qrect.h:58
QHashableLatin1Literal::toString
QString toString() const
Definition: qgtkstyle_p.h:110
QPoint::y
int y() const
Returns the y coordinate of this point.
Definition: qpoint.h:131
QStyle::proxy
const QStyle * proxy() const
Definition: qstyle.cpp:2546
QStyleOptionSlider
The QStyleOptionSlider class is used to describe the parameters needed for drawing a slider...
Definition: qstyleoption.h:701
QPainter::setFont
void setFont(const QFont &f)
Sets the painter&#39;s font to the given font.
Definition: qpainter.cpp:4288
QCleanlooksStyle::drawComplexControl
void drawComplexControl(ComplexControl control, const QStyleOptionComplex *option, QPainter *painter, const QWidget *widget) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:2419
QPoint::x
int x() const
Returns the x coordinate of this point.
Definition: qpoint.h:128
QRect::isValid
bool isValid() const
Returns true if the rectangle is valid, otherwise returns false.
Definition: qrect.h:237
QPalette::button
const QBrush & button() const
Returns the button brush of the current color group.
Definition: qpalette.h:125
QStyleOptionButton
The QStyleOptionButton class is used to describe the parameters for drawing buttons.
Definition: qstyleoption.h:279
QLatin1Char
The QLatin1Char class provides an 8-bit ASCII/Latin-1 character.
Definition: qchar.h:55
QStyleOption::rect
QRect rect
the area that should be used for various calculations and painting
Definition: qstyleoption.h:90
QGtkStyle::styleHint
int styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget, QStyleHintReturn *returnData) const
Reimplemented Function
Definition: qgtkstyle.cpp:582
QStyleOptionComplex::subControls
QStyle::SubControls subControls
This variable holds a bitwise OR of the sub-controls to be drawn for the complex control.
Definition: qstyleoption.h:693
QPainter::fillRect
void fillRect(const QRectF &, const QBrush &)
Fills the given rectangle with the brush specified.
Definition: qpainter.cpp:7420
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61
QPalette::resolve
QPalette resolve(const QPalette &) const
Returns a new QPalette that has attributes copied from other.
Definition: qpalette.cpp:1101
QPalette
The QPalette class contains color groups for each widget state.
Definition: qpalette.h:61

◆ drawControl()

void QGtkStyle::drawControl ( ControlElement  control,
const QStyleOption *  option,
QPainter *  painter,
const QWidget *  widget 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 2177 of file qgtkstyle.cpp.

2181 {
2182  Q_D(const QGtkStyle);
2183 
2184  if (!d->isThemeAvailable()) {
2185  QCleanlooksStyle::drawControl(element, option, painter, widget);
2186  return;
2187  }
2188 
2189  GtkStyle* style = d->gtkStyle();
2190  QGtkPainter gtkPainter(painter);
2191 
2192  switch (element) {
2193  case CE_ProgressBarLabel:
2194  if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
2195  GtkWidget *gtkProgressBar = d->gtkWidget("GtkProgressBar");
2196  if (!gtkProgressBar)
2197  return;
2198 
2199  QRect leftRect;
2200  QRect rect = bar->rect;
2201  GdkColor gdkText = gtkProgressBar->style->fg[GTK_STATE_NORMAL];
2202  QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
2203  gdkText = gtkProgressBar->style->fg[GTK_STATE_PRELIGHT];
2204  QColor alternateTextColor= QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
2205 
2206  painter->save();
2207  bool vertical = false, inverted = false;
2208  if (const QStyleOptionProgressBarV2 *bar2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {
2209  vertical = (bar2->orientation == Qt::Vertical);
2210  inverted = bar2->invertedAppearance;
2211  }
2212  if (vertical)
2213  rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // flip width and height
2214  const int progressIndicatorPos = (bar->progress - qreal(bar->minimum)) * rect.width() /
2215  qMax(qreal(1.0), qreal(bar->maximum) - bar->minimum);
2216  if (progressIndicatorPos >= 0 && progressIndicatorPos <= rect.width())
2217  leftRect = QRect(rect.left(), rect.top(), progressIndicatorPos, rect.height());
2218  if (vertical)
2219  leftRect.translate(rect.width() - progressIndicatorPos, 0);
2220 
2221  bool flip = (!vertical && (((bar->direction == Qt::RightToLeft) && !inverted) ||
2222  ((bar->direction == Qt::LeftToRight) && inverted)));
2223 
2224  QRegion rightRect = rect;
2225  rightRect = rightRect.subtracted(leftRect);
2226  painter->setClipRegion(rightRect);
2227  painter->setPen(flip ? alternateTextColor : textColor);
2228  painter->drawText(rect, bar->text, QTextOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter));
2229  if (!leftRect.isNull()) {
2230  painter->setPen(flip ? textColor : alternateTextColor);
2231  painter->setClipRect(leftRect);
2232  painter->drawText(rect, bar->text, QTextOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter));
2233  }
2234  painter->restore();
2235  }
2236  break;
2237  case CE_PushButtonLabel:
2238  if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {
2239  QRect ir = button->rect;
2240  uint tf = Qt::AlignVCenter | Qt::TextShowMnemonic;
2241  QPoint buttonShift;
2242 
2243  if (option->state & State_Sunken)
2244  buttonShift = QPoint(pixelMetric(PM_ButtonShiftHorizontal, option, widget),
2245  proxy()->pixelMetric(PM_ButtonShiftVertical, option, widget));
2246 
2247  if (proxy()->styleHint(SH_UnderlineShortcut, button, widget))
2248  tf |= Qt::TextShowMnemonic;
2249  else
2250  tf |= Qt::TextHideMnemonic;
2251 
2252  if (!button->icon.isNull()) {
2253  //Center both icon and text
2254  QPoint point;
2255 
2256  QIcon::Mode mode = button->state & State_Enabled ? QIcon::Normal : QIcon::Disabled;
2257  if (mode == QIcon::Normal && button->state & State_HasFocus)
2258  mode = QIcon::Active;
2259 
2260  QIcon::State state = QIcon::Off;
2261 
2262  if (button->state & State_On)
2263  state = QIcon::On;
2264 
2265  QPixmap pixmap = button->icon.pixmap(button->iconSize, mode, state);
2266  int w = pixmap.width();
2267  int h = pixmap.height();
2268 
2269  if (!button->text.isEmpty())
2270  w += button->fontMetrics.boundingRect(option->rect, tf, button->text).width() + 4;
2271 
2272  point = QPoint(ir.x() + ir.width() / 2 - w / 2,
2273  ir.y() + ir.height() / 2 - h / 2);
2274 
2275  if (button->direction == Qt::RightToLeft)
2276  point.rx() += pixmap.width();
2277 
2278  painter->drawPixmap(visualPos(button->direction, button->rect, point + buttonShift), pixmap);
2279 
2280  if (button->direction == Qt::RightToLeft)
2281  ir.translate(-point.x() - 2, 0);
2282  else
2283  ir.translate(point.x() + pixmap.width() + 2, 0);
2284 
2285  // left-align text if there is
2286  if (!button->text.isEmpty())
2287  tf |= Qt::AlignLeft;
2288 
2289  } else {
2290  tf |= Qt::AlignHCenter;
2291  }
2292 
2293  ir.translate(buttonShift);
2294 
2295  if (button->features & QStyleOptionButton::HasMenu)
2296  ir = ir.adjusted(0, 0, -pixelMetric(PM_MenuButtonIndicator, button, widget), 0);
2297 
2298  GtkWidget *gtkButton = d->gtkWidget("GtkButton");
2299  QPalette pal = button->palette;
2300  int labelState = GTK_STATE_INSENSITIVE;
2301  if (option->state & State_Enabled)
2302  labelState = (option->state & State_MouseOver && !(option->state & State_Sunken)) ?
2303  GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
2304 
2305  GdkColor gdkText = gtkButton->style->fg[labelState];
2306  QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
2307  pal.setBrush(QPalette::ButtonText, textColor);
2308  proxy()->drawItemText(painter, ir, tf, pal, (button->state & State_Enabled),
2309  button->text, QPalette::ButtonText);
2310  }
2311  break;
2312 
2313  case CE_RadioButton: // Fall through
2314  case CE_CheckBox:
2315  if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
2316  bool isRadio = (element == CE_RadioButton);
2317 
2318  // Draw prelight background
2319  GtkWidget *gtkRadioButton = d->gtkWidget("GtkRadioButton");
2320 
2321  if (option->state & State_MouseOver) {
2322  gtkPainter.paintFlatBox(gtkRadioButton, "checkbutton", option->rect,
2323  GTK_STATE_PRELIGHT, GTK_SHADOW_ETCHED_OUT, gtkRadioButton->style);
2324  }
2325 
2326  QStyleOptionButton subopt = *btn;
2327  subopt.rect = subElementRect(isRadio ? SE_RadioButtonIndicator
2328  : SE_CheckBoxIndicator, btn, widget);
2329  proxy()->drawPrimitive(isRadio ? PE_IndicatorRadioButton : PE_IndicatorCheckBox,
2330  &subopt, painter, widget);
2331  subopt.rect = subElementRect(isRadio ? SE_RadioButtonContents
2332  : SE_CheckBoxContents, btn, widget);
2333  // Get label text color
2334  QPalette pal = subopt.palette;
2335  int labelState = GTK_STATE_INSENSITIVE;
2336  if (option->state & State_Enabled)
2337  labelState = (option->state & State_MouseOver) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
2338 
2339  GdkColor gdkText = gtkRadioButton->style->fg[labelState];
2340  QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
2341  pal.setBrush(QPalette::WindowText, textColor);
2342  subopt.palette = pal;
2343  proxy()->drawControl(isRadio ? CE_RadioButtonLabel : CE_CheckBoxLabel, &subopt, painter, widget);
2344 
2345  if (btn->state & State_HasFocus) {
2346  QStyleOptionFocusRect fropt;
2347  fropt.QStyleOption::operator=(*btn);
2348  fropt.rect = subElementRect(isRadio ? SE_RadioButtonFocusRect
2349  : SE_CheckBoxFocusRect, btn, widget);
2350  proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, painter, widget);
2351  }
2352  }
2353  break;
2354 
2355 #ifndef QT_NO_COMBOBOX
2356 
2357  case CE_ComboBoxLabel:
2358  if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
2359  QRect editRect = proxy()->subControlRect(CC_ComboBox, cb, SC_ComboBoxEditField, widget);
2360  bool appearsAsList = !proxy()->styleHint(QStyle::SH_ComboBox_Popup, cb, widget);
2361  painter->save();
2362  painter->setClipRect(editRect);
2363 
2364  if (!cb->currentIcon.isNull()) {
2365  QIcon::Mode mode = cb->state & State_Enabled ? QIcon::Normal
2366  : QIcon::Disabled;
2367  QPixmap pixmap = cb->currentIcon.pixmap(cb->iconSize, mode);
2368  QRect iconRect(editRect);
2369  iconRect.setWidth(cb->iconSize.width() + 4);
2370 
2371  iconRect = alignedRect(cb->direction,
2372  Qt::AlignLeft | Qt::AlignVCenter,
2373  iconRect.size(), editRect);
2374 
2375  if (cb->editable)
2376  painter->fillRect(iconRect, option->palette.brush(QPalette::Base));
2377 
2378  proxy()->drawItemPixmap(painter, iconRect, Qt::AlignCenter, pixmap);
2379 
2380  if (cb->direction == Qt::RightToLeft)
2381  editRect.translate(-4 - cb->iconSize.width(), 0);
2382  else
2383  editRect.translate(cb->iconSize.width() + 4, 0);
2384  }
2385 
2386  if (!cb->currentText.isEmpty() && !cb->editable) {
2387  GtkWidget *gtkCombo = d->gtkWidget("GtkComboBox");
2388  QPalette pal = cb->palette;
2389  int labelState = GTK_STATE_INSENSITIVE;
2390 
2391  if (option->state & State_Enabled)
2392  labelState = (option->state & State_MouseOver && !appearsAsList) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
2393 
2394  GdkColor gdkText = gtkCombo->style->fg[labelState];
2395 
2396  QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
2397 
2398  pal.setBrush(QPalette::ButtonText, textColor);
2399 
2400  proxy()->drawItemText(painter, editRect.adjusted(1, 0, -1, 0),
2401  visualAlignment(cb->direction, Qt::AlignLeft | Qt::AlignVCenter),
2402  pal, cb->state & State_Enabled, cb->currentText, QPalette::ButtonText);
2403  }
2404 
2405  painter->restore();
2406  }
2407  break;
2408 
2409 #endif // QT_NO_COMBOBOX
2410 
2411  case CE_DockWidgetTitle:
2412  painter->save();
2413  if (const QStyleOptionDockWidget *dwOpt = qstyleoption_cast<const QStyleOptionDockWidget *>(option)) {
2414  const QStyleOptionDockWidgetV2 *v2
2415  = qstyleoption_cast<const QStyleOptionDockWidgetV2*>(dwOpt);
2416  bool verticalTitleBar = v2 == 0 ? false : v2->verticalTitleBar;
2417 
2418  QRect rect = dwOpt->rect;
2419  QRect titleRect = subElementRect(SE_DockWidgetTitleBarText, option, widget).adjusted(-2, 0, -2, 0);
2420  QRect r = rect.adjusted(0, 0, -1, -1);
2421  if (verticalTitleBar)
2422  r.adjust(0, 0, 0, -1);
2423 
2424  if (verticalTitleBar) {
2425  QRect r = rect;
2426  QSize s = r.size();
2427  s.transpose();
2428  r.setSize(s);
2429 
2430  titleRect = QRect(r.left() + rect.bottom()
2431  - titleRect.bottom(),
2432  r.top() + titleRect.left() - rect.left(),
2433  titleRect.height(), titleRect.width());
2434 
2435  painter->translate(r.left(), r.top() + r.width());
2436  painter->rotate(-90);
2437  painter->translate(-r.left(), -r.top());
2438 
2439  rect = r;
2440  }
2441 
2442  if (!dwOpt->title.isEmpty()) {
2443  QString titleText
2444  = painter->fontMetrics().elidedText(dwOpt->title,
2445  Qt::ElideRight, titleRect.width());
2446  proxy()->drawItemText(painter,
2447  titleRect,
2448  Qt::AlignLeft | Qt::AlignVCenter | Qt::TextShowMnemonic, dwOpt->palette,
2449  dwOpt->state & State_Enabled, titleText,
2450  QPalette::WindowText);
2451  }
2452  }
2453  painter->restore();
2454  break;
2455 
2456 
2457 
2458  case CE_HeaderSection:
2459  painter->save();
2460 
2461  // Draws the header in tables.
2462  if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
2463  Q_UNUSED(header);
2464  GtkWidget *gtkTreeView = d->gtkWidget("GtkTreeView");
2465  // Get the middle column
2466  GtkTreeViewColumn *column = d->gtk_tree_view_get_column((GtkTreeView*)gtkTreeView, 1);
2467  Q_ASSERT(column);
2468 
2469  GtkWidget *gtkTreeHeader = column->button;
2470  GtkStateType state = gtkPainter.gtkState(option);
2471  GtkShadowType shadow = GTK_SHADOW_OUT;
2472 
2473  if (option->state & State_Sunken)
2474  shadow = GTK_SHADOW_IN;
2475 
2476  gtkPainter.paintBox(gtkTreeHeader, "button", option->rect.adjusted(-1, 0, 0, 0), state, shadow, gtkTreeHeader->style);
2477  }
2478 
2479  painter->restore();
2480  break;
2481 
2482 #ifndef QT_NO_SIZEGRIP
2483 
2484  case CE_SizeGrip: {
2485  GtkWidget *gtkStatusbar = d->gtkWidget("GtkStatusbar.GtkFrame");
2486  QRect gripRect = option->rect.adjusted(0, 0, -gtkStatusbar->style->xthickness, -gtkStatusbar->style->ythickness);
2487  gtkPainter.paintResizeGrip( gtkStatusbar, "statusbar", gripRect, GTK_STATE_NORMAL,
2488  GTK_SHADOW_OUT, QApplication::isRightToLeft() ?
2489  GDK_WINDOW_EDGE_SOUTH_WEST : GDK_WINDOW_EDGE_SOUTH_EAST,
2490  gtkStatusbar->style);
2491  }
2492  break;
2493 
2494 #endif // QT_NO_SIZEGRIP
2495 
2496  case CE_MenuBarEmptyArea: {
2497  GtkWidget *gtkMenubar = d->gtkWidget("GtkMenuBar");
2498  GdkColor gdkBg = gtkMenubar->style->bg[GTK_STATE_NORMAL]; // Theme can depend on transparency
2499  painter->fillRect(option->rect, QColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8));
2500  if (widget) { // See CE_MenuBarItem
2501  QRect menuBarRect = widget->rect();
2502  QPixmap pixmap(menuBarRect.size());
2503  pixmap.fill(Qt::transparent);
2504  QPainter pmPainter(&pixmap);
2505  QGtkPainter gtkMenuBarPainter(&pmPainter);
2506  GtkShadowType shadow_type;
2507  d->gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
2508  gtkMenuBarPainter.paintBox( gtkMenubar, "menubar", menuBarRect,
2509  GTK_STATE_NORMAL, shadow_type, gtkMenubar->style);
2510  pmPainter.end();
2511  painter->drawPixmap(option->rect, pixmap, option->rect);
2512  }
2513  }
2514  break;
2515 
2516  case CE_MenuBarItem:
2517  painter->save();
2518 
2519  if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
2520  GtkWidget *gtkMenubarItem = d->gtkWidget("GtkMenuBar.GtkMenuItem");
2521  GtkWidget *gtkMenubar = d->gtkWidget("GtkMenuBar");
2522 
2523  style = gtkMenubarItem->style;
2524 
2525  if (widget) {
2526  // Since Qt does not currently allow filling the entire background
2527  // we use a hack for this by making a complete menubar each time and
2528  // paint with the correct offset inside it. Pixmap caching should resolve
2529  // most of the performance penalty.
2530  QRect menuBarRect = widget->rect();
2531  QPixmap pixmap(menuBarRect.size());
2532  pixmap.fill(Qt::transparent);
2533  QPainter pmPainter(&pixmap);
2534  QGtkPainter menubarPainter(&pmPainter);
2535  GtkShadowType shadow_type;
2536  d->gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
2537  GdkColor gdkBg = gtkMenubar->style->bg[GTK_STATE_NORMAL]; // Theme can depend on transparency
2538  painter->fillRect(option->rect, QColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8));
2539  menubarPainter.paintBox(gtkMenubar, "menubar", menuBarRect,
2540  GTK_STATE_NORMAL, shadow_type, gtkMenubar->style);
2541  pmPainter.end();
2542  painter->drawPixmap(option->rect, pixmap, option->rect);
2543  }
2544 
2545  QStyleOptionMenuItem item = *mbi;
2546  bool act = mbi->state & State_Selected && mbi->state & State_Sunken;
2547  bool dis = !(mbi->state & State_Enabled);
2548  item.rect = mbi->rect;
2549  GdkColor gdkText = gtkMenubarItem->style->fg[dis ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL];
2550  GdkColor gdkHText = gtkMenubarItem->style->fg[GTK_STATE_PRELIGHT];
2551  QColor normalTextColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
2552  QColor highlightedTextColor = QColor(gdkHText.red>>8, gdkHText.green>>8, gdkHText.blue>>8);
2553  item.palette.setBrush(QPalette::HighlightedText, highlightedTextColor);
2554  item.palette.setBrush(QPalette::Text, normalTextColor);
2555  item.palette.setBrush(QPalette::ButtonText, normalTextColor);
2556  QCommonStyle::drawControl(element, &item, painter, widget);
2557 
2558  if (act) {
2559  GtkShadowType shadowType = GTK_SHADOW_NONE;
2560  d->gtk_widget_style_get (gtkMenubarItem, "selected-shadow-type", &shadowType, NULL);
2561  gtkPainter.paintBox(gtkMenubarItem, "menuitem", option->rect.adjusted(0, 0, 0, 3),
2562  GTK_STATE_PRELIGHT, shadowType, gtkMenubarItem->style);
2563  //draw text
2564  QPalette::ColorRole textRole = dis ? QPalette::Text : QPalette::HighlightedText;
2565  uint alignment = Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
2566 
2567  if (!proxy()->styleHint(SH_UnderlineShortcut, mbi, widget))
2568  alignment |= Qt::TextHideMnemonic;
2569 
2570  proxy()->drawItemText(painter, item.rect, alignment, item.palette, mbi->state & State_Enabled, mbi->text, textRole);
2571  }
2572  }
2573  painter->restore();
2574  break;
2575 
2576  case CE_Splitter: {
2577  GtkWidget *gtkWindow = d->gtkWidget("GtkWindow"); // The Murrine Engine currently assumes a widget is passed
2578  gtkPainter.paintHandle(gtkWindow, "splitter", option->rect, gtkPainter.gtkState(option), GTK_SHADOW_NONE,
2579  !(option->state & State_Horizontal) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL,
2580  style);
2581  }
2582  break;
2583 
2584 #ifndef QT_NO_TOOLBAR
2585 
2586  case CE_ToolBar:
2587  if (const QStyleOptionToolBar *toolbar = qstyleoption_cast<const QStyleOptionToolBar *>(option)) {
2588  // Reserve the beveled appearance only for mainwindow toolbars
2589  if (!(widget && qobject_cast<const QMainWindow*> (widget->parentWidget())))
2590  break;
2591 
2592  QRect rect = option->rect;
2593  // There is a 1 pixel gap between toolbar lines in some styles (i.e Human)
2594  if (toolbar->positionWithinLine != QStyleOptionToolBar::End)
2595  rect.adjust(0, 0, 1, 0);
2596 
2597  GtkWidget *gtkToolbar = d->gtkWidget("GtkToolbar");
2598  GtkShadowType shadow_type = GTK_SHADOW_NONE;
2599  d->gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
2600  gtkPainter.paintBox( gtkToolbar, "toolbar", rect,
2601  GTK_STATE_NORMAL, shadow_type, gtkToolbar->style);
2602  }
2603  break;
2604 
2605 #endif // QT_NO_TOOLBAR
2606 
2607  case CE_MenuItem:
2608  painter->save();
2609 
2610  // Draws one item in a popup menu.
2611  if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
2612  const int windowsItemFrame = 2; // menu item frame width
2613  const int windowsItemHMargin = 3; // menu item hor text margin
2614  const int windowsItemVMargin = 26; // menu item ver text margin
2615  const int windowsRightBorder = 15; // right border on windows
2616  GtkWidget *gtkMenuItem = menuItem->checked ? d->gtkWidget("GtkMenu.GtkCheckMenuItem") :
2617  d->gtkWidget("GtkMenu.GtkMenuItem");
2618 
2619  style = gtkPainter.getStyle(gtkMenuItem);
2620  QColor shadow = option->palette.dark().color();
2621 
2622  if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) {
2623  GtkWidget *gtkMenuSeparator = d->gtkWidget("GtkMenu.GtkSeparatorMenuItem");
2624  painter->setPen(shadow.lighter(106));
2625  gboolean wide_separators = 0;
2626  gint separator_height = 0;
2627  guint horizontal_padding = 3;
2628  QRect separatorRect = option->rect;
2629  if (!d->gtk_check_version(2, 10, 0)) {
2630  d->gtk_widget_style_get(gtkMenuSeparator,
2631  "wide-separators", &wide_separators,
2632  "separator-height", &separator_height,
2633  "horizontal-padding", &horizontal_padding,
2634  NULL);
2635  }
2636  separatorRect.setHeight(option->rect.height() - 2 * gtkMenuSeparator->style->ythickness);
2637  separatorRect.setWidth(option->rect.width() - 2 * (horizontal_padding + gtkMenuSeparator->style->xthickness));
2638  separatorRect.moveCenter(option->rect.center());
2639  if (wide_separators)
2640  gtkPainter.paintBox( gtkMenuSeparator, "hseparator",
2641  separatorRect, GTK_STATE_NORMAL, GTK_SHADOW_NONE, gtkMenuSeparator->style);
2642  else
2643  gtkPainter.paintHline( gtkMenuSeparator, "hseparator",
2644  separatorRect, GTK_STATE_NORMAL, gtkMenuSeparator->style,
2645  0, option->rect.right() - 1, 1);
2646  painter->restore();
2647  break;
2648  }
2649 
2650  bool selected = menuItem->state & State_Selected && menuItem->state & State_Enabled;
2651 
2652  if (selected) {
2653  QRect rect = option->rect;
2654 #ifndef QT_NO_COMBOBOX
2655  if (qobject_cast<const QComboBox*>(widget))
2656  rect = option->rect;
2657 #endif
2658  gtkPainter.paintBox( gtkMenuItem, "menuitem", rect, GTK_STATE_PRELIGHT, GTK_SHADOW_OUT, style);
2659  }
2660 
2661  bool checkable = menuItem->checkType != QStyleOptionMenuItem::NotCheckable;
2662  bool checked = menuItem->checked;
2663  bool enabled = menuItem->state & State_Enabled;
2664  bool ignoreCheckMark = false;
2665 
2666  gint checkSize;
2667  d->gtk_widget_style_get(d->gtkWidget("GtkMenu.GtkCheckMenuItem"), "indicator-size", &checkSize, NULL);
2668 
2669  int checkcol = qMax(menuItem->maxIconWidth, qMax(20, checkSize));
2670 
2671 #ifndef QT_NO_COMBOBOX
2672 
2673  if (qobject_cast<const QComboBox*>(widget))
2674  ignoreCheckMark = true; // Ignore the checkmarks provided by the QComboMenuDelegate
2675 
2676 #endif
2677  if (!ignoreCheckMark) {
2678  // Check
2679  QRect checkRect(option->rect.left() + 7, option->rect.center().y() - checkSize/2 + 1, checkSize, checkSize);
2680  checkRect = visualRect(menuItem->direction, menuItem->rect, checkRect);
2681 
2682  if (checkable && menuItem->icon.isNull()) {
2683  // Some themes such as aero-clone draw slightly outside the paint rect
2684  int spacing = 1; // ### Consider using gtkCheckBox : "indicator-spacing" instead
2685 
2686  if (menuItem->checkType & QStyleOptionMenuItem::Exclusive) {
2687  // Radio button
2688  GtkShadowType shadow = GTK_SHADOW_OUT;
2689  GtkStateType state = gtkPainter.gtkState(option);
2690 
2691  if (selected)
2692  state = GTK_STATE_PRELIGHT;
2693  if (checked)
2694  shadow = GTK_SHADOW_IN;
2695 
2696  gtkPainter.setClipRect(checkRect.adjusted(-spacing, -spacing, spacing, spacing));
2697  gtkPainter.paintOption(gtkMenuItem, checkRect.translated(-spacing, -spacing), state, shadow,
2698  gtkMenuItem->style, QLS("option"));
2699  gtkPainter.setClipRect(QRect());
2700 
2701  } else {
2702  // Check box
2703  if (menuItem->icon.isNull()) {
2704  GtkShadowType shadow = GTK_SHADOW_OUT;
2705  GtkStateType state = gtkPainter.gtkState(option);
2706 
2707  if (selected)
2708  state = GTK_STATE_PRELIGHT;
2709  if (checked)
2710  shadow = GTK_SHADOW_IN;
2711 
2712  gtkPainter.setClipRect(checkRect.adjusted(-spacing, -spacing, -spacing, -spacing));
2713  gtkPainter.paintCheckbox(gtkMenuItem, checkRect.translated(-spacing, -spacing), state, shadow,
2714  gtkMenuItem->style, QLS("check"));
2715  gtkPainter.setClipRect(QRect());
2716  }
2717  }
2718  }
2719 
2720  } else {
2721  // Ignore checkmark
2722  if (menuItem->icon.isNull())
2723  checkcol = 0;
2724  else
2725  checkcol = menuItem->maxIconWidth;
2726  }
2727 
2728  bool dis = !(menuItem->state & State_Enabled);
2729  bool act = menuItem->state & State_Selected;
2730  const QStyleOption *opt = option;
2731  const QStyleOptionMenuItem *menuitem = menuItem;
2732  QPainter *p = painter;
2733  QRect vCheckRect = visualRect(opt->direction, menuitem->rect,
2734  QRect(menuitem->rect.x() + 3, menuitem->rect.y(),
2735  checkcol, menuitem->rect.height()));
2736 
2737  if (!menuItem->icon.isNull()) {
2738  QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal;
2739 
2740  if (act && !dis)
2741  mode = QIcon::Active;
2742 
2743  QPixmap pixmap;
2744  int smallIconSize = proxy()->pixelMetric(PM_SmallIconSize, option, widget);
2745  QSize iconSize(smallIconSize, smallIconSize);
2746 
2747 #ifndef QT_NO_COMBOBOX
2748  if (const QComboBox *combo = qobject_cast<const QComboBox*>(widget))
2749  iconSize = combo->iconSize();
2750 
2751 #endif // QT_NO_COMBOBOX
2752  if (checked)
2753  pixmap = menuItem->icon.pixmap(iconSize, mode, QIcon::On);
2754  else
2755  pixmap = menuItem->icon.pixmap(iconSize, mode);
2756 
2757  int pixw = pixmap.width();
2758  int pixh = pixmap.height();
2759  QRect pmr(0, 0, pixw, pixh);
2760  pmr.moveCenter(vCheckRect.center() - QPoint(0, 1));
2761  painter->setPen(menuItem->palette.text().color());
2762  if (!ignoreCheckMark && checkable && checked) {
2763  QStyleOption opt = *option;
2764 
2765  if (act) {
2766  QColor activeColor = mergedColors(option->palette.background().color(),
2767  option->palette.highlight().color());
2768  opt.palette.setBrush(QPalette::Button, activeColor);
2769  }
2770  opt.state |= State_Sunken;
2771  opt.rect = vCheckRect;
2772  proxy()->drawPrimitive(PE_PanelButtonCommand, &opt, painter, widget);
2773  }
2774  painter->drawPixmap(pmr.topLeft(), pixmap);
2775  }
2776 
2777  GdkColor gdkText = gtkMenuItem->style->fg[GTK_STATE_NORMAL];
2778  GdkColor gdkDText = gtkMenuItem->style->fg[GTK_STATE_INSENSITIVE];
2779  GdkColor gdkHText = gtkMenuItem->style->fg[GTK_STATE_PRELIGHT];
2780  uint resolve_mask = option->palette.resolve();
2781  QColor textColor = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
2782  QColor disabledTextColor = QColor(gdkDText.red>>8, gdkDText.green>>8, gdkDText.blue>>8);
2783  if (resolve_mask & (1 << QPalette::ButtonText)) {
2784  textColor = option->palette.buttonText().color();
2785  disabledTextColor = option->palette.brush(QPalette::Disabled, QPalette::ButtonText).color();
2786  }
2787 
2788  QColor highlightedTextColor = QColor(gdkHText.red>>8, gdkHText.green>>8, gdkHText.blue>>8);
2789  if (resolve_mask & (1 << QPalette::HighlightedText)) {
2790  highlightedTextColor = option->palette.highlightedText().color();
2791  }
2792 
2793  if (selected)
2794  painter->setPen(highlightedTextColor);
2795  else
2796  painter->setPen(textColor);
2797 
2798  int x, y, w, h;
2799  menuitem->rect.getRect(&x, &y, &w, &h);
2800  int tab = menuitem->tabWidth;
2801  int xm = windowsItemFrame + checkcol + windowsItemHMargin;
2802  int xpos = menuitem->rect.x() + xm + 1;
2803  QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);
2804  QRect vTextRect = visualRect(opt->direction, menuitem->rect, textRect);
2805  QString s = menuitem->text;
2806 
2807  if (!s.isEmpty()) { // Draw text
2808  p->save();
2809  int t = s.indexOf(QLatin1Char('\t'));
2810  int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
2811 
2812  if (!proxy()->styleHint(SH_UnderlineShortcut, menuitem, widget))
2813  text_flags |= Qt::TextHideMnemonic;
2814 
2815  // Draw shortcut right aligned
2816  text_flags |= Qt::AlignRight;
2817 
2818  if (t >= 0) {
2819  int rightMargin = 12; // Hardcode for now
2820  QRect vShortcutRect = visualRect(opt->direction, menuitem->rect,
2821  QRect(textRect.topRight(), QPoint(menuitem->rect.right() - rightMargin, textRect.bottom())));
2822 
2823  if (dis)
2824  p->setPen(disabledTextColor);
2825  p->drawText(vShortcutRect, text_flags , s.mid(t + 1));
2826  s = s.left(t);
2827  }
2828 
2829  text_flags &= ~Qt::AlignRight;
2830  text_flags |= Qt::AlignLeft;
2831  QFont font = menuitem->font;
2832  if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem)
2833  font.setBold(true);
2834  p->setFont(font);
2835 
2836  if (dis)
2837  p->setPen(disabledTextColor);
2838  p->drawText(vTextRect, text_flags, s.left(t));
2839  p->restore();
2840  }
2841 
2842  // Arrow
2843  if (menuItem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow
2844 
2845  QFontMetrics fm(menuitem->font);
2846  int arrow_size = fm.ascent() + fm.descent() - 2 * gtkMenuItem->style->ythickness;
2847  gfloat arrow_scaling = 0.8;
2848  int extra = 0;
2849  if (!d->gtk_check_version(2, 16, 0)) {
2850  // "arrow-scaling" is actually hardcoded and fails on hardy (see gtk+-2.12/gtkmenuitem.c)
2851  // though the current documentation states otherwise
2852  d->gtk_widget_style_get(gtkMenuItem, "arrow-scaling", &arrow_scaling, NULL);
2853  // in versions < 2.16 ythickness was previously subtracted from the arrow_size
2854  extra = 2 * gtkMenuItem->style->ythickness;
2855  }
2856 
2857  int horizontal_padding;
2858  d->gtk_widget_style_get(gtkMenuItem, "horizontal-padding", &horizontal_padding, NULL);
2859 
2860  const int dim = static_cast<int>(arrow_size * arrow_scaling) + extra;
2861  int xpos = menuItem->rect.left() + menuItem->rect.width() - horizontal_padding - dim;
2862  QRect vSubMenuRect = visualRect(option->direction, menuItem->rect,
2863  QRect(xpos, menuItem->rect.top() +
2864  menuItem->rect.height() / 2 - dim / 2, dim, dim));
2865  GtkStateType state = enabled ? (act ? GTK_STATE_PRELIGHT: GTK_STATE_NORMAL) : GTK_STATE_INSENSITIVE;
2866  GtkShadowType shadowType = (state == GTK_STATE_PRELIGHT) ? GTK_SHADOW_OUT : GTK_SHADOW_IN;
2867  gtkPainter.paintArrow(gtkMenuItem, "menuitem", vSubMenuRect, QApplication::isRightToLeft() ? GTK_ARROW_LEFT : GTK_ARROW_RIGHT, state,
2868  shadowType, FALSE, style);
2869  }
2870  }
2871  painter->restore();
2872  break;
2873 
2874  case CE_PushButton:
2875  if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
2876  GtkWidget *gtkButton = d->gtkWidget("GtkButton");
2877  proxy()->drawControl(CE_PushButtonBevel, btn, painter, widget);
2878  QStyleOptionButton subopt = *btn;
2879  subopt.rect = subElementRect(SE_PushButtonContents, btn, widget);
2880  gint interiorFocus = true;
2881  d->gtk_widget_style_get(gtkButton, "interior-focus", &interiorFocus, NULL);
2882  int xt = interiorFocus ? gtkButton->style->xthickness : 0;
2883  int yt = interiorFocus ? gtkButton->style->ythickness : 0;
2884 
2885  if (btn->features & QStyleOptionButton::Flat && btn->state & State_HasFocus)
2886  // The normal button focus rect does not work well for flat buttons in Clearlooks
2887  proxy()->drawPrimitive(PE_FrameFocusRect, option, painter, widget);
2888  else if (btn->state & State_HasFocus)
2889  gtkPainter.paintFocus(gtkButton, "button",
2890  option->rect.adjusted(xt, yt, -xt, -yt),
2891  btn->state & State_Sunken ? GTK_STATE_ACTIVE : GTK_STATE_NORMAL,
2892  gtkButton->style);
2893 
2894  proxy()->drawControl(CE_PushButtonLabel, &subopt, painter, widget);
2895  }
2896  break;
2897 
2898 #ifndef QT_NO_TABBAR
2899 
2900  case CE_TabBarTabShape:
2901  if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {
2902  GtkWidget *gtkNotebook = d->gtkWidget("GtkNotebook");
2903  style = gtkPainter.getStyle(gtkNotebook);
2904 
2905  QRect rect = option->rect;
2906  GtkShadowType shadow = GTK_SHADOW_OUT;
2907  GtkStateType state = GTK_STATE_ACTIVE;
2908  if (tab->state & State_Selected)
2909  state = GTK_STATE_NORMAL;
2910 
2911  bool selected = (tab->state & State_Selected);
2912  bool first = false, last = false;
2913  if (widget) {
2914  // This is most accurate and avoids resizing tabs while moving
2915  first = tab->rect.left() == widget->rect().left();
2916  last = tab->rect.right() == widget->rect().right();
2917  } else if (option->direction == Qt::RightToLeft) {
2918  bool tmp = first;
2919  first = last;
2920  last = tmp;
2921  }
2922  int topIndent = 3;
2923  int bottomIndent = 1;
2924  int tabOverlap = 1;
2925  painter->save();
2926 
2927  switch (tab->shape) {
2928  case QTabBar::RoundedNorth:
2929  if (!selected)
2930  rect.adjust(first ? 0 : -tabOverlap, topIndent, last ? 0 : tabOverlap, -bottomIndent);
2931  gtkPainter.paintExtention( gtkNotebook, "tab", rect,
2932  state, shadow, GTK_POS_BOTTOM, style);
2933  break;
2934 
2935  case QTabBar::RoundedSouth:
2936  if (!selected)
2937  rect.adjust(first ? 0 : -tabOverlap, 0, last ? 0 : tabOverlap, -topIndent);
2938  gtkPainter.paintExtention( gtkNotebook, "tab", rect.adjusted(0, 1, 0, 0),
2939  state, shadow, GTK_POS_TOP, style);
2940  break;
2941 
2942  case QTabBar::RoundedWest:
2943  if (!selected)
2944  rect.adjust(topIndent, 0, -bottomIndent, 0);
2945  gtkPainter.paintExtention( gtkNotebook, "tab", rect, state, shadow, GTK_POS_RIGHT, style);
2946  break;
2947 
2948  case QTabBar::RoundedEast:
2949  if (!selected)
2950  rect.adjust(bottomIndent, 0, -topIndent, 0);
2951  gtkPainter.paintExtention( gtkNotebook, "tab", rect, state, shadow, GTK_POS_LEFT, style);
2952  break;
2953 
2954  default:
2955  QCleanlooksStyle::drawControl(element, option, painter, widget);
2956  break;
2957  }
2958 
2959  painter->restore();
2960  }
2961 
2962  break;
2963 
2964 #endif //QT_NO_TABBAR
2965 
2966  case CE_ProgressBarGroove:
2967  if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
2968  Q_UNUSED(bar);
2969  GtkWidget *gtkProgressBar = d->gtkWidget("GtkProgressBar");
2970  GtkStateType state = gtkPainter.gtkState(option);
2971  gtkPainter.paintBox( gtkProgressBar, "trough", option->rect, state, GTK_SHADOW_IN, gtkProgressBar->style);
2972  }
2973 
2974  break;
2975 
2976  case CE_ProgressBarContents:
2977  if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
2978  GtkStateType state = option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE;
2979  GtkWidget *gtkProgressBar = d->gtkWidget("GtkProgressBar");
2980  style = gtkProgressBar->style;
2981  gtkPainter.paintBox( gtkProgressBar, "trough", option->rect, state, GTK_SHADOW_IN, style);
2982  int xt = style->xthickness;
2983  int yt = style->ythickness;
2984  QRect rect = bar->rect.adjusted(xt, yt, -xt, -yt);
2985  bool vertical = false;
2986  bool inverted = false;
2987  bool indeterminate = (bar->minimum == 0 && bar->maximum == 0);
2988  // Get extra style options if version 2
2989 
2990  if (const QStyleOptionProgressBarV2 *bar2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {
2991  vertical = (bar2->orientation == Qt::Vertical);
2992  inverted = bar2->invertedAppearance;
2993  }
2994 
2995  // If the orientation is vertical, we use a transform to rotate
2996  // the progress bar 90 degrees clockwise. This way we can use the
2997  // same rendering code for both orientations.
2998  if (vertical) {
2999  rect.translate(xt, -yt * 2);
3000  rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // Flip width and height
3001  QTransform m = QTransform::fromTranslate(rect.height(), 0);
3002  m.rotate(90.0);
3003  painter->setTransform(m);
3004  }
3005 
3006  int maxWidth = rect.width();
3007  int minWidth = 4;
3008 
3009  qint64 progress = (qint64)qMax(bar->progress, bar->minimum); // Workaround for bug in QProgressBar
3010  double vc6_workaround = ((progress - qint64(bar->minimum)) / double(qint64(bar->maximum) - qint64(bar->minimum))) * maxWidth;
3011  int progressBarWidth = (int(vc6_workaround) > minWidth ) ? int(vc6_workaround) : minWidth;
3012  int width = indeterminate ? maxWidth : progressBarWidth;
3013  bool reverse = (!vertical && (bar->direction == Qt::RightToLeft)) || vertical;
3014 
3015  if (inverted)
3016  reverse = !reverse;
3017 
3018  int maximum = 2;
3019  int fakePos = 0;
3020  if (bar->minimum == bar->maximum)
3021  maximum = 0;
3022  if (bar->progress == bar->maximum)
3023  fakePos = maximum;
3024  else if (bar->progress > bar->minimum)
3025  fakePos = maximum - 1;
3026 
3027  d->gtk_progress_configure((GtkProgress*)gtkProgressBar, fakePos, 0, maximum);
3028 
3029  QRect progressBar;
3030 
3031  if (!indeterminate) {
3032  if (!reverse)
3033  progressBar.setRect(rect.left(), rect.top(), width, rect.height());
3034  else
3035  progressBar.setRect(rect.right() - width, rect.top(), width, rect.height());
3036 
3037  } else {
3038  Q_D(const QGtkStyle);
3039  int slideWidth = ((rect.width() - 4) * 2) / 3;
3040  int step = ((d->animateStep * slideWidth) / d->animationFps) % slideWidth;
3041  if ((((d->animateStep * slideWidth) / d->animationFps) % (2 * slideWidth)) >= slideWidth)
3042  step = slideWidth - step;
3043  progressBar.setRect(rect.left() + step, rect.top(), slideWidth / 2, rect.height());
3044  }
3045 
3046  QString key = QString(QLS("%0")).arg(fakePos);
3047  if (inverted) {
3048  key += QLatin1String("inv");
3049  gtkPainter.setFlipHorizontal(true);
3050  }
3051  gtkPainter.paintBox( gtkProgressBar, "bar", progressBar, GTK_STATE_SELECTED, GTK_SHADOW_OUT, style, key);
3052  }
3053 
3054  break;
3055 
3056  default:
3057  QCleanlooksStyle::drawControl(element, option, painter, widget);
3058  }
3059 }
QPainter::setTransform
void setTransform(const QTransform &transform, bool combine=false)
Sets the world transformation matrix.
Definition: qpainter.cpp:9547
QPainter
The QPainter class performs low-level painting on widgets and other paint devices.
Definition: qpainter.h:86
QColor
The QColor class provides colors based on RGB, HSV or CMYK values.
Definition: qcolor.h:67
d
double d
Definition: qnumeric_p.h:62
QStyle::alignedRect
static QRect alignedRect(Qt::LayoutDirection direction, Qt::Alignment alignment, const QSize &size, const QRect &rectangle)
Returns a new rectangle of the specified size that is aligned to the given rectangle according to the...
Definition: qstyle.cpp:2120
QPalette::highlight
const QBrush & highlight() const
Returns the highlight brush of the current color group.
Definition: qpalette.h:140
QWidget::parentWidget
QWidget * parentWidget() const
Returns the parent of this widget, or 0 if it does not have any parent widget.
Definition: qwidget.h:1035
QRect::adjusted
QRect adjusted(int x1, int y1, int x2, int y2) const
Returns a new rectangle with dx1, dy1, dx2 and dy2 added respectively to the existing coordinates of ...
Definition: qrect.h:431
QRect::isNull
bool isNull() const
Returns true if the rectangle is a null rectangle, otherwise returns false.
Definition: qrect.h:231
QRect::setHeight
void setHeight(int h)
Sets the height of the rectangle to the given height.
Definition: qrect.h:445
qreal
double qreal
Definition: qglobal.h:1193
QFontMetrics
The QFontMetrics class provides font metrics information.
Definition: qfontmetrics.h:65
QStyleOptionDockWidget
The QStyleOptionDockWidget class is used to describe the parameters for drawing a dock widget...
Definition: qstyleoption.h:504
QBrush::color
const QColor & color() const
Returns the brush color.
Definition: qbrush.h:183
QPixmap::width
int width() const
Returns the width of the pixmap.
Definition: qpixmap.cpp:630
QPalette::ColorRole
ColorRole
The ColorRole enum defines the different symbolic color roles used in current GUIs.
Definition: qpalette.h:93
QStyle::visualPos
static QPoint visualPos(Qt::LayoutDirection direction, const QRect &boundingRect, const QPoint &logicalPos)
Returns the given logicalPosition converted to screen coordinates based on the specified direction...
Definition: qstyle.cpp:2109
QPalette::dark
const QBrush & dark() const
Returns the dark brush of the current color group.
Definition: qpalette.h:127
QStyleOption::state
QStyle::State state
the style flags that are used when drawing the control
Definition: qstyleoption.h:88
QStyleOptionMenuItem
The QStyleOptionMenuItem class is used to describe the parameter necessary for drawing a menu item...
Definition: qstyleoption.h:435
QStyleOptionHeader
The QStyleOptionHeader class is used to describe the parameters for drawing a header.
Definition: qstyleoption.h:251
QStyle::subControlRect
virtual QRect subControlRect(ComplexControl cc, const QStyleOptionComplex *opt, SubControl sc, const QWidget *widget=0) const =0
Returns the rectangle containing the specified subControl of the given complex control (with the styl...
QPainter::rotate
void rotate(qreal a)
Rotates the coordinate system the given angle clockwise.
Definition: qpainter.cpp:3287
QPalette::background
const QBrush & background() const
Use window() instead.
Definition: qpalette.h:134
QStyle::pixelMetric
virtual int pixelMetric(PixelMetric metric, const QStyleOption *option=0, const QWidget *widget=0) const =0
Returns the value of the given pixel metric.
QStyleOptionMenuItem::font
QFont font
the font used for the menu item text
Definition: qstyleoption.h:454
reverse
static C reverse(const C &l)
Definition: qdatetimeedit.cpp:928
QPainter::setClipRect
void setClipRect(const QRectF &, Qt::ClipOperation op=Qt::ReplaceClip)
Enables clipping, and sets the clip region to the given rectangle using the given clip operation...
Definition: qpainter.cpp:2801
QPainter::restore
void restore()
Restores the current painter state (pops a saved state off the stack).
Definition: qpainter.cpp:1620
QIcon::State
State
This enum describes the state for which a pixmap is intended to be used.
Definition: qicon.h:64
QStyle::styleHint
virtual int styleHint(StyleHint stylehint, const QStyleOption *opt=0, const QWidget *widget=0, QStyleHintReturn *returnData=0) const =0
Returns an integer representing the specified style hint for the given widget described by the provid...
QRect::left
int left() const
Returns the x-coordinate of the rectangle&#39;s left edge.
Definition: qrect.h:240
QRect::width
int width() const
Returns the width of the rectangle.
Definition: qrect.h:303
QStyleOptionToolBar
The QStyleOptionToolBar class is used to describe the parameters for drawing a toolbar.
Definition: qstyleoption.h:369
QLatin1String
QLatin1String(DBUS_INTERFACE_DBUS))) Q_GLOBAL_STATIC_WITH_ARGS(QString
QStyle::drawItemText
virtual void drawItemText(QPainter *painter, const QRect &rect, int flags, const QPalette &pal, bool enabled, const QString &text, QPalette::ColorRole textRole=QPalette::NoRole) const
Draws the given text in the specified rectangle using the provided painter and palette.
Definition: qstyle.cpp:532
QGtkStyle::pixelMetric
int pixelMetric(PixelMetric metric, const QStyleOption *option=0, const QWidget *widget=0) const
Reimplemented Function
Definition: qgtkstyle.cpp:408
QRect::height
int height() const
Returns the height of the rectangle.
Definition: qrect.h:306
QRect::bottom
int bottom() const
Returns the y-coordinate of the rectangle&#39;s bottom edge.
Definition: qrect.h:249
QString
The QString class provides a Unicode character string.
Definition: qstring.h:83
Q_ASSERT
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QCleanlooksStyle::drawControl
void drawControl(ControlElement ce, const QStyleOption *option, QPainter *painter, const QWidget *widget) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:1382
toolbar
NSToolbar * toolbar
Definition: qcocoasharedwindowmethods_mac_p.h:584
QStyleOptionMenuItem::text
QString text
the text for the menu item
Definition: qstyleoption.h:450
QPainter::save
void save()
Saves the current painter state (pushes the state onto a stack).
Definition: qpainter.cpp:1590
qMax
Q_DECL_CONSTEXPR const T & qMax(const T &a, const T &b)
Definition: qglobal.h:1217
QFontMetrics::elidedText
QString elidedText(const QString &text, Qt::TextElideMode mode, int width, int flags=0) const
If the string text is wider than width, returns an elided version of the string (i.
Definition: qfontmetrics.cpp:937
QStyleOptionProgressBarV2
The QStyleOptionProgressBarV2 class is used to describe the parameters necessary for drawing a progre...
Definition: qstyleoption.h:417
QPainter::drawText
void drawText(const QPointF &p, const QString &s)
Draws the given text with the currently defined text direction, beginning at the given position...
Definition: qpainter.cpp:6231
QPainter::fontMetrics
QFontMetrics fontMetrics() const
Returns the font metrics for the painter if the painter is active.
Definition: qpainter.cpp:2077
QPalette::setBrush
void setBrush(ColorRole cr, const QBrush &brush)
Sets the brush for the given color role to the specified brush for all groups in the palette...
Definition: qpalette.h:206
QFont::setBold
void setBold(bool)
If enable is true sets the font&#39;s weight to QFont::Bold ; otherwise sets the weight to QFont::Normal...
Definition: qfont.h:352
windowsItemFrame
static const int windowsItemFrame
Definition: qcleanlooksstyle.cpp:83
QString::left
QString left(int n) const Q_REQUIRED_RESULT
Returns a substring that contains the n leftmost characters of the string.
Definition: qstring.cpp:3664
QStyleOption
The QStyleOption class stores the parameters used by QStyle functions.
Definition: qstyleoption.h:67
QString::isEmpty
bool isEmpty() const
Returns true if the string has no characters; otherwise returns false.
Definition: qstring.h:704
QLS
#define QLS(x)
Definition: qgtkstyle_p.h:77
QTransform::rotate
QTransform & rotate(qreal a, Qt::Axis axis=Qt::ZAxis)
Rotates the coordinate system counterclockwise by the given angle about the specified axis and return...
Definition: qtransform.cpp:615
QRect::size
QSize size() const
Returns the size of the rectangle.
Definition: qrect.h:309
QIcon::Mode
Mode
This enum type describes the mode for which a pixmap is intended to be used.
Definition: qicon.h:63
QRect::adjust
void adjust(int x1, int y1, int x2, int y2)
Adds dx1, dy1, dx2 and dy2 respectively to the existing coordinates of the rectangle.
Definition: qrect.h:434
QComboBox
The QComboBox widget is a combined button and popup list.
Definition: qcombobox.h:62
QStyle::drawPrimitive
virtual void drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const =0
Draws the given primitive element with the provided painter using the style options specified by opti...
QStyleOptionFocusRect
The QStyleOptionFocusRect class is used to describe the parameters for drawing a focus rectangle with...
Definition: qstyleoption.h:103
QPoint::rx
int & rx()
Returns a reference to the x coordinate of this point.
Definition: qpoint.h:140
QRect::setSize
void setSize(const QSize &s)
Sets the size of the rectangle to the given size.
Definition: qrect.h:448
QSize::transpose
void transpose()
Swaps the width and height values.
Definition: qsize.cpp:196
uint
unsigned int uint
Definition: qglobal.h:996
QString::indexOf
int indexOf(QChar c, int from=0, Qt::CaseSensitivity cs=Qt::CaseSensitive) const
Definition: qstring.cpp:2838
FALSE
#define FALSE
Synonym for false.
Definition: qglobal.h:1019
QRegion
The QRegion class specifies a clip region for a painter.
Definition: qregion.h:68
qint64
__int64 qint64
Definition: qglobal.h:942
QStyleOptionMenuItem::menuItemType
MenuItemType menuItemType
the type of menu item
Definition: qstyleoption.h:445
QPalette::brush
const QBrush & brush(ColorGroup cg, ColorRole cr) const
Returns the brush in the specified color group, used for the given color role.
Definition: qpalette.cpp:874
QRect::moveCenter
void moveCenter(const QPoint &p)
Moves the rectangle, leaving the center point at the given position.
Definition: qrect.cpp:840
QPixmap::fill
void fill(const QColor &fillColor=Qt::white)
Fills the pixmap with the given color.
Definition: qpixmap.cpp:1080
QStyleOption::palette
QPalette palette
the palette that should be used when painting the control
Definition: qstyleoption.h:92
QRect::center
QPoint center() const
Returns the center point of the rectangle.
Definition: qrect.h:300
QString::mid
QString mid(int position, int n=-1) const Q_REQUIRED_RESULT
Returns a string that contains n characters of this string, starting at the specified position index...
Definition: qstring.cpp:3706
QStyle::drawItemPixmap
virtual void drawItemPixmap(QPainter *painter, const QRect &rect, int alignment, const QPixmap &pixmap) const
Draws the given pixmap in the specified rectangle, according to the specified alignment, using the provided painter.
Definition: qstyle.cpp:570
QRect::top
int top() const
Returns the y-coordinate of the rectangle&#39;s top edge.
Definition: qrect.h:243
QStyle::visualAlignment
static Qt::Alignment visualAlignment(Qt::LayoutDirection direction, Qt::Alignment alignment)
Transforms an alignment of Qt::AlignLeft or Qt::AlignRight without Qt::AlignAbsolute into Qt::AlignLe...
Definition: qstyle.cpp:2149
QString::arg
QString arg(qlonglong a, int fieldwidth=0, int base=10, const QChar &fillChar=QLatin1Char(' ')) const Q_REQUIRED_RESULT
Definition: qstring.cpp:7186
QStyle::visualRect
static QRect visualRect(Qt::LayoutDirection direction, const QRect &boundingRect, const QRect &logicalRect)
Returns the given logicalRectangle converted to screen coordinates based on the specified direction...
Definition: qstyle.cpp:2087
QPainter::setClipRegion
void setClipRegion(const QRegion &, Qt::ClipOperation op=Qt::ReplaceClip)
Sets the clip region to the given region using the specified clip operation.
Definition: qpainter.cpp:2917
QRect::right
int right() const
Returns the x-coordinate of the rectangle&#39;s right edge.
Definition: qrect.h:246
mergedColors
static QColor mergedColors(const QColor &colorA, const QColor &colorB, int factor=50)
Definition: qgtkstyle.cpp:149
QWidget::rect
QRect rect
the internal geometry of the widget excluding any window frame
Definition: qwidget.h:168
QFont
The QFont class specifies a font used for drawing text.
Definition: qfont.h:64
QRect::y
int y() const
Returns the y-coordinate of the rectangle&#39;s top edge.
Definition: qrect.h:255
QPalette::highlightedText
const QBrush & highlightedText() const
Returns the highlighted text brush of the current color group.
Definition: qpalette.h:141
qstyleoption_cast
T qstyleoption_cast(const QStyleOption *opt)
Definition: qstyleoption.h:885
QStyleOptionMenuItem::tabWidth
int tabWidth
the tab width for the menu item
Definition: qstyleoption.h:453
QRect::x
int x() const
Returns the x-coordinate of the rectangle&#39;s left edge.
Definition: qrect.h:252
QRect::setRect
void setRect(int x, int y, int w, int h)
Sets the coordinates of the rectangle&#39;s top-left corner to ({x}, {y}), and its size to the given widt...
Definition: qrect.h:400
key
int key
Definition: qkeysequence.cpp:395
QPoint
The QPoint class defines a point in the plane using integer precision.
Definition: qpoint.h:53
QStyle::drawControl
virtual void drawControl(ControlElement element, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const =0
Draws the given element with the provided painter with the style options specified by option...
QStyleOptionComboBox
The QStyleOptionComboBox class is used to describe the parameter for drawing a combobox.
Definition: qstyleoption.h:796
QRect::setWidth
void setWidth(int w)
Sets the width of the rectangle to the given width.
Definition: qrect.h:442
QPainter::setPen
void setPen(const QColor &color)
Sets the painter&#39;s pen to have style Qt::SolidLine, width 0 and the specified color.
Definition: qpainter.cpp:4047
QStyleOption::direction
Qt::LayoutDirection direction
the text layout direction that should be used when drawing text in the control
Definition: qstyleoption.h:89
QRect
The QRect class defines a rectangle in the plane using integer precision.
Definition: qrect.h:58
Qt
Definition: qnamespace.h:54
QTextOption
The QTextOption class provides a description of general rich text properties.
Definition: qtextoption.h:59
QRect::getRect
void getRect(int *x, int *y, int *w, int *h) const
Extracts the position of the rectangle&#39;s top-left corner to *x and *y, and its dimensions to *width a...
Definition: qrect.h:392
windowsItemHMargin
static const int windowsItemHMargin
Definition: qcleanlooksstyle.cpp:84
QPoint::y
int y() const
Returns the y coordinate of this point.
Definition: qpoint.h:131
QStyle::proxy
const QStyle * proxy() const
Definition: qstyle.cpp:2546
QCommonStyle::drawControl
void drawControl(ControlElement element, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const
Reimplemented Function
Definition: qcommonstyle.cpp:1203
QPixmap
The QPixmap class is an off-screen image representation that can be used as a paint device...
Definition: qpixmap.h:71
QStyleOptionTab
The QStyleOptionTab class is used to describe the parameters for drawing a tab bar.
Definition: qstyleoption.h:304
QPainter::drawPixmap
void drawPixmap(const QRectF &targetRect, const QPixmap &pixmap, const QRectF &sourceRect)
Draws the rectangular portion source of the given pixmap into the given target in the paint device...
Definition: qpainter.cpp:5619
QPixmap::height
int height() const
Returns the height of the pixmap.
Definition: qpixmap.cpp:645
QSize
The QSize class defines the size of a two-dimensional object using integer point precision.
Definition: qsize.h:53
QPainter::setFont
void setFont(const QFont &f)
Sets the painter&#39;s font to the given font.
Definition: qpainter.cpp:4288
QTransform::fromTranslate
static QTransform fromTranslate(qreal dx, qreal dy)
Creates a matrix which corresponds to a translation of dx along the x axis and dy along the y axis...
Definition: qtransform.cpp:462
QPalette::buttonText
const QBrush & buttonText() const
Returns the button text foreground brush of the current color group.
Definition: qpalette.h:138
QPoint::x
int x() const
Returns the x coordinate of this point.
Definition: qpoint.h:128
QRegion::subtracted
QRegion subtracted(const QRegion &r) const
Returns a region which is r subtracted from this region.
Definition: qregion.h:114
windowsItemVMargin
static const int windowsItemVMargin
Definition: qcleanlooksstyle.cpp:85
QStyleOptionProgressBar
The QStyleOptionProgressBar class is used to describe the parameters necessary for drawing a progress...
Definition: qstyleoption.h:396
QColor::lighter
QColor lighter(int f=150) const
Returns a lighter (or darker) color, but does not change this object.
Definition: qcolor.h:298
QRect::translate
void translate(int dx, int dy)
Moves the rectangle dx along the x axis and dy along the y axis, relative to the current position...
Definition: qrect.h:312
QApplication::isRightToLeft
static bool isRightToLeft()
Returns true if the application&#39;s layout direction is Qt::RightToLeft; otherwise returns false...
Definition: qapplication.h:233
QGtkStyle::subElementRect
QRect subElementRect(SubElement sr, const QStyleOption *opt, const QWidget *w) const
Reimplemented Function
Definition: qgtkstyle.cpp:3490
QStyleOptionButton
The QStyleOptionButton class is used to describe the parameters for drawing buttons.
Definition: qstyleoption.h:279
Q_UNUSED
#define Q_UNUSED(x)
Indicates to the compiler that the parameter with the specified name is not used in the body of a fun...
Definition: qglobal.h:1729
QLatin1Char
The QLatin1Char class provides an 8-bit ASCII/Latin-1 character.
Definition: qchar.h:55
QStyleOption::rect
QRect rect
the area that should be used for various calculations and painting
Definition: qstyleoption.h:90
QGtkStyle::styleHint
int styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget, QStyleHintReturn *returnData) const
Reimplemented Function
Definition: qgtkstyle.cpp:582
enabled
#define enabled
QPainter::fillRect
void fillRect(const QRectF &, const QBrush &)
Fills the given rectangle with the brush specified.
Definition: qpainter.cpp:7420
QPalette::text
const QBrush & text() const
Returns the text foreground brush of the current color group.
Definition: qpalette.h:129
QTransform
The QTransform class specifies 2D transformations of a coordinate system.
Definition: qtransform.h:65
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61
QPalette::resolve
QPalette resolve(const QPalette &) const
Returns a new QPalette that has attributes copied from other.
Definition: qpalette.cpp:1101
QPainter::translate
void translate(const QPointF &offset)
Translates the coordinate system by the given offset; i.e.
Definition: qpainter.cpp:3311
windowsRightBorder
static const int windowsRightBorder
Definition: qcleanlooksstyle.cpp:86
QPalette
The QPalette class contains color groups for each widget state.
Definition: qpalette.h:61

◆ drawItemPixmap()

void QGtkStyle::drawItemPixmap ( QPainter *  painter,
const QRect &  rect,
int  alignment,
const QPixmap &  pixmap 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 3535 of file qgtkstyle.cpp.

3537 {
3538  QCleanlooksStyle::drawItemPixmap(painter, rect, alignment, pixmap);
3539 }
QCleanlooksStyle::drawItemPixmap
void drawItemPixmap(QPainter *painter, const QRect &rect, int alignment, const QPixmap &pixmap) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:4271

◆ drawItemText()

void QGtkStyle::drawItemText ( QPainter *  painter,
const QRect &  rect,
int  alignment,
const QPalette &  pal,
bool  enabled,
const QString &  text,
QPalette::ColorRole  textRole 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 3562 of file qgtkstyle.cpp.

3564 {
3565  return QCleanlooksStyle::drawItemText(painter, rect, alignment, pal, enabled, text, textRole);
3566 }
enabled
#define enabled
QCleanlooksStyle::drawItemText
void drawItemText(QPainter *painter, const QRect &rect, int flags, const QPalette &pal, bool enabled, const QString &text, QPalette::ColorRole textRole=QPalette::NoRole) const
Draws the given text in the specified rectangle using the provided painter and palette.
Definition: qcleanlooksstyle.cpp:652

◆ drawPrimitive()

void QGtkStyle::drawPrimitive ( PrimitiveElement  element,
const QStyleOption *  option,
QPainter *  painter,
const QWidget *  widget 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 686 of file qgtkstyle.cpp.

690 {
691  Q_D(const QGtkStyle);
692 
693  if (!d->isThemeAvailable()) {
694  QCleanlooksStyle::drawPrimitive(element, option, painter, widget);
695  return;
696  }
697 
698  GtkStyle* style = d->gtkStyle();
699  QGtkPainter gtkPainter(painter);
700 
701  switch (element) {
702  case PE_Frame: {
703  if (widget && widget->inherits("QComboBoxPrivateContainer")){
704  QStyleOption copy = *option;
705  copy.state |= State_Raised;
706  proxy()->drawPrimitive(PE_PanelMenu, &copy, painter, widget);
707  break;
708  }
709  // Drawing the entire itemview frame is very expensive, especially on the native X11 engine
710  // Instead we cheat a bit and draw a border image without the center part, hence only scaling
711  // thin rectangular images
712  const int pmSize = 64;
713  const int border = proxy()->pixelMetric(PM_DefaultFrameWidth, option, widget);
714  const QString pmKey = QLatin1Literal("windowframe") % HexString<uint>(option->state);
715 
716  QPixmap pixmap;
717  QRect pmRect(QPoint(0,0), QSize(pmSize, pmSize));
718 
719  // Only draw through style once
720  if (!QPixmapCache::find(pmKey, pixmap)) {
721  pixmap = QPixmap(pmSize, pmSize);
722  pixmap.fill(Qt::transparent);
723  QPainter pmPainter(&pixmap);
724  QGtkPainter gtkFramePainter(&pmPainter);
725  gtkFramePainter.setUsePixmapCache(false); // Don't cache twice
726 
727  GtkShadowType shadow_type = GTK_SHADOW_NONE;
728  if (option->state & State_Sunken)
729  shadow_type = GTK_SHADOW_IN;
730  else if (option->state & State_Raised)
731  shadow_type = GTK_SHADOW_OUT;
732 
733  GtkStyle *style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(),
734  "*.GtkScrolledWindow", "*.GtkScrolledWindow", d->gtk_window_get_type());
735  if (style)
736  gtkFramePainter.paintShadow(d->gtkWidget("GtkFrame"), "viewport", pmRect,
737  option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE,
738  shadow_type, style);
739  QPixmapCache::insert(pmKey, pixmap);
740  }
741 
742  QRect rect = option->rect;
743  const int rw = rect.width() - border;
744  const int rh = rect.height() - border;
745  const int pw = pmRect.width() - border;
746  const int ph = pmRect.height() - border;
747 
748  // Sidelines
749  painter->drawPixmap(rect.adjusted(border, 0, -border, -rh), pixmap, pmRect.adjusted(border, 0, -border,-ph));
750  painter->drawPixmap(rect.adjusted(border, rh, -border, 0), pixmap, pmRect.adjusted(border, ph,-border,0));
751  painter->drawPixmap(rect.adjusted(0, border, -rw, -border), pixmap, pmRect.adjusted(0, border, -pw, -border));
752  painter->drawPixmap(rect.adjusted(rw, border, 0, -border), pixmap, pmRect.adjusted(pw, border, 0, -border));
753 
754  // Corners
755  painter->drawPixmap(rect.adjusted(0, 0, -rw, -rh), pixmap, pmRect.adjusted(0, 0, -pw,-ph));
756  painter->drawPixmap(rect.adjusted(rw, 0, 0, -rh), pixmap, pmRect.adjusted(pw, 0, 0,-ph));
757  painter->drawPixmap(rect.adjusted(0, rh, -rw, 0), pixmap, pmRect.adjusted(0, ph, -pw,0));
758  painter->drawPixmap(rect.adjusted(rw, rh, 0, 0), pixmap, pmRect.adjusted(pw, ph, 0,0));
759  }
760  break;
761 
762  case PE_PanelTipLabel: {
763  GtkWidget *gtkWindow = d->gtkWidget("GtkWindow"); // The Murrine Engine currently assumes a widget is passed
764  style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(), "gtk-tooltips", "GtkWindow",
765  d->gtk_window_get_type());
766  gtkPainter.paintFlatBox(gtkWindow, "tooltip", option->rect, GTK_STATE_NORMAL, GTK_SHADOW_NONE, style);
767  }
768  break;
769 
770  case PE_PanelStatusBar: {
771  if (widget && widget->testAttribute(Qt::WA_SetPalette) &&
772  option->palette.resolve() & (1 << QPalette::Window)) {
773  // Respect custom palette
774  painter->fillRect(option->rect, option->palette.window());
775  break;
776  }
777  GtkShadowType shadow_type;
778  GtkWidget *gtkStatusbarFrame = d->gtkWidget("GtkStatusbar.GtkFrame");
779  d->gtk_widget_style_get(gtkStatusbarFrame->parent, "shadow-type", &shadow_type, NULL);
780  gtkPainter.paintShadow(gtkStatusbarFrame, "frame", option->rect, GTK_STATE_NORMAL,
781  shadow_type, gtkStatusbarFrame->style);
782  }
783  break;
784 
785  case PE_IndicatorHeaderArrow:
786  if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
787  GtkWidget *gtkTreeHeader = d->gtkWidget("GtkTreeView.GtkButton");
788  GtkStateType state = gtkPainter.gtkState(option);
789  style = gtkTreeHeader->style;
790  GtkArrowType type = GTK_ARROW_UP;
791  QImage arrow;
792  // This sorting indicator inversion is intentional, and follows the GNOME HIG.
793  // See http://library.gnome.org/devel/hig-book/stable/controls-lists.html.en#controls-lists-sortable
794  if (header->sortIndicator & QStyleOptionHeader::SortUp)
795  type = GTK_ARROW_UP;
796  else if (header->sortIndicator & QStyleOptionHeader::SortDown)
797  type = GTK_ARROW_DOWN;
798 
799  gtkPainter.paintArrow(gtkTreeHeader, "button", option->rect.adjusted(1, 1, -1, -1), type, state,
800  GTK_SHADOW_NONE, FALSE, style);
801  }
802  break;
803 
804  case PE_FrameFocusRect:
805  if (!widget || qobject_cast<const QAbstractItemView*>(widget))
806  QCleanlooksStyle::drawPrimitive(element, option, painter, widget);
807  else {
808  // ### this mess should move to subcontrolrect
809  QRect frameRect = option->rect.adjusted(1, 1, -1, -2);
810 
811  if (qobject_cast<const QTabBar*>(widget)) {
812  GtkWidget *gtkNotebook = d->gtkWidget("GtkNotebook");
813  style = gtkPainter.getStyle(gtkNotebook);
814  gtkPainter.paintFocus(gtkNotebook, "tab", frameRect.adjusted(-1, 1, 1, 1), GTK_STATE_ACTIVE, style);
815  } else {
816  gtkPainter.paintFocus(NULL, "tab", frameRect, GTK_STATE_ACTIVE, style);
817  }
818  }
819  break;
820 
821  case PE_IndicatorBranch:
822  if (option->state & State_Children) {
823  QRect rect = option->rect;
824  rect = QRect(0, 0, 12, 12);
825  rect.moveCenter(option->rect.center());
826  rect.translate(2, 0);
827  GtkExpanderStyle openState = GTK_EXPANDER_EXPANDED;
828  GtkExpanderStyle closedState = GTK_EXPANDER_COLLAPSED;
829  GtkWidget *gtkTreeView = d->gtkWidget("GtkTreeView");
830 
831  GtkStateType state = GTK_STATE_NORMAL;
832  if (!(option->state & State_Enabled))
833  state = GTK_STATE_INSENSITIVE;
834  else if (option->state & State_MouseOver)
835  state = GTK_STATE_PRELIGHT;
836 
837  gtkPainter.paintExpander(gtkTreeView, "treeview", rect, state,
838  option->state & State_Open ? openState : closedState , gtkTreeView->style);
839  }
840  break;
841 
842  case PE_PanelItemViewRow:
843  // This primitive is only used to draw selection behind selected expander arrows.
844  // We try not to decorate the tree branch background unless you inherit from StyledItemDelegate
845  // The reason for this is that a lot of code that relies on custom item delegates will look odd having
846  // a gradient on the branch but a flat shaded color on the item itself.
847  QCommonStyle::drawPrimitive(element, option, painter, widget);
848  if (!option->state & State_Selected) {
849  break;
850  } else {
851  if (const QAbstractItemView *view = qobject_cast<const QAbstractItemView*>(widget)) {
852  if (!qobject_cast<QStyledItemDelegate*>(view->itemDelegate()))
853  break;
854  }
855  } // fall through
856 
857  case PE_PanelItemViewItem:
858  if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
859  uint resolve_mask = vopt->palette.resolve();
860  if (vopt->backgroundBrush.style() != Qt::NoBrush
861  || (resolve_mask & (1 << QPalette::Base)))
862  {
863  QPointF oldBO = painter->brushOrigin();
864  painter->setBrushOrigin(vopt->rect.topLeft());
865  painter->fillRect(vopt->rect, vopt->backgroundBrush);
866  painter->setBrushOrigin(oldBO);
867  if (!(option->state & State_Selected))
868  break;
869  }
870  if (GtkWidget *gtkTreeView = d->gtkWidget("GtkTreeView")) {
871  const char *detail = "cell_even_ruled";
872  if (vopt && vopt->features & QStyleOptionViewItemV2::Alternate)
873  detail = "cell_odd_ruled";
874  bool isActive = option->state & State_Active;
875  QString key;
876  if (isActive ) {
877  // Required for active/non-active window appearance
878  key = QLS("a");
879  GTK_WIDGET_SET_FLAGS(gtkTreeView, GTK_HAS_FOCUS);
880  }
881  bool isEnabled = (widget ? widget->isEnabled() : (vopt->state & QStyle::State_Enabled));
882  gtkPainter.paintFlatBox(gtkTreeView, detail, option->rect,
883  option->state & State_Selected ? GTK_STATE_SELECTED :
884  isEnabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE,
885  GTK_SHADOW_OUT, gtkTreeView->style, key);
886  if (isActive )
887  GTK_WIDGET_UNSET_FLAGS(gtkTreeView, GTK_HAS_FOCUS);
888  }
889  }
890  break;
891  case PE_IndicatorToolBarSeparator:
892  {
893  const int margin = 6;
894  GtkWidget *gtkSeparator = d->gtkWidget("GtkToolbar.GtkSeparatorToolItem");
895  if (option->state & State_Horizontal) {
896  const int offset = option->rect.width()/2;
897  QRect rect = option->rect.adjusted(offset, margin, 0, -margin);
898  painter->setPen(QPen(option->palette.background().color().darker(110)));
899  gtkPainter.paintVline( gtkSeparator, "vseparator",
900  rect, GTK_STATE_NORMAL, gtkSeparator->style,
901  0, rect.height(), 0);
902  } else { //Draw vertical separator
903  const int offset = option->rect.height()/2;
904  QRect rect = option->rect.adjusted(margin, offset, -margin, 0);
905  painter->setPen(QPen(option->palette.background().color().darker(110)));
906  gtkPainter.paintHline( gtkSeparator, "hseparator",
907  rect, GTK_STATE_NORMAL, gtkSeparator->style,
908  0, rect.width(), 0);
909  }
910  }
911  break;
912 
913  case PE_IndicatorToolBarHandle: {
914  GtkWidget *gtkToolbar = d->gtkWidget("GtkToolbar");
915  GtkShadowType shadow_type;
916  d->gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
917  //Note when the toolbar is horizontal, the handle is vertical
918  painter->setClipRect(option->rect);
919  gtkPainter.paintHandle(gtkToolbar, "toolbar", option->rect.adjusted(-1, -1 ,0 ,1),
920  GTK_STATE_NORMAL, shadow_type, !(option->state & State_Horizontal) ?
921  GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL, gtkToolbar->style);
922  }
923  break;
924 
925  case PE_IndicatorArrowUp:
926  case PE_IndicatorArrowDown:
927  case PE_IndicatorArrowLeft:
928  case PE_IndicatorArrowRight: {
929 
930 
931  GtkArrowType type = GTK_ARROW_UP;
932 
933  switch (element) {
934 
935  case PE_IndicatorArrowDown:
936  type = GTK_ARROW_DOWN;
937  break;
938 
939  case PE_IndicatorArrowLeft:
940  type = GTK_ARROW_LEFT;
941  break;
942 
943  case PE_IndicatorArrowRight:
944  type = GTK_ARROW_RIGHT;
945  break;
946 
947  default:
948  break;
949  }
950  int size = qMin(option->rect.height(), option->rect.width());
951  int border = (size > 9) ? (size/4) : 0; //Allow small arrows to have exact dimensions
952  int bsx = 0, bsy = 0;
953  if (option->state & State_Sunken) {
954  bsx = proxy()->pixelMetric(PM_ButtonShiftHorizontal);
955  bsy = proxy()->pixelMetric(PM_ButtonShiftVertical);
956  }
957  QRect arrowRect = option->rect.adjusted(border + bsx, border + bsy, -border + bsx, -border + bsy);
958  GtkShadowType shadow = option->state & State_Sunken ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
959  GtkStateType state = gtkPainter.gtkState(option);
960 
961  QColor arrowColor = option->palette.buttonText().color();
962  GtkWidget *gtkArrow = d->gtkWidget("GtkArrow");
963  GdkColor color = fromQColor(arrowColor);
964  d->gtk_widget_modify_fg (gtkArrow, state, &color);
965  gtkPainter.paintArrow(gtkArrow, "button", arrowRect,
966  type, state, shadow, FALSE, gtkArrow->style,
967  QString::number(arrowColor.rgba(), 16));
968  // Passing NULL will revert the color change
969  d->gtk_widget_modify_fg (gtkArrow, state, NULL);
970  }
971  break;
972 
973  case PE_FrameGroupBox:
974  // Do nothing here, the GNOME groupboxes are flat
975  break;
976 
977  case PE_PanelMenu: {
978  GtkWidget *gtkMenu = d->gtkWidget("GtkMenu");
979  gtkPainter.setAlphaSupport(false); // Note, alpha disabled for performance reasons
980  gtkPainter.paintBox(gtkMenu, "menu", option->rect, GTK_STATE_NORMAL, GTK_SHADOW_OUT, gtkMenu->style, QString());
981  }
982  break;
983 
984  case PE_FrameMenu:
985  //This is actually done by PE_Widget due to a clipping issue
986  //Otherwise Menu items will not be able to span the entire menu width
987 
988  // This is only used by floating tool bars
989  if (qobject_cast<const QToolBar *>(widget)) {
990  GtkWidget *gtkMenubar = d->gtkWidget("GtkMenuBar");
991  gtkPainter.paintBox( gtkMenubar, "toolbar", option->rect,
992  GTK_STATE_NORMAL, GTK_SHADOW_OUT, style);
993  gtkPainter.paintBox( gtkMenubar, "menu", option->rect,
994  GTK_STATE_NORMAL, GTK_SHADOW_OUT, style);
995  }
996  break;
997 
998  case PE_FrameLineEdit: {
999  GtkWidget *gtkEntry = d->gtkWidget("GtkEntry");
1000 
1001 
1002  gboolean interior_focus;
1003  gint focus_line_width;
1004  QRect rect = option->rect;
1005  d->gtk_widget_style_get(gtkEntry,
1006  "interior-focus", &interior_focus,
1007  "focus-line-width", &focus_line_width, NULL);
1008 
1009  // See https://bugzilla.mozilla.org/show_bug.cgi?id=405421 for info about this hack
1010  g_object_set_data(G_OBJECT(gtkEntry), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
1011 
1012  if (!interior_focus && option->state & State_HasFocus)
1013  rect.adjust(focus_line_width, focus_line_width, -focus_line_width, -focus_line_width);
1014 
1015  if (option->state & State_HasFocus)
1016  GTK_WIDGET_SET_FLAGS(gtkEntry, GTK_HAS_FOCUS);
1017  gtkPainter.paintShadow(gtkEntry, "entry", rect, option->state & State_Enabled ?
1018  GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE,
1019  GTK_SHADOW_IN, gtkEntry->style,
1020  option->state & State_HasFocus ? QLS("focus") : QString());
1021  if (!interior_focus && option->state & State_HasFocus)
1022  gtkPainter.paintShadow(gtkEntry, "entry", option->rect, option->state & State_Enabled ?
1023  GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
1024  GTK_SHADOW_IN, gtkEntry->style, QLS("GtkEntryShadowIn"));
1025 
1026  if (option->state & State_HasFocus)
1027  GTK_WIDGET_UNSET_FLAGS(gtkEntry, GTK_HAS_FOCUS);
1028  }
1029  break;
1030 
1031  case PE_PanelLineEdit:
1032  if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(option)) {
1033  GtkWidget *gtkEntry = d->gtkWidget("GtkEntry");
1034  if (panel->lineWidth > 0)
1035  proxy()->drawPrimitive(PE_FrameLineEdit, option, painter, widget);
1036  uint resolve_mask = option->palette.resolve();
1037  QRect textRect = option->rect.adjusted(gtkEntry->style->xthickness, gtkEntry->style->ythickness,
1038  -gtkEntry->style->xthickness, -gtkEntry->style->ythickness);
1039 
1040  if (widget && widget->testAttribute(Qt::WA_SetPalette) &&
1041  resolve_mask & (1 << QPalette::Base)) // Palette overridden by user
1042  painter->fillRect(textRect, option->palette.base());
1043  else
1044  gtkPainter.paintFlatBox( gtkEntry, "entry_bg", textRect,
1045  option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, GTK_SHADOW_NONE, gtkEntry->style);
1046  }
1047  break;
1048 
1049  case PE_FrameTabWidget:
1050  if (const QStyleOptionTabWidgetFrame *frame = qstyleoption_cast<const QStyleOptionTabWidgetFrame*>(option)) {
1051  GtkWidget *gtkNotebook = d->gtkWidget("GtkNotebook");
1052  style = gtkPainter.getStyle(gtkNotebook);
1053  gtkPainter.setAlphaSupport(false);
1054  GtkShadowType shadow = GTK_SHADOW_OUT;
1055  GtkStateType state = GTK_STATE_NORMAL; // Only state supported by gtknotebook
1056  bool reverse = (option->direction == Qt::RightToLeft);
1057  QGtkStylePrivate::gtk_widget_set_direction(gtkNotebook, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
1058  if (const QStyleOptionTabWidgetFrameV2 *tabframe = qstyleoption_cast<const QStyleOptionTabWidgetFrameV2*>(option)) {
1059  GtkPositionType frameType = GTK_POS_TOP;
1060  QTabBar::Shape shape = frame->shape;
1061  int gapStart = 0;
1062  int gapSize = 0;
1063  if (shape == QTabBar::RoundedNorth || shape == QTabBar::RoundedSouth) {
1064  frameType = (shape == QTabBar::RoundedNorth) ? GTK_POS_TOP : GTK_POS_BOTTOM;
1065  gapStart = tabframe->selectedTabRect.left();
1066  gapSize = tabframe->selectedTabRect.width();
1067  } else {
1068  frameType = (shape == QTabBar::RoundedWest) ? GTK_POS_LEFT : GTK_POS_RIGHT;
1069  gapStart = tabframe->selectedTabRect.y();
1070  gapSize = tabframe->selectedTabRect.height();
1071  }
1072  gtkPainter.paintBoxGap(gtkNotebook, "notebook", option->rect, state, shadow, frameType,
1073  gapStart, gapSize, style);
1074  break; // done
1075  }
1076 
1077  // Note this is only the fallback option
1078  gtkPainter.paintBox(gtkNotebook, "notebook", option->rect, state, shadow, style);
1079  }
1080  break;
1081 
1082  case PE_PanelButtonCommand:
1083  case PE_PanelButtonTool: {
1084  bool isDefault = false;
1085  bool isTool = (element == PE_PanelButtonTool);
1086  if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton*>(option))
1087  isDefault = btn->features & QStyleOptionButton::DefaultButton;
1088 
1089  // don't draw a frame for tool buttons that have the autoRaise flag and are not enabled or on
1090  if (isTool && !(option->state & State_Enabled || option->state & State_On) && (option->state & State_AutoRaise))
1091  break;
1092  // don't draw a frame for dock widget buttons, unless we are hovering
1093  if (widget && widget->inherits("QDockWidgetTitleButton") && !(option->state & State_MouseOver))
1094  break;
1095 
1096  GtkStateType state = gtkPainter.gtkState(option);
1097  if (option->state & State_On || option->state & State_Sunken)
1098  state = GTK_STATE_ACTIVE;
1099  GtkWidget *gtkButton = isTool ? d->gtkWidget("GtkToolButton.GtkButton") : d->gtkWidget("GtkButton");
1100  gint focusWidth, focusPad;
1101  gboolean interiorFocus = false;
1102  d->gtk_widget_style_get (gtkButton,
1103  "focus-line-width", &focusWidth,
1104  "focus-padding", &focusPad,
1105  "interior-focus", &interiorFocus, NULL);
1106 
1107  style = gtkButton->style;
1108 
1109  QRect buttonRect = option->rect;
1110 
1111  QString key;
1112  if (isDefault) {
1113  key += QLS("def");
1114  GTK_WIDGET_SET_FLAGS(gtkButton, GTK_HAS_DEFAULT);
1115  gtkPainter.paintBox(gtkButton, "buttondefault", buttonRect, state, GTK_SHADOW_IN,
1116  style, isDefault ? QLS("d") : QString());
1117  }
1118 
1119  bool hasFocus = option->state & State_HasFocus;
1120 
1121  if (hasFocus) {
1122  key += QLS("def");
1123  GTK_WIDGET_SET_FLAGS(gtkButton, GTK_HAS_FOCUS);
1124  }
1125 
1126  if (!interiorFocus)
1127  buttonRect = buttonRect.adjusted(focusWidth, focusWidth, -focusWidth, -focusWidth);
1128 
1129  GtkShadowType shadow = (option->state & State_Sunken || option->state & State_On ) ?
1130  GTK_SHADOW_IN : GTK_SHADOW_OUT;
1131 
1132  gtkPainter.paintBox(gtkButton, "button", buttonRect, state, shadow,
1133  style, key);
1134  if (isDefault)
1135  GTK_WIDGET_UNSET_FLAGS(gtkButton, GTK_HAS_DEFAULT);
1136  if (hasFocus)
1137  GTK_WIDGET_UNSET_FLAGS(gtkButton, GTK_HAS_FOCUS);
1138  }
1139  break;
1140 
1141  case PE_IndicatorRadioButton: {
1142  GtkShadowType shadow = GTK_SHADOW_OUT;
1143  GtkStateType state = gtkPainter.gtkState(option);
1144 
1145  if (option->state & State_Sunken)
1146  state = GTK_STATE_ACTIVE;
1147 
1148  if (option->state & State_NoChange)
1149  shadow = GTK_SHADOW_ETCHED_IN;
1150  else if (option->state & State_On)
1151  shadow = GTK_SHADOW_IN;
1152  else
1153  shadow = GTK_SHADOW_OUT;
1154 
1155  GtkWidget *gtkRadioButton = d->gtkWidget("GtkRadioButton");
1156  gint spacing;
1157  d->gtk_widget_style_get(gtkRadioButton, "indicator-spacing", &spacing, NULL);
1158  QRect buttonRect = option->rect.adjusted(spacing, spacing, -spacing, -spacing);
1159  gtkPainter.setClipRect(option->rect);
1160  // ### Note: Ubuntulooks breaks when the proper widget is passed
1161  // Murrine engine requires a widget not to get RGBA check - warnings
1162  GtkWidget *gtkCheckButton = d->gtkWidget("GtkCheckButton");
1163  QString key(QLS("radiobutton"));
1164  if (option->state & State_HasFocus) { // Themes such as Nodoka check this flag
1165  key += QLatin1Char('f');
1166  GTK_WIDGET_SET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS);
1167  }
1168  gtkPainter.paintOption(gtkCheckButton , buttonRect, state, shadow, gtkRadioButton->style, key);
1169  if (option->state & State_HasFocus)
1170  GTK_WIDGET_UNSET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS);
1171  }
1172  break;
1173 
1174  case PE_IndicatorCheckBox: {
1175  GtkShadowType shadow = GTK_SHADOW_OUT;
1176  GtkStateType state = gtkPainter.gtkState(option);
1177 
1178  if (option->state & State_Sunken)
1179  state = GTK_STATE_ACTIVE;
1180 
1181  if (option->state & State_NoChange)
1182  shadow = GTK_SHADOW_ETCHED_IN;
1183  else if (option->state & State_On)
1184  shadow = GTK_SHADOW_IN;
1185  else
1186  shadow = GTK_SHADOW_OUT;
1187 
1188  int spacing;
1189 
1190  GtkWidget *gtkCheckButton = d->gtkWidget("GtkCheckButton");
1191  QString key(QLS("checkbutton"));
1192  if (option->state & State_HasFocus) { // Themes such as Nodoka checks this flag
1193  key += QLatin1Char('f');
1194  GTK_WIDGET_SET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS);
1195  }
1196 
1197  // Some styles such as aero-clone assume they can paint in the spacing area
1198  gtkPainter.setClipRect(option->rect);
1199 
1200  d->gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, NULL);
1201 
1202  QRect checkRect = option->rect.adjusted(spacing, spacing, -spacing, -spacing);
1203 
1204  gtkPainter.paintCheckbox(gtkCheckButton, checkRect, state, shadow, gtkCheckButton->style,
1205  key);
1206  if (option->state & State_HasFocus)
1207  GTK_WIDGET_UNSET_FLAGS(gtkCheckButton, GTK_HAS_FOCUS);
1208 
1209  }
1210  break;
1211 
1212 #ifndef QT_NO_TABBAR
1213 
1214  case PE_FrameTabBarBase:
1215  if (const QStyleOptionTabBarBase *tbb
1216  = qstyleoption_cast<const QStyleOptionTabBarBase *>(option)) {
1217  QRect tabRect = tbb->rect;
1218  painter->save();
1219  painter->setPen(QPen(option->palette.dark().color().dark(110), 0));
1220  switch (tbb->shape) {
1221 
1222  case QTabBar::RoundedNorth:
1223  painter->drawLine(tabRect.topLeft(), tabRect.topRight());
1224  break;
1225 
1226  case QTabBar::RoundedWest:
1227  painter->drawLine(tabRect.left(), tabRect.top(), tabRect.left(), tabRect.bottom());
1228  break;
1229 
1230  case QTabBar::RoundedSouth:
1231  painter->drawLine(tbb->rect.left(), tbb->rect.bottom(),
1232  tabRect.right(), tabRect.bottom());
1233  break;
1234 
1235  case QTabBar::RoundedEast:
1236  painter->drawLine(tabRect.topRight(), tabRect.bottomRight());
1237  break;
1238 
1239  case QTabBar::TriangularNorth:
1240  case QTabBar::TriangularEast:
1241  case QTabBar::TriangularWest:
1242  case QTabBar::TriangularSouth:
1243  painter->restore();
1244  QWindowsStyle::drawPrimitive(element, option, painter, widget);
1245  return;
1246  }
1247 
1248  painter->restore();
1249  }
1250  return;
1251 
1252 #endif // QT_NO_TABBAR
1253 
1254  case PE_Widget:
1255  break;
1256 
1257  default:
1258  QCleanlooksStyle::drawPrimitive(element, option, painter, widget);
1259  }
1260 }
QString::number
static QString number(int, int base=10)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: qstring.cpp:6448
QPainter
The QPainter class performs low-level painting on widgets and other paint devices.
Definition: qpainter.h:86
QColor
The QColor class provides colors based on RGB, HSV or CMYK values.
Definition: qcolor.h:67
d
double d
Definition: qnumeric_p.h:62
pmKey
static int pmKey(const QSize &size, QIcon::Mode mode, QIcon::State state)
Definition: qsvgiconengine.cpp:90
QLatin1Literal
The QLatin1Literal class provides a thin wrapper around string literals used in source code...
Definition: qstringbuilder.h:63
QRect::adjusted
QRect adjusted(int x1, int y1, int x2, int y2) const
Returns a new rectangle with dx1, dy1, dx2 and dy2 added respectively to the existing coordinates of ...
Definition: qrect.h:431
QPalette::base
const QBrush & base() const
Returns the base brush of the current color group.
Definition: qpalette.h:130
type
int type
Definition: qmetatype.cpp:239
qMin
Q_DECL_CONSTEXPR const T & qMin(const T &a, const T &b)
Definition: qglobal.h:1215
QBrush::color
const QColor & color() const
Returns the brush color.
Definition: qbrush.h:183
QPalette::dark
const QBrush & dark() const
Returns the dark brush of the current color group.
Definition: qpalette.h:127
QGtkStylePrivate::gtk_widget_set_direction
static Ptr_gtk_widget_set_direction gtk_widget_set_direction
Definition: qgtkstyle_p.h:432
QStyleOption::state
QStyle::State state
the style flags that are used when drawing the control
Definition: qstyleoption.h:88
QStyleOptionHeader
The QStyleOptionHeader class is used to describe the parameters for drawing a header.
Definition: qstyleoption.h:251
QPalette::background
const QBrush & background() const
Use window() instead.
Definition: qpalette.h:134
QStyle::pixelMetric
virtual int pixelMetric(PixelMetric metric, const QStyleOption *option=0, const QWidget *widget=0) const =0
Returns the value of the given pixel metric.
reverse
static C reverse(const C &l)
Definition: qdatetimeedit.cpp:928
QPainter::setClipRect
void setClipRect(const QRectF &, Qt::ClipOperation op=Qt::ReplaceClip)
Enables clipping, and sets the clip region to the given rectangle using the given clip operation...
Definition: qpainter.cpp:2801
QPointF
The QPointF class defines a point in the plane using floating point precision.
Definition: qpoint.h:214
QPainter::restore
void restore()
Restores the current painter state (pops a saved state off the stack).
Definition: qpainter.cpp:1620
QStyleOptionViewItemV4
The QStyleOptionViewItemV4 class is used to describe the parameters necessary for drawing a frame in ...
Definition: qstyleoption.h:609
QRect::left
int left() const
Returns the x-coordinate of the rectangle&#39;s left edge.
Definition: qrect.h:240
QRect::width
int width() const
Returns the width of the rectangle.
Definition: qrect.h:303
QPainter::drawLine
void drawLine(const QLineF &line)
Draws a line defined by line.
Definition: qpainter.h:573
QRect::height
int height() const
Returns the height of the rectangle.
Definition: qrect.h:306
QRect::bottom
int bottom() const
Returns the y-coordinate of the rectangle&#39;s bottom edge.
Definition: qrect.h:249
QString
The QString class provides a Unicode character string.
Definition: qstring.h:83
QWindowsStyle::drawPrimitive
void drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const
Reimplemented Function
Definition: qwindowsstyle.cpp:1253
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QPen
The QPen class defines how a QPainter should draw lines and outlines of shapes.
Definition: qpen.h:64
QPainter::setBrushOrigin
void setBrushOrigin(int x, int y)
Sets the brush&#39;s origin to point (x, y).
Definition: qpainter.h:825
fromQColor
static GdkColor fromQColor(const QColor &color)
Definition: qgtkstyle.cpp:159
QPainter::save
void save()
Saves the current painter state (pushes the state onto a stack).
Definition: qpainter.cpp:1590
QPixmapCache::find
static QPixmap * find(const QString &key)
Definition: qpixmapcache.cpp:493
QColor::darker
QColor darker(int f=200) const
Returns a darker (or lighter) color, but does not change this object.
Definition: qcolor.h:301
QTabBar::Shape
Shape
This enum type lists the built-in shapes supported by QTabBar.
Definition: qtabbar.h:81
QRect::bottomRight
QPoint bottomRight() const
Returns the position of the rectangle&#39;s bottom-right corner.
Definition: qrect.h:291
QPainter::brushOrigin
QPoint brushOrigin() const
Returns the currently set brush origin.
Definition: qpainter.cpp:2168
QStyleOption
The QStyleOption class stores the parameters used by QStyle functions.
Definition: qstyleoption.h:67
QWidget::testAttribute
bool testAttribute(Qt::WidgetAttribute) const
Returns true if attribute attribute is set on this widget; otherwise returns false.
Definition: qwidget.h:1041
QLS
#define QLS(x)
Definition: qgtkstyle_p.h:77
QColor::dark
QColor dark(int f=200) const
Use darker(factor) instead.
Definition: qcolor.cpp:2447
QRect::adjust
void adjust(int x1, int y1, int x2, int y2)
Adds dx1, dy1, dx2 and dy2 respectively to the existing coordinates of the rectangle.
Definition: qrect.h:434
QStyle::drawPrimitive
virtual void drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const =0
Draws the given primitive element with the provided painter using the style options specified by opti...
QImage
The QImage class provides a hardware-independent image representation that allows direct access to th...
Definition: qimage.h:87
QStyleOptionFrame
The QStyleOptionFrame class is used to describe the parameters for drawing a frame.
Definition: qstyleoption.h:118
uint
unsigned int uint
Definition: qglobal.h:996
FALSE
#define FALSE
Synonym for false.
Definition: qglobal.h:1019
QStyleOptionTabWidgetFrame
The QStyleOptionTabWidgetFrame class is used to describe the parameters for drawing the frame around ...
Definition: qstyleoption.h:175
QStyleOptionTabBarBase
The QStyleOptionTabBarBase class is used to describe the base of a tab bar, i.e.
Definition: qstyleoption.h:218
QCommonStyle::drawPrimitive
void drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const
Reimplemented Function
Definition: qcommonstyle.cpp:143
QObject::inherits
bool inherits(const char *classname) const
Returns true if this object is an instance of a class that inherits className or a QObject subclass t...
Definition: qobject.h:275
QWidget::isEnabled
bool isEnabled() const
Definition: qwidget.h:948
QRect::moveCenter
void moveCenter(const QPoint &p)
Moves the rectangle, leaving the center point at the given position.
Definition: qrect.cpp:840
TRUE
#define TRUE
Synonym for true.
Definition: qglobal.h:1018
QRect::topRight
QPoint topRight() const
Returns the position of the rectangle&#39;s top-right corner.
Definition: qrect.h:294
QStyleOption::palette
QPalette palette
the palette that should be used when painting the control
Definition: qstyleoption.h:92
QRect::center
QPoint center() const
Returns the center point of the rectangle.
Definition: qrect.h:300
QAbstractItemView
The QAbstractItemView class provides the basic functionality for item view classes.
Definition: qabstractitemview.h:63
QRect::top
int top() const
Returns the y-coordinate of the rectangle&#39;s top edge.
Definition: qrect.h:243
QRect::right
int right() const
Returns the x-coordinate of the rectangle&#39;s right edge.
Definition: qrect.h:246
QPixmapCache::insert
static bool insert(const QString &key, const QPixmap &pixmap)
Inserts a copy of the pixmap pixmap associated with the key into the cache.
Definition: qpixmapcache.cpp:569
key
int key
Definition: qkeysequence.cpp:395
QPoint
The QPoint class defines a point in the plane using integer precision.
Definition: qpoint.h:53
QPainter::setPen
void setPen(const QColor &color)
Sets the painter&#39;s pen to have style Qt::SolidLine, width 0 and the specified color.
Definition: qpainter.cpp:4047
QStyleOption::direction
Qt::LayoutDirection direction
the text layout direction that should be used when drawing text in the control
Definition: qstyleoption.h:89
if
if(void) toggleToolbarShown
Definition: qcocoasharedwindowmethods_mac_p.h:220
QRect
The QRect class defines a rectangle in the plane using integer precision.
Definition: qrect.h:58
isTool
bool isTool
Definition: qcocoasharedwindowmethods_mac_p.h:109
QStyle::proxy
const QStyle * proxy() const
Definition: qstyle.cpp:2546
QPixmap
The QPixmap class is an off-screen image representation that can be used as a paint device...
Definition: qpixmap.h:71
QPainter::drawPixmap
void drawPixmap(const QRectF &targetRect, const QPixmap &pixmap, const QRectF &sourceRect)
Draws the rectangular portion source of the given pixmap into the given target in the paint device...
Definition: qpainter.cpp:5619
QSize
The QSize class defines the size of a two-dimensional object using integer point precision.
Definition: qsize.h:53
QPalette::buttonText
const QBrush & buttonText() const
Returns the button text foreground brush of the current color group.
Definition: qpalette.h:138
QColor::rgba
QRgb rgba() const
Returns the RGB value of the color, including its alpha.
Definition: qcolor.cpp:1019
QCleanlooksStyle::drawPrimitive
void drawPrimitive(PrimitiveElement elem, const QStyleOption *option, QPainter *painter, const QWidget *widget=0) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:683
QRect::translate
void translate(int dx, int dy)
Moves the rectangle dx along the x axis and dy along the y axis, relative to the current position...
Definition: qrect.h:312
QStyleOptionButton
The QStyleOptionButton class is used to describe the parameters for drawing buttons.
Definition: qstyleoption.h:279
QPalette::window
const QBrush & window() const
Returns the window (general background) brush of the current color group.
Definition: qpalette.h:135
QStyleOptionTabWidgetFrameV2
The QStyleOptionTabWidgetFrameV2 class is used to describe the parameters for drawing the frame aroun...
Definition: qstyleoption.h:196
QLatin1Char
The QLatin1Char class provides an 8-bit ASCII/Latin-1 character.
Definition: qchar.h:55
QStyleOption::rect
QRect rect
the area that should be used for various calculations and painting
Definition: qstyleoption.h:90
QPainter::fillRect
void fillRect(const QRectF &, const QBrush &)
Fills the given rectangle with the brush specified.
Definition: qpainter.cpp:7420
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61
QPalette::resolve
QPalette resolve(const QPalette &) const
Returns a new QPalette that has attributes copied from other.
Definition: qpalette.cpp:1101
QRect::topLeft
QPoint topLeft() const
Returns the position of the rectangle&#39;s top-left corner.
Definition: qrect.h:288

◆ generatedIconPixmap()

QPixmap QGtkStyle::generatedIconPixmap ( QIcon::Mode  iconMode,
const QPixmap &  pixmap,
const QStyleOption *  opt 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 3553 of file qgtkstyle.cpp.

3555 {
3556  return QCleanlooksStyle::generatedIconPixmap(iconMode, pixmap, opt);
3557 }
QCleanlooksStyle::generatedIconPixmap
QPixmap generatedIconPixmap(QIcon::Mode iconMode, const QPixmap &pixmap, const QStyleOption *opt) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:4289

◆ getGConfBool()

bool QGtkStyle::getGConfBool ( const QString &  key,
bool  fallback = 0 
)
static

Returns the configuration boolean for key.

Returns fallback if key is not found.

Definition at line 144 of file qgtkstyle.cpp.

145 {
146  return QGtkStylePrivate::getGConfBool(key, fallback);
147 }
QGtkStylePrivate::getGConfBool
static bool getGConfBool(const QString &key, bool fallback=0)
Definition: qgtkstyle_p.cpp:634
fallback
static QMenuBar * fallback
Definition: qmenu_mac.mm:1617

◆ getGConfString()

QString QGtkStyle::getGConfString ( const QString &  value,
const QString &  fallback = QString() 
)
static

Returns the configuration string for value.

Returns fallback if value is not found.

Definition at line 135 of file qgtkstyle.cpp.

136 {
137  return QGtkStylePrivate::getGConfString(value, fallback);
138 }
QGtkStylePrivate::getGConfString
static QString getGConfString(const QString &key, const QString &fallback=QString())
Definition: qgtkstyle_p.cpp:615

◆ hitTestComplexControl()

QStyle::SubControl QGtkStyle::hitTestComplexControl ( ComplexControl  cc,
const QStyleOptionComplex *  opt,
const QPoint &  pt,
const QWidget *  w 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 3544 of file qgtkstyle.cpp.

3546 {
3547  return QCleanlooksStyle::hitTestComplexControl(cc, opt, pt, w);
3548 }
QCleanlooksStyle::hitTestComplexControl
SubControl hitTestComplexControl(ComplexControl cc, const QStyleOptionComplex *opt, const QPoint &pt, const QWidget *w=0) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:4280

◆ itemPixmapRect()

QRect QGtkStyle::itemPixmapRect ( const QRect &  r,
int  flags,
const QPixmap &  pixmap 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 3527 of file qgtkstyle.cpp.

3528 {
3529  return QCleanlooksStyle::itemPixmapRect(r, flags, pixmap);
3530 }
QCleanlooksStyle::itemPixmapRect
QRect itemPixmapRect(const QRect &r, int flags, const QPixmap &pixmap) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:4263

◆ pixelMetric()

int QGtkStyle::pixelMetric ( PixelMetric  metric,
const QStyleOption *  option = 0,
const QWidget *  widget = 0 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 408 of file qgtkstyle.cpp.

Referenced by drawControl().

411 {
412  Q_D(const QGtkStyle);
413 
414  if (!d->isThemeAvailable())
415  return QCleanlooksStyle::pixelMetric(metric, option, widget);
416 
417  switch (metric) {
418  case PM_DefaultFrameWidth:
419  if (qobject_cast<const QFrame*>(widget)) {
420  if (GtkStyle *style =
421  d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(),
422  "*.GtkScrolledWindow",
423  "*.GtkScrolledWindow",
424  d->gtk_window_get_type()))
425  return qMax(style->xthickness, style->ythickness);
426  }
427  return 2;
428 
429  case PM_MenuButtonIndicator:
430  return 20;
431 
432  case PM_TabBarBaseOverlap:
433  return 1;
434 
435  case PM_ToolBarSeparatorExtent:
436  return 11;
437 
438  case PM_ToolBarFrameWidth:
439  return 1;
440 
441  case PM_ToolBarItemSpacing:
442  return 0;
443 
444  case PM_ButtonShiftHorizontal: {
445  GtkWidget *gtkButton = d->gtkWidget("GtkButton");
446  guint horizontal_shift;
447  d->gtk_widget_style_get(gtkButton, "child-displacement-x", &horizontal_shift, NULL);
448  return horizontal_shift;
449  }
450 
451  case PM_ButtonShiftVertical: {
452  GtkWidget *gtkButton = d->gtkWidget("GtkButton");
453  guint vertical_shift;
454  d->gtk_widget_style_get(gtkButton, "child-displacement-y", &vertical_shift, NULL);
455  return vertical_shift;
456  }
457 
458  case PM_MenuBarPanelWidth:
459  return 0;
460 
461  case PM_MenuPanelWidth: {
462  GtkWidget *gtkMenu = d->gtkWidget("GtkMenu");
463  guint horizontal_padding = 0;
464  // horizontal-padding is used by Maemo to get thicker borders
465  if (!d->gtk_check_version(2, 10, 0))
466  d->gtk_widget_style_get(gtkMenu, "horizontal-padding", &horizontal_padding, NULL);
467  int padding = qMax<int>(gtkMenu->style->xthickness, horizontal_padding);
468  return padding;
469  }
470 
471  case PM_ButtonIconSize: {
472  int retVal = 24;
473  GtkSettings *settings = d->gtk_settings_get_default();
474  gchararray icon_sizes;
475  g_object_get(settings, "gtk-icon-sizes", &icon_sizes, NULL);
476  QStringList values = QString(QLS(icon_sizes)).split(QLatin1Char(':'));
477  g_free(icon_sizes);
478  QChar splitChar(QLatin1Char(','));
479  foreach (const QString &value, values) {
480  if (value.startsWith(QLS("gtk-button="))) {
481  QString iconSize = value.right(value.size() - 11);
482 
483  if (iconSize.contains(splitChar))
484  retVal = iconSize.split(splitChar)[0].toInt();
485  break;
486  }
487  }
488  return retVal;
489  }
490 
491  case PM_MenuVMargin:
492 
493  case PM_MenuHMargin:
494  return 0;
495 
496  case PM_DockWidgetTitleMargin:
497  return 0;
498 
499  case PM_DockWidgetTitleBarButtonMargin:
500  return 5;
501 
502  case PM_TabBarTabVSpace:
503  return 12;
504 
505  case PM_TabBarTabHSpace:
506  return 14;
507 
508  case PM_TabBarTabShiftVertical:
509  return 2;
510 
511  case PM_ToolBarHandleExtent:
512  return 9;
513 
514  case PM_SplitterWidth:
515  return 6;
516 
517  case PM_SliderThickness:
518  case PM_SliderControlThickness: {
519  GtkWidget *gtkScale = d->gtkWidget("GtkHScale");
520  gint val;
521  d->gtk_widget_style_get(gtkScale, "slider-width", &val, NULL);
522  if (metric == PM_SliderControlThickness)
523  return val + 2*gtkScale->style->ythickness;
524  return val;
525  }
526 
527  case PM_ScrollBarExtent: {
528  gint sliderLength;
529  gint trough_border;
530  GtkWidget *hScrollbar = d->gtkWidget("GtkHScrollbar");
531  d->gtk_widget_style_get(hScrollbar,
532  "trough-border", &trough_border,
533  "slider-width", &sliderLength,
534  NULL);
535  return sliderLength + trough_border*2;
536  }
537 
538  case PM_ScrollBarSliderMin:
539  return 34;
540 
541  case PM_SliderLength:
542  gint val;
543  d->gtk_widget_style_get(d->gtkWidget("GtkHScale"), "slider-length", &val, NULL);
544  return val;
545 
546  case PM_ExclusiveIndicatorWidth:
547  case PM_ExclusiveIndicatorHeight:
548  case PM_IndicatorWidth:
549  case PM_IndicatorHeight: {
550  GtkWidget *gtkCheckButton = d->gtkWidget("GtkCheckButton");
551  gint size, spacing;
552  d->gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, "indicator-size", &size, NULL);
553  return size + 2 * spacing;
554  }
555 
556  case PM_MenuBarVMargin: {
557  GtkWidget *gtkMenubar = d->gtkWidget("GtkMenuBar");
558  return qMax(0, gtkMenubar->style->ythickness);
559  }
560  case PM_ScrollView_ScrollBarSpacing:
561  {
562  gint spacing = 3;
563  GtkWidget *gtkScrollWindow = d->gtkWidget("GtkScrolledWindow");
564  Q_ASSERT(gtkScrollWindow);
565  d->gtk_widget_style_get(gtkScrollWindow, "scrollbar-spacing", &spacing, NULL);
566  return spacing;
567  }
568  case PM_SubMenuOverlap: {
569  gint offset = 0;
570  GtkWidget *gtkMenu = d->gtkWidget("GtkMenu");
571  d->gtk_widget_style_get(gtkMenu, "horizontal-offset", &offset, NULL);
572  return offset;
573  }
574  default:
575  return QCleanlooksStyle::pixelMetric(metric, option, widget);
576  }
577 }
QString::contains
QBool contains(QChar c, Qt::CaseSensitivity cs=Qt::CaseSensitive) const
Definition: qstring.h:904
d
double d
Definition: qnumeric_p.h:62
QString::startsWith
bool startsWith(const QString &s, Qt::CaseSensitivity cs=Qt::CaseSensitive) const
Returns true if the string starts with s; otherwise returns false.
Definition: qstring.cpp:3734
QString
The QString class provides a Unicode character string.
Definition: qstring.h:83
Q_ASSERT
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72
qMax
Q_DECL_CONSTEXPR const T & qMax(const T &a, const T &b)
Definition: qglobal.h:1217
QString::size
int size() const
Returns the number of characters in this string.
Definition: qstring.h:102
QLS
#define QLS(x)
Definition: qgtkstyle_p.h:77
QStringList
The QStringList class provides a list of strings.
Definition: qstringlist.h:66
QString::right
QString right(int n) const Q_REQUIRED_RESULT
Returns a substring that contains the n rightmost characters of the string.
Definition: qstring.cpp:3682
values
quint16 values[128]
Definition: qsimplecodec.cpp:55
QCleanlooksStyle::pixelMetric
int pixelMetric(PixelMetric metric, const QStyleOption *option=0, const QWidget *widget=0) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:3697
QString::split
QStringList split(const QString &sep, SplitBehavior behavior=KeepEmptyParts, Qt::CaseSensitivity cs=Qt::CaseSensitive) const Q_REQUIRED_RESULT
Splits the string into substrings wherever sep occurs, and returns the list of those strings...
Definition: qstring.cpp:6526
QLatin1Char
The QLatin1Char class provides an 8-bit ASCII/Latin-1 character.
Definition: qchar.h:55
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ polish() [1/3]

void QGtkStyle::polish ( QWidget *  widget)
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 376 of file qgtkstyle.cpp.

377 {
378  Q_D(QGtkStyle);
379 
380  QCleanlooksStyle::polish(widget);
381  if (!d->isThemeAvailable())
382  return;
383  if (qobject_cast<QAbstractButton*>(widget)
384  || qobject_cast<QToolButton*>(widget)
385  || qobject_cast<QComboBox*>(widget)
386  || qobject_cast<QGroupBox*>(widget)
387  || qobject_cast<QScrollBar*>(widget)
388  || qobject_cast<QSlider*>(widget)
389  || qobject_cast<QAbstractSpinBox*>(widget)
390  || qobject_cast<QSpinBox*>(widget)
391  || qobject_cast<QHeaderView*>(widget))
392  widget->setAttribute(Qt::WA_Hover);
393  else if (QTreeView *tree = qobject_cast<QTreeView *> (widget))
394  tree->viewport()->setAttribute(Qt::WA_Hover);
395 }
QCleanlooksStyle::polish
void polish(QWidget *widget)
Reimplemented Function
Definition: qcleanlooksstyle.cpp:3906
d
double d
Definition: qnumeric_p.h:62
widget
QPointer< QWidget > widget
Definition: qapplication_mac.mm:879
QObject::qobject_cast
T * qobject_cast(QObject *object)
Definition: qobject.h:375
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QTreeView
The QTreeView class provides a default model/view implementation of a tree view.
Definition: qtreeview.h:58
QGroupBox
The QGroupBox widget provides a group box frame with a title.
Definition: qgroupbox.h:57
QSlider
The QSlider widget provides a vertical or horizontal slider.
Definition: qslider.h:57
QSpinBox
The QSpinBox class provides a spin box widget.
Definition: qspinbox.h:56
QWidget::setAttribute
void setAttribute(Qt::WidgetAttribute, bool on=true)
Sets the attribute attribute on this widget if on is true; otherwise clears the attribute.
Definition: qwidget.cpp:11087
QToolButton
The QToolButton class provides a quick-access button to commands or options, usually used inside a QT...
Definition: qtoolbutton.h:59
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ polish() [2/3]

void QGtkStyle::polish ( QApplication *  app)
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 330 of file qgtkstyle.cpp.

331 {
332  Q_D(QGtkStyle);
333 
334  QCleanlooksStyle::polish(app);
335  // Custom fonts and palettes with QtConfig are intentionally
336  // not supported as these should be entirely determined by
337  // current Gtk settings
338  if (app->desktopSettingsAware() && d->isThemeAvailable()) {
339  QApplicationPrivate::setSystemPalette(standardPalette());
340  QApplicationPrivate::setSystemFont(d->getThemeFont());
341  d->applyCustomPaletteHash();
342  if (!d->isKDE4Session()) {
343  qt_filedialog_open_filename_hook = &QGtkStylePrivate::openFilename;
344  qt_filedialog_save_filename_hook = &QGtkStylePrivate::saveFilename;
345  qt_filedialog_open_filenames_hook = &QGtkStylePrivate::openFilenames;
346  qt_filedialog_existing_directory_hook = &QGtkStylePrivate::openDirectory;
347  qApp->installEventFilter(&d->filter);
348  }
349  }
350 }
QCleanlooksStyle::polish
void polish(QWidget *widget)
Reimplemented Function
Definition: qcleanlooksstyle.cpp:3906
d
double d
Definition: qnumeric_p.h:62
qt_filedialog_existing_directory_hook
Q_GUI_EXPORT _qt_filedialog_existing_directory_hook qt_filedialog_existing_directory_hook
Definition: qfiledialog.cpp:85
QGtkStylePrivate::saveFilename
static QString saveFilename(QWidget *parent, const QString &caption, const QString &dir, const QString &filter, QString *selectedFilter, QFileDialog::Options options)
Definition: qgtkstyle_p.cpp:1087
qt_filedialog_open_filename_hook
Q_GUI_EXPORT _qt_filedialog_open_filename_hook qt_filedialog_open_filename_hook
Definition: qfiledialog.cpp:88
QGtkStylePrivate::openFilenames
static QStringList openFilenames(QWidget *parent, const QString &caption, const QString &dir, const QString &filter, QString *selectedFilter, QFileDialog::Options options)
Definition: qgtkstyle_p.cpp:1051
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QApplicationPrivate::setSystemFont
static void setSystemFont(const QFont &font)
Definition: qapplication.cpp:2123
QGtkStylePrivate::openFilename
static QString openFilename(QWidget *parent, const QString &caption, const QString &dir, const QString &filter, QString *selectedFilter, QFileDialog::Options options)
Definition: qgtkstyle_p.cpp:988
qApp
#define qApp
Definition: qcoreapplication.h:69
QGtkStyle::standardPalette
QPalette standardPalette() const
Reimplemented Function
Definition: qgtkstyle.cpp:225
qt_filedialog_save_filename_hook
Q_GUI_EXPORT _qt_filedialog_save_filename_hook qt_filedialog_save_filename_hook
Definition: qfiledialog.cpp:94
QApplication::desktopSettingsAware
static bool desktopSettingsAware()
Returns true if Qt is set to use the system&#39;s standard colors, fonts, etc.
Definition: qapplication.cpp:3371
QGtkStylePrivate::openDirectory
static QString openDirectory(QWidget *parent, const QString &caption, const QString &dir, QFileDialog::Options options)
Definition: qgtkstyle_p.cpp:1023
QApplicationPrivate::setSystemPalette
static void setSystemPalette(const QPalette &pal)
Definition: qapplication.cpp:1948
qt_filedialog_open_filenames_hook
Q_GUI_EXPORT _qt_filedialog_open_filenames_hook qt_filedialog_open_filenames_hook
Definition: qfiledialog.cpp:91
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ polish() [3/3]

void QGtkStyle::polish ( QPalette &  palette)
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 314 of file qgtkstyle.cpp.

315 {
316  Q_D(QGtkStyle);
317 
318  // QCleanlooksStyle will alter the palette, hence we do
319  // not want to polish the palette unless we are using it as
320  // the fallback
321  if (!d->isThemeAvailable())
322  QCleanlooksStyle::polish(palette);
323  else
324  palette = palette.resolve(standardPalette());
325 }
QCleanlooksStyle::polish
void polish(QWidget *widget)
Reimplemented Function
Definition: qcleanlooksstyle.cpp:3906
d
double d
Definition: qnumeric_p.h:62
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QGtkStyle::standardPalette
QPalette standardPalette() const
Reimplemented Function
Definition: qgtkstyle.cpp:225
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61
QPalette::resolve
QPalette resolve(const QPalette &) const
Returns a new QPalette that has attributes copied from other.
Definition: qpalette.cpp:1101

◆ sizeFromContents()

QSize QGtkStyle::sizeFromContents ( ContentsType  type,
const QStyleOption *  option,
const QSize &  size,
const QWidget *  widget 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 3247 of file qgtkstyle.cpp.

3249 {
3250  Q_D(const QGtkStyle);
3251 
3252  QSize newSize = QCleanlooksStyle::sizeFromContents(type, option, size, widget);
3253  if (!d->isThemeAvailable())
3254  return newSize;
3255 
3256  switch (type) {
3257 
3258  case CT_ToolButton:
3259  if (const QStyleOptionToolButton *toolbutton = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {
3260  GtkWidget *gtkButton = d->gtkWidget("GtkToolButton.GtkButton");
3261  newSize = size + QSize(2 * gtkButton->style->xthickness, 2 + 2 * gtkButton->style->ythickness);
3262  if (widget && qobject_cast<QToolBar *>(widget->parentWidget())) {
3263  QSize minSize(0, 25);
3264  if (toolbutton->toolButtonStyle != Qt::ToolButtonTextOnly)
3265  minSize = toolbutton->iconSize + QSize(12, 12);
3266  newSize = newSize.expandedTo(minSize);
3267  }
3268 
3269  if (toolbutton->features & QStyleOptionToolButton::HasMenu)
3270  newSize += QSize(6, 0);
3271  }
3272  break;
3273  case CT_MenuItem:
3274  if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
3275  int textMargin = 8;
3276 
3277  if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) {
3278  GtkWidget *gtkMenuSeparator = d->gtkWidget("GtkMenu.GtkSeparatorMenuItem");
3279  GtkRequisition sizeReq = {0, 0};
3280  d->gtk_widget_size_request(gtkMenuSeparator, &sizeReq);
3281  newSize = QSize(size.width(), sizeReq.height);
3282  break;
3283  }
3284 
3285  GtkWidget *gtkMenuItem = d->gtkWidget("GtkMenu.GtkCheckMenuItem");
3286  GtkStyle* style = gtkMenuItem->style;
3287 
3288  // Note we get the perfect height for the default font since we
3289  // set a fake text label on the gtkMenuItem
3290  // But if custom fonts are used on the widget we need a minimum size
3291  GtkRequisition sizeReq = {0, 0};
3292  d->gtk_widget_size_request(gtkMenuItem, &sizeReq);
3293  newSize.setHeight(qMax(newSize.height() - 4, sizeReq.height));
3294  newSize += QSize(textMargin + style->xthickness - 1, 0);
3295 
3296  // Cleanlooks assumes a check column of 20 pixels so we need to
3297  // expand it a bit
3298  gint checkSize;
3299  d->gtk_widget_style_get(gtkMenuItem, "indicator-size", &checkSize, NULL);
3300  newSize.setWidth(newSize.width() + qMax(0, checkSize - 20));
3301  }
3302 
3303  break;
3304 
3305  case CT_SpinBox:
3306  // QSpinBox does some nasty things that depends on CT_LineEdit
3307  newSize = size + QSize(0, -d->gtkWidget("GtkSpinButton")->style->ythickness * 2);
3308  break;
3309 
3310  case CT_PushButton:
3311  if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
3312  GtkWidget *gtkButton = d->gtkWidget("GtkButton");
3313  gint focusPadding, focusWidth;
3314  d->gtk_widget_style_get(gtkButton, "focus-padding", &focusPadding, NULL);
3315  d->gtk_widget_style_get(gtkButton, "focus-line-width", &focusWidth, NULL);
3316  newSize = size;
3317  newSize += QSize(2*gtkButton->style->xthickness + 4, 2*gtkButton->style->ythickness);
3318  newSize += QSize(2*(focusWidth + focusPadding + 2), 2*(focusWidth + focusPadding));
3319 
3320  GtkWidget *gtkButtonBox = d->gtkWidget("GtkHButtonBox");
3321  gint minWidth = 85, minHeight = 0;
3322  d->gtk_widget_style_get(gtkButtonBox, "child-min-width", &minWidth,
3323  "child-min-height", &minHeight, NULL);
3324  if (!btn->text.isEmpty() && newSize.width() < minWidth)
3325  newSize.setWidth(minWidth);
3326  if (newSize.height() < minHeight)
3327  newSize.setHeight(minHeight);
3328  }
3329 
3330  break;
3331 
3332  case CT_Slider: {
3333  GtkWidget *gtkSlider = d->gtkWidget("GtkHScale");
3334  newSize = size + QSize(2*gtkSlider->style->xthickness, 2*gtkSlider->style->ythickness);
3335  }
3336  break;
3337 
3338  case CT_LineEdit: {
3339  GtkWidget *gtkEntry = d->gtkWidget("GtkEntry");
3340  newSize = size + QSize(2*gtkEntry->style->xthickness, 2 + 2*gtkEntry->style->ythickness);
3341  }
3342  break;
3343 
3344  case CT_ItemViewItem:
3345  newSize += QSize(0, 2);
3346  break;
3347 
3348  case CT_ComboBox:
3349  if (const QStyleOptionComboBox *combo = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
3350  GtkWidget *gtkCombo = d->gtkWidget("GtkComboBox");
3351  QRect arrowButtonRect = proxy()->subControlRect(CC_ComboBox, combo, SC_ComboBoxArrow, widget);
3352  newSize = size + QSize(12 + arrowButtonRect.width() + 2*gtkCombo->style->xthickness, 4 + 2*gtkCombo->style->ythickness);
3353 
3354  if (!(widget && qobject_cast<QToolBar *>(widget->parentWidget())))
3355  newSize += QSize(0, 2);
3356  }
3357  break;
3358 
3359  case CT_GroupBox:
3360  newSize += QSize(4, groupBoxBottomMargin + groupBoxTopMargin + groupBoxTitleMargin); // Add some space below the groupbox
3361  break;
3362 
3363  case CT_TabBarTab:
3364  if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {
3365  if (!tab->icon.isNull())
3366  newSize += QSize(6, 0);
3367  }
3368  newSize += QSize(1, 1);
3369  break;
3370 
3371  default:
3372  break;
3373  }
3374 
3375  return newSize;
3376 }
d
double d
Definition: qnumeric_p.h:62
QWidget::parentWidget
QWidget * parentWidget() const
Returns the parent of this widget, or 0 if it does not have any parent widget.
Definition: qwidget.h:1035
type
int type
Definition: qmetatype.cpp:239
QStyleOptionMenuItem
The QStyleOptionMenuItem class is used to describe the parameter necessary for drawing a menu item...
Definition: qstyleoption.h:435
groupBoxTitleMargin
static const int groupBoxTitleMargin
Definition: qgtkstyle.cpp:128
QStyle::subControlRect
virtual QRect subControlRect(ComplexControl cc, const QStyleOptionComplex *opt, SubControl sc, const QWidget *widget=0) const =0
Returns the rectangle containing the specified subControl of the given complex control (with the styl...
QSize::expandedTo
QSize expandedTo(const QSize &) const
Returns a size holding the maximum width and height of this size and the given otherSize.
Definition: qsize.h:187
QRect::width
int width() const
Returns the width of the rectangle.
Definition: qrect.h:303
QSize::setHeight
void setHeight(int h)
Sets the height to the given height.
Definition: qsize.h:135
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QCleanlooksStyle::sizeFromContents
QSize sizeFromContents(ContentsType type, const QStyleOption *option, const QSize &size, const QWidget *widget) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:3797
QStyleOptionToolButton
The QStyleOptionToolButton class is used to describe the parameters for drawing a tool button...
Definition: qstyleoption.h:768
qMax
Q_DECL_CONSTEXPR const T & qMax(const T &a, const T &b)
Definition: qglobal.h:1217
QSize::setWidth
void setWidth(int w)
Sets the width to the given width.
Definition: qsize.h:132
groupBoxTopMargin
static const int groupBoxTopMargin
Definition: qgtkstyle.cpp:129
QSize::width
int width() const
Returns the width.
Definition: qsize.h:126
groupBoxBottomMargin
static const int groupBoxBottomMargin
Definition: qgtkstyle.cpp:127
QStyleOptionComboBox
The QStyleOptionComboBox class is used to describe the parameter for drawing a combobox.
Definition: qstyleoption.h:796
QSize::height
int height() const
Returns the height.
Definition: qsize.h:129
QRect
The QRect class defines a rectangle in the plane using integer precision.
Definition: qrect.h:58
QStyle::proxy
const QStyle * proxy() const
Definition: qstyle.cpp:2546
QStyleOptionTab
The QStyleOptionTab class is used to describe the parameters for drawing a tab bar.
Definition: qstyleoption.h:304
QSize
The QSize class defines the size of a two-dimensional object using integer point precision.
Definition: qsize.h:53
QStyleOptionButton
The QStyleOptionButton class is used to describe the parameters for drawing buttons.
Definition: qstyleoption.h:279
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ standardIconImplementation

QIcon QGtkStyle::standardIconImplementation ( StandardPixmap  standardIcon,
const QStyleOption *  option,
const QWidget *  widget = 0 
) const
protectedslot
Warning
This function is not part of the public interface.

Definition at line 3448 of file qgtkstyle.cpp.

3451 {
3452  Q_D(const QGtkStyle);
3453 
3454  if (!d->isThemeAvailable())
3455  return QCleanlooksStyle::standardIconImplementation(standardIcon, option, widget);
3456  switch (standardIcon) {
3457  case SP_DialogDiscardButton:
3458  return QGtkPainter::getIcon(GTK_STOCK_DELETE);
3459  case SP_DialogOkButton:
3460  return QGtkPainter::getIcon(GTK_STOCK_OK);
3461  case SP_DialogCancelButton:
3462  return QGtkPainter::getIcon(GTK_STOCK_CANCEL);
3463  case SP_DialogYesButton:
3464  return QGtkPainter::getIcon(GTK_STOCK_YES);
3465  case SP_DialogNoButton:
3466  return QGtkPainter::getIcon(GTK_STOCK_NO);
3467  case SP_DialogOpenButton:
3468  return QGtkPainter::getIcon(GTK_STOCK_OPEN);
3469  case SP_DialogCloseButton:
3470  return QGtkPainter::getIcon(GTK_STOCK_CLOSE);
3471  case SP_DialogApplyButton:
3472  return QGtkPainter::getIcon(GTK_STOCK_APPLY);
3473  case SP_DialogSaveButton:
3474  return QGtkPainter::getIcon(GTK_STOCK_SAVE);
3475  case SP_MessageBoxWarning:
3476  return QGtkPainter::getIcon(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
3477  case SP_MessageBoxQuestion:
3478  return QGtkPainter::getIcon(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG);
3479  case SP_MessageBoxInformation:
3480  return QGtkPainter::getIcon(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
3481  case SP_MessageBoxCritical:
3482  return QGtkPainter::getIcon(GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG);
3483  default:
3484  return QCleanlooksStyle::standardIconImplementation(standardIcon, option, widget);
3485  }
3486 }
d
double d
Definition: qnumeric_p.h:62
QCleanlooksStyle::standardIconImplementation
QIcon standardIconImplementation(StandardPixmap standardIcon, const QStyleOption *option, const QWidget *widget=0) const
Definition: qcleanlooksstyle.cpp:4421
QGtkPainter::getIcon
static QPixmap getIcon(const char *iconName, GtkIconSize size=GTK_ICON_SIZE_BUTTON)
Definition: qgtkpainter.cpp:191
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QStyle::standardIcon
QIcon standardIcon(StandardPixmap standardIcon, const QStyleOption *option=0, const QWidget *widget=0) const
Returns an icon for the given standardIcon.
Definition: qstyle.cpp:2327
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ standardPalette()

QPalette QGtkStyle::standardPalette ( ) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 225 of file qgtkstyle.cpp.

Referenced by polish().

226 {
227  Q_D(const QGtkStyle);
228 
229  QPalette palette = QCleanlooksStyle::standardPalette();
230  if (d->isThemeAvailable()) {
231  GtkStyle *style = d->gtkStyle();
232  GtkWidget *gtkButton = d->gtkWidget("GtkButton");
233  GtkWidget *gtkEntry = d->getTextColorWidget();
234  GdkColor gdkBg, gdkBase, gdkText, gdkForeground, gdkSbg, gdkSfg, gdkaSbg, gdkaSfg;
235  QColor bg, base, text, fg, highlight, highlightText, inactiveHighlight, inactiveHighlightedTExt;
236  gdkBg = style->bg[GTK_STATE_NORMAL];
237  gdkForeground = gtkButton->style->fg[GTK_STATE_NORMAL];
238 
239  // Our base and selected color is primarily used for text
240  // so we assume a gtkEntry will have the most correct value
241  gdkBase = gtkEntry->style->base[GTK_STATE_NORMAL];
242  gdkText = gtkEntry->style->text[GTK_STATE_NORMAL];
243  gdkSbg = gtkEntry->style->base[GTK_STATE_SELECTED];
244  gdkSfg = gtkEntry->style->text[GTK_STATE_SELECTED];
245 
246  // The ACTIVE base color is really used for inactive windows
247  gdkaSbg = gtkEntry->style->base[GTK_STATE_ACTIVE];
248  gdkaSfg = gtkEntry->style->text[GTK_STATE_ACTIVE];
249 
250  bg = QColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
251  text = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
252  fg = QColor(gdkForeground.red>>8, gdkForeground.green>>8, gdkForeground.blue>>8);
253  base = QColor(gdkBase.red>>8, gdkBase.green>>8, gdkBase.blue>>8);
254  highlight = QColor(gdkSbg.red>>8, gdkSbg.green>>8, gdkSbg.blue>>8);
255  highlightText = QColor(gdkSfg.red>>8, gdkSfg.green>>8, gdkSfg.blue>>8);
256  inactiveHighlight = QColor(gdkaSbg.red>>8, gdkaSbg.green>>8, gdkaSbg.blue>>8);
257  inactiveHighlightedTExt = QColor(gdkaSfg.red>>8, gdkaSfg.green>>8, gdkaSfg.blue>>8);
258 
259  palette.setColor(QPalette::HighlightedText, highlightText);
260 
261 
262  palette.setColor(QPalette::Light, bg.lighter(125));
263  palette.setColor(QPalette::Shadow, bg.darker(130));
264  palette.setColor(QPalette::Dark, bg.darker(120));
265  palette.setColor(QPalette::Text, text);
266  palette.setColor(QPalette::WindowText, fg);
267  palette.setColor(QPalette::ButtonText, fg);
268  palette.setColor(QPalette::Base, base);
269 
270  QColor alternateRowColor = palette.base().color().lighter(93); // ref gtkstyle.c draw_flat_box
271  GtkWidget *gtkTreeView = d->gtkWidget("GtkTreeView");
272  GdkColor *gtkAltBase = NULL;
273  d->gtk_widget_style_get(gtkTreeView, "odd-row-color", &gtkAltBase, NULL);
274  if (gtkAltBase) {
275  alternateRowColor = QColor(gtkAltBase->red>>8, gtkAltBase->green>>8, gtkAltBase->blue>>8);
276  d->gdk_color_free(gtkAltBase);
277  }
278  palette.setColor(QPalette::AlternateBase, alternateRowColor);
279 
280  palette.setColor(QPalette::Window, bg);
281  palette.setColor(QPalette::Button, bg);
282  palette.setColor(QPalette::Background, bg);
283  QColor disabled((fg.red() + bg.red()) / 2,
284  (fg.green() + bg.green())/ 2,
285  (fg.blue() + bg.blue()) / 2);
286  palette.setColor(QPalette::Disabled, QPalette::Text, disabled);
287  palette.setColor(QPalette::Disabled, QPalette::WindowText, disabled);
288  palette.setColor(QPalette::Disabled, QPalette::Foreground, disabled);
289  palette.setColor(QPalette::Disabled, QPalette::ButtonText, disabled);
290  palette.setColor(QPalette::Highlight, highlight);
291  // calculate disabled colors by removing saturation
292  highlight.setHsv(highlight.hue(), 0, highlight.value(), highlight.alpha());
293  highlightText.setHsv(highlightText.hue(), 0, highlightText.value(), highlightText.alpha());
294  palette.setColor(QPalette::Disabled, QPalette::Highlight, highlight);
295  palette.setColor(QPalette::Disabled, QPalette::HighlightedText, highlightText);
296 
297  palette.setColor(QPalette::Inactive, QPalette::HighlightedText, inactiveHighlightedTExt);
298  palette.setColor(QPalette::Inactive, QPalette::Highlight, inactiveHighlight);
299 
300  style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(), "gtk-tooltips", "GtkWindow",
301  d->gtk_window_get_type());
302  if (style) {
303  gdkText = style->fg[GTK_STATE_NORMAL];
304  text = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
305  palette.setColor(QPalette::ToolTipText, text);
306  }
307  }
308  return palette;
309 }
QColor
The QColor class provides colors based on RGB, HSV or CMYK values.
Definition: qcolor.h:67
d
double d
Definition: qnumeric_p.h:62
QPalette::base
const QBrush & base() const
Returns the base brush of the current color group.
Definition: qpalette.h:130
disabled
#define disabled
QBrush::color
const QColor & color() const
Returns the brush color.
Definition: qbrush.h:183
QColor::hue
ushort hue
Returns the hue color component of this color.
Definition: qcolor.h:250
QColor::red
ushort red
Returns the red color component of this color.
Definition: qcolor.h:243
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
base
static const uint base
Definition: qurl.cpp:268
QColor::setHsv
void setHsv(int h, int s, int v, int a=255)
Sets a HSV color value; h is the hue, s is the saturation, v is the value and a is the alpha componen...
Definition: qcolor.cpp:734
QColor::darker
QColor darker(int f=200) const
Returns a darker (or lighter) color, but does not change this object.
Definition: qcolor.h:301
QColor::value
ushort value
Returns the value color component of this color.
Definition: qcolor.h:252
QColor::blue
ushort blue
Returns the blue color component of this color.
Definition: qcolor.h:245
QColor::alpha
ushort alpha
Returns the alpha color component of this color.
Definition: qcolor.h:242
QCleanlooksStyle::standardPalette
QPalette standardPalette() const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:2374
QPalette::setColor
void setColor(ColorGroup cg, ColorRole cr, const QColor &color)
Sets the color in the specified color group, used for the given color role, to the specified solid co...
Definition: qpalette.h:201
QColor::lighter
QColor lighter(int f=150) const
Returns a lighter (or darker) color, but does not change this object.
Definition: qcolor.h:298
QColor::green
ushort green
Returns the green color component of this color.
Definition: qcolor.h:244
text
#define text
Definition: qobjectdefs.h:80
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61
QPalette
The QPalette class contains color groups for each widget state.
Definition: qpalette.h:61

◆ standardPixmap()

QPixmap QGtkStyle::standardPixmap ( StandardPixmap  sp,
const QStyleOption *  option,
const QWidget *  widget 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 3380 of file qgtkstyle.cpp.

3382 {
3383  Q_D(const QGtkStyle);
3384 
3385  if (!d->isThemeAvailable())
3386  return QCleanlooksStyle::standardPixmap(sp, option, widget);
3387 
3388  QPixmap pixmap;
3389  switch (sp) {
3390 
3391  case SP_TitleBarNormalButton: {
3392  QImage restoreButton((const char **)dock_widget_restore_xpm);
3393  QColor alphaCorner = restoreButton.color(2);
3394  alphaCorner.setAlpha(80);
3395  restoreButton.setColor(2, alphaCorner.rgba());
3396  alphaCorner.setAlpha(180);
3397  restoreButton.setColor(4, alphaCorner.rgba());
3398  return QPixmap::fromImage(restoreButton);
3399  }
3400  break;
3401 
3402  case SP_TitleBarCloseButton: // Fall through
3403  case SP_DockWidgetCloseButton: {
3404 
3405  QImage closeButton((const char **)dock_widget_close_xpm);
3406  QColor alphaCorner = closeButton.color(2);
3407  alphaCorner.setAlpha(80);
3408  closeButton.setColor(2, alphaCorner.rgba());
3409  return QPixmap::fromImage(closeButton);
3410  }
3411  break;
3412 
3413  case SP_DialogDiscardButton:
3414  return QGtkPainter::getIcon(GTK_STOCK_DELETE);
3415  case SP_DialogOkButton:
3416  return QGtkPainter::getIcon(GTK_STOCK_OK);
3417  case SP_DialogCancelButton:
3418  return QGtkPainter::getIcon(GTK_STOCK_CANCEL);
3419  case SP_DialogYesButton:
3420  return QGtkPainter::getIcon(GTK_STOCK_YES);
3421  case SP_DialogNoButton:
3422  return QGtkPainter::getIcon(GTK_STOCK_NO);
3423  case SP_DialogOpenButton:
3424  return QGtkPainter::getIcon(GTK_STOCK_OPEN);
3425  case SP_DialogCloseButton:
3426  return QGtkPainter::getIcon(GTK_STOCK_CLOSE);
3427  case SP_DialogApplyButton:
3428  return QGtkPainter::getIcon(GTK_STOCK_APPLY);
3429  case SP_DialogSaveButton:
3430  return QGtkPainter::getIcon(GTK_STOCK_SAVE);
3431  case SP_MessageBoxWarning:
3432  return QGtkPainter::getIcon(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
3433  case SP_MessageBoxQuestion:
3434  return QGtkPainter::getIcon(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG);
3435  case SP_MessageBoxInformation:
3436  return QGtkPainter::getIcon(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
3437  case SP_MessageBoxCritical:
3438  return QGtkPainter::getIcon(GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG);
3439  default:
3440  return QCleanlooksStyle::standardPixmap(sp, option, widget);
3441  }
3442  return pixmap;
3443 }
QColor
The QColor class provides colors based on RGB, HSV or CMYK values.
Definition: qcolor.h:67
d
double d
Definition: qnumeric_p.h:62
QPixmap::fromImage
static QPixmap fromImage(const QImage &image, Qt::ImageConversionFlags flags=Qt::AutoColor)
Converts the given image to a pixmap using the specified flags to control the conversion.
Definition: qpixmap.cpp:2197
QGtkPainter::getIcon
static QPixmap getIcon(const char *iconName, GtkIconSize size=GTK_ICON_SIZE_BUTTON)
Definition: qgtkpainter.cpp:191
QCleanlooksStyle::standardPixmap
QPixmap standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt, const QWidget *widget=0) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:4431
dock_widget_close_xpm
static const char *const dock_widget_close_xpm[]
Definition: qgtkstyle.cpp:81
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QImage
The QImage class provides a hardware-independent image representation that allows direct access to th...
Definition: qimage.h:87
dock_widget_restore_xpm
static const char *const dock_widget_restore_xpm[]
Definition: qgtkstyle.cpp:104
QColor::setAlpha
void setAlpha(int alpha)
Sets the alpha of this color to alpha.
Definition: qcolor.cpp:1094
QPixmap
The QPixmap class is an off-screen image representation that can be used as a paint device...
Definition: qpixmap.h:71
QColor::rgba
QRgb rgba() const
Returns the RGB value of the color, including its alpha.
Definition: qcolor.cpp:1019
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ styleHint()

int QGtkStyle::styleHint ( StyleHint  hint,
const QStyleOption *  option,
const QWidget *  widget,
QStyleHintReturn *  returnData = 0 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 582 of file qgtkstyle.cpp.

Referenced by drawComplexControl(), and drawControl().

585 {
586  Q_D(const QGtkStyle);
587 
588  if (!d->isThemeAvailable())
589  return QCleanlooksStyle::styleHint(hint, option, widget, returnData);
590 
591  switch (hint) {
592 
593  case SH_DialogButtonLayout: {
594  int ret = QDialogButtonBox::GnomeLayout;
595  gboolean alternateOrder = 0;
596  GtkSettings *settings = d->gtk_settings_get_default();
597  g_object_get(settings, "gtk-alternative-button-order", &alternateOrder, NULL);
598 
599  if (alternateOrder)
600  ret = QDialogButtonBox::WinLayout;
601 
602  return ret;
603  }
604 
605  break;
606 
607  case SH_ToolButtonStyle:
608  {
609  if (d->isKDE4Session())
610  return QCleanlooksStyle::styleHint(hint, option, widget, returnData);
611  GtkWidget *gtkToolbar = d->gtkWidget("GtkToolbar");
612  GtkToolbarStyle toolbar_style = GTK_TOOLBAR_ICONS;
613  g_object_get(gtkToolbar, "toolbar-style", &toolbar_style, NULL);
614  switch (toolbar_style) {
615  case GTK_TOOLBAR_TEXT:
616  return Qt::ToolButtonTextOnly;
617  case GTK_TOOLBAR_BOTH:
618  return Qt::ToolButtonTextUnderIcon;
619  case GTK_TOOLBAR_BOTH_HORIZ:
620  return Qt::ToolButtonTextBesideIcon;
621  case GTK_TOOLBAR_ICONS:
622  default:
623  return Qt::ToolButtonIconOnly;
624  }
625  }
626  break;
627  case SH_SpinControls_DisableOnBounds:
628  return int(true);
629 
630  case SH_DitherDisabledText:
631  return int(false);
632 
633  case SH_ComboBox_Popup: {
634  GtkWidget *gtkComboBox = d->gtkWidget("GtkComboBox");
635  gboolean appears_as_list;
636  d->gtk_widget_style_get((GtkWidget*)gtkComboBox, "appears-as-list", &appears_as_list, NULL);
637  return appears_as_list ? 0 : 1;
638  }
639 
640  case SH_MenuBar_AltKeyNavigation:
641  return int(false);
642 
643  case SH_EtchDisabledText:
644  return int(false);
645 
646  case SH_Menu_SubMenuPopupDelay: {
647  gint delay = 225;
648  GtkSettings *settings = d->gtk_settings_get_default();
649  g_object_get(settings, "gtk-menu-popup-delay", &delay, NULL);
650  return delay;
651  }
652 
653  case SH_ScrollView_FrameOnlyAroundContents: {
654  gboolean scrollbars_within_bevel = false;
655  if (widget && widget->isWindow())
656  scrollbars_within_bevel = true;
657  else if (!d->gtk_check_version(2, 12, 0)) {
658  GtkWidget *gtkScrollWindow = d->gtkWidget("GtkScrolledWindow");
659  d->gtk_widget_style_get(gtkScrollWindow, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
660  }
661  return !scrollbars_within_bevel;
662  }
663 
664  case SH_DialogButtonBox_ButtonsHaveIcons: {
665  static bool buttonsHaveIcons = d->getGConfBool(QLS("/desktop/gnome/interface/buttons_have_icons"));
666  return buttonsHaveIcons;
667  }
668 
669  case SH_UnderlineShortcut: {
670  gboolean underlineShortcut = true;
671  if (!d->gtk_check_version(2, 12, 0)) {
672  GtkSettings *settings = d->gtk_settings_get_default();
673  g_object_get(settings, "gtk-enable-mnemonics", &underlineShortcut, NULL);
674  }
675  return underlineShortcut;
676  }
677 
678  default:
679  return QCleanlooksStyle::styleHint(hint, option, widget, returnData);
680  }
681 }
d
double d
Definition: qnumeric_p.h:62
QWidget::isWindow
bool isWindow() const
Returns true if the widget is an independent window, otherwise returns false.
Definition: qwidget.h:945
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QLS
#define QLS(x)
Definition: qgtkstyle_p.h:77
QCleanlooksStyle::styleHint
int styleHint(StyleHint hint, const QStyleOption *option=0, const QWidget *widget=0, QStyleHintReturn *returnData=0) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:4298
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ subControlRect()

QRect QGtkStyle::subControlRect ( ComplexControl  control,
const QStyleOptionComplex *  option,
SubControl  subControl,
const QWidget *  widget 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 3064 of file qgtkstyle.cpp.

3066 {
3067  Q_D(const QGtkStyle);
3068 
3069  QRect rect = QWindowsStyle::subControlRect(control, option, subControl, widget);
3070  if (!d->isThemeAvailable())
3071  return QCleanlooksStyle::subControlRect(control, option, subControl, widget);
3072 
3073  switch (control) {
3074  case CC_TitleBar:
3075  return QCleanlooksStyle::subControlRect(control, option, subControl, widget);
3076 
3077  case CC_Slider:
3078  if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
3079  // Reserve space for outside focus rect
3080  QStyleOptionSlider sliderCopy = *slider;
3081  sliderCopy.rect = option->rect.adjusted(2, 2, -2, -2);
3082  return QCleanlooksStyle::subControlRect(control, &sliderCopy, subControl, widget);
3083  }
3084 
3085  break;
3086 
3087 #ifndef QT_NO_GROUPBOX
3088 
3089  case CC_GroupBox:
3090  if (qstyleoption_cast<const QStyleOptionGroupBox *>(option)) {
3091  rect = option->rect.adjusted(0, groupBoxTopMargin, 0, -groupBoxBottomMargin);
3092  int topMargin = 0;
3093  int topHeight = 0;
3094  topHeight = 10;
3095  QRect frameRect = rect;
3096  frameRect.setTop(topMargin);
3097 
3098  if (subControl == SC_GroupBoxFrame)
3099  return rect;
3100  else if (subControl == SC_GroupBoxContents) {
3101  int margin = 0;
3102  int leftMarginExtension = 8;
3103  return frameRect.adjusted(leftMarginExtension + margin, margin + topHeight + groupBoxTitleMargin, -margin, -margin);
3104  }
3105 
3106  if (const QGroupBox *groupBoxWidget = qobject_cast<const QGroupBox *>(widget)) {
3107  //Prepare metrics for a bold font
3108  QFont font = widget->font();
3109  font.setBold(true);
3110  QFontMetrics fontMetrics(font);
3111  QSize textRect = fontMetrics.boundingRect(groupBoxWidget->title()).size() + QSize(4, 4);
3112  int indicatorWidth = proxy()->pixelMetric(PM_IndicatorWidth, option, widget);
3113  int indicatorHeight = proxy()->pixelMetric(PM_IndicatorHeight, option, widget);
3114 
3115  if (subControl == SC_GroupBoxCheckBox) {
3116  rect.setWidth(indicatorWidth);
3117  rect.setHeight(indicatorHeight);
3118  rect.moveTop((textRect.height() - indicatorHeight) / 2);
3119 
3120  } else if (subControl == SC_GroupBoxLabel) {
3121  if (groupBoxWidget->isCheckable())
3122  rect.adjust(indicatorWidth + 4, 0, 0, 0);
3123  rect.setSize(textRect);
3124  }
3125  rect = visualRect(option->direction, option->rect, rect);
3126  }
3127  }
3128 
3129  return rect;
3130 
3131 #endif
3132 #ifndef QT_NO_SPINBOX
3133 
3134  case CC_SpinBox:
3135  if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
3136  GtkWidget *gtkSpinButton = d->gtkWidget("GtkSpinButton");
3137  int center = spinbox->rect.height() / 2;
3138  int xt = spinbox->frame ? gtkSpinButton->style->xthickness : 0;
3139  int yt = spinbox->frame ? gtkSpinButton->style->ythickness : 0;
3140  int y = yt;
3141 
3142  QSize bs;
3143  bs.setHeight(qMax(8, spinbox->rect.height()/2 - y));
3144  bs.setWidth(d->getSpinboxArrowSize());
3145  int x, lx, rx;
3146  x = spinbox->rect.width() - y - bs.width() + 2;
3147  lx = xt;
3148  rx = x - xt;
3149 
3150  switch (subControl) {
3151 
3152  case SC_SpinBoxUp:
3153  if (spinbox->buttonSymbols == QAbstractSpinBox::NoButtons)
3154  return QRect();
3155  rect = QRect(x, xt, bs.width(), center - yt);
3156  break;
3157 
3158  case SC_SpinBoxDown:
3159  if (spinbox->buttonSymbols == QAbstractSpinBox::NoButtons)
3160  return QRect();
3161  rect = QRect(x, center, bs.width(), spinbox->rect.bottom() - center - yt + 1);
3162  break;
3163 
3164  case SC_SpinBoxEditField:
3165  if (spinbox->buttonSymbols == QAbstractSpinBox::NoButtons)
3166  rect = QRect(lx, yt, spinbox->rect.width() - 2*xt, spinbox->rect.height() - 2*yt);
3167  else
3168  rect = QRect(lx, yt, rx - qMax(xt - 1, 0), spinbox->rect.height() - 2*yt);
3169  break;
3170 
3171  case SC_SpinBoxFrame:
3172  rect = spinbox->rect;
3173 
3174  default:
3175  break;
3176  }
3177 
3178  rect = visualRect(spinbox->direction, spinbox->rect, rect);
3179  }
3180 
3181  break;
3182 
3183 #endif // Qt_NO_SPINBOX
3184 #ifndef QT_NO_COMBOBOX
3185 
3186  case CC_ComboBox:
3187  if (const QStyleOptionComboBox *box = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
3188  // We employ the gtk widget to position arrows and separators for us
3189  GtkWidget *gtkCombo = box->editable ? d->gtkWidget("GtkComboBoxEntry")
3190  : d->gtkWidget("GtkComboBox");
3191  d->gtk_widget_set_direction(gtkCombo, (option->direction == Qt::RightToLeft) ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
3192  GtkAllocation geometry = {0, 0, qMax(0, option->rect.width()), qMax(0, option->rect.height())};
3193  d->gtk_widget_size_allocate(gtkCombo, &geometry);
3194  int appears_as_list = !proxy()->styleHint(QStyle::SH_ComboBox_Popup, option, widget);
3195  QHashableLatin1Literal arrowPath("GtkComboBoxEntry.GtkToggleButton");
3196  if (!box->editable) {
3197  if (appears_as_list)
3198  arrowPath = "GtkComboBox.GtkToggleButton";
3199  else
3200  arrowPath = "GtkComboBox.GtkToggleButton.GtkHBox.GtkArrow";
3201  }
3202 
3203  GtkWidget *arrowWidget = d->gtkWidget(arrowPath);
3204  if (!arrowWidget)
3205  return QCleanlooksStyle::subControlRect(control, option, subControl, widget);
3206 
3207  QRect buttonRect(option->rect.left() + arrowWidget->allocation.x,
3208  option->rect.top() + arrowWidget->allocation.y,
3209  arrowWidget->allocation.width, arrowWidget->allocation.height);
3210 
3211  switch (subControl) {
3212 
3213  case SC_ComboBoxArrow: // Note: this indicates the arrowbutton for editable combos
3214  rect = buttonRect;
3215  break;
3216 
3217  case SC_ComboBoxEditField: {
3218  rect = visualRect(option->direction, option->rect, rect);
3219  int xMargin = box->editable ? 1 : 4, yMargin = 2;
3220  rect.setRect(option->rect.left() + gtkCombo->style->xthickness + xMargin,
3221  option->rect.top() + gtkCombo->style->ythickness + yMargin,
3222  option->rect.width() - buttonRect.width() - 2*(gtkCombo->style->xthickness + xMargin),
3223  option->rect.height() - 2*(gtkCombo->style->ythickness + yMargin));
3224  rect = visualRect(option->direction, option->rect, rect);
3225  break;
3226  }
3227 
3228  default:
3229  break;
3230  }
3231  }
3232 
3233  break;
3234 
3235 #endif // QT_NO_COMBOBOX
3236 
3237  default:
3238  break;
3239  }
3240 
3241  return rect;
3242 }
d
double d
Definition: qnumeric_p.h:62
QRect::adjusted
QRect adjusted(int x1, int y1, int x2, int y2) const
Returns a new rectangle with dx1, dy1, dx2 and dy2 added respectively to the existing coordinates of ...
Definition: qrect.h:431
QRect::setHeight
void setHeight(int h)
Sets the height of the rectangle to the given height.
Definition: qrect.h:445
QFontMetrics
The QFontMetrics class provides font metrics information.
Definition: qfontmetrics.h:65
groupBoxTitleMargin
static const int groupBoxTitleMargin
Definition: qgtkstyle.cpp:128
QStyle::pixelMetric
virtual int pixelMetric(PixelMetric metric, const QStyleOption *option=0, const QWidget *widget=0) const =0
Returns the value of the given pixel metric.
QWidget::font
QFont font
the font currently set for the widget
Definition: qwidget.h:181
QStyle::styleHint
virtual int styleHint(StyleHint stylehint, const QStyleOption *opt=0, const QWidget *widget=0, QStyleHintReturn *returnData=0) const =0
Returns an integer representing the specified style hint for the given widget described by the provid...
QRect::left
int left() const
Returns the x-coordinate of the rectangle&#39;s left edge.
Definition: qrect.h:240
QRect::width
int width() const
Returns the width of the rectangle.
Definition: qrect.h:303
QRect::height
int height() const
Returns the height of the rectangle.
Definition: qrect.h:306
QSize::setHeight
void setHeight(int h)
Sets the height to the given height.
Definition: qsize.h:135
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
qMax
Q_DECL_CONSTEXPR const T & qMax(const T &a, const T &b)
Definition: qglobal.h:1217
QSize::setWidth
void setWidth(int w)
Sets the width to the given width.
Definition: qsize.h:132
groupBoxTopMargin
static const int groupBoxTopMargin
Definition: qgtkstyle.cpp:129
QSize::width
int width() const
Returns the width.
Definition: qsize.h:126
QFont::setBold
void setBold(bool)
If enable is true sets the font&#39;s weight to QFont::Bold ; otherwise sets the weight to QFont::Normal...
Definition: qfont.h:352
QStyleOptionSpinBox
The QStyleOptionSpinBox class is used to describe the parameters necessary for drawing a spin box...
Definition: qstyleoption.h:729
QRect::setTop
void setTop(int pos)
Sets the top edge of the rectangle to the given y coordinate.
Definition: qrect.h:261
QRect::adjust
void adjust(int x1, int y1, int x2, int y2)
Adds dx1, dy1, dx2 and dy2 respectively to the existing coordinates of the rectangle.
Definition: qrect.h:434
groupBoxBottomMargin
static const int groupBoxBottomMargin
Definition: qgtkstyle.cpp:127
QRect::setSize
void setSize(const QSize &s)
Sets the size of the rectangle to the given size.
Definition: qrect.h:448
QGroupBox
The QGroupBox widget provides a group box frame with a title.
Definition: qgroupbox.h:57
center
Q_CORE_EXPORT QTextStream & center(QTextStream &s)
QRect::top
int top() const
Returns the y-coordinate of the rectangle&#39;s top edge.
Definition: qrect.h:243
QStyle::visualRect
static QRect visualRect(Qt::LayoutDirection direction, const QRect &boundingRect, const QRect &logicalRect)
Returns the given logicalRectangle converted to screen coordinates based on the specified direction...
Definition: qstyle.cpp:2087
QFont
The QFont class specifies a font used for drawing text.
Definition: qfont.h:64
QRect::setRect
void setRect(int x, int y, int w, int h)
Sets the coordinates of the rectangle&#39;s top-left corner to ({x}, {y}), and its size to the given widt...
Definition: qrect.h:400
QStyleOptionComboBox
The QStyleOptionComboBox class is used to describe the parameter for drawing a combobox.
Definition: qstyleoption.h:796
QRect::setWidth
void setWidth(int w)
Sets the width of the rectangle to the given width.
Definition: qrect.h:442
QSize::height
int height() const
Returns the height.
Definition: qsize.h:129
QStyleOption::direction
Qt::LayoutDirection direction
the text layout direction that should be used when drawing text in the control
Definition: qstyleoption.h:89
QRect
The QRect class defines a rectangle in the plane using integer precision.
Definition: qrect.h:58
QStyle::proxy
const QStyle * proxy() const
Definition: qstyle.cpp:2546
QStyleOptionSlider
The QStyleOptionSlider class is used to describe the parameters needed for drawing a slider...
Definition: qstyleoption.h:701
QSize
The QSize class defines the size of a two-dimensional object using integer point precision.
Definition: qsize.h:53
QRect::moveTop
void moveTop(int pos)
Moves the rectangle vertically, leaving the rectangle&#39;s top edge at the given y coordinate.
Definition: qrect.h:353
QStyleOption::rect
QRect rect
the area that should be used for various calculations and painting
Definition: qstyleoption.h:90
QCommonStyle::subControlRect
QRect subControlRect(ComplexControl cc, const QStyleOptionComplex *opt, SubControl sc, const QWidget *w=0) const
Reimplemented Function
Definition: qcommonstyle.cpp:3941
QCleanlooksStyle::subControlRect
QRect subControlRect(ComplexControl cc, const QStyleOptionComplex *opt, SubControl sc, const QWidget *widget) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:3992
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ subElementRect()

QRect QGtkStyle::subElementRect ( SubElement  sr,
const QStyleOption *  opt,
const QWidget *  w 
) const
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 3490 of file qgtkstyle.cpp.

Referenced by drawControl().

3491 {
3492  Q_D(const QGtkStyle);
3493 
3494  QRect r = QCleanlooksStyle::subElementRect(element, option, widget);
3495  if (!d->isThemeAvailable())
3496  return r;
3497 
3498  switch (element) {
3499  case SE_ProgressBarLabel:
3500  case SE_ProgressBarContents:
3501  case SE_ProgressBarGroove:
3502  return option->rect;
3503  case SE_PushButtonContents:
3504  if (!d->gtk_check_version(2, 10, 0)) {
3505  GtkWidget *gtkButton = d->gtkWidget("GtkButton");
3506  GtkBorder *border = 0;
3507  d->gtk_widget_style_get(gtkButton, "inner-border", &border, NULL);
3508  if (border) {
3509  r = option->rect.adjusted(border->left, border->top, -border->right, -border->bottom);
3510  d->gtk_border_free(border);
3511  } else {
3512  r = option->rect.adjusted(1, 1, -1, -1);
3513  }
3514  r = visualRect(option->direction, option->rect, r);
3515  }
3516  break;
3517  default:
3518  break;
3519  }
3520 
3521  return r;
3522 }
d
double d
Definition: qnumeric_p.h:62
QRect::adjusted
QRect adjusted(int x1, int y1, int x2, int y2) const
Returns a new rectangle with dx1, dy1, dx2 and dy2 added respectively to the existing coordinates of ...
Definition: qrect.h:431
QCleanlooksStyle::subElementRect
QRect subElementRect(SubElement r, const QStyleOption *opt, const QWidget *widget=0) const
Reimplemented Function
Definition: qcleanlooksstyle.cpp:4387
widget
QPointer< QWidget > widget
Definition: qapplication_mac.mm:879
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
QStyle::visualRect
static QRect visualRect(Qt::LayoutDirection direction, const QRect &boundingRect, const QRect &logicalRect)
Returns the given logicalRectangle converted to screen coordinates based on the specified direction...
Definition: qstyle.cpp:2087
QRect
The QRect class defines a rectangle in the plane using integer precision.
Definition: qrect.h:58
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61

◆ unpolish() [1/2]

void QGtkStyle::unpolish ( QWidget *  widget)
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 400 of file qgtkstyle.cpp.

401 {
402  QCleanlooksStyle::unpolish(widget);
403 }
QCleanlooksStyle::unpolish
void unpolish(QWidget *widget)
Reimplemented Function
Definition: qcleanlooksstyle.cpp:3953

◆ unpolish() [2/2]

void QGtkStyle::unpolish ( QApplication *  app)
virtual

Reimplemented Function

Reimplemented from QCleanlooksStyle.

Definition at line 355 of file qgtkstyle.cpp.

356 {
357  Q_D(QGtkStyle);
358 
359  QCleanlooksStyle::unpolish(app);
360  QPixmapCache::clear();
361 
362  if (app->desktopSettingsAware() && d->isThemeAvailable()
363  && !d->isKDE4Session()) {
364  qt_filedialog_open_filename_hook = 0;
365  qt_filedialog_save_filename_hook = 0;
366  qt_filedialog_open_filenames_hook = 0;
367  qt_filedialog_existing_directory_hook = 0;
368  qApp->removeEventFilter(&d->filter);
369  }
370 }
d
double d
Definition: qnumeric_p.h:62
qt_filedialog_existing_directory_hook
Q_GUI_EXPORT _qt_filedialog_existing_directory_hook qt_filedialog_existing_directory_hook
Definition: qfiledialog.cpp:85
qt_filedialog_open_filename_hook
Q_GUI_EXPORT _qt_filedialog_open_filename_hook qt_filedialog_open_filename_hook
Definition: qfiledialog.cpp:88
Q_D
#define Q_D(Class)
Definition: qglobal.h:2482
qApp
#define qApp
Definition: qcoreapplication.h:69
QPixmapCache::clear
static void clear()
Removes all pixmaps from the cache.
Definition: qpixmapcache.cpp:666
qt_filedialog_save_filename_hook
Q_GUI_EXPORT _qt_filedialog_save_filename_hook qt_filedialog_save_filename_hook
Definition: qfiledialog.cpp:94
QApplication::desktopSettingsAware
static bool desktopSettingsAware()
Returns true if Qt is set to use the system&#39;s standard colors, fonts, etc.
Definition: qapplication.cpp:3371
qt_filedialog_open_filenames_hook
Q_GUI_EXPORT _qt_filedialog_open_filenames_hook qt_filedialog_open_filenames_hook
Definition: qfiledialog.cpp:91
QCleanlooksStyle::unpolish
void unpolish(QWidget *widget)
Reimplemented Function
Definition: qcleanlooksstyle.cpp:3953
QGtkStyle
The QGtkStyle class provides a widget style rendered by GTK+.
Definition: qgtkstyle.h:61
The documentation for this class was generated from the following files:
Qt 4.8 Source Code Browser