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

removed GimpFillType. 

2001-06-29  Michael Natterer  <mitch@gimp.org>

	* app/appenums.h: removed GimpFillType.

	* app/gimprc.c: parse the session-info's new "aux-info" field.

	* app/global_edit.[ch]: removed the old "Paste Named" dialog and
	prefixed all functions with "gimp_".

	* app/core/core-types.h: added GimpFillType.

	* app/core/gimpbrush.[ch]: new signal "spacing_changed".

	* app/gui/Makefile.am
	* app/gui/tools-commands.[ch]: one more file cut out of commands.[ch].

	* app/gui/commands.[ch]: removed the tools stuff here.

	* app/gui/brush-select.[ch]
	* app/gui/dialogs-constructors.c: use the new GimpBrushFactoryView
	(see below).

	* app/gui/dialogs-commands.[ch]
	* app/gui/menus.[ch]:

	- Made it 64bit safe again by passing the dialog factory's
	  identifiers as GQuarks, not as guints created by GPOINTER_TO_UINT().
	- Added a "gchar *quark_string" field to GimpItemFactoryEntry
	  which gets transformed into a GQuark by menus_create_item().
	- Added SEPARATOR() and BRANCH() macros which make the *_entries[]
	  arrays more readable.
	- Added a menu item to show/hide GimpImageDock's image menu.
	- Removed file_last_opened_cmd_callback().

	* app/gui/edit-commands.c: the global_edit functions are "gimp_"
	prefixed now.

	* app/gui/file-commands.[ch]: added file_last_opened_cmd_callback()
	here.

	* app/widgets/Makefile.am
	* app/widgets/widgets-types.h
	* app/widgets/gimpbrushfactoryview.[ch]: new widget: a
	GimpDataFactory subclass with a "spacing" scale.

	* app/widgets/gimpcontainereditor.[ch]:

	- Connect to the GimpContainerView's "select_item",
	  "activate_item" and "context_item" signals here once instead of
	  in each subclass and dispatch them via new virtual functions.
	- Added a convenience function which makes DND to the buttons much
	  less painful for subclasses.

	* app/widgets/gimpbufferview.c
	* app/widgets/gimpdatafactoryview.[ch]: changed accordingly.

	* app/widgets/gimpdialogfactory.[ch]:

	- Added gimp_dialog_factory_dialog_raise() which can raise
	  toplevel dialogs _and_ dockables (and creates them if they are
	  not open yet).
	- Keep track of all created dialogs (not only toplevels).
	- Added an "aux_info" field to GimpSessionInfo which is a GList of
	  gchar* and is saved in sessionrc.
	- Remember if GimpImageDock's image menu is visible by using an
	  aux_info string.
	- The code did not become nicer with all those new constraints. I
	  have to add comments before I forget how it works.

	* app/widgets/gimpdockbook.c: set the state of the "Show Image Menu"
	menu item before popping up the item factory.

	* app/widgets/gimpimagedock.[ch]: added
	gimp_image_dock_set_show_image_meu().

	* plug-ins/gdyntext/gdyntext.c
	* plug-ins/perl/examples/fit-text
	* plug-ins/perl/examples/terral_text
	* plug-ins/perl/examples/tex-to-float: register all text rendering
	plug-ins under <Image>/Filters/Text

	* app/pdb/brush_select_cmds.c
	* app/pdb/drawable_cmds.c
	* app/pdb/edit_cmds.c
	* tools/pdbgen/pdb/brush_select.pdb
	* tools/pdbgen/pdb/edit.pdb
	* tools/pdbgen/enums.pl
	* po/POTFILES.in: changed according to all the stuff above.
This commit is contained in:
Michael Natterer 2001-06-29 19:25:03 +00:00 committed by Michael Natterer
parent def2f7762b
commit d81b47ce70
71 changed files with 4072 additions and 3217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
ChangeLog
View File

@ -1,3 +1,92 @@
2001-06-29 Michael Natterer <mitch@gimp.org>
* app/appenums.h: removed GimpFillType.
* app/gimprc.c: parse the session-info's new "aux-info" field.
* app/global_edit.[ch]: removed the old "Paste Named" dialog and
prefixed all functions with "gimp_".
* app/core/core-types.h: added GimpFillType.
* app/core/gimpbrush.[ch]: new signal "spacing_changed".
* app/gui/Makefile.am
* app/gui/tools-commands.[ch]: one more file cut out of commands.[ch].
* app/gui/commands.[ch]: removed the tools stuff here.
* app/gui/brush-select.[ch]
* app/gui/dialogs-constructors.c: use the new GimpBrushFactoryView
(see below).
* app/gui/dialogs-commands.[ch]
* app/gui/menus.[ch]:
- Made it 64bit safe again by passing the dialog factory's
identifiers as GQuarks, not as guints created by GPOINTER_TO_UINT().
- Added a "gchar *quark_string" field to GimpItemFactoryEntry
which gets transformed into a GQuark by menus_create_item().
- Added SEPARATOR() and BRANCH() macros which make the *_entries[]
arrays more readable.
- Added a menu item to show/hide GimpImageDock's image menu.
- Removed file_last_opened_cmd_callback().
* app/gui/edit-commands.c: the global_edit functions are "gimp_"
prefixed now.
* app/gui/file-commands.[ch]: added file_last_opened_cmd_callback()
here.
* app/widgets/Makefile.am
* app/widgets/widgets-types.h
* app/widgets/gimpbrushfactoryview.[ch]: new widget: a
GimpDataFactory subclass with a "spacing" scale.
* app/widgets/gimpcontainereditor.[ch]:
- Connect to the GimpContainerView's "select_item",
"activate_item" and "context_item" signals here once instead of
in each subclass and dispatch them via new virtual functions.
- Added a convenience function which makes DND to the buttons much
less painful for subclasses.
* app/widgets/gimpbufferview.c
* app/widgets/gimpdatafactoryview.[ch]: changed accordingly.
* app/widgets/gimpdialogfactory.[ch]:
- Added gimp_dialog_factory_dialog_raise() which can raise
toplevel dialogs _and_ dockables (and creates them if they are
not open yet).
- Keep track of all created dialogs (not only toplevels).
- Added an "aux_info" field to GimpSessionInfo which is a GList of
gchar* and is saved in sessionrc.
- Remember if GimpImageDock's image menu is visible by using an
aux_info string.
- The code did not become nicer with all those new constraints. I
have to add comments before I forget how it works.
* app/widgets/gimpdockbook.c: set the state of the "Show Image Menu"
menu item before popping up the item factory.
* app/widgets/gimpimagedock.[ch]: added
gimp_image_dock_set_show_image_meu().
* plug-ins/gdyntext/gdyntext.c
* plug-ins/perl/examples/fit-text
* plug-ins/perl/examples/terral_text
* plug-ins/perl/examples/tex-to-float: register all text rendering
plug-ins under <Image>/Filters/Text
* app/pdb/brush_select_cmds.c
* app/pdb/drawable_cmds.c
* app/pdb/edit_cmds.c
* tools/pdbgen/pdb/brush_select.pdb
* tools/pdbgen/pdb/edit.pdb
* tools/pdbgen/enums.pl
* po/POTFILES.in: changed according to all the stuff above.
2001-06-27 Sven Neumann <sven@gimp.org>
* README.i18n: merged changes from stable branch.

42
app/actions/dialogs-commands.c
View File

@ -24,9 +24,9 @@
#include "widgets/widgets-types.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpdock.h"
#include "widgets/gimpdockable.h"
#include "widgets/gimpdockbook.h"
#include "widgets/gimpimagedock.h"
#include "dialogs.h"
#include "dialogs-commands.h"
@ -39,8 +39,12 @@ dialogs_create_toplevel_cmd_callback (GtkWidget *widget,
{
if (action)
{
gimp_dialog_factory_dialog_new (global_dialog_factory,
GUINT_TO_POINTER (action));
gchar *identifier;
identifier = g_quark_to_string ((GQuark) action);
if (identifier)
gimp_dialog_factory_dialog_new (global_dialog_factory, identifier);
}
}
@ -56,13 +60,19 @@ dialogs_add_tab_cmd_callback (GtkWidget *widget,
if (dockbook && action)
{
GtkWidget *dockable;
gchar *identifier;
dockable = gimp_dialog_factory_dockable_new (dockbook->dock->factory,
dockbook->dock,
GUINT_TO_POINTER (action));
identifier = g_quark_to_string ((GQuark) action);
if (dockable)
gimp_dockbook_add (dockbook, GIMP_DOCKABLE (dockable), -1);
if (identifier)
{
dockable = gimp_dialog_factory_dockable_new (dockbook->dock->factory,
dockbook->dock,
identifier);
if (dockable)
gimp_dockbook_add (dockbook, GIMP_DOCKABLE (dockable), -1);
}
}
}
@ -90,6 +100,22 @@ dialogs_remove_tab_cmd_callback (GtkWidget *widget,
}
}
void
dialogs_toggle_image_menu_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GimpDockbook *dockbook;
dockbook = (GimpDockbook *) gtk_item_factory_popup_data_from_widget (widget);
if (dockbook)
{
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dockbook->dock),
GTK_CHECK_MENU_ITEM (widget)->active);
}
}
void
dialogs_create_lc_cmd_callback (GtkWidget *widget,
gpointer data,

27
app/actions/dialogs-commands.h
View File

@ -20,20 +20,23 @@
#define __DIALOGS_COMMANDS_H__
void dialogs_create_toplevel_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_create_toplevel_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_add_tab_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_remove_tab_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_add_tab_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_remove_tab_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_toggle_image_menu_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_create_lc_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_create_lc_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
#endif /* __DIALOGS_COMMANDS_H__ */

53
app/actions/edit-commands.c
View File

@ -34,6 +34,9 @@
#include "tools/tool_manager.h"
#include "widgets/gimpdialogfactory.h"
#include "dialogs.h"
#include "edit-commands.h"
#include "context_manager.h"
@ -91,8 +94,8 @@ edit_cut_cmd_callback (GtkWidget *widget,
/* stop any active tool */
tool_manager_control_active (HALT, gdisp);
if (edit_cut (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage)))
if (gimp_edit_cut (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage)))
{
gdisplays_flush ();
}
@ -105,8 +108,8 @@ edit_copy_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
edit_copy (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage));
gimp_edit_copy (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage));
}
void
@ -121,10 +124,10 @@ edit_paste_cmd_callback (GtkWidget *widget,
/* stop any active tool */
tool_manager_control_active (HALT, gdisp);
if (edit_paste (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
global_buffer,
FALSE))
if (gimp_edit_paste (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
global_buffer,
FALSE))
{
gdisplays_update_title (gdisp->gimage);
gdisplays_flush ();
@ -144,10 +147,10 @@ edit_paste_into_cmd_callback (GtkWidget *widget,
/* stop any active tool */
tool_manager_control_active (HALT, gdisp);
if (edit_paste (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
global_buffer,
TRUE))
if (gimp_edit_paste (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
global_buffer,
TRUE))
{
gdisplays_update_title (gdisp->gimage);
gdisplays_flush ();
@ -167,8 +170,8 @@ edit_paste_as_new_cmd_callback (GtkWidget *widget,
/* stop any active tool */
tool_manager_control_active (HALT, gdisp);
edit_paste_as_new (gdisp->gimage,
global_buffer);
gimp_edit_paste_as_new (gdisp->gimage,
global_buffer);
}
}
@ -220,7 +223,7 @@ edit_named_paste_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
named_edit_paste (gdisp->gimage);
gimp_dialog_factory_dialog_raise (global_dock_factory, "gimp:buffer-list");
}
void
@ -230,7 +233,7 @@ edit_clear_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
edit_clear (gdisp->gimage, gimp_image_active_drawable (gdisp->gimage));
gimp_edit_clear (gdisp->gimage, gimp_image_active_drawable (gdisp->gimage));
gdisplays_flush ();
}
@ -246,8 +249,10 @@ edit_fill_cmd_callback (GtkWidget *widget,
fill_type = (GimpFillType) action;
edit_fill (gdisp->gimage, gimp_image_active_drawable (gdisp->gimage),
fill_type);
gimp_edit_fill (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
fill_type);
gdisplays_flush ();
}
@ -258,7 +263,9 @@ edit_stroke_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
gimage_mask_stroke (gdisp->gimage, gimp_image_active_drawable (gdisp->gimage));
gimage_mask_stroke (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage));
gdisplays_flush ();
}
@ -275,7 +282,8 @@ cut_named_buffer_callback (GtkWidget *widget,
gimage = (GimpImage *) data;
new_tiles = edit_cut (gimage, gimp_image_active_drawable (gimage));
new_tiles = gimp_edit_cut (gimage,
gimp_image_active_drawable (gimage));
if (new_tiles)
{
@ -297,8 +305,9 @@ copy_named_buffer_callback (GtkWidget *widget,
GimpImage *gimage;
gimage = (GimpImage *) data;
new_tiles = edit_copy (gimage, gimp_image_active_drawable (gimage));
new_tiles = gimp_edit_copy (gimage,
gimp_image_active_drawable (gimage));
if (new_tiles)
{

27
app/actions/file-commands.c
View File

@ -31,6 +31,7 @@
#include "gdisplay.h"
#include "gdisplay_ops.h"
#include "image_new.h"
#include "menus.h"
#include "libgimp/gimpintl.h"
@ -69,6 +70,32 @@ file_open_cmd_callback (GtkWidget *widget,
file_open_callback (widget, data);
}
void
file_last_opened_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
gchar *filename;
guint num_entries;
gint status;
num_entries = g_slist_length (last_opened_raw_filenames);
if (action >= num_entries)
return;
filename =
((GString *) g_slist_nth_data (last_opened_raw_filenames, action))->str;
status = file_open_with_display (filename, filename);
if (status != GIMP_PDB_SUCCESS &&
status != GIMP_PDB_CANCEL)
{
g_message (_("Error opening file: %s\n"), filename);
}
}
void
file_save_cmd_callback (GtkWidget *widget,
gpointer data)

3
app/actions/file-commands.h
View File

@ -25,6 +25,9 @@ void file_new_cmd_callback (GtkWidget *widget,
guint action);
void file_open_cmd_callback (GtkWidget *widget,
gpointer data);
void file_last_opened_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_cmd_callback (GtkWidget *widget,
gpointer data);
void file_save_as_cmd_callback (GtkWidget *widget,

116
app/actions/help-commands.c
View File

@ -20,143 +20,37 @@
#include <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "core/core-types.h"
#include "tools/tools-types.h"
#include "core/gimpcontext.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
#include "core/gimptoolinfo.h"
#include "tools/gimptool.h"
#include "tools/tool_manager.h"
#include "commands.h"
#include "layer-select.h"
#include "app_procs.h"
#include "context_manager.h"
#include "gdisplay.h"
#include "gimprc.h"
#include "image_render.h"
#include "plug_in.h"
#include "undo.h"
#include "libgimp/gimpintl.h"
#define return_if_no_display(gdisp) \
gdisp = gdisplay_active (); \
if (!gdisp) return
/***** Tools *****/
void
tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer client_data)
{
gimp_context_set_default_colors (gimp_context_get_user ());
}
void
tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer client_data)
{
gimp_context_swap_colors (gimp_context_get_user ());
}
void
tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer client_data)
{
static GimpContext *swap_context = NULL;
static GimpContext *temp_context = NULL;
if (! swap_context)
{
swap_context = gimp_context_new ("Swap Context",
gimp_context_get_user ());
temp_context = gimp_context_new ("Temp Context", NULL);
}
gimp_context_copy_args (gimp_context_get_user (),
temp_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (swap_context,
gimp_context_get_user (),
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (temp_context,
swap_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
}
void
tools_select_cmd_callback (GtkWidget *widget,
gpointer callback_data,
guint callback_action)
{
GtkType tool_type;
GimpToolInfo *tool_info;
GDisplay *gdisp;
tool_type = callback_action;
tool_info = tool_manager_get_info_by_type (tool_type);
gdisp = gdisplay_active ();
gimp_context_set_tool (gimp_context_get_user (), tool_info);
#ifdef __GNUC__
#warning FIXME (let the tool manager to this stuff)
#endif
/* Paranoia */
active_tool->drawable = NULL;
/* Complete the initialisation by doing the same stuff
* tools_initialize() does after it did what tools_select() does
*/
if (GIMP_TOOL_CLASS (GTK_OBJECT (active_tool)->klass)->initialize)
{
gimp_tool_initialize (active_tool, gdisp);
active_tool->drawable = gimp_image_active_drawable (gdisp->gimage);
}
/* setting the tool->gdisp here is a HACK to allow the tools'
* dialog windows being hidden if the tool was selected from
* a tear-off-menu and there was no mouse click in the display
* before deleting it
*/
active_tool->gdisp = gdisp;
}
/***** Filters *****/
void
filters_repeat_cmd_callback (GtkWidget *widget,
gpointer callback_data,
guint callback_action)
gpointer data,
guint action)
{
plug_in_repeat (callback_action);
plug_in_repeat ((gboolean) action);
}
/***** Help *****/
void
help_help_cmd_callback (GtkWidget *widget,
gpointer client_data)
gpointer data)
{
gimp_standard_help_func (NULL);
}
void
help_context_help_cmd_callback (GtkWidget *widget,
gpointer client_data)
gpointer data)
{
gimp_context_help ();
}

24
app/actions/help-commands.h
View File

@ -20,24 +20,14 @@
#define __COMMANDS_H__
void tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_select_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void filters_repeat_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void filters_repeat_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void help_help_cmd_callback (GtkWidget *widget,
gpointer data);
void help_context_help_cmd_callback (GtkWidget *widget,
gpointer data);
void help_help_cmd_callback (GtkWidget *widget,
gpointer data);
void help_context_help_cmd_callback (GtkWidget *widget,
gpointer data);
#endif /* __COMMANDS_H__ */

117
app/actions/tools-commands.c Normal file
View File

@ -0,0 +1,117 @@
/* 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 <gtk/gtk.h>
#include "tools/tools-types.h"
#include "core/gimpcontext.h"
#include "core/gimpimage.h"
#include "tools/gimptool.h"
#include "tools/tool_manager.h"
#include "gdisplay.h"
#define return_if_no_display(gdisp) \
gdisp = gdisplay_active (); \
if (!gdisp) return
void
tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer data)
{
gimp_context_set_default_colors (gimp_context_get_user ());
}
void
tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer data)
{
gimp_context_swap_colors (gimp_context_get_user ());
}
void
tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer data)
{
static GimpContext *swap_context = NULL;
static GimpContext *temp_context = NULL;
if (! swap_context)
{
swap_context = gimp_context_new ("Swap Context",
gimp_context_get_user ());
temp_context = gimp_context_new ("Temp Context", NULL);
}
gimp_context_copy_args (gimp_context_get_user (),
temp_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (swap_context,
gimp_context_get_user (),
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (temp_context,
swap_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
}
void
tools_select_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GtkType tool_type;
GimpToolInfo *tool_info;
GDisplay *gdisp;
tool_type = (GtkType) action;
tool_info = tool_manager_get_info_by_type (tool_type);
gdisp = gdisplay_active ();
gimp_context_set_tool (gimp_context_get_user (), tool_info);
#ifdef __GNUC__
#warning FIXME (let the tool manager to this stuff)
#endif
/* Paranoia */
active_tool->drawable = NULL;
/* Complete the initialisation by doing the same stuff
* tools_initialize() does after it did what tools_select() does
*/
if (GIMP_TOOL_CLASS (GTK_OBJECT (active_tool)->klass)->initialize)
{
gimp_tool_initialize (active_tool, gdisp);
active_tool->drawable = gimp_image_active_drawable (gdisp->gimage);
}
/* setting the tool->gdisp here is a HACK to allow the tools'
* dialog windows being hidden if the tool was selected from
* a tear-off-menu and there was no mouse click in the display
* before deleting it
*/
active_tool->gdisp = gdisp;
}

