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::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)> {
  template<class O, class M>
  im_watcher (O object, M method)
  : callback<void (void)> (object, method)
  { }

  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;

  template<class O, class M>
  xevent_watcher (O object, M method)
  : callback<void (XEvent &)> (object, method)
  { }

  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));
};

#endif

Revision:	1.34
Committed:	Sun Nov 11 04:08:00 2007 UTC (16 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.33:	+28 -5 lines
Log Message:	first rough cut at libev integration
#	User	Rev	Content
1	root	1.27	/----------------------------------------------------------------------
2	root	1.26	* 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	root	1.1	#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	root	1.34	#include "ev_cpp.h"
33	root	1.1
34			#include "rxvtlib.h"
35			#include "rxvtutil.h"
36
37			#include "callback.h"
38
39	root	1.11	// 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	root	1.14	XA_AVERAGE_WIDTH,
53			XA_WEIGHT_NAME,
54			XA_SLANT,
55			XA_CHARSET_REGISTRY,
56			XA_CHARSET_ENCODING,
57	root	1.11	#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	root	1.31	#if ENABLE_TRANSPARENCY
71	root	1.11	XA_XROOTPMAP_ID,
72			XA_ESETROOT_PMAP_ID,
73			#endif
74			#if ENABLE_XEMBED
75			XA_XEMBED,
76			XA_XEMBED_INFO,
77			#endif
78	root	1.14	#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	root	1.15	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	root	1.14	#endif
96	root	1.11	NUM_XA
97			};
98
99	root	1.1	struct rxvt_term;
100	root	1.2	struct rxvt_display;
101	root	1.1
102			struct im_watcher;
103			struct xevent_watcher;
104
105	root	1.34	template<class watcher>
106			struct event_vec : vector<watcher *> {
107			void erase_unordered (unsigned int pos)
108			{
109			watcher w = (this)[this->size () - 1];
110			this->pop_back ();
111
112			if (!this->empty ())
113			if (((*this)[pos] = w)) // '=' is correct!
114			w->active = pos + 1;
115			}
116			};
117
118			struct rxvt_watcher {
119			int active; /* 0 == inactive, else index into respective vector */
120
121			bool is_active () { return active; }
122
123			rxvt_watcher () : active (0) { }
124			};
125
126	root	1.1	struct refcounted {
127			int referenced;
128			char *id;
129
130			refcounted (const char *id);
131	root	1.9	bool ref_init () { return false; }
132			void ref_next () { }
133	root	1.1	~refcounted ();
134			};
135
136			template<class T>
137			struct refcache : vector<T *> {
138			T get (const char id);
139			void put (T *obj);
140	root	1.7	void clear ();
141
142			~refcache ()
143			{
144			clear ();
145			}
146	root	1.1	};
147
148			/////////////////////////////////////////////////////////////////////////////
149
150	root	1.24	struct rxvt_screen;
151
152			struct rxvt_drawable {
153			rxvt_screen *screen;
154			Drawable drawable;
155			operator Drawable() { return drawable; }
156
157			#if XFT
158			XftDraw *xftdrawable;
159			operator XftDraw *();
160			#endif
161
162			rxvt_drawable (rxvt_screen *screen, Drawable drawable)
163			: screen(screen),
164			#if XFT
165			xftdrawable(0),
166			#endif
167			drawable(drawable)
168			{ }
169
170			#if XFT
171			~rxvt_drawable ();
172			#endif
173			};
174
175			/////////////////////////////////////////////////////////////////////////////
176
177	root	1.1	#ifdef USE_XIM
178			struct rxvt_xim : refcounted {
179			void destroy ();
180			rxvt_display *display;
181
182			//public
183			XIM xim;
184
185			rxvt_xim (const char *id) : refcounted (id) { }
186	root	1.9	bool ref_init ();
187	root	1.1	~rxvt_xim ();
188			};
189			#endif
190
191	root	1.12	struct rxvt_screen {
192			rxvt_display *display;
193	root	1.23	Display *dpy;
194	root	1.12	int depth;
195			Visual *visual;
196			Colormap cmap;
197
198	root	1.24	#if XFT
199			// scratch pixmap
200			rxvt_drawable *scratch_area;
201			int scratch_w, scratch_h;
202
203			rxvt_drawable &scratch_drawable (int w, int h);
204
205			rxvt_screen ();
206			#endif
207
208	root	1.12	void set (rxvt_display *disp);
209	root	1.29	void select_visual (int bitdepth);
210	root	1.12	void clear ();
211			};
212
213	root	1.1	struct rxvt_display : refcounted {
214	root	1.34	event_vec<xevent_watcher> xw;
215	root	1.1
216	root	1.34	ev::io x_ev; void x_cb (ev::io &w, int revents);
217	root	1.1
218			#ifdef USE_XIM
219			refcache<rxvt_xim> xims;
220			vector<im_watcher *> imw;
221
222			void im_change_cb ();
223	root	1.3	void im_change_check ();
224	root	1.1	#endif
225
226			//public
227	root	1.23	Display *dpy;
228	root	1.7	int screen;
229			Window root;
230	root	1.1	rxvt_term *selection_owner;
231	root	1.11	Atom xa[NUM_XA];
232	root	1.7	bool is_local;
233			#ifdef POINTER_BLANK
234			Cursor blank_cursor;
235	root	1.1	#endif
236
237			rxvt_display (const char *id);
238	root	1.22	XrmDatabase get_resources (bool refresh);
239	root	1.9	bool ref_init ();
240			void ref_next ();
241	root	1.1	~rxvt_display ();
242
243			void flush ();
244	root	1.5	Atom atom (const char *name);
245	root	1.1	void set_selection_owner (rxvt_term *owner);
246
247			void reg (xevent_watcher *w);
248			void unreg (xevent_watcher *w);
249
250			#ifdef USE_XIM
251			void reg (im_watcher *w);
252			void unreg (im_watcher *w);
253
254			rxvt_xim get_xim (const char locale, const char *modifiers);
255			void put_xim (rxvt_xim *xim);
256			#endif
257			};
258
259			#ifdef USE_XIM
260	root	1.34	struct im_watcher : rxvt_watcher, callback<void (void)> {
261	root	1.28	template<class O, class M>
262			im_watcher (O object, M method)
263			: callback<void (void)> (object, method)
264	root	1.1	{ }
265
266			void start (rxvt_display *display)
267			{
268			display->reg (this);
269			}
270	root	1.34
271	root	1.1	void stop (rxvt_display *display)
272			{
273			display->unreg (this);
274			}
275			};
276			#endif
277
278	root	1.34	struct xevent_watcher : rxvt_watcher, callback<void (XEvent &)> {
279	root	1.1	Window window;
280
281	root	1.28	template<class O, class M>
282			xevent_watcher (O object, M method)
283			: callback<void (XEvent &)> (object, method)
284	root	1.1	{ }
285
286			void start (rxvt_display *display, Window window)
287			{
288			this->window = window;
289			display->reg (this);
290			}
291	root	1.34
292	root	1.1	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	root	1.19	struct rgba {
305	root	1.13	unsigned short r, g, b, a;
306
307			enum { MIN_CC = 0x0000, MAX_CC = 0xffff };
308
309	root	1.19	rgba ()
310	root	1.13	{ }
311
312	root	1.19	rgba (unsigned short r, unsigned short g, unsigned short b, unsigned short a = MAX_CC)
313	root	1.13	: r(r), g(g), b(b), a(a)
314			{ }
315			};
316
317	root	1.1	struct rxvt_color {
318			#if XFT
319			XftColor c;
320			#else
321	root	1.19	XColor c;
322	root	1.1	#endif
323
324	root	1.19	operator Pixel () const { return c.pixel; }
325
326	root	1.1	bool operator == (const rxvt_color &b) const { return Pixel (*this) == Pixel (b); }
327			bool operator != (const rxvt_color &b) const { return Pixel (*this) != Pixel (b); }
328
329	root	1.19	bool alloc (rxvt_screen *screen, const rgba &color);
330	root	1.16	void free (rxvt_screen *screen);
331
332	root	1.20	void get (rgba &color);
333	root	1.21	void get (XColor &color);
334	ayin	1.33
335	root	1.12	bool set (rxvt_screen screen, const char name);
336	root	1.19	bool set (rxvt_screen *screen, const rgba &color);
337	root	1.1
338	root	1.19	void fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to = rgba (0, 0, 0));
339	root	1.1	};
340
341			#endif
342