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.179 by sf-exg, Sat Dec 24 09:44:10 2011 UTC vs.
Revision 1.216 by sf-exg, Sun May 20 16:23:42 2012 UTC

… …
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de> 6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net> 7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8 * Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it> 8 * Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify 10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by 11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or 12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version. 13 * (at your option) any later version.
… …
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#ifndef RepeatPad
38#define RepeatPad True
39#endif
40
37#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
38void 60void
39rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
40{ 62{
41#ifdef HAVE_AFTERIMAGE
42 if (original_asim)
43 safe_asimage_destroy (original_asim);
44 if (asv)
45 destroy_asvisual (asv, 0);
46 if (asimman)
47 destroy_image_manager (asimman, 0);
48#endif
49
50#ifdef HAVE_PIXBUF
51 if (pixbuf)
52 g_object_unref (pixbuf);
53#endif
54
55 if (bg_pixmap) 63 if (bg_pixmap)
56 XFreePixmap (dpy, bg_pixmap); 64 XFreePixmap (dpy, bg_pixmap);
57} 65}
58 66
59bool 67bool
… …
77 if (bg_flags & BG_IS_TRANSPARENT) 85 if (bg_flags & BG_IS_TRANSPARENT)
78 return true; 86 return true;
79# endif 87# endif
80 88
81# ifdef BG_IMAGE_FROM_FILE 89# ifdef BG_IMAGE_FROM_FILE
82 if (bg_flags & BG_IS_FROM_FILE) 90 if (bg_image.flags & IM_IS_SET)
83 { 91 {
84 if (bg_flags & BG_IS_SIZE_SENSITIVE) 92 if ((bg_image.flags & IM_IS_SIZE_SENSITIVE)
93 || bg_image.width () > szHint.width
94 || bg_image.height () > szHint.height)
85 return true; 95 return true;
86 } 96 }
87# endif 97# endif
88 98
89 return false; 99 return false;
… …
96 if (bg_flags & BG_IS_TRANSPARENT) 106 if (bg_flags & BG_IS_TRANSPARENT)
97 return true; 107 return true;
98# endif 108# endif
99 109
100# ifdef BG_IMAGE_FROM_FILE 110# ifdef BG_IMAGE_FROM_FILE
101 if (bg_flags & BG_IS_FROM_FILE) 111 if (bg_image.flags & IM_IS_SET)
102 { 112 {
103 if (bg_flags & BG_ROOT_ALIGN) 113 if (bg_image.flags & IM_ROOT_ALIGN)
104 return true; 114 return true;
105 } 115 }
106# endif 116# endif
107 117
108 return false; 118 return false;
109} 119}
110 120
111# ifdef BG_IMAGE_FROM_FILE 121# ifdef BG_IMAGE_FROM_FILE
112static inline bool
113check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
114{
115 if (geom_flags & flag)
116 {
117 if (new_value > 1000)
118 new_value = 1000;
119 if (new_value != scale)
120 {
121 scale = new_value;
122 return true;
123 }
124 }
125 return false;
126}
127
128static inline bool
129check_set_align_value (int geom_flags, int flag, int &align, int new_value)
130{
131 if (geom_flags & flag)
132 {
133 if (new_value < -100)
134 new_value = -100;
135 else if (new_value > 200)
136 new_value = 200;
137 if (new_value != align)
138 {
139 align = new_value;
140 return true;
141 }
142 }
143 return false;
144}
145
146static inline int 122static inline int
147make_align_position (int align, int window_size, int image_size) 123make_align_position (int align, int window_size, int image_size)
148{ 124{
149 int diff = window_size - image_size;
150 int smaller = min (image_size, window_size);
151
152 if (align >= 0 && align <= 100) 125 if (align >= 0 && align <= 100)
153 return diff * align / 100; 126 return lerp (0, window_size - image_size, align);
154 else if (align > 100 && align <= 200) 127 else if (align > 100)
155 return (align - 100) * smaller / 100 + window_size - smaller; 128 return lerp (window_size - image_size, window_size, align - 100);
156 else if (align >= -100 && align < 0) 129 else
157 return (align + 100) * smaller / 100 - image_size; 130 return lerp (-image_size, 0, align + 100);
158 return 0;
159} 131}
160 132
161static inline int 133static inline int
162make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 134make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
163{ 135{
… …
169 src_pos = -pos; 141 src_pos = -pos;
170 dst_pos = 0; 142 dst_pos = 0;
171 dst_size += pos; 143 dst_size += pos;
172 } 144 }
173 145
174 if (dst_pos + dst_size > target_size)
175 dst_size = target_size - dst_pos; 146 min_it (dst_size, target_size - dst_pos);
176 return src_pos; 147 return src_pos;
177} 148}
178 149
179bool 150bool
180rxvt_term::bg_set_geometry (const char *geom, bool update) 151rxvt_image::set_geometry (const char *geom, bool update)
181{ 152{
182 bool changed = false; 153 bool changed = false;
183 int geom_flags = 0; 154 int geom_flags = 0;
184 int x = 0, y = 0; 155 int x = h_align;
156 int y = v_align;
185 unsigned int w = 0, h = 0; 157 unsigned int w = h_scale;
186 unsigned long new_flags = bg_flags & ~BG_GEOMETRY_FLAGS; 158 unsigned int h = v_scale;
159 unsigned long new_flags = 0;
187 160
188 if (geom == NULL) 161 if (geom == NULL)
189 return false; 162 return false;
190 163
191 if (geom[0]) 164 if (geom[0])
… …
194 167
195 for (int i = 0; arr[i]; i++) 168 for (int i = 0; arr[i]; i++)
196 { 169 {
197 if (!strcasecmp (arr[i], "style=tiled")) 170 if (!strcasecmp (arr[i], "style=tiled"))
198 { 171 {
199 new_flags = BG_TILE; 172 new_flags = IM_TILE;
200 w = h = noScale; 173 w = h = noScale;
201 x = y = 0; 174 x = y = 0;
202 geom_flags = WidthValue|HeightValue|XValue|YValue; 175 geom_flags = WidthValue|HeightValue|XValue|YValue;
203 } 176 }
204 else if (!strcasecmp (arr[i], "style=aspect-stretched")) 177 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
205 { 178 {
206 new_flags = BG_KEEP_ASPECT; 179 new_flags = IM_KEEP_ASPECT;
207 w = h = windowScale; 180 w = h = windowScale;
208 x = y = centerAlign; 181 x = y = centerAlign;
209 geom_flags = WidthValue|HeightValue|XValue|YValue; 182 geom_flags = WidthValue|HeightValue|XValue|YValue;
210 } 183 }
211 else if (!strcasecmp (arr[i], "style=stretched")) 184 else if (!strcasecmp (arr[i], "style=stretched"))
… …
221 x = y = centerAlign; 194 x = y = centerAlign;
222 geom_flags = WidthValue|HeightValue|XValue|YValue; 195 geom_flags = WidthValue|HeightValue|XValue|YValue;
223 } 196 }
224 else if (!strcasecmp (arr[i], "style=root-tiled")) 197 else if (!strcasecmp (arr[i], "style=root-tiled"))
225 { 198 {
226 new_flags = BG_TILE|BG_ROOT_ALIGN; 199 new_flags = IM_TILE|IM_ROOT_ALIGN;
227 w = h = noScale; 200 w = h = noScale;
228 geom_flags = WidthValue|HeightValue; 201 geom_flags = WidthValue|HeightValue;
229 } 202 }
230 else if (!strcasecmp (arr[i], "op=tile")) 203 else if (!strcasecmp (arr[i], "op=tile"))
231 new_flags |= BG_TILE; 204 new_flags |= IM_TILE;
232 else if (!strcasecmp (arr[i], "op=keep-aspect")) 205 else if (!strcasecmp (arr[i], "op=keep-aspect"))
233 new_flags |= BG_KEEP_ASPECT; 206 new_flags |= IM_KEEP_ASPECT;
234 else if (!strcasecmp (arr[i], "op=root-align")) 207 else if (!strcasecmp (arr[i], "op=root-align"))
235 new_flags |= BG_ROOT_ALIGN; 208 new_flags |= IM_ROOT_ALIGN;
236 209
237 // deprecated 210 // deprecated
238 else if (!strcasecmp (arr[i], "tile")) 211 else if (!strcasecmp (arr[i], "tile"))
239 { 212 {
240 new_flags |= BG_TILE; 213 new_flags |= IM_TILE;
241 w = h = noScale; 214 w = h = noScale;
242 geom_flags |= WidthValue|HeightValue; 215 geom_flags |= WidthValue|HeightValue;
243 } 216 }
244 else if (!strcasecmp (arr[i], "propscale")) 217 else if (!strcasecmp (arr[i], "propscale"))
245 { 218 {
246 new_flags |= BG_KEEP_ASPECT; 219 new_flags |= IM_KEEP_ASPECT;
247 w = h = windowScale; 220 w = h = windowScale;
248 geom_flags |= WidthValue|HeightValue; 221 geom_flags |= WidthValue|HeightValue;
249 } 222 }
250 else if (!strcasecmp (arr[i], "hscale")) 223 else if (!strcasecmp (arr[i], "hscale"))
251 { 224 {
252 new_flags |= BG_TILE; 225 new_flags |= IM_TILE;
253 w = windowScale; 226 w = windowScale;
254 h = noScale; 227 h = noScale;
255 geom_flags |= WidthValue|HeightValue; 228 geom_flags |= WidthValue|HeightValue;
256 } 229 }
257 else if (!strcasecmp (arr[i], "vscale")) 230 else if (!strcasecmp (arr[i], "vscale"))
258 { 231 {
259 new_flags |= BG_TILE; 232 new_flags |= IM_TILE;
260 h = windowScale; 233 h = windowScale;
261 w = noScale; 234 w = noScale;
262 geom_flags |= WidthValue|HeightValue; 235 geom_flags |= WidthValue|HeightValue;
263 } 236 }
264 else if (!strcasecmp (arr[i], "scale")) 237 else if (!strcasecmp (arr[i], "scale"))
… …
272 x = y = centerAlign; 245 x = y = centerAlign;
273 geom_flags |= WidthValue|HeightValue|XValue|YValue; 246 geom_flags |= WidthValue|HeightValue|XValue|YValue;
274 } 247 }
275 else if (!strcasecmp (arr[i], "root")) 248 else if (!strcasecmp (arr[i], "root"))
276 { 249 {
277 new_flags |= BG_TILE|BG_ROOT_ALIGN; 250 new_flags |= IM_TILE|IM_ROOT_ALIGN;
278 w = h = noScale; 251 w = h = noScale;
279 geom_flags |= WidthValue|HeightValue; 252 geom_flags |= WidthValue|HeightValue;
280 } 253 }
281 254
282 else 255 else
283 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h); 256 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
284 } /* done parsing ops */ 257 } /* done parsing ops */
285 258
286 rxvt_free_strsplit (arr); 259 rxvt_free_strsplit (arr);
287 } 260 }
261
262 new_flags |= flags & ~IM_GEOMETRY_FLAGS;
288 263
289 if (!update) 264 if (!update)
290 { 265 {
291 if (!(geom_flags & XValue)) 266 if (!(geom_flags & XValue))
292 x = y = defaultAlign; 267 x = y = defaultAlign;
… …
297 w = h = defaultScale; 272 w = h = defaultScale;
298 else if (!(geom_flags & HeightValue)) 273 else if (!(geom_flags & HeightValue))
299 h = w; 274 h = w;
300 else if (!(geom_flags & WidthValue)) 275 else if (!(geom_flags & WidthValue))
301 w = h; 276 w = h;
302
303 geom_flags |= WidthValue|HeightValue|XValue|YValue;
304 }
305
306 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
307 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
308 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
309 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
310
311 if (new_flags != bg_flags)
312 { 277 }
278
279 min_it (w, 1000);
280 min_it (h, 1000);
281 clamp_it (x, -100, 200);
282 clamp_it (y, -100, 200);
283
284 if (flags != new_flags
285 || h_scale != w
286 || v_scale != h
287 || h_align != x
288 || v_align != y)
289 {
313 bg_flags = new_flags; 290 flags = new_flags;
291 h_scale = w;
292 v_scale = h;
293 h_align = x;
294 v_align = y;
314 changed = true; 295 changed = true;
315 } 296 }
316 297
298 if (!(flags & IM_TILE)
299 || h_scale || v_scale
300 || (!(flags & IM_ROOT_ALIGN) && (h_align || v_align)))
301 flags |= IM_IS_SIZE_SENSITIVE;
302 else
303 flags &= ~IM_IS_SIZE_SENSITIVE;
304
317 return changed; 305 return changed;
318} 306}
319 307
320void 308void
321rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 309rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
322{ 310{
311 int image_width = image.width ();
312 int image_height = image.height ();
323 int target_width = szHint.width; 313 int target_width = szHint.width;
324 int target_height = szHint.height; 314 int target_height = szHint.height;
325 315
326 w = h_scale * target_width / 100; 316 w = image.h_scale * target_width / 100;
327 h = v_scale * target_height / 100; 317 h = image.v_scale * target_height / 100;
328 318
329 if (bg_flags & BG_KEEP_ASPECT) 319 if (image.flags & IM_KEEP_ASPECT)
330 { 320 {
331 float scale = (float)w / image_width; 321 float scale = (float)w / image_width;
332 min_it (scale, (float)h / image_height); 322 min_it (scale, (float)h / image_height);
333 w = image_width * scale + 0.5; 323 w = image_width * scale + 0.5;
334 h = image_height * scale + 0.5; 324 h = image_height * scale + 0.5;
335 } 325 }
336 326
337 if (!w) w = image_width; 327 if (!w) w = image_width;
338 if (!h) h = image_height; 328 if (!h) h = image_height;
339 329
340 if (bg_flags & BG_ROOT_ALIGN) 330 if (image.flags & IM_ROOT_ALIGN)
341 { 331 {
342 x = -target_x; 332 x = -target_x;
343 y = -target_y; 333 y = -target_y;
344 } 334 }
345 else 335 else
346 { 336 {
347 x = make_align_position (h_align, target_width, w); 337 x = make_align_position (image.h_align, target_width, w);
348 y = make_align_position (v_align, target_height, h); 338 y = make_align_position (image.v_align, target_height, h);
349 }
350
351 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
352 if (!(bg_flags & BG_TILE)
353 || h_scale || v_scale
354 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
355 || w > target_width || h > target_height)
356 bg_flags |= BG_IS_SIZE_SENSITIVE;
357}
358
359# ifdef HAVE_AFTERIMAGE
360bool
361rxvt_term::render_image (unsigned long tr_flags)
362{
363 init_asv ();
364
365 ASImage *background = NULL;
366 ARGB32 background_tint = TINT_LEAVE_SAME;
367
368# ifdef ENABLE_TRANSPARENCY
369 if (tr_flags)
370 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
371
372 if (tr_flags & BG_NEEDS_TINT)
373 { 339 }
374 ShadingInfo as_shade; 340}
375 as_shade.shading = shade;
376 341
377 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 342# ifdef HAVE_PIXBUF
378 if (bg_flags & BG_TINT_SET) 343bool
379 tint.get (c); 344rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
380 as_shade.tintColor.red = c.r; 345 int src_x, int src_y, int dst_x, int dst_y,
381 as_shade.tintColor.green = c.g; 346 unsigned int width, unsigned int height)
382 as_shade.tintColor.blue = c.b; 347{
348 XImage *ximage;
349 char *line;
350 int width_r, width_g, width_b, width_a;
351 int sh_r, sh_g, sh_b, sh_a;
352 uint32_t alpha_mask;
353 int rowstride;
354 int channels;
355 unsigned char *row;
383 356
384 background_tint = shading2tint32 (&as_shade); 357 if (visual->c_class != TrueColor)
358 return false;
359
360#if XRENDER
361 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
362 if (format)
363 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
364 else
365#endif
366 alpha_mask = 0;
367
368 width_r = ecb_popcount32 (visual->red_mask);
369 width_g = ecb_popcount32 (visual->green_mask);
370 width_b = ecb_popcount32 (visual->blue_mask);
371 width_a = ecb_popcount32 (alpha_mask);
372
373 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
374 return false;
375
376 sh_r = ecb_ctz32 (visual->red_mask);
377 sh_g = ecb_ctz32 (visual->green_mask);
378 sh_b = ecb_ctz32 (visual->blue_mask);
379 sh_a = ecb_ctz32 (alpha_mask);
380
381 if (width > 32767 || height > 32767)
382 return false;
383
384 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, 0,
385 width, height, 32, 0);
386 if (!ximage)
387 return false;
388
389 if (height > INT_MAX / ximage->bytes_per_line
390 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
385 } 391 {
386 392 XDestroyImage (ximage);
387 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL) 393 return false;
388 { 394 }
389 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 395
390 ASA_XImage, 396 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
391 100, ASIMAGE_QUALITY_DEFAULT); 397
392 if (tmp) 398 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
399 channels = gdk_pixbuf_get_n_channels (pixbuf);
400 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
401 line = ximage->data;
402
403 rgba c (0, 0, 0);
404
405 if (channels == 4 && alpha_mask == 0)
406 {
407 pix_colors[Color_bg].get (c);
408 c.r >>= 8;
409 c.g >>= 8;
410 c.b >>= 8;
411 }
412
413 for (int y = 0; y < height; y++)
414 {
415 for (int x = 0; x < width; x++)
416 {
417 unsigned char *pixel = row + x * channels;
418 uint32_t value;
419 unsigned char r, g, b, a;
420
421 if (channels == 4)
393 { 422 {
394 destroy_asimage (&background); 423 a = pixel[3];
395 background = tmp; 424 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
425 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
426 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
427 }
428 else
429 {
430 a = 0xff;
431 r = pixel[0];
432 g = pixel[1];
433 b = pixel[2];
434 }
435
436 value = ((r >> (8 - width_r)) << sh_r)
437 | ((g >> (8 - width_g)) << sh_g)
438 | ((b >> (8 - width_b)) << sh_b)
439 | ((a >> (8 - width_a)) << sh_a);
440
441 if (ximage->bits_per_pixel == 32)
442 ((uint32_t *)line)[x] = value;
443 else
444 XPutPixel (ximage, x, y, value);
396 } 445 }
397 }
398# endif
399 446
400 ASImage *result = 0; 447 row += rowstride;
448 line += ximage->bytes_per_line;
449 }
450
451 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
452 XDestroyImage (ximage);
453 return true;
454}
455
456bool
457rxvt_term::render_image (rxvt_image &image)
458{
459 GdkPixbuf *pixbuf = image.pixbuf;
460 if (!pixbuf)
461 return false;
462
463 bool need_blend = bg_flags & BG_IS_VALID;
464
465 if (need_blend
466 && !(bg_flags & BG_HAS_RENDER))
467 return false;
468
469 GdkPixbuf *result;
470
471 int image_width = gdk_pixbuf_get_width (pixbuf);
472 int image_height = gdk_pixbuf_get_height (pixbuf);
401 473
402 int target_width = szHint.width; 474 int target_width = szHint.width;
403 int target_height = szHint.height; 475 int target_height = szHint.height;
404 int new_pmap_width = target_width; 476 int new_pmap_width = target_width;
405 int new_pmap_height = target_height; 477 int new_pmap_height = target_height;
… …
407 int x = 0; 479 int x = 0;
408 int y = 0; 480 int y = 0;
409 int w = 0; 481 int w = 0;
410 int h = 0; 482 int h = 0;
411 483
412 if (original_asim) 484 get_image_geometry (image, w, h, x, y);
413 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
414 485
415 if (!original_asim
416 || (!(bg_flags & BG_ROOT_ALIGN)
417 && (x >= target_width
418 || y >= target_height
419 || x + w <= 0
420 || y + h <= 0)))
421 {
422 if (background)
423 {
424 new_pmap_width = background->width;
425 new_pmap_height = background->height;
426 result = background;
427
428 if (background_tint != TINT_LEAVE_SAME)
429 {
430 ASImage *tmp = tile_asimage (asv, background, 0, 0,
431 target_width, target_height, background_tint,
432 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
433 if (tmp)
434 result = tmp;
435 }
436 }
437 else
438 new_pmap_width = new_pmap_height = 0;
439 }
440 else
441 {
442 result = original_asim;
443
444 if (w != original_asim->width
445 || h != original_asim->height)
446 {
447 result = scale_asimage (asv, original_asim,
448 w, h,
449 ASA_XImage,
450 100, ASIMAGE_QUALITY_DEFAULT);
451 }
452
453 if (background == NULL)
454 {
455 if (bg_flags & BG_TILE)
456 {
457 /* if tiling - pixmap has to be sized exactly as the image,
458 but there is no need to make it bigger than the window! */
459 new_pmap_width = min (result->width, target_width);
460 new_pmap_height = min (result->height, target_height);
461
462 /* we also need to tile our image in both directions */
463 ASImage *tmp = tile_asimage (asv, result,
464 (int)result->width - x,
465 (int)result->height - y,
466 new_pmap_width,
467 new_pmap_height,
468 TINT_LEAVE_SAME, ASA_XImage,
469 100, ASIMAGE_QUALITY_DEFAULT);
470 if (tmp)
471 {
472 if (result != original_asim)
473 destroy_asimage (&result);
474
475 result = tmp;
476 }
477 }
478 }
479 else
480 {
481 /* if blending background and image - pixmap has to be sized same as target window */
482 ASImageLayer *layers = create_image_layers (2);
483
484 layers[0].im = background;
485 layers[0].clip_width = target_width;
486 layers[0].clip_height = target_height;
487 layers[0].tint = background_tint;
488 layers[1].im = result;
489
490 if (bg_flags & BG_TILE)
491 {
492 /* tile horizontally */
493 while (x > 0) x -= (int)result->width;
494 layers[1].dst_x = x;
495 layers[1].clip_width = result->width+target_width;
496 }
497 else
498 {
499 /* clip horizontally */
500 layers[1].dst_x = x;
501 layers[1].clip_width = result->width;
502 }
503
504 if (bg_flags & BG_TILE)
505 {
506 while (y > 0) y -= (int)result->height;
507 layers[1].dst_y = y;
508 layers[1].clip_height = result->height + target_height;
509 }
510 else
511 {
512 layers[1].dst_y = y;
513 layers[1].clip_height = result->height;
514 }
515
516 if (rs[Rs_blendtype])
517 {
518 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
519 if (layers[1].merge_scanlines == NULL)
520 layers[1].merge_scanlines = alphablend_scanlines;
521 }
522
523 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
524 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
525
526 if (tmp)
527 {
528 if (result != original_asim)
529 destroy_asimage (&result);
530
531 result = tmp;
532 }
533
534 free (layers);
535 }
536 }
537
538 bool ret = false;
539
540 if (result)
541 {
542 XGCValues gcv;
543 GC gc;
544
545 /* create Pixmap */
546 if (bg_pixmap == None
547 || bg_pmap_width != new_pmap_width
548 || bg_pmap_height != new_pmap_height)
549 {
550 if (bg_pixmap)
551 XFreePixmap (dpy, bg_pixmap);
552 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
553 bg_pmap_width = new_pmap_width;
554 bg_pmap_height = new_pmap_height;
555 }
556 /* fill with background color (if result's not completely overlapping it) */
557 gcv.foreground = pix_colors[Color_bg];
558 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
559
560 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
561 int dst_width = result->width, dst_height = result->height;
562 if (background == NULL)
563 {
564 if (!(bg_flags & BG_TILE))
565 {
566 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
567 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
568 }
569
570 if (dst_x > 0 || dst_y > 0
571 || dst_x + dst_width < new_pmap_width
572 || dst_y + dst_height < new_pmap_height)
573 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
574 }
575
576 /* put result on pixmap */
577 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
578 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
579
580 if (result != background && result != original_asim)
581 destroy_asimage (&result);
582
583 XFreeGC (dpy, gc);
584
585 ret = true;
586 }
587
588 if (background)
589 destroy_asimage (&background);
590
591 return ret;
592}
593# endif /* HAVE_AFTERIMAGE */
594
595# ifdef HAVE_PIXBUF
596bool
597rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
598 int src_x, int src_y, int dst_x, int dst_y,
599 unsigned int width, unsigned int height)
600{
601 XImage *ximage;
602 char *data, *line;
603 int bytes_per_pixel;
604 int width_r, width_g, width_b;
605 int sh_r, sh_g, sh_b;
606 int rowstride;
607 int channels;
608 unsigned char *row;
609
610 if (visual->c_class != TrueColor)
611 return false;
612
613 if (depth == 24 || depth == 32)
614 bytes_per_pixel = 4;
615 else if (depth == 15 || depth == 16)
616 bytes_per_pixel = 2;
617 else
618 return false;
619
620 width_r = ecb_popcount32 (visual->red_mask);
621 width_g = ecb_popcount32 (visual->green_mask);
622 width_b = ecb_popcount32 (visual->blue_mask);
623
624 if (width_r > 8 || width_g > 8 || width_b > 8)
625 return false;
626
627 sh_r = ecb_ctz32 (visual->red_mask);
628 sh_g = ecb_ctz32 (visual->green_mask);
629 sh_b = ecb_ctz32 (visual->blue_mask);
630
631 if (width > INT_MAX / height / bytes_per_pixel)
632 return false;
633
634 data = (char *)malloc (width * height * bytes_per_pixel);
635 if (!data)
636 return false;
637
638 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
639 width, height, bytes_per_pixel * 8, 0);
640 if (!ximage)
641 {
642 free (data);
643 return false;
644 }
645
646 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
647
648 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
649 channels = gdk_pixbuf_get_n_channels (pixbuf);
650 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
651 line = data;
652
653 for (int y = 0; y < height; y++)
654 {
655 for (int x = 0; x < width; x++)
656 {
657 unsigned char *pixel = row + x * channels;
658 uint32_t value;
659
660 value = ((pixel[0] >> (8 - width_r)) << sh_r)
661 | ((pixel[1] >> (8 - width_g)) << sh_g)
662 | ((pixel[2] >> (8 - width_b)) << sh_b);
663
664 if (bytes_per_pixel == 4)
665 ((uint32_t *)line)[x] = value;
666 else
667 ((uint16_t *)line)[x] = value;
668 }
669
670 row += rowstride;
671 line += ximage->bytes_per_line;
672 }
673
674 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
675 XDestroyImage (ximage);
676 return true;
677}
678
679bool
680rxvt_term::render_image (unsigned long tr_flags)
681{
682 if (!pixbuf)
683 return false;
684
685 if (tr_flags
686 && !(bg_flags & BG_HAS_RENDER))
687 return false;
688
689 GdkPixbuf *result;
690
691 int image_width = gdk_pixbuf_get_width (pixbuf);
692 int image_height = gdk_pixbuf_get_height (pixbuf);
693
694 int target_width = szHint.width;
695 int target_height = szHint.height;
696 int new_pmap_width = target_width;
697 int new_pmap_height = target_height;
698
699 int x = 0;
700 int y = 0;
701 int w = 0;
702 int h = 0;
703
704 get_image_geometry (image_width, image_height, w, h, x, y);
705
706 if (!(bg_flags & BG_ROOT_ALIGN) 486 if (!(image.flags & IM_ROOT_ALIGN)
707 && (x >= target_width 487 && (x >= target_width
708 || y >= target_height 488 || y >= target_height
709 || x + w <= 0 489 || x + w <= 0
710 || y + h <= 0)) 490 || y + h <= 0))
711 return false; 491 return false;
… …
725 505
726 bool ret = false; 506 bool ret = false;
727 507
728 XGCValues gcv; 508 XGCValues gcv;
729 GC gc; 509 GC gc;
730 Pixmap root_pmap; 510 Pixmap tmp_pixmap;
731 511
732 image_width = gdk_pixbuf_get_width (result); 512 image_width = gdk_pixbuf_get_width (result);
733 image_height = gdk_pixbuf_get_height (result); 513 image_height = gdk_pixbuf_get_height (result);
734 514
735 if (tr_flags) 515 if (need_blend)
736 { 516 {
737 root_pmap = bg_pixmap; 517 tmp_pixmap = bg_pixmap;
738 bg_pixmap = None; 518 bg_pixmap = None;
739 } 519 }
740 else 520 else
741 { 521 {
742 if (bg_flags & BG_TILE) 522 if (image.flags & IM_TILE)
743 { 523 {
744 new_pmap_width = min (image_width, target_width); 524 new_pmap_width = min (image_width, target_width);
745 new_pmap_height = min (image_height, target_height); 525 new_pmap_height = min (image_height, target_height);
746 } 526 }
747 } 527 }
… …
760 gcv.foreground = pix_colors[Color_bg]; 540 gcv.foreground = pix_colors[Color_bg];
761 gc = XCreateGC (dpy, vt, GCForeground, &gcv); 541 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
762 542
763 if (gc) 543 if (gc)
764 { 544 {
765 if (bg_flags & BG_TILE) 545 if (image.flags & IM_TILE)
766 { 546 {
767 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth); 547 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
768 pixbuf_to_pixmap (result, tile, gc, 548 pixbuf_to_pixmap (result, tile, gc,
769 0, 0, 549 0, 0,
770 0, 0, 550 0, 0,
… …
798 dst_x, dst_y, 578 dst_x, dst_y,
799 dst_width, dst_height); 579 dst_width, dst_height);
800 } 580 }
801 581
802#if XRENDER 582#if XRENDER
803 if (tr_flags) 583 if (need_blend)
804 { 584 {
805 XRenderPictureAttributes pa;
806
807 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 585 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
586
808 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 587 Picture src = XRenderCreatePicture (dpy, tmp_pixmap, format, 0, 0);
809 588
810 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
811 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 589 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
812 590
813 pa.repeat = True; 591 Picture mask = create_xrender_mask (dpy, vt, False, False);
814 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
815 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
816 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
817 XFreePixmap (dpy, mask_pmap);
818 592
819 XRenderColor mask_c; 593 XRenderColor mask_c;
820 594
821 mask_c.alpha = 0x8000; 595 mask_c.alpha = 0x8000;
822 mask_c.red = 0; 596 mask_c.red =
823 mask_c.green = 0; 597 mask_c.green =
824 mask_c.blue = 0; 598 mask_c.blue = 0;
825 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 599 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
600
826 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 601 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
827 602
828 XRenderFreePicture (dpy, src); 603 XRenderFreePicture (dpy, src);
829 XRenderFreePicture (dpy, dst); 604 XRenderFreePicture (dpy, dst);
830 XRenderFreePicture (dpy, mask); 605 XRenderFreePicture (dpy, mask);
… …
837 } 612 }
838 613
839 if (result != pixbuf) 614 if (result != pixbuf)
840 g_object_unref (result); 615 g_object_unref (result);
841 616
842 if (tr_flags) 617 if (need_blend)
843 XFreePixmap (dpy, root_pmap); 618 XFreePixmap (dpy, tmp_pixmap);
844 619
845 return ret; 620 return ret;
846} 621}
847# endif /* HAVE_PIXBUF */ 622# endif /* HAVE_PIXBUF */
848 623
849bool 624bool
850rxvt_term::bg_set_file (const char *file) 625rxvt_image::set_file (const char *file)
851{ 626{
852 if (!file || !*file) 627 if (!file || !*file)
853 return false; 628 return false;
854 629
855 bool ret = false; 630 bool ret = false;
… …
862 memcpy (f, file, len); 637 memcpy (f, file, len);
863 f[len] = '\0'; 638 f[len] = '\0';
864 file = f; 639 file = f;
865 } 640 }
866 641
867# ifdef HAVE_AFTERIMAGE
868 if (!asimman)
869 asimman = create_generic_imageman (rs[Rs_path]);
870 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
871 if (image)
872 {
873 if (original_asim)
874 safe_asimage_destroy (original_asim);
875 original_asim = image;
876 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
877 ret = true;
878 }
879# endif
880
881# ifdef HAVE_PIXBUF 642# ifdef HAVE_PIXBUF
882 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 643 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
883 if (image) 644 if (image)
884 { 645 {
885 if (pixbuf) 646 if (pixbuf)
886 g_object_unref (pixbuf); 647 g_object_unref (pixbuf);
887 pixbuf = image; 648 pixbuf = image;
888 bg_flags |= BG_IS_FROM_FILE;
889 ret = true; 649 ret = true;
890 } 650 }
891# endif 651# endif
892 652
893 if (ret) 653 if (ret)
894 { 654 {
655 flags = IM_IS_SET | IM_IS_SIZE_SENSITIVE;
656 h_scale = v_scale = defaultScale;
657 h_align = v_align = defaultAlign;
658
895 if (p) 659 if (p)
896 bg_set_geometry (p + 1); 660 set_geometry (p + 1);
897 else
898 bg_set_default_geometry ();
899 } 661 }
900 662
901 return ret; 663 return ret;
902} 664}
903 665
904# endif /* BG_IMAGE_FROM_FILE */ 666# endif /* BG_IMAGE_FROM_FILE */
905 667
906# ifdef ENABLE_TRANSPARENCY 668# ifdef ENABLE_TRANSPARENCY
907bool
908rxvt_term::bg_set_transparent ()
909{
910 if (!(bg_flags & BG_IS_TRANSPARENT))
911 {
912 bg_flags |= BG_IS_TRANSPARENT;
913 return true;
914 }
915
916 return false;
917}
918
919bool 669bool
920rxvt_term::bg_set_blur (const char *geom) 670rxvt_term::bg_set_blur (const char *geom)
921{ 671{
922 bool changed = false; 672 bool changed = false;
923 unsigned int hr, vr; 673 unsigned int hr, vr;
… …
942 { 692 {
943 changed = true; 693 changed = true;
944 v_blurRadius = vr; 694 v_blurRadius = vr;
945 } 695 }
946 696
947 if (v_blurRadius == 0 && h_blurRadius == 0)
948 bg_flags &= ~BG_NEEDS_BLUR;
949 else
950 bg_flags |= BG_NEEDS_BLUR;
951
952 return changed; 697 return changed;
953} 698}
954 699
955void 700bool
956rxvt_term::set_tint_shade_flags () 701rxvt_term::bg_set_tint (rxvt_color &new_tint)
957{ 702{
958 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 703 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
959 bool has_shade = shade != 100; 704 {
960 705 tint = new_tint;
961 bg_flags &= ~BG_TINT_FLAGS; 706 bg_flags |= BG_TINT_SET;
962 707
963 if (bg_flags & BG_TINT_SET) 708 rgba c;
964 {
965 tint.get (c); 709 tint.get (c);
966 if (!has_shade
967 && (c.r <= 0x00ff || c.r >= 0xff00) 710 if ((c.r <= 0x00ff || c.r >= 0xff00)
968 && (c.g <= 0x00ff || c.g >= 0xff00) 711 && (c.g <= 0x00ff || c.g >= 0xff00)
969 && (c.b <= 0x00ff || c.b >= 0xff00)) 712 && (c.b <= 0x00ff || c.b >= 0xff00))
970 bg_flags |= BG_TINT_BITAND; 713 bg_flags |= BG_TINT_BITAND;
971 } 714 else
972
973 if (has_shade || (bg_flags & BG_TINT_SET))
974 bg_flags |= BG_NEEDS_TINT;
975}
976
977bool
978rxvt_term::bg_set_tint (rxvt_color &new_tint)
979{
980 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
981 {
982 tint = new_tint;
983 bg_flags |= BG_TINT_SET; 715 bg_flags &= ~BG_TINT_BITAND;
984 set_tint_shade_flags (); 716
985 return true; 717 return true;
986 } 718 }
987 719
988 return false; 720 return false;
989} 721}
990 722
991bool 723bool
992rxvt_term::bg_set_shade (const char *shade_str) 724rxvt_term::bg_set_shade (const char *shade_str)
993{ 725{
994 int new_shade = (shade_str) ? atoi (shade_str) : 100; 726 int new_shade = atoi (shade_str);
995 727
996 clamp_it (new_shade, -100, 200); 728 clamp_it (new_shade, -100, 200);
997 if (new_shade < 0) 729 if (new_shade < 0)
998 new_shade = 200 - (100 + new_shade); 730 new_shade = 200 - (100 + new_shade);
999 731
1000 if (new_shade != shade) 732 if (new_shade != shade)
1001 { 733 {
1002 shade = new_shade; 734 shade = new_shade;
1003 set_tint_shade_flags ();
1004 return true; 735 return true;
1005 } 736 }
1006 737
1007 return false; 738 return false;
1008} 739}
… …
1029 params[i+2] = XDoubleToFixed (kernel[i] / sum); 760 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1030} 761}
1031#endif 762#endif
1032 763
1033bool 764bool
1034rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 765rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1035{ 766{
1036 bool ret = false; 767 bool ret = false;
1037#if XRENDER 768#if XRENDER
769 if (!(bg_flags & BG_HAS_RENDER_CONV))
770 return false;
771
1038 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 772 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1039 double *kernel = (double *)malloc (size * sizeof (double)); 773 double *kernel = (double *)malloc (size * sizeof (double));
1040 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 774 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1041 775
1042 XRenderPictureAttributes pa; 776 XRenderPictureAttributes pa;
1043 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 777 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1044 778
779 pa.repeat = RepeatPad;
1045 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 780 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
781 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1046 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 782 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
783 XFreePixmap (dpy, tmp);
1047 784
1048 if (kernel && params) 785 if (kernel && params)
1049 { 786 {
1050 if (h_blurRadius)
1051 {
1052 size = h_blurRadius * 2 + 1; 787 size = h_blurRadius * 2 + 1;
1053 get_gaussian_kernel (h_blurRadius, size, kernel, params); 788 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1054 789
1055 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 790 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1056 XRenderComposite (dpy, 791 XRenderComposite (dpy,
1057 PictOpSrc, 792 PictOpSrc,
1058 src, 793 src,
1059 None, 794 None,
1060 dst, 795 dst,
1061 0, 0, 796 0, 0,
1062 0, 0, 797 0, 0,
1063 0, 0, 798 0, 0,
1064 width, height); 799 width, height);
1065 }
1066 800
1067 if (v_blurRadius) 801 ::swap (src, dst);
1068 { 802
1069 size = v_blurRadius * 2 + 1; 803 size = v_blurRadius * 2 + 1;
1070 get_gaussian_kernel (v_blurRadius, size, kernel, params); 804 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1071 ::swap (params[0], params[1]); 805 ::swap (params[0], params[1]);
1072 806
1073 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 807 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1074 XRenderComposite (dpy, 808 XRenderComposite (dpy,
1075 PictOpSrc, 809 PictOpSrc,
1076 src, 810 src,
1077 None, 811 None,
1078 dst, 812 dst,
1079 0, 0, 813 0, 0,
1080 0, 0, 814 0, 0,
1081 0, 0, 815 0, 0,
1082 width, height); 816 width, height);
1083 }
1084 817
1085 ret = true; 818 ret = true;
1086 } 819 }
1087 820
1088 free (kernel); 821 free (kernel);
… …
1092#endif 825#endif
1093 return ret; 826 return ret;
1094} 827}
1095 828
1096bool 829bool
1097rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 830rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1098{ 831{
1099 bool ret = false; 832 bool ret = false;
1100 833
1101 if (bg_flags & BG_TINT_BITAND) 834 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1102 { 835 {
1103 XGCValues gcv; 836 XGCValues gcv;
1104 GC gc; 837 GC gc;
1105 838
1106 /* In this case we can tint image server-side getting significant 839 /* In this case we can tint image server-side getting significant
… …
1115 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 848 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1116 ret = true; 849 ret = true;
1117 XFreeGC (dpy, gc); 850 XFreeGC (dpy, gc);
1118 } 851 }
1119 } 852 }
1120 else
1121 {
1122# if XRENDER 853# if XRENDER
854 else if (bg_flags & BG_HAS_RENDER)
855 {
1123 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 856 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1124 857
1125 if (bg_flags & BG_TINT_SET) 858 if (bg_flags & BG_TINT_SET)
1126 tint.get (c); 859 tint.get (c);
1127 860
… …
1136 c.r = c.r * (200 - shade) / 100; 869 c.r = c.r * (200 - shade) / 100;
1137 c.g = c.g * (200 - shade) / 100; 870 c.g = c.g * (200 - shade) / 100;
1138 c.b = c.b * (200 - shade) / 100; 871 c.b = c.b * (200 - shade) / 100;
1139 } 872 }
1140 873
1141 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1142 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 874 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1143 XRenderPictureAttributes pa;
1144 875
1145 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 876 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1146 877
1147 pa.repeat = True; 878 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1148 879
1149 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 880 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1150 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1151 XFreePixmap (dpy, overlay_pmap);
1152
1153 pa.component_alpha = True;
1154 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1155 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1156 XFreePixmap (dpy, mask_pmap);
1157 881
1158 XRenderColor mask_c; 882 XRenderColor mask_c;
1159 883
1160 mask_c.alpha = 0xffff; 884 mask_c.alpha = 0xffff;
1161 mask_c.red = 885 mask_c.red =
… …
1166 mask_c.alpha = 0; 890 mask_c.alpha = 0;
1167 mask_c.red = 0xffff - c.r; 891 mask_c.red = 0xffff - c.r;
1168 mask_c.green = 0xffff - c.g; 892 mask_c.green = 0xffff - c.g;
1169 mask_c.blue = 0xffff - c.b; 893 mask_c.blue = 0xffff - c.b;
1170 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 894 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
895
1171 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 896 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1172 897
1173 if (shade > 100) 898 if (shade > 100)
1174 { 899 {
1175 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1176 mask_c.alpha = 0; 900 mask_c.alpha = 0;
901 mask_c.red =
902 mask_c.green =
903 mask_c.blue = 0xffff * (shade - 100) / 100;
1177 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 904 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1178 905
1179 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 906 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1180 } 907 }
1181 908
1182 ret = true; 909 ret = true;
1183 910
1184 XRenderFreePicture (dpy, mask_pic); 911 XRenderFreePicture (dpy, mask_pic);
1185 XRenderFreePicture (dpy, overlay_pic); 912 XRenderFreePicture (dpy, overlay_pic);
1186 XRenderFreePicture (dpy, back_pic); 913 XRenderFreePicture (dpy, back_pic);
914 }
1187# endif 915# endif
1188 }
1189 916
1190 return ret; 917 return ret;
1191} 918}
1192 919
1193/* 920/*
1194 * Builds a pixmap of the same size as the terminal window that contains 921 * Builds a pixmap of the same size as the terminal window that contains
1195 * the tiled portion of the root pixmap that is supposed to be covered by 922 * the tiled portion of the root pixmap that is supposed to be covered by
1196 * our window. 923 * our window.
1197 */ 924 */
1198unsigned long 925bool
1199rxvt_term::make_transparency_pixmap () 926rxvt_term::make_transparency_pixmap ()
1200{ 927{
1201 unsigned long result = 0; 928 bool ret = false;
1202 929
1203 /* root dimensions may change from call to call - but Display structure should 930 /* root dimensions may change from call to call - but Display structure should
1204 * be always up-to-date, so let's use it : 931 * be always up-to-date, so let's use it :
1205 */ 932 */
1206 int screen = display->screen; 933 int screen = display->screen;
… …
1244#if XRENDER 971#if XRENDER
1245 if (bg_flags & BG_HAS_RENDER) 972 if (bg_flags & BG_HAS_RENDER)
1246 { 973 {
1247 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 974 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1248 975
1249 XRenderPictureAttributes pa;
1250
1251 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 976 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1252 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 977 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1253 978
1254 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 979 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1255 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 980 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1256 981
1257 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 982 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1258 983
1259 XRenderFreePicture (dpy, src); 984 XRenderFreePicture (dpy, src);
1260 XRenderFreePicture (dpy, dst); 985 XRenderFreePicture (dpy, dst);
… …
1289 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1014 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1290 1015
1291 if (gc) 1016 if (gc)
1292 { 1017 {
1293 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1018 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1294 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1019 ret = true;
1020 bool need_blur = h_blurRadius && v_blurRadius;
1021 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1022
1023 if (!(bg_flags & BG_CLIENT_RENDER))
1024 {
1025 if (need_blur)
1026 {
1027 if (blur_pixmap (bg_pixmap, window_width, window_height))
1028 need_blur = false;
1029 }
1030 if (need_tint)
1031 {
1032 if (tint_pixmap (bg_pixmap, window_width, window_height))
1033 need_tint = false;
1034 }
1035 if (need_tint)
1036 {
1037 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1038 if (ximage)
1039 {
1040 /* our own client-side tinting */
1041 tint_ximage (ximage);
1042
1043 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1044 XDestroyImage (ximage);
1045 }
1046 }
1047 } /* server side rendering completed */
1048
1295 XFreeGC (dpy, gc); 1049 XFreeGC (dpy, gc);
1296
1297 if (!(bg_flags & BG_CLIENT_RENDER))
1298 {
1299 if ((bg_flags & BG_NEEDS_BLUR)
1300 && (bg_flags & BG_HAS_RENDER_CONV))
1301 {
1302 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1303 result &= ~BG_NEEDS_BLUR;
1304 }
1305 if ((bg_flags & BG_NEEDS_TINT)
1306 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1307 {
1308 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1309 result &= ~BG_NEEDS_TINT;
1310 }
1311 } /* server side rendering completed */
1312 } 1050 }
1313 1051
1314 if (recoded_root_pmap != root_pixmap) 1052 if (recoded_root_pmap != root_pixmap)
1315 XFreePixmap (dpy, recoded_root_pmap); 1053 XFreePixmap (dpy, recoded_root_pmap);
1316 1054
1317 return result; 1055 return ret;
1318} 1056}
1319 1057
1320void 1058void
1321rxvt_term::bg_set_root_pixmap () 1059rxvt_term::bg_set_root_pixmap ()
1322{ 1060{
… …
1326 1064
1327 root_pixmap = new_root_pixmap; 1065 root_pixmap = new_root_pixmap;
1328} 1066}
1329# endif /* ENABLE_TRANSPARENCY */ 1067# endif /* ENABLE_TRANSPARENCY */
1330 1068
1331#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1332static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1333# endif
1334
1335bool 1069bool
1336rxvt_term::bg_render () 1070rxvt_term::bg_render ()
1337{ 1071{
1338 unsigned long tr_flags = 0;
1339
1340 bg_invalidate (); 1072 bg_invalidate ();
1341# ifdef ENABLE_TRANSPARENCY 1073# ifdef ENABLE_TRANSPARENCY
1342 if (bg_flags & BG_IS_TRANSPARENT) 1074 if (bg_flags & BG_IS_TRANSPARENT)
1343 { 1075 {
1344 /* we need to re-generate transparency pixmap in that case ! */ 1076 /* we need to re-generate transparency pixmap in that case ! */
1345 tr_flags = make_transparency_pixmap (); 1077 if (make_transparency_pixmap ())
1346 if (tr_flags == 0)
1347 return false;
1348 bg_flags |= BG_IS_VALID; 1078 bg_flags |= BG_IS_VALID;
1349 } 1079 }
1350# endif 1080# endif
1351 1081
1352# ifdef BG_IMAGE_FROM_FILE 1082# ifdef BG_IMAGE_FROM_FILE
1353 if ((bg_flags & BG_IS_FROM_FILE) 1083 if (bg_image.flags & IM_IS_SET)
1354 || (tr_flags & BG_EFFECTS_FLAGS))
1355 { 1084 {
1356 if (render_image (tr_flags)) 1085 if (render_image (bg_image))
1357 bg_flags |= BG_IS_VALID; 1086 bg_flags |= BG_IS_VALID;
1358 }
1359# endif
1360
1361# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1362 XImage *result = NULL;
1363
1364 if (tr_flags & BG_NEEDS_TINT)
1365 {
1366 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1367 }
1368
1369 if (result)
1370 {
1371 /* our own client-side tinting */
1372 //if (tr_flags & BG_NEEDS_TINT)
1373 if (1)
1374 {
1375 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1376 if (bg_flags & BG_TINT_SET)
1377 tint.get (c);
1378 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1379 }
1380
1381 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1382
1383 if (gc)
1384 {
1385 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1386
1387 XFreeGC (dpy, gc);
1388 }
1389
1390 XDestroyImage (result);
1391 } 1087 }
1392# endif 1088# endif
1393 1089
1394 if (!(bg_flags & BG_IS_VALID)) 1090 if (!(bg_flags & BG_IS_VALID))
1395 { 1091 {
… …
1432#endif 1128#endif
1433} 1129}
1434 1130
1435#endif /* HAVE_BG_PIXMAP */ 1131#endif /* HAVE_BG_PIXMAP */
1436 1132
1437#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1133#ifdef ENABLE_TRANSPARENCY
1438/* based on code from aterm-0.4.2 */ 1134/* based on code from aterm-0.4.2 */
1439 1135
1440static inline void 1136static inline void
1441fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high) 1137fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1442{ 1138{
… …
1447 tmp += (mask >> sh) * low; 1143 tmp += (mask >> sh) * low;
1448 lookup[i] = (tmp / 0xffff) << sh; 1144 lookup[i] = (tmp / 0xffff) << sh;
1449 } 1145 }
1450} 1146}
1451 1147
1452static void 1148void
1453shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1149rxvt_term::tint_ximage (XImage *ximage)
1454{ 1150{
1151 unsigned int size_r, size_g, size_b;
1455 int sh_r, sh_g, sh_b; 1152 int sh_r, sh_g, sh_b;
1456 uint32_t mask_r, mask_g, mask_b; 1153 uint32_t mask_r, mask_g, mask_b;
1457 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1154 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1458 rgba low; 1155 unsigned short low;
1459 rgba high;
1460 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1156 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1461 1157
1462 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1158 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1463 1159
1464 /* for convenience */ 1160 /* for convenience */
1465 mask_r = visual->red_mask; 1161 mask_r = visual->red_mask;
1466 mask_g = visual->green_mask; 1162 mask_g = visual->green_mask;
1467 mask_b = visual->blue_mask; 1163 mask_b = visual->blue_mask;
1468 1164
1469 /* boring lookup table pre-initialization */ 1165 /* boring lookup table pre-initialization */
1470 switch (ximage->depth) 1166 sh_r = ecb_ctz32 (mask_r);
1471 { 1167 sh_g = ecb_ctz32 (mask_g);
1472 case 15: 1168 sh_b = ecb_ctz32 (mask_b);
1473 if ((mask_r != 0x7c00) || 1169
1474 (mask_g != 0x03e0) || 1170 size_r = mask_r >> sh_r;
1475 (mask_b != 0x001f)) 1171 size_g = mask_g >> sh_g;
1172 size_b = mask_b >> sh_b;
1173
1174 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1476 return; 1175 return;
1477 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1176
1177 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1478 lookup_r = lookup; 1178 lookup_r = lookup;
1479 lookup_g = lookup+32; 1179 lookup_g = lookup + size_r;
1480 lookup_b = lookup+32+32; 1180 lookup_b = lookup + size_r + size_g;
1481 sh_r = 10; 1181
1482 sh_g = 5; 1182 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1483 sh_b = 0; 1183
1484 break; 1184 if (bg_flags & BG_TINT_SET)
1485 case 16: 1185 tint.get (c);
1486 if ((mask_r != 0xf800) ||
1487 (mask_g != 0x07e0) ||
1488 (mask_b != 0x001f))
1489 return;
1490 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1491 lookup_r = lookup;
1492 lookup_g = lookup+32;
1493 lookup_b = lookup+32+64;
1494 sh_r = 11;
1495 sh_g = 5;
1496 sh_b = 0;
1497 break;
1498 case 24:
1499 if ((mask_r != 0xff0000) ||
1500 (mask_g != 0x00ff00) ||
1501 (mask_b != 0x0000ff))
1502 return;
1503 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1504 lookup_r = lookup;
1505 lookup_g = lookup+256;
1506 lookup_b = lookup+256+256;
1507 sh_r = 16;
1508 sh_g = 8;
1509 sh_b = 0;
1510 break;
1511 case 32:
1512 if ((mask_r != 0xff0000) ||
1513 (mask_g != 0x00ff00) ||
1514 (mask_b != 0x0000ff))
1515 return;
1516 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1517 lookup_r = lookup;
1518 lookup_g = lookup+256;
1519 lookup_b = lookup+256+256;
1520 sh_r = 16;
1521 sh_g = 8;
1522 sh_b = 0;
1523 break;
1524 default:
1525 return; /* we do not support this color depth */
1526 }
1527 1186
1528 /* prepare limits for color transformation (each channel is handled separately) */ 1187 /* prepare limits for color transformation (each channel is handled separately) */
1529 if (shade > 100) 1188 if (shade > 100)
1530 { 1189 {
1531 shade = 200 - shade;
1532
1533 high.r = c.r * shade / 100;
1534 high.g = c.g * shade / 100;
1535 high.b = c.b * shade / 100;
1536
1537 low.r = 65535 * (100 - shade) / 100; 1190 c.r = c.r * (200 - shade) / 100;
1538 low.g = 65535 * (100 - shade) / 100; 1191 c.g = c.g * (200 - shade) / 100;
1539 low.b = 65535 * (100 - shade) / 100; 1192 c.b = c.b * (200 - shade) / 100;
1193
1194 low = 0xffff * (shade - 100) / 100;
1540 } 1195 }
1541 else 1196 else
1542 { 1197 {
1543 high.r = c.r * shade / 100; 1198 c.r = c.r * shade / 100;
1544 high.g = c.g * shade / 100; 1199 c.g = c.g * shade / 100;
1545 high.b = c.b * shade / 100; 1200 c.b = c.b * shade / 100;
1546 1201
1547 low.r = low.g = low.b = 0; 1202 low = 0;
1548 } 1203 }
1549 1204
1550 /* fill our lookup tables */ 1205 /* fill our lookup tables */
1551 fill_lut (lookup_r, mask_r, sh_r, low.r, high.r); 1206 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1552 fill_lut (lookup_g, mask_g, sh_g, low.g, high.g); 1207 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1553 fill_lut (lookup_b, mask_b, sh_b, low.b, high.b); 1208 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1554 1209
1555 /* apply table to input image (replacing colors by newly calculated ones) */ 1210 /* apply table to input image (replacing colors by newly calculated ones) */
1556 if (ximage->bits_per_pixel == 32 1211 if (ximage->bits_per_pixel == 32
1557 && (ximage->depth == 24 || ximage->depth == 32)
1558 && ximage->byte_order == host_byte_order) 1212 && ximage->byte_order == host_byte_order)
1559 { 1213 {
1560 uint32_t *p1, *pf, *p, *pl; 1214 char *line = ximage->data;
1561 p1 = (uint32_t *) ximage->data;
1562 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1563 1215
1564 while (p1 < pf) 1216 for (int y = 0; y < ximage->height; y++)
1565 {
1566 p = p1;
1567 pl = p1 + ximage->width;
1568 for (; p < pl; p++)
1569 { 1217 {
1570 *p = lookup_r[(*p & 0xff0000) >> 16] | 1218 uint32_t *p = (uint32_t *)line;
1571 lookup_g[(*p & 0x00ff00) >> 8] | 1219 for (int x = 0; x < ximage->width; x++)
1572 lookup_b[(*p & 0x0000ff)] |
1573 (*p & 0xff000000);
1574 } 1220 {
1575 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1221 *p = lookup_r[(*p & mask_r) >> sh_r] |
1222 lookup_g[(*p & mask_g) >> sh_g] |
1223 lookup_b[(*p & mask_b) >> sh_b];
1224 p++;
1225 }
1226 line += ximage->bytes_per_line;
1576 } 1227 }
1577 } 1228 }
1578 else 1229 else
1579 { 1230 {
1580 for (int y = 0; y < ximage->height; y++) 1231 for (int y = 0; y < ximage->height; y++)
… …
1588 } 1239 }
1589 } 1240 }
1590 1241
1591 free (lookup); 1242 free (lookup);
1592} 1243}
1593#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1244#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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