34
app/actions/tools-commands.h Normal file
View File

@ -0,0 +1,34 @@
/* 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 __TOOLS_COMMANDS_H__
#define __TOOLS_COMMANDS_H__
void tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_select_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
#endif /* __TOOLS_COMMANDS_H__ */

10
app/appenums.h
View File

@ -20,16 +20,6 @@
#define __APPENUMS_H__
/* Fill types */
typedef enum
{
FOREGROUND_FILL, /*< nick=FG_IMAGE_FILL >*/
BACKGROUND_FILL, /*< nick=BG_IMAGE_FILL >*/
WHITE_FILL, /*< nick=WHITE_IMAGE_FILL >*/
TRANSPARENT_FILL, /*< nick=TRANS_IMAGE_FILL >*/
NO_FILL /*< nick=NO_IMAGE_FILL >*/
} GimpFillType;
/* Brush application types */
typedef enum
{

10
app/core/core-types.h
View File

@ -61,6 +61,16 @@ typedef enum
DISCARD
} MaskApplyMode;
/* Fill types */
typedef enum
{
FOREGROUND_FILL, /*< nick=FG_IMAGE_FILL >*/
BACKGROUND_FILL, /*< nick=BG_IMAGE_FILL >*/
WHITE_FILL, /*< nick=WHITE_IMAGE_FILL >*/
TRANSPARENT_FILL, /*< nick=TRANS_IMAGE_FILL >*/
NO_FILL /*< nick=NO_IMAGE_FILL >*/
} GimpFillType;
/* base objects */

284
app/core/gimp-edit.c
View File

@ -56,28 +56,9 @@
#include "libgimp/gimpintl.h"
typedef enum
{
PASTE,
PASTE_INTO,
PASTE_AS_NEW
} PasteAction;
typedef struct _PasteNamedDialog PasteNamedDialog;
struct _PasteNamedDialog
{
GtkWidget *shell;
GtkWidget *list;
GimpImage *gimage;
PasteAction action;
};
TileManager *
edit_cut (GimpImage *gimage,
GimpDrawable *drawable)
gimp_edit_cut (GimpImage *gimage,
GimpDrawable *drawable)
{
TileManager *cut;
TileManager *cropped_cut;
@ -133,8 +114,8 @@ edit_cut (GimpImage *gimage,
}
TileManager *
edit_copy (GimpImage *gimage,
GimpDrawable *drawable)
gimp_edit_copy (GimpImage *gimage,
GimpDrawable *drawable)
{
TileManager *copy;
TileManager *cropped_copy;
@ -184,10 +165,10 @@ edit_copy (GimpImage *gimage,
}
GimpLayer *
edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into)
gimp_edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into)
{
GimpLayer *layer;
gint x1, y1, x2, y2;
@ -262,8 +243,8 @@ edit_paste (GimpImage *gimage,
}
GimpImage *
edit_paste_as_new (GimpImage *invoke,
TileManager *paste)
gimp_edit_paste_as_new (GimpImage *invoke,
TileManager *paste)
{
GimpImage *gimage;
GimpLayer *layer;
@ -304,8 +285,8 @@ edit_paste_as_new (GimpImage *invoke,
}
gboolean
edit_clear (GimpImage *gimage,
GimpDrawable *drawable)
gimp_edit_clear (GimpImage *gimage,
GimpDrawable *drawable)
{
TileManager *buf_tiles;
PixelRegion bufPR;
@ -347,9 +328,9 @@ edit_clear (GimpImage *gimage,
}
gboolean
edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type)
gimp_edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type)
{
TileManager *buf_tiles;
PixelRegion bufPR;
@ -421,238 +402,3 @@ edit_fill (GimpImage *gimage,
return TRUE;
}
/*********************************************/
/* Named buffer operations */
static void
set_list_of_named_buffers (GtkWidget *list_widget)
{
GList *list;
GimpBuffer *buffer;
GtkWidget *list_item;
gtk_list_clear_items (GTK_LIST (list_widget), 0, -1);
for (list = GIMP_LIST (named_buffers)->list;
list;
list = g_list_next (list))
{
buffer = (GimpBuffer *) list->data;
list_item = gtk_list_item_new_with_label (GIMP_OBJECT (buffer)->name);
gtk_container_add (GTK_CONTAINER (list_widget), list_item);
gtk_object_set_user_data (GTK_OBJECT (list_item), buffer);
gtk_widget_show (list_item);
}
}
static void
named_buffer_paste_foreach (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
GimpBuffer *buffer;
if (widget->state == GTK_STATE_SELECTED)
{
pn_dialog = (PasteNamedDialog *) data;
buffer = (GimpBuffer *) gtk_object_get_user_data (GTK_OBJECT (widget));
switch (pn_dialog->action)
{
case PASTE:
edit_paste (pn_dialog->gimage,
gimp_image_active_drawable (pn_dialog->gimage),
buffer->tiles, FALSE);
break;
case PASTE_INTO:
edit_paste (pn_dialog->gimage,
gimp_image_active_drawable (pn_dialog->gimage),
buffer->tiles, TRUE);
break;
case PASTE_AS_NEW:
edit_paste_as_new (pn_dialog->gimage, buffer->tiles);
break;
default:
break;
}
}
gdisplays_flush ();
}
static void
named_buffer_paste_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
pn_dialog->action = PASTE_INTO;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_paste_foreach, data);
gtk_widget_destroy (pn_dialog->shell);
}
static void
named_buffer_paste_into_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
pn_dialog->action = PASTE_INTO;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_paste_foreach, data);
gtk_widget_destroy (pn_dialog->shell);
}
static void
named_buffer_paste_as_new_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
pn_dialog->action = PASTE_AS_NEW;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_paste_foreach, data);
gtk_widget_destroy (pn_dialog->shell);
}
static void
named_buffer_delete_foreach (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
GimpBuffer *buffer;
if (widget->state == GTK_STATE_SELECTED)
{
pn_dialog = (PasteNamedDialog *) data;
buffer = (GimpBuffer *) gtk_object_get_user_data (GTK_OBJECT (widget));
gimp_container_remove (named_buffers, GIMP_OBJECT (buffer));
}
}
static void
named_buffer_delete_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_delete_foreach, data);
set_list_of_named_buffers (pn_dialog->list);
}
static void
paste_named_buffer (GimpImage *gimage)
{
PasteNamedDialog *pn_dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *listbox;
GtkWidget *bbox;
GtkWidget *button;
gint i;
static gchar *paste_action_labels[] =
{
N_("Paste"),
N_("Paste Into"),
N_("Paste as New"),
};
static GtkSignalFunc paste_action_functions[] =
{
named_buffer_paste_callback,
named_buffer_paste_into_callback,
named_buffer_paste_as_new_callback,
};
pn_dialog = g_new0 (PasteNamedDialog, 1);
pn_dialog->gimage = gimage;
pn_dialog->shell =
gimp_dialog_new (_("Paste Named Buffer"), "paste_named_buffer",
gimp_standard_help_func,
"dialogs/paste_named.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("Delete"), named_buffer_delete_callback,
pn_dialog, NULL, NULL, FALSE, FALSE,
_("Cancel"), gtk_widget_destroy,
NULL, 1, NULL, TRUE, TRUE,
NULL);
gtk_signal_connect_object (GTK_OBJECT (pn_dialog->shell), "destroy",
GTK_SIGNAL_FUNC (g_free),
(GtkObject *) pn_dialog);
vbox = gtk_vbox_new (FALSE, 1);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 1);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (pn_dialog->shell)->vbox), vbox);
gtk_widget_show (vbox);
label = gtk_label_new (_("Select a buffer to paste:"));
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
gtk_widget_show (label);
listbox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (listbox),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), listbox, TRUE, TRUE, 0);
gtk_widget_set_usize (listbox, 125, 150);
gtk_widget_show (listbox);
pn_dialog->list = gtk_list_new ();
gtk_list_set_selection_mode (GTK_LIST (pn_dialog->list), GTK_SELECTION_BROWSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (listbox),
pn_dialog->list);
set_list_of_named_buffers (pn_dialog->list);
gtk_widget_show (pn_dialog->list);
bbox = gtk_hbutton_box_new ();
gtk_container_set_border_width (GTK_CONTAINER (bbox), 6);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), 2);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
for (i = 0; i < 3; i++)
{
button = gtk_button_new_with_label (gettext (paste_action_labels[i]));
gtk_container_add (GTK_CONTAINER (bbox), button);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) paste_action_functions[i],
pn_dialog);
gtk_widget_show (button);
}
gtk_widget_show (bbox);
gtk_widget_show (pn_dialog->shell);
}
gboolean
named_edit_paste (GimpImage *gimage)
{
paste_named_buffer (gimage);
return TRUE;
}

32
app/core/gimp-edit.h
View File

@ -20,23 +20,21 @@
#define __GLOBAL_EDIT_H__
TileManager * edit_cut (GimpImage *gimage,
GimpDrawable *drawable);
TileManager * edit_copy (GimpImage *gimage,
GimpDrawable *drawable);
GimpLayer * edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into);
GimpImage * edit_paste_as_new (GimpImage *gimage,
TileManager *tiles);
gboolean edit_clear (GimpImage *gimage,
GimpDrawable *drawable);
gboolean edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type);
gboolean named_edit_paste (GimpImage *gimage);
TileManager * gimp_edit_cut (GimpImage *gimage,
GimpDrawable *drawable);
TileManager * gimp_edit_copy (GimpImage *gimage,
GimpDrawable *drawable);
GimpLayer * gimp_edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into);
GimpImage * gimp_edit_paste_as_new (GimpImage *gimage,
TileManager *tiles);
gboolean gimp_edit_clear (GimpImage *gimage,
GimpDrawable *drawable);
gboolean gimp_edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type);
#endif /* __GLOBAL_EDIT_H__ */

46
app/core/gimpbrush-load.c
View File

@ -58,6 +58,13 @@
#include "libgimp/gimpintl.h"
enum
{
SPACING_CHANGED,
LAST_SIGNAL
};
static void gimp_brush_class_init (GimpBrushClass *klass);
static void gimp_brush_init (GimpBrush *brush);
static void gimp_brush_destroy (GtkObject *object);
@ -70,7 +77,9 @@ static GimpBrush * gimp_brush_select_brush (GimpPaintTool *paint_tool);
static gboolean gimp_brush_want_null_motion (GimpPaintTool *paint_tool);
static GimpViewableClass *parent_class = NULL;
static guint brush_signals[LAST_SIGNAL] = { 0 };
static GimpDataClass *parent_class = NULL;
GtkType
@ -110,14 +119,25 @@ gimp_brush_class_init (GimpBrushClass *klass)
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_brush_destroy;
brush_signals[SPACING_CHANGED] =
gtk_signal_new ("spacing_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpBrushClass,
spacing_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, brush_signals, LAST_SIGNAL);
object_class->destroy = gimp_brush_destroy;
viewable_class->get_new_preview = gimp_brush_get_new_preview;
data_class->get_extension = gimp_brush_get_extension;
data_class->get_extension = gimp_brush_get_extension;
klass->select_brush = gimp_brush_select_brush;
klass->want_null_motion = gimp_brush_want_null_motion;
klass->select_brush = gimp_brush_select_brush;
klass->want_null_motion = gimp_brush_want_null_motion;
}
static void
@ -379,7 +399,21 @@ gimp_brush_set_spacing (GimpBrush *brush,
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH (brush));
brush->spacing = spacing;
if (brush->spacing != spacing)
{
brush->spacing = spacing;
gimp_brush_spacing_changed (brush);
}
}
void
gimp_brush_spacing_changed (GimpBrush *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH (brush));
gtk_signal_emit (GTK_OBJECT (brush), brush_signals[SPACING_CHANGED]);
}
GimpBrush *

46
app/core/gimpbrush.c
View File

@ -58,6 +58,13 @@
#include "libgimp/gimpintl.h"
enum
{
SPACING_CHANGED,
LAST_SIGNAL
};
static void gimp_brush_class_init (GimpBrushClass *klass);
static void gimp_brush_init (GimpBrush *brush);
static void gimp_brush_destroy (GtkObject *object);
@ -70,7 +77,9 @@ static GimpBrush * gimp_brush_select_brush (GimpPaintTool *paint_tool);
static gboolean gimp_brush_want_null_motion (GimpPaintTool *paint_tool);
static GimpViewableClass *parent_class = NULL;
static guint brush_signals[LAST_SIGNAL] = { 0 };
static GimpDataClass *parent_class = NULL;
GtkType
@ -110,14 +119,25 @@ gimp_brush_class_init (GimpBrushClass *klass)
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_brush_destroy;
brush_signals[SPACING_CHANGED] =
gtk_signal_new ("spacing_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpBrushClass,
spacing_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, brush_signals, LAST_SIGNAL);
object_class->destroy = gimp_brush_destroy;
viewable_class->get_new_preview = gimp_brush_get_new_preview;
data_class->get_extension = gimp_brush_get_extension;
data_class->get_extension = gimp_brush_get_extension;
klass->select_brush = gimp_brush_select_brush;
klass->want_null_motion = gimp_brush_want_null_motion;
klass->select_brush = gimp_brush_select_brush;
klass->want_null_motion = gimp_brush_want_null_motion;
}
static void
@ -379,7 +399,21 @@ gimp_brush_set_spacing (GimpBrush *brush,
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH (brush));
brush->spacing = spacing;
if (brush->spacing != spacing)
{
brush->spacing = spacing;
gimp_brush_spacing_changed (brush);
}
}
void
gimp_brush_spacing_changed (GimpBrush *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH (brush));
gtk_signal_emit (GTK_OBJECT (brush), brush_signals[SPACING_CHANGED]);
}
GimpBrush *

25
app/core/gimpbrush.h
View File

@ -55,27 +55,30 @@ struct _GimpBrushClass
{
GimpDataClass parent_class;
void (* spacing_changed) (GimpBrush *brush);
/* FIXME: these are no virtual function pointers but bad hacks: */
GimpBrush * (* select_brush) (GimpPaintTool *paint_tool);
gboolean (* want_null_motion) (GimpPaintTool *paint_tool);
};
GtkType gimp_brush_get_type (void);
GtkType gimp_brush_get_type (void);
GimpData * gimp_brush_new (const gchar *name);
GimpData * gimp_brush_get_standard (void);
GimpData * gimp_brush_load (const gchar *filename);
GimpData * gimp_brush_new (const gchar *name);
GimpData * gimp_brush_get_standard (void);
GimpData * gimp_brush_load (const gchar *filename);
GimpBrush * gimp_brush_load_brush (gint fd,
const gchar *filename);
GimpBrush * gimp_brush_load_brush (gint fd,
const gchar *filename);
TempBuf * gimp_brush_get_mask (const GimpBrush *brush);
TempBuf * gimp_brush_get_pixmap (const GimpBrush *brush);
TempBuf * gimp_brush_get_mask (const GimpBrush *brush);
TempBuf * gimp_brush_get_pixmap (const GimpBrush *brush);
gint gimp_brush_get_spacing (const GimpBrush *brush);
void gimp_brush_set_spacing (GimpBrush *brush,
gint spacing);
gint gimp_brush_get_spacing (const GimpBrush *brush);
void gimp_brush_set_spacing (GimpBrush *brush,
gint spacing);
void gimp_brush_spacing_changed (GimpBrush *brush);
#endif /* __GIMP_BRUSH_H__ */

284
app/core/gimpedit.c
View File

