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.35 by root, Mon Jan 30 16:12:58 2006 UTC vs.
Revision 1.113 by sf-exg, Fri Jan 14 11:09:54 2011 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-2007 Marc Lehmann <pcg@goof.com>
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 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 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 10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
… …
26 26
27#include <unistd.h> 27#include <unistd.h>
28#include <fcntl.h> 28#include <fcntl.h>
29 29
30#include <sys/utsname.h> 30#include <sys/utsname.h>
31
32#ifndef NO_SLOW_LINK_SUPPORT
33# include <sys/socket.h> 31#include <sys/socket.h>
34# include <sys/un.h> 32#include <sys/un.h>
35#endif
36 33
37#if XFT 34#if XFT
38# include <X11/extensions/Xrender.h> 35# include <X11/extensions/Xrender.h>
39#endif 36#endif
40 37
41const char *const xa_names[] = 38static const char *const xa_names[] =
42{ 39{
43 "TEXT", 40 "TEXT",
44 "COMPOUND_TEXT", 41 "COMPOUND_TEXT",
45 "UTF8_STRING", 42 "UTF8_STRING",
46 "MULTIPLE", 43 "MULTIPLE",
… …
62#if ENABLE_EWMH 59#if ENABLE_EWMH
63 "_NET_WM_PID", 60 "_NET_WM_PID",
64 "_NET_WM_NAME", 61 "_NET_WM_NAME",
65 "_NET_WM_ICON_NAME", 62 "_NET_WM_ICON_NAME",
66 "_NET_WM_PING", 63 "_NET_WM_PING",
64 "_NET_WM_ICON",
67#endif 65#endif
68#if USE_XIM 66#if USE_XIM
69 "WM_LOCALE_NAME", 67 "WM_LOCALE_NAME",
70 "XIM_SERVERS", 68 "XIM_SERVERS",
71#endif 69#endif
72#ifdef TRANSPARENT 70#ifdef ENABLE_TRANSPARENCY
73 "_XROOTPMAP_ID", 71 "_XROOTPMAP_ID",
74 "ESETROOT_PMAP_ID", 72 "ESETROOT_PMAP_ID",
75#endif 73#endif
76#if ENABLE_XEMBED 74#if ENABLE_XEMBED
77 "_XEMBED", 75 "_XEMBED",
… …
81 "SCREEN_RESOURCES", 79 "SCREEN_RESOURCES",
82 "XDCCC_LINEAR_RGB_CORRECTION", 80 "XDCCC_LINEAR_RGB_CORRECTION",
83 "XDCCC_LINEAR_RGB_MATRICES", 81 "XDCCC_LINEAR_RGB_MATRICES",
84 "WM_COLORMAP_WINDOWS", 82 "WM_COLORMAP_WINDOWS",
85 "WM_STATE", 83 "WM_STATE",
84 "cursor",
85# if USE_XIM
86 "TRANSPORT",
87 "LOCALES",
88 "_XIM_PROTOCOL",
89 "_XIM_XCONNECT",
90 "_XIM_MOREDATA",
91# endif
86#endif 92#endif
87}; 93};
88 94
89///////////////////////////////////////////////////////////////////////////// 95/////////////////////////////////////////////////////////////////////////////
90 96
… …
169bool 175bool
170rxvt_xim::ref_init () 176rxvt_xim::ref_init ()
171{ 177{
172 display = GET_R->display; //HACK: TODO 178 display = GET_R->display; //HACK: TODO
173 179
174 xim = XOpenIM (display->display, NULL, NULL, NULL); 180 xim = XOpenIM (display->dpy, 0, 0, 0);
175 181
176 if (!xim) 182 if (!xim)
177 return false; 183 return false;
178 184
179 XIMCallback ximcallback; 185 XIMCallback ximcallback;
180 ximcallback.client_data = (XPointer)this; 186 ximcallback.client_data = (XPointer)this;
181 ximcallback.callback = im_destroy_cb; 187 ximcallback.callback = im_destroy_cb;
182 188
183 XSetIMValues (xim, XNDestroyCallback, &ximcallback, NULL); 189 XSetIMValues (xim, XNDestroyCallback, &ximcallback, (char *)0);
184 190
185 return true; 191 return true;
186} 192}
187 193
188rxvt_xim::~rxvt_xim () 194rxvt_xim::~rxvt_xim ()
… …
193 199
194#endif 200#endif
195 201
196///////////////////////////////////////////////////////////////////////////// 202/////////////////////////////////////////////////////////////////////////////
197 203
204#if XFT
205rxvt_drawable::~rxvt_drawable ()
206{
207 if (xftdrawable)
208 XftDrawDestroy (xftdrawable);
209}
210
211rxvt_drawable::operator XftDraw *()
212{
213 if (!xftdrawable)
214 xftdrawable = XftDrawCreate (screen->dpy, drawable, screen->visual, screen->cmap);
215
216 return xftdrawable;
217}
218#endif
219
220/////////////////////////////////////////////////////////////////////////////
221
222#if XFT
223
224// not strictly necessary as it is only used with superclass of zero_initialised
225rxvt_screen::rxvt_screen ()
226: scratch_area (0)
227{
228}
229
230rxvt_drawable &rxvt_screen::scratch_drawable (int w, int h)
231{
232 if (!scratch_area || w > scratch_w || h > scratch_h)
233 {
234 if (scratch_area)
235 {
236 XFreePixmap (dpy, scratch_area->drawable);
237 delete scratch_area;
238 }
239
240 Pixmap pm = XCreatePixmap (dpy, RootWindowOfScreen (ScreenOfDisplay (dpy, display->screen)),
241 scratch_w = w, scratch_h = h, depth);
242
243 scratch_area = new rxvt_drawable (this, pm);
244 }
245
246 return *scratch_area;
247}
248
249#endif
250
198void 251void
199rxvt_screen::set (rxvt_display *disp) 252rxvt_screen::set (rxvt_display *disp)
200{ 253{
201 display = disp; 254 display = disp;
202 xdisp = disp->display; 255 dpy = disp->dpy;
203 256
204 Screen *screen = ScreenOfDisplay (xdisp, disp->screen); 257 Screen *screen = ScreenOfDisplay (dpy, disp->screen);
205 258
206 depth = DefaultDepthOfScreen (screen); 259 depth = DefaultDepthOfScreen (screen);
207 visual = DefaultVisualOfScreen (screen); 260 visual = DefaultVisualOfScreen (screen);
208 cmap = DefaultColormapOfScreen (screen); 261 cmap = DefaultColormapOfScreen (screen);
209} 262}
210 263
211void 264void
212rxvt_screen::set (rxvt_display *disp, int bitdepth) 265rxvt_screen::select_visual (int bitdepth)
213{ 266{
214 set (disp);
215
216#if XFT 267#if XFT
217 XVisualInfo vinfo; 268 XVisualInfo vinfo;
218 269
219 if (XMatchVisualInfo (xdisp, display->screen, bitdepth, TrueColor, &vinfo)) 270 if (XMatchVisualInfo (dpy, display->screen, bitdepth, TrueColor, &vinfo))
220 { 271 {
221 depth = bitdepth; 272 depth = bitdepth;
222 visual = vinfo.visual; 273 visual = vinfo.visual;
223 cmap = XCreateColormap (xdisp, disp->root, visual, AllocNone); 274 cmap = XCreateColormap (dpy, display->root, visual, AllocNone);
224 } 275 }
225#endif 276#endif
226} 277}
227 278
228void 279void
229rxvt_screen::clear () 280rxvt_screen::clear ()
230{ 281{
282#if XFT
283 if (scratch_area)
284 {
285 XFreePixmap (dpy, scratch_area->drawable);
286 delete scratch_area;
287 }
288#endif
289
231 if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (xdisp, display->screen))) 290 if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (dpy, display->screen)))
232 XFreeColormap (xdisp, cmap); 291 XFreeColormap (dpy, cmap);
233} 292}
234 293
235///////////////////////////////////////////////////////////////////////////// 294/////////////////////////////////////////////////////////////////////////////
236 295
237rxvt_display::rxvt_display (const char *id) 296rxvt_display::rxvt_display (const char *id)
238: refcounted (id) 297: refcounted (id)
239, x_ev (this, &rxvt_display::x_cb)
240, selection_owner (0) 298, selection_owner (0)
299, clipboard_owner (0)
241{ 300{
301 x_ev .set<rxvt_display, &rxvt_display::x_cb > (this);
302 flush_ev.set<rxvt_display, &rxvt_display::flush_cb> (this);
242} 303}
243 304
244XrmDatabase 305XrmDatabase
245rxvt_display::get_resources () 306rxvt_display::get_resources (bool refresh)
246{ 307{
247 char *homedir = (char *)getenv ("HOME"); 308 char *homedir = getenv ("HOME");
248 char fname[1024]; 309 char fname[1024];
249 310
250 /* 311 /*
251 * get resources using the X library function 312 * get resources using the X library function
252 */ 313 */
253 char *displayResource, *xe; 314 char *displayResource, *xe;
254 XrmDatabase database, rdb1; 315 XrmDatabase rdb1, database = 0;
255
256 database = NULL;
257 316
258 // for ordering, see for example http://www.faqs.org/faqs/Xt-FAQ/ Subject: 20 317 // for ordering, see for example http://www.faqs.org/faqs/Xt-FAQ/ Subject: 20
318 // as opposed to "standard practise", we always read in ~/.Xdefaults
259 319
260 // 6. System wide per application default file. 320 // 6. System wide per application default file.
261 321
262 /* Add in $XAPPLRESDIR/Rxvt only; not bothering with XUSERFILESEARCHPATH */ 322 /* Add in $XAPPLRESDIR/Rxvt only; not bothering with XUSERFILESEARCHPATH */
263 if ((xe = (char *)getenv ("XAPPLRESDIR"))) 323 if ((xe = getenv ("XAPPLRESDIR")))
264 { 324 {
265 snprintf (fname, sizeof (fname), "%s/%s", xe, RESCLASS); 325 snprintf (fname, sizeof (fname), "%s/%s", xe, RESCLASS);
266 326
267 if ((rdb1 = XrmGetFileDatabase (fname))) 327 if ((rdb1 = XrmGetFileDatabase (fname)))
268 XrmMergeDatabases (rdb1, &database); 328 XrmMergeDatabases (rdb1, &database);
… …
270 330
271 // 5. User's per application default file. 331 // 5. User's per application default file.
272 // none 332 // none
273 333
274 // 4. User's defaults file. 334 // 4. User's defaults file.
335 if (homedir)
336 {
337 snprintf (fname, sizeof (fname), "%s/.Xdefaults", homedir);
338
339 if ((rdb1 = XrmGetFileDatabase (fname)))
340 XrmMergeDatabases (rdb1, &database);
341 }
342
275 /* Get any Xserver defaults */ 343 /* Get any Xserver defaults */
344 if (refresh)
345 {
346 // fucking xlib keeps a copy of the rm string
347 Atom actual_type;
348 int actual_format;
349 unsigned long nitems, nremaining;
350 char *val = 0;
351
352#if XLIB_ILLEGAL_ACCESS
353 if (dpy->xdefaults)
354 XFree (dpy->xdefaults);
355#endif
356
357 if (XGetWindowProperty (dpy, RootWindow (dpy, 0), XA_RESOURCE_MANAGER,
358 0L, 100000000L, False,
359 XA_STRING, &actual_type, &actual_format,
360 &nitems, &nremaining,
361 (unsigned char **)&val) == Success
362 && actual_type == XA_STRING
363 && actual_format == 8)
364 displayResource = val;
365 else
366 {
367 displayResource = 0;
368
369 if (val)
370 XFree (val);
371 }
372
373#if XLIB_ILLEGAL_ACCESS
374 dpy->xdefaults = displayResource;
375#endif
376 }
377 else
276 displayResource = XResourceManagerString (display); 378 displayResource = XResourceManagerString (dpy);
277 379
278 if (displayResource != NULL) 380 if (displayResource)
279 { 381 {
280 if ((rdb1 = XrmGetStringDatabase (displayResource))) 382 if ((rdb1 = XrmGetStringDatabase (displayResource)))
281 XrmMergeDatabases (rdb1, &database); 383 XrmMergeDatabases (rdb1, &database);
282 } 384 }
283 else if (homedir)
284 {
285 snprintf (fname, sizeof (fname), "%s/.Xdefaults", homedir);
286 385
287 if ((rdb1 = XrmGetFileDatabase (fname))) 386#if !XLIB_ILLEGAL_ACCESS
288 XrmMergeDatabases (rdb1, &database); 387 if (refresh && displayResource)
289 } 388 XFree (displayResource);
389#endif
290 390
291 /* Get screen specific resources */ 391 /* Get screen specific resources */
292 displayResource = XScreenResourceString (ScreenOfDisplay (display, screen)); 392 displayResource = XScreenResourceString (ScreenOfDisplay (dpy, screen));
293 393
294 if (displayResource != NULL) 394 if (displayResource)
295 { 395 {
296 if ((rdb1 = XrmGetStringDatabase (displayResource))) 396 if ((rdb1 = XrmGetStringDatabase (displayResource)))
297 /* Merge with screen-independent resources */ 397 /* Merge with screen-independent resources */
298 XrmMergeDatabases (rdb1, &database); 398 XrmMergeDatabases (rdb1, &database);
299 399
300 XFree (displayResource); 400 XFree (displayResource);
301 } 401 }
302 402
303 // 3. User's per host defaults file 403 // 3. User's per host defaults file
304 /* Add in XENVIRONMENT file */ 404 /* Add in XENVIRONMENT file */
305 if ((xe = (char *)getenv ("XENVIRONMENT")) 405 if ((xe = getenv ("XENVIRONMENT"))
306 && (rdb1 = XrmGetFileDatabase (xe))) 406 && (rdb1 = XrmGetFileDatabase (xe)))
307 XrmMergeDatabases (rdb1, &database); 407 XrmMergeDatabases (rdb1, &database);
308 else if (homedir) 408 else if (homedir)
309 { 409 {
310 struct utsname un; 410 struct utsname un;
… …
324bool rxvt_display::ref_init () 424bool rxvt_display::ref_init ()
325{ 425{
326#ifdef LOCAL_X_IS_UNIX 426#ifdef LOCAL_X_IS_UNIX
327 if (id[0] == ':') 427 if (id[0] == ':')
328 { 428 {
329 val = rxvt_malloc (5 + strlen (id) + 1); 429 if (!(val = rxvt_temp_buf<char> (5 + strlen (id) + 1)))
430 return false;
330 strcpy (val, "unix/"); 431 strcpy (val, "unix/");
331 strcat (val, id); 432 strcat (val, id);
332 display = XOpenDisplay (val); 433 dpy = XOpenDisplay (val);
333 free (val);
334 } 434 }
335 else 435 else
336#endif 436#endif
337 display = 0; 437 dpy = 0;
338 438
339 if (!display) 439 if (!dpy)
340 display = XOpenDisplay (id); 440 dpy = XOpenDisplay (id);
341 441
342 if (!display) 442 if (!dpy)
343 return false; 443 return false;
344 444
345 screen = DefaultScreen (display); 445 screen = DefaultScreen (dpy);
346 root = DefaultRootWindow (display); 446 root = DefaultRootWindow (dpy);
347 447
348 assert (sizeof (xa_names) / sizeof (char *) == NUM_XA); 448 assert (ARRAY_LENGTH(xa_names) == NUM_XA);
349 XInternAtoms (display, (char **)xa_names, NUM_XA, False, xa); 449 XInternAtoms (dpy, (char **)xa_names, NUM_XA, False, xa);
350 450
351 XrmSetDatabase (display, get_resources ()); 451 XrmSetDatabase (dpy, get_resources (false));
352 452
353#ifdef POINTER_BLANK 453#ifdef POINTER_BLANK
354 XColor blackcolour; 454 XColor blackcolour;
355 blackcolour.red = 0; 455 blackcolour.red = 0;
356 blackcolour.green = 0; 456 blackcolour.green = 0;
357 blackcolour.blue = 0; 457 blackcolour.blue = 0;
358 Font f = XLoadFont (display, "fixed"); 458 Font f = XLoadFont (dpy, "fixed");
359 blank_cursor = XCreateGlyphCursor (display, f, f, ' ', ' ', 459 blank_cursor = XCreateGlyphCursor (dpy, f, f, ' ', ' ',
360 &blackcolour, &blackcolour); 460 &blackcolour, &blackcolour);
361 XUnloadFont (display, f); 461 XUnloadFont (dpy, f);
362#endif 462#endif
363 463
364 int fd = XConnectionNumber (display); 464 int fd = XConnectionNumber (dpy);
365 465
366#ifndef NO_SLOW_LINK_SUPPORT
367 // try to detect wether we have a local connection. 466 // try to detect whether we have a local connection.
368 // assume unix domains socket == local, everything else not 467 // assume unix domain socket == local, everything else not
369 // TODO: might want to check for inet/127.0.0.1 468 // TODO: might want to check for inet/127.0.0.1
370 is_local = 0; 469 is_local = 0;
371 sockaddr_un sa; 470 sockaddr_un sa;
372 socklen_t sl = sizeof (sa); 471 socklen_t sl = sizeof (sa);
373 472
374 if (!getsockname (fd, (sockaddr *)&sa, &sl)) 473 if (!getsockname (fd, (sockaddr *)&sa, &sl))
375 is_local = sa.sun_family == AF_LOCAL; 474 is_local = sa.sun_family == AF_UNIX;
376#endif
377 475
476 flush_ev.start ();
378 x_ev.start (fd, EVENT_READ); 477 x_ev.start (fd, ev::READ);
379 fcntl (fd, F_SETFD, FD_CLOEXEC); 478 fcntl (fd, F_SETFD, FD_CLOEXEC);
380 479
381 XSelectInput (display, root, PropertyChangeMask); 480 XSelectInput (dpy, root, PropertyChangeMask);
382 481
383 flush (); 482 flush ();
384 483
385 return true; 484 return true;
386} 485}
387 486
388void 487void
389rxvt_display::ref_next () 488rxvt_display::ref_next ()
390{ 489{
391 // TODO: somehow check wether the database files/resources changed 490 // TODO: somehow check whether the database files/resources changed
392 // before re-loading/parsing 491 // before affording re-loading/parsing
393 XrmDestroyDatabase (XrmGetDatabase (display)); 492 XrmDestroyDatabase (XrmGetDatabase (dpy));
394 XrmSetDatabase (display, get_resources ()); 493 XrmSetDatabase (dpy, get_resources (true));
395} 494}
396 495
397rxvt_display::~rxvt_display () 496rxvt_display::~rxvt_display ()
398{ 497{
399 if (!display) 498 if (!dpy)
400 return; 499 return;
401 500
402#ifdef POINTER_BLANK 501#ifdef POINTER_BLANK
403 XFreeCursor (display, blank_cursor); 502 XFreeCursor (dpy, blank_cursor);
404#endif 503#endif
405 x_ev.stop (); 504 x_ev.stop ();
505 flush_ev.stop ();
406#ifdef USE_XIM 506#ifdef USE_XIM
407 xims.clear (); 507 xims.clear ();
408#endif 508#endif
509 XrmDestroyDatabase (XrmGetDatabase (dpy));
409 XCloseDisplay (display); 510 XCloseDisplay (dpy);
410} 511}
411 512
412#ifdef USE_XIM 513#ifdef USE_XIM
413void rxvt_display::im_change_cb () 514void rxvt_display::im_change_cb ()
414{ 515{
… …
422 // registers, as xlib crashes due to a race otherwise. 523 // registers, as xlib crashes due to a race otherwise.
423 Atom actual_type, *atoms; 524 Atom actual_type, *atoms;
424 int actual_format; 525 int actual_format;
425 unsigned long nitems, bytes_after; 526 unsigned long nitems, bytes_after;
426 527
427 if (XGetWindowProperty (display, root, xa[XA_XIM_SERVERS], 0L, 1000000L, 528 if (XGetWindowProperty (dpy, root, xa[XA_XIM_SERVERS], 0L, 1000000L,
428 False, XA_ATOM, &actual_type, &actual_format, 529 False, XA_ATOM, &actual_type, &actual_format,
429 &nitems, &bytes_after, (unsigned char **)&atoms) 530 &nitems, &bytes_after, (unsigned char **)&atoms)
430 != Success ) 531 != Success)
431 return; 532 return;
432 533
433 if (actual_type == XA_ATOM && actual_format == 32) 534 if (actual_type == XA_ATOM && actual_format == 32)
434 for (int i = 0; i < nitems; i++) 535 for (int i = 0; i < nitems; i++)
435 if (XGetSelectionOwner (display, atoms[i])) 536 if (XGetSelectionOwner (dpy, atoms[i]))
436 { 537 {
437 im_change_cb (); 538 im_change_cb ();
438 break; 539 break;
439 } 540 }
440 541
441 XFree (atoms); 542 XFree (atoms);
442} 543}
443#endif 544#endif
444 545
445void rxvt_display::x_cb (io_watcher &w, short revents) 546void rxvt_display::x_cb (ev::io &w, int revents)
446{ 547{
548 flush_ev.start ();
549}
550
551void rxvt_display::flush_cb (ev::prepare &w, int revents)
552{
553 while (XEventsQueued (dpy, QueuedAfterFlush))
447 do 554 do
448 { 555 {
449 XEvent xev; 556 XEvent xev;
450 XNextEvent (display, &xev); 557 XNextEvent (dpy, &xev);
451 558
452#ifdef USE_XIM 559#ifdef USE_XIM
453 if (!XFilterEvent (&xev, None)) 560 if (!XFilterEvent (&xev, None))
454 { 561 {
455 if (xev.type == PropertyNotify 562 if (xev.type == PropertyNotify
456 && xev.xany.window == root 563 && xev.xany.window == root
457 && xev.xproperty.atom == xa[XA_XIM_SERVERS]) 564 && xev.xproperty.atom == xa[XA_XIM_SERVERS])
458 im_change_check (); 565 im_change_check ();
459#endif 566#endif
567 if (xev.type == MappingNotify)
568 XRefreshKeyboardMapping (&xev.xmapping);
569
460 for (int i = xw.size (); i--; ) 570 for (int i = xw.size (); i--; )
461 { 571 {
462 if (!xw[i]) 572 if (!xw[i])
463 xw.erase_unordered (i); 573 xw.erase_unordered (i);
464 else if (xw[i]->window == xev.xany.window) 574 else if (xw[i]->window == xev.xany.window)
465 xw[i]->call (xev); 575 xw[i]->call (xev);
466 } 576 }
467#ifdef USE_XIM 577#ifdef USE_XIM
468 } 578 }
469#endif 579#endif
470 } 580 }
471 while (XEventsQueued (display, QueuedAlready)); 581 while (XEventsQueued (dpy, QueuedAlready));
472 582
473 XFlush (display); 583 w.stop ();
474}
475
476void rxvt_display::flush ()
477{
478 if (XEventsQueued (display, QueuedAlready))
479 x_cb (x_ev, EVENT_READ);
480
481 XFlush (display);
482} 584}
483 585
484void rxvt_display::reg (xevent_watcher *w) 586void rxvt_display::reg (xevent_watcher *w)
485{ 587{
588 if (!w->active)
589 {
486 xw.push_back (w); 590 xw.push_back (w);
487 w->active = xw.size (); 591 w->active = xw.size ();
592 }
488} 593}
489 594
490void rxvt_display::unreg (xevent_watcher *w) 595void rxvt_display::unreg (xevent_watcher *w)
491{ 596{
492 if (w->active) 597 if (w->active)
598 {
493 xw[w->active - 1] = 0; 599 xw[w->active - 1] = 0;
600 w->active = 0;
601 }
494} 602}
495 603
496void rxvt_display::set_selection_owner (rxvt_term *owner) 604void rxvt_display::set_selection_owner (rxvt_term *owner, bool clipboard)
497{ 605{
606 rxvt_term * &cur_owner = !clipboard ? selection_owner : clipboard_owner;
607
498 if (selection_owner && selection_owner != owner) 608 if (cur_owner && cur_owner != owner)
499 selection_owner->selection_clear (); 609 {
610 rxvt_term *term = cur_owner;
611 term->selection_clear (clipboard);
612 term->flush ();
613 }
500 614
501 selection_owner = owner; 615 cur_owner = owner;
502} 616}
503 617
504#ifdef USE_XIM 618#ifdef USE_XIM
619
505void rxvt_display::reg (im_watcher *w) 620void rxvt_display::reg (im_watcher *w)
506{ 621{
507 imw.push_back (w); 622 imw.push_back (w);
508} 623}
509 624
… …
518 int l, m; 633 int l, m;
519 634
520 l = strlen (locale); 635 l = strlen (locale);
521 m = strlen (modifiers); 636 m = strlen (modifiers);
522 637
523 if (!(id = (char *)malloc (l + m + 2))) 638 if (!(id = rxvt_temp_buf<char> (l + m + 2)))
524 return 0; 639 return 0;
525 640
526 memcpy (id, locale, l); id[l] = '\n'; 641 memcpy (id, locale, l); id[l] = '\n';
527 memcpy (id + l + 1, modifiers, m); id[l + m + 1] = 0; 642 memcpy (id + l + 1, modifiers, m); id[l + m + 1] = 0;
528 643
529 rxvt_xim *xim = xims.get (id); 644 rxvt_xim *xim = xims.get (id);
530 645
531 free (id);
532
533 return xim; 646 return xim;
534} 647}
535 648
536void rxvt_display::put_xim (rxvt_xim *xim) 649void rxvt_display::put_xim (rxvt_xim *xim)
537{ 650{
538#if XLIB_IS_RACEFREE 651# if XLIB_IS_RACEFREE
539 xims.put (xim); 652 xims.put (xim);
540#endif 653# endif
541} 654}
655
542#endif 656#endif
543 657
544Atom rxvt_display::atom (const char *name) 658Atom rxvt_display::atom (const char *name)
545{ 659{
546 return XInternAtom (display, name, False); 660 return XInternAtom (dpy, name, False);
547} 661}
548 662
549///////////////////////////////////////////////////////////////////////////// 663/////////////////////////////////////////////////////////////////////////////
550 664
551template class refcache<rxvt_display>; 665template class refcache<rxvt_display>;
552refcache<rxvt_display> displays; 666refcache<rxvt_display> displays;
553 667
554///////////////////////////////////////////////////////////////////////////// 668/////////////////////////////////////////////////////////////////////////////
555 669//
670
671static unsigned int
672insert_component (unsigned int value, unsigned int mask, unsigned int shift)
673{
674 return (value * (mask + 1) >> 16) << shift;
675}
676
677bool
678rxvt_color::alloc (rxvt_screen *screen, const rgba &color)
679{
680 //TODO: only supports 24 bit
681 int alpha = color.a >= 0xff00 ? 0xffff : color.a;
682
683#if XFT
684 XRenderPictFormat *format;
685
686 // FUCKING Xft gets it wrong, of course, so work around it.
687 // Transparency users should eat shit and die, and then
688 // XRenderQueryPictIndexValues themselves plenty.
689 if ((screen->visual->c_class == TrueColor)
690 && (format = XRenderFindVisualFormat (screen->dpy, screen->visual)))
691 {
692 // the fun lies in doing everything manually...
693 c.color.red = color.r;
694 c.color.green = color.g;
695 c.color.blue = color.b;
696 c.color.alpha = alpha;
697
698 c.pixel = insert_component (color.r, format->direct.redMask , format->direct.red )
699 | insert_component (color.g, format->direct.greenMask, format->direct.green)
700 | insert_component (color.b, format->direct.blueMask , format->direct.blue )
701 | insert_component (alpha , format->direct.alphaMask, format->direct.alpha);
702
703 return true;
704 }
705 else
706 {
707 XRenderColor d;
708
709 d.red = color.r;
710 d.green = color.g;
711 d.blue = color.b;
712 d.alpha = alpha;
713
714 return XftColorAllocValue (screen->dpy, screen->visual, screen->cmap, &d, &c);
715 }
716#else
717 c.red = color.r;
718 c.green = color.g;
719 c.blue = color.b;
720
721 if (screen->visual->c_class == TrueColor)
722 {
723 c.pixel = (color.r >> (16 - rxvt_popcount (screen->visual->red_mask )) << rxvt_ctz (screen->visual->red_mask ))
724 | (color.g >> (16 - rxvt_popcount (screen->visual->green_mask)) << rxvt_ctz (screen->visual->green_mask))
725 | (color.b >> (16 - rxvt_popcount (screen->visual->blue_mask )) << rxvt_ctz (screen->visual->blue_mask ));
726
727 return true;
728 }
729 else if (XAllocColor (screen->dpy, screen->cmap, &c))
730 return true;
731 else
732 c.pixel = (color.r + color.g + color.b) > 128*3
733 ? WhitePixelOfScreen (DefaultScreenOfDisplay (screen->dpy))
734 : BlackPixelOfScreen (DefaultScreenOfDisplay (screen->dpy));
735#endif
736
737 return false;
738}
739
556bool 740bool
557rxvt_color::set (rxvt_screen *screen, const char *name) 741rxvt_color::set (rxvt_screen *screen, const char *name)
558{ 742{
743 rgba c;
744 char eos;
745 int skip;
746
747 c.a = rgba::MAX_CC;
748
749 // parse the nonstandard "[alphapercent]" prefix
750 if (1 <= sscanf (name, "[%hd]%n", &c.a, &skip))
751 {
752 c.a = lerp<int, int, int> (0, rgba::MAX_CC, c.a);
753 name += skip;
754 }
755
756 // parse the non-standard "rgba:rrrr/gggg/bbbb/aaaa" format
757 if (strlen (name) != 4+5*4 || 4 != sscanf (name, "rgba:%4hx/%4hx/%4hx/%4hx%c", &c.r, &c.g, &c.b, &c.a, &eos))
758 {
759 XColor xc;
760
761 if (XParseColor (screen->dpy, screen->cmap, name, &xc))
762 {
763 c.r = xc.red;
764 c.g = xc.green;
765 c.b = xc.blue;
766 }
767 else
768 {
769 c.r = 0xffff;
770 c.g = 0x6969;
771 c.b = 0xb4b4;
772
773 rxvt_warn ("unable to parse color '%s', using pink instead.\n", name);
774 }
775 }
776
777 return set (screen, c);
778}
779
780bool
781rxvt_color::set (rxvt_screen *screen, const rgba &color)
782{
783 bool got = alloc (screen, color);
784
785#if !ENABLE_MINIMAL
786 int cmap_size = screen->visual->map_entries;
787
788 if (!got
789 && screen->visual->c_class == PseudoColor
790 && cmap_size < 4096)
791 {
792 XColor *colors = new XColor [screen->visual->map_entries];
793
794 for (int i = 0; i < cmap_size; i++)
795 colors [i].pixel = i;
796
797 // many kilobytes transfer per colour, but pseudocolor isn't worth
798 // many extra optimisations.
799 XQueryColors (screen->dpy, screen->cmap, colors, cmap_size);
800
801 int diff = 0x7fffffffUL;
802 XColor *best = colors;
803
804 for (int i = 0; i < cmap_size; i++)
805 {
806 int d = (squared_diff<int> (color.r >> 2, colors [i].red >> 2))
807 + (squared_diff<int> (color.g >> 2, colors [i].green >> 2))
808 + (squared_diff<int> (color.b >> 2, colors [i].blue >> 2));
809
810 if (d < diff)
811 {
812 diff = d;
813 best = colors + i;
814 }
815 }
816
817 //rxvt_warn ("could not allocate %04x %04x %04x, getting %04x %04x %04x instead (%d)\n",
818 // color.r, color.g, color.b, best->red, best->green, best->blue, diff);
819
820 got = alloc (screen, rgba (best->red, best->green, best->blue));
821
822 delete [] colors;
823 }
824#endif
825
826 return got;
827}
828
829void
830rxvt_color::get (rgba &color)
831{
559#if XFT 832#if XFT
560 int l = strlen (name); 833 color.r = c.color.red;
561 rxvt_rgba r; 834 color.g = c.color.green;
562 char eos; 835 color.b = c.color.blue;
563 int mult; 836 color.a = c.color.alpha;
564
565 // shortcutting this saves countless server RTTs for the built-in colours
566 if (l == 3+3*3 && 3 == sscanf (name, "rgb:%hx/%hx/%hx/%hx%c", &r.r, &r.g, &r.b, &r.a, &eos))
567 {
568 r.a = rxvt_rgba::MAX_CC;
569 mult = rxvt_rgba::MAX_CC / 0x00ff;
570 }
571
572 // parse a number of non-standard ARGB colour specifications
573 else if ( l == 1+4*1 && 4 == sscanf (name, "#%1hx%1hx%1hx%1hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
574 mult = rxvt_rgba::MAX_CC / 0x000f;
575 else if (l == 1+4*2 && 4 == sscanf (name, "#%2hx%2hx%2hx%2hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
576 mult = rxvt_rgba::MAX_CC / 0x00ff;
577 else if (l == 1+4*4 && 4 == sscanf (name, "#%4hx%4hx%4hx%4hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
578 mult = rxvt_rgba::MAX_CC / 0xffff;
579 else if (l == 4+5*4 && 4 == sscanf (name, "rgba:%hx/%hx/%hx/%hx%c", &r.r, &r.g, &r.b, &r.a, &eos))
580 mult = rxvt_rgba::MAX_CC / 0xffff;
581
582 // slow case: server round trip
583 else
584 return XftColorAllocName (screen->xdisp, screen->visual, screen->cmap, name, &c);
585
586 r.r *= mult; r.g *= mult; r.b *= mult; r.a *= mult;
587
588 return set (screen, r);
589#else 837#else
590 XColor xc; 838 color.r = c.red;
591 839 color.g = c.green;
592 if (XParseColor (screen->xdisp, screen->cmap, name, &xc)) 840 color.b = c.blue;
593 return set (screen, rxvt_rgba (xc.red, xc.green, xc.blue)); 841 color.a = rgba::MAX_CC;
594
595 return false;
596#endif 842#endif
597} 843}
598 844
599bool 845void
846rxvt_color::get (XColor &color)
847{
848 rgba c;
849 get (c);
850
851 color.red = c.r;
852 color.green = c.g;
853 color.blue = c.b;
854 color.pixel = (Pixel)*this;
855}
856
857void
600rxvt_color::set (rxvt_screen *screen, rxvt_rgba rgba) 858rxvt_color::free (rxvt_screen *screen)
601{ 859{
860 if (screen->visual->c_class == TrueColor)
861 return; // nothing to do
862
602#if XFT 863#if XFT
603 XRenderPictFormat *format;
604
605 // FUCKING Xft gets it wrong, of course, so work around it
606 // transparency users should eat shit and die, and then
607 // XRenderQueryPictIndexValues themselves plenty.
608 if (screen->visual->c_class == TrueColor
609 && (format = XRenderFindVisualFormat (screen->xdisp, screen->visual)))
610 {
611 // the fun lies in doing everything manually...
612 c.color.red = rgba.r;
613 c.color.green = rgba.g;
614 c.color.blue = rgba.b;
615 c.color.alpha = rgba.a;
616
617 c.pixel = ((rgba.r * format->direct.redMask / rxvt_rgba::MAX_CC) << format->direct.red )
618 | ((rgba.g * format->direct.greenMask / rxvt_rgba::MAX_CC) << format->direct.green)
619 | ((rgba.b * format->direct.blueMask / rxvt_rgba::MAX_CC) << format->direct.blue )
620 | ((rgba.a * format->direct.alphaMask / rxvt_rgba::MAX_CC) << format->direct.alpha);
621
622 return true;
623 }
624 else
625 {
626 XRenderColor d;
627
628 d.red = rgba.r;
629 d.green = rgba.g;
630 d.blue = rgba.b;
631 d.alpha = rgba.a;
632
633 return XftColorAllocValue (screen->xdisp, screen->visual, screen->cmap, &d, &c); 864 XftColorFree (screen->dpy, screen->visual, screen->cmap, &c);
634 }
635
636 return false;
637#else 865#else
638 if (screen->visual->c_class == TrueColor)
639 {
640 p = (rgba.r * (screen->visual->red_mask >> ctz (screen->visual->red_mask ))
641 / rxvt_rgba::MAX_CC) << ctz (screen->visual->red_mask )
642 | (rgba.g * (screen->visual->green_mask >> ctz (screen->visual->green_mask))
643 / rxvt_rgba::MAX_CC) << ctz (screen->visual->green_mask)
644 | (rgba.b * (screen->visual->blue_mask >> ctz (screen->visual->blue_mask ))
645 / rxvt_rgba::MAX_CC) << ctz (screen->visual->blue_mask );
646
647 return true;
648 }
649 else
650 {
651 XColor xc;
652
653 xc.red = rgba.r;
654 xc.green = rgba.g;
655 xc.blue = rgba.b;
656 xc.flags = DoRed | DoGreen | DoBlue;
657
658 if (XAllocColor (screen->xdisp, screen->cmap, &xc))
659 {
660 p = xc.pixel;
661 return true;
662 }
663 }
664
665 return false;
666#endif
667}
668
669void
670rxvt_color::get (rxvt_screen *screen, rxvt_rgba &rgba)
671{
672#if XFT
673 rgba.r = c.color.red;
674 rgba.g = c.color.green;
675 rgba.b = c.color.blue;
676 rgba.a = c.color.alpha;
677#else
678 XColor c;
679
680 c.pixel = p;
681 XQueryColor (screen->xdisp, screen->cmap, &c);
682
683 rgba.r = c.red;
684 rgba.g = c.green;
685 rgba.b = c.blue;
686 rgba.a = rxvt_rgba::MAX_CC;
687#endif
688}
689
690void
691rxvt_color::free (rxvt_screen *screen)
692{
693#if XFT
694 XftColorFree (screen->xdisp, screen->visual, screen->cmap, &c);
695#else
696 XFreeColors (screen->xdisp, screen->cmap, &p, 1, AllPlanes); 866 XFreeColors (screen->dpy, screen->cmap, &c.pixel, 1, AllPlanes);
697#endif 867#endif
698} 868}
699 869
700rxvt_color 870void
701rxvt_color::fade (rxvt_screen *screen, int percent)
702{
703 rxvt_color faded;
704
705 rxvt_rgba c;
706 get (screen, c);
707
708 c.r = lerp (0, c.r, percent);
709 c.g = lerp (0, c.g, percent);
710 c.b = lerp (0, c.b, percent);
711
712 faded.set (screen, c);
713
714 return faded;
715}
716
717rxvt_color
718rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &fadeto) 871rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to)
719{ 872{
720 rxvt_rgba c, fc; 873 rgba c;
721 rxvt_color faded; 874 get (c);
722
723 get (screen, c);
724 fadeto.get (screen, fc);
725 875
726 faded.set ( 876 result.set (
727 screen, 877 screen,
728 rxvt_rgba ( 878 rgba (
729 lerp (fc.r, c.r, percent), 879 lerp (c.r, to.r, percent),
730 lerp (fc.g, c.g, percent), 880 lerp (c.g, to.g, percent),
731 lerp (fc.b, c.b, percent), 881 lerp (c.b, to.b, percent),
732 lerp (fc.a, c.a, percent) 882 lerp (c.a, to.a, percent)
733 ) 883 )
734 ); 884 );
735
736 return faded;
737} 885}
738 886

Diff Legend

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