Deliantra/Deliantra/MapWidget.pm

=head1 NAME

Crossfire::MapWidget - Gtk2 widget displaying cf maps

=head1 SYNOPSIS

  use Crossfire::MapWidget;

=head1 DESCRIPTION

=head2 METHODS

=over 4

=cut

package Crossfire::MapWidget;

use strict;

use Gtk2;

use Crossfire;
use Crossfire::Tilecache;

use Glib::Object::Subclass
   'Gtk2::DrawingArea';

use List::Util qw(min max);

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

   $self->signal_connect (destroy => sub {
      my ($self) = @_;

      $self->{tip}->destroy if $self->{tip};

      %$self = ();

      0
   });
   $self->signal_connect (realize => sub {
      my ($self) = @_;

      $self->{window} = $self->window;

      1
   });

   $self->set_redraw_on_allocate (0);
   $self->double_buffered (0);

   $self->{tooltip} = -1; # need focus in first

   # reduces unnecessary redraws
   $self->signal_connect (focus_in_event  => sub { $self->enable_tooltip;  1 });
   $self->signal_connect (focus_out_event => sub { $self->disable_tooltip; 1 });

   $self->signal_connect_after (enter_notify_event => sub { $self->update_tooltip; 0 });
   $self->signal_connect_after (leave_notify_event => sub { $self->update_tooltip; 0 });

   $self->signal_connect (size_request => sub {
      $_[1]->width  (TILESIZE);
      $_[1]->height (TILESIZE);

      1
   });

   $self->signal_connect (expose_event => sub { $self->expose ($_[1]); 1 });

   $self->signal_connect_after (configure_event => sub {
      $self->set_viewport ($self->{x}, $self->{y});

      0
   });

   $self->signal_connect (button_press_event => sub {
      my ($self, $event) = @_;

      my ($x, $y) = ($event->x, $event->y);

      if ($_[1]->button == 2 && !$self->{in_drag}) {
         $self->disable_tooltip;

         $_[0]->grab_focus;
         $self->{in_drag} = [$self->{x}, $self->{y}, $x, $y];
         return 1;
      }

      0
   });

   $self->signal_connect (motion_notify_event => sub {
      my ($self) = @_;

      $self->update_tooltip;

      if (my $di = $self->{in_drag}) {
         my ($x, $y) = $self->get_pointer;

         $self->set_viewport (
            $di->[0] + $di->[2] - $x,
            $di->[1] + $di->[3] - $y,
         );

         return 1;
      }

      0
   });

   $self->signal_connect (button_release_event => sub {
      my ($self) = @_;

      $self->enable_tooltip 
         if delete $self->{in_drag};

      0
   });

   # gtk+ supports no motion compression, a major lacking feature. we have to pay for the
   # workaround with incorrect behaviour and extra server-turnarounds.
   $self->add_events ([qw(button_press_mask button_release_mask button-motion-mask
                          pointer-motion-mask pointer-motion-hint-mask
                          enter-notify-mask leave-notify-mask)]);
   $self->can_focus (1);

#   $self->signal_connect (key_press_event => sub { $self->handle_key ($_[1]->keyval, $_[1]->state) });
}

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

   $self->{tooltip}++;
   $self->update_tooltip;
}

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

   $self->{tooltip}--;
   $self->update_tooltip;
}