@ -56,28 +56,9 @@
#include "libgimp/gimpintl.h"
typedef enum
{
PASTE,
PASTE_INTO,
PASTE_AS_NEW
} PasteAction;
typedef struct _PasteNamedDialog PasteNamedDialog;
struct _PasteNamedDialog
{
GtkWidget *shell;
GtkWidget *list;
GimpImage *gimage;
PasteAction action;
};
TileManager *
edit_cut (GimpImage *gimage,
GimpDrawable *drawable)
gimp_edit_cut (GimpImage *gimage,
GimpDrawable *drawable)
{
TileManager *cut;
TileManager *cropped_cut;
@ -133,8 +114,8 @@ edit_cut (GimpImage *gimage,
}
TileManager *
edit_copy (GimpImage *gimage,
GimpDrawable *drawable)
gimp_edit_copy (GimpImage *gimage,
GimpDrawable *drawable)
{
TileManager *copy;
TileManager *cropped_copy;
@ -184,10 +165,10 @@ edit_copy (GimpImage *gimage,
}
GimpLayer *
edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into)
gimp_edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into)
{
GimpLayer *layer;
gint x1, y1, x2, y2;
@ -262,8 +243,8 @@ edit_paste (GimpImage *gimage,
}
GimpImage *
edit_paste_as_new (GimpImage *invoke,
TileManager *paste)
gimp_edit_paste_as_new (GimpImage *invoke,
TileManager *paste)
{
GimpImage *gimage;
GimpLayer *layer;
@ -304,8 +285,8 @@ edit_paste_as_new (GimpImage *invoke,
}
gboolean
edit_clear (GimpImage *gimage,
GimpDrawable *drawable)
gimp_edit_clear (GimpImage *gimage,
GimpDrawable *drawable)
{
TileManager *buf_tiles;
PixelRegion bufPR;
@ -347,9 +328,9 @@ edit_clear (GimpImage *gimage,
}
gboolean
edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type)
gimp_edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type)
{
TileManager *buf_tiles;
PixelRegion bufPR;
@ -421,238 +402,3 @@ edit_fill (GimpImage *gimage,
return TRUE;
}
/*********************************************/
/* Named buffer operations */
static void
set_list_of_named_buffers (GtkWidget *list_widget)
{
GList *list;
GimpBuffer *buffer;
GtkWidget *list_item;
gtk_list_clear_items (GTK_LIST (list_widget), 0, -1);
for (list = GIMP_LIST (named_buffers)->list;
list;
list = g_list_next (list))
{
buffer = (GimpBuffer *) list->data;
list_item = gtk_list_item_new_with_label (GIMP_OBJECT (buffer)->name);
gtk_container_add (GTK_CONTAINER (list_widget), list_item);
gtk_object_set_user_data (GTK_OBJECT (list_item), buffer);
gtk_widget_show (list_item);
}
}
static void
named_buffer_paste_foreach (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
GimpBuffer *buffer;
if (widget->state == GTK_STATE_SELECTED)
{
pn_dialog = (PasteNamedDialog *) data;
buffer = (GimpBuffer *) gtk_object_get_user_data (GTK_OBJECT (widget));
switch (pn_dialog->action)
{
case PASTE:
edit_paste (pn_dialog->gimage,
gimp_image_active_drawable (pn_dialog->gimage),
buffer->tiles, FALSE);
break;
case PASTE_INTO:
edit_paste (pn_dialog->gimage,
gimp_image_active_drawable (pn_dialog->gimage),
buffer->tiles, TRUE);
break;
case PASTE_AS_NEW:
edit_paste_as_new (pn_dialog->gimage, buffer->tiles);
break;
default:
break;
}
}
gdisplays_flush ();
}
static void
named_buffer_paste_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
pn_dialog->action = PASTE_INTO;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_paste_foreach, data);
gtk_widget_destroy (pn_dialog->shell);
}
static void
named_buffer_paste_into_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
pn_dialog->action = PASTE_INTO;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_paste_foreach, data);
gtk_widget_destroy (pn_dialog->shell);
}
static void
named_buffer_paste_as_new_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
pn_dialog->action = PASTE_AS_NEW;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_paste_foreach, data);
gtk_widget_destroy (pn_dialog->shell);
}
static void
named_buffer_delete_foreach (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
GimpBuffer *buffer;
if (widget->state == GTK_STATE_SELECTED)
{
pn_dialog = (PasteNamedDialog *) data;
buffer = (GimpBuffer *) gtk_object_get_user_data (GTK_OBJECT (widget));
gimp_container_remove (named_buffers, GIMP_OBJECT (buffer));
}
}
static void
named_buffer_delete_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_delete_foreach, data);
set_list_of_named_buffers (pn_dialog->list);
}
static void
paste_named_buffer (GimpImage *gimage)
{
PasteNamedDialog *pn_dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *listbox;
GtkWidget *bbox;
GtkWidget *button;
gint i;
static gchar *paste_action_labels[] =
{
N_("Paste"),
N_("Paste Into"),
N_("Paste as New"),
};
static GtkSignalFunc paste_action_functions[] =
{
named_buffer_paste_callback,
named_buffer_paste_into_callback,
named_buffer_paste_as_new_callback,
};
pn_dialog = g_new0 (PasteNamedDialog, 1);
pn_dialog->gimage = gimage;
pn_dialog->shell =
gimp_dialog_new (_("Paste Named Buffer"), "paste_named_buffer",
gimp_standard_help_func,
"dialogs/paste_named.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("Delete"), named_buffer_delete_callback,
pn_dialog, NULL, NULL, FALSE, FALSE,
_("Cancel"), gtk_widget_destroy,
NULL, 1, NULL, TRUE, TRUE,
NULL);
gtk_signal_connect_object (GTK_OBJECT (pn_dialog->shell), "destroy",
GTK_SIGNAL_FUNC (g_free),
(GtkObject *) pn_dialog);
vbox = gtk_vbox_new (FALSE, 1);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 1);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (pn_dialog->shell)->vbox), vbox);
gtk_widget_show (vbox);
label = gtk_label_new (_("Select a buffer to paste:"));
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
gtk_widget_show (label);
listbox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (listbox),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), listbox, TRUE, TRUE, 0);
gtk_widget_set_usize (listbox, 125, 150);
gtk_widget_show (listbox);
pn_dialog->list = gtk_list_new ();
gtk_list_set_selection_mode (GTK_LIST (pn_dialog->list), GTK_SELECTION_BROWSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (listbox),
pn_dialog->list);
set_list_of_named_buffers (pn_dialog->list);
gtk_widget_show (pn_dialog->list);
bbox = gtk_hbutton_box_new ();
gtk_container_set_border_width (GTK_CONTAINER (bbox), 6);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), 2);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
for (i = 0; i < 3; i++)
{
button = gtk_button_new_with_label (gettext (paste_action_labels[i]));
gtk_container_add (GTK_CONTAINER (bbox), button);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) paste_action_functions[i],
pn_dialog);
gtk_widget_show (button);
}
gtk_widget_show (bbox);
gtk_widget_show (pn_dialog->shell);
}
gboolean
named_edit_paste (GimpImage *gimage)
{
paste_named_buffer (gimage);
return TRUE;
}

32
app/core/gimpedit.h
View File

@ -20,23 +20,21 @@
#define __GLOBAL_EDIT_H__
TileManager * edit_cut (GimpImage *gimage,
GimpDrawable *drawable);
TileManager * edit_copy (GimpImage *gimage,
GimpDrawable *drawable);
GimpLayer * edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into);
GimpImage * edit_paste_as_new (GimpImage *gimage,
TileManager *tiles);
gboolean edit_clear (GimpImage *gimage,
GimpDrawable *drawable);
gboolean edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type);
gboolean named_edit_paste (GimpImage *gimage);
TileManager * gimp_edit_cut (GimpImage *gimage,
GimpDrawable *drawable);
TileManager * gimp_edit_copy (GimpImage *gimage,
GimpDrawable *drawable);
GimpLayer * gimp_edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into);
GimpImage * gimp_edit_paste_as_new (GimpImage *gimage,
TileManager *tiles);
gboolean gimp_edit_clear (GimpImage *gimage,
GimpDrawable *drawable);
gboolean gimp_edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type);
#endif /* __GLOBAL_EDIT_H__ */

31
app/dialogs/dialogs-constructors.c
View File

@ -35,6 +35,7 @@
#include "core/gimplayer.h"
#include "core/gimptoolinfo.h"
#include "widgets/gimpbrushfactoryview.h"
#include "widgets/gimpbufferview.h"
#include "widgets/gimpcontainerlistview.h"
#include "widgets/gimpcontainergridview.h"
@ -316,12 +317,13 @@ dialogs_brush_list_view_new (GimpDialogFactory *factory,
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_LIST,
global_brush_factory,
dialogs_edit_brush_func,
context,
32,
5, 3);
view = gimp_brush_factory_view_new (GIMP_VIEW_TYPE_LIST,
global_brush_factory,
dialogs_edit_brush_func,
context,
TRUE,
32,
5, 3);
return dialogs_dockable_new (view,
"Brush List", "Brushes",
@ -447,12 +449,13 @@ dialogs_brush_grid_view_new (GimpDialogFactory *factory,
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_GRID,
global_brush_factory,
dialogs_edit_brush_func,
context,
32,
5, 3);
view = gimp_brush_factory_view_new (GIMP_VIEW_TYPE_GRID,
global_brush_factory,
dialogs_edit_brush_func,
context,
TRUE,
32,
5, 3);
return dialogs_dockable_new (view,
"Brush Grid", "Brushes",
@ -871,9 +874,7 @@ dialogs_set_editor_context_func (GimpDockable *dockable,
"gimp-dialogs-view");
if (editor)
{
/* TODO: gimp_container_editor_set_context (editor, context); */
}
gimp_container_view_set_context (editor->view, context);
}
static void

20
app/gimprc.c
View File

@ -2491,6 +2491,26 @@ parse_session_info (gpointer val1p,
{
info->open = TRUE;
}
else if (!strcmp ("aux-info", token_sym))
{
token = peek_next_token ();
if (!token || (token != TOKEN_LEFT_PAREN))
goto error;
token = get_next_token ();
while (peek_next_token () == TOKEN_STRING)
{
token = get_next_token ();
info->aux_info = g_list_append (info->aux_info,
g_strdup (token_str));
}
token = peek_next_token ();
if (!token || (token != TOKEN_RIGHT_PAREN))
goto error;
token = get_next_token ();
}
else if (!strcmp ("dock", token_sym))
{
if (info->toplevel_entry)

284
app/global_edit.c
View File

@ -56,28 +56,9 @@
#include "libgimp/gimpintl.h"
typedef enum
{
PASTE,
PASTE_INTO,
PASTE_AS_NEW
} PasteAction;
typedef struct _PasteNamedDialog PasteNamedDialog;
struct _PasteNamedDialog
{
GtkWidget *shell;
GtkWidget *list;
GimpImage *gimage;
PasteAction action;
};
TileManager *
edit_cut (GimpImage *gimage,
GimpDrawable *drawable)
gimp_edit_cut (GimpImage *gimage,
GimpDrawable *drawable)
{
TileManager *cut;
TileManager *cropped_cut;
@ -133,8 +114,8 @@ edit_cut (GimpImage *gimage,
}
TileManager *
edit_copy (GimpImage *gimage,
GimpDrawable *drawable)
gimp_edit_copy (GimpImage *gimage,
GimpDrawable *drawable)
{
TileManager *copy;
TileManager *cropped_copy;
@ -184,10 +165,10 @@ edit_copy (GimpImage *gimage,
}
GimpLayer *
edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into)
gimp_edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into)
{
GimpLayer *layer;
gint x1, y1, x2, y2;
@ -262,8 +243,8 @@ edit_paste (GimpImage *gimage,
}
GimpImage *
edit_paste_as_new (GimpImage *invoke,
TileManager *paste)
gimp_edit_paste_as_new (GimpImage *invoke,
TileManager *paste)
{
GimpImage *gimage;
GimpLayer *layer;
@ -304,8 +285,8 @@ edit_paste_as_new (GimpImage *invoke,
}
gboolean
edit_clear (GimpImage *gimage,
GimpDrawable *drawable)
gimp_edit_clear (GimpImage *gimage,
GimpDrawable *drawable)
{
TileManager *buf_tiles;
PixelRegion bufPR;
@ -347,9 +328,9 @@ edit_clear (GimpImage *gimage,
}
gboolean
edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type)
gimp_edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type)
{
TileManager *buf_tiles;
PixelRegion bufPR;
@ -421,238 +402,3 @@ edit_fill (GimpImage *gimage,
return TRUE;
}
/*********************************************/
/* Named buffer operations */
static void
set_list_of_named_buffers (GtkWidget *list_widget)
{
GList *list;
GimpBuffer *buffer;
GtkWidget *list_item;
gtk_list_clear_items (GTK_LIST (list_widget), 0, -1);
for (list = GIMP_LIST (named_buffers)->list;
list;
list = g_list_next (list))
{
buffer = (GimpBuffer *) list->data;
list_item = gtk_list_item_new_with_label (GIMP_OBJECT (buffer)->name);
gtk_container_add (GTK_CONTAINER (list_widget), list_item);
gtk_object_set_user_data (GTK_OBJECT (list_item), buffer);
gtk_widget_show (list_item);
}
}
static void
named_buffer_paste_foreach (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
GimpBuffer *buffer;
if (widget->state == GTK_STATE_SELECTED)
{
pn_dialog = (PasteNamedDialog *) data;
buffer = (GimpBuffer *) gtk_object_get_user_data (GTK_OBJECT (widget));
switch (pn_dialog->action)
{
case PASTE:
edit_paste (pn_dialog->gimage,
gimp_image_active_drawable (pn_dialog->gimage),
buffer->tiles, FALSE);
break;
case PASTE_INTO:
edit_paste (pn_dialog->gimage,
gimp_image_active_drawable (pn_dialog->gimage),
buffer->tiles, TRUE);
break;
case PASTE_AS_NEW:
edit_paste_as_new (pn_dialog->gimage, buffer->tiles);
break;
default:
break;
}
}
gdisplays_flush ();
}
static void
named_buffer_paste_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
pn_dialog->action = PASTE_INTO;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_paste_foreach, data);
gtk_widget_destroy (pn_dialog->shell);
}
static void
named_buffer_paste_into_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
pn_dialog->action = PASTE_INTO;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_paste_foreach, data);
gtk_widget_destroy (pn_dialog->shell);
}
static void
named_buffer_paste_as_new_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
pn_dialog->action = PASTE_AS_NEW;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_paste_foreach, data);
gtk_widget_destroy (pn_dialog->shell);
}
static void
named_buffer_delete_foreach (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
GimpBuffer *buffer;
if (widget->state == GTK_STATE_SELECTED)
{
pn_dialog = (PasteNamedDialog *) data;
buffer = (GimpBuffer *) gtk_object_get_user_data (GTK_OBJECT (widget));
gimp_container_remove (named_buffers, GIMP_OBJECT (buffer));
}
}
static void
named_buffer_delete_callback (GtkWidget *widget,
gpointer data)
{
PasteNamedDialog *pn_dialog;
pn_dialog = (PasteNamedDialog *) data;
gtk_container_foreach (GTK_CONTAINER (pn_dialog->list),
named_buffer_delete_foreach, data);
set_list_of_named_buffers (pn_dialog->list);
}
static void
paste_named_buffer (GimpImage *gimage)
{
PasteNamedDialog *pn_dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *listbox;
GtkWidget *bbox;
GtkWidget *button;
gint i;
static gchar *paste_action_labels[] =
{
N_("Paste"),
N_("Paste Into"),
N_("Paste as New"),
};
static GtkSignalFunc paste_action_functions[] =
{
named_buffer_paste_callback,
named_buffer_paste_into_callback,
named_buffer_paste_as_new_callback,
};
pn_dialog = g_new0 (PasteNamedDialog, 1);
pn_dialog->gimage = gimage;
pn_dialog->shell =
gimp_dialog_new (_("Paste Named Buffer"), "paste_named_buffer",
gimp_standard_help_func,
"dialogs/paste_named.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("Delete"), named_buffer_delete_callback,
pn_dialog, NULL, NULL, FALSE, FALSE,
_("Cancel"), gtk_widget_destroy,
NULL, 1, NULL, TRUE, TRUE,
NULL);
gtk_signal_connect_object (GTK_OBJECT (pn_dialog->shell), "destroy",
GTK_SIGNAL_FUNC (g_free),
(GtkObject *) pn_dialog);
vbox = gtk_vbox_new (FALSE, 1);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 1);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (pn_dialog->shell)->vbox), vbox);
gtk_widget_show (vbox);
label = gtk_label_new (_("Select a buffer to paste:"));
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
gtk_widget_show (label);
listbox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (listbox),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), listbox, TRUE, TRUE, 0);
gtk_widget_set_usize (listbox, 125, 150);
gtk_widget_show (listbox);
pn_dialog->list = gtk_list_new ();
gtk_list_set_selection_mode (GTK_LIST (pn_dialog->list), GTK_SELECTION_BROWSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (listbox),
pn_dialog->list);
set_list_of_named_buffers (pn_dialog->list);
gtk_widget_show (pn_dialog->list);
bbox = gtk_hbutton_box_new ();
gtk_container_set_border_width (GTK_CONTAINER (bbox), 6);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), 2);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
for (i = 0; i < 3; i++)
{
button = gtk_button_new_with_label (gettext (paste_action_labels[i]));
gtk_container_add (GTK_CONTAINER (bbox), button);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) paste_action_functions[i],
pn_dialog);
gtk_widget_show (button);
}
gtk_widget_show (bbox);
gtk_widget_show (pn_dialog->shell);
}
gboolean
named_edit_paste (GimpImage *gimage)
{
paste_named_buffer (gimage);
return TRUE;
}

32
app/global_edit.h
View File

@ -20,23 +20,21 @@
#define __GLOBAL_EDIT_H__
TileManager * edit_cut (GimpImage *gimage,
GimpDrawable *drawable);
TileManager * edit_copy (GimpImage *gimage,
GimpDrawable *drawable);
GimpLayer * edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into);
GimpImage * edit_paste_as_new (GimpImage *gimage,
TileManager *tiles);
gboolean edit_clear (GimpImage *gimage,
GimpDrawable *drawable);
gboolean edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type);
gboolean named_edit_paste (GimpImage *gimage);
TileManager * gimp_edit_cut (GimpImage *gimage,
GimpDrawable *drawable);
TileManager * gimp_edit_copy (GimpImage *gimage,
GimpDrawable *drawable);
GimpLayer * gimp_edit_paste (GimpImage *gimage,
GimpDrawable *drawable,
TileManager *paste,
gboolean paste_into);
GimpImage * gimp_edit_paste_as_new (GimpImage *gimage,
TileManager *tiles);
gboolean gimp_edit_clear (GimpImage *gimage,
GimpDrawable *drawable);
gboolean gimp_edit_fill (GimpImage *gimage,
GimpDrawable *drawable,
GimpFillType fill_type);
#endif /* __GLOBAL_EDIT_H__ */

2
app/gui/Makefile.am
View File

@ -94,6 +94,8 @@ libappgui_a_SOURCES = @STRIP_BEGIN@ \
tool-options-dialog.h \
toolbox.c \
toolbox.h \
tools-commands.c \
tools-commands.h \
view-commands.c \
view-commands.h \
@STRIP_END@

85
app/gui/brush-select.c
View File

