[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

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