QDecorationDefault Class Reference

The QDecorationDefault class is a base class providing default window decorations. More...

#include <qdecorationdefault_qws.h>

Inheritance diagram for QDecorationDefault:

Public Functions
virtual bool	paint (QPainter *painter, const QWidget *widget, int decorationRegion=All, DecorationState state=Normal)
	Paints the border and title decoration for the top-level widget using the painter provided and the decoration state. More...
	QDecorationDefault ()
	Default constructor. More...
virtual QRegion	region (const QWidget *widget, const QRect &rect, int decorationRegion=All)
	Returns the region specified by decorationRegion for the top-level widget. More...
virtual	~QDecorationDefault ()
	The constructor deletes the static pixmaps. More...
Public Functions inherited from QDecoration
virtual void	buildSysMenu (QWidget *widget, QMenu *menu)
	Builds the system menu for the given top level widget, adding Restore, Move, Size, Minimize, Maximize and Close actions to the given menu. More...
void	menuTriggered (QWidget *widget, QAction *action)
	This function is called whenever an action in a top level widget's menu is triggered, and simply calls the regionClicked() function passing the widget and action parameters as arguments. More...
	QDecoration ()
	Constructs a decoration object. More...
QRegion	region (const QWidget *w, int decorationRegion=All)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
virtual int	regionAt (const QWidget *w, const QPoint &point)
	Returns the type of the first region of the specified top level widget containing the given point. More...
virtual void	regionClicked (QWidget *widget, int region)
	Handles the event that the specified region in the given top level widget is activated by a single click (the region parameter is described using the DecorationRegion enum). More...
virtual void	regionDoubleClicked (QWidget *widget, int region)
	Handles the event that the specified region in the given top level widget is activated by a double click (the region parameter is described using the DecorationRegion enum). More...
virtual	~QDecoration ()
	Destroys this decoration object. More...

Protected Functions
virtual void	paintButton (QPainter *painter, const QWidget *widget, int buttonRegion, DecorationState state, const QPalette &pal)
	Paints a region of the top-level widget. More...
virtual QPixmap	pixmapFor (const QWidget *widget, int decorationRegion, int &xoff, int &yoff)
	Returns a pointer to the QPixmap for the widget specified by widget and decorationRegion. More...
virtual int	titleBarHeight (const QWidget *widget)
	Returns the title bar height in pixels for the given widget. More...
QString	windowTitleFor (const QWidget *widget) const
virtual const char **	xpmForRegion (int region)
	Returns a pointer to the X pixmap for the icon specified by region. More...

Protected Variables
int	close_width
int	help_width
int	maximize_width
int	menu_width
int	minimize_width
int	normalize_width

Static Private Attributes
static QPixmap *	staticClosePixmap = 0
static QPixmap *	staticHelpPixmap = 0
static QPixmap *	staticMaximizePixmap = 0
static QPixmap *	staticMenuPixmap = 0
static QPixmap *	staticMinimizePixmap = 0
static QPixmap *	staticNormalizePixmap = 0

Additional Inherited Members
Public Types inherited from QDecoration
enum	DecorationRegion {   None = 0x0000000000, All = 0x7fffffff, TopLeft = 0x0000000001, Top = 0x0000000002,   TopRight = 0x0000000004, Left = 0x0000000008, Right = 0x0000000010, BottomLeft = 0x0000000020,   Bottom = 0x0000000040, BottomRight = 0x0000000080, Borders = 0x00000000ff, Menu = 0x0000000100,   Title = 0x0000000200, Help = 0x0000000400, Minimize = 0x0000000800, Maximize = 0x0000001000,   Normalize = 0x0000002000, Close = 0x0000004000, Move = 0x0000008000, Resize = 0x0000010000 }
	This enum describes the various regions of the window decoration. More...
enum	DecorationState { Normal = 0x04, Disabled = 0x08, Hover = 0x01, Pressed = 0x02 }
	This enum describes the various states of a decoration region. More...