@ -28,14 +28,14 @@
#include "base/temp-buf.h"
#include "core/gimpbrushgenerated.h"
#include "core/gimpbrush.h"
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimpdatafactory.h"
#include "pdb/procedural_db.h"
#include "widgets/gimpdatafactoryview.h"
#include "widgets/gimpbrushfactoryview.h"
#include "widgets/gimpwidgets-constructors.h"
#include "brush-select.h"
@ -194,13 +194,14 @@ brush_select_new (gchar *title,
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (bsp->shell)->vbox), main_vbox);
/* The Brush Grid */
bsp->view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_GRID,
global_brush_factory,
dialogs_edit_brush_func,
bsp->context,
MIN_CELL_SIZE,
STD_BRUSH_COLUMNS,
STD_BRUSH_ROWS);
bsp->view = gimp_brush_factory_view_new (GIMP_VIEW_TYPE_GRID,
global_brush_factory,
dialogs_edit_brush_func,
bsp->context,
title ? FALSE : TRUE,
MIN_CELL_SIZE,
STD_BRUSH_COLUMNS,
STD_BRUSH_ROWS);
gtk_box_pack_start (GTK_BOX (main_vbox), bsp->view, TRUE, TRUE, 0);
gtk_widget_show (bsp->view);
@ -246,35 +247,21 @@ brush_select_new (gchar *title,
gtk_box_pack_start (GTK_BOX (bsp->paint_options_box), sep, FALSE, FALSE, 0);
gtk_widget_show (sep);
/* Create the spacing scale widget */
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
gtk_box_pack_end (GTK_BOX (bsp->view), table, FALSE, FALSE, 0);
bsp->spacing_data =
GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 1.0, 1000.0, 1.0, 1.0, 0.0));
slider = gtk_hscale_new (bsp->spacing_data);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Spacing:"), 1.0, 1.0,
slider, 1, FALSE);
if (title && init_spacing >= 0)
{
GtkAdjustment *adj;
adj = GIMP_BRUSH_FACTORY_VIEW (bsp->view)->spacing_adjustment;
/* Use passed spacing instead of brushes default */
gtk_adjustment_set_value (GTK_ADJUSTMENT (bsp->spacing_data),
init_spacing);
}
else if (active)
{
gtk_adjustment_set_value (GTK_ADJUSTMENT (bsp->spacing_data),
gimp_brush_get_spacing (active));
gtk_adjustment_set_value (adj, init_spacing);
}
gtk_signal_connect (GTK_OBJECT (bsp->spacing_data), "value_changed",
GTK_SIGNAL_FUNC (spacing_scale_update),
bsp);
gtk_signal_connect
(GTK_OBJECT (GIMP_BRUSH_FACTORY_VIEW (bsp->view)->spacing_adjustment),
"value_changed",
GTK_SIGNAL_FUNC (spacing_scale_update),
bsp);
gtk_widget_show (table);
@ -382,7 +369,7 @@ brush_select_change_callbacks (BrushSelect *bsp,
GIMP_PDB_INT32, brush->mask->width,
GIMP_PDB_INT32, brush->mask->height,
GIMP_PDB_INT32, (brush->mask->width *
brush->mask->height),
brush->mask->height),
GIMP_PDB_INT8ARRAY, temp_buf_data (brush->mask),
GIMP_PDB_INT32, (gint) closing,
GIMP_PDB_END);
@ -436,16 +423,9 @@ brush_select_brush_changed (GimpContext *context,
GimpBrush *brush,
BrushSelect *bsp)
{
if (brush)
if (brush && bsp->callback_name)
{
gtk_adjustment_set_value (GTK_ADJUSTMENT (bsp->spacing_data),
gimp_brush_get_spacing (brush));
gtk_widget_set_sensitive (GIMP_DATA_FACTORY_VIEW (bsp->view)->edit_button,
GIMP_IS_BRUSH_GENERATED (brush));
if (bsp->callback_name)
brush_select_change_callbacks (bsp, FALSE);
brush_select_change_callbacks (bsp, FALSE);
}
}
@ -469,7 +449,7 @@ brush_select_paint_mode_changed (GimpContext *context,
BrushSelect *bsp)
{
gimp_option_menu_set_history (GTK_OPTION_MENU (bsp->option_menu),
(gpointer) paint_mode);
GINT_TO_POINTER (paint_mode));
if (bsp->callback_name)
brush_select_change_callbacks (bsp, FALSE);
@ -497,7 +477,8 @@ paint_mode_menu_callback (GtkWidget *widget,
bsp = (BrushSelect *) data;
paint_mode = (LayerModeEffects) gtk_object_get_user_data (GTK_OBJECT (widget));
paint_mode = (LayerModeEffects)
GPOINTER_TO_INT (gtk_object_get_user_data (GTK_OBJECT (widget)));
gimp_context_set_paint_mode (bsp->context, paint_mode);
}
@ -510,18 +491,10 @@ spacing_scale_update (GtkAdjustment *adjustment,
bsp = (BrushSelect *) data;
if (bsp == brush_select_dialog)
if (bsp->callback_name && bsp->spacing_value != adjustment->value)
{
gimp_brush_set_spacing (gimp_context_get_brush (bsp->context),
(gint) adjustment->value);
}
else
{
if (bsp->spacing_value != adjustment->value)
{
bsp->spacing_value = adjustment->value;
brush_select_change_callbacks (bsp, FALSE);
}
bsp->spacing_value = adjustment->value;
brush_select_change_callbacks (bsp, FALSE);
}
}

2
app/gui/brush-select.h
View File

@ -29,8 +29,6 @@ struct _BrushSelect
GtkWidget *view;
GtkWidget *paint_options_box;
GtkAdjustment *spacing_data;
GtkAdjustment *opacity_data;
GtkWidget *option_menu;

116
app/gui/commands.c
View File

@ -20,143 +20,37 @@
#include <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "core/core-types.h"
#include "tools/tools-types.h"
#include "core/gimpcontext.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
#include "core/gimptoolinfo.h"
#include "tools/gimptool.h"
#include "tools/tool_manager.h"
#include "commands.h"
#include "layer-select.h"
#include "app_procs.h"
#include "context_manager.h"
#include "gdisplay.h"
#include "gimprc.h"
#include "image_render.h"
#include "plug_in.h"
#include "undo.h"
#include "libgimp/gimpintl.h"
#define return_if_no_display(gdisp) \
gdisp = gdisplay_active (); \
if (!gdisp) return
/***** Tools *****/
void
tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer client_data)
{
gimp_context_set_default_colors (gimp_context_get_user ());
}
void
tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer client_data)
{
gimp_context_swap_colors (gimp_context_get_user ());
}
void
tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer client_data)
{
static GimpContext *swap_context = NULL;
static GimpContext *temp_context = NULL;
if (! swap_context)
{
swap_context = gimp_context_new ("Swap Context",
gimp_context_get_user ());
temp_context = gimp_context_new ("Temp Context", NULL);
}
gimp_context_copy_args (gimp_context_get_user (),
temp_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (swap_context,
gimp_context_get_user (),
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (temp_context,
swap_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
}
void
tools_select_cmd_callback (GtkWidget *widget,
gpointer callback_data,
guint callback_action)
{
GtkType tool_type;
GimpToolInfo *tool_info;
GDisplay *gdisp;
tool_type = callback_action;
tool_info = tool_manager_get_info_by_type (tool_type);
gdisp = gdisplay_active ();
gimp_context_set_tool (gimp_context_get_user (), tool_info);
#ifdef __GNUC__
#warning FIXME (let the tool manager to this stuff)
#endif
/* Paranoia */
active_tool->drawable = NULL;
/* Complete the initialisation by doing the same stuff
* tools_initialize() does after it did what tools_select() does
*/
if (GIMP_TOOL_CLASS (GTK_OBJECT (active_tool)->klass)->initialize)
{
gimp_tool_initialize (active_tool, gdisp);
active_tool->drawable = gimp_image_active_drawable (gdisp->gimage);
}
/* setting the tool->gdisp here is a HACK to allow the tools'
* dialog windows being hidden if the tool was selected from
* a tear-off-menu and there was no mouse click in the display
* before deleting it
*/
active_tool->gdisp = gdisp;
}
/***** Filters *****/
void
filters_repeat_cmd_callback (GtkWidget *widget,
gpointer callback_data,
guint callback_action)
gpointer data,
guint action)
{
plug_in_repeat (callback_action);
plug_in_repeat ((gboolean) action);
}
/***** Help *****/
void
help_help_cmd_callback (GtkWidget *widget,
gpointer client_data)
gpointer data)
{
gimp_standard_help_func (NULL);
}
void
help_context_help_cmd_callback (GtkWidget *widget,
gpointer client_data)
gpointer data)
{
gimp_context_help ();
}

24
app/gui/commands.h
View File

@ -20,24 +20,14 @@
#define __COMMANDS_H__
void tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_select_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void filters_repeat_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void filters_repeat_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void help_help_cmd_callback (GtkWidget *widget,
gpointer data);
void help_context_help_cmd_callback (GtkWidget *widget,
gpointer data);
void help_help_cmd_callback (GtkWidget *widget,
gpointer data);
void help_context_help_cmd_callback (GtkWidget *widget,
gpointer data);
#endif /* __COMMANDS_H__ */

42
app/gui/dialogs-commands.c
View File

@ -24,9 +24,9 @@
#include "widgets/widgets-types.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpdock.h"
#include "widgets/gimpdockable.h"
#include "widgets/gimpdockbook.h"
#include "widgets/gimpimagedock.h"
#include "dialogs.h"
#include "dialogs-commands.h"
@ -39,8 +39,12 @@ dialogs_create_toplevel_cmd_callback (GtkWidget *widget,
{
if (action)
{
gimp_dialog_factory_dialog_new (global_dialog_factory,
GUINT_TO_POINTER (action));
gchar *identifier;
identifier = g_quark_to_string ((GQuark) action);
if (identifier)
gimp_dialog_factory_dialog_new (global_dialog_factory, identifier);
}
}
@ -56,13 +60,19 @@ dialogs_add_tab_cmd_callback (GtkWidget *widget,
if (dockbook && action)
{
GtkWidget *dockable;
gchar *identifier;
dockable = gimp_dialog_factory_dockable_new (dockbook->dock->factory,
dockbook->dock,
GUINT_TO_POINTER (action));
identifier = g_quark_to_string ((GQuark) action);
if (dockable)
gimp_dockbook_add (dockbook, GIMP_DOCKABLE (dockable), -1);
if (identifier)
{
dockable = gimp_dialog_factory_dockable_new (dockbook->dock->factory,
dockbook->dock,
identifier);
if (dockable)
gimp_dockbook_add (dockbook, GIMP_DOCKABLE (dockable), -1);
}
}
}
@ -90,6 +100,22 @@ dialogs_remove_tab_cmd_callback (GtkWidget *widget,
}
}
void
dialogs_toggle_image_menu_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GimpDockbook *dockbook;
dockbook = (GimpDockbook *) gtk_item_factory_popup_data_from_widget (widget);
if (dockbook)
{
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dockbook->dock),
GTK_CHECK_MENU_ITEM (widget)->active);
}
}
void
dialogs_create_lc_cmd_callback (GtkWidget *widget,
gpointer data,

27
app/gui/dialogs-commands.h
View File

@ -20,20 +20,23 @@
#define __DIALOGS_COMMANDS_H__
void dialogs_create_toplevel_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_create_toplevel_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_add_tab_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_remove_tab_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_add_tab_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_remove_tab_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_toggle_image_menu_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_create_lc_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void dialogs_create_lc_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
#endif /* __DIALOGS_COMMANDS_H__ */

31
app/gui/dialogs-constructors.c
View File

@ -35,6 +35,7 @@
#include "core/gimplayer.h"
#include "core/gimptoolinfo.h"
#include "widgets/gimpbrushfactoryview.h"
#include "widgets/gimpbufferview.h"
#include "widgets/gimpcontainerlistview.h"
#include "widgets/gimpcontainergridview.h"
@ -316,12 +317,13 @@ dialogs_brush_list_view_new (GimpDialogFactory *factory,
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_LIST,
global_brush_factory,
dialogs_edit_brush_func,
context,
32,
5, 3);
view = gimp_brush_factory_view_new (GIMP_VIEW_TYPE_LIST,
global_brush_factory,
dialogs_edit_brush_func,
context,
TRUE,
32,
5, 3);
return dialogs_dockable_new (view,
"Brush List", "Brushes",
@ -447,12 +449,13 @@ dialogs_brush_grid_view_new (GimpDialogFactory *factory,
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_GRID,
global_brush_factory,
dialogs_edit_brush_func,
context,
32,
5, 3);
view = gimp_brush_factory_view_new (GIMP_VIEW_TYPE_GRID,
global_brush_factory,
dialogs_edit_brush_func,
context,
TRUE,
32,
5, 3);
return dialogs_dockable_new (view,
"Brush Grid", "Brushes",
@ -871,9 +874,7 @@ dialogs_set_editor_context_func (GimpDockable *dockable,
"gimp-dialogs-view");
if (editor)
{
/* TODO: gimp_container_editor_set_context (editor, context); */
}
gimp_container_view_set_context (editor->view, context);
}
static void

53
app/gui/edit-commands.c
View File

@ -34,6 +34,9 @@
#include "tools/tool_manager.h"
#include "widgets/gimpdialogfactory.h"
#include "dialogs.h"
#include "edit-commands.h"
#include "context_manager.h"
@ -91,8 +94,8 @@ edit_cut_cmd_callback (GtkWidget *widget,
/* stop any active tool */
tool_manager_control_active (HALT, gdisp);
if (edit_cut (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage)))
if (gimp_edit_cut (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage)))
{
gdisplays_flush ();
}
@ -105,8 +108,8 @@ edit_copy_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
edit_copy (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage));
gimp_edit_copy (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage));
}
void
@ -121,10 +124,10 @@ edit_paste_cmd_callback (GtkWidget *widget,
/* stop any active tool */
tool_manager_control_active (HALT, gdisp);
if (edit_paste (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
global_buffer,
FALSE))
if (gimp_edit_paste (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
global_buffer,
FALSE))
{
gdisplays_update_title (gdisp->gimage);
gdisplays_flush ();
@ -144,10 +147,10 @@ edit_paste_into_cmd_callback (GtkWidget *widget,
/* stop any active tool */
tool_manager_control_active (HALT, gdisp);
if (edit_paste (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
global_buffer,
TRUE))
if (gimp_edit_paste (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
global_buffer,
TRUE))
{
gdisplays_update_title (gdisp->gimage);
gdisplays_flush ();
@ -167,8 +170,8 @@ edit_paste_as_new_cmd_callback (GtkWidget *widget,
/* stop any active tool */
tool_manager_control_active (HALT, gdisp);
edit_paste_as_new (gdisp->gimage,
global_buffer);
gimp_edit_paste_as_new (gdisp->gimage,
global_buffer);
}
}
@ -220,7 +223,7 @@ edit_named_paste_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
named_edit_paste (gdisp->gimage);
gimp_dialog_factory_dialog_raise (global_dock_factory, "gimp:buffer-list");
}
void
@ -230,7 +233,7 @@ edit_clear_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
edit_clear (gdisp->gimage, gimp_image_active_drawable (gdisp->gimage));
gimp_edit_clear (gdisp->gimage, gimp_image_active_drawable (gdisp->gimage));
gdisplays_flush ();
}
@ -246,8 +249,10 @@ edit_fill_cmd_callback (GtkWidget *widget,
fill_type = (GimpFillType) action;
edit_fill (gdisp->gimage, gimp_image_active_drawable (gdisp->gimage),
fill_type);
gimp_edit_fill (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage),
fill_type);
gdisplays_flush ();
}
@ -258,7 +263,9 @@ edit_stroke_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
gimage_mask_stroke (gdisp->gimage, gimp_image_active_drawable (gdisp->gimage));
gimage_mask_stroke (gdisp->gimage,
gimp_image_active_drawable (gdisp->gimage));
gdisplays_flush ();
}
@ -275,7 +282,8 @@ cut_named_buffer_callback (GtkWidget *widget,
gimage = (GimpImage *) data;
new_tiles = edit_cut (gimage, gimp_image_active_drawable (gimage));
new_tiles = gimp_edit_cut (gimage,
gimp_image_active_drawable (gimage));
if (new_tiles)
{
@ -297,8 +305,9 @@ copy_named_buffer_callback (GtkWidget *widget,
GimpImage *gimage;
gimage = (GimpImage *) data;
new_tiles = edit_copy (gimage, gimp_image_active_drawable (gimage));
new_tiles = gimp_edit_copy (gimage,
gimp_image_active_drawable (gimage));
if (new_tiles)
{

27
app/gui/file-commands.c
View File

@ -31,6 +31,7 @@
#include "gdisplay.h"
#include "gdisplay_ops.h"
#include "image_new.h"
#include "menus.h"
#include "libgimp/gimpintl.h"
@ -69,6 +70,32 @@ file_open_cmd_callback (GtkWidget *widget,
file_open_callback (widget, data);
}
void
file_last_opened_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
gchar *filename;
guint num_entries;
gint status;
num_entries = g_slist_length (last_opened_raw_filenames);
if (action >= num_entries)
return;
filename =
((GString *) g_slist_nth_data (last_opened_raw_filenames, action))->str;
status = file_open_with_display (filename, filename);
if (status != GIMP_PDB_SUCCESS &&
status != GIMP_PDB_CANCEL)
{
g_message (_("Error opening file: %s\n"), filename);
}
}
void
file_save_cmd_callback (GtkWidget *widget,
gpointer data)

3
app/gui/file-commands.h
View File

@ -25,6 +25,9 @@ void file_new_cmd_callback (GtkWidget *widget,
guint action);
void file_open_cmd_callback (GtkWidget *widget,
gpointer data);
void file_last_opened_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void file_save_cmd_callback (GtkWidget *widget,
gpointer data);
void file_save_as_cmd_callback (GtkWidget *widget,

116
app/gui/help-commands.c
View File

@ -20,143 +20,37 @@
#include <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "core/core-types.h"
#include "tools/tools-types.h"
#include "core/gimpcontext.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
#include "core/gimptoolinfo.h"
#include "tools/gimptool.h"
#include "tools/tool_manager.h"
#include "commands.h"
#include "layer-select.h"
#include "app_procs.h"
#include "context_manager.h"
#include "gdisplay.h"
#include "gimprc.h"
#include "image_render.h"
#include "plug_in.h"
#include "undo.h"
#include "libgimp/gimpintl.h"
#define return_if_no_display(gdisp) \
gdisp = gdisplay_active (); \
if (!gdisp) return
/***** Tools *****/
void
tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer client_data)
{
gimp_context_set_default_colors (gimp_context_get_user ());
}
void
tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer client_data)
{
gimp_context_swap_colors (gimp_context_get_user ());
}
void
tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer client_data)
{
static GimpContext *swap_context = NULL;
static GimpContext *temp_context = NULL;
if (! swap_context)
{
swap_context = gimp_context_new ("Swap Context",
gimp_context_get_user ());
temp_context = gimp_context_new ("Temp Context", NULL);
}
gimp_context_copy_args (gimp_context_get_user (),
temp_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (swap_context,
gimp_context_get_user (),
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (temp_context,
swap_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
}
void
tools_select_cmd_callback (GtkWidget *widget,
gpointer callback_data,
guint callback_action)
{
GtkType tool_type;
GimpToolInfo *tool_info;
GDisplay *gdisp;
tool_type = callback_action;
tool_info = tool_manager_get_info_by_type (tool_type);
gdisp = gdisplay_active ();
gimp_context_set_tool (gimp_context_get_user (), tool_info);
#ifdef __GNUC__
#warning FIXME (let the tool manager to this stuff)
#endif
/* Paranoia */
active_tool->drawable = NULL;
/* Complete the initialisation by doing the same stuff
* tools_initialize() does after it did what tools_select() does
*/
if (GIMP_TOOL_CLASS (GTK_OBJECT (active_tool)->klass)->initialize)
{
gimp_tool_initialize (active_tool, gdisp);
active_tool->drawable = gimp_image_active_drawable (gdisp->gimage);
}
/* setting the tool->gdisp here is a HACK to allow the tools'
* dialog windows being hidden if the tool was selected from
* a tear-off-menu and there was no mouse click in the display
* before deleting it
*/
active_tool->gdisp = gdisp;
}
/***** Filters *****/
void
filters_repeat_cmd_callback (GtkWidget *widget,
gpointer callback_data,
guint callback_action)
gpointer data,
guint action)
{
plug_in_repeat (callback_action);
plug_in_repeat ((gboolean) action);
}
/***** Help *****/
void
help_help_cmd_callback (GtkWidget *widget,
gpointer client_data)
gpointer data)
{
gimp_standard_help_func (NULL);
}
void
help_context_help_cmd_callback (GtkWidget *widget,
gpointer client_data)
gpointer data)
{
gimp_context_help ();
}

24
app/gui/help-commands.h
View File

@ -20,24 +20,14 @@
#define __COMMANDS_H__
void tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_select_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void filters_repeat_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void filters_repeat_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void help_help_cmd_callback (GtkWidget *widget,
gpointer data);
void help_context_help_cmd_callback (GtkWidget *widget,
gpointer data);
void help_help_cmd_callback (GtkWidget *widget,
gpointer data);
void help_context_help_cmd_callback (GtkWidget *widget,
gpointer data);
#endif /* __COMMANDS_H__ */

1146
app/gui/menus.c
View File

File diff suppressed because it is too large Load Diff

5
app/gui/menus.h
View File

@ -26,11 +26,16 @@ struct _GimpItemFactoryEntry
{
GtkItemFactoryEntry entry;
const gchar *quark_string;
const gchar *help_page;
const gchar *description;
};
extern GSList *last_opened_raw_filenames;
GtkItemFactory * menus_get_toolbox_factory (void);
GtkItemFactory * menus_get_image_factory (void);
GtkItemFactory * menus_get_load_factory (void);

117
app/gui/tools-commands.c Normal file
View File

@ -0,0 +1,117 @@
/* 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 <gtk/gtk.h>
#include "tools/tools-types.h"
#include "core/gimpcontext.h"
#include "core/gimpimage.h"
#include "tools/gimptool.h"
#include "tools/tool_manager.h"
#include "gdisplay.h"
#define return_if_no_display(gdisp) \
gdisp = gdisplay_active (); \
if (!gdisp) return
void
tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer data)
{
gimp_context_set_default_colors (gimp_context_get_user ());
}
void
tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer data)
{
gimp_context_swap_colors (gimp_context_get_user ());
}
void
tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer data)
{
static GimpContext *swap_context = NULL;
static GimpContext *temp_context = NULL;
if (! swap_context)
{
swap_context = gimp_context_new ("Swap Context",
gimp_context_get_user ());
temp_context = gimp_context_new ("Temp Context", NULL);
}
gimp_context_copy_args (gimp_context_get_user (),
temp_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (swap_context,
gimp_context_get_user (),
GIMP_CONTEXT_ALL_ARGS_MASK);
gimp_context_copy_args (temp_context,
swap_context,
GIMP_CONTEXT_ALL_ARGS_MASK);
}
void
tools_select_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GtkType tool_type;
GimpToolInfo *tool_info;
GDisplay *gdisp;
tool_type = (GtkType) action;
tool_info = tool_manager_get_info_by_type (tool_type);
gdisp = gdisplay_active ();
gimp_context_set_tool (gimp_context_get_user (), tool_info);
#ifdef __GNUC__
#warning FIXME (let the tool manager to this stuff)
#endif
/* Paranoia */
active_tool->drawable = NULL;
/* Complete the initialisation by doing the same stuff
* tools_initialize() does after it did what tools_select() does
*/
if (GIMP_TOOL_CLASS (GTK_OBJECT (active_tool)->klass)->initialize)
{
gimp_tool_initialize (active_tool, gdisp);
active_tool->drawable = gimp_image_active_drawable (gdisp->gimage);
}
/* setting the tool->gdisp here is a HACK to allow the tools'
* dialog windows being hidden if the tool was selected from
* a tear-off-menu and there was no mouse click in the display
* before deleting it
*/
active_tool->gdisp = gdisp;
}

