[ViewVC] Contents of: cvs/rxvt-unicode/src/perl/background

#! perl

#:META:X_RESOURCE:%.expr:string:background expression
#:META:X_RESOURCE:%.border.:boolean:respect the terminal border

#TODO: once, rootalign

=head1 background - manage terminal background

=head2 SYNOPSIS

   rxvt -background-expr 'background expression'
        -background-border

=head2 DESCRIPTION

=head2 REFERENCE

=cut

our $EXPR;
#$EXPR = 'move W * 0.1, -H * 0.1, resize W * 0.5, H * 0.5, repeat_none load "opensource.png"';
$EXPR = 'move -TX, -TY, load "argb.png"';
#$EXPR = '
#   rotate W, H, 50, 50, counter 1/59.95, repeat_mirror,
#   clip X, Y, W, H, repeat_mirror,
#   load "/root/pix/das_fette_schwein.jpg"
#';
#$EXPR = 'solid "red"';
#$EXPR = 'blur root, 10, 10'
#$EXPR = 'blur move (root, -x, -y), 5, 5'
#resize load "/root/pix/das_fette_schwein.jpg", w, h

our ($self, $old, $new);
our ($x, $y, $w, $h);

# enforce at least this interval between updates
our $MIN_INTERVAL = 1/100;

