← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to plug-ins/imagemap/imap_menu.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/imagemap/imap_menu.c
3
3
 *
4
4
 * Generates clickable image maps.
5
5
 *
6
 
 * Copyright (C) 1998-2004 Maurits Rijk  m.rijk@chello.nl
 
6
 * Copyright (C) 1998-2006 Maurits Rijk  m.rijk@chello.nl
7
7
 *
8
8
 * This program is free software; you can redistribute it and/or modify
9
9
 * it under the terms of the GNU General Public License as published by
24
24
#include "config.h"
25
25
 
26
26
#include <gtk/gtk.h>
27
 
#include <gdk/gdkkeysyms.h>
28
 
 
 
27
 
 
28
#include "libgimpwidgets/gimpwidgets.h"
 
29
 
 
30
#include "imap_about.h"
29
31
#include "imap_circle.h"
30
32
#include "imap_file.h"
31
33
#include "imap_grid.h"
33
35
#include "imap_menu.h"
34
36
#include "imap_menu_funcs.h"
35
37
#include "imap_polygon.h"
36
 
#include "imap_popup.h"
37
38
#include "imap_preferences.h"
38
39
#include "imap_rectangle.h"
39
40
#include "imap_settings.h"
40
41
#include "imap_stock.h"
41
42
#include "imap_source.h"
42
 
#include "imap_tools.h"
43
43
 
44
44
#include "libgimp/stdplugins-intl.h"
45
45
 
46
 
static gint _menu_callback_lock;
47
46
static Menu_t _menu;
 
47
static GtkUIManager *ui_manager;
 
48
 
 
49
GtkWidget*
 
50
menu_get_widget(const gchar *path)
 
51
{
 
52
  return gtk_ui_manager_get_widget (ui_manager, path);
 
53
}
48
54
 
49
55
static void
50
 
menu_select(GtkWidget *item)
 
56
set_sensitive (const gchar *path, gboolean sensitive)
51
57
{
52
 
   _menu_callback_lock = TRUE;
53
 
   gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
 
58
  GtkAction *action = gtk_ui_manager_get_action (ui_manager, path);
 
59
  g_object_set (action, "sensitive", sensitive, NULL);
54
60
}
55
61
 
56
62
static void
71
77
void
72
78
menu_set_zoom_sensitivity(gint factor)
73
79
{
74
 
   gtk_widget_set_sensitive(_menu.zoom_in, factor < 8);
75
 
   gtk_widget_set_sensitive(_menu.zoom_out, factor > 1);
 
80
  set_sensitive ("/MainMenu/ViewMenu/ZoomIn", factor < 8);
 
81
  set_sensitive ("/MainMenu/ViewMenu/ZoomOut", factor > 1);
 
82
}
 
83
 
 
84
void
 
85
menu_set_zoom(gint factor)
 
86
{
 
87
  menu_set_zoom_sensitivity (factor);
76
88
}
77
89
 
78
90
void
79
91
menu_shapes_selected(gint count)
80
92
{
81
 
   gboolean sensitive = (count > 0);
82
 
   gtk_widget_set_sensitive(_menu.cut, sensitive);
83
 
   gtk_widget_set_sensitive(_menu.copy, sensitive);
84
 
   gtk_widget_set_sensitive(_menu.clear, sensitive);
85
 
   gtk_widget_set_sensitive(_menu.edit, sensitive);
86
 
   gtk_widget_set_sensitive(_menu.deselect_all, sensitive);
87
 
}
88
 
 
89
 
static void
90
 
menu_zoom_to(GtkWidget *widget, gpointer data)
91
 
{
92
 
   if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
93
 
      gint factor = GPOINTER_TO_INT (data);
94
 
 
95
 
      if (_menu_callback_lock) {
96
 
         _menu_callback_lock--;
97
 
      } else {
98
 
         set_zoom(factor);
99
 
      }
100
 
      menu_set_zoom_sensitivity(factor);
101
 
   }
102
 
}
103
 
 
104
 
static void
105
 
menu_rectangle(GtkWidget *widget, gpointer data)
106
 
{
107
 
   if (_menu_callback_lock) {
108
 
      _menu_callback_lock = FALSE;
109
 
   } else {
110
 
      set_rectangle_func();
111
 
      tools_select_rectangle();
112
 
      popup_select_rectangle();
113
 
   }
114
 
}
115
 
 
116
 
static void
117
 
menu_circle(GtkWidget *widget, gpointer data)
118
 
{
119
 
   if (_menu_callback_lock) {
120
 
      _menu_callback_lock = FALSE;
121
 
   } else {
122
 
      set_circle_func();
123
 
      tools_select_circle();
124
 
      popup_select_circle();
125
 
   }
126
 
}
127
 
 
128
 
static void
129
 
menu_polygon(GtkWidget *widget, gpointer data)
130
 
{
131
 
   if (_menu_callback_lock) {
132
 
      _menu_callback_lock = FALSE;
133
 
   } else {
134
 
      set_polygon_func();
135
 
      tools_select_polygon();
136
 
      popup_select_polygon();
137
 
   }
138
 
}
139
 
 
140
 
