X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FFontInfo.h;h=ab1fab670dc18cdddef2c2f0cc58d134e9f9408e;hb=8a69ffd3bfaa4ab23b281a38b9a65f0a8550c997;hp=49fbbfe299eb52e0d44dab429bbbc811d82218e0;hpb=76938908d7da15b92bad3908e71eb969c9449c0e;p=lyx.git diff --git a/src/FontInfo.h b/src/FontInfo.h index 49fbbfe299..ab1fab670d 100644 --- a/src/FontInfo.h +++ b/src/FontInfo.h @@ -1,94 +1,178 @@ // -*- 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 "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( + FontFamily family, + FontSeries series, + FontShape shape, + FontSize size, + ColorCode color, + ColorCode background, + FontState emph, + FontState underbar, + FontState noun, + FontState number + ): family_(family), series_(series), shape_(shape), size_(size), + color_(color), background_(background), emph_(emph), + underbar_(underbar), 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 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; } + ///@} /// - explicit FontInfo(string const & pat) - : pattern(pat) { init(); } + void update(FontInfo const & newfont, bool toggleall); - /// Destructor - ~FontInfo() { release(); } + /** Reduce font to fall back to template where possible. + Equal fields are reduced to INHERIT */ + void reduce(FontInfo const & tmplt); - /// Does any font match our pattern? - bool exist() { - query(); - return matches != 0; - } + /// Realize font from a template (INHERIT are realized) + FontInfo & realize(FontInfo const & tmplt); + /// Is a given font fully resolved? + bool resolved() const; - /// Is this font scalable? - bool isScalable() { - query(); - return scalable; + /// + ColorCode realColor() const; + + /// 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_; } - /// Get existing pattern - string getPattern() const { return pattern; } - - /// Set new pattern - void setPattern(string const & pat); + 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; + } + } - /** 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; - - /// 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; + friend bool operator==(FontInfo const & lhs, FontInfo const & rhs); - /// Initialize empty record - void init(); - - /// Release allocated stuff - void release(); + /// + FontFamily family_; + /// + FontSeries series_; + /// + FontShape shape_; + /// + FontSize size_; + /// + ColorCode color_; + /// + ColorCode background_; + /// + FontState emph_; + /// + FontState underbar_; + /// + 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.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