CharacterColor.h

Go to the documentation of this file.

/*
    This file is part of Konsole, KDE's terminal.

    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
    Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301  USA.
*/

#ifndef CHARACTERCOLOR_H
#define CHARACTERCOLOR_H

// Qt
#include <QtGui/QColor>

namespace Konsole
{
class ColorEntry
{
public:
    enum FontWeight {
        Bold,
        Normal,
        UseCurrentFormat
    };

    explicit ColorEntry(QColor c,  FontWeight weight = UseCurrentFormat)
        : color(c), fontWeight(weight) {}

    ColorEntry() : fontWeight(UseCurrentFormat) {}

    void operator=(const ColorEntry& rhs) {
        color = rhs.color;
        fontWeight = rhs.fontWeight;
    }

    QColor color;

    FontWeight fontWeight;

    friend bool operator == (const ColorEntry& a, const ColorEntry& b);
    friend bool operator != (const ColorEntry& a, const ColorEntry& b);

};

inline bool operator == (const ColorEntry& a, const ColorEntry& b)
{
    return  a.color == b.color &&
            a.fontWeight == b.fontWeight;
}

inline bool operator != (const ColorEntry& a, const ColorEntry& b)
{
    return !operator==(a, b);
}

// Attributed Character Representations ///////////////////////////////

// Colors

#define BASE_COLORS   (2+8)
#define INTENSITIES   2
#define TABLE_COLORS  (INTENSITIES*BASE_COLORS)

#define DEFAULT_FORE_COLOR 0
#define DEFAULT_BACK_COLOR 1

/* CharacterColor is a union of the various color spaces.

   Assignment is as follows:

   Type  - Space        - Values

   0     - Undefined   - u:  0,      v:0        w:0
   1     - Default     - u:  0..1    v:intense  w:0
   2     - System      - u:  0..7    v:intense  w:0
   3     - Index(256)  - u: 16..255  v:0        w:0
   4     - RGB         - u:  0..255  v:0..256   w:0..256

   Default color space has two separate colors, namely
   default foreground and default background color.
*/

#define COLOR_SPACE_UNDEFINED   0
#define COLOR_SPACE_DEFAULT     1
#define COLOR_SPACE_SYSTEM      2
#define COLOR_SPACE_256         3
#define COLOR_SPACE_RGB         4

class CharacterColor
{
    friend class Character;

public:
    CharacterColor()
        : _colorSpace(COLOR_SPACE_UNDEFINED),
          _u(0),
          _v(0),
          _w(0)
    {}

    CharacterColor(quint8 colorSpace, int co)
        : _colorSpace(colorSpace),
          _u(0),
          _v(0),
          _w(0) {
        switch (colorSpace) {
        case COLOR_SPACE_DEFAULT:
            _u = co & 1;
            break;
        case COLOR_SPACE_SYSTEM:
            _u = co & 7;
            _v = (co >> 3) & 1;
            break;
        case COLOR_SPACE_256:
            _u = co & 255;
            break;
        case COLOR_SPACE_RGB:
            _u = co >> 16;
            _v = co >> 8;
            _w = co;
            break;
        default:
            _colorSpace = COLOR_SPACE_UNDEFINED;
        }
    }

    bool isValid() const {
        return _colorSpace != COLOR_SPACE_UNDEFINED;
    }

    void setIntensive();

    QColor color(const ColorEntry* palette) const;

    friend bool operator == (const CharacterColor& a, const CharacterColor& b);
    friend bool operator != (const CharacterColor& a, const CharacterColor& b);

private:
    quint8 _colorSpace;

    // bytes storing the character color
    quint8 _u;
    quint8 _v;
    quint8 _w;
};

inline bool operator == (const CharacterColor& a, const CharacterColor& b)
{
    return     a._colorSpace == b._colorSpace &&
               a._u == b._u &&
               a._v == b._v &&
               a._w == b._w;
}
inline bool operator != (const CharacterColor& a, const CharacterColor& b)
{
    return !operator==(a, b);
}

inline const QColor color256(quint8 u, const ColorEntry* base)
{
    //   0.. 16: system colors
    if (u < 8) {
        return base[u + 2].color;
    }
    u -= 8;
    if (u < 8) {
        return base[u + 2 + BASE_COLORS].color;
    }
    u -= 8;

    //  16..231: 6x6x6 rgb color cube
    if (u < 216) {
        return QColor(((u / 36) % 6) ? (40 * ((u / 36) % 6) + 55) : 0,
                      ((u / 6) % 6) ? (40 * ((u / 6) % 6) + 55) : 0,
                      ((u / 1) % 6) ? (40 * ((u / 1) % 6) + 55) : 0);
    }
    u -= 216;

    // 232..255: gray, leaving out black and white
    int gray = u * 10 + 8;

    return QColor(gray, gray, gray);
}

inline QColor CharacterColor::color(const ColorEntry* base) const
{
    switch (_colorSpace) {
    case COLOR_SPACE_DEFAULT:
        return base[_u + 0 + (_v ? BASE_COLORS : 0)].color;
    case COLOR_SPACE_SYSTEM:
        return base[_u + 2 + (_v ? BASE_COLORS : 0)].color;
    case COLOR_SPACE_256:
        return color256(_u, base);
    case COLOR_SPACE_RGB:
        return QColor(_u, _v, _w);
    case COLOR_SPACE_UNDEFINED:
        return QColor();
    }

    Q_ASSERT(false); // invalid color space

    return QColor();
}

inline void CharacterColor::setIntensive()
{
    if (_colorSpace == COLOR_SPACE_SYSTEM || _colorSpace == COLOR_SPACE_DEFAULT) {
        _v = 1;
    }
}
}

#endif // CHARACTERCOLOR_H