sub overlay {
   my ($self, $name, $x, $y, $w, $h, $cb) = @_;

   if (my $ov = delete $self->{overlay}{$name}) {
      my ($x, $y, $w, $h) = @$ov;

      $self->queue_draw_area ($x - $self->{x}, $y - $self->{y}, $w, $h);
   }

   if ($h) {
      $self->{overlay}{$name} = [$x, $y, $w, $h, $cb];

      $self->queue_draw_area ($x - $self->{x}, $y - $self->{y}, $w, $h);
   }
}

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

   if ($self->{tooltip} >= 0
       && $self->mapped
       && $self->get_toplevel->has_toplevel_focus) {
      my $screen = $self->{window}->get_screen;

      if ($self->{window} == ($screen->get_display->get_window_at_pointer)[0]) {
         my ($pscreen, $x, $y) = $screen->get_display->get_pointer;

         if ($pscreen == $screen) {
            if (!$self->{tip}) {
               $self->{tip} = new Gtk2::Window "popup";
               $self->{tip}->can_focus (0);
               $self->{tip}->set_name ("gtk-tooltips");
               $self->{tip}->set_decorated (0);
               $self->{tip}->set_border_width (4);
               $self->{tip}->set_has_frame (0);
               $self->{tip}->set_resizable (0);
               $self->{tip}->set_transient_for ($self->get_toplevel);
            }

            my ($mx, $my) = $self->coord ($self->get_pointer);

            if ($self->{tipinfo}[0] != $mx || $self->{tipinfo}[1] != $my) {
               $self->fill_tooltip ($mx, $my);

               $self->{tipinfo} = [$mx, $my];

               $self->overlay (_tooltip => $mx * TILESIZE, $my * TILESIZE, TILESIZE, TILESIZE, sub {
                  my ($self, $x, $y) = @_;

                  $self->{window}->draw_rectangle ($_ & 1 ? $self->style->black_gc : $self->style->white_gc, 0,
                                                   $x + $_, $y + $_,
                                                   TILESIZE - 1 - $_ * 2, TILESIZE - 1 - $_ * 2)
                     for 0..3;

                  my $req = $self->{tip}->size_request;
                  $self->{tip}->resize ($req->width, $req->height);
               });
            }

            $self->{tip}->move ($x + TILESIZE, $y);
            $self->{tip}->show_all;

            return;
         }
      }
   }

   $self->overlay ("_tooltip");
   delete $self->{tipinfo};
   (delete $self->{tip})->destroy if $self->{tip};
}

sub fill_tooltip {
   my ($self, $x, $y) = @_;

   $self->{tip}->remove ($self->{tip}->get_children)
      if $self->{tip}->get_children;

   $self->{tip}->add (my $frame = new Gtk2::Frame "($x|$y)");

   if ($x < 0 || $x >= $self->{map}{width}
       || $y < 0 || $y >= $self->{map}{height}) {
     $frame->add (new Gtk2::Label "<off-map>");
   } else {
      $frame->add (my $vbox = new Gtk2::VBox 1, 1);

      #TODO: fill tooltip via signal, defaulting to this:

      # fill tooltip with info about $x, $y
      my $as = $self->{map}{map}[$x][$y] || [];
      for my $a (reverse @$as) {
         $vbox->add (my $hbox = new Gtk2::HBox 0, 2);

         my $tile = $Crossfire::Tilecache::TILECACHE{ $a->{face} || $ARCH->{$a->{_name}}{face} };

         # this is awful, is this really the best way?
         my $pb = new Gtk2::Gdk::Pixbuf 'rgb', 1, 8, TILESIZE, TILESIZE;
         $pb->fill (0x00000000);
         
         $Crossfire::Tilecache::TILECACHE->composite ($pb,
            0, 0,
            TILESIZE, TILESIZE,
            - ($tile->{idx} % 64) * TILESIZE, - TILESIZE * int $tile->{idx} / 64,
            1, 1, 'nearest', 255
         );

         $hbox->add (my $img = new_from_pixbuf Gtk2::Image $pb);
         $img->set_alignment (0, 0.5);

         $hbox->add (my $label = new Gtk2::Label $a->{_name});
         $label->set_alignment (0, 0.5);
      }
   }
}

sub set_viewport {
   my ($self, $x, $y) = @_;

   my $area = $self->allocation;

   $x = max 0, min $self->{width}  - $area->width , $x;
   $y = max 0, min $self->{height} - $area->height, $y;

   $self->window->scroll ($self->{x} - $x, $self->{y} - $y);

   ($self->{x}, $self->{y}) = ($x, $y);
}

