ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/rxvttoolkit.C
(Generate patch)

Comparing rxvt-unicode/src/rxvttoolkit.C (file contents):
Revision 1.33 by root, Sun Jan 29 22:39:26 2006 UTC vs.
Revision 1.139 by sf-exg, Sun Oct 14 13:43:25 2012 UTC

1/*--------------------------------*-C-*---------------------------------* 1/*----------------------------------------------------------------------*
2 * File: rxvttoolkit.C 2 * File: rxvttoolkit.C
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com> 6 * Copyright (c) 2003-2011 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2011 Emanuele Giaquinta <e.giaquinta@glauco.it>
7 * 8 *
8 * This program is free software; you can redistribute it and/or modify 9 * 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 * 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 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version. 12 * (at your option) any later version.
… …
26 27
27#include <unistd.h> 28#include <unistd.h>
28#include <fcntl.h> 29#include <fcntl.h>
29 30
30#include <sys/utsname.h> 31#include <sys/utsname.h>
31
32#ifndef NO_SLOW_LINK_SUPPORT
33# include <sys/socket.h> 32#include <sys/socket.h>
34# include <sys/un.h> 33#include <sys/un.h>
35#endif
36 34
37#if XFT 35#if XFT
38# include <X11/extensions/Xrender.h> 36# include <X11/extensions/Xrender.h>
39#endif 37#endif
40 38
41const char *const xa_names[] = 39static const char *const xa_names[] =
42 { 40{
43 "TEXT", 41 "TEXT",
44 "COMPOUND_TEXT", 42 "COMPOUND_TEXT",
45 "UTF8_STRING", 43 "UTF8_STRING",
46 "MULTIPLE", 44 "MULTIPLE",
47 "TARGETS", 45 "TARGETS",
48 "TIMESTAMP", 46 "TIMESTAMP",
49 "VT_SELECTION", 47 "VT_SELECTION",
50 "INCR", 48 "INCR",
51 "WM_PROTOCOLS", 49 "WM_PROTOCOLS",
52 "WM_DELETE_WINDOW", 50 "WM_DELETE_WINDOW",
53 "CLIPBOARD", 51 "CLIPBOARD",
52 "AVERAGE_WIDTH",
53 "WEIGHT_NAME",
54 "SLANT",
55 "CHARSET_REGISTRY",
56 "CHARSET_ENCODING",
54#if ENABLE_FRILLS 57#if ENABLE_FRILLS
55 "_MOTIF_WM_HINTS", 58 "_MOTIF_WM_HINTS",
56#endif 59#endif
57#if ENABLE_EWMH 60#if ENABLE_EWMH
58 "_NET_WM_PID", 61 "_NET_WM_PID",
59 "_NET_WM_NAME", 62 "_NET_WM_NAME",
60 "_NET_WM_ICON_NAME", 63 "_NET_WM_ICON_NAME",
61 "_NET_WM_PING", 64 "_NET_WM_PING",
65 "_NET_WM_ICON",
62#endif 66#endif
63#if USE_XIM 67#if USE_XIM
64 "WM_LOCALE_NAME", 68 "WM_LOCALE_NAME",
65 "XIM_SERVERS", 69 "XIM_SERVERS",
66#endif 70#endif
67#ifdef TRANSPARENT 71#if ENABLE_TRANSPARENCY || ENABLE_PERL
68 "_XROOTPMAP_ID", 72 "_XROOTPMAP_ID",
69 "ESETROOT_PMAP_ID", 73 "ESETROOT_PMAP_ID",
70#endif 74#endif
71#if ENABLE_XEMBED 75#if ENABLE_XEMBED
72 "_XEMBED", 76 "_XEMBED",
73 "_XEMBED_INFO", 77 "_XEMBED_INFO",
78#endif
79#if !ENABLE_MINIMAL
80 "SCREEN_RESOURCES",
81 "XDCCC_LINEAR_RGB_CORRECTION",
82 "XDCCC_LINEAR_RGB_MATRICES",
83 "WM_COLORMAP_WINDOWS",
84 "WM_STATE",
85 "cursor",
86# if USE_XIM
87 "TRANSPORT",
88 "LOCALES",
89 "_XIM_PROTOCOL",
90 "_XIM_XCONNECT",
91 "_XIM_MOREDATA",
74#endif 92# endif
75 }; 93#endif
94};
76 95
77///////////////////////////////////////////////////////////////////////////// 96/////////////////////////////////////////////////////////////////////////////
78 97
79refcounted::refcounted (const char *id) 98refcounted::refcounted (const char *id)
80{ 99{
… …
134 put (*this->begin ()); 153 put (*this->begin ());
135} 154}
136 155
137///////////////////////////////////////////////////////////////////////////// 156/////////////////////////////////////////////////////////////////////////////
138 157
139#ifdef USE_XIM 158#if USE_XIM
140 159
141static void 160static void
142#if XIMCB_PROTO_BROKEN 161#if XIMCB_PROTO_BROKEN
143im_destroy_cb (XIC unused1, XPointer client_data, XPointer unused3) 162im_destroy_cb (XIC unused1, XPointer client_data, XPointer unused3)
144#else 163#else
… …
157bool 176bool
158rxvt_xim::ref_init () 177rxvt_xim::ref_init ()
159{ 178{
160 display = GET_R->display; //HACK: TODO 179 display = GET_R->display; //HACK: TODO
161 180
162 xim = XOpenIM (display->display, NULL, NULL, NULL); 181 xim = XOpenIM (display->dpy, 0, 0, 0);
163 182
164 if (!xim) 183 if (!xim)
165 return false; 184 return false;
166 185
167 XIMCallback ximcallback; 186 XIMCallback ximcallback;
168 ximcallback.client_data = (XPointer)this; 187 ximcallback.client_data = (XPointer)this;
169 ximcallback.callback = im_destroy_cb; 188 ximcallback.callback = im_destroy_cb;
170 189
171 XSetIMValues (xim, XNDestroyCallback, &ximcallback, NULL); 190 XSetIMValues (xim, XNDestroyCallback, &ximcallback, (char *)0);
172 191
173 return true; 192 return true;
174} 193}
175 194
176rxvt_xim::~rxvt_xim () 195rxvt_xim::~rxvt_xim ()
… …
181 200
182#endif 201#endif
183 202
184///////////////////////////////////////////////////////////////////////////// 203/////////////////////////////////////////////////////////////////////////////
185 204
205#if XFT
206rxvt_drawable::~rxvt_drawable ()
207{
208 if (xftdrawable)
209 XftDrawDestroy (xftdrawable);
210}
211
212rxvt_drawable::operator XftDraw *()
213{
214 if (!xftdrawable)
215 xftdrawable = XftDrawCreate (screen->dpy, drawable, screen->visual, screen->cmap);
216
217 return xftdrawable;
218}
219#endif
220
221/////////////////////////////////////////////////////////////////////////////
222
223#if XFT
224
225// not strictly necessary as it is only used with superclass of zero_initialised
226rxvt_screen::rxvt_screen ()
227: scratch_area (0)
228{
229}
230
231rxvt_drawable &rxvt_screen::scratch_drawable (int w, int h)
232{
233 if (!scratch_area || w > scratch_w || h > scratch_h)
234 {
235 if (scratch_area)
236 {
237 XFreePixmap (dpy, scratch_area->drawable);
238 delete scratch_area;
239 }
240
241 Pixmap pm = XCreatePixmap (dpy, RootWindowOfScreen (ScreenOfDisplay (dpy, display->screen)),
242 scratch_w = w, scratch_h = h, depth);
243
244 scratch_area = new rxvt_drawable (this, pm);
245 }
246
247 return *scratch_area;
248}
249
250#endif
251
186void 252void
187rxvt_screen::set (rxvt_display *disp) 253rxvt_screen::set (rxvt_display *disp)
188{ 254{
189 display = disp; 255 display = disp;
190 xdisp = disp->display; 256 dpy = disp->dpy;
191 257
192 Screen *screen = ScreenOfDisplay (xdisp, disp->screen); 258 Screen *screen = ScreenOfDisplay (dpy, disp->screen);
193 259
194 depth = DefaultDepthOfScreen (screen); 260 depth = DefaultDepthOfScreen (screen);
195 visual = DefaultVisualOfScreen (screen); 261 visual = DefaultVisualOfScreen (screen);
196 cmap = DefaultColormapOfScreen (screen); 262 cmap = DefaultColormapOfScreen (screen);
197} 263}
198 264
199void 265#if ENABLE_FRILLS
200rxvt_screen::set (rxvt_display *disp, int bitdepth)
201{
202 set (disp);
203 266
267void
268rxvt_screen::select_visual (int id)
269{
270 XVisualInfo vinfo;
271 vinfo.visualid = id;
272 int n;
273
274 if (XVisualInfo *vi = XGetVisualInfo (dpy, VisualIDMask, &vinfo, &n))
275 {
276 depth = vi->depth;
277 visual = vi->visual;
278
279 XFree (vi);
280
281 cmap = XCreateColormap (dpy, display->root, visual, AllocNone);
282 }
283 else
284 rxvt_warn ("cannot requested visual id 0x%02x, using default visual.\n", id);
285}
286
287void
288rxvt_screen::select_depth (int bitdepth)
289{
290 XVisualInfo vinfo;
291
292 if (XMatchVisualInfo (dpy, display->screen, bitdepth, TrueColor, &vinfo))
293 select_visual (vinfo.visualid);
294 else
295 rxvt_warn ("no visual found for requested depth %d, using default visual.\n", bitdepth);
296}
297
298#endif
299
300void
301rxvt_screen::clear ()
302{
204#if XFT 303#if XFT
205 XVisualInfo vinfo; 304 if (scratch_area)
206
207 if (XMatchVisualInfo (xdisp, display->screen, bitdepth, TrueColor, &vinfo))
208 {
209 depth = bitdepth;
210 visual = vinfo.visual;
211 cmap = XCreateColormap (xdisp, disp->root, visual, AllocNone);
212 } 305 {
306 XFreePixmap (dpy, scratch_area->drawable);
307 delete scratch_area;
308 }
213#endif 309#endif
214}
215 310
216void
217rxvt_screen::clear ()
218{
219 if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (xdisp, display->screen))) 311 if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (dpy, display->screen)))
220 XFreeColormap (xdisp, cmap); 312 XFreeColormap (dpy, cmap);
221} 313}
222 314
223///////////////////////////////////////////////////////////////////////////// 315/////////////////////////////////////////////////////////////////////////////
224 316
225rxvt_display::rxvt_display (const char *id) 317rxvt_display::rxvt_display (const char *id)
226: refcounted (id) 318: refcounted (id)
227, x_ev (this, &rxvt_display::x_cb)
228, selection_owner (0) 319, selection_owner (0)
320, clipboard_owner (0)
229{ 321{
322 x_ev .set<rxvt_display, &rxvt_display::x_cb > (this);
323 flush_ev.set<rxvt_display, &rxvt_display::flush_cb> (this);
230} 324}
231 325
232XrmDatabase 326XrmDatabase
233rxvt_display::get_resources () 327rxvt_display::get_resources (bool refresh)
234{ 328{
235 char *homedir = (char *)getenv ("HOME"); 329 char *homedir = getenv ("HOME");
236 char fname[1024]; 330 char fname[1024];
237 331
238 /* 332 /*
239 * get resources using the X library function 333 * get resources using the X library function
240 */ 334 */
241 char *displayResource, *xe; 335 char *displayResource, *xe;
242 XrmDatabase database, rdb1; 336 XrmDatabase rdb1, database = 0;
243 337
244 database = NULL; 338#if !XLIB_ILLEGAL_ACCESS
339 /* work around a bug in XrmSetDatabase where it frees the db, see ref_next */
340 database = XrmGetStringDatabase ("");
341#endif
245 342
246 // for ordering, see for example http://www.faqs.org/faqs/Xt-FAQ/ Subject: 20 343 // for ordering, see for example http://www.faqs.org/faqs/Xt-FAQ/ Subject: 20
344 // as opposed to "standard practise", we always read in ~/.Xdefaults
247 345
248 // 6. System wide per application default file. 346 // 6. System wide per application default file.
249 347
250 /* Add in $XAPPLRESDIR/Rxvt only; not bothering with XUSERFILESEARCHPATH */ 348 /* Add in $XAPPLRESDIR/Rxvt only; not bothering with XUSERFILESEARCHPATH */
251 if ((xe = (char *)getenv ("XAPPLRESDIR"))) 349 if ((xe = getenv ("XAPPLRESDIR")))
252 { 350 {
253 snprintf (fname, sizeof (fname), "%s/%s", xe, RESCLASS); 351 snprintf (fname, sizeof (fname), "%s/%s", xe, RESCLASS);
254 352
255 if ((rdb1 = XrmGetFileDatabase (fname))) 353 if ((rdb1 = XrmGetFileDatabase (fname)))
256 XrmMergeDatabases (rdb1, &database); 354 XrmMergeDatabases (rdb1, &database);
… …
258 356
259 // 5. User's per application default file. 357 // 5. User's per application default file.
260 // none 358 // none
261 359
262 // 4. User's defaults file. 360 // 4. User's defaults file.
361 if (homedir)
362 {
363 snprintf (fname, sizeof (fname), "%s/.Xdefaults", homedir);
364
365 if ((rdb1 = XrmGetFileDatabase (fname)))
366 XrmMergeDatabases (rdb1, &database);
367 }
368
263 /* Get any Xserver defaults */ 369 /* Get any Xserver defaults */
370 if (refresh)
371 {
372 // fucking xlib keeps a copy of the rm string
373 Atom actual_type;
374 int actual_format;
375 unsigned long nitems, nremaining;
376 char *val = 0;
377
378#if XLIB_ILLEGAL_ACCESS
379 if (dpy->xdefaults)
380 XFree (dpy->xdefaults);
381#endif
382
383 if (XGetWindowProperty (dpy, RootWindow (dpy, 0), XA_RESOURCE_MANAGER,
384 0L, 100000000L, False,
385 XA_STRING, &actual_type, &actual_format,
386 &nitems, &nremaining,
387 (unsigned char **)&val) == Success
388 && actual_type == XA_STRING
389 && actual_format == 8)
390 displayResource = val;
391 else
392 {
393 displayResource = 0;
394
395 if (val)
396 XFree (val);
397 }
398
399#if XLIB_ILLEGAL_ACCESS
400 dpy->xdefaults = displayResource;
401#endif
402 }
403 else
264 displayResource = XResourceManagerString (display); 404 displayResource = XResourceManagerString (dpy);
265 405
266 if (displayResource != NULL) 406 if (displayResource)
267 { 407 {
268 if ((rdb1 = XrmGetStringDatabase (displayResource))) 408 if ((rdb1 = XrmGetStringDatabase (displayResource)))
269 XrmMergeDatabases (rdb1, &database); 409 XrmMergeDatabases (rdb1, &database);
270 } 410 }
271 else if (homedir)
272 {
273 snprintf (fname, sizeof (fname), "%s/.Xdefaults", homedir);
274 411
275 if ((rdb1 = XrmGetFileDatabase (fname))) 412#if !XLIB_ILLEGAL_ACCESS
276 XrmMergeDatabases (rdb1, &database); 413 if (refresh && displayResource)
277 } 414 XFree (displayResource);
415#endif
278 416
279 /* Get screen specific resources */ 417 /* Get screen specific resources */
280 displayResource = XScreenResourceString (ScreenOfDisplay (display, screen)); 418 displayResource = XScreenResourceString (ScreenOfDisplay (dpy, screen));
281 419
282 if (displayResource != NULL) 420 if (displayResource)
283 { 421 {
284 if ((rdb1 = XrmGetStringDatabase (displayResource))) 422 if ((rdb1 = XrmGetStringDatabase (displayResource)))
285 /* Merge with screen-independent resources */ 423 /* Merge with screen-independent resources */
286 XrmMergeDatabases (rdb1, &database); 424 XrmMergeDatabases (rdb1, &database);
287 425
288 XFree (displayResource); 426 XFree (displayResource);
289 } 427 }
290 428
291 // 3. User's per host defaults file 429 // 3. User's per host defaults file
292 /* Add in XENVIRONMENT file */ 430 /* Add in XENVIRONMENT file */
293 if ((xe = (char *)getenv ("XENVIRONMENT")) 431 if ((xe = getenv ("XENVIRONMENT"))
294 && (rdb1 = XrmGetFileDatabase (xe))) 432 && (rdb1 = XrmGetFileDatabase (xe)))
295 XrmMergeDatabases (rdb1, &database); 433 XrmMergeDatabases (rdb1, &database);
296 else if (homedir) 434 else if (homedir)
297 { 435 {
298 struct utsname un; 436 struct utsname un;
… …
312bool rxvt_display::ref_init () 450bool rxvt_display::ref_init ()
313{ 451{
314#ifdef LOCAL_X_IS_UNIX 452#ifdef LOCAL_X_IS_UNIX
315 if (id[0] == ':') 453 if (id[0] == ':')
316 { 454 {
317 val = rxvt_malloc (5 + strlen (id) + 1); 455 char *val = rxvt_temp_buf<char> (5 + strlen (id) + 1);
456
318 strcpy (val, "unix/"); 457 strcpy (val, "unix/");
319 strcat (val, id); 458 strcat (val, id);
459
320 display = XOpenDisplay (val); 460 dpy = XOpenDisplay (val);
321 free (val);
322 } 461 }
323 else 462 else
324#endif 463#endif
325 display = 0; 464 dpy = 0;
326 465
327 if (!display) 466 if (!dpy)
328 display = XOpenDisplay (id); 467 dpy = XOpenDisplay (id);
329 468
330 if (!display) 469 if (!dpy)
331 return false; 470 return false;
332 471
333 screen = DefaultScreen (display); 472 screen = DefaultScreen (dpy);
334 root = DefaultRootWindow (display); 473 root = DefaultRootWindow (dpy);
335 474
336 assert (sizeof (xa_names) / sizeof (char *) == NUM_XA); 475 assert (ecb_array_length (xa_names) == NUM_XA);
337 XInternAtoms (display, (char **)xa_names, NUM_XA, False, xa); 476 XInternAtoms (dpy, (char **)xa_names, NUM_XA, False, xa);
338 477
339 XrmSetDatabase (display, get_resources ()); 478 XrmSetDatabase (dpy, get_resources (false));
340 479
341#ifdef POINTER_BLANK 480#ifdef POINTER_BLANK
342 XColor blackcolour; 481 XColor blackcolour;
343 blackcolour.red = 0; 482 blackcolour.red = 0;
344 blackcolour.green = 0; 483 blackcolour.green = 0;
345 blackcolour.blue = 0; 484 blackcolour.blue = 0;
346 Font f = XLoadFont (display, "fixed"); 485 Font f = XLoadFont (dpy, "fixed");
347 blank_cursor = XCreateGlyphCursor (display, f, f, ' ', ' ', 486 blank_cursor = XCreateGlyphCursor (dpy, f, f, ' ', ' ',
348 &blackcolour, &blackcolour); 487 &blackcolour, &blackcolour);
349 XUnloadFont (display, f); 488 XUnloadFont (dpy, f);
350#endif 489#endif
351 490
491 flags = 0;
492#if XRENDER
493 int major, minor;
494 if (XRenderQueryVersion (dpy, &major, &minor))
495 if (major > 0 || (major == 0 && minor >= 10))
496 {
497 flags |= DISPLAY_HAS_RENDER;
498
499#if 0
500 if (major > 0 || (major == 0 && minor >= 11))
501 flags |= DISPLAY_HAS_RENDER_MUL;
502#endif
503
504 if (XFilters *filters = XRenderQueryFilters (dpy, root))
505 {
506 for (int i = 0; i < filters->nfilter; i++)
507 if (!strcmp (filters->filter [i], FilterConvolution))
508 flags |= DISPLAY_HAS_RENDER_CONV;
509
510 XFree (filters);
511 }
512 }
513#endif
514
352 int fd = XConnectionNumber (display); 515 int fd = XConnectionNumber (dpy);
353 516
354#ifndef NO_SLOW_LINK_SUPPORT
355 // try to detect wether we have a local connection. 517 // try to detect whether we have a local connection.
356 // assume unix domains socket == local, everything else not 518 // assume unix domain socket == local, everything else not
357 // TODO: might want to check for inet/127.0.0.1 519 // TODO: might want to check for inet/127.0.0.1
358 is_local = 0; 520 is_local = 0;
359 sockaddr_un sa; 521 sockaddr_un sa;
360 socklen_t sl = sizeof (sa); 522 socklen_t sl = sizeof (sa);
361 523
362 if (!getsockname (fd, (sockaddr *)&sa, &sl)) 524 if (!getsockname (fd, (sockaddr *)&sa, &sl))
363 is_local = sa.sun_family == AF_LOCAL; 525 is_local = sa.sun_family == AF_UNIX;
364#endif
365 526
527 flush_ev.start ();
366 x_ev.start (fd, EVENT_READ); 528 x_ev.start (fd, ev::READ);
367 fcntl (fd, F_SETFD, FD_CLOEXEC); 529 fcntl (fd, F_SETFD, FD_CLOEXEC);
368 530
369 XSelectInput (display, root, PropertyChangeMask); 531 XSelectInput (dpy, root, PropertyChangeMask);
370 532
371 flush (); 533 flush ();
372 534
373 return true; 535 return true;
374} 536}
375 537
376void 538void
377rxvt_display::ref_next () 539rxvt_display::ref_next ()
378{ 540{
379 // TODO: somehow check wether the database files/resources changed 541 // TODO: somehow check whether the database files/resources changed
380 // before re-loading/parsing 542 // before affording re-loading/parsing
381 XrmDestroyDatabase (XrmGetDatabase (display)); 543 XrmDestroyDatabase (XrmGetDatabase (dpy));
544#if XLIB_ILLEGAL_ACCESS
545 /* work around a bug in XrmSetDatabase where it frees the db */
546 dpy->db = 0;
547#endif
382 XrmSetDatabase (display, get_resources ()); 548 XrmSetDatabase (dpy, get_resources (true));
383} 549}
384 550
385rxvt_display::~rxvt_display () 551rxvt_display::~rxvt_display ()
386{ 552{
387 if (!display) 553 if (!dpy)
388 return; 554 return;
389 555
390#ifdef POINTER_BLANK 556#ifdef POINTER_BLANK
391 XFreeCursor (display, blank_cursor); 557 XFreeCursor (dpy, blank_cursor);
392#endif 558#endif
393 x_ev.stop (); 559 x_ev.stop ();
560 flush_ev.stop ();
394#ifdef USE_XIM 561#if USE_XIM
395 xims.clear (); 562 xims.clear ();
396#endif 563#endif
564 XrmDestroyDatabase (XrmGetDatabase (dpy));
397 XCloseDisplay (display); 565 XCloseDisplay (dpy);
398} 566}
399 567
400#ifdef USE_XIM 568#if USE_XIM
401void rxvt_display::im_change_cb () 569void rxvt_display::im_change_cb ()
402{ 570{
403 for (im_watcher **i = imw.begin (); i != imw.end (); ++i) 571 for (im_watcher **i = imw.begin (); i != imw.end (); ++i)
404 (*i)->call (); 572 (*i)->call ();
405} 573}
… …
410 // registers, as xlib crashes due to a race otherwise. 578 // registers, as xlib crashes due to a race otherwise.
411 Atom actual_type, *atoms; 579 Atom actual_type, *atoms;
412 int actual_format; 580 int actual_format;
413 unsigned long nitems, bytes_after; 581 unsigned long nitems, bytes_after;
414 582
415 if (XGetWindowProperty (display, root, xa[XA_XIM_SERVERS], 0L, 1000000L, 583 if (XGetWindowProperty (dpy, root, xa[XA_XIM_SERVERS], 0L, 1000000L,
416 False, XA_ATOM, &actual_type, &actual_format, 584 False, XA_ATOM, &actual_type, &actual_format,
417 &nitems, &bytes_after, (unsigned char **)&atoms) 585 &nitems, &bytes_after, (unsigned char **)&atoms)
418 != Success ) 586 != Success)
419 return; 587 return;
420 588
421 if (actual_type == XA_ATOM && actual_format == 32) 589 if (actual_type == XA_ATOM && actual_format == 32)
422 for (int i = 0; i < nitems; i++) 590 for (int i = 0; i < nitems; i++)
423 if (XGetSelectionOwner (display, atoms[i])) 591 if (XGetSelectionOwner (dpy, atoms[i]))
424 { 592 {
425 im_change_cb (); 593 im_change_cb ();
426 break; 594 break;
427 } 595 }
428 596
429 XFree (atoms); 597 XFree (atoms);
430} 598}
431#endif 599#endif
432 600
433void rxvt_display::x_cb (io_watcher &w, short revents) 601void rxvt_display::x_cb (ev::io &w, int revents)
434{ 602{
603 flush_ev.start ();
604}
605
606void rxvt_display::flush_cb (ev::prepare &w, int revents)
607{
608 while (XEventsQueued (dpy, QueuedAfterFlush))
435 do 609 do
436 { 610 {
437 XEvent xev; 611 XEvent xev;
438 XNextEvent (display, &xev); 612 XNextEvent (dpy, &xev);
439 613
440#ifdef USE_XIM 614#if USE_XIM
441 if (!XFilterEvent (&xev, None)) 615 if (!XFilterEvent (&xev, None))
442 { 616 {
443 if (xev.type == PropertyNotify 617 if (xev.type == PropertyNotify
444 && xev.xany.window == root 618 && xev.xany.window == root
445 && xev.xproperty.atom == xa[XA_XIM_SERVERS]) 619 && xev.xproperty.atom == xa[XA_XIM_SERVERS])
446 im_change_check (); 620 im_change_check ();
447#endif 621#endif
622 if (xev.type == MappingNotify)
623 XRefreshKeyboardMapping (&xev.xmapping);
624
448 for (int i = xw.size (); i--; ) 625 for (int i = xw.size (); i--; )
449 { 626 {
450 if (!xw[i]) 627 if (!xw[i])
451 xw.erase_unordered (i); 628 xw.erase_unordered (i);
452 else if (xw[i]->window == xev.xany.window) 629 else if (xw[i]->window == xev.xany.window)
453 xw[i]->call (xev); 630 xw[i]->call (xev);
454 } 631 }
455#ifdef USE_XIM 632#if USE_XIM
456 } 633 }
457#endif 634#endif
458 } 635 }
459 while (XEventsQueued (display, QueuedAlready)); 636 while (XEventsQueued (dpy, QueuedAlready));
460 637
461 XFlush (display); 638 w.stop ();
462}
463
464void rxvt_display::flush ()
465{
466 if (XEventsQueued (display, QueuedAlready))
467 x_cb (x_ev, EVENT_READ);
468
469 XFlush (display);
470} 639}
471 640
472void rxvt_display::reg (xevent_watcher *w) 641void rxvt_display::reg (xevent_watcher *w)
473{ 642{
643 if (!w->active)
644 {
474 xw.push_back (w); 645 xw.push_back (w);
475 w->active = xw.size (); 646 w->active = xw.size ();
647 }
476} 648}
477 649
478void rxvt_display::unreg (xevent_watcher *w) 650void rxvt_display::unreg (xevent_watcher *w)
479{ 651{
480 if (w->active) 652 if (w->active)
653 {
481 xw[w->active - 1] = 0; 654 xw[w->active - 1] = 0;
655 w->active = 0;
656 }
482} 657}
483 658
484void rxvt_display::set_selection_owner (rxvt_term *owner) 659void rxvt_display::set_selection_owner (rxvt_term *owner, bool clipboard)
485{ 660{
661 rxvt_term * &cur_owner = !clipboard ? selection_owner : clipboard_owner;
662
486 if (selection_owner && selection_owner != owner) 663 if (cur_owner && cur_owner != owner)
487 selection_owner->selection_clear (); 664 {
665 rxvt_term *term = cur_owner;
666 term->selection_clear (clipboard);
667 term->flush ();
668 }
488 669
489 selection_owner = owner; 670 cur_owner = owner;
490} 671}
491 672
492#ifdef USE_XIM 673#if USE_XIM
674
493void rxvt_display::reg (im_watcher *w) 675void rxvt_display::reg (im_watcher *w)
494{ 676{
495 imw.push_back (w); 677 imw.push_back (w);
496} 678}
497 679
… …
506 int l, m; 688 int l, m;
507 689
508 l = strlen (locale); 690 l = strlen (locale);
509 m = strlen (modifiers); 691 m = strlen (modifiers);
510 692
511 if (!(id = (char *)malloc (l + m + 2))) 693 if (!(id = rxvt_temp_buf<char> (l + m + 2)))
512 return 0; 694 return 0;
513 695
514 memcpy (id, locale, l); id[l] = '\n'; 696 memcpy (id, locale, l); id[l] = '\n';
515 memcpy (id + l + 1, modifiers, m); id[l + m + 1] = 0; 697 memcpy (id + l + 1, modifiers, m); id[l + m + 1] = 0;
516 698
517 rxvt_xim *xim = xims.get (id); 699 rxvt_xim *xim = xims.get (id);
518 700
519 free (id);
520
521 return xim; 701 return xim;
522} 702}
523 703
524void rxvt_display::put_xim (rxvt_xim *xim) 704void rxvt_display::put_xim (rxvt_xim *xim)
525{ 705{
526#if XLIB_IS_RACEFREE 706# if XLIB_IS_RACEFREE
527 xims.put (xim); 707 xims.put (xim);
528#endif 708# endif
529} 709}
710
530#endif 711#endif
531 712
532Atom rxvt_display::atom (const char *name) 713Atom rxvt_display::atom (const char *name)
533{ 714{
534 return XInternAtom (display, name, False); 715 return XInternAtom (dpy, name, False);
716}
717
718Pixmap
719rxvt_display::get_pixmap_property (Atom property)
720{
721 Pixmap pixmap = None;
722
723 int aformat;
724 unsigned long nitems, bytes_after;
725 Atom atype;
726 unsigned char *prop;
727 int result = XGetWindowProperty (dpy, root, property,
728 0L, 1L, False, XA_PIXMAP, &atype, &aformat,
729 &nitems, &bytes_after, &prop);
730 if (result == Success)
731 {
732 if (atype == XA_PIXMAP)
733 pixmap = *(Pixmap *)prop;
734 XFree (prop);
735 }
736
737 return pixmap;
535} 738}
536 739
537///////////////////////////////////////////////////////////////////////////// 740/////////////////////////////////////////////////////////////////////////////
538 741
539template class refcache<rxvt_display>; 742template class refcache<rxvt_display>;
540refcache<rxvt_display> displays; 743refcache<rxvt_display> displays;
541 744
542///////////////////////////////////////////////////////////////////////////// 745/////////////////////////////////////////////////////////////////////////////
543 746//
747
748static unsigned int
749insert_component (unsigned int value, unsigned int mask, unsigned int shift)
750{
751 return (value * (mask + 1) >> 16) << shift;
752}
753
754bool
755rxvt_color::alloc (rxvt_screen *screen, const rgba &color)
756{
757 //TODO: only supports 24 bit
758 unsigned int alpha = color.a >= 0xff00 ? 0xffff : color.a;
759
760#if XFT
761 XRenderPictFormat *format;
762
763 // FUCKING Xft gets it wrong, of course, so work around it.
764 // Transparency users should eat shit and die, and then
765 // XRenderQueryPictIndexValues themselves plenty.
766 if ((screen->visual->c_class == TrueColor)
767 && (format = XRenderFindVisualFormat (screen->dpy, screen->visual)))
768 {
769 // the fun lies in doing everything manually...
770 c.color.red = color.r;
771 c.color.green = color.g;
772 c.color.blue = color.b;
773 c.color.alpha = alpha;
774
775 // Xft wants premultiplied alpha, but abuses the alpha channel
776 // as blend factor, and doesn't allow us to set the alpha channel
777 c.color.red = c.color.red * alpha / 0xffff;
778 c.color.green = c.color.green * alpha / 0xffff;
779 c.color.blue = c.color.blue * alpha / 0xffff;
780
781 c.pixel = insert_component (c.color.red , format->direct.redMask , format->direct.red )
782 | insert_component (c.color.green, format->direct.greenMask, format->direct.green)
783 | insert_component (c.color.blue , format->direct.blueMask , format->direct.blue )
784 | insert_component (alpha , format->direct.alphaMask, format->direct.alpha);
785
786 return true;
787 }
788 else
789 {
790 XRenderColor d;
791
792 d.red = color.r;
793 d.green = color.g;
794 d.blue = color.b;
795 d.alpha = alpha;
796
797 if (XftColorAllocValue (screen->dpy, screen->visual, screen->cmap, &d, &c))
798 return true;
799 }
800#else
801 c.red = color.r;
802 c.green = color.g;
803 c.blue = color.b;
804
805 if (screen->visual->c_class == TrueColor)
806 {
807 c.pixel = (color.r >> (16 - ecb_popcount32 (screen->visual->red_mask )) << ecb_ctz32 (screen->visual->red_mask ))
808 | (color.g >> (16 - ecb_popcount32 (screen->visual->green_mask)) << ecb_ctz32 (screen->visual->green_mask))
809 | (color.b >> (16 - ecb_popcount32 (screen->visual->blue_mask )) << ecb_ctz32 (screen->visual->blue_mask ));
810
811 return true;
812 }
813 else if (XAllocColor (screen->dpy, screen->cmap, &c))
814 return true;
815#endif
816
817 c.pixel = (color.r + color.g + color.b) > 128*3
818 ? WhitePixelOfScreen (DefaultScreenOfDisplay (screen->dpy))
819 : BlackPixelOfScreen (DefaultScreenOfDisplay (screen->dpy));
820
821 return false;
822}
823
544bool 824bool
545rxvt_color::set (rxvt_screen *screen, const char *name) 825rxvt_color::set (rxvt_screen *screen, const char *name)
546{ 826{
827 rgba c;
828 char eos;
829 int skip;
830
831 c.a = rgba::MAX_CC;
832
833 // parse the nonstandard "[alphapercent]" prefix
834 if (1 <= sscanf (name, "[%hd]%n", &c.a, &skip))
835 {
836 c.a = lerp<int, int, int> (0, rgba::MAX_CC, c.a);
837 name += skip;
838 }
839
840 // parse the non-standard "rgba:rrrr/gggg/bbbb/aaaa" format
841 if (strlen (name) != 4+5*4 || 4 != sscanf (name, "rgba:%4hx/%4hx/%4hx/%4hx%c", &c.r, &c.g, &c.b, &c.a, &eos))
842 {
843 XColor xc;
844
845 if (XParseColor (screen->dpy, screen->cmap, name, &xc))
846 {
847 c.r = xc.red;
848 c.g = xc.green;
849 c.b = xc.blue;
850 }
851 else
852 {
853 c.r = 0xffff;
854 c.g = 0x6969;
855 c.b = 0xb4b4;
856
857 rxvt_warn ("unable to parse color '%s', using pink instead.\n", name);
858 }
859 }
860
861 return set (screen, c);
862}
863
864bool
865rxvt_color::set (rxvt_screen *screen, const rgba &color)
866{
867 bool got = alloc (screen, color);
868
869#if !ENABLE_MINIMAL
870 int cmap_size = screen->visual->map_entries;
871
872 if (!got
873 && screen->visual->c_class == PseudoColor
874 && cmap_size < 4096)
875 {
876 XColor *colors = new XColor [screen->visual->map_entries];
877
878 for (int i = 0; i < cmap_size; i++)
879 colors [i].pixel = i;
880
881 // many kilobytes transfer per colour, but pseudocolor isn't worth
882 // many extra optimisations.
883 XQueryColors (screen->dpy, screen->cmap, colors, cmap_size);
884
885 int diff = 0x7fffffffUL;
886 XColor *best = colors;
887
888 for (int i = 0; i < cmap_size; i++)
889 {
890 int d = (squared_diff<int> (color.r >> 2, colors [i].red >> 2))
891 + (squared_diff<int> (color.g >> 2, colors [i].green >> 2))
892 + (squared_diff<int> (color.b >> 2, colors [i].blue >> 2));
893
894 if (d < diff)
895 {
896 diff = d;
897 best = colors + i;
898 }
899 }
900
901 //rxvt_warn ("could not allocate %04x %04x %04x, getting %04x %04x %04x instead (%d)\n",
902 // color.r, color.g, color.b, best->red, best->green, best->blue, diff);
903
904 got = alloc (screen, rgba (best->red, best->green, best->blue));
905
906 delete [] colors;
907 }
908#endif
909
910 return got;
911}
912
913void
914rxvt_color::get (rgba &color) const
915{
547#if XFT 916#if XFT
548 int l = strlen (name); 917 color.r = c.color.red;
549 rxvt_rgba r; 918 color.g = c.color.green;
550 char eos; 919 color.b = c.color.blue;
551 int mult; 920 color.a = c.color.alpha;
552
553 if ( l == 1+4*1 && 4 == sscanf (name, "#%1hx%1hx%1hx%1hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
554 mult = rxvt_rgba::MAX_CC / 0x000f;
555 else if (l == 1+4*2 && 4 == sscanf (name, "#%2hx%2hx%2hx%2hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
556 mult = rxvt_rgba::MAX_CC / 0x00ff;
557 else if (l == 1+4*4 && 4 == sscanf (name, "#%4hx%4hx%4hx%4hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
558 mult = rxvt_rgba::MAX_CC / 0xffff;
559 else if (l == 4+5*4 && 4 == sscanf (name, "rgba:%hx/%hx/%hx/%hx%c", &r.r, &r.g, &r.b, &r.a, &eos))
560 mult = rxvt_rgba::MAX_CC / 0xffff;
561 else
562 return XftColorAllocName (screen->xdisp, screen->visual, screen->cmap, name, &c);
563
564 r.r *= mult; r.g *= mult; r.b *= mult; r.a *= mult;
565 return set (screen, r);
566#else 921#else
567 XColor xc; 922 color.r = c.red;
568 923 color.g = c.green;
569 if (XParseColor (screen->xdisp, screen->cmap, name, &xc)) 924 color.b = c.blue;
570 return set (screen, rxvt_rgba (xc.red, xc.green, xc.blue)); 925 color.a = rgba::MAX_CC;
571
572 return false;
573#endif 926#endif
574} 927}
575 928
576bool 929void
930rxvt_color::get (XColor &color) const
931{
932 rgba c;
933 get (c);
934
935 color.red = c.r;
936 color.green = c.g;
937 color.blue = c.b;
938 color.pixel = (Pixel)*this;
939}
940
941void
577rxvt_color::set (rxvt_screen *screen, rxvt_rgba rgba) 942rxvt_color::free (rxvt_screen *screen)
578{ 943{
944 if (screen->visual->c_class == TrueColor)
945 return; // nothing to do
946
579#if XFT 947#if XFT
580 XRenderPictFormat *format;
581
582 // FUCKING Xft gets it wrong, of course, so work around it
583 // transparency users should eat shit and die, and then
584 // XRenderQueryPictIndexValues themselves plenty.
585 if (screen->visual->c_class == TrueColor
586 && (format = XRenderFindVisualFormat (screen->xdisp, screen->visual)))
587 {
588 // the fun lies in doing everything manually...
589 c.color.red = rgba.r;
590 c.color.green = rgba.g;
591 c.color.blue = rgba.b;
592 c.color.alpha = rgba.a;
593
594 c.pixel = ((rgba.r * format->direct.redMask / rxvt_rgba::MAX_CC) << format->direct.red )
595 | ((rgba.g * format->direct.greenMask / rxvt_rgba::MAX_CC) << format->direct.green)
596 | ((rgba.b * format->direct.blueMask / rxvt_rgba::MAX_CC) << format->direct.blue )
597 | ((rgba.a * format->direct.alphaMask / rxvt_rgba::MAX_CC) << format->direct.alpha);
598
599 return true;
600 }
601 else
602 {
603 XRenderColor d;
604
605 d.red = rgba.r;
606 d.green = rgba.g;
607 d.blue = rgba.b;
608 d.alpha = rgba.a;
609
610 return XftColorAllocValue (screen->xdisp, screen->visual, screen->cmap, &d, &c); 948 XftColorFree (screen->dpy, screen->visual, screen->cmap, &c);
611 }
612
613 return false;
614#else 949#else
615 XColor xc;
616
617 xc.red = rgba.r;
618 xc.green = rgba.g;
619 xc.blue = rgba.b;
620 xc.flags = DoRed | DoGreen | DoBlue;
621
622 if (XAllocColor (screen->xdisp, screen->cmap, &xc))
623 {
624 p = xc.pixel;
625 return true;
626 }
627
628 return false;
629#endif
630}
631
632void
633rxvt_color::get (rxvt_screen *screen, rxvt_rgba &rgba)
634{
635#if XFT
636 rgba.r = c.color.red;
637 rgba.g = c.color.green;
638 rgba.b = c.color.blue;
639 rgba.a = c.color.alpha;
640#else
641 XColor c;
642
643 c.pixel = p;
644 XQueryColor (screen->xdisp, screen->cmap, &c);
645
646 rgba.r = c.red;
647 rgba.g = c.green;
648 rgba.b = c.blue;
649 rgba.a = rxvt_rgba::MAX_CC;
650#endif
651}
652
653void
654rxvt_color::free (rxvt_screen *screen)
655{
656#if XFT
657 XftColorFree (screen->xdisp, screen->visual, screen->cmap, &c);
658#else
659 XFreeColors (screen->xdisp, screen->cmap, &p, 1, AllPlanes); 950 XFreeColors (screen->dpy, screen->cmap, &c.pixel, 1, AllPlanes);
660#endif 951#endif
661} 952}
662 953
663rxvt_color 954void
664rxvt_color::fade (rxvt_screen *screen, int percent)
665{
666 rxvt_color faded;
667
668 rxvt_rgba c;
669 get (screen, c);
670
671 c.r = lerp (0, c.r, percent);
672 c.g = lerp (0, c.g, percent);
673 c.b = lerp (0, c.b, percent);
674
675 faded.set (screen, c);
676
677 return faded;
678}
679
680rxvt_color
681rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &fadeto) 955rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to)
682{ 956{
683 rxvt_rgba c, fc; 957 rgba c;
684 rxvt_color faded; 958 get (c);
685
686 get (screen, c);
687 fadeto.get (screen, fc);
688 959
689 faded.set ( 960 result.set (
690 screen, 961 screen,
691 rxvt_rgba ( 962 rgba (
692 lerp (fc.r, c.r, percent), 963 lerp (c.r, to.r, percent),
693 lerp (fc.g, c.g, percent), 964 lerp (c.g, to.g, percent),
694 lerp (fc.b, c.b, percent), 965 lerp (c.b, to.b, percent),
695 lerp (fc.a, c.a, percent) 966 lerp (c.a, to.a, percent)
696 ) 967 )
697 ); 968 );
969}
698 970
971rxvt_selection::rxvt_selection (rxvt_display *disp, int selnum, Time tm, Window win, Atom prop, rxvt_term *term)
972: display (disp), request_time (tm), request_win (win), request_prop (prop), term (term)
973{
974 assert (selnum >= Sel_Primary && selnum <= Sel_Clipboard);
975
976 timer_ev.set<rxvt_selection, &rxvt_selection::timer_cb> (this);
977 timer_ev.repeat = 10.;
978 x_ev.set<rxvt_selection, &rxvt_selection::x_cb> (this);
979
980 incr_buf = 0;
981 incr_buf_size = incr_buf_fill = 0;
982 selection_wait = Sel_normal;
983 selection_type = selnum;
984 cb_sv = 0;
985}
986
987void
988rxvt_selection::stop ()
989{
990 free (incr_buf);
991 incr_buf = 0;
992 timer_ev.stop ();
993 x_ev.stop (display);
994}
995
996rxvt_selection::~rxvt_selection ()
997{
998 stop ();
999}
1000
1001void
1002rxvt_selection::run ()
1003{
1004 int selnum = selection_type;
1005
1006#if ENABLE_FRILLS
1007 if (selnum == Sel_Primary && display->selection_owner)
1008 {
1009 /* internal selection */
1010 char *str = rxvt_wcstombs (display->selection_owner->selection.text, display->selection_owner->selection.len);
1011 finish (str, strlen (str));
1012 free (str);
1013 return;
1014 }
1015#endif
1016
1017#if X_HAVE_UTF8_STRING
1018 selection_type = Sel_UTF8String;
1019 if (request (display->xa[XA_UTF8_STRING], selnum))
1020 return;
1021#else
1022 selection_type = Sel_CompoundText;
1023 if (request (display->xa[XA_COMPOUND_TEXT], selnum))
1024 return;
1025#endif
1026
1027 // fallback to CUT_BUFFER0 if the requested property has no owner
1028 handle_selection (display->root, XA_CUT_BUFFER0, false);
1029}
1030
1031void
1032rxvt_selection::finish (char *data, unsigned int len)
1033{
1034 if (!cb_sv)
1035 {
1036 if (data)
1037 term->paste (data, len);
1038
1039 term->selection_req = 0;
1040 delete this;
1041 }
1042#if ENABLE_PERL
1043 else
1044 {
1045 stop (); // we do not really trust perl callbacks
1046 rxvt_perl.selection_finish (this, data, len);
1047 }
1048#endif
1049}
1050
1051bool
1052rxvt_selection::request (Atom target, int selnum)
1053{
1054 Atom sel;
1055
1056 selection_type |= selnum;
1057
1058 if (selnum == Sel_Primary)
1059 sel = XA_PRIMARY;
1060 else if (selnum == Sel_Secondary)
1061 sel = XA_SECONDARY;
1062 else
1063 sel = display->xa[XA_CLIPBOARD];
1064
1065 if (XGetSelectionOwner (display->dpy, sel) != None)
1066 {
1067 XConvertSelection (display->dpy, sel, target, request_prop,
1068 request_win, request_time);
1069 x_ev.start (display, request_win);
1070 timer_ev.again ();
1071 return true;
1072 }
1073
699 return faded; 1074 return false;
700} 1075}
701 1076
1077void
1078rxvt_selection::handle_selection (Window win, Atom prop, bool delete_prop)
1079{
1080 Display *dpy = display->dpy;
1081 char *data = 0;
1082 unsigned int data_len = 0;
1083 unsigned long bytes_after;
1084 XTextProperty ct;
1085
1086 // check for failed XConvertSelection
1087 if (prop == None)
1088 {
1089 bool error = true;
1090 int selnum = selection_type & Sel_whereMask;
1091
1092 if (selection_type & Sel_CompoundText)
1093 {
1094 selection_type = 0;
1095 error = !request (XA_STRING, selnum);
1096 }
1097
1098 if (selection_type & Sel_UTF8String)
1099 {
1100 selection_type = Sel_CompoundText;
1101 error = !request (display->xa[XA_COMPOUND_TEXT], selnum);
1102 }
1103
1104 if (error)
1105 {
1106 ct.value = 0;
1107 goto bailout;
1108 }
1109
1110 return;
1111 }
1112
1113 // length == (2^31 - 1) / 4, as gdk
1114 if (XGetWindowProperty (dpy, win, prop,
1115 0, 0x1fffffff,
1116 delete_prop, AnyPropertyType,
1117 &ct.encoding, &ct.format,
1118 &ct.nitems, &bytes_after,
1119 &ct.value) != Success)
1120 {
1121 ct.value = 0;
1122 goto bailout;
1123 }
1124
1125 if (ct.encoding == None)
1126 goto bailout;
1127
1128 if (ct.value == 0)
1129 goto bailout;
1130
1131 if (ct.encoding == display->xa[XA_INCR])
1132 {
1133 // INCR selection, start handshake
1134 if (!delete_prop)
1135 XDeleteProperty (dpy, win, prop);
1136
1137 selection_wait = Sel_incr;
1138 timer_ev.again ();
1139
1140 goto bailout;
1141 }
1142
1143 if (ct.nitems == 0)
1144 {
1145 if (selection_wait == Sel_incr)
1146 {
1147 XFree (ct.value);
1148
1149 // finally complete, now paste the whole thing
1150 selection_wait = Sel_normal;
1151 ct.value = (unsigned char *)incr_buf;
1152 ct.nitems = incr_buf_fill;
1153 incr_buf = 0;
1154 timer_ev.stop ();
1155 }
1156 else
1157 {
1158 // avoid recursion
1159 if (win != display->root || prop != XA_CUT_BUFFER0)
1160 {
1161 XFree (ct.value);
1162
1163 // fallback to CUT_BUFFER0 if the requested property
1164 // has an owner but is empty
1165 handle_selection (display->root, XA_CUT_BUFFER0, False);
1166 return;
1167 }
1168
1169 goto bailout;
1170 }
1171 }
1172 else if (selection_wait == Sel_incr)
1173 {
1174 timer_ev.again ();
1175
1176 while (incr_buf_fill + ct.nitems > incr_buf_size)
1177 {
1178 incr_buf_size = incr_buf_size ? incr_buf_size * 2 : 128*1024;
1179 incr_buf = (char *)rxvt_realloc (incr_buf, incr_buf_size);
1180 }
1181
1182 memcpy (incr_buf + incr_buf_fill, ct.value, ct.nitems);
1183 incr_buf_fill += ct.nitems;
1184
1185 goto bailout;
1186 }
1187
1188 char **cl;
1189 int cr;
1190
1191 // we honour the first item only
1192
1193#if !ENABLE_MINIMAL
1194 // xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
1195 // so recode it manually
1196 if (ct.encoding == display->xa[XA_UTF8_STRING])
1197 {
1198 wchar_t *w = rxvt_utf8towcs ((const char *)ct.value, ct.nitems);
1199 data = rxvt_wcstombs (w);
1200 free (w);
1201 }
1202 else
1203#endif
1204 if (XmbTextPropertyToTextList (dpy, &ct, &cl, &cr) >= 0
1205 && cl)
1206 {
1207 data = strdup (cl[0]);
1208 XFreeStringList (cl);
1209 }
1210 else
1211 {
1212 // paste raw
1213 data = strdup ((const char *)ct.value);
1214 }
1215
1216 data_len = strlen (data);
1217
1218bailout:
1219 XFree (ct.value);
1220
1221 if (selection_wait == Sel_normal)
1222 {
1223 finish (data, data_len);
1224 free (data);
1225 }
1226}
1227
1228void
1229rxvt_selection::timer_cb (ev::timer &w, int revents)
1230{
1231 if (selection_wait == Sel_incr)
1232 rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
1233
1234 finish ();
1235}
1236
1237void
1238rxvt_selection::x_cb (XEvent &xev)
1239{
1240 switch (xev.type)
1241 {
1242 case PropertyNotify:
1243 if (selection_wait == Sel_incr
1244 && xev.xproperty.atom == request_prop
1245 && xev.xproperty.state == PropertyNewValue)
1246 handle_selection (xev.xproperty.window, xev.xproperty.atom, true);
1247 break;
1248
1249 case SelectionNotify:
1250 if (selection_wait == Sel_normal
1251 && xev.xselection.time == request_time)
1252 {
1253 timer_ev.stop ();
1254 handle_selection (xev.xselection.requestor, xev.xselection.property, true);
1255 }
1256 break;
1257 }
1258}

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines