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.162 by sf-exg, Thu Aug 11 12:27:26 2011 UTC vs.
Revision 1.203 by sf-exg, Tue Apr 10 15:08:47 2012 UTC

… …
20 * You should have received a copy of the GNU General Public License 20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software 21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *---------------------------------------------------------------------*/ 23 *---------------------------------------------------------------------*/
24 24
25#include <cmath> 25#include <math.h>
26#include "../config.h" /* NECESSARY */ 26#include "../config.h" /* NECESSARY */
27#include "rxvt.h" /* NECESSARY */ 27#include "rxvt.h" /* NECESSARY */
28 28
29#if XRENDER 29#if XRENDER
30# include <X11/extensions/Xrender.h> 30# include <X11/extensions/Xrender.h>
… …
32 32
33#ifndef FilterConvolution 33#ifndef FilterConvolution
34#define FilterConvolution "convolution" 34#define FilterConvolution "convolution"
35#endif 35#endif
36 36
37/* 37#ifndef RepeatPad
38 * Pixmap geometry string interpretation : 38#define RepeatPad True
39 * Each geometry string contains zero or one scale/position 39#endif
40 * adjustment and may optionally be followed by a colon and one or more
41 * colon-delimited pixmap operations.
42 * The following table shows the valid geometry strings and their
43 * effects on the background image :
44 *
45 * WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
46 * W and H are percentages of the terminal window size.
47 * X and Y are also percentages; e.g., +50+50 centers
48 * the image in the window.
49 *
50 * Pixmap Operations : (should be prepended by a colon)
51 */
52 40
53#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
42# if XRENDER
43static Picture
44create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
45{
46 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
47
48 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
49 XRenderPictureAttributes pa;
50 pa.repeat = True;
51 pa.component_alpha = component_alpha;
52 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
53
54 XFreePixmap (dpy, pixmap);
55
56 return mask;
57}
58# endif
59
54void 60void
55rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
56{ 62{
57#ifdef HAVE_AFTERIMAGE
58 if (original_asim)
59 safe_asimage_destroy (original_asim);
60 if (asv)
61 destroy_asvisual (asv, 0);
62 if (asimman)
63 destroy_image_manager (asimman, 0);
64#endif
65
66#ifdef HAVE_PIXBUF 63#ifdef HAVE_PIXBUF
67 if (pixbuf) 64 if (pixbuf)
68 g_object_unref (pixbuf); 65 g_object_unref (pixbuf);
69#endif 66#endif
70 67
… …
123 120
124 return false; 121 return false;
125} 122}
126 123
127# ifdef BG_IMAGE_FROM_FILE 124# ifdef BG_IMAGE_FROM_FILE
128static inline bool
129check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
130{
131 if (geom_flags & flag)
132 {
133 if (new_value > 1000)
134 new_value = 1000;
135 if (new_value != scale)
136 {
137 scale = new_value;
138 return true;
139 }
140 }
141 return false;
142}
143
144static inline bool
145check_set_align_value (int geom_flags, int flag, int &align, int new_value)
146{
147 if (geom_flags & flag)
148 {
149 if (new_value < -100)
150 new_value = -100;
151 else if (new_value > 200)
152 new_value = 200;
153 if (new_value != align)
154 {
155 align = new_value;
156 return true;
157 }
158 }
159 return false;
160}
161
162static inline int 125static inline int
163make_align_position (int align, int window_size, int image_size) 126make_align_position (int align, int window_size, int image_size)
164{ 127{
165 int diff = window_size - image_size; 128 int diff = window_size - image_size;
166 int smaller = min (image_size, window_size); 129 int smaller = min (image_size, window_size);
167 130
168 if (align >= 0 && align <= 100) 131 if (align >= 0 && align <= 100)
169 return diff * align / 100; 132 return diff * align / 100;
170 else if (align > 100 && align <= 200) 133 else if (align > 100 && align <= 200)
171 return ((align - 100) * smaller / 100) + window_size - smaller; 134 return (align - 100) * smaller / 100 + window_size - smaller;
172 else if (align >= -100 && align < 0) 135 else if (align >= -100 && align < 0)
173 return ((align + 100) * smaller / 100) - image_size; 136 return (align + 100) * smaller / 100 - image_size;
174 return 0; 137 return 0;
175} 138}
176 139
177static inline int 140static inline int
178make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 141make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
… …
185 src_pos = -pos; 148 src_pos = -pos;
186 dst_pos = 0; 149 dst_pos = 0;
187 dst_size += pos; 150 dst_size += pos;
188 } 151 }
189 152
190 if (dst_pos + dst_size > target_size)
191 dst_size = target_size - dst_pos; 153 min_it (dst_size, target_size - dst_pos);
192 return src_pos; 154 return src_pos;
193} 155}
194 156
195bool 157bool
196rxvt_term::bg_set_geometry (const char *geom, bool update) 158rxvt_term::bg_set_geometry (const char *geom, bool update)
197{ 159{
198 bool changed = false; 160 bool changed = false;
199 int geom_flags = 0; 161 int geom_flags = 0;
200 int x = 0, y = 0; 162 int x = h_align;
163 int y = v_align;
201 unsigned int w = 0, h = 0; 164 unsigned int w = h_scale;
202 unsigned int n; 165 unsigned int h = v_scale;
203 unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS)); 166 unsigned long new_flags = 0;
204 const char *ops;
205 167
206 if (geom == NULL) 168 if (geom == NULL)
207 return false; 169 return false;
208 170
209 char str[256]; 171 if (geom[0])
210
211 ops = strchr (geom, ':');
212 if (ops == NULL)
213 n = strlen (geom);
214 else
215 n = ops - geom;
216
217 if (n >= sizeof (str))
218 return false;
219
220 memcpy (str, geom, n);
221 str[n] = '\0';
222 rxvt_strtrim (str);
223
224 if (str[0])
225 { 172 {
226 /* we have geometry string - let's handle it prior to applying ops */ 173 char **arr = rxvt_strsplit (':', geom);
174
175 for (int i = 0; arr[i]; i++)
176 {
177 if (!strcasecmp (arr[i], "style=tiled"))
178 {
179 new_flags = BG_TILE;
180 w = h = noScale;
181 x = y = 0;
182 geom_flags = WidthValue|HeightValue|XValue|YValue;
183 }
184 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
185 {
186 new_flags = BG_KEEP_ASPECT;
187 w = h = windowScale;
188 x = y = centerAlign;
189 geom_flags = WidthValue|HeightValue|XValue|YValue;
190 }
191 else if (!strcasecmp (arr[i], "style=stretched"))
192 {
193 new_flags = 0;
194 w = h = windowScale;
195 geom_flags = WidthValue|HeightValue;
196 }
197 else if (!strcasecmp (arr[i], "style=centered"))
198 {
199 new_flags = 0;
200 w = h = noScale;
201 x = y = centerAlign;
202 geom_flags = WidthValue|HeightValue|XValue|YValue;
203 }
204 else if (!strcasecmp (arr[i], "style=root-tiled"))
205 {
206 new_flags = BG_TILE|BG_ROOT_ALIGN;
207 w = h = noScale;
208 geom_flags = WidthValue|HeightValue;
209 }
210 else if (!strcasecmp (arr[i], "op=tile"))
211 new_flags |= BG_TILE;
212 else if (!strcasecmp (arr[i], "op=keep-aspect"))
213 new_flags |= BG_KEEP_ASPECT;
214 else if (!strcasecmp (arr[i], "op=root-align"))
215 new_flags |= BG_ROOT_ALIGN;
216
217 // deprecated
218 else if (!strcasecmp (arr[i], "tile"))
219 {
220 new_flags |= BG_TILE;
221 w = h = noScale;
222 geom_flags |= WidthValue|HeightValue;
223 }
224 else if (!strcasecmp (arr[i], "propscale"))
225 {
226 new_flags |= BG_KEEP_ASPECT;
227 w = h = windowScale;
228 geom_flags |= WidthValue|HeightValue;
229 }
230 else if (!strcasecmp (arr[i], "hscale"))
231 {
232 new_flags |= BG_TILE;
233 w = windowScale;
234 h = noScale;
235 geom_flags |= WidthValue|HeightValue;
236 }
237 else if (!strcasecmp (arr[i], "vscale"))
238 {
239 new_flags |= BG_TILE;
240 h = windowScale;
241 w = noScale;
242 geom_flags |= WidthValue|HeightValue;
243 }
244 else if (!strcasecmp (arr[i], "scale"))
245 {
246 w = h = windowScale;
247 geom_flags |= WidthValue|HeightValue;
248 }
249 else if (!strcasecmp (arr[i], "auto"))
250 {
251 w = h = windowScale;
252 x = y = centerAlign;
253 geom_flags |= WidthValue|HeightValue|XValue|YValue;
254 }
255 else if (!strcasecmp (arr[i], "root"))
256 {
257 new_flags |= BG_TILE|BG_ROOT_ALIGN;
258 w = h = noScale;
259 geom_flags |= WidthValue|HeightValue;
260 }
261
262 else
227 geom_flags = XParseGeometry (str, &x, &y, &w, &h); 263 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
228 } /* done parsing geometry string */ 264 } /* done parsing ops */
265
266 rxvt_free_strsplit (arr);
267 }
268
269 new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
229 270
230 if (!update) 271 if (!update)
231 { 272 {
232 if (!(geom_flags & XValue)) 273 if (!(geom_flags & XValue))
233 x = y = defaultAlign; 274 x = y = defaultAlign;
… …
238 w = h = defaultScale; 279 w = h = defaultScale;
239 else if (!(geom_flags & HeightValue)) 280 else if (!(geom_flags & HeightValue))
240 h = w; 281 h = w;
241 else if (!(geom_flags & WidthValue)) 282 else if (!(geom_flags & WidthValue))
242 w = h; 283 w = h;
243
244 geom_flags |= WidthValue|HeightValue|XValue|YValue;
245 }
246
247 if (ops)
248 { 284 }
249 char **arr = rxvt_strsplit (':', ops + 1);
250 285
251 for (int i = 0; arr[i]; i++) 286 min_it (w, 1000);
252 { 287 min_it (h, 1000);
253 if (!strcasecmp (arr[i], "style=tiled")) 288 clamp_it (x, -100, 200);
254 { 289 clamp_it (y, -100, 200);
255 new_flags = BG_TILE;
256 w = h = noScale;
257 x = y = 0;
258 geom_flags = WidthValue|HeightValue|XValue|YValue;
259 }
260 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
261 {
262 new_flags = BG_PROP_SCALE;
263 x = y = centerAlign;
264 geom_flags = XValue|YValue;
265 }
266 else if (!strcasecmp (arr[i], "style=stretched"))
267 {
268 new_flags = 0;
269 w = h = windowScale;
270 geom_flags = WidthValue|HeightValue;
271 }
272 else if (!strcasecmp (arr[i], "style=centered"))
273 {
274 new_flags = 0;
275 w = h = noScale;
276 x = y = centerAlign;
277 geom_flags = WidthValue|HeightValue|XValue|YValue;
278 }
279 else if (!strcasecmp (arr[i], "style=root-tiled"))
280 {
281 new_flags = BG_TILE|BG_ROOT_ALIGN;
282 w = h = noScale;
283 geom_flags = WidthValue|HeightValue;
284 }
285 else if (!strcasecmp (arr[i], "op=tile"))
286 new_flags |= BG_TILE;
287 else if (!strcasecmp (arr[i], "op=pscale"))
288 new_flags |= BG_PROP_SCALE;
289 else if (!strcasecmp (arr[i], "op=root"))
290 new_flags |= BG_ROOT_ALIGN;
291 290
292 // deprecated 291 if (bg_flags != new_flags
293 else if (!strcasecmp (arr[i], "tile")) 292 || h_scale != w
294 { 293 || v_scale != h
295 new_flags |= BG_TILE; 294 || h_align != x
296 w = h = noScale; 295 || v_align != y)
297 geom_flags |= WidthValue|HeightValue;
298 }
299 else if (!strcasecmp (arr[i], "propscale"))
300 {
301 new_flags |= BG_PROP_SCALE;
302 }
303 else if (!strcasecmp (arr[i], "hscale"))
304 {
305 new_flags |= BG_TILE;
306 w = windowScale;
307 h = noScale;
308 geom_flags |= WidthValue|HeightValue;
309 }
310 else if (!strcasecmp (arr[i], "vscale"))
311 {
312 new_flags |= BG_TILE;
313 h = windowScale;
314 w = noScale;
315 geom_flags |= WidthValue|HeightValue;
316 }
317 else if (!strcasecmp (arr[i], "scale"))
318 {
319 w = h = windowScale;
320 geom_flags |= WidthValue|HeightValue;
321 }
322 else if (!strcasecmp (arr[i], "auto"))
323 {
324 w = h = windowScale;
325 x = y = centerAlign;
326 geom_flags |= WidthValue|HeightValue|XValue|YValue;
327 }
328 else if (!strcasecmp (arr[i], "root"))
329 {
330 new_flags |= BG_TILE|BG_ROOT_ALIGN;
331 w = h = noScale;
332 geom_flags |= WidthValue|HeightValue;
333 }
334 } /* done parsing ops */
335
336 rxvt_free_strsplit (arr);
337 }
338
339 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
340 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
341 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
342 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
343
344 if (new_flags != bg_flags)
345 { 296 {
346 bg_flags = new_flags; 297 bg_flags = new_flags;
298 h_scale = w;
299 v_scale = h;
300 h_align = x;
301 v_align = y;
347 changed = true; 302 changed = true;
348 } 303 }
349 304
350 return changed; 305 return changed;
351} 306}
… …
354rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 309rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
355{ 310{
356 int target_width = szHint.width; 311 int target_width = szHint.width;
357 int target_height = szHint.height; 312 int target_height = szHint.height;
358 313
314 w = h_scale * target_width / 100;
315 h = v_scale * target_height / 100;
316
359 if (bg_flags & BG_PROP_SCALE) 317 if (bg_flags & BG_KEEP_ASPECT)
360 { 318 {
361 float scale = (float)target_width / image_width; 319 float scale = (float)w / image_width;
362 min_it (scale, (float)target_height / image_height); 320 min_it (scale, (float)h / image_height);
363 w = image_width * scale + 0.5; 321 w = image_width * scale + 0.5;
364 h = image_height * scale + 0.5; 322 h = image_height * scale + 0.5;
365 } 323 }
366 else
367 {
368 w = h_scale * target_width / 100;
369 h = v_scale * target_height / 100;
370 }
371 324
372 if (!w) w = image_width; 325 if (!w) w = image_width;
373 if (!h) h = image_height; 326 if (!h) h = image_height;
374 327
375 if (bg_flags & BG_ROOT_ALIGN) 328 if (bg_flags & BG_ROOT_ALIGN)
… …
383 y = make_align_position (v_align, target_height, h); 336 y = make_align_position (v_align, target_height, h);
384 } 337 }
385 338
386 bg_flags &= ~BG_IS_SIZE_SENSITIVE; 339 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
387 if (!(bg_flags & BG_TILE) 340 if (!(bg_flags & BG_TILE)
388 || (bg_flags & BG_PROP_SCALE) || h_scale || v_scale 341 || h_scale || v_scale
389 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 342 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
390 || w > target_width || h > target_height) 343 || w > target_width || h > target_height)
391 bg_flags |= BG_IS_SIZE_SENSITIVE; 344 bg_flags |= BG_IS_SIZE_SENSITIVE;
392} 345}
393
394# ifdef HAVE_AFTERIMAGE
395bool
396rxvt_term::render_image (unsigned long tr_flags)
397{
398 init_asv ();
399
400 ASImage *background = NULL;
401 ARGB32 background_tint = TINT_LEAVE_SAME;
402
403# ifdef ENABLE_TRANSPARENCY
404 if (tr_flags)
405 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
406
407 if (tr_flags & BG_NEEDS_TINT)
408 {
409 ShadingInfo as_shade;
410 as_shade.shading = shade;
411
412 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
413 if (bg_flags & BG_TINT_SET)
414 tint.get (c);
415 as_shade.tintColor.red = c.r;
416 as_shade.tintColor.green = c.g;
417 as_shade.tintColor.blue = c.b;
418
419 background_tint = shading2tint32 (&as_shade);
420 }
421
422 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
423 {
424 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
425 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,
426 100, ASIMAGE_QUALITY_DEFAULT);
427 if (tmp)
428 {
429 destroy_asimage (&background);
430 background = tmp;
431 }
432 }
433# endif
434
435 ASImage *result = 0;
436
437 int target_width = szHint.width;
438 int target_height = szHint.height;
439 int new_pmap_width = target_width;
440 int new_pmap_height = target_height;
441
442 int x = 0;
443 int y = 0;
444 int w = 0;
445 int h = 0;
446
447 if (original_asim)
448 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
449
450 if (!original_asim
451 || (!(bg_flags & BG_ROOT_ALIGN)
452 && (x >= target_width
453 || y >= target_height
454 || (x + w <= 0)
455 || (y + h <= 0))))
456 {
457 if (background)
458 {
459 new_pmap_width = background->width;
460 new_pmap_height = background->height;
461 result = background;
462
463 if (background_tint != TINT_LEAVE_SAME)
464 {
465 ASImage *tmp = tile_asimage (asv, background, 0, 0,
466 target_width, target_height, background_tint,
467 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
468 if (tmp)
469 result = tmp;
470 }
471 }
472 else
473 new_pmap_width = new_pmap_height = 0;
474 }
475 else
476 {
477 result = original_asim;
478
479 if ((w != original_asim->width)
480 || (h != original_asim->height))
481 {
482 result = scale_asimage (asv, original_asim,
483 w, h,
484 background ? ASA_ASImage : ASA_XImage,
485 100, ASIMAGE_QUALITY_DEFAULT);
486 }
487
488 if (background == NULL)
489 {
490 if (bg_flags & BG_TILE)
491 {
492 /* if tiling - pixmap has to be sized exactly as the image,
493 but there is no need to make it bigger than the window! */
494 new_pmap_width = min (result->width, target_width);
495 new_pmap_height = min (result->height, target_height);
496
497 /* we also need to tile our image in both directions */
498 ASImage *tmp = tile_asimage (asv, result,
499 (int)result->width - x,
500 (int)result->height - y,
501 new_pmap_width,
502 new_pmap_height,
503 TINT_LEAVE_SAME, ASA_XImage,
504 100, ASIMAGE_QUALITY_DEFAULT);
505 if (tmp)
506 {
507 if (result != original_asim)
508 destroy_asimage (&result);
509
510 result = tmp;
511 }
512 }
513 }
514 else
515 {
516 /* if blending background and image - pixmap has to be sized same as target window */
517 ASImageLayer *layers = create_image_layers (2);
518
519 layers[0].im = background;
520 layers[0].clip_width = target_width;
521 layers[0].clip_height = target_height;
522 layers[0].tint = background_tint;
523 layers[1].im = result;
524
525 if (bg_flags & BG_TILE)
526 {
527 /* tile horizontally */
528 while (x > 0) x -= (int)result->width;
529 layers[1].dst_x = x;
530 layers[1].clip_width = result->width+target_width;
531 }
532 else
533 {
534 /* clip horizontally */
535 layers[1].dst_x = x;
536 layers[1].clip_width = result->width;
537 }
538
539 if (bg_flags & BG_TILE)
540 {
541 while (y > 0) y -= (int)result->height;
542 layers[1].dst_y = y;
543 layers[1].clip_height = result->height + target_height;
544 }
545 else
546 {
547 layers[1].dst_y = y;
548 layers[1].clip_height = result->height;
549 }
550
551 if (rs[Rs_blendtype])
552 {
553 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
554 if (layers[1].merge_scanlines == NULL)
555 layers[1].merge_scanlines = alphablend_scanlines;
556 }
557
558 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
559 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
560
561 if (tmp)
562 {
563 if (result != original_asim)
564 destroy_asimage (&result);
565
566 result = tmp;
567 }
568
569 free (layers);
570 }
571 }
572
573 bool ret = false;
574
575 if (result)
576 {
577 XGCValues gcv;
578 GC gc;
579
580 /* create Pixmap */
581 if (bg_pixmap == None
582 || bg_pmap_width != new_pmap_width
583 || bg_pmap_height != new_pmap_height)
584 {
585 if (bg_pixmap)
586 XFreePixmap (dpy, bg_pixmap);
587 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
588 bg_pmap_width = new_pmap_width;
589 bg_pmap_height = new_pmap_height;
590 }
591 /* fill with background color (if result's not completely overlapping it) */
592 gcv.foreground = pix_colors[Color_bg];
593 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
594
595 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
596 int dst_width = result->width, dst_height = result->height;
597 if (background == NULL)
598 {
599 if (!(bg_flags & BG_TILE))
600 {
601 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
602 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
603 }
604
605 if (dst_x > 0 || dst_y > 0
606 || dst_x + dst_width < new_pmap_width
607 || dst_y + dst_height < new_pmap_height)
608 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
609 }
610
611 /* put result on pixmap */
612 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
613 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
614
615 if (result != background && result != original_asim)
616 destroy_asimage (&result);
617
618 XFreeGC (dpy, gc);
619
620 ret = true;
621 }
622
623 if (background)
624 destroy_asimage (&background);
625
626 return ret;
627}
628# endif /* HAVE_AFTERIMAGE */
629 346
630# ifdef HAVE_PIXBUF 347# ifdef HAVE_PIXBUF
631bool 348bool
632rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc, 349rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
633 int src_x, int src_y, int dst_x, int dst_y, 350 int src_x, int src_y, int dst_x, int dst_y,
… …
710 XDestroyImage (ximage); 427 XDestroyImage (ximage);
711 return true; 428 return true;
712} 429}
713 430
714bool 431bool
715rxvt_term::render_image (unsigned long tr_flags) 432rxvt_term::render_image (bool transparent)
716{ 433{
717 if (!pixbuf) 434 if (!pixbuf)
718 return false; 435 return false;
719 436
720 if (tr_flags 437 if (transparent
721 && !(bg_flags & BG_HAS_RENDER)) 438 && !(bg_flags & BG_HAS_RENDER))
722 return false; 439 return false;
723 440
724 GdkPixbuf *result; 441 GdkPixbuf *result;
725 442
… …
739 get_image_geometry (image_width, image_height, w, h, x, y); 456 get_image_geometry (image_width, image_height, w, h, x, y);
740 457
741 if (!(bg_flags & BG_ROOT_ALIGN) 458 if (!(bg_flags & BG_ROOT_ALIGN)
742 && (x >= target_width 459 && (x >= target_width
743 || y >= target_height 460 || y >= target_height
744 || (x + w <= 0) 461 || x + w <= 0
745 || (y + h <= 0))) 462 || y + h <= 0))
746 return false; 463 return false;
747 464
748 result = pixbuf; 465 result = pixbuf;
749 466
750 if ((w != image_width) 467 if (w != image_width
751 || (h != image_height)) 468 || h != image_height)
752 { 469 {
753 result = gdk_pixbuf_scale_simple (pixbuf, 470 result = gdk_pixbuf_scale_simple (pixbuf,
754 w, h, 471 w, h,
755 GDK_INTERP_BILINEAR); 472 GDK_INTERP_BILINEAR);
756 } 473 }
… …
765 Pixmap root_pmap; 482 Pixmap root_pmap;
766 483
767 image_width = gdk_pixbuf_get_width (result); 484 image_width = gdk_pixbuf_get_width (result);
768 image_height = gdk_pixbuf_get_height (result); 485 image_height = gdk_pixbuf_get_height (result);
769 486
770 if (tr_flags) 487 if (transparent)
771 { 488 {
772 root_pmap = bg_pixmap; 489 root_pmap = bg_pixmap;
773 bg_pixmap = None; 490 bg_pixmap = None;
774 } 491 }
775 else 492 else
… …
833 dst_x, dst_y, 550 dst_x, dst_y,
834 dst_width, dst_height); 551 dst_width, dst_height);
835 } 552 }
836 553
837#if XRENDER 554#if XRENDER
838 if (tr_flags) 555 if (transparent)
839 { 556 {
840 XRenderPictureAttributes pa;
841
842 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 557 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
558
843 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 559 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
844 560
845 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
846 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 561 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
847 562
848 pa.repeat = True; 563 Picture mask = create_xrender_mask (dpy, vt, False, False);
849 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
850 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
851 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
852 XFreePixmap (dpy, mask_pmap);
853 564
854 XRenderColor mask_c; 565 XRenderColor mask_c;
855 566
856 mask_c.alpha = 0x8000; 567 mask_c.alpha = 0x8000;
857 mask_c.red = 0; 568 mask_c.red =
858 mask_c.green = 0; 569 mask_c.green =
859 mask_c.blue = 0; 570 mask_c.blue = 0;
860 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 571 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
572
861 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 573 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
862 574
863 XRenderFreePicture (dpy, src); 575 XRenderFreePicture (dpy, src);
864 XRenderFreePicture (dpy, dst); 576 XRenderFreePicture (dpy, dst);
865 XRenderFreePicture (dpy, mask); 577 XRenderFreePicture (dpy, mask);
… …
872 } 584 }
873 585
874 if (result != pixbuf) 586 if (result != pixbuf)
875 g_object_unref (result); 587 g_object_unref (result);
876 588
877 if (tr_flags) 589 if (transparent)
878 XFreePixmap (dpy, root_pmap); 590 XFreePixmap (dpy, root_pmap);
879 591
880 return ret; 592 return ret;
881} 593}
882# endif /* HAVE_PIXBUF */ 594# endif /* HAVE_PIXBUF */
… …
885rxvt_term::bg_set_file (const char *file) 597rxvt_term::bg_set_file (const char *file)
886{ 598{
887 if (!file || !*file) 599 if (!file || !*file)
888 return false; 600 return false;
889 601
602 bool ret = false;
890 if (const char *p = strchr (file, ';')) 603 const char *p = strchr (file, ';');
604
605 if (p)
891 { 606 {
892 size_t len = p - file; 607 size_t len = p - file;
893 char *f = rxvt_temp_buf<char> (len + 1); 608 char *f = rxvt_temp_buf<char> (len + 1);
894 memcpy (f, file, len); 609 memcpy (f, file, len);
895 f[len] = '\0'; 610 f[len] = '\0';
896 file = f; 611 file = f;
897 } 612 }
898 613
899# ifdef HAVE_AFTERIMAGE
900 if (!asimman)
901 asimman = create_generic_imageman (rs[Rs_path]);
902 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
903 if (image)
904 {
905 if (original_asim)
906 safe_asimage_destroy (original_asim);
907 original_asim = image;
908 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
909 return true;
910 }
911# endif
912
913# ifdef HAVE_PIXBUF 614# ifdef HAVE_PIXBUF
914 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 615 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
915 if (image) 616 if (image)
916 { 617 {
917 if (pixbuf) 618 if (pixbuf)
918 g_object_unref (pixbuf); 619 g_object_unref (pixbuf);
919 pixbuf = image; 620 pixbuf = image;
920 bg_flags |= BG_IS_FROM_FILE; 621 bg_flags |= BG_IS_FROM_FILE;
921 return true; 622 ret = true;
922 } 623 }
923# endif 624# endif
924 625
626 if (ret)
627 {
628 if (p)
629 bg_set_geometry (p + 1);
630 else
631 bg_set_default_geometry ();
632 }
633
925 return false; 634 return ret;
926} 635}
927 636
928# endif /* BG_IMAGE_FROM_FILE */ 637# endif /* BG_IMAGE_FROM_FILE */
929 638
930# ifdef ENABLE_TRANSPARENCY 639# ifdef ENABLE_TRANSPARENCY
… …
966 { 675 {
967 changed = true; 676 changed = true;
968 v_blurRadius = vr; 677 v_blurRadius = vr;
969 } 678 }
970 679
971 if (v_blurRadius == 0 && h_blurRadius == 0) 680 if (h_blurRadius == 0 || v_blurRadius == 0)
972 bg_flags &= ~BG_NEEDS_BLUR; 681 bg_flags &= ~BG_NEEDS_BLUR;
973 else 682 else
974 bg_flags |= BG_NEEDS_BLUR; 683 bg_flags |= BG_NEEDS_BLUR;
975 684
976 return changed; 685 return changed;
977} 686}
978 687
979void 688void
980rxvt_term::set_tint_shade_flags () 689rxvt_term::set_tint_shade_flags ()
981{ 690{
982 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 691 if (shade != 100 || (bg_flags & BG_TINT_SET))
983 bool has_shade = shade != 100; 692 bg_flags |= BG_NEEDS_TINT;
693 else
694 bg_flags &= ~BG_NEEDS_TINT;
695}
984 696
697bool
698rxvt_term::bg_set_tint (rxvt_color &new_tint)
699{
700 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
701 {
702 tint = new_tint;
985 bg_flags &= ~BG_TINT_FLAGS; 703 bg_flags |= BG_TINT_SET;
986 704
987 if (bg_flags & BG_TINT_SET) 705 rgba c;
988 {
989 tint.get (c); 706 tint.get (c);
990 if (!has_shade
991 && (c.r <= 0x00ff || c.r >= 0xff00) 707 if ((c.r <= 0x00ff || c.r >= 0xff00)
992 && (c.g <= 0x00ff || c.g >= 0xff00) 708 && (c.g <= 0x00ff || c.g >= 0xff00)
993 && (c.b <= 0x00ff || c.b >= 0xff00)) 709 && (c.b <= 0x00ff || c.b >= 0xff00))
994 bg_flags |= BG_TINT_BITAND; 710 bg_flags |= BG_TINT_BITAND;
995 } 711 else
996
997 if (has_shade || (bg_flags & BG_TINT_SET))
998 bg_flags |= BG_NEEDS_TINT;
999}
1000
1001bool
1002rxvt_term::bg_set_tint (rxvt_color &new_tint)
1003{
1004 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1005 {
1006 tint = new_tint;
1007 bg_flags |= BG_TINT_SET; 712 bg_flags &= ~BG_TINT_BITAND;
713
1008 set_tint_shade_flags (); 714 set_tint_shade_flags ();
1009 return true; 715 return true;
1010 } 716 }
1011 717
1012 return false; 718 return false;
1013} 719}
1014 720
1015bool 721bool
1016rxvt_term::bg_set_shade (const char *shade_str) 722rxvt_term::bg_set_shade (const char *shade_str)
1017{ 723{
1018 int new_shade = (shade_str) ? atoi (shade_str) : 100; 724 int new_shade = atoi (shade_str);
1019 725
1020 clamp_it (new_shade, -100, 200); 726 clamp_it (new_shade, -100, 200);
1021 if (new_shade < 0) 727 if (new_shade < 0)
1022 new_shade = 200 - (100 + new_shade); 728 new_shade = 200 - (100 + new_shade);
1023 729
… …
1053 params[i+2] = XDoubleToFixed (kernel[i] / sum); 759 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1054} 760}
1055#endif 761#endif
1056 762
1057bool 763bool
1058rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 764rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1059{ 765{
1060 bool ret = false; 766 bool ret = false;
1061#if XRENDER 767#if XRENDER
768 if (!(bg_flags & BG_HAS_RENDER_CONV))
769 return false;
770
1062 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 771 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1063 double *kernel = (double *)malloc (size * sizeof (double)); 772 double *kernel = (double *)malloc (size * sizeof (double));
1064 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 773 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1065 774
1066 XRenderPictureAttributes pa; 775 XRenderPictureAttributes pa;
1067 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 776 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1068 777
778 pa.repeat = RepeatPad;
1069 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 779 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
780 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1070 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 781 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
782 XFreePixmap (dpy, tmp);
1071 783
1072 if (kernel && params) 784 if (kernel && params)
1073 { 785 {
1074 if (h_blurRadius)
1075 {
1076 size = h_blurRadius * 2 + 1; 786 size = h_blurRadius * 2 + 1;
1077 get_gaussian_kernel (h_blurRadius, size, kernel, params); 787 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1078 788
1079 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 789 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1080 XRenderComposite (dpy, 790 XRenderComposite (dpy,
1081 PictOpSrc, 791 PictOpSrc,
1082 src, 792 src,
1083 None, 793 None,
1084 dst, 794 dst,
1085 0, 0, 795 0, 0,
1086 0, 0, 796 0, 0,
1087 0, 0, 797 0, 0,
1088 width, height); 798 width, height);
1089 }
1090 799
1091 if (v_blurRadius) 800 ::swap (src, dst);
1092 { 801
1093 size = v_blurRadius * 2 + 1; 802 size = v_blurRadius * 2 + 1;
1094 get_gaussian_kernel (v_blurRadius, size, kernel, params); 803 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1095 ::swap (params[0], params[1]); 804 ::swap (params[0], params[1]);
1096 805
1097 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 806 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1098 XRenderComposite (dpy, 807 XRenderComposite (dpy,
1099 PictOpSrc, 808 PictOpSrc,
1100 src, 809 src,
1101 None, 810 None,
1102 dst, 811 dst,
1103 0, 0, 812 0, 0,
1104 0, 0, 813 0, 0,
1105 0, 0, 814 0, 0,
1106 width, height); 815 width, height);
1107 }
1108 816
1109 ret = true; 817 ret = true;
1110 } 818 }
1111 819
1112 free (kernel); 820 free (kernel);
… …
1120bool 828bool
1121rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 829rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1122{ 830{
1123 bool ret = false; 831 bool ret = false;
1124 832
1125 if (bg_flags & BG_TINT_BITAND) 833 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1126 { 834 {
1127 XGCValues gcv; 835 XGCValues gcv;
1128 GC gc; 836 GC gc;
1129 837
1130 /* In this case we can tint image server-side getting significant 838 /* In this case we can tint image server-side getting significant
… …
1139 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 847 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1140 ret = true; 848 ret = true;
1141 XFreeGC (dpy, gc); 849 XFreeGC (dpy, gc);
1142 } 850 }
1143 } 851 }
1144 else
1145 {
1146# if XRENDER 852# if XRENDER
853 else if (bg_flags & BG_HAS_RENDER)
854 {
1147 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 855 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1148 856
1149 if (bg_flags & BG_TINT_SET) 857 if (bg_flags & BG_TINT_SET)
1150 tint.get (c); 858 tint.get (c);
1151 859
… …
1160 c.r = c.r * (200 - shade) / 100; 868 c.r = c.r * (200 - shade) / 100;
1161 c.g = c.g * (200 - shade) / 100; 869 c.g = c.g * (200 - shade) / 100;
1162 c.b = c.b * (200 - shade) / 100; 870 c.b = c.b * (200 - shade) / 100;
1163 } 871 }
1164 872
1165 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1166 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 873 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1167 XRenderPictureAttributes pa;
1168 874
1169 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 875 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1170 876
1171 pa.repeat = True; 877 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1172 878
1173 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 879 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1174 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1175 XFreePixmap (dpy, overlay_pmap);
1176
1177 pa.component_alpha = True;
1178 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1179 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1180 XFreePixmap (dpy, mask_pmap);
1181 880
1182 XRenderColor mask_c; 881 XRenderColor mask_c;
1183 882
1184 mask_c.alpha = 0xffff; 883 mask_c.alpha = 0xffff;
1185 mask_c.red = 884 mask_c.red =
… …
1190 mask_c.alpha = 0; 889 mask_c.alpha = 0;
1191 mask_c.red = 0xffff - c.r; 890 mask_c.red = 0xffff - c.r;
1192 mask_c.green = 0xffff - c.g; 891 mask_c.green = 0xffff - c.g;
1193 mask_c.blue = 0xffff - c.b; 892 mask_c.blue = 0xffff - c.b;
1194 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 893 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
894
1195 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 895 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1196 896
1197 if (shade > 100) 897 if (shade > 100)
1198 { 898 {
1199 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1200 mask_c.alpha = 0; 899 mask_c.alpha = 0;
900 mask_c.red =
901 mask_c.green =
902 mask_c.blue = 0xffff * (shade - 100) / 100;
1201 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 903 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1202 904
1203 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 905 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1204 } 906 }
1205 907
1206 ret = true; 908 ret = true;
1207 909
1208 XRenderFreePicture (dpy, mask_pic); 910 XRenderFreePicture (dpy, mask_pic);
1209 XRenderFreePicture (dpy, overlay_pic); 911 XRenderFreePicture (dpy, overlay_pic);
1210 XRenderFreePicture (dpy, back_pic); 912 XRenderFreePicture (dpy, back_pic);
913 }
1211# endif 914# endif
1212 }
1213 915
1214 return ret; 916 return ret;
1215} 917}
1216 918
1217/* 919/*
1218 * Builds a pixmap of the same size as the terminal window that contains 920 * Builds a pixmap of the same size as the terminal window that contains
1219 * the tiled portion of the root pixmap that is supposed to be covered by 921 * the tiled portion of the root pixmap that is supposed to be covered by
1220 * our window. 922 * our window.
1221 */ 923 */
1222unsigned long 924bool
1223rxvt_term::make_transparency_pixmap () 925rxvt_term::make_transparency_pixmap ()
1224{ 926{
1225 unsigned long result = 0; 927 bool ret = false;
1226 928
1227 /* root dimensions may change from call to call - but Display structure should 929 /* root dimensions may change from call to call - but Display structure should
1228 * be always up-to-date, so let's use it : 930 * be always up-to-date, so let's use it :
1229 */ 931 */
1230 int screen = display->screen; 932 int screen = display->screen;
… …
1268#if XRENDER 970#if XRENDER
1269 if (bg_flags & BG_HAS_RENDER) 971 if (bg_flags & BG_HAS_RENDER)
1270 { 972 {
1271 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 973 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1272 974
1273 XRenderPictureAttributes pa;
1274
1275 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 975 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1276 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 976 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1277 977
1278 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 978 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1279 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 979 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1280 980
1281 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 981 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1282 982
1283 XRenderFreePicture (dpy, src); 983 XRenderFreePicture (dpy, src);
1284 XRenderFreePicture (dpy, dst); 984 XRenderFreePicture (dpy, dst);
… …
1301 bg_pmap_width = window_width; 1001 bg_pmap_width = window_width;
1302 bg_pmap_height = window_height; 1002 bg_pmap_height = window_height;
1303 } 1003 }
1304 1004
1305 /* straightforward pixmap copy */ 1005 /* straightforward pixmap copy */
1306 while (sx < 0) sx += root_width; 1006 while (sx < 0) sx += root_pmap_width;
1307 while (sy < 0) sy += root_height; 1007 while (sy < 0) sy += root_pmap_height;
1308 1008
1309 gcv.tile = recoded_root_pmap; 1009 gcv.tile = recoded_root_pmap;
1310 gcv.fill_style = FillTiled; 1010 gcv.fill_style = FillTiled;
1311 gcv.ts_x_origin = -sx; 1011 gcv.ts_x_origin = -sx;
1312 gcv.ts_y_origin = -sy; 1012 gcv.ts_y_origin = -sy;
1313 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1013 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1314 1014
1315 if (gc) 1015 if (gc)
1316 { 1016 {
1317 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1017 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1318 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1018 ret = true;
1019 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1020
1021 if (!(bg_flags & BG_CLIENT_RENDER))
1022 {
1023 if (bg_flags & BG_NEEDS_BLUR)
1024 {
1025 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1026 tr_flags &= ~BG_NEEDS_BLUR;
1027 }
1028 if (bg_flags & BG_NEEDS_TINT)
1029 {
1030 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1031 tr_flags &= ~BG_NEEDS_TINT;
1032 }
1033 if (tr_flags & BG_NEEDS_TINT)
1034 {
1035 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1036 if (ximage)
1037 {
1038 /* our own client-side tinting */
1039 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1040
1041 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1042 XDestroyImage (ximage);
1043 }
1044 }
1045 } /* server side rendering completed */
1046
1319 XFreeGC (dpy, gc); 1047 XFreeGC (dpy, gc);
1320
1321 if (!(bg_flags & BG_CLIENT_RENDER))
1322 {
1323 if ((bg_flags & BG_NEEDS_BLUR)
1324 && (bg_flags & BG_HAS_RENDER_CONV))
1325 {
1326 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1327 result &= ~BG_NEEDS_BLUR;
1328 }
1329 if ((bg_flags & BG_NEEDS_TINT)
1330 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1331 {
1332 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1333 result &= ~BG_NEEDS_TINT;
1334 }
1335 } /* server side rendering completed */
1336 } 1048 }
1337 1049
1338 if (recoded_root_pmap != root_pixmap) 1050 if (recoded_root_pmap != root_pixmap)
1339 XFreePixmap (dpy, recoded_root_pmap); 1051 XFreePixmap (dpy, recoded_root_pmap);
1340 1052
1341 return result; 1053 return ret;
1342} 1054}
1343 1055
1344void 1056void
1345rxvt_term::bg_set_root_pixmap () 1057rxvt_term::bg_set_root_pixmap ()
1346{ 1058{
… …
1350 1062
1351 root_pixmap = new_root_pixmap; 1063 root_pixmap = new_root_pixmap;
1352} 1064}
1353# endif /* ENABLE_TRANSPARENCY */ 1065# endif /* ENABLE_TRANSPARENCY */
1354 1066
1355#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1356static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1357# endif
1358
1359bool 1067bool
1360rxvt_term::bg_render () 1068rxvt_term::bg_render ()
1361{ 1069{
1362 unsigned long tr_flags = 0; 1070 bool transparent = false;
1363 1071
1364 bg_invalidate (); 1072 bg_invalidate ();
1365# ifdef ENABLE_TRANSPARENCY 1073# ifdef ENABLE_TRANSPARENCY
1366 if (bg_flags & BG_IS_TRANSPARENT) 1074 if (bg_flags & BG_IS_TRANSPARENT)
1367 { 1075 {
1368 /* we need to re-generate transparency pixmap in that case ! */ 1076 /* we need to re-generate transparency pixmap in that case ! */
1369 tr_flags = make_transparency_pixmap (); 1077 transparent = make_transparency_pixmap ();
1370 if (tr_flags == 0) 1078 if (transparent)
1371 return false;
1372 else if (!(tr_flags & BG_EFFECTS_FLAGS))
1373 bg_flags |= BG_IS_VALID; 1079 bg_flags |= BG_IS_VALID;
1374 } 1080 }
1375# endif 1081# endif
1376 1082
1377# ifdef BG_IMAGE_FROM_FILE 1083# ifdef BG_IMAGE_FROM_FILE
1378 if ((bg_flags & BG_IS_FROM_FILE) 1084 if (bg_flags & BG_IS_FROM_FILE)
1379 || (tr_flags & BG_EFFECTS_FLAGS))
1380 { 1085 {
1381 if (render_image (tr_flags)) 1086 if (render_image (transparent))
1382 bg_flags |= BG_IS_VALID; 1087 bg_flags |= BG_IS_VALID;
1383 }
1384# endif
1385
1386# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1387 XImage *result = NULL;
1388
1389 if (tr_flags && !(bg_flags & BG_IS_VALID))
1390 {
1391 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1392 }
1393
1394 if (result)
1395 {
1396 /* our own client-side tinting */
1397 if (tr_flags & BG_NEEDS_TINT)
1398 {
1399 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1400 if (bg_flags & BG_TINT_SET)
1401 tint.get (c);
1402 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1403 }
1404
1405 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1406
1407 if (gc)
1408 {
1409 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1410
1411 XFreeGC (dpy, gc);
1412 bg_flags |= BG_IS_VALID;
1413 }
1414
1415 XDestroyImage (result);
1416 } 1088 }
1417# endif 1089# endif
1418 1090
1419 if (!(bg_flags & BG_IS_VALID)) 1091 if (!(bg_flags & BG_IS_VALID))
1420 { 1092 {
… …
1457#endif 1129#endif
1458} 1130}
1459 1131
1460#endif /* HAVE_BG_PIXMAP */ 1132#endif /* HAVE_BG_PIXMAP */
1461 1133
1462#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1134#ifdef ENABLE_TRANSPARENCY
1463/* taken from aterm-0.4.2 */ 1135/* based on code from aterm-0.4.2 */
1464 1136
1465static void 1137static inline void
1466shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1138fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1139{
1140 for (int i = 0; i <= mask >> sh; i++)
1141 {
1142 uint32_t tmp;
1143 tmp = i * high;
1144 tmp += (mask >> sh) * low;
1145 lookup[i] = (tmp / 0xffff) << sh;
1146 }
1147}
1148
1149void
1150rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1467{ 1151{
1468 int sh_r, sh_g, sh_b; 1152 int sh_r, sh_g, sh_b;
1469 uint32_t mask_r, mask_g, mask_b; 1153 uint32_t mask_r, mask_g, mask_b;
1470 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1154 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1471 rgba low; 1155 unsigned short low;
1472 rgba high;
1473 int i;
1474 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1156 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1475 1157
1476 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1158 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1477 1159
1478 /* for convenience */ 1160 /* for convenience */
… …
1537 break; 1219 break;
1538 default: 1220 default:
1539 return; /* we do not support this color depth */ 1221 return; /* we do not support this color depth */
1540 } 1222 }
1541 1223
1224 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1225
1226 if (bg_flags & BG_TINT_SET)
1227 tint.get (c);
1228
1542 /* prepare limits for color transformation (each channel is handled separately) */ 1229 /* prepare limits for color transformation (each channel is handled separately) */
1543 if (shade > 100) 1230 if (shade > 100)
1544 { 1231 {
1545 shade = 200 - shade;
1546
1547 high.r = c.r * shade / 100;
1548 high.g = c.g * shade / 100;
1549 high.b = c.b * shade / 100;
1550
1551 low.r = 65535 * (100 - shade) / 100; 1232 c.r = c.r * (200 - shade) / 100;
1552 low.g = 65535 * (100 - shade) / 100; 1233 c.g = c.g * (200 - shade) / 100;
1553 low.b = 65535 * (100 - shade) / 100; 1234 c.b = c.b * (200 - shade) / 100;
1235
1236 low = 0xffff * (shade - 100) / 100;
1554 } 1237 }
1555 else 1238 else
1556 { 1239 {
1557 high.r = c.r * shade / 100; 1240 c.r = c.r * shade / 100;
1558 high.g = c.g * shade / 100; 1241 c.g = c.g * shade / 100;
1559 high.b = c.b * shade / 100; 1242 c.b = c.b * shade / 100;
1560 1243
1561 low.r = low.g = low.b = 0; 1244 low = 0;
1562 } 1245 }
1563 1246
1564 /* fill our lookup tables */ 1247 /* fill our lookup tables */
1565 for (i = 0; i <= mask_r>>sh_r; i++) 1248 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1566 { 1249 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1567 uint32_t tmp; 1250 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1568 tmp = i * high.r;
1569 tmp += (mask_r>>sh_r) * low.r;
1570 lookup_r[i] = (tmp/65535)<<sh_r;
1571 }
1572 for (i = 0; i <= mask_g>>sh_g; i++)
1573 {
1574 uint32_t tmp;
1575 tmp = i * high.g;
1576 tmp += (mask_g>>sh_g) * low.g;
1577 lookup_g[i] = (tmp/65535)<<sh_g;
1578 }
1579 for (i = 0; i <= mask_b>>sh_b; i++)
1580 {
1581 uint32_t tmp;
1582 tmp = i * high.b;
1583 tmp += (mask_b>>sh_b) * low.b;
1584 lookup_b[i] = (tmp/65535)<<sh_b;
1585 }
1586 1251
1587 /* apply table to input image (replacing colors by newly calculated ones) */ 1252 /* apply table to input image (replacing colors by newly calculated ones) */
1588 if (ximage->bits_per_pixel == 32 1253 if (ximage->bits_per_pixel == 32
1589 && (ximage->depth == 24 || ximage->depth == 32) 1254 && (ximage->depth == 24 || ximage->depth == 32)
1590 && ximage->byte_order == host_byte_order) 1255 && ximage->byte_order == host_byte_order)
… …
1620 } 1285 }
1621 } 1286 }
1622 1287
1623 free (lookup); 1288 free (lookup);
1624} 1289}
1625#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1290#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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