gde/GCE/MapEditor.pm

package GCE::MapEditor;

=head1 NAME

  GCE::MapEditor - the map editing widget

=cut

use Gtk2;
use Gtk2::Gdk::Keysyms;
use Gtk2::SimpleMenu;

use Crossfire;
use Crossfire::Map;
use Crossfire::MapWidget;

use GCE::AttrEdit;
use GCE::Util;

use Glib::Object::Subclass
    Gtk2::Window;

use strict;

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

   my $menu_tree = [
      _File => {
         item_type => '<Branch>',
         children => [
            "_Save" => {
               callback => sub { $self->save_map },
               accelerator => '<ctrl>S'
            },
            "Save As" => {
               callback => sub { $self->save_map_as },
            },
            "Close" => {
               callback => sub { $self->delete; 1 },
            },
         ]
      },
      _Edit => {
         item_type => '<Branch>',
         children => [
            "_Undo" => {
               callback => sub { $self->undo },
               accelerator => "<ctrl>Z"
            },
            "_Redo" => {
               callback => sub { $self->redo },
               accelerator => "<ctrl>Y"
            },
            "_Map Properties" => {
               callback => sub { $self->open_map_prop },
               accelerator => "<ctrl>P"
            },
            "_Map Resize" => {
               callback => sub { $self->open_resize_map },
               accelerator => "<ctrl>R"
            },
         ]
      },
      _Go => {
         item_type => '<Branch>',
         children => [
            "_Up" => {
               callback => sub { $self->follow ('u') },
               accelerator => "<ctrl>U"
            },
            "_Down" => {
               callback => sub { $self->follow ('d') },
               accelerator => "<ctrl>D"
            },
            "_Right" => {
               callback => sub { $self->follow ('r') },
               accelerator => "<ctrl>R"
            },
            "_Left" => {
               callback => sub { $self->follow ('l') },
               accelerator => "<ctrl>L"
            },
         ]
      },
      _Help => {
         item_type => '<Branch>',
         children => [
            _Help => {
               callback => sub { $::MAINWIN->show_help_window },
               accelerator => "<ctrl>H"
            },
         ]
      },
   ];

   my $men =
      Gtk2::SimpleMenu->new (
         menu_tree => $menu_tree,
         default_callback => \&default_cb,
      );

   for (
        [i => 'pick'],
        [p => 'place'],
        [e => 'erase'],
        [s => 'select'],
        [l => 'eval'],
        [x => 'connectexit'],
        [f => 'followexit']
       )
   {
      my $tool = $_->[1];
      $men->{accel_group}->connect ($Gtk2::Gdk::Keysyms{$_->[0]}, [], 'visible',
         sub { $::MAINWIN->set_edit_tool ($tool) });
   }

   $self->add_accel_group ($men->{accel_group});

   return $men->{widget};
}