{
   package urxvt::bgdsl; # background language

=head2 PROVIDERS/GENERATORS

These functions provide an image, by loading it from disk, grabbing it
from the root screen or by simply generating it. They are used as starting
points to get an image you can play with.

=over 4

=item load $path

Loads the image at the given C<$path>. The image is set to plane tiling
mode.

Loaded images will be cached for one cycle.

=cut

   sub load($) {
      my ($path) = @_;

      $new->{load}{$path} = $old->{load}{$path} || $self->new_img_from_file ($path);
   }

=item root

Returns the root window pixmap, that is, hopefully, the background image
of your screen. The image is set to extend mode.

This function makes your expression root sensitive, that means it will be
reevaluated when the bg image changes.

=cut

   sub root() {
      $new->{rootpmap_sensitive} = 1;
      die "root op not supported, exg, we need you";
   }

=item solid $colour

=item solid $width, $height, $colour

Creates a new image and completely fills it with the given colour. The
image is set to tiling mode.

If <$width> and C<$height> are omitted, it creates a 1x1 image, which is
useful for solid backgrounds or for use in filtering effects.

=cut

   sub solid($$;$) {
      my $colour = pop;

      my $img = $self->new_img (urxvt::PictStandardARGB32, $_[0] || 1, $_[1] || 1);
      $img->fill ($colour);
      $img
   }

=back

=head2 VARIABLES

The following functions provide variable data such as the terminal
window dimensions. Most of them make your expression sensitive to some
events, for example using C<TW> (terminal width) means your expression is
evaluated again when the terminal is resized.

=over 4

=item TX

=item TY

Return the X and Y coordinates 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 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.

   move -TX, -TY, load "mybg.png"

=item TW

Return the width (C<TW>) and height (C<TH>) 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.

These functions are mainly useful to scale images, or to clip images to
the window size to conserve memory.

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, blur 5, root

=cut

   sub TX() { $new->{position_sensitive} = 1; $x }
   sub TY() { $new->{position_sensitive} = 1; $y }
   sub TW() { $new->{size_sensitive}     = 1; $w }
   sub TH() { $new->{size_sensitive}     = 1; $h }

=item now

Returns the current time as (fractional) seconds since the epoch.

Using this expression does I<not> make your expression sensitive to time,
but the next two functions do.

=item again $seconds

When this function is used the expression will be reevaluated again in
C<$seconds> seconds.

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 TW, TH, 50, 50, (now % 86400) * -720 / 86400, scale load "myclock.png"

=item counter $seconds

Like C<again>, but also returns an increasing counter value, starting at
0, which might be useful for some simple animation effects.

=cut

   sub now() { urxvt::NOW }

   sub again($) {
      $new->{again} = $_[0];
   }

   sub counter($) {
      $new->{again} = $_[0];
      $self->{counter} + 0
   }

=back

=head2 TILING MODES

The following operators modify the tiling mode of an image, that is, the
way that pixels outside the image area are painted when the image is used.

=over 4

=item tile $img

Tiles the whole plane with the image and returns this new image - or in
other words, it returns a copy of the image in plane tiling mode.

Example: load an image and tile it over the background, without
resizing. The C<tile> call is superfluous because C<load> already defaults
to tiling mode.

   tile load "mybg.png"

=item mirror $img

Similar to tile, but reflects the image each time it uses a new copy, so
that top edges always touch top edges, right edges always touch right
edges and so on (with normal tiling, left edges always touch right edges
and top always touch bottom edges).

Exmaple: load an image and mirror it over the background, avoiding sharp
edges at the image borders at the expense of mirroring the image itself

   mirror load "mybg.png"

=item pad $img

Takes an image and modifies it so that all pixels outside the image area
become transparent. This mode is most useful when you want to place an
image over another image or the background colour while leaving all
background pixels outside the image unchanged.

Example: load an image and display it in the upper left corner. The rets
of the space is left "empty" (transparent or wahtever your compisotr does
in alpha mode, else background colour).

   pad load "mybg.png"

=item extend $img

Extends the image over the whole plane, using the closest pixel in the
area outside the image. This mode is mostly useful when you more complex
filtering operations and want the pixels outside the image to have the
same values as the pixels near the edge.

Example: just for curiosity, how does this pixel extension stuff work?

   extend move 50, 50, load "mybg.png"

=cut

   sub pad($) {
      my $img = $_[0]->clone;
      $img->repeat_mode (urxvt::RepeatNone);
      $img
   }

   sub tile($) {
      my $img = $_[0]->clone;
      $img->repeat_mode (urxvt::RepeatNormal);
      $img
   }

   sub mirror($) {
      my $img = $_[0]->clone;
      $img->repeat_mode (urxvt::RepeatReflect);
      $img
   }

   sub extend($) {
      my $img = $_[0]->clone;
      $img->repeat_mode (urxvt::RepeatPad);
      $img
   }

=back

=head2 PIXEL OPERATORS

The following operators modify the image pixels in various ways.

=over 4

=item clone $img

Returns an exact copy of the image.

=cut

   sub clone($) {
      $_[0]->clone
   }

=item clip $img

=item clip $width, $height, $img

=item clip $x, $y, $width, $height, $img

Clips an image to the given rectangle. If the rectangle is outside the
image area (e.g. when C<$x> or C<$y> are negative) or the rectangle is
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<$width> and C<$height> are missing, then the window size will be
assumed.

Example: load an image, blur it, and clip it to the window size to save
memory.

   clip blur 10, load "mybg.png"

=cut

   sub clip($;$$;$$) {
      my $img = pop;
      my $h = pop || TH;
      my $w = pop || TW;
      $img->sub_rect ($_[0], $_[1], $w, $h)
   }

=item scale $img

=item scale $size_percent, $img

=item scale $width_percent, $height_percent, $img

Scales the image by the given percentages in horizontal
(C<$width_percent>) and vertical (C<$height_percent>) direction.

If only one percentage is give, it is used for both directions.

If no percentages are given, scales the image to the window size without
keeping aspect.

=item resize $width, $height, $img

Resizes the image to exactly C<$width> times C<$height> pixels.

=cut

#TODO: maximise, maximise_fill?

   sub scale($;$;$) {
      my $img = pop;

      @_ == 2 ? $img->scale ($_[0] * $img->w * 0.01, $_[1] * $img->h * 0.01)
      : @_    ? $img->scale ($_[0] * $img->w * 0.01, $_[0] * $img->h * 0.01)
              : $img->scale (TW, TH)
   }

   sub resize($$$) {
      my $img = pop;
      $img->scale ($_[0], $_[1])
   }

   sub move($$;$) {
      my $img = pop->clone;
      $img->move ($_[0], $_[1]);
      $img
   }

   sub rotate($$$$$$) {
      my $img = pop;
      $img->rotate (
         $_[0],
         $_[1],
         $_[2] * $img->w * .01,
         $_[3] * $img->h * .01,
         $_[4] * (3.14159265 / 180),
      )
   }

   sub blur($$;$) {
      my $img = pop;
      $img->blur ($_[0], @_ >= 2 ? $_[1] : $_[0])
   }

   sub contrast($$;$$;$) {
      my $img = pop;
      my ($r, $g, $b, $a) = @_;

      ($g, $b) = ($r, $r) if @_ < 4;
      $a       = 1        if @_ < 5;

      $img = $img->clone;
      $img->contrast ($r, $g, $b, $a);
      $img
   }

   sub brightness($$;$$;$) {
      my $img = pop;
      my ($r, $g, $b, $a) = @_;

      ($g, $b) = ($r, $r) if @_ < 4;
      $a       = 1        if @_ < 5;

      $img = $img->clone;
      $img->brightness ($r, $g, $b, $a);
      $img
   }

=back

=cut

}