static void
141
 
menu_arrow(GtkWidget *widget, gpointer data)
142
 
{
143
 
   if (_menu_callback_lock) {
144
 
      _menu_callback_lock = FALSE;
145
 
   } else {
146
 
      set_arrow_func();
147
 
      tools_select_arrow();
148
 
      popup_select_arrow();
149
 
   }
150
 
}
151
 
 
152
 
static void
153
 
menu_fuzzy_select(GtkWidget *widget, gpointer data)
154
 
{
155
 
   if (_menu_callback_lock) {
156
 
      _menu_callback_lock = FALSE;
157
 
   } else {
158
 
/*
159
 
      set_fuzzy_select_func();
160
 
      tools_select_fuzzy();
161
 
      popup_select_fuzzy();
162
 
*/
163
 
   }
164
 
}
165
 
 
166
 
static void
167
 
menu_grid(GtkWidget *widget, gpointer data)
168
 
{
169
 
   if (_menu_callback_lock) {
170
 
      _menu_callback_lock = FALSE;
171
 
   } else {
172
 
      gint grid = toggle_grid();
173
 
      popup_check_grid(grid);
174
 
      main_toolbar_set_grid(grid);
175
 
   }
176
 
}
177
 
 
178
 
static void
179
 
make_file_menu(GtkWidget *menu_bar)
180
 
{
181
 
   GtkWidget *file_menu = make_menu_bar_item(menu_bar, _("_File"));
182
 
   GtkWidget *item;
183
 
 
184
 
   _menu.file_menu = file_menu;
185
 
   make_item_with_image(file_menu, GTK_STOCK_OPEN, menu_command,
186
 
                        &_menu.cmd_open);
187
 
   _menu.open_recent = make_sub_menu(file_menu, _("Open recent"));
188
 
   make_item_with_image(file_menu, GTK_STOCK_SAVE, menu_command,
189
 
                        &_menu.cmd_save);
190
 
   item = make_item_with_image(file_menu, GTK_STOCK_SAVE_AS, menu_command,
191
 
                               &_menu.cmd_save_as);
192
 
   add_accelerator(item, 'S', GDK_SHIFT_MASK|GDK_CONTROL_MASK);
193
 
   make_separator(file_menu);
194
 
   make_item_with_image(file_menu, GTK_STOCK_CLOSE, menu_command,
195
 
                        &_menu.cmd_close);
196
 
   make_item_with_image(file_menu, GTK_STOCK_QUIT, menu_command,
197
 
                        &_menu.cmd_quit);
198
 
}
199
 
 
 
93
  gboolean sensitive = (count > 0);
 
94
  set_sensitive ("/MainMenu/EditMenu/Cut", sensitive);
 
95
  set_sensitive ("/MainMenu/EditMenu/Copy", sensitive);
 
96
  set_sensitive ("/MainMenu/EditMenu/Clear", sensitive);
 
97
  set_sensitive ("/MainMenu/EditMenu/EditAreaInfo", sensitive);
 
98
  set_sensitive ("/MainMenu/EditMenu/DeselectAll", sensitive);
 
99
}
 
100
 
 
101
#ifdef _NOT_READY_YET_
200
102
static void
201
103
command_list_changed(Command_t *command, gpointer data)
202
104
{
234
136
   gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(_menu.redo), icon);
235
137
   gtk_widget_show(icon);
236
138
}
 
139
#endif
237
140
 
238
141
static void
239
142
paste_buffer_added(Object_t *obj, gpointer data)
240
143
{
241
 
   gtk_widget_set_sensitive((GtkWidget*) data, TRUE);
 
144
  set_sensitive("/MainMenu/EditMenu/Paste", TRUE);
242
145
}
243
146
 
244
147
static void
245
148
paste_buffer_removed(Object_t *obj, gpointer data)
246
149
{
247
 
   gtk_widget_set_sensitive((GtkWidget*) data, FALSE);
248
 
}
249
 
 
250
 
static void
251
 
make_edit_menu(GtkWidget *menu_bar)
252
 
