graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-20 19:43:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move away from creating all item_factories statically in menus_init() but

Browse source 
2003-01-10  Michael Natterer  <mitch@gimp.org>

	Move away from creating all item_factories statically in
	menus_init() but create a new one for each place where one is
	needed:

	* app/widgets/Makefile.am
	* app/widgets/widgets-types.h
	* app/widgets/gimpmenufactory.[ch]: new factory which creates and
	configures the GimpItemFactories it knows about on-the-fly.

	* app/widgets/gimpitemfactory.[ch]: added
	gimp_item_factory_update() which calls the "update_func". Added
	"gboolean update_on_popup" so item_factories can be configured to
	require manual updates (used for the <Image> factory).

	* app/gui/menus.[ch]: create a "global_menu_factory" and register
	all menus we have with it. Added various setup functions which
	do stuff like adding the "Open Recent" menu or reorder plug-in
	menu entries. Removed the debugging stuff...

	* app/gui/Makefile.am
	* app/gui/debug-commands.[ch]: ...and added it here.

	* app/gui/gui.c: create the <Toolbox>, the popup-<Image> and the
	<Paths> factories here because they are still global.

	* app/gui/plug-in-menus.[ch]: changed the "image_factory"
	parameters to "item_factory" and create/update the entries for the
	passed item_factory only. Makes the whole stuff much more
	straightforward.

	* app/plug-in/plug-ins.c: don't call plug_in_make_menu().

	* app/display/gimpdisplay.[ch]
	* app/display/gimpdisplayshell.[ch]: added "menu_factory" and
	"popup_factory" parameters to gimp_display_new() and
	gimp_display_shell_new(). Create the menubar_factory and the
	qmask_factory dynamically. Pass the shell, not a Gimp to the QMask
	callbacks. Changed gimp_display_shell_set_menu_sensitivity() to
	gimp_display_shell_menu_update() and don't call it directly (it's
	a GimpItemFactory update_func now). Call gimp_item_factory_update()
	on the resp. factories instead.

	* app/gui/qmask-commands.c
	* app/display/gimpdisplayshell-callbacks.c
	* app/tools/gimpimagemaptool.c: changed accordingly.

	* app/widgets/gimpbrusheditor.c
	* app/widgets/gimpbrushfactoryview.[ch]
	* app/widgets/gimpbufferview.[ch]
	* app/widgets/gimpcolormapeditor.[ch]
	* app/widgets/gimpcontainereditor.[ch]
	* app/widgets/gimpdataeditor.[ch]
	* app/widgets/gimpdatafactoryview.[ch]
	* app/widgets/gimpdialogfactory.[ch]
	* app/widgets/gimpdock.c
	* app/widgets/gimpdockbook.[ch]
	* app/widgets/gimpdocumentview.[ch]
	* app/widgets/gimpgradienteditor.[ch]
	* app/widgets/gimpimageview.[ch]
	* app/widgets/gimpitemlistview.[ch]
	* app/widgets/gimppaletteeditor.[ch]: pass around lots of
	GimpMenuFactory pointers and menu_identifiers so all views can
	create their item_factories themselves. Unref the factories when
	they are no longer needed because they belong to the views now.

	* app/gui/dialogs-commands.c
	* app/gui/dialogs-constructors.c
	* app/gui/dialogs.c
	* app/gui/brush-select.c
	* app/gui/gradient-select.c
	* app/gui/palette-select.c
	* app/gui/pattern-select.c: changed accordingly.

	* app/gui/file-dialog-utils.[ch] (file_dialog_new): require
	menu_factory and menu_identifier parameters.

	* app/gui/file-open-dialog.[ch]
	* app/gui/file-save-dialog.[ch]: removed file_*_dialog_menu_init()
	(they went to menus.c as setup_funcs). Added file_*_dialog_set_type()
	and moved the <Load> and <Save> factory callbacks to file-commands.c

	* app/gui/file-commands.[ch]: changed accordingly.

	* app/gui/view-commands.c: changed the statusbar, menubar, rulers
	and guides callbacks to do their job only if the setting has
	actually changed. Don't update whole item factories afterwards.
	Instead, just change the state of the items that actually need
	update.

	Unrelated:

	* app/core/gimpchannel.c (gimp_channel_init): set "bounds_known"
	and friends to FALSE since we don't know that the new channel will
	be empty (fixes QMask and probably other stuff).

	* app/gui/image-commands.c
	* app/gui/vectors-commands.c: cleanup.
This commit is contained in:
Michael Natterer 2003-01-10 17:55:53 +00:00 committed by Michael Natterer
parent 2a6d3edd4e
commit 8d86ec25e0
100 changed files with 2902 additions and 2060 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

100
ChangeLog
View file

@ -1,3 +1,103 @@
2003-01-10 Michael Natterer <mitch@gimp.org>
Move away from creating all item_factories statically in
menus_init() but create a new one for each place where one is
needed:
* app/widgets/Makefile.am
* app/widgets/widgets-types.h
* app/widgets/gimpmenufactory.[ch]: new factory which creates and
configures the GimpItemFactories it knows about on-the-fly.
* app/widgets/gimpitemfactory.[ch]: added
gimp_item_factory_update() which calls the "update_func". Added
"gboolean update_on_popup" so item_factories can be configured to
require manual updates (used for the <Image> factory).
* app/gui/menus.[ch]: create a "global_menu_factory" and register
all menus we have with it. Added various setup functions which
do stuff like adding the "Open Recent" menu or reorder plug-in
menu entries. Removed the debugging stuff...
* app/gui/Makefile.am
* app/gui/debug-commands.[ch]: ...and added it here.
* app/gui/gui.c: create the <Toolbox>, the popup-<Image> and the
<Paths> factories here because they are still global.
* app/gui/plug-in-menus.[ch]: changed the "image_factory"
parameters to "item_factory" and create/update the entries for the
passed item_factory only. Makes the whole stuff much more
straightforward.
* app/plug-in/plug-ins.c: don't call plug_in_make_menu().
* app/display/gimpdisplay.[ch]
* app/display/gimpdisplayshell.[ch]: added "menu_factory" and
"popup_factory" parameters to gimp_display_new() and
gimp_display_shell_new(). Create the menubar_factory and the
qmask_factory dynamically. Pass the shell, not a Gimp to the QMask
callbacks. Changed gimp_display_shell_set_menu_sensitivity() to
gimp_display_shell_menu_update() and don't call it directly (it's
a GimpItemFactory update_func now). Call gimp_item_factory_update()
on the resp. factories instead.
* app/gui/qmask-commands.c
* app/display/gimpdisplayshell-callbacks.c
* app/tools/gimpimagemaptool.c: changed accordingly.
* app/widgets/gimpbrusheditor.c
* app/widgets/gimpbrushfactoryview.[ch]
* app/widgets/gimpbufferview.[ch]
* app/widgets/gimpcolormapeditor.[ch]
* app/widgets/gimpcontainereditor.[ch]
* app/widgets/gimpdataeditor.[ch]
* app/widgets/gimpdatafactoryview.[ch]
* app/widgets/gimpdialogfactory.[ch]
* app/widgets/gimpdock.c
* app/widgets/gimpdockbook.[ch]
* app/widgets/gimpdocumentview.[ch]
* app/widgets/gimpgradienteditor.[ch]
* app/widgets/gimpimageview.[ch]
* app/widgets/gimpitemlistview.[ch]
* app/widgets/gimppaletteeditor.[ch]: pass around lots of
GimpMenuFactory pointers and menu_identifiers so all views can
create their item_factories themselves. Unref the factories when
they are no longer needed because they belong to the views now.
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.c
* app/gui/dialogs.c
* app/gui/brush-select.c
* app/gui/gradient-select.c
* app/gui/palette-select.c
* app/gui/pattern-select.c: changed accordingly.
* app/gui/file-dialog-utils.[ch] (file_dialog_new): require
menu_factory and menu_identifier parameters.
* app/gui/file-open-dialog.[ch]
* app/gui/file-save-dialog.[ch]: removed file_*_dialog_menu_init()
(they went to menus.c as setup_funcs). Added file_*_dialog_set_type()
and moved the <Load> and <Save> factory callbacks to file-commands.c
* app/gui/file-commands.[ch]: changed accordingly.
* app/gui/view-commands.c: changed the statusbar, menubar, rulers
and guides callbacks to do their job only if the setting has
actually changed. Don't update whole item factories afterwards.
Instead, just change the state of the items that actually need
update.
Unrelated:
* app/core/gimpchannel.c (gimp_channel_init): set "bounds_known"
and friends to FALSE since we don't know that the new channel will
be empty (fixes QMask and probably other stuff).
* app/gui/image-commands.c
* app/gui/vectors-commands.c: cleanup.
2003-01-10 Sven Neumann <sven@gimp.org>
* libgimpwidgets/gimpstock.c (gimp_stock_init): fixed my last commit.

188
app/actions/debug-commands.c Normal file
View file

@ -0,0 +1,188 @@
/* 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 "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include "libgimpbase/gimpbase.h"
#include "gui-types.h"
#include "core/gimpobject.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "debug-commands.h"
#include "menus.h"
#ifdef ENABLE_DEBUG_ENTRIES
/* local function prototypes */
static void debug_dump_menus_recurse_menu (GtkWidget *menu,
gint depth,
gchar *path);
/* public functions */
void
debug_dump_menus_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GList *list;
for (list = global_menu_factory->registered_menus;
list;
list = g_list_next (list))
{
GimpMenuFactoryEntry *entry;
GimpItemFactory *item_factory;
entry = list->data;
item_factory = gimp_item_factory_from_path (entry->identifier);
if (item_factory)
{
GtkWidget *menu_item;
g_print ("%s\n", entry->identifier);
menu_item = gtk_item_factory_get_item (GTK_ITEM_FACTORY (item_factory),
entry->entries[0].entry.path);
if (menu_item &&
menu_item->parent &&
GTK_IS_MENU (menu_item->parent))
debug_dump_menus_recurse_menu (menu_item->parent, 1,
entry->identifier);
g_print ("\n");
}
}
}
void
debug_mem_profile_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
extern gboolean gimp_debug_memsize;
gimp_debug_memsize = TRUE;
gimp_object_get_memsize (GIMP_OBJECT (data));
gimp_debug_memsize = FALSE;
}
/* private functions */
static void
debug_dump_menus_recurse_menu (GtkWidget *menu,
gint depth,
gchar *path)
{
GtkItemFactory *item_factory;
GtkWidget *menu_item;
GList *list;
const gchar *label;
gchar *help_page;
gchar *help_path;
gchar *factory_path;
gchar *hash;
gchar *full_path;
gchar *format_str;
for (list = GTK_MENU_SHELL (menu)->children; list; list = g_list_next (list))
{
menu_item = GTK_WIDGET (list->data);
if (GTK_IS_LABEL (GTK_BIN (menu_item)->child))
{
label = gtk_label_get_text (GTK_LABEL (GTK_BIN (menu_item)->child));
full_path = g_strconcat (path, "/", label, NULL);
item_factory = GTK_ITEM_FACTORY (gimp_item_factory_from_path (path));
help_page = g_object_get_data (G_OBJECT (menu_item), "help_page");
if (item_factory)
{
factory_path = g_object_get_data (G_OBJECT (item_factory),
"factory_path");
if (factory_path)
{
help_page = g_build_filename (factory_path, help_page, NULL);
}
else
{
help_page = g_strdup (help_page);
}
}
else
{
help_page = g_strdup (help_page);
}
if (help_page)
{
help_path = g_build_filename (gimp_data_directory (),
"help", "C", help_page, NULL);
if ((hash = strchr (help_path, '#')) != NULL)
*hash = '\0';
if (g_file_test (help_path, G_FILE_TEST_EXISTS))
{
g_free (help_path);
help_path = g_strconcat ("! ", help_page, NULL);
g_free (help_page);
help_page = help_path;
}
else
{
g_free (help_path);
}
}
format_str = g_strdup_printf ("%%%ds%%%ds %%-20s %%s\n",
depth * 2, depth * 2 - 40);
g_print (format_str,
"", label, "", help_page ? help_page : "");
g_free (format_str);
g_free (help_page);
if (GTK_MENU_ITEM (menu_item)->submenu)
debug_dump_menus_recurse_menu (GTK_MENU_ITEM (menu_item)->submenu,
depth + 1, full_path);
g_free (full_path);
}
}
}
#endif /* ENABLE_DEBUG_ENTRIES */

36
app/actions/debug-commands.h Normal file
View file

@ -0,0 +1,36 @@
/* 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.
*/
#ifndef __DEBUG_COMMANDS_H__
#define __DEBUG_COMMANDS_H__
#define ENABLE_DEBUG_ENTRIES 1
#ifdef ENABLE_DEBUG_ENTRIES
void debug_dump_menus_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void debug_mem_profile_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
#endif /* ENABLE_DEBUG_ENTRIES */
#endif /* __DEBUG_COMMANDS_H__ */

6
app/actions/dialogs-commands.c
View file

@ -24,6 +24,8 @@
#include "gui-types.h"
#include "core/gimpcontext.h"
#include "widgets/gimpcontainerview.h"
#include "widgets/gimpcontainerview-utils.h"
#include "widgets/gimpdialogfactory.h"
@ -314,7 +316,7 @@ dialogs_create_lc_cmd_callback (GtkWidget *widget,
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dock), TRUE);
dockbook = gimp_dockbook_new ();
dockbook = gimp_dockbook_new (global_dock_factory->menu_factory);
gimp_dock_add_book (GIMP_DOCK (dock), GIMP_DOCKBOOK (dockbook), 0);
@ -353,7 +355,7 @@ dialogs_create_stuff_cmd_callback (GtkWidget *widget,
dock = gimp_dialog_factory_dock_new (global_dock_factory);
dockbook = gimp_dockbook_new ();
dockbook = gimp_dockbook_new (global_dock_factory->menu_factory);
gimp_dock_add_book (GIMP_DOCK (dock), GIMP_DOCKBOOK (dockbook), 0);

33
app/actions/file-commands.c
View file

@ -44,6 +44,7 @@
#include "file-new-dialog.h"
#include "file-open-dialog.h"
#include "file-save-dialog.h"
#include "menus.h"
#include "undo.h"
@ -107,7 +108,15 @@ file_open_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
file_open_dialog_menu_reset ();
file_open_dialog_set_type (NULL);
}
void
file_open_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
file_open_dialog_set_type ((PlugInProcDef *) data);
}
void
@ -125,7 +134,7 @@ file_open_cmd_callback (GtkWidget *widget,
else
gimage = NULL;
file_open_dialog_show (gimp, gimage, NULL);
file_open_dialog_show (gimp, gimage, NULL, global_menu_factory);
}
void
@ -160,7 +169,15 @@ file_save_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
file_save_dialog_menu_reset ();
file_save_dialog_set_type (NULL);
}
void
file_save_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
file_save_dialog_set_type ((PlugInProcDef *) data);
}
void
@ -215,7 +232,7 @@ file_save_as_cmd_callback (GtkWidget *widget,
GimpDisplay *gdisp;
return_if_no_display (gdisp, data);
file_save_dialog_show (gdisp->gimage);
file_save_dialog_show (gdisp->gimage, global_menu_factory);
}
void
@ -226,7 +243,7 @@ file_save_a_copy_cmd_callback (GtkWidget *widget,
GimpDisplay *gdisp;
return_if_no_display (gdisp, data);
file_save_a_copy_dialog_show (gdisp->gimage);
file_save_a_copy_dialog_show (gdisp->gimage, global_menu_factory);
}
void
@ -309,6 +326,12 @@ file_quit_cmd_callback (GtkWidget *widget,
gimp_exit (gimp, FALSE);
}
void
file_file_open_dialog (Gimp *gimp,
const gchar *uri)
{
file_open_dialog_show (gimp, NULL, uri, global_menu_factory);
}
/* private functions */

81
app/actions/file-commands.h
View file

@ -20,45 +20,54 @@
#define __FILE_COMMANDS_H__
void file_new_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_new_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_last_opened_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_last_opened_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_as_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_a_copy_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_as_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_a_copy_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_revert_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_pref_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_close_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_quit_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_revert_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_pref_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_close_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_quit_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_file_open_dialog (Gimp *gimp,
const gchar *uri);
#endif /* __FILE_COMMANDS_H__ */

2
app/actions/image-commands.c
View file

@ -254,6 +254,8 @@ image_flatten_image_cmd_callback (GtkWidget *widget,
gimp_image_flatten (gimage);
gimp_image_flush (gimage);
}
/****************************/
/* The layer merge dialog */
/****************************/

48
app/actions/qmask-commands.c
View file

@ -33,7 +33,6 @@
#include "widgets/gimpcolorpanel.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpviewabledialog.h"
#include "widgets/gimpwidgets-utils.h"
#include "display/gimpdisplay.h"
#include "display/gimpdisplayshell.h"
@ -57,13 +56,13 @@ struct _EditQmaskOptions
/* local function prototypes */
static void qmask_channel_query (GimpDisplayShell *shell);
static void qmask_query_ok_callback (GtkWidget *widget,
gpointer client_data);
static void qmask_query_scale_update (GtkAdjustment *adjustment,
gpointer data);
static void qmask_query_color_changed (GimpColorButton *button,
gpointer data);
static void qmask_channel_query (GimpDisplayShell *shell);
static void qmask_query_ok_callback (GtkWidget *widget,
gpointer client_data);
static void qmask_query_scale_update (GtkAdjustment *adjustment,
gpointer data);
static void qmask_query_color_changed (GimpColorButton *button,
gpointer data);
/* public functionss */
@ -75,15 +74,15 @@ qmask_toggle_cmd_callback (GtkWidget *widget,
{
GimpDisplayShell *shell;
shell = (GimpDisplayShell *) gimp_widget_get_callback_context (widget);
shell = GIMP_DISPLAY_SHELL (data);
if (! shell)
return;
if (GTK_CHECK_MENU_ITEM (widget)->active != shell->gdisp->gimage->qmask_state)
{
gimp_image_set_qmask_state (shell->gdisp->gimage,
GTK_CHECK_MENU_ITEM (widget)->active);
gimp_image_set_qmask_state (shell->gdisp->gimage,
GTK_CHECK_MENU_ITEM (widget)->active);
gimp_image_flush (shell->gdisp->gimage);
gimp_image_flush (shell->gdisp->gimage);
}
}
void
@ -93,17 +92,17 @@ qmask_invert_cmd_callback (GtkWidget *widget,
{
GimpDisplayShell *shell;
shell = (GimpDisplayShell *) gimp_widget_get_callback_context (widget);
if (! shell)
return;
shell = GIMP_DISPLAY_SHELL (data);
if (GTK_CHECK_MENU_ITEM (widget)->active)
{
gimp_image_qmask_invert (shell->gdisp->gimage);
if (action != shell->gdisp->gimage->qmask_inverted)
{
gimp_image_qmask_invert (shell->gdisp->gimage);
if (shell->gdisp->gimage->qmask_state)
gimp_image_flush (shell->gdisp->gimage);
if (shell->gdisp->gimage->qmask_state)
gimp_image_flush (shell->gdisp->gimage);
}
}
}
@ -114,10 +113,7 @@ qmask_configure_cmd_callback (GtkWidget *widget,
{
GimpDisplayShell *shell;
shell = (GimpDisplayShell *) gimp_widget_get_callback_context (widget);
if (! shell)
return;
shell = GIMP_DISPLAY_SHELL (data);
qmask_channel_query (shell);
}

48
app/actions/quick-mask-commands.c
View file

@ -33,7 +33,6 @@
#include "widgets/gimpcolorpanel.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpviewabledialog.h"
#include "widgets/gimpwidgets-utils.h"
#include "display/gimpdisplay.h"
#include "display/gimpdisplayshell.h"
@ -57,13 +56,13 @@ struct _EditQmaskOptions
/* local function prototypes */
static void qmask_channel_query (GimpDisplayShell *shell);
static void qmask_query_ok_callback (GtkWidget *widget,
gpointer client_data);
static void qmask_query_scale_update (GtkAdjustment *adjustment,
gpointer data);
static void qmask_query_color_changed (GimpColorButton *button,
gpointer data);
static void qmask_channel_query (GimpDisplayShell *shell);
static void qmask_query_ok_callback (GtkWidget *widget,
gpointer client_data);
static void qmask_query_scale_update (GtkAdjustment *adjustment,
gpointer data);
static void qmask_query_color_changed (GimpColorButton *button,
gpointer data);
/* public functionss */
@ -75,15 +74,15 @@ qmask_toggle_cmd_callback (GtkWidget *widget,
{
GimpDisplayShell *shell;
shell = (GimpDisplayShell *) gimp_widget_get_callback_context (widget);
shell = GIMP_DISPLAY_SHELL (data);
if (! shell)
return;
if (GTK_CHECK_MENU_ITEM (widget)->active != shell->gdisp->gimage->qmask_state)
{
gimp_image_set_qmask_state (shell->gdisp->gimage,
GTK_CHECK_MENU_ITEM (widget)->active);
gimp_image_set_qmask_state (shell->gdisp->gimage,
GTK_CHECK_MENU_ITEM (widget)->active);
gimp_image_flush (shell->gdisp->gimage);
gimp_image_flush (shell->gdisp->gimage);
}
}
void
@ -93,17 +92,17 @@ qmask_invert_cmd_callback (GtkWidget *widget,
{
GimpDisplayShell *shell;
shell = (GimpDisplayShell *) gimp_widget_get_callback_context (widget);
if (! shell)
return;
shell = GIMP_DISPLAY_SHELL (data);
if (GTK_CHECK_MENU_ITEM (widget)->active)
{
gimp_image_qmask_invert (shell->gdisp->gimage);
if (action != shell->gdisp->gimage->qmask_inverted)
{
gimp_image_qmask_invert (shell->gdisp->gimage);
if (shell->gdisp->gimage->qmask_state)
gimp_image_flush (shell->gdisp->gimage);
if (shell->gdisp->gimage->qmask_state)
gimp_image_flush (shell->gdisp->gimage);
}
}
}
@ -114,10 +113,7 @@ qmask_configure_cmd_callback (GtkWidget *widget,
{
GimpDisplayShell *shell;
shell = (GimpDisplayShell *) gimp_widget_get_callback_context (widget);
if (! shell)
return;
shell = GIMP_DISPLAY_SHELL (data);
qmask_channel_query (shell);
}

8
app/actions/vectors-commands.c
View file

@ -441,14 +441,12 @@ vectors_new_vectors_query (GimpImage *gimage,
{
GimpVectors *new_vectors;
/* undo_push_group_start (gimage, EDIT_PASTE_UNDO_GROUP); */
new_vectors = NULL; /*gimp_vectors_new (gimage, _("Empty Vectors Copy"));*/
new_vectors = g_object_new (GIMP_TYPE_VECTORS, NULL);
gimp_image_add_vectors (gimage, new_vectors, -1);
/* undo_push_group_end (gimage); */
gimp_object_set_name (GIMP_OBJECT (new_vectors),
_("Empty Vectors Copy"));
return;
}

147
app/actions/view-commands.c
View file

@ -37,6 +37,7 @@
#include "display/gimpdisplayshell-selection.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpitemfactory.h"
#include "dialogs.h"
#include "info-dialog.h"
@ -100,11 +101,24 @@ void
view_dot_for_dot_cmd_callback (GtkWidget *widget,
gpointer data)
{
GimpDisplay *gdisp;
GimpDisplay *gdisp;
GimpDisplayShell *shell;
return_if_no_display (gdisp, data);
gimp_display_shell_scale_set_dot_for_dot (GIMP_DISPLAY_SHELL (gdisp->shell),
GTK_CHECK_MENU_ITEM (widget)->active);
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
if (shell->dot_for_dot != GTK_CHECK_MENU_ITEM (widget)->active)
{
gimp_display_shell_scale_set_dot_for_dot (shell,
GTK_CHECK_MENU_ITEM (widget)->active);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Dot for Dot",
shell->dot_for_dot);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Dot for Dot",
shell->dot_for_dot);
}
}
void
@ -164,19 +178,22 @@ view_toggle_selection_cmd_callback (GtkWidget *widget,
{
GimpDisplay *gdisp;
GimpDisplayShell *shell;
gint new_val;
return_if_no_display (gdisp, data);
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
new_val = GTK_CHECK_MENU_ITEM (widget)->active;
/* hidden == TRUE corresponds to the menu toggle being FALSE */
if (new_val == shell->select->hidden)
if (GTK_CHECK_MENU_ITEM (widget)->active == shell->select->hidden)
{
gimp_display_shell_selection_toggle (shell->select);
gimp_display_shell_flush (shell);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Selection",
! shell->select->hidden);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Selection",
! shell->select->hidden);
}
}
@ -186,19 +203,22 @@ view_toggle_layer_boundary_cmd_callback (GtkWidget *widget,
{
GimpDisplay *gdisp;
GimpDisplayShell *shell;
gint new_val;
return_if_no_display (gdisp, data);
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
new_val = GTK_CHECK_MENU_ITEM (widget)->active;
/* hidden == TRUE corresponds to the menu toggle being FALSE */
if (new_val == shell->select->layer_hidden)
if (GTK_CHECK_MENU_ITEM (widget)->active == shell->select->layer_hidden)
{
gimp_display_shell_selection_toggle_layer (shell->select);
gimp_display_shell_flush (shell);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Layer Boundary",
! shell->select->layer_hidden);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Layer Boundary",
! shell->select->layer_hidden);
}
}
@ -215,18 +235,21 @@ view_toggle_menubar_cmd_callback (GtkWidget *widget,
menubar = GTK_ITEM_FACTORY (shell->menubar_factory)->widget;
if (! GTK_CHECK_MENU_ITEM (widget)->active)
if (GTK_CHECK_MENU_ITEM (widget)->active !=
GTK_WIDGET_VISIBLE (menubar))
{
if (GTK_WIDGET_VISIBLE (menubar))
gtk_widget_hide (menubar);
}
else
{
if (! GTK_WIDGET_VISIBLE (menubar))
else
gtk_widget_show (menubar);
}
gimp_display_shell_set_menu_sensitivity (shell, gdisp->gimage->gimp, FALSE);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Menubar",
GTK_WIDGET_VISIBLE (menubar));
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Menubar",
GTK_WIDGET_VISIBLE (menubar));
}
}
void
@ -242,30 +265,29 @@ view_toggle_rulers_cmd_callback (GtkWidget *widget,
config = GIMP_DISPLAY_CONFIG (gdisp->gimage->gimp->config);
if (! GTK_CHECK_MENU_ITEM (widget)->active)
if (GTK_CHECK_MENU_ITEM (widget)->active !=
GTK_WIDGET_VISIBLE (shell->origin))
{
if (GTK_WIDGET_VISIBLE (shell->origin))
{
gtk_widget_hide (shell->origin);
gtk_widget_hide (shell->hrule);
gtk_widget_hide (shell->vrule);
gtk_widget_queue_resize (GTK_WIDGET (shell->origin->parent));
}
}
else
{
if (! GTK_WIDGET_VISIBLE (shell->origin))
else
{
gtk_widget_show (shell->origin);
gtk_widget_show (shell->hrule);
gtk_widget_show (shell->vrule);
gtk_widget_queue_resize (GTK_WIDGET (shell->origin->parent));
}
}
gimp_display_shell_set_menu_sensitivity (shell, gdisp->gimage->gimp, FALSE);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Rulers",
GTK_WIDGET_VISIBLE (shell->origin));
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Rulers",
GTK_WIDGET_VISIBLE (shell->origin));
}
}
void
@ -278,18 +300,21 @@ view_toggle_statusbar_cmd_callback (GtkWidget *widget,
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
if (! GTK_CHECK_MENU_ITEM (widget)->active)
if (GTK_CHECK_MENU_ITEM (widget)->active !=
GTK_WIDGET_VISIBLE (shell->statusbar))
{
if (GTK_WIDGET_VISIBLE (shell->statusbar))
gtk_widget_hide (shell->statusbar);
}
else
{
if (! GTK_WIDGET_VISIBLE (shell->statusbar))
else
gtk_widget_show (shell->statusbar);
}
gimp_display_shell_set_menu_sensitivity (shell, gdisp->gimage->gimp, FALSE);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Statusbar",
GTK_WIDGET_VISIBLE (shell->statusbar));
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Statusbar",
GTK_WIDGET_VISIBLE (shell->statusbar));
}
}
void
@ -297,16 +322,30 @@ view_toggle_guides_cmd_callback (GtkWidget *widget,
gpointer data)
{
GimpDisplay *gdisp;
gboolean old_val;
return_if_no_display (gdisp, data);
old_val = gdisp->draw_guides;
gdisp->draw_guides = GTK_CHECK_MENU_ITEM (widget)->active;
if ((old_val != gdisp->draw_guides) && gdisp->gimage->guides)
if (GTK_CHECK_MENU_ITEM (widget)->active != gdisp->draw_guides)
{
gimp_display_shell_expose_full (GIMP_DISPLAY_SHELL (gdisp->shell));
gimp_display_flush (gdisp);
GimpDisplayShell *shell;
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
gdisp->draw_guides = GTK_CHECK_MENU_ITEM (widget)->active;
if (gdisp->gimage->guides)
{
gimp_display_shell_expose_full (shell);
gimp_display_flush (gdisp);
}
else
{
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Guides",
gdisp->draw_guides);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Guides",
gdisp->draw_guides);
}
}
}
@ -314,13 +353,23 @@ void
view_snap_to_guides_cmd_callback (GtkWidget *widget,
gpointer data)
{
GimpDisplay *gdisp;
GimpDisplay *gdisp;
GimpDisplayShell *shell;
return_if_no_display (gdisp, data);
gdisp->snap_to_guides = GTK_CHECK_MENU_ITEM (widget)->active;
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
gimp_display_shell_set_menu_sensitivity (GIMP_DISPLAY_SHELL (gdisp->shell),
gdisp->gimage->gimp, FALSE);
if (gdisp->snap_to_guides != GTK_CHECK_MENU_ITEM (widget)->active)
{
gdisp->snap_to_guides = GTK_CHECK_MENU_ITEM (widget)->active;
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Snap to Guides",
gdisp->snap_to_guides);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Snap to Guides",
gdisp->snap_to_guides);
}
}
void

