1 |
/*----------------------------------------------------------------------* |
2 |
* File: background.C |
3 |
*----------------------------------------------------------------------* |
4 |
* |
5 |
* All portions of code are copyright by their respective author/s. |
6 |
* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de> |
7 |
* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net> |
8 |
* Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it> |
9 |
* |
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 |
12 |
* the Free Software Foundation; either version 2 of the License, or |
13 |
* (at your option) any later version. |
14 |
* |
15 |
* This program is distributed in the hope that it will be useful, |
16 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
17 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
18 |
* GNU General Public License for more details. |
19 |
* |
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 |
22 |
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
23 |
*---------------------------------------------------------------------*/ |
24 |
|
25 |
#include "../config.h" /* NECESSARY */ |
26 |
#include "rxvt.h" /* NECESSARY */ |
27 |
|
28 |
#ifdef HAVE_BG_PIXMAP |
29 |
|
30 |
void |
31 |
rxvt_term::bg_destroy () |
32 |
{ |
33 |
# if BG_IMAGE_FROM_ROOT |
34 |
delete root_img; |
35 |
root_img = 0; |
36 |
# endif |
37 |
|
38 |
# if BG_IMAGE_FROM_FILE |
39 |
fimage.destroy (); |
40 |
# endif |
41 |
} |
42 |
|
43 |
bool |
44 |
rxvt_term::bg_window_size_sensitive () |
45 |
{ |
46 |
# if BG_IMAGE_FROM_ROOT |
47 |
if (root_img) |
48 |
return true; |
49 |
# endif |
50 |
|
51 |
# if BG_IMAGE_FROM_FILE |
52 |
if (fimage.img) |
53 |
{ |
54 |
if ((fimage.flags & IM_IS_SIZE_SENSITIVE) |
55 |
|| fimage.img->w > szHint.width |
56 |
|| fimage.img->h > szHint.height) |
57 |
return true; |
58 |
} |
59 |
# endif |
60 |
|
61 |
return false; |
62 |
} |
63 |
|
64 |
bool |
65 |
rxvt_term::bg_window_position_sensitive () |
66 |
{ |
67 |
# if BG_IMAGE_FROM_ROOT |
68 |
if (root_img) |
69 |
return true; |
70 |
# endif |
71 |
|
72 |
# if BG_IMAGE_FROM_FILE |
73 |
if (fimage.img) |
74 |
{ |
75 |
if (fimage.flags & IM_ROOT_ALIGN) |
76 |
return true; |
77 |
} |
78 |
# endif |
79 |
|
80 |
return false; |
81 |
} |
82 |
|
83 |
# if BG_IMAGE_FROM_FILE |
84 |
static inline int |
85 |
make_align_position (int align, int window_size, int image_size) |
86 |
{ |
87 |
if (align >= 0 && align <= 100) |
88 |
return lerp (0, window_size - image_size, align); |
89 |
else if (align > 100) |
90 |
return lerp (window_size - image_size, window_size, align - 100); |
91 |
else |
92 |
return lerp (-image_size, 0, align + 100); |
93 |
} |
94 |
|
95 |
static void |
96 |
parse_style (const char *style, int &x, int &y, unsigned int &w, unsigned int &h, uint8_t &flags) |
97 |
{ |
98 |
if (!strcasecmp (style, "tiled")) |
99 |
{ |
100 |
flags = IM_TILE; |
101 |
w = h = noScale; |
102 |
x = y = 0; |
103 |
} |
104 |
else if (!strcasecmp (style, "aspect-stretched")) |
105 |
{ |
106 |
flags = IM_KEEP_ASPECT; |
107 |
w = h = windowScale; |
108 |
x = y = centerAlign; |
109 |
} |
110 |
else if (!strcasecmp (style, "stretched")) |
111 |
{ |
112 |
flags = 0; |
113 |
w = h = windowScale; |
114 |
x = y = centerAlign; |
115 |
} |
116 |
else if (!strcasecmp (style, "centered")) |
117 |
{ |
118 |
flags = 0; |
119 |
w = h = noScale; |
120 |
x = y = centerAlign; |
121 |
} |
122 |
else if (!strcasecmp (style, "root-tiled")) |
123 |
{ |
124 |
flags = IM_TILE|IM_ROOT_ALIGN; |
125 |
w = h = noScale; |
126 |
x = y = 0; |
127 |
} |
128 |
} |
129 |
|
130 |
bool |
131 |
rxvt_image::set_geometry (const char *geom, bool update) |
132 |
{ |
133 |
bool changed = false; |
134 |
int geom_flags = 0; |
135 |
int x = h_align; |
136 |
int y = v_align; |
137 |
unsigned int w = h_scale; |
138 |
unsigned int h = v_scale; |
139 |
uint8_t new_flags = 0; |
140 |
|
141 |
if (geom == NULL) |
142 |
return false; |
143 |
|
144 |
if (geom[0]) |
145 |
{ |
146 |
char **arr = rxvt_strsplit (':', geom); |
147 |
|
148 |
for (int i = 0; arr[i]; i++) |
149 |
{ |
150 |
if (!strncasecmp (arr[i], "style=", 6)) |
151 |
{ |
152 |
parse_style (arr[i] + 6, x, y, w, h, new_flags); |
153 |
geom_flags = WidthValue|HeightValue|XValue|YValue; |
154 |
} |
155 |
else if (!strcasecmp (arr[i], "op=tile")) |
156 |
new_flags |= IM_TILE; |
157 |
else if (!strcasecmp (arr[i], "op=keep-aspect")) |
158 |
new_flags |= IM_KEEP_ASPECT; |
159 |
else if (!strcasecmp (arr[i], "op=root-align")) |
160 |
new_flags |= IM_ROOT_ALIGN; |
161 |
|
162 |
// deprecated |
163 |
else if (!strcasecmp (arr[i], "tile")) |
164 |
{ |
165 |
new_flags |= IM_TILE; |
166 |
w = h = noScale; |
167 |
geom_flags |= WidthValue|HeightValue; |
168 |
} |
169 |
else if (!strcasecmp (arr[i], "propscale")) |
170 |
{ |
171 |
new_flags |= IM_KEEP_ASPECT; |
172 |
w = h = windowScale; |
173 |
geom_flags |= WidthValue|HeightValue; |
174 |
} |
175 |
else if (!strcasecmp (arr[i], "hscale")) |
176 |
{ |
177 |
new_flags |= IM_TILE; |
178 |
w = windowScale; |
179 |
h = noScale; |
180 |
geom_flags |= WidthValue|HeightValue; |
181 |
} |
182 |
else if (!strcasecmp (arr[i], "vscale")) |
183 |
{ |
184 |
new_flags |= IM_TILE; |
185 |
h = windowScale; |
186 |
w = noScale; |
187 |
geom_flags |= WidthValue|HeightValue; |
188 |
} |
189 |
else if (!strcasecmp (arr[i], "scale")) |
190 |
{ |
191 |
w = h = windowScale; |
192 |
geom_flags |= WidthValue|HeightValue; |
193 |
} |
194 |
else if (!strcasecmp (arr[i], "auto")) |
195 |
{ |
196 |
w = h = windowScale; |
197 |
x = y = centerAlign; |
198 |
geom_flags |= WidthValue|HeightValue|XValue|YValue; |
199 |
} |
200 |
else if (!strcasecmp (arr[i], "root")) |
201 |
{ |
202 |
new_flags |= IM_TILE|IM_ROOT_ALIGN; |
203 |
w = h = noScale; |
204 |
geom_flags |= WidthValue|HeightValue; |
205 |
} |
206 |
|
207 |
else |
208 |
geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h); |
209 |
} /* done parsing ops */ |
210 |
|
211 |
rxvt_free_strsplit (arr); |
212 |
} |
213 |
|
214 |
new_flags |= flags & ~IM_GEOMETRY_FLAGS; |
215 |
|
216 |
if (!update) |
217 |
{ |
218 |
if (!(geom_flags & XValue)) |
219 |
x = y = defaultAlign; |
220 |
else if (!(geom_flags & YValue)) |
221 |
y = x; |
222 |
|
223 |
if (!(geom_flags & (WidthValue|HeightValue))) |
224 |
w = h = defaultScale; |
225 |
else if (!(geom_flags & HeightValue)) |
226 |
h = w; |
227 |
else if (!(geom_flags & WidthValue)) |
228 |
w = h; |
229 |
} |
230 |
|
231 |
clamp_it (x, -100, 200); |
232 |
clamp_it (y, -100, 200); |
233 |
|
234 |
if (flags != new_flags |
235 |
|| h_scale != w |
236 |
|| v_scale != h |
237 |
|| h_align != x |
238 |
|| v_align != y) |
239 |
{ |
240 |
flags = new_flags; |
241 |
h_scale = w; |
242 |
v_scale = h; |
243 |
h_align = x; |
244 |
v_align = y; |
245 |
changed = true; |
246 |
} |
247 |
|
248 |
if (is_size_sensitive ()) |
249 |
flags |= IM_IS_SIZE_SENSITIVE; |
250 |
else |
251 |
flags &= ~IM_IS_SIZE_SENSITIVE; |
252 |
|
253 |
return changed; |
254 |
} |
255 |
|
256 |
bool |
257 |
rxvt_term::render_image (rxvt_image &image) |
258 |
{ |
259 |
int image_width = image.img->w; |
260 |
int image_height = image.img->h; |
261 |
int parent_width = szHint.width; |
262 |
int parent_height = szHint.height; |
263 |
int h_scale = min (image.h_scale, 32767 * 100 / parent_width); |
264 |
int v_scale = min (image.v_scale, 32767 * 100 / parent_height); |
265 |
|
266 |
int w; |
267 |
int h; |
268 |
int x; |
269 |
int y; |
270 |
|
271 |
w = h_scale * parent_width / 100; |
272 |
h = v_scale * parent_height / 100; |
273 |
|
274 |
if (image.flags & IM_KEEP_ASPECT) |
275 |
{ |
276 |
float scale = (float)w / image_width; |
277 |
min_it (scale, (float)h / image_height); |
278 |
w = image_width * scale + 0.5; |
279 |
h = image_height * scale + 0.5; |
280 |
} |
281 |
|
282 |
if (!w) w = image_width; |
283 |
if (!h) h = image_height; |
284 |
|
285 |
if (image.flags & IM_ROOT_ALIGN) |
286 |
{ |
287 |
x = -parent_x; |
288 |
y = -parent_y; |
289 |
} |
290 |
else |
291 |
{ |
292 |
x = make_align_position (image.h_align, parent_width, w); |
293 |
y = make_align_position (image.v_align, parent_height, h); |
294 |
} |
295 |
|
296 |
if (!(image.flags & IM_ROOT_ALIGN) |
297 |
&& (x >= parent_width |
298 |
|| y >= parent_height |
299 |
|| x + w <= 0 |
300 |
|| y + h <= 0)) |
301 |
return false; |
302 |
|
303 |
rxvt_img *img = image.img->scale (w, h); |
304 |
|
305 |
if (image.flags & IM_TILE) |
306 |
img->repeat_mode (RepeatNormal); |
307 |
else |
308 |
img->repeat_mode (RepeatNone); |
309 |
img->sub_rect (-x, -y, parent_width, parent_height)->replace (img); |
310 |
|
311 |
if (bg_img) |
312 |
img->draw (bg_img, PictOpOver, image.alpha * 1. / 0xffff); |
313 |
|
314 |
XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); |
315 |
img->convert_format (format, pix_colors [Color_bg])->replace (img); |
316 |
|
317 |
delete bg_img; |
318 |
bg_img = img; |
319 |
|
320 |
return true; |
321 |
} |
322 |
|
323 |
rxvt_image::rxvt_image () |
324 |
{ |
325 |
alpha = 0xffff; |
326 |
flags = 0; |
327 |
h_scale = |
328 |
v_scale = defaultScale; |
329 |
h_align = |
330 |
v_align = defaultAlign; |
331 |
|
332 |
img = 0; |
333 |
} |
334 |
|
335 |
void |
336 |
rxvt_image::set_file_geometry (rxvt_screen *s, const char *file) |
337 |
{ |
338 |
if (!file || !*file) |
339 |
return; |
340 |
|
341 |
const char *p = strchr (file, ';'); |
342 |
|
343 |
if (p) |
344 |
{ |
345 |
size_t len = p - file; |
346 |
char *f = rxvt_temp_buf<char> (len + 1); |
347 |
memcpy (f, file, len); |
348 |
f[len] = '\0'; |
349 |
file = f; |
350 |
} |
351 |
|
352 |
set_file (s, file); |
353 |
alpha = 0x8000; |
354 |
set_geometry (p ? p + 1 : ""); |
355 |
} |
356 |
|
357 |
void |
358 |
rxvt_image::set_file (rxvt_screen *s, const char *file) |
359 |
{ |
360 |
rxvt_img *img2 = rxvt_img::new_from_file (s, file); |
361 |
delete img; |
362 |
img = img2; |
363 |
} |
364 |
|
365 |
# endif /* BG_IMAGE_FROM_FILE */ |
366 |
|
367 |
bool |
368 |
image_effects::set_blur (const char *geom) |
369 |
{ |
370 |
bool changed = false; |
371 |
unsigned int hr, vr; |
372 |
int junk; |
373 |
int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr); |
374 |
|
375 |
if (!(geom_flags & WidthValue)) |
376 |
hr = 1; |
377 |
if (!(geom_flags & HeightValue)) |
378 |
vr = hr; |
379 |
|
380 |
min_it (hr, 128); |
381 |
min_it (vr, 128); |
382 |
|
383 |
if (h_blurRadius != hr) |
384 |
{ |
385 |
changed = true; |
386 |
h_blurRadius = hr; |
387 |
} |
388 |
|
389 |
if (v_blurRadius != vr) |
390 |
{ |
391 |
changed = true; |
392 |
v_blurRadius = vr; |
393 |
} |
394 |
|
395 |
return changed; |
396 |
} |
397 |
|
398 |
bool |
399 |
image_effects::set_tint (const rxvt_color &new_tint) |
400 |
{ |
401 |
if (!tint_set || tint != new_tint) |
402 |
{ |
403 |
tint = new_tint; |
404 |
tint_set = true; |
405 |
|
406 |
return true; |
407 |
} |
408 |
|
409 |
return false; |
410 |
} |
411 |
|
412 |
bool |
413 |
image_effects::set_shade (const char *shade_str) |
414 |
{ |
415 |
int new_shade = atoi (shade_str); |
416 |
|
417 |
clamp_it (new_shade, -100, 200); |
418 |
if (new_shade < 0) |
419 |
new_shade = 200 - (100 + new_shade); |
420 |
|
421 |
if (new_shade != shade) |
422 |
{ |
423 |
shade = new_shade; |
424 |
return true; |
425 |
} |
426 |
|
427 |
return false; |
428 |
} |
429 |
|
430 |
# if BG_IMAGE_FROM_ROOT |
431 |
/* |
432 |
* Builds a pixmap of the same size as the terminal window that contains |
433 |
* the tiled portion of the root pixmap that is supposed to be covered by |
434 |
* our window. |
435 |
*/ |
436 |
bool |
437 |
rxvt_term::render_root_image () |
438 |
{ |
439 |
/* root dimensions may change from call to call - but Display structure should |
440 |
* be always up-to-date, so let's use it : |
441 |
*/ |
442 |
int screen = display->screen; |
443 |
int root_width = DisplayWidth (dpy, screen); |
444 |
int root_height = DisplayHeight (dpy, screen); |
445 |
int parent_width = szHint.width; |
446 |
int parent_height = szHint.height; |
447 |
int sx, sy; |
448 |
|
449 |
sx = parent_x; |
450 |
sy = parent_y; |
451 |
|
452 |
/* check if we are outside of the visible part of the virtual screen : */ |
453 |
if (sx + parent_width <= 0 || sy + parent_height <= 0 |
454 |
|| sx >= root_width || sy >= root_height) |
455 |
return 0; |
456 |
|
457 |
while (sx < 0) sx += root_img->w; |
458 |
while (sy < 0) sy += root_img->h; |
459 |
|
460 |
rxvt_img *img = root_img->sub_rect (sx, sy, parent_width, parent_height); |
461 |
|
462 |
if (root_effects.need_blur ()) |
463 |
img->blur (root_effects.h_blurRadius, root_effects.v_blurRadius)->replace (img); |
464 |
|
465 |
if (root_effects.need_tint ()) |
466 |
tint_image (img, root_effects.tint, root_effects.tint_set, root_effects.shade); |
467 |
|
468 |
XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); |
469 |
img->convert_format (format, pix_colors [Color_bg])->replace (img); |
470 |
|
471 |
delete bg_img; |
472 |
bg_img = img; |
473 |
|
474 |
return true; |
475 |
} |
476 |
# endif /* BG_IMAGE_FROM_ROOT */ |
477 |
|
478 |
void |
479 |
rxvt_term::bg_render () |
480 |
{ |
481 |
if (bg_flags & BG_INHIBIT_RENDER) |
482 |
return; |
483 |
|
484 |
delete bg_img; |
485 |
bg_img = 0; |
486 |
bg_flags = 0; |
487 |
|
488 |
if (!mapped) |
489 |
return; |
490 |
|
491 |
# if BG_IMAGE_FROM_ROOT |
492 |
if (root_img) |
493 |
if (render_root_image ()) |
494 |
bg_flags |= BG_IS_TRANSPARENT; |
495 |
# endif |
496 |
|
497 |
# if BG_IMAGE_FROM_FILE |
498 |
if (fimage.img) |
499 |
render_image (fimage); |
500 |
# endif |
501 |
|
502 |
scr_recolour (false); |
503 |
bg_flags |= BG_NEEDS_REFRESH; |
504 |
|
505 |
bg_valid_since = ev::now (); |
506 |
} |
507 |
|
508 |
void |
509 |
rxvt_term::bg_init () |
510 |
{ |
511 |
#if BG_IMAGE_FROM_ROOT |
512 |
if (option (Opt_transparent)) |
513 |
{ |
514 |
if (rs [Rs_blurradius]) |
515 |
root_effects.set_blur (rs [Rs_blurradius]); |
516 |
|
517 |
if (ISSET_PIXCOLOR (Color_tint)) |
518 |
root_effects.set_tint (pix_colors_focused [Color_tint]); |
519 |
|
520 |
if (rs [Rs_shade]) |
521 |
root_effects.set_shade (rs [Rs_shade]); |
522 |
|
523 |
rxvt_img::new_from_root (this)->replace (root_img); |
524 |
XSelectInput (dpy, display->root, PropertyChangeMask); |
525 |
rootwin_ev.start (display, display->root); |
526 |
} |
527 |
#endif |
528 |
|
529 |
#if BG_IMAGE_FROM_FILE |
530 |
if (rs[Rs_backgroundPixmap]) |
531 |
{ |
532 |
fimage.set_file_geometry (this, rs[Rs_backgroundPixmap]); |
533 |
if (!bg_window_position_sensitive ()) |
534 |
update_background (); |
535 |
} |
536 |
#endif |
537 |
} |
538 |
|
539 |
void |
540 |
rxvt_term::tint_image (rxvt_img *img, rxvt_color &tint, bool tint_set, int shade) |
541 |
{ |
542 |
rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); |
543 |
|
544 |
if (tint_set) |
545 |
tint.get (c); |
546 |
|
547 |
if (shade > 100) |
548 |
{ |
549 |
c.r = c.r * (200 - shade) / 100; |
550 |
c.g = c.g * (200 - shade) / 100; |
551 |
c.b = c.b * (200 - shade) / 100; |
552 |
} |
553 |
else |
554 |
{ |
555 |
c.r = c.r * shade / 100; |
556 |
c.g = c.g * shade / 100; |
557 |
c.b = c.b * shade / 100; |
558 |
} |
559 |
|
560 |
img->contrast (c.r, c.g, c.b, c.a); |
561 |
|
562 |
if (shade > 100) |
563 |
{ |
564 |
c.a = 0xffff; |
565 |
c.r = |
566 |
c.g = |
567 |
c.b = 0xffff * (shade - 100) / 100; |
568 |
img->brightness (c.r, c.g, c.b, c.a); |
569 |
} |
570 |
} |
571 |
|
572 |
#endif /* HAVE_BG_PIXMAP */ |