sub set_map {
   my ($self, $map) = @_;

   $self->{map} = $map;

   $self->{width}  = $map->{width}  * TILESIZE;
   $self->{height} = $map->{height} * TILESIZE;
   
   $self->{x} =
   $self->{y} = 0;

   delete $self->{face};
   $self->update_map (0, 0, $self->{width}, $self->{height});
   delete $self->{tipinfo}; $self->update_tooltip;
   $self->invalidate_all;
}

sub coord {
   my ($self, $x, $y) = @_;

   (
      int +($self->{x} + $x) / TILESIZE,
      int +($self->{y} + $y) / TILESIZE,
   )
}

#sub handle_key {
#   my ($self, $key, $state) = @_;
#
#   $self->prefetch_cancel;
#
#   if ($state * "control-mask") {
#      if ($key == $Gtk2::Gdk::Keysyms{g}) {
#         my @sel = keys %{$self->{sel}};
#         $self->generate_thumbnails (@sel ? @sel : 0 .. $#{$self->{entry}});
#   }
#
#   1
#}

sub invalidate {
   my ($self, $x, $y, $w, $h) = @_;

   return unless $self->{window};

   $self->queue_draw_area (
      map $_ * TILESIZE, $x - 1 , $y - 1, $w + 2, $h + 2
   );
}

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

   $self->queue_draw;
}

sub update_map {
   my ($self, $x, $y, $w, $h) = @_;

   delete $self->{tipinfo}; $self->update_tooltip;

   push @{ $self->{queue_draw_areay} }, [$x * TILESIZE - $self->{x},
                                         $y * TILESIZE - $self->{y},
                                         $w * TILESIZE, $h * TILESIZE];

   $self->{update_map} ||= add Glib::Idle sub {
      delete $self->{update_map};
      delete $self->{overlay};
      
      my $map = $self->{map}{map};
      my $ov  = $self->{face} ||= [];

      my ($x, $w) = (0, $self->{map}{width});
      my ($y, $h) = (0, $self->{map}{height});

      my @x = ($x .. $x + $w - 1);
      my @y = ($y .. $y + $h - 1);

      my $TC = \%Crossfire::Tilecache::TILECACHE;

      my @ov;

      # update overlay map with bigfaces and chained faces
      my $a;
      for my $x (@x) {
         my $ass = $self->{map}{map}[$x];
         my $oss = $ov->[$x] ||= [];
         for my $y (@y) {
            my $os = $oss->[$y] = [];
            for my $a (@{ $ass->[$y] || [] }) {
               my $o = $ARCH->{$a->{_name}}
                  or (warn "arch '$a->{_name}' not found at ($x|$y)\n"), next;

               my $tile = $TC->{$a->{face} || $o->{face}}
                  or (warn "no gfx found for arch '$a->{_name}' at ($x|$y)\n"), next;

               if ($tile->{w} > 1 || $tile->{h} > 1) {
                  # bigfaces
                  for my $ox (0 .. $tile->{w} - 1) {
                     for my $oy (0 .. $tile->{h} - 1) {
                        push @ov, [$x + $ox, $y + $oy,
                                   $tile->{idx} + $ox + $oy * $tile->{w}];
                     }
                  }

               } elsif ($o->{more}) {
                  # linked faces
                  do {
                     my $tile = $TC->{$o->{face}}
                        or (warn "no gfx found for arch '$a->{_name}' at ($x*|$y*)\n"), next;
                     push @ov, [$x + $o->{x}, $y + $o->{y}, $tile->{idx}];
                  } while $o = $o->{more};

               } else {
                  # single face
                  push @$os, $tile->{idx};

               }
            }
         }
      }

      # bigger faces always on top, I don't give a shit to those who think otherwise
      for (@ov) {
         my ($x, $y, $idx) = @$_;

         push @{ $ov->[$x][$y] }, $idx;
      }

      $self->queue_draw_area (@$_)
         for @{ delete $self->{queue_draw_areay} };

      0
   };
}