18
app/core/gimpchannel-combine.c
View file

@ -115,13 +115,13 @@ gimp_channel_init (GimpChannel *channel)
channel->show_masked = FALSE;
/* Selection mask variables */
channel->boundary_known = TRUE;
channel->boundary_known = FALSE;
channel->segs_in = NULL;
channel->segs_out = NULL;
channel->num_segs_in = 0;
channel->num_segs_out = 0;
channel->empty = TRUE;
channel->bounds_known = TRUE;
channel->empty = FALSE;
channel->bounds_known = FALSE;
channel->x1 = 0;
channel->y1 = 0;
channel->x2 = 0;
@ -242,13 +242,17 @@ gimp_channel_copy (const GimpChannel *channel,
FALSE));
/* set the channel color and opacity */
new_channel->color = channel->color;
new_channel->color = channel->color;
new_channel->show_masked = channel->show_masked;
new_channel->show_masked = channel->show_masked;
/* selection mask variables */
new_channel->x2 = gimp_drawable_width (GIMP_DRAWABLE (new_channel));
new_channel->y2 = gimp_drawable_height (GIMP_DRAWABLE (new_channel));
new_channel->bounds_known = channel->bounds_known;
new_channel->empty = channel->empty;
new_channel->x1 = channel->x1;
new_channel->y1 = channel->y1;
new_channel->x2 = channel->x2;
new_channel->y2 = channel->y2;
return new_channel;
}

18
app/core/gimpchannel.c
View file

@ -115,13 +115,13 @@ gimp_channel_init (GimpChannel *channel)
channel->show_masked = FALSE;
/* Selection mask variables */
channel->boundary_known = TRUE;
channel->boundary_known = FALSE;
channel->segs_in = NULL;
channel->segs_out = NULL;
channel->num_segs_in = 0;
channel->num_segs_out = 0;
channel->empty = TRUE;
channel->bounds_known = TRUE;
channel->empty = FALSE;
channel->bounds_known = FALSE;
channel->x1 = 0;
channel->y1 = 0;
channel->x2 = 0;
@ -242,13 +242,17 @@ gimp_channel_copy (const GimpChannel *channel,
FALSE));
/* set the channel color and opacity */
new_channel->color = channel->color;
new_channel->color = channel->color;
new_channel->show_masked = channel->show_masked;
new_channel->show_masked = channel->show_masked;
/* selection mask variables */
new_channel->x2 = gimp_drawable_width (GIMP_DRAWABLE (new_channel));
new_channel->y2 = gimp_drawable_height (GIMP_DRAWABLE (new_channel));
new_channel->bounds_known = channel->bounds_known;
new_channel->empty = channel->empty;
new_channel->x1 = channel->x1;
new_channel->y1 = channel->y1;
new_channel->x2 = channel->x2;
new_channel->y2 = channel->y2;
return new_channel;
}

23
app/core/gimpprojection.c
View file

