File indexing completed on 2024-05-19 05:28:14

 /*
     This file is part of Konsole, KDE's terminal.
 
     SPDX-FileCopyrightText: 2007-2008 Robert Knight <robertknight@gmail.com>
     SPDX-FileCopyrightText: 1997, 1998 Lars Doelle <lars.doelle@on-line.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 
     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 CHARACTER_H
 #define CHARACTER_H
 
 // Qt
 #include <QHash>
 #include <span>
 
 // Local
 #include "CharacterColor.h"
 
 // std
 #include <unordered_map>
 
 namespace Konsole
 {
 
 typedef unsigned char LineProperty;
 
 constexpr auto LINE_DEFAULT = 0;
 constexpr auto LINE_WRAPPED = (1 << 0);
 constexpr auto LINE_DOUBLEWIDTH = (1 << 1);
 constexpr auto LINE_DOUBLEHEIGHT = (1 << 2);
 
 constexpr auto DEFAULT_RENDITION = 0;
 constexpr auto RE_BOLD = (1 << 0);
 constexpr auto RE_BLINK = (1 << 1);
 constexpr auto RE_UNDERLINE = (1 << 2);
 constexpr auto RE_REVERSE = (1 << 3); // Screen only
 constexpr auto RE_INTENSIVE = (1 << 3); // Widget only
 constexpr auto RE_ITALIC = (1 << 4);
 constexpr auto RE_CURSOR = (1 << 5);
 constexpr auto RE_EXTENDED_CHAR = (1 << 6);
 constexpr auto RE_FAINT = (1 << 7);
 constexpr auto RE_STRIKEOUT = (1 << 8);
 constexpr auto RE_CONCEAL = (1 << 9);
 constexpr auto RE_OVERLINE = (1 << 10);
 
 /**
  * A single character in the terminal which consists of a unicode character
  * value, foreground and background colors and a set of rendition attributes
  * which specify how it should be drawn.
  */
 class Character
 {
 public:
     /**
      * Constructs a new character.
      *
      * @param _c The unicode character value of this character.
      * @param _f The foreground color used to draw the character.
      * @param _b The color used to draw the character's background.
      * @param _r A set of rendition flags which specify how this character is to be drawn.
      */
     constexpr inline Character(quint16 _c = ' ',
                                CharacterColor _f = CharacterColor(COLOR_SPACE_DEFAULT, DEFAULT_FORE_COLOR),
                                CharacterColor _b = CharacterColor(COLOR_SPACE_DEFAULT, DEFAULT_BACK_COLOR),
                                quint8 _r = DEFAULT_RENDITION)
         : character(_c)
         , rendition(_r)
         , foregroundColor(_f)
         , backgroundColor(_b)
     {
     }
 
     union {
         /** The unicode character value for this character. */
         QChar character;
         /**
          * Experimental addition which allows a single Character instance to contain more than
          * one unicode character.
          *
          * charSequence is a hash code which can be used to look up the unicode
          * character sequence in the ExtendedCharTable used to create the sequence.
          */
         quint16 charSequence;
     };
 
     /** A combination of RENDITION flags which specify options for drawing the character. */
     quint8 rendition;
 
     /** The foreground color used to draw this character. */
     CharacterColor foregroundColor;
     /** The color used to draw this character's background. */
     CharacterColor backgroundColor;
 
     /**
      * Returns true if this character has a transparent background when
      * it is drawn with the specified @p palette.
      */
     bool isTransparent(const ColorEntry *palette) const;
     /**
      * Returns true if this character should always be drawn in bold when
      * it is drawn with the specified @p palette, independent of whether
      * or not the character has the RE_BOLD rendition flag.
      */
     ColorEntry::FontWeight fontWeight(const ColorEntry *base) const;
 
     /**
      * returns true if the format (color, rendition flag) of the compared characters is equal
      */
     bool equalsFormat(const Character &other) const;
 
     /**
      * Compares two characters and returns true if they have the same unicode character value,
      * rendition and colors.
      */
     friend bool operator==(const Character &a, const Character &b);
     /**
      * Compares two characters and returns true if they have different unicode character values,
      * renditions or colors.
      */
     friend bool operator!=(const Character &a, const Character &b);
 };
 
 inline bool operator==(const Character &a, const Character &b)
 {
     return a.character == b.character && a.rendition == b.rendition && a.foregroundColor == b.foregroundColor && a.backgroundColor == b.backgroundColor;
 }
 
 inline bool operator!=(const Character &a, const Character &b)
 {
     return a.character != b.character || a.rendition != b.rendition || a.foregroundColor != b.foregroundColor || a.backgroundColor != b.backgroundColor;
 }
 
 inline bool Character::isTransparent(const ColorEntry *base) const
 {
     return ((backgroundColor._colorSpace == COLOR_SPACE_DEFAULT) && base[backgroundColor._u + 0 + (backgroundColor._v ? BASE_COLORS : 0)].transparent)
         || ((backgroundColor._colorSpace == COLOR_SPACE_SYSTEM) && base[backgroundColor._u + 2 + (backgroundColor._v ? BASE_COLORS : 0)].transparent);
 }
 
 inline bool Character::equalsFormat(const Character &other) const
 {
     return backgroundColor == other.backgroundColor && foregroundColor == other.foregroundColor && rendition == other.rendition;
 }
 
 inline ColorEntry::FontWeight Character::fontWeight(const ColorEntry *base) const
 {
     if (backgroundColor._colorSpace == COLOR_SPACE_DEFAULT)
         return base[backgroundColor._u + 0 + (backgroundColor._v ? BASE_COLORS : 0)].fontWeight;
     else if (backgroundColor._colorSpace == COLOR_SPACE_SYSTEM)
         return base[backgroundColor._u + 2 + (backgroundColor._v ? BASE_COLORS : 0)].fontWeight;
     else
         return ColorEntry::UseCurrentFormat;
 }
 
 /**
  * A table which stores sequences of unicode characters, referenced
  * by hash keys.  The hash key itself is the same size as a unicode
  * character ( ushort ) so that it can occupy the same space in
  * a structure.
  */
 class ExtendedCharTable
 {
 public:
     /** Constructs a new character table. */
     ExtendedCharTable();
     ~ExtendedCharTable();
 
     /**
      * Adds a sequences of unicode characters to the table and returns
      * a hash code which can be used later to look up the sequence
      * using lookupExtendedChar()
      *
      * If the same sequence already exists in the table, the hash
      * of the existing sequence will be returned.
      *
      * @param unicodePoints An array of unicode character points
      * @param length Length of @p unicodePoints
      */
     ushort createExtendedChar(ushort *unicodePoints, ushort length);
     /**
      * Looks up and returns a pointer to a sequence of unicode characters
      * which was added to the table using createExtendedChar().
      *
      * @param hash The hash key returned by createExtendedChar()
      * @param length This variable is set to the length of the
      * character sequence.
      *
      * @return A unicode character sequence of size @p length.
      */
     std::span<const ushort> lookupExtendedChar(ushort hash, ushort &length) const;
 
     /** The global ExtendedCharTable instance. */
     static ExtendedCharTable instance;
 
 private:
     // calculates the hash key of a sequence of unicode points of size 'length'
     ushort extendedCharHash(ushort *unicodePoints, ushort length) const;
     // tests whether the entry in the table specified by 'hash' matches the
     // character sequence 'unicodePoints' of size 'length'
     bool extendedCharMatch(ushort hash, ushort *unicodePoints, ushort length) const;
     // internal, maps hash keys to character sequence buffers.  The first ushort
     // in each value is the length of the buffer, followed by the ushorts in the buffer
     // themselves.
     std::unordered_map<ushort, std::vector<ushort>> extendedCharTable;
 };
 
 }
 Q_DECLARE_TYPEINFO(Konsole::Character, Q_MOVABLE_TYPE);
 
 #endif // CHARACTER_H