sub expose {
   my ($self, $event) = @_;

   no integer;

   my $ox = $self->{x}; my $ix = int $ox / TILESIZE;
   my $oy = $self->{y}; my $iy = int $oy / TILESIZE;

   # get_rectangles is buggy in older versions
   my @rectangles = $Gtk2::VERSION > 1.115
                    ? $event->region->get_rectangles : $event->area;

   for my $area (@rectangles) {
      my ($x, $y, $w, $h) = $area->values; # x y w h

      my @x = ((int ($ox + $x) / TILESIZE) .. int +($ox + $x + $w + TILESIZE - 1) / TILESIZE);
      my @y = ((int ($oy + $y) / TILESIZE) .. int +($oy + $y + $h + TILESIZE - 1) / TILESIZE);

      my $PB = $Crossfire::Tilecache::TILECACHE;

      my $window = $self->{window};

      my $pb = new Gtk2::Gdk::Pixbuf 'rgb', 0, 8, TILESIZE * (@x + 1), TILESIZE * (@y + 1);
      $pb->fill (0x00000000);

      for my $x (@x) {
         my $dx = ($x - $x[0]) * TILESIZE;
         my $oss = $self->{face}[$x];

         for my $y (@y) {
            my $dy = ($y - $y[0]) * TILESIZE;

            for my $idx (@{$oss->[$y]}) {
               $PB->composite ($pb,
                  $dx, $dy,
                  TILESIZE, TILESIZE,
                  $dx - ($idx % 64) * TILESIZE, $dy - TILESIZE * int $idx / 64,
                  1, 1, 'nearest', 255
               );
            }
         }
      }

      $pb->render_to_drawable ($window, $self->style->black_gc,
               0, 0,
               $x[0] * TILESIZE - $ox, $y[0] * TILESIZE - $oy,
               TILESIZE * @x, TILESIZE * @y,
               'max', 0, 0);
   }

   $_->[4]->($self, $_->[0] - $self->{x}, $_->[1] - $self->{y})
      for values %{ $self->{overlay} || {} };
}

=back

=head1 AUTHOR

Marc Lehmann <schmorp@schmorp.de>

=cut

1

