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-2011 Marc Lehmann <schmorp@schmorp.de>
 * Copyright (c) 2011      Emanuele Giaquinta <e.giaquinta@glauco.it>
 *
 * 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 3 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 "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,
  XA_NET_WM_ICON,
#endif
#if USE_XIM
  XA_WM_LOCALE_NAME,
  XA_XIM_SERVERS,
#endif
#if HAVE_IMG || ENABLE_PERL
  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 subsystems, 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
};

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

#if 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 id);
  void select_depth (int bitdepth); // select visual by depth
  void clear ();
};

enum
{
  DISPLAY_HAS_RENDER      = 1 << 0,
  DISPLAY_HAS_RENDER_CONV = 1 << 1,
};

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

#if 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;
  rxvt_term *clipboard_owner;
  Atom      xa[NUM_XA];
  bool      is_local;
#ifdef POINTER_BLANK
  Cursor    blank_cursor;
#endif
  uint8_t   flags;

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

  void flush ()
  {
    flush_ev.start ();
  }

  Atom atom (const char *name);
  Pixmap get_pixmap_property (Atom property);
  void set_selection_owner (rxvt_term *owner, bool clipboard);

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

#if 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
};

#if 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
{
  uint16_t r, g, b, a;

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

  rgba ()
  { }

  rgba (uint16_t r, uint16_t g, uint16_t b, uint16_t 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 is_opaque () const
  {
#if XFT
    return c.color.alpha == rgba::MAX_CC;
#else
    return 1;
#endif
  }

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

  operator rgba () const
  {
    rgba c;
    get (c);
    return c;
  }
  void get (rgba &color) const;
  void get (XColor &color) const;

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

#define Sel_normal              0x01    /* normal selection */
#define Sel_incr                0x02    /* incremental selection */
#define Sel_Primary             0x01
#define Sel_Secondary           0x02
#define Sel_Clipboard           0x03
#define Sel_whereMask           0x0f
#define Sel_CompoundText        0x10    /* last request was COMPOUND_TEXT */
#define Sel_UTF8String          0x20    /* last request was UTF8_STRING */

struct rxvt_selection
{
  rxvt_selection (rxvt_display *disp, int selnum, Time tm, Window win, Atom prop, rxvt_term *term);
  void run ();
  ~rxvt_selection ();

  rxvt_term *term; // terminal to paste to, may be 0
  void *cb_sv;     // managed by perl

  rxvt_display *display;
  Time request_time;
  Window request_win;
  Atom request_prop;

private:
  unsigned char selection_wait;
  unsigned char selection_type;

  char *incr_buf;
  size_t incr_buf_size, incr_buf_fill;

  void timer_cb (ev::timer &w, int revents); ev::timer timer_ev;
  void x_cb (XEvent &xev); xevent_watcher x_ev;

  void finish (char *data = 0, unsigned int len = 0);
  void stop ();
  bool request (Atom target, int selnum);
  void handle_selection (Window win, Atom prop, bool delete_prop);
};

#endif

Revision:	1.71
Committed:	Thu May 22 18:54:33 2014 UTC (10 years ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rxvt-unicode-rel-9_29, rxvt-unicode-rel-9_26, rxvt-unicode-rel-9_25, rxvt-unicode-rel-9_22, rxvt-unicode-rel-9_21, rxvt-unicode-rel-9_30, HEAD
Changes since 1.70:	+1 -1 lines
Log Message:	GPLv3
#	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	root	1.57	* Copyright (c) 2003-2011 Marc Lehmann <schmorp@schmorp.de>
7	sf-exg	1.51	* Copyright (c) 2011 Emanuele Giaquinta <e.giaquinta@glauco.it>
8	root	1.26	*
9			* This program is free software; you can redistribute it and/or modify
10			* it under the terms of the GNU General Public License as published by
11	root	1.71	* the Free Software Foundation; either version 3 of the License, or
12	root	1.26	* (at your option) any later version.
13			*
14			* This program is distributed in the hope that it will be useful,
15			* but WITHOUT ANY WARRANTY; without even the implied warranty of
16			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			* GNU General Public License for more details.
18			*
19			* You should have received a copy of the GNU General Public License
20			* along with this program; if not, write to the Free Software
21			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22			----------------------------------------------------------------------/
23
24	root	1.1	#ifndef RXVT_TOOLKIT_H
25			#define RXVT_TOOLKIT_H
26
27			#include <X11/Xlib.h>
28
29			#if XFT
30			# include <X11/Xft/Xft.h>
31			#endif
32
33	root	1.34	#include "ev_cpp.h"
34	root	1.1
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	root	1.46	XA_NET_WM_ICON,
66	root	1.11	#endif
67			#if USE_XIM
68			XA_WM_LOCALE_NAME,
69			XA_XIM_SERVERS,
70			#endif
71	sf-exg	1.70	#if HAVE_IMG \|\| ENABLE_PERL
72	root	1.11	XA_XROOTPMAP_ID,
73			XA_ESETROOT_PMAP_ID,
74			#endif
75			#if ENABLE_XEMBED
76			XA_XEMBED,
77			XA_XEMBED_INFO,
78			#endif
79	root	1.14	#if !ENABLE_MINIMAL
80	ayin	1.41	// these are usually allocated by other subsystems, but we do it
81	root	1.14	// here to avoid a server roundtrip.
82			XA_SCREEN_RESOURCES,
83			XA_XDCCC_LINEAR_RGB_CORRECTION,
84			XA_XDCCC_LINEAR_RGB_MATRICES,
85			XA_WM_COLORMAP_WINDOWS,
86			XA_WM_STATE,
87	root	1.15	XA_cursor,
88			# if USE_XIM
89			// various selection targets used by XIM
90			XA_TRANSPORT,
91			XA_LOCALES,
92			XA__XIM_PROTOCOL,
93			XA__XIM_XCONNECT,
94			XA__XIM_MOREDATA,
95			# endif
96	root	1.14	#endif
97	root	1.11	NUM_XA
98			};
99
100	root	1.1	struct rxvt_term;
101	root	1.2	struct rxvt_display;
102	root	1.1
103			struct im_watcher;
104			struct xevent_watcher;
105
106	root	1.34	template<class watcher>
107	root	1.37	struct event_vec : vector<watcher *>
108			{
109	root	1.34	void erase_unordered (unsigned int pos)
110			{
111			watcher w = (this)[this->size () - 1];
112			this->pop_back ();
113
114			if (!this->empty ())
115			if (((*this)[pos] = w)) // '=' is correct!
116			w->active = pos + 1;
117			}
118			};
119
120	root	1.37	struct rxvt_watcher
121			{
122	root	1.34	int active; /* 0 == inactive, else index into respective vector */
123
124			bool is_active () { return active; }
125
126			rxvt_watcher () : active (0) { }
127			};
128
129	root	1.37	struct refcounted
130			{
131	root	1.1	int referenced;
132			char *id;
133
134			refcounted (const char *id);
135	root	1.9	bool ref_init () { return false; }
136			void ref_next () { }
137	root	1.1	~refcounted ();
138			};
139
140			template<class T>
141	root	1.37	struct refcache : vector<T *>
142			{
143	root	1.1	T get (const char id);
144			void put (T *obj);
145	root	1.7	void clear ();
146
147			~refcache ()
148			{
149			clear ();
150			}
151	root	1.1	};
152
153			/////////////////////////////////////////////////////////////////////////////
154
155	root	1.24	struct rxvt_screen;
156
157	root	1.37	struct rxvt_drawable
158			{
159	root	1.24	rxvt_screen *screen;
160			Drawable drawable;
161			operator Drawable() { return drawable; }
162
163			#if XFT
164			XftDraw *xftdrawable;
165			operator XftDraw *();
166			#endif
167
168			rxvt_drawable (rxvt_screen *screen, Drawable drawable)
169			: screen(screen),
170			#if XFT
171			xftdrawable(0),
172			#endif
173			drawable(drawable)
174			{ }
175
176			#if XFT
177			~rxvt_drawable ();
178			#endif
179			};
180
181			/////////////////////////////////////////////////////////////////////////////
182
183	root	1.61	#if USE_XIM
184	root	1.37	struct rxvt_xim : refcounted
185			{
186	root	1.1	void destroy ();
187			rxvt_display *display;
188
189			//public
190			XIM xim;
191
192			rxvt_xim (const char *id) : refcounted (id) { }
193	root	1.9	bool ref_init ();
194	root	1.1	~rxvt_xim ();
195			};
196			#endif
197
198	root	1.37	struct rxvt_screen
199			{
200	root	1.12	rxvt_display *display;
201	root	1.23	Display *dpy;
202	root	1.12	int depth;
203			Visual *visual;
204			Colormap cmap;
205
206	root	1.24	#if XFT
207			// scratch pixmap
208			rxvt_drawable *scratch_area;
209			int scratch_w, scratch_h;
210
211			rxvt_drawable &scratch_drawable (int w, int h);
212
213			rxvt_screen ();
214			#endif
215
216	root	1.12	void set (rxvt_display *disp);
217	root	1.64	void select_visual (int id);
218			void select_depth (int bitdepth); // select visual by depth
219	root	1.12	void clear ();
220			};
221
222	root	1.65	enum
223			{
224	sf-exg	1.59	DISPLAY_HAS_RENDER = 1 << 0,
225	root	1.65	DISPLAY_HAS_RENDER_CONV = 1 << 1,
226	sf-exg	1.59	};
227
228	root	1.37	struct rxvt_display : refcounted
229			{
230	root	1.34	event_vec<xevent_watcher> xw;
231	root	1.1
232	root	1.45	ev::prepare flush_ev; void flush_cb (ev::prepare &w, int revents);
233	root	1.38	ev::io x_ev ; void x_cb (ev::io &w, int revents);
234	root	1.1
235	root	1.61	#if USE_XIM
236	root	1.1	refcache<rxvt_xim> xims;
237			vector<im_watcher *> imw;
238
239			void im_change_cb ();
240	root	1.3	void im_change_check ();
241	root	1.1	#endif
242
243			//public
244	root	1.23	Display *dpy;
245	root	1.7	int screen;
246			Window root;
247	root	1.1	rxvt_term *selection_owner;
248	sf-exg	1.48	rxvt_term *clipboard_owner;
249	root	1.11	Atom xa[NUM_XA];
250	root	1.7	bool is_local;
251			#ifdef POINTER_BLANK
252			Cursor blank_cursor;
253	root	1.1	#endif
254	sf-exg	1.59	uint8_t flags;
255	root	1.1
256			rxvt_display (const char *id);
257	root	1.22	XrmDatabase get_resources (bool refresh);
258	root	1.9	bool ref_init ();
259			void ref_next ();
260	root	1.1	~rxvt_display ();
261
262	root	1.39	void flush ()
263			{
264			flush_ev.start ();
265			}
266
267	root	1.5	Atom atom (const char *name);
268	sf-exg	1.60	Pixmap get_pixmap_property (Atom property);
269	sf-exg	1.48	void set_selection_owner (rxvt_term *owner, bool clipboard);
270	root	1.1
271			void reg (xevent_watcher *w);
272			void unreg (xevent_watcher *w);
273
274	root	1.61	#if USE_XIM
275	root	1.1	void reg (im_watcher *w);
276			void unreg (im_watcher *w);
277
278			rxvt_xim get_xim (const char locale, const char *modifiers);
279			void put_xim (rxvt_xim *xim);
280			#endif
281			};
282
283	root	1.61	#if USE_XIM
284	root	1.47	struct im_watcher : rxvt_watcher, callback<void (void)>
285			{
286	root	1.1	void start (rxvt_display *display)
287			{
288			display->reg (this);
289			}
290	root	1.34
291	root	1.1	void stop (rxvt_display *display)
292			{
293			display->unreg (this);
294			}
295			};
296			#endif
297
298	root	1.37	struct xevent_watcher : rxvt_watcher, callback<void (XEvent &)>
299			{
300	root	1.1	Window window;
301
302			void start (rxvt_display *display, Window window)
303			{
304			this->window = window;
305			display->reg (this);
306			}
307	root	1.34
308	root	1.1	void stop (rxvt_display *display)
309			{
310			display->unreg (this);
311			}
312			};
313
314			extern refcache<rxvt_display> displays;
315
316			/////////////////////////////////////////////////////////////////////////////
317
318			typedef unsigned long Pixel;
319
320	root	1.37	struct rgba
321			{
322	root	1.67	uint16_t r, g, b, a;
323	root	1.13
324			enum { MIN_CC = 0x0000, MAX_CC = 0xffff };
325
326	root	1.19	rgba ()
327	root	1.13	{ }
328
329	root	1.67	rgba (uint16_t r, uint16_t g, uint16_t b, uint16_t a = MAX_CC)
330	root	1.13	: r(r), g(g), b(b), a(a)
331			{ }
332			};
333
334	root	1.37	struct rxvt_color
335			{
336	root	1.1	#if XFT
337			XftColor c;
338			#else
339	root	1.19	XColor c;
340	root	1.1	#endif
341
342	root	1.19	operator Pixel () const { return c.pixel; }
343
344	root	1.1	bool operator == (const rxvt_color &b) const { return Pixel (*this) == Pixel (b); }
345			bool operator != (const rxvt_color &b) const { return Pixel (*this) != Pixel (b); }
346
347	root	1.42	bool is_opaque () const
348			{
349			#if XFT
350	root	1.43	return c.color.alpha == rgba::MAX_CC;
351	root	1.42	#else
352			return 1;
353			#endif
354			}
355
356	root	1.19	bool alloc (rxvt_screen *screen, const rgba &color);
357	root	1.16	void free (rxvt_screen *screen);
358
359	root	1.66	operator rgba () const
360			{
361			rgba c;
362			get (c);
363			return c;
364			}
365	root	1.63	void get (rgba &color) const;
366			void get (XColor &color) const;
367	ayin	1.33
368	root	1.12	bool set (rxvt_screen screen, const char name);
369	root	1.19	bool set (rxvt_screen *screen, const rgba &color);
370	root	1.1
371	root	1.19	void fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to = rgba (0, 0, 0));
372	root	1.1	};
373
374	sf-exg	1.50	#define Sel_normal 0x01 /* normal selection */
375			#define Sel_incr 0x02 /* incremental selection */
376			#define Sel_Primary 0x01
377			#define Sel_Secondary 0x02
378			#define Sel_Clipboard 0x03
379			#define Sel_whereMask 0x0f
380			#define Sel_CompoundText 0x10 /* last request was COMPOUND_TEXT */
381			#define Sel_UTF8String 0x20 /* last request was UTF8_STRING */
382
383			struct rxvt_selection
384			{
385	root	1.56	rxvt_selection (rxvt_display disp, int selnum, Time tm, Window win, Atom prop, rxvt_term term);
386	sf-exg	1.52	void run ();
387	sf-exg	1.50	~rxvt_selection ();
388
389	root	1.54	rxvt_term *term; // terminal to paste to, may be 0
390	root	1.56	void *cb_sv; // managed by perl
391	sf-exg	1.58
392	sf-exg	1.50	rxvt_display *display;
393			Time request_time;
394			Window request_win;
395			Atom request_prop;
396
397	root	1.56	private:
398	sf-exg	1.50	unsigned char selection_wait;
399			unsigned char selection_type;
400
401			char *incr_buf;
402			size_t incr_buf_size, incr_buf_fill;
403
404			void timer_cb (ev::timer &w, int revents); ev::timer timer_ev;
405			void x_cb (XEvent &xev); xevent_watcher x_ev;
406
407	root	1.54	void finish (char *data = 0, unsigned int len = 0);
408	sf-exg	1.50	void stop ();
409			bool request (Atom target, int selnum);
410			void handle_selection (Window win, Atom prop, bool delete_prop);
411			};
412
413	root	1.1	#endif
414