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.30 by root, Sun Jan 29 21:54:33 2006 UTC vs.
Revision 1.78 by root, Fri Nov 23 07:59:14 2007 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-2006 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>
33
34#if XFT
35# include <X11/extensions/Xrender.h>
35#endif 36#endif
36 37
37const char *const xa_names[] = 38const char *const xa_names[] =
38 { 39{
39 "TEXT", 40 "TEXT",
40 "COMPOUND_TEXT", 41 "COMPOUND_TEXT",
41 "UTF8_STRING", 42 "UTF8_STRING",
42 "MULTIPLE", 43 "MULTIPLE",
43 "TARGETS", 44 "TARGETS",
44 "TIMESTAMP", 45 "TIMESTAMP",
45 "VT_SELECTION", 46 "VT_SELECTION",
46 "INCR", 47 "INCR",
47 "WM_PROTOCOLS", 48 "WM_PROTOCOLS",
48 "WM_DELETE_WINDOW", 49 "WM_DELETE_WINDOW",
49 "CLIPBOARD", 50 "CLIPBOARD",
51 "AVERAGE_WIDTH",
52 "WEIGHT_NAME",
53 "SLANT",
54 "CHARSET_REGISTRY",
55 "CHARSET_ENCODING",
50#if ENABLE_FRILLS 56#if ENABLE_FRILLS
51 "_MOTIF_WM_HINTS", 57 "_MOTIF_WM_HINTS",
52#endif 58#endif
53#if ENABLE_EWMH 59#if ENABLE_EWMH
54 "_NET_WM_PID", 60 "_NET_WM_PID",
55 "_NET_WM_NAME", 61 "_NET_WM_NAME",
56 "_NET_WM_ICON_NAME", 62 "_NET_WM_ICON_NAME",
57 "_NET_WM_PING", 63 "_NET_WM_PING",
58#endif 64#endif
59#if USE_XIM 65#if USE_XIM
60 "WM_LOCALE_NAME", 66 "WM_LOCALE_NAME",
61 "XIM_SERVERS", 67 "XIM_SERVERS",
62#endif 68#endif
63#ifdef TRANSPARENT 69#ifdef ENABLE_TRANSPARENCY
64 "_XROOTPMAP_ID", 70 "_XROOTPMAP_ID",
65 "ESETROOT_PMAP_ID", 71 "ESETROOT_PMAP_ID",
66#endif 72#endif
67#if ENABLE_XEMBED 73#if ENABLE_XEMBED
68 "_XEMBED", 74 "_XEMBED",
69 "_XEMBED_INFO", 75 "_XEMBED_INFO",
76#endif
77#if !ENABLE_MINIMAL
78 "SCREEN_RESOURCES",
79 "XDCCC_LINEAR_RGB_CORRECTION",
80 "XDCCC_LINEAR_RGB_MATRICES",
81 "WM_COLORMAP_WINDOWS",
82 "WM_STATE",
83 "cursor",
84# if USE_XIM
85 "TRANSPORT",
86 "LOCALES",
87 "_XIM_PROTOCOL",
88 "_XIM_XCONNECT",
89 "_XIM_MOREDATA",
70#endif 90# endif
71 }; 91#endif
92};
72 93
73///////////////////////////////////////////////////////////////////////////// 94/////////////////////////////////////////////////////////////////////////////
74 95
75refcounted::refcounted (const char *id) 96refcounted::refcounted (const char *id)
76{ 97{
… …
153bool 174bool
154rxvt_xim::ref_init () 175rxvt_xim::ref_init ()
155{ 176{
156 display = GET_R->display; //HACK: TODO 177 display = GET_R->display; //HACK: TODO
157 178
158 xim = XOpenIM (display->display, NULL, NULL, NULL); 179 xim = XOpenIM (display->dpy, 0, 0, 0);
159 180
160 if (!xim) 181 if (!xim)
161 return false; 182 return false;
162 183
163 XIMCallback ximcallback; 184 XIMCallback ximcallback;
164 ximcallback.client_data = (XPointer)this; 185 ximcallback.client_data = (XPointer)this;
165 ximcallback.callback = im_destroy_cb; 186 ximcallback.callback = im_destroy_cb;
166 187
167 XSetIMValues (xim, XNDestroyCallback, &ximcallback, NULL); 188 XSetIMValues (xim, XNDestroyCallback, &ximcallback, (char *)0);
168 189
169 return true; 190 return true;
170} 191}
171 192
172rxvt_xim::~rxvt_xim () 193rxvt_xim::~rxvt_xim ()
… …
177 198
178#endif 199#endif
179 200
180///////////////////////////////////////////////////////////////////////////// 201/////////////////////////////////////////////////////////////////////////////
181 202
203#if XFT
204rxvt_drawable::~rxvt_drawable ()
205{
206 if (xftdrawable)
207 XftDrawDestroy (xftdrawable);
208}
209
210rxvt_drawable::operator XftDraw *()
211{
212 if (!xftdrawable)
213 xftdrawable = XftDrawCreate (screen->dpy, drawable, screen->visual, screen->cmap);
214
215 return xftdrawable;
216}
217#endif
218
219/////////////////////////////////////////////////////////////////////////////
220
221#if XFT
222
223// not strictly necessary as it is only used with superclass of zero_initialised
224rxvt_screen::rxvt_screen ()
225: scratch_area (0)
226{
227}
228
229rxvt_drawable &rxvt_screen::scratch_drawable (int w, int h)
230{
231 // it's actually faster to re-allocate every time. don't ask me
232 // why, but its likely no big deal there are no roundtrips
233 // (I think/hope).
234 if (!scratch_area || w > scratch_w || h > scratch_h || 1/*D*/)
235 {
236 if (scratch_area)
237 {
238 XFreePixmap (dpy, scratch_area->drawable);
239 delete scratch_area;
240 }
241
242 Pixmap pm = XCreatePixmap (dpy, RootWindowOfScreen (ScreenOfDisplay (dpy, display->screen)),
243 scratch_w = w, scratch_h = h, depth);
244
245 scratch_area = new rxvt_drawable (this, pm);
246 }
247
248 return *scratch_area;
249}
250
251#endif
252
182void 253void
183rxvt_screen::set (rxvt_display *disp) 254rxvt_screen::set (rxvt_display *disp)
184{ 255{
185 display = disp; 256 display = disp;
186 xdisp = disp->display; 257 dpy = disp->dpy;
187 258
188 Screen *screen = ScreenOfDisplay (xdisp, disp->screen); 259 Screen *screen = ScreenOfDisplay (dpy, disp->screen);
189 260
190 depth = DefaultDepthOfScreen (screen); 261 depth = DefaultDepthOfScreen (screen);
191 visual = DefaultVisualOfScreen (screen); 262 visual = DefaultVisualOfScreen (screen);
192 cmap = DefaultColormapOfScreen (screen); 263 cmap = DefaultColormapOfScreen (screen);
193} 264}
194 265
195void 266void
196rxvt_screen::set (rxvt_display *disp, int bitdepth) 267rxvt_screen::select_visual (int bitdepth)
197{ 268{
198 set (disp); 269#if XFT
199
200 XVisualInfo vinfo; 270 XVisualInfo vinfo;
201 271
202 if (XMatchVisualInfo (xdisp, display->screen, bitdepth, TrueColor, &vinfo)) 272 if (XMatchVisualInfo (dpy, display->screen, bitdepth, TrueColor, &vinfo))
203 { 273 {
204 depth = bitdepth; 274 depth = bitdepth;
205 visual = vinfo.visual; 275 visual = vinfo.visual;
206 cmap = XCreateColormap (xdisp, disp->root, visual, AllocNone); 276 cmap = XCreateColormap (dpy, display->root, visual, AllocNone);
207 } 277 }
278#endif
208} 279}
209 280
210void 281void
211rxvt_screen::clear () 282rxvt_screen::clear ()
212{ 283{
284#if XFT
285 if (scratch_area)
286 {
287 XFreePixmap (dpy, scratch_area->drawable);
288 delete scratch_area;
289 }
290#endif
291
213 if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (xdisp, display->screen))) 292 if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (dpy, display->screen)))
214 XFreeColormap (xdisp, cmap); 293 XFreeColormap (dpy, cmap);
215} 294}
216 295
217///////////////////////////////////////////////////////////////////////////// 296/////////////////////////////////////////////////////////////////////////////
218 297
219rxvt_display::rxvt_display (const char *id) 298rxvt_display::rxvt_display (const char *id)
… …
222, selection_owner (0) 301, selection_owner (0)
223{ 302{
224} 303}
225 304
226XrmDatabase 305XrmDatabase
227rxvt_display::get_resources () 306rxvt_display::get_resources (bool refresh)
228{ 307{
229 char *homedir = (char *)getenv ("HOME"); 308 char *homedir = (char *)getenv ("HOME");
230 char fname[1024]; 309 char fname[1024];
231 310
232 /* 311 /*
233 * get resources using the X library function 312 * get resources using the X library function
234 */ 313 */
235 char *displayResource, *xe; 314 char *displayResource, *xe;
236 XrmDatabase database, rdb1; 315 XrmDatabase rdb1, database = 0;
237
238 database = NULL;
239 316
240 // 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
241 319
242 // 6. System wide per application default file. 320 // 6. System wide per application default file.
243 321
244 /* Add in $XAPPLRESDIR/Rxvt only; not bothering with XUSERFILESEARCHPATH */ 322 /* Add in $XAPPLRESDIR/Rxvt only; not bothering with XUSERFILESEARCHPATH */
245 if ((xe = (char *)getenv ("XAPPLRESDIR"))) 323 if ((xe = (char *)getenv ("XAPPLRESDIR")))
… …
252 330
253 // 5. User's per application default file. 331 // 5. User's per application default file.
254 // none 332 // none
255 333
256 // 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
257 /* 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
258 displayResource = XResourceManagerString (display); 378 displayResource = XResourceManagerString (dpy);
259 379
260 if (displayResource != NULL) 380 if (displayResource)
261 { 381 {
262 if ((rdb1 = XrmGetStringDatabase (displayResource))) 382 if ((rdb1 = XrmGetStringDatabase (displayResource)))
263 XrmMergeDatabases (rdb1, &database); 383 XrmMergeDatabases (rdb1, &database);
264 } 384 }
265 else if (homedir)
266 {
267 snprintf (fname, sizeof (fname), "%s/.Xdefaults", homedir);
268 385
269 if ((rdb1 = XrmGetFileDatabase (fname))) 386#if !XLIB_ILLEGAL_ACCESS
270 XrmMergeDatabases (rdb1, &database); 387 if (refresh && displayResource)
271 } 388 XFree (displayResource);
389#endif
272 390
273 /* Get screen specific resources */ 391 /* Get screen specific resources */
274 displayResource = XScreenResourceString (ScreenOfDisplay (display, screen)); 392 displayResource = XScreenResourceString (ScreenOfDisplay (dpy, screen));
275 393
276 if (displayResource != NULL) 394 if (displayResource)
277 { 395 {
278 if ((rdb1 = XrmGetStringDatabase (displayResource))) 396 if ((rdb1 = XrmGetStringDatabase (displayResource)))
279 /* Merge with screen-independent resources */ 397 /* Merge with screen-independent resources */
280 XrmMergeDatabases (rdb1, &database); 398 XrmMergeDatabases (rdb1, &database);
281 399
… …
309 if (id[0] == ':') 427 if (id[0] == ':')
310 { 428 {
311 val = rxvt_malloc (5 + strlen (id) + 1); 429 val = rxvt_malloc (5 + strlen (id) + 1);
312 strcpy (val, "unix/"); 430 strcpy (val, "unix/");
313 strcat (val, id); 431 strcat (val, id);
314 display = XOpenDisplay (val); 432 dpy = XOpenDisplay (val);
315 free (val); 433 free (val);
316 } 434 }
317 else 435 else
318#endif 436#endif
319 display = 0; 437 dpy = 0;
320 438
321 if (!display) 439 if (!dpy)
322 display = XOpenDisplay (id); 440 dpy = XOpenDisplay (id);
323 441
324 if (!display) 442 if (!dpy)
325 return false; 443 return false;
326 444
327 screen = DefaultScreen (display); 445 screen = DefaultScreen (dpy);
328 root = DefaultRootWindow (display); 446 root = DefaultRootWindow (dpy);
329 447
330 assert (sizeof (xa_names) / sizeof (char *) == NUM_XA); 448 assert (sizeof (xa_names) / sizeof (char *) == NUM_XA);
331 XInternAtoms (display, (char **)xa_names, NUM_XA, False, xa); 449 XInternAtoms (dpy, (char **)xa_names, NUM_XA, False, xa);
332 450
333 XrmSetDatabase (display, get_resources ()); 451 XrmSetDatabase (dpy, get_resources (false));
334 452
335#ifdef POINTER_BLANK 453#ifdef POINTER_BLANK
336 XColor blackcolour; 454 XColor blackcolour;
337 blackcolour.red = 0; 455 blackcolour.red = 0;
338 blackcolour.green = 0; 456 blackcolour.green = 0;
339 blackcolour.blue = 0; 457 blackcolour.blue = 0;
340 Font f = XLoadFont (display, "fixed"); 458 Font f = XLoadFont (dpy, "fixed");
341 blank_cursor = XCreateGlyphCursor (display, f, f, ' ', ' ', 459 blank_cursor = XCreateGlyphCursor (dpy, f, f, ' ', ' ',
342 &blackcolour, &blackcolour); 460 &blackcolour, &blackcolour);
343 XUnloadFont (display, f); 461 XUnloadFont (dpy, f);
344#endif 462#endif
345 463
346 int fd = XConnectionNumber (display); 464 int fd = XConnectionNumber (dpy);
347 465
348#ifndef NO_SLOW_LINK_SUPPORT
349 // try to detect wether we have a local connection. 466 // try to detect wether we have a local connection.
350 // assume unix domains socket == local, everything else not 467 // assume unix domain socket == local, everything else not
351 // TODO: might want to check for inet/127.0.0.1 468 // TODO: might want to check for inet/127.0.0.1
352 is_local = 0; 469 is_local = 0;
353 sockaddr_un sa; 470 sockaddr_un sa;
354 socklen_t sl = sizeof (sa); 471 socklen_t sl = sizeof (sa);
355 472
356 if (!getsockname (fd, (sockaddr *)&sa, &sl)) 473 if (!getsockname (fd, (sockaddr *)&sa, &sl))
357 is_local = sa.sun_family == AF_LOCAL; 474 is_local = sa.sun_family == AF_UNIX;
358#endif
359 475
360 x_ev.start (fd, EVENT_READ); 476 x_ev.start (fd, ev::READ);
361 fcntl (fd, F_SETFD, FD_CLOEXEC); 477 fcntl (fd, F_SETFD, FD_CLOEXEC);
362 478
363 XSelectInput (display, root, PropertyChangeMask); 479 XSelectInput (dpy, root, PropertyChangeMask);
364 480
365 flush (); 481 flush ();
366 482
367 return true; 483 return true;
368} 484}
369 485
370void 486void
371rxvt_display::ref_next () 487rxvt_display::ref_next ()
372{ 488{
373 // TODO: somehow check wether the database files/resources changed 489 // TODO: somehow check wether the database files/resources changed
374 // before re-loading/parsing 490 // before affording re-loading/parsing
375 XrmDestroyDatabase (XrmGetDatabase (display)); 491 XrmDestroyDatabase (XrmGetDatabase (dpy));
376 XrmSetDatabase (display, get_resources ()); 492 XrmSetDatabase (dpy, get_resources (true));
377} 493}
378 494
379rxvt_display::~rxvt_display () 495rxvt_display::~rxvt_display ()
380{ 496{
381 if (!display) 497 if (!dpy)
382 return; 498 return;
383 499
384#ifdef POINTER_BLANK 500#ifdef POINTER_BLANK
385 XFreeCursor (display, blank_cursor); 501 XFreeCursor (dpy, blank_cursor);
386#endif 502#endif
387 x_ev.stop (); 503 x_ev.stop ();
388#ifdef USE_XIM 504#ifdef USE_XIM
389 xims.clear (); 505 xims.clear ();
390#endif 506#endif
391 XCloseDisplay (display); 507 XCloseDisplay (dpy);
392} 508}
393 509
394#ifdef USE_XIM 510#ifdef USE_XIM
395void rxvt_display::im_change_cb () 511void rxvt_display::im_change_cb ()
396{ 512{
… …
404 // registers, as xlib crashes due to a race otherwise. 520 // registers, as xlib crashes due to a race otherwise.
405 Atom actual_type, *atoms; 521 Atom actual_type, *atoms;
406 int actual_format; 522 int actual_format;
407 unsigned long nitems, bytes_after; 523 unsigned long nitems, bytes_after;
408 524
409 if (XGetWindowProperty (display, root, xa[XA_XIM_SERVERS], 0L, 1000000L, 525 if (XGetWindowProperty (dpy, root, xa[XA_XIM_SERVERS], 0L, 1000000L,
410 False, XA_ATOM, &actual_type, &actual_format, 526 False, XA_ATOM, &actual_type, &actual_format,
411 &nitems, &bytes_after, (unsigned char **)&atoms) 527 &nitems, &bytes_after, (unsigned char **)&atoms)
412 != Success ) 528 != Success )
413 return; 529 return;
414 530
415 if (actual_type == XA_ATOM && actual_format == 32) 531 if (actual_type == XA_ATOM && actual_format == 32)
416 for (int i = 0; i < nitems; i++) 532 for (int i = 0; i < nitems; i++)
417 if (XGetSelectionOwner (display, atoms[i])) 533 if (XGetSelectionOwner (dpy, atoms[i]))
418 { 534 {
419 im_change_cb (); 535 im_change_cb ();
420 break; 536 break;
421 } 537 }
422 538
423 XFree (atoms); 539 XFree (atoms);
424} 540}
425#endif 541#endif
426 542
427void rxvt_display::x_cb (io_watcher &w, short revents) 543void rxvt_display::x_cb (ev::io &w, int revents)
428{ 544{
429 do 545 while (XEventsQueued (dpy, QueuedAfterReading))
430 { 546 {
431 XEvent xev; 547 XEvent xev;
432 XNextEvent (display, &xev); 548 XNextEvent (dpy, &xev);
433 549
434#ifdef USE_XIM 550#ifdef USE_XIM
435 if (!XFilterEvent (&xev, None)) 551 if (!XFilterEvent (&xev, None))
436 { 552 {
437 if (xev.type == PropertyNotify 553 if (xev.type == PropertyNotify
438 && xev.xany.window == root 554 && xev.xany.window == root
439 && xev.xproperty.atom == xa[XA_XIM_SERVERS]) 555 && xev.xproperty.atom == xa[XA_XIM_SERVERS])
440 im_change_check (); 556 im_change_check ();
441#endif 557#endif
558 if (xev.type == MappingNotify)
559 XRefreshKeyboardMapping (&xev.xmapping);
560
442 for (int i = xw.size (); i--; ) 561 for (int i = xw.size (); i--; )
443 { 562 {
444 if (!xw[i]) 563 if (!xw[i])
445 xw.erase_unordered (i); 564 xw.erase_unordered (i);
446 else if (xw[i]->window == xev.xany.window) 565 else if (xw[i]->window == xev.xany.window)
… …
448 } 567 }
449#ifdef USE_XIM 568#ifdef USE_XIM
450 } 569 }
451#endif 570#endif
452 } 571 }
453 while (XEventsQueued (display, QueuedAlready));
454 572
455 XFlush (display); 573 XFlush (dpy);
456} 574}
457 575
458void rxvt_display::flush () 576void rxvt_display::flush ()
459{ 577{
460 if (XEventsQueued (display, QueuedAlready))
461 x_cb (x_ev, EVENT_READ); 578 x_cb (x_ev, ev::READ);
462
463 XFlush (display);
464} 579}
465 580
466void rxvt_display::reg (xevent_watcher *w) 581void rxvt_display::reg (xevent_watcher *w)
467{ 582{
583 if (!w->active)
584 {
468 xw.push_back (w); 585 xw.push_back (w);
469 w->active = xw.size (); 586 w->active = xw.size ();
587 }
470} 588}
471 589
472void rxvt_display::unreg (xevent_watcher *w) 590void rxvt_display::unreg (xevent_watcher *w)
473{ 591{
474 if (w->active) 592 if (w->active)
593 {
475 xw[w->active - 1] = 0; 594 xw[w->active - 1] = 0;
595 w->active = 0;
596 }
476} 597}
477 598
478void rxvt_display::set_selection_owner (rxvt_term *owner) 599void rxvt_display::set_selection_owner (rxvt_term *owner)
479{ 600{
480 if (selection_owner && selection_owner != owner) 601 if (selection_owner && selection_owner != owner)
… …
482 603
483 selection_owner = owner; 604 selection_owner = owner;
484} 605}
485 606
486#ifdef USE_XIM 607#ifdef USE_XIM
608
487void rxvt_display::reg (im_watcher *w) 609void rxvt_display::reg (im_watcher *w)
488{ 610{
489 imw.push_back (w); 611 imw.push_back (w);
490} 612}
491 613
… …
515 return xim; 637 return xim;
516} 638}
517 639
518void rxvt_display::put_xim (rxvt_xim *xim) 640void rxvt_display::put_xim (rxvt_xim *xim)
519{ 641{
520#if XLIB_IS_RACEFREE 642# if XLIB_IS_RACEFREE
521 xims.put (xim); 643 xims.put (xim);
522#endif 644# endif
523} 645}
646
524#endif 647#endif
525 648
526Atom rxvt_display::atom (const char *name) 649Atom rxvt_display::atom (const char *name)
527{ 650{
528 return XInternAtom (display, name, False); 651 return XInternAtom (dpy, name, False);
529} 652}
530 653
531///////////////////////////////////////////////////////////////////////////// 654/////////////////////////////////////////////////////////////////////////////
532 655
533template class refcache<rxvt_display>; 656template class refcache<rxvt_display>;
534refcache<rxvt_display> displays; 657refcache<rxvt_display> displays;
535 658
536///////////////////////////////////////////////////////////////////////////// 659/////////////////////////////////////////////////////////////////////////////
537 660//
661
662static unsigned int
663insert_component (unsigned int value, unsigned int mask, unsigned int shift)
664{
665 return (value * (mask + 1) >> 16) << shift;
666}
667
668bool
669rxvt_color::alloc (rxvt_screen *screen, const rgba &color)
670{
671#if XFT
672 XRenderPictFormat *format;
673
674 // FUCKING Xft gets it wrong, of course, so work around it.
675 // Transparency users should eat shit and die, and then
676 // XRenderQueryPictIndexValues themselves plenty.
677 if ((screen->visual->c_class == TrueColor)
678 && (format = XRenderFindVisualFormat (screen->dpy, screen->visual)))
679 {
680 // the fun lies in doing everything manually...
681 c.color.red = color.r;
682 c.color.green = color.g;
683 c.color.blue = color.b;
684 c.color.alpha = color.a;
685
686 c.pixel = insert_component (color.r, format->direct.redMask , format->direct.red )
687 | insert_component (color.g, format->direct.greenMask, format->direct.green)
688 | insert_component (color.b, format->direct.blueMask , format->direct.blue )
689 | insert_component (color.a, format->direct.alphaMask, format->direct.alpha);
690
691 return true;
692 }
693 else
694 {
695 XRenderColor d;
696
697 d.red = color.r;
698 d.green = color.g;
699 d.blue = color.b;
700 d.alpha = color.a;
701
702 return XftColorAllocValue (screen->dpy, screen->visual, screen->cmap, &d, &c);
703 }
704#else
705 c.red = color.r;
706 c.green = color.g;
707 c.blue = color.b;
708
709 if (screen->visual->c_class == TrueColor)
710 {
711 c.pixel = (color.r >> (16 - popcount (screen->visual->red_mask )) << ctz (screen->visual->red_mask ))
712 | (color.g >> (16 - popcount (screen->visual->green_mask)) << ctz (screen->visual->green_mask))
713 | (color.b >> (16 - popcount (screen->visual->blue_mask )) << ctz (screen->visual->blue_mask ));
714
715 return true;
716 }
717 else if (XAllocColor (screen->dpy, screen->cmap, &c))
718 return true;
719 else
720 c.pixel = (color.r + color.g + color.b) > 128*3
721 ? WhitePixelOfScreen (DefaultScreenOfDisplay (screen->dpy))
722 : BlackPixelOfScreen (DefaultScreenOfDisplay (screen->dpy));
723#endif
724
725 return false;
726}
727
538bool 728bool
539rxvt_color::set (rxvt_screen *screen, const char *name) 729rxvt_color::set (rxvt_screen *screen, const char *name)
540{ 730{
731 rgba c;
732 char eos;
733 int skip;
734
735 // parse the nonstandard "[alphapercent]" prefix
736 if (1 <= sscanf (name, "[%hd]%n", &c.a, &skip))
737 {
738 c.a = lerp<int, int, int> (0, rgba::MAX_CC, c.a);
739 name += skip;
740 }
741 else
742 c.a = rgba::MAX_CC;
743
744 // parse the non-standard "#aarrggbb" format
745 if (name[0] == '#' && strlen (name) == 1+2+2+2+2 && 4 == sscanf (name+1, "%2hx%2hx%2hx%2hx%c", &c.a, &c.r, &c.g, &c.b, &eos))
746 {
747 if (c.r)
748 c.r = (c.r << 8) | 0x0ff;
749 if (c.g)
750 c.g = (c.g << 8) | 0x0ff;
751 if (c.b)
752 c.b = (c.b << 8) | 0x0ff;
753 if (c.a)
754 c.a = (c.a << 8) | 0x0ff;
755 }
756 // parse the non-standard "rgba:rrrr/gggg/bbbb/aaaa" format
757 else 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{
541#if XFT 832#if XFT
542 int l = strlen (name); 833 color.r = c.color.red;
543 rxvt_rgba r; 834 color.g = c.color.green;
544 char eos; 835 color.b = c.color.blue;
545 int mult; 836 color.a = c.color.alpha;
546
547 if ( l == 1+4*1 && 4 == sscanf (name, "#%1hx%1hx%1hx%1hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
548 mult = rxvt_rgba::MAX_CC / 0x000f;
549 else if (l == 1+4*2 && 4 == sscanf (name, "#%2hx%2hx%2hx%2hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
550 mult = rxvt_rgba::MAX_CC / 0x00ff;
551 else if (l == 1+4*4 && 4 == sscanf (name, "#%4hx%4hx%4hx%4hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
552 mult = rxvt_rgba::MAX_CC / 0xffff;
553 else if (l == 4+5*4 && 4 == sscanf (name, "rgba:%hx/%hx/%hx/%hx%c", &r.r, &r.g, &r.b, &r.a, &eos))
554 mult = rxvt_rgba::MAX_CC / 0xffff;
555 else
556 return XftColorAllocName (screen->xdisp, screen->visual, screen->cmap, name, &c);
557
558 r.r *= mult; r.g *= mult; r.b *= mult; r.a *= mult;
559 return set (screen, r);
560#else 837#else
561 XColor xc; 838 color.r = c.red;
562 839 color.g = c.green;
563 if (XParseColor (screen->xdisp, screen->cmap, name, &xc)) 840 color.b = c.blue;
564 return set (screen, rxvt_rgba (xc.red, xc.green, xc.blue)); 841 color.a = rgba::MAX_CC;
565
566 return false;
567#endif 842#endif
568} 843}
569 844
570bool 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
571rxvt_color::set (rxvt_screen *screen, rxvt_rgba rgba) 858rxvt_color::free (rxvt_screen *screen)
572{ 859{
860 if (screen->visual->c_class == TrueColor)
861 return; // nothing to do
862
573#if XFT 863#if XFT
574 XRenderColor d;
575
576 d.red = rgba.r;
577 d.green = rgba.g;
578 d.blue = rgba.b;
579 d.alpha = rgba.a;
580
581 if (XftColorAllocValue (screen->xdisp, screen->visual, screen->cmap, &d, &c)) 864 XftColorFree (screen->dpy, screen->visual, screen->cmap, &c);
582 {
583 // FUCKING Xft gets it wrong, of course, fix it for the common case
584 // transparency users should eat shit and die, and then
585 // XRenderQueryPictIndexValues themselves plenty.
586 if (screen->depth == 32 && screen->visual->c_class == TrueColor)
587 if ((screen->visual->red_mask | screen->visual->green_mask | screen->visual->blue_mask) == 0x00ffffffUL)
588 c.pixel = c.pixel & 0x00ffffffUL | ((rgba.a >> 8) << 24);
589 else if ((screen->visual->red_mask | screen->visual->green_mask | screen->visual->blue_mask) == 0xffffff00UL)
590 c.pixel = c.pixel & 0xffffff00UL | (rgba.a >> 8);
591
592 return true;
593 }
594
595 return false;
596#else 865#else
597 XColor xc;
598
599 xc.red = rgba.r;
600 xc.green = rgba.g;
601 xc.blue = rgba.b;
602 xc.flags = DoRed | DoGreen | DoBlue;
603
604 if (XAllocColor (screen->xdisp, screen->cmap, &xc))
605 {
606 p = xc.pixel;
607 return true;
608 }
609
610 return false;
611#endif
612}
613
614void
615rxvt_color::get (rxvt_screen *screen, rxvt_rgba &rgba)
616{
617#if XFT
618 rgba.r = c.color.red;
619 rgba.g = c.color.green;
620 rgba.b = c.color.blue;
621 rgba.a = c.color.alpha;
622#else
623 XColor c;
624
625 c.pixel = p;
626 XQueryColor (screen->xdisp, screen->cmap, &c);
627
628 rgba.r = c.red;
629 rgba.g = c.green;
630 rgba.b = c.blue;
631 rgba.a = rxvt_rgba::MAX_CC;
632#endif
633}
634
635void
636rxvt_color::free (rxvt_screen *screen)
637{
638#if XFT
639 XftColorFree (screen->xdisp, screen->visual, screen->cmap, &c);
640#else
641 XFreeColors (screen->xdisp, screen->cmap, &p, 1, AllPlanes); 866 XFreeColors (screen->dpy, screen->cmap, &c.pixel, 1, AllPlanes);
642#endif 867#endif
643} 868}
644 869
645rxvt_color 870void
646rxvt_color::fade (rxvt_screen *screen, int percent)
647{
648 rxvt_color faded;
649
650 rxvt_rgba c;
651 get (screen, c);
652
653 c.r = lerp (0, c.r, percent);
654 c.g = lerp (0, c.g, percent);
655 c.b = lerp (0, c.b, percent);
656
657 faded.set (screen, c);
658
659 return faded;
660}
661
662rxvt_color
663rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &fadeto) 871rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to)
664{ 872{
665 rxvt_rgba c, fc; 873 rgba c;
666 rxvt_color faded; 874 get (c);
667
668 get (screen, c);
669 fadeto.get (screen, fc);
670 875
671 faded.set ( 876 result.set (
672 screen, 877 screen,
673 rxvt_rgba ( 878 rgba (
674 lerp (fc.r, c.r, percent), 879 lerp (c.r, to.r, percent),
675 lerp (fc.g, c.g, percent), 880 lerp (c.g, to.g, percent),
676 lerp (fc.b, c.b, percent), 881 lerp (c.b, to.b, percent),
677 lerp (fc.a, c.a, percent) 882 lerp (c.a, to.a, percent)
678 ) 883 )
679 ); 884 );
885}
680 886
887#if TRACE_PIXMAPS
888# undef XCreatePixmap
889# undef XFreePixmap
890Pixmap trace_XCreatePixmap (const char *file, int line, Display *dpy, Window r, unsigned int w, unsigned int h, unsigned int d)
891{
892 Pixmap res = XCreatePixmap (dpy, r, w, h, d);
893 fprintf (stderr, "%s:%d: XCreatePixmap (%p,%lX,%u,%u,%u) returned %lX\n", file, line, dpy, r, w, h, d, res);
681 return faded; 894 return res;
682} 895}
683 896
897void trace_XFreePixmap (const char *file, int line, Display *dpy, Pixmap p)
898{
899 fprintf (stderr, "%s:%d: XFreePixmap (%p,%lX)\n", file, line, dpy, p);
900 XFreePixmap (dpy,p);
901}
902#endif

Diff Legend

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