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.41 by root, Tue Jan 31 16:43:55 2006 UTC vs.
Revision 1.53 by root, Sun Feb 19 16:25:13 2006 UTC

… …
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>
35#endif
36 33
37#if XFT 34#if XFT
38# include <X11/extensions/Xrender.h> 35# include <X11/extensions/Xrender.h>
39#endif 36#endif
40 37
… …
177bool 174bool
178rxvt_xim::ref_init () 175rxvt_xim::ref_init ()
179{ 176{
180 display = GET_R->display; //HACK: TODO 177 display = GET_R->display; //HACK: TODO
181 178
182 xim = XOpenIM (display->display, NULL, NULL, NULL); 179 xim = XOpenIM (display->dpy, 0, 0, 0);
183 180
184 if (!xim) 181 if (!xim)
185 return false; 182 return false;
186 183
187 XIMCallback ximcallback; 184 XIMCallback ximcallback;
188 ximcallback.client_data = (XPointer)this; 185 ximcallback.client_data = (XPointer)this;
189 ximcallback.callback = im_destroy_cb; 186 ximcallback.callback = im_destroy_cb;
190 187
191 XSetIMValues (xim, XNDestroyCallback, &ximcallback, NULL); 188 XSetIMValues (xim, XNDestroyCallback, &ximcallback, 0);
192 189
193 return true; 190 return true;
194} 191}
195 192
196rxvt_xim::~rxvt_xim () 193rxvt_xim::~rxvt_xim ()
… …
201 198
202#endif 199#endif
203 200
204///////////////////////////////////////////////////////////////////////////// 201/////////////////////////////////////////////////////////////////////////////
205 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
206void 253void
207rxvt_screen::set (rxvt_display *disp) 254rxvt_screen::set (rxvt_display *disp)
208{ 255{
209 display = disp; 256 display = disp;
210 xdisp = disp->display; 257 dpy = disp->dpy;
211 258
212 Screen *screen = ScreenOfDisplay (xdisp, disp->screen); 259 Screen *screen = ScreenOfDisplay (dpy, disp->screen);
213 260
214 depth = DefaultDepthOfScreen (screen); 261 depth = DefaultDepthOfScreen (screen);
215 visual = DefaultVisualOfScreen (screen); 262 visual = DefaultVisualOfScreen (screen);
216 cmap = DefaultColormapOfScreen (screen); 263 cmap = DefaultColormapOfScreen (screen);
217} 264}
… …
222 set (disp); 269 set (disp);
223 270
224#if XFT 271#if XFT
225 XVisualInfo vinfo; 272 XVisualInfo vinfo;
226 273
227 if (XMatchVisualInfo (xdisp, display->screen, bitdepth, TrueColor, &vinfo)) 274 if (XMatchVisualInfo (dpy, display->screen, bitdepth, TrueColor, &vinfo))
228 { 275 {
229 depth = bitdepth; 276 depth = bitdepth;
230 visual = vinfo.visual; 277 visual = vinfo.visual;
231 cmap = XCreateColormap (xdisp, disp->root, visual, AllocNone); 278 cmap = XCreateColormap (dpy, disp->root, visual, AllocNone);
232 } 279 }
233#endif 280#endif
234} 281}
235 282
236void 283void
237rxvt_screen::clear () 284rxvt_screen::clear ()
238{ 285{
286#if XFT
287 if (scratch_area)
288 {
289 XFreePixmap (dpy, scratch_area->drawable);
290 delete scratch_area;
291 }
292#endif
293
239 if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (xdisp, display->screen))) 294 if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (dpy, display->screen)))
240 XFreeColormap (xdisp, cmap); 295 XFreeColormap (dpy, cmap);
241} 296}
242 297
243///////////////////////////////////////////////////////////////////////////// 298/////////////////////////////////////////////////////////////////////////////
244 299
245rxvt_display::rxvt_display (const char *id) 300rxvt_display::rxvt_display (const char *id)
… …
248, selection_owner (0) 303, selection_owner (0)
249{ 304{
250} 305}
251 306
252XrmDatabase 307XrmDatabase
253rxvt_display::get_resources () 308rxvt_display::get_resources (bool refresh)
254{ 309{
255 char *homedir = (char *)getenv ("HOME"); 310 char *homedir = (char *)getenv ("HOME");
256 char fname[1024]; 311 char fname[1024];
257 312
258 /* 313 /*
259 * get resources using the X library function 314 * get resources using the X library function
260 */ 315 */
261 char *displayResource, *xe; 316 char *displayResource, *xe;
262 XrmDatabase database, rdb1; 317 XrmDatabase rdb1, database = 0;
263
264 database = NULL;
265 318
266 // for ordering, see for example http://www.faqs.org/faqs/Xt-FAQ/ Subject: 20 319 // for ordering, see for example http://www.faqs.org/faqs/Xt-FAQ/ Subject: 20
267 320
268 // 6. System wide per application default file. 321 // 6. System wide per application default file.
269 322
… …
279 // 5. User's per application default file. 332 // 5. User's per application default file.
280 // none 333 // none
281 334
282 // 4. User's defaults file. 335 // 4. User's defaults file.
283 /* Get any Xserver defaults */ 336 /* Get any Xserver defaults */
337 if (refresh)
338 {
339 // fucking xlib keeps a copy of the rm string
340 Atom actual_type;
341 int actual_format;
342 unsigned long nitems, nremaining;
343 char *val = 0;
344
345#if XLIB_ILLEGAL_ACCESS
346 if (dpy->xdefaults)
347 XFree (dpy->xdefaults);
348#endif
349
350 if (XGetWindowProperty (dpy, root, XA_RESOURCE_MANAGER,
351 0L, 100000000L, False,
352 XA_STRING, &actual_type, &actual_format,
353 &nitems, &nremaining,
354 (unsigned char **)&val) == Success
355 && actual_type == XA_STRING
356 && actual_format == 8)
357 displayResource = val;
358 else
359 {
360 displayResource = 0;
361 if (val)
362 XFree(val);
363 }
364
365#if XLIB_ILLEGAL_ACCESS
366 dpy->xdefaults = displayResource;
367#endif
368 }
369 else
284 displayResource = XResourceManagerString (display); 370 displayResource = XResourceManagerString (dpy);
285 371
286 if (displayResource != NULL) 372 if (displayResource)
287 { 373 {
288 if ((rdb1 = XrmGetStringDatabase (displayResource))) 374 if ((rdb1 = XrmGetStringDatabase (displayResource)))
289 XrmMergeDatabases (rdb1, &database); 375 XrmMergeDatabases (rdb1, &database);
290 } 376 }
291 else if (homedir) 377 else if (homedir)
… …
294 380
295 if ((rdb1 = XrmGetFileDatabase (fname))) 381 if ((rdb1 = XrmGetFileDatabase (fname)))
296 XrmMergeDatabases (rdb1, &database); 382 XrmMergeDatabases (rdb1, &database);
297 } 383 }
298 384
385#if !XLIB_ILLEGAL_ACCESS
386 if (refresh && displayResource)
387 XFree (displayResource);
388#endif
389
299 /* Get screen specific resources */ 390 /* Get screen specific resources */
300 displayResource = XScreenResourceString (ScreenOfDisplay (display, screen)); 391 displayResource = XScreenResourceString (ScreenOfDisplay (dpy, screen));
301 392
302 if (displayResource != NULL) 393 if (displayResource)
303 { 394 {
304 if ((rdb1 = XrmGetStringDatabase (displayResource))) 395 if ((rdb1 = XrmGetStringDatabase (displayResource)))
305 /* Merge with screen-independent resources */ 396 /* Merge with screen-independent resources */
306 XrmMergeDatabases (rdb1, &database); 397 XrmMergeDatabases (rdb1, &database);
307 398
… …
335 if (id[0] == ':') 426 if (id[0] == ':')
336 { 427 {
337 val = rxvt_malloc (5 + strlen (id) + 1); 428 val = rxvt_malloc (5 + strlen (id) + 1);
338 strcpy (val, "unix/"); 429 strcpy (val, "unix/");
339 strcat (val, id); 430 strcat (val, id);
340 display = XOpenDisplay (val); 431 dpy = XOpenDisplay (val);
341 free (val); 432 free (val);
342 } 433 }
343 else 434 else
344#endif 435#endif
345 display = 0; 436 dpy = 0;
346 437
347 if (!display) 438 if (!dpy)
348 display = XOpenDisplay (id); 439 dpy = XOpenDisplay (id);
349 440
350 if (!display) 441 if (!dpy)
351 return false; 442 return false;
352 443
353 screen = DefaultScreen (display); 444 screen = DefaultScreen (dpy);
354 root = DefaultRootWindow (display); 445 root = DefaultRootWindow (dpy);
355 446
356 assert (sizeof (xa_names) / sizeof (char *) == NUM_XA); 447 assert (sizeof (xa_names) / sizeof (char *) == NUM_XA);
357 XInternAtoms (display, (char **)xa_names, NUM_XA, False, xa); 448 XInternAtoms (dpy, (char **)xa_names, NUM_XA, False, xa);
358 449
359 XrmSetDatabase (display, get_resources ()); 450 XrmSetDatabase (dpy, get_resources (false));
360 451
361#ifdef POINTER_BLANK 452#ifdef POINTER_BLANK
362 XColor blackcolour; 453 XColor blackcolour;
363 blackcolour.red = 0; 454 blackcolour.red = 0;
364 blackcolour.green = 0; 455 blackcolour.green = 0;
365 blackcolour.blue = 0; 456 blackcolour.blue = 0;
366 Font f = XLoadFont (display, "fixed"); 457 Font f = XLoadFont (dpy, "fixed");
367 blank_cursor = XCreateGlyphCursor (display, f, f, ' ', ' ', 458 blank_cursor = XCreateGlyphCursor (dpy, f, f, ' ', ' ',
368 &blackcolour, &blackcolour); 459 &blackcolour, &blackcolour);
369 XUnloadFont (display, f); 460 XUnloadFont (dpy, f);
370#endif 461#endif
371 462
372 int fd = XConnectionNumber (display); 463 int fd = XConnectionNumber (dpy);
373 464
374#ifndef NO_SLOW_LINK_SUPPORT
375 // try to detect wether we have a local connection. 465 // try to detect wether we have a local connection.
376 // assume unix domains socket == local, everything else not 466 // assume unix domains socket == local, everything else not
377 // TODO: might want to check for inet/127.0.0.1 467 // TODO: might want to check for inet/127.0.0.1
378 is_local = 0; 468 is_local = 0;
379 sockaddr_un sa; 469 sockaddr_un sa;
380 socklen_t sl = sizeof (sa); 470 socklen_t sl = sizeof (sa);
381 471
382 if (!getsockname (fd, (sockaddr *)&sa, &sl)) 472 if (!getsockname (fd, (sockaddr *)&sa, &sl))
383 is_local = sa.sun_family == AF_LOCAL; 473 is_local = sa.sun_family == AF_LOCAL;
384#endif
385 474
386 x_ev.start (fd, EVENT_READ); 475 x_ev.start (fd, EVENT_READ);
387 fcntl (fd, F_SETFD, FD_CLOEXEC); 476 fcntl (fd, F_SETFD, FD_CLOEXEC);
388 477
389 XSelectInput (display, root, PropertyChangeMask); 478 XSelectInput (dpy, root, PropertyChangeMask);
390 479
391 flush (); 480 flush ();
392 481
393 return true; 482 return true;
394} 483}
395 484
396void 485void
397rxvt_display::ref_next () 486rxvt_display::ref_next ()
398{ 487{
399 // TODO: somehow check wether the database files/resources changed 488 // TODO: somehow check wether the database files/resources changed
400 // before re-loading/parsing 489 // before affording re-loading/parsing
401 XrmDestroyDatabase (XrmGetDatabase (display)); 490 XrmDestroyDatabase (XrmGetDatabase (dpy));
402 XrmSetDatabase (display, get_resources ()); 491 XrmSetDatabase (dpy, get_resources (true));
403} 492}
404 493
405rxvt_display::~rxvt_display () 494rxvt_display::~rxvt_display ()
406{ 495{
407 if (!display) 496 if (!dpy)
408 return; 497 return;
409 498
410#ifdef POINTER_BLANK 499#ifdef POINTER_BLANK
411 XFreeCursor (display, blank_cursor); 500 XFreeCursor (dpy, blank_cursor);
412#endif 501#endif
413 x_ev.stop (); 502 x_ev.stop ();
414#ifdef USE_XIM 503#ifdef USE_XIM
415 xims.clear (); 504 xims.clear ();
416#endif 505#endif
417 XCloseDisplay (display); 506 XCloseDisplay (dpy);
418} 507}
419 508
420#ifdef USE_XIM 509#ifdef USE_XIM
421void rxvt_display::im_change_cb () 510void rxvt_display::im_change_cb ()
422{ 511{
… …
430 // registers, as xlib crashes due to a race otherwise. 519 // registers, as xlib crashes due to a race otherwise.
431 Atom actual_type, *atoms; 520 Atom actual_type, *atoms;
432 int actual_format; 521 int actual_format;
433 unsigned long nitems, bytes_after; 522 unsigned long nitems, bytes_after;
434 523
435 if (XGetWindowProperty (display, root, xa[XA_XIM_SERVERS], 0L, 1000000L, 524 if (XGetWindowProperty (dpy, root, xa[XA_XIM_SERVERS], 0L, 1000000L,
436 False, XA_ATOM, &actual_type, &actual_format, 525 False, XA_ATOM, &actual_type, &actual_format,
437 &nitems, &bytes_after, (unsigned char **)&atoms) 526 &nitems, &bytes_after, (unsigned char **)&atoms)
438 != Success ) 527 != Success )
439 return; 528 return;
440 529
441 if (actual_type == XA_ATOM && actual_format == 32) 530 if (actual_type == XA_ATOM && actual_format == 32)
442 for (int i = 0; i < nitems; i++) 531 for (int i = 0; i < nitems; i++)
443 if (XGetSelectionOwner (display, atoms[i])) 532 if (XGetSelectionOwner (dpy, atoms[i]))
444 { 533 {
445 im_change_cb (); 534 im_change_cb ();
446 break; 535 break;
447 } 536 }
448 537
… …
453void rxvt_display::x_cb (io_watcher &w, short revents) 542void rxvt_display::x_cb (io_watcher &w, short revents)
454{ 543{
455 do 544 do
456 { 545 {
457 XEvent xev; 546 XEvent xev;
458 XNextEvent (display, &xev); 547 XNextEvent (dpy, &xev);
459 548
460#ifdef USE_XIM 549#ifdef USE_XIM
461 if (!XFilterEvent (&xev, None)) 550 if (!XFilterEvent (&xev, None))
462 { 551 {
463 if (xev.type == PropertyNotify 552 if (xev.type == PropertyNotify
… …
474 } 563 }
475#ifdef USE_XIM 564#ifdef USE_XIM
476 } 565 }
477#endif 566#endif
478 } 567 }
479 while (XEventsQueued (display, QueuedAlready)); 568 while (XEventsQueued (dpy, QueuedAlready));
480 569
481 XFlush (display); 570 XFlush (dpy);
482} 571}
483 572
484void rxvt_display::flush () 573void rxvt_display::flush ()
485{ 574{
486 if (XEventsQueued (display, QueuedAlready)) 575 if (XEventsQueued (dpy, QueuedAlready))
487 x_cb (x_ev, EVENT_READ); 576 x_cb (x_ev, EVENT_READ);
488 577
489 XFlush (display); 578 XFlush (dpy);
490} 579}
491 580
492void rxvt_display::reg (xevent_watcher *w) 581void rxvt_display::reg (xevent_watcher *w)
493{ 582{
494 xw.push_back (w); 583 xw.push_back (w);
… …
508 597
509 selection_owner = owner; 598 selection_owner = owner;
510} 599}
511 600
512#ifdef USE_XIM 601#ifdef USE_XIM
602
513void rxvt_display::reg (im_watcher *w) 603void rxvt_display::reg (im_watcher *w)
514{ 604{
515 imw.push_back (w); 605 imw.push_back (w);
516} 606}
517 607
… …
541 return xim; 631 return xim;
542} 632}
543 633
544void rxvt_display::put_xim (rxvt_xim *xim) 634void rxvt_display::put_xim (rxvt_xim *xim)
545{ 635{
546#if XLIB_IS_RACEFREE 636# if XLIB_IS_RACEFREE
547 xims.put (xim); 637 xims.put (xim);
548#endif 638# endif
549} 639}
640
550#endif 641#endif
551 642
552Atom rxvt_display::atom (const char *name) 643Atom rxvt_display::atom (const char *name)
553{ 644{
554 return XInternAtom (display, name, False); 645 return XInternAtom (dpy, name, False);
555} 646}
556 647
557///////////////////////////////////////////////////////////////////////////// 648/////////////////////////////////////////////////////////////////////////////
558 649
559template class refcache<rxvt_display>; 650template class refcache<rxvt_display>;
560refcache<rxvt_display> displays; 651refcache<rxvt_display> displays;
561 652
562///////////////////////////////////////////////////////////////////////////// 653/////////////////////////////////////////////////////////////////////////////
563 654
564bool 655bool
565rxvt_color::alloc (rxvt_screen *screen, const rxvt_rgba &color) 656rxvt_color::alloc (rxvt_screen *screen, const rgba &color)
566{ 657{
567#if XFT 658#if XFT
568 XRenderPictFormat *format; 659 XRenderPictFormat *format;
569 660
570 // FUCKING Xft gets it wrong, of course, so work around it 661 // FUCKING Xft gets it wrong, of course, so work around it.
571 // transparency users should eat shit and die, and then 662 // Transparency users should eat shit and die, and then
572 // XRenderQueryPictIndexValues themselves plenty. 663 // XRenderQueryPictIndexValues themselves plenty.
573 if ((screen->visual->c_class == TrueColor || screen->visual->c_class == DirectColor) 664 if ((screen->visual->c_class == TrueColor)
574 && (format = XRenderFindVisualFormat (screen->xdisp, screen->visual))) 665 && (format = XRenderFindVisualFormat (screen->dpy, screen->visual)))
575 { 666 {
576 // the fun lies in doing everything manually... 667 // the fun lies in doing everything manually...
577 c.color.red = color.r; 668 c.color.red = color.r;
578 c.color.green = color.g; 669 c.color.green = color.g;
579 c.color.blue = color.b; 670 c.color.blue = color.b;
580 c.color.alpha = color.a; 671 c.color.alpha = color.a;
581 672
582 c.pixel = ((color.r * format->direct.redMask / rxvt_rgba::MAX_CC) << format->direct.red ) 673 c.pixel = ((color.r * format->direct.redMask / rgba::MAX_CC) << format->direct.red )
583 | ((color.g * format->direct.greenMask / rxvt_rgba::MAX_CC) << format->direct.green) 674 | ((color.g * format->direct.greenMask / rgba::MAX_CC) << format->direct.green)
584 | ((color.b * format->direct.blueMask / rxvt_rgba::MAX_CC) << format->direct.blue ) 675 | ((color.b * format->direct.blueMask / rgba::MAX_CC) << format->direct.blue )
585 | ((color.a * format->direct.alphaMask / rxvt_rgba::MAX_CC) << format->direct.alpha); 676 | ((color.a * format->direct.alphaMask / rgba::MAX_CC) << format->direct.alpha);
586 677
587 return true; 678 return true;
588 } 679 }
589 else 680 else
590 { 681 {
… …
593 d.red = color.r; 684 d.red = color.r;
594 d.green = color.g; 685 d.green = color.g;
595 d.blue = color.b; 686 d.blue = color.b;
596 d.alpha = color.a; 687 d.alpha = color.a;
597 688
598 return XftColorAllocValue (screen->xdisp, screen->visual, screen->cmap, &d, &c); 689 return XftColorAllocValue (screen->dpy, screen->visual, screen->cmap, &d, &c);
599 } 690 }
600#else 691#else
601 if (screen->visual->c_class == TrueColor || screen->visual->c_class == DirectColor) 692 c.red = color.r;
693 c.green = color.g;
694 c.blue = color.b;
695
696 if (screen->visual->c_class == TrueColor)
602 { 697 {
603 p = (color.r * (screen->visual->red_mask >> ctz (screen->visual->red_mask )) 698 c.pixel = (color.r * (screen->visual->red_mask >> ctz (screen->visual->red_mask ))
604 / rxvt_rgba::MAX_CC) << ctz (screen->visual->red_mask ) 699 / rgba::MAX_CC) << ctz (screen->visual->red_mask )
605 | (color.g * (screen->visual->green_mask >> ctz (screen->visual->green_mask)) 700 | (color.g * (screen->visual->green_mask >> ctz (screen->visual->green_mask))
606 / rxvt_rgba::MAX_CC) << ctz (screen->visual->green_mask) 701 / rgba::MAX_CC) << ctz (screen->visual->green_mask)
607 | (color.b * (screen->visual->blue_mask >> ctz (screen->visual->blue_mask )) 702 | (color.b * (screen->visual->blue_mask >> ctz (screen->visual->blue_mask ))
608 / rxvt_rgba::MAX_CC) << ctz (screen->visual->blue_mask ); 703 / rgba::MAX_CC) << ctz (screen->visual->blue_mask );
609 704
610 return true; 705 return true;
611 } 706 }
707 else if (XAllocColor (screen->dpy, screen->cmap, &c))
708 return true;
612 else 709 else
613 {
614 XColor xc;
615
616 xc.red = color.r;
617 xc.green = color.g;
618 xc.blue = color.b;
619
620 if (XAllocColor (screen->xdisp, screen->cmap, &xc))
621 {
622 p = xc.pixel;
623 return true;
624 }
625 else
626 p = (color.r + color.g + color.b) > 128*3 710 c.pixel = (color.r + color.g + color.b) > 128*3
627 ? WhitePixelOfScreen (DefaultScreenOfDisplay (screen->xdisp)) 711 ? WhitePixelOfScreen (DefaultScreenOfDisplay (screen->dpy))
628 : BlackPixelOfScreen (DefaultScreenOfDisplay (screen->xdisp)); 712 : BlackPixelOfScreen (DefaultScreenOfDisplay (screen->dpy));
629 }
630#endif 713#endif
631 714
632 return false; 715 return false;
633} 716}
634 717
635bool 718bool
636rxvt_color::set (rxvt_screen *screen, const char *name) 719rxvt_color::set (rxvt_screen *screen, const char *name)
637{ 720{
638 rxvt_rgba c; 721 rgba c;
639 char eos; 722 char eos;
640 int skip; 723 int skip;
641 724
725 // parse the nonstandard "[alphapercent]" prefix
642 if (1 <= sscanf (name, "[%hd]%n", &c.a, &skip)) 726 if (1 <= sscanf (name, "[%hd]%n", &c.a, &skip))
643 { 727 {
644 c.a = lerp<int, int, int> (0, rxvt_rgba::MAX_CC, c.a); 728 c.a = lerp<int, int, int> (0, rgba::MAX_CC, c.a);
645 name += skip; 729 name += skip;
646 } 730 }
647 else 731 else
648 c.a = rxvt_rgba::MAX_CC; 732 c.a = rgba::MAX_CC;
649 733
650 // parse the non-standard rgba format 734 // parse the non-standard "rgba:rrrr/gggg/bbbb/aaaa" format
651 if (strlen (name) != 4+5*4 || 4 != sscanf (name, "rgba:%hx/%hx/%hx/%hx%c", &c.r, &c.g, &c.b, &c.a, &eos)) 735 if (strlen (name) != 4+5*4 || 4 != sscanf (name, "rgba:%4hx/%4hx/%4hx/%4hx%c", &c.r, &c.g, &c.b, &c.a, &eos))
652 { 736 {
653 XColor xc, xc_exact; 737 XColor xc, xc_exact;
654 738
655 if (XParseColor (screen->xdisp, screen->cmap, name, &xc)) 739 if (XParseColor (screen->dpy, screen->cmap, name, &xc))
656 { 740 {
657 c.r = xc.red; 741 c.r = xc.red;
658 c.g = xc.green; 742 c.g = xc.green;
659 c.b = xc.blue; 743 c.b = xc.blue;
660 } 744 }
… …
670 754
671 return set (screen, c); 755 return set (screen, c);
672} 756}
673 757
674bool 758bool
675rxvt_color::set (rxvt_screen *screen, const rxvt_rgba &color) 759rxvt_color::set (rxvt_screen *screen, const rgba &color)
676{ 760{
677 bool got = alloc (screen, color); 761 bool got = alloc (screen, color);
678 762
679#if !ENABLE_MINIMAL 763#if !ENABLE_MINIMAL
680 int cmap_size = screen->visual->map_entries; 764 int cmap_size = screen->visual->map_entries;
… …
686 XColor *colors = new XColor [screen->visual->map_entries]; 770 XColor *colors = new XColor [screen->visual->map_entries];
687 771
688 for (int i = 0; i < cmap_size; i++) 772 for (int i = 0; i < cmap_size; i++)
689 colors [i].pixel = i; 773 colors [i].pixel = i;
690 774
775 // many kilobytes transfer per colour, but pseudocolor isn't worth
776 // many extra optimisations.
691 XQueryColors (screen->xdisp, screen->cmap, colors, cmap_size); 777 XQueryColors (screen->dpy, screen->cmap, colors, cmap_size);
692 778
693 int diff = 0x7fffffffUL; 779 int diff = 0x7fffffffUL;
694 XColor *best = colors; 780 XColor *best = colors;
695 781
696 for (int i = 0; i < cmap_size; i++) 782 for (int i = 0; i < cmap_size; i++)
… …
707 } 793 }
708 794
709 //rxvt_warn ("could not allocate %04x %04x %04x, getting %04x %04x %04x instead (%d)\n", 795 //rxvt_warn ("could not allocate %04x %04x %04x, getting %04x %04x %04x instead (%d)\n",
710 // color.r, color.g, color.b, best->red, best->green, best->blue, diff); 796 // color.r, color.g, color.b, best->red, best->green, best->blue, diff);
711 797
712 got = alloc (screen, rxvt_rgba (best->red, best->green, best->blue)); 798 got = alloc (screen, rgba (best->red, best->green, best->blue));
713 799
714 delete colors; 800 delete colors;
715 } 801 }
716#endif 802#endif
717 803
718 return got; 804 return got;
719} 805}
720 806
721void 807void
722rxvt_color::get (rxvt_screen *screen, rxvt_rgba &color) 808rxvt_color::get (rgba &color)
723{ 809{
724#if XFT 810#if XFT
725 color.r = c.color.red; 811 color.r = c.color.red;
726 color.g = c.color.green; 812 color.g = c.color.green;
727 color.b = c.color.blue; 813 color.b = c.color.blue;
728 color.a = c.color.alpha; 814 color.a = c.color.alpha;
729#else 815#else
730 XColor c;
731
732 c.pixel = p;
733 XQueryColor (screen->xdisp, screen->cmap, &c);
734
735 color.r = c.red; 816 color.r = c.red;
736 color.g = c.green; 817 color.g = c.green;
737 color.b = c.blue; 818 color.b = c.blue;
738 color.a = rxvt_rgba::MAX_CC; 819 color.a = rgba::MAX_CC;
739#endif 820#endif
821}
822
823void
824rxvt_color::get (XColor &color)
825{
826 rgba c;
827 get (c);
828
829 color.red = c.r;
830 color.green = c.g;
831 color.blue = c.b;
832 color.pixel = (Pixel)*this;
740} 833}
741 834
742void 835void
743rxvt_color::free (rxvt_screen *screen) 836rxvt_color::free (rxvt_screen *screen)
744{ 837{
838 if (screen->visual->c_class == TrueColor)
839 return; // nothing to do
840
745#if XFT 841#if XFT
746 XftColorFree (screen->xdisp, screen->visual, screen->cmap, &c); 842 XftColorFree (screen->dpy, screen->visual, screen->cmap, &c);
747#else 843#else
748 XFreeColors (screen->xdisp, screen->cmap, &p, 1, AllPlanes); 844 XFreeColors (screen->dpy, screen->cmap, &c.pixel, 1, AllPlanes);
749#endif 845#endif
750} 846}
751 847
752rxvt_color 848void
753rxvt_color::fade (rxvt_screen *screen, int percent, const rxvt_rgba &to) 849rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &result, const rgba &to)
754{ 850{
755 rxvt_rgba c; 851 rgba c;
756 get (screen, c); 852 get (c);
757 853
758 rxvt_color faded; 854 result.set (
759 faded.set (
760 screen, 855 screen,
761 rxvt_rgba ( 856 rgba (
762 lerp (to.r, c.r, percent), 857 lerp (c.r, to.r, percent),
763 lerp (to.g, c.g, percent), 858 lerp (c.g, to.g, percent),
764 lerp (to.b, c.b, percent), 859 lerp (c.b, to.b, percent),
765 lerp (to.a, c.a, percent) 860 lerp (c.a, to.a, percent)
766 ) 861 )
767 ); 862 );
768
769 return faded;
770} 863}
771 864

Diff Legend

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