sub parse_expr {
   my $expr = eval "sub {\npackage urxvt::bgdsl;\n#line 0 'background expression'\n$_[0]\n}";
   die if $@;
   $expr
}

# compiles a parsed expression
sub set_expr {
   my ($self, $expr) = @_;

   $self->{expr} = $expr;
   $self->recalculate;
}

# evaluate the current bg expression
sub recalculate {
   my ($arg_self) = @_;

   # rate limit evaluation

   if ($arg_self->{next_refresh} > urxvt::NOW) {
      $arg_self->{next_refresh_timer} = urxvt::timer->new->after ($arg_self->{next_refresh} - urxvt::NOW)->cb (sub {
         $arg_self->recalculate;
      });
      return;
   }

   $arg_self->{next_refresh} = urxvt::NOW + $MIN_INTERVAL;

   # set environment to evaluate user expression

   local $self = $arg_self;

   local $old = $self->{state};
   local $new = my $state = $self->{state} = {};

   ($x, $y, $w, $h) =
      $self->background_geometry ($self->{border});

   # evaluate user expression

   my $img = eval { $self->{expr}->() };
   warn $@ if $@;#d#
   die if !UNIVERSAL::isa $img, "urxvt::img";

   $state->{size_sensitive} = 1
      if $img->repeat_mode != urxvt::RepeatNormal;

   # if the expression is sensitive to external events, prepare reevaluation then

   my $repeat;

   if (my $again = $state->{again}) {
      $repeat = 1;
      my $self = $self;
      $state->{timer} = $again == $old->{again}
                        ? $old->{timer}
                        : urxvt::timer->new->after ($again)->interval ($again)->cb (sub {
                             ++$self->{counter};
                             $self->recalculate
                          });
   }

   if (delete $state->{position_sensitive}) {
      $repeat = 1;
      $self->enable (position_change => sub { $_[0]->recalculate });
   } else {
      $self->disable ("position_change");
   }

   if (delete $state->{size_sensitive}) {
      $repeat = 1;
      $self->enable (size_change => sub { $_[0]->recalculate });
   } else {
      $self->disable ("size_change");
   }

   if (delete $state->{rootpmap_sensitive}) {
      $repeat = 1;
      $self->enable (rootpmap_change => sub { $_[0]->recalculate });
   } else {
      $self->disable ("rootpmap_change");
   }

   # clear stuff we no longer need

   %$old = ();

   unless ($repeat) {
      delete $self->{state};
      delete $self->{expr};
   }

   # set background pixmap

   $self->set_background ($img, $self->{border});
   $self->scr_recolour (0);
   $self->want_refresh;
}

sub on_start {
   my ($self) = @_;

   my $expr = $self->x_resource ("background.expr")
      or return;

   $self->set_expr (parse_expr $expr);
   $self->{border} = $self->x_resource_boolean ("background.border");

   ()
}