{
253
 
   GtkWidget *edit_menu = make_menu_bar_item(menu_bar, _("_Edit"));
254
 
   GtkWidget *item, *paste;
255
 
 
256
 
   _menu.edit_menu = edit_menu;
257
 
   command_list_changed(NULL, NULL);
258
 
 
259
 
   make_separator(edit_menu);
260
 
   _menu.cut = make_item_with_image(edit_menu, GTK_STOCK_CUT, menu_command,
261
 
                                    &_menu.cmd_cut);
262
 
   _menu.copy = make_item_with_image(edit_menu, GTK_STOCK_COPY, menu_command,
263
 
                                     &_menu.cmd_copy);
264
 
   paste = make_item_with_image(edit_menu, GTK_STOCK_PASTE, menu_command,
265
 
                                &_menu.cmd_paste);
266
 
   gtk_widget_set_sensitive(paste, FALSE);
267
 
   _menu.clear = make_item_with_image(edit_menu, GTK_STOCK_CLEAR, menu_command,
268
 
                                      &_menu.cmd_clear);
269
 
   add_accelerator(_menu.clear, 'K', GDK_CONTROL_MASK);
270
 
   make_separator(edit_menu);
271
 
   item = make_item_with_label(edit_menu, _("Select _all"), menu_command,
272
 
                               &_menu.cmd_select_all);
273
 
   add_accelerator(item, 'A', GDK_CONTROL_MASK);
274
 
   _menu.deselect_all = make_item_with_label(edit_menu, _("Deselect _all"),
275
 
                                             menu_command,
276
 
                                             &_menu.cmd_deselect_all);
277
 
   add_accelerator(_menu.deselect_all, 'A', GDK_SHIFT_MASK|GDK_CONTROL_MASK);
278
 
   make_separator(edit_menu);
279
 
   _menu.edit = make_item_with_label(edit_menu, _("Edit area info..."),
280
 
                                     menu_command, &_menu.cmd_edit_area_info);
281
 
   make_separator(edit_menu);
282
 
   make_item_with_image(edit_menu, GTK_STOCK_PREFERENCES, menu_command,
283
 
                        &_menu.cmd_preferences);
284
 
 
285
 
   paste_buffer_add_add_cb(paste_buffer_added, (gpointer) paste);
286
 
   paste_buffer_add_remove_cb(paste_buffer_removed, (gpointer) paste);
287
 
 
288
 
   command_list_add_update_cb(command_list_changed, NULL);
289
 
}
290
 
 
291
 
static void
292
 
make_view_menu(GtkWidget *menu_bar)
293
 
{
294
 
   GtkWidget *view_menu = make_menu_bar_item(menu_bar, _("_View"));
295
 
   GtkWidget *zoom_menu, *item;
296
 
   GSList *group = NULL;
297
 
 
298
 
   item = make_check_item(view_menu, _("Area list"), menu_command,
299
 
                          &_menu.cmd_area_list);
300
 
   GTK_CHECK_MENU_ITEM(item)->active = TRUE;
301
 
 
302
 
   make_item_with_label(view_menu, _("Source..."), menu_command,
303
 
                        &_menu.cmd_source);
304
 
   make_separator(view_menu);
305
 
 
306
 
   _menu.color = make_radio_item(view_menu, NULL, _("Color"), menu_command,
307
 
                                 &_menu.cmd_color);
308
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.color));
309
 
 
310
 
   _menu.gray = make_radio_item(view_menu, group, _("Grayscale"), menu_command,
311
 
                                &_menu.cmd_gray);
312
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.gray));
313
 
 
314
 
   if (!get_map_info()->color) { /* Gray image */
315
 
      gtk_widget_set_sensitive(_menu.color, FALSE);
316
 
      GTK_CHECK_MENU_ITEM(_menu.color)->active = FALSE;
317
 
      GTK_CHECK_MENU_ITEM(_menu.gray)->active = TRUE;
318
 
   }
319
 
 
320
 
   make_separator(view_menu);
321
 
 
322
 
   _menu.zoom_in = make_item_with_image(view_menu, GTK_STOCK_ZOOM_IN,
323
 
                                        menu_command, &_menu.cmd_zoom_in);
324
 
   _menu.zoom_out = make_item_with_image(view_menu, GTK_STOCK_ZOOM_OUT,
325
 
                                         menu_command, &_menu.cmd_zoom_out);
326
 
   gtk_widget_set_sensitive(_menu.zoom_out, FALSE);
327
 
 
328
 
   zoom_menu = make_sub_menu(view_menu, _("Zoom to"));
329
 
 
330
 
   _menu.zoom[0] = make_radio_item(zoom_menu, NULL, "1:1", menu_zoom_to,
331
 
                                   (gpointer) 1);
332
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.zoom[0]));
333
 
   _menu.zoom[1] = make_radio_item(zoom_menu, group, "1:2", menu_zoom_to,
334
 
                                   (gpointer) 2);
335
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.zoom[1]));
336
 
   _menu.zoom[2] = make_radio_item(zoom_menu, group, "1:3", menu_zoom_to,
337
 
                                   (gpointer) 3);
338
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.zoom[2]));
339
 
   _menu.zoom[3] = make_radio_item(zoom_menu, group, "1:4", menu_zoom_to,
340
 
                                   (gpointer) 4);
341
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.zoom[3]));
342
 
   _menu.zoom[4] = make_radio_item(zoom_menu, group, "1:5", menu_zoom_to,
343
 
                                   (gpointer) 5);
344
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.zoom[4]));
345
 
   _menu.zoom[5] = make_radio_item(zoom_menu, group, "1:6", menu_zoom_to,
346
 
                                   (gpointer) 6);
347
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.zoom[5]));
348
 
   _menu.zoom[6] = make_radio_item(zoom_menu, group, "1:7", menu_zoom_to,
349
 
                                   (gpointer) 7);
350
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.zoom[6]));
351
 
   _menu.zoom[7] = make_radio_item(zoom_menu, group, "1:8", menu_zoom_to,
352
 
                                   (gpointer) 8);
353
 
}
354
 
 
355
 
static void
356
 
make_mapping_menu(GtkWidget *menu_bar)
357
 
{
358
 
   GtkWidget *menu = make_menu_bar_item(menu_bar, _("_Mapping"));
359
 
   GSList    *group;
360
 
 
361
 
   _menu.arrow = make_radio_item(menu, NULL, _("Arrow"), menu_arrow, NULL);
362
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.arrow));
363
 
#ifdef _NOT_READY_YET_
364
 
   _menu.fuzzy_select = make_radio_item(menu, group,
365
 
                                        _("Select contiguous region"),
366
 
                                        menu_fuzzy_select, NULL);
367
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.fuzzy_select));
368
 
#endif
369
 
   _menu.rectangle = make_radio_item(menu, group, _("Rectangle"),
370
 
                                     menu_rectangle, NULL);
371
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.rectangle));
372
 
   _menu.circle = make_radio_item(menu, group, _("Circle"), menu_circle, NULL);
373
 
   group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(_menu.circle));
374
 
   _menu.polygon = make_radio_item(menu, group, _("Polygon"), menu_polygon,
375
 
                                   NULL);
376
 
   make_separator(menu);
377
 
   make_item_with_image(menu, IMAP_STOCK_MAP_INFO, menu_command,
378
 
                        &_menu.cmd_edit_map_info);
379
 
}
380
 
 
381
 
static void
382
 
make_tools_menu(GtkWidget *menu_bar)
383
 
{
384
 
   GtkWidget *tools_menu = make_menu_bar_item(menu_bar, _("_Tools"));
385
 
   _menu.grid = make_check_item(tools_menu, _("Grid"), menu_grid, NULL);
386
 
   make_item_with_label(tools_menu, _("Grid settings..."), menu_command,
387
 
                        &_menu.cmd_grid_settings);
388
 
   make_separator(tools_menu);
389
 
   make_item_with_label(tools_menu, _("Use GIMP guides..."), menu_command,
390
 
                        &_menu.cmd_use_gimp_guides);
391
 
   make_item_with_label(tools_menu, _("Create guides..."), menu_command,
392
 
                        &_menu.cmd_create_guides);
393
 
}
394
 
 
395
 
static void
396
 
make_help_menu(GtkWidget *menu_bar)
397
 
{
398
 
  GtkWidget *item;
399
 
  GtkWidget *help_menu = make_menu_bar_item(menu_bar, _("_Help"));
400
 
 
401
 
  item = make_item_with_label(help_menu, _("_Contents"), menu_command,
402
 
                              &_menu.cmd_help);
403
 
  add_accelerator(item, GDK_F1, 0);
404
 
 
405
 
  make_item_with_label(help_menu, _("_About ImageMap"), menu_command,
406
 
                       &_menu.cmd_about);
407
 
}
 
150
  set_sensitive("/MainMenu/EditMenu/Paste", FALSE);
 
151
}
 
152
 
 
153
/* Normal items */
 
