rxvt-unicode/src/rxvttoolkit.h

/*----------------------------------------------------------------------*
 * File:        rxvttoolkit.h - provide toolkit-functionality for rxvt.
 *----------------------------------------------------------------------*
 *
 * All portions of code are copyright by their respective author/s.
 * Copyright (c) 2003-2006 Marc Lehmann <pcg@goof.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *----------------------------------------------------------------------*/

#ifndef RXVT_TOOLKIT_H
#define RXVT_TOOLKIT_H

#include <X11/Xlib.h>

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

#include "ev_cpp.h"

#include "rxvtlib.h"
#include "rxvtutil.h"

#include "callback.h"

// see rxvttoolkit.C:xa_names, which must be kept in sync
enum {
  XA_TEXT,
  XA_COMPOUND_TEXT,
  XA_UTF8_STRING,
  XA_MULTIPLE,
  XA_TARGETS,
  XA_TIMESTAMP,
  XA_VT_SELECTION,
  XA_INCR,
  XA_WM_PROTOCOLS,
  XA_WM_DELETE_WINDOW,
  XA_CLIPBOARD,
  XA_AVERAGE_WIDTH,
  XA_WEIGHT_NAME,
  XA_SLANT,
  XA_CHARSET_REGISTRY,
  XA_CHARSET_ENCODING,
#if ENABLE_FRILLS
  XA_MOTIF_WM_HINTS,
#endif
#if ENABLE_EWMH
  XA_NET_WM_PID,
  XA_NET_WM_NAME,
  XA_NET_WM_ICON_NAME,
  XA_NET_WM_PING,
#endif
#if USE_XIM
  XA_WM_LOCALE_NAME,
  XA_XIM_SERVERS,
#endif
#if ENABLE_TRANSPARENCY
  XA_XROOTPMAP_ID,
  XA_ESETROOT_PMAP_ID,
#endif
#if ENABLE_XEMBED
  XA_XEMBED,
  XA_XEMBED_INFO,
#endif
#if !ENABLE_MINIMAL
  // these are usually allocated by other subsystens, but we do it
  // here to avoid a server roundtrip.
  XA_SCREEN_RESOURCES,
  XA_XDCCC_LINEAR_RGB_CORRECTION,
  XA_XDCCC_LINEAR_RGB_MATRICES,
  XA_WM_COLORMAP_WINDOWS,
  XA_WM_STATE,
  XA_cursor,
# if USE_XIM
  // various selection targets used by XIM
  XA_TRANSPORT,
  XA_LOCALES,
  XA__XIM_PROTOCOL,
  XA__XIM_XCONNECT,
  XA__XIM_MOREDATA,
# endif
#endif
  NUM_XA
};

struct rxvt_term;
struct rxvt_display;

struct im_watcher;
struct xevent_watcher;

template<class watcher>
struct event_vec : vector<watcher *>
{
  void erase_unordered (unsigned int pos)
  {
    watcher *w = (*this)[this->size () - 1];
    this->pop_back ();

    if (!this->empty ())
      if (((*this)[pos] = w)) // '=' is correct!
        w->active = pos + 1;
  }
};

struct rxvt_watcher
{
  int active; /* 0 == inactive, else index into respective vector */

  bool is_active () { return active; }

  rxvt_watcher () : active (0) { }
};

struct refcounted
{
  int referenced;
  char *id;

  refcounted (const char *id);
  bool ref_init () { return false; }
  void ref_next () { }
  ~refcounted ();
};

template<class T>
struct refcache : vector<T *>
{
  T *get (const char *id);
  void put (T *obj);
  void clear ();

  ~refcache ()
  {
    clear ();
  }
};

/////////////////////////////////////////////////////////////////////////////

struct rxvt_screen;

struct rxvt_drawable
{
  rxvt_screen *screen;
  Drawable drawable;
  operator Drawable() { return drawable; }

#if XFT
  XftDraw *xftdrawable;
  operator XftDraw *();
#endif

  rxvt_drawable (rxvt_screen *screen, Drawable drawable)
  : screen(screen),
#if XFT
    xftdrawable(0),
#endif
    drawable(drawable)
  { }

#if XFT
  ~rxvt_drawable ();
#endif
};

/////////////////////////////////////////////////////////////////////////////

#ifdef USE_XIM
struct rxvt_xim : refcounted
{
  void destroy ();
  rxvt_display *display;

//public
  XIM xim;

  rxvt_xim (const char *id) : refcounted (id) { }
  bool ref_init ();
  ~rxvt_xim ();
};
#endif