Static Public Functions inherited from QDecoration
static void	startMove (QWidget *widget)
	Starts to move the given top level widget by making its Title region active and grabbing the mouse input. More...
static void	startResize (QWidget *widget)
	Starts to resize the given top level widget by making its BottomRight region active and grabbing the mouse input. More...

Detailed Description

The QDecorationDefault class is a base class providing default window decorations.

Since

4.4

See the documentation for class QDecoration for a detailed description. This subclass of QDecoration provides standard icons for the decoration regions.

Note that this class is non-portable and only available in Qt for Embedded Linux.

Definition at line 59 of file qdecorationdefault_qws.h.

Constructors and Destructors

QDecorationDefault()

QDecorationDefault::QDecorationDefault

(

)

Default constructor.

Definition at line 229 of file qdecorationdefault_qws.cpp.

    : QDecoration()
{
    menu_width = 20;
    help_width = 20;
    close_width = 20;
    minimize_width = 20;
    maximize_width = 20;
    normalize_width = 20;
}

~QDecorationDefault()

QDecorationDefault::~QDecorationDefault ( )

virtual

The constructor deletes the static pixmaps.

Definition at line 243 of file qdecorationdefault_qws.cpp.

{
    delete staticMenuPixmap;
    delete staticClosePixmap;
    delete staticMinimizePixmap;
    delete staticMaximizePixmap;
    delete staticNormalizePixmap;

    // This makes it safe to delete and then create a QDecorationDefault
    staticMenuPixmap = 0;
    staticClosePixmap = 0;
    staticMinimizePixmap = 0;
    staticMaximizePixmap = 0;
    staticNormalizePixmap = 0;
}

Functions

paint()

bool QDecorationDefault::paint ( QPainter *  painter, const QWidget *  widget, int  decorationRegion = All, DecorationState  state = Normal  )

virtual

Paints the border and title decoration for the top-level widget using the painter provided and the decoration state.

The value of decorationRegion is a combination of the bitmask values of enum DecorationRegion.

Note that Qt for Embedded Linux expects this function to return true if any of the widget's decorations are repainted; otherwise it returns false.

Implements QDecoration.

Reimplemented in QDecorationStyled, and QDecorationWindows.

Definition at line 644 of file qdecorationdefault_qws.cpp.

Referenced by QDecorationWindows::paint().

