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>
 * 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 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 "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 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 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
};

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

#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;
  rxvt_term *clipboard_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 ()
  {
    flush_ev.start ();
  }

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

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

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

#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 */

typedef void (*sel_cb)(char *data, unsigned int len, struct rxvt_selection *rs, void *ptr);

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

private:
  rxvt_display *display;
  Time request_time;
  Window request_win;
  Atom request_prop;
  sel_cb request_cb;
  void *user_data;

  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 stop ();
  bool request (Atom target, int selnum);
  void handle_selection (Window win, Atom prop, bool delete_prop);
};

#endif

Revision:	1.52
Committed:	Sat Feb 12 00:30:01 2011 UTC (13 years, 3 months ago) by sf-exg
Content type:	text/plain
Branch:	MAIN
Changes since 1.51:	+1 -0 lines
Log Message:	Do not allow more than one concurrent selection request and delete the ongoing selection request, if any, on destruction of the terminal, to avoid a use-after-free crash.
#	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	* Copyright (c) 2011 Emanuele Giaquinta <e.giaquinta@glauco.it>
8	*
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	* the Free Software Foundation; either version 2 of the License, or
12	* (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	#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	#include "ev_cpp.h"
34
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	XA_NET_WM_ICON,
66	#endif
67	#if USE_XIM
68	XA_WM_LOCALE_NAME,
69	XA_XIM_SERVERS,
70	#endif
71	#if ENABLE_TRANSPARENCY
72	XA_XROOTPMAP_ID,
73	XA_ESETROOT_PMAP_ID,
74	#endif
75	#if ENABLE_XEMBED
76	XA_XEMBED,
77	XA_XEMBED_INFO,
78	#endif
79	#if !ENABLE_MINIMAL
80	// these are usually allocated by other subsystems, but we do it
81	// 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	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	#endif
97	NUM_XA
98	};
99
100	struct rxvt_term;
101	struct rxvt_display;
102
103	struct im_watcher;
104	struct xevent_watcher;
105
106	template<class watcher>
107	struct event_vec : vector<watcher *>
108	{
109	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	struct rxvt_watcher
121	{
122	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	struct refcounted
130	{
131	int referenced;
132	char *id;
133
134	refcounted (const char *id);
135	bool ref_init () { return false; }
136	void ref_next () { }
137	~refcounted ();
138	};
139
140	template<class T>
141	struct refcache : vector<T *>
142	{
143	T get (const char id);
144	void put (T *obj);
145	void clear ();
146
147	~refcache ()
148	{
149	clear ();
150	}
151	};
152
153	/////////////////////////////////////////////////////////////////////////////
154
155	struct rxvt_screen;
156
157	struct rxvt_drawable
158	{
159	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	#ifdef USE_XIM
184	struct rxvt_xim : refcounted
185	{
186	void destroy ();
187	rxvt_display *display;
188
189	//public
190	XIM xim;
191
192	rxvt_xim (const char *id) : refcounted (id) { }
193	bool ref_init ();
194	~rxvt_xim ();
195	};
196	#endif
197
198	struct rxvt_screen
199	{
200	rxvt_display *display;
201	Display *dpy;
202	int depth;
203	Visual *visual;
204	Colormap cmap;
205
206	#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	void set (rxvt_display *disp);
217	void select_visual (int bitdepth);
218	void clear ();
219	};
220
221	struct rxvt_display : refcounted
222	{
223	event_vec<xevent_watcher> xw;
224
225	ev::prepare flush_ev; void flush_cb (ev::prepare &w, int revents);
226	ev::io x_ev ; void x_cb (ev::io &w, int revents);
227
228	#ifdef USE_XIM
229	refcache<rxvt_xim> xims;
230	vector<im_watcher *> imw;
231
232	void im_change_cb ();
233	void im_change_check ();
234	#endif
235
236	//public
237	Display *dpy;
238	int screen;
239	Window root;
240	rxvt_term *selection_owner;
241	rxvt_term *clipboard_owner;
242	Atom xa[NUM_XA];
243	bool is_local;
244	#ifdef POINTER_BLANK
245	Cursor blank_cursor;
246	#endif
247
248	rxvt_display (const char *id);
249	XrmDatabase get_resources (bool refresh);
250	bool ref_init ();
251	void ref_next ();
252	~rxvt_display ();
253
254	void flush ()
255	{
256	flush_ev.start ();
257	}
258
259	Atom atom (const char *name);
260	void set_selection_owner (rxvt_term *owner, bool clipboard);
261
262	void reg (xevent_watcher *w);
263	void unreg (xevent_watcher *w);
264
265	#ifdef USE_XIM
266	void reg (im_watcher *w);
267	void unreg (im_watcher *w);
268
269	rxvt_xim get_xim (const char locale, const char *modifiers);
270	void put_xim (rxvt_xim *xim);
271	#endif
272	};
273
274	#ifdef USE_XIM
275	struct im_watcher : rxvt_watcher, callback<void (void)>
276	{
277	void start (rxvt_display *display)
278	{
279	display->reg (this);
280	}
281
282	void stop (rxvt_display *display)
283	{
284	display->unreg (this);
285	}
286	};
287	#endif
288
289	struct xevent_watcher : rxvt_watcher, callback<void (XEvent &)>
290	{
291	Window window;
292
293	void start (rxvt_display *display, Window window)
294	{
295	this->window = window;
296	display->reg (this);
297	}
298
299	void stop (rxvt_display *display)
300	{
301	display->unreg (this);
302	}
303	};
304
305	extern refcache<rxvt_display> displays;
306
307	/////////////////////////////////////////////////////////////////////////////
308
309	typedef unsigned long Pixel;
310
311	struct rgba
312	{
313	unsigned short r, g, b, a;
314
315	enum { MIN_CC = 0x0000, MAX_CC = 0xffff };
316
317	rgba ()
318	{ }
319
320	rgba (unsigned short r, unsigned short g, unsigned short b, unsigned short a = MAX_CC)
321	: r(r), g(g), b(b), a(a)
322	{ }
323	};
324
325	struct rxvt_color
326	{
327	#if XFT
328	XftColor c;
329	#else
330	XColor c;
331	#endif
332
333	operator Pixel () const { return c.pixel; }
334
335	bool operator == (const rxvt_color &b) const { return Pixel (*this) == Pixel (b); }
336	bool operator != (const rxvt_color &b) const { return Pixel (*this) != Pixel (b); }
337
338	bool is_opaque () const
339	{
340	#if XFT
341	return c.color.alpha == rgba::MAX_CC;
342	#else
343	return 1;
344	#endif
345	}
346
347	bool alloc (rxvt_screen *screen, const rgba &color);
348	void free (rxvt_screen *screen);
349
350	void get (rgba &color);
351	void get (XColor &color);
352
353	bool set (rxvt_screen screen, const char name);
354	bool set (rxvt_screen *screen, const rgba &color);
355
356	void fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to = rgba (0, 0, 0));
357	};
358
359	#define Sel_normal 0x01 /* normal selection */
360	#define Sel_incr 0x02 /* incremental selection */
361	#define Sel_Primary 0x01
362	#define Sel_Secondary 0x02
363	#define Sel_Clipboard 0x03
364	#define Sel_whereMask 0x0f
365	#define Sel_CompoundText 0x10 /* last request was COMPOUND_TEXT */
366	#define Sel_UTF8String 0x20 /* last request was UTF8_STRING */
367
368	typedef void (sel_cb)(char data, unsigned int len, struct rxvt_selection rs, void ptr);
369
370	struct rxvt_selection
371	{
372	rxvt_selection (rxvt_display disp, int selnum, Time tm, Window win, Atom prop, sel_cb cb, void ptr);
373	void run ();
374	~rxvt_selection ();
375
376	private:
377	rxvt_display *display;
378	Time request_time;
379	Window request_win;
380	Atom request_prop;
381	sel_cb request_cb;
382	void *user_data;
383
384	unsigned char selection_wait;
385	unsigned char selection_type;
386
387	char *incr_buf;
388	size_t incr_buf_size, incr_buf_fill;
389
390	void timer_cb (ev::timer &w, int revents); ev::timer timer_ev;
391	void x_cb (XEvent &xev); xevent_watcher x_ev;
392
393	void stop ();
394	bool request (Atom target, int selnum);
395	void handle_selection (Window win, Atom prop, bool delete_prop);
396	};
397
398	#endif
399