struct rxvt_screen
{
  rxvt_display *display;
  Display *dpy;
  int depth;
  Visual *visual;
  Colormap cmap;

#if XFT
  // scratch pixmap
  rxvt_drawable *scratch_area;
  int scratch_w, scratch_h;

  rxvt_drawable &scratch_drawable (int w, int h);

  rxvt_screen ();
#endif

  void set (rxvt_display *disp);
  void select_visual (int bitdepth);
  void clear ();
};

struct rxvt_display : refcounted
{
  event_vec<xevent_watcher> xw;

  ev::prepare flush_ev; void flush_cb (ev::prepare &w, int revents);
  ev::io      x_ev    ; void x_cb     (ev::io      &w, int revents);

#ifdef USE_XIM
  refcache<rxvt_xim> xims;
  vector<im_watcher *> imw;

  void im_change_cb ();
  void im_change_check ();
#endif

//public
  Display   *dpy;
  int       screen;
  Window    root;
  rxvt_term *selection_owner;
  Atom      xa[NUM_XA];
  bool      is_local;
#ifdef POINTER_BLANK
  Cursor    blank_cursor;
#endif

  rxvt_display (const char *id);
  XrmDatabase get_resources (bool refresh);
  bool ref_init ();
  void ref_next ();
  ~rxvt_display ();

  void flush ();
  Atom atom (const char *name);
  void set_selection_owner (rxvt_term *owner);

  void reg (xevent_watcher *w);
  void unreg (xevent_watcher *w);

#ifdef USE_XIM
  void reg (im_watcher *w);
  void unreg (im_watcher *w);

  rxvt_xim *get_xim (const char *locale, const char *modifiers);
  void put_xim (rxvt_xim *xim);
#endif
};

#ifdef USE_XIM
struct im_watcher : rxvt_watcher, callback<void (void)> {
  void start (rxvt_display *display)
  {
    display->reg (this);
  }

  void stop (rxvt_display *display)
  {
    display->unreg (this);
  }
};
#endif

struct xevent_watcher : rxvt_watcher, callback<void (XEvent &)>
{
  Window window;

  void start (rxvt_display *display, Window window)
  {
    this->window = window;
    display->reg (this);
  }

  void stop (rxvt_display *display)
  {
    display->unreg (this);
  }
};

extern refcache<rxvt_display> displays;

/////////////////////////////////////////////////////////////////////////////

typedef unsigned long Pixel;

struct rgba
{
  unsigned short r, g, b, a;

  enum { MIN_CC = 0x0000, MAX_CC  = 0xffff };

  rgba ()
  { }

  rgba (unsigned short r, unsigned short g, unsigned short b, unsigned short a = MAX_CC)
  : r(r), g(g), b(b), a(a)
  { }
};

struct rxvt_color
{
#if XFT
  XftColor c;
#else
  XColor c;
#endif

  operator Pixel () const { return c.pixel; }

  bool operator == (const rxvt_color &b) const { return Pixel (*this) == Pixel (b); }
  bool operator != (const rxvt_color &b) const { return Pixel (*this) != Pixel (b); }

  bool alloc (rxvt_screen *screen, const rgba &color);
  void free (rxvt_screen *screen);

  void get (rgba &color);
  void get (XColor &color);

  bool set (rxvt_screen *screen, const char *name);
  bool set (rxvt_screen *screen, const rgba &color);

  void fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to = rgba (0, 0, 0));
};

#if TRACE_PIXMAPS
Pixmap trace_XCreatePixmap (const char *file, int line, Display *dpy, Window r, unsigned int w, unsigned int h, unsigned int d);
void trace_XFreePixmap (const char *file, int line, Display *dpy, Pixmap p);

# define XCreatePixmap(dpy,r,w,h,d) trace_XCreatePixmap (__FILE__,__LINE__,dpy,r,w,h,d)
# define XFreePixmap(dpy,p) trace_XFreePixmap (__FILE__,__LINE__,dpy,p)
#endif

#endif