{
    if (decorationRegion == None)
        return false;

    const QRect titleRect = QDecoration::region(widget, Title).boundingRect();
    const QPalette pal = QApplication::palette();
    int titleHeight = titleRect.height();
    int titleWidth = titleRect.width();
    QRegion oldClipRegion = painter->clipRegion();


    Qt::WindowFlags flags = widget->windowFlags();
    bool hasBorder = !widget->isMaximized();
    bool hasTitle = flags & Qt::WindowTitleHint;
    bool hasSysMenu = flags & Qt::WindowSystemMenuHint;
    bool hasContextHelp = flags & Qt::WindowContextHelpButtonHint;
    bool hasMinimize = flags & Qt::WindowMinimizeButtonHint;
    bool hasMaximize = flags & Qt::WindowMaximizeButtonHint;

    bool paintAll = (decorationRegion == int(All));
    bool handled = false;

    bool porterDuff = painter->paintEngine()->hasFeature(QPaintEngine::PorterDuff);

    if ((paintAll || decorationRegion & Borders) && state == Normal && hasBorder) {
        if (hasTitle) { // reduce flicker
            QRect rect(widget->rect());
            QRect r(rect.left(), rect.top() - titleHeight,
                    rect.width(), titleHeight);
            painter->setClipRegion(oldClipRegion - r);
        }
        QRect br = QDecoration::region(widget).boundingRect();
        if (porterDuff)
            painter->setCompositionMode(QPainter::CompositionMode_Source);
        qDrawWinPanel(painter, br.x(), br.y(), br.width(),
                    br.height(), pal, false,
                    &pal.brush(QPalette::Window));
        if (porterDuff)
            painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
        handled |= true;
    }

    if ((paintAll || decorationRegion & Title && titleWidth > 0) && state == Normal && hasTitle) {
        painter->setClipRegion(oldClipRegion);
        QBrush titleBrush;
        QPen   titlePen;

        if (widget == qApp->activeWindow()) {
            titleBrush = pal.brush(QPalette::Highlight);
            titlePen   = pal.color(QPalette::HighlightedText);
        } else {
            titleBrush = pal.brush(QPalette::Window);
            titlePen   = pal.color(QPalette::Text);
        }

        if (porterDuff)
            painter->setCompositionMode(QPainter::CompositionMode_Source);
        qDrawShadePanel(painter,
                        titleRect.x(), titleRect.y(), titleRect.width(), titleRect.height(),
                        pal, true, 1, &titleBrush);
        if (porterDuff)
            painter->setCompositionMode(QPainter::CompositionMode_SourceOver);

        painter->setPen(titlePen);
        painter->drawText(titleRect.x() + 4, titleRect.y(),
                          titleRect.width() - 8, titleRect.height(),
                          Qt::AlignVCenter, windowTitleFor(widget));
        handled |= true;
    }

    if (state != Hover) {
        painter->setClipRegion(oldClipRegion);
        if ((paintAll || decorationRegion & Menu) && hasSysMenu) {
            paintButton(painter, widget, Menu, state, pal);
            handled |= true;
        }

        if ((paintAll || decorationRegion & Help) && hasContextHelp) {
            paintButton(painter, widget, Help, state, pal);
            handled |= true;
        }

        if ((paintAll || decorationRegion & Minimize) && hasMinimize) {
            paintButton(painter, widget, Minimize, state, pal);
            handled |= true;
        }

        if ((paintAll || decorationRegion & Maximize) && hasMaximize) {
            paintButton(painter, widget,
                        ((widget->windowState() & Qt::WindowMaximized)? Normalize : Maximize),
                        state, pal);
            handled |= true;
        }

        if (paintAll || decorationRegion & Close) {
            paintButton(painter, widget, Close, state, pal);
            handled |= true;
        }
    }
    return handled;
}

paintButton()

void QDecorationDefault::paintButton ( QPainter *  painter, const QWidget *  widget, int  buttonRegion, DecorationState  state, const QPalette &  pal  )

protectedvirtual

Paints a region of the top-level widget.

The region is painted in the specified decoration state using the painter and palette provided. The region to be painted is specified by buttonRegion, which is a combination of the bitmask values of DecorationRegion. If the value of buttonRegion is one of Help, Menu, Close, Minimize, Maximize, and Normalize, the button pixmap for that region is painted.

See also

pixmapFor()

Reimplemented in QDecorationWindows.

Definition at line 765 of file qdecorationdefault_qws.cpp.

Referenced by paint().

{
    int xoff = 2;
    int yoff = 2;

    const QPixmap pm = pixmapFor(widget, buttonRegion, xoff, yoff);
    QRect brect(QDecoration::region(widget, buttonRegion).boundingRect());
    bool porterDuff = painter->paintEngine()->hasFeature(QPaintEngine::PorterDuff);

    if (state & QDecoration::Pressed) {
        if (porterDuff)
            painter->setCompositionMode(QPainter::CompositionMode_Source);
        qDrawWinPanel(painter, brect, pal, true, &pal.brush(QPalette::Window));
        if (porterDuff)
            painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
        ++xoff;
        ++yoff;
    } else {
        painter->fillRect(brect, pal.brush(QPalette::Window));
    }

    if (!pm.isNull())
        painter->drawPixmap(brect.x() + xoff, brect.y() + yoff, pm);
}

pixmapFor()

