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.29 by root, Sun Jan 29 21:45:47 2006 UTC vs.
Revision 1.67 by ayin, Mon Jun 25 23:27:18 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 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);
447
448#ifdef HAVE_AFTERIMAGE
449 ::dpy = dpy; /* init global var from libAfter... */
450 asv = create_asvisual_for_id (dpy, screen, DefaultDepth (dpy,screen),
451 XVisualIDFromVisual (DefaultVisual (dpy, screen)), None, NULL);
452#endif
329 453
330 assert (sizeof (xa_names) / sizeof (char *) == NUM_XA); 454 assert (sizeof (xa_names) / sizeof (char *) == NUM_XA);
331 XInternAtoms (display, (char **)xa_names, NUM_XA, False, xa); 455 XInternAtoms (dpy, (char **)xa_names, NUM_XA, False, xa);
332 456
333 XrmSetDatabase (display, get_resources ()); 457 XrmSetDatabase (dpy, get_resources (false));
334 458
335#ifdef POINTER_BLANK 459#ifdef POINTER_BLANK
336 XColor blackcolour; 460 XColor blackcolour;
337 blackcolour.red = 0; 461 blackcolour.red = 0;
338 blackcolour.green = 0; 462 blackcolour.green = 0;
339 blackcolour.blue = 0; 463 blackcolour.blue = 0;
340 Font f = XLoadFont (display, "fixed"); 464 Font f = XLoadFont (dpy, "fixed");
341 blank_cursor = XCreateGlyphCursor (display, f, f, ' ', ' ', 465 blank_cursor = XCreateGlyphCursor (dpy, f, f, ' ', ' ',
342 &blackcolour, &blackcolour); 466 &blackcolour, &blackcolour);
343 XUnloadFont (display, f); 467 XUnloadFont (dpy, f);
344#endif 468#endif
345 469
346 int fd = XConnectionNumber (display); 470 int fd = XConnectionNumber (dpy);
347 471
348#ifndef NO_SLOW_LINK_SUPPORT
349 // try to detect wether we have a local connection. 472 // try to detect wether we have a local connection.
350 // assume unix domains socket == local, everything else not 473 // assume unix domains socket == local, everything else not
351 // TODO: might want to check for inet/127.0.0.1 474 // TODO: might want to check for inet/127.0.0.1
352 is_local = 0; 475 is_local = 0;
353 sockaddr_un sa; 476 sockaddr_un sa;
354 socklen_t sl = sizeof (sa); 477 socklen_t sl = sizeof (sa);
355 478
356 if (!getsockname (fd, (sockaddr *)&sa, &sl)) 479 if (!getsockname (fd, (sockaddr *)&sa, &sl))
357 is_local = sa.sun_family == AF_LOCAL; 480 is_local = sa.sun_family == AF_UNIX;
358#endif
359 481
360 x_ev.start (fd, EVENT_READ); 482 x_ev.start (fd, EVENT_READ);
361 fcntl (fd, F_SETFD, FD_CLOEXEC); 483 fcntl (fd, F_SETFD, FD_CLOEXEC);
362 484
363 XSelectInput (display, root, PropertyChangeMask); 485 XSelectInput (dpy, root, PropertyChangeMask);
364 486
365 flush (); 487 flush ();
366 488
367 return true; 489 return true;
368} 490}
369 491
370void 492void
371rxvt_display::ref_next () 493rxvt_display::ref_next ()
372{ 494{
373 // TODO: somehow check wether the database files/resources changed 495 // TODO: somehow check wether the database files/resources changed
374 // before re-loading/parsing 496 // before affording re-loading/parsing
375 XrmDestroyDatabase (XrmGetDatabase (display)); 497 XrmDestroyDatabase (XrmGetDatabase (dpy));
376 XrmSetDatabase (display, get_resources ()); 498 XrmSetDatabase (dpy, get_resources (true));
377} 499}
378 500
379rxvt_display::~rxvt_display () 501rxvt_display::~rxvt_display ()
380{ 502{
381 if (!display) 503 if (!dpy)
382 return; 504 return;
383 505
384#ifdef POINTER_BLANK 506#ifdef POINTER_BLANK
385 XFreeCursor (display, blank_cursor); 507 XFreeCursor (dpy, blank_cursor);
386#endif 508#endif
387 x_ev.stop (); 509 x_ev.stop ();
388#ifdef USE_XIM 510#ifdef USE_XIM
389 xims.clear (); 511 xims.clear ();
390#endif 512#endif
391 XCloseDisplay (display); 513 XCloseDisplay (dpy);
392} 514}
393 515
394#ifdef USE_XIM 516#ifdef USE_XIM
395void rxvt_display::im_change_cb () 517void rxvt_display::im_change_cb ()
396{ 518{
… …
404 // registers, as xlib crashes due to a race otherwise. 526 // registers, as xlib crashes due to a race otherwise.
405 Atom actual_type, *atoms; 527 Atom actual_type, *atoms;
406 int actual_format; 528 int actual_format;
407 unsigned long nitems, bytes_after; 529 unsigned long nitems, bytes_after;
408 530
409 if (XGetWindowProperty (display, root, xa[XA_XIM_SERVERS], 0L, 1000000L, 531 if (XGetWindowProperty (dpy, root, xa[XA_XIM_SERVERS], 0L, 1000000L,
410 False, XA_ATOM, &actual_type, &actual_format, 532 False, XA_ATOM, &actual_type, &actual_format,
411 &nitems, &bytes_after, (unsigned char **)&atoms) 533 &nitems, &bytes_after, (unsigned char **)&atoms)
412 != Success ) 534 != Success )
413 return; 535 return;
414 536
415 if (actual_type == XA_ATOM && actual_format == 32) 537 if (actual_type == XA_ATOM && actual_format == 32)
416 for (int i = 0; i < nitems; i++) 538 for (int i = 0; i < nitems; i++)
417 if (XGetSelectionOwner (display, atoms[i])) 539 if (XGetSelectionOwner (dpy, atoms[i]))
418 { 540 {
419 im_change_cb (); 541 im_change_cb ();
420 break; 542 break;
421 } 543 }
422 544
… …
427void rxvt_display::x_cb (io_watcher &w, short revents) 549void rxvt_display::x_cb (io_watcher &w, short revents)
428{ 550{
429 do 551 do
430 { 552 {
431 XEvent xev; 553 XEvent xev;
432 XNextEvent (display, &xev); 554 XNextEvent (dpy, &xev);
433 555
434#ifdef USE_XIM 556#ifdef USE_XIM
435 if (!XFilterEvent (&xev, None)) 557 if (!XFilterEvent (&xev, None))
436 { 558 {
437 if (xev.type == PropertyNotify 559 if (xev.type == PropertyNotify
… …
448 } 570 }
449#ifdef USE_XIM 571#ifdef USE_XIM
450 } 572 }
451#endif 573#endif
452 } 574 }
453 while (XEventsQueued (display, QueuedAlready)); 575 while (XEventsQueued (dpy, QueuedAlready));
454 576
455 XFlush (display); 577 XFlush (dpy);
456} 578}
457 579
458void rxvt_display::flush () 580void rxvt_display::flush ()
459{ 581{
460 if (XEventsQueued (display, QueuedAlready)) 582 if (XEventsQueued (dpy, QueuedAlready))
461 x_cb (x_ev, EVENT_READ); 583 x_cb (x_ev, EVENT_READ);
462 584
463 XFlush (display); 585 XFlush (dpy);
464} 586}
465 587
466void rxvt_display::reg (xevent_watcher *w) 588void rxvt_display::reg (xevent_watcher *w)
467{ 589{
590 if (!w->active)
591 {
468 xw.push_back (w); 592 xw.push_back (w);
469 w->active = xw.size (); 593 w->active = xw.size ();
594 }
470} 595}
471 596
472void rxvt_display::unreg (xevent_watcher *w) 597void rxvt_display::unreg (xevent_watcher *w)
473{ 598{
474 if (w->active) 599 if (w->active)
600 {
475 xw[w->active - 1] = 0; 601 xw[w->active - 1] = 0;
602 w->active = 0;
603 }
476} 604}
477 605
478void rxvt_display::set_selection_owner (rxvt_term *owner) 606void rxvt_display::set_selection_owner (rxvt_term *owner)
479{ 607{
480 if (selection_owner && selection_owner != owner) 608 if (selection_owner && selection_owner != owner)
… …
482 610
483 selection_owner = owner; 611 selection_owner = owner;
484} 612}
485 613
486#ifdef USE_XIM 614#ifdef USE_XIM
615
487void rxvt_display::reg (im_watcher *w) 616void rxvt_display::reg (im_watcher *w)
488{ 617{
489 imw.push_back (w); 618 imw.push_back (w);
490} 619}
491 620
… …
515 return xim; 644 return xim;
516} 645}
517 646
518void rxvt_display::put_xim (rxvt_xim *xim) 647void rxvt_display::put_xim (rxvt_xim *xim)
519{ 648{
520#if XLIB_IS_RACEFREE 649# if XLIB_IS_RACEFREE
521 xims.put (xim); 650 xims.put (xim);
522#endif 651# endif
523} 652}
653
524#endif 654#endif
525 655
526Atom rxvt_display::atom (const char *name) 656Atom rxvt_display::atom (const char *name)
527{ 657{
528 return XInternAtom (display, name, False); 658 return XInternAtom (dpy, name, False);
529} 659}
530 660
531///////////////////////////////////////////////////////////////////////////// 661/////////////////////////////////////////////////////////////////////////////
532 662
533template class refcache<rxvt_display>; 663template class refcache<rxvt_display>;
534refcache<rxvt_display> displays; 664refcache<rxvt_display> displays;
535 665
536///////////////////////////////////////////////////////////////////////////// 666/////////////////////////////////////////////////////////////////////////////
537 667//
668
669static unsigned int
670insert_component (unsigned int value, unsigned int mask, unsigned int shift)
671{
672 return (value * (mask + 1) >> 16) << shift;
673}
674
675bool
676rxvt_color::alloc (rxvt_screen *screen, const rgba &color)
677{
678#if XFT
679 XRenderPictFormat *format;
680
681 // FUCKING Xft gets it wrong, of course, so work around it.
682 // Transparency users should eat shit and die, and then
683 // XRenderQueryPictIndexValues themselves plenty.
684 if ((screen->visual->c_class == TrueColor)
685 && (format = XRenderFindVisualFormat (screen->dpy, screen->visual)))
686 {
687 // the fun lies in doing everything manually...
688 c.color.red = color.r;
689 c.color.green = color.g;
690 c.color.blue = color.b;
691 c.color.alpha = color.a;
692
693 c.pixel = insert_component (color.r, format->direct.redMask , format->direct.red )
694 | insert_component (color.g, format->direct.greenMask, format->direct.green)
695 | insert_component (color.b, format->direct.blueMask , format->direct.blue )
696 | insert_component (color.a, format->direct.alphaMask, format->direct.alpha);
697
698 return true;
699 }
700 else
701 {
702 XRenderColor d;
703
704 d.red = color.r;
705 d.green = color.g;
706 d.blue = color.b;
707 d.alpha = color.a;
708
709 return XftColorAllocValue (screen->dpy, screen->visual, screen->cmap, &d, &c);
710 }
711#else
712 c.red = color.r;
713 c.green = color.g;
714 c.blue = color.b;
715
716 if (screen->visual->c_class == TrueColor)
717 {
718 c.pixel = (color.r >> (16 - popcount (screen->visual->red_mask )) << ctz (screen->visual->red_mask ))
719 | (color.g >> (16 - popcount (screen->visual->green_mask)) << ctz (screen->visual->green_mask))
720 | (color.b >> (16 - popcount (screen->visual->blue_mask )) << ctz (screen->visual->blue_mask ));
721
722 return true;
723 }
724 else if (XAllocColor (screen->dpy, screen->cmap, &c))
725 return true;
726 else
727 c.pixel = (color.r + color.g + color.b) > 128*3
728 ? WhitePixelOfScreen (DefaultScreenOfDisplay (screen->dpy))
729 : BlackPixelOfScreen (DefaultScreenOfDisplay (screen->dpy));
730#endif
731
732 return false;
733}
734
538bool 735bool
539rxvt_color::set (rxvt_screen *screen, const char *name) 736rxvt_color::set (rxvt_screen *screen, const char *name)
540{ 737{
738 rgba c;
739 char eos;
740 int skip;
741
742 // parse the nonstandard "[alphapercent]" prefix
743 if (1 <= sscanf (name, "[%hd]%n", &c.a, &skip))
744 {
745 c.a = lerp<int, int, int> (0, rgba::MAX_CC, c.a);
746 name += skip;
747 }
748 else
749 c.a = rgba::MAX_CC;
750
751 // parse the non-standard "rgba:rrrr/gggg/bbbb/aaaa" format
752 if (strlen (name) != 4+5*4 || 4 != sscanf (name, "rgba:%4hx/%4hx/%4hx/%4hx%c", &c.r, &c.g, &c.b, &c.a, &eos))
753 {
754 XColor xc, xc_exact;
755
756 if (XParseColor (screen->dpy, screen->cmap, name, &xc))
757 {
758 c.r = xc.red;
759 c.g = xc.green;
760 c.b = xc.blue;
761 }
762 else
763 {
764 c.r = 0xffff;
765 c.g = 0x6969;
766 c.b = 0xb4b4;
767
768 rxvt_warn ("unable to parse color '%s', using pink instead.\n", name);
769 }
770 }
771
772 return set (screen, c);
773}
774
775bool
776rxvt_color::set (rxvt_screen *screen, const rgba &color)
777{
778 bool got = alloc (screen, color);
779
780#if !ENABLE_MINIMAL
781 int cmap_size = screen->visual->map_entries;
782
783 if (!got
784 && screen->visual->c_class == PseudoColor
785 && cmap_size < 4096)
786 {
787 XColor *colors = new XColor [screen->visual->map_entries];
788
789 for (int i = 0; i < cmap_size; i++)
790 colors [i].pixel = i;
791
792 // many kilobytes transfer per colour, but pseudocolor isn't worth
793 // many extra optimisations.
794 XQueryColors (screen->dpy, screen->cmap, colors, cmap_size);
795
796 int diff = 0x7fffffffUL;
797 XColor *best = colors;
798
799 for (int i = 0; i < cmap_size; i++)
800 {
801 int d = (squared_diff<int> (color.r >> 2, colors [i].red >> 2))
802 + (squared_diff<int> (color.g >> 2, colors [i].green >> 2))
803 + (squared_diff<int> (color.b >> 2, colors [i].blue >> 2));
804
805 if (d < diff)
806 {
807 diff = d;
808 best = colors + i;
809 }
810 }
811
812 //rxvt_warn ("could not allocate %04x %04x %04x, getting %04x %04x %04x instead (%d)\n",
813 // color.r, color.g, color.b, best->red, best->green, best->blue, diff);
814
815 got = alloc (screen, rgba (best->red, best->green, best->blue));
816
817 delete [] colors;
818 }
819#endif
820
821 return got;
822}
823
824void
825rxvt_color::get (rgba &color)
826{
541#if XFT 827#if XFT
542 int l = strlen (name); 828 color.r = c.color.red;
543 rxvt_rgba r; 829 color.g = c.color.green;
544 char eos; 830 color.b = c.color.blue;
545 int mult; 831 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 832#else
561 XColor xc; 833 color.r = c.red;
562 834 color.g = c.green;
563 if (XParseColor (screen->xdisp, screen->cmap, name, &xc)) 835 color.b = c.blue;
564 return set (screen, rxvt_rgba (xc.red, xc.green, xc.blue)); 836 color.a = rgba::MAX_CC;
565
566 return false;
567#endif 837#endif
568} 838}
569 839
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
587 && screen->visual->c_class == TrueColor
588 && screen->visual->red_mask == 0x00ff0000
589 && screen->visual->green_mask == 0x0000ff00
590 && screen->visual->blue_mask == 0x000000ff)
591 c.pixel = c.pixel & 0x00ffffffUL | ((rgba.a >> 8) << 24);
592
593 return true;
594 }
595
596 return false;
597#else
598 XColor xc;
599
600 xc.red = rgba.r;
601 xc.green = rgba.g;
602 xc.blue = rgba.b;
603 xc.flags = DoRed | DoGreen | DoBlue;
604
605 if (XAllocColor (screen->xdisp, screen->cmap, &xc))
606 {
607 p = xc.pixel;
608 return true;
609 }
610
611 return false;
612#endif
613}
614
615void 840void
616rxvt_color::get (rxvt_screen *screen, rxvt_rgba &rgba) 841rxvt_color::get (XColor &color)
617{ 842{
618#if XFT 843 rgba c;
619 rgba.r = c.color.red; 844 get (c);
620 rgba.g = c.color.green;
621 rgba.b = c.color.blue;
622 rgba.a = c.color.alpha;
623#else
624 XColor c;
625 845
626 c.pixel = p; 846 color.red = c.r;
627 XQueryColor (screen->xdisp, screen->cmap, &c); 847 color.green = c.g;
628 848 color.blue = c.b;
629 rgba.r = c.red; 849 color.pixel = (Pixel)*this;
630 rgba.g = c.green;
631 rgba.b = c.blue;
632 rgba.a = rxvt_rgba::MAX_CC;
633#endif
634} 850}
635 851
636void 852void
637rxvt_color::free (rxvt_screen *screen) 853rxvt_color::free (rxvt_screen *screen)
638{ 854{
855 if (screen->visual->c_class == TrueColor)
856 return; // nothing to do
857
639#if XFT 858#if XFT
640 XftColorFree (screen->xdisp, screen->visual, screen->cmap, &c); 859 XftColorFree (screen->dpy, screen->visual, screen->cmap, &c);
641#else 860#else
642 XFreeColors (screen->xdisp, screen->cmap, &p, 1, AllPlanes); 861 XFreeColors (screen->dpy, screen->cmap, &c.pixel, 1, AllPlanes);
643#endif 862#endif
644} 863}
645 864
646rxvt_color 865void
647rxvt_color::fade (rxvt_screen *screen, int percent)
648{
649 rxvt_color faded;
650
651 rxvt_rgba c;
652 get (screen, c);
653
654 c.r = lerp (0, c.r, percent);
655 c.g = lerp (0, c.g, percent);
656 c.b = lerp (0, c.b, percent);
657
658 faded.set (screen, c);
659
660 return faded;
661}
662
663rxvt_color
664rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &fadeto) 866rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to)
665{ 867{
666 rxvt_rgba c, fc; 868 rgba c;
667 rxvt_color faded; 869 get (c);
668
669 get (screen, c);
670 fadeto.get (screen, fc);
671 870
672 faded.set ( 871 result.set (
673 screen, 872 screen,
674 rxvt_rgba ( 873 rgba (
675 lerp (fc.r, c.r, percent), 874 lerp (c.r, to.r, percent),
676 lerp (fc.g, c.g, percent), 875 lerp (c.g, to.g, percent),
677 lerp (fc.b, c.b, percent), 876 lerp (c.b, to.b, percent),
678 lerp (fc.a, c.a, percent) 877 lerp (c.a, to.a, percent)
679 ) 878 )
680 ); 879 );
681
682 return faded;
683} 880}
684 881

Diff Legend

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