@ -19,6 +19,7 @@
#include "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include "display-types.h"
@ -32,6 +33,8 @@
#include "core/gimpimage-projection.h"
#include "core/gimplist.h"
#include "widgets/gimpitemfactory.h"
#include "libgimptool/gimptool.h"
#include "tools/tool_manager.h"
@ -203,8 +206,10 @@ gimp_display_get_property (GObject *object,
}
GimpDisplay *
gimp_display_new (GimpImage *gimage,
guint scale)
gimp_display_new (GimpImage *gimage,
guint scale,
GimpMenuFactory *menu_factory,
GimpItemFactory *popup_factory)
{
GimpDisplay *gdisp;
@ -222,7 +227,8 @@ gimp_display_new (GimpImage *gimage,
gimp_display_connect (gdisp, gimage);
/* create the shell for the image */
gdisp->shell = gimp_display_shell_new (gdisp, scale);
gdisp->shell = gimp_display_shell_new (gdisp, scale,
menu_factory, popup_factory);
gtk_widget_show (gdisp->shell);
@ -474,7 +480,16 @@ gimp_display_flush_whenever (GimpDisplay *gdisp,
/* ensure the consistency of the menus */
if (! now)
gimp_display_shell_set_menu_sensitivity (shell, gdisp->gimage->gimp, FALSE);
{
GimpContext *context;
gimp_item_factory_update (shell->menubar_factory, shell);
context = gimp_get_current_context (gdisp->gimage->gimp);
if (gdisp == gimp_context_get_display (context))
gimp_item_factory_update (shell->popup_factory, shell);
}
}
static void

34
app/core/gimpprojection.h
View file

@ -76,27 +76,29 @@ struct _GimpDisplayClass
GType gimp_display_get_type (void) G_GNUC_CONST;
GimpDisplay * gimp_display_new (GimpImage *gimage,
guint scale);
void gimp_display_delete (GimpDisplay *gdisp);
GimpDisplay * gimp_display_new (GimpImage *gimage,
guint scale,
GimpMenuFactory *menu_factory,
GimpItemFactory *popup_factory);
void gimp_display_delete (GimpDisplay *gdisp);
gint gimp_display_get_ID (GimpDisplay *gdisp);
GimpDisplay * gimp_display_get_by_ID (Gimp *gimp,
gint ID);
gint gimp_display_get_ID (GimpDisplay *gdisp);
GimpDisplay * gimp_display_get_by_ID (Gimp *gimp,
gint ID);
void gimp_display_reconnect (GimpDisplay *gdisp,
GimpImage *gimage);
void gimp_display_reconnect (GimpDisplay *gdisp,
GimpImage *gimage);
void gimp_display_add_update_area (GimpDisplay *gdisp,
gint x,
gint y,
gint w,
gint h);
void gimp_display_add_update_area (GimpDisplay *gdisp,
gint x,
gint y,
gint w,
gint h);
void gimp_display_flush (GimpDisplay *gdisp);
void gimp_display_flush_now (GimpDisplay *gdisp);
void gimp_display_flush (GimpDisplay *gdisp);
void gimp_display_flush_now (GimpDisplay *gdisp);
void gimp_display_finish_draw (GimpDisplay *gdisp);
void gimp_display_finish_draw (GimpDisplay *gdisp);
gboolean gimp_display_coords_in_active_drawable (GimpDisplay *gdisp,
const GimpCoords *coords);

42
app/dialogs/dialogs-constructors.c
View file

@ -78,6 +78,7 @@
#include "dialogs-constructors.h"
#include "documents-commands.h"
#include "error-console-dialog.h"
#include "file-commands.h"
#include "gradients-commands.h"
#include "layers-commands.h"
#include "module-browser.h"
@ -343,7 +344,7 @@ dialogs_image_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Images>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Image List"), _("Images"), NULL,
@ -365,7 +366,7 @@ dialogs_brush_list_view_new (GimpDialogFactory *factory,
TRUE,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Brushes>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Brush List"), _("Brushes"), NULL,
@ -386,7 +387,7 @@ dialogs_pattern_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Patterns>"));
factory->menu_factory, "<Patterns>");
return dialogs_dockable_new (view,
_("Pattern List"), _("Patterns"), NULL,
@ -407,7 +408,7 @@ dialogs_gradient_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Gradients>"));
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Gradient List"), _("Gradients"), NULL,
@ -428,7 +429,7 @@ dialogs_palette_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Palettes>"));
factory->menu_factory, "<Palettes>");
return dialogs_dockable_new (view,
_("Palette List"), _("Palettes"), NULL,
@ -467,7 +468,7 @@ dialogs_buffer_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Buffers>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Buffer List"), _("Buffers"),
@ -491,7 +492,7 @@ dialogs_image_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Images>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Image Grid"), _("Images"), NULL,
@ -513,7 +514,7 @@ dialogs_brush_grid_view_new (GimpDialogFactory *factory,
TRUE,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Brushes>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Brush Grid"), _("Brushes"), NULL,
@ -534,7 +535,7 @@ dialogs_pattern_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Patterns>"));
factory->menu_factory, "<Patterns>");
return dialogs_dockable_new (view,
_("Pattern Grid"), _("Patterns"), NULL,
@ -555,7 +556,7 @@ dialogs_gradient_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Gradients>"));
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Gradient Grid"), _("Gradients"), NULL,
@ -576,7 +577,7 @@ dialogs_palette_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Gradients>"));
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Palette Grid"), _("Palettes"), NULL,
@ -615,7 +616,7 @@ dialogs_buffer_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Buffers>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Buffer Grid"), _("Buffers"),
@ -655,7 +656,7 @@ dialogs_layer_list_view_new (GimpDialogFactory *factory,
(GimpNewItemFunc) layers_new_layer_query,
(GimpEditItemFunc) layers_edit_layer_query,
(GimpActivateItemFunc) layers_edit_layer_query,
gimp_item_factory_from_path ("<Layers>"));
factory->menu_factory, "<Layers>");
layer_view = GIMP_LAYER_LIST_VIEW (view);
@ -698,7 +699,7 @@ dialogs_channel_list_view_new (GimpDialogFactory *factory,
(GimpNewItemFunc) channels_new_channel_query,
(GimpEditItemFunc) channels_edit_channel_query,
(GimpActivateItemFunc) channels_edit_channel_query,
gimp_item_factory_from_path ("<Channels>"));
factory->menu_factory, "<Channels>");
dockable = dialogs_dockable_new (view,
_("Channel List"), _("Channels"), NULL,
@ -749,7 +750,7 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
(GimpNewItemFunc) vectors_new_vectors_query,
(GimpEditItemFunc) vectors_edit_vectors_query,
(GimpActivateItemFunc) vectors_vectors_tool,
gimp_item_factory_from_path ("<Vectors>"));
factory->menu_factory, "<Vectors>");
vectors_view = GIMP_VECTORS_LIST_VIEW (view);
@ -802,7 +803,7 @@ dialogs_indexed_palette_new (GimpDialogFactory *factory,
gimage = gimp_context_get_image (context);
view = gimp_colormap_editor_new (gimage);
view = gimp_colormap_editor_new (gimage, factory->menu_factory);
dockable = dialogs_dockable_new (view,
_("Indexed Palette"), _("Colormap"), NULL,
@ -873,7 +874,8 @@ dialogs_document_history_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Documents>"));
file_file_open_dialog,
factory->menu_factory);
return dialogs_dockable_new (view,
_("Document History"), _("History"),
@ -921,7 +923,8 @@ dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
gradient_editor = gimp_gradient_editor_new (context->gimp);
gradient_editor = gimp_gradient_editor_new (context->gimp,
factory->menu_factory);
return dialogs_dockable_new (GTK_WIDGET (gradient_editor),
_("Gradient Editor"), _("Gradient Editor"), NULL,
@ -948,7 +951,8 @@ dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
palette_editor = gimp_palette_editor_new (context->gimp);
palette_editor = gimp_palette_editor_new (context->gimp,
factory->menu_factory);
return dialogs_dockable_new (GTK_WIDGET (palette_editor),
_("Palette Editor"), _("Palette Editor"), NULL,

5
app/dialogs/dialogs.c
View file

@ -30,6 +30,7 @@
#include "dialogs.h"
#include "dialogs-constructors.h"
#include "menus.h"
GimpDialogFactory *global_dialog_factory = NULL;
@ -102,12 +103,12 @@ dialogs_init (Gimp *gimp)
global_toolbox_factory = gimp_dialog_factory_new ("toolbox",
gimp_get_user_context (gimp),
NULL,
global_menu_factory,
dialogs_toolbox_get);
global_dock_factory = gimp_dialog_factory_new ("dock",
gimp_get_user_context (gimp),
gimp_item_factory_from_path ("<Dialogs>"),
global_menu_factory,
dialogs_dock_new);
for (i = 0; i < G_N_ELEMENTS (toplevel_entries); i++)

28
app/dialogs/file-dialog-utils.c
View file

@ -32,6 +32,7 @@
#include "plug-in/plug-in-proc.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "file-dialog-utils.h"
@ -40,7 +41,8 @@
GtkWidget *
file_dialog_new (Gimp *gimp,
GimpItemFactory *item_factory,
GimpMenuFactory *menu_factory,
const gchar *menu_identifier,
const gchar *title,
const gchar *wmclass_name,
const gchar *help_data,
@ -50,7 +52,8 @@ file_dialog_new (Gimp *gimp,
GtkFileSelection *fs;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (menu_identifier != NULL, NULL);
g_return_val_if_fail (title != NULL, NULL);
g_return_val_if_fail (wmclass_name != NULL, NULL);
g_return_val_if_fail (help_data != NULL, NULL);
@ -83,22 +86,31 @@ file_dialog_new (Gimp *gimp,
/* The file type menu */
{
GtkWidget *hbox;
GtkWidget *option_menu;
GtkWidget *label;
GimpItemFactory *item_factory;
GtkWidget *hbox;
GtkWidget *option_menu;
GtkWidget *label;
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_end (GTK_BOX (fs->main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
item_factory = gimp_menu_factory_menu_new (menu_factory,
menu_identifier,
GTK_TYPE_MENU,
gimp,
FALSE);
option_menu = gtk_option_menu_new ();
gtk_box_pack_end (GTK_BOX (hbox), option_menu, FALSE, FALSE, 0);
gtk_widget_show (option_menu);
g_object_weak_ref (G_OBJECT (option_menu),
(GWeakNotify) g_object_unref,
item_factory);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu),
GTK_ITEM_FACTORY (item_factory)->widget);
gtk_box_pack_end (GTK_BOX (fs->main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Determine File Type:"));
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);

3
app/dialogs/file-dialog-utils.h
View file

@ -21,7 +21,8 @@
GtkWidget * file_dialog_new (Gimp *gimp,
GimpItemFactory *item_factory,
GimpMenuFactory *menu_factory,
const gchar *menu_identifier,
const gchar *title,
const gchar *wmclass_name,
const gchar *help_data,

92
app/dialogs/file-open-dialog.c
View file

@ -54,7 +54,7 @@
#include "file/file-open.h"
#include "file/file-utils.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "widgets/gimppreview.h"
#include "widgets/gimpwidgets-utils.h"
@ -68,9 +68,8 @@
/* local function prototypes */
static GtkWidget * file_open_dialog_create (Gimp *gimp);
static void file_open_type_callback (GtkWidget *widget,
gpointer data);
static GtkWidget * file_open_dialog_create (Gimp *gimp,
GimpMenuFactory *menu_factory);
static void file_open_selchanged_callback (GtkTreeSelection *sel,
GtkWidget *open_dialog);
static void file_open_imagefile_info_changed (GimpImagefile *imagefile,
@ -107,77 +106,28 @@ static PlugInProcDef *load_file_proc = NULL;
/* public functions */
void
file_open_dialog_menu_init (Gimp *gimp,
GimpItemFactory *item_factory)
file_open_dialog_set_type (PlugInProcDef *proc)
{
GimpItemFactoryEntry entry;
PlugInProcDef *file_proc;
GSList *list;
if (proc)
file_dialog_update_name (proc, GTK_FILE_SELECTION (fileload));
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_ITEM_FACTORY (item_factory));
gimp->load_procs = g_slist_reverse (gimp->load_procs);
for (list = gimp->load_procs; list; list = g_slist_next (list))
{
gchar *basename;
gchar *lowercase_basename;
gchar *help_page;
file_proc = (PlugInProcDef *) list->data;
basename = g_path_get_basename (file_proc->prog);
lowercase_basename = g_ascii_strdown (basename, -1);
g_free (basename);
/* NOT g_build_filename() because this is a relative URI */
help_page = g_strconcat ("filters/",
lowercase_basename,
".html",
NULL);
g_free (lowercase_basename);
entry.entry.path = strstr (file_proc->menu_path, "/");
entry.entry.accelerator = NULL;
entry.entry.callback = file_open_type_callback;
entry.entry.callback_action = 0;
entry.entry.item_type = NULL;
entry.quark_string = NULL;
entry.help_page = help_page;
entry.description = NULL;
gimp_item_factory_create_item (item_factory,
&entry,
NULL,
file_proc, 2,
TRUE, FALSE);
g_free (help_page);
}
load_file_proc = proc;
}
void
file_open_dialog_menu_reset (void)
{
load_file_proc = NULL;
}
void
file_open_dialog_show (Gimp *gimp,
GimpImage *gimage,
const gchar *uri)
file_open_dialog_show (Gimp *gimp,
GimpImage *gimage,
const gchar *uri,
GimpMenuFactory *menu_factory)
{
gchar *filename = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
if (! fileload)
fileload = file_open_dialog_create (gimp);
fileload = file_open_dialog_create (gimp, menu_factory);
gtk_widget_set_sensitive (GTK_WIDGET (fileload), TRUE);
@ -223,14 +173,15 @@ file_open_dialog_show (Gimp *gimp,
/* private functions */
static GtkWidget *
file_open_dialog_create (Gimp *gimp)
file_open_dialog_create (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
GtkWidget *open_dialog;
GtkFileSelection *fs;
GtkTreeSelection *tree_sel;
open_dialog = file_dialog_new (gimp,
gimp_item_factory_from_path ("<Load>"),
menu_factory, "<Load>",
_("Open Image"), "open_image",
"open/dialogs/file_open.html",
G_CALLBACK (file_open_ok_callback));
@ -402,17 +353,6 @@ file_open_dialog_create (Gimp *gimp)
return open_dialog;
}
static void
file_open_type_callback (GtkWidget *widget,
gpointer data)
{
PlugInProcDef *proc = (PlugInProcDef *) data;
file_dialog_update_name (proc, GTK_FILE_SELECTION (fileload));
load_file_proc = proc;
}
static void
file_open_imagefile_info_changed (GimpImagefile *imagefile,
GtkLabel *label)

11
app/dialogs/file-open-dialog.h
View file

@ -20,13 +20,12 @@
#define __FILE_OPEN_DIALOG_H__
void file_open_dialog_menu_init (Gimp *gimp,
GimpItemFactory *item_factory);
void file_open_dialog_menu_reset (void);
void file_open_dialog_set_type (PlugInProcDef *proc);
void file_open_dialog_show (Gimp *gimp,
GimpImage *gimage,
const gchar *uri);
void file_open_dialog_show (Gimp *gimp,
GimpImage *gimage,
const gchar *uri,
GimpMenuFactory *menu_factory);
#endif /* __FILE_OPEN_DIALOG_H__ */

122
app/dialogs/file-save-dialog.c
View file

@ -44,7 +44,7 @@
#include "file/file-save.h"
#include "file/file-utils.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "file-dialog-utils.h"
#include "file-save-dialog.h"
@ -54,23 +54,22 @@
/* local function prototypes */
static GtkWidget * file_save_dialog_create (Gimp *gimp);
static void file_save_type_callback (GtkWidget *widget,
gpointer data);
static void file_save_ok_callback (GtkWidget *widget,
GtkWidget *save_dialog);
static void file_save_overwrite (GtkWidget *save_dialog,
const gchar *uri,
const gchar *raw_filename);
static void file_save_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data);
static void file_save_dialog_save_image (GtkWidget *save_dialog,
GimpImage *gimage,
const gchar *uri,
const gchar *raw_filename,
PlugInProcDef *save_proc,
gboolean set_uri);
static GtkWidget * file_save_dialog_create (Gimp *gimp,
GimpMenuFactory *menu_factory);
static void file_save_ok_callback (GtkWidget *widget,
GtkWidget *save_dialog);
static void file_save_overwrite (GtkWidget *save_dialog,
const gchar *uri,
const gchar *raw_filename);
static void file_save_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data);
static void file_save_dialog_save_image (GtkWidget *save_dialog,
GimpImage *gimage,
const gchar *uri,
const gchar *raw_filename,
PlugInProcDef *save_proc,
gboolean set_uri);
static GtkWidget *filesave = NULL;
@ -83,71 +82,22 @@ static gboolean set_uri = TRUE;
/* public functions */
void
file_save_dialog_menu_init (Gimp *gimp,
GimpItemFactory *item_factory)
file_save_dialog_set_type (PlugInProcDef *proc)
{
GimpItemFactoryEntry entry;
PlugInProcDef *file_proc;
GSList *list;
if (proc)
file_dialog_update_name (proc, GTK_FILE_SELECTION (filesave));
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_ITEM_FACTORY (item_factory));
gimp->save_procs = g_slist_reverse (gimp->save_procs);
for (list = gimp->save_procs; list; list = g_slist_next (list))
{
gchar *basename;
gchar *lowercase_basename;
gchar *help_page;
file_proc = (PlugInProcDef *) list->data;
basename = g_path_get_basename (file_proc->prog);
lowercase_basename = g_ascii_strdown (basename, -1);
g_free (basename);
/* NOT g_build_filename() because this is a relative URI */
help_page = g_strconcat ("filters/",
lowercase_basename,
".html",
NULL);
g_free (lowercase_basename);
entry.entry.path = strstr (file_proc->menu_path, "/");
entry.entry.accelerator = NULL;
entry.entry.callback = file_save_type_callback;
entry.entry.callback_action = 0;
entry.entry.item_type = NULL;
entry.quark_string = NULL;
entry.help_page = help_page;
entry.description = NULL;
gimp_item_factory_create_item (item_factory,
&entry,
NULL,
file_proc, 2,
TRUE, FALSE);
g_free (help_page);
}
save_file_proc = proc;
}
void
file_save_dialog_menu_reset (void)
{
save_file_proc = NULL;
}
void
file_save_dialog_show (GimpImage *gimage)
file_save_dialog_show (GimpImage *gimage,
GimpMenuFactory *menu_factory)
{
gchar *filename;
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
if (! gimp_image_active_drawable (gimage))
return;
@ -156,7 +106,7 @@ file_save_dialog_show (GimpImage *gimage)
set_uri = TRUE;
if (! filesave)
filesave = file_save_dialog_create (gimage->gimp);
filesave = file_save_dialog_create (gimage->gimp, menu_factory);
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
@ -184,12 +134,14 @@ file_save_dialog_show (GimpImage *gimage)
}
void
file_save_a_copy_dialog_show (GimpImage *gimage)
file_save_a_copy_dialog_show (GimpImage *gimage,
GimpMenuFactory *menu_factory)
{
const gchar *uri;
gchar *filename = NULL;
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
if (! gimp_image_active_drawable (gimage))
return;
@ -203,7 +155,7 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
filename = g_filename_from_uri (uri, NULL, NULL);
if (! filesave)
filesave = file_save_dialog_create (gimage->gimp);
filesave = file_save_dialog_create (gimage->gimp, menu_factory);
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
@ -230,26 +182,16 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
/* private functions */
static GtkWidget *
file_save_dialog_create (Gimp *gimp)
file_save_dialog_create (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
return file_dialog_new (gimp,
gimp_item_factory_from_path ("<Save>"),
menu_factory, "<Save>",
_("Save Image"), "save_image",
"save/dialogs/file_save.html",
G_CALLBACK (file_save_ok_callback));
}
static void
file_save_type_callback (GtkWidget *widget,
gpointer data)
{
PlugInProcDef *proc = (PlugInProcDef *) data;
file_dialog_update_name (proc, GTK_FILE_SELECTION (filesave));
save_file_proc = proc;
}
static void
file_save_ok_callback (GtkWidget *widget,
GtkWidget *save_dialog)

10
app/dialogs/file-save-dialog.h
View file

@ -20,12 +20,12 @@
#define __FILE_SAVE_DIALOG_H__
void file_save_dialog_menu_init (Gimp *gimp,
GimpItemFactory *item_factory);
void file_save_dialog_menu_reset (void);
void file_save_dialog_set_type (PlugInProcDef *proc);
void file_save_dialog_show (GimpImage *gimage);
void file_save_a_copy_dialog_show (GimpImage *gimage);
void file_save_dialog_show (GimpImage *gimage,
GimpMenuFactory *menu_factory);
void file_save_a_copy_dialog_show (GimpImage *gimage,
GimpMenuFactory *menu_factory);
#endif /* __FILE_SAVE_DIALOG_H__ */

23
app/display/gimpdisplay.c
View file

@ -19,6 +19,7 @@
#include "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include "display-types.h"
@ -32,6 +33,8 @@
#include "core/gimpimage-projection.h"
#include "core/gimplist.h"
#include "widgets/gimpitemfactory.h"
#include "libgimptool/gimptool.h"
#include "tools/tool_manager.h"
@ -203,8 +206,10 @@ gimp_display_get_property (GObject *object,
}
GimpDisplay *
gimp_display_new (GimpImage *gimage,
guint scale)
gimp_display_new (GimpImage *gimage,
guint scale,
GimpMenuFactory *menu_factory,
GimpItemFactory *popup_factory)
{
GimpDisplay *gdisp;
@ -222,7 +227,8 @@ gimp_display_new (GimpImage *gimage,
gimp_display_connect (gdisp, gimage);
/* create the shell for the image */
gdisp->shell = gimp_display_shell_new (gdisp, scale);
gdisp->shell = gimp_display_shell_new (gdisp, scale,
menu_factory, popup_factory);
gtk_widget_show (gdisp->shell);
@ -474,7 +480,16 @@ gimp_display_flush_whenever (GimpDisplay *gdisp,
/* ensure the consistency of the menus */
if (! now)
gimp_display_shell_set_menu_sensitivity (shell, gdisp->gimage->gimp, FALSE);
{
GimpContext *context;
gimp_item_factory_update (shell->menubar_factory, shell);
context = gimp_get_current_context (gdisp->gimage->gimp);
if (gdisp == gimp_context_get_display (context))
gimp_item_factory_update (shell->popup_factory, shell);
}
}
static void

34
app/display/gimpdisplay.h
View file

@ -76,27 +76,29 @@ struct _GimpDisplayClass
GType gimp_display_get_type (void) G_GNUC_CONST;
GimpDisplay * gimp_display_new (GimpImage *gimage,
guint scale);
void gimp_display_delete (GimpDisplay *gdisp);
GimpDisplay * gimp_display_new (GimpImage *gimage,
guint scale,
GimpMenuFactory *menu_factory,
GimpItemFactory *popup_factory);
void gimp_display_delete (GimpDisplay *gdisp);
gint gimp_display_get_ID (GimpDisplay *gdisp);
GimpDisplay * gimp_display_get_by_ID (Gimp *gimp,
gint ID);
gint gimp_display_get_ID (GimpDisplay *gdisp);
GimpDisplay * gimp_display_get_by_ID (Gimp *gimp,
gint ID);
void gimp_display_reconnect (GimpDisplay *gdisp,
GimpImage *gimage);
void gimp_display_reconnect (GimpDisplay *gdisp,
GimpImage *gimage);
void gimp_display_add_update_area (GimpDisplay *gdisp,
gint x,
gint y,
gint w,
gint h);
void gimp_display_add_update_area (GimpDisplay *gdisp,
gint x,
gint y,
gint w,
gint h);
void gimp_display_flush (GimpDisplay *gdisp);
void gimp_display_flush_now (GimpDisplay *gdisp);
void gimp_display_flush (GimpDisplay *gdisp);
void gimp_display_flush_now (GimpDisplay *gdisp);
void gimp_display_finish_draw (GimpDisplay *gdisp);
void gimp_display_finish_draw (GimpDisplay *gdisp);
gboolean gimp_display_coords_in_active_drawable (GimpDisplay *gdisp,
const GimpCoords *coords);

6
app/display/gimpdisplayshell-callbacks.c
View file

@ -1356,11 +1356,7 @@ gimp_display_shell_qmask_button_press (GtkWidget *widget,
{
if ((bevent->type == GDK_BUTTON_PRESS) && (bevent->button == 3))
{
GimpItemFactory *factory;
factory = gimp_item_factory_from_path ("<QMask>");
gimp_item_factory_popup_with_data (factory, shell, NULL);
gimp_item_factory_popup_with_data (shell->qmask_factory, shell, NULL);
return TRUE;
}

95
app/display/gimpdisplayshell-draw.c
View file

@ -53,6 +53,7 @@
#include "widgets/gimpcolorpanel.h"
#include "widgets/gimpdnd.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "widgets/gimpwidgets-utils.h"
#include "gui/info-window.h"
@ -202,6 +203,7 @@ gimp_display_shell_init (GimpDisplayShell *shell)
shell->gdisp = NULL;
shell->menubar_factory = NULL;
shell->popup_factory = NULL;
shell->qmask_factory = NULL;
shell->scale = 0;
shell->dot_for_dot = TRUE;
@ -339,6 +341,12 @@ gimp_display_shell_destroy (GtkObject *object)
shell->popup_factory = NULL;
if (shell->qmask_factory)
{
g_object_unref (shell->qmask_factory);
shell->qmask_factory = NULL;
}
if (shell->select)
{
gimp_display_shell_selection_free (shell->select);
@ -398,8 +406,10 @@ gimp_display_shell_delete_event (GtkWidget *widget,
}
GtkWidget *
gimp_display_shell_new (GimpDisplay *gdisp,
guint scale)
gimp_display_shell_new (GimpDisplay *gdisp,
guint scale,
GimpMenuFactory *menu_factory,
GimpItemFactory *popup_factory)
{
GimpDisplayShell *shell;
GimpDisplayConfig *config;
@ -418,6 +428,8 @@ gimp_display_shell_new (GimpDisplay *gdisp,
gint scalesrc, scaledest;
g_return_val_if_fail (GIMP_IS_DISPLAY (gdisp), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (popup_factory), NULL);
/* the toplevel shell */
shell = g_object_new (GIMP_TYPE_DISPLAY_SHELL, NULL);
@ -462,12 +474,19 @@ gimp_display_shell_new (GimpDisplay *gdisp,
shell->scale = (scaledest << 8) + scalesrc;
shell->menubar_factory =
menus_get_new_image_factory (shell->gdisp->gimage->gimp,
shell->gdisp,
TRUE);
shell->menubar_factory = gimp_menu_factory_menu_new (menu_factory,
"<Image>",
GTK_TYPE_MENU_BAR,
gdisp,
TRUE);
shell->popup_factory = gimp_item_factory_from_path ("<Image>");
shell->popup_factory = popup_factory;
shell->qmask_factory = gimp_menu_factory_menu_new (menu_factory,
"<QMask>",
GTK_TYPE_MENU,
shell,
FALSE);
/* The accelerator table for images */
gimp_window_add_accel_group (GTK_WINDOW (shell),
@ -864,34 +883,39 @@ gimp_display_shell_scrolled (GimpDisplayShell *shell)
void
gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
Gimp *gimp,
gboolean popup_only)
gimp_display_shell_menu_update (GtkItemFactory *item_factory,
gpointer data)
{
GtkItemFactory *item_factory = NULL;
GimpDisplay *gdisp = NULL;
GimpImage *gimage = NULL;
GimpImageType type = -1;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
GimpRGB fg;
GimpRGB bg;
gboolean is_rgb = FALSE;
gboolean is_gray = FALSE;
gboolean is_indexed = FALSE;
gboolean fs = FALSE;
gboolean aux = FALSE;
gboolean lm = FALSE;
gboolean lp = FALSE;
gboolean sel = FALSE;
gboolean alpha = FALSE;
gint lind = -1;
gint lnum = -1;
Gimp *gimp = NULL;
GimpDisplayShell *shell = NULL;
GimpDisplay *gdisp = NULL;
GimpImage *gimage = NULL;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
GimpImageType drawable_type = -1;
GimpRGB fg;
GimpRGB bg;
gboolean is_rgb = FALSE;
gboolean is_gray = FALSE;
gboolean is_indexed = FALSE;
gboolean fs = FALSE;
gboolean aux = FALSE;
gboolean lm = FALSE;
gboolean lp = FALSE;
gboolean sel = FALSE;
gboolean alpha = FALSE;
gint lind = -1;
gint lnum = -1;
g_return_if_fail (shell == NULL || GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (popup_only == TRUE || GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (GIMP_IS_GIMP (gimp));
gimp = GIMP_ITEM_FACTORY (item_factory)->gimp;
if (data)
{
shell = GIMP_DISPLAY_SHELL (data);
gdisp = shell->gdisp;
}
#if 0
if (shell)
{
gdisp = shell->gdisp;
@ -905,6 +929,7 @@ gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
{
item_factory = GTK_ITEM_FACTORY (gimp_item_factory_from_path ("<Image>"));
}
#endif
if (gdisp)
{
@ -925,7 +950,7 @@ gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
drawable = gimp_image_active_drawable (gimage);
if (drawable)
type = gimp_drawable_type (drawable);
drawable_type = gimp_drawable_type (drawable);
if (lp)
{
@ -1130,8 +1155,9 @@ gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
#undef SET_LABEL
#undef SET_SENSITIVE
plug_in_set_menu_sensitivity (GIMP_ITEM_FACTORY (item_factory), type);
plug_in_set_menu_sensitivity (GIMP_ITEM_FACTORY (item_factory), drawable_type);
#if 0
/* update the popup menu */
if (! popup_only)
{
@ -1151,6 +1177,7 @@ gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
TRUE);
}
}
#endif
}
GimpGuide *

10
app/display/gimpdisplayshell-draw.h
View file

@ -75,6 +75,7 @@ struct _GimpDisplayShell
GimpItemFactory *menubar_factory;
GimpItemFactory *popup_factory;
GimpItemFactory *qmask_factory;
gdouble monitor_xres;
gdouble monitor_yres;
@ -163,7 +164,9 @@ struct _GimpDisplayShellClass
GType gimp_display_shell_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_display_shell_new (GimpDisplay *gdisp,
guint scale);
guint scale,
GimpMenuFactory *menu_factory,
GimpItemFactory *popup_factory);
void gimp_display_shell_close (GimpDisplayShell *shell,
gboolean kill_it);
@ -173,9 +176,8 @@ void gimp_display_shell_reconnect (GimpDisplayShell *shell);
void gimp_display_shell_scaled (GimpDisplayShell *shell);
void gimp_display_shell_scrolled (GimpDisplayShell *shell);
void gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
Gimp *gimp,
gboolean popup_only);
void gimp_display_shell_menu_update (GtkItemFactory *item_factory,
gpointer data);
GimpGuide * gimp_display_shell_find_guide (GimpDisplayShell *shell,
gdouble x,

95
app/display/gimpdisplayshell.c
View file

@ -53,6 +53,7 @@
#include "widgets/gimpcolorpanel.h"
#include "widgets/gimpdnd.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "widgets/gimpwidgets-utils.h"
#include "gui/info-window.h"
@ -202,6 +203,7 @@ gimp_display_shell_init (GimpDisplayShell *shell)
shell->gdisp = NULL;
shell->menubar_factory = NULL;
shell->popup_factory = NULL;
shell->qmask_factory = NULL;
shell->scale = 0;
shell->dot_for_dot = TRUE;
@ -339,6 +341,12 @@ gimp_display_shell_destroy (GtkObject *object)
shell->popup_factory = NULL;
if (shell->qmask_factory)
{
g_object_unref (shell->qmask_factory);
shell->qmask_factory = NULL;
}
if (shell->select)
{
gimp_display_shell_selection_free (shell->select);
@ -398,8 +406,10 @@ gimp_display_shell_delete_event (GtkWidget *widget,
}
GtkWidget *
gimp_display_shell_new (GimpDisplay *gdisp,
guint scale)
gimp_display_shell_new (GimpDisplay *gdisp,
guint scale,
GimpMenuFactory *menu_factory,
GimpItemFactory *popup_factory)
{
GimpDisplayShell *shell;
GimpDisplayConfig *config;
@ -418,6 +428,8 @@ gimp_display_shell_new (GimpDisplay *gdisp,
gint scalesrc, scaledest;
g_return_val_if_fail (GIMP_IS_DISPLAY (gdisp), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (popup_factory), NULL);
/* the toplevel shell */
shell = g_object_new (GIMP_TYPE_DISPLAY_SHELL, NULL);
@ -462,12 +474,19 @@ gimp_display_shell_new (GimpDisplay *gdisp,
shell->scale = (scaledest << 8) + scalesrc;
shell->menubar_factory =
menus_get_new_image_factory (shell->gdisp->gimage->gimp,
shell->gdisp,
TRUE);
shell->menubar_factory = gimp_menu_factory_menu_new (menu_factory,
"<Image>",
GTK_TYPE_MENU_BAR,
gdisp,
TRUE);
shell->popup_factory = gimp_item_factory_from_path ("<Image>");
shell->popup_factory = popup_factory;
shell->qmask_factory = gimp_menu_factory_menu_new (menu_factory,
"<QMask>",
GTK_TYPE_MENU,
shell,
FALSE);
/* The accelerator table for images */
gimp_window_add_accel_group (GTK_WINDOW (shell),
@ -864,34 +883,39 @@ gimp_display_shell_scrolled (GimpDisplayShell *shell)
void
gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
Gimp *gimp,
gboolean popup_only)
gimp_display_shell_menu_update (GtkItemFactory *item_factory,
gpointer data)
{
GtkItemFactory *item_factory = NULL;
GimpDisplay *gdisp = NULL;
GimpImage *gimage = NULL;
GimpImageType type = -1;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
GimpRGB fg;
GimpRGB bg;
gboolean is_rgb = FALSE;
gboolean is_gray = FALSE;
gboolean is_indexed = FALSE;
gboolean fs = FALSE;
gboolean aux = FALSE;
gboolean lm = FALSE;
gboolean lp = FALSE;
gboolean sel = FALSE;
gboolean alpha = FALSE;
gint lind = -1;
gint lnum = -1;
Gimp *gimp = NULL;
GimpDisplayShell *shell = NULL;
GimpDisplay *gdisp = NULL;
GimpImage *gimage = NULL;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
GimpImageType drawable_type = -1;
GimpRGB fg;
GimpRGB bg;
gboolean is_rgb = FALSE;
gboolean is_gray = FALSE;
gboolean is_indexed = FALSE;
gboolean fs = FALSE;
gboolean aux = FALSE;
gboolean lm = FALSE;
gboolean lp = FALSE;
gboolean sel = FALSE;
gboolean alpha = FALSE;
gint lind = -1;
gint lnum = -1;
g_return_if_fail (shell == NULL || GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (popup_only == TRUE || GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (GIMP_IS_GIMP (gimp));
gimp = GIMP_ITEM_FACTORY (item_factory)->gimp;
if (data)
{
shell = GIMP_DISPLAY_SHELL (data);
gdisp = shell->gdisp;
}
#if 0
if (shell)
{
gdisp = shell->gdisp;
@ -905,6 +929,7 @@ gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
{
item_factory = GTK_ITEM_FACTORY (gimp_item_factory_from_path ("<Image>"));
}
#endif
if (gdisp)
{
@ -925,7 +950,7 @@ gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
drawable = gimp_image_active_drawable (gimage);
if (drawable)
type = gimp_drawable_type (drawable);
drawable_type = gimp_drawable_type (drawable);
if (lp)
{
@ -1130,8 +1155,9 @@ gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
#undef SET_LABEL
#undef SET_SENSITIVE
plug_in_set_menu_sensitivity (GIMP_ITEM_FACTORY (item_factory), type);
plug_in_set_menu_sensitivity (GIMP_ITEM_FACTORY (item_factory), drawable_type);
#if 0
/* update the popup menu */
if (! popup_only)
{
@ -1151,6 +1177,7 @@ gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
TRUE);
}
}
#endif
}
GimpGuide *

10
app/display/gimpdisplayshell.h
View file

@ -75,6 +75,7 @@ struct _GimpDisplayShell
GimpItemFactory *menubar_factory;
GimpItemFactory *popup_factory;
GimpItemFactory *qmask_factory;
gdouble monitor_xres;
gdouble monitor_yres;
@ -163,7 +164,9 @@ struct _GimpDisplayShellClass
GType gimp_display_shell_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_display_shell_new (GimpDisplay *gdisp,
guint scale);
guint scale,
GimpMenuFactory *menu_factory,
GimpItemFactory *popup_factory);
void gimp_display_shell_close (GimpDisplayShell *shell,
gboolean kill_it);
@ -173,9 +176,8 @@ void gimp_display_shell_reconnect (GimpDisplayShell *shell);
void gimp_display_shell_scaled (GimpDisplayShell *shell);
void gimp_display_shell_scrolled (GimpDisplayShell *shell);
void gimp_display_shell_set_menu_sensitivity (GimpDisplayShell *shell,
Gimp *gimp,
gboolean popup_only);
void gimp_display_shell_menu_update (GtkItemFactory *item_factory,
gpointer data);
GimpGuide * gimp_display_shell_find_guide (GimpDisplayShell *shell,
gdouble x,

2
app/gui/Makefile.am
View file

@ -24,6 +24,8 @@ libappgui_a_SOURCES = \
convert-dialog.h \
data-commands.c \
data-commands.h \
debug-commands.c \
debug-commands.h \
device-status-dialog.c \
device-status-dialog.h \
dialogs.c \

4
app/gui/brush-select.c
View file

@ -37,11 +37,11 @@
#include "pdb/procedural_db.h"
#include "widgets/gimpbrushfactoryview.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpwidgets-constructors.h"
#include "brush-select.h"
#include "dialogs-constructors.h"
#include "menus.h"
#include "libgimp/gimpintl.h"
@ -168,7 +168,7 @@ brush_select_new (Gimp *gimp,
MIN_CELL_SIZE,
STD_BRUSH_COLUMNS,
STD_BRUSH_ROWS,
gimp_item_factory_from_path ("<Brushes>"));
global_menu_factory);
gtk_container_set_border_width (GTK_CONTAINER (bsp->view), 4);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (bsp->shell)->vbox), bsp->view);

188
app/gui/debug-commands.c Normal file
View file

@ -0,0 +1,188 @@
/* 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 "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include "libgimpbase/gimpbase.h"
#include "gui-types.h"
#include "core/gimpobject.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "debug-commands.h"
#include "menus.h"
#ifdef ENABLE_DEBUG_ENTRIES
/* local function prototypes */
static void debug_dump_menus_recurse_menu (GtkWidget *menu,
gint depth,
gchar *path);
/* public functions */
void
debug_dump_menus_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GList *list;
for (list = global_menu_factory->registered_menus;
list;
list = g_list_next (list))
{
GimpMenuFactoryEntry *entry;
GimpItemFactory *item_factory;
entry = list->data;
item_factory = gimp_item_factory_from_path (entry->identifier);
if (item_factory)
{
GtkWidget *menu_item;
g_print ("%s\n", entry->identifier);
menu_item = gtk_item_factory_get_item (GTK_ITEM_FACTORY (item_factory),
entry->entries[0].entry.path);
if (menu_item &&
menu_item->parent &&
GTK_IS_MENU (menu_item->parent))
debug_dump_menus_recurse_menu (menu_item->parent, 1,
entry->identifier);
g_print ("\n");
}
}
}
void
debug_mem_profile_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
extern gboolean gimp_debug_memsize;
gimp_debug_memsize = TRUE;
gimp_object_get_memsize (GIMP_OBJECT (data));
gimp_debug_memsize = FALSE;
}
/* private functions */
static void
debug_dump_menus_recurse_menu (GtkWidget *menu,
gint depth,
gchar *path)
{
GtkItemFactory *item_factory;
GtkWidget *menu_item;
GList *list;
const gchar *label;
gchar *help_page;
gchar *help_path;
gchar *factory_path;
gchar *hash;
gchar *full_path;
gchar *format_str;
for (list = GTK_MENU_SHELL (menu)->children; list; list = g_list_next (list))
{
menu_item = GTK_WIDGET (list->data);
if (GTK_IS_LABEL (GTK_BIN (menu_item)->child))
{
label = gtk_label_get_text (GTK_LABEL (GTK_BIN (menu_item)->child));
full_path = g_strconcat (path, "/", label, NULL);
item_factory = GTK_ITEM_FACTORY (gimp_item_factory_from_path (path));
help_page = g_object_get_data (G_OBJECT (menu_item), "help_page");
if (item_factory)
{
factory_path = g_object_get_data (G_OBJECT (item_factory),
"factory_path");
if (factory_path)
{
help_page = g_build_filename (factory_path, help_page, NULL);
}
else
{
help_page = g_strdup (help_page);
}
}
else
{
help_page = g_strdup (help_page);
}
if (help_page)
{
help_path = g_build_filename (gimp_data_directory (),
"help", "C", help_page, NULL);
if ((hash = strchr (help_path, '#')) != NULL)
*hash = '\0';
if (g_file_test (help_path, G_FILE_TEST_EXISTS))
{
g_free (help_path);
help_path = g_strconcat ("! ", help_page, NULL);
g_free (help_page);
help_page = help_path;
}
else
{
g_free (help_path);
}
}
format_str = g_strdup_printf ("%%%ds%%%ds %%-20s %%s\n",
depth * 2, depth * 2 - 40);
g_print (format_str,
"", label, "", help_page ? help_page : "");
g_free (format_str);
g_free (help_page);
if (GTK_MENU_ITEM (menu_item)->submenu)
debug_dump_menus_recurse_menu (GTK_MENU_ITEM (menu_item)->submenu,
depth + 1, full_path);
g_free (full_path);
}
}
}
#endif /* ENABLE_DEBUG_ENTRIES */

36
app/gui/debug-commands.h Normal file
View file

@ -0,0 +1,36 @@
/* 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.
*/
#ifndef __DEBUG_COMMANDS_H__
#define __DEBUG_COMMANDS_H__
#define ENABLE_DEBUG_ENTRIES 1
#ifdef ENABLE_DEBUG_ENTRIES
void debug_dump_menus_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void debug_mem_profile_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
#endif /* ENABLE_DEBUG_ENTRIES */
#endif /* __DEBUG_COMMANDS_H__ */

6
app/gui/dialogs-commands.c
View file

@ -24,6 +24,8 @@
#include "gui-types.h"
#include "core/gimpcontext.h"
#include "widgets/gimpcontainerview.h"
#include "widgets/gimpcontainerview-utils.h"
#include "widgets/gimpdialogfactory.h"
@ -314,7 +316,7 @@ dialogs_create_lc_cmd_callback (GtkWidget *widget,
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dock), TRUE);
dockbook = gimp_dockbook_new ();
dockbook = gimp_dockbook_new (global_dock_factory->menu_factory);
gimp_dock_add_book (GIMP_DOCK (dock), GIMP_DOCKBOOK (dockbook), 0);
@ -353,7 +355,7 @@ dialogs_create_stuff_cmd_callback (GtkWidget *widget,
dock = gimp_dialog_factory_dock_new (global_dock_factory);
dockbook = gimp_dockbook_new ();
dockbook = gimp_dockbook_new (global_dock_factory->menu_factory);
gimp_dock_add_book (GIMP_DOCK (dock), GIMP_DOCKBOOK (dockbook), 0);

42
app/gui/dialogs-constructors.c
View file

@ -78,6 +78,7 @@
#include "dialogs-constructors.h"
#include "documents-commands.h"
#include "error-console-dialog.h"
#include "file-commands.h"
#include "gradients-commands.h"
#include "layers-commands.h"
#include "module-browser.h"
@ -343,7 +344,7 @@ dialogs_image_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Images>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Image List"), _("Images"), NULL,
@ -365,7 +366,7 @@ dialogs_brush_list_view_new (GimpDialogFactory *factory,
TRUE,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Brushes>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Brush List"), _("Brushes"), NULL,
@ -386,7 +387,7 @@ dialogs_pattern_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Patterns>"));
factory->menu_factory, "<Patterns>");
return dialogs_dockable_new (view,
_("Pattern List"), _("Patterns"), NULL,
@ -407,7 +408,7 @@ dialogs_gradient_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Gradients>"));
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Gradient List"), _("Gradients"), NULL,
@ -428,7 +429,7 @@ dialogs_palette_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Palettes>"));
factory->menu_factory, "<Palettes>");
return dialogs_dockable_new (view,
_("Palette List"), _("Palettes"), NULL,
@ -467,7 +468,7 @@ dialogs_buffer_list_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Buffers>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Buffer List"), _("Buffers"),
@ -491,7 +492,7 @@ dialogs_image_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Images>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Image Grid"), _("Images"), NULL,
@ -513,7 +514,7 @@ dialogs_brush_grid_view_new (GimpDialogFactory *factory,
TRUE,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Brushes>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Brush Grid"), _("Brushes"), NULL,
@ -534,7 +535,7 @@ dialogs_pattern_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Patterns>"));
factory->menu_factory, "<Patterns>");
return dialogs_dockable_new (view,
_("Pattern Grid"), _("Patterns"), NULL,
@ -555,7 +556,7 @@ dialogs_gradient_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Gradients>"));
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Gradient Grid"), _("Gradients"), NULL,
@ -576,7 +577,7 @@ dialogs_palette_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Gradients>"));
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Palette Grid"), _("Palettes"), NULL,
@ -615,7 +616,7 @@ dialogs_buffer_grid_view_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Buffers>"));
factory->menu_factory);
return dialogs_dockable_new (view,
_("Buffer Grid"), _("Buffers"),
@ -655,7 +656,7 @@ dialogs_layer_list_view_new (GimpDialogFactory *factory,
(GimpNewItemFunc) layers_new_layer_query,
(GimpEditItemFunc) layers_edit_layer_query,
(GimpActivateItemFunc) layers_edit_layer_query,
gimp_item_factory_from_path ("<Layers>"));
factory->menu_factory, "<Layers>");
layer_view = GIMP_LAYER_LIST_VIEW (view);
@ -698,7 +699,7 @@ dialogs_channel_list_view_new (GimpDialogFactory *factory,
(GimpNewItemFunc) channels_new_channel_query,
(GimpEditItemFunc) channels_edit_channel_query,
(GimpActivateItemFunc) channels_edit_channel_query,
gimp_item_factory_from_path ("<Channels>"));
factory->menu_factory, "<Channels>");
dockable = dialogs_dockable_new (view,
_("Channel List"), _("Channels"), NULL,
@ -749,7 +750,7 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
(GimpNewItemFunc) vectors_new_vectors_query,
(GimpEditItemFunc) vectors_edit_vectors_query,
(GimpActivateItemFunc) vectors_vectors_tool,
gimp_item_factory_from_path ("<Vectors>"));
factory->menu_factory, "<Vectors>");
vectors_view = GIMP_VECTORS_LIST_VIEW (view);
@ -802,7 +803,7 @@ dialogs_indexed_palette_new (GimpDialogFactory *factory,
gimage = gimp_context_get_image (context);
view = gimp_colormap_editor_new (gimage);
view = gimp_colormap_editor_new (gimage, factory->menu_factory);
dockable = dialogs_dockable_new (view,
_("Indexed Palette"), _("Colormap"), NULL,
@ -873,7 +874,8 @@ dialogs_document_history_new (GimpDialogFactory *factory,
context,
preview_size,
5, 3,
gimp_item_factory_from_path ("<Documents>"));
file_file_open_dialog,
factory->menu_factory);
return dialogs_dockable_new (view,
_("Document History"), _("History"),
@ -921,7 +923,8 @@ dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
gradient_editor = gimp_gradient_editor_new (context->gimp);
gradient_editor = gimp_gradient_editor_new (context->gimp,
factory->menu_factory);
return dialogs_dockable_new (GTK_WIDGET (gradient_editor),
_("Gradient Editor"), _("Gradient Editor"), NULL,
@ -948,7 +951,8 @@ dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
palette_editor = gimp_palette_editor_new (context->gimp);
palette_editor = gimp_palette_editor_new (context->gimp,
factory->menu_factory);
return dialogs_dockable_new (GTK_WIDGET (palette_editor),
_("Palette Editor"), _("Palette Editor"), NULL,

5
app/gui/dialogs.c
View file

@ -30,6 +30,7 @@
#include "dialogs.h"
#include "dialogs-constructors.h"
#include "menus.h"
GimpDialogFactory *global_dialog_factory = NULL;
@ -102,12 +103,12 @@ dialogs_init (Gimp *gimp)
global_toolbox_factory = gimp_dialog_factory_new ("toolbox",
gimp_get_user_context (gimp),
NULL,
global_menu_factory,
dialogs_toolbox_get);
global_dock_factory = gimp_dialog_factory_new ("dock",
gimp_get_user_context (gimp),
gimp_item_factory_from_path ("<Dialogs>"),
global_menu_factory,
dialogs_dock_new);
for (i = 0; i < G_N_ELEMENTS (toplevel_entries); i++)

33
app/gui/file-commands.c
View file

@ -44,6 +44,7 @@
#include "file-new-dialog.h"
#include "file-open-dialog.h"
#include "file-save-dialog.h"
#include "menus.h"
#include "undo.h"
@ -107,7 +108,15 @@ file_open_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
file_open_dialog_menu_reset ();
file_open_dialog_set_type (NULL);
}
void
file_open_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
file_open_dialog_set_type ((PlugInProcDef *) data);
}
void
@ -125,7 +134,7 @@ file_open_cmd_callback (GtkWidget *widget,
else
gimage = NULL;
file_open_dialog_show (gimp, gimage, NULL);
file_open_dialog_show (gimp, gimage, NULL, global_menu_factory);
}
void
@ -160,7 +169,15 @@ file_save_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
file_save_dialog_menu_reset ();
file_save_dialog_set_type (NULL);
}
void
file_save_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
file_save_dialog_set_type ((PlugInProcDef *) data);
}
void
@ -215,7 +232,7 @@ file_save_as_cmd_callback (GtkWidget *widget,
GimpDisplay *gdisp;
return_if_no_display (gdisp, data);
file_save_dialog_show (gdisp->gimage);
file_save_dialog_show (gdisp->gimage, global_menu_factory);
}
void
@ -226,7 +243,7 @@ file_save_a_copy_cmd_callback (GtkWidget *widget,
GimpDisplay *gdisp;
return_if_no_display (gdisp, data);
file_save_a_copy_dialog_show (gdisp->gimage);
file_save_a_copy_dialog_show (gdisp->gimage, global_menu_factory);
}
void
@ -309,6 +326,12 @@ file_quit_cmd_callback (GtkWidget *widget,
gimp_exit (gimp, FALSE);
}
void
file_file_open_dialog (Gimp *gimp,
const gchar *uri)
{
file_open_dialog_show (gimp, NULL, uri, global_menu_factory);
}
/* private functions */

81
app/gui/file-commands.h
View file

@ -20,45 +20,54 @@
#define __FILE_COMMANDS_H__
void file_new_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_new_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_last_opened_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_open_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_last_opened_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_as_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_a_copy_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_by_extension_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_as_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_a_copy_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_revert_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_pref_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_close_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_quit_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_revert_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_pref_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_close_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_quit_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_file_open_dialog (Gimp *gimp,
const gchar *uri);
#endif /* __FILE_COMMANDS_H__ */

28
app/gui/file-dialog-utils.c
View file

@ -32,6 +32,7 @@
#include "plug-in/plug-in-proc.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "file-dialog-utils.h"
@ -40,7 +41,8 @@
GtkWidget *
file_dialog_new (Gimp *gimp,
GimpItemFactory *item_factory,
GimpMenuFactory *menu_factory,
const gchar *menu_identifier,
const gchar *title,
const gchar *wmclass_name,
const gchar *help_data,
@ -50,7 +52,8 @@ file_dialog_new (Gimp *gimp,
GtkFileSelection *fs;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (menu_identifier != NULL, NULL);
g_return_val_if_fail (title != NULL, NULL);
g_return_val_if_fail (wmclass_name != NULL, NULL);
g_return_val_if_fail (help_data != NULL, NULL);
@ -83,22 +86,31 @@ file_dialog_new (Gimp *gimp,
/* The file type menu */
{
GtkWidget *hbox;
GtkWidget *option_menu;
GtkWidget *label;
GimpItemFactory *item_factory;
GtkWidget *hbox;
GtkWidget *option_menu;
GtkWidget *label;
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_end (GTK_BOX (fs->main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
item_factory = gimp_menu_factory_menu_new (menu_factory,
menu_identifier,
GTK_TYPE_MENU,
gimp,
FALSE);
option_menu = gtk_option_menu_new ();
gtk_box_pack_end (GTK_BOX (hbox), option_menu, FALSE, FALSE, 0);
gtk_widget_show (option_menu);
g_object_weak_ref (G_OBJECT (option_menu),
(GWeakNotify) g_object_unref,
item_factory);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu),
GTK_ITEM_FACTORY (item_factory)->widget);
gtk_box_pack_end (GTK_BOX (fs->main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Determine File Type:"));
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);

3
app/gui/file-dialog-utils.h
View file

@ -21,7 +21,8 @@
GtkWidget * file_dialog_new (Gimp *gimp,
GimpItemFactory *item_factory,
GimpMenuFactory *menu_factory,
const gchar *menu_identifier,
const gchar *title,
const gchar *wmclass_name,
const gchar *help_data,

92
app/gui/file-open-dialog.c
View file

@ -54,7 +54,7 @@
#include "file/file-open.h"
#include "file/file-utils.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "widgets/gimppreview.h"
#include "widgets/gimpwidgets-utils.h"
@ -68,9 +68,8 @@
/* local function prototypes */
static GtkWidget * file_open_dialog_create (Gimp *gimp);
static void file_open_type_callback (GtkWidget *widget,
gpointer data);
static GtkWidget * file_open_dialog_create (Gimp *gimp,
GimpMenuFactory *menu_factory);
static void file_open_selchanged_callback (GtkTreeSelection *sel,
GtkWidget *open_dialog);
static void file_open_imagefile_info_changed (GimpImagefile *imagefile,
@ -107,77 +106,28 @@ static PlugInProcDef *load_file_proc = NULL;
/* public functions */
void
file_open_dialog_menu_init (Gimp *gimp,
GimpItemFactory *item_factory)
file_open_dialog_set_type (PlugInProcDef *proc)
{
GimpItemFactoryEntry entry;
PlugInProcDef *file_proc;
GSList *list;
if (proc)
file_dialog_update_name (proc, GTK_FILE_SELECTION (fileload));
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_ITEM_FACTORY (item_factory));
gimp->load_procs = g_slist_reverse (gimp->load_procs);
for (list = gimp->load_procs; list; list = g_slist_next (list))
{
gchar *basename;
gchar *lowercase_basename;
gchar *help_page;
file_proc = (PlugInProcDef *) list->data;
basename = g_path_get_basename (file_proc->prog);
lowercase_basename = g_ascii_strdown (basename, -1);
g_free (basename);
/* NOT g_build_filename() because this is a relative URI */
help_page = g_strconcat ("filters/",
lowercase_basename,
".html",
NULL);
g_free (lowercase_basename);
entry.entry.path = strstr (file_proc->menu_path, "/");
entry.entry.accelerator = NULL;
entry.entry.callback = file_open_type_callback;
entry.entry.callback_action = 0;
entry.entry.item_type = NULL;
entry.quark_string = NULL;
entry.help_page = help_page;
entry.description = NULL;
gimp_item_factory_create_item (item_factory,
&entry,
NULL,
file_proc, 2,
TRUE, FALSE);
g_free (help_page);
}
load_file_proc = proc;
}
void
file_open_dialog_menu_reset (void)
{
load_file_proc = NULL;
}
void
file_open_dialog_show (Gimp *gimp,
GimpImage *gimage,
const gchar *uri)
file_open_dialog_show (Gimp *gimp,
GimpImage *gimage,
const gchar *uri,
GimpMenuFactory *menu_factory)
{
gchar *filename = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
if (! fileload)
fileload = file_open_dialog_create (gimp);
fileload = file_open_dialog_create (gimp, menu_factory);
gtk_widget_set_sensitive (GTK_WIDGET (fileload), TRUE);
@ -223,14 +173,15 @@ file_open_dialog_show (Gimp *gimp,
/* private functions */
static GtkWidget *
file_open_dialog_create (Gimp *gimp)
file_open_dialog_create (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
GtkWidget *open_dialog;
GtkFileSelection *fs;
GtkTreeSelection *tree_sel;
open_dialog = file_dialog_new (gimp,
gimp_item_factory_from_path ("<Load>"),
menu_factory, "<Load>",
_("Open Image"), "open_image",
"open/dialogs/file_open.html",
G_CALLBACK (file_open_ok_callback));
@ -402,17 +353,6 @@ file_open_dialog_create (Gimp *gimp)
return open_dialog;
}
static void
file_open_type_callback (GtkWidget *widget,
gpointer data)
{
PlugInProcDef *proc = (PlugInProcDef *) data;
file_dialog_update_name (proc, GTK_FILE_SELECTION (fileload));
load_file_proc = proc;
}
static void
file_open_imagefile_info_changed (GimpImagefile *imagefile,
GtkLabel *label)

11
app/gui/file-open-dialog.h
View file

@ -20,13 +20,12 @@
#define __FILE_OPEN_DIALOG_H__
void file_open_dialog_menu_init (Gimp *gimp,
GimpItemFactory *item_factory);
void file_open_dialog_menu_reset (void);
void file_open_dialog_set_type (PlugInProcDef *proc);
void file_open_dialog_show (Gimp *gimp,
GimpImage *gimage,
const gchar *uri);
void file_open_dialog_show (Gimp *gimp,
GimpImage *gimage,
const gchar *uri,
GimpMenuFactory *menu_factory);
#endif /* __FILE_OPEN_DIALOG_H__ */

122
app/gui/file-save-dialog.c
View file

@ -44,7 +44,7 @@
#include "file/file-save.h"
#include "file/file-utils.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "file-dialog-utils.h"
#include "file-save-dialog.h"
@ -54,23 +54,22 @@
/* local function prototypes */
static GtkWidget * file_save_dialog_create (Gimp *gimp);
static void file_save_type_callback (GtkWidget *widget,
gpointer data);
static void file_save_ok_callback (GtkWidget *widget,
GtkWidget *save_dialog);
static void file_save_overwrite (GtkWidget *save_dialog,
const gchar *uri,
const gchar *raw_filename);
static void file_save_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data);
static void file_save_dialog_save_image (GtkWidget *save_dialog,
GimpImage *gimage,
const gchar *uri,
const gchar *raw_filename,
PlugInProcDef *save_proc,
gboolean set_uri);
static GtkWidget * file_save_dialog_create (Gimp *gimp,
GimpMenuFactory *menu_factory);
static void file_save_ok_callback (GtkWidget *widget,
GtkWidget *save_dialog);
static void file_save_overwrite (GtkWidget *save_dialog,
const gchar *uri,
const gchar *raw_filename);
static void file_save_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data);
static void file_save_dialog_save_image (GtkWidget *save_dialog,
GimpImage *gimage,
const gchar *uri,
const gchar *raw_filename,
PlugInProcDef *save_proc,
gboolean set_uri);
static GtkWidget *filesave = NULL;
@ -83,71 +82,22 @@ static gboolean set_uri = TRUE;
/* public functions */
void
file_save_dialog_menu_init (Gimp *gimp,
GimpItemFactory *item_factory)
file_save_dialog_set_type (PlugInProcDef *proc)
{
GimpItemFactoryEntry entry;
PlugInProcDef *file_proc;
GSList *list;
if (proc)
file_dialog_update_name (proc, GTK_FILE_SELECTION (filesave));
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_ITEM_FACTORY (item_factory));
gimp->save_procs = g_slist_reverse (gimp->save_procs);
for (list = gimp->save_procs; list; list = g_slist_next (list))
{
gchar *basename;
gchar *lowercase_basename;
gchar *help_page;
file_proc = (PlugInProcDef *) list->data;
basename = g_path_get_basename (file_proc->prog);
lowercase_basename = g_ascii_strdown (basename, -1);
g_free (basename);
/* NOT g_build_filename() because this is a relative URI */
help_page = g_strconcat ("filters/",
lowercase_basename,
".html",
NULL);
g_free (lowercase_basename);
entry.entry.path = strstr (file_proc->menu_path, "/");
entry.entry.accelerator = NULL;
entry.entry.callback = file_save_type_callback;
entry.entry.callback_action = 0;
entry.entry.item_type = NULL;
entry.quark_string = NULL;
entry.help_page = help_page;
entry.description = NULL;
gimp_item_factory_create_item (item_factory,
&entry,
NULL,
file_proc, 2,
TRUE, FALSE);
g_free (help_page);
}
save_file_proc = proc;
}
void
file_save_dialog_menu_reset (void)
{
save_file_proc = NULL;
}
void
file_save_dialog_show (GimpImage *gimage)
file_save_dialog_show (GimpImage *gimage,
GimpMenuFactory *menu_factory)
{
gchar *filename;
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
if (! gimp_image_active_drawable (gimage))
return;
@ -156,7 +106,7 @@ file_save_dialog_show (GimpImage *gimage)
set_uri = TRUE;
if (! filesave)
filesave = file_save_dialog_create (gimage->gimp);
filesave = file_save_dialog_create (gimage->gimp, menu_factory);
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
@ -184,12 +134,14 @@ file_save_dialog_show (GimpImage *gimage)
}
void
file_save_a_copy_dialog_show (GimpImage *gimage)
file_save_a_copy_dialog_show (GimpImage *gimage,
GimpMenuFactory *menu_factory)
{
const gchar *uri;
gchar *filename = NULL;
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
if (! gimp_image_active_drawable (gimage))
return;
@ -203,7 +155,7 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
filename = g_filename_from_uri (uri, NULL, NULL);
if (! filesave)
filesave = file_save_dialog_create (gimage->gimp);
filesave = file_save_dialog_create (gimage->gimp, menu_factory);
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
@ -230,26 +182,16 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
/* private functions */
static GtkWidget *
file_save_dialog_create (Gimp *gimp)
file_save_dialog_create (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
return file_dialog_new (gimp,
gimp_item_factory_from_path ("<Save>"),
menu_factory, "<Save>",
_("Save Image"), "save_image",
"save/dialogs/file_save.html",
G_CALLBACK (file_save_ok_callback));
}
static void
file_save_type_callback (GtkWidget *widget,
gpointer data)
{
PlugInProcDef *proc = (PlugInProcDef *) data;
file_dialog_update_name (proc, GTK_FILE_SELECTION (filesave));
save_file_proc = proc;
}
static void
file_save_ok_callback (GtkWidget *widget,
GtkWidget *save_dialog)

10
app/gui/file-save-dialog.h
View file

@ -20,12 +20,12 @@
#define __FILE_SAVE_DIALOG_H__
void file_save_dialog_menu_init (Gimp *gimp,
GimpItemFactory *item_factory);
void file_save_dialog_menu_reset (void);
void file_save_dialog_set_type (PlugInProcDef *proc);
void file_save_dialog_show (GimpImage *gimage);
void file_save_a_copy_dialog_show (GimpImage *gimage);
void file_save_dialog_show (GimpImage *gimage,
GimpMenuFactory *menu_factory);
void file_save_a_copy_dialog_show (GimpImage *gimage,
GimpMenuFactory *menu_factory);
#endif /* __FILE_SAVE_DIALOG_H__ */

17
app/gui/gradient-select.c
View file

@ -36,10 +36,10 @@
#include "pdb/procedural_db.h"
#include "widgets/gimpdatafactoryview.h"
#include "widgets/gimpitemfactory.h"
#include "dialogs-constructors.h"
#include "gradient-select.h"
#include "menus.h"
#include "libgimp/gimpintl.h"
@ -126,14 +126,13 @@ gradient_select_new (Gimp *gimp,
NULL);
/* the gradient list */
gsp->view =
gimp_data_factory_view_new (GIMP_VIEW_TYPE_LIST,
gsp->context->gimp->gradient_factory,
dialogs_edit_gradient_func,
gsp->context,
GIMP_PREVIEW_SIZE_EXTRA_SMALL,
6, 6,
gimp_item_factory_from_path ("<Gradients>"));
gsp->view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_LIST,
gsp->context->gimp->gradient_factory,
dialogs_edit_gradient_func,
gsp->context,
GIMP_PREVIEW_SIZE_EXTRA_SMALL,
6, 6,
global_menu_factory, "<Gradients>");
gtk_container_set_border_width (GTK_CONTAINER (gsp->view), 4);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (gsp->shell)->vbox), gsp->view);

48
app/gui/gui.c
View file

@ -45,14 +45,13 @@
#include "widgets/gimpdevices.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "widgets/gimpwidgets-utils.h"
#include "device-status-dialog.h"
#include "dialogs.h"
#include "dialogs-commands.h"
#include "error-console-dialog.h"
#include "file-open-dialog.h"
#include "file-save-dialog.h"
#include "gui.h"
#include "menus.h"
#include "session.h"
@ -101,6 +100,10 @@ static GQuark image_disconnect_handler_id = 0;
static GHashTable *themes_hash = NULL;
static GimpItemFactory *toolbox_item_factory = NULL;
static GimpItemFactory *image_item_factory = NULL;
static GimpItemFactory *paths_item_factory = NULL;
/* public functions */
@ -285,10 +288,23 @@ gui_restore (Gimp *gimp,
gimp->message_handler = GIMP_MESSAGE_BOX;
file_open_dialog_menu_init (gimp, gimp_item_factory_from_path ("<Load>"));
file_save_dialog_menu_init (gimp, gimp_item_factory_from_path ("<Save>"));
toolbox_item_factory = gimp_menu_factory_menu_new (global_menu_factory,
"<Toolbox>",
GTK_TYPE_MENU_BAR,
gimp,
TRUE);
menus_restore (gimp);
image_item_factory = gimp_menu_factory_menu_new (global_menu_factory,
"<Image>",
GTK_TYPE_MENU,
gimp,
TRUE);
paths_item_factory = gimp_menu_factory_menu_new (global_menu_factory,
"<Paths>",
GTK_TYPE_MENU,
gimp,
FALSE);
gimp_devices_restore (gimp);
@ -425,14 +441,16 @@ static GimpObject *
gui_display_new (GimpImage *gimage,
guint scale)
{
GimpDisplay *gdisp;
GimpDisplayShell *shell;
GimpDisplay *gdisp;
gdisp = gimp_display_new (gimage, scale);
gdisp = gimp_display_new (gimage, scale,
global_menu_factory,
image_item_factory);
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
gimp_display_shell_set_menu_sensitivity (shell, gimage->gimp, FALSE);
gimp_item_factory_update (shell->menubar_factory, shell);
gimp_context_set_display (gimp_get_user_context (gimage->gimp), gdisp);
@ -553,6 +571,15 @@ static gboolean
gui_exit_finish_callback (Gimp *gimp,
gboolean kill_it)
{
g_object_unref (toolbox_item_factory);
toolbox_item_factory = NULL;
g_object_unref (image_item_factory);
image_item_factory = NULL;
g_object_unref (paths_item_factory);
paths_item_factory = NULL;
menus_exit (gimp);
render_exit (gimp);
@ -624,12 +651,15 @@ gui_display_changed (GimpContext *context,
GimpDisplay *display,
Gimp *gimp)
{
GimpItemFactory *item_factory;
GimpDisplayShell *shell = NULL;
item_factory = gimp_item_factory_from_path ("<Image>");
if (display)
shell = GIMP_DISPLAY_SHELL (display->shell);
gimp_display_shell_set_menu_sensitivity (shell, gimp, TRUE);
gimp_item_factory_update (item_factory, shell);
}
static void

2
app/gui/image-commands.c
View file

@ -254,6 +254,8 @@ image_flatten_image_cmd_callback (GtkWidget *widget,
gimp_image_flatten (gimage);
gimp_image_flush (gimage);
}
/****************************/
/* The layer merge dialog */
/****************************/

769
app/gui/menus.c
View file

@ -39,14 +39,19 @@
#include "file/file-utils.h"
#include "plug-in/plug-ins.h"
#include "plug-in/plug-in-proc.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "display/gimpdisplayshell.h"
#include "brushes-commands.h"
#include "buffers-commands.h"
#include "channels-commands.h"
#include "colormap-editor-commands.h"
#include "data-commands.h"
#include "debug-commands.h"
#include "dialogs-commands.h"
#include "documents-commands.h"
#include "drawable-commands.h"
@ -75,9 +80,6 @@
#include "libgimp/gimpintl.h"
#define ENABLE_DEBUG_ENTRIES 1
/* local function prototypes */
static void menus_last_opened_add (GimpItemFactory *item_factory,
@ -96,17 +98,6 @@ static void menus_background_changed (GimpContext *context,
const GimpRGB *color,
GimpItemFactory *item_factory);
static void menus_filters_subdirs_to_top (GtkMenu *menu);
#ifdef ENABLE_DEBUG_ENTRIES
static void menus_debug_recurse_menu (GtkWidget *menu,
gint depth,
gchar *path);
static void menus_debug_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
static void menus_mem_profile_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
#endif /* ENABLE_DEBUG_ENTRIES */
#define SEPARATOR(path) \
@ -260,10 +251,10 @@ static GimpItemFactoryEntry toolbox_entries[] =
NULL, NULL, NULL },
{ { "/File/Debug/Mem Profile", NULL,
menus_mem_profile_cmd_callback, 0 },
debug_mem_profile_cmd_callback, 0 },
NULL, NULL, NULL },
{ { "/File/Debug/Dump Items", NULL,
menus_debug_cmd_callback, 0 },
debug_dump_menus_cmd_callback, 0 },
NULL, NULL, NULL },
{ { "/File/Debug/Serialize User Context", NULL,
test_serialize_context_cmd_callback, 0 },
@ -2046,10 +2037,10 @@ static GimpItemFactoryEntry qmask_entries[] =
SEPARATOR ("/---"),
{ { N_("/Mask Selected Areas"), NULL,
qmask_invert_cmd_callback, FALSE, "<RadioItem>" },
qmask_invert_cmd_callback, TRUE, "<RadioItem>" },
NULL, NULL, NULL },
{ { N_("/Mask Unselected Areas"), NULL,
qmask_invert_cmd_callback, TRUE, "/Mask Selected Areas" },
qmask_invert_cmd_callback, FALSE, "/Mask Selected Areas" },
NULL, NULL, NULL },
SEPARATOR ("/---"),
@ -2060,38 +2051,81 @@ static GimpItemFactoryEntry qmask_entries[] =
};
static gboolean menus_initialized = FALSE;
static GList *all_factories = NULL;
/* GimpItemFactory setup functions */
/* public functions */
GimpItemFactory *
menus_get_new_image_factory (Gimp *gimp,
gpointer callback_data,
gboolean menu_bar)
static void
menus_toolbox_factory_setup (GimpItemFactory *factory)
{
GimpItemFactory *image_factory;
static gchar *reorder_subsubmenus[] = { "/Xtns" };
image_factory = gimp_item_factory_new (gimp,
menu_bar ?
GTK_TYPE_MENU_BAR : GTK_TYPE_MENU,
"<Image>", "image",
NULL,
G_N_ELEMENTS (image_entries),
image_entries,
callback_data,
TRUE);
GtkWidget *menu_item;
GtkWidget *menu;
GList *list;
gint i, pos;
if (menu_bar)
menus_last_opened_add (factory, factory->gimp);
plug_in_make_menu (factory, proc_defs);
/* Move all menu items under "<Toolbox>/Xtns" which are not submenus or
* separators to the top of the menu
*/
pos = 1;
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
"/Xtns/Module Browser...");
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
{
gimp_item_factory_set_visible (GTK_ITEM_FACTORY (image_factory),
menu = menu_item->parent;
for (list = g_list_nth (GTK_MENU_SHELL (menu)->children, pos); list;
list = g_list_next (list))
{
menu_item = GTK_WIDGET (list->data);
if (! GTK_MENU_ITEM (menu_item)->submenu &&
GTK_IS_LABEL (GTK_BIN (menu_item)->child))
{
gtk_menu_reorder_child (GTK_MENU (menu_item->parent),
menu_item, pos);
list = g_list_nth (GTK_MENU_SHELL (menu)->children, pos);
pos++;
}
}
}
for (i = 0; i < G_N_ELEMENTS (reorder_subsubmenus); i++)
{
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
reorder_subsubmenus[i]);
if (menu && GTK_IS_MENU (menu))
{
for (list = GTK_MENU_SHELL (menu)->children; list;
list = g_list_next (list))
{
GtkMenuItem *menu_item;
menu_item = GTK_MENU_ITEM (list->data);
if (menu_item->submenu)
menus_filters_subdirs_to_top (GTK_MENU (menu_item->submenu));
}
}
}
}
static void
menus_image_factory_setup (GimpItemFactory *factory)
{
if (GTK_IS_MENU_BAR (GTK_ITEM_FACTORY (factory)->widget))
{
gimp_item_factory_set_visible (GTK_ITEM_FACTORY (factory),
"/tearoff1", FALSE);
gimp_item_factory_set_visible (GTK_ITEM_FACTORY (image_factory),
gimp_item_factory_set_visible (GTK_ITEM_FACTORY (factory),
"/filters-separator", FALSE);
}
menus_last_opened_add (image_factory, gimp);
menus_last_opened_add (factory, factory->gimp);
/* create tool menu items */
{
@ -2106,7 +2140,7 @@ menus_get_new_image_factory (Gimp *gimp,
GList *list;
gint i;
for (list = GIMP_LIST (gimp->tool_info_list)->list;
for (list = GIMP_LIST (factory->gimp->tool_info_list)->list;
list;
list = g_list_next (list))
{
@ -2126,7 +2160,7 @@ menus_get_new_image_factory (Gimp *gimp,
entry.help_page = tool_info->help_data;
entry.description = NULL;
gimp_item_factory_create_item (image_factory,
gimp_item_factory_create_item (factory,
&entry,
NULL,
tool_info, 2,
@ -2136,10 +2170,10 @@ menus_get_new_image_factory (Gimp *gimp,
/* reorder <Image>/Image/Colors */
tool_info = (GimpToolInfo *)
gimp_container_get_child_by_name (gimp->tool_info_list,
gimp_container_get_child_by_name (factory->gimp->tool_info_list,
"gimp-posterize-tool");
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
tool_info->menu_path);
if (menu_item && menu_item->parent)
gtk_menu_reorder_child (GTK_MENU (menu_item->parent), menu_item, 4);
@ -2147,10 +2181,10 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (color_tools); i++)
{
tool_info = (GimpToolInfo *)
gimp_container_get_child_by_name (gimp->tool_info_list,
gimp_container_get_child_by_name (factory->gimp->tool_info_list,
color_tools[i]);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
tool_info->menu_path);
if (menu_item && menu_item->parent)
{
@ -2165,23 +2199,23 @@ menus_get_new_image_factory (Gimp *gimp,
GimpRGB fg;
GimpRGB bg;
user_context = gimp_get_user_context (gimp);
user_context = gimp_get_user_context (factory->gimp);
g_signal_connect_object (user_context, "foreground_changed",
G_CALLBACK (menus_foreground_changed),
image_factory, 0);
factory, 0);
g_signal_connect_object (user_context, "background_changed",
G_CALLBACK (menus_background_changed),
image_factory, 0);
factory, 0);
gimp_context_get_foreground (user_context, &fg);
gimp_context_get_background (user_context, &bg);
menus_foreground_changed (user_context, &fg, image_factory);
menus_background_changed (user_context, &bg, image_factory);
menus_foreground_changed (user_context, &fg, factory);
menus_background_changed (user_context, &bg, factory);
}
plug_in_make_menu (image_factory, proc_defs);
plug_in_make_menu (factory, proc_defs);
{
static gchar *rotate_plugins[] = { "Rotate 90 degrees",
@ -2204,7 +2238,7 @@ menus_get_new_image_factory (Gimp *gimp,
* separators to the top of the menu
*/
pos = 3;
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
"/Filters/Filter all Layers...");
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
{
@ -2231,7 +2265,7 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (rotate_plugins); i++)
{
path = g_strconcat ("/Image/Transform/", rotate_plugins[i], NULL);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
path);
g_free (path);
@ -2247,7 +2281,7 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (rotate_plugins); i++)
{
path = g_strconcat ("/Layer/Transform/", rotate_plugins[i], NULL);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
path);
g_free (path);
@ -2263,7 +2297,7 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (image_file_entries); i++)
{
path = g_strconcat ("/File/", image_file_entries[i], NULL);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
path);
g_free (path);
@ -2274,7 +2308,7 @@ menus_get_new_image_factory (Gimp *gimp,
/* Reorder menus where plugins registered submenus */
for (i = 0; i < G_N_ELEMENTS (reorder_submenus); i++)
{
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
reorder_submenus[i]);
if (menu && GTK_IS_MENU (menu))
@ -2283,7 +2317,7 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (reorder_subsubmenus); i++)
{
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
reorder_subsubmenus[i]);
if (menu && GTK_IS_MENU (menu))
@ -2304,7 +2338,7 @@ menus_get_new_image_factory (Gimp *gimp,
/* Move all submenus which registered after "<Image>/Filters/Toys"
* before the separator after "<Image>/Filters/Web"
*/
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
"/Filters/---INSERT");
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
@ -2312,7 +2346,7 @@ menus_get_new_image_factory (Gimp *gimp,
menu = menu_item->parent;
pos = g_list_index (GTK_MENU_SHELL (menu)->children, menu_item);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
"/Filters/Toys");
if (menu_item && GTK_IS_MENU (menu_item))
@ -2340,186 +2374,250 @@ menus_get_new_image_factory (Gimp *gimp,
}
}
}
return image_factory;
}
static void
menus_open_factory_setup (GimpItemFactory *factory)
{
GimpItemFactoryEntry entry;
PlugInProcDef *file_proc;
GSList *list;
factory->gimp->load_procs = g_slist_reverse (factory->gimp->load_procs);
for (list = factory->gimp->load_procs; list; list = g_slist_next (list))
{
gchar *basename;
gchar *lowercase_basename;
gchar *help_page;
file_proc = (PlugInProcDef *) list->data;
basename = g_path_get_basename (file_proc->prog);
lowercase_basename = g_ascii_strdown (basename, -1);
g_free (basename);
/* NOT g_build_filename() because this is a relative URI */
help_page = g_strconcat ("filters/",
lowercase_basename,
".html",
NULL);
g_free (lowercase_basename);
entry.entry.path = strstr (file_proc->menu_path, "/");
entry.entry.accelerator = NULL;
entry.entry.callback = file_open_type_cmd_callback;
entry.entry.callback_action = 0;
entry.entry.item_type = NULL;
entry.quark_string = NULL;
entry.help_page = help_page;
entry.description = NULL;
gimp_item_factory_create_item (factory,
&entry,
NULL,
file_proc, 2,
TRUE, FALSE);
g_free (help_page);
}
}
static void
menus_save_factory_setup (GimpItemFactory *factory)
{
GimpItemFactoryEntry entry;
PlugInProcDef *file_proc;
GSList *list;
factory->gimp->save_procs = g_slist_reverse (factory->gimp->save_procs);
for (list = factory->gimp->save_procs; list; list = g_slist_next (list))
{
gchar *basename;
gchar *lowercase_basename;
gchar *help_page;
file_proc = (PlugInProcDef *) list->data;
basename = g_path_get_basename (file_proc->prog);
lowercase_basename = g_ascii_strdown (basename, -1);
g_free (basename);
/* NOT g_build_filename() because this is a relative URI */
help_page = g_strconcat ("filters/",
lowercase_basename,
".html",
NULL);
g_free (lowercase_basename);
entry.entry.path = strstr (file_proc->menu_path, "/");
entry.entry.accelerator = NULL;
entry.entry.callback = file_save_type_cmd_callback;
entry.entry.callback_action = 0;
entry.entry.item_type = NULL;
entry.quark_string = NULL;
entry.help_page = help_page;
entry.description = NULL;
gimp_item_factory_create_item (factory,
&entry,
NULL,
file_proc, 2,
TRUE, FALSE);
g_free (help_page);
}
}
/* The item factories to register with the global_menu_factory */
static const GimpMenuFactoryEntry factory_entries[] =
{
{
"<Toolbox>", "toolbox",
menus_toolbox_factory_setup, NULL, FALSE,
G_N_ELEMENTS (toolbox_entries), toolbox_entries
},
{
"<Image>", "image",
menus_image_factory_setup, gimp_display_shell_menu_update, FALSE,
G_N_ELEMENTS (image_entries), image_entries
},
{
"<Load>", "open",
menus_open_factory_setup, NULL, FALSE,
G_N_ELEMENTS (load_entries), load_entries
},
{
"<Save>", "save",
menus_save_factory_setup, NULL, FALSE,
G_N_ELEMENTS (save_entries), save_entries
},
{
"<Layers>", "layers",
NULL, layers_menu_update, TRUE,
G_N_ELEMENTS (layers_entries), layers_entries
},
{
"<Channels>", "channels",
NULL, channels_menu_update, TRUE,
G_N_ELEMENTS (channels_entries), channels_entries
},
{
"<Vectors>", "vectors",
NULL, vectors_menu_update, TRUE,
G_N_ELEMENTS (vectors_entries), vectors_entries
},
{
"<Paths>", "paths",
NULL, NULL, FALSE,
G_N_ELEMENTS (paths_entries), paths_entries
},
{
"<Dialogs>", "dialogs",
NULL, dialogs_menu_update, TRUE,
G_N_ELEMENTS (dialogs_entries), dialogs_entries
},
{
"<Brushes>", "brushes",
NULL, brushes_menu_update, TRUE,
G_N_ELEMENTS (brushes_entries), brushes_entries
},
{
"<Patterns>", "patterns",
NULL, patterns_menu_update, TRUE,
G_N_ELEMENTS (patterns_entries), patterns_entries
},
{
"<Gradients>", "gradients",
NULL, gradients_menu_update, TRUE,
G_N_ELEMENTS (gradients_entries), gradients_entries
},
{
"<Palettes>", "palettes",
NULL, palettes_menu_update, TRUE,
G_N_ELEMENTS (palettes_entries), palettes_entries
},
{
"<Buffers>", "buffers",
NULL, buffers_menu_update, TRUE,
G_N_ELEMENTS (buffers_entries), buffers_entries
},
{
"<Documents>", "documents",
NULL, documents_menu_update, TRUE,
G_N_ELEMENTS (documents_entries), documents_entries
},
{
"<Images>", "images",
NULL, images_menu_update, TRUE,
G_N_ELEMENTS (images_entries), images_entries
},
{
"<GradientEditor>", "gradient_editor",
NULL, gradient_editor_menu_update, TRUE,
G_N_ELEMENTS (gradient_editor_entries), gradient_editor_entries
},
{
"<PaletteEditor>", "palette_editor",
NULL, palette_editor_menu_update, TRUE,
G_N_ELEMENTS (palette_editor_entries), palette_editor_entries
},
{
"<ColormapEditor>", "colormap_editor",
NULL, colormap_editor_menu_update, TRUE,
G_N_ELEMENTS (colormap_editor_entries), colormap_editor_entries
},
{
"<QMask>", "qmask",
NULL, qmask_menu_update, TRUE,
G_N_ELEMENTS (qmask_entries), qmask_entries
}
};
static gboolean menus_initialized = FALSE;
GimpMenuFactory *global_menu_factory = NULL;
/* public functions */
void
menus_init (Gimp *gimp)
{
GimpItemFactory *toolbox_factory;
gchar *filename;
gchar *filename;
gint i;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (menus_initialized == FALSE);
menus_initialized = TRUE;
#define ADD_FACTORY(f) (all_factories = g_list_append (all_factories, (f)));
global_menu_factory = gimp_menu_factory_new (gimp);
toolbox_factory = gimp_item_factory_new (gimp,
GTK_TYPE_MENU_BAR,
"<Toolbox>", "toolbox",
NULL,
G_N_ELEMENTS (toolbox_entries),
toolbox_entries,
gimp,
TRUE);
menus_last_opened_add (toolbox_factory, gimp);
ADD_FACTORY (toolbox_factory);
ADD_FACTORY (menus_get_new_image_factory (gimp, gimp, FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Load>", "open",
NULL,
G_N_ELEMENTS (load_entries),
load_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Save>", "save",
NULL,
G_N_ELEMENTS (save_entries),
save_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Layers>", "layers",
layers_menu_update,
G_N_ELEMENTS (layers_entries),
layers_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Channels>", "channels",
channels_menu_update,
G_N_ELEMENTS (channels_entries),
channels_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Vectors>", "vectors",
vectors_menu_update,
G_N_ELEMENTS (vectors_entries),
vectors_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Paths>", "paths",
NULL,
G_N_ELEMENTS (paths_entries),
paths_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Dialogs>", "dialogs",
dialogs_menu_update,
G_N_ELEMENTS (dialogs_entries),
dialogs_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Brushes>", "brushes",
brushes_menu_update,
G_N_ELEMENTS (brushes_entries),
brushes_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Patterns>", "patterns",
patterns_menu_update,
G_N_ELEMENTS (patterns_entries),
patterns_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<GradientEditor>", "gradient_editor",
gradient_editor_menu_update,
G_N_ELEMENTS (gradient_editor_entries),
gradient_editor_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Gradients>", "gradients",
gradients_menu_update,
G_N_ELEMENTS (gradients_entries),
gradients_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<PaletteEditor>", "palette_editor",
palette_editor_menu_update,
G_N_ELEMENTS (palette_editor_entries),
palette_editor_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Palettes>", "palettes",
palettes_menu_update,
G_N_ELEMENTS (palettes_entries),
palettes_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Buffers>", "buffers",
buffers_menu_update,
G_N_ELEMENTS (buffers_entries),
buffers_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Documents>", "documents",
documents_menu_update,
G_N_ELEMENTS (documents_entries),
documents_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Images>", "images",
images_menu_update,
G_N_ELEMENTS (images_entries),
images_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<ColormapEditor>", "colormap_editor",
colormap_editor_menu_update,
G_N_ELEMENTS (colormap_editor_entries),
colormap_editor_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<QMask>", "qmask",
qmask_menu_update,
G_N_ELEMENTS (qmask_entries),
qmask_entries,
gimp,
FALSE));
for (i = 0; i < G_N_ELEMENTS (factory_entries); i++)
{
gimp_menu_factory_menu_register (global_menu_factory,
factory_entries[i].identifier,
factory_entries[i].help_path,
factory_entries[i].setup_func,
factory_entries[i].update_func,
factory_entries[i].update_on_popup,
factory_entries[i].n_entries,
factory_entries[i].entries);
}
filename = gimp_personal_rc_file ("menurc");
gtk_accel_map_load (filename);
g_free (filename);
#undef ADD_FACTORY
}
void
@ -2533,72 +2631,8 @@ menus_exit (Gimp *gimp)
gtk_accel_map_save (filename);
g_free (filename);
g_list_foreach (all_factories, (GFunc) g_object_unref, NULL);
g_list_free (all_factories);
all_factories = NULL;
}
void
menus_restore (Gimp *gimp)
{
static gchar *reorder_subsubmenus[] = { "<Toolbox>/Xtns" };
GimpItemFactory *item_factory;
GtkWidget *menu_item;
GtkWidget *menu;
GList *list;
gint i, pos;
g_return_if_fail (GIMP_IS_GIMP (gimp));
/* Move all menu items under "<Toolbox>/Xtns" which are not submenus or
* separators to the top of the menu
*/
pos = 1;
item_factory = gimp_item_factory_from_path ("<Toolbox>");
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (item_factory),
"/Xtns/Module Browser...");
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
{
menu = menu_item->parent;
for (list = g_list_nth (GTK_MENU_SHELL (menu)->children, pos); list;
list = g_list_next (list))
{
menu_item = GTK_WIDGET (list->data);
if (! GTK_MENU_ITEM (menu_item)->submenu &&
GTK_IS_LABEL (GTK_BIN (menu_item)->child))
{
gtk_menu_reorder_child (GTK_MENU (menu_item->parent),
menu_item, pos);
list = g_list_nth (GTK_MENU_SHELL (menu)->children, pos);
pos++;
}
}
}
for (i = 0; i < G_N_ELEMENTS (reorder_subsubmenus); i++)
{
item_factory = gimp_item_factory_from_path (reorder_subsubmenus[i]);
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (item_factory),
reorder_subsubmenus[i]);
if (menu && GTK_IS_MENU (menu))
{
for (list = GTK_MENU_SHELL (menu)->children; list;
list = g_list_next (list))
{
GtkMenuItem *menu_item;
menu_item = GTK_MENU_ITEM (list->data);
if (menu_item->submenu)
menus_filters_subdirs_to_top (GTK_MENU (menu_item->submenu));
}
}
}
g_object_unref (global_menu_factory);
global_menu_factory = NULL;
}
@ -2805,156 +2839,3 @@ menus_filters_subdirs_to_top (GtkMenu *menu)
gtk_widget_show (separator);
}
}
#ifdef ENABLE_DEBUG_ENTRIES
static void
menus_debug_recurse_menu (GtkWidget *menu,
gint depth,
gchar *path)
{
GtkItemFactory *item_factory;
GtkWidget *menu_item;
GList *list;
const gchar *label;
gchar *help_page;
gchar *help_path;
gchar *factory_path;
gchar *hash;
gchar *full_path;
gchar *format_str;
for (list = GTK_MENU_SHELL (menu)->children; list; list = g_list_next (list))
{
menu_item = GTK_WIDGET (list->data);
if (GTK_IS_LABEL (GTK_BIN (menu_item)->child))
{
label = gtk_label_get_text (GTK_LABEL (GTK_BIN (menu_item)->child));
full_path = g_strconcat (path, "/", label, NULL);
item_factory = GTK_ITEM_FACTORY (gimp_item_factory_from_path (path));
help_page = g_object_get_data (G_OBJECT (menu_item), "help_page");
if (item_factory)
{
factory_path = g_object_get_data (G_OBJECT (item_factory),
"factory_path");
if (factory_path)
{
help_page = g_build_filename (factory_path, help_page, NULL);
}
else
{
help_page = g_strdup (help_page);
}
}
else
{
help_page = g_strdup (help_page);
}
if (help_page)
{
help_path = g_build_filename (gimp_data_directory (),
"help", "C", help_page, NULL);
if ((hash = strchr (help_path, '#')) != NULL)
*hash = '\0';
if (g_file_test (help_path, G_FILE_TEST_EXISTS))
{
g_free (help_path);
help_path = g_strconcat ("! ", help_page, NULL);
g_free (help_page);
help_page = help_path;
}
else
{
g_free (help_path);
}
}
format_str = g_strdup_printf ("%%%ds%%%ds %%-20s %%s\n",
depth * 2, depth * 2 - 40);
g_print (format_str,
"", label, "", help_page ? help_page : "");
g_free (format_str);
g_free (help_page);
if (GTK_MENU_ITEM (menu_item)->submenu)
menus_debug_recurse_menu (GTK_MENU_ITEM (menu_item)->submenu,
depth + 1, full_path);
g_free (full_path);
}
}
}
static void
menus_debug_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
#if 0
gint n_factories = 7;
GtkItemFactory *factories[7];
GimpItemFactoryEntry *entries[7];
GtkWidget *menu_item;
gint i;
factories[0] = GTK_ITEM_FACTORY (toolbox_factory);
factories[1] = GTK_ITEM_FACTORY (image_factory);
factories[2] = GTK_ITEM_FACTORY (layers_factory);
factories[3] = GTK_ITEM_FACTORY (channels_factory);
factories[4] = GTK_ITEM_FACTORY (paths_factory);
factories[5] = GTK_ITEM_FACTORY (load_factory);
factories[6] = GTK_ITEM_FACTORY (save_factory);
entries[0] = toolbox_entries;
entries[1] = image_entries;
entries[2] = layers_entries;
entries[3] = channels_entries;
entries[4] = paths_entries;
entries[5] = load_entries;
entries[6] = save_entries;
/* toolbox needs special treatment */
g_print ("%s\n", factories[0]->path);
menu_item = gtk_item_factory_get_item (factories[0], "/File");
if (menu_item && menu_item->parent && GTK_IS_MENU_BAR (menu_item->parent))
menus_debug_recurse_menu (menu_item->parent, 1, factories[0]->path);
g_print ("\n");
for (i = 1; i < n_factories; i++)
{
g_print ("%s\n", factories[i]->path);
menu_item = gtk_item_factory_get_item (factories[i], entries[i][0].entry.path);
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
menus_debug_recurse_menu (menu_item->parent, 1, factories[i]->path);
g_print ("\n");
}
#endif
}
static void
menus_mem_profile_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
extern gboolean gimp_debug_memsize;
gimp_debug_memsize = TRUE;
gimp_object_get_memsize (GIMP_OBJECT (data));
gimp_debug_memsize = FALSE;
}
#endif /* ENABLE_DEBUG_ENTRIES */

12
app/gui/menus.h
View file

@ -20,17 +20,11 @@
#define __MENUS_H__
void menus_init (Gimp *gimp);
void menus_exit (Gimp *gimp);
void menus_restore (Gimp *gimp);
extern GimpMenuFactory *global_menu_factory;
/* FIXME: remove this and add a GimpMenuFactory class which produces
* GimpItemFactories on demand
*/
GimpItemFactory * menus_get_new_image_factory (Gimp *gimp,
gpointer callback_data,
gboolean menu_bar);
void menus_init (Gimp *gimp);
void menus_exit (Gimp *gimp);
#endif /* __MENUS_H__ */

17
app/gui/palette-select.c
View file

@ -36,9 +36,9 @@
#include "pdb/procedural_db.h"
#include "widgets/gimpdatafactoryview.h"
#include "widgets/gimpitemfactory.h"
#include "dialogs-constructors.h"
#include "menus.h"
#include "palette-select.h"
#include "libgimp/gimpintl.h"
@ -127,14 +127,13 @@ palette_select_new (Gimp *gimp,
NULL);
/* The Palette List */
psp->view =
gimp_data_factory_view_new (GIMP_VIEW_TYPE_LIST,
gimp->palette_factory,
dialogs_edit_palette_func,
psp->context,
32,
5, 3,
gimp_item_factory_from_path ("<Palettes>"));
psp->view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_LIST,
gimp->palette_factory,
dialogs_edit_palette_func,
psp->context,
32,
5, 3,
global_menu_factory, "<Palettes>");
gtk_container_set_border_width (GTK_CONTAINER (psp->view), 4);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (psp->shell)->vbox), psp->view);

19
app/gui/pattern-select.c
View file

@ -37,8 +37,8 @@
#include "pdb/procedural_db.h"
#include "widgets/gimpdatafactoryview.h"
#include "widgets/gimpitemfactory.h"
#include "menus.h"
#include "pattern-select.h"
#include "libgimp/gimpintl.h"
@ -128,15 +128,14 @@ pattern_select_new (Gimp *gimp,
NULL);
/* the pattern grid */
psp->view =
gimp_data_factory_view_new (GIMP_VIEW_TYPE_GRID,
gimp->pattern_factory,
NULL,
psp->context,
MIN_CELL_SIZE,
STD_PATTERN_COLUMNS,
STD_PATTERN_ROWS,
gimp_item_factory_from_path ("<Patterns>"));
psp->view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_GRID,
gimp->pattern_factory,
NULL,
psp->context,
MIN_CELL_SIZE,
STD_PATTERN_COLUMNS,
STD_PATTERN_ROWS,
global_menu_factory, "<Patterns>");
gtk_container_set_border_width (GTK_CONTAINER (psp->view), 4);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (psp->shell)->vbox), psp->view);

104
app/gui/plug-in-menus.c
View file

@ -54,7 +54,7 @@ struct _PlugInMenuEntry
static gboolean plug_in_menu_tree_traverse_func (gpointer foo,
PlugInMenuEntry *menu_entry,
GimpItemFactory *image_factory);
GimpItemFactory *item_factory);
static gchar * plug_in_escape_uline (const gchar *menu_path);
@ -108,15 +108,15 @@ plug_in_menus_init (GSList *plug_in_defs,
}
void
plug_in_make_menu (GimpItemFactory *image_factory,
plug_in_make_menu (GimpItemFactory *item_factory,
GSList *proc_defs)
{
PlugInProcDef *proc_def;
GSList *procs;
GTree *menu_entries;
g_return_if_fail (image_factory == NULL ||
GIMP_IS_ITEM_FACTORY (image_factory));
g_return_if_fail (item_factory == NULL ||
GIMP_IS_ITEM_FACTORY (item_factory));
g_return_if_fail (proc_defs != NULL);
menu_entries = g_tree_new_full ((GCompareDataFunc) g_utf8_collate, NULL,
@ -151,12 +151,12 @@ plug_in_make_menu (GimpItemFactory *image_factory,
g_tree_foreach (menu_entries,
(GTraverseFunc) plug_in_menu_tree_traverse_func,
image_factory);
item_factory);
g_tree_destroy (menu_entries);
}
void
plug_in_make_menu_entry (GimpItemFactory *image_factory,
plug_in_make_menu_entry (GimpItemFactory *item_factory,
PlugInProcDef *proc_def,
const gchar *domain,
const gchar *help_path)
@ -167,8 +167,8 @@ plug_in_make_menu_entry (GimpItemFactory *image_factory,
gchar *basename;
gchar *lowercase_page;
g_return_if_fail (image_factory == NULL ||
GIMP_IS_ITEM_FACTORY (image_factory));
g_return_if_fail (item_factory == NULL ||
GIMP_IS_ITEM_FACTORY (item_factory));
basename = g_path_get_basename (proc_def->prog);
@ -205,11 +205,16 @@ plug_in_make_menu_entry (GimpItemFactory *image_factory,
entry.help_page = lowercase_page;
entry.description = NULL;
if (image_factory)
if (item_factory)
{
if (! strncmp (proc_def->menu_path, "<Image>", 7))
gchar *factory_path;
factory_path = GTK_ITEM_FACTORY (item_factory)->path;
if (! strncmp (proc_def->menu_path,
factory_path, strlen (factory_path)))
{
gimp_item_factory_create_item (image_factory,
gimp_item_factory_create_item (item_factory,
&entry,
domain,
&proc_def->db_info, 2,
@ -224,7 +229,7 @@ plug_in_make_menu_entry (GimpItemFactory *image_factory,
list;
list = g_list_next (list))
{
GimpItemFactory *item_factory = list->data;
item_factory = list->data;
gimp_item_factory_create_item (item_factory,
&entry,
@ -256,15 +261,20 @@ plug_in_delete_menu_entry (const gchar *menu_path)
}
void
plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
plug_in_set_menu_sensitivity (GimpItemFactory *item_factory,
GimpImageType type)
{
PlugInProcDef *proc_def;
GSList *tmp;
gboolean sensitive = FALSE;
gchar *factory_path;
gboolean is_image_factory = FALSE;
g_return_if_fail (image_factory == NULL ||
GIMP_IS_ITEM_FACTORY (image_factory));
g_return_if_fail (GIMP_IS_ITEM_FACTORY (item_factory));
factory_path = GTK_ITEM_FACTORY (item_factory)->path;
if (! strcmp (factory_path, "<Image>"))
is_image_factory = TRUE;
for (tmp = proc_defs; tmp; tmp = g_slist_next (tmp))
{
@ -272,6 +282,8 @@ plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
if (proc_def->image_types_val && proc_def->menu_path)
{
gboolean sensitive;
switch (type)
{
case GIMP_RGB_IMAGE:
@ -297,16 +309,16 @@ plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
break;
}
if (image_factory && ! strncmp (proc_def->menu_path, "<Image>", 7))
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (image_factory),
proc_def->menu_path,
sensitive);
else
gimp_item_factories_set_sensitive (proc_def->menu_path,
if (! strncmp (proc_def->menu_path, factory_path,
strlen (factory_path)))
{
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
proc_def->menu_path,
sensitive);
}
if (last_plug_in && (last_plug_in == &proc_def->db_info))
if (is_image_factory &&
last_plug_in && (last_plug_in == &proc_def->db_info))
{
gchar *basename;
gchar *ellipses;
@ -325,37 +337,37 @@ plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
g_free (basename);
gimp_item_factories_set_label ("<Image>",
"/Filters/Repeat Last", repeat);
gimp_item_factories_set_label ("<Image>",
"/Filters/Re-Show Last", reshow);
gimp_item_factory_set_label (GTK_ITEM_FACTORY (item_factory),
"/Filters/Repeat Last", repeat);
gimp_item_factory_set_label (GTK_ITEM_FACTORY (item_factory),
"/Filters/Re-Show Last", reshow);
g_free (repeat);
g_free (reshow);
gimp_item_factories_set_sensitive ("<Image>",
"/Filters/Repeat Last",
sensitive);
gimp_item_factories_set_sensitive ("<Image>",
"/Filters/Re-Show Last",
sensitive);
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
"/Filters/Repeat Last",
sensitive);
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
"/Filters/Re-Show Last",
sensitive);
}
}
}
if (! last_plug_in)
if (is_image_factory && ! last_plug_in)
{
gimp_item_factories_set_label ("<Image>",
"/Filters/Repeat Last",
_("Repeat Last"));
gimp_item_factories_set_label ("<Image>",
"/Filters/Re-Show Last",
_("Re-Show Last"));
gimp_item_factory_set_label (GTK_ITEM_FACTORY (item_factory),
"/Filters/Repeat Last",
_("Repeat Last"));
gimp_item_factory_set_label (GTK_ITEM_FACTORY (item_factory),
"/Filters/Re-Show Last",
_("Re-Show Last"));
gimp_item_factories_set_sensitive ("<Image>",
"/Filters/Repeat Last", FALSE);
gimp_item_factories_set_sensitive ("<Image>",
"/Filters/Re-Show Last", FALSE);
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
"/Filters/Repeat Last", FALSE);
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
"/Filters/Re-Show Last", FALSE);
}
}
@ -365,9 +377,9 @@ plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
static gboolean
plug_in_menu_tree_traverse_func (gpointer foo,
PlugInMenuEntry *menu_entry,
GimpItemFactory *image_factory)
GimpItemFactory *item_factory)
{
plug_in_make_menu_entry (image_factory,
plug_in_make_menu_entry (item_factory,
menu_entry->proc_def,
menu_entry->domain,
menu_entry->help_path);

6
app/gui/plug-in-menus.h
View file

@ -23,14 +23,14 @@
void plug_in_menus_init (GSList *plug_in_defs,
const gchar *std_plugins_domain);
void plug_in_make_menu (GimpItemFactory *image_factory,
void plug_in_make_menu (GimpItemFactory *item_factory,
GSList *proc_defs);
void plug_in_make_menu_entry (GimpItemFactory *image_factory,
void plug_in_make_menu_entry (GimpItemFactory *item_factory,
PlugInProcDef *proc_def,
const gchar *locale_domain,
const gchar *help_path);
void plug_in_delete_menu_entry (const gchar *menu_path);
void plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
void plug_in_set_menu_sensitivity (GimpItemFactory *item_factory,
GimpImageType type);

48
app/gui/qmask-commands.c
View file

@ -33,7 +33,6 @@
#include "widgets/gimpcolorpanel.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpviewabledialog.h"
#include "widgets/gimpwidgets-utils.h"
#include "display/gimpdisplay.h"
#include "display/gimpdisplayshell.h"
@ -57,13 +56,13 @@ struct _EditQmaskOptions
/* local function prototypes */
static void qmask_channel_query (GimpDisplayShell *shell);
static void qmask_query_ok_callback (GtkWidget *widget,
gpointer client_data);
static void qmask_query_scale_update (GtkAdjustment *adjustment,
gpointer data);
static void qmask_query_color_changed (GimpColorButton *button,
gpointer data);
static void qmask_channel_query (GimpDisplayShell *shell);
static void qmask_query_ok_callback (GtkWidget *widget,
gpointer client_data);
static void qmask_query_scale_update (GtkAdjustment *adjustment,
gpointer data);
static void qmask_query_color_changed (GimpColorButton *button,
gpointer data);
/* public functionss */
@ -75,15 +74,15 @@ qmask_toggle_cmd_callback (GtkWidget *widget,
{
GimpDisplayShell *shell;
shell = (GimpDisplayShell *) gimp_widget_get_callback_context (widget);
shell = GIMP_DISPLAY_SHELL (data);
if (! shell)
return;
if (GTK_CHECK_MENU_ITEM (widget)->active != shell->gdisp->gimage->qmask_state)
{
gimp_image_set_qmask_state (shell->gdisp->gimage,
GTK_CHECK_MENU_ITEM (widget)->active);
gimp_image_set_qmask_state (shell->gdisp->gimage,
GTK_CHECK_MENU_ITEM (widget)->active);
gimp_image_flush (shell->gdisp->gimage);
gimp_image_flush (shell->gdisp->gimage);
}
}
void
@ -93,17 +92,17 @@ qmask_invert_cmd_callback (GtkWidget *widget,
{
GimpDisplayShell *shell;
shell = (GimpDisplayShell *) gimp_widget_get_callback_context (widget);
if (! shell)
return;
shell = GIMP_DISPLAY_SHELL (data);
if (GTK_CHECK_MENU_ITEM (widget)->active)
{
gimp_image_qmask_invert (shell->gdisp->gimage);
if (action != shell->gdisp->gimage->qmask_inverted)
{
gimp_image_qmask_invert (shell->gdisp->gimage);
if (shell->gdisp->gimage->qmask_state)
gimp_image_flush (shell->gdisp->gimage);
if (shell->gdisp->gimage->qmask_state)
gimp_image_flush (shell->gdisp->gimage);
}
}
}
@ -114,10 +113,7 @@ qmask_configure_cmd_callback (GtkWidget *widget,
{
GimpDisplayShell *shell;
shell = (GimpDisplayShell *) gimp_widget_get_callback_context (widget);
if (! shell)
return;
shell = GIMP_DISPLAY_SHELL (data);
qmask_channel_query (shell);
}

8
app/gui/vectors-commands.c
View file

@ -441,14 +441,12 @@ vectors_new_vectors_query (GimpImage *gimage,
{
GimpVectors *new_vectors;
/* undo_push_group_start (gimage, EDIT_PASTE_UNDO_GROUP); */
new_vectors = NULL; /*gimp_vectors_new (gimage, _("Empty Vectors Copy"));*/
new_vectors = g_object_new (GIMP_TYPE_VECTORS, NULL);
gimp_image_add_vectors (gimage, new_vectors, -1);
/* undo_push_group_end (gimage); */
gimp_object_set_name (GIMP_OBJECT (new_vectors),
_("Empty Vectors Copy"));
return;
}

147
app/gui/view-commands.c
View file

@ -37,6 +37,7 @@
#include "display/gimpdisplayshell-selection.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpitemfactory.h"
#include "dialogs.h"
#include "info-dialog.h"
@ -100,11 +101,24 @@ void
view_dot_for_dot_cmd_callback (GtkWidget *widget,
gpointer data)
{
GimpDisplay *gdisp;
GimpDisplay *gdisp;
GimpDisplayShell *shell;
return_if_no_display (gdisp, data);
gimp_display_shell_scale_set_dot_for_dot (GIMP_DISPLAY_SHELL (gdisp->shell),
GTK_CHECK_MENU_ITEM (widget)->active);
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
if (shell->dot_for_dot != GTK_CHECK_MENU_ITEM (widget)->active)
{
gimp_display_shell_scale_set_dot_for_dot (shell,
GTK_CHECK_MENU_ITEM (widget)->active);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Dot for Dot",
shell->dot_for_dot);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Dot for Dot",
shell->dot_for_dot);
}
}
void
@ -164,19 +178,22 @@ view_toggle_selection_cmd_callback (GtkWidget *widget,
{
GimpDisplay *gdisp;
GimpDisplayShell *shell;
gint new_val;
return_if_no_display (gdisp, data);
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
new_val = GTK_CHECK_MENU_ITEM (widget)->active;
/* hidden == TRUE corresponds to the menu toggle being FALSE */
if (new_val == shell->select->hidden)
if (GTK_CHECK_MENU_ITEM (widget)->active == shell->select->hidden)
{
gimp_display_shell_selection_toggle (shell->select);
gimp_display_shell_flush (shell);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Selection",
! shell->select->hidden);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Selection",
! shell->select->hidden);
}
}
@ -186,19 +203,22 @@ view_toggle_layer_boundary_cmd_callback (GtkWidget *widget,
{
GimpDisplay *gdisp;
GimpDisplayShell *shell;
gint new_val;
return_if_no_display (gdisp, data);
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
new_val = GTK_CHECK_MENU_ITEM (widget)->active;
/* hidden == TRUE corresponds to the menu toggle being FALSE */
if (new_val == shell->select->layer_hidden)
if (GTK_CHECK_MENU_ITEM (widget)->active == shell->select->layer_hidden)
{
gimp_display_shell_selection_toggle_layer (shell->select);
gimp_display_shell_flush (shell);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Layer Boundary",
! shell->select->layer_hidden);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Layer Boundary",
! shell->select->layer_hidden);
}
}
@ -215,18 +235,21 @@ view_toggle_menubar_cmd_callback (GtkWidget *widget,
menubar = GTK_ITEM_FACTORY (shell->menubar_factory)->widget;
if (! GTK_CHECK_MENU_ITEM (widget)->active)
if (GTK_CHECK_MENU_ITEM (widget)->active !=
GTK_WIDGET_VISIBLE (menubar))
{
if (GTK_WIDGET_VISIBLE (menubar))
gtk_widget_hide (menubar);
}
else
{
if (! GTK_WIDGET_VISIBLE (menubar))
else
gtk_widget_show (menubar);
}
gimp_display_shell_set_menu_sensitivity (shell, gdisp->gimage->gimp, FALSE);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Menubar",
GTK_WIDGET_VISIBLE (menubar));
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Menubar",
GTK_WIDGET_VISIBLE (menubar));
}
}
void
@ -242,30 +265,29 @@ view_toggle_rulers_cmd_callback (GtkWidget *widget,
config = GIMP_DISPLAY_CONFIG (gdisp->gimage->gimp->config);
if (! GTK_CHECK_MENU_ITEM (widget)->active)
if (GTK_CHECK_MENU_ITEM (widget)->active !=
GTK_WIDGET_VISIBLE (shell->origin))
{
if (GTK_WIDGET_VISIBLE (shell->origin))
{
gtk_widget_hide (shell->origin);
gtk_widget_hide (shell->hrule);
gtk_widget_hide (shell->vrule);
gtk_widget_queue_resize (GTK_WIDGET (shell->origin->parent));
}
}
else
{
if (! GTK_WIDGET_VISIBLE (shell->origin))
else
{
gtk_widget_show (shell->origin);
gtk_widget_show (shell->hrule);
gtk_widget_show (shell->vrule);
gtk_widget_queue_resize (GTK_WIDGET (shell->origin->parent));
}
}
gimp_display_shell_set_menu_sensitivity (shell, gdisp->gimage->gimp, FALSE);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Rulers",
GTK_WIDGET_VISIBLE (shell->origin));
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Rulers",
GTK_WIDGET_VISIBLE (shell->origin));
}
}
void
@ -278,18 +300,21 @@ view_toggle_statusbar_cmd_callback (GtkWidget *widget,
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
if (! GTK_CHECK_MENU_ITEM (widget)->active)
if (GTK_CHECK_MENU_ITEM (widget)->active !=
GTK_WIDGET_VISIBLE (shell->statusbar))
{
if (GTK_WIDGET_VISIBLE (shell->statusbar))
gtk_widget_hide (shell->statusbar);
}
else
{
if (! GTK_WIDGET_VISIBLE (shell->statusbar))
else
gtk_widget_show (shell->statusbar);
}
gimp_display_shell_set_menu_sensitivity (shell, gdisp->gimage->gimp, FALSE);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Statusbar",
GTK_WIDGET_VISIBLE (shell->statusbar));
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Statusbar",
GTK_WIDGET_VISIBLE (shell->statusbar));
}
}
void
@ -297,16 +322,30 @@ view_toggle_guides_cmd_callback (GtkWidget *widget,
gpointer data)
{
GimpDisplay *gdisp;
gboolean old_val;
return_if_no_display (gdisp, data);
old_val = gdisp->draw_guides;
gdisp->draw_guides = GTK_CHECK_MENU_ITEM (widget)->active;
if ((old_val != gdisp->draw_guides) && gdisp->gimage->guides)
if (GTK_CHECK_MENU_ITEM (widget)->active != gdisp->draw_guides)
{
gimp_display_shell_expose_full (GIMP_DISPLAY_SHELL (gdisp->shell));
gimp_display_flush (gdisp);
GimpDisplayShell *shell;
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
gdisp->draw_guides = GTK_CHECK_MENU_ITEM (widget)->active;
if (gdisp->gimage->guides)
{
gimp_display_shell_expose_full (shell);
gimp_display_flush (gdisp);
}
else
{
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Show Guides",
gdisp->draw_guides);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Show Guides",
gdisp->draw_guides);
}
}
}
@ -314,13 +353,23 @@ void
view_snap_to_guides_cmd_callback (GtkWidget *widget,
gpointer data)
{
GimpDisplay *gdisp;
GimpDisplay *gdisp;
GimpDisplayShell *shell;
return_if_no_display (gdisp, data);
gdisp->snap_to_guides = GTK_CHECK_MENU_ITEM (widget)->active;
shell = GIMP_DISPLAY_SHELL (gdisp->shell);
gimp_display_shell_set_menu_sensitivity (GIMP_DISPLAY_SHELL (gdisp->shell),
gdisp->gimage->gimp, FALSE);
if (gdisp->snap_to_guides != GTK_CHECK_MENU_ITEM (widget)->active)
{
gdisp->snap_to_guides = GTK_CHECK_MENU_ITEM (widget)->active;
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->menubar_factory),
"/View/Snap to Guides",
gdisp->snap_to_guides);
gimp_item_factory_set_active (GTK_ITEM_FACTORY (shell->popup_factory),
"/View/Snap to Guides",
gdisp->snap_to_guides);
}
}
void

769
app/menus/menus.c
View file

@ -39,14 +39,19 @@
#include "file/file-utils.h"
#include "plug-in/plug-ins.h"
#include "plug-in/plug-in-proc.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpmenufactory.h"
#include "display/gimpdisplayshell.h"
#include "brushes-commands.h"
#include "buffers-commands.h"
#include "channels-commands.h"
#include "colormap-editor-commands.h"
#include "data-commands.h"
#include "debug-commands.h"
#include "dialogs-commands.h"
#include "documents-commands.h"
#include "drawable-commands.h"
@ -75,9 +80,6 @@
#include "libgimp/gimpintl.h"
#define ENABLE_DEBUG_ENTRIES 1
/* local function prototypes */
static void menus_last_opened_add (GimpItemFactory *item_factory,
@ -96,17 +98,6 @@ static void menus_background_changed (GimpContext *context,
const GimpRGB *color,
GimpItemFactory *item_factory);
static void menus_filters_subdirs_to_top (GtkMenu *menu);
#ifdef ENABLE_DEBUG_ENTRIES
static void menus_debug_recurse_menu (GtkWidget *menu,
gint depth,
gchar *path);
static void menus_debug_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
static void menus_mem_profile_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
#endif /* ENABLE_DEBUG_ENTRIES */
#define SEPARATOR(path) \
@ -260,10 +251,10 @@ static GimpItemFactoryEntry toolbox_entries[] =
NULL, NULL, NULL },
{ { "/File/Debug/Mem Profile", NULL,
menus_mem_profile_cmd_callback, 0 },
debug_mem_profile_cmd_callback, 0 },
NULL, NULL, NULL },
{ { "/File/Debug/Dump Items", NULL,
menus_debug_cmd_callback, 0 },
debug_dump_menus_cmd_callback, 0 },
NULL, NULL, NULL },
{ { "/File/Debug/Serialize User Context", NULL,
test_serialize_context_cmd_callback, 0 },
@ -2046,10 +2037,10 @@ static GimpItemFactoryEntry qmask_entries[] =
SEPARATOR ("/---"),
{ { N_("/Mask Selected Areas"), NULL,
qmask_invert_cmd_callback, FALSE, "<RadioItem>" },
qmask_invert_cmd_callback, TRUE, "<RadioItem>" },
NULL, NULL, NULL },
{ { N_("/Mask Unselected Areas"), NULL,
qmask_invert_cmd_callback, TRUE, "/Mask Selected Areas" },
qmask_invert_cmd_callback, FALSE, "/Mask Selected Areas" },
NULL, NULL, NULL },
SEPARATOR ("/---"),
@ -2060,38 +2051,81 @@ static GimpItemFactoryEntry qmask_entries[] =
};
static gboolean menus_initialized = FALSE;
static GList *all_factories = NULL;
/* GimpItemFactory setup functions */
/* public functions */
GimpItemFactory *
menus_get_new_image_factory (Gimp *gimp,
gpointer callback_data,
gboolean menu_bar)
static void
menus_toolbox_factory_setup (GimpItemFactory *factory)
{
GimpItemFactory *image_factory;
static gchar *reorder_subsubmenus[] = { "/Xtns" };
image_factory = gimp_item_factory_new (gimp,
menu_bar ?
GTK_TYPE_MENU_BAR : GTK_TYPE_MENU,
"<Image>", "image",
NULL,
G_N_ELEMENTS (image_entries),
image_entries,
callback_data,
TRUE);
GtkWidget *menu_item;
GtkWidget *menu;
GList *list;
gint i, pos;
if (menu_bar)
menus_last_opened_add (factory, factory->gimp);
plug_in_make_menu (factory, proc_defs);
/* Move all menu items under "<Toolbox>/Xtns" which are not submenus or
* separators to the top of the menu
*/
pos = 1;
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
"/Xtns/Module Browser...");
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
{
gimp_item_factory_set_visible (GTK_ITEM_FACTORY (image_factory),
menu = menu_item->parent;
for (list = g_list_nth (GTK_MENU_SHELL (menu)->children, pos); list;
list = g_list_next (list))
{
menu_item = GTK_WIDGET (list->data);
if (! GTK_MENU_ITEM (menu_item)->submenu &&
GTK_IS_LABEL (GTK_BIN (menu_item)->child))
{
gtk_menu_reorder_child (GTK_MENU (menu_item->parent),
menu_item, pos);
list = g_list_nth (GTK_MENU_SHELL (menu)->children, pos);
pos++;
}
}
}
for (i = 0; i < G_N_ELEMENTS (reorder_subsubmenus); i++)
{
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
reorder_subsubmenus[i]);
if (menu && GTK_IS_MENU (menu))
{
for (list = GTK_MENU_SHELL (menu)->children; list;
list = g_list_next (list))
{
GtkMenuItem *menu_item;
menu_item = GTK_MENU_ITEM (list->data);
if (menu_item->submenu)
menus_filters_subdirs_to_top (GTK_MENU (menu_item->submenu));
}
}
}
}
static void
menus_image_factory_setup (GimpItemFactory *factory)
{
if (GTK_IS_MENU_BAR (GTK_ITEM_FACTORY (factory)->widget))
{
gimp_item_factory_set_visible (GTK_ITEM_FACTORY (factory),
"/tearoff1", FALSE);
gimp_item_factory_set_visible (GTK_ITEM_FACTORY (image_factory),
gimp_item_factory_set_visible (GTK_ITEM_FACTORY (factory),
"/filters-separator", FALSE);
}
menus_last_opened_add (image_factory, gimp);
menus_last_opened_add (factory, factory->gimp);
/* create tool menu items */
{
@ -2106,7 +2140,7 @@ menus_get_new_image_factory (Gimp *gimp,
GList *list;
gint i;
for (list = GIMP_LIST (gimp->tool_info_list)->list;
for (list = GIMP_LIST (factory->gimp->tool_info_list)->list;
list;
list = g_list_next (list))
{
@ -2126,7 +2160,7 @@ menus_get_new_image_factory (Gimp *gimp,
entry.help_page = tool_info->help_data;
entry.description = NULL;
gimp_item_factory_create_item (image_factory,
gimp_item_factory_create_item (factory,
&entry,
NULL,
tool_info, 2,
@ -2136,10 +2170,10 @@ menus_get_new_image_factory (Gimp *gimp,
/* reorder <Image>/Image/Colors */
tool_info = (GimpToolInfo *)
gimp_container_get_child_by_name (gimp->tool_info_list,
gimp_container_get_child_by_name (factory->gimp->tool_info_list,
"gimp-posterize-tool");
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
tool_info->menu_path);
if (menu_item && menu_item->parent)
gtk_menu_reorder_child (GTK_MENU (menu_item->parent), menu_item, 4);
@ -2147,10 +2181,10 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (color_tools); i++)
{
tool_info = (GimpToolInfo *)
gimp_container_get_child_by_name (gimp->tool_info_list,
gimp_container_get_child_by_name (factory->gimp->tool_info_list,
color_tools[i]);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
tool_info->menu_path);
if (menu_item && menu_item->parent)
{
@ -2165,23 +2199,23 @@ menus_get_new_image_factory (Gimp *gimp,
GimpRGB fg;
GimpRGB bg;
user_context = gimp_get_user_context (gimp);
user_context = gimp_get_user_context (factory->gimp);
g_signal_connect_object (user_context, "foreground_changed",
G_CALLBACK (menus_foreground_changed),
image_factory, 0);
factory, 0);
g_signal_connect_object (user_context, "background_changed",
G_CALLBACK (menus_background_changed),
image_factory, 0);
factory, 0);
gimp_context_get_foreground (user_context, &fg);
gimp_context_get_background (user_context, &bg);
menus_foreground_changed (user_context, &fg, image_factory);
menus_background_changed (user_context, &bg, image_factory);
menus_foreground_changed (user_context, &fg, factory);
menus_background_changed (user_context, &bg, factory);
}
plug_in_make_menu (image_factory, proc_defs);
plug_in_make_menu (factory, proc_defs);
{
static gchar *rotate_plugins[] = { "Rotate 90 degrees",
@ -2204,7 +2238,7 @@ menus_get_new_image_factory (Gimp *gimp,
* separators to the top of the menu
*/
pos = 3;
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
"/Filters/Filter all Layers...");
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
{
@ -2231,7 +2265,7 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (rotate_plugins); i++)
{
path = g_strconcat ("/Image/Transform/", rotate_plugins[i], NULL);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
path);
g_free (path);
@ -2247,7 +2281,7 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (rotate_plugins); i++)
{
path = g_strconcat ("/Layer/Transform/", rotate_plugins[i], NULL);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
path);
g_free (path);
@ -2263,7 +2297,7 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (image_file_entries); i++)
{
path = g_strconcat ("/File/", image_file_entries[i], NULL);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
path);
g_free (path);
@ -2274,7 +2308,7 @@ menus_get_new_image_factory (Gimp *gimp,
/* Reorder menus where plugins registered submenus */
for (i = 0; i < G_N_ELEMENTS (reorder_submenus); i++)
{
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
reorder_submenus[i]);
if (menu && GTK_IS_MENU (menu))
@ -2283,7 +2317,7 @@ menus_get_new_image_factory (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (reorder_subsubmenus); i++)
{
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
reorder_subsubmenus[i]);
if (menu && GTK_IS_MENU (menu))
@ -2304,7 +2338,7 @@ menus_get_new_image_factory (Gimp *gimp,
/* Move all submenus which registered after "<Image>/Filters/Toys"
* before the separator after "<Image>/Filters/Web"
*/
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
"/Filters/---INSERT");
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
@ -2312,7 +2346,7 @@ menus_get_new_image_factory (Gimp *gimp,
menu = menu_item->parent;
pos = g_list_index (GTK_MENU_SHELL (menu)->children, menu_item);
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (image_factory),
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (factory),
"/Filters/Toys");
if (menu_item && GTK_IS_MENU (menu_item))
@ -2340,186 +2374,250 @@ menus_get_new_image_factory (Gimp *gimp,
}
}
}
return image_factory;
}
static void
menus_open_factory_setup (GimpItemFactory *factory)
{
GimpItemFactoryEntry entry;
PlugInProcDef *file_proc;
GSList *list;
factory->gimp->load_procs = g_slist_reverse (factory->gimp->load_procs);
for (list = factory->gimp->load_procs; list; list = g_slist_next (list))
{
gchar *basename;
gchar *lowercase_basename;
gchar *help_page;
file_proc = (PlugInProcDef *) list->data;
basename = g_path_get_basename (file_proc->prog);
lowercase_basename = g_ascii_strdown (basename, -1);
g_free (basename);
/* NOT g_build_filename() because this is a relative URI */
help_page = g_strconcat ("filters/",
lowercase_basename,
".html",
NULL);
g_free (lowercase_basename);
entry.entry.path = strstr (file_proc->menu_path, "/");
entry.entry.accelerator = NULL;
entry.entry.callback = file_open_type_cmd_callback;
entry.entry.callback_action = 0;
entry.entry.item_type = NULL;
entry.quark_string = NULL;
entry.help_page = help_page;
entry.description = NULL;
gimp_item_factory_create_item (factory,
&entry,
NULL,
file_proc, 2,
TRUE, FALSE);
g_free (help_page);
}
}
static void
menus_save_factory_setup (GimpItemFactory *factory)
{
GimpItemFactoryEntry entry;
PlugInProcDef *file_proc;
GSList *list;
factory->gimp->save_procs = g_slist_reverse (factory->gimp->save_procs);
for (list = factory->gimp->save_procs; list; list = g_slist_next (list))
{
gchar *basename;
gchar *lowercase_basename;
gchar *help_page;
file_proc = (PlugInProcDef *) list->data;
basename = g_path_get_basename (file_proc->prog);
lowercase_basename = g_ascii_strdown (basename, -1);
g_free (basename);
/* NOT g_build_filename() because this is a relative URI */
help_page = g_strconcat ("filters/",
lowercase_basename,
".html",
NULL);
g_free (lowercase_basename);
entry.entry.path = strstr (file_proc->menu_path, "/");
entry.entry.accelerator = NULL;
entry.entry.callback = file_save_type_cmd_callback;
entry.entry.callback_action = 0;
entry.entry.item_type = NULL;
entry.quark_string = NULL;
entry.help_page = help_page;
entry.description = NULL;
gimp_item_factory_create_item (factory,
&entry,
NULL,
file_proc, 2,
TRUE, FALSE);
g_free (help_page);
}
}
/* The item factories to register with the global_menu_factory */
static const GimpMenuFactoryEntry factory_entries[] =
{
{
"<Toolbox>", "toolbox",
menus_toolbox_factory_setup, NULL, FALSE,
G_N_ELEMENTS (toolbox_entries), toolbox_entries
},
{
"<Image>", "image",
menus_image_factory_setup, gimp_display_shell_menu_update, FALSE,
G_N_ELEMENTS (image_entries), image_entries
},
{
"<Load>", "open",
menus_open_factory_setup, NULL, FALSE,
G_N_ELEMENTS (load_entries), load_entries
},
{
"<Save>", "save",
menus_save_factory_setup, NULL, FALSE,
G_N_ELEMENTS (save_entries), save_entries
},
{
"<Layers>", "layers",
NULL, layers_menu_update, TRUE,
G_N_ELEMENTS (layers_entries), layers_entries
},
{
"<Channels>", "channels",
NULL, channels_menu_update, TRUE,
G_N_ELEMENTS (channels_entries), channels_entries
},
{
"<Vectors>", "vectors",
NULL, vectors_menu_update, TRUE,
G_N_ELEMENTS (vectors_entries), vectors_entries
},
{
"<Paths>", "paths",
NULL, NULL, FALSE,
G_N_ELEMENTS (paths_entries), paths_entries
},
{
"<Dialogs>", "dialogs",
NULL, dialogs_menu_update, TRUE,
G_N_ELEMENTS (dialogs_entries), dialogs_entries
},
{
"<Brushes>", "brushes",
NULL, brushes_menu_update, TRUE,
G_N_ELEMENTS (brushes_entries), brushes_entries
},
{
"<Patterns>", "patterns",
NULL, patterns_menu_update, TRUE,
G_N_ELEMENTS (patterns_entries), patterns_entries
},
{
"<Gradients>", "gradients",
NULL, gradients_menu_update, TRUE,
G_N_ELEMENTS (gradients_entries), gradients_entries
},
{
"<Palettes>", "palettes",
NULL, palettes_menu_update, TRUE,
G_N_ELEMENTS (palettes_entries), palettes_entries
},
{
"<Buffers>", "buffers",
NULL, buffers_menu_update, TRUE,
G_N_ELEMENTS (buffers_entries), buffers_entries
},
{
"<Documents>", "documents",
NULL, documents_menu_update, TRUE,
G_N_ELEMENTS (documents_entries), documents_entries
},
{
"<Images>", "images",
NULL, images_menu_update, TRUE,
G_N_ELEMENTS (images_entries), images_entries
},
{
"<GradientEditor>", "gradient_editor",
NULL, gradient_editor_menu_update, TRUE,
G_N_ELEMENTS (gradient_editor_entries), gradient_editor_entries
},
{
"<PaletteEditor>", "palette_editor",
NULL, palette_editor_menu_update, TRUE,
G_N_ELEMENTS (palette_editor_entries), palette_editor_entries
},
{
"<ColormapEditor>", "colormap_editor",
NULL, colormap_editor_menu_update, TRUE,
G_N_ELEMENTS (colormap_editor_entries), colormap_editor_entries
},
{
"<QMask>", "qmask",
NULL, qmask_menu_update, TRUE,
G_N_ELEMENTS (qmask_entries), qmask_entries
}
};
static gboolean menus_initialized = FALSE;
GimpMenuFactory *global_menu_factory = NULL;
/* public functions */
void
menus_init (Gimp *gimp)
{
GimpItemFactory *toolbox_factory;
gchar *filename;
gchar *filename;
gint i;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (menus_initialized == FALSE);
menus_initialized = TRUE;
#define ADD_FACTORY(f) (all_factories = g_list_append (all_factories, (f)));
global_menu_factory = gimp_menu_factory_new (gimp);
toolbox_factory = gimp_item_factory_new (gimp,
GTK_TYPE_MENU_BAR,
"<Toolbox>", "toolbox",
NULL,
G_N_ELEMENTS (toolbox_entries),
toolbox_entries,
gimp,
TRUE);
menus_last_opened_add (toolbox_factory, gimp);
ADD_FACTORY (toolbox_factory);
ADD_FACTORY (menus_get_new_image_factory (gimp, gimp, FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Load>", "open",
NULL,
G_N_ELEMENTS (load_entries),
load_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Save>", "save",
NULL,
G_N_ELEMENTS (save_entries),
save_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Layers>", "layers",
layers_menu_update,
G_N_ELEMENTS (layers_entries),
layers_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Channels>", "channels",
channels_menu_update,
G_N_ELEMENTS (channels_entries),
channels_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Vectors>", "vectors",
vectors_menu_update,
G_N_ELEMENTS (vectors_entries),
vectors_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Paths>", "paths",
NULL,
G_N_ELEMENTS (paths_entries),
paths_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Dialogs>", "dialogs",
dialogs_menu_update,
G_N_ELEMENTS (dialogs_entries),
dialogs_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Brushes>", "brushes",
brushes_menu_update,
G_N_ELEMENTS (brushes_entries),
brushes_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Patterns>", "patterns",
patterns_menu_update,
G_N_ELEMENTS (patterns_entries),
patterns_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<GradientEditor>", "gradient_editor",
gradient_editor_menu_update,
G_N_ELEMENTS (gradient_editor_entries),
gradient_editor_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Gradients>", "gradients",
gradients_menu_update,
G_N_ELEMENTS (gradients_entries),
gradients_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<PaletteEditor>", "palette_editor",
palette_editor_menu_update,
G_N_ELEMENTS (palette_editor_entries),
palette_editor_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Palettes>", "palettes",
palettes_menu_update,
G_N_ELEMENTS (palettes_entries),
palettes_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Buffers>", "buffers",
buffers_menu_update,
G_N_ELEMENTS (buffers_entries),
buffers_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Documents>", "documents",
documents_menu_update,
G_N_ELEMENTS (documents_entries),
documents_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<Images>", "images",
images_menu_update,
G_N_ELEMENTS (images_entries),
images_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<ColormapEditor>", "colormap_editor",
colormap_editor_menu_update,
G_N_ELEMENTS (colormap_editor_entries),
colormap_editor_entries,
gimp,
FALSE));
ADD_FACTORY (gimp_item_factory_new (gimp,
GTK_TYPE_MENU,
"<QMask>", "qmask",
qmask_menu_update,
G_N_ELEMENTS (qmask_entries),
qmask_entries,
gimp,
FALSE));
for (i = 0; i < G_N_ELEMENTS (factory_entries); i++)
{
gimp_menu_factory_menu_register (global_menu_factory,
factory_entries[i].identifier,
factory_entries[i].help_path,
factory_entries[i].setup_func,
factory_entries[i].update_func,
factory_entries[i].update_on_popup,
factory_entries[i].n_entries,
factory_entries[i].entries);
}
filename = gimp_personal_rc_file ("menurc");
gtk_accel_map_load (filename);
g_free (filename);
#undef ADD_FACTORY
}
void
@ -2533,72 +2631,8 @@ menus_exit (Gimp *gimp)
gtk_accel_map_save (filename);
g_free (filename);
g_list_foreach (all_factories, (GFunc) g_object_unref, NULL);
g_list_free (all_factories);
all_factories = NULL;
}
void
menus_restore (Gimp *gimp)
{
static gchar *reorder_subsubmenus[] = { "<Toolbox>/Xtns" };
GimpItemFactory *item_factory;
GtkWidget *menu_item;
GtkWidget *menu;
GList *list;
gint i, pos;
g_return_if_fail (GIMP_IS_GIMP (gimp));
/* Move all menu items under "<Toolbox>/Xtns" which are not submenus or
* separators to the top of the menu
*/
pos = 1;
item_factory = gimp_item_factory_from_path ("<Toolbox>");
menu_item = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (item_factory),
"/Xtns/Module Browser...");
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
{
menu = menu_item->parent;
for (list = g_list_nth (GTK_MENU_SHELL (menu)->children, pos); list;
list = g_list_next (list))
{
menu_item = GTK_WIDGET (list->data);
if (! GTK_MENU_ITEM (menu_item)->submenu &&
GTK_IS_LABEL (GTK_BIN (menu_item)->child))
{
gtk_menu_reorder_child (GTK_MENU (menu_item->parent),
menu_item, pos);
list = g_list_nth (GTK_MENU_SHELL (menu)->children, pos);
pos++;
}
}
}
for (i = 0; i < G_N_ELEMENTS (reorder_subsubmenus); i++)
{
item_factory = gimp_item_factory_from_path (reorder_subsubmenus[i]);
menu = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (item_factory),
reorder_subsubmenus[i]);
if (menu && GTK_IS_MENU (menu))
{
for (list = GTK_MENU_SHELL (menu)->children; list;
list = g_list_next (list))
{
GtkMenuItem *menu_item;
menu_item = GTK_MENU_ITEM (list->data);
if (menu_item->submenu)
menus_filters_subdirs_to_top (GTK_MENU (menu_item->submenu));
}
}
}
g_object_unref (global_menu_factory);
global_menu_factory = NULL;
}
@ -2805,156 +2839,3 @@ menus_filters_subdirs_to_top (GtkMenu *menu)
gtk_widget_show (separator);
}
}
#ifdef ENABLE_DEBUG_ENTRIES
static void
menus_debug_recurse_menu (GtkWidget *menu,
gint depth,
gchar *path)
{
GtkItemFactory *item_factory;
GtkWidget *menu_item;
GList *list;
const gchar *label;
gchar *help_page;
gchar *help_path;
gchar *factory_path;
gchar *hash;
gchar *full_path;
gchar *format_str;
for (list = GTK_MENU_SHELL (menu)->children; list; list = g_list_next (list))
{
menu_item = GTK_WIDGET (list->data);
if (GTK_IS_LABEL (GTK_BIN (menu_item)->child))
{
label = gtk_label_get_text (GTK_LABEL (GTK_BIN (menu_item)->child));
full_path = g_strconcat (path, "/", label, NULL);
item_factory = GTK_ITEM_FACTORY (gimp_item_factory_from_path (path));
help_page = g_object_get_data (G_OBJECT (menu_item), "help_page");
if (item_factory)
{
factory_path = g_object_get_data (G_OBJECT (item_factory),
"factory_path");
if (factory_path)
{
help_page = g_build_filename (factory_path, help_page, NULL);
}
else
{
help_page = g_strdup (help_page);
}
}
else
{
help_page = g_strdup (help_page);
}
if (help_page)
{
help_path = g_build_filename (gimp_data_directory (),
"help", "C", help_page, NULL);
if ((hash = strchr (help_path, '#')) != NULL)
*hash = '\0';
if (g_file_test (help_path, G_FILE_TEST_EXISTS))
{
g_free (help_path);
help_path = g_strconcat ("! ", help_page, NULL);
g_free (help_page);
help_page = help_path;
}
else
{
g_free (help_path);
}
}
format_str = g_strdup_printf ("%%%ds%%%ds %%-20s %%s\n",
depth * 2, depth * 2 - 40);
g_print (format_str,
"", label, "", help_page ? help_page : "");
g_free (format_str);
g_free (help_page);
if (GTK_MENU_ITEM (menu_item)->submenu)
menus_debug_recurse_menu (GTK_MENU_ITEM (menu_item)->submenu,
depth + 1, full_path);
g_free (full_path);
}
}
}
static void
menus_debug_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
#if 0
gint n_factories = 7;
GtkItemFactory *factories[7];
GimpItemFactoryEntry *entries[7];
GtkWidget *menu_item;
gint i;
factories[0] = GTK_ITEM_FACTORY (toolbox_factory);
factories[1] = GTK_ITEM_FACTORY (image_factory);
factories[2] = GTK_ITEM_FACTORY (layers_factory);
factories[3] = GTK_ITEM_FACTORY (channels_factory);
factories[4] = GTK_ITEM_FACTORY (paths_factory);
factories[5] = GTK_ITEM_FACTORY (load_factory);
factories[6] = GTK_ITEM_FACTORY (save_factory);
entries[0] = toolbox_entries;
entries[1] = image_entries;
entries[2] = layers_entries;
entries[3] = channels_entries;
entries[4] = paths_entries;
entries[5] = load_entries;
entries[6] = save_entries;
/* toolbox needs special treatment */
g_print ("%s\n", factories[0]->path);
menu_item = gtk_item_factory_get_item (factories[0], "/File");
if (menu_item && menu_item->parent && GTK_IS_MENU_BAR (menu_item->parent))
menus_debug_recurse_menu (menu_item->parent, 1, factories[0]->path);
g_print ("\n");
for (i = 1; i < n_factories; i++)
{
g_print ("%s\n", factories[i]->path);
menu_item = gtk_item_factory_get_item (factories[i], entries[i][0].entry.path);
if (menu_item && menu_item->parent && GTK_IS_MENU (menu_item->parent))
menus_debug_recurse_menu (menu_item->parent, 1, factories[i]->path);
g_print ("\n");
}
#endif
}
static void
menus_mem_profile_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
extern gboolean gimp_debug_memsize;
gimp_debug_memsize = TRUE;
gimp_object_get_memsize (GIMP_OBJECT (data));
gimp_debug_memsize = FALSE;
}
#endif /* ENABLE_DEBUG_ENTRIES */

12
app/menus/menus.h
View file

@ -20,17 +20,11 @@
#define __MENUS_H__
void menus_init (Gimp *gimp);
void menus_exit (Gimp *gimp);
void menus_restore (Gimp *gimp);
extern GimpMenuFactory *global_menu_factory;
/* FIXME: remove this and add a GimpMenuFactory class which produces
* GimpItemFactories on demand
*/
GimpItemFactory * menus_get_new_image_factory (Gimp *gimp,
gpointer callback_data,
gboolean menu_bar);
void menus_init (Gimp *gimp);
void menus_exit (Gimp *gimp);
#endif /* __MENUS_H__ */

104
app/menus/plug-in-menus.c
View file

@ -54,7 +54,7 @@ struct _PlugInMenuEntry
static gboolean plug_in_menu_tree_traverse_func (gpointer foo,
PlugInMenuEntry *menu_entry,
GimpItemFactory *image_factory);
GimpItemFactory *item_factory);
static gchar * plug_in_escape_uline (const gchar *menu_path);
@ -108,15 +108,15 @@ plug_in_menus_init (GSList *plug_in_defs,
}
void
plug_in_make_menu (GimpItemFactory *image_factory,
plug_in_make_menu (GimpItemFactory *item_factory,
GSList *proc_defs)
{
PlugInProcDef *proc_def;
GSList *procs;
GTree *menu_entries;
g_return_if_fail (image_factory == NULL ||
GIMP_IS_ITEM_FACTORY (image_factory));
g_return_if_fail (item_factory == NULL ||
GIMP_IS_ITEM_FACTORY (item_factory));
g_return_if_fail (proc_defs != NULL);
menu_entries = g_tree_new_full ((GCompareDataFunc) g_utf8_collate, NULL,
@ -151,12 +151,12 @@ plug_in_make_menu (GimpItemFactory *image_factory,
g_tree_foreach (menu_entries,
(GTraverseFunc) plug_in_menu_tree_traverse_func,
image_factory);
item_factory);
g_tree_destroy (menu_entries);
}
void
plug_in_make_menu_entry (GimpItemFactory *image_factory,
plug_in_make_menu_entry (GimpItemFactory *item_factory,
PlugInProcDef *proc_def,
const gchar *domain,
const gchar *help_path)
@ -167,8 +167,8 @@ plug_in_make_menu_entry (GimpItemFactory *image_factory,
gchar *basename;
gchar *lowercase_page;
g_return_if_fail (image_factory == NULL ||
GIMP_IS_ITEM_FACTORY (image_factory));
g_return_if_fail (item_factory == NULL ||
GIMP_IS_ITEM_FACTORY (item_factory));
basename = g_path_get_basename (proc_def->prog);
@ -205,11 +205,16 @@ plug_in_make_menu_entry (GimpItemFactory *image_factory,
entry.help_page = lowercase_page;
entry.description = NULL;
if (image_factory)
if (item_factory)
{
if (! strncmp (proc_def->menu_path, "<Image>", 7))
gchar *factory_path;
factory_path = GTK_ITEM_FACTORY (item_factory)->path;
if (! strncmp (proc_def->menu_path,
factory_path, strlen (factory_path)))
{
gimp_item_factory_create_item (image_factory,
gimp_item_factory_create_item (item_factory,
&entry,
domain,
&proc_def->db_info, 2,
@ -224,7 +229,7 @@ plug_in_make_menu_entry (GimpItemFactory *image_factory,
list;
list = g_list_next (list))
{
GimpItemFactory *item_factory = list->data;
item_factory = list->data;
gimp_item_factory_create_item (item_factory,
&entry,
@ -256,15 +261,20 @@ plug_in_delete_menu_entry (const gchar *menu_path)
}
void
plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
plug_in_set_menu_sensitivity (GimpItemFactory *item_factory,
GimpImageType type)
{
PlugInProcDef *proc_def;
GSList *tmp;
gboolean sensitive = FALSE;
gchar *factory_path;
gboolean is_image_factory = FALSE;
g_return_if_fail (image_factory == NULL ||
GIMP_IS_ITEM_FACTORY (image_factory));
g_return_if_fail (GIMP_IS_ITEM_FACTORY (item_factory));
factory_path = GTK_ITEM_FACTORY (item_factory)->path;
if (! strcmp (factory_path, "<Image>"))
is_image_factory = TRUE;
for (tmp = proc_defs; tmp; tmp = g_slist_next (tmp))
{
@ -272,6 +282,8 @@ plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
if (proc_def->image_types_val && proc_def->menu_path)
{
gboolean sensitive;
switch (type)
{
case GIMP_RGB_IMAGE:
@ -297,16 +309,16 @@ plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
break;
}
if (image_factory && ! strncmp (proc_def->menu_path, "<Image>", 7))
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (image_factory),
proc_def->menu_path,
sensitive);
else
gimp_item_factories_set_sensitive (proc_def->menu_path,
if (! strncmp (proc_def->menu_path, factory_path,
strlen (factory_path)))
{
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
proc_def->menu_path,
sensitive);
}
if (last_plug_in && (last_plug_in == &proc_def->db_info))
if (is_image_factory &&
last_plug_in && (last_plug_in == &proc_def->db_info))
{
gchar *basename;
gchar *ellipses;
@ -325,37 +337,37 @@ plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
g_free (basename);
gimp_item_factories_set_label ("<Image>",
"/Filters/Repeat Last", repeat);
gimp_item_factories_set_label ("<Image>",
"/Filters/Re-Show Last", reshow);
gimp_item_factory_set_label (GTK_ITEM_FACTORY (item_factory),
"/Filters/Repeat Last", repeat);
gimp_item_factory_set_label (GTK_ITEM_FACTORY (item_factory),
"/Filters/Re-Show Last", reshow);
g_free (repeat);
g_free (reshow);
gimp_item_factories_set_sensitive ("<Image>",
"/Filters/Repeat Last",
sensitive);
gimp_item_factories_set_sensitive ("<Image>",
"/Filters/Re-Show Last",
sensitive);
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
"/Filters/Repeat Last",
sensitive);
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
"/Filters/Re-Show Last",
sensitive);
}
}
}
if (! last_plug_in)
if (is_image_factory && ! last_plug_in)
{
gimp_item_factories_set_label ("<Image>",
"/Filters/Repeat Last",
_("Repeat Last"));
gimp_item_factories_set_label ("<Image>",
"/Filters/Re-Show Last",
_("Re-Show Last"));
gimp_item_factory_set_label (GTK_ITEM_FACTORY (item_factory),
"/Filters/Repeat Last",
_("Repeat Last"));
gimp_item_factory_set_label (GTK_ITEM_FACTORY (item_factory),
"/Filters/Re-Show Last",
_("Re-Show Last"));
gimp_item_factories_set_sensitive ("<Image>",
"/Filters/Repeat Last", FALSE);
gimp_item_factories_set_sensitive ("<Image>",
"/Filters/Re-Show Last", FALSE);
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
"/Filters/Repeat Last", FALSE);
gimp_item_factory_set_sensitive (GTK_ITEM_FACTORY (item_factory),
"/Filters/Re-Show Last", FALSE);
}
}
@ -365,9 +377,9 @@ plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
static gboolean
plug_in_menu_tree_traverse_func (gpointer foo,
PlugInMenuEntry *menu_entry,
GimpItemFactory *image_factory)
GimpItemFactory *item_factory)
{
plug_in_make_menu_entry (image_factory,
plug_in_make_menu_entry (item_factory,
menu_entry->proc_def,
menu_entry->domain,
menu_entry->help_path);

6
app/menus/plug-in-menus.h
View file

@ -23,14 +23,14 @@
void plug_in_menus_init (GSList *plug_in_defs,
const gchar *std_plugins_domain);
void plug_in_make_menu (GimpItemFactory *image_factory,
void plug_in_make_menu (GimpItemFactory *item_factory,
GSList *proc_defs);
void plug_in_make_menu_entry (GimpItemFactory *image_factory,
void plug_in_make_menu_entry (GimpItemFactory *item_factory,
PlugInProcDef *proc_def,
const gchar *locale_domain,
const gchar *help_path);
void plug_in_delete_menu_entry (const gchar *menu_path);
void plug_in_set_menu_sensitivity (GimpItemFactory *image_factory,
void plug_in_set_menu_sensitivity (GimpItemFactory *item_factory,
GimpImageType type);

7
app/plug-in/gimppluginmanager.c
View file

@ -236,12 +236,7 @@ plug_ins_init (Gimp *gimp,
}
if (! gimp->no_interface)
{
plug_in_menus_init (plug_in_defs, STD_PLUGINS_DOMAIN);
/* make the menu */
plug_in_make_menu (NULL, proc_defs);
}
plug_in_menus_init (plug_in_defs, STD_PLUGINS_DOMAIN);
/* initial the plug-ins */
(* status_callback) (_("Initializing Plug-ins"), "", 0);

7
app/plug-in/plug-ins.c
View file

@ -236,12 +236,7 @@ plug_ins_init (Gimp *gimp,
}
if (! gimp->no_interface)
{
plug_in_menus_init (plug_in_defs, STD_PLUGINS_DOMAIN);
/* make the menu */
plug_in_make_menu (NULL, proc_defs);
}
plug_in_menus_init (plug_in_defs, STD_PLUGINS_DOMAIN);
/* initial the plug-ins */
(* status_callback) (_("Initializing Plug-ins"), "", 0);

18
app/tools/gimpimagemaptool.c
View file

@ -29,6 +29,7 @@
#include "core/gimpimagemap.h"
#include "core/gimptoolinfo.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpviewabledialog.h"
#include "display/gimpdisplay.h"
@ -256,8 +257,12 @@ gimp_image_map_tool_initialize (GimpTool *tool,
G_CALLBACK (gimp_image_map_tool_flush),
image_map_tool);
gimp_display_shell_set_menu_sensitivity (GIMP_DISPLAY_SHELL (gdisp->shell),
gdisp->gimage->gimp, FALSE);
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (gdisp->shell);
gimp_item_factory_update (shell->menubar_factory, shell);
gimp_item_factory_update (shell->popup_factory, shell);
}
}
static void
@ -356,7 +361,8 @@ static void
gimp_image_map_tool_ok_clicked (GtkWidget *widget,
GimpImageMapTool *image_map_tool)
{
GimpTool *tool;
GimpDisplayShell *shell;
GimpTool *tool;
tool = GIMP_TOOL (image_map_tool);
@ -377,8 +383,10 @@ gimp_image_map_tool_ok_clicked (GtkWidget *widget,
gimp_tool_control_set_preserve (tool->control, FALSE);
gimp_display_shell_set_menu_sensitivity (GIMP_DISPLAY_SHELL (tool->gdisp->shell),
tool->gdisp->gimage->gimp, FALSE);
shell = GIMP_DISPLAY_SHELL (tool->gdisp->shell);
gimp_item_factory_update (shell->menubar_factory, shell);
gimp_item_factory_update (shell->popup_factory, shell);
tool->gdisp = NULL;
tool->drawable = NULL;

2
app/widgets/Makefile.am
View file

@ -121,6 +121,8 @@ libappwidgets_a_sources = \
gimplayerlistview.h \
gimplistitem.c \
gimplistitem.h \
gimpmenufactory.c \
gimpmenufactory.h \
gimpmenuitem.c \
gimpmenuitem.h \
gimpnavigationpreview.c \

12
app/widgets/gimpbrusheditor.c
View file

@ -37,6 +37,7 @@
#include "base/temp-buf.h"
#include "core/gimp.h"
#include "core/gimpbrushgenerated.h"
#include "gimpbrusheditor.h"
@ -260,9 +261,14 @@ gimp_brush_editor_new (Gimp *gimp)
brush_editor = g_object_new (GIMP_TYPE_BRUSH_EDITOR, NULL);
gimp_data_editor_construct (GIMP_DATA_EDITOR (brush_editor),
gimp,
GIMP_TYPE_BRUSH);
if (! gimp_data_editor_construct (GIMP_DATA_EDITOR (brush_editor),
gimp,
GIMP_TYPE_BRUSH,
NULL, NULL))
{
g_object_unref (brush_editor);
return NULL;
}
return GIMP_DATA_EDITOR (brush_editor);
}

4
app/widgets/gimpbrushfactoryview.c
View file

@ -153,7 +153,7 @@ gimp_brush_factory_view_new (GimpViewType view_type,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory)
GimpMenuFactory *menu_factory)
{
GimpBrushFactoryView *factory_view;
GimpContainerEditor *editor;
@ -176,7 +176,7 @@ gimp_brush_factory_view_new (GimpViewType view_type,
preview_size,
min_items_x,
min_items_y,
item_factory))
menu_factory, "<Brushes>"))
{
g_object_unref (factory_view);
return NULL;

2
app/widgets/gimpbrushfactoryview.h
View file

@ -62,7 +62,7 @@ GtkWidget * gimp_brush_factory_view_new (GimpViewType view_type,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory);
GimpMenuFactory *menu_factory);
#endif /* __GIMP_BRUSH_FACTORY_VIEW_H__ */

4
app/widgets/gimpbufferview.c
View file

@ -118,7 +118,7 @@ gimp_buffer_view_new (GimpViewType view_type,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory)
GimpMenuFactory *menu_factory)
{
GimpBufferView *buffer_view;
GimpContainerEditor *editor;
@ -133,7 +133,7 @@ gimp_buffer_view_new (GimpViewType view_type,
TRUE, /* reorderable */
min_items_x,
min_items_y,
item_factory))
menu_factory, "<Buffers>"))
{
g_object_unref (buffer_view);
return NULL;

2
app/widgets/gimpbufferview.h
View file

@ -60,7 +60,7 @@ GtkWidget * gimp_buffer_view_new (GimpViewType view_type,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory);
GimpMenuFactory *menu_factory);
#endif /* __GIMP_BUFFER_VIEW_H__ */

31
app/widgets/gimpcolormapeditor.c
View file

@ -50,6 +50,7 @@
#include "gimpcolormapeditor.h"
#include "gimpdnd.h"
#include "gimpitemfactory.h"
#include "gimpmenufactory.h"
#include "gui/color-notebook.h"
@ -204,6 +205,12 @@ gimp_colormap_editor_destroy (GtkObject *object)
editor = GIMP_COLORMAP_EDITOR (object);
if (editor->item_factory)
{
g_object_unref (editor->item_factory);
editor->item_factory = NULL;
}
if (editor->color_notebook)
{
color_notebook_free (editor->color_notebook);
@ -221,9 +228,7 @@ gimp_colormap_editor_unmap (GtkWidget *widget)
editor = GIMP_COLORMAP_EDITOR (widget);
if (editor->color_notebook)
{
color_notebook_hide (editor->color_notebook);
}
color_notebook_hide (editor->color_notebook);
GTK_WIDGET_CLASS (parent_class)->unmap (widget);
}
@ -232,16 +237,24 @@ gimp_colormap_editor_unmap (GtkWidget *widget)
/* public functions */
GtkWidget *
gimp_colormap_editor_new (GimpImage *gimage)
gimp_colormap_editor_new (GimpImage *gimage,
GimpMenuFactory *menu_factory)
{
GimpColormapEditor *editor;
GtkWidget *frame;
GtkWidget *table;
g_return_val_if_fail (! gimage || GIMP_IS_IMAGE (gimage), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
editor = g_object_new (GIMP_TYPE_COLORMAP_EDITOR, NULL);
editor->item_factory = gimp_menu_factory_menu_new (menu_factory,
"<ColormapEditor>",
GTK_TYPE_MENU,
menu_factory->gimp,
FALSE);
/* The palette frame */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
@ -711,14 +724,8 @@ gimp_colormap_preview_button_press (GtkWidget *widget,
break;
case 3:
{
GimpItemFactory *factory;
factory = gimp_item_factory_from_path ("<ColormapEditor>");
gimp_colormap_editor_set_index (editor, col);
gimp_item_factory_popup_with_data (factory, editor, NULL);
}
gimp_colormap_editor_set_index (editor, col);
gimp_item_factory_popup_with_data (editor->item_factory, editor, NULL);
return TRUE;
default:

30
app/widgets/gimpcolormapeditor.h
View file

@ -37,19 +37,22 @@ typedef struct _GimpColormapEditorClass GimpColormapEditorClass;
struct _GimpColormapEditor
{
GimpEditor parent_instance;
GimpEditor parent_instance;
GimpImage *gimage;
gint col_index;
gint dnd_col_index;
GtkWidget *palette;
gint xn;
gint yn;
gint cellsize;
GtkAdjustment *index_adjustment;
GtkWidget *index_spinbutton;
GtkWidget *color_entry;
ColorNotebook *color_notebook;
GimpItemFactory *item_factory;
GimpImage *gimage;
gint col_index;
gint dnd_col_index;
GtkWidget *palette;
gint xn;
gint yn;
gint cellsize;
GtkAdjustment *index_adjustment;
GtkWidget *index_spinbutton;
GtkWidget *color_entry;
ColorNotebook *color_notebook;
};
struct _GimpColormapEditorClass
@ -62,7 +65,8 @@ struct _GimpColormapEditorClass
GType gimp_colormap_editor_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_colormap_editor_new (GimpImage *gimage);
GtkWidget * gimp_colormap_editor_new (GimpImage *gimage,
GimpMenuFactory *menu_factory);
void gimp_colormap_editor_selected (GimpColormapEditor *editor);

14
app/widgets/gimpcontainereditor.c
View file

@ -35,6 +35,7 @@
#include "gimpcontainerlistview.h"
#include "gimpdnd.h"
#include "gimpitemfactory.h"
#include "gimpmenufactory.h"
#include "gimppreview.h"
@ -138,20 +139,25 @@ gimp_container_editor_construct (GimpContainerEditor *editor,
gboolean reorderable,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory)
GimpMenuFactory *menu_factory,
const gchar *menu_identifier)
{
g_return_val_if_fail (GIMP_IS_CONTAINER_EDITOR (editor), FALSE);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);
g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), FALSE);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), FALSE);
g_return_val_if_fail (menu_identifier != NULL, FALSE);
g_return_val_if_fail (preview_size > 0 &&
preview_size <= GIMP_PREVIEW_MAX_SIZE, FALSE);
g_return_val_if_fail (min_items_x > 0 && min_items_x <= 64, FALSE);
g_return_val_if_fail (min_items_y > 0 && min_items_y <= 64, FALSE);
editor->item_factory = item_factory;
g_object_ref (editor->item_factory);
editor->item_factory = gimp_menu_factory_menu_new (menu_factory,
menu_identifier,
GTK_TYPE_MENU,
context->gimp,
FALSE);
switch (view_type)
{

21
app/widgets/gimpcontainereditor.h
View file

@ -57,20 +57,21 @@ struct _GimpContainerEditorClass
};
GType gimp_container_editor_get_type (void) G_GNUC_CONST;
GType gimp_container_editor_get_type (void) G_GNUC_CONST;
/* protected */
gboolean gimp_container_editor_construct (GimpContainerEditor *editor,
GimpViewType view_type,
GimpContainer *container,
GimpContext *context,
gint preview_size,
gboolean reorderable,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory);
gboolean gimp_container_editor_construct (GimpContainerEditor *editor,
GimpViewType view_type,
GimpContainer *container,
GimpContext *context,
gint preview_size,
gboolean reorderable,
gint min_items_x,
gint min_items_y,
GimpMenuFactory *menu_factory,
const gchar *menu_identifier);
#endif /* __GIMP_CONTAINER_EDITOR_H__ */

36
app/widgets/gimpdataeditor.c
View file

@ -32,6 +32,8 @@
#include "core/gimpdata.h"
#include "gimpdataeditor.h"
#include "gimpitemfactory.h"
#include "gimpmenufactory.h"
#include "libgimp/gimpintl.h"
@ -107,8 +109,9 @@ gimp_data_editor_class_init (GimpDataEditorClass *klass)
static void
gimp_data_editor_init (GimpDataEditor *editor)
{
editor->data_type = G_TYPE_NONE;
editor->data = NULL;
editor->data_type = G_TYPE_NONE;
editor->data = NULL;
editor->item_factory = NULL;
editor->name_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (editor), editor->name_entry,
@ -149,6 +152,12 @@ gimp_data_editor_dispose (GObject *object)
if (editor->data)
gimp_data_editor_set_data (editor, NULL);
if (editor->item_factory)
{
g_object_unref (editor->item_factory);
editor->item_factory = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
@ -190,18 +199,31 @@ gimp_data_editor_real_set_data (GimpDataEditor *editor,
}
gboolean
gimp_data_editor_construct (GimpDataEditor *editor,
Gimp *gimp,
GType data_type)
gimp_data_editor_construct (GimpDataEditor *editor,
Gimp *gimp,
GType data_type,
GimpMenuFactory *menu_factory,
const gchar *menu_identifier)
{
GimpData *data;
g_return_val_if_fail (GIMP_IS_DATA_EDITOR (editor), FALSE);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (g_type_is_a (data_type, GIMP_TYPE_DATA), FALSE);
g_return_val_if_fail (menu_factory == NULL ||
GIMP_IS_MENU_FACTORY (menu_factory), FALSE);
g_return_val_if_fail (menu_factory == NULL ||
menu_identifier != NULL, FALSE);
editor->gimp = gimp;
editor->data_type = data_type;
editor->gimp = gimp;
editor->data_type = data_type;
if (menu_factory && menu_identifier)
editor->item_factory = gimp_menu_factory_menu_new (menu_factory,
menu_identifier,
GTK_TYPE_MENU,
gimp,
FALSE);
data = (GimpData *)
gimp_context_get_by_type (gimp_get_user_context (gimp), data_type);

30
app/widgets/gimpdataeditor.h
View file

@ -38,17 +38,19 @@ typedef struct _GimpDataEditorClass GimpDataEditorClass;
struct _GimpDataEditor
{
GimpEditor parent_instance;
GimpEditor parent_instance;
Gimp *gimp;
Gimp *gimp;
GType data_type;
GimpData *data;
GType data_type;
GimpData *data;
GtkWidget *name_entry;
GimpItemFactory *item_factory;
GtkWidget *save_button;
GtkWidget *revert_button;
GtkWidget *name_entry;
GtkWidget *save_button;
GtkWidget *revert_button;
};
struct _GimpDataEditorClass
@ -64,13 +66,15 @@ struct _GimpDataEditorClass
GType gimp_data_editor_get_type (void) G_GNUC_CONST;
gboolean gimp_data_editor_construct (GimpDataEditor *editor,
Gimp *gimp,
GType data_type);
gboolean gimp_data_editor_construct (GimpDataEditor *editor,
Gimp *gimp,
GType data_type,
GimpMenuFactory *menu_factory,
const gchar *menu_identifier);
void gimp_data_editor_set_data (GimpDataEditor *editor,
GimpData *data);
GimpData * gimp_data_editor_get_data (GimpDataEditor *editor);
void gimp_data_editor_set_data (GimpDataEditor *editor,
GimpData *data);
GimpData * gimp_data_editor_get_data (GimpDataEditor *editor);
#endif /* __GIMP_DATA_EDITOR_H__ */

12
app/widgets/gimpdatafactoryview.c
View file

@ -130,7 +130,8 @@ gimp_data_factory_view_new (GimpViewType view_type,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory)
GimpMenuFactory *menu_factory,
const gchar *menu_identifier)
{
GimpDataFactoryView *factory_view;
@ -144,7 +145,8 @@ gimp_data_factory_view_new (GimpViewType view_type,
preview_size,
min_items_x,
min_items_y,
item_factory))
menu_factory,
menu_identifier))
{
g_object_unref (factory_view);
return NULL;
@ -162,7 +164,8 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory)
GimpMenuFactory *menu_factory,
const gchar *menu_identifier)
{
GimpContainerEditor *editor;
@ -184,7 +187,8 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
FALSE, /* reorderable */
min_items_x,
min_items_y,
item_factory))
menu_factory,
menu_identifier))
{
return FALSE;
}

6
app/widgets/gimpdatafactoryview.h
View file

@ -69,7 +69,8 @@ GtkWidget * gimp_data_factory_view_new (GimpViewType view_type,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory);
GimpMenuFactory *menu_factory,
const gchar *menu_identifier);
/* protected */
@ -82,7 +83,8 @@ gboolean gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory);
GimpMenuFactory *menu_factory,
const gchar *menu_identifier);
#endif /* __GIMP_DATA_FACTORY_VIEW_H__ */