QPixmap QDecorationDefault::pixmapFor ( const QWidget *  widget, int  decorationRegion, int &  xoff, int &  yoff  )

protectedvirtual

Returns a pointer to the QPixmap for the widget specified by widget and decorationRegion.

The returned QPixmap is constructed from the default X pixmap obtained from xpmForRegion().

xoff and yoff specify the offset for the pixmap.

The value of decorationRegion must be one of a subset of the values of enum DecorationRegion. The supported values are Help, Menu, Close, Minimize, Maximize, and Normalize. Other values of decorationRegion return 0.

See also

QDecoration::DecorationRegion

Definition at line 312 of file qdecorationdefault_qws.cpp.

Referenced by QDecorationWindows::paintButton(), and paintButton().

{
#ifdef QT_NO_IMAGEFORMAT_XPM
    Q_UNUSED(widget);
    Q_UNUSED(decorationRegion);
    Q_UNUSED(xoff);
    return QPixmap();
#else
    static const char **staticHelpPixmapXPM = 0;
    static const char **staticMenuPixmapXPM = 0;
    static const char **staticClosePixmapXPM = 0;
    static const char **staticMinimizePixmapXPM = 0;
    static const char **staticMaximizePixmapXPM = 0;
    static const char **staticNormalizePixmapXPM = 0;
    const char **xpm;

    // Why don't we just use/extend the enum type...

    if (staticHelpPixmapXPM != (xpm = xpmForRegion(Help)) || !staticHelpPixmap) {
        staticHelpPixmapXPM = xpm;
        staticHelpPixmap = new QPixmap(xpm);
    }
    if (staticMenuPixmapXPM != (xpm = xpmForRegion(Menu)) || !staticMenuPixmap) {
        staticMenuPixmapXPM = xpm;
        staticMenuPixmap = new QPixmap(xpm);
    }
    if (staticClosePixmapXPM != (xpm = xpmForRegion(Close)) || !staticClosePixmap) {
        staticClosePixmapXPM = xpm;
        staticClosePixmap = new QPixmap(xpm);
    }
    if (staticMinimizePixmapXPM != (xpm = xpmForRegion(Minimize)) || !staticMinimizePixmap) {
        staticMinimizePixmapXPM = xpm;
        staticMinimizePixmap = new QPixmap(xpm);
    }
    if (staticMaximizePixmapXPM != (xpm = xpmForRegion(Maximize)) || !staticMaximizePixmap) {
        staticMaximizePixmapXPM = xpm;
        staticMaximizePixmap = new QPixmap(xpm);
    }
    if (staticNormalizePixmapXPM != (xpm = xpmForRegion(Normalize)) || !staticNormalizePixmap) {
        staticNormalizePixmapXPM = xpm;
        staticNormalizePixmap = new QPixmap(xpm);
    }

    const QPixmap *pm = 0;

    switch (decorationRegion) {
        case Help:
            pm = staticHelpPixmap;
            break;
        case Menu:
            if (!widget->windowIcon().isNull())
                return widget->windowIcon().pixmap(16,16); //##### QIcon::pixmap() needs a size !!!!!!"
            if (!pm) {
                xoff = 1;
                pm = staticMenuPixmap;
            }
            break;
        case Close:
            pm = staticClosePixmap;
            break;
        case Maximize:
            pm = staticMaximizePixmap;
            break;
        case Normalize:
            pm = staticNormalizePixmap;
            break;
        case Minimize:
            pm = staticMinimizePixmap;
            break;
        default:
            break;
    }
    return *pm;
#endif
}

region()

QRegion QDecorationDefault::region ( const QWidget *  widget, const QRect &  rect, int  decorationRegion = All  )

virtual

Returns the region specified by decorationRegion for the top-level widget.

rect specifies the rectangle the decoration wraps. The value of decorationRegion is a combination of the bitmask values of enum DecorationRegion.

Implements QDecoration.

Reimplemented in QDecorationStyled, and QDecorationWindows.

