--- rxvt-unicode/src/perl/background 2012/06/14 19:31:17 1.59 +++ rxvt-unicode/src/perl/background 2019/09/17 20:38:14 1.98 @@ -1,12 +1,22 @@ #! perl -#:META:X_RESOURCE:%.expr:string:background expression -#:META:X_RESOURCE:%.border:boolean:respect the terminal border -#:META:X_RESOURCE:%.interval:seconds:minimum time between updates +#:META:RESOURCE:%.expr:string:background expression +#:META:RESOURCE:%.border:boolean:respect the terminal border +#:META:RESOURCE:%.interval:seconds:minimum time between updates +#:META:RESOURCE:pixmap:file[;geom]:set image as background +#:META:RESOURCE:backgroundPixmap:file[;geom]:set image as background +#:META:RESOURCE:tr:boolean:set root pixmap as background +#:META:RESOURCE:transparent:boolean:set root pixmap as background +#:META:RESOURCE:tint:color:tint background with color +#:META:RESOURCE:tintColor:color:tint background with color +#:META:RESOURCE:sh:number:shade background by number % +#:META:RESOURCE:shading:number:shade background by number % +#:META:RESOURCE:blr:HxV:gaussian-blur background with radii +#:META:RESOURCE:blurRadius:HxV:gaussian-blur background with radii =head1 NAME - background - manage terminal background +background - manage terminal background =head1 SYNOPSIS @@ -14,6 +24,30 @@ --background-border --background-interval seconds +=head1 QUICK AND DIRTY CHEAT SHEET + +Load a random jpeg image and tile the background with it without scaling +or anything else: + + load "/path/to/img.jpg" + +The same, but use mirroring/reflection instead of tiling: + + mirror load "/path/to/img.jpg" + +Load an image and scale it to exactly fill the terminal window: + + scale keep { load "/path/to/img.jpg" } + +Implement pseudo-transparency by using a suitably-aligned root pixmap +as window background: + + rootalign root + +Likewise, but keep a blurred copy: + + rootalign keep { blur 10, root } + =head1 DESCRIPTION This extension manages the terminal background by creating a picture that @@ -28,11 +62,11 @@ For example, to load an image and scale it to the window size, you would use: - urxvt --background-expr 'scale load "/path/to/mybg.png"' + urxvt --background-expr 'scale keep { load "/path/to/mybg.png" }' Or specified as a X resource: - URxvt.background-expr: scale load "/path/to/mybg.png" + URxvt.background.expr: scale keep { load "/path/to/mybg.png" } =head1 THEORY OF OPERATION @@ -55,9 +89,9 @@ pixmap is replaced by another one the root background changes; or when the timer elapses), then the expression will be evaluated again. -For example, an expression such as C scales the -image to the window size, so it relies on the window size and will -be reevaluated each time it is changed, but not when it moves for +For example, an expression such as C scales the image to the window size, so it relies on the window size +and will be reevaluated each time it is changed, but not when it moves for example. That ensures that the picture always fills the terminal, even after its size changes. @@ -66,15 +100,18 @@ Expressions are normal Perl expressions, in fact, they are Perl blocks - which means you could use multiple lines and statements: - again 3600; - if (localtime now)[6]) { - return scale load "$HOME/weekday.png"; - } else { - return scale load "$HOME/sunday.png"; + scale keep { + again 3600; + if (localtime now)[6]) { + return load "$HOME/weekday.png"; + } else { + return load "$HOME/sunday.png"; + } } -This expression is evaluated once per hour. It will set F as -background on Sundays, and F on all other days. +This inner expression is evaluated once per hour (and whenever the +terminal window is resized). It sets F as background on +Sundays, and F on all other days. Fortunately, we expect that most expressions will be much simpler, with little Perl knowledge needed. @@ -107,7 +144,7 @@ scale 2, load "$HOME/mypic.png" This enlarges the image by a factor of 2 (200%). As you can see, C -has now two arguments, the C<200> and the C expression, while +has now two arguments, the C<2> and the C expression, while C only has one argument. Arguments are separated from each other by commas. @@ -117,61 +154,108 @@ scale 0.5, 2, load "$HOME/mypic.png" -Other effects than scaling are also readily available, for example, you can -tile the image to fill the whole window, instead of resizing it: +IF you try out these expressions, you might suffer from some sluggishness, +because each time the terminal is resized, it loads the PNG image again +and scales it. Scaling is usually fast (and unavoidable), but loading the +image can be quite time consuming. This is where C comes in handy: + + scale 0.5, 2, keep { load "$HOME/mypic.png" } + +The C operator executes all the statements inside the braces only +once, or when it thinks the outcome might change. In other cases it +returns the last value computed by the brace block. - tile load "$HOME/mypic.png" +This means that the C is only executed once, which makes it much +faster, but also means that more memory is being used, because the loaded +image must be kept in memory at all times. In this expression, the +trade-off is likely worth it. -In fact, images returned by C are in C mode by default, so the C operator -is kind of superfluous. +But back to effects: Other effects than scaling are also readily +available, for example, you can tile the image to fill the whole window, +instead of resizing it: -Another common effect is to mirror the image, so that the same edges touch: + tile keep { load "$HOME/mypic.png" } - mirror load "$HOME/mypic.png" +In fact, images returned by C are in C mode by default, so the +C operator is kind of superfluous. -This is also a typical background expression: +Another common effect is to mirror the image, so that the same edges +touch: + + mirror keep { load "$HOME/mypic.png" } + +Another common background expression is: rootalign root -It first takes a snapshot of the screen background image, and then -moves it to the upper left corner of the screen - the result is -pseudo-transparency, as the image seems to be static while the window is -moved around. +This one first takes a snapshot of the screen background image, and then +moves it to the upper left corner of the screen (as opposed to the upper +left corner of the terminal window)- the result is pseudo-transparency: +the image seems to be static while the window is moved around. + +=head2 COLOUR SPECIFICATIONS + +Whenever an operator expects a "colour", then this can be specified in one +of two ways: Either as string with an X11 colour specification, such as: + + "red" # named colour + "#f00" # simple rgb + "[50]red" # red with 50% alpha + "TekHVC:300/50/50" # anything goes + +OR as an array reference with one, three or four components: + + [0.5] # 50% gray, 100% alpha + [0.5, 0, 0] # dark red, no green or blur, 100% alpha + [0.5, 0, 0, 0.7] # same with explicit 70% alpha + +=head2 CACHING AND SENSITIVITY -=head2 CYCLES AND CACHING +Since some operations (such as C and C) can take a long time, +caching results can be very important for a smooth operation. Caching can +also be useful to reduce memory usage, though, for example, when an image +is cached by C, it could be shared by multiple terminal windows +running inside urxvtd. -As has been mentioned before, the expression might be evaluated multiple -times. Each time the expression is reevaluated, a new cycle is said to -have begun. Many operators cache their results till the next cycle. +=head3 C caching -For example, the C operator keeps a copy of the image. If it is -asked to load the same image on the next cycle it will not load it again, -but return the cached copy. +The most important way to cache expensive operations is to use C. The C operator takes a block of multiple statements enclosed +by C<{}> and keeps the return value in memory. -This only works for one cycle though, so as long as you load the same -image every time, it will always be cached, but when you load a different -image, it will forget about the first one. +An expression can be "sensitive" to various external events, such as +scaling or moving the window, root background changes and timers. Simply +using an expression (such as C without parameters) that depends on +certain changing values (called "variables"), or using those variables +directly, will make an expression sensitive to these events - for example, +using C or C will make the expression sensitive to the terminal +size, and thus to resizing events. -This allows you to either speed things up by keeping multiple images in -memory, or conserve memory by loading images more often. +When such an event happens, C will automatically trigger a +reevaluation of the whole expression with the new value of the expression. -For example, you can keep two images in memory and use a random one like -this: +C is most useful for expensive operations, such as C: - my $img1 = load "img1.png"; - my $img2 = load "img2.png"; - (0.5 > rand) ? $img1 : $img2 + rootalign keep { blur 20, root } -Since both images are "loaded" every time the expression is evaluated, -they are always kept in memory. Contrast this version: +This makes a blurred copy of the root background once, and on subsequent +calls, just root-aligns it. Since C is usually quite slow and +C is quite fast, this trades extra memory (for the cached +blurred pixmap) with speed (blur only needs to be redone when root +changes). - my $path1 = "img1.png"; - my $path2 = "img2.png"; - load ((0.5 > rand) ? $path1 : $path2) +=head3 C caching -Here, a path is selected randomly, and load is only called for one image, -so keeps only one image in memory. If, on the next evaluation, luck -decides to use the other path, then it will have to load that image again. +The C operator itself does not keep images in memory, but as long as +the image is still in memory, C will use the in-memory image instead +of loading it freshly from disk. + +That means that this expression: + + keep { load "$HOME/path..." } + +Not only caches the image in memory, other terminal instances that try to +C it can reuse that in-memory copy. =head1 REFERENCE @@ -206,8 +290,8 @@ our %_IMG_CACHE; our $HOME; -our ($self, $old, $new); -our ($x, $y, $w, $h); +our ($self, $frame); +our ($x, $y, $w, $h, $focus); # enforce at least this interval between updates our $MIN_INTERVAL = 6/59.951; @@ -215,6 +299,11 @@ { package urxvt::bgdsl; # background language + sub FR_PARENT() { 0 } # parent frame, if any - must be #0 + sub FR_CACHE () { 1 } # cached values + sub FR_AGAIN () { 2 } # what this expr is sensitive to + sub FR_STATE () { 3 } # watchers etc. + use List::Util qw(min max sum shuffle); =head2 PROVIDERS/GENERATORS @@ -230,37 +319,35 @@ Loads the image at the given C<$path>. The image is set to plane tiling mode. -Loaded images will be cached for one cycle, and shared between temrinals -running in the same process (e.g. in C). +If the image is already in memory (e.g. because another terminal instance +uses it), then the in-memory copy is returned instead. =item load_uc $path -Load uncached - same as load, but does not cache the image. This function -is most useufl if you want to optimise a background expression in some -way. +Load uncached - same as load, but does not cache the image, which means it +is I loaded from the filesystem again, even if another copy of it +is in memory at the time. =cut sub load_uc($) { + $self->new_img_from_file ($_[0]) + } + + sub load($) { my ($path) = @_; $_IMG_CACHE{$path} || do { - my $img = $self->new_img_from_file ($path); + my $img = load_uc $path; Scalar::Util::weaken ($_IMG_CACHE{$path} = $img); $img } } - sub load($) { - my ($path) = @_; - - $new->{load}{$path} = $old->{load}{$path} || load_uc $path; - } - =item root Returns the root window pixmap, that is, hopefully, the background image -of your screen. The image is set to extend mode. +of your screen. This function makes your expression root sensitive, that means it will be reevaluated when the bg image changes. @@ -268,7 +355,7 @@ =cut sub root() { - $new->{again}{rootpmap} = 1; + $frame->[FR_AGAIN]{rootpmap} = 1; $self->new_img_from_root } @@ -306,11 +393,17 @@ =item merge $img ... Takes any number of images and merges them together, creating a single -image containing them all. +image containing them all. The tiling mode of the first image is used as +the tiling mode of the resulting image. + +This function is called automatically when an expression returns multiple +images. =cut sub merge(@) { + return $_[0] unless $#_; + # rather annoyingly clumsy, but optimisation is for another time my $x0 = +1e9; @@ -332,6 +425,7 @@ } my $base = $self->new_img (urxvt::PictStandardARGB32, $x0, $y0, $x1 - $x0, $y1 - $y0); + $base->repeat_mode ($_[0]->repeat_mode); $base->fill ([0, 0, 0, 0]); $base->draw ($_) @@ -340,6 +434,8 @@ $base } +=back + =head2 TILING MODES The following operators modify the tiling mode of an image, that is, the @@ -440,22 +536,24 @@ window is the full window by default, and the character area only when in border-respect mode). -Using these functions make your expression sensitive to window moves. +Using these functions makes your expression sensitive to window moves. These functions are mainly useful to align images to the root window. Example: load an image and align it so it looks as if anchored to the -background. +background (that's exactly what C does btw.): - move -TX, -TY, load "mybg.png" + move -TX, -TY, keep { load "mybg.png" } =item TW +=item TH + Return the width (C) and height (C) of the terminal window (the terminal window is the full window by default, and the character area only when in border-respect mode). -Using these functions make your expression sensitive to window resizes. +Using these functions makes your expression sensitive to window resizes. These functions are mainly useful to scale images, or to clip images to the window size to conserve memory. @@ -463,14 +561,31 @@ Example: take the screen background, clip it to the window size, blur it a bit, align it to the window position and use it as background. - clip move -TX, -TY, once { blur 5, root } + clip move -TX, -TY, keep { blur 5, root } + +=item FOCUS + +Returns a boolean indicating whether the terminal window has keyboard +focus, in which case it returns true. + +Using this function makes your expression sensitive to focus changes. + +A common use case is to fade the background image when the terminal loses +focus, often together with the C<-fade> command line option. In fact, +there is a special function for just that use case: C. + +Example: use two entirely different background images, depending on +whether the window has focus. + + FOCUS ? keep { load "has_focus.jpg" } : keep { load "no_focus.jpg" } =cut - sub TX() { $new->{again}{position} = 1; $x } - sub TY() { $new->{again}{position} = 1; $y } - sub TW() { $new->{again}{size} = 1; $w } - sub TH() { $new->{again}{size} = 1; $h } + sub TX () { $frame->[FR_AGAIN]{position} = 1; $x } + sub TY () { $frame->[FR_AGAIN]{position} = 1; $y } + sub TW () { $frame->[FR_AGAIN]{size} = 1; $w } + sub TH () { $frame->[FR_AGAIN]{size} = 1; $h } + sub FOCUS() { $frame->[FR_AGAIN]{focus} = 1; $focus } =item now @@ -487,7 +602,8 @@ Example: load some image and rotate it according to the time of day (as if it were the hour pointer of a clock). Update this image every minute. - again 60; rotate 50, 50, (now % 86400) * -720 / 86400, scale load "myclock.png" + again 60; + rotate 50, 50, (now % 86400) * -72 / 8640, scale keep { load "myclock.png" } =item counter $seconds @@ -499,12 +615,12 @@ sub now() { urxvt::NOW } sub again($) { - $new->{again}{time} = $_[0]; + $frame->[FR_AGAIN]{time} = $_[0]; } sub counter($) { - $new->{again}{time} = $_[0]; - $self->{counter} + 0 + $frame->[FR_AGAIN]{time} = $_[0]; + $frame->[FR_STATE]{counter} + 0 } =back @@ -526,7 +642,7 @@ larger than the image, then the tiling mode defines how the extra pixels will be filled. -If C<$x> an C<$y> are missing, then C<0> is assumed for both. +If C<$x> and C<$y> are missing, then C<0> is assumed for both. If C<$width> and C<$height> are missing, then the window size will be assumed. @@ -534,7 +650,7 @@ Example: load an image, blur it, and clip it to the window size to save memory. - clip blur 10, load "mybg.png" + clip keep { blur 10, load "mybg.png" } =cut @@ -554,7 +670,7 @@ Scales the image by the given factors in horizontal (C<$width>) and vertical (C<$height>) direction. -If only one factor is give, it is used for both directions. +If only one factor is given, it is used for both directions. If no factors are given, scales the image to the window size without keeping aspect. @@ -638,7 +754,7 @@ Example: load an image and center it. - center pad load "mybg.png" + center keep { pad load "mybg.png" } =item rootalign $img @@ -649,7 +765,7 @@ Example: load a background image, put it in mirror mode and root align it. - rootalign mirror load "mybg.png" + rootalign keep { mirror load "mybg.png" } Example: take the screen background and align it, giving the illusion of transparency as long as the window isn't in front of other windows. @@ -684,23 +800,22 @@ move -TX, -TY, $_[0] } -=item rotate $center_x, $center_y, $degrees +=item rotate $center_x, $center_y, $degrees, $img -Rotates the image by C<$degrees> degrees, counter-clockwise, around the -pointer at C<$center_x> and C<$center_y> (specified as factor of image -width/height). +Rotates the image clockwise by C<$degrees> degrees, around the point at +C<$center_x> and C<$center_y> (specified as factor of image width/height). -#TODO# new width, height, maybe more operators? +Example: rotate the image by 90 degrees around its center. -Example: rotate the image by 90 degrees + rotate 0.5, 0.5, 90, keep { load "$HOME/mybg.png" } =cut sub rotate($$$$) { my $img = pop; $img->rotate ( - $_[0] * $img->w, - $_[1] * $img->h, + $_[0] * ($img->w + $img->x), + $_[1] * ($img->h + $img->y), $_[2] * (3.14159265 / 180), ) } @@ -713,6 +828,34 @@ =over 4 +=item tint $color, $img + +Tints the image in the given colour. + +Example: tint the image red. + + tint "red", load "rgb.png" + +Example: the same, but specify the colour by component. + + tint [1, 0, 0], load "rgb.png" + +=cut + + sub tint($$) { + $_[1]->tint ($_[0]) + } + +=item shade $factor, $img + +Shade the image by the given factor. + +=cut + + sub shade($$) { + $_[1]->shade ($_[0]) + } + =item contrast $factor, $img =item contrast $r, $g, $b, $img @@ -751,6 +894,8 @@ Due to idiosyncrasies in the underlying XRender extension, biases less than zero can be I slow. +You can also try the experimental(!) C operator. + =cut sub contrast($$;$$;$) { @@ -777,6 +922,26 @@ $img } +=item muladd $mul, $add, $img # EXPERIMENTAL + +First multiplies the pixels by C<$mul>, then adds C<$add>. This can be used +to implement brightness and contrast at the same time, with a wider value +range than contrast and brightness operators. + +Due to numerous bugs in XRender implementations, it can also introduce a +number of visual artifacts. + +Example: increase contrast by a factor of C<$c> without changing image +brightness too much. + + muladd $c, (1 - $c) * 0.5, $img + +=cut + + sub muladd($$$) { + $_[2]->muladd ($_[0], $_[1]) + } + =item blur $radius, $img =item blur $radius_horz, $radius_vert, $img @@ -796,6 +961,39 @@ $img->blur ($_[0], @_ >= 2 ? $_[1] : $_[0]) } +=item focus_fade $img + +=item focus_fade $factor, $img + +=item focus_fade $factor, $color, $img + +Fades the image by the given factor (and colour) when focus is lost (the +same as the C<-fade>/C<-fadecolor> command line options, which also supply +the default values for C and C<$color>. Unlike with C<-fade>, the +C<$factor> is a real value, not a percentage value (that is, 0..1, not +0..100). + +Example: do the right thing when focus fading is requested. + + focus_fade load "mybg.jpg"; + +=cut + + sub focus_fade($;$$) { + my $img = pop; + + return $img + if FOCUS; + + my $fade = @_ >= 1 ? $_[0] : defined $self->resource ("fade") ? $self->resource ("fade") * 0.01 : 0; + my $color = @_ >= 2 ? $_[1] : $self->resource ("color+" . urxvt::Color_fade); + + $img = $img->tint ($color) if $color ne "rgb:00/00/00"; + $img = $img->muladd (1 - $fade, 0) if $fade; + + $img + } + =back =head2 OTHER STUFF @@ -805,59 +1003,218 @@ =over 4 -=item once { ... } +=item keep { ... } -This function takes a code block as argument, that is, one or more +This operator takes a code block as argument, that is, one or more statements enclosed by braces. -The trick is that this code block is only evaluated once - future calls -will simply return the original image (yes, it should only be used with -images). +The trick is that this code block is only evaluated when the outcome +changes - on other calls the C simply returns the image it computed +previously (yes, it should only be used with images). Or in other words, +C I the result of the code block so it doesn't need to be +computed again. + +This can be extremely useful to avoid redoing slow operations - for +example, if your background expression takes the root background, blurs it +and then root-aligns it it would have to blur the root background on every +window move or resize. + +Another example is C, which can be quite slow. + +In fact, urxvt itself encloses the whole expression in some kind of +C block so it only is reevaluated as required. + +Putting the blur into a C block will make sure the blur is only done +once, while the C is still done each time the window moves. + + rootalign keep { blur 10, root } + +This leaves the question of how to force reevaluation of the block, +in case the root background changes: If expression inside the block +is sensitive to some event (root background changes, window geometry +changes), then it will be reevaluated automatically as needed. + +=back + +=head1 OLD BACKGROUND IMAGE SETTINGS + +This extension also provides support for the old options/resources and +OSC sequences for setting a background image. These settings are +B and will be removed in future versions. + +=head2 OPTIONS AND RESOURCES + +=over 4 + +=item B<-pixmap> I + +=item B I + +Use the specified image file as the window's background and also +optionally specify a colon separated list of operations to modify it. +Note that you may need to quote the C<;> character when using the +command line option, as C<;> is usually a metacharacter in shells. +Supported operations are: + +=over 4 + +=item B + +sets scale and position. B<"W" / "H"> specify the horizontal/vertical +scale (percent), and B<"X" / "Y"> locate the image centre (percent). A +scale of 0 disables scaling. + +=item B + +enables tiling + +=item B + +maintain the image aspect ratio when scaling + +=item B + +use the position of the terminal window relative to the root window as +the image offset, simulating a root window background + +=back + +The default scale and position setting is C<100x100+50+50>. +Alternatively, a predefined set of templates can be used to achieve +the most common setups: + +=over 4 + +=item B + +the image is tiled with no scaling. Equivalent to 0x0+0+0:op=tile + +=item B + +the image is scaled to fill the whole window maintaining the aspect +ratio and centered. Equivalent to 100x100+50+50:op=keep-aspect + +=item B + +the image is scaled to fill the whole window. Equivalent to 100x100 + +=item B + +the image is centered with no scaling. Equivalent to 0x0+50+50 + +=item B + +the image is tiled with no scaling and using 'root' positioning. +Equivalent to 0x0:op=tile:op=root-align + +=back + +If multiple templates are specified the last one wins. Note that a +template overrides all the scale, position and operations settings. + +If used in conjunction with pseudo-transparency, the specified image +will be blended over the transparent background using alpha-blending. -This can be extremely useful to avoid redoign the same slow operations -again and again- for example, if your background expression takes the root -background, blurs it and then root-aligns it it would have to blur the -root background on every window move or resize. +=item B<-tr>|B<+tr> -Putting the blur into a C block will make sure the blur is only done -once: +=item B I - rootlign once { blur 10, root } +Turn on/off pseudo-transparency by using the root pixmap as background. -This leaves the question of how to force reevaluation of the block, in -case the root background changes: Right now, all once blocks forget that -they ahve been executed before each time the root background changes (if -the expression is sensitive to that) or when C is called. +=item B<-tint> I -=item once_again +=item B I -Resets all C block as if they had never been called, i.e. on the -next call they will be reevaluated again. +Tint the transparent background with the given colour. Note that a +black tint yields a completely black image while a white tint yields +the image unchanged. + +=item B<-sh> I + +=item B I + +Darken (0 .. 99) or lighten (101 .. 200) the transparent background. +A value of 100 means no shading. + +=item B<-blr> I + +=item B I + +Apply gaussian blur with the specified radius to the transparent +background. If a single number is specified, the vertical and +horizontal radii are considered to be the same. Setting one of the +radii to 1 and the other to a large number creates interesting effects +on some backgrounds. The maximum radius value is 128. An horizontal or +vertical radius of 0 disables blurring. + +=back + +=head2 OSC sequences + +This extension will react to the following OSC sequences. Note that +this extension will not be autoloaded when these are used currenmtly, +so to make urxvt recognize them, you have to enable the C +extension. One way to achieve that is to use the C<--background-expr ''> +command line argument or by specifying an empty C> +resource. + +=over 4 + +=item B<< C >> Change transparent background tint colour to B<< C >>. + +=item B<< C >> Change/Query background image +parameters: the value of B<< C >> can be one of the following +commands: + +=over 4 + +=item B<< C >> + +display scale and position in the title + +=item B<< C<;WxH+X+Y> >> + +change scale and/or position + +=item B<< C >> + +change background image + +=back =cut - sub once(&) { - my $once = $self->{once_cache}{$_[0]+0} ||= do { - local $new->{again}; - my @res = $_[0](); - [$new->{again}, \@res] - }; + sub keep(&) { + my $id = $_[0]+0; + + local $frame = $self->{frame_cache}{$id} ||= [$frame]; + + unless ($frame->[FR_CACHE]) { + $frame->[FR_CACHE] = [ $_[0]() ]; + + my $self = $self; + my $frame = $frame; + Scalar::Util::weaken $frame; + $self->compile_frame ($frame, sub { + # clear this frame cache, also for all parents + for (my $frame = $frame; $frame; $frame = $frame->[0]) { + undef $frame->[FR_CACHE]; + } - $new->{again} = { - %{ $new->{again} }, - %{ $once->[0] } + $self->recalculate; + }); }; # in scalar context we always return the first original result, which # is not quite how perl works. wantarray - ? @{ $once->[1] } - : $once->[1][0] + ? @{ $frame->[FR_CACHE] } + : $frame->[FR_CACHE][0] } - sub once_again() { - delete $self->{once_cache}; - } +# sub keep_clear() { +# delete $self->{frame_cache}; +# } =back @@ -866,8 +1223,23 @@ } sub parse_expr { - my $expr = eval "sub {\npackage urxvt::bgdsl;\n#line 0 'background expression'\n$_[0]\n}"; - die if $@; + my ($expr) = @_; + + # an empty expression is valid and represents the default background + if ($expr !~ /\S/) { + $expr = sub { + undef + }; + } else { + $expr = eval + "sub {\n" + . "package urxvt::bgdsl;\n" + . "#line 0 'background expression'\n" + . "$expr\n" + . "}"; + die if $@; + } + $expr } @@ -875,10 +1247,65 @@ sub set_expr { my ($self, $expr) = @_; + $self->{root} = []; # the outermost frame $self->{expr} = $expr; $self->recalculate; } +# takes a hash of sensitivity indicators and installs watchers +sub compile_frame { + my ($self, $frame, $cb) = @_; + + my $state = $frame->[urxvt::bgdsl::FR_STATE] ||= {}; + my $again = $frame->[urxvt::bgdsl::FR_AGAIN]; + + # don't keep stuff alive + Scalar::Util::weaken $state; + + if ($again->{nested}) { + $state->{nested} = 1; + } else { + delete $state->{nested}; + } + + if (my $interval = $again->{time}) { + $state->{time} = [$interval, urxvt::timer->new->after ($interval)->interval ($interval)] + if $state->{time}[0] != $interval; + + # callback *might* have changed, although we could just rule that out + $state->{time}[1]->cb (sub { + ++$state->{counter}; + $cb->(); + }); + } else { + delete $state->{time}; + } + + if ($again->{position}) { + $state->{position} = $self->on (position_change => $cb); + } else { + delete $state->{position}; + } + + if ($again->{size}) { + $state->{size} = $self->on (size_change => $cb); + } else { + delete $state->{size}; + } + + if ($again->{rootpmap}) { + $state->{rootpmap} = $self->on (rootpmap_change => $cb); + } else { + delete $state->{rootpmap}; + } + + if ($again->{focus}) { + $state->{focus} = $self->on (focus_in => $cb, focus_out => $cb); + } else { + delete $state->{focus}; + } +} + # evaluate the current bg expression sub recalculate { my ($arg_self) = @_; @@ -894,85 +1321,274 @@ $arg_self->{next_refresh} = urxvt::NOW + $MIN_INTERVAL; - # set environment to evaluate user expression + unless ($arg_self->has_render) { + warn "background extension needs RENDER extension 0.10 or higher, ignoring background-expr.\n"; + return; + } - local $self = $arg_self; + # set environment to evaluate user expression - local $HOME = $ENV{HOME}; - local $old = $self->{state}; - local $new = my $state = $self->{state} = {}; + local $self = $arg_self; + local $HOME = $ENV{HOME}; + local $frame = $self->{root}; - ($x, $y, $w, $h) = - $self->background_geometry ($self->{border}); + ($x, $y, $w, $h) = $self->background_geometry ($self->{border}); + $focus = $self->focus; # evaluate user expression - my $img = eval { $self->{expr}->() }; - warn $@ if $@;#d# - die "background-expr did not return an image.\n" if !UNIVERSAL::isa $img, "urxvt::img"; - - # if the expression is sensitive to external events, prepare reevaluation then - - my $again = delete $state->{again}; - - $again->{size} = 1 - if $img->repeat_mode != urxvt::RepeatNormal; - - if (my $again = $again->{time}) { - my $self = $self; - $state->{timer} = $again == $old->{again} - ? $old->{timer} - : urxvt::timer->new->after ($again)->interval ($again)->cb (sub { - ++$self->{counter}; - $self->recalculate - }); - } + my @img = eval { $self->{expr}->() }; + die $@ if $@; + die "background-expr did not return anything.\n" unless @img; - if ($again->{position}) { - $self->enable (position_change => sub { $_[0]->recalculate }); + if ($img[0]) { + die "background-expr: expected image(s), got something else.\n" + if grep { !UNIVERSAL::isa $_, "urxvt::img" } @img; + + my $img = urxvt::bgdsl::merge @img; + + $frame->[FR_AGAIN]{size} = 1 + if $img->repeat_mode != urxvt::RepeatNormal; + + # if the expression is sensitive to external events, prepare reevaluation then + $self->compile_frame ($frame, sub { $arg_self->recalculate }); + + # clear stuff we no longer need + +# unless (%{ $frame->[FR_STATE] }) { +# delete $self->{state}; +# delete $self->{expr}; +# } + + # set background pixmap + + $self->set_background ($img, $self->{border}); } else { - $self->disable ("position_change"); + $self->clr_background; } - if ($again->{size}) { - $self->enable (size_change => sub { $_[0]->recalculate }); - } else { - $self->disable ("size_change"); + $self->scr_recolor (0); + $self->want_refresh; +} + +sub old_bg_opts { + my ($self, $arg) = @_; + + $arg or return; + + my @str = split /;/, $arg; + + return unless $str[0] or $self->{bg_opts}->{path}; + + my $bg_opts = $self->{bg_opts}; + + if ($str[0]) { + $bg_opts->{tile} = 0; + $bg_opts->{keep_aspect} = 0; + $bg_opts->{root_align} = 0; + $bg_opts->{h_scale} = $bg_opts->{v_scale} = 100; + $bg_opts->{h_align} = $bg_opts->{v_align} = 50; + $bg_opts->{path} = $str[0]; + } + + my @oplist = split /:/, $str[1]; + + for (@oplist) { + if (/style=tiled/i) { + $bg_opts->{tile} = 1; + $bg_opts->{keep_aspect} = 0; + $bg_opts->{root_align} = 0; + $bg_opts->{h_scale} = $bg_opts->{v_scale} = 0; + $bg_opts->{h_align} = $bg_opts->{v_align} = 0; + } elsif (/style=aspect-stretched/i) { + $bg_opts->{tile} = 0; + $bg_opts->{keep_aspect} = 1; + $bg_opts->{root_align} = 0; + $bg_opts->{h_scale} = $bg_opts->{v_scale} = 100; + $bg_opts->{h_align} = $bg_opts->{v_align} = 50; + } elsif (/style=stretched/i) { + $bg_opts->{tile} = 0; + $bg_opts->{keep_aspect} = 0; + $bg_opts->{root_align} = 0; + $bg_opts->{h_scale} = $bg_opts->{v_scale} = 100; + $bg_opts->{h_align} = $bg_opts->{v_align} = 50; + } elsif (/style=centered/i) { + $bg_opts->{tile} = 0; + $bg_opts->{keep_aspect} = 0; + $bg_opts->{root_align} = 0; + $bg_opts->{h_scale} = $bg_opts->{v_scale} = 0; + $bg_opts->{h_align} = $bg_opts->{v_align} = 50; + } elsif (/style=root-tiled/i) { + $bg_opts->{tile} = 1; + $bg_opts->{keep_aspect} = 0; + $bg_opts->{root_align} = 1; + $bg_opts->{h_scale} = $bg_opts->{v_scale} = 0; + $bg_opts->{h_align} = $bg_opts->{v_align} = 0; + } elsif (/op=tile/i) { + $bg_opts->{tile} = 1; + } elsif (/op=keep-aspect/i) { + $bg_opts->{keep_aspect} = 1; + } elsif (/op=root-align/i) { + $bg_opts->{root_align} = 1; + } elsif (/^ =? ([0-9]+)? (?:[xX] ([0-9]+))? ([+-][0-9]+)? ([+-][0-9]+)? $/x) { + my ($w, $h, $x, $y) = ($1, $2, $3, $4); + + if ($str[0]) { + $w = $h unless defined $w; + $h = $w unless defined $h; + $y = $x unless defined $y; + } + + $bg_opts->{h_scale} = $w if defined $w; + $bg_opts->{v_scale} = $h if defined $h; + $bg_opts->{h_align} = $x if defined $x; + $bg_opts->{v_align} = $y if defined $y; + } } +} - if ($again->{rootpmap}) { - $self->enable (rootpmap_change => sub { - delete $_[0]{once_cache}; # this will override once-block values from - $_[0]->recalculate; - }); - } else { - $self->disable ("rootpmap_change"); +# helper function, quote string as perl without allowing +# any code execution or other shenanigans. does not +# support binary NULs in string. +sub q0 { + (my $str = shift) =~ s/\x00//g; # make sure there really aren't any embedded NULs + "q\x00$str\x00" +} + +sub old_bg_expr { + my ($self) = @_; + + my $expr; + + my $bg_opts = $self->{bg_opts}; + + if ($bg_opts->{root} =~ /^\s*(?:true|yes|on|1)\s*$/i) { + $expr .= "tile ("; + + my $shade = $bg_opts->{shade}; + + if ($shade) { + $shade = List::Util::min $shade, 200; + $shade = List::Util::max $shade, -100; + $shade = 200 - (100 + $shade) if $shade < 0; + + $shade = $shade * 0.01 - 1; + $expr .= "shade $shade, "; + } + + my $tint = $bg_opts->{tint}; + + if ($tint) { + $tint = q0 $tint; + $expr .= "tint $tint,"; + } + + my $blur = $bg_opts->{blur}; + + if ($blur and $blur =~ /^ =? ([0-9]+)? (?:[xX] ([0-9]+))? $/x) { + my $hr = defined $1 ? $1 : 1; + my $vr = defined $2 ? $2 : $hr; + + if ($hr != 0 and $vr != 0) { + $expr .= "blur $hr, $vr, "; + } + } + + $expr .= "rootalign root)"; } - # clear stuff we no longer need + if ($bg_opts->{path}) { + my $file_expr; + my $h_scale = $bg_opts->{h_scale} * 0.01; + my $v_scale = $bg_opts->{v_scale} * 0.01; + my $h_align = $bg_opts->{h_align} * 0.01; + my $v_align = $bg_opts->{v_align} * 0.01; + + if (!$bg_opts->{tile}) { + $file_expr .= "pad ("; + } else { + $file_expr .= "tile ("; + } + + if ($bg_opts->{root_align}) { + $file_expr .= "rootalign "; + } else { + $file_expr .= "align $h_align, $v_align, "; + } + + if ($h_scale != 0 and $v_scale != 0) { + my $op = $bg_opts->{keep_aspect} ? "fit" : "resize"; + $file_expr .= "$op TW * $h_scale, TH * $v_scale, "; + } + + my $path = q0 $bg_opts->{path}; - %$old = (); + $file_expr .= "keep { load $path })"; - unless (%$again) { - delete $self->{state}; - delete $self->{expr}; + if ($expr) { + $expr .= ", tint (\"[50]white\", $file_expr)"; + } else { + $expr = $file_expr; + } } - # set background pixmap + $expr +} - $self->set_background ($img, $self->{border}); - $self->scr_recolour (0); - $self->want_refresh; +sub on_osc_seq { + my ($self, $op, $arg) = @_; + + $self->{bg_opts} or return; + + $op =~ /^(?:20|705)$/ or return; + + if ($op eq "20") { + if ($arg eq "?") { + my $h_scale = $self->{bg_opts}->{h_scale}; + my $v_scale = $self->{bg_opts}->{v_scale}; + my $h_align = $self->{bg_opts}->{h_align}; + my $v_align = $self->{bg_opts}->{v_align}; + $self->cmd_parse ("\033]2;[${h_scale}x${v_scale}+${h_align}+${v_align}]\007"); + } else { + $self->old_bg_opts ($arg); + my $expr = $self->old_bg_expr; + $self->set_expr (parse_expr $expr) if $expr; + } + } elsif ($op eq "705") { + $self->{bg_opts}->{tint} = $arg; + my $expr = $self->old_bg_expr; + $self->set_expr (parse_expr $expr) if $expr; + } + + 1 +} + +sub find_resource { + my ($self, $res, $opt) = @_; + + my $v = $self->x_resource ($opt); + $v = $self->x_resource ($res) unless defined $v; + + $v } sub on_start { my ($self) = @_; - my $expr = $self->x_resource ("%.expr") - or return; + my $expr = $self->x_resource ("%.expr"); + + if (!$expr) { + $self->{bg_opts} = { h_scale => 100, v_scale => 100, + h_align => 50, v_align => 50 }; + + $self->{bg_opts}{shade} = $self->find_resource ("shading", "sh"); + $self->{bg_opts}{tint} = $self->find_resource ("tintColor", "tint"); + $self->{bg_opts}{blur} = $self->find_resource ("blurRadius", "blr"); + $self->{bg_opts}{root} = $self->find_resource ("transparent", "tr"); - $self->has_render - or die "background extension needs RENDER extension 0.10 or higher, ignoring background-expr.\n"; + $self->old_bg_opts ($self->find_resource ("backgroundPixmap", "pixmap")); + $expr = $self->old_bg_expr; + } $self->set_expr (parse_expr $expr); $self->{border} = $self->x_resource_boolean ("%.border");