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