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.62 by root, Mon Aug 7 15:41:05 2006 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 TRANSPARENT
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, 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 domains 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_LOCAL;
358#endif
359 475
360 x_ev.start (fd, EVENT_READ); 476 x_ev.start (fd, EVENT_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
427void rxvt_display::x_cb (io_watcher &w, short revents) 543void rxvt_display::x_cb (io_watcher &w, short revents)
428{ 544{
429 do 545 do
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
448 } 564 }
449#ifdef USE_XIM 565#ifdef USE_XIM
450 } 566 }
451#endif 567#endif
452 } 568 }
453 while (XEventsQueued (display, QueuedAlready)); 569 while (XEventsQueued (dpy, QueuedAlready));
454 570
455 XFlush (display); 571 XFlush (dpy);
456} 572}
457 573
458void rxvt_display::flush () 574void rxvt_display::flush ()
459{ 575{
460 if (XEventsQueued (display, QueuedAlready)) 576 if (XEventsQueued (dpy, QueuedAlready))
461 x_cb (x_ev, EVENT_READ); 577 x_cb (x_ev, EVENT_READ);
462 578
463 XFlush (display); 579 XFlush (dpy);
464} 580}
465 581
466void rxvt_display::reg (xevent_watcher *w) 582void rxvt_display::reg (xevent_watcher *w)
467{ 583{
584 if (!w->active)
585 {
468 xw.push_back (w); 586 xw.push_back (w);
469 w->active = xw.size (); 587 w->active = xw.size ();
588 }
470} 589}
471 590
472void rxvt_display::unreg (xevent_watcher *w) 591void rxvt_display::unreg (xevent_watcher *w)
473{ 592{
474 if (w->active) 593 if (w->active)
594 {
475 xw[w->active - 1] = 0; 595 xw[w->active - 1] = 0;
596 w->active = 0;
597 }
476} 598}
477 599
478void rxvt_display::set_selection_owner (rxvt_term *owner) 600void rxvt_display::set_selection_owner (rxvt_term *owner)
479{ 601{
480 if (selection_owner && selection_owner != owner) 602 if (selection_owner && selection_owner != owner)
482 604
483 selection_owner = owner; 605 selection_owner = owner;
484} 606}
485 607
486#ifdef USE_XIM 608#ifdef USE_XIM
609
487void rxvt_display::reg (im_watcher *w) 610void rxvt_display::reg (im_watcher *w)
488{ 611{
489 imw.push_back (w); 612 imw.push_back (w);
490} 613}
491 614
515 return xim; 638 return xim;
516} 639}
517 640
518void rxvt_display::put_xim (rxvt_xim *xim) 641void rxvt_display::put_xim (rxvt_xim *xim)
519{ 642{
520#if XLIB_IS_RACEFREE 643# if XLIB_IS_RACEFREE
521 xims.put (xim); 644 xims.put (xim);
522#endif 645# endif
523} 646}
647
524#endif 648#endif
525 649
526Atom rxvt_display::atom (const char *name) 650Atom rxvt_display::atom (const char *name)
527{ 651{
528 return XInternAtom (display, name, False); 652 return XInternAtom (dpy, name, False);
529} 653}
530 654
531///////////////////////////////////////////////////////////////////////////// 655/////////////////////////////////////////////////////////////////////////////
532 656
533template class refcache<rxvt_display>; 657template class refcache<rxvt_display>;
534refcache<rxvt_display> displays; 658refcache<rxvt_display> displays;
535 659
536///////////////////////////////////////////////////////////////////////////// 660/////////////////////////////////////////////////////////////////////////////
537 661//
662
663static unsigned int
664insert_component (unsigned int value, unsigned int mask, unsigned int shift)
665{
666 return (value * (mask + 1) >> 16) << shift;
667}
668
669bool
670rxvt_color::alloc (rxvt_screen *screen, const rgba &color)
671{
672#if XFT
673 XRenderPictFormat *format;
674
675 // FUCKING Xft gets it wrong, of course, so work around it.
676 // Transparency users should eat shit and die, and then
677 // XRenderQueryPictIndexValues themselves plenty.
678 if ((screen->visual->c_class == TrueColor)
679 && (format = XRenderFindVisualFormat (screen->dpy, screen->visual)))
680 {
681 // the fun lies in doing everything manually...
682 c.color.red = color.r;
683 c.color.green = color.g;
684 c.color.blue = color.b;
685 c.color.alpha = color.a;
686
687 c.pixel = insert_component (color.r, format->direct.redMask , format->direct.red )
688 | insert_component (color.g, format->direct.greenMask, format->direct.green)
689 | insert_component (color.b, format->direct.blueMask , format->direct.blue )
690 | insert_component (color.a, format->direct.alphaMask, format->direct.alpha);
691
692 return true;
693 }
694 else
695 {
696 XRenderColor d;
697
698 d.red = color.r;
699 d.green = color.g;
700 d.blue = color.b;
701 d.alpha = color.a;
702
703 return XftColorAllocValue (screen->dpy, screen->visual, screen->cmap, &d, &c);
704 }
705#else
706 c.red = color.r;
707 c.green = color.g;
708 c.blue = color.b;
709
710 if (screen->visual->c_class == TrueColor)
711 {
712 c.pixel = (color.r * (screen->visual->red_mask >> ctz (screen->visual->red_mask ))
713 / rgba::MAX_CC) << ctz (screen->visual->red_mask )
714 | (color.g * (screen->visual->green_mask >> ctz (screen->visual->green_mask))
715 / rgba::MAX_CC) << ctz (screen->visual->green_mask)
716 | (color.b * (screen->visual->blue_mask >> ctz (screen->visual->blue_mask ))
717 / rgba::MAX_CC) << ctz (screen->visual->blue_mask );
718
719 return true;
720 }
721 else if (XAllocColor (screen->dpy, screen->cmap, &c))
722 return true;
723 else
724 c.pixel = (color.r + color.g + color.b) > 128*3
725 ? WhitePixelOfScreen (DefaultScreenOfDisplay (screen->dpy))
726 : BlackPixelOfScreen (DefaultScreenOfDisplay (screen->dpy));
727#endif
728
729 return false;
730}
731
538bool 732bool
539rxvt_color::set (rxvt_screen *screen, const char *name) 733rxvt_color::set (rxvt_screen *screen, const char *name)
540{ 734{
735 rgba c;
736 char eos;
737 int skip;
738
739 // parse the nonstandard "[alphapercent]" prefix
740 if (1 <= sscanf (name, "[%hd]%n", &c.a, &skip))
741 {
742 c.a = lerp<int, int, int> (0, rgba::MAX_CC, c.a);
743 name += skip;
744 }
745 else
746 c.a = rgba::MAX_CC;
747
748 // parse the non-standard "rgba:rrrr/gggg/bbbb/aaaa" format
749 if (strlen (name) != 4+5*4 || 4 != sscanf (name, "rgba:%4hx/%4hx/%4hx/%4hx%c", &c.r, &c.g, &c.b, &c.a, &eos))
750 {
751 XColor xc, xc_exact;
752
753 if (XParseColor (screen->dpy, screen->cmap, name, &xc))
754 {
755 c.r = xc.red;
756 c.g = xc.green;
757 c.b = xc.blue;
758 }
759 else
760 {
761 c.r = 0xffff;
762 c.g = 0x6969;
763 c.b = 0xb4b4;
764
765 rxvt_warn ("unable to parse color '%s', using pink instead.\n", name);
766 }
767 }
768
769 return set (screen, c);
770}
771
772bool
773rxvt_color::set (rxvt_screen *screen, const rgba &color)
774{
775 bool got = alloc (screen, color);
776
777#if !ENABLE_MINIMAL
778 int cmap_size = screen->visual->map_entries;
779
780 if (!got
781 && screen->visual->c_class == PseudoColor
782 && cmap_size < 4096)
783 {
784 XColor *colors = new XColor [screen->visual->map_entries];
785
786 for (int i = 0; i < cmap_size; i++)
787 colors [i].pixel = i;
788
789 // many kilobytes transfer per colour, but pseudocolor isn't worth
790 // many extra optimisations.
791 XQueryColors (screen->dpy, screen->cmap, colors, cmap_size);
792
793 int diff = 0x7fffffffUL;
794 XColor *best = colors;
795
796 for (int i = 0; i < cmap_size; i++)
797 {
798 int d = (squared_diff<int> (color.r >> 2, colors [i].red >> 2))
799 + (squared_diff<int> (color.g >> 2, colors [i].green >> 2))
800 + (squared_diff<int> (color.b >> 2, colors [i].blue >> 2));
801
802 if (d < diff)
803 {
804 diff = d;
805 best = colors + i;
806 }
807 }
808
809 //rxvt_warn ("could not allocate %04x %04x %04x, getting %04x %04x %04x instead (%d)\n",
810 // color.r, color.g, color.b, best->red, best->green, best->blue, diff);
811
812 got = alloc (screen, rgba (best->red, best->green, best->blue));
813
814 delete colors;
815 }
816#endif
817
818 return got;
819}
820
821void
822rxvt_color::get (rgba &color)
823{
541#if XFT 824#if XFT
542 int l = strlen (name); 825 color.r = c.color.red;
543 rxvt_rgba r; 826 color.g = c.color.green;
544 char eos; 827 color.b = c.color.blue;
545 int mult; 828 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 829#else
561 XColor xc; 830 color.r = c.red;
562 831 color.g = c.green;
563 if (XParseColor (screen->xdisp, screen->cmap, name, &xc)) 832 color.b = c.blue;
564 return set (screen, rxvt_rgba (xc.red, xc.green, xc.blue)); 833 color.a = rgba::MAX_CC;
565
566 return false;
567#endif 834#endif
568} 835}
569 836
570bool
571rxvt_color::set (rxvt_screen *screen, rxvt_rgba rgba)
572{
573#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))
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
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 837void
615rxvt_color::get (rxvt_screen *screen, rxvt_rgba &rgba) 838rxvt_color::get (XColor &color)
616{ 839{
617#if XFT 840 rgba c;
618 rgba.r = c.color.red; 841 get (c);
619 rgba.g = c.color.green;
620 rgba.b = c.color.blue;
621 rgba.a = c.color.alpha;
622#else
623 XColor c;
624 842
625 c.pixel = p; 843 color.red = c.r;
626 XQueryColor (screen->xdisp, screen->cmap, &c); 844 color.green = c.g;
627 845 color.blue = c.b;
628 rgba.r = c.red; 846 color.pixel = (Pixel)*this;
629 rgba.g = c.green;
630 rgba.b = c.blue;
631 rgba.a = rxvt_rgba::MAX_CC;
632#endif
633} 847}
634 848
635void 849void
636rxvt_color::free (rxvt_screen *screen) 850rxvt_color::free (rxvt_screen *screen)
637{ 851{
852 if (screen->visual->c_class == TrueColor)
853 return; // nothing to do
854
638#if XFT 855#if XFT
639 XftColorFree (screen->xdisp, screen->visual, screen->cmap, &c); 856 XftColorFree (screen->dpy, screen->visual, screen->cmap, &c);
640#else 857#else
641 XFreeColors (screen->xdisp, screen->cmap, &p, 1, AllPlanes); 858 XFreeColors (screen->dpy, screen->cmap, &c.pixel, 1, AllPlanes);
642#endif 859#endif
643} 860}
644 861
645rxvt_color 862void
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) 863rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to)
664{ 864{
665 rxvt_rgba c, fc; 865 rgba c;
666 rxvt_color faded; 866 get (c);
667
668 get (screen, c);
669 fadeto.get (screen, fc);
670 867
671 faded.set ( 868 result.set (
672 screen, 869 screen,
673 rxvt_rgba ( 870 rgba (
674 lerp (fc.r, c.r, percent), 871 lerp (c.r, to.r, percent),
675 lerp (fc.g, c.g, percent), 872 lerp (c.g, to.g, percent),
676 lerp (fc.b, c.b, percent), 873 lerp (c.b, to.b, percent),
677 lerp (fc.a, c.a, percent) 874 lerp (c.a, to.a, percent)
678 ) 875 )
679 ); 876 );
680
681 return faded;
682} 877}
683 878

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines