From bd0f3345a938b35ce6a12f6150373b0955b8dd12 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sun, 10 Jul 2011 15:24:15 -0500 Subject: Add Qt3 development HEAD version --- src/kernel/qpalette.cpp | 1224 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1224 insertions(+) create mode 100644 src/kernel/qpalette.cpp (limited to 'src/kernel/qpalette.cpp') diff --git a/src/kernel/qpalette.cpp b/src/kernel/qpalette.cpp new file mode 100644 index 0000000..a9e07f7 --- /dev/null +++ b/src/kernel/qpalette.cpp @@ -0,0 +1,1224 @@ +/**************************************************************************** +** +** Implementation of QColorGroup and QPalette classes +** +** Created : 950323 +** +** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved. +** +** This file is part of the kernel module of the Qt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free Qt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.QPL +** included in the packaging of this file. Licensees holding valid Qt +** Commercial licenses may use this file in accordance with the Qt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#include "qpalette.h" + +#ifndef QT_NO_PALETTE +#include "qdatastream.h" +#include "qcleanuphandler.h" + +/***************************************************************************** + QColorGroup member functions + *****************************************************************************/ + +/*! + \class QColorGroup qpalette.h + \brief The QColorGroup class contains a group of widget colors. + + \ingroup appearance + \ingroup graphics + \ingroup images + + A color group contains a group of colors used by widgets for + drawing themselves. We recommend that widgets use color group + roles such as "foreground" and "base" rather than literal colors + like "red" or "turquoise". The color roles are enumerated and + defined in the \l ColorRole documentation. + + The most common use of QColorGroup is like this: + + \code + QPainter p; + ... + p.setPen( colorGroup().foreground() ); + p.drawLine( ... ) + \endcode + + It is also possible to modify color groups or create new color + groups from scratch. + + The color group class can be created using three different + constructors or by modifying one supplied by Qt. The default + constructor creates an all-black color group, which can then be + modified using set functions; there's also a constructor for + specifying all the color group colors. And there is also a copy + constructor. + + We strongly recommend using a system-supplied color group and + modifying that as necessary. + + You modify a color group by calling the access functions + setColor() and setBrush(), depending on whether you want a pure + color or a pixmap pattern. + + There are also corresponding color() and brush() getters, and a + commonly used convenience function to get each ColorRole: + background(), foreground(), base(), etc. + + \sa QColor QPalette QWidget::colorGroup() +*/ + + +/*! + \enum QColorGroup::ColorRole + + The ColorRole enum defines the different symbolic color roles used + in current GUIs. + + The central roles are: + + \value Background general background color. + + \value Foreground general foreground color. + + \value Base used as background color for text entry widgets, for example; + usually white or another light color. + + \value Text the foreground color used with \c Base. Usually this + is the same as the \c Foreground, in which case it must provide good + contrast with \c Background and \c Base. + + \value Button general button background color in which buttons need a + background different from \c Background, as in the Macintosh style. + + \value ButtonText a foreground color used with the \c Button color. + + There are some color roles used mostly for 3D bevel and shadow + effects: + + \value Light lighter than \c Button color. + + \value Midlight between \c Button and \c Light. + + \value Dark darker than \c Button. + + \value Mid between \c Button and \c Dark. + + \value Shadow a very dark color. + By default, the shadow color is \c Qt::black. + + All of these are normally derived from \c Background and used in + ways that depend on that relationship. For example, buttons depend + on it to make the bevels look attractive, and Motif scroll bars + depend on \c Mid to be slightly different from \c Background. + + Selected (marked) items have two roles: + + \value Highlight a color to indicate a selected item or the + current item. By default, the highlight color is \c Qt::darkBlue. + + \value HighlightedText a text color that contrasts with \c Highlight. + By default, the highlighted text color is \c Qt::white. + + Finally, there is a special role for text that needs to be + drawn where \c Text or \c Foreground would give poor contrast, + such as on pressed push buttons: + + \value BrightText a text color that is very different from \c + Foreground and contrasts well with e.g. \c Dark. + + \value Link a text color used for unvisited hyperlinks. + By default, the link color is \c Qt::blue. + + \value LinkVisited a text color used for already visited hyperlinks. + By default, the linkvisited color is \c Qt::magenta. + + \value NColorRoles Internal. + + Note that text colors can be used for things other than just + words; text colors are \e usually used for text, but it's quite + common to use the text color roles for lines, icons, etc. + + This image shows most of the color roles in use: + \img palette.png Color Roles +*/ + + +class QColorGroupPrivate : public QShared +{ +public: + QBrush br[QColorGroup::NColorRoles]; + QColorGroupPrivate* detach() { + if ( count > 1 ) { + deref(); + QColorGroupPrivate* d = new QColorGroupPrivate; + for (int i=0; ibr[i] = br[i]; + return d; + } + return this; + } +}; + +/*! + Constructs a color group with all colors set to black. +*/ + +QColorGroup::QColorGroup() +{ + static QColorGroupPrivate* defColorGroupData = 0; + if ( !defColorGroupData ) { + static QSharedCleanupHandler defColorGroupCleanup; + defColorGroupData = new QColorGroupPrivate; + defColorGroupCleanup.set( &defColorGroupData ); + } + d = defColorGroupData; + br = d->br; + d->ref(); +} + +/*! + Constructs a color group that is an independent copy of \a other. +*/ +QColorGroup::QColorGroup( const QColorGroup& other ) +{ + d = other.d; + d->ref(); + br = d->br; +} + +/*! + Copies the colors of \a other to this color group. +*/ +QColorGroup& QColorGroup::operator =(const QColorGroup& other) +{ + if ( d != other.d ) { + if ( d->deref() ) + delete d; + d = other.d; + br = d->br; + d->ref(); + } + return *this; +} + +static QColor qt_mix_colors( QColor a, QColor b) +{ + return QColor( (a.red() + b.red()) / 2, (a.green() + b.green()) / 2, (a.blue() + b.blue()) / 2 ); +} + + +/*! + Constructs a color group. You can pass either brushes, pixmaps or + plain colors for \a foreground, \a button, \a light, \a dark, \a + mid, \a text, \a bright_text, \a base and \a background. + + \sa QBrush +*/ + QColorGroup::QColorGroup( const QBrush &foreground, const QBrush &button, + const QBrush &light, const QBrush &dark, + const QBrush &mid, const QBrush &text, + const QBrush &bright_text, const QBrush &base, + const QBrush &background) +{ + d = new QColorGroupPrivate; + br = d->br; + br[Foreground] = foreground; + br[Button] = button; + br[Light] = light; + br[Dark] = dark; + br[Mid] = mid; + br[Text] = text; + br[BrightText] = bright_text; + br[ButtonText] = text; + br[Base] = base; + br[Background] = background; + br[Midlight] = qt_mix_colors( br[Button].color(), br[Light].color() ); + br[Shadow] = Qt::black; + br[Highlight] = Qt::darkBlue; + br[HighlightedText] = Qt::white; + br[Link] = Qt::blue; + br[LinkVisited] = Qt::magenta; +} + + +/*!\obsolete + + Constructs a color group with the specified colors. The button + color will be set to the background color. +*/ + +QColorGroup::QColorGroup( const QColor &foreground, const QColor &background, + const QColor &light, const QColor &dark, + const QColor &mid, + const QColor &text, const QColor &base ) +{ + d = new QColorGroupPrivate; + br = d->br; + br[Foreground] = QBrush(foreground); + br[Button] = QBrush(background); + br[Light] = QBrush(light); + br[Dark] = QBrush(dark); + br[Mid] = QBrush(mid); + br[Text] = QBrush(text); + br[BrightText] = br[Light]; + br[ButtonText] = br[Text]; + br[Base] = QBrush(base); + br[Background] = QBrush(background); + br[Midlight] = qt_mix_colors( br[Button].color(), br[Light].color() ); + br[Shadow] = Qt::black; + br[Highlight] = Qt::darkBlue; + br[HighlightedText] = Qt::white; + br[Link] = Qt::blue; + br[LinkVisited] = Qt::magenta; +} + +/*! + Destroys the color group. +*/ + +QColorGroup::~QColorGroup() +{ + if ( d->deref() ) + delete d; +} + +/*! + Returns the color that has been set for color role \a r. + + \sa brush() ColorRole + */ +const QColor &QColorGroup::color( ColorRole r ) const +{ + return br[r].color(); +} + +/*! + Returns the brush that has been set for color role \a r. + + \sa color() setBrush() ColorRole +*/ +const QBrush &QColorGroup::brush( ColorRole r ) const +{ + return br[r]; +} + +/*! + Sets the brush used for color role \a r to a solid color \a c. + + \sa brush() setColor() ColorRole +*/ +void QColorGroup::setColor( ColorRole r, const QColor &c ) +{ + setBrush( r, QBrush(c) ); +} + +/*! + Sets the brush used for color role \a r to \a b. + + \sa brush() setColor() ColorRole +*/ +void QColorGroup::setBrush( ColorRole r, const QBrush &b ) +{ + d = d->detach(); + br = d->br; + br[r] = b; +} + + +/*! + \fn const QColor & QColorGroup::foreground() const + + Returns the foreground color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::button() const + + Returns the button color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::light() const + + Returns the light color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor& QColorGroup::midlight() const + + Returns the midlight color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::dark() const + + Returns the dark color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::mid() const + + Returns the mid color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::text() const + + Returns the text foreground color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::brightText() const + + Returns the bright text foreground color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::buttonText() const + + Returns the button text foreground color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::base() const + + Returns the base color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::background() const + + Returns the background color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::shadow() const + + Returns the shadow color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::highlight() const + + Returns the highlight color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::highlightedText() const + + Returns the highlighted text color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::link() const + + Returns the unvisited link text color of the color group. + + \sa ColorRole +*/ + +/*! + \fn const QColor & QColorGroup::linkVisited() const + + Returns the visited link text color of the color group. + + \sa ColorRole +*/ + +/*! + \fn bool QColorGroup::operator!=( const QColorGroup &g ) const + + Returns TRUE if this color group is different from \a g; otherwise + returns FALSE. + + \sa operator!=() +*/ + +/*! + Returns TRUE if this color group is equal to \a g; otherwise + returns FALSE. + + \sa operator==() +*/ + +bool QColorGroup::operator==( const QColorGroup &g ) const +{ + if ( d == g.d ) + return TRUE; + for( int r = 0 ; r < NColorRoles ; r++ ) + if ( br[r] != g.br[r] ) + return FALSE; + return TRUE; +} + + +/***************************************************************************** + QPalette member functions + *****************************************************************************/ + +/*! + \class QPalette qpalette.h + + \brief The QPalette class contains color groups for each widget state. + + \ingroup appearance + \ingroup shared + \ingroup graphics + \ingroup images + \mainclass + + A palette consists of three color groups: \e active, \e disabled, + and \e inactive. All widgets contain a palette, and all widgets in + Qt use their palette to draw themselves. This makes the user + interface easily configurable and easier to keep consistent. + + If you create a new widget we strongly recommend that you use the + colors in the palette rather than hard-coding specific colors. + + The color groups: + \list + \i The active() group is used for the window that has keyboard focus. + \i The inactive() group is used for other windows. + \i The disabled() group is used for widgets (not windows) that are + disabled for some reason. + \endlist + + Both active and inactive windows can contain disabled widgets. + (Disabled widgets are often called \e inaccessible or \e{grayed + out}.) + + In Motif style, active() and inactive() look the same. In Windows + 2000 style and Macintosh Platinum style, the two styles look + slightly different. + + There are setActive(), setInactive(), and setDisabled() functions + to modify the palette. (Qt also supports a normal() group; this is + an obsolete alias for active(), supported for backwards + compatibility.) + + Colors and brushes can be set for particular roles in any of a + palette's color groups with setColor() and setBrush(). + + You can copy a palette using the copy constructor and test to see + if two palettes are \e identical using isCopyOf(). + + \sa QApplication::setPalette(), QWidget::setPalette(), QColorGroup, QColor +*/ + +/*! + \enum QPalette::ColorGroup + + \value Disabled + \value Active + \value Inactive + \value NColorGroups + \value Normal synonym for Active +*/ + +/*! + \obsolete + + \fn const QColorGroup &QPalette::normal() const + + Returns the active color group. Use active() instead. + + \sa setActive() active() +*/ + +/*! + \obsolete + + \fn void QPalette::setNormal( const QColorGroup & cg ) + + Sets the active color group to \a cg. Use setActive() instead. + + \sa setActive() active() +*/ + + +static int palette_count = 1; + +/*! + Constructs a palette that consists of color groups with only black + colors. +*/ + +QPalette::QPalette() +{ + static QPalData *defPalData = 0; + if ( !defPalData ) { // create common palette data + defPalData = new QPalData; // for the default palette + static QSharedCleanupHandler defPalCleanup; + defPalCleanup.set( &defPalData ); + defPalData->ser_no = palette_count++; + } + data = defPalData; + data->ref(); +} + +/*!\obsolete + Constructs a palette from the \a button color. The other colors are + automatically calculated, based on this color. Background will be + the button color as well. +*/ + +QPalette::QPalette( const QColor &button ) +{ + data = new QPalData; + Q_CHECK_PTR( data ); + data->ser_no = palette_count++; + QColor bg = button, btn = button, fg, base, disfg; + int h, s, v; + bg.hsv( &h, &s, &v ); + if ( v > 128 ) { // light background + fg = Qt::black; + base = Qt::white; + disfg = Qt::darkGray; + } else { // dark background + fg = Qt::white; + base = Qt::black; + disfg = Qt::darkGray; + } + data->active = QColorGroup( fg, btn, btn.light(150), btn.dark(), + btn.dark(150), fg, Qt::white, base, bg ); + data->disabled = QColorGroup( disfg, btn, btn.light(150), btn.dark(), + btn.dark(150), disfg, Qt::white, base, bg ); + data->inactive = data->active; +} + +/*! + Constructs a palette from a \a button color and a \a background. + The other colors are automatically calculated, based on these + colors. +*/ + +QPalette::QPalette( const QColor &button, const QColor &background ) +{ + data = new QPalData; + Q_CHECK_PTR( data ); + data->ser_no = palette_count++; + QColor bg = background, btn = button, fg, base, disfg; + int h, s, v; + bg.hsv( &h, &s, &v ); + if ( v > 128 ) { // light background + fg = Qt::black; + base = Qt::white; + disfg = Qt::darkGray; + } else { // dark background + fg = Qt::white; + base = Qt::black; + disfg = Qt::darkGray; + } + data->active = QColorGroup( fg, btn, btn.light(150), btn.dark(), + btn.dark(150), fg, Qt::white, base, bg ); + data->disabled = QColorGroup( disfg, btn, btn.light(150), btn.dark(), + btn.dark(150), disfg, Qt::white, base, bg ); + data->inactive = data->active; +} + +/*! + Constructs a palette that consists of the three color groups \a + active, \a disabled and \a inactive. See the \link #details + Detailed Description\endlink for definitions of the color groups + and \l QColorGroup::ColorRole for definitions of each color role + in the three groups. + + \sa QColorGroup QColorGroup::ColorRole QPalette +*/ + +QPalette::QPalette( const QColorGroup &active, const QColorGroup &disabled, + const QColorGroup &inactive ) +{ + data = new QPalData; + Q_CHECK_PTR( data ); + data->ser_no = palette_count++; + data->active = active; + data->disabled = disabled; + data->inactive = inactive; +} + +/*! + Constructs a copy of \a p. + + This constructor is fast (it uses copy-on-write). +*/ + +QPalette::QPalette( const QPalette &p ) +{ + data = p.data; + data->ref(); +} + +/*! + Destroys the palette. +*/ + +QPalette::~QPalette() +{ + if ( data->deref() ) + delete data; +} + +/*! + Assigns \a p to this palette and returns a reference to this + palette. + + This is fast (it uses copy-on-write). + + \sa copy() +*/ + +QPalette &QPalette::operator=( const QPalette &p ) +{ + p.data->ref(); + if ( data->deref() ) + delete data; + data = p.data; + return *this; +} + + +/*! + Returns the color in color group \a gr, used for color role \a r. + + \sa brush() setColor() QColorGroup::ColorRole +*/ +const QColor &QPalette::color( ColorGroup gr, QColorGroup::ColorRole r ) const +{ + return directBrush( gr, r ).color(); +} + +/*! + Returns the brush in color group \a gr, used for color role \a r. + + \sa color() setBrush() QColorGroup::ColorRole +*/ +const QBrush &QPalette::brush( ColorGroup gr, QColorGroup::ColorRole r ) const +{ + return directBrush( gr, r ); +} + +/*! + Sets the brush in color group \a gr, used for color role \a r, to + the solid color \a c. + + \sa setBrush() color() QColorGroup::ColorRole +*/ +void QPalette::setColor( ColorGroup gr, QColorGroup::ColorRole r, + const QColor &c) +{ + setBrush( gr, r, QBrush(c) ); +} + +/*! + Sets the brush in color group \a gr, used for color role \a r, to + \a b. + + \sa brush() setColor() QColorGroup::ColorRole +*/ +void QPalette::setBrush( ColorGroup gr, QColorGroup::ColorRole r, + const QBrush &b) +{ + detach(); + data->ser_no = palette_count++; + directSetBrush( gr, r, b); +} + +/*! + \overload + + Sets the brush color used for color role \a r to color \a c in all + three color groups. + + \sa color() setBrush() QColorGroup::ColorRole +*/ +void QPalette::setColor( QColorGroup::ColorRole r, const QColor &c ) +{ + setBrush( r, QBrush(c) ); +} + +/*! + \overload + + Sets the brush in for color role \a r in all three color groups to + \a b. + + \sa brush() setColor() QColorGroup::ColorRole active() inactive() disabled() +*/ +void QPalette::setBrush( QColorGroup::ColorRole r, const QBrush &b ) +{ + detach(); + data->ser_no = palette_count++; + directSetBrush( Active, r, b ); + directSetBrush( Disabled, r, b ); + directSetBrush( Inactive, r, b ); +} + + +/*! + Returns a deep copy of this palette. + + \warning This is slower than the copy constructor and assignment + operator and offers no benefits. +*/ + +QPalette QPalette::copy() const +{ + QPalette p( data->active, data->disabled, data->inactive ); + return p; +} + + +/*! + Detaches this palette from any other QPalette objects with which + it might implicitly share QColorGroup objects. In essence, does + the copying part of copy-on-write. + + Calling this should generally not be necessary; QPalette calls it + itself when necessary. +*/ + +void QPalette::detach() +{ + if ( data->count != 1 ) + *this = copy(); +} + +/*! + \fn const QColorGroup & QPalette::disabled() const + + Returns the disabled color group of this palette. + + \sa QColorGroup, setDisabled(), active(), inactive() +*/ + +/*! + Sets the \c Disabled color group to \a g. + + \sa disabled() setActive() setInactive() +*/ + +void QPalette::setDisabled( const QColorGroup &g ) +{ + detach(); + data->ser_no = palette_count++; + data->disabled = g; +} + +/*! + \fn const QColorGroup & QPalette::active() const + + Returns the active color group of this palette. + + \sa QColorGroup, setActive(), inactive(), disabled() +*/ + +/*! + Sets the \c Active color group to \a g. + + \sa active() setDisabled() setInactive() QColorGroup +*/ + +void QPalette::setActive( const QColorGroup &g ) +{ + detach(); + data->ser_no = palette_count++; + data->active = g; +} + +/*! + \fn const QColorGroup & QPalette::inactive() const + + Returns the inactive color group of this palette. + + \sa QColorGroup, setInactive(), active(), disabled() +*/ + +/*! + Sets the \c Inactive color group to \a g. + + \sa active() setDisabled() setActive() QColorGroup +*/ + +void QPalette::setInactive( const QColorGroup &g ) +{ + detach(); + data->ser_no = palette_count++; + data->inactive = g; +} + + +/*! + \fn bool QPalette::operator!=( const QPalette &p ) const + + Returns TRUE (slowly) if this palette is different from \a p; + otherwise returns FALSE (usually quickly). +*/ + +/*! + Returns TRUE (usually quickly) if this palette is equal to \a p; + otherwise returns FALSE (slowly). +*/ + +bool QPalette::operator==( const QPalette &p ) const +{ + return data->active == p.data->active && + data->disabled == p.data->disabled && + data->inactive == p.data->inactive; +} + + +/*! + \fn int QPalette::serialNumber() const + + Returns a number that uniquely identifies this QPalette object. + The serial number is intended for caching. Its value may not be + used for anything other than equality testing. + + Note that QPalette uses copy-on-write, and the serial number + changes during the lazy copy operation (detach()), not during a + shallow copy (copy constructor or assignment). + + \sa QPixmap QPixmapCache QCache +*/ + + +/***************************************************************************** + QColorGroup/QPalette stream functions + *****************************************************************************/ + +#ifndef QT_NO_DATASTREAM +/*! + \relates QColorGroup + + Writes color group, \a g to the stream \a s. + + \sa \link datastreamformat.html Format of the QDataStream operators \endlink +*/ + +QDataStream &operator<<( QDataStream &s, const QColorGroup &g ) +{ + if ( s.version() == 1 ) { + // Qt 1.x + s << g.foreground() + << g.background() + << g.light() + << g.dark() + << g.mid() + << g.text() + << g.base(); + } else { + int max = QColorGroup::NColorRoles; + if ( s.version() <= 3) // Qt 2.x + max = 14; + + for( int r = 0 ; r < max ; r++ ) + s << g.brush( (QColorGroup::ColorRole)r); + } + return s; +} + +/*! + \related QColorGroup + + Reads a color group from the stream. + + \sa \link datastreamformat.html Format of the QDataStream operators \endlink +*/ + +QDataStream &operator>>( QDataStream &s, QColorGroup &g ) +{ + if ( s.version() == 1 ) { + // Qt 1.x + QColor fg, bg, light, dark, mid, text, base; + s >> fg >> bg >> light >> dark >> mid >> text >> base; + QPalette p( bg ); + QColorGroup n( p.active() ); + n.setColor( QColorGroup::Foreground, fg ); + n.setColor( QColorGroup::Light, light ); + n.setColor( QColorGroup::Dark, dark ); + n.setColor( QColorGroup::Mid, mid ); + n.setColor( QColorGroup::Text, text ); + n.setColor( QColorGroup::Base, base ); + g = n; + } else { + int max = QColorGroup::NColorRoles; + if (s.version() <= 3) // Qt 2.x + max = 14; + + QBrush tmp; + for( int r = 0 ; r < max; r++ ) { + s >> tmp; + g.setBrush( (QColorGroup::ColorRole)r, tmp); + } + } + return s; +} + + +/*! + \relates QPalette + + Writes the palette, \a p to the stream \a s and returns a + reference to the stream. + + \sa \link datastreamformat.html Format of the QDataStream operators \endlink +*/ + +QDataStream &operator<<( QDataStream &s, const QPalette &p ) +{ + return s << p.active() + << p.disabled() + << p.inactive(); +} + + +static void readV1ColorGroup( QDataStream &s, QColorGroup &g, + QPalette::ColorGroup r ) +{ + QColor fg, bg, light, dark, mid, text, base; + s >> fg >> bg >> light >> dark >> mid >> text >> base; + QPalette p( bg ); + QColorGroup n; + switch ( r ) { + case QPalette::Disabled: + n = p.disabled(); + break; + case QPalette::Inactive: + n = p.inactive(); + break; + default: + n = p.active(); + break; + } + n.setColor( QColorGroup::Foreground, fg ); + n.setColor( QColorGroup::Light, light ); + n.setColor( QColorGroup::Dark, dark ); + n.setColor( QColorGroup::Mid, mid ); + n.setColor( QColorGroup::Text, text ); + n.setColor( QColorGroup::Base, base ); + g = n; +} + + +/*! + \relates QPalette + + Reads a palette from the stream, \a s into the palette \a p, and + returns a reference to the stream. + + \sa \link datastreamformat.html Format of the QDataStream operators \endlink +*/ + +QDataStream &operator>>( QDataStream &s, QPalette &p ) +{ + QColorGroup active, disabled, inactive; + if ( s.version() == 1 ) { + readV1ColorGroup( s, active, QPalette::Active ); + readV1ColorGroup( s, disabled, QPalette::Disabled ); + readV1ColorGroup( s, inactive, QPalette::Inactive ); + } else { + s >> active >> disabled >> inactive; + } + QPalette newpal( active, disabled, inactive ); + p = newpal; + return s; +} +#endif //QT_NO_DATASTREAM + +/*! + Returns TRUE if this palette and \a p are copies of each other, + i.e. one of them was created as a copy of the other and neither + was subsequently modified; otherwise returns FALSE. This is much + stricter than equality. + + \sa operator=() operator==() +*/ + +bool QPalette::isCopyOf( const QPalette & p ) +{ + return data && data == p.data; +} + +const QBrush &QPalette::directBrush( ColorGroup gr, QColorGroup::ColorRole r ) const +{ + if ( (uint)gr > (uint)QPalette::NColorGroups ) { +#if defined(QT_CHECK_RANGE) + qWarning( "QPalette::directBrush: colorGroup(%i) out of range", gr ); +#endif + return data->active.br[QColorGroup::Foreground]; + } + if ( (uint)r >= (uint)QColorGroup::NColorRoles ) { +#if defined(QT_CHECK_RANGE) + qWarning( "QPalette::directBrush: colorRole(%i) out of range", r ); +#endif + return data->active.br[QColorGroup::Foreground]; + } + switch( gr ) { + case Active: + return data->active.br[r]; + //break; + case Disabled: + return data->disabled.br[r]; + //break; + case Inactive: + return data->inactive.br[r]; + //break; + default: + break; + } +#if defined(QT_CHECK_RANGE) + qWarning( "QPalette::directBrush: colorGroup(%i) internal error", gr ); +#endif + return data->active.br[QColorGroup::Foreground]; // Satisfy compiler +} + +void QPalette::directSetBrush( ColorGroup gr, QColorGroup::ColorRole r, const QBrush& b) +{ + if ( (uint)gr > (uint)QPalette::NColorGroups ) { +#if defined(QT_CHECK_RANGE) + qWarning( "QPalette::directBrush: colorGroup(%i) out of range", gr ); +#endif + return; + } + if ( (uint)r >= (uint)QColorGroup::NColorRoles ) { +#if defined(QT_CHECK_RANGE) + qWarning( "QPalette::directBrush: colorRole(%i) out of range", r ); +#endif + return; + } + switch( gr ) { + case Active: + data->active.setBrush(r,b); + break; + case Disabled: + data->disabled.setBrush(r,b); + break; + case Inactive: + data->inactive.setBrush(r,b); + break; + default: +#if defined(QT_CHECK_RANGE) + qWarning( "QPalette::directBrush: colorGroup(%i) internal error", gr ); +#endif + break; + } +} + + +/*!\internal*/ +QColorGroup::ColorRole QPalette::foregroundRoleFromMode( Qt::BackgroundMode mode ) +{ + switch (mode) { + case Qt::PaletteButton: + return QColorGroup::ButtonText; + case Qt::PaletteBase: + return QColorGroup::Text; + case Qt::PaletteDark: + case Qt::PaletteShadow: + return QColorGroup::Light; + case Qt::PaletteHighlight: + return QColorGroup::HighlightedText; + case Qt::PaletteBackground: + default: + return QColorGroup::Foreground; + } +} + +/*!\internal*/ +QColorGroup::ColorRole QPalette::backgroundRoleFromMode( Qt::BackgroundMode mode) +{ + switch (mode) { + case Qt::PaletteForeground: + return QColorGroup::Foreground; + case Qt::PaletteButton: + return QColorGroup::Button; + case Qt::PaletteLight: + return QColorGroup::Light; + case Qt::PaletteMidlight: + return QColorGroup::Midlight; + case Qt::PaletteDark: + return QColorGroup::Dark; + case Qt::PaletteMid: + return QColorGroup::Mid; + case Qt::PaletteText: + return QColorGroup::Text; + case Qt::PaletteBrightText: + return QColorGroup::BrightText; + case Qt::PaletteButtonText: + return QColorGroup::ButtonText; + case Qt::PaletteBase: + return QColorGroup::Base; + case Qt::PaletteShadow: + return QColorGroup::Shadow; + case Qt::PaletteHighlight: + return QColorGroup::Highlight; + case Qt::PaletteHighlightedText: + return QColorGroup::HighlightedText; + case Qt::PaletteLink: + return QColorGroup::Link; + case Qt::PaletteLinkVisited: + return QColorGroup::LinkVisited; + case Qt::PaletteBackground: + default: + return QColorGroup::Background; + } +} + +#endif // QT_NO_PALETTE -- cgit v1.2.1