Definition at line 409 of file qdecorationdefault_qws.cpp.

Referenced by QDecorationStyled::region(), and QDecorationWindows::region().

{
    Qt::WindowFlags flags = widget->windowFlags();
    bool hasBorder = !widget->isMaximized();
    bool hasTitle = flags & Qt::WindowTitleHint;
    bool hasSysMenu = flags & Qt::WindowSystemMenuHint;
    bool hasContextHelp = flags & Qt::WindowContextHelpButtonHint;
    bool hasMinimize = flags & Qt::WindowMinimizeButtonHint;
    bool hasMaximize = flags & Qt::WindowMaximizeButtonHint;
    int state = widget->windowState();
    bool isMinimized = state & Qt::WindowMinimized;
    bool isMaximized = state & Qt::WindowMaximized;

    int titleHeight = hasTitle ? titleBarHeight(widget) : 0;
    int bw = hasBorder ? BORDER_WIDTH : 0;
    int bbw = hasBorder ? BOTTOM_BORDER_WIDTH : 0;

    QRegion region;
    switch (decorationRegion) {
        case All: {
                QRect r(rect.left() - bw,
                        rect.top() - titleHeight - bw,
                        rect.width() + 2 * bw,
                        rect.height() + titleHeight + bw + bbw);
                region = r;
                region -= rect;
            }
            break;

        case Title: {
                QRect r(rect.left()
                        + (hasSysMenu ? menu_width : 0),
                        rect.top() - titleHeight,
                        rect.width()
                        - (hasSysMenu ? menu_width : 0)
                        - close_width
                        - (hasMaximize ? maximize_width : 0)
                        - (hasMinimize ? minimize_width : 0)
                        - (hasContextHelp ? help_width : 0),

                        titleHeight);
                if (r.width() > 0)
                    region = r;
            }
            break;

        case Top: {
                QRect r(rect.left() + CORNER_GRAB,
                        rect.top() - titleHeight - bw,
                        rect.width() - 2 * CORNER_GRAB,
                        bw);
                region = r;
            }
            break;

        case Left: {
                QRect r(rect.left() - bw,
                        rect.top() - titleHeight + CORNER_GRAB,
                        bw,
                        rect.height() + titleHeight - 2 * CORNER_GRAB);
                region = r;
            }
            break;

        case Right: {
                QRect r(rect.right() + 1,
                        rect.top() - titleHeight + CORNER_GRAB,
                        bw,
                        rect.height() + titleHeight - 2 * CORNER_GRAB);
                region = r;
            }
            break;

        case Bottom: {
                QRect r(rect.left() + CORNER_GRAB,
                        rect.bottom() + 1,
                        rect.width() - 2 * CORNER_GRAB,
                        bw);
                region = r;
            }
            break;

        case TopLeft: {
                QRect r1(rect.left() - bw,
                        rect.top() - bw - titleHeight,
                        CORNER_GRAB + bw,
                        bw);

                QRect r2(rect.left() - bw,
                        rect.top() - bw - titleHeight,
                        bw,
                        CORNER_GRAB + bw);

                region = QRegion(r1) + r2;
            }
            break;

        case TopRight: {
                QRect r1(rect.right() - CORNER_GRAB,
                        rect.top() - bw - titleHeight,
                        CORNER_GRAB + bw,
                        bw);

                QRect r2(rect.right() + 1,
                        rect.top() - bw - titleHeight,
                        bw,
                        CORNER_GRAB + bw);

                region = QRegion(r1) + r2;
            }
            break;

        case BottomLeft: {
                QRect r1(rect.left() - bw,
                        rect.bottom() + 1,
                        CORNER_GRAB + bw,
                        bw);

                QRect r2(rect.left() - bw,
                        rect.bottom() - CORNER_GRAB,
                        bw,
                        CORNER_GRAB + bw);
                region = QRegion(r1) + r2;
            }
            break;

        case BottomRight: {
                QRect r1(rect.right() - CORNER_GRAB,
                        rect.bottom() + 1,
                        CORNER_GRAB + bw,
                        bw);

                QRect r2(rect.right() + 1,
                        rect.bottom() - CORNER_GRAB,
                        bw,
                        CORNER_GRAB + bw);
                region = QRegion(r1) + r2;
            }
            break;

        case Menu: {
                if (hasSysMenu) {
                    region = QRect(rect.left(), rect.top() - titleHeight,
                                   menu_width, titleHeight);
                }
            }
            break;

        case Help: {
                if (hasContextHelp) {
                    QRect r(rect.right()
                            - close_width
                            - (hasMaximize ? maximize_width : 0)
                            - (hasMinimize ? minimize_width : 0)
                            - help_width + 1, rect.top() - titleHeight,
                            help_width, titleHeight);
                    if (r.left() > rect.left() + titleHeight)
                        region = r;
                }
            }
            break;


        case Minimize: {
                if (hasMinimize && !isMinimized) {
                    QRect r(rect.right() - close_width
                            - (hasMaximize ? maximize_width : 0)
                            - minimize_width + 1, rect.top() - titleHeight,
                            minimize_width, titleHeight);
                    if (r.left() > rect.left() + titleHeight)
                        region = r;
                }
            }
            break;

        case Maximize: {
                if (hasMaximize && !isMaximized) {
                    QRect r(rect.right() - close_width - maximize_width + 1,
                            rect.top() - titleHeight, maximize_width, titleHeight);
                    if (r.left() > rect.left() + titleHeight)
                        region = r;
                }
            }
            break;

        case Normalize: {
                if (hasMinimize && isMinimized) {
                    QRect r(rect.right() - close_width
                            - (hasMaximize ? maximize_width : 0)
                            - minimize_width + 1, rect.top() - titleHeight,
                            minimize_width, titleHeight);
                    if (r.left() > rect.left() + titleHeight)
                        region = r;
                } else if (hasMaximize && isMaximized) {
                    QRect r(rect.right() - close_width - maximize_width + 1,
                            rect.top() - titleHeight, maximize_width, titleHeight);
                    if (r.left() > rect.left() + titleHeight)
                        region = r;
                }
            }
            break;

        case Close: {
                QRect r(rect.right() - close_width + 1, rect.top() - titleHeight,
                        close_width, titleHeight);
                if (r.left() > rect.left() + titleHeight)
                    region = r;
            }
            break;

    default: {
        int i = 1;
        while (i) {
            if (i & decorationRegion)
                region += this->region(widget, rect, i);
            i <<= 1;
        }
    }
            break;
    }

    return region;
}