sub ea {
   my ($self) = @_;
   $self->{ea_alt} || $::MAINWIN->{sel_editaction};
}

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

   $self->set_title ('gce - map editor');
   $self->add (my $vb = Gtk2::VBox->new);

   $self->signal_connect (delete_event => sub { $self->delete; 1 });

   $vb->pack_start (my $menu = $self->build_menu, 0, 1, 0);

   $vb->pack_start (my $map = $self->{map} = Crossfire::MapWidget->new, 1, 1, 0);

   $self->signal_connect (focus_in_event => sub {
      my $ea = $::MAINWIN->{sel_editaction};
      if ($ea->special_arrow) {
         $self->{map}->{window}->set_cursor (Gtk2::Gdk::Cursor->new ($ea->special_arrow));
      } else {
         $self->{map}->{window}->set_cursor (Gtk2::Gdk::Cursor->new ('GDK_LEFT_PTR'));
      }
      delete $self->{ea_alt};
   });

   $map->signal_connect (key_press_event => sub {
      my ($map, $event) = @_;

      my $kv = $event->keyval;

      my ($x, $y) = $map->coord ($map->get_pointer);
      for ([Control_L => sub { $self->{ea_alt} = $::MAINWIN->{edit_collection}{erase} }],
           [Alt_L     => sub { $self->{ea_alt} = $::MAINWIN->{edit_collection}{pick}  }],
           [c         => sub { $::MAINWIN->{edit_collection}{select}->copy }],
           [v         => sub { $::MAINWIN->{edit_collection}{select}->paste ($map, $x, $y) }],
           [n         => sub { $::MAINWIN->{edit_collection}{select}->invoke }],
          )
      {
         if ($kv == $Gtk2::Gdk::Keysyms{$_->[0]}) {
            $_->[1]->();
         }
      }

      if ($self->ea->special_arrow) {
         $map->{window}->set_cursor (Gtk2::Gdk::Cursor->new ($self->ea->special_arrow));
      }
      1;
   });
   $map->signal_connect (key_release_event => sub {
      my ($map, $event) = @_;

      if ($event->keyval == $Gtk2::Gdk::Keysyms{Control_L}
          or $event->keyval == $Gtk2::Gdk::Keysyms{Alt_L})
      {
         delete $self->{ea_alt};
      }

      if ($self->ea->special_arrow) {
         $map->{window}->set_cursor (Gtk2::Gdk::Cursor->new ($self->ea->special_arrow));
      } else {
         # XXX: Get the original cursor and insert it here
         $map->{window}->set_cursor (Gtk2::Gdk::Cursor->new ('GDK_LEFT_PTR'));
      }
      1;
   });
   $map->signal_connect (button_press_event => sub {
      my ($map, $event) = @_;

      my ($x, $y) = $map->coord ($event->x, $event->y);
      my $as = $map->get ($x, $y);

      if ((not $self->{draw_mode}) and $event->button != 2) {

         my $ea = $self->ea;

         $ea->begin ($map, $x, $y, $self)
            if $x >= 0 and $y >= 0 and $x < $map->{map}{width} and $y < $map->{map}{height};

         $self->{draw_mode} = [$x, $y];

         $ea->want_cursor
            or $map->disable_tooltip;

         return 1;
      }
      0
   });

   $map->signal_connect_after (motion_notify_event => sub {
      my ($map, $event) = @_;

      $self->{draw_mode}
         or return;

      my $ea = $self->ea;

      my ($X, $Y) = @{$self->{draw_mode}}[0,1];
      my ($x, $y) = $map->coord ($map->get_pointer);

      while ($x != $X || $y != $Y) {

         $X++ if $X < $x;
         $X-- if $X > $x;
         $Y++ if $Y < $y;
         $Y-- if $Y > $y;

         $ea->edit ($map, $X, $Y, $self)
            if $X >= 0 and $Y >= 0 and $X < $map->{map}{width} and $Y < $map->{map}{height};
      }

      @{$self->{draw_mode}}[0,1] = ($X, $Y);

      1
   });

   $map->signal_connect (button_release_event => sub {
      my ($map, $event) = @_;

      if ($self->{draw_mode}) {
         my ($x, $y) = $map->coord ($map->get_pointer);

         my $ea = $self->ea;
         $ea->end ($map, $x, $y, $self);

         delete $self->{draw_mode};

         $ea->want_cursor
            or $map->enable_tooltip;

         return 1;
      }

      0
   });
}

# FIXME: Fix the automatic update of the attribute editor! and also the stack view!
sub undo {
   my ($self) = @_;

   my $map = $self->{map}; # the Crossfire::MapWidget

   $map->{undo_stack_pos}
      or return;

   $map->change_swap ($map->{undo_stack}[--$map->{undo_stack_pos}]);
}

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

   my $map = $self->{map}; # the Crossfire::MapWidget

   $map->{undo_stack} 
      and $map->{undo_stack_pos} < @{$map->{undo_stack}}
         or return;

   $map->change_swap ($map->{undo_stack}[$map->{undo_stack_pos}++]);
}

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

   # check and modla dialog if "dirty"

   if ($self->{mapkey}) {
      # XXX: This should be in a delete event handler in the MainWindow.pm... but it doesnt work
      delete $::MAINWIN->{loaded_maps}->{$self->{mapkey}};
   }

   $self->destroy;
}

sub open_map {
   my ($self, $path, $key) = @_;

   $self->{mapkey} = $key;

   if (ref $path) {
      $self->{map}->set_map ($path);

   } else {
      $self->{path} = $path;
#   print "OPENMAP $path\n";
      $self->{map}->set_map (my $m = new_from_file Crossfire::Map $path);
      require Data::Dumper;
#   print "FOO:" .Data::Dumper::Dumper ($m) . "\n";
   }
}

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

   if ($self->{path}) {
      $self->{map}{map}->write_file ($self->{path});
      quick_msg ($self, "saved to $self->{path}");
   } else {
      $self->save_map_as;
   }
}

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

   my $fc = $::MAINWIN->new_filechooser ('gce - save map', 1, $self->{path});

   if ('ok' eq $fc->run) {

      $::MAINWIN->{fc_last_folder} = $fc->get_current_folder;
      $::MAINWIN->{fc_last_folders}->{$self->{fc_last_folder}}++;

      $self->{map}{map}->write_file ($self->{path} = $fc->get_filename);
      quick_msg ($self, "saved to $self->{path}");
   }

   $fc->destroy;
}

sub _add_prop_entry {
   my ($self, $table, $idx, $key, $desc, $type, $changecb) = @_;

   my $edwid;

   if ($type eq 'string') {
      $table->attach_defaults (my $lbl = Gtk2::Label->new ($desc), 0, 1, $idx, $idx + 1);
      $edwid = Gtk2::Entry->new;
         $edwid->set_text ($self->{map}{map}{info}{$key});
         $edwid->signal_connect (changed => sub {
            $self->{map}{map}{info}{$key} = $_[0]->get_text;
            if ($changecb) {
               $changecb->($_[0]->get_text);
            }
         });
      $table->attach_defaults ($edwid, 1, 2, $idx, $idx + 1);

   } elsif ($type eq 'button') {
      $table->attach_defaults (my $b = Gtk2::Button->new_with_label ($desc), 0, 2, $idx, $idx + 1);
      $b->signal_connect (clicked => ($changecb || sub {}));

   } elsif ($type eq 'label') {
      $table->attach_defaults (my $lbl = Gtk2::Label->new ($desc), 0, 1, $idx, $idx + 1);
      $edwid = Gtk2::Label->new ($self->{map}{map}{info}{$key});
      $table->attach_defaults ($edwid, 1, 2, $idx, $idx + 1);

   } elsif ($type eq 'check') {
      $table->attach_defaults (my $lbl1 = Gtk2::Label->new ($desc), 0, 1, $idx, $idx + 1);
      $table->attach_defaults (my $lbl = Gtk2::CheckButton->new, 1, 2, $idx, $idx + 1);
      $lbl->set_active ($self->{map}{map}{info}{$key});
      $lbl->signal_connect (toggled => sub {
         my ($lbl) = @_;
         $self->{map}{map}{info}{$key} = $lbl->get_active * 1;
         ($changecb || sub {})->($lbl->get_active);
      });

   } elsif ($type eq 'sep') {
      $table->attach_defaults (my $lbl1 = Gtk2::HSeparator->new, 0, 2, $idx, $idx + 1);
   } else {
      $edwid = Gtk2::Label->new ("FOO");
   }
}

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

   my $w = Gtk2::Window->new ('toplevel');
   $w->set_default_size (250, 150);
   $w->add (my $sw = Gtk2::ScrolledWindow->new);
      $sw->add_with_viewport (my $v = Gtk2::VBox->new);
      $sw->set_policy ('automatic', 'automatic');
         $v->pack_start (my $t = Gtk2::Table->new (2, 10), 0, 0, 0);

   my $i = 0;
   for (
         [qw/width Width string/],
         [qw/height Height string/],
         [qw/save Save button/,
            sub {
               $self->{map}{map}->resize ($self->{map}{map}{info}{width}, $self->{map}{map}{info}{height});
               $self->{map}->invalidate_all;
               $w->destroy;
            }
         ],
       )
   {
      $self->_add_prop_entry ($t, $i++, @$_);
   }

   $w->show_all;
}

