X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FFontInfo.h;h=10d72354efeae4717d1a723c7922957895500a7a;hb=381b86788d382ffe26a1f24427a668b9ee1d061e;hp=450c76c44a9bf4947a96722bcddbfe85240ef7f8;hpb=1c9a8d27a26b5f76562914f0e81aa98334f8c06a;p=lyx.git diff --git a/src/FontInfo.h b/src/FontInfo.h index 450c76c44a..10d72354ef 100644 --- a/src/FontInfo.h +++ b/src/FontInfo.h @@ -1,101 +1,190 @@ // -*- C++ -*- -/* This file is part of - * ====================================================== - * - * LyX, The Document Processor - * - * Copyright 1997 Asger Alstrup - * and the LyX Team. +/** + * \file src/FontInfo.h + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * ====================================================== */ + * \author Lars Gullik Bjønnes + * \author Jean-Marc Lasgouttes + * \author Angus Leeming + * \author Dekel Tsur + * + * Full author contact details are available in file CREDITS. + */ -#ifndef FONTINFO_H -#define FONTINFO_H +#ifndef FONT_PROPERTIES_H +#define FONT_PROPERTIES_H -#ifdef __GNUG__ -#pragma interface -#endif +#ifdef TEX2LYX +#include "tex2lyx/Font.h" +#else -#include "LString.h" +#include "Color.h" +#include "ColorCode.h" +#include "FontEnums.h" -/** This class manages a font. -The idea is to create a FontInfo object with a font name pattern with a -wildcard at the size field. Then this object can host request for font- -instances of any given size. If no exact match is found, the closest size -is chosen instead. If the font is scalable, the flag lyxrc.use_scalable_fonts -determines whether to allow scalable fonts to give an exact match. */ -class FontInfo { +namespace lyx { + +/// +class FontInfo +{ public: /// - FontInfo() { init(); } - + FontInfo(); /// - FontInfo(string const & pat) - : pattern(pat) { init(); } + FontInfo( + FontFamily family, + FontSeries series, + FontShape shape, + FontSize size, + ColorCode color, + ColorCode background, + FontState emph, + FontState underbar, + FontState strikeout, + FontState noun, + FontState number) + : family_(family), series_(series), shape_(shape), size_(size), + color_(color), background_(background), paint_color_(), emph_(emph), + underbar_(underbar), strikeout_(strikeout), noun_(noun), number_(number) + {} + + /// Decreases font size by one + FontInfo & decSize(); + /// Increases font size by one + FontInfo & incSize(); + + /// Accessor methods. + ///@{ + FontFamily family() const { return family_; } + void setFamily(FontFamily f) { family_ = f; } + FontSeries series() const { return series_; } + void setSeries(FontSeries s) { series_ = s; } + FontShape shape() const { return shape_; } + void setShape(FontShape s) { shape_ = s; } + FontSize size() const { return size_; } + void setSize(FontSize s) { size_ = s; } + FontState emph() const { return emph_; } + void setEmph(FontState e) { emph_ = e; } + FontState underbar() const { return underbar_; } + void setUnderbar(FontState u) { underbar_ = u; } + FontState strikeout() const { return strikeout_; } + void setStrikeout(FontState s) { strikeout_ = s; } + FontState noun() const { return noun_; } + void setNoun(FontState n) { noun_ = n; } + FontState number() const { return number_; } + void setNumber(FontState n) { number_ = n; } + ColorCode color() const { return color_; } + void setColor(ColorCode c) { color_ = c; } + ColorCode background() const { return background_; } + void setBackground(ColorCode b) { background_ = b; } + ///@} - /// Destructor - ~FontInfo() { release(); } - - /// Does any font match our pattern? - bool exist() { - query(); - return matches != 0; + /// + void update(FontInfo const & newfont, bool toggleall); + + /** Reduce font to fall back to template where possible. + Equal fields are reduced to INHERIT */ + void reduce(FontInfo const & tmplt); + + /// Realize font from a template (INHERIT are realized) + FontInfo & realize(FontInfo const & tmplt); + /// Is a given font fully resolved? + bool resolved() const; + + /// The real color of the font. This can be the color that is + /// set for painting, the color of the font or a default color. + Color realColor() const; + /// Sets the color which is used during painting + void setPaintColor(Color c) { paint_color_ = c; } + + /// Converts logical attributes to concrete shape attribute + /// Try hard to inline this as it shows up with 4.6 % in the profiler. + FontShape realShape() const + { + if (noun_ == FONT_ON) + return SMALLCAPS_SHAPE; + if (emph_ == FONT_ON) + return (shape_ == UP_SHAPE) ? ITALIC_SHAPE : UP_SHAPE; + return shape_; } - /// Is this font scalable? - bool isScalable() { - query(); - return scalable; + bool isSymbolFont() const + { + switch (family_) { + case SYMBOL_FAMILY: + case CMSY_FAMILY: + case CMM_FAMILY: + case CMEX_FAMILY: + case MSA_FAMILY: + case MSB_FAMILY: + case WASY_FAMILY: + case ESINT_FAMILY: + return true; + default: + return false; + } } - /// Get existing pattern - string getPattern() const { return pattern; } - - /// Set new pattern - void setPattern(string const & pat); - - /** Return full name of font close to this size. - If impossible, result is the empty string */ - string getFontname(int size); private: - /// Font pattern (with wildcard for size) - string pattern; + friend bool operator==(FontInfo const & lhs, FontInfo const & rhs); - /// Available size list - int * sizes; - - /// Corresponding name list - string * strings; - - /// Number of matches - int matches; - - /// Did we query X about this font? - bool queried; - - /// Is this font scalable? - bool scalable; - - /// Which index points to scalable font entry? - int scaleindex; - - /// Initialize empty record - void init() { - sizes = 0; - strings = 0; - matches = 0; - queried = false; - scalable = false; - scaleindex = -1; - } - - /// Release allocated stuff - void release(); + /// + FontFamily family_; + /// + FontSeries series_; + /// + FontShape shape_; + /// + FontSize size_; + /// + ColorCode color_; + /// + ColorCode background_; + /// The color used for painting + Color paint_color_; + /// + FontState emph_; + /// + FontState underbar_; + /// + FontState strikeout_; + /// + FontState noun_; + /// + FontState number_; +}; - /// Ask X11 about this font pattern - void query(); - /// Build newly sized font string - string resize(string const &, int size) const; -}; +inline bool operator==(FontInfo const & lhs, FontInfo const & rhs) +{ + return lhs.family_ == rhs.family_ + && lhs.series_ == rhs.series_ + && lhs.shape_ == rhs.shape_ + && lhs.size_ == rhs.size_ + && lhs.color_ == rhs.color_ + && lhs.background_ == rhs.background_ + && lhs.emph_ == rhs.emph_ + && lhs.underbar_ == rhs.underbar_ + && lhs.strikeout_ == rhs.strikeout_ + && lhs.noun_ == rhs.noun_ + && lhs.number_ == rhs.number_; +} + + +inline bool operator!=(FontInfo const & lhs, FontInfo const & rhs) +{ + return !operator==(lhs, rhs); +} + +/// Sane font. +extern FontInfo const sane_font; +/// All inherit font. +extern FontInfo const inherit_font; +/// All ignore font. +extern FontInfo const ignore_font; + +} // namespace lyx + +#endif // TEX2LYX_FONT_H #endif