34
app/gui/tools-commands.h Normal file
View File

@ -0,0 +1,34 @@
/* 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 __TOOLS_COMMANDS_H__
#define __TOOLS_COMMANDS_H__
void tools_default_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_colors_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_swap_contexts_cmd_callback (GtkWidget *widget,
gpointer data);
void tools_select_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
#endif /* __TOOLS_COMMANDS_H__ */

1146
app/menus/menus.c
View File

File diff suppressed because it is too large Load Diff

5
app/menus/menus.h
View File

@ -26,11 +26,16 @@ struct _GimpItemFactoryEntry
{
GtkItemFactoryEntry entry;
const gchar *quark_string;
const gchar *help_page;
const gchar *description;
};
extern GSList *last_opened_raw_filenames;
GtkItemFactory * menus_get_toolbox_factory (void);
GtkItemFactory * menus_get_image_factory (void);
GtkItemFactory * menus_get_load_factory (void);

8
app/pdb/brush_select_cmds.c
View File

@ -36,6 +36,7 @@
#include "core/gimpdatafactory.h"
#include "core/gimplist.h"
#include "gui/brush-select.h"
#include "widgets/gimpbrushfactoryview.h"
static ProcRecord brushes_popup_proc;
static ProcRecord brushes_close_popup_proc;
@ -265,7 +266,10 @@ brushes_set_popup_invoker (Argument *args)
if (object)
{
GimpBrush *active = GIMP_BRUSH (object);
GimpBrush *active = GIMP_BRUSH (object);
GtkAdjustment *spacing_adj;
spacing_adj = GIMP_BRUSH_FACTORY_VIEW (bsp->view)->spacing_adjustment;
/* Updating the context updates the widgets as well */
@ -273,7 +277,7 @@ brushes_set_popup_invoker (Argument *args)
gimp_context_set_opacity (bsp->context, opacity);
gimp_context_set_paint_mode (bsp->context, paint_mode);
gtk_adjustment_set_value (GTK_ADJUSTMENT (bsp->spacing_data), spacing);
gtk_adjustment_set_value (spacing_adj, spacing);
}
else
success = FALSE;

1
app/pdb/drawable_cmds.c
View File

@ -29,7 +29,6 @@
#include "core/core-types.h"
#include "procedural_db.h"
#include "appenums.h"
#include "base/temp-buf.h"
#include "base/tile-manager.h"
#include "base/tile.h"

12
app/pdb/edit_cmds.c
View File

@ -28,7 +28,7 @@
#include "core/core-types.h"
#include "procedural_db.h"
#include "appenums.h"
#include "core/core-types.h"
#include "core/gimpimage-mask.h"
#include "core/gimplayer.h"
#include "drawable.h"
@ -68,7 +68,7 @@ edit_cut_invoker (Argument *args)
if (success)
{
gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable));
success = edit_cut (gimage, drawable) != NULL;
success = gimp_edit_cut (gimage, drawable) != NULL;
}
return procedural_db_return_args (&edit_cut_proc, success);
@ -113,7 +113,7 @@ edit_copy_invoker (Argument *args)
if (success)
{
gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable));
success = edit_copy (gimage, drawable) != NULL;
success = gimp_edit_copy (gimage, drawable) != NULL;
}
return procedural_db_return_args (&edit_copy_proc, success);
@ -163,7 +163,7 @@ edit_paste_invoker (Argument *args)
if (success)
{
gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable));
layer = edit_paste (gimage, drawable, global_buffer, paste_into);
layer = gimp_edit_paste (gimage, drawable, global_buffer, paste_into);
success = layer != NULL;
}
@ -228,7 +228,7 @@ edit_clear_invoker (Argument *args)
if (success)
{
gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable));
success = edit_clear (gimage, drawable);
success = gimp_edit_clear (gimage, drawable);
}
return procedural_db_return_args (&edit_clear_proc, success);
@ -278,7 +278,7 @@ edit_fill_invoker (Argument *args)
if (success)
{
gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable));
success = edit_fill (gimage, drawable, (GimpFillType) fill_type);
success = gimp_edit_fill (gimage, drawable, (GimpFillType) fill_type);
}
return procedural_db_return_args (&edit_fill_proc, success);

2
app/widgets/Makefile.am
View File

@ -4,6 +4,8 @@ noinst_LIBRARIES = libappwidgets.a
libappwidgets_a_SOURCES = @STRIP_BEGIN@ \
widgets-types.h \
gimpbrushfactoryview.c \
gimpbrushfactoryview.h \
gimpbrushpreview.c \
gimpbrushpreview.h \
gimpbufferpreview.c \

270
app/widgets/gimpbrushfactoryview.c Normal file
View File

@ -0,0 +1,270 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpbrushfactoryview.c
* Copyright (C) 2001 Michael Natterer
*
* 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 <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimpbrush.h"
#include "core/gimpbrushgenerated.h"
#include "core/gimpdatafactory.h"
#include "core/gimpmarshal.h"
#include "gimpcontainerview.h"
#include "gimpbrushfactoryview.h"
#include "libgimp/gimpintl.h"
static void gimp_brush_factory_view_class_init (GimpBrushFactoryViewClass *klass);
static void gimp_brush_factory_view_init (GimpBrushFactoryView *view);
static void gimp_brush_factory_view_destroy (GtkObject *object);
static void gimp_brush_factory_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static void gimp_brush_factory_view_spacing_changed (GimpBrush *brush,
GimpBrushFactoryView *view);
static void gimp_brush_factory_view_spacing_update (GtkAdjustment *adjustment,
GimpBrushFactoryView *view);
static GimpDataFactoryViewClass *parent_class = NULL;
GtkType
gimp_brush_factory_view_get_type (void)
{
static guint view_type = 0;
if (! view_type)
{
GtkTypeInfo view_info =
{
"GimpBrushFactoryView",
sizeof (GimpBrushFactoryView),
sizeof (GimpBrushFactoryViewClass),
(GtkClassInitFunc) gimp_brush_factory_view_class_init,
(GtkObjectInitFunc) gimp_brush_factory_view_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL
};
view_type = gtk_type_unique (GIMP_TYPE_DATA_FACTORY_VIEW, &view_info);
}
return view_type;
}
static void
gimp_brush_factory_view_class_init (GimpBrushFactoryViewClass *klass)
{
GtkObjectClass *object_class;
GimpContainerEditorClass *editor_class;
object_class = (GtkObjectClass *) klass;
editor_class = (GimpContainerEditorClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA_FACTORY_VIEW);
object_class->destroy = gimp_brush_factory_view_destroy;
editor_class->select_item = gimp_brush_factory_view_select_item;
}
static void
gimp_brush_factory_view_init (GimpBrushFactoryView *view)
{
GtkWidget *table;
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
gtk_box_pack_end (GTK_BOX (view), table, FALSE, FALSE, 0);
gtk_widget_show (table);
view->spacing_adjustment =
GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 1.0, 1000.0, 1.0, 1.0, 0.0));
view->spacing_scale = gtk_hscale_new (view->spacing_adjustment);
gtk_scale_set_value_pos (GTK_SCALE (view->spacing_scale), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (view->spacing_scale),
GTK_UPDATE_DELAYED);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Spacing:"), 1.0, 1.0,
view->spacing_scale, 1, FALSE);
gtk_signal_connect (GTK_OBJECT (view->spacing_adjustment), "value_changed",
GTK_SIGNAL_FUNC (gimp_brush_factory_view_spacing_update),
view);
view->spacing_changed_handler_id = 0;
}
static void
gimp_brush_factory_view_destroy (GtkObject *object)
{
GimpBrushFactoryView *view;
view = GIMP_BRUSH_FACTORY_VIEW (object);
if (view->spacing_changed_handler_id)
{
gimp_container_remove_handler
(GIMP_CONTAINER_EDITOR (view)->view->container,
view->spacing_changed_handler_id);
view->spacing_changed_handler_id = 0;
}
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
GtkWidget *
gimp_brush_factory_view_new (GimpViewType view_type,
GimpDataFactory *factory,
GimpDataEditFunc edit_func,
GimpContext *context,
gboolean change_brush_spacing,
gint preview_size,
gint min_items_x,
gint min_items_y)
{
GimpBrushFactoryView *factory_view;
GimpContainerEditor *editor;
g_return_val_if_fail (factory != NULL, NULL);
g_return_val_if_fail (GIMP_IS_DATA_FACTORY (factory), NULL);
g_return_val_if_fail (preview_size > 0 && preview_size <= 64, NULL);
g_return_val_if_fail (min_items_x > 0 && min_items_x <= 64, NULL);
g_return_val_if_fail (min_items_y > 0 && min_items_y <= 64, NULL);
factory_view = gtk_type_new (GIMP_TYPE_BRUSH_FACTORY_VIEW);
factory_view->change_brush_spacing = change_brush_spacing;
if (! gimp_data_factory_view_construct (GIMP_DATA_FACTORY_VIEW (factory_view),
view_type,
factory,
edit_func,
context,
preview_size,
min_items_x,
min_items_y))
{
gtk_object_unref (GTK_OBJECT (factory_view));
return NULL;
}
editor = GIMP_CONTAINER_EDITOR (factory_view);
gimp_container_add_handler
(editor->view->container, "spacing_changed",
GTK_SIGNAL_FUNC (gimp_brush_factory_view_spacing_changed),
factory_view);
return GTK_WIDGET (factory_view);
}
static void
gimp_brush_factory_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
GimpBrushFactoryView *view;
GimpBrush *brush;
gboolean edit_sensitive = FALSE;
gboolean spacing_sensitive = FALSE;
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
view = GIMP_BRUSH_FACTORY_VIEW (editor);
brush = GIMP_BRUSH (viewable);
if (brush &&
gimp_container_have (GIMP_CONTAINER_EDITOR (view)->view->container,
GIMP_OBJECT (brush)))
{
edit_sensitive = GIMP_IS_BRUSH_GENERATED (brush);
spacing_sensitive = TRUE;
gtk_signal_handler_block_by_func (GTK_OBJECT (view->spacing_adjustment),
gimp_brush_factory_view_spacing_update,
view);
gtk_adjustment_set_value (view->spacing_adjustment,
gimp_brush_get_spacing (brush));
gtk_signal_handler_unblock_by_func (GTK_OBJECT (view->spacing_adjustment),
gimp_brush_factory_view_spacing_update,
view);
}
gtk_widget_set_sensitive (GIMP_DATA_FACTORY_VIEW (view)->edit_button,
edit_sensitive);
gtk_widget_set_sensitive (view->spacing_scale, spacing_sensitive);
}
static void
gimp_brush_factory_view_spacing_changed (GimpBrush *brush,
GimpBrushFactoryView *view)
{
if (brush == GIMP_CONTAINER_EDITOR (view)->view->context->brush)
{
gtk_signal_handler_block_by_func (GTK_OBJECT (view->spacing_adjustment),
gimp_brush_factory_view_spacing_update,
view);
gtk_adjustment_set_value (view->spacing_adjustment,
gimp_brush_get_spacing (brush));
gtk_signal_handler_unblock_by_func (GTK_OBJECT (view->spacing_adjustment),
gimp_brush_factory_view_spacing_update,
view);
}
}
static void
gimp_brush_factory_view_spacing_update (GtkAdjustment *adjustment,
GimpBrushFactoryView *view)
{
GimpBrush *brush;
brush = GIMP_CONTAINER_EDITOR (view)->view->context->brush;
if (brush && view->change_brush_spacing)
{
gtk_signal_handler_block_by_func (GTK_OBJECT (brush),
gimp_brush_factory_view_spacing_changed,
view);
gimp_brush_set_spacing (brush, adjustment->value);
gtk_signal_handler_unblock_by_func (GTK_OBJECT (brush),
gimp_brush_factory_view_spacing_changed,
view);
}
}

67
app/widgets/gimpbrushfactoryview.h Normal file
View File

@ -0,0 +1,67 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpbrushfactoryview.h
* Copyright (C) 2001 Michael Natterer
*
* 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_BRUSH_FACTORY_VIEW_H__
#define __GIMP_BRUSH_FACTORY_VIEW_H__
#include "gimpdatafactoryview.h"
#define GIMP_TYPE_BRUSH_FACTORY_VIEW (gimp_brush_factory_view_get_type ())
#define GIMP_BRUSH_FACTORY_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_BRUSH_FACTORY_VIEW, GimpBrushFactoryView))
#define GIMP_BRUSH_FACTORY_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH_FACTORY_VIEW, GimpBrushFactoryViewClass))
#define GIMP_IS_BRUSH_FACTORY_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_BRUSH_FACTORY_VIEW))
#define GIMP_IS_BRUSH_FACTORY_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BRUSH_FACTORY_VIEW))
typedef struct _GimpBrushFactoryViewClass GimpBrushFactoryViewClass;
struct _GimpBrushFactoryView
{
GimpDataFactoryView parent_instance;
GtkWidget *spacing_scale;
GtkAdjustment *spacing_adjustment;
gboolean change_brush_spacing;
GQuark spacing_changed_handler_id;
};
struct _GimpBrushFactoryViewClass
{
GimpDataFactoryViewClass parent_class;
};
GtkType gimp_brush_factory_view_get_type (void);
GtkWidget * gimp_brush_factory_view_new (GimpViewType view_type,
GimpDataFactory *factory,
GimpDataEditFunc edit_func,
GimpContext *context,
gboolean change_brush_spacing,
gint preview_size,
gint min_items_x,
gint min_items_y);
#endif /* __GIMP_BRUSH_FACTORY_VIEW_H__ */

223
app/widgets/gimpbufferview.c
View File

