rxvt-unicode/src/rxvtfont.h

#ifndef DEFAULTFONT_H_
#define DEFAULTFONT_H_

#include <X11/Xlib.h>
#if XFT
# include <X11/Xft/Xft.h>
#endif

#include <inttypes.h>

#include "encoding.h"
#include "rxvtutil.h"
#include "rxvttoolkit.h"

struct rxvt_term;

struct rxvt_fontprop
{
  enum {
    unset  = -1,
    medium = 100, bold = 200,
    roman  = 0, italic = 100,
  };
  int width, height, ascent;
  int weight, slant;
};

struct rxvt_font
{
  // managed by the fontset
  rxvt_term *term;
  void set_term (rxvt_term *term) { this->term = term; }

  char *name;
  codeset cs;
  bool loaded; // whether we tried loading it before (not whether it's loaded)
  bool can_compose; // whether the font composes glyphs itself or not, should be a class method, but.. speed....

  // managed by the font object
  int ascent, descent,
      width, height;

  void set_name (char *name_);

  rxvt_font ();
  virtual ~rxvt_font () { free (name); };

  virtual void clear () { };

  void clear_rect (rxvt_drawable &d, int x, int y, int w, int h, int color) const;

  virtual rxvt_fontprop properties () = 0;

  virtual bool load (const rxvt_fontprop &morph, bool force_prop) = 0;
  virtual bool has_char (uint32_t unicode, const rxvt_fontprop *prop, bool &careful) const = 0;

  virtual void draw (rxvt_drawable &d,
                     int x, int y,
                     const text_t *text, int len,
                     int fg, int bg) = 0;

  void unref ()
  {
    clear ();
    delete this;
  }
};

struct rxvt_fallback_font;

struct rxvt_fontset
{
  char *fontdesc;

  // must be power-of-two - 1, also has to match RS_fontMask in rxvt.h
#if USE_256_COLORS
  enum { fontCount =   7 }; // 2 extra colors bits, 2 fewer fontcount bits
#else
  enum { fontCount =  31 };
#endif

  // index of first font in set
  enum { firstFont = 2 };

  rxvt_fontset (rxvt_term *term);
  ~rxvt_fontset ();

  bool populate (const char *desc);
  void set_prop (const rxvt_fontprop &prop, bool force_prop) { this->prop = prop; this->force_prop = force_prop; }
  int find_font_idx (uint32_t unicode);
  int find_font (const char *name) const;
  bool realize_font (int i);

  rxvt_font *operator [] (int id) const
  {
    return fonts[id >> 1];
  }

  int
  find_font (unicode_t unicode)
  {
    return min<int> ((fontCount << 1) | 1, find_font_idx (unicode));
  }

private:
  rxvt_term *term;
  rxvt_fontprop prop;
  bool force_prop;
  simplevec<rxvt_font *> fonts;
  const rxvt_fallback_font *fallback;

  // this once was a "typedef xxx pagemap[256]
  // but c++ arrays are not normal types, and cannot be
  // put into containers, new doesn't work for them etc. etc.
  // so we wrap out array into an object that acts like one. doh.
  // example: C++ has no separate new and new [] forms,
  // and if pagemap is char[256], new incorrectly assumes we want to
  // allocate an array of chars instead of a single pagemap.
  struct pagemap
  {
    unsigned char cppsucks[256];
    unsigned char &operator [](int i) { return cppsucks [i]; };
  };
  vector<pagemap *> fmap;

  void clear ();
  rxvt_font *new_font (const char *name, codeset cs);
  void prepare_font (rxvt_font *font, codeset cs);
  void add_fonts (const char *desc);
  void push_font (rxvt_font *font);
};

#endif /* _DEFAULTFONT_H_ */