Revision:	1.38
Committed:	Fri Dec 14 05:25:26 2007 UTC (16 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.37:	+2 -1 lines
Log Message:	* empty log message *
#	Content
1	/----------------------------------------------------------------------
2	* File: rxvttoolkit.h - provide toolkit-functionality for rxvt.
3	----------------------------------------------------------------------
4	*
5	* All portions of code are copyright by their respective author/s.
6	* Copyright (c) 2003-2006 Marc Lehmann <pcg@goof.com>
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or
11	* (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	----------------------------------------------------------------------/
22
23	#ifndef RXVT_TOOLKIT_H
24	#define RXVT_TOOLKIT_H
25
26	#include <X11/Xlib.h>
27
28	#if XFT
29	# include <X11/Xft/Xft.h>
30	#endif
31
32	#include "ev_cpp.h"
33
34	#include "rxvtlib.h"
35	#include "rxvtutil.h"
36
37	#include "callback.h"
38
39	// see rxvttoolkit.C:xa_names, which must be kept in sync
40	enum {
41	XA_TEXT,
42	XA_COMPOUND_TEXT,
43	XA_UTF8_STRING,
44	XA_MULTIPLE,
45	XA_TARGETS,
46	XA_TIMESTAMP,
47	XA_VT_SELECTION,
48	XA_INCR,
49	XA_WM_PROTOCOLS,
50	XA_WM_DELETE_WINDOW,
51	XA_CLIPBOARD,
52	XA_AVERAGE_WIDTH,
53	XA_WEIGHT_NAME,
54	XA_SLANT,
55	XA_CHARSET_REGISTRY,
56	XA_CHARSET_ENCODING,
57	#if ENABLE_FRILLS
58	XA_MOTIF_WM_HINTS,
59	#endif
60	#if ENABLE_EWMH
61	XA_NET_WM_PID,
62	XA_NET_WM_NAME,
63	XA_NET_WM_ICON_NAME,
64	XA_NET_WM_PING,
65	#endif
66	#if USE_XIM
67	XA_WM_LOCALE_NAME,
68	XA_XIM_SERVERS,
69	#endif
70	#if ENABLE_TRANSPARENCY
71	XA_XROOTPMAP_ID,
72	XA_ESETROOT_PMAP_ID,
73	#endif
74	#if ENABLE_XEMBED
75	XA_XEMBED,
76	XA_XEMBED_INFO,
77	#endif
78	#if !ENABLE_MINIMAL
79	// these are usually allocated by other subsystens, but we do it
80	// here to avoid a server roundtrip.
81	XA_SCREEN_RESOURCES,
82	XA_XDCCC_LINEAR_RGB_CORRECTION,
83	XA_XDCCC_LINEAR_RGB_MATRICES,
84	XA_WM_COLORMAP_WINDOWS,
85	XA_WM_STATE,
86	XA_cursor,
87	# if USE_XIM
88	// various selection targets used by XIM
89	XA_TRANSPORT,
90	XA_LOCALES,
91	XA__XIM_PROTOCOL,
92	XA__XIM_XCONNECT,
93	XA__XIM_MOREDATA,
94	# endif
95	#endif
96	NUM_XA
97	};
98
99	struct rxvt_term;
100	struct rxvt_display;
101
102	struct im_watcher;
103	struct xevent_watcher;
104
105	template<class watcher>
106	struct event_vec : vector<watcher *>
107	{
108	void erase_unordered (unsigned int pos)
109	{
110	watcher w = (this)[this->size () - 1];
111	this->pop_back ();
112
113	if (!this->empty ())
114	if (((*this)[pos] = w)) // '=' is correct!
115	w->active = pos + 1;
116	}
117	};
118
119	struct rxvt_watcher
120	{
121	int active; /* 0 == inactive, else index into respective vector */
122
123	bool is_active () { return active; }
124
125	rxvt_watcher () : active (0) { }
126	};
127
128	struct refcounted
129	{
130	int referenced;
131	char *id;
132
133	refcounted (const char *id);
134	bool ref_init () { return false; }
135	void ref_next () { }
136	~refcounted ();
137	};
138
139	template<class T>
140	struct refcache : vector<T *>
141	{
142	T get (const char id);
143	void put (T *obj);
144	void clear ();
145
146	~refcache ()
147	{
148	clear ();
149	}
150	};
151
152	/////////////////////////////////////////////////////////////////////////////
153
154	struct rxvt_screen;
155
156	struct rxvt_drawable
157	{
158	rxvt_screen *screen;
159	Drawable drawable;
160	operator Drawable() { return drawable; }
161
162	#if XFT
163	XftDraw *xftdrawable;
164	operator XftDraw *();
165	#endif
166
167	rxvt_drawable (rxvt_screen *screen, Drawable drawable)
168	: screen(screen),
169	#if XFT
170	xftdrawable(0),
171	#endif
172	drawable(drawable)
173	{ }
174
175	#if XFT
176	~rxvt_drawable ();
177	#endif
178	};
179
180	/////////////////////////////////////////////////////////////////////////////
181
182	#ifdef USE_XIM
183	struct rxvt_xim : refcounted
184	{
185	void destroy ();
186	rxvt_display *display;
187
188	//public
189	XIM xim;
190
191	rxvt_xim (const char *id) : refcounted (id) { }
192	bool ref_init ();
193	~rxvt_xim ();
194	};
195	#endif
196
197	struct rxvt_screen
198	{
199	rxvt_display *display;
200	Display *dpy;
201	int depth;
202	Visual *visual;
203	Colormap cmap;
204
205	#if XFT
206	// scratch pixmap
207	rxvt_drawable *scratch_area;
208	int scratch_w, scratch_h;
209
210	rxvt_drawable &scratch_drawable (int w, int h);
211
212	rxvt_screen ();
213	#endif
214
215	void set (rxvt_display *disp);
216	void select_visual (int bitdepth);
217	void clear ();
218	};
219
220	struct rxvt_display : refcounted
221	{
222	event_vec<xevent_watcher> xw;
223
224	ev::prepare flush_ev; void flush_cb (ev::prepare &w, int revents);
225	ev::io x_ev ; void x_cb (ev::io &w, int revents);
226
227	#ifdef USE_XIM
228	refcache<rxvt_xim> xims;
229	vector<im_watcher *> imw;
230
231	void im_change_cb ();
232	void im_change_check ();
233	#endif
234
235	//public
236	Display *dpy;
237	int screen;
238	Window root;
239	rxvt_term *selection_owner;
240	Atom xa[NUM_XA];
241	bool is_local;
242	#ifdef POINTER_BLANK
243	Cursor blank_cursor;
244	#endif
245
246	rxvt_display (const char *id);
247	XrmDatabase get_resources (bool refresh);
248	bool ref_init ();
249	void ref_next ();
250	~rxvt_display ();
251
252	void flush ();
253	Atom atom (const char *name);
254	void set_selection_owner (rxvt_term *owner);
255
256	void reg (xevent_watcher *w);
257	void unreg (xevent_watcher *w);
258
259	#ifdef USE_XIM
260	void reg (im_watcher *w);
261	void unreg (im_watcher *w);
262
263	rxvt_xim get_xim (const char locale, const char *modifiers);
264	void put_xim (rxvt_xim *xim);
265	#endif
266	};
267
268	#ifdef USE_XIM
269	struct im_watcher : rxvt_watcher, callback<void (void)> {
270	void start (rxvt_display *display)
271	{
272	display->reg (this);
273	}
274
275	void stop (rxvt_display *display)
276	{
277	display->unreg (this);
278	}
279	};
280	#endif
281
282	struct xevent_watcher : rxvt_watcher, callback<void (XEvent &)>
283	{
284	Window window;
285
286	void start (rxvt_display *display, Window window)
287	{
288	this->window = window;
289	display->reg (this);
290	}
291
292	void stop (rxvt_display *display)
293	{
294	display->unreg (this);
295	}
296	};
297
298	extern refcache<rxvt_display> displays;
299
300	/////////////////////////////////////////////////////////////////////////////
301
302	typedef unsigned long Pixel;
303
304	struct rgba
305	{
306	unsigned short r, g, b, a;
307
308	enum { MIN_CC = 0x0000, MAX_CC = 0xffff };
309
310	rgba ()
311	{ }
312
313	rgba (unsigned short r, unsigned short g, unsigned short b, unsigned short a = MAX_CC)
314	: r(r), g(g), b(b), a(a)
315	{ }
316	};
317
318	struct rxvt_color
319	{
320	#if XFT
321	XftColor c;
322	#else
323	XColor c;
324	#endif
325
326	operator Pixel () const { return c.pixel; }
327
328	bool operator == (const rxvt_color &b) const { return Pixel (*this) == Pixel (b); }
329	bool operator != (const rxvt_color &b) const { return Pixel (*this) != Pixel (b); }
330
331	bool alloc (rxvt_screen *screen, const rgba &color);
332	void free (rxvt_screen *screen);
333
334	void get (rgba &color);
335	void get (XColor &color);
336
337	bool set (rxvt_screen screen, const char name);
338	bool set (rxvt_screen *screen, const rgba &color);
339
340	void fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to = rgba (0, 0, 0));
341	};
342
343	#if TRACE_PIXMAPS
344	Pixmap trace_XCreatePixmap (const char file, int line, Display dpy, Window r, unsigned int w, unsigned int h, unsigned int d);
345	void trace_XFreePixmap (const char file, int line, Display dpy, Pixmap p);
346
347	# define XCreatePixmap(dpy,r,w,h,d) trace_XCreatePixmap (__FILE__,__LINE__,dpy,r,w,h,d)
348	# define XFreePixmap(dpy,p) trace_XFreePixmap (__FILE__,__LINE__,dpy,p)
349	#endif
350
351	#endif
352