@ -53,35 +53,17 @@ static void gimp_buffer_view_destroy (GtkObject *object);
static void gimp_buffer_view_paste_clicked (GtkWidget *widget,
GimpBufferView *view);
static void gimp_buffer_view_paste_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);
static void gimp_buffer_view_paste_into_clicked (GtkWidget *widget,
GimpBufferView *view);
static void gimp_buffer_view_paste_into_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);
static void gimp_buffer_view_paste_as_new_clicked (GtkWidget *widget,
GimpBufferView *view);
static void gimp_buffer_view_paste_as_new_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);
static void gimp_buffer_view_delete_clicked (GtkWidget *widget,
GimpBufferView *view);
static void gimp_buffer_view_delete_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);
static void gimp_buffer_view_item_changed (GimpContext *context,
GimpViewable *viewable,
GimpBufferView *view);
static void gimp_buffer_view_item_activate (GtkWidget *context,
GimpViewable *viewable,
gpointer insert_data,
GimpBufferView *view);
static void gimp_buffer_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static void gimp_buffer_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static GimpContainerEditorClass *parent_class = NULL;
@ -115,13 +97,18 @@ gimp_buffer_view_get_type (void)
static void
gimp_buffer_view_class_init (GimpBufferViewClass *klass)
{
GtkObjectClass *object_class;
GtkObjectClass *object_class;
GimpContainerEditorClass *editor_class;
object_class = (GtkObjectClass *) klass;
editor_class = (GimpContainerEditorClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_CONTAINER_EDITOR);
object_class->destroy = gimp_buffer_view_destroy;
object_class->destroy = gimp_buffer_view_destroy;
editor_class->select_item = gimp_buffer_view_select_item;
editor_class->activate_item = gimp_buffer_view_activate_item;
}
static void
@ -131,69 +118,29 @@ gimp_buffer_view_init (GimpBufferView *view)
editor = GIMP_CONTAINER_EDITOR (view);
/* paste */
view->paste_button =
gimp_container_editor_add_button (editor,
paste_xpm,
_("Paste"), NULL,
gimp_buffer_view_paste_clicked);
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view->paste_button),
GTK_DEST_DEFAULT_ALL,
GIMP_TYPE_BUFFER,
GDK_ACTION_COPY);
gimp_dnd_viewable_dest_set (GTK_WIDGET (view->paste_button),
GIMP_TYPE_BUFFER,
gimp_buffer_view_paste_dropped,
view);
/* paste into */
view->paste_into_button =
gimp_container_editor_add_button (editor,
paste_into_xpm,
_("Paste Into"), NULL,
gimp_buffer_view_paste_into_clicked);
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view->paste_into_button),
GTK_DEST_DEFAULT_ALL,
GIMP_TYPE_BUFFER,
GDK_ACTION_COPY);
gimp_dnd_viewable_dest_set (GTK_WIDGET (view->paste_into_button),
GIMP_TYPE_BUFFER,
gimp_buffer_view_paste_into_dropped,
view);
/* paste as new */
view->paste_as_new_button =
gimp_container_editor_add_button (editor,
paste_as_new_xpm,
_("Paste Into"), NULL,
_("Paste as New"), NULL,
gimp_buffer_view_paste_as_new_clicked);
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view->paste_as_new_button),
GTK_DEST_DEFAULT_ALL,
GIMP_TYPE_BUFFER,
GDK_ACTION_COPY);
gimp_dnd_viewable_dest_set (GTK_WIDGET (view->paste_as_new_button),
GIMP_TYPE_BUFFER,
gimp_buffer_view_paste_as_new_dropped,
view);
/* delete */
view->delete_button =
gimp_container_editor_add_button (editor,
delete_xpm,
_("Delete"), NULL,
gimp_buffer_view_delete_clicked);
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view->delete_button),
GTK_DEST_DEFAULT_ALL,
GIMP_TYPE_BUFFER,
GDK_ACTION_COPY);
gimp_dnd_viewable_dest_set (GTK_WIDGET (view->delete_button),
GIMP_TYPE_BUFFER,
gimp_buffer_view_delete_dropped,
view);
gtk_widget_set_sensitive (view->paste_button, FALSE);
gtk_widget_set_sensitive (view->paste_into_button, FALSE);
@ -239,23 +186,14 @@ gimp_buffer_view_new (GimpViewType view_type,
editor = GIMP_CONTAINER_EDITOR (buffer_view);
gtk_signal_connect_while_alive
(GTK_OBJECT (context), "buffer_changed",
GTK_SIGNAL_FUNC (gimp_buffer_view_item_changed),
buffer_view,
GTK_OBJECT (buffer_view));
gtk_signal_connect_while_alive
(GTK_OBJECT (editor->view), "activate_item",
GTK_SIGNAL_FUNC (gimp_buffer_view_item_activate),
buffer_view,
GTK_OBJECT (buffer_view));
/* set button sensitivity */
gimp_buffer_view_item_changed (context,
(GimpViewable *)
gimp_context_get_buffer (context),
buffer_view);
gimp_container_editor_enable_dnd (editor,
GTK_BUTTON (buffer_view->paste_button));
gimp_container_editor_enable_dnd (editor,
GTK_BUTTON (buffer_view->paste_into_button));
gimp_container_editor_enable_dnd (editor,
GTK_BUTTON (buffer_view->paste_as_new_button));
gimp_container_editor_enable_dnd (editor,
GTK_BUTTON (buffer_view->delete_button));
return GTK_WIDGET (buffer_view);
}
@ -280,35 +218,16 @@ gimp_buffer_view_paste_clicked (GtkWidget *widget,
if (gimage)
{
edit_paste (gimage,
gimp_image_active_drawable (gimage),
buffer->tiles,
FALSE);
gimp_edit_paste (gimage,
gimp_image_active_drawable (gimage),
buffer->tiles,
FALSE);
gdisplays_flush ();
}
}
}
static void
gimp_buffer_view_paste_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
GimpContainerEditor *editor;
editor = (GimpContainerEditor *) data;
if (viewable && gimp_container_have (editor->view->container,
GIMP_OBJECT (viewable)))
{
gimp_context_set_buffer (editor->view->context,
GIMP_BUFFER (viewable));
gimp_buffer_view_paste_clicked (NULL, data);
}
}
static void
gimp_buffer_view_paste_into_clicked (GtkWidget *widget,
GimpBufferView *view)
@ -329,35 +248,16 @@ gimp_buffer_view_paste_into_clicked (GtkWidget *widget,
if (gimage)
{
edit_paste (gimage,
gimp_image_active_drawable (gimage),
buffer->tiles,
TRUE);
gimp_edit_paste (gimage,
gimp_image_active_drawable (gimage),
buffer->tiles,
TRUE);
gdisplays_flush ();
}
}
}
static void
gimp_buffer_view_paste_into_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
GimpContainerEditor *editor;
editor = (GimpContainerEditor *) data;
if (viewable && gimp_container_have (editor->view->container,
GIMP_OBJECT (viewable)))
{
gimp_context_set_buffer (editor->view->context,
GIMP_BUFFER (viewable));
gimp_buffer_view_paste_into_clicked (NULL, data);
}
}
static void
gimp_buffer_view_paste_as_new_clicked (GtkWidget *widget,
GimpBufferView *view)
@ -378,30 +278,11 @@ gimp_buffer_view_paste_as_new_clicked (GtkWidget *widget,
if (gimage)
{
edit_paste_as_new (gimage, buffer->tiles);
gimp_edit_paste_as_new (gimage, buffer->tiles);
}
}
}
static void
gimp_buffer_view_paste_as_new_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
GimpContainerEditor *editor;
editor = (GimpContainerEditor *) data;
if (viewable && gimp_container_have (editor->view->container,
GIMP_OBJECT (viewable)))
{
gimp_context_set_buffer (editor->view->context,
GIMP_BUFFER (viewable));
gimp_buffer_view_paste_as_new_clicked (NULL, data);
}
}
static void
gimp_buffer_view_delete_clicked (GtkWidget *widget,
GimpBufferView *view)
@ -422,36 +303,23 @@ gimp_buffer_view_delete_clicked (GtkWidget *widget,
}
static void
gimp_buffer_view_delete_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
gimp_buffer_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
GimpContainerEditor *editor;
GimpBufferView *view;
editor = (GimpContainerEditor *) data;
if (viewable && gimp_container_have (editor->view->container,
GIMP_OBJECT (viewable)))
{
gimp_context_set_buffer (editor->view->context,
GIMP_BUFFER (viewable));
gimp_buffer_view_delete_clicked (NULL, data);
}
}
static void
gimp_buffer_view_item_changed (GimpContext *context,
GimpViewable *viewable,
GimpBufferView *view)
{
gboolean paste_sensitive = FALSE;
gboolean paste_into_sensitive = FALSE;
gboolean paste_as_new_sensitive = FALSE;
gboolean delete_sensitive = FALSE;
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
view = GIMP_BUFFER_VIEW (editor);
if (viewable &&
gimp_container_have (GIMP_CONTAINER_EDITOR (view)->view->container,
gimp_container_have (editor->view->container,
GIMP_OBJECT (viewable)))
{
paste_sensitive = TRUE;
@ -467,13 +335,18 @@ gimp_buffer_view_item_changed (GimpContext *context,
}
static void
gimp_buffer_view_item_activate (GtkWidget *widget,
GimpViewable *viewable,
gpointer insert_data,
GimpBufferView *view)
gimp_buffer_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
GimpBufferView *view;
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->activate_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->activate_item (editor, viewable);
view = GIMP_BUFFER_VIEW (editor);
if (viewable &&
gimp_container_have (GIMP_CONTAINER_EDITOR (view)->view->container,
gimp_container_have (editor->view->container,
GIMP_OBJECT (viewable)))
{
gimp_buffer_view_paste_clicked (NULL, view);

135
app/widgets/gimpcontainereditor.c
View File

@ -33,12 +33,30 @@
#include "gimpcontainereditor.h"
#include "gimpcontainergridview.h"
#include "gimpcontainerlistview.h"
#include "gimpdnd.h"
static void gimp_container_editor_class_init (GimpContainerEditorClass *klass);
static void gimp_container_editor_init (GimpContainerEditor *view);
static void gimp_container_editor_destroy (GtkObject *object);
static void gimp_container_editor_viewable_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);
static void gimp_container_editor_select_item (GtkWidget *widget,
GimpViewable *viewable,
gpointer insert_data,
GimpContainerEditor *editor);
static void gimp_container_editor_activate_item (GtkWidget *widget,
GimpViewable *viewable,
gpointer insert_data,
GimpContainerEditor *editor);
static void gimp_container_editor_context_item (GtkWidget *widget,
GimpViewable *viewable,
gpointer insert_data,
GimpContainerEditor *editor);
static GtkVBoxClass *parent_class = NULL;
@ -78,6 +96,10 @@ gimp_container_editor_class_init (GimpContainerEditorClass *klass)
parent_class = gtk_type_class (GTK_TYPE_VBOX);
object_class->destroy = gimp_container_editor_destroy;
klass->select_item = NULL;
klass->activate_item = NULL;
klass->context_item = NULL;
}
static void
@ -152,6 +174,32 @@ gimp_container_editor_construct (GimpContainerEditor *editor,
GTK_WIDGET (editor->view));
gtk_widget_show (GTK_WIDGET (editor->view));
gtk_signal_connect_while_alive
(GTK_OBJECT (editor->view), "select_item",
GTK_SIGNAL_FUNC (gimp_container_editor_select_item),
editor,
GTK_OBJECT (editor));
gtk_signal_connect_while_alive
(GTK_OBJECT (editor->view), "activate_item",
GTK_SIGNAL_FUNC (gimp_container_editor_activate_item),
editor,
GTK_OBJECT (editor));
gtk_signal_connect_while_alive
(GTK_OBJECT (editor->view), "context_item",
GTK_SIGNAL_FUNC (gimp_container_editor_context_item),
editor,
GTK_OBJECT (editor));
/* select the active item */
gimp_container_editor_select_item
(GTK_WIDGET (editor->view),
(GimpViewable *)
gimp_context_get_by_type (context, container->children_type),
NULL,
editor);
return TRUE;
}
@ -187,3 +235,90 @@ gimp_container_editor_add_button (GimpContainerEditor *editor,
return button;
}
void
gimp_container_editor_enable_dnd (GimpContainerEditor *editor,
GtkButton *button)
{
g_return_if_fail (editor != NULL);
g_return_if_fail (GIMP_IS_CONTAINER_EDITOR (editor));
g_return_if_fail (button != NULL);
g_return_if_fail (GTK_IS_BUTTON (button));
g_return_if_fail (editor->view != NULL);
g_return_if_fail (editor->view->container != NULL);
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (button),
GTK_DEST_DEFAULT_ALL,
editor->view->container->children_type,
GDK_ACTION_COPY);
gimp_dnd_viewable_dest_set (GTK_WIDGET (button),
editor->view->container->children_type,
gimp_container_editor_viewable_dropped,
editor);
}
/* private functions */
static void
gimp_container_editor_viewable_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
GimpContainerEditor *editor;
editor = (GimpContainerEditor *) data;
if (viewable && gimp_container_have (editor->view->container,
GIMP_OBJECT (viewable)))
{
gimp_context_set_by_type (editor->view->context,
editor->view->container->children_type,
GIMP_OBJECT (viewable));
gtk_button_clicked (GTK_BUTTON (widget));
}
}
static void
gimp_container_editor_select_item (GtkWidget *widget,
GimpViewable *viewable,
gpointer insert_data,
GimpContainerEditor *editor)
{
GimpContainerEditorClass *klass;
klass = GIMP_CONTAINER_EDITOR_CLASS (GTK_OBJECT (editor)->klass);
if (klass->select_item)
klass->select_item (editor, viewable);
}
static void
gimp_container_editor_activate_item (GtkWidget *widget,
GimpViewable *viewable,
gpointer insert_data,
GimpContainerEditor *editor)
{
GimpContainerEditorClass *klass;
klass = GIMP_CONTAINER_EDITOR_CLASS (GTK_OBJECT (editor)->klass);
if (klass->activate_item)
klass->activate_item (editor, viewable);
}
static void
gimp_container_editor_context_item (GtkWidget *widget,
GimpViewable *viewable,
gpointer insert_data,
GimpContainerEditor *editor)
{
GimpContainerEditorClass *klass;
klass = GIMP_CONTAINER_EDITOR_CLASS (GTK_OBJECT (editor)->klass);
if (klass->context_item)
klass->context_item (editor, viewable);
}

10
app/widgets/gimpcontainereditor.h
View File

@ -57,6 +57,13 @@ struct _GimpContainerEditor
struct _GimpContainerEditorClass
{
GtkVBoxClass parent_class;
void (* select_item) (GimpContainerEditor *editor,
GimpViewable *object);
void (* activate_item) (GimpContainerEditor *editor,
GimpViewable *object);
void (* context_item) (GimpContainerEditor *editor,
GimpViewable *object);
};
@ -72,11 +79,14 @@ gboolean gimp_container_editor_construct (GimpContainerEditor *editor,
gint preview_size,
gint min_items_x,
gint min_items_y);
GtkWidget * gimp_container_editor_add_button (GimpContainerEditor *editor,
gchar **xpm_data,
const gchar *tooltip,
const gchar *help_data,
GtkSignalFunc callback);
void gimp_container_editor_enable_dnd (GimpContainerEditor *editor,
GtkButton *button);
#endif /* __GIMP_CONTAINER_EDITOR_H__ */

327
app/widgets/gimpdatafactoryview.c
View File