sub follow {
   my ($self, $dir) = @_;

   my %dir_to_path = (
         u => 'tile_path_1',
         d => 'tile_path_3',
         r => 'tile_path_2',
         l => 'tile_path_4',
   );

   defined $dir_to_path{$dir}
      or return;
   my $map = $self->{map}{map}{info}{$dir_to_path{$dir}}
      or return;

   $map = map2abs ($map, $self);
   $::MAINWIN->open_map_editor ($map);
}

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


   my $w = Gtk2::Window->new ('toplevel');
   $w->set_default_size (500, 500);
   $w->add (my $sw = Gtk2::ScrolledWindow->new);
      $sw->add_with_viewport (my $v = Gtk2::VBox->new);
      $sw->set_policy ('automatic', 'automatic');
         $v->pack_start (my $t = Gtk2::Table->new (2, 10), 0, 0, 0);

   my $i = 0;
   for (
         [qw/name        Name          string/],
         [qw/region      Region        string/],
         [qw/enter_x     Enter-x       string/],
         [qw/enter_y     Enter-y       string/],
         [qw/reset_timeout Reset-timeout  string/],
         [qw/swap_time Swap-timeout  string/],
         [qw/x           x             sep/],
         [qw/difficulty  Difficulty    string/],
         [qw/windspeed   Windspeed     string/],
         [qw/pressure    Pressure      string/],
         [qw/humid       Humid         string/],
         [qw/temp        Temp          string/],
         [qw/darkness    Darkness      string/],
         [qw/sky         Sky           string/],
         [qw/winddir     Winddir       string/],
         [qw/x           x             sep/],
         [qw/width       Width         label/], # sub { $self->{map}{map}->resize ($_[0], $self->{map}{map}{height}) }],
         [qw/height      Height        label/], # sub { $self->{map}{map}->resize ($self->{map}{map}{width}, $_[0])  }],
         [qw/x           x             sep/],
         [qw/msg         Text          text/],
         [qw/maplore     Maplore       text/],
         [qw/outdoor     Outdoor       check/],
         [qw/unique      Unique        check/],
         [qw/fixed_resettime Fixed-resettime        check/],
         [qw/x           x             sep/],
         [qw/tile_path_1 Northpath     string/],
         [qw/tile_path_2 Eastpath      string/],
         [qw/tile_path_3 Southpath     string/],
         [qw/tile_path_4 Westpath      string/],
         [qw/tile_path_5 Toppath       string/],
         [qw/tile_path_6 Bottompath    string/],
       )
   {
      $self->_add_prop_entry ($t, $i++, @$_);
   }

   $w->show_all;
}

=head1 AUTHOR

 Marc Lehmann <schmorp@schmorp.de>
 http://home.schmorp.de/

 Robin Redeker <elmex@ta-sa.org>
 http://www.ta-sa.org/

=cut
1;

