qpalette.cpp

qt-x11-opensource-src-4.1.4.tar.gz源码

        }
    }
    if(group2 >= (int)NColorGroups) {
        if(group2 == Current) {
            group2 = (ColorGroup)current_group;
        } else {
            qWarning("QPalette::brush: Unknown ColorGroup(2): %d", (int)group2);
            group2 = Active;
        }
    }
    if(group1 == group2)
        return true;
    for(int role = 0; role < (int)NColorRoles; role++) {
        if(d->br[group1][role] != d->br[group2][role])
                return false;
    }
    return true;
}

/*!
    \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 implicit sharing, and the serial number changes
    during the lazy copy operation (when the palette is actually modified), not
    during a shallow copy (copy constructor or assignment).

    \sa QPixmap QPixmapCache QCache
*/
int QPalette::serialNumber() const
{
    return d->ser_no;
}

/*!
    Returns a new QPalette that has attributes copied from \a other.
*/
QPalette QPalette::resolve(const QPalette &other) const
{
    if (*this == other && resolve_mask == other.resolve_mask
        || resolve_mask == 0) {
        QPalette o = other;
        o.resolve_mask = resolve_mask;
        return o;
    }

    QPalette palette(*this);
    palette.detach();

    for(int role = 0; role < (int)NColorRoles; role++)
        if (!(resolve_mask & (1<<role)))
            for(int grp = 0; grp < (int)NColorGroups; grp++)
                palette.d->br[grp][role] = other.d->br[grp][role];

    return palette;
}

/*!
    \fn uint QPalette::resolve() const
    \internal
*/

/*!
    \fn void QPalette::resolve(uint mask)
    \internal
*/


/*****************************************************************************
  QPalette stream functions
 *****************************************************************************/

#ifndef QT_NO_DATASTREAM

static const int NumOldRoles = 7;
static const int oldRoles[7] = { QPalette::Foreground, QPalette::Background, QPalette::Light,
                                 QPalette::Dark, QPalette::Mid, QPalette::Text, QPalette::Base };

/*!
    \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)
{
    for (int grp = 0; grp < (int)QPalette::NColorGroups; grp++) {
        if (s.version() == 1) {
            // Qt 1.x
            for (int i = 0; i < NumOldRoles; ++i)
                s << p.d->br[grp][oldRoles[i]].color();
        } else {
            int max = QPalette::NColorRoles;
            if (s.version() <= 3) // Qt 2.x
                max = 14;
            for (int r = 0; r < max; r++)
                s << p.d->br[grp][r];
        }
    }
    return s;
}

static void readV1ColorGroup(QDataStream &s, QPalette &pal, QPalette::ColorGroup grp)
{
    for (int i = 0; i < NumOldRoles; ++i) {
        QColor col;
        s >> col;
        pal.setColor(grp, (QPalette::ColorRole)oldRoles[i], col);
    }
}

/*!
    \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)
{
    if(s.version() == 1) {
        p = QPalette();
        readV1ColorGroup(s, p, QPalette::Active);
        readV1ColorGroup(s, p, QPalette::Disabled);
        readV1ColorGroup(s, p, QPalette::Inactive);
    } else {
        int max = QPalette::NColorRoles;
        if (s.version() <= 3) { // Qt 2.x
            p = QPalette();
            max = 14;
        }

        QBrush tmp;
        for(int grp = 0; grp < (int)QPalette::NColorGroups; ++grp) {
            for(int role = 0; role < max; ++role) {
                s >> tmp;
                p.setBrush((QPalette::ColorGroup)grp, (QPalette::ColorRole)role, tmp);
            }
        }
    }
    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) const
{
    return d == p.d;
}

/*!

    Sets a the group at \a cg. You can pass either brushes, pixmaps or
    plain colors for \a windowText, \a button, \a light, \a dark, \a
    mid, \a text, \a bright_text, \a base and \a window.

    \sa QBrush
*/
void QPalette::setColorGroup(ColorGroup cg, const QBrush &windowText, const QBrush &button,
                             const QBrush &light, const QBrush &dark, const QBrush &mid,
                             const QBrush &text, const QBrush &bright_text, const QBrush &base,
                             const QBrush &window)
{
    QBrush alt_base = QBrush(qt_mix_colors(base.color(), button.color()));
    QBrush mid_light = QBrush(qt_mix_colors(button.color(), light.color()));
    setColorGroup(cg, windowText, button, light, dark, mid, text, bright_text, base,
                  alt_base, window, mid_light, text,
                  QBrush(Qt::black), QBrush(Qt::darkBlue), QBrush(Qt::white),
                  QBrush(Qt::blue), QBrush(Qt::magenta));

    resolve_mask &= ~(1 << Highlight);
    resolve_mask &= ~(1 << HighlightedText);
    resolve_mask &= ~(1 << LinkVisited);
    resolve_mask &= ~(1 << Link);
}