@ -60,29 +60,17 @@ static void gimp_data_factory_view_new_clicked (GtkWidget *wid
GimpDataFactoryView *view);
static void gimp_data_factory_view_duplicate_clicked (GtkWidget *widget,
GimpDataFactoryView *view);
static void gimp_data_factory_view_duplicate_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);
static void gimp_data_factory_view_edit_clicked (GtkWidget *widget,
GimpDataFactoryView *view);
static void gimp_data_factory_view_edit_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);
static void gimp_data_factory_view_delete_clicked (GtkWidget *widget,
GimpDataFactoryView *view);
static void gimp_data_factory_view_delete_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);
static void gimp_data_factory_view_refresh_clicked (GtkWidget *widget,
GimpDataFactoryView *view);
static void gimp_data_factory_view_data_changed (GimpContext *context,
GimpData *data,
GimpDataFactoryView *view);
static void gimp_data_factory_view_data_activate (GtkWidget *context,
GimpData *data,
gpointer insert_data,
GimpDataFactoryView *view);
static void gimp_data_factory_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static void gimp_data_factory_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static GimpContainerEditorClass *parent_class = NULL;
@ -116,107 +104,56 @@ gimp_data_factory_view_get_type (void)
static void
gimp_data_factory_view_class_init (GimpDataFactoryViewClass *klass)
{
GtkObjectClass *object_class;
GtkObjectClass *object_class;
GimpContainerEditorClass *editor_class;
object_class = (GtkObjectClass *) klass;
editor_class = (GimpContainerEditorClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_CONTAINER_EDITOR);
object_class->destroy = gimp_data_factory_view_destroy;
object_class->destroy = gimp_data_factory_view_destroy;
editor_class->select_item = gimp_data_factory_view_select_item;
editor_class->activate_item = gimp_data_factory_view_activate_item;
}
static void
gimp_data_factory_view_init (GimpDataFactoryView *view)
{
GimpContainerEditor *editor;
GtkWidget *pixmap;
editor = GIMP_CONTAINER_EDITOR (view);
/* new */
view->new_button =
gimp_container_editor_add_button (editor,
new_xpm,
_("New"), NULL,
gimp_data_factory_view_new_clicked);
view->new_button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (editor->button_box), view->new_button,
TRUE, TRUE, 0);
gtk_widget_show (view->new_button);
view->duplicate_button =
gimp_container_editor_add_button (editor,
duplicate_xpm,
_("Duplicate"), NULL,
gimp_data_factory_view_duplicate_clicked);
gimp_help_set_help_data (view->new_button, _("New"), NULL);
view->edit_button =
gimp_container_editor_add_button (editor,
edit_xpm,
_("Edit"), NULL,
gimp_data_factory_view_edit_clicked);
gtk_signal_connect (GTK_OBJECT (view->new_button), "clicked",
GTK_SIGNAL_FUNC (gimp_data_factory_view_new_clicked),
view);
view->delete_button =
gimp_container_editor_add_button (editor,
delete_xpm,
_("Delete"), NULL,
gimp_data_factory_view_delete_clicked);
pixmap = gimp_pixmap_new (new_xpm);
gtk_container_add (GTK_CONTAINER (view->new_button), pixmap);
gtk_widget_show (pixmap);
/* duplicate */
view->duplicate_button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (editor->button_box), view->duplicate_button,
TRUE, TRUE, 0);
gtk_widget_show (view->duplicate_button);
gimp_help_set_help_data (view->duplicate_button, _("Duplicate"), NULL);
gtk_signal_connect (GTK_OBJECT (view->duplicate_button), "clicked",
GTK_SIGNAL_FUNC (gimp_data_factory_view_duplicate_clicked),
view);
pixmap = gimp_pixmap_new (duplicate_xpm);
gtk_container_add (GTK_CONTAINER (view->duplicate_button), pixmap);
gtk_widget_show (pixmap);
/* edit */
view->edit_button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (editor->button_box), view->edit_button,
TRUE, TRUE, 0);
gtk_widget_show (view->edit_button);
gimp_help_set_help_data (view->edit_button, _("Edit"), NULL);
gtk_signal_connect (GTK_OBJECT (view->edit_button), "clicked",
GTK_SIGNAL_FUNC (gimp_data_factory_view_edit_clicked),
view);
pixmap = gimp_pixmap_new (edit_xpm);
gtk_container_add (GTK_CONTAINER (view->edit_button), pixmap);
gtk_widget_show (pixmap);
/* delete */
view->delete_button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (editor->button_box), view->delete_button,
TRUE, TRUE, 0);
gtk_widget_show (view->delete_button);
gimp_help_set_help_data (view->delete_button, _("Delete"), NULL);
gtk_signal_connect (GTK_OBJECT (view->delete_button), "clicked",
GTK_SIGNAL_FUNC (gimp_data_factory_view_delete_clicked),
view);
pixmap = gimp_pixmap_new (delete_xpm);
gtk_container_add (GTK_CONTAINER (view->delete_button), pixmap);
gtk_widget_show (pixmap);
/* refresh */
view->refresh_button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (editor->button_box), view->refresh_button,
TRUE, TRUE, 0);
gtk_widget_show (view->refresh_button);
gimp_help_set_help_data (view->refresh_button, _("Refresh"), NULL);
gtk_signal_connect (GTK_OBJECT (view->refresh_button), "clicked",
GTK_SIGNAL_FUNC (gimp_data_factory_view_refresh_clicked),
view);
pixmap = gimp_pixmap_new (refresh_xpm);
gtk_container_add (GTK_CONTAINER (view->refresh_button), pixmap);
gtk_widget_show (pixmap);
view->refresh_button =
gimp_container_editor_add_button (editor,
refresh_xpm,
_("Refresh"), NULL,
gimp_data_factory_view_refresh_clicked);
gtk_widget_set_sensitive (view->duplicate_button, FALSE);
gtk_widget_set_sensitive (view->edit_button, FALSE);
@ -245,14 +182,44 @@ gimp_data_factory_view_new (GimpViewType view_type,
{
GimpDataFactoryView *factory_view;
g_return_val_if_fail (factory != NULL, NULL);
g_return_val_if_fail (GIMP_IS_DATA_FACTORY (factory), NULL);
g_return_val_if_fail (preview_size > 0 && preview_size <= 64, NULL);
g_return_val_if_fail (min_items_x > 0 && min_items_x <= 64, NULL);
g_return_val_if_fail (min_items_y > 0 && min_items_y <= 64, NULL);
factory_view = gtk_type_new (GIMP_TYPE_DATA_FACTORY_VIEW);
if (! gimp_data_factory_view_construct (factory_view,
view_type,
factory,
edit_func,
context,
preview_size,
min_items_x,
min_items_y))
{
gtk_object_unref (GTK_OBJECT (factory_view));
return NULL;
}
return GTK_WIDGET (factory_view);
}
gboolean
gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
GimpViewType view_type,
GimpDataFactory *factory,
GimpDataEditFunc edit_func,
GimpContext *context,
gint preview_size,
gint min_items_x,
gint min_items_y)
{
GimpContainerEditor *editor;
g_return_val_if_fail (factory_view != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_DATA_FACTORY_VIEW (factory_view), FALSE);
g_return_val_if_fail (factory != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_DATA_FACTORY (factory), FALSE);
g_return_val_if_fail (preview_size > 0 && preview_size <= 64, 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);
factory_view->factory = factory;
factory_view->data_edit_func = edit_func;
@ -264,61 +231,19 @@ gimp_data_factory_view_new (GimpViewType view_type,
min_items_x,
min_items_y))
{
gtk_object_unref (GTK_OBJECT (factory_view));
return NULL;
return FALSE;
}
gtk_signal_connect_while_alive
(GTK_OBJECT (context),
gimp_context_type_to_signal_name (factory->container->children_type),
GTK_SIGNAL_FUNC (gimp_data_factory_view_data_changed),
factory_view,
GTK_OBJECT (factory_view));
editor = GIMP_CONTAINER_EDITOR (factory_view);
gtk_signal_connect_while_alive
(GTK_OBJECT (GIMP_CONTAINER_EDITOR (factory_view)->view), "activate_item",
GTK_SIGNAL_FUNC (gimp_data_factory_view_data_activate),
factory_view,
GTK_OBJECT (factory_view));
gimp_container_editor_enable_dnd (editor,
GTK_BUTTON (factory_view->duplicate_button));
gimp_container_editor_enable_dnd (editor,
GTK_BUTTON (factory_view->edit_button));
gimp_container_editor_enable_dnd (editor,
GTK_BUTTON (factory_view->delete_button));
/* drop to "duplicate" */
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (factory_view->duplicate_button),
GTK_DEST_DEFAULT_ALL,
factory_view->factory->container->children_type,
GDK_ACTION_COPY);
gimp_dnd_viewable_dest_set (GTK_WIDGET (factory_view->duplicate_button),
factory_view->factory->container->children_type,
gimp_data_factory_view_duplicate_dropped,
factory_view);
/* drop to "edit" */
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (factory_view->edit_button),
GTK_DEST_DEFAULT_ALL,
factory_view->factory->container->children_type,
GDK_ACTION_COPY);
gimp_dnd_viewable_dest_set (GTK_WIDGET (factory_view->edit_button),
factory_view->factory->container->children_type,
gimp_data_factory_view_edit_dropped,
factory_view);
/* drop to "delete" */
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (factory_view->delete_button),
GTK_DEST_DEFAULT_ALL,
factory_view->factory->container->children_type,
GDK_ACTION_COPY);
gimp_dnd_viewable_dest_set (GTK_WIDGET (factory_view->delete_button),
factory_view->factory->container->children_type,
gimp_data_factory_view_delete_dropped,
factory_view);
/* set button sensitivity */
gimp_data_factory_view_data_changed
(context,
(GimpData *)
gimp_context_get_by_type (context, factory->container->children_type),
factory_view);
return GTK_WIDGET (factory_view);
return TRUE;
}
static void
@ -400,26 +325,6 @@ gimp_data_factory_view_duplicate_clicked (GtkWidget *widget,
}
}
static void
gimp_data_factory_view_duplicate_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
GimpDataFactoryView *view;
view = (GimpDataFactoryView *) data;
if (viewable && gimp_container_have (view->factory->container,
GIMP_OBJECT (viewable)))
{
gimp_context_set_by_type (GIMP_CONTAINER_EDITOR (view)->view->context,
view->factory->container->children_type,
GIMP_OBJECT (viewable));
gimp_data_factory_view_duplicate_clicked (NULL, data);
}
}
static void
gimp_data_factory_view_edit_clicked (GtkWidget *widget,
GimpDataFactoryView *view)
@ -439,27 +344,6 @@ gimp_data_factory_view_edit_clicked (GtkWidget *widget,
}
}
static void
gimp_data_factory_view_edit_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
GimpDataFactoryView *view;
view = (GimpDataFactoryView *) data;
if (viewable && gimp_container_have (view->factory->container,
GIMP_OBJECT (viewable)))
{
gimp_context_set_by_type (GIMP_CONTAINER_EDITOR (view)->view->context,
view->factory->container->children_type,
GIMP_OBJECT (viewable));
gimp_data_factory_view_edit_clicked (NULL, data);
}
}
typedef struct _GimpDataDeleteData GimpDataDeleteData;
struct _GimpDataDeleteData
@ -538,26 +422,6 @@ gimp_data_factory_view_delete_clicked (GtkWidget *widget,
}
}
static void
gimp_data_factory_view_delete_dropped (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
GimpDataFactoryView *view;
view = (GimpDataFactoryView *) data;
if (viewable && gimp_container_have (view->factory->container,
GIMP_OBJECT (viewable)))
{
gimp_context_set_by_type (GIMP_CONTAINER_EDITOR (view)->view->context,
view->factory->container->children_type,
GIMP_OBJECT (viewable));
gimp_data_factory_view_delete_clicked (NULL, data);
}
}
static void
gimp_data_factory_view_refresh_clicked (GtkWidget *widget,
GimpDataFactoryView *view)
@ -566,14 +430,22 @@ gimp_data_factory_view_refresh_clicked (GtkWidget *widget,
}
static void
gimp_data_factory_view_data_changed (GimpContext *context,
GimpData *data,
GimpDataFactoryView *view)
gimp_data_factory_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
GimpDataFactoryView *view;
GimpData *data;
gboolean duplicate_sensitive = FALSE;
gboolean edit_sensitive = FALSE;
gboolean delete_sensitive = FALSE;
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
view = GIMP_DATA_FACTORY_VIEW (editor);
data = GIMP_DATA (viewable);
if (data && gimp_container_have (view->factory->container,
GIMP_OBJECT (data)))
{
@ -590,11 +462,18 @@ gimp_data_factory_view_data_changed (GimpContext *context,
}
static void
gimp_data_factory_view_data_activate (GtkWidget *widget,
GimpData *data,
gpointer insert_data,
GimpDataFactoryView *view)
gimp_data_factory_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
GimpDataFactoryView *view;
GimpData *data;
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->activate_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->activate_item (editor, viewable);
view = GIMP_DATA_FACTORY_VIEW (editor);
data = GIMP_DATA (viewable);
if (data && gimp_container_have (view->factory->container,
GIMP_OBJECT (data)))
{

27
app/widgets/gimpdatafactoryview.h
View File

@ -59,15 +59,26 @@ struct _GimpDataFactoryViewClass
};
GtkType gimp_data_factory_view_get_type (void);
GtkType gimp_data_factory_view_get_type (void);
GtkWidget * gimp_data_factory_view_new (GimpViewType view_type,
GimpDataFactory *factory,
GimpDataEditFunc edit_func,
GimpContext *context,
gint preview_size,
gint min_items_x,
gint min_items_y);
GtkWidget * gimp_data_factory_view_new (GimpViewType view_type,
GimpDataFactory *factory,
GimpDataEditFunc edit_func,
GimpContext *context,
gint preview_size,
gint min_items_x,
gint min_items_y);
/* protected */
gboolean gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
GimpViewType view_type,
GimpDataFactory *factory,
GimpDataEditFunc edit_func,
GimpContext *context,
gint preview_size,
gint min_items_x,
gint min_items_y);
#endif /* __GIMP_DATA_FACTORY_VIEW_H__ */

241
app/widgets/gimpdialogfactory.c
View File

