← Back to branch summary

~ubuntu-branches/ubuntu/wily/padre/wily

« back to all changes in this revision

Viewing changes to lib/Padre/Wx/Menu/Edit.pm

  • Committer: Bazaar Package Importer
  • Author(s): Damyan Ivanov
  • Date: 2009-08-12 14:44:55 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20090812144455-yvk90oa92khfcnls
Tags: 0.42-1
* New Upstream Version
  + add explicit dependency on libtest-simple-perl (>= 0.88)
  + rules: use dh --with quilt (and bump quilt build-dependency to 0.46-7)
  + rules: no need to re-generate .mo files from .po. Upstream does it now
  + copyright: describe share/icons/padre/16x16/logo.png
    - describe share/icons/padre/16x16/toggle-comments.png
    - Padre license is the same as Perl (i.e. not Perl 5)
    - update list of copright holders
    - also list translators
  + drop libtest-most-perl from build-dependencies
  + add liblocale-msgfmt-perl to build-dependencies
  + add libcapture-tiny-perl to (build-)dependencies
  + add libfile-remove-perl (>= 1.42) to (build-)dependencies
  + drop libmodule-inspector-perl from (build-)dependencies
  + add libppix-editortools-perl to (build-)dependencies
  + add libparse-exuberantctags-perl to (build-)dependencies
  + patches:
    - drop lower-wx-requirement-to-2.8.7.patch and replace it with
      SKIP_WXWIDGETS_VERSION_CHECK=1 when configuring
      adjust README.debian accordingly
    - refresh disable-tcp-server.patch
    - drop don't-require-new-file-path.patch (applied upstream)
    - rework fix-pod2-errors.patch (new release, new errors :))
* add fix-perl-interpreter-path.patch fixing the path to the perl interpreter
  in three examples (thanks lintian)
* add more lintian overrides about script-not-executable for scripts that are
  treated as examples/templates
* add fix-whatis.patch fixing the whatis entry of Padre::Wx
* add menu and .desktop file

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/Padre/Wx/Menu/Edit.pm
9
9
use Padre::Wx       ();
10
10
use Padre::Wx::Menu ();
11
11
 
12
 
our $VERSION = '0.36';
 
12
our $VERSION = '0.42';
13
13
our @ISA     = 'Padre::Wx::Menu';
14
14
 
15
15
#####################################################################
26
26
        $self->{main} = $main;
27
27
 
28
28
        # Undo/Redo
29
 
        $self->{undo} = $self->Append(
30
 
                Wx::wxID_UNDO,
31
 
                Wx::gettext("&Undo")
32
 
        );
