home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / imagemap / imap_menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-23  |  14.3 KB  |  509 lines
  1. /*
  2.  * This is a plug-in for the GIMP.
  3.  *
  4.  * Generates clickable image maps.
  5.  *
  6.  * Copyright (C) 1998-1999 Maurits Rijk  lpeek.mrijk@consunet.nl
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21.  *
  22.  */
  23.  
  24. #include <sys/types.h>
  25. #include <sys/stat.h>
  26.  
  27. #include "config.h"
  28. #include "libgimp/stdplugins-intl.h"
  29.  
  30. #include "imap_circle.h"
  31. #include "imap_file.h"
  32. #include "imap_grid.h"
  33. #include "imap_main.h"
  34. #include "imap_menu.h"
  35. #include "imap_menu_funcs.h"
  36. #include "imap_polygon.h"
  37. #include "imap_popup.h"
  38. #include "imap_preferences.h"
  39. #include "imap_rectangle.h"
  40. #include "imap_settings.h"
  41. #include "imap_source.h"
  42. #include "imap_tools.h"
  43.  
  44. static gint _menu_callback_lock;
  45. static Menu_t _menu;
  46.  
  47. static void
  48. menu_select(GtkWidget *item)
  49. {
  50.    _menu_callback_lock = TRUE;
  51.    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
  52. }
  53.  
  54. static void
  55. menu_mru(GtkWidget *widget, gpointer data)
  56. {
  57.    MRU_t *mru = get_mru();
  58.    char *filename = (char*) data;
  59.    struct stat buf;
  60.    int err;
  61.  
  62.    err = stat(filename, &buf);
  63.    if (!err && (buf.st_mode & S_IFREG)) {
  64.       load(filename);
  65.    } else {
  66.       do_file_error_dialog(_("Error opening file"), filename);
  67.       mru_remove(mru, filename);
  68.       menu_build_mru_items(mru);
  69.    }
  70. }
  71.  
  72. void
  73. menu_set_zoom_sensitivity(gint factor)
  74. {
  75.    gtk_widget_set_sensitive(_menu.zoom_in, factor < 8);
  76.    gtk_widget_set_sensitive(_menu.zoom_out, factor > 1);
  77. }
  78.  
  79. void
  80. menu_shapes_selected(gint count)
  81. {
  82.    gint sensitive = (count > 0);
  83.    gtk_widget_set_sensitive(_menu.cut, sensitive);
  84.    gtk_widget_set_sensitive(_menu.copy, sensitive);
  85.    gtk_widget_set_sensitive(_menu.clear, sensitive);
  86.    gtk_widget_set_sensitive(_menu.edit, sensitive);
  87. }
  88.  
  89. static void
  90. menu_zoom_to(gint factor)
  91. {
  92.    if (_menu_callback_lock) {
  93.       _menu_callback_lock--;
  94.    } else {
  95.       set_zoom(factor);
  96.    }
  97.    menu_set_zoom_sensitivity(factor);
  98. }
  99.  
  100. static void
  101. menu_zoom_to_1(GtkWidget *widget, gpointer data)
  102. {
  103.    menu_zoom_to(1);
  104. }
  105.  
  106. static void
  107. menu_zoom_to_2(GtkWidget *widget, gpointer data)
  108. {
  109.    menu_zoom_to(2);
  110. }
  111.  
  112. static void
  113. menu_zoom_to_3(GtkWidget *widget, gpointer data)
  114. {
  115.    menu_zoom_to(3);
  116. }
  117.  
  118. static void
  119. menu_zoom_to_4(GtkWidget *widget, gpointer data)
  120. {
  121.    menu_zoom_to(4);
  122. }
  123.  
  124. static void
  125. menu_zoom_to_5(GtkWidget *widget, gpointer data)
  126. {
  127.    menu_zoom_to(5);
  128. }
  129.  
  130. static void
  131. menu_zoom_to_6(GtkWidget *widget, gpointer data)
  132. {
  133.    menu_zoom_to(6);
  134. }
  135.  
  136. static void
  137. menu_zoom_to_7(GtkWidget *widget, gpointer data)
  138. {
  139.    menu_zoom_to(7);
  140. }
  141.  
  142. static void
  143. menu_zoom_to_8(GtkWidget *widget, gpointer data)
  144. {
  145.    menu_zoom_to(8);
  146. }
  147.  
  148. static void
  149. menu_rectangle(GtkWidget *widget, gpointer data)
  150. {
  151.    if (_menu_callback_lock) {
  152.       _menu_callback_lock = FALSE;
  153.    } else {
  154.       set_rectangle_func();
  155.       tools_select_rectangle();
  156.       popup_select_rectangle();
  157.    }
  158. }
  159.  
  160. static void
  161. menu_circle(GtkWidget *widget, gpointer data)
  162. {
  163.    if (_menu_callback_lock) {
  164.       _menu_callback_lock = FALSE;
  165.    } else {
  166.       set_circle_func();
  167.       tools_select_circle();
  168.       popup_select_circle();
  169.    }
  170. }
  171.  
  172. static void
  173. menu_polygon(GtkWidget *widget, gpointer data)
  174. {
  175.    if (_menu_callback_lock) {
  176.       _menu_callback_lock = FALSE;
  177.    } else {
  178.       set_polygon_func();
  179.       tools_select_polygon();
  180.       popup_select_polygon();
  181.    }
  182. }
  183.  
  184. static void
  185. menu_arrow(GtkWidget *widget, gpointer data)
  186. {
  187.    if (_menu_callback_lock) {
  188.       _menu_callback_lock = FALSE;
  189.    } else {
  190.       set_arrow_func();
  191.       tools_select_arrow();
  192.       popup_select_arrow();
  193.    }
  194. }
  195.  
  196. static void
  197. menu_grid(GtkWidget *widget, gpointer data)
  198. {
  199.    if (_menu_callback_lock) {
  200.       _menu_callback_lock = FALSE;
  201.    } else {
  202.       gint grid = toggle_grid();
  203.       popup_check_grid(grid);
  204.       main_toolbar_set_grid(grid);
  205.    }
  206. }
  207.  
  208. static void
  209. make_file_menu(GtkWidget *menu_bar)
  210. {
  211.    GtkWidget     *file_menu = make_menu_bar_item(menu_bar, _("File"));
  212.    GtkWidget    *item;
  213.  
  214.    _menu.file_menu = file_menu;
  215.    item = make_item_with_label(file_menu, _("Open..."), menu_command,
  216.                    &_menu.cmd_open);
  217.    add_accelerator(item, 'O', GDK_CONTROL_MASK);
  218.    item = make_item_with_label(file_menu, _("Save"), menu_command,
  219.                    &_menu.cmd_save);
  220.    add_accelerator(item, 'S', GDK_CONTROL_MASK);
  221.    make_item_with_label(file_menu, _("Save As..."), menu_command,
  222.             &_menu.cmd_save_as);
  223.    make_separator(file_menu);
  224.    make_item_with_label(file_menu, _("Preferences..."), menu_command,
  225.             &_menu.cmd_preferences);
  226.    make_separator(file_menu);
  227.    item = make_item_with_label(file_menu, _("Close"), menu_command,
  228.                    &_menu.cmd_close);
  229.    add_accelerator(item, 'W', GDK_CONTROL_MASK);
  230.    item = make_item_with_label(file_menu, _("Quit"), menu_command,
  231.                    &_menu.cmd_quit);
  232.    add_accelerator(item, 'Q', GDK_CONTROL_MASK);
  233. }
  234.  
  235. static void
  236. command_list_changed(Command_t *command, gpointer data)
  237. {
  238.    gchar *scratch;
  239.  
  240.    /* Set undo entry */
  241.    if (_menu.undo)
  242.       gtk_widget_destroy(_menu.undo);
  243.    scratch = g_strdup_printf (_("Undo %s"), (command) ? command->name : "");
  244.    _menu.undo = insert_item_with_label(_menu.edit_menu, 1, scratch,
  245.                        menu_command, &_menu.cmd_undo);
  246.    g_free (scratch);
  247.    add_accelerator(_menu.undo, 'Z', GDK_CONTROL_MASK);
  248.    gtk_widget_set_sensitive(_menu.undo, (command != NULL));
  249.  
  250.    /* Set redo entry */
  251.    command = command_list_get_redo_command();
  252.    if (_menu.redo)
  253.       gtk_widget_destroy(_menu.redo);
  254.    scratch = g_strdup_printf (_("Redo %s"), (command) ? command->name : "");
  255.    _menu.redo = insert_item_with_label(_menu.edit_menu, 2, scratch,
  256.                        menu_command, &_menu.cmd_redo);
  257.    g_free (scratch);
  258.    add_accelerator(_menu.redo, 'R', GDK_CONTROL_MASK);
  259.    gtk_widget_set_sensitive(_menu.redo, (command != NULL));
  260. }
  261.  
  262. static void
  263. paste_buffer_added(Object_t *obj, gpointer data)
  264. {
  265.    gtk_widget_set_sensitive((GtkWidget*) data, TRUE);
  266. }
  267.  
  268. static void
  269. paste_buffer_removed(Object_t *obj, gpointer data)
  270. {
  271.    gtk_widget_set_sensitive((GtkWidget*) data, FALSE);
  272. }
  273.  
  274. static void
  275. make_edit_menu(GtkWidget *menu_bar)
  276. {
  277.    GtkWidget *edit_menu = make_menu_bar_item(menu_bar, _("Edit"));
  278.    GtkWidget *item, *paste;
  279.  
  280.    _menu.edit_menu = edit_menu;
  281.    command_list_changed(NULL, NULL);
  282.  
  283.    make_separator(edit_menu);
  284.    _menu.cut = make_item_with_label(edit_menu, _("Cut"), menu_command,
  285.                     &_menu.cmd_cut);
  286.    add_accelerator(_menu.cut, 'X', GDK_CONTROL_MASK);
  287.    _menu.copy = make_item_with_label(edit_menu, _("Copy"), menu_command,
  288.                      &_menu.cmd_copy);
  289.    add_accelerator(_menu.copy, 'C', GDK_CONTROL_MASK);
  290.    paste = make_item_with_label(edit_menu, _("Paste"), menu_command,
  291.                 &_menu.cmd_paste);
  292.    add_accelerator(paste, 'V', GDK_CONTROL_MASK);
  293.    gtk_widget_set_sensitive(paste, FALSE);
  294.    item = make_item_with_label(edit_menu, _("Select All"), menu_command,
  295.                    &_menu.cmd_select_all);
  296.    add_accelerator(item, 'A', GDK_CONTROL_MASK);
  297.    make_separator(edit_menu);
  298.    _menu.clear = make_item_with_label(edit_menu, _("Clear"), menu_command,
  299.                       &_menu.cmd_clear);
  300.    add_accelerator(_menu.clear, 'K', GDK_CONTROL_MASK);
  301.    _menu.edit = make_item_with_label(edit_menu, _("Edit Area Info..."),
  302.                      menu_command, &_menu.cmd_edit_area_info);
  303.  
  304.    paste_buffer_add_add_cb(paste_buffer_added, (gpointer) paste);
  305.    paste_buffer_add_remove_cb(paste_buffer_removed, (gpointer) paste);
  306.  
  307.    command_list_add_update_cb(command_list_changed, NULL);
  308. }
  309.  
  310. static void
  311. make_view_menu(GtkWidget *menu_bar)
  312. {
  313.    GtkWidget *view_menu = make_menu_bar_item(menu_bar, _("View"));
  314.    GtkWidget *zoom_menu, *item;
  315.    GSList *group = NULL;
  316.  
  317.    item = make_check_item(view_menu, _("Area List"), menu_command,
  318.               &_menu.cmd_area_list);
  319.    GTK_CHECK_MENU_ITEM(item)->active = TRUE;
  320.  
  321.    make_item_with_label(view_menu, _("Source..."), menu_command,
  322.             &_menu.cmd_source);
  323.    make_separator(view_menu);
  324.  
  325.    _menu.color = make_radio_item(view_menu, NULL, _("Color"), menu_command,
  326.                  &_menu.cmd_color);
  327.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.color));
  328.  
  329.    _menu.gray = make_radio_item(view_menu, group, _("Grayscale"), menu_command,
  330.                 &_menu.cmd_gray);
  331.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.gray));
  332.  
  333.    if (!get_map_info()->color) { /* Gray image */
  334.       gtk_widget_set_sensitive(_menu.color, FALSE);
  335.       GTK_CHECK_MENU_ITEM(_menu.color)->active = FALSE;
  336.       GTK_CHECK_MENU_ITEM(_menu.gray)->active = TRUE;
  337.    }
  338.  
  339.    make_separator(view_menu);
  340.  
  341.    _menu.zoom_in = make_item_with_label(view_menu, _("Zoom In"), menu_command,
  342.                     &_menu.cmd_zoom_in);
  343.    add_accelerator(_menu.zoom_in, '=', 0);
  344.    _menu.zoom_out = make_item_with_label(view_menu, _("Zoom Out"), 
  345.                      menu_command, &_menu.cmd_zoom_out);
  346.    add_accelerator(_menu.zoom_out, '-', 0);
  347.    gtk_widget_set_sensitive(_menu.zoom_out, FALSE);
  348.  
  349.    zoom_menu = make_sub_menu(view_menu, _("Zoom To"));
  350.  
  351.    _menu.zoom[0] = make_radio_item(zoom_menu, NULL, "1:1", menu_zoom_to_1,
  352.                    NULL);
  353.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[0]));
  354.    _menu.zoom[1] = make_radio_item(zoom_menu, group, "1:2", menu_zoom_to_2,
  355.                    NULL);
  356.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[1]));
  357.    _menu.zoom[2] = make_radio_item(zoom_menu, group, "1:3", menu_zoom_to_3,
  358.                    NULL);
  359.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[2]));
  360.    _menu.zoom[3] = make_radio_item(zoom_menu, group, "1:4", menu_zoom_to_4,
  361.                    NULL);
  362.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[3]));
  363.    _menu.zoom[4] = make_radio_item(zoom_menu, group, "1:5", menu_zoom_to_5,
  364.                    NULL);
  365.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[4]));
  366.    _menu.zoom[5] = make_radio_item(zoom_menu, group, "1:6", menu_zoom_to_6,
  367.                    NULL);
  368.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[5]));
  369.    _menu.zoom[6] = make_radio_item(zoom_menu, group, "1:7", menu_zoom_to_7,
  370.                    NULL);
  371.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[6]));
  372.    _menu.zoom[7] = make_radio_item(zoom_menu, group, "1:8", menu_zoom_to_8,
  373.                    NULL);
  374. }
  375.  
  376. static void
  377. make_mapping_menu(GtkWidget *menu_bar)
  378. {
  379.    GtkWidget *menu = make_menu_bar_item(menu_bar, _("Mapping"));
  380.    GSList    *group;
  381.  
  382.    _menu.arrow = make_radio_item(menu, NULL, _("Arrow"), menu_arrow, NULL);
  383.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.arrow));
  384.    _menu.rectangle = make_radio_item(menu, group, _("Rectangle"),
  385.                      menu_rectangle, NULL);
  386.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.rectangle));
  387.    _menu.circle = make_radio_item(menu, group, _("Circle"), menu_circle, NULL);
  388.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.circle));
  389.    _menu.polygon = make_radio_item(menu, group, _("Polygon"), menu_polygon,
  390.                    NULL);
  391.    make_separator(menu);
  392.    make_item_with_label(menu, _("Edit Map Info..."), menu_command,
  393.             &_menu.cmd_edit_map_info);
  394. }
  395.  
  396. static void
  397. make_goodies_menu(GtkWidget *menu_bar)
  398. {
  399.    GtkWidget *goodies_menu = make_menu_bar_item(menu_bar, _("Goodies"));
  400.    _menu.grid = make_check_item(goodies_menu, _("Grid"), menu_grid, NULL);
  401.    make_item_with_label(goodies_menu, _("Grid Settings..."), menu_command,
  402.             &_menu.cmd_grid_settings);
  403.    make_item_with_label(goodies_menu, _("Create Guides..."), menu_command,
  404.             &_menu.cmd_create_guides);
  405. }
  406.  
  407. static void
  408. make_help_menu(GtkWidget *menu_bar)
  409. {
  410.    GtkWidget *help_menu = make_menu_bar_item(menu_bar, _("Help"));
  411.    gtk_menu_item_right_justify(GTK_MENU_ITEM(gtk_menu_get_attach_widget(
  412.       GTK_MENU(help_menu))));
  413.    make_item_with_label(help_menu, _("About ImageMap..."), menu_command,
  414.             &_menu.cmd_about);
  415. }
  416.  
  417. Menu_t*
  418. make_menu(GtkWidget *main_vbox, GtkWidget *window)
  419. {
  420.    GtkWidget *menu_bar = gtk_menu_bar_new();
  421.  
  422.    gtk_box_pack_start(GTK_BOX(main_vbox), menu_bar, FALSE, TRUE, 0);
  423.    gtk_widget_show(menu_bar);
  424.  
  425.    init_accel_group(window);
  426.  
  427.    make_file_menu(menu_bar);
  428.    make_edit_menu(menu_bar);
  429.    make_view_menu(menu_bar);
  430.    make_mapping_menu(menu_bar);
  431.    make_goodies_menu(menu_bar);
  432.    make_help_menu(menu_bar);
  433.  
  434.    menu_shapes_selected(0);
  435.  
  436.    return &_menu;
  437. }
  438.  
  439. void
  440. menu_build_mru_items(MRU_t *mru)
  441. {
  442.    GList *p;
  443.    gint position = 7;        /* Position of 'Close' entry */
  444.    int i;
  445.  
  446.    if (_menu.nr_off_mru_items) {
  447.       GList *children = gtk_container_children(GTK_CONTAINER(_menu.file_menu));
  448.       
  449.       p = g_list_nth(children, position);
  450.       for (i = 0; i < _menu.nr_off_mru_items; i++, p = p->next) {
  451.      gtk_widget_destroy((GtkWidget*) p->data);
  452.       }
  453.       g_list_free(children);
  454.    }
  455.  
  456.    i = 0;
  457.    for (p = mru->list; p; p = p->next, i++) {
  458.       GtkWidget *item = insert_item_with_label(_menu.file_menu, position++,
  459.                            (gchar*) p->data,
  460.                            menu_mru, p->data);
  461.       if (i < 9) {
  462.      guchar accelerator_key = '1' + i;
  463.      add_accelerator(item, accelerator_key, GDK_CONTROL_MASK);
  464.       }
  465.    }
  466.    insert_separator(_menu.file_menu, position);
  467.    _menu.nr_off_mru_items = i + 1;
  468. }
  469.  
  470. void
  471. menu_select_arrow(void)
  472. {
  473.    menu_select(_menu.arrow);
  474. }
  475.  
  476. void
  477. menu_select_rectangle(void)
  478. {
  479.    menu_select(_menu.rectangle);
  480. }
  481.  
  482. void
  483. menu_select_circle(void)
  484. {
  485.    menu_select(_menu.circle);
  486. }
  487.  
  488. void
  489. menu_select_polygon(void)
  490. {
  491.    menu_select(_menu.polygon);
  492. }
  493.  
  494. void
  495. menu_check_grid(gint check)
  496. {
  497.    _menu_callback_lock = TRUE;
  498.    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(_menu.grid), check);
  499. }
  500.  
  501. void
  502. menu_set_zoom(gint factor)
  503. {
  504.    _menu_callback_lock = 2;
  505.    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(_menu.zoom[factor - 1]),
  506.                   TRUE);
  507.    menu_set_zoom_sensitivity(factor);
  508. }
  509.