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

Diff Legend

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