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

Comparing rxvt-unicode/src/perl/background (file contents):
Revision 1.38 by root, Fri Jun 8 21:48:07 2012 UTC vs.
Revision 1.49 by root, Sun Jun 10 15:29:18 2012 UTC

1#! perl 1#! perl
2 2
3#:META:X_RESOURCE:%.expr:string:background expression 3#:META:X_RESOURCE:%.expr:string:background expression
4#:META:X_RESOURCE:%.border.:boolean:respect the terminal border 4#:META:X_RESOURCE:%.border:boolean:respect the terminal border
5#:META:X_RESOURCE:%.interval:seconds:minimum time between updates
5 6
6#TODO: once, rootalign 7#TODO: once, rootalign
7 8
9=head1 NAME
10
8=head1 background - manage terminal background 11 background - manage terminal background
9 12
10=head2 SYNOPSIS 13=head1 SYNOPSIS
11 14
12 urxvt --background-expr 'background expression' 15 urxvt --background-expr 'background expression'
13 --background-border 16 --background-border
17 --background-interval seconds
14 18
15=head2 DESCRIPTION 19=head1 DESCRIPTION
16 20
17This extension manages the terminal background by creating a picture that 21This extension manages the terminal background by creating a picture that
18is behind the text, replacing the normal background colour. 22is behind the text, replacing the normal background colour.
19 23
20It does so by evaluating a Perl expression that I<calculates> the image on 24It does so by evaluating a Perl expression that I<calculates> the image on
… …
30 34
31Or specified as a X resource: 35Or specified as a X resource:
32 36
33 URxvt.background-expr: scale load "/path/to/mybg.png" 37 URxvt.background-expr: scale load "/path/to/mybg.png"
34 38
35=head2 THEORY OF OPERATION 39=head1 THEORY OF OPERATION
36 40
37At startup, just before the window is mapped for the first time, the 41At startup, just before the window is mapped for the first time, the
38expression is evaluated and must yield an image. The image is then 42expression is evaluated and must yield an image. The image is then
39extended as necessary to cover the whole terminal window, and is set as a 43extended as necessary to cover the whole terminal window, and is set as a
40background pixmap. 44background pixmap.
… …
57image to the window size, so it relies on the window size and will 61image to the window size, so it relies on the window size and will
58be reevaluated each time it is changed, but not when it moves for 62be reevaluated each time it is changed, but not when it moves for
59example. That ensures that the picture always fills the terminal, even 63example. That ensures that the picture always fills the terminal, even
60after it's size changes. 64after it's size changes.
61 65
62=head3 EXPRESSIONS 66=head2 EXPRESSIONS
63 67
64Expressions are normal Perl expressions, in fact, they are Perl blocks - 68Expressions are normal Perl expressions, in fact, they are Perl blocks -
65which means you could use multiple lines and statements: 69which means you could use multiple lines and statements:
66 70
67 again 3600; 71 again 3600;
… …
70 } else { 74 } else {
71 return scale load "$HOME/sunday.png"; 75 return scale load "$HOME/sunday.png";
72 } 76 }
73 77
74This expression gets evaluated once per hour. It will set F<sunday.png> as 78This expression gets evaluated once per hour. It will set F<sunday.png> as
75background on sundays, and F<weekday.png> on all other days. 79background on Sundays, and F<weekday.png> on all other days.
76 80
77Fortunately, we expect that most expressions will be much simpler, with 81Fortunately, we expect that most expressions will be much simpler, with
78little Perl knowledge needed. 82little Perl knowledge needed.
79 83
80Basically, you always start with a function that "generates" an image 84Basically, you always start with a function that "generates" an image
… …
97its result becomes the argument to the C<scale> function. 101its result becomes the argument to the C<scale> function.
98 102
99Many operators also allow some parameters preceding the input image 103Many operators also allow some parameters preceding the input image
100that modify its behaviour. For example, C<scale> without any additional 104that modify its behaviour. For example, C<scale> without any additional
101arguments scales the image to size of the terminal window. If you specify 105arguments scales the image to size of the terminal window. If you specify
102an additional argument, it uses it as a percentage: 106an additional argument, it uses it as a scale factor (multiply by 100 to
107get a percentage):
103 108
104 scale 200, load "$HOME/mypic.png" 109 scale 2, load "$HOME/mypic.png"
105 110
106This enlarges the image by a factor of 2 (200%). As you can see, C<scale> 111This enlarges the image by a factor of 2 (200%). As you can see, C<scale>
107has now two arguments, the C<200> and the C<load> expression, while 112has now two arguments, the C<200> and the C<load> expression, while
108C<load> only has one argument. Arguments are separated from each other by 113C<load> only has one argument. Arguments are separated from each other by
109commas. 114commas.
110 115
111Scale also accepts two arguments, which are then separate factors for both 116Scale also accepts two arguments, which are then separate factors for both
112horizontal and vertical dimensions. For example, this halves the image 117horizontal and vertical dimensions. For example, this halves the image
113width and doubles the image height: 118width and doubles the image height:
114 119
115 scale 50, 200, load "$HOME/mypic.png" 120 scale 0.5, 2, load "$HOME/mypic.png"
116 121
117TODO 122Other effects than scalign are also readily available, for exmaple, you can
123tile the image to fill the whole window, instead of resizing it:
118 124
125 tile load "$HOME/mypic.png"
126
127In fact, images returned by C<load> are in C<tile> mode by default, so the C<tile> operator
128is kind of superfluous.
129
130Another common effect is to mirror the image, so that the same edges touch:
131
132 mirror load "$HOME/mypic.png"
133
134This is also a typical background expression:
135
136 rootalign root
137
138It first takes a snapshot of the screen background image, and then
139moves it to the upper left corner of the screen - the result is
140pseudo-transparency, as the image seems to be static while the window is
141moved around.
142
119=head3 CYCLES AND CACHING 143=head2 CYCLES AND CACHING
120 144
121TODO 145As has been mentioned before, the expression might be evaluated multiple
122
123Each time the expression is reevaluated, a new cycle is said to have begun. Many operators 146times. Each time the expression is reevaluated, a new cycle is said to
124cache their results till the next cycle. For example 147have begun. Many operators cache their results till the next cycle.
125 148
149For example, the C<load> operator keeps a copy of the image. If it is
150asked to load the same image on the next cycle it will not load it again,
151but return the cached copy.
152
153This only works for one cycle though, so as long as you load the same
154image every time, it will always be cached, but when you load a different
155image, it will forget about the first one.
156
157This allows you to either speed things up by keeping multiple images in
158memory, or comserve memory by loading images more often.
159
160For example, you can keep two images in memory and use a random one like
161this:
162
163 my $img1 = load "img1.png";
164 my $img2 = load "img2.png";
165 (0.5 > rand) ? $img1 : $img2
166
167Since both images are "loaded" every time the expression is evaluated,
168they are always kept in memory. Contrast this version:
169
170 my $path1 = "img1.png";
171 my $path2 = "img2.png";
172 load ((0.5 > rand) ? $path1 : $path2)
173
174Here, a path is selected randomly, and load is only called for one image,
175so keeps only one image in memory. If, on the next evaluation, luck
176decides to use the other path, then it will have to load that image again.
177
126=head2 REFERENCE 178=head1 REFERENCE
127 179
128=head3 COMMAND LINE SWITCHES 180=head2 COMMAND LINE SWITCHES
129 181
130=over 4 182=over 4
131 183
132=item --background-expr perl-expression 184=item --background-expr perl-expression
133 185
… …
139overwriting borders and any other areas, such as the scrollbar. 191overwriting borders and any other areas, such as the scrollbar.
140 192
141Specifying this flag changes the behaviour, so that the image only 193Specifying this flag changes the behaviour, so that the image only
142replaces the background of the character area. 194replaces the background of the character area.
143 195
196=item --background-interval seconds
197
198Since some operations in the underlying XRender extension can effetively
199freeze your X-server for prolonged time, this extension enforces a minimum
200time between updates, which is normally about 0.1 seconds.
201
202If you want to do updates more often, you can decrease this safety
203interval with this switch.
204
144=back 205=back
145 206
146=cut 207=cut
147 208
148our $EXPR;#d# 209our %_IMGCACHE;
149#$EXPR = 'move W * 0.1, -H * 0.1, resize W * 0.5, H * 0.5, repeat_none load "opensource.png"';
150$EXPR = 'move -TX, -TY, load "argb.png"';
151#$EXPR = '
152# rotate W, H, 50, 50, counter 1/59.95, repeat_mirror,
153# clip X, Y, W, H, repeat_mirror,
154# load "/root/pix/das_fette_schwein.jpg"
155#';
156#$EXPR = 'solid "red"';
157#$EXPR = 'blur root, 10, 10'
158#$EXPR = 'blur move (root, -x, -y), 5, 5'
159#resize load "/root/pix/das_fette_schwein.jpg", w, h
160
161our $HOME; 210our $HOME;
162our ($self, $old, $new); 211our ($self, $old, $new);
163our ($x, $y, $w, $h); 212our ($x, $y, $w, $h);
164 213
165# enforce at least this interval between updates 214# enforce at least this interval between updates
166our $MIN_INTERVAL = 1/100; 215our $MIN_INTERVAL = 6/59.951;
167 216
168{ 217{
169 package urxvt::bgdsl; # background language 218 package urxvt::bgdsl; # background language
219
220 use List::Util qw(min max sum shuffle);
170 221
171=head2 PROVIDERS/GENERATORS 222=head2 PROVIDERS/GENERATORS
172 223
173These functions provide an image, by loading it from disk, grabbing it 224These functions provide an image, by loading it from disk, grabbing it
174from the root screen or by simply generating it. They are used as starting 225from the root screen or by simply generating it. They are used as starting
… …
211=item solid $width, $height, $colour 262=item solid $width, $height, $colour
212 263
213Creates a new image and completely fills it with the given colour. The 264Creates a new image and completely fills it with the given colour. The
214image is set to tiling mode. 265image is set to tiling mode.
215 266
216If <$width> and C<$height> are omitted, it creates a 1x1 image, which is 267If C<$width> and C<$height> are omitted, it creates a 1x1 image, which is
217useful for solid backgrounds or for use in filtering effects. 268useful for solid backgrounds or for use in filtering effects.
218 269
219=cut 270=cut
220 271
221 sub solid($$;$) { 272 sub solid($;$$) {
222 my $colour = pop; 273 my $colour = pop;
223 274
224 my $img = $self->new_img (urxvt::PictStandardARGB32, $_[0] || 1, $_[1] || 1); 275 my $img = $self->new_img (urxvt::PictStandardARGB32, $_[0] || 1, $_[1] || 1);
225 $img->fill ($colour); 276 $img->fill ($colour);
226 $img 277 $img
227 } 278 }
228 279
280=item clone $img
281
282Returns an exact copy of the image. This is useful if you want to have
283multiple copies of the same image to apply different effects to.
284
285=cut
286
287 sub clone($) {
288 $_[0]->clone
289 }
290
229=back 291=back
230 292
293=head2 TILING MODES
294
295The following operators modify the tiling mode of an image, that is, the
296way that pixels outside the image area are painted when the image is used.
297
298=over 4
299
300=item tile $img
301
302Tiles the whole plane with the image and returns this new image - or in
303other words, it returns a copy of the image in plane tiling mode.
304
305Example: load an image and tile it over the background, without
306resizing. The C<tile> call is superfluous because C<load> already defaults
307to tiling mode.
308
309 tile load "mybg.png"
310
311=item mirror $img
312
313Similar to tile, but reflects the image each time it uses a new copy, so
314that top edges always touch top edges, right edges always touch right
315edges and so on (with normal tiling, left edges always touch right edges
316and top always touch bottom edges).
317
318Example: load an image and mirror it over the background, avoiding sharp
319edges at the image borders at the expense of mirroring the image itself
320
321 mirror load "mybg.png"
322
323=item pad $img
324
325Takes an image and modifies it so that all pixels outside the image area
326become transparent. This mode is most useful when you want to place an
327image over another image or the background colour while leaving all
328background pixels outside the image unchanged.
329
330Example: load an image and display it in the upper left corner. The rest
331of the space is left "empty" (transparent or wahtever your compisotr does
332in alpha mode, else background colour).
333
334 pad load "mybg.png"
335
336=item extend $img
337
338Extends the image over the whole plane, using the closest pixel in the
339area outside the image. This mode is mostly useful when you more complex
340filtering operations and want the pixels outside the image to have the
341same values as the pixels near the edge.
342
343Example: just for curiosity, how does this pixel extension stuff work?
344
345 extend move 50, 50, load "mybg.png"
346
347=cut
348
349 sub pad($) {
350 my $img = $_[0]->clone;
351 $img->repeat_mode (urxvt::RepeatNone);
352 $img
353 }
354
355 sub tile($) {
356 my $img = $_[0]->clone;
357 $img->repeat_mode (urxvt::RepeatNormal);
358 $img
359 }
360
361 sub mirror($) {
362 my $img = $_[0]->clone;
363 $img->repeat_mode (urxvt::RepeatReflect);
364 $img
365 }
366
367 sub extend($) {
368 my $img = $_[0]->clone;
369 $img->repeat_mode (urxvt::RepeatPad);
370 $img
371 }
372
373=back
374
231=head2 VARIABLES 375=head2 VARIABLE VALUES
232 376
233The following functions provide variable data such as the terminal 377The following functions provide variable data such as the terminal window
378dimensions. They are not (Perl-) variables, they just return stuff that
234window dimensions. Most of them make your expression sensitive to some 379varies. Most of them make your expression sensitive to some events, for
235events, for example using C<TW> (terminal width) means your expression is 380example using C<TW> (terminal width) means your expression is evaluated
236evaluated again when the terminal is resized. 381again when the terminal is resized.
237 382
238=over 4 383=over 4
239 384
240=item TX 385=item TX
241 386
… …
312 $self->{counter} + 0 457 $self->{counter} + 0
313 } 458 }
314 459
315=back 460=back
316 461
317=head2 TILING MODES 462=head2 SHAPE CHANGING OPERATORS
318 463
319The following operators modify the tiling mode of an image, that is, the 464The following operators modify the shape, size or position of the image.
320way that pixels outside the image area are painted when the image is used.
321 465
322=over 4 466=over 4
323
324=item tile $img
325
326Tiles the whole plane with the image and returns this new image - or in
327other words, it returns a copy of the image in plane tiling mode.
328
329Example: load an image and tile it over the background, without
330resizing. The C<tile> call is superfluous because C<load> already defaults
331to tiling mode.
332
333 tile load "mybg.png"
334
335=item mirror $img
336
337Similar to tile, but reflects the image each time it uses a new copy, so
338that top edges always touch top edges, right edges always touch right
339edges and so on (with normal tiling, left edges always touch right edges
340and top always touch bottom edges).
341
342Example: load an image and mirror it over the background, avoiding sharp
343edges at the image borders at the expense of mirroring the image itself
344
345 mirror load "mybg.png"
346
347=item pad $img
348
349Takes an image and modifies it so that all pixels outside the image area
350become transparent. This mode is most useful when you want to place an
351image over another image or the background colour while leaving all
352background pixels outside the image unchanged.
353
354Example: load an image and display it in the upper left corner. The rest
355of the space is left "empty" (transparent or wahtever your compisotr does
356in alpha mode, else background colour).
357
358 pad load "mybg.png"
359
360=item extend $img
361
362Extends the image over the whole plane, using the closest pixel in the
363area outside the image. This mode is mostly useful when you more complex
364filtering operations and want the pixels outside the image to have the
365same values as the pixels near the edge.
366
367Example: just for curiosity, how does this pixel extension stuff work?
368
369 extend move 50, 50, load "mybg.png"
370
371=cut
372
373 sub pad($) {
374 my $img = $_[0]->clone;
375 $img->repeat_mode (urxvt::RepeatNone);
376 $img
377 }
378
379 sub tile($) {
380 my $img = $_[0]->clone;
381 $img->repeat_mode (urxvt::RepeatNormal);
382 $img
383 }
384
385 sub mirror($) {
386 my $img = $_[0]->clone;
387 $img->repeat_mode (urxvt::RepeatReflect);
388 $img
389 }
390
391 sub extend($) {
392 my $img = $_[0]->clone;
393 $img->repeat_mode (urxvt::RepeatPad);
394 $img
395 }
396
397=back
398
399=head2 PIXEL OPERATORS
400
401The following operators modify the image pixels in various ways.
402
403=over 4
404
405=item clone $img
406
407Returns an exact copy of the image.
408
409=cut
410
411 sub clone($) {
412 $_[0]->clone
413 }
414 467
415=item clip $img 468=item clip $img
416 469
417=item clip $width, $height, $img 470=item clip $width, $height, $img
418 471
… …
442 $img->sub_rect ($_[0], $_[1], $w, $h) 495 $img->sub_rect ($_[0], $_[1], $w, $h)
443 } 496 }
444 497
445=item scale $img 498=item scale $img
446 499
447=item scale $size_percent, $img 500=item scale $size_factor, $img
448 501
449=item scale $width_percent, $height_percent, $img 502=item scale $width_factor, $height_factor, $img
450 503
451Scales the image by the given percentages in horizontal 504Scales the image by the given factors in horizontal
452(C<$width_percent>) and vertical (C<$height_percent>) direction. 505(C<$width>) and vertical (C<$height>) direction.
453 506
454If only one percentage is give, it is used for both directions. 507If only one factor is give, it is used for both directions.
455 508
456If no percentages are given, scales the image to the window size without 509If no factors are given, scales the image to the window size without
457keeping aspect. 510keeping aspect.
458 511
459=item resize $width, $height, $img 512=item resize $width, $height, $img
460 513
461Resizes the image to exactly C<$width> times C<$height> pixels. 514Resizes the image to exactly C<$width> times C<$height> pixels.
462 515
463=cut 516=item fit $img
464 517
465#TODO: maximise, maximise_fill? 518=item fit $width, $height, $img
519
520Fits the image into the given C<$width> and C<$height> without changing
521aspect, or the terminal size. That means it will be shrunk or grown until
522the whole image fits into the given area, possibly leaving borders.
523
524=item cover $img
525
526=item cover $width, $height, $img
527
528Similar to C<fit>, but shrinks or grows until all of the area is covered
529by the image, so instead of potentially leaving borders, it will cut off
530image data that doesn't fit.
531
532=cut
466 533
467 sub scale($;$;$) { 534 sub scale($;$;$) {
468 my $img = pop; 535 my $img = pop;
469 536
470 @_ == 2 ? $img->scale ($_[0] * $img->w * 0.01, $_[1] * $img->h * 0.01) 537 @_ == 2 ? $img->scale ($_[0] * $img->w, $_[1] * $img->h)
471 : @_ ? $img->scale ($_[0] * $img->w * 0.01, $_[0] * $img->h * 0.01) 538 : @_ ? $img->scale ($_[0] * $img->w, $_[0] * $img->h)
472 : $img->scale (TW, TH) 539 : $img->scale (TW, TH)
473 } 540 }
474 541
475 sub resize($$$) { 542 sub resize($$$) {
476 my $img = pop; 543 my $img = pop;
477 $img->scale ($_[0], $_[1]) 544 $img->scale ($_[0], $_[1])
545 }
546
547 sub fit($;$$) {
548 my $img = pop;
549 my $w = ($_[0] || TW) / $img->w;
550 my $h = ($_[1] || TH) / $img->h;
551 scale +(min $w, $h), $img
552 }
553
554 sub cover($;$$) {
555 my $img = pop;
556 my $w = ($_[0] || TW) / $img->w;
557 my $h = ($_[1] || TH) / $img->h;
558 scale +(max $w, $h), $img
478 } 559 }
479 560
480=item move $dx, $dy, $img 561=item move $dx, $dy, $img
481 562
482Moves the image by C<$dx> pixels in the horizontal, and C<$dy> pixels in 563Moves the image by C<$dx> pixels in the horizontal, and C<$dy> pixels in
483the vertical. 564the vertical.
484 565
485Example: move the image right by 20 pixels and down by 30. 566Example: move the image right by 20 pixels and down by 30.
486 567
487 move 20, 30, ... 568 move 20, 30, ...
569
570=item align $xalign, $yalign, $img
571
572Aligns the image according to a factor - C<0> means the image is moved to
573the left or top edge (for C<$xalign> or C<$yalign>), C<0.5> means it is
574exactly centered and C<1> means it touches the right or bottom edge.
575
576Example: remove any visible border around an image, center it vertically but move
577it to the right hand side.
578
579 align 1, 0.5, pad $img
580
581=item center $img
582
583=item center $width, $height, $img
584
585Centers the image, i.e. the center of the image is moved to the center of
586the terminal window (or the box specified by C<$width> and C<$height> if
587given).
588
589Example: load an image and center it.
590
591 center pad load "mybg.png"
488 592
489=item rootalign $img 593=item rootalign $img
490 594
491Moves the image so that it appears glued to the screen as opposed to the 595Moves the image so that it appears glued to the screen as opposed to the
492window. This gives the illusion of a larger area behind the window. It is 596window. This gives the illusion of a larger area behind the window. It is
… …
498 rootalign mirror load "mybg.png" 602 rootalign mirror load "mybg.png"
499 603
500Example: take the screen background and align it, giving the illusion of 604Example: take the screen background and align it, giving the illusion of
501transparency as long as the window isn't in front of other windows. 605transparency as long as the window isn't in front of other windows.
502 606
503 rootalign root 607 rootalign root
504 608
505=cut 609=cut
506 610
507 sub move($$;$) { 611 sub move($$;$) {
508 my $img = pop->clone; 612 my $img = pop->clone;
509 $img->move ($_[0], $_[1]); 613 $img->move ($_[0], $_[1]);
510 $img 614 $img
511 } 615 }
512 616
617 sub align($;$$) {
618 my $img = pop;
619
620 move $_[0] * (TW - $img->w),
621 $_[1] * (TH - $img->h),
622 $img
623 }
624
625 sub center($;$$) {
626 my $img = pop;
627 my $w = $_[0] || TW;
628 my $h = $_[1] || TH;
629
630 move 0.5 * ($w - $img->w), 0.5 * ($h - $img->h), $img
631 }
632
513 sub rootalign($) { 633 sub rootalign($) {
514 move -TX, -TY, $_[0] 634 move -TX, -TY, $_[0]
515 } 635 }
516 636
637=back
638
639=head2 COLOUR MODIFICATIONS
640
641The following operators change the pixels of the image.
642
643=over 4
644
517=item contrast $factor, $img 645=item contrast $factor, $img
518 646
519=item contrast $r, $g, $b, $img 647=item contrast $r, $g, $b, $img
520 648
521=item contrast $r, $g, $b, $a, $img 649=item contrast $r, $g, $b, $a, $img
522 650
523Adjusts the I<contrast> of an image. 651Adjusts the I<contrast> of an image.
524 652
525#TODO# 653The first form applies a single C<$factor> to red, green and blue, the
654second form applies separate factors to each colour channel, and the last
655form includes the alpha channel.
526 656
657Values from 0 to 1 lower the contrast, values higher than 1 increase the
658contrast.
659
660Due to limitations in the underlying XRender extension, lowering contrast
661also reduces brightness, while increasing contrast currently also
662increases brightness.
663
527=item brightness $factor, $img 664=item brightness $bias, $img
528 665
529=item brightness $r, $g, $b, $img 666=item brightness $r, $g, $b, $img
530 667
531=item brightness $r, $g, $b, $a, $img 668=item brightness $r, $g, $b, $a, $img
532 669
533Adjusts the brightness of an image. 670Adjusts the brightness of an image.
534 671
672The first form applies a single C<$bias> to red, green and blue, the
673second form applies separate biases to each colour channel, and the last
674form includes the alpha channel.
675
676Values less than 0 reduce brightness, while values larger than 0 increase
677it. Useful range is from -1 to 1 - the former results in a black, the
678latter in a white picture.
679
680Due to idiosynchrasies in the underlying XRender extension, biases less
681than zero can be I<very> slow.
682
535=cut 683=cut
536 684
537 sub contrast($$;$$;$) { 685 sub contrast($$;$$;$) {
538 my $img = pop; 686 my $img = pop;
539 my ($r, $g, $b, $a) = @_; 687 my ($r, $g, $b, $a) = @_;
540 688
541 ($g, $b) = ($r, $r) if @_ < 4; 689 ($g, $b) = ($r, $r) if @_ < 3;
542 $a = 1 if @_ < 5; 690 $a = 1 if @_ < 4;
543 691
544 $img = $img->clone; 692 $img = $img->clone;
545 $img->contrast ($r, $g, $b, $a); 693 $img->contrast ($r, $g, $b, $a);
546 $img 694 $img
547 } 695 }
548 696
549 sub brightness($$;$$;$) { 697 sub brightness($$;$$;$) {
550 my $img = pop; 698 my $img = pop;
551 my ($r, $g, $b, $a) = @_; 699 my ($r, $g, $b, $a) = @_;
552 700
553 ($g, $b) = ($r, $r) if @_ < 4; 701 ($g, $b) = ($r, $r) if @_ < 3;
554 $a = 1 if @_ < 5; 702 $a = 1 if @_ < 4;
555 703
556 $img = $img->clone; 704 $img = $img->clone;
557 $img->brightness ($r, $g, $b, $a); 705 $img->brightness ($r, $g, $b, $a);
558 $img 706 $img
559 } 707 }
… …
563=item blur $radius_horz, $radius_vert, $img 711=item blur $radius_horz, $radius_vert, $img
564 712
565Gaussian-blurs the image with (roughly) C<$radius> pixel radius. The radii 713Gaussian-blurs the image with (roughly) C<$radius> pixel radius. The radii
566can also be specified separately. 714can also be specified separately.
567 715
716Blurring is often I<very> slow, at least compared or other
717operators. Larger blur radii are slower than smaller ones, too, so if you
718don't want to freeze your screen for long times, start experimenting with
719low values for radius (<5).
720
568=cut 721=cut
569 722
570 sub blur($$;$) { 723 sub blur($$;$) {
571 my $img = pop; 724 my $img = pop;
572 $img->blur ($_[0], @_ >= 2 ? $_[1] : $_[0]) 725 $img->blur ($_[0], @_ >= 2 ? $_[1] : $_[0])
573 } 726 }
574 727
575=item rotate $new_width, $new_height, $center_x, $center_y, $degrees 728=item rotate $new_width, $new_height, $center_x, $center_y, $degrees
576 729
577Rotates the image by C<$degrees> degrees, counter-clockwise, around the 730Rotates the image by C<$degrees> degrees, counter-clockwise, around the
578pointer at C<$center_x> and C<$center_y> (specified as percentage of image 731pointer at C<$center_x> and C<$center_y> (specified as factor of image
579width/height), generating a new image with width C<$new_width> and height 732width/height), generating a new image with width C<$new_width> and height
580C<$new_height>. 733C<$new_height>.
581 734
582#TODO# new width, height, maybe more operators? 735#TODO# new width, height, maybe more operators?
583 736
… …
588 sub rotate($$$$$$) { 741 sub rotate($$$$$$) {
589 my $img = pop; 742 my $img = pop;
590 $img->rotate ( 743 $img->rotate (
591 $_[0], 744 $_[0],
592 $_[1], 745 $_[1],
593 $_[2] * $img->w * .01, 746 $_[2] * $img->w,
594 $_[3] * $img->h * .01, 747 $_[3] * $img->h,
595 $_[4] * (3.14159265 / 180), 748 $_[4] * (3.14159265 / 180),
596 ) 749 )
597 } 750 }
598 751
599=back 752=back
… …
644 797
645 # evaluate user expression 798 # evaluate user expression
646 799
647 my $img = eval { $self->{expr}->() }; 800 my $img = eval { $self->{expr}->() };
648 warn $@ if $@;#d# 801 warn $@ if $@;#d#
649 die if !UNIVERSAL::isa $img, "urxvt::img"; 802 die "background-expr did not return an image.\n" if !UNIVERSAL::isa $img, "urxvt::img";
650 803
651 $state->{size_sensitive} = 1 804 $state->{size_sensitive} = 1
652 if $img->repeat_mode != urxvt::RepeatNormal; 805 if $img->repeat_mode != urxvt::RepeatNormal;
653 806
654 # if the expression is sensitive to external events, prepare reevaluation then 807 # if the expression is sensitive to external events, prepare reevaluation then
… …
704} 857}
705 858
706sub on_start { 859sub on_start {
707 my ($self) = @_; 860 my ($self) = @_;
708 861
709 my $expr = $self->x_resource ("background.expr") 862 my $expr = $self->x_resource ("%.expr")
710 or return; 863 or return;
711 864
865 $self->has_render
866 or die "background extension needs RENDER extension 0.10 or higher, ignoring background-expr.\n";
867
712 $self->set_expr (parse_expr $expr); 868 $self->set_expr (parse_expr $expr);
713 $self->{border} = $self->x_resource_boolean ("background.border"); 869 $self->{border} = $self->x_resource_boolean ("%.border");
870
871 $MIN_INTERVAL = $self->x_resource ("%.interval");
714 872
715 () 873 ()
716} 874}
717 875

Diff Legend

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