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

Diff Legend

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