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.52 by root, Tue Jun 12 10:45:53 2012 UTC vs.
Revision 1.58 by root, Thu Jun 14 18:13:19 2012 UTC

… …
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
… …
203=back 203=back
204 204
205=cut 205=cut
206 206
207our %_IMG_CACHE; 207our %_IMG_CACHE;
208our %_ONCE_CACHE;
209our $HOME; 208our $HOME;
210our ($self, $old, $new); 209our ($self, $old, $new);
211our ($x, $y, $w, $h); 210our ($x, $y, $w, $h);
212 211
213# enforce at least this interval between updates 212# enforce at least this interval between updates
… …
229=item load $path 228=item load $path
230 229
231Loads 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
232mode. 231mode.
233 232
234Loaded 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>).
235 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
236=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 }
237 253
238 sub load($) { 254 sub load($) {
239 my ($path) = @_; 255 my ($path) = @_;
240 256
241 $new->{load}{$path} = $old->{load}{$path} || $self->new_img_from_file ($path); 257 $new->{load}{$path} = $old->{load}{$path} || load_uc $path;
242 } 258 }
243 259
244=item root 260=item root
245 261
246Returns the root window pixmap, that is, hopefully, the background image 262Returns the root window pixmap, that is, hopefully, the background image
… …
250reevaluated when the bg image changes. 266reevaluated when the bg image changes.
251 267
252=cut 268=cut
253 269
254 sub root() { 270 sub root() {
255 $new->{rootpmap_sensitive} = 1; 271 $new->{again}{rootpmap} = 1;
256 $self->new_img_from_root 272 $self->new_img_from_root
257 } 273 }
258 274
259=item solid $colour 275=item solid $colour
260 276
… …
283 299
284=cut 300=cut
285 301
286 sub clone($) { 302 sub clone($) {
287 $_[0]->clone 303 $_[0]->clone
304 }
305
306=item merge $img ...
307
308Takes any number of images and merges them together, creating a single
309image containing them all.
310
311=cut
312
313 sub merge(@) {
314 # rather annoyingly clumsy, but optimisation is for another time
315
316 my $x0 = 1e9;
317 my $y0 = 1e9;
318 my $x1 = -1e9;
319 my $y1 = -1e9;
320
321 for (@_) {
322 my ($x, $y, $w, $h) = $_->geometry;
323
324 $x0 = $x if $x0 > $x;
325 $y0 = $y if $y0 > $y;
326
327 $x += $w;
328 $y += $h;
329
330 $x1 = $x if $x1 > $x;
331 $y1 = $y if $y1 > $y;
332 }
333
334 my $base = $self->new_img ($x0, $y0, $x1 - $x0, $y1 - $y0);
335 $base->fill ([0, 0, 0, 0]);
336
337 $base->blend (1., $_)
338 for @_;
339
340 $base
288 } 341 }
289 342
290=head2 TILING MODES 343=head2 TILING MODES
291 344
292The following operators modify the tiling mode of an image, that is, the 345The following operators modify the tiling mode of an image, that is, the
… …
408the window size to conserve memory. 461the window size to conserve memory.
409 462
410Example: take the screen background, clip it to the window size, blur it a 463Example: take the screen background, clip it to the window size, blur it a
411bit, align it to the window position and use it as background. 464bit, align it to the window position and use it as background.
412 465
413 clip move -TX, -TY, blur 5, root 466 clip move -TX, -TY, once { blur 5, root }
414 467
415=cut 468=cut
416 469
417 sub TX() { $new->{position_sensitive} = 1; $x } 470 sub TX() { $new->{again}{position} = 1; $x }
418 sub TY() { $new->{position_sensitive} = 1; $y } 471 sub TY() { $new->{again}{position} = 1; $y }
419 sub TW() { $new->{size_sensitive} = 1; $w } 472 sub TW() { $new->{again}{size} = 1; $w }
420 sub TH() { $new->{size_sensitive} = 1; $h } 473 sub TH() { $new->{again}{size} = 1; $h }
421 474
422=item now 475=item now
423 476
424Returns the current time as (fractional) seconds since the epoch. 477Returns the current time as (fractional) seconds since the epoch.
425 478
… …
432C<$seconds> seconds. 485C<$seconds> seconds.
433 486
434Example: load some image and rotate it according to the time of day (as if it were 487Example: load some image and rotate it according to the time of day (as if it were
435the hour pointer of a clock). Update this image every minute. 488the hour pointer of a clock). Update this image every minute.
436 489
437 again 60; rotate TW, TH, 50, 50, (now % 86400) * -720 / 86400, scale load "myclock.png" 490 again 60; rotate 50, 50, (now % 86400) * -720 / 86400, scale load "myclock.png"
438 491
439=item counter $seconds 492=item counter $seconds
440 493
441Like C<again>, but also returns an increasing counter value, starting at 494Like C<again>, but also returns an increasing counter value, starting at
4420, which might be useful for some simple animation effects. 4950, which might be useful for some simple animation effects.
… …
444=cut 497=cut
445 498
446 sub now() { urxvt::NOW } 499 sub now() { urxvt::NOW }
447 500
448 sub again($) { 501 sub again($) {
449 $new->{again} = $_[0]; 502 $new->{again}{time} = $_[0];
450 } 503 }
451 504
452 sub counter($) { 505 sub counter($) {
453 $new->{again} = $_[0]; 506 $new->{again}{time} = $_[0];
454 $self->{counter} + 0 507 $self->{counter} + 0
455 } 508 }
456 509
457=back 510=back
458 511
… …
629 682
630 sub rootalign($) { 683 sub rootalign($) {
631 move -TX, -TY, $_[0] 684 move -TX, -TY, $_[0]
632 } 685 }
633 686
634=item rotate $center_x, $center_y, $degrees, $new_width, $new_height 687=item rotate $center_x, $center_y, $degrees
635 688
636Rotates the image by C<$degrees> degrees, counter-clockwise, around the 689Rotates the image by C<$degrees> degrees, counter-clockwise, around the
637pointer at C<$center_x> and C<$center_y> (specified as factor of image 690pointer at C<$center_x> and C<$center_y> (specified as factor of image
638width/height), generating a new image with width C<$new_width> and height 691width/height).
639C<$new_height>.
640 692
641#TODO# new width, height, maybe more operators? 693#TODO# new width, height, maybe more operators?
642 694
643Example: rotate the image by 90 degrees 695Example: rotate the image by 90 degrees
644 696
645=cut 697=cut
646 698
647 sub rotate($$$$$$) { 699 sub rotate($$$$) {
648 my $img = pop; 700 my $img = pop;
649 $img->rotate ( 701 $img->rotate (
650 $_[0] * $img->w, 702 $_[0] * $img->w,
651 $_[1] * $img->h, 703 $_[1] * $img->h,
652 $_[2] * (3.14159265 / 180), 704 $_[2] * (3.14159265 / 180),
653 $_[3],
654 $_[4],
655 ) 705 )
656 } 706 }
657 707
658=back 708=back
659 709
… …
748 798
749=back 799=back
750 800
751=head2 OTHER STUFF 801=head2 OTHER STUFF
752 802
753Anything that didn't fit any of the other categories, even after appliyng 803Anything that didn't fit any of the other categories, even after applying
754force and closing our eyes. 804force and closing our eyes.
755 805
756=over 4 806=over 4
757 807
758=item once { ... } 808=item once { ... }
… …
785next call they will be reevaluated again. 835next call they will be reevaluated again.
786 836
787=cut 837=cut
788 838
789 sub once(&) { 839 sub once(&) {
790 $_ONCE_CACHE{$_[0]+0} ||= $_[0]() 840 my $once = $self->{once_cache}{$_[0]+0} ||= do {
841 local $new->{again};
842 my @res = $_[0]();
843 [$new->{again}, \@res]
844 };
845
846 $new->{again} = {
847 %{ $new->{again} },
848 %{ $once->[0] }
849 };
850
851 # in scalar context we always return the first original result, which
852 # is not quite how perl works.
853 wantarray
854 ? @{ $once->[1] }
855 : $once->[1][0]
791 } 856 }
792 857
793 sub once_again() { 858 sub once_again() {
794 %_ONCE_CACHE = (); 859 delete $self->{once_cache};
795 } 860 }
796 861
797=back 862=back
798 863
799=cut 864=cut
… …
844 909
845 my $img = eval { $self->{expr}->() }; 910 my $img = eval { $self->{expr}->() };
846 warn $@ if $@;#d# 911 warn $@ if $@;#d#
847 die "background-expr did not return an image.\n" if !UNIVERSAL::isa $img, "urxvt::img"; 912 die "background-expr did not return an image.\n" if !UNIVERSAL::isa $img, "urxvt::img";
848 913
849 $state->{size_sensitive} = 1 914 # if the expression is sensitive to external events, prepare reevaluation then
915
916 my $again = delete $state->{again};
917
918 $again->{size} = 1
850 if $img->repeat_mode != urxvt::RepeatNormal; 919 if $img->repeat_mode != urxvt::RepeatNormal;
851 920
852 # if the expression is sensitive to external events, prepare reevaluation then
853
854 my $repeat;
855
856 if (my $again = $state->{again}) { 921 if (my $again = $again->{time}) {
857 $repeat = 1;
858 my $self = $self; 922 my $self = $self;
859 $state->{timer} = $again == $old->{again} 923 $state->{timer} = $again == $old->{again}
860 ? $old->{timer} 924 ? $old->{timer}
861 : urxvt::timer->new->after ($again)->interval ($again)->cb (sub { 925 : urxvt::timer->new->after ($again)->interval ($again)->cb (sub {
862 ++$self->{counter}; 926 ++$self->{counter};
863 $self->recalculate 927 $self->recalculate
864 }); 928 });
865 } 929 }
866 930
867 if (delete $state->{position_sensitive}) { 931 if ($again->{position}) {
868 $repeat = 1;
869 $self->enable (position_change => sub { $_[0]->recalculate }); 932 $self->enable (position_change => sub { $_[0]->recalculate });
870 } else { 933 } else {
871 $self->disable ("position_change"); 934 $self->disable ("position_change");
872 } 935 }
873 936
874 if (delete $state->{size_sensitive}) { 937 if ($again->{size}) {
875 $repeat = 1;
876 $self->enable (size_change => sub { $_[0]->recalculate }); 938 $self->enable (size_change => sub { $_[0]->recalculate });
877 } else { 939 } else {
878 $self->disable ("size_change"); 940 $self->disable ("size_change");
879 } 941 }
880 942
881 if (delete $state->{rootpmap_sensitive}) { 943 if ($again->{rootpmap}) {
882 $repeat = 1;
883 $self->enable (rootpmap_change => sub { $_[0]->recalculate }); 944 $self->enable (rootpmap_change => sub {
945 delete $_[0]{once_cache}; # this will override once-block values from
946 $_[0]->recalculate;
947 });
884 } else { 948 } else {
885 $self->disable ("rootpmap_change"); 949 $self->disable ("rootpmap_change");
886 } 950 }
887 951
888 # clear stuff we no longer need 952 # clear stuff we no longer need
889 953
890 %$old = (); 954 %$old = ();
891 955
892 unless ($repeat) { 956 unless (%$again) {
893 delete $self->{state}; 957 delete $self->{state};
894 delete $self->{expr}; 958 delete $self->{expr};
895 } 959 }
896 960
897 # set background pixmap 961 # set background pixmap

Diff Legend

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