X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FFontInfo.h;h=b471c297194f8ec71063ff6470cd0459ea02d78f;hb=35058f35a9864f8adf9ae225d0747cd19d84122c;hp=c330c311acb5f1e4490c1f6674b285578659e07d;hpb=a040c0bc6f017d0591bbc7ad1aa590589dbc40ff;p=lyx.git diff --git a/src/FontInfo.h b/src/FontInfo.h index c330c311ac..b471c29719 100644 --- a/src/FontInfo.h +++ b/src/FontInfo.h @@ -1,102 +1,225 @@ // -*- C++ -*- -/* This file is part of - * ====================================================== - * - * LyX, The Document Processor - * - * Copyright (C) 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 +#include "Color.h" +#include "ColorCode.h" +#include "FontEnums.h" +#include "support/strfwd.h" -#include "LString.h" +namespace lyx { -/** 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 { +class Lexer; + +/// +class FontInfo +{ public: /// - FontInfo() { init(); } + FontInfo(); + /// + FontInfo( + FontFamily family, + FontSeries series, + FontShape shape, + FontSize size, + ColorCode color, + ColorCode background, + FontState emph, + FontState underbar, + FontState strikeout, + FontState uuline, + FontState uwave, + FontState noun, + FontState number) + : family_(family), series_(series), shape_(shape), size_(size), + color_(color), background_(background), paint_color_(), emph_(emph), + underbar_(underbar), strikeout_(strikeout), uuline_(uuline), + uwave_(uwave), noun_(noun), number_(number) + {} + + /// Decreases font size by one + FontInfo & decSize(); + /// Increases font size by one + FontInfo & incSize(); + + /// \name 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 uuline() const { return uuline_; } + void setUuline(FontState s) { uuline_ = s; } + FontState uwave() const { return uwave_; } + void setUwave(FontState s) { uwave_ = 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; } + //@} /// - 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); + + /// 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; } + + /// + docstring asCSS() const; - /// Does any font match our pattern? - bool exist() { - query(); - return matches != 0; + /// 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; } +private: + friend bool operator==(FontInfo const & lhs, FontInfo const & rhs); + + /// + 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 uuline_; + /// + FontState uwave_; + /// + FontState noun_; + /// + FontState number_; +}; + - /// Set new pattern - void setPattern(string const & pat); +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.uuline_ == rhs.uuline_ + && lhs.uwave_ == rhs.uwave_ + && lhs.noun_ == rhs.noun_ + && lhs.number_ == rhs.number_; +} - /** 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; +inline bool operator!=(FontInfo const & lhs, FontInfo const & rhs) +{ + return !operator==(lhs, rhs); +} - /// Corresponding name list - string * strings; +/// Sane font. +extern FontInfo const sane_font; +/// All inherit font. +extern FontInfo const inherit_font; +/// All ignore font. +extern FontInfo const ignore_font; - /// Number of matches - int matches; +/// Set family after LyX text format +void setLyXFamily(std::string const &, FontInfo &); - /// Did we query X about this font? - bool queried; +/// Set series after LyX text format +void setLyXSeries(std::string const &, FontInfo &); - /// Is this font scalable? - bool scalable; +/// Set shape after LyX text format +void setLyXShape(std::string const &, FontInfo &); - /// Which index points to scalable font entry? - int scaleindex; +/// Set size after LyX text format +void setLyXSize(std::string const &, FontInfo &); - /// Initialize empty record - void init() - { - sizes = 0; - strings = 0; - matches = 0; - queried = false; - scalable = false; - scaleindex = -1; - } +/// Sets color after LyX text format +void setLyXColor(std::string const &, FontInfo &); - /// Release allocated stuff - void release(); +/// Returns misc flag after LyX text format +FontState setLyXMisc(std::string const &); - /// Ask X11 about this font pattern - void query(); +/// Read a font specification from Lexer. Used for layout files. +FontInfo lyxRead(Lexer &, FontInfo const & fi = sane_font); + +} // namespace lyx - /// Build newly sized font string - string resize(string const &, int size) const; -}; #endif