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.50 by root, Sun Jun 10 17:31:53 2012 UTC vs.
Revision 1.62 by root, Sun Jun 17 21:58:18 2012 UTC

… …
57 57
58For 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
59image 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
60be 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
61example. That ensures that the picture always fills the terminal, even 61example. That ensures that the picture always fills the terminal, even
62after it's size changes. 62after its size changes.
63 63
64=head2 EXPRESSIONS 64=head2 EXPRESSIONS
65 65
66Expressions are normal Perl expressions, in fact, they are Perl blocks - 66Expressions are normal Perl expressions, in fact, they are Perl blocks -
67which means you could use multiple lines and statements: 67which means you could use multiple lines and statements:
… …
71 return scale load "$HOME/weekday.png"; 71 return scale load "$HOME/weekday.png";
72 } else { 72 } else {
73 return scale load "$HOME/sunday.png"; 73 return scale load "$HOME/sunday.png";
74 } 74 }
75 75
76This expression gets evaluated once per hour. It will set F<sunday.png> as 76This expression is evaluated once per hour. It will set F<sunday.png> as
77background on Sundays, and F<weekday.png> on all other days. 77background on Sundays, and F<weekday.png> on all other days.
78 78
79Fortunately, we expect that most expressions will be much simpler, with 79Fortunately, we expect that most expressions will be much simpler, with
80little Perl knowledge needed. 80little Perl knowledge needed.
81 81
… …
115horizontal and vertical dimensions. For example, this halves the image 115horizontal and vertical dimensions. For example, this halves the image
116width and doubles the image height: 116width and doubles the image height:
117 117
118 scale 0.5, 2, load "$HOME/mypic.png" 118 scale 0.5, 2, load "$HOME/mypic.png"
119 119
120Other effects than scalign are also readily available, for exmaple, you can 120Other effects than scaling are also readily available, for example, you can
121tile the image to fill the whole window, instead of resizing it: 121tile the image to fill the whole window, instead of resizing it:
122 122
123 tile load "$HOME/mypic.png" 123 tile load "$HOME/mypic.png"
124 124
125In 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
… …
151This 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
152image 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
153image, it will forget about the first one. 153image, it will forget about the first one.
154 154
155This 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
156memory, or comserve memory by loading images more often. 156memory, or conserve memory by loading images more often.
157 157
158For 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
159this: 159this:
160 160
161 my $img1 = load "img1.png"; 161 my $img1 = load "img1.png";
… …
191Specifying this flag changes the behaviour, so that the image only 191Specifying this flag changes the behaviour, so that the image only
192replaces the background of the character area. 192replaces the background of the character area.
193 193
194=item --background-interval seconds 194=item --background-interval seconds
195 195
196Since some operations in the underlying XRender extension can effetively 196Since some operations in the underlying XRender extension can effectively
197freeze your X-server for prolonged time, this extension enforces a minimum 197freeze your X-server for prolonged time, this extension enforces a minimum
198time between updates, which is normally about 0.1 seconds. 198time between updates, which is normally about 0.1 seconds.
199 199
200If you want to do updates more often, you can decrease this safety 200If you want to do updates more often, you can decrease this safety
201interval with this switch. 201interval with this switch.
202 202
203=back 203=back
204 204
205=cut 205=cut
206 206
207our %_IMGCACHE; 207our %_IMG_CACHE;
208our $HOME; 208our $HOME;
209our ($self, $old, $new); 209our ($self, $old, $new);
210our ($x, $y, $w, $h); 210our ($x, $y, $w, $h);
211 211
212# enforce at least this interval between updates 212# enforce at least this interval between updates
… …
228=item load $path 228=item load $path
229 229
230Loads the image at the given C<$path>. The image is set to plane tiling 230Loads the image at the given C<$path>. The image is set to plane tiling
231mode. 231mode.
232 232
233Loaded images will be cached for one cycle. 233Loaded images will be cached for one cycle, and shared between temrinals
234running in the same process (e.g. in C<urxvtd>).
234 235
236=item load_uc $path
237
238Load uncached - same as load, but does not cache the image. This function
239is most useufl if you want to optimise a background expression in some
240way.
241
235=cut 242=cut
243
244 sub load_uc($) {
245 my ($path) = @_;
246
247 $_IMG_CACHE{$path} || do {
248 my $img = $self->new_img_from_file ($path);
249 Scalar::Util::weaken ($_IMG_CACHE{$path} = $img);
250 $img
251 }
252 }
236 253
237 sub load($) { 254 sub load($) {
238 my ($path) = @_; 255 my ($path) = @_;
239 256
240 $new->{load}{$path} = $old->{load}{$path} || $self->new_img_from_file ($path); 257 $new->{load}{$path} = $old->{load}{$path} || load_uc $path;
241 } 258 }
242 259
243=item root 260=item root
244 261
245Returns the root window pixmap, that is, hopefully, the background image 262Returns the root window pixmap, that is, hopefully, the background image
246of your screen. The image is set to extend mode. 263of your screen.
247 264
248This function makes your expression root sensitive, that means it will be 265This function makes your expression root sensitive, that means it will be
249reevaluated when the bg image changes. 266reevaluated when the bg image changes.
250 267
251=cut 268=cut
252 269
253 sub root() { 270 sub root() {
254 $new->{rootpmap_sensitive} = 1; 271 $new->{again}{rootpmap} = 1;
255 die "root op not supported, exg, we need you"; 272 $self->new_img_from_root
256 } 273 }
257 274
258=item solid $colour 275=item solid $colour
259 276
260=item solid $width, $height, $colour 277=item solid $width, $height, $colour
… …
268=cut 285=cut
269 286
270 sub solid($;$$) { 287 sub solid($;$$) {
271 my $colour = pop; 288 my $colour = pop;
272 289
273 my $img = $self->new_img (urxvt::PictStandardARGB32, $_[0] || 1, $_[1] || 1); 290 my $img = $self->new_img (urxvt::PictStandardARGB32, 0, 0, $_[0] || 1, $_[1] || 1);
274 $img->fill ($colour); 291 $img->fill ($colour);
275 $img 292 $img
276 } 293 }
277 294
278=item clone $img 295=item clone $img
… …
284 301
285 sub clone($) { 302 sub clone($) {
286 $_[0]->clone 303 $_[0]->clone
287 } 304 }
288 305
289=back 306=item merge $img ...
307
308Takes any number of images and merges them together, creating a single
309image containing them all. The tiling mode of the first image is used as
310the tiling mdoe of the resulting image.
311
312This function is called automatically when an expression returns multiple
313images.
314
315=cut
316
317 sub merge(@) {
318 return $_[0] unless $#_;
319
320 # rather annoyingly clumsy, but optimisation is for another time
321
322 my $x0 = +1e9;
323 my $y0 = +1e9;
324 my $x1 = -1e9;
325 my $y1 = -1e9;
326
327 for (@_) {
328 my ($x, $y, $w, $h) = $_->geometry;
329
330 $x0 = $x if $x0 > $x;
331 $y0 = $y if $y0 > $y;
332
333 $x += $w;
334 $y += $h;
335
336 $x1 = $x if $x1 < $x;
337 $y1 = $y if $y1 < $y;
338 }
339
340 my $base = $self->new_img (urxvt::PictStandardARGB32, $x0, $y0, $x1 - $x0, $y1 - $y0);
341 $base->repeat_mode ($_[0]->repeat_mode);
342 $base->fill ([0, 0, 0, 0]);
343
344 $base->draw ($_)
345 for @_;
346
347 $base
348 }
290 349
291=head2 TILING MODES 350=head2 TILING MODES
292 351
293The following operators modify the tiling mode of an image, that is, the 352The 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. 353way that pixels outside the image area are painted when the image is used.
… …
324become transparent. This mode is most useful when you want to place an 383become transparent. This mode is most useful when you want to place an
325image over another image or the background colour while leaving all 384image over another image or the background colour while leaving all
326background pixels outside the image unchanged. 385background pixels outside the image unchanged.
327 386
328Example: load an image and display it in the upper left corner. The rest 387Example: load an image and display it in the upper left corner. The rest
329of the space is left "empty" (transparent or wahtever your compisotr does 388of the space is left "empty" (transparent or whatever your compositor does
330in alpha mode, else background colour). 389in alpha mode, else background colour).
331 390
332 pad load "mybg.png" 391 pad load "mybg.png"
333 392
334=item extend $img 393=item extend $img
335 394
336Extends the image over the whole plane, using the closest pixel in the 395Extends the image over the whole plane, using the closest pixel in the
337area outside the image. This mode is mostly useful when you more complex 396area 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 397filtering operations and want the pixels outside the image to have the
339same values as the pixels near the edge. 398same values as the pixels near the edge.
340 399
341Example: just for curiosity, how does this pixel extension stuff work? 400Example: just for curiosity, how does this pixel extension stuff work?
342 401
… …
409the window size to conserve memory. 468the window size to conserve memory.
410 469
411Example: take the screen background, clip it to the window size, blur it a 470Example: take the screen background, clip it to the window size, blur it a
412bit, align it to the window position and use it as background. 471bit, align it to the window position and use it as background.
413 472
414 clip move -TX, -TY, blur 5, root 473 clip move -TX, -TY, once { blur 5, root }
415 474
416=cut 475=cut
417 476
418 sub TX() { $new->{position_sensitive} = 1; $x } 477 sub TX() { $new->{again}{position} = 1; $x }
419 sub TY() { $new->{position_sensitive} = 1; $y } 478 sub TY() { $new->{again}{position} = 1; $y }
420 sub TW() { $new->{size_sensitive} = 1; $w } 479 sub TW() { $new->{again}{size} = 1; $w }
421 sub TH() { $new->{size_sensitive} = 1; $h } 480 sub TH() { $new->{again}{size} = 1; $h }
422 481
423=item now 482=item now
424 483
425Returns the current time as (fractional) seconds since the epoch. 484Returns the current time as (fractional) seconds since the epoch.
426 485
… …
433C<$seconds> seconds. 492C<$seconds> seconds.
434 493
435Example: load some image and rotate it according to the time of day (as if it were 494Example: load some image and rotate it according to the time of day (as if it were
436the hour pointer of a clock). Update this image every minute. 495the hour pointer of a clock). Update this image every minute.
437 496
438 again 60; rotate TW, TH, 50, 50, (now % 86400) * -720 / 86400, scale load "myclock.png" 497 again 60; rotate 50, 50, (now % 86400) * -720 / 86400, scale load "myclock.png"
439 498
440=item counter $seconds 499=item counter $seconds
441 500
442Like C<again>, but also returns an increasing counter value, starting at 501Like C<again>, but also returns an increasing counter value, starting at
4430, which might be useful for some simple animation effects. 5020, which might be useful for some simple animation effects.
… …
445=cut 504=cut
446 505
447 sub now() { urxvt::NOW } 506 sub now() { urxvt::NOW }
448 507
449 sub again($) { 508 sub again($) {
450 $new->{again} = $_[0]; 509 $new->{again}{time} = $_[0];
451 } 510 }
452 511
453 sub counter($) { 512 sub counter($) {
454 $new->{again} = $_[0]; 513 $new->{again}{time} = $_[0];
455 $self->{counter} + 0 514 $self->{counter} + 0
456 } 515 }
457 516
458=back 517=back
459 518
… …
630 689
631 sub rootalign($) { 690 sub rootalign($) {
632 move -TX, -TY, $_[0] 691 move -TX, -TY, $_[0]
633 } 692 }
634 693
694=item rotate $center_x, $center_y, $degrees
695
696Rotates the image by C<$degrees> degrees, counter-clockwise, around the
697pointer at C<$center_x> and C<$center_y> (specified as factor of image
698width/height).
699
700#TODO# new width, height, maybe more operators?
701
702Example: rotate the image by 90 degrees
703
704=cut
705
706 sub rotate($$$$) {
707 my $img = pop;
708 $img->rotate (
709 $_[0] * ($img->w + $img->x),
710 $_[1] * ($img->h + $img->y),
711 $_[2] * (3.14159265 / 180),
712 )
713 }
714
635=back 715=back
636 716
637=head2 COLOUR MODIFICATIONS 717=head2 COLOUR MODIFICATIONS
638 718
639The following operators change the pixels of the image. 719The following operators change the pixels of the image.
… …
673 753
674Values less than 0 reduce brightness, while values larger than 0 increase 754Values 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 755it. Useful range is from -1 to 1 - the former results in a black, the
676latter in a white picture. 756latter in a white picture.
677 757
678Due to idiosynchrasies in the underlying XRender extension, biases less 758Due to idiosyncrasies in the underlying XRender extension, biases less
679than zero can be I<very> slow. 759than zero can be I<very> slow.
680 760
681=cut 761=cut
682 762
683 sub contrast($$;$$;$) { 763 sub contrast($$;$$;$) {
… …
721 sub blur($$;$) { 801 sub blur($$;$) {
722 my $img = pop; 802 my $img = pop;
723 $img->blur ($_[0], @_ >= 2 ? $_[1] : $_[0]) 803 $img->blur ($_[0], @_ >= 2 ? $_[1] : $_[0])
724 } 804 }
725 805
726=item rotate $new_width, $new_height, $center_x, $center_y, $degrees 806=back
727 807
728Rotates the image by C<$degrees> degrees, counter-clockwise, around the 808=head2 OTHER STUFF
729pointer at C<$center_x> and C<$center_y> (specified as factor of image
730width/height), generating a new image with width C<$new_width> and height
731C<$new_height>.
732 809
733#TODO# new width, height, maybe more operators? 810Anything that didn't fit any of the other categories, even after applying
811force and closing our eyes.
734 812
735Example: rotate the image by 90 degrees 813=over 4
736 814
737=cut 815=item once { ... }
738 816
739 sub rotate($$$$$$) { 817This function takes a code block as argument, that is, one or more
740 my $img = pop; 818statements enclosed by braces.
741 $img->rotate ( 819
742 $_[0], 820The trick is that this code block is only evaluated once - future calls
743 $_[1], 821will simply return the original image (yes, it should only be used with
744 $_[2] * $img->w, 822images).
745 $_[3] * $img->h, 823
746 $_[4] * (3.14159265 / 180), 824This can be extremely useful to avoid redoign the same slow operations
825again and again- for example, if your background expression takes the root
826background, blurs it and then root-aligns it it would have to blur the
827root background on every window move or resize.
828
829Putting the blur into a C<once> block will make sure the blur is only done
830once:
831
832 rootlign once { blur 10, root }
833
834This leaves the question of how to force reevaluation of the block, in
835case the root background changes: Right now, all once blocks forget that
836they ahve been executed before each time the root background changes (if
837the expression is sensitive to that) or when C<once_again> is called.
838
839=item once_again
840
841Resets all C<once> block as if they had never been called, i.e. on the
842next call they will be reevaluated again.
843
844=cut
845
846 sub once(&) {
847 my $once = $self->{once_cache}{$_[0]+0} ||= do {
848 local $new->{again};
849 my @res = $_[0]();
850 [$new->{again}, \@res]
747 ) 851 };
852
853 $new->{again} = {
854 %{ $new->{again} },
855 %{ $once->[0] }
856 };
857
858 # in scalar context we always return the first original result, which
859 # is not quite how perl works.
860 wantarray
861 ? @{ $once->[1] }
862 : $once->[1][0]
863 }
864
865 sub once_again() {
866 delete $self->{once_cache};
748 } 867 }
749 868
750=back 869=back
751 870
752=cut 871=cut
… …
793 ($x, $y, $w, $h) = 912 ($x, $y, $w, $h) =
794 $self->background_geometry ($self->{border}); 913 $self->background_geometry ($self->{border});
795 914
796 # evaluate user expression 915 # evaluate user expression
797 916
798 my $img = eval { $self->{expr}->() }; 917 my $img = eval { urxvt::bgdsl::merge $self->{expr}->() };
799 warn $@ if $@;#d# 918 die $@ if $@;
800 die "background-expr did not return an image.\n" if !UNIVERSAL::isa $img, "urxvt::img"; 919 die "background-expr did not return an image.\n" if !UNIVERSAL::isa $img, "urxvt::img";
801 920
802 $state->{size_sensitive} = 1 921 # if the expression is sensitive to external events, prepare reevaluation then
922
923 my $again = delete $state->{again};
924
925 $again->{size} = 1
803 if $img->repeat_mode != urxvt::RepeatNormal; 926 if $img->repeat_mode != urxvt::RepeatNormal;
804 927
805 # if the expression is sensitive to external events, prepare reevaluation then
806
807 my $repeat;
808
809 if (my $again = $state->{again}) { 928 if (my $again = $again->{time}) {
810 $repeat = 1;
811 my $self = $self; 929 my $self = $self;
812 $state->{timer} = $again == $old->{again} 930 $state->{timer} = $again == $old->{again}
813 ? $old->{timer} 931 ? $old->{timer}
814 : urxvt::timer->new->after ($again)->interval ($again)->cb (sub { 932 : urxvt::timer->new->after ($again)->interval ($again)->cb (sub {
815 ++$self->{counter}; 933 ++$self->{counter};
816 $self->recalculate 934 $self->recalculate
817 }); 935 });
818 } 936 }
819 937
820 if (delete $state->{position_sensitive}) { 938 if ($again->{position}) {
821 $repeat = 1;
822 $self->enable (position_change => sub { $_[0]->recalculate }); 939 $self->enable (position_change => sub { $_[0]->recalculate });
823 } else { 940 } else {
824 $self->disable ("position_change"); 941 $self->disable ("position_change");
825 } 942 }
826 943
827 if (delete $state->{size_sensitive}) { 944 if ($again->{size}) {
828 $repeat = 1;
829 $self->enable (size_change => sub { $_[0]->recalculate }); 945 $self->enable (size_change => sub { $_[0]->recalculate });
830 } else { 946 } else {
831 $self->disable ("size_change"); 947 $self->disable ("size_change");
832 } 948 }
833 949
834 if (delete $state->{rootpmap_sensitive}) { 950 if ($again->{rootpmap}) {
835 $repeat = 1;
836 $self->enable (rootpmap_change => sub { $_[0]->recalculate }); 951 $self->enable (rootpmap_change => sub {
952 delete $_[0]{once_cache}; # this will override once-block values from
953 $_[0]->recalculate;
954 });
837 } else { 955 } else {
838 $self->disable ("rootpmap_change"); 956 $self->disable ("rootpmap_change");
839 } 957 }
840 958
841 # clear stuff we no longer need 959 # clear stuff we no longer need
842 960
843 %$old = (); 961 %$old = ();
844 962
845 unless ($repeat) { 963 unless (%$again) {
846 delete $self->{state}; 964 delete $self->{state};
847 delete $self->{expr}; 965 delete $self->{expr};
848 } 966 }
849 967
850 # set background pixmap 968 # set background pixmap

Diff Legend

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