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

Diff Legend

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