33
app/widgets/gimpdialogfactory.c
View file

@ -40,7 +40,7 @@
#include "gimpdockbook.h"
#include "gimpdockable.h"
#include "gimpimagedock.h"
#include "gimpitemfactory.h"
#include "gimpmenufactory.h"
/* #define DEBUG_FACTORY */
@ -153,7 +153,7 @@ gimp_dialog_factory_class_init (GimpDialogFactoryClass *klass)
static void
gimp_dialog_factory_init (GimpDialogFactory *factory)
{
factory->item_factory = NULL;
factory->menu_factory = NULL;
factory->new_dock_func = NULL;
factory->registered_dialogs = NULL;
factory->session_infos = NULL;
@ -235,7 +235,7 @@ gimp_dialog_factory_finalize (GObject *object)
GimpDialogFactory *
gimp_dialog_factory_new (const gchar *name,
GimpContext *context,
GimpItemFactory *item_factory,
GimpMenuFactory *menu_factory,
GimpDialogNewFunc new_dock_func)
{
GimpDialogFactoryClass *factory_class;
@ -243,7 +243,7 @@ gimp_dialog_factory_new (const gchar *name,
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (! item_factory || GIMP_IS_ITEM_FACTORY (item_factory),
g_return_val_if_fail (! menu_factory || GIMP_IS_MENU_FACTORY (menu_factory),
NULL);
/* EEK */
@ -264,7 +264,7 @@ gimp_dialog_factory_new (const gchar *name,
GIMP_OBJECT (factory)->name, factory);
factory->context = context;
factory->item_factory = item_factory;
factory->menu_factory = menu_factory;
factory->new_dock_func = new_dock_func;
return factory;
@ -419,10 +419,14 @@ gimp_dialog_factory_dialog_new_internal (GimpDialogFactory *factory,
*/
if (factory->new_dock_func && ! context)
{
dock = gimp_dialog_factory_dock_new (factory);
GtkWidget *dockbook;
dock = gimp_dialog_factory_dock_new (factory);
dockbook = gimp_dockbook_new (factory->menu_factory);
gimp_dock_add_book (GIMP_DOCK (dock),
GIMP_DOCKBOOK (gimp_dockbook_new ()), 0);
GIMP_DOCKBOOK (dockbook),
0);
}
/* Create the new dialog in the appropriate context which is
@ -1180,12 +1184,12 @@ gimp_dialog_factories_restore_foreach (gchar *name,
for (books = info->sub_dialogs; books; books = g_list_next (books))
{
GimpDockbook *dockbook;
GList *pages;
GtkWidget *dockbook;
GList *pages;
dockbook = GIMP_DOCKBOOK (gimp_dockbook_new ());
dockbook = gimp_dockbook_new (factory->menu_factory);
gimp_dock_add_book (dock, dockbook, -1);
gimp_dock_add_book (dock, GIMP_DOCKBOOK (dockbook), -1);
for (pages = books->data; pages; pages = g_list_next (pages))
{
@ -1218,7 +1222,8 @@ gimp_dialog_factories_restore_foreach (gchar *name,
preview_size);
if (dockable)
gimp_dockbook_add (dockbook, GIMP_DOCKABLE (dockable), -1);
gimp_dockbook_add (GIMP_DOCKBOOK (dockbook),
GIMP_DOCKABLE (dockable), -1);
g_free (identifier);
}
@ -1309,8 +1314,8 @@ gimp_dialog_factory_set_window_geometry (GtkWidget *window,
screen_height = gdk_screen_height ();
}
info->x = CLAMP (info->x, 0, screen_width - 32);
info->y = CLAMP (info->y, 0, screen_height - 32);
info->x = CLAMP (info->x, 0, screen_width - 128);
info->y = CLAMP (info->y, 0, screen_height - 128);
gtk_window_move (GTK_WINDOW (window), info->x, info->y);

4
app/widgets/gimpdialogfactory.h
View file

@ -84,7 +84,7 @@ struct _GimpDialogFactory
GimpObject parent_instance;
GimpContext *context;
GimpItemFactory *item_factory;
GimpMenuFactory *menu_factory;
/*< private >*/
GimpDialogNewFunc new_dock_func;
@ -107,7 +107,7 @@ GType gimp_dialog_factory_get_type (void) G_GNUC_CONST;
GimpDialogFactory * gimp_dialog_factory_new (const gchar *name,
GimpContext *context,
GimpItemFactory *item_factory,
GimpMenuFactory *menu_factory,
GimpDialogNewFunc new_dock_func);
GimpDialogFactory * gimp_dialog_factory_from_name (const gchar *name);

2
app/widgets/gimpdock.c
View file

@ -650,7 +650,7 @@ gimp_dock_separator_drag_drop (GtkWidget *widget,
gimp_dockbook_remove (src_dockable->dockbook, src_dockable);
dockbook = gimp_dockbook_new ();
dockbook = gimp_dockbook_new (dock->dialog_factory->menu_factory);
gimp_dock_add_book (dock, GIMP_DOCKBOOK (dockbook), index);
gimp_dockbook_add (GIMP_DOCKBOOK (dockbook), src_dockable, -1);

60
app/widgets/gimpdockbook.c
View file

@ -29,12 +29,15 @@
#include "widgets-types.h"
#include "core/gimpcontext.h"
#include "gimpdialogfactory.h"
#include "gimpdnd.h"
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimpimagedock.h"
#include "gimpitemfactory.h"
#include "gimpmenufactory.h"
#include "gimppreview.h"
@ -48,6 +51,8 @@
static void gimp_dockbook_class_init (GimpDockbookClass *klass);
static void gimp_dockbook_init (GimpDockbook *dockbook);
static void gimp_dockbook_finalize (GObject *object);
static void gimp_dockbook_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static gboolean gimp_dockbook_drag_drop (GtkWidget *widget,
@ -119,12 +124,16 @@ gimp_dockbook_get_type (void)
static void
gimp_dockbook_class_init (GimpDockbookClass *klass)
{
GObjectClass *object_class;
GtkWidgetClass *widget_class;
object_class = G_OBJECT_CLASS (klass);
widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_dockbook_finalize;
widget_class->style_set = gimp_dockbook_style_set;
widget_class->drag_drop = gimp_dockbook_drag_drop;
@ -145,7 +154,8 @@ gimp_dockbook_class_init (GimpDockbookClass *klass)
static void
gimp_dockbook_init (GimpDockbook *dockbook)
{
dockbook->dock = NULL;
dockbook->dock = NULL;
dockbook->item_factory = NULL;
gtk_notebook_popup_enable (GTK_NOTEBOOK (dockbook));
gtk_notebook_set_scrollable (GTK_NOTEBOOK (dockbook), TRUE);
@ -156,10 +166,38 @@ gimp_dockbook_init (GimpDockbook *dockbook)
GDK_ACTION_MOVE);
}
GtkWidget *
gimp_dockbook_new (void)
static void
gimp_dockbook_finalize (GObject *object)
{
return GTK_WIDGET (g_object_new (GIMP_TYPE_DOCKBOOK, NULL));
GimpDockbook *dockbook;
dockbook = GIMP_DOCKBOOK (object);
if (dockbook->item_factory)
{
g_object_unref (dockbook->item_factory);
dockbook->item_factory = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GtkWidget *
gimp_dockbook_new (GimpMenuFactory *menu_factory)
{
GimpDockbook *dockbook;
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
dockbook = g_object_new (GIMP_TYPE_DOCKBOOK, NULL);
dockbook->item_factory = gimp_menu_factory_menu_new (menu_factory,
"<Dialogs>",
GTK_TYPE_MENU,
menu_factory->gimp,
FALSE);
return GTK_WIDGET (dockbook);
}
static void
@ -507,13 +545,11 @@ gimp_dockbook_tab_button_press (GtkWidget *widget,
if (bevent->button == 3)
{
GimpItemFactory *item_factory;
GtkWidget *add_widget;
GtkWidget *add_widget;
item_factory = dockbook->dock->dialog_factory->item_factory;
add_widget = gtk_item_factory_get_widget (GTK_ITEM_FACTORY (item_factory),
"/Select Tab");
add_widget =
gtk_item_factory_get_widget (GTK_ITEM_FACTORY (dockbook->item_factory),
"/Select Tab");
/* do evil things */
{
@ -537,7 +573,7 @@ gimp_dockbook_tab_button_press (GtkWidget *widget,
*/
g_object_ref (dockbook);
gimp_item_factory_popup_with_data (item_factory,
gimp_item_factory_popup_with_data (dockbook->item_factory,
dockbook,
(GtkDestroyNotify) gimp_dockbook_menu_end);
}
@ -649,7 +685,7 @@ gimp_dockbook_tab_drag_end (GtkWidget *widget,
gtk_window_set_position (GTK_WINDOW (dock), GTK_WIN_POS_MOUSE);
dockbook = gimp_dockbook_new ();
dockbook = gimp_dockbook_new (src_dock->dialog_factory->menu_factory);
gimp_dock_add_book (GIMP_DOCK (dock), GIMP_DOCKBOOK (dockbook), 0);

7
app/widgets/gimpdockbook.h
View file

@ -38,9 +38,10 @@ typedef struct _GimpDockbookClass GimpDockbookClass;
struct _GimpDockbook
{
GtkNotebook parent_instance;
GtkNotebook parent_instance;
GimpDock *dock;
GimpDock *dock;
GimpItemFactory *item_factory;
};
struct _GimpDockbookClass
@ -51,7 +52,7 @@ struct _GimpDockbookClass
GType gimp_dockbook_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_dockbook_new (void);
GtkWidget * gimp_dockbook_new (GimpMenuFactory *menu_factory);
void gimp_dockbook_add (GimpDockbook *dockbook,
GimpDockable *dockable,

31
app/widgets/gimpdocumentview.c
View file

@ -45,8 +45,6 @@
#include "display/gimpdisplay.h"
#include "gui/file-open-dialog.h"
#include "gimpcontainerview.h"
#include "gimpdocumentview.h"
#include "gimpdnd.h"
@ -130,18 +128,21 @@ gimp_document_view_init (GimpDocumentView *view)
}
GtkWidget *
gimp_document_view_new (GimpViewType view_type,
GimpContainer *container,
GimpContext *context,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory)
gimp_document_view_new (GimpViewType view_type,
GimpContainer *container,
GimpContext *context,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpFileOpenDialogFunc file_open_dialog_func,
GimpMenuFactory *menu_factory)
{
GimpDocumentView *document_view;
GimpContainerEditor *editor;
gchar *str;
g_return_val_if_fail (file_open_dialog_func != NULL, NULL);
document_view = g_object_new (GIMP_TYPE_DOCUMENT_VIEW, NULL);
if (! gimp_container_editor_construct (GIMP_CONTAINER_EDITOR (document_view),
@ -152,12 +153,14 @@ gimp_document_view_new (GimpViewType view_type,
TRUE, /* reorderable */
min_items_x,
min_items_y,
item_factory))
menu_factory, "<Documents>"))
{
g_object_unref (document_view);
return NULL;
}
document_view->file_open_dialog_func = file_open_dialog_func;
editor = GIMP_CONTAINER_EDITOR (document_view);
str = g_strdup_printf (_("Open the selected entry\n"
@ -235,7 +238,7 @@ gimp_document_view_open_clicked (GtkWidget *widget,
}
else
{
file_open_dialog_show (editor->view->context->gimp, NULL, NULL);
view->file_open_dialog_func (editor->view->context->gimp, NULL);
}
}
@ -285,8 +288,8 @@ gimp_document_view_open_extended_clicked (GtkWidget *widget,
{
if (state & GDK_CONTROL_MASK)
{
file_open_dialog_show (editor->view->context->gimp, NULL,
gimp_object_get_name (GIMP_OBJECT (imagefile)));
view->file_open_dialog_func (editor->view->context->gimp,
gimp_object_get_name (GIMP_OBJECT (imagefile)));
}
else if (state & GDK_SHIFT_MASK)
{
@ -311,7 +314,7 @@ gimp_document_view_open_extended_clicked (GtkWidget *widget,
}
else
{
file_open_dialog_show (editor->view->context->gimp, NULL, NULL);
view->file_open_dialog_func (editor->view->context->gimp, NULL);
}
}

29
app/widgets/gimpdocumentview.h
View file

@ -26,6 +26,10 @@
#include "gimpcontainereditor.h"
typedef void (* GimpFileOpenDialogFunc) (Gimp *gimp,
const gchar *uri);
#define GIMP_TYPE_DOCUMENT_VIEW (gimp_document_view_get_type ())
#define GIMP_DOCUMENT_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DOCUMENT_VIEW, GimpDocumentView))
#define GIMP_DOCUMENT_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DOCUMENT_VIEW, GimpDocumentViewClass))
@ -38,11 +42,13 @@ typedef struct _GimpDocumentViewClass GimpDocumentViewClass;
struct _GimpDocumentView
{
GimpContainerEditor parent_instance;
GimpContainerEditor parent_instance;
GtkWidget *open_button;
GtkWidget *remove_button;
GtkWidget *refresh_button;
GimpFileOpenDialogFunc file_open_dialog_func;
GtkWidget *open_button;
GtkWidget *remove_button;
GtkWidget *refresh_button;
};
struct _GimpDocumentViewClass
@ -53,13 +59,14 @@ struct _GimpDocumentViewClass
GType gimp_document_view_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_document_view_new (GimpViewType view_type,
GimpContainer *container,
GimpContext *context,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory);
GtkWidget * gimp_document_view_new (GimpViewType view_type,
GimpContainer *container,
GimpContext *context,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpFileOpenDialogFunc file_open_dialog_func,
GimpMenuFactory *menu_factory);
#endif /* __GIMP_DOCUMENT_VIEW_H__ */

23
app/widgets/gimpgradienteditor.c
View file

@ -520,15 +520,21 @@ gimp_gradient_editor_set_data (GimpDataEditor *editor,
/* public functions */
GimpDataEditor *
gimp_gradient_editor_new (Gimp *gimp)
gimp_gradient_editor_new (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
GimpGradientEditor *editor;
editor = g_object_new (GIMP_TYPE_GRADIENT_EDITOR, NULL);
gimp_data_editor_construct (GIMP_DATA_EDITOR (editor),
gimp,
GIMP_TYPE_GRADIENT);
if (! gimp_data_editor_construct (GIMP_DATA_EDITOR (editor),
gimp,
GIMP_TYPE_GRADIENT,
menu_factory, "<GradientEditor>"))
{
g_object_unref (editor);
return NULL;
}
return GIMP_DATA_EDITOR (editor);
}
@ -768,11 +774,8 @@ preview_events (GtkWidget *widget,
case 3:
if (! GIMP_DATA_EDITOR (editor)->data->internal)
{
GimpItemFactory *factory;
factory = gimp_item_factory_from_path ("<GradientEditor>");
gimp_item_factory_popup_with_data (factory, editor, NULL);
gimp_item_factory_popup_with_data (GIMP_DATA_EDITOR (editor)->item_factory,
editor, NULL);
}
break;
@ -1311,7 +1314,7 @@ control_button_press (GimpGradientEditor *editor,
{
GimpItemFactory *factory;
factory = gimp_item_factory_from_path ("<GradientEditor>");
factory = GIMP_DATA_EDITOR (editor)->item_factory;
gimp_item_factory_popup_with_data (factory, editor, NULL);
}

3
app/widgets/gimpgradienteditor.h
View file

@ -121,7 +121,8 @@ struct _GimpGradientEditorClass
GType gimp_gradient_editor_get_type (void) G_GNUC_CONST;
GimpDataEditor * gimp_gradient_editor_new (Gimp *gimp);
GimpDataEditor * gimp_gradient_editor_new (Gimp *gimp,
GimpMenuFactory *menu_factory);
void gimp_gradient_editor_update (GimpGradientEditor *editor,
GradientEditorUpdateMask flags);

4
app/widgets/gimpimageview.c
View file

@ -114,7 +114,7 @@ gimp_image_view_new (GimpViewType view_type,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory)
GimpMenuFactory *menu_factory)
{
GimpImageView *image_view;
GimpContainerEditor *editor;
@ -129,7 +129,7 @@ gimp_image_view_new (GimpViewType view_type,
TRUE, /* reorderable */
min_items_x,
min_items_y,
item_factory))
menu_factory, "<Images>"))
{
g_object_unref (image_view);
return NULL;

2
app/widgets/gimpimageview.h
View file

@ -59,7 +59,7 @@ GtkWidget * gimp_image_view_new (GimpViewType view_type,
gint preview_size,
gint min_items_x,
gint min_items_y,
GimpItemFactory *item_factory);
GimpMenuFactory *menu_factory);
#endif /* __GIMP_IMAGE_VIEW_H__ */

25
app/widgets/gimpitemfactory.c
View file

@ -113,8 +113,9 @@ gimp_item_factory_class_init (GimpItemFactoryClass *klass)
static void
gimp_item_factory_init (GimpItemFactory *factory)
{
factory->gimp = NULL;
factory->update_func = NULL;
factory->gimp = NULL;
factory->update_func = NULL;
factory->update_on_popup = FALSE;
}
static void
@ -161,6 +162,7 @@ gimp_item_factory_new (Gimp *gimp,
const gchar *factory_path,
const gchar *help_path,
GimpItemFactoryUpdateFunc update_func,
gboolean update_on_popup,
guint n_entries,
GimpItemFactoryEntry *entries,
gpointer callback_data,
@ -190,8 +192,9 @@ gimp_item_factory_new (Gimp *gimp,
factory,
NULL);
factory->gimp = gimp;
factory->update_func = update_func;
factory->gimp = gimp;
factory->update_func = update_func;
factory->update_on_popup = update_on_popup;
list = g_hash_table_lookup (factory_class->factories, factory_path);
@ -358,6 +361,16 @@ gimp_item_factory_create_items (GimpItemFactory *item_factory,
}
}
void
gimp_item_factory_update (GimpItemFactory *item_factory,
gpointer popup_data)
{
g_return_if_fail (GIMP_IS_ITEM_FACTORY (item_factory));
if (item_factory->update_func)
item_factory->update_func (GTK_ITEM_FACTORY (item_factory), popup_data);
}
void
gimp_item_factory_popup_with_data (GimpItemFactory *item_factory,
gpointer data,
@ -369,8 +382,8 @@ gimp_item_factory_popup_with_data (GimpItemFactory *item_factory,
g_return_if_fail (GIMP_IS_ITEM_FACTORY (item_factory));
if (item_factory->update_func)
item_factory->update_func (GTK_ITEM_FACTORY (item_factory), data);
if (item_factory->update_on_popup)
gimp_item_factory_update (item_factory, data);
gimp_menu_position (GTK_MENU (GTK_ITEM_FACTORY (item_factory)->widget),
&x, &y,

10
app/widgets/gimpitemfactory.h
View file

@ -22,12 +22,6 @@
G_BEGIN_DECLS
typedef void (* GimpItemFactoryUpdateFunc) (GtkItemFactory *factory,
gpointer data);
typedef struct _GimpItemFactoryEntry GimpItemFactoryEntry;
struct _GimpItemFactoryEntry
{
GtkItemFactoryEntry entry;
@ -55,6 +49,7 @@ struct _GimpItemFactory
Gimp *gimp;
GimpItemFactoryUpdateFunc update_func;
gboolean update_on_popup;
};
struct _GimpItemFactoryClass
@ -72,6 +67,7 @@ GimpItemFactory * gimp_item_factory_new (Gimp *gimp,
const gchar *factory_path,
const gchar *help_path,
GimpItemFactoryUpdateFunc update_func,
gboolean update_on_popup,
guint n_entries,
GimpItemFactoryEntry *entries,
gpointer callback_data,
@ -95,6 +91,8 @@ void gimp_item_factory_create_items (GimpItemFactory *factory,
gboolean create_tearoff,
gboolean static_entries);
void gimp_item_factory_update (GimpItemFactory *item_factory,
gpointer popup_data);
void gimp_item_factory_popup_with_data (GimpItemFactory *factory,
gpointer data,
GtkDestroyNotify popdown_func);

14
app/widgets/gimpitemlistview.c
View file

@ -47,6 +47,7 @@
#include "gimpitemfactory.h"
#include "gimplayerlistview.h"
#include "gimplistitem.h"
#include "gimpmenufactory.h"
#include "gimppreview.h"
#include "gimpvectorslistview.h"
#include "gimpwidgets-utils.h"
@ -289,7 +290,8 @@ gimp_item_list_view_new (gint preview_size,
GimpNewItemFunc new_item_func,
GimpEditItemFunc edit_item_func,
GimpActivateItemFunc activate_item_func,
GimpItemFactory *item_factory)
GimpMenuFactory *menu_factory,
const gchar *menu_identifier)
{
GimpItemListView *list_view;
GimpContainerView *view;
@ -309,7 +311,8 @@ gimp_item_list_view_new (gint preview_size,
g_return_val_if_fail (new_item_func != NULL, NULL);
g_return_val_if_fail (edit_item_func != NULL, NULL);
g_return_val_if_fail (activate_item_func != NULL, NULL);
g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (menu_identifier != NULL, NULL);
if (item_type == GIMP_TYPE_LAYER)
{
@ -351,8 +354,11 @@ gimp_item_list_view_new (gint preview_size,
list_view->edit_item_func = edit_item_func;
list_view->activate_item_func = activate_item_func;
list_view->item_factory = item_factory;
g_object_ref (list_view->item_factory);
list_view->item_factory = gimp_menu_factory_menu_new (menu_factory,
menu_identifier,
GTK_TYPE_MENU,
menu_factory->gimp,
FALSE);
/* connect "drop to new" manually as it makes a difference whether
* it was clicked or dropped

3
app/widgets/gimpitemlistview.h
View file

@ -120,7 +120,8 @@ GtkWidget * gimp_item_list_view_new (gint preview_size,
GimpNewItemFunc new_item_func,
GimpEditItemFunc edit_item_func,
GimpActivateItemFunc activate_item_func,
GimpItemFactory *item_facotry);
GimpMenuFactory *menu_facotry,
const gchar *menu_identifier);
void gimp_item_list_view_set_image (GimpItemListView *view,
GimpImage *gimage);

14
app/widgets/gimpitemtreeview.c
View file

@ -47,6 +47,7 @@
#include "gimpitemfactory.h"
#include "gimplayerlistview.h"
#include "gimplistitem.h"
#include "gimpmenufactory.h"
#include "gimppreview.h"
#include "gimpvectorslistview.h"
#include "gimpwidgets-utils.h"
@ -289,7 +290,8 @@ gimp_item_list_view_new (gint preview_size,
GimpNewItemFunc new_item_func,
GimpEditItemFunc edit_item_func,
GimpActivateItemFunc activate_item_func,
GimpItemFactory *item_factory)
GimpMenuFactory *menu_factory,
const gchar *menu_identifier)
{
GimpItemListView *list_view;
GimpContainerView *view;
@ -309,7 +311,8 @@ gimp_item_list_view_new (gint preview_size,
g_return_val_if_fail (new_item_func != NULL, NULL);
g_return_val_if_fail (edit_item_func != NULL, NULL);
g_return_val_if_fail (activate_item_func != NULL, NULL);
g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (menu_identifier != NULL, NULL);
if (item_type == GIMP_TYPE_LAYER)
{
@ -351,8 +354,11 @@ gimp_item_list_view_new (gint preview_size,
list_view->edit_item_func = edit_item_func;
list_view->activate_item_func = activate_item_func;
list_view->item_factory = item_factory;
g_object_ref (list_view->item_factory);
list_view->item_factory = gimp_menu_factory_menu_new (menu_factory,
menu_identifier,
GTK_TYPE_MENU,
menu_factory->gimp,
FALSE);
/* connect "drop to new" manually as it makes a difference whether
* it was clicked or dropped

3
app/widgets/gimpitemtreeview.h
View file

@ -120,7 +120,8 @@ GtkWidget * gimp_item_list_view_new (gint preview_size,
GimpNewItemFunc new_item_func,
GimpEditItemFunc edit_item_func,
GimpActivateItemFunc activate_item_func,
GimpItemFactory *item_facotry);
GimpMenuFactory *menu_facotry,
const gchar *menu_identifier);
void gimp_item_list_view_set_image (GimpItemListView *view,
GimpImage *gimage);

206
app/widgets/gimpmenufactory.c Normal file
View file

@ -0,0 +1,206 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmenufactory.c
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
*
* 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 "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "core/gimp.h"
#include "gimpmenufactory.h"
#include "gimpitemfactory.h"
static void gimp_menu_factory_class_init (GimpMenuFactoryClass *klass);
static void gimp_menu_factory_init (GimpMenuFactory *factory);
static void gimp_menu_factory_finalize (GObject *object);
static GimpObjectClass *parent_class = NULL;
GType
gimp_menu_factory_get_type (void)
{
static GType factory_type = 0;
if (! factory_type)
{
static const GTypeInfo factory_info =
{
sizeof (GimpMenuFactoryClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_menu_factory_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpMenuFactory),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_menu_factory_init,
};
factory_type = g_type_register_static (GIMP_TYPE_OBJECT,
"GimpMenuFactory",
&factory_info, 0);
}
return factory_type;
}
static void
gimp_menu_factory_class_init (GimpMenuFactoryClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_menu_factory_finalize;
}
static void
gimp_menu_factory_init (GimpMenuFactory *factory)
{
factory->gimp = NULL;
factory->registered_menus = NULL;
}
static void
gimp_menu_factory_finalize (GObject *object)
{
GimpMenuFactory *factory;
GList *list;
factory = GIMP_MENU_FACTORY (object);
for (list = factory->registered_menus; list; list = g_list_next (list))
{
GimpMenuFactoryEntry *entry;
entry = (GimpMenuFactoryEntry *) list->data;
g_free (entry->identifier);
g_free (entry->help_path);
g_free (entry);
}
g_list_free (factory->registered_menus);
factory->registered_menus = NULL;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GimpMenuFactory *
gimp_menu_factory_new (Gimp *gimp)
{
GimpMenuFactory *factory;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
factory = g_object_new (GIMP_TYPE_MENU_FACTORY, NULL);
factory->gimp = gimp;
return factory;
}
void
gimp_menu_factory_menu_register (GimpMenuFactory *factory,
const gchar *identifier,
const gchar *help_path,
GimpItemFactorySetupFunc setup_func,
GimpItemFactoryUpdateFunc update_func,
gboolean update_on_popup,
guint n_entries,
GimpItemFactoryEntry *entries)
{
GimpMenuFactoryEntry *entry;
g_return_if_fail (GIMP_IS_MENU_FACTORY (factory));
g_return_if_fail (identifier != NULL);
g_return_if_fail (help_path != NULL);
g_return_if_fail (n_entries > 0);
g_return_if_fail (entries != NULL);
entry = g_new0 (GimpMenuFactoryEntry, 1);
entry->identifier = g_strdup (identifier);
entry->help_path = g_strdup (help_path);
entry->setup_func = setup_func;
entry->update_func = update_func;
entry->update_on_popup = update_on_popup ? TRUE : FALSE;
entry->n_entries = n_entries;
entry->entries = entries;
factory->registered_menus = g_list_prepend (factory->registered_menus, entry);
}
GimpItemFactory *
gimp_menu_factory_menu_new (GimpMenuFactory *factory,
const gchar *identifier,
GType container_type,
gpointer callback_data,
gboolean create_tearoff)
{
GList *list;
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (factory), NULL);
g_return_val_if_fail (identifier != NULL, NULL);
for (list = factory->registered_menus; list; list = g_list_next (list))
{
GimpMenuFactoryEntry *entry = list->data;
if (! strcmp (entry->identifier, identifier))
{
GimpItemFactory *item_factory;
item_factory = gimp_item_factory_new (factory->gimp,
container_type,
entry->identifier,
entry->help_path,
entry->update_func,
entry->update_on_popup,
entry->n_entries,
entry->entries,
callback_data,
create_tearoff);
if (entry->setup_func)
entry->setup_func (item_factory);
return item_factory;
}
}
g_warning ("%s: no entry registered for \"%s\"",
G_GNUC_FUNCTION, identifier);
return NULL;
}

87
app/widgets/gimpmenufactory.h Normal file
View file

@ -0,0 +1,87 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmenufactory.h
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* 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.
*/
#ifndef __GIMP_MENU_FACTORY_H__
#define __GIMP_MENU_FACTORY_H__
#include "core/gimpobject.h"
typedef struct _GimpMenuFactoryEntry GimpMenuFactoryEntry;
struct _GimpMenuFactoryEntry
{
gchar *identifier;
gchar *help_path;
GimpItemFactorySetupFunc setup_func;
GimpItemFactoryUpdateFunc update_func;
gboolean update_on_popup;
guint n_entries;
GimpItemFactoryEntry *entries;
};
#define GIMP_TYPE_MENU_FACTORY (gimp_menu_factory_get_type ())
#define GIMP_MENU_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_MENU_FACTORY, GimpMenuFactory))
#define GIMP_MENU_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_MENU_FACTORY, GimpMenuFactoryClass))
#define GIMP_IS_MENU_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_MENU_FACTORY))
#define GIMP_IS_MENU_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_MENU_FACTORY))
#define GIMP_MENU_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_MENU_FACTORY, GimpMenuFactoryClass))
typedef struct _GimpMenuFactoryClass GimpMenuFactoryClass;
struct _GimpMenuFactory
{
GimpObject parent_instance;
Gimp *gimp;
GList *registered_menus;
};
struct _GimpMenuFactoryClass
{
GimpObjectClass parent_class;
};
GType gimp_menu_factory_get_type (void) G_GNUC_CONST;
GimpMenuFactory * gimp_menu_factory_new (Gimp *gimp);
void gimp_menu_factory_menu_register (GimpMenuFactory *factory,
const gchar *identifier,
const gchar *help_path,
GimpItemFactorySetupFunc setup_func,
GimpItemFactoryUpdateFunc update_func,
gboolean update_on_popup,
guint n_entries,
GimpItemFactoryEntry *entries);
GimpItemFactory * gimp_menu_factory_menu_new (GimpMenuFactory *factory,
const gchar *identifier,
GType container_type,
gpointer callback_data,
gboolean create_tearoff);
#endif /* __GIMP_MENU_FACTORY_H__ */

21
app/widgets/gimppaletteeditor.c
View file

@ -388,15 +388,21 @@ gimp_palette_editor_set_data (GimpDataEditor *editor,
/* public functions */
GimpDataEditor *
gimp_palette_editor_new (Gimp *gimp)
gimp_palette_editor_new (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
GimpPaletteEditor *palette_editor;
palette_editor = g_object_new (GIMP_TYPE_PALETTE_EDITOR, NULL);
gimp_data_editor_construct (GIMP_DATA_EDITOR (palette_editor),
gimp,
GIMP_TYPE_PALETTE);
if (! gimp_data_editor_construct (GIMP_DATA_EDITOR (palette_editor),
gimp,
GIMP_TYPE_PALETTE,
menu_factory, "<PaletteEditor>"))
{
g_object_unref (palette_editor);
return NULL;
}
return GIMP_DATA_EDITOR (palette_editor);
}
@ -452,11 +458,8 @@ palette_editor_eventbox_button_press (GtkWidget *widget,
{
if (bevent->button == 3)
{
GimpItemFactory *factory;
factory = gimp_item_factory_from_path ("<PaletteEditor>");
gimp_item_factory_popup_with_data (factory, editor, NULL);
gimp_item_factory_popup_with_data (GIMP_DATA_EDITOR (editor)->item_factory,
editor, NULL);
}
return TRUE;

3
app/widgets/gimppaletteeditor.h
View file

@ -76,7 +76,8 @@ struct _GimpPaletteEditorClass
GType gimp_palette_editor_get_type (void) G_GNUC_CONST;
GimpDataEditor * gimp_palette_editor_new (Gimp *gimp);
GimpDataEditor * gimp_palette_editor_new (Gimp *gimp,
GimpMenuFactory *menu_factory);
void gimp_palette_editor_update_color (GimpContext *context,
const GimpRGB *color,

13
app/widgets/widgets-types.h
View file

@ -32,6 +32,7 @@
typedef struct _GimpDeviceInfo GimpDeviceInfo;
typedef struct _GimpDialogFactory GimpDialogFactory;
typedef struct _GimpItemFactory GimpItemFactory;
typedef struct _GimpMenuFactory GimpMenuFactory;
/* widgets */
@ -102,10 +103,18 @@ typedef struct _GimpHistogramView GimpHistogramView;
typedef struct _GimpHistogramBox GimpHistogramBox;
/* structs */
typedef struct _GimpItemFactoryEntry GimpItemFactoryEntry;
/* function types */
typedef gchar * (* GimpItemGetNameFunc) (GtkWidget *widget,
gchar **tooltip);
typedef void (* GimpItemFactorySetupFunc) (GimpItemFactory *factory);
typedef void (* GimpItemFactoryUpdateFunc) (GtkItemFactory *factory,
gpointer data);
typedef gchar * (* GimpItemGetNameFunc) (GtkWidget *widget,
gchar **tooltip);
#endif /* __WIDGETS_TYPES_H__ */