titleBarHeight()

int QDecorationDefault::titleBarHeight ( const QWidget *  widget )

protectedvirtual

Returns the title bar height in pixels for the given widget.

It is the greater of 20, or the sum of the application font's line spacing value plus a border width fudge factor.

Reimplemented in QDecorationStyled.

Definition at line 398 of file qdecorationdefault_qws.cpp.

Referenced by region().

{
    return qMax(20, QApplication::fontMetrics().height() + BORDER_WIDTH);
}

windowTitleFor()

QString QDecorationDefault::windowTitleFor ( const QWidget *  widget ) const

protected

Warning

This function is not part of the public interface.

Definition at line 799 of file qdecorationdefault_qws.cpp.

Referenced by QDecorationStyled::paint(), QDecorationWindows::paint(), paint(), QDecorationStyled::region(), and QDecorationStyled::titleBarHeight().

{
    return qt_setWindowTitle_helperHelper(widget->windowTitle(), widget);
}

xpmForRegion()

const char ** QDecorationDefault::xpmForRegion ( int  region )

protectedvirtual

Returns a pointer to the X pixmap for the icon specified by region.

An X pixmap is an ASCII-text-based image. The value of region must be one of a subset of the values of enum DecorationRegion. The supported values are Help, Menu, Close, Minimize, Maximize, and Normalize. Other values of region cause zero to be returned.