/*!\internal*/
void
QPalette::setColorGroup(ColorGroup cg, 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 &alternate_base,
                        const QBrush &background, const QBrush &midlight,
                        const QBrush &button_text, const QBrush &shadow,
                        const QBrush &highlight, const QBrush &highlighted_text,
                        const QBrush &link, const QBrush &link_visited)
{
    detach();
    setBrush(cg, Foreground, foreground);
    setBrush(cg, Button, button);
    setBrush(cg, Light, light);
    setBrush(cg, Dark, dark);
    setBrush(cg, Mid, mid);
    setBrush(cg, Text, text);
    setBrush(cg, BrightText, bright_text);
    setBrush(cg, Base, base);
    setBrush(cg, AlternateBase, alternate_base);
    setBrush(cg, Background, background);
    setBrush(cg, Midlight, midlight);
    setBrush(cg, ButtonText, button_text);
    setBrush(cg, Shadow, shadow);
    setBrush(cg, Highlight, highlight);
    setBrush(cg, HighlightedText, highlighted_text);
    setBrush(cg, Link, link);
    setBrush(cg, LinkVisited, link_visited);
}

/*!
    \fn QPalette QPalette::copy() const

    Use simple assignment instead.
*/

/*!
    \fn QColorGroup QPalette::normal() const

    Use createColorGroup(Active) instead.
*/

/*!
    \fn void QPalette::setNormal(const QColorGroup &colorGroup)

    Use setColorGroup(Active, colorGroup) instead.
*/

/*!
    \fn QColorGroup QPalette::active() const
*/

/*!
    \fn QColorGroup QPalette::disabled() const
*/

/*!
    \fn QColorGroup QPalette::inactive() const
*/

/*!
    \fn void QPalette::setActive(const QColorGroup &colorGroup)

    Use setColorGroup(Active, colorGroup) instead.
*/

/*!
    \fn void QPalette::setDisabled(const QColorGroup &colorGroup)

    Use setColorGroup(Disabled, colorGroup) instead.
*/

/*!
    \fn void QPalette::setInactive(const QColorGroup &colorGroup)

    Use setColorGroup(Inactive, colorGroup) instead.
*/

/*! \class QColorGroup
    \compat
*/

/*! \fn QColorGroup::QColorGroup()

    Use QPalette() instead.
*/

/*! \fn 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)

    Use QPalette(\a foreground, \a button, \a light, \a dark, \a mid,
    \a text, \a bright_text, \a base, \a background) instead.
*/

/*! \fn QColorGroup::QColorGroup(const QColor &foreground, const QColor &background, \
                                 const QColor &light, const QColor &dark, const QColor &mid, \
                                 const QColor &text, const QColor &base)

    Use QColorGroup(\a foreground, \a background, \a light, \a dark,
    \a mid, \a text, \a base) instead.
*/

/*! \fn QColorGroup::QColorGroup(const QColorGroup &other)

    Use QPalette(\a other) instead.
*/

/*! \fn QColorGroup::QColorGroup(const QPalette &pal)

    Use QPalette(\a pal) instead.
*/

/*! \fn const QColor &QColorGroup::foreground() const

    Use QPalette::windowText().color() instead.
*/

/*! \fn const QColor &QColorGroup::button() const

    Use QPalette::button().color() instead.
*/

/*! \fn const QColor &QColorGroup::light() const

    Use QPalette::light().color() instead.
*/

/*! \fn const QColor &QColorGroup::dark() const

    Use QPalette::dark().color() instead.
*/

/*! \fn const QColor &QColorGroup::mid() const

    Use QPalette::mid().color() instead.
*/

/*! \fn const QColor &QColorGroup::text() const

    Use QPalette::text().color() instead.
*/

/*! \fn const QColor &QColorGroup::base() const

    Use QPalette::base().color() instead.
*/

/*! \fn const QColor &QColorGroup::background() const

    Use QPalette::window().color() instead.
*/

/*! \fn const QColor &QColorGroup::midlight() const

    Use QPalette::midlight().color() instead.
*/

/*! \fn const QColor &QColorGroup::brightText() const

    Use QPalette::brightText().color() instead.
*/

/*! \fn const QColor &QColorGroup::buttonText() const

    Use QPalette::buttonText().color() instead.
*/

/*! \fn const QColor &QColorGroup::shadow() const

    Use QPalette::shadow().color() instead.
*/

/*! \fn const QColor &QColorGroup::highlight() const

    Use QPalette::highlight().color() instead.
*/

/*! \fn const QColor &QColorGroup::highlightedText() const

    Use QPalette::highlightedText().color() instead.
*/

/*! \fn const QColor &QColorGroup::link() const

    Use QPalette::link().color() instead.
*/

/*! \fn const QColor &QColorGroup::linkVisited() const

    Use QPalette::linkVisited().color() instead.
*/

/*! \fn QDataStream &operator<<(QDataStream &ds, const QColorGroup &colorGroup)
    \relates QColorGroup
    \compat
*/

/*! \fn QDataStream &operator>>(QDataStream &ds, QColorGroup &colorGroup)
    \relates QColorGroup
    \compat
*/

/*! \fn bool QColorGroup::operator==(const QColorGroup &other) const

    Returns true if this color group is equal to \a other; otherwise
    returns false.
*/

/*! \fn bool QColorGroup::operator!=(const QColorGroup &other) const

    Returns true if this color group is not equal to \a other;
    otherwise returns false.
*/