154
static const GtkActionEntry entries[] = {
 
155
  { "FileMenu", NULL, N_("_File") },
 
156
  { "Open", GTK_STOCK_OPEN, N_("_Open..."), NULL, N_("Open"),
 
157
    do_file_open_dialog},
 
158
  { "Save", GTK_STOCK_SAVE, N_("_Save..."), NULL, N_("Save"),
 
159
    save},
 
160
  { "SaveAs", GTK_STOCK_SAVE_AS, N_("Save _As..."), "<shift><control>S", NULL,
 
161
    do_file_save_as_dialog},
 
162
  { "Close", GTK_STOCK_CLOSE, NULL, NULL, NULL, do_close},
 
163
  { "Quit", GTK_STOCK_QUIT, NULL, NULL, NULL, do_quit},
 
164
 
 
165
  { "EditMenu", NULL, N_("_Edit") },
 
166
  { "Undo", GTK_STOCK_UNDO, NULL, NULL, N_("Undo"), NULL},
 
167
  { "Redo", GTK_STOCK_REDO, NULL, NULL, N_("Redo"), NULL},
 
168
  { "Cut", GTK_STOCK_CUT, NULL, NULL, N_("Cut"), do_cut},
 
169
  { "Copy", GTK_STOCK_COPY, NULL, NULL, N_("Copy"), do_copy},
 
170
  { "Paste", GTK_STOCK_PASTE, NULL, NULL, N_("Paste"), do_paste},
 
171
  { "Clear", GTK_STOCK_DELETE, NULL, N_("Delete"), NULL, do_clear},
 
172
  { "SelectAll", NULL, N_("Select _All"), "<control>A", NULL, do_select_all},
 
173
  { "DeselectAll", NULL, N_("D_eselect All"), "<shift><control>A", NULL,
 
174
    do_deselect_all},
 
175
  { "EditAreaInfo", GTK_STOCK_EDIT, N_("Edit Area _Info..."), NULL,
 
176
    N_("Edit selected area info"), do_edit_selected_shape},
 
177
  { "Preferences", GTK_STOCK_PREFERENCES, NULL, NULL, N_("Preferences"),
 
178
    do_preferences_dialog},
 
179
  { "MoveToFront", IMAP_STOCK_TO_FRONT, "", NULL, N_("Move to Front"),
 
180
    do_move_to_front},
 
181
  { "SendToBack", IMAP_STOCK_TO_BACK, "", NULL, N_("Send to Back"),
 
182
    do_send_to_back},
 
183
  { "DeleteArea", NULL, N_("Delete Area"), NULL, NULL, NULL},
 
184
  { "MoveUp", GTK_STOCK_GO_UP, N_("Move Up"), NULL, NULL, NULL},
 
185
  { "MoveDown", GTK_STOCK_GO_DOWN, N_("Move Down"), NULL, NULL, NULL},
 
186
 
 
187
  { "InsertPoint", NULL, N_("Insert Point"), NULL, NULL, polygon_insert_point},
 
188
  { "DeletePoint", NULL, N_("Delete Point"), NULL, NULL, polygon_delete_point},
 
189
 
 
190
  { "ViewMenu", NULL, N_("_View") },
 
191
  { "Source", NULL, N_("Source..."), NULL, NULL, do_source_dialog},
 
192
  { "ZoomIn", GTK_STOCK_ZOOM_IN, NULL, "plus", N_("Zoom in"), do_zoom_in},
 
193
  { "ZoomOut", GTK_STOCK_ZOOM_OUT, NULL, "minus", N_("Zoom out"), do_zoom_out},
 
194
  { "ZoomToMenu", NULL, N_("_Zoom To") },
 
195
 
 
196
  { "MappingMenu", NULL, N_("_Mapping") },
 
197
  { "EditMapInfo", GTK_STOCK_INFO, N_("Edit Map Info..."), NULL,
 
198
    N_("Edit Map Info"), do_settings_dialog},
 
199
 
 
200
  { "ToolsMenu", NULL, N_("_Tools") },
 
201
  { "GridSettings", NULL, N_("Grid Settings..."), NULL, NULL,
 
202
    do_grid_settings_dialog},
 
203
  { "UseGimpGuides", NULL, N_("Use GIMP Guides..."), NULL, NULL,
 
204
    do_use_gimp_guides_dialog},
 
205
  { "CreateGuides", NULL, N_("Create Guides..."), NULL, NULL,
 
206
    do_create_guides_dialog},
 
207
 
 
208
  { "HelpMenu", NULL, N_("_Help") },
 
209
  { "Contents", GTK_STOCK_HELP, N_("_Contents"), NULL, NULL, imap_help},
 
210
  { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, do_about_dialog},
 
211
 
 
212
  { "ZoomMenu", NULL, N_("_Zoom") },
 
213
};
 
214
 
 
215
/* Toggle items */
 
216
static const GtkToggleActionEntry toggle_entries[] = {
 
217
  { "AreaList", NULL, N_("Area List"), NULL, NULL, NULL, TRUE },
 
218
  { "Grid", GIMP_STOCK_GRID, N_("_Grid"), NULL, N_("Grid"), toggle_grid, FALSE }
 
219
};
 
220
 
 
221
static const GtkRadioActionEntry color_entries[] = {
 
222
  { "Color", NULL, N_("Color"), NULL, NULL, 0},
 
223
  { "Gray", NULL, N_("Gray"), NULL, NULL, 1},
 
224
};
 
225
 
 
226
static const GtkRadioActionEntry mapping_entries[] = {
 
227
  { "Arrow", GIMP_STOCK_CURSOR, N_("Arrow"), NULL,
 
228
    N_("Select existing area"), 0},
 
229
  { "Rectangle", IMAP_STOCK_RECTANGLE, N_("Rectangle"), NULL,
 
230
    N_("Define Rectangle area"), 1},
 
231
  { "Circle", IMAP_STOCK_CIRCLE, N_("Circle"), NULL,
 
232
    N_("Define Circle/Oval area"), 2},
 
233
  { "Polygon", IMAP_STOCK_POLYGON, N_("Polygon"), NULL,
 
234
    N_("Define Polygon area"), 3},
 
235
};
 
236
 
 
237
static const GtkRadioActionEntry zoom_entries[] = {
 
238
  { "Zoom1:1", NULL, "1:1", NULL, NULL, 0},
 
239
  { "Zoom1:2", NULL, "1:2", NULL, NULL, 1},
 
240
  { "Zoom1:3", NULL, "1:3", NULL, NULL, 2},
 
241
  { "Zoom1:4", NULL, "1:4", NULL, NULL, 3},
 
242
  { "Zoom1:5", NULL, "1:5", NULL, NULL, 4},
 
243
  { "Zoom1:6", NULL, "1:6", NULL, NULL, 5},
 
244
  { "Zoom1:7", NULL, "1:7", NULL, NULL, 6},
 
245
  { "Zoom1:8", NULL, "1:8", NULL, NULL, 7},
 
246
};
 
