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.51 by root, Sat Feb 18 14:14:43 2006 UTC

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

Diff Legend

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