Revision:	1.13
Committed:	Tue Feb 7 17:41:25 2006 UTC (18 years, 3 months ago) by root
Branch:	MAIN
Changes since 1.12:	+65 -57 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	=head1 NAME
2
3			Crossfire::MapWidget - Gtk2 widget displaying cf maps
4
5			=head1 SYNOPSIS
6
7			use Crossfire::MapWidget;
8
9			=head1 DESCRIPTION
10
11			=head2 METHODS
12
13			=over 4
14
15			=cut
16
17			package Crossfire::MapWidget;
18
19			use strict;
20
21			use Gtk2;
22
23			use Crossfire;
24			use Crossfire::Tilecache;
25
26			use Glib::Object::Subclass
27			'Gtk2::DrawingArea';
28
29			use List::Util qw(min max);
30
31			sub INIT_INSTANCE {
32			my ($self) = @_;
33
34	root	1.7	$self->signal_connect (destroy => sub {
35			my ($self) = @_;
36	root	1.8
37	root	1.7	$self->{tip}->destroy if $self->{tip};
38	root	1.8
39	root	1.7	%$self = ();
40	root	1.8
41	root	1.7	0
42			});
43	root	1.1	$self->signal_connect (realize => sub {
44			my ($self) = @_;
45
46			$self->{window} = $self->window;
47
48			1
49			});
50
51	root	1.7	$self->set_redraw_on_allocate (0);
52	root	1.1	$self->double_buffered (0);
53
54	root	1.9	$self->{tooltip} = -1; # need focus in first
55
56	root	1.7	# reduces unnecessary redraws
57	root	1.9	$self->signal_connect (focus_in_event => sub { $self->enable_tooltip; 1 });
58			$self->signal_connect (focus_out_event => sub { $self->disable_tooltip; 1 });
59
60			$self->signal_connect_after (enter_notify_event => sub { $self->update_tooltip; 0 });
61			$self->signal_connect_after (leave_notify_event => sub { $self->update_tooltip; 0 });
62	root	1.7
63	root	1.1	$self->signal_connect (size_request => sub {
64	root	1.10	$_[1]->width (TILESIZE);
65			$_[1]->height (TILESIZE);
66	root	1.1
67			1
68			});
69
70	root	1.2	$self->signal_connect (expose_event => sub { $self->expose ($_[1]); 1 });
71	root	1.1
72			$self->signal_connect_after (configure_event => sub {
73			$self->set_viewport ($self->{x}, $self->{y});
74	root	1.2
75			0
76	root	1.1	});
77
78			$self->signal_connect (button_press_event => sub {
79			my ($self, $event) = @_;
80
81	root	1.5	my ($x, $y) = ($event->x, $event->y);
82	root	1.2
83	root	1.5	if ($_[1]->button == 2 && !$self->{in_drag}) {
84			$self->disable_tooltip;
85	root	1.1
86			$_[0]->grab_focus;
87			$self->{in_drag} = [$self->{x}, $self->{y}, $x, $y];
88	root	1.2	return 1;
89	root	1.1	}
90
91	root	1.2	0
92	root	1.1	});
93
94			$self->signal_connect (motion_notify_event => sub {
95			my ($self) = @_;
96
97	root	1.2	$self->update_tooltip;
98	root	1.1
99			if (my $di = $self->{in_drag}) {
100	root	1.2	my ($x, $y) = $self->get_pointer;
101
102	root	1.1	$self->set_viewport (
103			$di->[0] + $di->[2] - $x,
104			$di->[1] + $di->[3] - $y,
105			);
106
107	root	1.2	return 1;
108	root	1.1	}
109
110	root	1.2	0
111	root	1.1	});
112
113			$self->signal_connect (button_release_event => sub {
114			my ($self) = @_;
115
116	root	1.5	$self->enable_tooltip
117			if delete $self->{in_drag};
118	root	1.2
119	root	1.5	0
120	root	1.1	});
121
122			# gtk+ supports no motion compression, a major lacking feature. we have to pay for the
123			# workaround with incorrect behaviour and extra server-turnarounds.
124	root	1.8	$self->add_events ([qw(button_press_mask button_release_mask button-motion-mask
125	root	1.2	pointer-motion-mask pointer-motion-hint-mask
126			enter-notify-mask leave-notify-mask)]);
127	root	1.1	$self->can_focus (1);
128
129			# $self->signal_connect (key_press_event => sub { $self->handle_key ($_[1]->keyval, $_[1]->state) });
130			}
131
132	root	1.2	sub enable_tooltip {
133			my ($self) = @_;
134
135			$self->{tooltip}++;
136			$self->update_tooltip;
137			}
138
139			sub disable_tooltip {
140			my ($self) = @_;
141
142			$self->{tooltip}--;
143			$self->update_tooltip;
144			}
145
146	root	1.3	sub overlay {
147			my ($self, $name, $x, $y, $w, $h, $cb) = @_;
148
149			if (my $ov = delete $self->{overlay}{$name}) {
150			my ($x, $y, $w, $h) = @$ov;
151
152			$self->queue_draw_area ($x - $self->{x}, $y - $self->{y}, $w, $h);
153			}
154
155			if ($h) {
156			$self->{overlay}{$name} = [$x, $y, $w, $h, $cb];
157
158			$self->queue_draw_area ($x - $self->{x}, $y - $self->{y}, $w, $h);
159			}
160			}
161
162	root	1.2	sub update_tooltip {
163			my ($self) = @_;
164
165	root	1.9	if ($self->{tooltip} >= 0
166			&& $self->mapped
167			&& $self->get_toplevel->has_toplevel_focus) {
168	root	1.2	my $screen = $self->{window}->get_screen;
169
170	root	1.9	if ($self->{window} == ($screen->get_display->get_window_at_pointer)[0]) {
171			my ($pscreen, $x, $y) = $screen->get_display->get_pointer;
172
173			if ($pscreen == $screen) {
174			if (!$self->{tip}) {
175			$self->{tip} = new Gtk2::Window "popup";
176			$self->{tip}->can_focus (0);
177			$self->{tip}->set_name ("gtk-tooltips");
178			$self->{tip}->set_decorated (0);
179			$self->{tip}->set_border_width (4);
180			$self->{tip}->set_has_frame (0);
181			$self->{tip}->set_resizable (0);
182			$self->{tip}->set_transient_for ($self->get_toplevel);
183			}
184	root	1.2
185	root	1.9	my ($mx, $my) = $self->coord ($self->get_pointer);
186	root	1.2
187	root	1.9	if ($self->{tipinfo}[0] != $mx \|\| $self->{tipinfo}[1] != $my) {
188			$self->fill_tooltip ($mx, $my);
189	root	1.2
190	root	1.9	$self->{tipinfo} = [$mx, $my];
191	root	1.3
192	root	1.9	$self->overlay (_tooltip => $mx * TILESIZE, $my * TILESIZE, TILESIZE, TILESIZE, sub {
193			my ($self, $x, $y) = @_;
194	root	1.3
195	root	1.9	$self->{window}->draw_rectangle ($_ & 1 ? $self->style->black_gc : $self->style->white_gc, 0,
196			$x + $_, $y + $_,
197			TILESIZE - 1 - $_ * 2, TILESIZE - 1 - $_ * 2)
198			for 0..3;
199	root	1.3
200	root	1.9	my $req = $self->{tip}->size_request;
201			$self->{tip}->resize ($req->width, $req->height);
202			});
203			}
204	root	1.3
205	root	1.9	$self->{tip}->move ($x + TILESIZE, $y);
206	root	1.3	$self->{tip}->show_all;
207	root	1.9
208			return;
209	root	1.2	}
210			}
211			}
212
213	root	1.3	$self->overlay ("_tooltip");
214	root	1.2	delete $self->{tipinfo};
215			(delete $self->{tip})->destroy if $self->{tip};
216			}
217
218			sub fill_tooltip {
219			my ($self, $x, $y) = @_;
220
221			$self->{tip}->remove ($self->{tip}->get_children)
222			if $self->{tip}->get_children;
223
224			$self->{tip}->add (my $frame = new Gtk2::Frame "($x\|$y)");
225
226			if ($x < 0 \|\| $x >= $self->{map}{width}
227			\|\| $y < 0 \|\| $y >= $self->{map}{height}) {
228			$frame->add (new Gtk2::Label "<off-map>");
229			} else {
230	root	1.6	$frame->add (my $vbox = new Gtk2::VBox 1, 1);
231	root	1.2
232			#TODO: fill tooltip via signal, defaulting to this:
233
234			# fill tooltip with info about $x, $y
235			my $as = $self->{map}{map}[$x][$y] \|\| [];
236	root	1.9	for my $a (reverse @$as) {
237	root	1.6	$vbox->add (my $hbox = new Gtk2::HBox 0, 2);
238
239			my $tile = $Crossfire::Tilecache::TILECACHE{ $a->{face} \|\| $ARCH->{$a->{_name}}{face} };
240
241			# this is awful, is this really the best way?
242			my $pb = new Gtk2::Gdk::Pixbuf 'rgb', 1, 8, TILESIZE, TILESIZE;
243			$pb->fill (0x00000000);
244
245			$Crossfire::Tilecache::TILECACHE->composite ($pb,
246			0, 0,
247			TILESIZE, TILESIZE,
248			- ($tile->{idx} % 64) * TILESIZE, - TILESIZE * int $tile->{idx} / 64,
249			1, 1, 'nearest', 255
250			);
251
252			$hbox->add (my $img = new_from_pixbuf Gtk2::Image $pb);
253			$img->set_alignment (0, 0.5);
254
255			$hbox->add (my $label = new Gtk2::Label $a->{_name});
256	root	1.5	$label->set_alignment (0, 0.5);
257	root	1.2	}
258			}
259			}
260
261	root	1.1	sub set_viewport {
262			my ($self, $x, $y) = @_;
263
264			my $area = $self->allocation;
265
266			$x = max 0, min $self->{width} - $area->width , $x;
267			$y = max 0, min $self->{height} - $area->height, $y;
268
269			$self->window->scroll ($self->{x} - $x, $self->{y} - $y);
270
271			($self->{x}, $self->{y}) = ($x, $y);
272			}
273
274			sub set_map {
275			my ($self, $map) = @_;
276
277			$self->{map} = $map;
278
279			$self->{width} = $map->{width} * TILESIZE;
280			$self->{height} = $map->{height} * TILESIZE;
281
282			$self->{x} =
283			$self->{y} = 0;
284
285			delete $self->{face};
286			$self->update_map (0, 0, $self->{width}, $self->{height});
287	root	1.11	delete $self->{tipinfo}; $self->update_tooltip;
288	root	1.1	$self->invalidate_all;
289			}
290
291			sub coord {
292			my ($self, $x, $y) = @_;
293
294			(
295	root	1.4	int +($self->{x} + $x) / TILESIZE,
296			int +($self->{y} + $y) / TILESIZE,
297	root	1.1	)
298			}
299
300			#sub handle_key {
301			# my ($self, $key, $state) = @_;
302			#
303			# $self->prefetch_cancel;
304			#
305			# if ($state * "control-mask") {
306			# if ($key == $Gtk2::Gdk::Keysyms{g}) {
307			# my @sel = keys %{$self->{sel}};
308			# $self->generate_thumbnails (@sel ? @sel : 0 .. $#{$self->{entry}});
309			# }
310			#
311			# 1
312			#}
313
314			sub invalidate {
315			my ($self, $x, $y, $w, $h) = @_;
316
317			return unless $self->{window};
318
319			$self->queue_draw_area (
320			map $_ * TILESIZE, $x - 1 , $y - 1, $w + 2, $h + 2
321			);
322			}
323
324			sub invalidate_all {
325			my ($self) = @_;
326
327			$self->queue_draw;
328			}
329
330			sub update_map {
331			my ($self, $x, $y, $w, $h) = @_;
332
333	root	1.13	delete $self->{tipinfo}; $self->update_tooltip;
334
335			push @{ $self->{queue_draw_areay} }, [$x * TILESIZE - $self->{x},
336			$y * TILESIZE - $self->{y},
337			$w * TILESIZE, $h * TILESIZE];
338
339			$self->{update_map} \|\|= add Glib::Idle sub {
340			delete $self->{update_map};
341			delete $self->{overlay};
342
343			my $map = $self->{map}{map};
344			my $ov = $self->{face} \|\|= [];
345
346			my ($x, $w) = (0, $self->{map}{width});
347			my ($y, $h) = (0, $self->{map}{height});
348
349			my @x = ($x .. $x + $w - 1);
350			my @y = ($y .. $y + $h - 1);
351
352			my $TC = \%Crossfire::Tilecache::TILECACHE;
353
354			my @ov;
355
356			# update overlay map with bigfaces and chained faces
357			my $a;
358			for my $x (@x) {
359			my $ass = $self->{map}{map}[$x];
360			my $oss = $ov->[$x] \|\|= [];
361			for my $y (@y) {
362			my $os = $oss->[$y] = [];
363			for my $a (@{ $ass->[$y] \|\| [] }) {
364			my $o = $ARCH->{$a->{_name}}
365			or (warn "arch '$a->{_name}' not found at ($x\|$y)\n"), next;
366
367			my $tile = $TC->{$a->{face} \|\| $o->{face}}
368			or (warn "no gfx found for arch '$a->{_name}' at ($x\|$y)\n"), next;
369
370			if ($tile->{w} > 1 \|\| $tile->{h} > 1) {
371			# bigfaces
372			for my $ox (0 .. $tile->{w} - 1) {
373			for my $oy (0 .. $tile->{h} - 1) {
374			push @ov, [$x + $ox, $y + $oy,
375			$tile->{idx} + $ox + $oy * $tile->{w}];
376			}
377	root	1.1	}
378
379	root	1.13	} elsif ($o->{more}) {
380			# linked faces
381			do {
382			my $tile = $TC->{$o->{face}}
383			or (warn "no gfx found for arch '$a->{_name}' at ($x\|$y)\n"), next;
384			push @ov, [$x + $o->{x}, $y + $o->{y}, $tile->{idx}];
385			} while $o = $o->{more};
386
387			} else {
388			# single face
389			push @$os, $tile->{idx};
390	root	1.1
391	root	1.13	}
392	root	1.1	}
393			}
394			}
395
396	root	1.13	# bigger faces always on top, I don't give a shit to those who think otherwise
397			for (@ov) {
398			my ($x, $y, $idx) = @$_;
399	root	1.1
400	root	1.13	push @{ $ov->[$x][$y] }, $idx;
401			}
402	root	1.9
403	root	1.13	$self->queue_draw_area (@$_)
404			for @{ delete $self->{queue_draw_areay} };
405	root	1.11
406	root	1.13	0
407			};
408	root	1.1	}
409
410			sub expose {
411			my ($self, $event) = @_;
412
413			no integer;
414
415			my $ox = $self->{x}; my $ix = int $ox / TILESIZE;
416			my $oy = $self->{y}; my $iy = int $oy / TILESIZE;
417
418			# get_rectangles is buggy in older versions
419	root	1.11	my @rectangles = $Gtk2::VERSION > 1.115
420			? $event->region->get_rectangles : $event->area;
421
422			for my $area (@rectangles) {
423	root	1.1	my ($x, $y, $w, $h) = $area->values; # x y w h
424
425			my @x = ((int ($ox + $x) / TILESIZE) .. int +($ox + $x + $w + TILESIZE - 1) / TILESIZE);
426			my @y = ((int ($oy + $y) / TILESIZE) .. int +($oy + $y + $h + TILESIZE - 1) / TILESIZE);
427
428			my $PB = $Crossfire::Tilecache::TILECACHE;
429
430			my $window = $self->{window};
431
432			my $pb = new Gtk2::Gdk::Pixbuf 'rgb', 0, 8, TILESIZE * (@x + 1), TILESIZE * (@y + 1);
433			$pb->fill (0x00000000);
434
435			for my $x (@x) {
436			my $dx = ($x - $x[0]) * TILESIZE;
437			my $oss = $self->{face}[$x];
438
439			for my $y (@y) {
440			my $dy = ($y - $y[0]) * TILESIZE;
441
442			for my $idx (@{$oss->[$y]}) {
443			$PB->composite ($pb,
444			$dx, $dy,
445			TILESIZE, TILESIZE,
446			$dx - ($idx % 64) * TILESIZE, $dy - TILESIZE * int $idx / 64,
447			1, 1, 'nearest', 255
448			);
449			}
450			}
451			}
452
453			$pb->render_to_drawable ($window, $self->style->black_gc,
454			0, 0,
455			$x[0] * TILESIZE - $ox, $y[0] * TILESIZE - $oy,
456			TILESIZE * @x, TILESIZE * @y,
457			'max', 0, 0);
458			}
459	root	1.3
460			$_->[4]->($self, $_->[0] - $self->{x}, $_->[1] - $self->{y})
461			for values %{ $self->{overlay} \|\| {} };
462	root	1.1	}
463
464			=back
465
466			=head1 AUTHOR
467
468			Marc Lehmann <schmorp@schmorp.de>
469
470			=cut
471
472			1
473