mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-11-10 20:04:46 +00:00
2ac6d6da48
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@189 a592a061-630c-0410-9148-cb99ea01b6c8
640 lines
12 KiB
C++
640 lines
12 KiB
C++
// -*- C++ -*-
|
|
/* This file is part of
|
|
* ======================================================
|
|
*
|
|
* LyX, The Document Processor
|
|
*
|
|
* Copyright (C) 1995 Matthias Ettrich
|
|
*
|
|
*======================================================*/
|
|
|
|
#ifndef LYXFONT_H
|
|
#define LYXFONT_H
|
|
|
|
#ifdef __GNUG__
|
|
#pragma interface
|
|
#endif
|
|
|
|
#include FORMS_H_LOCATION
|
|
#include "LString.h"
|
|
#include "debug.h"
|
|
|
|
// It might happen that locale.h defines ON and OFF. This is not good
|
|
// for us, since we use these names below. But of course this is due
|
|
// to some old compilers. Than is broken when it comes to C++ scoping.
|
|
#include "gettext.h" // so that we are sure tht it won't be included
|
|
// later.
|
|
#ifdef ON
|
|
#undef ON
|
|
#endif
|
|
|
|
#ifdef OFF
|
|
#undef OFF
|
|
#endif
|
|
|
|
class LyXLex;
|
|
|
|
///
|
|
class LyXFont {
|
|
public:
|
|
/** The value INHERIT_* means that the font attribute is
|
|
inherited from the layout. In the case of layout fonts, the
|
|
attribute is inherited from the default font.
|
|
The value IGNORE_* is used with LyXFont::update() when the
|
|
attribute should not be changed.
|
|
*/
|
|
enum FONT_FAMILY {
|
|
///
|
|
ROMAN_FAMILY, // fontstruct rely on this to be 0
|
|
///
|
|
SANS_FAMILY,
|
|
///
|
|
TYPEWRITER_FAMILY,
|
|
///
|
|
SYMBOL_FAMILY,
|
|
///
|
|
INHERIT_FAMILY,
|
|
///
|
|
IGNORE_FAMILY
|
|
};
|
|
|
|
///
|
|
enum FONT_SERIES {
|
|
///
|
|
MEDIUM_SERIES, // fontstruct rely on this to be 0
|
|
///
|
|
BOLD_SERIES,
|
|
///
|
|
INHERIT_SERIES,
|
|
///
|
|
IGNORE_SERIES
|
|
};
|
|
|
|
///
|
|
enum FONT_SHAPE {
|
|
///
|
|
UP_SHAPE, // fontstruct rely on this to be 0
|
|
///
|
|
ITALIC_SHAPE,
|
|
///
|
|
SLANTED_SHAPE,
|
|
///
|
|
SMALLCAPS_SHAPE,
|
|
///
|
|
INHERIT_SHAPE,
|
|
///
|
|
IGNORE_SHAPE
|
|
};
|
|
|
|
///
|
|
enum FONT_SIZE {
|
|
///
|
|
SIZE_TINY, // fontstruct rely on this to be 0
|
|
///
|
|
SIZE_SCRIPT,
|
|
///
|
|
SIZE_FOOTNOTE,
|
|
///
|
|
SIZE_SMALL,
|
|
///
|
|
SIZE_NORMAL,
|
|
///
|
|
SIZE_LARGE,
|
|
///
|
|
SIZE_LARGER,
|
|
///
|
|
SIZE_LARGEST,
|
|
///
|
|
SIZE_HUGE,
|
|
///
|
|
SIZE_HUGER,
|
|
///
|
|
INCREASE_SIZE,
|
|
///
|
|
DECREASE_SIZE,
|
|
///
|
|
INHERIT_SIZE,
|
|
///
|
|
IGNORE_SIZE
|
|
};
|
|
|
|
/// Used for emph, underbar, noun and latex toggles
|
|
enum FONT_MISC_STATE {
|
|
///
|
|
OFF,
|
|
///
|
|
ON,
|
|
///
|
|
TOGGLE,
|
|
///
|
|
INHERIT,
|
|
///
|
|
IGNORE
|
|
};
|
|
|
|
///
|
|
enum FONT_COLOR {
|
|
///
|
|
NONE,
|
|
///
|
|
BLACK,
|
|
///
|
|
WHITE,
|
|
///
|
|
RED,
|
|
///
|
|
GREEN,
|
|
///
|
|
BLUE,
|
|
///
|
|
CYAN,
|
|
///
|
|
MAGENTA,
|
|
///
|
|
YELLOW,
|
|
///
|
|
MATH,
|
|
///
|
|
INSET,
|
|
///
|
|
INHERIT_COLOR,
|
|
///
|
|
IGNORE_COLOR
|
|
};
|
|
|
|
/// Trick to overload constructor and make it megafast
|
|
enum FONT_INIT1 {
|
|
///
|
|
ALL_INHERIT
|
|
};
|
|
///
|
|
enum FONT_INIT2 {
|
|
///
|
|
ALL_IGNORE
|
|
};
|
|
///
|
|
enum FONT_INIT3 {
|
|
///
|
|
ALL_SANE
|
|
};
|
|
|
|
///
|
|
LyXFont();
|
|
|
|
/// LyXFont x(LyXFont ...) and LyXFont x = LyXFont ...
|
|
LyXFont(LyXFont const & x);
|
|
|
|
/// Shortcut initialization
|
|
LyXFont(LyXFont::FONT_INIT1);
|
|
/// Shortcut initialization
|
|
LyXFont(LyXFont::FONT_INIT2);
|
|
/// Shortcut initialization
|
|
LyXFont(LyXFont::FONT_INIT3);
|
|
|
|
/// LyXFont x,y; x=y;
|
|
LyXFont& operator=(LyXFont const & x);
|
|
|
|
/// Decreases font size by one
|
|
LyXFont & decSize();
|
|
|
|
/// Increases font size by one
|
|
LyXFont & incSize();
|
|
|
|
///
|
|
FONT_FAMILY family() const;
|
|
|
|
///
|
|
FONT_SERIES series() const;
|
|
|
|
///
|
|
FONT_SHAPE shape() const;
|
|
|
|
///
|
|
FONT_SIZE size() const;
|
|
|
|
///
|
|
FONT_MISC_STATE emph() const;
|
|
|
|
///
|
|
FONT_MISC_STATE underbar() const;
|
|
|
|
///
|
|
FONT_MISC_STATE noun() const;
|
|
|
|
///
|
|
FONT_MISC_STATE latex() const;
|
|
|
|
///
|
|
FONT_COLOR color() const;
|
|
|
|
///
|
|
LyXFont & setFamily(LyXFont::FONT_FAMILY f);
|
|
///
|
|
LyXFont & setSeries(LyXFont::FONT_SERIES s);
|
|
///
|
|
LyXFont & setShape(LyXFont::FONT_SHAPE s);
|
|
///
|
|
LyXFont & setSize(LyXFont::FONT_SIZE s);
|
|
///
|
|
LyXFont & setEmph(LyXFont::FONT_MISC_STATE e);
|
|
///
|
|
LyXFont & setUnderbar(LyXFont::FONT_MISC_STATE u);
|
|
///
|
|
LyXFont & setNoun(LyXFont::FONT_MISC_STATE n);
|
|
///
|
|
LyXFont & setLatex(LyXFont::FONT_MISC_STATE l);
|
|
///
|
|
LyXFont & setColor(LyXFont::FONT_COLOR c);
|
|
|
|
/// Set family after LyX text format
|
|
LyXFont & setLyXFamily(string const &);
|
|
|
|
/// Set series after LyX text format
|
|
LyXFont & setLyXSeries(string const &);
|
|
|
|
/// Set shape after LyX text format
|
|
LyXFont & setLyXShape(string const &);
|
|
|
|
/// Set size after LyX text format
|
|
LyXFont & setLyXSize(string const &);
|
|
|
|
/// Returns misc flag after LyX text format
|
|
LyXFont::FONT_MISC_STATE setLyXMisc(string const &);
|
|
|
|
/// Sets color after LyX text format
|
|
LyXFont & setLyXColor(string const &);
|
|
|
|
/// Sets size after GUI name
|
|
LyXFont & setGUISize(string const &);
|
|
|
|
/// Returns size of font in LaTeX text notation
|
|
string latexSize() const;
|
|
|
|
/** Updates font settings according to request. If an
|
|
attribute is IGNORE, the attribute is left as it is. */
|
|
/*
|
|
* When toggleall=true, all properties that matches the font in use
|
|
* will have the effect that the properties is reset to the
|
|
* default. If we have a text that is TYPEWRITER_FAMILY, and is
|
|
* update()'ed with TYPEWRITER_FAMILY, the operation will be as if
|
|
* a INHERIT_FAMILY was asked for. This is necessary for the
|
|
* toggle-user-defined-style button on the toolbar.
|
|
*/
|
|
void update(LyXFont const & newfont, bool toggleall=false);
|
|
|
|
/** Reduce font to fall back to template where possible.
|
|
Equal fields are reduced to INHERIT */
|
|
void reduce(LyXFont const & tmplt);
|
|
|
|
/// Realize font from a template (INHERIT are realized)
|
|
LyXFont & realize(LyXFont const & tmplt);
|
|
|
|
/// Is a given font fully resolved?
|
|
bool resolved() const;
|
|
|
|
/// Read a font specification from LyXLex. Used for layout files.
|
|
LyXFont & lyxRead(LyXLex&);
|
|
|
|
/// Writes the changes from this font to orgfont in .lyx format in file
|
|
void lyxWriteChanges(LyXFont const & orgfont, FILE *) const;
|
|
|
|
/** Writes the head of the LaTeX needed to change to this font.
|
|
Writes to file, the head of the LaTeX needed to change to this font.
|
|
Returns number of chars written. Base is the font state active now.
|
|
*/
|
|
int latexWriteStartChanges(FILE *, LyXFont const & base) const;
|
|
|
|
/** Writes to string, the head of the LaTeX needed to change
|
|
to this font. Returns number of chars written. Base is the
|
|
font state active now.
|
|
*/
|
|
int latexWriteStartChanges(string &, LyXFont const & base) const;
|
|
|
|
/** Writes the tail of the LaTeX needd to change to this font.
|
|
Returns number of chars written. Base is the font state we want
|
|
to achieve.
|
|
*/
|
|
int latexWriteEndChanges(FILE *, LyXFont const & base) const;
|
|
|
|
/** Writes tha tail of the LaTeX needed to chagne to this font.
|
|
Returns number of chars written. Base is the font state we want
|
|
to achieve.
|
|
*/
|
|
int latexWriteEndChanges(string &, LyXFont const & base) const;
|
|
|
|
/// Build GUI description of font state
|
|
string stateText() const;
|
|
|
|
///
|
|
int maxAscent() const;
|
|
|
|
///
|
|
int maxDescent() const;
|
|
|
|
///
|
|
int ascent(char c) const;
|
|
|
|
///
|
|
int descent(char c) const;
|
|
|
|
///
|
|
int width(char c) const;
|
|
|
|
///
|
|
int textWidth(char const *s, int n) const;
|
|
|
|
///
|
|
int stringWidth(string const & s) const;
|
|
|
|
///
|
|
int signedStringWidth(string const & s) const;
|
|
|
|
/// Draws text and returns width of text
|
|
int drawText(char const*, int n, Pixmap, int baseline, int x) const;
|
|
|
|
///
|
|
int drawString(string const &, Pixmap pm, int baseline, int x) const;
|
|
|
|
///
|
|
GC getGC() const;
|
|
|
|
///
|
|
friend inline
|
|
bool operator==(LyXFont const & font1, LyXFont const & font2) {
|
|
return font1.bits == font2.bits;
|
|
}
|
|
|
|
///
|
|
friend inline
|
|
bool operator!=(LyXFont const & font1, LyXFont const & font2) {
|
|
return font1.bits != font2.bits;
|
|
}
|
|
|
|
/// compares two fonts, ignoring the setting of the Latex part.
|
|
bool equalExceptLatex(LyXFont const &) const;
|
|
|
|
private:
|
|
/// This have to be at least 32 bits, but 64 or more does not hurt
|
|
typedef unsigned int ui32;
|
|
|
|
/** Representation: bit table
|
|
Layout of bit table:
|
|
11 1111 111 122 222 222 2233
|
|
Bit 012 34 567 8901 2345 678 901 234 567 8901
|
|
FFF SS SSS SSSS CCCC EEE UUU NNN LLL
|
|
aaa ee hhh iiii oooo mmm nnn ooo aaa
|
|
mmm rr aaa zzzz llll ppp ddd uuu ttt
|
|
|
|
Some might think this is a dirty representation, but it gives
|
|
us at least 25% speed-up, so why not?
|
|
*/
|
|
ui32 bits;
|
|
|
|
///
|
|
enum FONT_POSITION {
|
|
///
|
|
Fam_Pos = 0,
|
|
///
|
|
Ser_Pos = 3,
|
|
///
|
|
Sha_Pos = 5,
|
|
///
|
|
Siz_Pos = 8,
|
|
///
|
|
Col_Pos = 12,
|
|
///
|
|
Emp_Pos = 16,
|
|
///
|
|
Und_Pos = 19,
|
|
///
|
|
Nou_Pos = 22,
|
|
///
|
|
Lat_Pos = 25
|
|
};
|
|
|
|
///
|
|
enum FONT_MASK {
|
|
///
|
|
Fam_Mask = 0x07,
|
|
///
|
|
Ser_Mask = 0x03,
|
|
///
|
|
Sha_Mask = 0x07,
|
|
///
|
|
Siz_Mask = 0x0f,
|
|
///
|
|
Col_Mask = 0x0f,
|
|
///
|
|
Misc_Mask = 0x07
|
|
};
|
|
|
|
/// Sane font
|
|
enum { sane = ui32(ROMAN_FAMILY) << Fam_Pos
|
|
| ui32(MEDIUM_SERIES) << Ser_Pos
|
|
| ui32(UP_SHAPE) << Sha_Pos
|
|
| ui32(SIZE_NORMAL) << Siz_Pos
|
|
| ui32(NONE) << Col_Pos
|
|
| ui32(OFF) << Emp_Pos
|
|
| ui32(OFF) << Und_Pos
|
|
| ui32(OFF) << Nou_Pos
|
|
| ui32(OFF) << Lat_Pos};
|
|
|
|
/// All inherit font
|
|
enum{ inherit = ui32(INHERIT_FAMILY) << Fam_Pos
|
|
| ui32(INHERIT_SERIES) << Ser_Pos
|
|
| ui32(INHERIT_SHAPE) << Sha_Pos
|
|
| ui32(INHERIT_SIZE) << Siz_Pos
|
|
| ui32(INHERIT_COLOR) << Col_Pos
|
|
| ui32(INHERIT) << Emp_Pos
|
|
| ui32(INHERIT) << Und_Pos
|
|
| ui32(INHERIT) << Nou_Pos
|
|
| ui32(INHERIT) << Lat_Pos};
|
|
|
|
/// All ignore font
|
|
enum{ ignore = ui32(IGNORE_FAMILY) << Fam_Pos
|
|
| ui32(IGNORE_SERIES) << Ser_Pos
|
|
| ui32(IGNORE_SHAPE) << Sha_Pos
|
|
| ui32(IGNORE_SIZE) << Siz_Pos
|
|
| ui32(IGNORE_COLOR) << Col_Pos
|
|
| ui32(IGNORE) << Emp_Pos
|
|
| ui32(IGNORE) << Und_Pos
|
|
| ui32(IGNORE) << Nou_Pos
|
|
| ui32(IGNORE) << Lat_Pos};
|
|
|
|
/// Updates a misc setting according to request
|
|
LyXFont::FONT_MISC_STATE setMisc(LyXFont::FONT_MISC_STATE newfont,
|
|
LyXFont::FONT_MISC_STATE org);
|
|
|
|
/// Converts logical attributes to concrete shape attribute
|
|
LyXFont::FONT_SHAPE realShape() const;
|
|
|
|
///
|
|
XFontStruct* getXFontstruct() const;
|
|
};
|
|
|
|
ostream & operator<<(ostream &, LyXFont::FONT_MISC_STATE);
|
|
|
|
inline LyXFont::LyXFont()
|
|
{
|
|
bits = sane;
|
|
}
|
|
|
|
|
|
inline LyXFont::LyXFont(LyXFont const & x)
|
|
{
|
|
bits = x.bits;
|
|
}
|
|
|
|
|
|
inline LyXFont::LyXFont(LyXFont::FONT_INIT1)
|
|
{
|
|
bits = inherit;
|
|
}
|
|
|
|
|
|
inline LyXFont::LyXFont(LyXFont::FONT_INIT2)
|
|
{
|
|
bits = ignore;
|
|
}
|
|
|
|
|
|
inline LyXFont::LyXFont(LyXFont::FONT_INIT3)
|
|
{
|
|
bits = sane;
|
|
}
|
|
|
|
|
|
inline LyXFont & LyXFont::operator=(LyXFont const & x)
|
|
{
|
|
bits = x.bits;
|
|
return *this;
|
|
}
|
|
|
|
|
|
// You don't have to understand the stuff below :-)
|
|
// It works, and it's bloody fast. (Asger)
|
|
inline LyXFont::FONT_FAMILY LyXFont::family() const
|
|
{
|
|
return LyXFont::FONT_FAMILY((bits >> Fam_Pos) & Fam_Mask);
|
|
}
|
|
|
|
|
|
inline LyXFont::FONT_SERIES LyXFont::series() const
|
|
{
|
|
return LyXFont::FONT_SERIES((bits >> Ser_Pos) & Ser_Mask);
|
|
}
|
|
|
|
|
|
inline LyXFont::FONT_SHAPE LyXFont::shape() const
|
|
{
|
|
return LyXFont::FONT_SHAPE((bits >> Sha_Pos) & Sha_Mask);
|
|
}
|
|
|
|
|
|
inline LyXFont::FONT_SIZE LyXFont::size() const
|
|
{
|
|
return LyXFont::FONT_SIZE((bits >> Siz_Pos) & Siz_Mask);
|
|
}
|
|
|
|
|
|
inline LyXFont::FONT_MISC_STATE LyXFont::emph() const
|
|
{
|
|
return LyXFont::FONT_MISC_STATE((bits >> Emp_Pos) & Misc_Mask);
|
|
}
|
|
|
|
|
|
inline LyXFont::FONT_MISC_STATE LyXFont::underbar() const
|
|
{
|
|
return LyXFont::FONT_MISC_STATE((bits >> Und_Pos) & Misc_Mask);
|
|
}
|
|
|
|
|
|
inline LyXFont::FONT_MISC_STATE LyXFont::noun() const
|
|
{
|
|
return LyXFont::FONT_MISC_STATE((bits >> Nou_Pos) & Misc_Mask);
|
|
}
|
|
|
|
|
|
inline LyXFont::FONT_MISC_STATE LyXFont::latex() const
|
|
{
|
|
return LyXFont::FONT_MISC_STATE((bits >> Lat_Pos) & Misc_Mask);
|
|
}
|
|
|
|
|
|
inline LyXFont::FONT_COLOR LyXFont::color() const
|
|
{
|
|
return LyXFont::FONT_COLOR((bits >> Col_Pos) & Col_Mask);
|
|
}
|
|
|
|
|
|
inline LyXFont & LyXFont::setFamily(LyXFont::FONT_FAMILY f)
|
|
{
|
|
bits &= ~(Fam_Mask << Fam_Pos);
|
|
bits |= ui32(f) << Fam_Pos;
|
|
return *this;
|
|
}
|
|
|
|
|
|
inline LyXFont & LyXFont::setSeries(LyXFont::FONT_SERIES s)
|
|
{
|
|
bits &= ~(Ser_Mask << Ser_Pos);
|
|
bits |= ui32(s) << Ser_Pos;
|
|
return *this;
|
|
}
|
|
|
|
|
|
inline LyXFont & LyXFont::setShape(LyXFont::FONT_SHAPE s)
|
|
{
|
|
bits &= ~(Sha_Mask << Sha_Pos);
|
|
bits |= ui32(s) << Sha_Pos;
|
|
return *this;
|
|
}
|
|
|
|
|
|
inline LyXFont & LyXFont::setSize(LyXFont::FONT_SIZE s)
|
|
{
|
|
bits &= ~(Siz_Mask << Siz_Pos);
|
|
bits |= ui32(s) << Siz_Pos;
|
|
return *this;
|
|
}
|
|
|
|
|
|
inline LyXFont & LyXFont::setEmph(LyXFont::FONT_MISC_STATE e)
|
|
{
|
|
bits &= ~(Misc_Mask << Emp_Pos);
|
|
bits |= ui32(e) << Emp_Pos;
|
|
return *this;
|
|
}
|
|
|
|
|
|
inline LyXFont & LyXFont::setUnderbar(LyXFont::FONT_MISC_STATE u)
|
|
{
|
|
bits &= ~(Misc_Mask << Und_Pos);
|
|
bits |= ui32(u) << Und_Pos;
|
|
return *this;
|
|
}
|
|
|
|
|
|
inline LyXFont & LyXFont::setNoun(LyXFont::FONT_MISC_STATE n)
|
|
{
|
|
bits &= ~(Misc_Mask << Nou_Pos);
|
|
bits |= ui32(n) << Nou_Pos;
|
|
return *this;
|
|
}
|
|
|
|
inline LyXFont & LyXFont::setLatex(LyXFont::FONT_MISC_STATE l)
|
|
{
|
|
bits &= ~(Misc_Mask << Lat_Pos);
|
|
bits |= ui32(l) << Lat_Pos;
|
|
return *this;
|
|
}
|
|
|
|
|
|
inline LyXFont & LyXFont::setColor(LyXFont::FONT_COLOR c)
|
|
{
|
|
bits &= ~(Col_Mask << Col_Pos);
|
|
bits |= ui32(c) << Col_Pos;
|
|
return *this;
|
|
}
|
|
#endif
|