247
 
 
248
static const gchar ui_description[] =
 
249
"<ui>"
 
250
"  <menubar name='MainMenu'>"
 
251
"    <menu action='FileMenu'>"
 
252
"      <menuitem action='Open'/>"
 
253
"      <menuitem action='Save'/>"
 
254
"      <menuitem action='SaveAs'/>"
 
255
"      <separator/>"
 
256
"      <menuitem action='Close'/>"
 
257
"      <menuitem action='Quit'/>"
 
258
"    </menu>"
 
259
"    <menu action='EditMenu'>"
 
260
"      <menuitem action='Cut'/>"
 
261
"      <menuitem action='Copy'/>"
 
262
"      <menuitem action='Paste'/>"
 
263
"      <menuitem action='Clear'/>"
 
264
"      <separator/>"
 
265
"      <menuitem action='SelectAll'/>"
 
266
"      <menuitem action='DeselectAll'/>"
 
267
"      <separator/>"
 
268
"      <menuitem action='EditAreaInfo'/>"
 
269
"      <separator/>"
 
270
"      <menuitem action='Preferences'/>"
 
271
"    </menu>"
 
272
"    <menu action='ViewMenu'>"
 
273
"      <menuitem action='AreaList'/>"
 
274
"      <menuitem action='Source'/>"
 
275
"      <separator/>"
 
276
"      <menuitem action='Color'/>"
 
277
"      <menuitem action='Gray'/>"
 
278
"      <separator/>"
 
279
"      <menuitem action='ZoomIn'/>"
 
280
"      <menuitem action='ZoomOut'/>"
 
281
"      <menu action='ZoomToMenu'>"
 
282
"        <menuitem action='Zoom1:1'/>"
 
283
"        <menuitem action='Zoom1:2'/>"
 
284
"        <menuitem action='Zoom1:3'/>"
 
285
"        <menuitem action='Zoom1:4'/>"
 
286
"        <menuitem action='Zoom1:5'/>"
 
287
"        <menuitem action='Zoom1:6'/>"
 
288
"        <menuitem action='Zoom1:7'/>"
 
289
"        <menuitem action='Zoom1:8'/>"
 
290
"      </menu>"
 
291
"    </menu>"
 
292
"    <menu action='MappingMenu'>"
 
293
"      <menuitem action='Arrow'/>"
 
294
"      <menuitem action='Rectangle'/>"
 
295
"      <menuitem action='Circle'/>"
 
296
"      <menuitem action='Polygon'/>"
 
297
"      <separator/>"
 
298
"      <menuitem action='EditMapInfo'/>"
 
299
"    </menu>"
 
300
"    <menu action='ToolsMenu'>"
 
301
"      <menuitem action='Grid'/>"
 
302
"      <menuitem action='GridSettings'/>"
 
303
"      <separator/>"
 
304
"      <menuitem action='UseGimpGuides'/>"
 
305
"      <menuitem action='CreateGuides'/>"
 
306
"    </menu>"
 
307
"    <menu action='HelpMenu'>"
 
308
"      <menuitem action='Contents'/>"
 
309
"      <menuitem action='About'/>"
 
310
"    </menu>"
 
311
"  </menubar>"
 
312
""
 
313
"  <popup name='PopupMenu'>"
 
314
"    <menuitem action='EditMapInfo'/>"
 
315
"    <menu action='ToolsMenu'>"
 
316
"      <menuitem action='Arrow'/>"
 
317
"      <menuitem action='Rectangle'/>"
 
318
"      <menuitem action='Circle'/>"
 
319
"      <menuitem action='Polygon'/>"
 
320
"    </menu>"
 
321
"    <menu action='ZoomMenu'>"
 
322
"      <menuitem action='ZoomIn'/>"
 
323
"      <menuitem action='ZoomOut'/>"
 
324
"    </menu>"
 
325
"    <menuitem action='Grid'/>"
 
326
"    <menuitem action='GridSettings'/>"
 
327
"    <menuitem action='CreateGuides'/>"
 
328
"    <menuitem action='Paste'/>"
 
329
"  </popup>"
 
330
""
 
331
"  <popup name='ObjectPopupMenu'>"
 
332
"    <menuitem action='EditAreaInfo'/>"
 
333
"    <menuitem action='DeleteArea'/>"
 
334
"    <menuitem action='MoveUp'/>"
 
335
"    <menuitem action='MoveDown'/>"
 
336
"    <menuitem action='Cut'/>"
 
337
"    <menuitem action='Copy'/>"
 
338
"  </popup>"
 
339
""
 
340
"  <popup name='PolygonPopupMenu'>"
 
341
"    <menuitem action='InsertPoint'/>"
 
342
"    <menuitem action='DeletePoint'/>"
 