@ -33,6 +33,7 @@
#include "gimpdock.h"
#include "gimpdockbook.h"
#include "gimpdockable.h"
#include "gimpimagedock.h"
static void gimp_dialog_factory_class_init (GimpDialogFactoryClass *klass);
@ -251,8 +252,10 @@ gimp_dialog_factory_find_session_info (GimpDialogFactory *factory,
info = (GimpSessionInfo *) list->data;
if (info->toplevel_entry &&
! strcmp (identifier, info->toplevel_entry->identifier))
if ((info->toplevel_entry &&
! strcmp (identifier, info->toplevel_entry->identifier)) ||
(info->dockable_entry &&
! strcmp (identifier, info->dockable_entry->identifier)))
{
return info;
}
@ -264,7 +267,8 @@ gimp_dialog_factory_find_session_info (GimpDialogFactory *factory,
static GtkWidget *
gimp_dialog_factory_dialog_new_internal (GimpDialogFactory *factory,
GimpContext *context,
const gchar *identifier)
const gchar *identifier,
gboolean raise_if_found)
{
GimpDialogFactoryEntry *entry;
GtkWidget *dialog = NULL;
@ -289,7 +293,7 @@ gimp_dialog_factory_dialog_new_internal (GimpDialogFactory *factory,
return NULL;
}
if (entry->singleton)
if (raise_if_found || entry->singleton)
{
GimpSessionInfo *info;
@ -301,7 +305,24 @@ gimp_dialog_factory_dialog_new_internal (GimpDialogFactory *factory,
if (! dialog)
{
dialog = entry->new_func (factory, context);
GtkWidget *dock = NULL;
if (factory->new_dock_func && ! context)
{
dock = gimp_dialog_factory_dock_new (factory);
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dock), FALSE);
gimp_dock_add_book (GIMP_DOCK (dock),
GIMP_DOCKBOOK (gimp_dockbook_new ()), 0);
}
if (context)
dialog = entry->new_func (factory, context);
else if (dock)
dialog = entry->new_func (factory, GIMP_DOCK (dock)->context);
else
dialog = entry->new_func (factory, factory->context);
if (dialog)
{
@ -312,19 +333,59 @@ gimp_dialog_factory_dialog_new_internal (GimpDialogFactory *factory,
"gimp-dialog-factory-entry",
entry);
if (GTK_WIDGET_TOPLEVEL (dialog))
gimp_dialog_factory_add_dialog (factory, dialog);
if (dock)
{
gimp_dialog_factory_add_toplevel (factory, dialog);
gimp_dock_add (GIMP_DOCK (dock), GIMP_DOCKABLE (dialog), 0, 0);
gtk_widget_show (dock);
}
}
else if (dock)
{
gtk_widget_destroy (dock);
}
}
if (dialog && GTK_WIDGET_TOPLEVEL (dialog))
if (dialog)
{
if (! GTK_WIDGET_VISIBLE (dialog))
gtk_widget_show (dialog);
else if (dialog->window)
gdk_window_raise (dialog->window);
if (GTK_WIDGET_TOPLEVEL (dialog))
{
if (! GTK_WIDGET_VISIBLE (dialog))
gtk_widget_show (dialog);
else if (dialog->window)
gdk_window_raise (dialog->window);
}
else if (GIMP_IS_DOCKABLE (dialog))
{
GimpDockable *dockable;
gint page_num;
dockable = GIMP_DOCKABLE (dialog);
if (dockable->dockbook && dockable->dockbook->dock)
{
page_num =
gtk_notebook_page_num (GTK_NOTEBOOK (dockable->dockbook),
dialog);
if (page_num != -1)
{
GtkWidget *toplevel;
gtk_notebook_set_page (GTK_NOTEBOOK (dockable->dockbook),
page_num);
toplevel = gtk_widget_get_toplevel (dialog);
if (! GTK_WIDGET_VISIBLE (toplevel))
gtk_widget_show (toplevel);
else if (toplevel->window)
gdk_window_raise (toplevel->window);
}
}
}
}
return dialog;
@ -340,7 +401,22 @@ gimp_dialog_factory_dialog_new (GimpDialogFactory *factory,
return gimp_dialog_factory_dialog_new_internal (factory,
factory->context,
identifier);
identifier,
FALSE);
}
GtkWidget *
gimp_dialog_factory_dialog_raise (GimpDialogFactory *factory,
const gchar *identifier)
{
g_return_val_if_fail (factory != NULL, NULL);
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL);
g_return_val_if_fail (identifier != NULL, NULL);
return gimp_dialog_factory_dialog_new_internal (factory,
NULL,
identifier,
TRUE);
}
GtkWidget *
@ -356,7 +432,8 @@ gimp_dialog_factory_dockable_new (GimpDialogFactory *factory,
return gimp_dialog_factory_dialog_new_internal (factory,
dock->context,
identifier);
identifier,
FALSE);
}
GtkWidget *
@ -371,54 +448,61 @@ gimp_dialog_factory_dock_new (GimpDialogFactory *factory)
dock = factory->new_dock_func (factory, factory->context);
if (dock)
gimp_dialog_factory_add_toplevel (factory, dock);
gimp_dialog_factory_add_dialog (factory, dock);
return dock;
}
void
gimp_dialog_factory_add_toplevel (GimpDialogFactory *factory,
GtkWidget *toplevel)
gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
GtkWidget *dialog)
{
GimpDialogFactory *toplevel_factory;
GimpDialogFactory *dialog_factory;
GimpDialogFactoryEntry *entry;
GimpSessionInfo *info;
GList *list;
g_return_if_fail (factory != NULL);
g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory));
g_return_if_fail (toplevel != NULL);
g_return_if_fail (GTK_IS_WIDGET (toplevel));
g_return_if_fail (dialog != NULL);
g_return_if_fail (GTK_IS_WIDGET (dialog));
if (g_list_find (factory->open_dialogs, toplevel))
if (g_list_find (factory->open_dialogs, dialog))
{
g_warning ("%s(): dialog already registered", G_GNUC_FUNCTION);
return;
}
toplevel_factory = gtk_object_get_data (GTK_OBJECT (toplevel),
"gimp-dialog-factory");
dialog_factory = gtk_object_get_data (GTK_OBJECT (dialog),
"gimp-dialog-factory");
if (toplevel_factory && toplevel_factory != factory)
if (dialog_factory && dialog_factory != factory)
{
g_warning ("%s(): dialog was created by a different GimpDialogFactory",
G_GNUC_FUNCTION);
return;
}
entry = gtk_object_get_data (GTK_OBJECT (toplevel),
entry = gtk_object_get_data (GTK_OBJECT (dialog),
"gimp-dialog-factory-entry");
if (entry) /* toplevel was created by this factory */
if (entry) /* dialog was created by this factory */
{
g_print ("%s: registering toplevel \"%s\"\n",
G_GNUC_FUNCTION, entry->identifier);
gboolean toplevel;
toplevel = GTK_WIDGET_TOPLEVEL (dialog);
g_print ("%s: registering %s \"%s\"\n",
G_GNUC_FUNCTION,
toplevel ? "toplevel" : "dockable",
entry->identifier);
for (list = factory->session_infos; list; list = g_list_next (list))
{
info = (GimpSessionInfo *) list->data;
if (info->toplevel_entry == entry)
if (((info->toplevel_entry == entry) && toplevel) ||
(info->dockable_entry == entry))
{
if (entry->singleton)
{
@ -434,7 +518,7 @@ gimp_dialog_factory_add_toplevel (GimpDialogFactory *factory,
continue;
}
info->widget = toplevel;
info->widget = dialog;
if (entry->session_managed)
{
@ -449,8 +533,12 @@ gimp_dialog_factory_add_toplevel (GimpDialogFactory *factory,
{
info = g_new0 (GimpSessionInfo, 1);
info->widget = toplevel;
info->toplevel_entry = entry;
info->widget = dialog;
if (toplevel)
info->toplevel_entry = entry;
else
info->dockable_entry = entry;
factory->session_infos = g_list_append (factory->session_infos, info);
}
@ -465,7 +553,7 @@ gimp_dialog_factory_add_toplevel (GimpDialogFactory *factory,
if (! info->widget) /* take the first empty slot */
{
info->widget = toplevel;
info->widget = dialog;
gimp_dialog_factory_set_window_geometry (info->widget, info);
@ -477,44 +565,45 @@ gimp_dialog_factory_add_toplevel (GimpDialogFactory *factory,
{
info = g_new0 (GimpSessionInfo, 1);
info->widget = toplevel;
info->widget = dialog;
factory->session_infos = g_list_append (factory->session_infos, info);
}
}
factory->open_dialogs = g_list_prepend (factory->open_dialogs, toplevel);
factory->open_dialogs = g_list_prepend (factory->open_dialogs, dialog);
gtk_signal_connect_object_while_alive (GTK_OBJECT (toplevel), "destroy",
GTK_SIGNAL_FUNC (gimp_dialog_factory_remove_toplevel),
GTK_OBJECT (factory));
gtk_signal_connect_object_while_alive
(GTK_OBJECT (dialog), "destroy",
GTK_SIGNAL_FUNC (gimp_dialog_factory_remove_dialog),
GTK_OBJECT (factory));
}
void
gimp_dialog_factory_remove_toplevel (GimpDialogFactory *factory,
GtkWidget *toplevel)
gimp_dialog_factory_remove_dialog (GimpDialogFactory *factory,
GtkWidget *dialog)
{
GimpDialogFactory *toplevel_factory;
GimpDialogFactory *dialog_factory;
GimpSessionInfo *session_info;
GList *list;
g_return_if_fail (factory != NULL);
g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory));
g_return_if_fail (toplevel != NULL);
g_return_if_fail (GTK_IS_WIDGET (toplevel));
g_return_if_fail (dialog != NULL);
g_return_if_fail (GTK_IS_WIDGET (dialog));
if (! g_list_find (factory->open_dialogs, toplevel))
if (! g_list_find (factory->open_dialogs, dialog))
{
g_warning ("%s(): dialog not registered", G_GNUC_FUNCTION);
return;
}
factory->open_dialogs = g_list_remove (factory->open_dialogs, toplevel);
factory->open_dialogs = g_list_remove (factory->open_dialogs, dialog);
toplevel_factory = gtk_object_get_data (GTK_OBJECT (toplevel),
"gimp-dialog-factory");
dialog_factory = gtk_object_get_data (GTK_OBJECT (dialog),
"gimp-dialog-factory");
if (toplevel_factory && toplevel_factory != factory)
if (dialog_factory && dialog_factory != factory)
{
g_warning ("%s(): dialog was created by a different GimpDialogFactory",
G_GNUC_FUNCTION);
@ -525,10 +614,19 @@ gimp_dialog_factory_remove_toplevel (GimpDialogFactory *factory,
{
session_info = (GimpSessionInfo *) list->data;
if (session_info->widget == toplevel)
if (session_info->widget == dialog)
{
session_info->widget = NULL;
/* don't save session info for empty docks */
if (GIMP_IS_DOCK (dialog))
{
factory->session_infos = g_list_remove (factory->session_infos,
session_info);
g_free (session_info);
}
break;
}
}
@ -547,10 +645,11 @@ gimp_dialog_factories_session_save_foreach (gchar *name,
info = (GimpSessionInfo *) list->data;
/* we keep session info entries for all dialogs created by the
* factory but don't save them if they don't want to be managed
*/
if (info->toplevel_entry && ! info->toplevel_entry->session_managed)
/* we keep session info entries for all toplevel dialogs created
* by the factory but don't save them if they don't want to be
* managed */
if (info->dockable_entry ||
(info->toplevel_entry && ! info->toplevel_entry->session_managed))
continue;
if (info->widget)
@ -574,6 +673,17 @@ gimp_dialog_factories_session_save_foreach (gchar *name,
dock = GIMP_DOCK (info->widget);
/* FIXME: make the aux-info stuff generic */
{
gboolean menu_shown;
menu_shown =
GTK_WIDGET_VISIBLE (GIMP_IMAGE_DOCK (dock)->option_menu->parent);
fprintf (fp, "\n (aux-info (\"%s\"))",
menu_shown ? "menu-shown" : "menu-hidden");
}
fprintf (fp, "\n (dock ");
for (books = dock->dockbooks; books; books = g_list_next (books))
@ -633,6 +743,7 @@ gimp_dialog_factories_session_restore_foreach (gchar *name,
gpointer data)
{
GList *list;
GList *aux;
for (list = factory->session_infos; list; list = g_list_next (list))
{
@ -657,6 +768,26 @@ gimp_dialog_factories_session_restore_foreach (gchar *name,
dock = GIMP_DOCK (gimp_dialog_factory_dock_new (factory));
/* FIXME: make the aux-info stuff generic */
{
gboolean menu_shown = TRUE;
for (aux = info->aux_info; aux; aux = g_list_next (aux))
{
gchar *str;
str = (gchar *) aux->data;
if (! strcmp (str, "menu-shown"))
menu_shown = TRUE;
else if (! strcmp (str, "menu-hidden"))
menu_shown = FALSE;
}
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dock),
menu_shown);
}
for (books = info->sub_dialogs; books; books = g_list_next (books))
{
GimpDockbook *dockbook;
@ -691,6 +822,10 @@ gimp_dialog_factories_session_restore_foreach (gchar *name,
gtk_widget_show (GTK_WIDGET (dock));
}
g_list_foreach (info->aux_info, (GFunc) g_free, NULL);
g_list_free (info->aux_info);
info->aux_info = NULL;
}
}

18
app/widgets/gimpdialogfactory.h
View File

@ -33,6 +33,7 @@ typedef GtkWidget * (* GimpDialogNewFunc) (GimpDialogFactory *factory,
typedef struct _GimpDialogFactoryEntry GimpDialogFactoryEntry;
typedef struct _GimpSessionInfo GimpSessionInfo;
struct _GimpDialogFactoryEntry
{
@ -43,9 +44,6 @@ struct _GimpDialogFactoryEntry
gboolean remember_size;
};
typedef struct _GimpSessionInfo GimpSessionInfo;
struct _GimpSessionInfo
{
gint x;
@ -58,8 +56,12 @@ struct _GimpSessionInfo
/* only valid while restoring and saving the session */
gboolean open;
/* GList of gchar* of optional additional dialog specific info */
GList *aux_info;
/* only one of these is valid */
GimpDialogFactoryEntry *toplevel_entry;
GimpDialogFactoryEntry *dockable_entry;
GList *sub_dialogs; /* GList of GLists of entries */
};
@ -119,15 +121,17 @@ void gimp_dialog_factory_register (GimpDialogFactory *factory,
GtkWidget * gimp_dialog_factory_dialog_new (GimpDialogFactory *factory,
const gchar *identifier);
GtkWidget * gimp_dialog_factory_dialog_raise (GimpDialogFactory *factory,
const gchar *identifier);
GtkWidget * gimp_dialog_factory_dockable_new (GimpDialogFactory *factory,
GimpDock *dock,
const gchar *identifier);
GtkWidget * gimp_dialog_factory_dock_new (GimpDialogFactory *factory);
void gimp_dialog_factory_add_toplevel (GimpDialogFactory *factory,
GtkWidget *toplevel);
void gimp_dialog_factory_remove_toplevel (GimpDialogFactory *factory,
GtkWidget *toplevel);
void gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
GtkWidget *dialog);
void gimp_dialog_factory_remove_dialog (GimpDialogFactory *factory,
GtkWidget *dialog);
void gimp_dialog_factories_session_save (FILE *file);
void gimp_dialog_factories_session_restore (void);

8
app/widgets/gimpdockbook.c
View File

@ -29,9 +29,9 @@
#include "gimpdialogfactory.h"
#include "gimpdnd.h"
#include "gimpdock.h"
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimpimagedock.h"
#define TAB_WIDGET_SIZE 24
@ -419,6 +419,7 @@ gimp_dockbook_tab_button_press (GtkWidget *widget,
{
GtkItemFactory *ifactory;
GtkWidget *add_widget;
GtkWidget *toggle_widget;
GtkWidget *notebook_menu;
gint origin_x;
gint origin_y;
@ -426,6 +427,7 @@ gimp_dockbook_tab_button_press (GtkWidget *widget,
ifactory = GTK_ITEM_FACTORY (dockbook->dock->factory->item_factory);
add_widget = gtk_item_factory_get_widget (ifactory, "/Select Tab");
toggle_widget = gtk_item_factory_get_widget (ifactory, "/Show Image Menu");
notebook_menu = GTK_NOTEBOOK (dockbook)->menu;
gtk_object_ref (GTK_OBJECT (notebook_menu));
@ -453,6 +455,10 @@ gimp_dockbook_tab_button_press (GtkWidget *widget,
*/
gtk_object_ref (GTK_OBJECT (dockbook));
gtk_check_menu_item_set_active
(GTK_CHECK_MENU_ITEM (toggle_widget),
GTK_WIDGET_VISIBLE (GIMP_IMAGE_DOCK (dockbook->dock)->option_menu->parent));
gtk_item_factory_popup_with_data (ifactory,
dockbook,
(GtkDestroyNotify) gimp_dockbook_menu_end,

17
app/widgets/gimpimagedock.c
View File

@ -198,6 +198,23 @@ gimp_image_dock_new (GimpDialogFactory *factory,
return GTK_WIDGET (image_dock);
}
void
gimp_image_dock_set_show_image_menu (GimpImageDock *image_dock,
gboolean show)
{
g_return_if_fail (image_dock != NULL);
g_return_if_fail (GIMP_IS_IMAGE_DOCK (image_dock));
if (show)
{
gtk_widget_show (image_dock->option_menu->parent);
}
else
{
gtk_widget_hide (image_dock->option_menu->parent);
}
}
static void
gimp_image_dock_factory_image_changed (GimpContext *context,
GimpImage *gimage,

9
app/widgets/gimpimagedock.h
View File

@ -53,10 +53,13 @@ struct _GimpImageDockClass
};
GtkType gimp_image_dock_get_type (void);
GtkType gimp_image_dock_get_type (void);
GtkWidget * gimp_image_dock_new (GimpDialogFactory *factory,
GimpContainer *image_container);
GtkWidget * gimp_image_dock_new (GimpDialogFactory *factory,
GimpContainer *image_container);
void gimp_image_dock_set_show_image_menu (GimpImageDock *image_dock,
gboolean show);
#endif /* __GIMP_IMAGE_DOCK_H__ */

1146
app/widgets/gimpitemfactory.c
View File

File diff suppressed because it is too large Load Diff

5
app/widgets/gimpitemfactory.h
View File

@ -26,11 +26,16 @@ struct _GimpItemFactoryEntry
{
GtkItemFactoryEntry entry;
const gchar *quark_string;
const gchar *help_page;
const gchar *description;
};
extern GSList *last_opened_raw_filenames;
GtkItemFactory * menus_get_toolbox_factory (void);
GtkItemFactory * menus_get_image_factory (void);
GtkItemFactory * menus_get_load_factory (void);

17
app/widgets/gimpmenudock.c
View File

@ -198,6 +198,23 @@ gimp_image_dock_new (GimpDialogFactory *factory,
return GTK_WIDGET (image_dock);
}
void
gimp_image_dock_set_show_image_menu (GimpImageDock *image_dock,
gboolean show)
{
g_return_if_fail (image_dock != NULL);
g_return_if_fail (GIMP_IS_IMAGE_DOCK (image_dock));
if (show)
{
gtk_widget_show (image_dock->option_menu->parent);
}
else
{
gtk_widget_hide (image_dock->option_menu->parent);
}
}
static void
gimp_image_dock_factory_image_changed (GimpContext *context,
GimpImage *gimage,

9
app/widgets/gimpmenudock.h
View File

@ -53,10 +53,13 @@ struct _GimpImageDockClass
};
GtkType gimp_image_dock_get_type (void);
GtkType gimp_image_dock_get_type (void);
GtkWidget * gimp_image_dock_new (GimpDialogFactory *factory,
GimpContainer *image_container);
GtkWidget * gimp_image_dock_new (GimpDialogFactory *factory,
GimpContainer *image_container);
void gimp_image_dock_set_show_image_menu (GimpImageDock *image_dock,
gboolean show);
#endif /* __GIMP_IMAGE_DOCK_H__ */

3
app/widgets/widgets-types.h
View File

@ -131,8 +131,9 @@ typedef struct _GimpLayerListView GimpLayerListView;
typedef struct _GimpChannelListView GimpChannelListView;
typedef struct _GimpContainerEditor GimpContainerEditor;
typedef struct _GimpDataFactoryView GimpDataFactoryView;
typedef struct _GimpBufferView GimpBufferView;
typedef struct _GimpDataFactoryView GimpDataFactoryView;
typedef struct _GimpBrushFactoryView GimpBrushFactoryView;
typedef struct _GimpListItem GimpListItem;
typedef struct _GimpChannelListItem GimpChannelListItem;

2
plug-ins/gdyntext/gdyntext.c
View File

@ -91,7 +91,7 @@ gdt_query (void)
"Marco Lamberto <lm@geocities.com>",
"Marco Lamberto",
"Jan 1999",
N_("<Image>/Filters/Render/Dynamic Text..."),
N_("<Image>/Filters/Text/Dynamic Text..."),
"RGB*,GRAY*,INDEXED*",
GIMP_PLUGIN,
ngdt_args, ngdt_rets,

2
plug-ins/perl/examples/fit-text
View File

@ -40,7 +40,7 @@ register "fit_text",
"Seth Burgess",
"Seth Burgess <sjburges\@gimp.org>",
"2000-01-29",
N_"<Image>/Filters/Render/Fit Text...",
N_"<Image>/Filters/Text/Fit Text...",
"*",
[
[PF_FONT, "font", "What font type to use - size will be ignored", $defaultfont],

2
plug-ins/perl/examples/terral_text
View File

@ -43,7 +43,7 @@ register
"Seth Burgess",
"Seth Burgess <sjburges\@gimp.org>",
"1999-03-15",
N_"<Image>/Filters/Render/Terral Text...",
N_"<Image>/Filters/Text/Terral Text...",
"RGB*,GRAY*",
[
[ PF_RADIO, "solid_noise", "The Texture Type", 0, ["solid noise" => 1, "current picture" => 0]],

2
plug-ins/perl/examples/tex-to-float
View File

@ -166,7 +166,7 @@ sub tex_string_to_float {
register "tex_string_to_float", "Turn a TeX-string into floating layer", "Takes a TeX string as input and creates a floating layer of the rendered string in the current layer in the foreground color.",
"Dov Grobgeld <dov\@imagic.weizmann.ac.il>", "Dov Grobgeld",
"1999-03-16",
N_"<Image>/Filters/Render/TeX String...",
N_"<Image>/Filters/Text/TeX String...",
"*",
[
[PF_STRING, "input_file", "TeX macro file to input"],

1
po/POTFILES.in
View File

@ -51,7 +51,6 @@ app/gui/color-area.c
app/gui/color-notebook.c
app/gui/color-select.c
app/gui/colormap-dialog.c
app/gui/commands.c
app/gui/convert-dialog.c
app/gui/dialogs-constructors.c
app/gui/edit-commands.c

32
tools/pdbgen/enums.pl
View File

@ -128,22 +128,6 @@ package Gimp::CodeGen::enums;
GIMP_PDB_SUCCESS => 'PDB_SUCCESS',
GIMP_PDB_CANCEL => 'PDB_CANCEL' }
},
GimpFillType =>
{ contig => 1,
header => 'appenums.h',
symbols => [ qw(FOREGROUND_FILL BACKGROUND_FILL WHITE_FILL
TRANSPARENT_FILL NO_FILL) ],
mapping => { FOREGROUND_FILL => '0',
BACKGROUND_FILL => '1',
WHITE_FILL => '2',
TRANSPARENT_FILL => '3',
NO_FILL => '4' },
nicks => { FOREGROUND_FILL => 'FG_IMAGE_FILL',
BACKGROUND_FILL => 'BG_IMAGE_FILL',
WHITE_FILL => 'WHITE_IMAGE_FILL',
TRANSPARENT_FILL => 'TRANS_IMAGE_FILL',
NO_FILL => 'NO_IMAGE_FILL' }
},
BrushApplicationMode =>
{ contig => 1,
header => 'appenums.h',
@ -336,6 +320,22 @@ package Gimp::CodeGen::enums;
mapping => { APPLY => '0',
DISCARD => '1' }
},
GimpFillType =>
{ contig => 1,
header => 'core/core-types.h',
symbols => [ qw(FOREGROUND_FILL BACKGROUND_FILL WHITE_FILL
TRANSPARENT_FILL NO_FILL) ],
mapping => { FOREGROUND_FILL => '0',
BACKGROUND_FILL => '1',
WHITE_FILL => '2',
TRANSPARENT_FILL => '3',
NO_FILL => '4' },
nicks => { FOREGROUND_FILL => 'FG_IMAGE_FILL',
BACKGROUND_FILL => 'BG_IMAGE_FILL',
WHITE_FILL => 'WHITE_IMAGE_FILL',
TRANSPARENT_FILL => 'TRANS_IMAGE_FILL',
NO_FILL => 'NO_IMAGE_FILL' }
},
GimpOffsetType =>
{ contig => 1,
header => 'core/gimpdrawable-offset.h',

10
tools/pdbgen/pdb/brush_select.pdb
View File

@ -125,7 +125,8 @@ sub brushes_set_popup {
);
%invoke = (
headers => [ qw("core/gimpbrush.h" "core/gimplist.h") ],
headers => [ qw("core/gimpbrush.h" "core/gimplist.h"
"widgets/gimpbrushfactoryview.h") ],
vars => [ 'ProcRecord *prec', 'BrushSelect *bsp' ],
code => <<'CODE'
{
@ -138,7 +139,10 @@ sub brushes_set_popup {
if (object)
{
GimpBrush *active = GIMP_BRUSH (object);
GimpBrush *active = GIMP_BRUSH (object);
GtkAdjustment *spacing_adj;
spacing_adj = GIMP_BRUSH_FACTORY_VIEW (bsp->view)->spacing_adjustment;
/* Updating the context updates the widgets as well */
@ -146,7 +150,7 @@ sub brushes_set_popup {
gimp_context_set_opacity (bsp->context, opacity);
gimp_context_set_paint_mode (bsp->context, paint_mode);
gtk_adjustment_set_value (GTK_ADJUSTMENT (bsp->spacing_data), spacing);
gtk_adjustment_set_value (spacing_adj, spacing);
}
else
success = FALSE;

10
tools/pdbgen/pdb/edit.pdb
View File

@ -55,7 +55,7 @@ HELP
&std_pdb_misc;
&inargs('cut from');
&invoke('edit_cut (gimage, drawable) != NULL');
&invoke('gimp_edit_cut (gimage, drawable) != NULL');
}
sub edit_copy {
@ -72,7 +72,7 @@ HELP
&std_pdb_misc;
&inargs('copy from');
&invoke('edit_copy (gimage, drawable) != NULL');
&invoke('gimp_edit_copy (gimage, drawable) != NULL');
}
sub edit_paste {
@ -106,7 +106,7 @@ HELP
);
&invoke('layer != NULL');
$cmd = "layer = edit_paste (gimage, drawable, global_buffer, paste_into);\n";
$cmd = "layer = gimp_edit_paste (gimage, drawable, global_buffer, paste_into);\n";
$invoke{code} =~ s/(success.*$)/"$cmd $1"/me;
}
@ -123,7 +123,7 @@ HELP
&std_pdb_misc;
&inargs('clear from');
&invoke('edit_clear (gimage, drawable)');
&invoke('gimp_edit_clear (gimage, drawable)');
}
sub edit_fill {
@ -146,7 +146,7 @@ HELP
{ name => 'fill_type', type => 'enum GimpFillType',
desc => 'The type of fill: %%desc%%' }
);
&invoke('edit_fill (gimage, drawable, (GimpFillType) fill_type)');
&invoke('gimp_edit_fill (gimage, drawable, (GimpFillType) fill_type)');
}
sub edit_stroke {