See also

QDecoration::DecorationRegion

Reimplemented in QDecorationWindows.

Definition at line 271 of file qdecorationdefault_qws.cpp.

Referenced by pixmapFor(), and QDecorationWindows::xpmForRegion().

{
#ifdef QT_NO_IMAGEFORMAT_XPM
    Q_UNUSED(reg);
#else
    switch(reg)
    {
    case Help:
        return (const char **)default_help_xpm;
    case Menu:
        return (const char **)default_menu_xpm;
    case Close:
        return (const char **)default_close_xpm;
    case Minimize:
        return (const char **)default_minimize_xpm;
    case Maximize:
        return (const char **)default_maximize_xpm;
    case Normalize:
        return (const char **)default_normalize_xpm;
    }
#endif
    return 0;
}

Properties

close_width

int QDecorationDefault::close_width

protected

Definition at line 81 of file qdecorationdefault_qws.h.

Referenced by QDecorationDefault(), QDecorationWindows::QDecorationWindows(), QDecorationWindows::region(), and region().

help_width

int QDecorationDefault::help_width

protected

Definition at line 80 of file qdecorationdefault_qws.h.

Referenced by QDecorationDefault(), QDecorationWindows::QDecorationWindows(), QDecorationWindows::region(), and region().

maximize_width

int QDecorationDefault::maximize_width

protected

Definition at line 83 of file qdecorationdefault_qws.h.

Referenced by QDecorationDefault(), QDecorationWindows::QDecorationWindows(), QDecorationWindows::region(), and region().

menu_width

int QDecorationDefault::menu_width

protected

Definition at line 79 of file qdecorationdefault_qws.h.

Referenced by QDecorationDefault(), QDecorationWindows::QDecorationWindows(), QDecorationWindows::region(), and region().

minimize_width

int QDecorationDefault::minimize_width

protected

Definition at line 82 of file qdecorationdefault_qws.h.

Referenced by QDecorationDefault(), QDecorationWindows::QDecorationWindows(), QDecorationWindows::region(), and region().

normalize_width

int QDecorationDefault::normalize_width

protected

Definition at line 84 of file qdecorationdefault_qws.h.

Referenced by QDecorationDefault().

staticClosePixmap

QPixmap * QDecorationDefault::staticClosePixmap = 0

staticprivate

Definition at line 89 of file qdecorationdefault_qws.h.

Referenced by pixmapFor(), and ~QDecorationDefault().

staticHelpPixmap

QPixmap * QDecorationDefault::staticHelpPixmap = 0

staticprivate

Definition at line 87 of file qdecorationdefault_qws.h.

Referenced by pixmapFor().

staticMaximizePixmap

QPixmap * QDecorationDefault::staticMaximizePixmap = 0

staticprivate

Definition at line 91 of file qdecorationdefault_qws.h.

Referenced by pixmapFor(), and ~QDecorationDefault().

staticMenuPixmap

QPixmap * QDecorationDefault::staticMenuPixmap = 0

staticprivate

Definition at line 88 of file qdecorationdefault_qws.h.

Referenced by pixmapFor(), and ~QDecorationDefault().

staticMinimizePixmap

QPixmap * QDecorationDefault::staticMinimizePixmap = 0

staticprivate

Definition at line 90 of file qdecorationdefault_qws.h.

Referenced by pixmapFor(), and ~QDecorationDefault().

staticNormalizePixmap

QPixmap * QDecorationDefault::staticNormalizePixmap = 0

staticprivate

Definition at line 92 of file qdecorationdefault_qws.h.

Referenced by pixmapFor(), and ~QDecorationDefault().

---

The documentation for this class was generated from the following files:

• /src/gui/embedded/qdecorationdefault_qws.h
• /src/gui/embedded/qdecorationdefault_qws.cpp