ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/background.C
(Generate patch)

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.53 by sf-exg, Wed Sep 1 13:18:55 2010 UTC vs.
Revision 1.63 by sf-exg, Sun Oct 3 21:44:39 2010 UTC

… …
96 // this is basically redundant as bgPixmap_t is only used in 96 // this is basically redundant as bgPixmap_t is only used in
97 // zero_initialised-derived structs 97 // zero_initialised-derived structs
98#ifdef HAVE_AFTERIMAGE 98#ifdef HAVE_AFTERIMAGE
99 original_asim = NULL; 99 original_asim = NULL;
100#endif 100#endif
101#ifdef HAVE_PIXBUF
102 pixbuf = NULL;
103#endif
101#ifdef BG_IMAGE_FROM_FILE 104#ifdef BG_IMAGE_FROM_FILE
102 have_image = false; 105 have_image = false;
103 h_scale = v_scale = 0; 106 h_scale = v_scale = 0;
104 h_align = v_align = 0; 107 h_align = v_align = 0;
105#endif 108#endif
… …
115#ifdef HAVE_AFTERIMAGE 118#ifdef HAVE_AFTERIMAGE
116 if (original_asim) 119 if (original_asim)
117 safe_asimage_destroy (original_asim); 120 safe_asimage_destroy (original_asim);
118#endif 121#endif
119 122
123#ifdef HAVE_PIXBUF
124 if (pixbuf)
125 g_object_unref (pixbuf);
126#endif
127
120 if (pixmap && target) 128 if (pixmap && target)
121 XFreePixmap (target->dpy, pixmap); 129 XFreePixmap (target->dpy, pixmap);
122} 130}
123 131
124bool 132bool
… …
130# endif 138# endif
131 139
132# ifdef BG_IMAGE_FROM_FILE 140# ifdef BG_IMAGE_FROM_FILE
133 if (have_image) 141 if (have_image)
134 { 142 {
135 if (h_scale != 0 || v_scale != 0 143 if (flags & sizeSensitive)
136 || h_align != 0 || v_align != 0)
137 return true; 144 return true;
138 } 145 }
139# endif 146# endif
140 147
141 return false; 148 return false;
… …
150# endif 157# endif
151 158
152# ifdef BG_IMAGE_FROM_FILE 159# ifdef BG_IMAGE_FROM_FILE
153 if (have_image) 160 if (have_image)
154 { 161 {
155 if (h_align == rootAlign || v_align == rootAlign) 162 if (flags & rootAlign)
156 return true; 163 return true;
157 } 164 }
158# endif 165# endif
159 166
160 return false; 167 return false;
… …
200static inline bool 207static inline bool
201check_set_align_value (int geom_flags, int flag, int &align, int new_value) 208check_set_align_value (int geom_flags, int flag, int &align, int new_value)
202{ 209{
203 if (geom_flags & flag) 210 if (geom_flags & flag)
204 { 211 {
205 if (new_value != bgPixmap_t::rootAlign)
206 {
207 if (new_value < -100) 212 if (new_value < -100)
208 new_value = -100; 213 new_value = -100;
209 else if (new_value > 200) 214 else if (new_value > 200)
210 new_value = 200; 215 new_value = 200;
211 }
212 if (new_value != align) 216 if (new_value != align)
213 { 217 {
214 align = new_value; 218 align = new_value;
215 return true; 219 return true;
216 } 220 }
… …
220 224
221static inline int 225static inline int
222make_align_position (int align, int window_size, int image_size) 226make_align_position (int align, int window_size, int image_size)
223{ 227{
224 int diff = window_size - image_size; 228 int diff = window_size - image_size;
225 int smaller = MIN (image_size,window_size); 229 int smaller = min (image_size, window_size);
226 230
227 if (align >= 0 && align <= 50) 231 if (align >= 0 && align <= 50)
228 return diff * align / 100; 232 return diff * align / 100;
229 else if (align > 50 && align <= 100) 233 else if (align > 50 && align <= 100)
230 return window_size - image_size - diff * (100 - align) / 100; 234 return window_size - image_size - diff * (100 - align) / 100;
… …
239make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 243make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
240{ 244{
241 int src_pos = 0; 245 int src_pos = 0;
242 dst_pos = 0; 246 dst_pos = 0;
243 dst_size = size; 247 dst_size = size;
244 if (pos < 0 && size > target_size) 248 if (pos < 0)
245 { 249 {
246 src_pos = -pos; 250 src_pos = -pos;
247 dst_size += pos; 251 dst_size += pos;
248 } 252 }
249 else if (pos > 0) 253 else if (pos > 0)
… …
380 w = h = noScale; 384 w = h = noScale;
381 geom_flags |= WidthValue|HeightValue; 385 geom_flags |= WidthValue|HeightValue;
382 } 386 }
383 else if (CHECK_GEOM_OPS ("propscale")) 387 else if (CHECK_GEOM_OPS ("propscale"))
384 { 388 {
385 if (w == 0 && h == 0)
386 {
387 w = windowScale;
388 geom_flags |= WidthValue;
389 }
390 new_flags |= propScale; 389 new_flags |= propScale;
391 } 390 }
392 else if (CHECK_GEOM_OPS ("hscale")) 391 else if (CHECK_GEOM_OPS ("hscale"))
393 { 392 {
394 if (w == 0) w = windowScale; 393 if (w == 0) w = windowScale;
… …
416 x = y = centerAlign; 415 x = y = centerAlign;
417 geom_flags |= WidthValue|HeightValue|XValue|YValue; 416 geom_flags |= WidthValue|HeightValue|XValue|YValue;
418 } 417 }
419 else if (CHECK_GEOM_OPS ("root")) 418 else if (CHECK_GEOM_OPS ("root"))
420 { 419 {
420 new_flags |= rootAlign;
421 w = h = noScale; 421 w = h = noScale;
422 x = y = rootAlign;
423 geom_flags |= WidthValue|HeightValue|XValue|YValue; 422 geom_flags |= WidthValue|HeightValue;
424 } 423 }
425# undef CHECK_GEOM_OPS 424# undef CHECK_GEOM_OPS
426 425
427 while (*ops != ':' && *ops != '\0') ++ops; 426 while (*ops != ':' && *ops != '\0') ++ops;
428 } /* done parsing ops */ 427 } /* done parsing ops */
… …
441 } 440 }
442 441
443 //fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n", 442 //fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
444 // flags, h_scale, v_scale, h_align, v_align); 443 // flags, h_scale, v_scale, h_align, v_align);
445 return (changed > 0); 444 return (changed > 0);
445}
446
447void
448bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
449{
450 int target_width = target->szHint.width;
451 int target_height = target->szHint.height;
452
453 if (flags & propScale)
454 {
455 float scale = (float)target_width / image_width;
456 min_it (scale, (float)target_height / image_height);
457 w = image_width * scale + 0.5;
458 h = image_height * scale + 0.5;
459 }
460 else
461 {
462 w = h_scale * target_width / 100;
463 h = v_scale * target_height / 100;
464 }
465
466 if (flags & rootAlign)
467 {
468 target->get_window_origin (x, y);
469 x = -x;
470 y = -y;
471 }
472 else
473 {
474 x = make_align_position (h_align, target_width, w > 0 ? w : image_width);
475 y = make_align_position (v_align, target_height, h > 0 ? h : image_height);
476 }
477
478 flags &= ~sizeSensitive;
479 if (h_scale != 0 || v_scale != 0
480 || h_align != 0 || v_align != 0
481 || image_width > target_width || image_height > target_height)
482 flags |= sizeSensitive;
446} 483}
447 484
448# ifdef HAVE_AFTERIMAGE 485# ifdef HAVE_AFTERIMAGE
449bool 486bool
450bgPixmap_t::render_image (unsigned long background_flags) 487bgPixmap_t::render_image (unsigned long background_flags)
… …
496 int new_pmap_width = target_width; 533 int new_pmap_width = target_width;
497 int new_pmap_height = target_height; 534 int new_pmap_height = target_height;
498 535
499 int x = 0; 536 int x = 0;
500 int y = 0; 537 int y = 0;
501 int w = h_scale * target_width / 100; 538 int w = 0;
502 int h = v_scale * target_height / 100; 539 int h = 0;
503 540
504 TIMING_TEST_START (asim); 541 TIMING_TEST_START (asim);
505 542
506 if (original_asim) 543 if (original_asim)
507 { 544 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
508 if (h_align == rootAlign || v_align == rootAlign)
509 {
510 target->get_window_origin (x, y);
511 x = -x;
512 y = -y;
513 }
514
515 if (h_align != rootAlign)
516 x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
517
518 if (v_align != rootAlign)
519 y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
520 }
521 545
522 if (!original_asim 546 if (!original_asim
523 || x >= target_width 547 || x >= target_width
524 || y >= target_height 548 || y >= target_height
525 || (w > 0 && x + w <= 0) 549 || (w > 0 && x + w <= 0)
… …
557 100, ASIMAGE_QUALITY_DEFAULT); 581 100, ASIMAGE_QUALITY_DEFAULT);
558 } 582 }
559 583
560 if (background == NULL) 584 if (background == NULL)
561 { 585 {
562 /* if tiling - pixmap has to be sized exactly as the image,
563 but there is no need to make it bigger than the window! */
564 if (h_scale == 0)
565 new_pmap_width = min (result->width, target_width);
566 if (v_scale == 0)
567 new_pmap_height = min (result->height, target_height);
568 /* we also need to tile our image in one or both directions */
569 if (h_scale == 0 || v_scale == 0) 586 if (h_scale == 0 || v_scale == 0)
570 { 587 {
588 /* if tiling - pixmap has to be sized exactly as the image,
589 but there is no need to make it bigger than the window! */
590 new_pmap_width = min (result->width, target_width);
591 new_pmap_height = min (result->height, target_height);
592
593 /* we also need to tile our image in both directions */
571 ASImage *tmp = tile_asimage (target->asv, result, 594 ASImage *tmp = tile_asimage (target->asv, result,
572 (h_scale > 0) ? 0 : (int)result->width - x, 595 (int)result->width - x,
573 (v_scale > 0) ? 0 : (int)result->height - y, 596 (int)result->height - y,
574 new_pmap_width, 597 new_pmap_width,
575 new_pmap_height, 598 new_pmap_height,
576 TINT_LEAVE_SAME, ASA_XImage, 599 TINT_LEAVE_SAME, ASA_XImage,
577 100, ASIMAGE_QUALITY_DEFAULT); 600 100, ASIMAGE_QUALITY_DEFAULT);
578 if (tmp) 601 if (tmp)
… …
676 699
677 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0; 700 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
678 int dst_width = result->width, dst_height = result->height; 701 int dst_width = result->width, dst_height = result->height;
679 if (background == NULL) 702 if (background == NULL)
680 { 703 {
704 if (!(h_scale == 0 || v_scale == 0))
705 {
681 if (h_scale > 0) src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width ); 706 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
682 if (v_scale > 0) src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height); 707 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
708 }
683 709
684 if (dst_x > 0 || dst_y > 0 710 if (dst_x > 0 || dst_y > 0
685 || dst_x + dst_width < new_pmap_width 711 || dst_x + dst_width < new_pmap_width
686 || dst_y + dst_height < new_pmap_height) 712 || dst_y + dst_height < new_pmap_height)
687 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 713 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
… …
704 destroy_asimage (&background); 730 destroy_asimage (&background);
705 731
706 return ret; 732 return ret;
707} 733}
708# endif /* HAVE_AFTERIMAGE */ 734# endif /* HAVE_AFTERIMAGE */
735
736# ifdef HAVE_PIXBUF
737bool
738bgPixmap_t::render_image (unsigned long background_flags)
739{
740 if (target == NULL)
741 return false;
742
743 if (!pixbuf)
744 return false;
745
746 // TODO: add alpha blending
747 if (background_flags)
748 return false;
749
750 GdkPixbuf *result;
751
752 int image_width = gdk_pixbuf_get_width (pixbuf);
753 int image_height = gdk_pixbuf_get_height (pixbuf);
754
755 int target_width = target->szHint.width;
756 int target_height = target->szHint.height;
757 int new_pmap_width = target_width;
758 int new_pmap_height = target_height;
759
760 int x = 0;
761 int y = 0;
762 int w = 0;
763 int h = 0;
764
765 get_image_geometry (image_width, image_height, w, h, x, y);
766
767 if (x >= target_width
768 || y >= target_height
769 || (w > 0 && x + w <= 0)
770 || (h > 0 && y + h <= 0))
771 return false;
772
773 result = pixbuf;
774
775 if ((w > 0 && w != image_width)
776 || (h > 0 && h != image_height))
777 {
778 result = gdk_pixbuf_scale_simple (pixbuf,
779 w > 0 ? w : image_width,
780 h > 0 ? h : image_height,
781 GDK_INTERP_BILINEAR);
782 }
783
784 bool ret = false;
785
786 if (result)
787 {
788 XGCValues gcv;
789 GC gc;
790
791 image_width = gdk_pixbuf_get_width (result);
792 image_height = gdk_pixbuf_get_height (result);
793
794 if (h_scale == 0 || v_scale == 0)
795 {
796 new_pmap_width = min (image_width, target_width);
797 new_pmap_height = min (image_height, target_height);
798 }
799
800 if (pixmap)
801 {
802 if (pmap_width != new_pmap_width
803 || pmap_height != new_pmap_height
804 || pmap_depth != target->depth)
805 {
806 XFreePixmap (target->dpy, pixmap);
807 pixmap = None;
808 }
809 }
810
811 if (pixmap == None)
812 {
813 pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
814 pmap_width = new_pmap_width;
815 pmap_height = new_pmap_height;
816 pmap_depth = target->depth;
817 }
818
819 gcv.foreground = target->pix_colors[Color_bg];
820 gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
821
822 if (h_scale == 0 || v_scale == 0)
823 {
824 Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth);
825 gdk_pixbuf_xlib_render_to_drawable (result, tile, gc,
826 0, 0,
827 0, 0,
828 image_width, image_height,
829 XLIB_RGB_DITHER_NONE,
830 0, 0);
831
832 gcv.tile = tile;
833 gcv.fill_style = FillTiled;
834 gcv.ts_x_origin = x;
835 gcv.ts_y_origin = y;
836 XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
837
838 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
839 XFreePixmap (target->dpy, tile);
840 }
841 else
842 {
843 int src_x, src_y, dst_x, dst_y;
844 int dst_width, dst_height;
845
846 src_x = make_clip_rectangle (x, image_width , new_pmap_width , dst_x, dst_width );
847 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
848
849 if (dst_x > 0 || dst_y > 0
850 || dst_x + dst_width < new_pmap_width
851 || dst_y + dst_height < new_pmap_height)
852 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
853
854 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
855 gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc,
856 src_x, src_y,
857 dst_x, dst_y,
858 dst_width, dst_height,
859 XLIB_RGB_DITHER_NONE,
860 0, 0);
861 }
862
863 if (result != pixbuf)
864 g_object_unref (result);
865
866 XFreeGC (target->dpy, gc);
867
868 ret = true;
869 }
870
871 return ret;
872}
873# endif /* HAVE_PIXBUF */
709 874
710bool 875bool
711bgPixmap_t::set_file (const char *file) 876bgPixmap_t::set_file (const char *file)
712{ 877{
713 assert (file); 878 assert (file);
… …
726# ifdef HAVE_AFTERIMAGE 891# ifdef HAVE_AFTERIMAGE
727 if (!target->asimman) 892 if (!target->asimman)
728 target->asimman = create_generic_imageman (target->rs[Rs_path]); 893 target->asimman = create_generic_imageman (target->rs[Rs_path]);
729 original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100); 894 original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);
730 if (original_asim) 895 if (original_asim)
896 have_image = true;
897 return have_image;
898# endif
899
900# ifdef HAVE_PIXBUF
901 pixbuf = gdk_pixbuf_new_from_file (file, NULL);
902 if (pixbuf)
731 have_image = true; 903 have_image = true;
732 return have_image; 904 return have_image;
733# endif 905# endif
734 } 906 }
735 907
… …
1189 XImage *result = NULL; 1361 XImage *result = NULL;
1190 1362
1191 if (background_flags && (flags & isInvalid)) 1363 if (background_flags && (flags & isInvalid))
1192 { 1364 {
1193 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap); 1365 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1366 }
1194 1367
1368 if (result)
1369 {
1195# if !defined(HAVE_AFTERIMAGE) && !XFT 1370# if !defined(HAVE_AFTERIMAGE) && !XFT
1196 /* our own client-side tinting */ 1371 /* our own client-side tinting */
1197 /* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side. 1372 /* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
1198 This may need to be changed in need_client_side_rendering() logic is altered !!! */ 1373 This may need to be changed in need_client_side_rendering() logic is altered !!! */
1199 if (result != NULL && !(background_flags & transpPmapTinted) && (flags & tintNeeded)) 1374 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1200 { 1375 {
1201 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 1376 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1202 if (flags & tintSet) 1377 if (flags & tintSet)
1203 tint.get (c); 1378 tint.get (c);
1204 ShadeXImage (target, result, shade, c.r, c.g, c.b); 1379 ShadeXImage (target, result, shade, c.r, c.g, c.b);
1205 } 1380 }
1206# endif 1381# endif
1207 }
1208 1382
1209 if (result)
1210 {
1211 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL); 1383 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1212 1384
1213 if (gc) 1385 if (gc)
1214 { 1386 {
1215 if (/*pmap_depth != target->depth &&*/ pixmap != None) 1387 if (/*pmap_depth != target->depth &&*/ pixmap != None)

Diff Legend

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