343
"    <menuitem action='EditAreaInfo'/>"
 
344
"    <menuitem action='DeleteArea'/>"
 
345
"    <menuitem action='MoveUp'/>"
 
346
"    <menuitem action='MoveDown'/>"
 
347
"    <menuitem action='Cut'/>"
 
348
"    <menuitem action='Copy'/>"
 
349
"  </popup>"
 
350
""
 
351
"  <toolbar name='Toolbar'>"
 
352
"    <toolitem action='Open'/>"
 
353
"    <toolitem action='Save'/>"
 
354
"    <separator/>"
 
355
"    <toolitem action='Preferences'/>"
 
356
"    <separator/>"
 
357
"    <toolitem action='Undo'/>"
 
358
"    <toolitem action='Redo'/>"
 
359
"    <separator/>"
 
360
"    <toolitem action='Cut'/>"
 
361
"    <toolitem action='Copy'/>"
 
362
"    <toolitem action='Paste'/>"
 
363
"    <separator/>"
 
364
"    <toolitem action='ZoomIn'/>"
 
365
"    <toolitem action='ZoomOut'/>"
 
366
"    <separator/>"
 
367
"    <toolitem action='EditMapInfo'/>"
 
368
"    <separator/>"
 
369
"    <toolitem action='MoveToFront'/>"
 
370
"    <toolitem action='SendToBack'/>"
 
371
"    <separator/>"
 
372
"    <toolitem action='Grid'/>"
 
373
"  </toolbar>"
 
374
""
 
375
"  <toolbar name='Tools'>"
 
376
"    <toolitem action='Arrow'/>"
 
377
"    <toolitem action='Rectangle'/>"
 
378
"    <toolitem action='Circle'/>"
 
379
"    <toolitem action='Polygon'/>"
 
380
"    <separator/>"
 
381
"    <toolitem action='EditAreaInfo'/>"
 
382
"  </toolbar>"
 
383
""
 
384
"  <toolbar name='Selection'>"
 
385
"    <toolitem action='MoveUp'/>"
 
386
"    <toolitem action='MoveDown'/>"
 
387
"    <toolitem action='EditAreaInfo'/>"
 
388
"    <toolitem action='Clear'/>"
 
389
"  </toolbar>"
 
390
"</ui>";
408
391
 
409
392
Menu_t*
410
393
make_menu(GtkWidget *main_vbox, GtkWidget *window)
411
394
{
412
 
   GtkWidget *menu_bar = gtk_menu_bar_new();
413
 
 
414
 
   gtk_box_pack_start(GTK_BOX(main_vbox), menu_bar, FALSE, TRUE, 0);
415
 
   gtk_widget_show(menu_bar);
416
 
 
417
 
   init_accel_group(window);
418
 
 
419
 
   make_file_menu(menu_bar);
420
 
   make_edit_menu(menu_bar);
421
 
   make_view_menu(menu_bar);
422
 
   make_mapping_menu(menu_bar);
423
 
   make_tools_menu(menu_bar);
424
 
   make_help_menu(menu_bar);
425
 
 
426
 
   menu_shapes_selected(0);
427
 
 
428
 
   return &_menu;
 
395
  GtkWidget *menubar;
 
396
  GtkActionGroup *action_group;
 
397
  GtkAccelGroup *accel_group;
 
398
  GError *error;
 
399
 
 
400
  action_group = gtk_action_group_new ("MenuActions");
 
401
  gtk_action_group_set_translation_domain (action_group, NULL);
 
402
 
 
403
  gtk_action_group_add_actions (action_group, entries, G_N_ELEMENTS (entries),
 
404
                                window);
 
405
  gtk_action_group_add_toggle_actions (action_group, toggle_entries,
 
406
                                       G_N_ELEMENTS (toggle_entries), window);
 
407
 
 
408
  gtk_action_group_add_radio_actions (action_group, color_entries,
 
409
                                      G_N_ELEMENTS (color_entries), 0,
 
410
                                      G_CALLBACK (set_preview_color), NULL);
 
411
  gtk_action_group_add_radio_actions (action_group, zoom_entries,
 
412
                                      G_N_ELEMENTS (zoom_entries), 0,
 
413
                                      G_CALLBACK (set_zoom_factor), NULL);
 
414
  gtk_action_group_add_radio_actions (action_group, mapping_entries,
 
415
                                      G_N_ELEMENTS (mapping_entries), 0,
 
416
                                      G_CALLBACK (set_func), window);
 
417
 
 
418
  ui_manager = gtk_ui_manager_new ();
 
419
  gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
 
420
 
 
421
  accel_group = gtk_ui_manager_get_accel_group (ui_manager);
 
422
  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
 
423
 
 
424
  error = NULL;
 
425
  if (!gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1,
 
426
                                          &error))
 
427
    {
 
428
      g_warning ("building menus failed: %s", error->message);
 
429
      g_error_free (error);
 
430
      /* exit (EXIT_FAILURE); */
 
431
    }
 