33
 
        Wx::Event::EVT_MENU(
34
 
                $main,    # Ctrl-Z
35
 
                $self->{undo},
36
 
                sub {
37
 
                        Padre::Current->editor->Undo;
 
29
        $self->{undo} = $self->add_menu_item(
 
30
                $self,
 
31
                name       => 'edit.undo',
 
32
                id         => Wx::wxID_UNDO,
 
33
                label      => Wx::gettext('&Undo'),
 
34
                shortcut   => 'Ctrl-Z',
 
35
                menu_event => sub {
 
36
                        my $editor = Padre::Current->editor or return;
 
37
                        $editor->Undo;
38
38
                },
39
39
        );
40
40
 
41
 
        $self->{redo} = $self->Append(
42
 
                Wx::wxID_REDO,
43
 
                Wx::gettext("&Redo")
44
 
        );
45
 
        Wx::Event::EVT_MENU(
46
 
                $main,    # Ctrl-Y
47
 
                $self->{redo},
48
 
                sub {
49
 
                        Padre::Current->editor->Redo;
 
41
        $self->{redo} = $self->add_menu_item(
 
42
                $self,
 
43
                name       => 'edit.redo',
 
44
                id         => Wx::wxID_REDO,
 
45
                label      => Wx::gettext('&Redo'),
 
46
                shortcut   => 'Ctrl-Y',
 
47
                menu_event => sub {
 
48
                        my $editor = Padre::Current->editor or return;
 
49
                        $editor->Redo;
50
50
                },
51
51
        );
52
52
 
59
59
                Wx::gettext("Select"),
60
60
                $edit_select
61
61
        );
62
 
        Wx::Event::EVT_MENU(
63
 
                $main,
64
 
                $edit_select->Append(
65
 
                        Wx::wxID_SELECTALL,
66
 
                        Wx::gettext("Select all\tCtrl-A")
67
 
                ),
68
 
                sub {
 
62
        $self->add_menu_item(
 
63
                $edit_select,
 
64
                name       => 'edit.select_all',
 
65
                id         => Wx::wxID_SELECTALL,
 
66
                label      => Wx::gettext('Select all'),
 
67
                shortcut   => 'Ctrl-A',
 
68
                menu_event => sub {
69
69
                        require Padre::Wx::Editor;
70
70
                        Padre::Wx::Editor::text_select_all(@_);
71
71
                },
72
72
        );
73
73
 
74
74
        $edit_select->AppendSeparator;
75
 
        Wx::Event::EVT_MENU(
76
 
                $main,
77
 
                $edit_select->Append(
78
 
                        -1,
79
 
                        Wx::gettext("Mark selection start\tCtrl-[")
80
 
                ),
81
 
                sub {
 
75
        $self->add_menu_item(
 
76
                $edit_select,
 
77
                name       => 'edit.mark_selection_start',
 
78
                label      => Wx::gettext('Mark selection start'),
 
79
                shortcut   => 'Ctrl-[',
 
80
                menu_event => sub {
82
81
                        my $editor = Padre::Current->editor or return;
83
82
                        $editor->text_selection_mark_start;
84
83
                },
85
84
        );
86
85
 
87
 
        Wx::Event::EVT_MENU(
88
 
                $main,
89
 
                $edit_select->Append(
90
 
                        -1,
91
 
                        Wx::gettext("Mark selection end\tCtrl-]")
92
 
                ),
93
 
                sub {
 
86
        $self->add_menu_item(
 
87
                $edit_select,
 
88
                name       => 'edit.mark_selection_end',
 
89
                label      => Wx::gettext('Mark selection end'),
 
90
                shortcut   => 'Ctrl-]',
 
91
                menu_event => sub {
94
92
                        my $editor = Padre::Current->editor or return;
95
93
                        $editor->text_selection_mark_end;
96
94
                },
97
95
        );
98
96
 
99
 
        Wx::Event::EVT_MENU(
100
 
                $main,
101
 
                $edit_select->Append(
102
 
                        -1,
103
 
                        Wx::gettext("Clear selection marks")
104
 
                ),
105
 
                sub {
 
97
        $self->add_menu_item(
 
98
                $edit_select,
 
99
                name       => 'edit.clear_selection_marks',
 
100
                label      => Wx::gettext('Clear selection marks'),
 
101
                menu_event => sub {
106
102
                        require Padre::Wx::Editor;
107
103
                        Padre::Wx::Editor::text_selection_clear_marks(@_);
108
104
                },
109
105
        );
110
106
 
111
107
        # Cut and Paste
112
 
        $self->{cut} = $self->Append(
113
 
                Wx::wxID_CUT,
114
 
                Wx::gettext("Cu&t\tCtrl-X")
115
 
        );
116
 
        Wx::Event::EVT_MENU(
117
 
                $main,
118
 
                $self->{cut},
119
 
                sub {
 
108
        $self->{cut} = $self->add_menu_item(
 
109
                $self,
 
110
                name       => 'edit.cut',
 
111
                id         => Wx::wxID_CUT,
 
112
                label      => Wx::gettext('Cu&t'),
 
113
                shortcut   => 'Ctrl-X',
 
114
                menu_event => sub {
120
115
                        my $editor = Padre::Current->editor or return;
121
116
                        $editor->Cut;
122
 
                }
 
117
                },
123
118
        );
124
119
 
125
 
        $self->{copy} = $self->Append(
126
 
                Wx::wxID_COPY,
127
 
                Wx::gettext("&Copy\tCtrl-C")
128
 
        );
129
 
        Wx::Event::EVT_MENU(
130
 
                $main,
131
 
                $self->{copy},
132
 
                sub {
 
120
        $self->{copy} = $self->add_menu_item(
 
121
                $self,
 
122
                name       => 'edit.copy',
 
123
                id         => Wx::wxID_COPY,
 
124
                label      => Wx::gettext('&Copy'),
 
125
                shortcut   => 'Ctrl-C',
 
126
                menu_event => sub {
133
127
                        my $editor = Padre::Current->editor or return;
134
128
                        $editor->Copy;
135
 
                }
 
129
                },
136
130
        );
137
131
 
138
 
        $self->{paste} = $self->Append(
139
 
                Wx::wxID_PASTE,
140
 
                Wx::gettext("&Paste\tCtrl-V")
141
 
        );
142
 
        Wx::Event::EVT_MENU(
143
 
                $main,
144
 
                $self->{paste},
145
 
                sub {
 
132
        $self->{paste} = $self->add_menu_item(
 
133
                $self,
 
134
                name       => 'edit.paste',
 
135
                id         => Wx::wxID_PASTE,
 
136
                label      => Wx::gettext('&Paste'),
 
137
                shortcut   => 'Ctrl-V',
 
138
                menu_event => sub {
146
139
                        my $editor = Padre::Current->editor or return;
147
140
                        $editor->Paste;
148
141
                },
151
144
        $self->AppendSeparator;
152
145
 
153
146
        # Miscellaneous Actions
154
 
        $self->{goto} = $self->Append(
155
 
                -1,
156
 
                Wx::gettext("&Goto\tCtrl-G")
157
 
        );
158
 
        Wx::Event::EVT_MENU(
159
 
                $main,
160
 
                $self->{goto},
161
 
                sub {
 
147
        $self->{goto} = $self->add_menu_item(
 
148
                $self,
 
149
                name       => 'edit.goto',
 
150
                label      => Wx::gettext('&Goto Line'),
 
151
                shortcut   => 'Ctrl-G',
 
152
                menu_event => sub {
162
153
                        Padre::Wx::Main::on_goto(@_);
163
154
                },
164
155
        );
165
156
 
166
 
        $self->{autocomp} = $self->Append(
167
 
                -1,
168
 
                Wx::gettext("&AutoComp\tCtrl-P")
169
 
        );
170
 
        Wx::Event::EVT_MENU(
171
 
                $main,
172
 
                $self->{autocomp},
173
 
                sub {
 
157
        $self->{autocomp} = $self->add_menu_item(
 
158
                $self,
 
159
                name       => 'edit.autocomp',
 
160
                label      => Wx::gettext('&AutoComp'),
 
161
                shortcut   => 'Ctrl-P',
 
162
                menu_event => sub {
174
163
                        Padre::Wx::Main::on_autocompletition(@_);
175
164
                },
176
165
        );
177
166
 
178
 
        $self->{brace_match} = $self->Append(
179
 
                -1,
180
 
                Wx::gettext("&Brace matching\tCtrl-1")
181
 
        );
182
 
        Wx::Event::EVT_MENU(
183
 
                $main,
184
 
                $self->{brace_match},
185
 
                sub {
 
167
        $self->{brace_match} = $self->add_menu_item(
 
168
                $self,
 
169
                name       => 'edit.brace_match',
 
170
                label      => Wx::gettext('&Brace matching'),
 
171
                shortcut   => 'Ctrl-1',
 
172
                menu_event => sub {
186
173
                        Padre::Wx::Main::on_brace_matching(@_);
187
174
                },
188
175
        );
189
176
 
190
 
        $self->{join_lines} = $self->Append(
191
 
                -1,
192
 
                Wx::gettext("&Join lines\tCtrl-J")
193
 
        );
194
 
        Wx::Event::EVT_MENU(
195
 
                $main,
196
 
                $self->{join_lines},
197
 
                sub {
 
177
        $self->{join_lines} = $self->add_menu_item(
 
178
                $self,
 
179
                name       => 'edit.join_lines',
 
180
                label      => Wx::gettext('&Join lines'),
 
181
                shortcut   => 'Ctrl-J',
 
182
                menu_event => sub {
198
183
                        Padre::Wx::Main::on_join_lines(@_);
199
184
                },
200
185
        );
201
186
 
202
 
        $self->{snippets} = $self->Append(
203
 
                -1,
204
 
                Wx::gettext("Snippets\tCtrl-Shift-A")
205
 
        );
206
 
        Wx::Event::EVT_MENU(
207
 
                $main,
208
 
                $self->{snippets},
209
 
                sub {
 
187
        $self->{snippets} = $self->add_menu_item(
 
188
                $self,
 
189
                name       => 'edit.snippets',
 
190
                label      => Wx::gettext('Snippets'),
 
191
                shortcut   => 'Ctrl-Shift-A',
 
192
                menu_event => sub {
210
193
                        require Padre::Wx::Dialog::Snippets;
211
194
                        Padre::Wx::Dialog::Snippets->snippets(@_);
212
195
                },
215
198
        $self->AppendSeparator;
216
199
 
217
200
        # Commenting
218
 
        $self->{comment_toggle} = $self->Append(
219
 
                -1,
220
 
                Wx::gettext("&Toggle Comment\tCtrl-Shift-C")
221
 
        );
222
 
        Wx::Event::EVT_MENU(
223
 
                $main,
224
 
                $self->{comment_toggle},
225
 
                sub {
 
201
        $self->{comment_toggle} = $self->add_menu_item(
 
202
                $self,
 
203
                name       => 'edit.comment_toggle',
 
204
                label      => Wx::gettext('&Toggle Comment'),
 
205
                shortcut   => 'Ctrl-Shift-C',
 
206
                menu_event => sub {
226
207
                        Padre::Wx::Main::on_comment_toggle_block(@_);
227
208
                },
228
209
        );
229
210
 
230
 
        $self->{comment_out} = $self->Append(
231
 
                -1,
232
 
                Wx::gettext("&Comment Selected Lines\tCtrl-M")
233
 
        );
234
 
        Wx::Event::EVT_MENU(
235
 
                $main,
236
 
                $self->{comment_out},
237
 
                sub {
 
211
        $self->{comment_out} = $self->add_menu_item(
 
212
                $self,
 
213
                name       => 'edit.comment_out',
 
214
                label      => Wx::gettext('&Comment Selected Lines'),
 
215
                shortcut   => 'Ctrl-M',
 
216
                menu_event => sub {
238
217
                        Padre::Wx::Main::on_comment_out_block(@_);
239
218
                },
240
219
        );
241
220
 
242
 
        $self->{uncomment} = $self->Append(
243
 
                -1,
244
 
                Wx::gettext("&Uncomment Selected Lines\tCtrl-Shift-M")
245
 
        );
246
 
        Wx::Event::EVT_MENU(
247
 
                $main,
248
 
                $self->{uncomment},
249
 
                sub {
 
221
        $self->{uncomment} = $self->add_menu_item(
 
222
                $self,
 
223
                name       => 'edit.uncomment',
 
224
                label      => Wx::gettext('&Uncomment Selected Lines'),
 
225
                shortcut   => 'Ctrl-Shift-M',
 
226
                menu_event => sub {
250
227
                        Padre::Wx::Main::on_uncomment_block(@_);
251
228
                },
252
229
        );
253
230
        $self->AppendSeparator;
254
231
 
255
232
        # Conversions and Transforms
 
233
        $self->{convert_encoding} = Wx::Menu->new;
 
234
        $self->Append(
 
235
                -1,
 
236
                Wx::gettext("Convert Encoding"),
 
237
                $self->{convert_encoding}
 
238
        );
 
239
 
 
240
        $self->{convert_encoding_system} = $self->add_menu_item(
 
241
                $self->{convert_encoding},
 
242
                name       => 'edit.convert_encoding_system',
 
243
                label      => Wx::gettext('Encode document to System Default'),
 
244
                menu_event => sub {
 
245
                        require Padre::Wx::Dialog::Encode;
 
246
                        Padre::Wx::Dialog::Encode::encode_document_to_system_default(@_);
 
247
                },
 
248
        );
 
249
 
 
250
        $self->{convert_encoding_utf8} = $self->add_menu_item(
 
251
                $self->{convert_encoding},
 
252
                name       => 'edit.convert_encoding_utf8',
 
253
                label      => Wx::gettext('Encode document to utf-8'),
 
254
                menu_event => sub {
 
255
                        require Padre::Wx::Dialog::Encode;
 
256
                        Padre::Wx::Dialog::Encode::encode_document_to_utf8(@_);
 
257
                },
 
258
        );
 
259
 
 
260
        $self->{convert_encoding_to} = $self->add_menu_item(
 
261
                $self->{convert_encoding},
 
262
                name       => 'edit.convert_encoding_to',
 
263
                label      => Wx::gettext('Encode document to...'),
 
264
                menu_event => sub {
 
265
                        require Padre::Wx::Dialog::Encode;
 
266
                        Padre::Wx::Dialog::Encode::encode_document_to(@_);
 
267
                },
 
268
        );
 
269
 
256
270
        $self->{convert_nl} = Wx::Menu->new;
257
271
        $self->Append(
258
272
                -1,
259
 
                Wx::gettext("Convert Encoding"),
 
273
                Wx::gettext("Convert EOL"),
260
274
                $self->{convert_nl}
261
275
        );
262
276
 
263
 
        $self->{convert_nl_windows} = $self->{convert_nl}->Append(
264
 
                -1,
265
 
                Wx::gettext("EOL to Windows")
266
 
        );
267
 
        Wx::Event::EVT_MENU(
268
 
                $main,
269
 
                $self->{convert_nl_windows},
270
 
                sub {
 
277
        $self->{convert_nl_windows} = $self->add_menu_item(
 
278
                $self->{convert_nl},
 
279
                name       => 'edit.convert_nl_windows',
 
280
                label      => Wx::gettext('EOL to Windows'),
 
281
                menu_event => sub {
271
282
                        $_[0]->convert_to("WIN");
272
283
                },
273
284
        );
274
285
 
275
 
        $self->{convert_nl_unix} = $self->{convert_nl}->Append(
276
 
                -1,
277
 
                Wx::gettext("EOL to Unix")
278
 
        );
279
 
        Wx::Event::EVT_MENU(
280
 
                $main,
281
 
                $self->{convert_nl_unix},
282
 
                sub {
 
286
        $self->{convert_nl_unix} = $self->add_menu_item(
 
287
                $self->{convert_nl},
 
288
                name       => 'edit.convert_nl_unix',
 
289
                label      => Wx::gettext('EOL to Unix'),
 
290
                menu_event => sub {
283
291
                        $_[0]->convert_to("UNIX");
284
292
                },
285
293
        );
286
294
 
287
 
        $self->{convert_nl_mac} = $self->{convert_nl}->Append(
288
 
                -1,
289
 
                Wx::gettext("EOL to Mac Classic")
290
 
        );
291
 
        Wx::Event::EVT_MENU(
292
 
                $main,
293
 
                $self->{convert_nl_mac},
294
 
                sub {
 
295
        $self->{convert_nl_mac} = $self->add_menu_item(
 
296
                $self->{convert_nl},
 
297
                name       => 'edit.convert_nl_mac',
 
298
                label      => Wx::gettext('EOL to Mac Classic'),
 
299
                menu_event => sub {
295
300
                        $_[0]->convert_to("MAC");
296
301
                },
297
302
        );
304
309
                $self->{tabs},
305
310
        );
306
311
 
307
 
        $self->{tabs_to_spaces} = $self->{tabs}->Append(
308
 
                -1,
309
 
                Wx::gettext("Tabs to Spaces...")
310
 
        );
311
 
        Wx::Event::EVT_MENU(
312
 
                $main,
313
 
                $self->{tabs_to_spaces},
314
 
                sub {
 
312
        $self->{tabs_to_spaces} = $self->add_menu_item(
 
313
                $self->{tabs},
 
314
                name       => 'edit.tabs_to_spaces',
 
315
                label      => Wx::gettext('Tabs to Spaces...'),
 
316
                menu_event => sub {
315
317
                        $_[0]->on_tab_and_space('Tab_to_Space');
316
318
                },
317
319
        );
318
320
 
319
 
        $self->{spaces_to_tabs} = $self->{tabs}->Append(
320
 
                -1,
321
 
                Wx::gettext("Spaces to Tabs...")
322
 
        );
323
 
        Wx::Event::EVT_MENU(
324
 
                $main,
325
 
                $self->{spaces_to_tabs},
326
 
                sub {
 
321
        $self->{spaces_to_tabs} = $self->add_menu_item(
 
322
                $self->{tabs},
 
323
                name       => 'edit.spaces_to_tabs',
 
324
                label      => Wx::gettext('Spaces to Tabs...'),
 
325
                menu_event => sub {
327
326
                        $_[0]->on_tab_and_space('Space_to_Tab');
328
327
                },
329
328
        );
330
329
 
331
330
        $self->{tabs}->AppendSeparator;
332
331
 
333
 
        $self->{delete_trailing} = $self->{tabs}->Append(
334
 
                -1,
335
 
                Wx::gettext("Delete Trailing Spaces")
336
 
        );
337
 
        Wx::Event::EVT_MENU(
338
 
                $main,
339
 
                $self->{delete_trailing},
340
 
                sub {
 
332
        $self->{delete_trailing} = $self->add_menu_item(
 
333
                $self->{tabs},
 
334
                name       => 'edit.delete_trailing',
 
335
                label      => Wx::gettext('Delete Trailing Spaces'),
 
336
                menu_event => sub {
341
337
                        $_[0]->on_delete_ending_space;
342
338
                },
343
339
        );
344
340
 
345
 
        $self->{delete_leading} = $self->{tabs}->Append(
346
 
                -1,
347
 
                Wx::gettext("Delete Leading Spaces")
348
 
        );
349
 
        Wx::Event::EVT_MENU(
350
 
                $main,
351
 
                $self->{delete_leading},
352
 
                sub {
 
341
        $self->{delete_leading} = $self->add_menu_item(
 
342
                $self->{tabs},
 
343
                name       => 'edit.delete_leading',
 
344
                label      => Wx::gettext('Delete Leading Spaces'),
 
345
                menu_event => sub {
353
346
                        $_[0]->on_delete_leading_space;
354
347
                },
355
348
        );
362
355
                $self->{case},
363
356
        );
364
357
 
365
 
        $self->{case_upper} = $self->{case}->Append(
366
 
                -1,
367
 
                Wx::gettext("Upper All\tCtrl-Shift-U"),
368
 
        );
369
 
        Wx::Event::EVT_MENU(
370
 
                $main,
371
 
                $self->{case_upper},
372
 
                sub {
 
358
        $self->{case_upper} = $self->add_menu_item(
 
359
                $self->{case},
 
360
                name       => 'edit.case_upper',
 
361
                label      => Wx::gettext('Upper All'),
 
362
                shortcut   => 'Ctrl-Shift-U',
 
363
                menu_event => sub {
373
364
                        $_[0]->current->editor->UpperCase;
374
365
                },
375
366
        );
376
367
 
377
 
        $self->{case_lower} = $self->{case}->Append(
378
 
                -1,
379
 
                Wx::gettext("Lower All\tCtrl-U"),
380
 
        );
381
 
        Wx::Event::EVT_MENU(
382
 
                $main,
383
 
                $self->{case_lower},
384
 
                sub {
 
368
        $self->{case_lower} = $self->add_menu_item(
 
369
                $self->{case},
 
370
                name       => 'edit.case_lower',
 
371
                label      => Wx::gettext('Lower All'),
 
372
                shortcut   => 'Ctrl-U',
 
373
                menu_event => sub {
385
374
                        $_[0]->current->editor->LowerCase;
386
375
                },
387
376
        );
388
377
 
389
378
        $self->AppendSeparator;
390
379
 
391
 
        # Diff
392
 
        $self->{diff} = $self->Append(
393
 
                -1,
394
 
                Wx::gettext("Diff")
395
 
        );
396
 
        Wx::Event::EVT_MENU(
397
 
                $main,
398
 
                $self->{diff},
399
 
                sub {
400
 
                        Padre::Wx::Main::on_diff(@_);
401
 
                },
402
 
        );
403
 
 
404
 
        $self->{insert_from_file} = $self->Append(
405
 
                -1,
406
 
                Wx::gettext("Insert From File...")
407
 
        );
408
 
        Wx::Event::EVT_MENU(
409
 
                $main,
410
 
                $self->{insert_from_file},
411
 
                sub {
 
380
        # Diff tools
 
381
        $self->{diff} = Wx::Menu->new;
 
382
        $self->Append(
 
383
                -1,
 
384
                Wx::gettext("Diff Tools"),
 
385
                $self->{diff},
 
386
        );
 
387
 
 
388
        $self->{diff2saved} = $self->add_menu_item(
 
389
                $self->{diff},
 
390
                name       => 'edit.diff2saved',
 
391
                label      => Wx::gettext('Diff to Saved Version'),
 
392
                menu_event => sub {
 
393
                        Padre::Wx::Main::on_diff(@_);
 
394
                },
 
395
        );
 
396
        $self->{diff}->AppendSeparator;
 
397
        $self->{applydiff2file} = $self->add_menu_item(
 
398
                $self->{diff},
 
399
                name       => 'edit.applydiff2file',
 
400
                label      => Wx::gettext('Apply Diff to File'),
 
401
                menu_event => sub {
 
402
                        Padre::Wx::Main::on_diff(@_);
 
403
                },
 
404
        );
 
405
        $self->{applydiff2project} = $self->add_menu_item(
 
406
                $self->{diff},
 
407
                name       => 'edit.applydiff2project',
 
408
                label      => Wx::gettext('Apply Diff to Project'),
 
409
                menu_event => sub {
 
410
                        Padre::Wx::Main::on_diff(@_);
 
411
                },
 
412
        );
 
413
 
 
414
        $self->{insert_from_file} = $self->add_menu_item(
 
415
                $self,
 
416
                name       => 'edit.insert_from_file',
 
417
                label      => Wx::gettext('Insert From File...'),
 
418
                menu_event => sub {
412
419
                        Padre::Wx::Main::on_insert_from_file(@_);
413
420
                },
414
421
        );
415
422
 
416
423
        $self->AppendSeparator;
417
424
 
 
425
        $self->{show_as_number} = Wx::Menu->new;
 
426
        $self->Append(
 
427
                -1,
 
428
                Wx::gettext("Show as ..."),
 
429
                $self->{show_as_number}
 
430
        );
 
431
 
 
432
        $self->{show_as_hex} = $self->add_menu_item(
 
433
                $self->{show_as_number},
 
434
                name       => 'edit.show_as_hex',
 
435
                label      => Wx::gettext('Show as hexa'),
 
436
                menu_event => sub {
 
437
                        Padre::Wx::Main::show_as_numbers( @_, 'hex' );
 
438
                },
 
439
        );
 
440
 
 
441
        $self->{show_as_decimal} = $self->add_menu_item(
 
442
                $self->{show_as_number},
 
443
                name       => 'edit.show_as_decimal',
 
444
                label      => Wx::gettext('Show as decimal'),
 
445
                menu_event => sub {
 
446
                        Padre::Wx::Main::show_as_numbers( @_, 'decimal' );
 
447
                },
 
448
        );
 
449
 
 
450
        $self->AppendSeparator;
 
451
 
418
452
        # User Preferences
419
 
        Wx::Event::EVT_MENU(
420
 
                $main,
421
 
                $self->Append(
422
 
                        -1,
423
 
                        Wx::gettext("Preferences")
424
 
                ),
425
 
                sub {
 
453
        $self->add_menu_item(
 
454
                $self,
 
455
                name       => 'edit.preferences',
 
456
                label      => Wx::gettext('Preferences'),
 
457
                menu_event => sub {
426
458
                        Padre::Wx::Main::on_preferences(@_);
427
459
                },
428
460
        );
445
477
        $self->{brace_match}->Enable($hasdoc);
446
478
        $self->{join_lines}->Enable($hasdoc);
447
479
        $self->{snippets}->Enable($hasdoc);
 
480
        $self->{comment_toggle}->Enable($hasdoc);
448
481
        $self->{comment_out}->Enable($hasdoc);
449
482
        $self->{uncomment}->Enable($hasdoc);
450
 
        $self->{diff}->Enable($hasdoc);
 
483
        $self->{diff2saved}->Enable($hasdoc);
 
484
        $self->{applydiff2file}->Enable(0);
 
485
        $self->{applydiff2project}->Enable(0);
451
486
        $self->{insert_from_file}->Enable($hasdoc);
452
487
        $self->{case_upper}->Enable($hasdoc);
453
488
        $self->{case_lower}->Enable($hasdoc);