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 "iom.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 TRANSPARENT
  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;

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

#ifdef HAVE_AFTERIMAGE  
struct ASVisual;
#endif

struct rxvt_display : refcounted {
  io_manager_vec<xevent_watcher> xw;

  io_watcher x_ev; void x_cb (io_watcher &w, short 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;
#ifdef HAVE_AFTERIMAGE  
  struct ASVisual  *asv;
#endif
  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 : 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 : 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.30
Committed:	Fri Jun 8 20:04:12 2007 UTC (16 years, 11 months ago) by sasha
Content type:	text/plain
Branch:	MAIN
Changes since 1.29:	+7 -0 lines
Log Message:	added preliminary support to use libAfterImage for background pixmap loading and rendering of transparency effects including blending of pixmap over background using several methods, and gaussian blurr of the transparency background
#	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			#include "iom.h"
33
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			#if TRANSPARENT
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	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			struct refcounted {
106			int referenced;
107			char *id;
108
109			refcounted (const char *id);
110	root	1.9	bool ref_init () { return false; }
111			void ref_next () { }
112	root	1.1	~refcounted ();
113			};
114
115			template<class T>
116			struct refcache : vector<T *> {
117			T get (const char id);
118			void put (T *obj);
119	root	1.7	void clear ();
120
121			~refcache ()
122			{
123			clear ();
124			}
125	root	1.1	};
126
127			/////////////////////////////////////////////////////////////////////////////
128
129	root	1.24	struct rxvt_screen;
130
131			struct rxvt_drawable {
132			rxvt_screen *screen;
133			Drawable drawable;
134			operator Drawable() { return drawable; }
135
136			#if XFT
137			XftDraw *xftdrawable;
138			operator XftDraw *();
139			#endif
140
141			rxvt_drawable (rxvt_screen *screen, Drawable drawable)
142			: screen(screen),
143			#if XFT
144			xftdrawable(0),
145			#endif
146			drawable(drawable)
147			{ }
148
149			#if XFT
150			~rxvt_drawable ();
151			#endif
152			};
153
154			/////////////////////////////////////////////////////////////////////////////
155
156	root	1.1	#ifdef USE_XIM
157			struct rxvt_xim : refcounted {
158			void destroy ();
159			rxvt_display *display;
160
161			//public
162			XIM xim;
163
164			rxvt_xim (const char *id) : refcounted (id) { }
165	root	1.9	bool ref_init ();
166	root	1.1	~rxvt_xim ();
167			};
168			#endif
169
170	root	1.12	struct rxvt_screen {
171			rxvt_display *display;
172	root	1.23	Display *dpy;
173	root	1.12	int depth;
174			Visual *visual;
175			Colormap cmap;
176
177	root	1.24	#if XFT
178			// scratch pixmap
179			rxvt_drawable *scratch_area;
180			int scratch_w, scratch_h;
181
182			rxvt_drawable &scratch_drawable (int w, int h);
183
184			rxvt_screen ();
185			#endif
186
187	root	1.12	void set (rxvt_display *disp);
188	root	1.29	void select_visual (int bitdepth);
189	root	1.12	void clear ();
190			};
191
192	sasha	1.30	#ifdef HAVE_AFTERIMAGE
193			struct ASVisual;
194			#endif
195
196	root	1.1	struct rxvt_display : refcounted {
197			io_manager_vec<xevent_watcher> xw;
198
199			io_watcher x_ev; void x_cb (io_watcher &w, short revents);
200
201			#ifdef USE_XIM
202			refcache<rxvt_xim> xims;
203			vector<im_watcher *> imw;
204
205			void im_change_cb ();
206	root	1.3	void im_change_check ();
207	root	1.1	#endif
208
209			//public
210	root	1.23	Display *dpy;
211	root	1.7	int screen;
212			Window root;
213	sasha	1.30	#ifdef HAVE_AFTERIMAGE
214			struct ASVisual *asv;
215			#endif
216	root	1.1	rxvt_term *selection_owner;
217	root	1.11	Atom xa[NUM_XA];
218	root	1.7	bool is_local;
219			#ifdef POINTER_BLANK
220			Cursor blank_cursor;
221	root	1.1	#endif
222
223			rxvt_display (const char *id);
224	root	1.22	XrmDatabase get_resources (bool refresh);
225	root	1.9	bool ref_init ();
226			void ref_next ();
227	root	1.1	~rxvt_display ();
228
229			void flush ();
230	root	1.5	Atom atom (const char *name);
231	root	1.1	void set_selection_owner (rxvt_term *owner);
232
233			void reg (xevent_watcher *w);
234			void unreg (xevent_watcher *w);
235
236			#ifdef USE_XIM
237			void reg (im_watcher *w);
238			void unreg (im_watcher *w);
239
240			rxvt_xim get_xim (const char locale, const char *modifiers);
241			void put_xim (rxvt_xim *xim);
242			#endif
243			};
244
245			#ifdef USE_XIM
246	root	1.28	struct im_watcher : watcher, callback<void (void)> {
247			template<class O, class M>
248			im_watcher (O object, M method)
249			: callback<void (void)> (object, method)
250	root	1.1	{ }
251
252			void start (rxvt_display *display)
253			{
254			display->reg (this);
255			}
256			void stop (rxvt_display *display)
257			{
258			display->unreg (this);
259			}
260			};
261			#endif
262
263	root	1.28	struct xevent_watcher : watcher, callback<void (XEvent &)> {
264	root	1.1	Window window;
265
266	root	1.28	template<class O, class M>
267			xevent_watcher (O object, M method)
268			: callback<void (XEvent &)> (object, method)
269	root	1.1	{ }
270
271			void start (rxvt_display *display, Window window)
272			{
273			this->window = window;
274			display->reg (this);
275			}
276			void stop (rxvt_display *display)
277			{
278			display->unreg (this);
279			}
280			};
281
282			extern refcache<rxvt_display> displays;
283
284			/////////////////////////////////////////////////////////////////////////////
285
286			typedef unsigned long Pixel;
287
288	root	1.19	struct rgba {
289	root	1.13	unsigned short r, g, b, a;
290
291			enum { MIN_CC = 0x0000, MAX_CC = 0xffff };
292
293	root	1.19	rgba ()
294	root	1.13	{ }
295
296	root	1.19	rgba (unsigned short r, unsigned short g, unsigned short b, unsigned short a = MAX_CC)
297	root	1.13	: r(r), g(g), b(b), a(a)
298			{ }
299			};
300
301	root	1.1	struct rxvt_color {
302			#if XFT
303			XftColor c;
304			#else
305	root	1.19	XColor c;
306	root	1.1	#endif
307
308	root	1.19	operator Pixel () const { return c.pixel; }
309
310	root	1.1	bool operator == (const rxvt_color &b) const { return Pixel (*this) == Pixel (b); }
311			bool operator != (const rxvt_color &b) const { return Pixel (*this) != Pixel (b); }
312
313	root	1.19	bool alloc (rxvt_screen *screen, const rgba &color);
314	root	1.16	void free (rxvt_screen *screen);
315
316	root	1.20	void get (rgba &color);
317	root	1.21	void get (XColor &color);
318	root	1.1
319	root	1.12	bool set (rxvt_screen screen, const char name);
320	root	1.19	bool set (rxvt_screen *screen, const rgba &color);
321	root	1.1
322	root	1.19	void fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to = rgba (0, 0, 0));
323	root	1.1	};
324
325			#endif
326