432
 
 
433
  menubar = gtk_ui_manager_get_widget (ui_manager, "/MainMenu");
 
434
  gtk_widget_show (menubar);
 
435
  gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, FALSE, 0);
 
436
 
 
437
  paste_buffer_add_add_cb(paste_buffer_added, NULL);
 
438
  paste_buffer_add_remove_cb(paste_buffer_removed, NULL);
 
439
 
 
440
  set_sensitive ("/MainMenu/EditMenu/Paste", FALSE);
 
441
  menu_shapes_selected (0);
 
442
 
 
443
  menu_set_zoom_sensitivity (1);
 
444
 
 
445
  return &_menu;
429
446
}
430
447
 
431
448
void
435
452
   gint position = 0;
436
453
   int i;
437
454
 
 
455
  return;
 
456
 
438
457
   if (_menu.nr_off_mru_items) {
439
458
      GList *children;
440
459
 
460
479
}
461
480
 
462
481
void
463
 
menu_select_arrow(void)
464
 
{
465
 
   menu_select(_menu.arrow);
466
 
}
467
 
 
468
 
void
469
 
menu_select_fuzzy_select(void)
470
 
{
471
 
   menu_select(_menu.fuzzy_select);
472
 
}
473
 
 
474
 
void
475
 
menu_select_rectangle(void)
476
 
{
477
 
   menu_select(_menu.rectangle);
478
 
}
479
 
 
480
 
void
481
 
menu_select_circle(void)
482
 
{
483
 
   menu_select(_menu.circle);
484
 
}
485
 
 
486
 
void
487
 
menu_select_polygon(void)
488
 
{
489
 
   menu_select(_menu.polygon);
490
 
}
491
 
 
492
 
void
493
 
menu_check_grid(gint check)
494
 
{
495
 
   _menu_callback_lock = TRUE;
496
 
   gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(_menu.grid), check);
497
 
}
498
 
 
499
 
void
500
 
menu_set_zoom(gint factor)
501
 
{
502
 
   _menu_callback_lock = 2;
503
 
   gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(_menu.zoom[factor - 1]),
504
 
                                  TRUE);
505
 
   menu_set_zoom_sensitivity(factor);
 
482
do_main_popup_menu(GdkEventButton *event)
 
483
{
 
484
  GtkWidget *popup = gtk_ui_manager_get_widget (ui_manager, "/PopupMenu");
 
485
  gtk_menu_popup (GTK_MENU (popup), NULL, NULL, NULL, NULL,
 
486
                  event->button, event->time);
 
487
}
 
488
 
 
489
void
 
490
menu_check_grid(gboolean check)
 
491
{
 
492
  GtkAction *action = gtk_ui_manager_get_action (ui_manager,
 
493
                                                 "/MainMenu/ToolsMenu/Grid");
 
494
  gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), check);
 
495
}
 
496
 
 
497
GtkWidget*
 
498
make_toolbar(GtkWidget *main_vbox, GtkWidget *window)
 
499
{
 
500
  GtkWidget *handlebox, *toolbar;
 
501
 
 
502
  handlebox = gtk_handle_box_new ();
 
503
  gtk_box_pack_start (GTK_BOX (main_vbox), handlebox, FALSE, FALSE, 0);
 
504
  toolbar = gtk_ui_manager_get_widget (ui_manager, "/Toolbar");
 
505
 
 
506
  gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
 
507
  gtk_container_set_border_width (GTK_CONTAINER (toolbar), 0);
 
508
 
 
509
  gtk_container_add (GTK_CONTAINER (handlebox), toolbar);
 
510
  gtk_widget_show (toolbar);
 
511
  gtk_widget_show (handlebox);
 
512
 
 
513
  return handlebox;
 
514
}
 
515
 
 
516
GtkWidget*
 
517
make_tools(GtkWidget *window)
 
518
{
 
519
  GtkWidget *handlebox, *toolbar;
 
520
 
 
521
  handlebox = gtk_handle_box_new ();
 
522
  toolbar = gtk_ui_manager_get_widget (ui_manager, "/Tools");
 
523
  gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar),
 
524
                               GTK_ORIENTATION_VERTICAL);
 
525
 
 
526
  gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
 
527
  gtk_container_set_border_width (GTK_CONTAINER (toolbar), 0);
 
528
 
 
529
  gtk_container_add (GTK_CONTAINER (handlebox), toolbar);
 
530
  gtk_widget_show (toolbar);
 
531
  gtk_widget_show (handlebox);
 
532
 
 
533
  return handlebox;
 
534
}
 
535
 
 
536
GtkWidget*
 
537
make_selection_toolbar(void)
 
538
{
 
539
  GtkWidget *toolbar;
 
540
 
 
541
  toolbar = gtk_ui_manager_get_widget (ui_manager, "/Selection");
 
542
 
 
543
  gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
 
544
  gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_VERTICAL);
 
545
  gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
 
546
 
 
547
  gtk_widget_show (toolbar);
 
548
  return toolbar;
506
549
}