Revision:	1.44
Committed:	Thu Jun 17 00:49:20 2021 UTC (2 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.43:	+1 -0 lines
Log Message:	add can_compose flag tor xvt_font, to indicate whether the font handles glyph composiiton (might go away) allow rxvt_composite.expand to work with whcar_t and text_t as output, will likely change.
#	Content
1	#ifndef DEFAULTFONT_H_
2	#define DEFAULTFONT_H_
3
4	#include <X11/Xlib.h>
5	#if XFT
6	# include <X11/Xft/Xft.h>
7	#endif
8
9	#include <inttypes.h>
10
11	#include "encoding.h"
12	#include "rxvtutil.h"
13	#include "rxvttoolkit.h"
14
15	struct rxvt_term;
16
17	struct rxvt_fontprop
18	{
19	enum {
20	unset = -1,
21	medium = 100, bold = 200,
22	roman = 0, italic = 100,
23	};
24	int width, height, ascent;
25	int weight, slant;
26	};
27
28	struct rxvt_font
29	{
30	// managed by the fontset
31	rxvt_term *term;
32	void set_term (rxvt_term *term) { this->term = term; }
33
34	char *name;
35	codeset cs;
36	bool loaded; // whether we tried loading it before (not whether it's loaded)
37	bool can_compose; // whether the font composes glyphs itself or not, should be a class method, but.. speed....
38
39	// managed by the font object
40	int ascent, descent,
41	width, height;
42
43	void set_name (char *name_);
44
45	rxvt_font ();
46	virtual ~rxvt_font () { free (name); };
47
48	virtual void clear () { };
49
50	void clear_rect (rxvt_drawable &d, int x, int y, int w, int h, int color) const;
51
52	virtual rxvt_fontprop properties () = 0;
53
54	virtual bool load (const rxvt_fontprop &morph, bool force_prop) = 0;
55	virtual bool has_char (uint32_t unicode, const rxvt_fontprop *prop, bool &careful) const = 0;
56
57	virtual void draw (rxvt_drawable &d,
58	int x, int y,
59	const text_t *text, int len,
60	int fg, int bg) = 0;
61
62	void unref ()
63	{
64	clear ();
65	delete this;
66	}
67	};
68
69	struct rxvt_fallback_font;
70
71	struct rxvt_fontset
72	{
73	char *fontdesc;
74
75	// must be power-of-two - 1, also has to match RS_fontMask in rxvt.h
76	#if USE_256_COLORS
77	enum { fontCount = 7 }; // 2 extra colors bits, 2 fewer fontcount bits
78	#else
79	enum { fontCount = 31 };
80	#endif
81
82	// index of first font in set
83	enum { firstFont = 2 };
84
85	rxvt_fontset (rxvt_term *term);
86	~rxvt_fontset ();
87
88	bool populate (const char *desc);
89	void set_prop (const rxvt_fontprop &prop, bool force_prop) { this->prop = prop; this->force_prop = force_prop; }
90	int find_font_idx (uint32_t unicode);
91	int find_font (const char *name) const;
92	bool realize_font (int i);
93
94	rxvt_font *operator [] (int id) const
95	{
96	return fonts[id >> 1];
97	}
98
99	int
100	find_font (unicode_t unicode)
101	{
102	return min<int> ((fontCount << 1) \| 1, find_font_idx (unicode));
103	}
104
105	private:
106	rxvt_term *term;
107	rxvt_fontprop prop;
108	bool force_prop;
109	simplevec<rxvt_font *> fonts;
110	const rxvt_fallback_font *fallback;
111
112	// this once was a "typedef xxx pagemap[256]
113	// but c++ arrays are not normal types, and cannot be
114	// put into containers, new doesn't work for them etc. etc.
115	// so we wrap out array into an object that acts like one. doh.
116	// example: C++ has no separate new and new [] forms,
117	// and if pagemap is char[256], new incorrectly assumes we want to
118	// allocate an array of chars instead of a single pagemap.
119	struct pagemap
120	{
121	unsigned char cppsucks[256];
122	unsigned char &operator [](int i) { return cppsucks [i]; };
123	};
124	vector<pagemap *> fmap;
125
126	void clear ();
127	rxvt_font new_font (const char name, codeset cs);
128	void prepare_font (rxvt_font *font, codeset cs);
129	void add_fonts (const char *desc);
130	void push_font (rxvt_font *font);
131	};
132
133	#endif /* _DEFAULTFONT_H_ */
134