You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tde-style-domino/domino/domino.h

866 lines
23 KiB

/* Domino widget style for KDE 3
Copyright (C) 2006 Michael Lentner <michaell@gmx.net>
based on the KDE style "Plastik":
Copyright (C) 2003 Sandro Giessl <ceebx@users.sourceforge.net>
based on the KDE style "dotNET":
Copyright (C) 2001-2002, Chris Lee <clee@kde.org>
Carsten Pfeiffer <pfeiffer@kde.org>
Karol Szwed <gallium@kde.org>
Drawing routines completely reimplemented from KDE3 HighColor, which was
originally based on some stuff from the KDE2 HighColor.
based on drawing routines of the style "Keramik":
Copyright (c) 2002 Malte Starostik <malte@kde.org>
(c) 2002,2003 Maksim Orlovich <mo002j@mail.rochester.edu>
based on the KDE3 HighColor Style
Copyright (C) 2001-2002 Karol Szwed <gallium@kde.org>
(C) 2001-2002 Fredrik H<EFBFBD>glund <fredrik@kde.org>
Drawing routines adapted from the KDE2 HCStyle,
Copyright (C) 2000 Daniel M. Duley <mosfet@kde.org>
(C) 2000 Dirk Mueller <mueller@kde.org>
(C) 2001 Martijn Klingens <klingens@kde.org>
Progressbar code based on KStyle,
Copyright (C) 2001-2002 Karol Szwed <gallium@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __DOMINO_H
#define __DOMINO_H
#include <kstyle.h>
#include <qintcache.h>
#include <ktoolbarbutton.h>
#include "misc.h"
#include "data.h"
#include <qpixmapcache.h>
// #include <X11/extensions/Xrender.h>
#include <X11/Xft/Xft.h>
class ButtonContour;
class RubberWidget;
class Rubber;
enum ContourType
{
Contour_Sunken = 0,
Contour_Raised = 1,
Contour_Simple = 2
};
enum ContourState
{
Contour_Default = 0,
Contour_Pressed = 1,
Contour_MouseOver = 2,
Contour_DefaultButton = 3
};
enum TextEffect
{
TextEffect_None = 0,
TextEffect_OnlyButton = 1,
TextEffect_Everywhere = 2
};
struct DSurface {
int numGradients;
QColor g1Color1;
QColor g1Color2;
QColor g2Color1;
QColor g2Color2;
QColor background;
int g1Top;
int g1Bottom;
int g2Top;
int g2Bottom;
};
class DominoStyle : public KStyle
{
Q_OBJECT
public:
DominoStyle();
virtual ~DominoStyle();
enum PaletteTyp
{
Palette_Application,
Palette_Parent,
Palette_Widget
};
void polish(QApplication* app );
void polish(QWidget* widget );
void polish( QPalette &p );
void unPolish(QWidget* widget );
void drawKStylePrimitive(KStylePrimitive kpe,
QPainter* p,
const QWidget* widget,
const QRect &r,
const QColorGroup &cg,
SFlags flags = Style_Default,
const QStyleOption& = QStyleOption::Default ) const;
void drawPrimitive(PrimitiveElement pe,
QPainter *p,
const QRect &r,
const QColorGroup &cg,
SFlags flags = Style_Default,
const QStyleOption &opt = QStyleOption::Default ) const;
void drawControl(ControlElement element,
QPainter *p,
const QWidget *widget,
const QRect &r,
const QColorGroup &cg,
SFlags flags = Style_Default,
const QStyleOption& = QStyleOption::Default ) const;
void drawControlMask( ControlElement, QPainter *, const QWidget *, const QRect &, const QStyleOption &) const;
void drawComplexControl(ComplexControl control,
QPainter *p,
const QWidget *widget,
const QRect &r,
const QColorGroup &cg,
SFlags flags = Style_Default,
SCFlags controls = SC_All,
SCFlags active = SC_None,
const QStyleOption& = QStyleOption::Default ) const;
int pixelMetric(PixelMetric m,
const QWidget *widget = 0 ) const;
QRect subRect(SubRect r,
const QWidget *widget ) const;
QRect querySubControlMetrics(ComplexControl control,
const QWidget *widget,
SubControl subcontrol,
const QStyleOption &opt = QStyleOption::Default ) const;
QSize sizeFromContents(QStyle::ContentsType t,
const QWidget *w,
const QSize &s,
const QStyleOption &o) const;
int styleHint(StyleHint, const QWidget * = 0,
const QStyleOption & = QStyleOption::Default,
QStyleHintReturn * = 0 ) const;
QPixmap stylePixmap(StylePixmap stylepixmap, const QWidget* widget, const QStyleOption& opt) const;
void drawItem( QPainter *p, const QRect &r,
int flags, const QColorGroup &g, bool enabled,
const QPixmap *pixmap, const QString &text,
int len = -1, const QColor *penColor = 0) const;
void dominoDrawItem( QPainter *p, const QRect &r,
int flags, const QColorGroup &g, bool enabled,
const QPixmap *pixmap, const QString &text,
int len = -1, const QColor *penColor = 0, bool buttonTextEffect = 0 ) const;
void setDominoButtonPalette(QWidget* widget, PaletteTyp type);
virtual void drawFocusIndicator(QPainter *p,
const QRect &r,
int flags,
const QColorGroup cg,
bool /*enabled*/,
const QPixmap* /*pixmap*/,
const QString & text,
int /*len = -1*/,
const QColor& highlight = 0,
bool drawLine = true,
bool isButton = false) const;
QPixmap renderOutlineIcon(const QPixmap* icon) const;
void renderSurface(QPainter *p,
const QRect &r,
const QColor &backgroundColor,
const QColor &buttonColor,
const QColor &highlightColor,
const uint flags = Draw_Left|Draw_Right|Draw_Top|Draw_Bottom|
Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight|Is_Horizontal) const;
inline QWidget::BackgroundOrigin setPixmapOrigin(QWidget::BackgroundOrigin origin);
mutable Rubber* rubber;
mutable QRect oldRubberRect;
mutable bool viewPortPressed;
mutable bool ignoreNextFocusRect;
uint _argbRubberBandColor;
mutable bool compositeManagerRunning;
const QWidget* rubberViewPort;
protected:
enum RubberType
{
ArgbRubber = 1,
LineRubber = 2,
DistRubber = 3
};
RubberType rubberBandType;
enum TabPosition
{
First ,
Middle,
Last,
Single
};
struct TextEffectSettings {
TextEffect mode;
QColor color;
QColor buttonColor;
int opacity;
int buttonOpacity;
QPoint pos;
QPoint buttonPos;
};
struct GroupBoxSettings {
bool tintBackground;
int brightness;
bool customColor;
QColor color;
};
struct FocusIndicatorSettings {
QColor color;
int opacity;
QColor buttonColor;
int buttonOpacity;
bool drawUnderline;
bool indicateFocus;
};
mutable TextEffectSettings textEffectSettings;
GroupBoxSettings groupBoxSettings;
FocusIndicatorSettings focusIndicatorSettings;
ButtonContour* buttonContour;
enum SurfaceFlags {
Draw_Left = 0x00000001,
Draw_Right = 0x00000002,
Draw_Top = 0x00000004,
Draw_Bottom = 0x00000008,
Is_Horizontal = 0x00000200,
Is_Highlight = 0x00000400,
Is_Default = 0x00000800,
Is_Disabled = 0x00001000,
Round_UpperLeft = 0x00002000,
Round_UpperRight = 0x00004000,
Round_BottomLeft = 0x00008000,
Round_BottomRight = 0x00010000,
Rectangular_UpperLeft = 0x00000010,
Rectangular_UpperRight = 0x10000020,
Rectangular_BottomLeft = 0x00000040,
Rectangular_BottomRight = 0x00000080,
Draw_AlphaBlend = 0x00020000,
Is_ComboBox = 0x00080000,
Is_Button = 0x00100000,
Is_CheckItem = 0x00200000,
Is_RadioButton = 0x00400000,
Is_TabTop = 0x00000100,
Is_TabBottom = 0x01000000,
Is_ActiveTabTop = 0x00040000,
Is_ActiveTabBottom = 0x00800000,
Is_ScrollBarBtn = 0x02000000,
Is_Header = 0x04000000,
Is_ScrollBarGroove = 0x08000000,
Is_Slider = 0x20000000,
Is_Down = 0x40000000
};
enum DominoStyleFlags {
Domino_noCache = 0x80000000
};
enum DominoPrimitiveElement {
PE_ScrollBarSubLine2 = 0xf000001
};
void renderContour(QPainter *p,
const QRect &r,
const QColor &backgroundColor,
const QColor &contourColor,
const uint flags = Draw_Left|Draw_Right|Draw_Top|Draw_Bottom|
Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight) const;
void renderButtonShadow(QPainter *p, const QRect &r, const uint flags = Draw_Left|Draw_Right|Draw_Top|Draw_Bottom|
Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight|Is_Horizontal) const;
QPixmap* renderLineEditShadow(QWidget* widget, QRect rect, QColor bg, uint flags, bool reverse);
inline void renderPixel(QPainter *p,
const QPoint &pos,
const int alpha,
const QColor &color,
const QColor &background = QColor(),
bool fullAlphaBlend = true) const;
void renderButton(QPainter *p,
const QRect &r,
const QColorGroup &g,
bool sunken = false,
bool mouseOver = false,
bool horizontal = true,
bool enabled = true,
bool khtmlMode = false) const;
void renderHeader(QPainter *p,
const QRect &r,
const QColorGroup &g,
bool sunken = false,
bool mouseOver = false,
bool horizontal = true,
bool enabled = true) const;
void renderGradient(QPainter *p,
const QRect &r,
const QColor &c1,
const QColor &c2,
bool horizontal = true) const;
void renderTab(QPainter *p,
const QRect &r,
const QColorGroup &g,
bool mouseOver = false,
const bool selected = false,
const bool bottom = false,
const TabPosition pos = Middle,
const bool triangular = false,
const bool cornerWidget = false,
const bool konqTab = false) const;
DSurface btnSurface;
DSurface tabTopSurface;
DSurface activeTabTopSurface;
DSurface tabBottomSurface;
DSurface activeTabBottomSurface;
DSurface scrollBarSurface;
DSurface scrollBarGrooveSurface;
DSurface headerSurface;
DSurface checkItemSurface;
bool eventFilter(QObject *, QEvent *);
QString configMode;
void removeCachedSbPix(const QColor &color) {
QPixmapCache::remove("sHCap"+QString::number(color.pixel(), 16)+"1"+configMode);
QPixmapCache::remove("sHCap"+QString::number(color.pixel(), 16)+"0"+configMode);
QPixmapCache::remove("sVCap"+QString::number(color.pixel(), 16)+"1"+configMode);
QPixmapCache::remove("sVCap"+QString::number(color.pixel(), 16)+"0"+configMode);
QPixmapCache::remove(QString::number(color.pixel(), 16)+"sh"+configMode);
QPixmapCache::remove(QString::number(color.pixel(), 16)+"sv"+configMode);
QPixmapCache::remove(QString::number(color.pixel(), 16)+"ah"+configMode);
QPixmapCache::remove(QString::number(color.pixel(), 16)+"av"+configMode);
};
QColor getGroupBoxColor(const QWidget* w) const;
QPixmap* createCheckMark(const QColor color) const;
QPixmap* createRadioIndicator(const QColor color) const;
QPixmap disableIcon(const QPixmap* icon) const;;
QWidget* hoverWidget;
QPixmap* checkMark;
QPixmap* radioIndicator;
QPixmap* popupFrame;
QPixmap* border1;
mutable bool alphaButtonMode;
bool KApplicationMode;
QColor _checkMarkColor;
QMap<const QGroupBox*, const QPixmap*> groupBoxPixmaps;
uint preMultiplyColor(const uint &c) const;
QToolButton* popupButton;
QTimer* popupTimer;
QPoint popupMousePressPos;
protected slots:
void khtmlWidgetDestroyed(QObject* w);
void groupBoxDestroyed(QObject* w);
//Animation slots.
void updateProgressPos();
void updateScrollPos(); // smoothscroll
void progressBarDestroyed(QObject* bar);
inline QColor dGetColor(const QColor &color, const int value) const;
inline QColor lightenColor(const QColor &color, const int value) const;
inline QColor darkenColor(const QColor &color, const int value) const;
void updateTabWidgetFrame();
void spinBoxValueChanged(int);
void toolPopupPressed();
void popupToolMenu();
void toolPopupReleased();
private:
// Disable copy constructor and = operator
DominoStyle( const DominoStyle & );
DominoStyle& operator=( const DominoStyle & );
bool kickerMode;
bool konquerorMode;
bool konsoleMode;
mutable bool flatMode;
bool sideRepaint;
bool _animateProgressBar;
bool _drawTriangularExpander;
bool _customCheckMarkColor;
bool _smoothScrolling;
QColor _toolTipColor;
int _buttonHeightAdjustment;
bool _customPopupMenuColor;
QColor _popupMenuColor;
bool _customSelMenuItemColor;
QColor _selMenuItemColor;
bool _drawPopupMenuGradient;
bool _indentPopupMenuItems;
bool _centerTabs;
bool _wheelSwitchesTabs;
bool _customSliderHandleContourColor;
bool _drawButtonSunkenShadow;
bool _toolBtnAsBtn;
bool _highlightToolBtnIcon;
bool konqTab;
int minTabLength;
bool macStyleBar;
int konqTabBarContrast;
bool spinWidgetDown;
mutable int sliderlen;
// smoothscrolling
int scrollDistance;
bool scrollVertical;
QScrollView* scrollWidget;
QTimer* scrollTimer;
bool hoveredToolBoxTab;
// track khtml widgets.
QMap<const QWidget*,bool> khtmlWidgets;
//Animation support.
QMap<QWidget*, int> progAnimWidgets;
// pixmap cache.
enum CacheEntryType {
cSurface,
cGradientTile,
cAlphaDot
};
struct CacheEntry
{
CacheEntryType type;
int width;
int height;
QRgb c1Rgb;
QRgb c2Rgb;
bool horizontal;
QPixmap* pixmap;
CacheEntry(CacheEntryType t, int w, int h, QRgb c1, QRgb c2 = 0,
bool hor = false, QPixmap* p = 0 ):
type(t), width(w), height(h), c1Rgb(c1), c2Rgb(c2), horizontal(hor), pixmap(p)
{}
~CacheEntry()
{
delete pixmap;
}
int key()
{
// create an int key from the properties which is used to refer to entries in the QIntCache.
// the result may not be 100% correct as we don't have so much space in one integer -- use
// == operator after find to make sure we got the right one. :)
return horizontal ^ (type<<1) ^ (width<<5) ^ (height<<10) ^ (c1Rgb<<19) ^ (c2Rgb<<22);
}
bool operator == (const CacheEntry& other)
{
bool match = (type == other.type) &&
(width == other.width) &&
(height == other.height) &&
(c1Rgb == other.c1Rgb) &&
(c1Rgb == other.c1Rgb) &&
(horizontal = other.horizontal);
// if(!match) {
// qDebug("operator ==: CacheEntries don't match!");
// qDebug("width: %d\t\tother width: %d", width, other.width);
// qDebug("height: %d\t\tother height: %d", height, other.height);
// qDebug("fgRgb: %d\t\tother fgRgb: %d", fgRgb, other.fgRgb);
// qDebug("bgRgb: %d\t\tother bgRgb: %d", bgRgb, other.bgRgb);
// qDebug("surfaceFlags: %d\t\tother surfaceFlags: %d", surfaceFlags, other.surfaceFlags);
// }
return match;
}
};
QIntCache<CacheEntry> *pixmapCache;
// For KPE_ListViewBranch
mutable QBitmap *verticalLine;
mutable QBitmap *horizontalLine;
// For progress bar animation
QTimer *animationTimer;
void renderTabSeparator(QPainter *p, const QRect &r, const QColor buttonColor, bool tabAbove) const;
void renderGroupBox(QObject *obj, QEvent *ev);
};
class ButtonContour
{
friend class DominoStyleConfig;
friend class DominoStyle;
public:
ButtonContour();
virtual ~ButtonContour();
static const int num_states = 4;
static const int num_types = 3;
ContourType defaultType;
ContourType type;
ContourState state;
bool alpha_mode;
bool drawButtonSunkenShadow;
int created[num_types][num_states];
int shadowCreated[num_states];
QColor contour[num_states];
uint c1[num_types][num_states]; // top shadow
uint c2[num_types][num_states]; // outer ring
uint c3[num_types][num_states]; // inner ring
uint c4[num_types][num_states]; // bottom first shadow line
uint c5[num_types][num_states]; // bottom second shadow line
uint c6[num_types][num_states]; // first left shadow line
QPixmap* btnEdges[num_types][num_states];
QPixmap* btnVLines[num_types][num_states];
QPixmap* btnHLines[num_types][num_states];
// for sunken type and sunken flat buttons
QPixmap* buttonShadowRectangular[num_states];
QPixmap* buttonShadowRound [num_states];
QPixmap* buttonShadowHlines[num_states];
QPixmap* buttonShadowVlines[num_states];
bool alphaMode() {
return alpha_mode;
}
uint color1() {
return c1[type][state];
}
uint color2() {
return c2[type][state];
}
uint color3() {
return c3[type][state];
}
uint color4() {
return c4[type][state];
}
uint color5() {
return c5[type][state];
}
uint color6() {
return c6[type][state];
}
QColor contourColor(int t) {
return contour[t];
}
QPixmap* buttonEdges() {
return btnEdges[type][state];
}
QPixmap* buttonVLines() {
return btnVLines[type][state];
}
QPixmap* buttonHLines() {
return btnHLines[type][state];
}
void setType(ContourType t = Contour_Sunken) {
type = t;
createPixmaps(type, state);
}
void setState(ContourState s = Contour_Default) {
state = s;
if(s == Contour_Pressed && type != Contour_Sunken)
type = Contour_Simple;
createPixmaps(type, state);
}
void setContour(ContourType t = Contour_Sunken, ContourState s = Contour_Default) {
type = t;
state = s;
createPixmaps(type, state);
}
void setColor(ContourState s, QColor color) {
contour[s] = color;
uint c2_tmp;
uint c3_tmp;
if(defaultType == Contour_Sunken /*|| defaultType == Contour_Simple*/) {
c2_tmp = qRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 218);
c3_tmp = qRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 35);
}
else {
c2_tmp = qRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 203);
QColor whiteColor(qRgba(Qt::white.red(), Qt::white.green(), Qt::white.blue(), 34));
QColor blackColor(qRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 35));
c3_tmp = blendColors(whiteColor, blackColor).rgb();
}
for(int t = 0; t < num_types; t++) {
c2[t][s] = c2_tmp; // outer ring
c3[t][s] = c3_tmp; // inner ring
}
}
void setDefaultType(ContourType t = Contour_Raised, bool create = true) {
defaultType = t;
type = t;
if(create)
createPixmaps(type, state);
}
void setAlphaMode() {
alpha_mode = true;
}
void reset() {
type = defaultType;
state = Contour_Default;
alpha_mode = false;
}
QPixmap* shadowRound() {
return buttonShadowRound[state];
}
QPixmap* shadowRectangular() {
return buttonShadowRectangular[state];
}
QPixmap* shadowHLines() {
return buttonShadowHlines[state];
}
QPixmap* shadowVLines() {
return buttonShadowVlines[state];
}
void createPixmaps(ContourType t = Contour_Sunken, ContourState s = Contour_Default) {
type = t;
state = s;
// for pressed sunken buttons + pressed KMultiTabbarTabs
if(drawButtonSunkenShadow && !shadowCreated[state]) {
QColor shadowColor = alphaBlendColors(Qt::black, contour[state], 120);
buttonShadowRectangular[state] = new QPixmap(tintImage(qembed_findImage("btnPressedShadowRectangular"), shadowColor));
buttonShadowRound[state] = new QPixmap(tintImage(qembed_findImage("btnPressedShadowRound"), shadowColor));
buttonShadowHlines[state] = new QPixmap(tintImage(qembed_findImage("btnPressedShadowHLines"), shadowColor));
buttonShadowVlines[state] = new QPixmap(tintImage(qembed_findImage("btnPressedShadowVLines"), shadowColor));
shadowCreated[state] = 1;
}
if(created[type][state])
return;
QImage btnVLines_img;
QImage btnHLines_img;
QImage btnShadow_img;
switch(type) {
case Contour_Simple: // now pressed raised!
btnShadow_img = qembed_findImage("btnRSPr"); // the inner white ring
blend(tintImage(qembed_findImage("btn"), contour[state]), btnShadow_img, btnShadow_img);
btnHLines_img = qembed_findImage("btnHRSPr");
blend(tintImage(qembed_findImage("btnH"), contour[state]), btnHLines_img, btnHLines_img);
btnVLines_img = qembed_findImage("btnVRSPr");
blend(tintImage(qembed_findImage("btnV"), contour[state]), btnVLines_img, btnVLines_img);
break;
case Contour_Sunken:
btnShadow_img = qembed_findImage("btnSSh");
blend(tintImage(qembed_findImage("btn"), contour[state]), btnShadow_img, btnShadow_img);
btnHLines_img = qembed_findImage("btnHSSh");
blend(tintImage(qembed_findImage("btnH"), contour[state]), btnHLines_img, btnHLines_img);
btnVLines_img = qembed_findImage("btnVSSh");
blend(tintImage(qembed_findImage("btnV"), contour[state]), btnVLines_img, btnVLines_img);
break;
case Contour_Raised:
btnShadow_img = qembed_findImage("btn17RaisedShadow3"); // the inner white ring + outer shadow
blend(tintImage(qembed_findImage("btn"), contour[state]), btnShadow_img, btnShadow_img);
btnHLines_img = qembed_findImage("btnHRSh");
blend(tintImage(qembed_findImage("btnH"), contour[state]), btnHLines_img, btnHLines_img);
btnVLines_img = qembed_findImage("btnVRSh");
blend(tintImage(qembed_findImage("btnV"), contour[state]), btnVLines_img, btnVLines_img);
default:
break;
}
btnEdges[type][state] = new QPixmap(btnShadow_img);
btnVLines[type][state] = new QPixmap(btnVLines_img);
btnHLines[type][state] = new QPixmap(btnHLines_img);
created[type][state] = 1;
}
};
class RubberWidget : public QWidget
{
public:
RubberWidget(Window window);
~RubberWidget();
};
class Rubber
{
friend class DominoStyle;
public:
Rubber(uint col);
~Rubber();
Visual* visual;
Colormap colormap;
XSetWindowAttributes wsa;
Window window;
RubberWidget* parent;
RubberWidget* rubber;
QRegion mask;
uint color;
void destroy() {
if(parent) {
delete rubber;
delete parent;
window = 0;
parent = 0;
rubber = 0;
}
}
void create(QRect& r, QRegion& mask);
void updateMask(QRegion& mask);
};
// DominoXXX classes to access protected (or private...) members
class DominoQGroupBox : public QGroupBox
{
friend class DominoStyle;
public:
DominoQGroupBox( QWidget* parent=0, const char* name=0 )
: QGroupBox( parent, name ) {}
};
class DominoQWidget : public QWidget
{
friend class DominoStyleConfig;
friend class DominoStyle;
public:
DominoQWidget( QWidget* parent=0, const char* name=0 )
: QWidget( parent, name ) {}
};
class DominoQFrame : public QFrame
{
friend class DominoStyle;
public:
DominoQFrame( QFrame* parent=0, const char* name=0 )
: QFrame( parent, name ) {}
};
// QWhatsThis
class DominoQWhatsThat : public QWidget
{
friend class DominoStyle;
public:
DominoQWhatsThat(): QWidget() {}
private:
QString text;
};
class DominoKToolBarButton : public KToolBarButton
{
friend class DominoStyle;
public:
DominoKToolBarButton(): KToolBarButton() {}
};
class DominoQListBoxItem : public QListBoxItem
{
friend class DominoStyle;
public:
DominoQListBoxItem(): QListBoxItem() {}
};
class DominoQTabWidget : public QTabWidget
{
friend class DominoStyleConfig;
friend class DominoStyle;
public:
DominoQTabWidget( QWidget* parent=0, const char* name=0 )
: QTabWidget( parent, name ) {}
};
class DominoQSpinBox : public QSpinBox
{
friend class DominoStyle;
public:
DominoQSpinBox( QFrame* parent=0, const char* name=0 )
: QSpinBox( parent, name ) {}
};
class DominoQPixmap : public QPixmap
{
friend class DominoStyle;
public:
DominoQPixmap( int w, int h, int depth = -1) : QPixmap(w, h, depth) {}
};
class DominoQButton : public QButton
{
friend class DominoStyle;
public:
DominoQButton(): QButton() {}
};
#endif // __DOMINO_H