dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/menus.c

644 lines
23 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "appenv.h"
#include "colormaps.h"
#include "commands.h"
#include "fileops.h"
#include "general.h"
#include "gimprc.h"
#include "interface.h"
#include "menus.h"
#include "paint_funcs.h"
#include "procedural_db.h"
#include "scale.h"
#include "tools.h"
#include "gdisplay.h"
#include "docindex.h"
#include "config.h"
#include "libgimp/gimpintl.h"
#include "libgimp/gimpenv.h"
#define MRU_MENU_ENTRY_SIZE (strlen (_("/File/MRU00 ")) + 1)
#define MRU_MENU_ACCEL_SIZE sizeof ("<control>0")
static char* G_GNUC_UNUSED dummyMRU = N_("/File/MRU00 ");
static void menus_init (void);
static GtkItemFactoryEntry * translate_entries (const GtkItemFactoryEntry *, gint);
static void free_translated_entries(GtkItemFactoryEntry *, gint);
static GSList *last_opened_raw_filenames = NULL;
static const GtkItemFactoryEntry toolbox_entries[] =
{
{ N_("/File/New"), "<control>N", file_new_cmd_callback, 0 },
{ N_("/File/Open"), "<control>O", file_open_cmd_callback, 0 },
{ N_("/File/About..."), NULL, about_dialog_cmd_callback, 0 },
{ N_("/File/Preferences..."), NULL, file_pref_cmd_callback, 0 },
{ N_("/File/Tip of the day"), NULL, tips_dialog_cmd_callback, 0 },
{ N_("/File/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/File/Dialogs/Brushes..."), "<control><shift>B", dialogs_brushes_cmd_callback, 0 },
{ N_("/File/Dialogs/Patterns..."), "<control><shift>P", dialogs_patterns_cmd_callback, 0 },
{ N_("/File/Dialogs/Palette..."), "<control>P", dialogs_palette_cmd_callback, 0 },
{ N_("/File/Dialogs/Gradient..."), "<control>G", dialogs_gradient_editor_cmd_callback, 0 },
{ N_("/File/Dialogs/Layers & Channels..."), "<control>L", dialogs_lc_cmd_callback, 0 },
{ N_("/File/Dialogs/Tool Options..."), "<control><shift>T", dialogs_tools_options_cmd_callback, 0 },
{ N_("/File/Dialogs/Input Devices..."), NULL, dialogs_input_devices_cmd_callback, 0 },
{ N_("/File/Dialogs/Device Status..."), NULL, dialogs_device_status_cmd_callback, 0 },
{ N_("/File/Dialogs/Document Index..."), NULL, raise_idea_callback, 0 },
{ N_("/File/Dialogs/Error Console..."), NULL, dialogs_error_console_cmd_callback, 0 },
{ N_("/File/Dialogs/Module Browser..."), NULL, dialogs_module_browser_cmd_callback, 0 },
{ N_("/File/---"), NULL, NULL, 0, "<Separator>" }
};
static guint n_toolbox_entries = sizeof (toolbox_entries) / sizeof (toolbox_entries[0]);
static GtkItemFactory *toolbox_factory = NULL;
static const GtkItemFactoryEntry file_menu_separator = { N_("/File/---"), NULL, NULL, 0, "<Separator>" };
static const GtkItemFactoryEntry toolbox_end = { N_("/File/Quit"), "<control>Q", file_quit_cmd_callback, 0 };
static const GtkItemFactoryEntry image_entries[] =
{
{ N_("/File/New"), "<control>N", file_new_cmd_callback, 1 },
{ N_("/File/Open"), "<control>O", file_open_cmd_callback, 0 },
{ N_("/File/Save"), "<control>S", file_save_cmd_callback, 0 },
{ N_("/File/Save as"), NULL, file_save_as_cmd_callback, 0 },
{ N_("/File/Revert"), NULL, file_revert_cmd_callback, 0 },
{ N_("/File/Preferences..."), NULL, file_pref_cmd_callback, 0 },
{ N_("/File/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/File/Close"), "<control>W", file_close_cmd_callback, 0 },
{ N_("/File/Quit"), "<control>Q", file_quit_cmd_callback, 0 },
{ N_("/File/---moved"), NULL, NULL, 0, "<Separator>" },
{ N_("/Edit/Cut"), "<control>X", edit_cut_cmd_callback, 0 },
{ N_("/Edit/Copy"), "<control>C", edit_copy_cmd_callback, 0 },
{ N_("/Edit/Paste"), "<control>V", edit_paste_cmd_callback, 0 },
{ N_("/Edit/Paste Into"), NULL, edit_paste_into_cmd_callback, 0 },
{ N_("/Edit/Clear"), "<control>K", edit_clear_cmd_callback, 0 },
{ N_("/Edit/Fill"), "<control>period", edit_fill_cmd_callback, 0 },
{ N_("/Edit/Stroke"), NULL, edit_stroke_cmd_callback, 0 },
{ N_("/Edit/Undo"), "<control>Z", edit_undo_cmd_callback, 0 },
{ N_("/Edit/Redo"), "<control>R", edit_redo_cmd_callback, 0 },
{ N_("/Edit/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/Edit/Cut Named"), "<control><shift>X", edit_named_cut_cmd_callback, 0 },
{ N_("/Edit/Copy Named"), "<control><shift>C", edit_named_copy_cmd_callback, 0 },
{ N_("/Edit/Paste Named"), "<control><shift>V", edit_named_paste_cmd_callback, 0 },
{ N_("/Edit/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/Select/Toggle"), "<control>T", select_toggle_cmd_callback, 0 },
{ N_("/Select/Invert"), "<control>I", select_invert_cmd_callback, 0 },
{ N_("/Select/All"), "<control>A", select_all_cmd_callback, 0 },
{ N_("/Select/None"), "<control><shift>A", select_none_cmd_callback, 0 },
{ N_("/Select/Float"), "<control><shift>L", select_float_cmd_callback, 0 },
{ N_("/Select/Sharpen"), "<control><shift>H", select_sharpen_cmd_callback, 0 },
{ N_("/Select/Border"), "<control><shift>B", select_border_cmd_callback, 0 },
{ N_("/Select/Feather"), "<control><shift>F", select_feather_cmd_callback, 0 },
{ N_("/Select/Grow"), NULL, select_grow_cmd_callback, 0 },
{ N_("/Select/Shrink"), NULL, select_shrink_cmd_callback, 0 },
{ N_("/Select/Save To Channel"), NULL, select_save_cmd_callback, 0 },
{ N_("/View/Zoom In"), "equal", view_zoomin_cmd_callback, 0 },
{ N_("/View/Zoom Out"), "minus", view_zoomout_cmd_callback, 0 },
{ N_("/View/Zoom/16:1"), NULL, view_zoom_16_1_callback, 0 },
{ N_("/View/Zoom/8:1"), NULL, view_zoom_8_1_callback, 0 },
{ N_("/View/Zoom/4:1"), NULL, view_zoom_4_1_callback, 0 },
{ N_("/View/Zoom/2:1"), NULL, view_zoom_2_1_callback, 0 },
{ N_("/View/Zoom/1:1"), "1", view_zoom_1_1_callback, 0 },
{ N_("/View/Zoom/1:2"), NULL, view_zoom_1_2_callback, 0 },
{ N_("/View/Zoom/1:4"), NULL, view_zoom_1_4_callback, 0 },
{ N_("/View/Zoom/1:8"), NULL, view_zoom_1_8_callback, 0 },
{ N_("/View/Zoom/1:16"), NULL, view_zoom_1_16_callback, 0 },
{ N_("/View/Dot for dot"), NULL, view_dot_for_dot_callback, 0, "<ToggleItem>"},
{ N_("/View/Window Info..."), "<control><shift>I", view_window_info_cmd_callback, 0 },
{ N_("/View/Toggle Rulers"), "<control><shift>R", view_toggle_rulers_cmd_callback, 0, "<ToggleItem>" },
{ N_("/View/Toggle Statusbar"), "<control><shift>S", view_toggle_statusbar_cmd_callback, 0, "<ToggleItem>" },
{ N_("/View/Toggle Guides"), "<control><shift>T", view_toggle_guides_cmd_callback, 0, "<ToggleItem>" },
{ N_("/View/Snap To Guides"), NULL, view_snap_to_guides_cmd_callback, 0, "<ToggleItem>" },
{ N_("/View/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/View/New View"), NULL, view_new_view_cmd_callback, 0 },
{ N_("/View/Shrink Wrap"), "<control>E", view_shrink_wrap_cmd_callback, 0 },
{ N_("/Image/Colors/Equalize"), NULL, image_equalize_cmd_callback, 0 },
{ N_("/Image/Colors/Invert"), NULL, image_invert_cmd_callback, 0 },
{ N_("/Image/Colors/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/Image/Colors/Desaturate"), NULL, image_desaturate_cmd_callback, 0 },
{ N_("/Image/Channel Ops/Duplicate"), "<control>D", channel_ops_duplicate_cmd_callback, 0 },
{ N_("/Image/Channel Ops/Offset"), "<control><shift>O", channel_ops_offset_cmd_callback, 0 },
{ N_("/Image/Alpha/Add Alpha Channel"), NULL, layers_add_alpha_channel_cmd_callback, 0 },
{ N_("/Image/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/Image/RGB"), NULL, image_convert_rgb_cmd_callback, 0 },
{ N_("/Image/Grayscale"), NULL, image_convert_grayscale_cmd_callback, 0 },
{ N_("/Image/Indexed"), NULL, image_convert_indexed_cmd_callback, 0 },
{ N_("/Image/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/Image/Resize"), NULL, image_resize_cmd_callback, 0 },
{ N_("/Image/Scale"), NULL, image_scale_cmd_callback, 0 },
{ N_("/Image/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/Layers/Layers & Channels..."), "<control>L", dialogs_lc_cmd_callback, 0 },
{ N_("/Layers/Raise Layer"), "<control>F", layers_raise_cmd_callback, 0 },
{ N_("/Layers/Lower Layer"), "<control>B", layers_lower_cmd_callback, 0 },
{ N_("/Layers/Anchor Layer"), "<control>H", layers_anchor_cmd_callback, 0 },
{ N_("/Layers/Merge Visible Layers"), "<control>M", layers_merge_cmd_callback, 0 },
{ N_("/Layers/Flatten Image"), NULL, layers_flatten_cmd_callback, 0 },
{ N_("/Layers/Alpha To Selection"), NULL, layers_alpha_select_cmd_callback, 0 },
{ N_("/Layers/Mask To Selection"), NULL, layers_mask_select_cmd_callback, 0 },
{ N_("/Layers/Add Alpha Channel"), NULL, layers_add_alpha_channel_cmd_callback, 0 },
/* these are built on the fly */
/*
{ N_("/Tools/Ellipse Select"), "E", tools_select_cmd_callback, ELLIPSE_SELECT },
{ N_("/Tools/Free Select"), "F", tools_select_cmd_callback, FREE_SELECT },
{ N_("/Tools/Fuzzy Select"), "Z", tools_select_cmd_callback, FUZZY_SELECT },
{ N_("/Tools/Bezier Select"), "B", tools_select_cmd_callback, BEZIER_SELECT },
{ N_("/Tools/Intelligent Scissors"), "I", tools_select_cmd_callback, ISCISSORS },
{ N_("/Tools/Move"), "M", tools_select_cmd_callback, MOVE },
{ N_("/Tools/Magnify"), "<shift>M", tools_select_cmd_callback, MAGNIFY },
{ N_("/Tools/Crop"), "<shift>C", tools_select_cmd_callback, CROP },
{ N_("/Tools/Transform"), "<shift>T", tools_select_cmd_callback, ROTATE },
{ N_("/Tools/Flip"), "<shift>F", tools_select_cmd_callback, FLIP_HORZ },
{ N_("/Tools/Text"), "T", tools_select_cmd_callback, TEXT },
{ N_("/Tools/Color Picker"), "O", tools_select_cmd_callback, COLOR_PICKER },
{ N_("/Tools/Bucket Fill"), "<shift>B", tools_select_cmd_callback, BUCKET_FILL },
{ N_("/Tools/Blend"), "L", tools_select_cmd_callback, BLEND },
{ N_("/Tools/Paintbrush"), "P", tools_select_cmd_callback, PAINTBRUSH },
{ N_("/Tools/Pencil"), "<shift>P", tools_select_cmd_callback, PENCIL },
{ N_("/Tools/Eraser"), "<shift>E", tools_select_cmd_callback, ERASER },
{ N_("/Tools/Airbrush"), "A", tools_select_cmd_callback, AIRBRUSH },
{ N_("/Tools/Clone"), "C", tools_select_cmd_callback, CLONE },
{ N_("/Tools/Convolve"), "V", tools_select_cmd_callback, CONVOLVE },
{ N_("/Tools/Ink"), "K", tools_select_cmd_callback, INK },
{ N_("/Tools/Default Colors"), "D", tools_default_colors_cmd_callback, 0 },
{ N_("/Tools/Toolbox"), NULL, toolbox_raise_callback, 0 },
{ N_("/Tools/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/Tools/Default Colors"), "D", tools_default_colors_cmd_callback, 0 },
{ N_("/Tools/Swap Colors"), "X", tools_swap_colors_cmd_callback, 0 },
*/
{ N_("/Tools/Toolbox"), NULL, toolbox_raise_callback, 0 },
{ N_("/Tools/Default Colors"), "D", tools_default_colors_cmd_callback, 0 },
{ N_("/Tools/Swap Colors"), "X", tools_swap_colors_cmd_callback, 0 },
{ N_("/Tools/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/Filters/Repeat last"), "<alt>F", filters_repeat_cmd_callback, 0x0 },
{ N_("/Filters/Re-show last"), "<alt><shift>F", filters_repeat_cmd_callback, 0x1 },
{ N_("/Filters/---"), NULL, NULL, 0, "<Separator>" },
{ N_("/Script-Fu/"), NULL, NULL, 0 },
{ N_("/Dialogs/Brushes..."), "<control><shift>B", dialogs_brushes_cmd_callback, 0 },
{ N_("/Dialogs/Patterns..."), "<control><shift>P", dialogs_patterns_cmd_callback, 0 },
{ N_("/Dialogs/Palette..."), "<control>P", dialogs_palette_cmd_callback, 0 },
{ N_("/Dialogs/Gradient..."), "<control>G", dialogs_gradient_editor_cmd_callback, 0 },
{ N_("/Dialogs/Layers & Channels..."), "<control>L", dialogs_lc_cmd_callback, 0 },
{ N_("/Dialogs/Indexed Palette..."), NULL, dialogs_indexed_palette_cmd_callback, 0 },
{ N_("/Dialogs/Tool Options..."), NULL, dialogs_tools_options_cmd_callback, 0 },
{ N_("/Dialogs/Input Devices..."), NULL, dialogs_input_devices_cmd_callback, 0 },
{ N_("/Dialogs/Device Status..."), NULL, dialogs_device_status_cmd_callback, 0 },
};
static guint n_image_entries = sizeof (image_entries) / sizeof (image_entries[0]);
static GtkItemFactory *image_factory = NULL;
static const GtkItemFactoryEntry load_entries[] =
{
{ N_("/Automatic"), NULL, file_load_by_extension_callback, 0 },
{ "/---", NULL, NULL, 0, "<Separator>" },
};
static guint n_load_entries = sizeof (load_entries) / sizeof (load_entries[0]);
static GtkItemFactory *load_factory = NULL;
static const GtkItemFactoryEntry save_entries[] =
{
{ N_("/By extension"), NULL, file_save_by_extension_callback, 0 },
{ "/---", NULL, NULL, 0, "<Separator>" },
};
static guint n_save_entries = sizeof (save_entries) / sizeof (save_entries[0]);
static GtkItemFactory *save_factory = NULL;
static int initialize = TRUE;
extern int num_tools;
void
menus_get_toolbox_menubar (GtkWidget **menubar,
GtkAccelGroup **accel_group)
{
if (initialize)
menus_init ();
if (menubar)
*menubar = toolbox_factory->widget;
if (accel_group)
*accel_group = toolbox_factory->accel_group;
}
void
menus_get_image_menu (GtkWidget **menu,
GtkAccelGroup **accel_group)
{
if (initialize)
menus_init ();
if (menu)
*menu = image_factory->widget;
if (accel_group)
*accel_group = image_factory->accel_group;
}
void
menus_get_load_menu (GtkWidget **menu,
GtkAccelGroup **accel_group)
{
if (initialize)
menus_init ();
if (menu)
*menu = load_factory->widget;
if (accel_group)
*accel_group = load_factory->accel_group;
}
void
menus_get_save_menu (GtkWidget **menu,
GtkAccelGroup **accel_group)
{
if (initialize)
menus_init ();
if (menu)
*menu = save_factory->widget;
if (accel_group)
*accel_group = save_factory->accel_group;
}
void
menus_create (GtkMenuEntry *entries,
int nmenu_entries)
{
GtkItemFactory *ifactory;
GtkWidget *menu_item;
int i;
int redo_image_menu = FALSE;
if (initialize)
menus_init ();
gtk_item_factory_create_menu_entries (nmenu_entries, entries);
for (i = 0; i < nmenu_entries; i++)
if (!strncmp(entries[i].path, "<Image>", 7))
redo_image_menu = TRUE;
if (redo_image_menu)
{
ifactory = gtk_item_factory_from_path ("<Image>/File/Quit");
menu_item = gtk_item_factory_get_widget (ifactory, "<Image>/File/---moved");
if (menu_item && menu_item->parent)
gtk_menu_reorder_child (GTK_MENU (menu_item->parent), menu_item, -1);
menu_item = gtk_item_factory_get_widget (ifactory, "<Image>/File/Close");
if (menu_item && menu_item->parent)
gtk_menu_reorder_child (GTK_MENU (menu_item->parent), menu_item, -1);
menu_item = gtk_item_factory_get_widget (ifactory, "<Image>/File/Quit");
if (menu_item && menu_item->parent)
gtk_menu_reorder_child (GTK_MENU (menu_item->parent), menu_item, -1);
}
}
void
menus_tools_create (ToolInfo *tool_info)
{
GtkItemFactoryEntry entry;
entry.path = gettext(tool_info->menu_path);
entry.accelerator = tool_info->menu_accel;
entry.callback = tools_select_cmd_callback;
entry.callback_action = tool_info->tool_id;
entry.item_type = NULL;
gtk_item_factory_create_item (image_factory,
&entry,
(gpointer)tool_info,
2);
}
void
menus_set_sensitive (char *path,
int sensitive)
{
GtkItemFactory *ifactory;
GtkWidget *widget = NULL;
if (initialize)
menus_init ();
ifactory = gtk_item_factory_from_path (path);
if (ifactory)
{
widget = gtk_item_factory_get_widget (ifactory, path);
gtk_widget_set_sensitive (widget, sensitive);
}
if (!ifactory || !widget)
g_message (_("Unable to set sensitivity for menu which doesn't exist:\n%s"), path);
}
void
menus_set_state (char *path,
int state)
{
GtkItemFactory *ifactory;
GtkWidget *widget = NULL;
if (initialize)
menus_init ();
ifactory = gtk_item_factory_from_path (path);
if (ifactory)
{
widget = gtk_item_factory_get_widget (ifactory, path);
if (widget && GTK_IS_CHECK_MENU_ITEM (widget))
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (widget), state);
else
widget = NULL;
}
if (!ifactory || !widget)
g_message (_("Unable to set state for menu which doesn't exist:\n%s\n"), path);
}
void
menus_destroy (char *path)
{
if (initialize)
menus_init ();
gtk_item_factories_path_delete (NULL, path);
}
void
menus_quit ()
{
gchar *filename;
filename = gimp_personal_rc_file ("menurc");
gtk_item_factory_dump_rc (filename, NULL, TRUE);
g_free (filename);
if (!initialize)
{
gtk_object_unref (GTK_OBJECT (toolbox_factory));
gtk_object_unref (GTK_OBJECT (image_factory));
gtk_object_unref (GTK_OBJECT (load_factory));
gtk_object_unref (GTK_OBJECT (save_factory));
}
}
void
menus_last_opened_cmd_callback (GtkWidget *widget,
gpointer callback_data,
guint num)
{
gchar *filename, *raw_filename;
raw_filename = ((GString *) g_slist_nth_data (last_opened_raw_filenames, num))->str;
filename = g_basename (raw_filename);
if (!file_open(raw_filename, filename))
g_message (_("Error opening file: %s\n"), raw_filename);
}
void
menus_last_opened_update_labels ()
{
GSList *filename_slist;
GString *entry_filename, *path;
GtkWidget *widget;
gint i;
guint num_entries;
entry_filename = g_string_new ("");
path = g_string_new ("");
filename_slist = last_opened_raw_filenames;
num_entries = g_slist_length (last_opened_raw_filenames);
for (i = 1; i <= num_entries; i++)
{
g_string_sprintf (entry_filename, "%d. %s", i, g_basename (((GString *) filename_slist->data)->str));
g_string_sprintf (path, _("/File/MRU%02d"), i);
widget = gtk_item_factory_get_widget (toolbox_factory, path->str);
gtk_widget_show (widget);
gtk_label_set (GTK_LABEL (GTK_BIN (widget)->child), entry_filename->str);
filename_slist = filename_slist->next;
}
g_string_free (entry_filename, TRUE);
g_string_free (path, TRUE);
}
void
menus_last_opened_add (gchar *filename)
{
GString *raw_filename;
GtkWidget *widget;
guint num_entries;
num_entries = g_slist_length (last_opened_raw_filenames);
if (num_entries == last_opened_size)
{
g_slist_remove_link (last_opened_raw_filenames,
g_slist_last (last_opened_raw_filenames));
}
raw_filename = g_string_new (filename);
last_opened_raw_filenames = g_slist_prepend (last_opened_raw_filenames, raw_filename);
if (num_entries == 0)
{
widget = gtk_item_factory_get_widget (toolbox_factory, gettext(file_menu_separator.path));
gtk_widget_show (widget);
}
menus_last_opened_update_labels ();
}
void
menus_init_mru (void)
{
gchar *paths, *accelerators;
gint i;
GtkItemFactoryEntry *last_opened_entries;
GtkWidget *widget;
last_opened_entries = g_new (GtkItemFactoryEntry, last_opened_size);
paths = g_new (gchar, last_opened_size * MRU_MENU_ENTRY_SIZE);
accelerators = g_new (gchar, 9 * MRU_MENU_ACCEL_SIZE);
for (i = 0; i < last_opened_size; i++)
{
gchar *path, *accelerator;
path = &paths[i * MRU_MENU_ENTRY_SIZE];
if (i < 9)
accelerator = &accelerators[i * MRU_MENU_ACCEL_SIZE];
else
accelerator = NULL;
last_opened_entries[i].path = path;
last_opened_entries[i].accelerator = accelerator;
last_opened_entries[i].callback = (GtkItemFactoryCallback) menus_last_opened_cmd_callback;
last_opened_entries[i].callback_action = i;
last_opened_entries[i].item_type = NULL;
g_snprintf (path, MRU_MENU_ENTRY_SIZE, _("/File/MRU%02d"), i + 1);
if (accelerator != NULL)
g_snprintf (accelerator, MRU_MENU_ACCEL_SIZE, "<control>%d", i + 1);
}
gtk_item_factory_create_items_ac (toolbox_factory, last_opened_size,
last_opened_entries, NULL, 2);
for (i=0; i < last_opened_size; i++)
{
widget = gtk_item_factory_get_widget (toolbox_factory,
last_opened_entries[i].path);
gtk_widget_hide (widget);
}
widget = gtk_item_factory_get_widget (toolbox_factory, gettext(file_menu_separator.path));
gtk_widget_hide (widget);
g_free (paths);
g_free (accelerators);
g_free (last_opened_entries);
}
void
menus_init_toolbox ()
{
GtkItemFactoryEntry *translated_entries;
toolbox_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<Toolbox>", NULL);
translated_entries=translate_entries(toolbox_entries, n_toolbox_entries);
gtk_item_factory_create_items_ac (toolbox_factory, n_toolbox_entries,
translated_entries, NULL, 2);
free_translated_entries(translated_entries, n_toolbox_entries);
menus_init_mru ();
translated_entries=translate_entries(&file_menu_separator,1);
gtk_item_factory_create_item (toolbox_factory, translated_entries, NULL, 2);
free_translated_entries(translated_entries, 1);
translated_entries=translate_entries(&toolbox_end,1);
gtk_item_factory_create_item (toolbox_factory, translated_entries, NULL, 2);
free_translated_entries(translated_entries, 1);
}
static GtkItemFactoryEntry *
translate_entries (const GtkItemFactoryEntry *entries, gint n)
{
gint i;
GtkItemFactoryEntry *ret;
ret=g_malloc( sizeof(GtkItemFactoryEntry) * n );
for (i=0; i<n; i++) {
/* Translation. Note the explicit use of gettext(). */
ret[i].path=g_strdup( gettext(entries[i].path) );
/* accelerator and item_type are not duped, only referenced */
ret[i].accelerator=entries[i].accelerator;
ret[i].callback=entries[i].callback;
ret[i].callback_action=entries[i].callback_action;
ret[i].item_type=entries[i].item_type;
}
return ret;
}
static void
free_translated_entries(GtkItemFactoryEntry *entries, gint n)
{
gint i;
for (i=0; i<n; i++)
g_free(entries[i].path);
g_free(entries);
}
static void
menus_init ()
{
int i;
GtkItemFactoryEntry *translated_entries;
if (initialize)
{
gchar *filename;
initialize = FALSE;
menus_init_toolbox ();
image_factory = gtk_item_factory_new (GTK_TYPE_MENU, "<Image>", NULL);
translated_entries=translate_entries(image_entries, n_image_entries);
gtk_item_factory_create_items_ac (image_factory,
n_image_entries,
translated_entries,
NULL, 2);
free_translated_entries(translated_entries, n_image_entries);
load_factory = gtk_item_factory_new (GTK_TYPE_MENU, "<Load>", NULL);
translated_entries=translate_entries(load_entries, n_load_entries);
gtk_item_factory_create_items_ac (load_factory,
n_load_entries,
translated_entries,
NULL, 2);
free_translated_entries(translated_entries, n_load_entries);
save_factory = gtk_item_factory_new (GTK_TYPE_MENU, "<Save>", NULL);
translated_entries=translate_entries(load_entries, n_save_entries);
gtk_item_factory_create_items_ac (save_factory,
n_save_entries,
translated_entries,
NULL, 2);
free_translated_entries(translated_entries, n_save_entries);
for (i = 0; i < num_tools; i++)
{
/* FIXME this need to use access functions to check a flag */
if (tool_info[i].menu_path)
menus_tools_create (tool_info+i);
}
filename = gimp_personal_rc_file ("menurc");
gtk_item_factory_parse_rc (filename);
g_free (filename);
}
}
Reference in New Issue View Git Blame Copy Permalink