Revision:	1.35
Committed:	Fri Jun 8 08:06:38 2012 UTC (12 years ago) by root
Branch:	MAIN
Changes since 1.34:	+3 -0 lines
Log Message:	* empty log message *
#	Content
1	#! perl
2
3	#:META:X_RESOURCE:%.expr:string:background expression
4	#:META:X_RESOURCE:%.border.:boolean:respect the terminal border
5
6	#TODO: once, rootalign
7
8	=head1 background - manage terminal background
9
10	=head2 SYNOPSIS
11
12	rxvt -background-expr 'background expression'
13	-background-border
14
15	=head2 DESCRIPTION
16
17	=head2 REFERENCE
18
19	=cut
20
21	our $EXPR;
22	#$EXPR = 'move W * 0.1, -H * 0.1, resize W * 0.5, H * 0.5, repeat_none load "opensource.png"';
23	$EXPR = 'move -TX, -TY, load "argb.png"';
24	#$EXPR = '
25	# rotate W, H, 50, 50, counter 1/59.95, repeat_mirror,
26	# clip X, Y, W, H, repeat_mirror,
27	# load "/root/pix/das_fette_schwein.jpg"
28	#';
29	#$EXPR = 'solid "red"';
30	#$EXPR = 'blur root, 10, 10'
31	#$EXPR = 'blur move (root, -x, -y), 5, 5'
32	#resize load "/root/pix/das_fette_schwein.jpg", w, h
33
34	our ($self, $old, $new);
35	our ($x, $y, $w, $h);
36
37	# enforce at least this interval between updates
38	our $MIN_INTERVAL = 1/100;
39
40	{
41	package urxvt::bgdsl; # background language
42
43	=head2 PROVIDERS/GENERATORS
44
45	These functions provide an image, by loading it from disk, grabbing it
46	from the root screen or by simply generating it. They are used as starting
47	points to get an image you can play with.
48
49	=over 4
50
51	=item load $path
52
53	Loads the image at the given C<$path>. The image is set to plane tiling
54	mode.
55
56	Loaded images will be cached for one cycle.
57
58	=cut
59
60	sub load($) {
61	my ($path) = @_;
62
63	$new->{load}{$path} = $old->{load}{$path} \|\| $self->new_img_from_file ($path);
64	}
65
66	=item root
67
68	Returns the root window pixmap, that is, hopefully, the background image
69	of your screen. The image is set to extend mode.
70
71	This function makes your expression root sensitive, that means it will be
72	reevaluated when the bg image changes.
73
74	=cut
75
76	sub root() {
77	$new->{rootpmap_sensitive} = 1;
78	die "root op not supported, exg, we need you";
79	}
80
81	=item solid $colour
82
83	=item solid $width, $height, $colour
84
85	Creates a new image and completely fills it with the given colour. The
86	image is set to tiling mode.
87
88	If <$width> and C<$height> are omitted, it creates a 1x1 image, which is
89	useful for solid backgrounds or for use in filtering effects.
90
91	=cut
92
93	sub solid($$;$) {
94	my $colour = pop;
95
96	my $img = $self->new_img (urxvt::PictStandardARGB32, $_[0] \|\| 1, $_[1] \|\| 1);
97	$img->fill ($colour);
98	$img
99	}
100
101	=back
102
103	=head2 VARIABLES
104
105	The following functions provide variable data such as the terminal
106	window dimensions. Most of them make your expression sensitive to some
107	events, for example using C<TW> (terminal width) means your expression is
108	evaluated again when the terminal is resized.
109
110	=over 4
111
112	=item TX
113
114	=item TY
115
116	Return the X and Y coordinates of the terminal window (the terminal
117	window is the full window by default, and the character area only when in
118	border-respect mode).
119
120	Using these functions make your expression sensitive to window moves.
121
122	These functions are mainly useful to align images to the root window.
123
124	Example: load an image and align it so it looks as if anchored to the
125	background.
126
127	move -TX, -TY, load "mybg.png"
128
129	=item TW
130
131	Return the width (C<TW>) and height (C<TH>) of the terminal window (the
132	terminal window is the full window by default, and the character area only
133	when in border-respect mode).
134
135	Using these functions make your expression sensitive to window resizes.
136
137	These functions are mainly useful to scale images, or to clip images to
138	the window size to conserve memory.
139
140	Example: take the screen background, clip it to the window size, blur it a
141	bit, align it to the window position and use it as background.
142
143	clip move -TX, -TY, blur 5, root
144
145	=cut
146
147	sub TX() { $new->{position_sensitive} = 1; $x }
148	sub TY() { $new->{position_sensitive} = 1; $y }
149	sub TW() { $new->{size_sensitive} = 1; $w }
150	sub TH() { $new->{size_sensitive} = 1; $h }
151
152	=item now
153
154	Returns the current time as (fractional) seconds since the epoch.
155
156	Using this expression does I<not> make your expression sensitive to time,
157	but the next two functions do.
158
159	=item again $seconds
160
161	When this function is used the expression will be reevaluated again in
162	C<$seconds> seconds.
163
164	Example: load some image and rotate it according to the time of day (as if it were
165	the hour pointer of a clock). update this image every minute.
166
167	again 60; rotate TW, TH, 50, 50, (now % 86400) * -720 / 86400, scale load "myclock.png"
168
169	=item counter $seconds
170
171	Like C<again>, but also returns an increasing counter value, starting at
172	0, which might be useful for some simple animation effects.
173
174	=cut
175
176	sub now() { urxvt::NOW }
177
178	sub again($) {
179	$new->{again} = $_[0];
180	}
181
182	sub counter($) {
183	$new->{again} = $_[0];
184	$self->{counter} + 0
185	}
186
187	=back
188
189	=head2 TILING MODES
190
191	The following operators modify the tiling mode of an image, that is, the
192	way that pixels outside the image area are painted when the image is used.
193
194	=over 4
195
196	=item tile $img
197
198	Tiles the whole plane with the image and returns this new image - or in
199	other words, it returns a copy of the image in plane tiling mode.
200
201	Example: load an image and tile it over the background, without
202	resizing. The C<tile> call is superfluous because C<load> already defaults
203	to tiling mode.
204
205	tile load "mybg.png"
206
207	=item mirror $img
208
209	Similar to tile, but reflects the image each time it uses a new copy, so
210	that top edges always touch top edges, right edges always touch right
211	edges and so on (with normal tiling, left edges always touch right edges
212	and top always touch bottom edges).
213
214	Exmaple: load an image and mirror it over the background, avoiding sharp
215	edges at the image borders at the expense of mirroring the image itself
216
217	mirror load "mybg.png"
218
219	=item pad $img
220
221	Takes an image and modifies it so that all pixels outside the image area
222	become transparent. This mode is most useful when you want to place an
223	image over another image or the background colour while leaving all
224	background pixels outside the image unchanged.
225
226	Example: load an image and display it in the upper left corner. The rets
227	of the space is left "empty" (transparent or wahtever your compisotr does
228	in alpha mode, else background colour).
229
230	pad load "mybg.png"
231
232	=item extend $img
233
234	Extends the image over the whole plane, using the closest pixel in the
235	area outside the image. This mode is mostly useful when you more complex
236	filtering operations and want the pixels outside the image to have the
237	same values as the pixels near the edge.
238
239	Example: just for curiosity, how does this pixel extension stuff work?
240
241	extend move 50, 50, load "mybg.png"
242
243	=cut
244
245	sub pad($) {
246	my $img = $_[0]->clone;
247	$img->repeat_mode (urxvt::RepeatNone);
248	$img
249	}
250
251	sub tile($) {
252	my $img = $_[0]->clone;
253	$img->repeat_mode (urxvt::RepeatNormal);
254	$img
255	}
256
257	sub mirror($) {
258	my $img = $_[0]->clone;
259	$img->repeat_mode (urxvt::RepeatReflect);
260	$img
261	}
262
263	sub extend($) {
264	my $img = $_[0]->clone;
265	$img->repeat_mode (urxvt::RepeatPad);
266	$img
267	}
268
269	=back
270
271	=head2 PIXEL OPERATORS
272
273	The following operators modify the image pixels in various ways.
274
275	=over 4
276
277	=item clone $img
278
279	Returns an exact copy of the image.
280
281	=cut
282
283	sub clone($) {
284	$_[0]->clone
285	}
286
287	=item clip $img
288
289	=item clip $width, $height, $img
290
291	=item clip $x, $y, $width, $height, $img
292
293	Clips an image to the given rectangle. If the rectangle is outside the
294	image area (e.g. when C<$x> or C<$y> are negative) or the rectangle is
295	larger than the image, then the tiling mode defines how the extra pixels
296	will be filled.
297
298	If C<$x> an C<$y> are missing, then C<0> is assumed for both.
299
300	If C<$width> and C<$height> are missing, then the window size will be
301	assumed.
302
303	Example: load an image, blur it, and clip it to the window size to save
304	memory.
305
306	clip blur 10, load "mybg.png"
307
308	=cut
309
310	sub clip($;$$;$$) {
311	my $img = pop;
312	my $h = pop \|\| TH;
313	my $w = pop \|\| TW;
314	$img->sub_rect ($_[0], $_[1], $w, $h)
315	}
316
317	=item scale $img
318
319	=item scale $size_percent, $img
320
321	=item scale $width_percent, $height_percent, $img
322
323	Scales the image by the given percentages in horizontal
324	(C<$width_percent>) and vertical (C<$height_percent>) direction.
325
326	If only one percentage is give, it is used for both directions.
327
328	If no percentages are given, scales the image to the window size without
329	keeping aspect.
330
331	=item resize $width, $height, $img
332
333	Resizes the image to exactly C<$width> times C<$height> pixels.
334
335	=cut
336
337	#TODO: maximise, maximise_fill?
338
339	sub scale($;$;$) {
340	my $img = pop;
341
342	@_ == 2 ? $img->scale ($_[0] * $img->w * 0.01, $_[1] * $img->h * 0.01)
343	: @_ ? $img->scale ($_[0] * $img->w * 0.01, $_[0] * $img->h * 0.01)
344	: $img->scale (TW, TH)
345	}
346
347	sub resize($$$) {
348	my $img = pop;
349	$img->scale ($_[0], $_[1])
350	}
351
352	sub move($$;$) {
353	my $img = pop->clone;
354	$img->move ($_[0], $_[1]);
355	$img
356	}
357
358	sub rotate($$$$$$) {
359	my $img = pop;
360	$img->rotate (
361	$_[0],
362	$_[1],
363	$_[2] * $img->w * .01,
364	$_[3] * $img->h * .01,
365	$_[4] * (3.14159265 / 180),
366	)
367	}
368
369	sub blur($$;$) {
370	my $img = pop;
371	$img->blur ($_[0], @_ >= 2 ? $_[1] : $_[0])
372	}
373
374	sub contrast($$;$$;$) {
375	my $img = pop;
376	my ($r, $g, $b, $a) = @_;
377
378	($g, $b) = ($r, $r) if @_ < 4;
379	$a = 1 if @_ < 5;
380
381	$img = $img->clone;
382	$img->contrast ($r, $g, $b, $a);
383	$img
384	}
385
386	sub brightness($$;$$;$) {
387	my $img = pop;
388	my ($r, $g, $b, $a) = @_;
389
390	($g, $b) = ($r, $r) if @_ < 4;
391	$a = 1 if @_ < 5;
392
393	$img = $img->clone;
394	$img->brightness ($r, $g, $b, $a);
395	$img
396	}
397
398	=back
399
400	=cut
401
402	}
403
404	sub parse_expr {
405	my $expr = eval "sub {\npackage urxvt::bgdsl;\n#line 0 'background expression'\n$_[0]\n}";
406	die if $@;
407	$expr
408	}
409
410	# compiles a parsed expression
411	sub set_expr {
412	my ($self, $expr) = @_;
413
414	$self->{expr} = $expr;
415	$self->recalculate;
416	}
417
418	# evaluate the current bg expression
419	sub recalculate {
420	my ($arg_self) = @_;
421
422	# rate limit evaluation
423
424	if ($arg_self->{next_refresh} > urxvt::NOW) {
425	$arg_self->{next_refresh_timer} = urxvt::timer->new->after ($arg_self->{next_refresh} - urxvt::NOW)->cb (sub {
426	$arg_self->recalculate;
427	});
428	return;
429	}
430
431	$arg_self->{next_refresh} = urxvt::NOW + $MIN_INTERVAL;
432
433	# set environment to evaluate user expression
434
435	local $self = $arg_self;
436
437	local $old = $self->{state};
438	local $new = my $state = $self->{state} = {};
439
440	($x, $y, $w, $h) =
441	$self->background_geometry ($self->{border});
442
443	# evaluate user expression
444
445	my $img = eval { $self->{expr}->() };
446	warn $@ if $@;#d#
447	die if !UNIVERSAL::isa $img, "urxvt::img";
448
449	$state->{size_sensitive} = 1
450	if $img->repeat_mode != urxvt::RepeatNormal;
451
452	# if the expression is sensitive to external events, prepare reevaluation then
453
454	my $repeat;
455
456	if (my $again = $state->{again}) {
457	$repeat = 1;
458	my $self = $self;
459	$state->{timer} = $again == $old->{again}
460	? $old->{timer}
461	: urxvt::timer->new->after ($again)->interval ($again)->cb (sub {
462	++$self->{counter};
463	$self->recalculate
464	});
465	}
466
467	if (delete $state->{position_sensitive}) {
468	$repeat = 1;
469	$self->enable (position_change => sub { $_[0]->recalculate });
470	} else {
471	$self->disable ("position_change");
472	}
473
474	if (delete $state->{size_sensitive}) {
475	$repeat = 1;
476	$self->enable (size_change => sub { $_[0]->recalculate });
477	} else {
478	$self->disable ("size_change");
479	}
480
481	if (delete $state->{rootpmap_sensitive}) {
482	$repeat = 1;
483	$self->enable (rootpmap_change => sub { $_[0]->recalculate });
484	} else {
485	$self->disable ("rootpmap_change");
486	}
487
488	# clear stuff we no longer need
489
490	%$old = ();
491
492	unless ($repeat) {
493	delete $self->{state};
494	delete $self->{expr};
495	}
496
497	# set background pixmap
498
499	$self->set_background ($img, $self->{border});
500	$self->scr_recolour (0);
501	$self->want_refresh;
502	}
503
504	sub on_start {
505	my ($self) = @_;
506
507	my $expr = $self->x_resource ("background.expr")
508	or return;
509
510	$self->set_expr (parse_expr $expr);
511	$self->{border} = $self->x_resource_boolean ("background.border");
512
513	()
514	}
515