Revision:	1.29
Committed:	Mon Mar 20 04:11:41 2006 UTC (18 years, 2 months ago) by elmex
Branch:	MAIN
Changes since 1.28:	+9 -1 lines
Log Message:	implemented help menu
#	User	Rev	Content
1	elmex	1.1	package GCE::MapEditor;
2
3			=head1 NAME
4
5			GCE::MapEditor - the map editing widget
6
7			=cut
8
9			use Gtk2;
10			use Gtk2::Gdk::Keysyms;
11			use Gtk2::SimpleMenu;
12
13			use Crossfire;
14	root	1.3	use Crossfire::Map;
15	elmex	1.1	use Crossfire::MapWidget;
16
17			use GCE::AttrEdit;
18	elmex	1.22	use GCE::Util;
19	elmex	1.1
20	elmex	1.4	use Glib::Object::Subclass
21	elmex	1.6	Gtk2::Window;
22	elmex	1.1
23			use strict;
24
25	root	1.9	sub build_menu {
26			my ($self) = @_;
27
28			my $menu_tree = [
29			_File => {
30			item_type => '<Branch>',
31			children => [
32			"_Save" => {
33	root	1.10	callback => sub { $self->save_map },
34	root	1.9	accelerator => '<ctrl>S'
35			},
36	root	1.10	"Save As" => {
37			callback => sub { $self->save_map_as },
38			},
39	root	1.13	"Close" => {
40			callback => sub { $self->delete; 1 },
41			},
42	root	1.10	]
43	root	1.9	},
44			_Edit => {
45			item_type => '<Branch>',
46			children => [
47			"_Undo" => {
48			callback => sub { $self->undo },
49	elmex	1.17	accelerator => "<ctrl>Z"
50	root	1.9	},
51			"_Redo" => {
52			callback => sub { $self->redo },
53	elmex	1.17	accelerator => "<ctrl>Y"
54			},
55			"_Map Properties" => {
56			callback => sub { $self->open_map_prop },
57			accelerator => "<ctrl>P"
58			},
59			"_Map Resize" => {
60			callback => sub { $self->open_resize_map },
61			accelerator => "<ctrl>R"
62	root	1.9	},
63			]
64			},
65	elmex	1.27	_Go => {
66			item_type => '<Branch>',
67			children => [
68			"_Up" => {
69			callback => sub { $self->follow ('u') },
70			accelerator => "<ctrl>U"
71			},
72			"_Down" => {
73			callback => sub { $self->follow ('d') },
74			accelerator => "<ctrl>D"
75			},
76			"_Right" => {
77			callback => sub { $self->follow ('r') },
78			accelerator => "<ctrl>R"
79			},
80			"_Left" => {
81			callback => sub { $self->follow ('l') },
82			accelerator => "<ctrl>L"
83			},
84			]
85			},
86	elmex	1.29	_Help => {
87			item_type => '<Branch>',
88			children => [
89			_Help => {
90			callback => sub { $::MAINWIN->show_help_window },
91			accelerator => "<ctrl>H"
92			},
93			]
94			},
95	root	1.9	];
96
97			my $men =
98			Gtk2::SimpleMenu->new (
99			menu_tree => $menu_tree,
100			default_callback => \&default_cb,
101			);
102
103	elmex	1.23	for (
104			[i => 'pick'],
105			[p => 'place'],
106	elmex	1.24	[e => 'erase'],
107			[s => 'select'],
108			[l => 'eval'],
109			[x => 'connectexit'],
110			[f => 'followexit']
111	elmex	1.23	)
112			{
113	elmex	1.24	my $tool = $_->[1];
114	elmex	1.23	$men->{accel_group}->connect ($Gtk2::Gdk::Keysyms{$_->[0]}, [], 'visible',
115	elmex	1.24	sub { $::MAINWIN->set_edit_tool ($tool) });
116	elmex	1.23	}
117
118	root	1.9	$self->add_accel_group ($men->{accel_group});
119
120			return $men->{widget};
121			}
122
123	elmex	1.19	sub ea {
124			my ($self) = @_;
125			$self->{ea_alt} \|\| $::MAINWIN->{sel_editaction};
126			}
127
128	elmex	1.1	sub INIT_INSTANCE {
129			my ($self) = @_;
130
131	elmex	1.6	$self->set_title ('gce - map editor');
132			$self->add (my $vb = Gtk2::VBox->new);
133	elmex	1.1
134	elmex	1.25	$self->signal_connect (delete_event => sub { $self->delete; 1 });
135	root	1.13
136	root	1.9	$vb->pack_start (my $menu = $self->build_menu, 0, 1, 0);
137
138			$vb->pack_start (my $map = $self->{map} = Crossfire::MapWidget->new, 1, 1, 0);
139
140	elmex	1.19	$self->signal_connect (focus_in_event => sub {
141			my $ea = $::MAINWIN->{sel_editaction};
142			if ($ea->special_arrow) {
143			$self->{map}->{window}->set_cursor (Gtk2::Gdk::Cursor->new ($ea->special_arrow));
144			} else {
145			$self->{map}->{window}->set_cursor (Gtk2::Gdk::Cursor->new ('GDK_LEFT_PTR'));
146			}
147	elmex	1.22	delete $self->{ea_alt};
148	elmex	1.19	});
149
150			$map->signal_connect (key_press_event => sub {
151			my ($map, $event) = @_;
152	root	1.9
153	elmex	1.19	my $kv = $event->keyval;
154	root	1.9
155	elmex	1.23	my ($x, $y) = $map->coord ($map->get_pointer);
156			for ([Control_L => sub { $self->{ea_alt} = $::MAINWIN->{edit_collection}{erase} }],
157			[Alt_L => sub { $self->{ea_alt} = $::MAINWIN->{edit_collection}{pick} }],
158			[c => sub { $::MAINWIN->{edit_collection}{select}->copy }],
159	elmex	1.28	[v => sub { $::MAINWIN->{edit_collection}{select}->paste ($map, $x, $y) }],
160	elmex	1.24	[n => sub { $::MAINWIN->{edit_collection}{select}->invoke }],
161	elmex	1.23	)
162			{
163			if ($kv == $Gtk2::Gdk::Keysyms{$_->[0]}) {
164			$_->[1]->();
165			}
166	elmex	1.19	}
167	root	1.9
168	elmex	1.19	if ($self->ea->special_arrow) {
169			$map->{window}->set_cursor (Gtk2::Gdk::Cursor->new ($self->ea->special_arrow));
170			}
171			1;
172			});
173			$map->signal_connect (key_release_event => sub {
174			my ($map, $event) = @_;
175
176			if ($event->keyval == $Gtk2::Gdk::Keysyms{Control_L}
177			or $event->keyval == $Gtk2::Gdk::Keysyms{Alt_L})
178			{
179			delete $self->{ea_alt};
180			}
181
182			if ($self->ea->special_arrow) {
183			$map->{window}->set_cursor (Gtk2::Gdk::Cursor->new ($self->ea->special_arrow));
184			} else {
185			# XXX: Get the original cursor and insert it here
186			$map->{window}->set_cursor (Gtk2::Gdk::Cursor->new ('GDK_LEFT_PTR'));
187			}
188			1;
189			});
190			$map->signal_connect (button_press_event => sub {
191			my ($map, $event) = @_;
192	elmex	1.1
193	elmex	1.19	my ($x, $y) = $map->coord ($event->x, $event->y);
194			my $as = $map->get ($x, $y);
195	elmex	1.1
196	elmex	1.19	if ((not $self->{draw_mode}) and $event->button != 2) {
197	elmex	1.4
198	elmex	1.19	my $ea = $self->ea;
199	elmex	1.4
200	elmex	1.22	$ea->begin ($map, $x, $y, $self)
201	elmex	1.19	if $x >= 0 and $y >= 0 and $x < $map->{map}{width} and $y < $map->{map}{height};
202
203			$self->{draw_mode} = [$x, $y];
204	root	1.9
205	elmex	1.19	$ea->want_cursor
206			or $map->disable_tooltip;
207	root	1.9
208	elmex	1.19	return 1;
209			}
210			0
211	root	1.9	});
212
213			$map->signal_connect_after (motion_notify_event => sub {
214			my ($map, $event) = @_;
215
216			$self->{draw_mode}
217			or return;
218
219	elmex	1.19	my $ea = $self->ea;
220
221			my ($X, $Y) = @{$self->{draw_mode}}[0,1];
222	root	1.9	my ($x, $y) = $map->coord ($map->get_pointer);
223	elmex	1.4
224	root	1.9	while ($x != $X \|\| $y != $Y) {
225	elmex	1.4
226	root	1.9	$X++ if $X < $x;
227			$X-- if $X > $x;
228			$Y++ if $Y < $y;
229			$Y-- if $Y > $y;
230	elmex	1.4
231	elmex	1.22	$ea->edit ($map, $X, $Y, $self)
232	elmex	1.15	if $X >= 0 and $Y >= 0 and $X < $map->{map}{width} and $Y < $map->{map}{height};
233	root	1.9	}
234	elmex	1.4
235	elmex	1.19	@{$self->{draw_mode}}[0,1] = ($X, $Y);
236	elmex	1.1
237	root	1.9	1
238			});
239	elmex	1.1
240	root	1.9	$map->signal_connect (button_release_event => sub {
241			my ($map, $event) = @_;
242	elmex	1.1
243	elmex	1.19	if ($self->{draw_mode}) {
244	root	1.9	my ($x, $y) = $map->coord ($map->get_pointer);
245	elmex	1.4
246	elmex	1.19	my $ea = $self->ea;
247	elmex	1.22	$ea->end ($map, $x, $y, $self);
248	elmex	1.1
249	root	1.9	delete $self->{draw_mode};
250	elmex	1.4
251	root	1.9	$ea->want_cursor
252			or $map->enable_tooltip;
253	elmex	1.1
254	root	1.9	return 1;
255			}
256	elmex	1.1
257	root	1.9	0
258			});
259			}
260	elmex	1.8
261	elmex	1.16	# FIXME: Fix the automatic update of the attribute editor! and also the stack view!
262	root	1.9	sub undo {
263			my ($self) = @_;
264	elmex	1.8
265	root	1.9	my $map = $self->{map}; # the Crossfire::MapWidget
266	elmex	1.1
267	root	1.9	$map->{undo_stack_pos}
268			or return;
269	elmex	1.1
270	root	1.9	$map->change_swap ($map->{undo_stack}[--$map->{undo_stack_pos}]);
271			}
272	elmex	1.1
273	root	1.9	sub redo {
274			my ($self) = @_;
275	elmex	1.7
276	root	1.9	my $map = $self->{map}; # the Crossfire::MapWidget
277	elmex	1.7
278	elmex	1.14	$map->{undo_stack}
279			and $map->{undo_stack_pos} < @{$map->{undo_stack}}
280			or return;
281	elmex	1.1
282	root	1.9	$map->change_swap ($map->{undo_stack}[$map->{undo_stack_pos}++]);
283	root	1.3	}
284
285	root	1.13	sub delete {
286			my ($self) = @_;
287
288			# check and modla dialog if "dirty"
289
290	elmex	1.26	if ($self->{mapkey}) {
291	elmex	1.25	# XXX: This should be in a delete event handler in the MainWindow.pm... but it doesnt work
292	elmex	1.26	delete $::MAINWIN->{loaded_maps}->{$self->{mapkey}};
293	elmex	1.25	}
294
295	root	1.13	$self->destroy;
296			}
297
298	root	1.3	sub open_map {
299	elmex	1.26	my ($self, $path, $key) = @_;
300
301			$self->{mapkey} = $key;
302	root	1.3
303	elmex	1.18	if (ref $path) {
304			$self->{map}->set_map ($path);
305
306			} else {
307			$self->{path} = $path;
308	elmex	1.17	# print "OPENMAP $path\n";
309	elmex	1.18	$self->{map}->set_map (my $m = new_from_file Crossfire::Map $path);
310			require Data::Dumper;
311			# print "FOO:" .Data::Dumper::Dumper ($m) . "\n";
312			}
313	root	1.3	}
314
315	root	1.13	sub save_map {
316			my ($self) = @_;
317
318	elmex	1.19	if ($self->{path}) {
319			$self->{map}{map}->write_file ($self->{path});
320	elmex	1.22	quick_msg ($self, "saved to $self->{path}");
321			} else {
322			$self->save_map_as;
323	elmex	1.19	}
324	root	1.13	}
325
326			sub save_map_as {
327			my ($self) = @_;
328	elmex	1.19
329	elmex	1.22	my $fc = $::MAINWIN->new_filechooser ('gce - save map', 1, $self->{path});
330	elmex	1.19
331			if ('ok' eq $fc->run) {
332
333			$::MAINWIN->{fc_last_folder} = $fc->get_current_folder;
334			$::MAINWIN->{fc_last_folders}->{$self->{fc_last_folder}}++;
335
336			$self->{map}{map}->write_file ($self->{path} = $fc->get_filename);
337	elmex	1.22	quick_msg ($self, "saved to $self->{path}");
338	elmex	1.19	}
339
340			$fc->destroy;
341	root	1.13	}
342
343	elmex	1.17	sub _add_prop_entry {
344			my ($self, $table, $idx, $key, $desc, $type, $changecb) = @_;
345
346			my $edwid;
347
348			if ($type eq 'string') {
349			$table->attach_defaults (my $lbl = Gtk2::Label->new ($desc), 0, 1, $idx, $idx + 1);
350			$edwid = Gtk2::Entry->new;
351			$edwid->set_text ($self->{map}{map}{info}{$key});
352			$edwid->signal_connect (changed => sub {
353			$self->{map}{map}{info}{$key} = $_[0]->get_text;
354			if ($changecb) {
355			$changecb->($_[0]->get_text);
356			}
357			});
358			$table->attach_defaults ($edwid, 1, 2, $idx, $idx + 1);
359
360			} elsif ($type eq 'button') {
361			$table->attach_defaults (my $b = Gtk2::Button->new_with_label ($desc), 0, 2, $idx, $idx + 1);
362			$b->signal_connect (clicked => ($changecb \|\| sub {}));
363
364			} elsif ($type eq 'label') {
365			$table->attach_defaults (my $lbl = Gtk2::Label->new ($desc), 0, 1, $idx, $idx + 1);
366			$edwid = Gtk2::Label->new ($self->{map}{map}{info}{$key});
367			$table->attach_defaults ($edwid, 1, 2, $idx, $idx + 1);
368
369	elmex	1.27	} elsif ($type eq 'check') {
370			$table->attach_defaults (my $lbl1 = Gtk2::Label->new ($desc), 0, 1, $idx, $idx + 1);
371			$table->attach_defaults (my $lbl = Gtk2::CheckButton->new, 1, 2, $idx, $idx + 1);
372			$lbl->set_active ($self->{map}{map}{info}{$key});
373			$lbl->signal_connect (toggled => sub {
374			my ($lbl) = @_;
375			$self->{map}{map}{info}{$key} = $lbl->get_active * 1;
376			($changecb \|\| sub {})->($lbl->get_active);
377			});
378
379			} elsif ($type eq 'sep') {
380			$table->attach_defaults (my $lbl1 = Gtk2::HSeparator->new, 0, 2, $idx, $idx + 1);
381	elmex	1.17	} else {
382			$edwid = Gtk2::Label->new ("FOO");
383			}
384			}
385
386			sub open_resize_map {
387			my ($self) = @_;
388
389			my $w = Gtk2::Window->new ('toplevel');
390			$w->set_default_size (250, 150);
391			$w->add (my $sw = Gtk2::ScrolledWindow->new);
392			$sw->add_with_viewport (my $v = Gtk2::VBox->new);
393			$sw->set_policy ('automatic', 'automatic');
394			$v->pack_start (my $t = Gtk2::Table->new (2, 10), 0, 0, 0);
395
396			my $i = 0;
397			for (
398			[qw/width Width string/],
399			[qw/height Height string/],
400			[qw/save Save button/,
401			sub {
402			$self->{map}{map}->resize ($self->{map}{map}{info}{width}, $self->{map}{map}{info}{height});
403	elmex	1.19	$self->{map}->invalidate_all;
404			$w->destroy;
405	elmex	1.17	}
406			],
407			)
408			{
409			$self->_add_prop_entry ($t, $i++, @$_);
410			}
411
412			$w->show_all;
413			}
414
415	elmex	1.27	sub follow {
416			my ($self, $dir) = @_;
417
418			my %dir_to_path = (
419			u => 'tile_path_1',
420			d => 'tile_path_3',
421			r => 'tile_path_2',
422			l => 'tile_path_4',
423			);
424
425			defined $dir_to_path{$dir}
426			or return;
427			my $map = $self->{map}{map}{info}{$dir_to_path{$dir}}
428			or return;
429
430			$map = map2abs ($map, $self);
431			$::MAINWIN->open_map_editor ($map);
432			}
433
434	elmex	1.17	sub open_map_prop {
435			my ($self) = @_;
436
437
438			my $w = Gtk2::Window->new ('toplevel');
439			$w->set_default_size (500, 500);
440			$w->add (my $sw = Gtk2::ScrolledWindow->new);
441			$sw->add_with_viewport (my $v = Gtk2::VBox->new);
442			$sw->set_policy ('automatic', 'automatic');
443			$v->pack_start (my $t = Gtk2::Table->new (2, 10), 0, 0, 0);
444
445			my $i = 0;
446			for (
447	elmex	1.27	[qw/name Name string/],
448			[qw/region Region string/],
449			[qw/enter_x Enter-x string/],
450			[qw/enter_y Enter-y string/],
451			[qw/reset_timeout Reset-timeout string/],
452			[qw/swap_time Swap-timeout string/],
453			[qw/x x sep/],
454			[qw/difficulty Difficulty string/],
455			[qw/windspeed Windspeed string/],
456			[qw/pressure Pressure string/],
457			[qw/humid Humid string/],
458			[qw/temp Temp string/],
459			[qw/darkness Darkness string/],
460			[qw/sky Sky string/],
461			[qw/winddir Winddir string/],
462			[qw/x x sep/],
463			[qw/width Width label/], # sub { $self->{map}{map}->resize ($_[0], $self->{map}{map}{height}) }],
464			[qw/height Height label/], # sub { $self->{map}{map}->resize ($self->{map}{map}{width}, $_[0]) }],
465			[qw/x x sep/],
466			[qw/msg Text text/],
467			[qw/maplore Maplore text/],
468			[qw/outdoor Outdoor check/],
469			[qw/unique Unique check/],
470			[qw/fixed_resettime Fixed-resettime check/],
471			[qw/x x sep/],
472			[qw/tile_path_1 Northpath string/],
473			[qw/tile_path_2 Eastpath string/],
474			[qw/tile_path_3 Southpath string/],
475			[qw/tile_path_4 Westpath string/],
476			[qw/tile_path_5 Toppath string/],
477			[qw/tile_path_6 Bottompath string/],
478	elmex	1.17	)
479			{
480			$self->_add_prop_entry ($t, $i++, @$_);
481			}
482
483			$w->show_all;
484			}
485
486	elmex	1.1	=head1 AUTHOR
487
488			Marc Lehmann <schmorp@schmorp.de>
489			http://home.schmorp.de/
490
491			Robin Redeker <elmex@ta-sa.org>
492			http://www.ta-sa.org/
493
494			=cut
495			1;
496