callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

app/actions/documents-actions.c app/actions/documents-commands.c

Browse Source 
2004-05-12  Michael Natterer  <mitch@gimp.org>

	* app/actions/documents-actions.c
	* app/actions/documents-commands.c
	* app/actions/edit-actions.c
	* app/actions/edit-commands.[ch]
	* app/actions/layers-actions.c
	* app/actions/layers-commands.c
	* app/actions/select-actions.c
	* app/actions/select-commands.[ch]
	* app/actions/vectors-actions.c
	* app/actions/vectors-commands.[ch]: added tooltips for actions
	which are now used for dialog buttons, added callback
	implementations which formerly lived in various widgets, moved
	some actions around and did some general cleanups.

	* menus/image-menu.xml.in: s/edit-stroke/select-stroke/

	* menus/Makefile.am
	* menus/selection-editor-menu.xml: new popup menu.

	* app/menus/menus.c: register <SelectionEditor> and <UndoEditor>
	UI managers.

	* app/widgets/gimpeditor.[ch]: added construct properties
	"menu-factory", "menu-identifier", "ui-path" and "popup-data".
	Implement GObject::constructor() and create the UI manager
	if all needed properties were set. Enables creating action
	buttons at widget construction time because they need a
	UI manager.

	(gimp_editor_add_action_button): changed to take a va_list of
	"extended" actions which are invoked if the resp. button emits
	"extended_clicked". Store the actions and their modifier masks in
	a list attached to the button.

	* app/widgets/gimpcontainerview.c
	(gimp_container_view_item_selected): if the view has container
	*and* context, simply change the context and return.

	(gimp_container_view_context_changed): don't emit "select_item"
	manually but simply call gimp_container_view_select_item().

	(gimp_container_view_viewable_dropped): use
	gimp_container_view_item_selected() instead of changing the
	context directly.

	* app/widgets/gimpcontainereditor.c
	(gimp_container_editor_select_item): update the UI manager.

	* app/widgets/gimpdockable.c: don't try to fiddle with the
	dialog's menu if it doesn't have a ui_path (happens if the UI
	manager is just a collection of actions for the dialog buttons and
	has no menu registered).

	* app/widgets/gimpimageeditor.c: connect to the image's "flush"
	signal and update the UI manager in the callback.

	* app/widgets/gimpitemtreeview.c: use GimpEditor's construct
	properties to create the UI manager so GimpItemTreeView subclasses
	can have action buttons. Update the UI manager in
	gimp_item_tree_view_select_item().

	* app/widgets/gimpbufferview.c
	* app/widgets/gimpcolormapeditor.c
	* app/widgets/gimpcontainergridview.c
	* app/widgets/gimpdatafactoryview.c
	* app/widgets/gimpfontview.c
	* app/widgets/gimpimageview.c
	* app/widgets/gimptemplateview.c
	* app/widgets/gimptoolview.c: changed calls to
	gimp_editor_add_action_button() accordingly and removed some
	unneeded select_item() implementations.

	* app/widgets/gimpchanneltreeview.c
	* app/widgets/gimpvectorstreeview.[ch]
	* app/widgets/gimpdocumentview.[ch]
	* app/widgets/gimplayertreeview.c
	* app/widgets/gimpselectioneditor.[ch]
	* app/widgets/gimpundoeditor.[ch]: use action buttons and removed
	lots of callbacks which went to the resp. action callbacks.

	* app/widgets/widgets-types.h: removed some now unneeded function
	prototypes.

	* app/gui/dialogs-constructors.c: changed (simplified) many dialog
	constructors accordingly.
This commit is contained in:
Michael Natterer
2004-05-12 18:36:33 +00:00
committed by Michael Natterer
parent 6750667d87
commit 2632cd8f64
47 changed files with 1254 additions and 1392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
ChangeLog
View File

@ -1,3 +1,91 @@
2004-05-12 Michael Natterer <mitch@gimp.org>
* app/actions/documents-actions.c
* app/actions/documents-commands.c
* app/actions/edit-actions.c
* app/actions/edit-commands.[ch]
* app/actions/layers-actions.c
* app/actions/layers-commands.c
* app/actions/select-actions.c
* app/actions/select-commands.[ch]
* app/actions/vectors-actions.c
* app/actions/vectors-commands.[ch]: added tooltips for actions
which are now used for dialog buttons, added callback
implementations which formerly lived in various widgets, moved
some actions around and did some general cleanups.
* menus/image-menu.xml.in: s/edit-stroke/select-stroke/
* menus/Makefile.am
* menus/selection-editor-menu.xml: new popup menu.
* app/menus/menus.c: register <SelectionEditor> and <UndoEditor>
UI managers.
* app/widgets/gimpeditor.[ch]: added construct properties
"menu-factory", "menu-identifier", "ui-path" and "popup-data".
Implement GObject::constructor() and create the UI manager
if all needed properties were set. Enables creating action
buttons at widget construction time because they need a
UI manager.
(gimp_editor_add_action_button): extended to take a va_list of
"extended" actions which are invoked if the resp. button emits
"extended_clicked". Store the actions and their modifier masks in
a list attached to the button.
* app/widgets/gimpcontainerview.c
(gimp_container_view_item_selected): if the view has container
*and* context, simply change the context and return.
(gimp_container_view_context_changed): don't emit "select_item"
manually but simply call gimp_container_view_select_item().
(gimp_container_view_viewable_dropped): use
gimp_container_view_item_selected() instead of changing the
context directly.
* app/widgets/gimpcontainereditor.c
(gimp_container_editor_select_item): update the UI manager.
* app/widgets/gimpdockable.c: don't try to fiddle with the
dialog's menu if it doesn't have a ui_path (happens if the UI
manager is just a collection of actions for the dialog buttons and
has no menu registered).
* app/widgets/gimpimageeditor.c: connect to the image's "flush"
signal and update the UI manager in the callback.
* app/widgets/gimpitemtreeview.c: use GimpEditor's construct
properties to create the UI manager so GimpItemTreeView subclasses
can have action buttons. Update the UI manager in
gimp_item_tree_view_select_item().
* app/widgets/gimpbufferview.c
* app/widgets/gimpcolormapeditor.c
* app/widgets/gimpcontainergridview.c
* app/widgets/gimpdatafactoryview.c
* app/widgets/gimpfontview.c
* app/widgets/gimpimageview.c
* app/widgets/gimptemplateview.c
* app/widgets/gimptoolview.c: changed calls to
gimp_editor_add_action_button() accordingly and removed some
unneeded select_item() implementations.
* app/widgets/gimpchanneltreeview.c
* app/widgets/gimpvectorstreeview.[ch]
* app/widgets/gimpdocumentview.[ch]
* app/widgets/gimplayertreeview.c
* app/widgets/gimpselectioneditor.[ch]
* app/widgets/gimpundoeditor.[ch]: use action buttons and removed
lots of callbacks which went to the resp. action callbacks.
* app/widgets/widgets-types.h: removed some now unneeded function
prototypes.
* app/gui/dialogs-constructors.c: changed (simplified) many dialog
constructors accordingly.
2004-05-12 Sven Neumann <sven@gimp.org> 2004-05-12 Sven Neumann <sven@gimp.org>
* libgimpwidgets/gimpwidgets.c (gimp_scale_entry_new_internal) * libgimpwidgets/gimpwidgets.c (gimp_scale_entry_new_internal)

19
app/actions/documents-actions.c
View File

@ -27,10 +27,9 @@
#include "core/gimpcontext.h" #include "core/gimpcontext.h"
#include "widgets/gimpactiongroup.h" #include "widgets/gimpactiongroup.h"
#include "widgets/gimpcontainereditor.h"
#include "widgets/gimpcontainerview.h"
#include "widgets/gimphelp-ids.h" #include "widgets/gimphelp-ids.h"
#include "actions.h"
#include "documents-actions.h" #include "documents-actions.h"
#include "documents-commands.h" #include "documents-commands.h"
@ -43,7 +42,8 @@ static GimpActionEntry documents_actions[] =
GIMP_HELP_DOCUMENT_DIALOG }, GIMP_HELP_DOCUMENT_DIALOG },
{ "documents-open", GTK_STOCK_OPEN, { "documents-open", GTK_STOCK_OPEN,
N_("_Open Image"), "", NULL, N_("_Open Image"), "",
N_("Open the selected entry"),
G_CALLBACK (documents_open_document_cmd_callback), G_CALLBACK (documents_open_document_cmd_callback),
GIMP_HELP_DOCUMENT_OPEN }, GIMP_HELP_DOCUMENT_OPEN },
@ -58,12 +58,14 @@ static GimpActionEntry documents_actions[] =
GIMP_HELP_DOCUMENT_OPEN }, GIMP_HELP_DOCUMENT_OPEN },
{ "documents-remove", GTK_STOCK_REMOVE, { "documents-remove", GTK_STOCK_REMOVE,
N_("Remove _Entry"), "", NULL, N_("Remove _Entry"), "",
N_("Remove the selected entry"),
G_CALLBACK (documents_remove_document_cmd_callback), G_CALLBACK (documents_remove_document_cmd_callback),
GIMP_HELP_DOCUMENT_REMOVE }, GIMP_HELP_DOCUMENT_REMOVE },
{ "documents-recreate-preview", GTK_STOCK_REFRESH, { "documents-recreate-preview", GTK_STOCK_REFRESH,
N_("Recreate _Preview"), "", NULL, N_("Recreate _Preview"), "",
N_("Recreate preview"),
G_CALLBACK (documents_recreate_preview_cmd_callback), G_CALLBACK (documents_recreate_preview_cmd_callback),
GIMP_HELP_DOCUMENT_REFRESH }, GIMP_HELP_DOCUMENT_REFRESH },
@ -91,13 +93,12 @@ void
documents_actions_update (GimpActionGroup *group, documents_actions_update (GimpActionGroup *group,
gpointer data) gpointer data)
{ {
GimpContainerEditor *editor;
GimpContext *context; GimpContext *context;
GimpImagefile *imagefile; GimpImagefile *imagefile = NULL;
editor = GIMP_CONTAINER_EDITOR (data); context = action_data_get_context (data);
context = gimp_container_view_get_context (editor->view);
if (context)
imagefile = gimp_context_get_imagefile (context); imagefile = gimp_context_get_imagefile (context);
#define SET_SENSITIVE(action,condition) \ #define SET_SENSITIVE(action,condition) \

209
app/actions/documents-commands.c
View File

@ -18,15 +18,39 @@
#include "config.h" #include "config.h"
#include <string.h>
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "libgimpthumb/gimpthumb.h"
#include "libgimpwidgets/gimpwidgets.h" #include "libgimpwidgets/gimpwidgets.h"
#include "actions-types.h" #include "actions-types.h"
#include "core/gimp.h"
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimpimagefile.h"
#include "file/file-open.h"
#include "file/file-utils.h"
#include "widgets/gimpcontainerview.h"
#include "widgets/gimpdocumentview.h" #include "widgets/gimpdocumentview.h"
#include "display/gimpdisplay.h"
#include "display/gimpdisplay-foreach.h"
#include "documents-commands.h" #include "documents-commands.h"
#include "file-commands.h"
#include "gimp-intl.h"
/* local function prototypes */
static void documents_open_image (GimpContext *context,
GimpImagefile *imagefile);
/* public functions */ /* public functions */
@ -35,66 +59,213 @@ void
documents_open_document_cmd_callback (GtkAction *action, documents_open_document_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data); GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
gtk_button_clicked (GTK_BUTTON (view->open_button)); context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
documents_open_image (context, imagefile);
}
else
{
file_file_open_dialog (context->gimp, NULL, GTK_WIDGET (editor));
}
}
typedef struct _RaiseClosure RaiseClosure;
struct _RaiseClosure
{
const gchar *name;
gboolean found;
};
static void
documents_raise_display (gpointer data,
gpointer user_data)
{
GimpDisplay *gdisp = (GimpDisplay *) data;
RaiseClosure *closure = (RaiseClosure *) user_data;
const gchar *uri;
uri = gimp_object_get_name (GIMP_OBJECT (gdisp->gimage));
if (uri && ! strcmp (closure->name, uri))
{
closure->found = TRUE;
gtk_window_present (GTK_WINDOW (gdisp->shell));
}
} }
void void
documents_raise_or_open_document_cmd_callback (GtkAction *action, documents_raise_or_open_document_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data); GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
gimp_button_extended_clicked (GIMP_BUTTON (view->open_button), context = gimp_container_view_get_context (editor->view);
GDK_SHIFT_MASK); container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
RaiseClosure closure;
closure.name = gimp_object_get_name (GIMP_OBJECT (imagefile));
closure.found = FALSE;
gimp_container_foreach (context->gimp->displays,
documents_raise_display,
&closure);
if (! closure.found)
documents_open_image (context, imagefile);
}
} }
void void
documents_file_open_dialog_cmd_callback (GtkAction *action, documents_file_open_dialog_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data); GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
gimp_button_extended_clicked (GIMP_BUTTON (view->open_button), context = gimp_container_view_get_context (editor->view);
GDK_CONTROL_MASK); container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
file_file_open_dialog (context->gimp,
gimp_object_get_name (GIMP_OBJECT (imagefile)),
GTK_WIDGET (editor));
}
} }
void void
documents_remove_document_cmd_callback (GtkAction *action, documents_remove_document_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data); GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
gtk_button_clicked (GTK_BUTTON (view->remove_button)); context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
gimp_container_remove (container, GIMP_OBJECT (imagefile));
}
} }
void void
documents_recreate_preview_cmd_callback (GtkAction *action, documents_recreate_preview_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data); GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
gtk_button_clicked (GTK_BUTTON (view->refresh_button)); context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
gint preview_size;
preview_size = gimp_container_view_get_preview_size (editor->view, NULL);
gimp_imagefile_create_thumbnail (imagefile, context, preview_size);
}
} }
void void
documents_reload_previews_cmd_callback (GtkAction *action, documents_reload_previews_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data); GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContainer *container;
gimp_button_extended_clicked (GIMP_BUTTON (view->refresh_button), container = gimp_container_view_get_container (editor->view);
GDK_SHIFT_MASK);
gimp_container_foreach (container,
(GFunc) gimp_imagefile_update,
editor->view);
}
static void
documents_delete_dangling_foreach (GimpImagefile *imagefile,
GimpContainer *container)
{
if (gimp_thumbnail_peek_image (imagefile->thumbnail) ==
GIMP_THUMB_STATE_NOT_FOUND)
{
gimp_container_remove (container, GIMP_OBJECT (imagefile));
}
} }
void void
documents_delete_dangling_documents_cmd_callback (GtkAction *action, documents_delete_dangling_documents_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data); GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContainer *container;
gimp_button_extended_clicked (GIMP_BUTTON (view->refresh_button), container = gimp_container_view_get_container (editor->view);
GDK_CONTROL_MASK);
gimp_container_foreach (container,
(GFunc) documents_delete_dangling_foreach,
container);
}
/* private functions */
static void
documents_open_image (GimpContext *context,
GimpImagefile *imagefile)
{
const gchar *uri;
GimpImage *gimage;
GimpPDBStatusType status;
GError *error = NULL;
uri = gimp_object_get_name (GIMP_OBJECT (imagefile));
gimage = file_open_with_display (context->gimp, context,
uri, &status, &error);
if (! gimage && status != GIMP_PDB_CANCEL)
{
gchar *filename;
filename = file_utils_uri_to_utf8_filename (uri);
g_message (_("Opening '%s' failed:\n\n%s"),
filename, error->message);
g_clear_error (&error);
g_free (filename);
}
} }

28
app/actions/edit-actions.c
View File

@ -64,15 +64,23 @@ static GimpActionEntry edit_actions[] =
{ "edit-buffer-menu", NULL, N_("Buffer") }, { "edit-buffer-menu", NULL, N_("Buffer") },
{ "edit-undo", GTK_STOCK_UNDO, { "edit-undo", GTK_STOCK_UNDO,
N_("_Undo"), "<control>Z", NULL, N_("_Undo"), "<control>Z",
N_("Undo"),
G_CALLBACK (edit_undo_cmd_callback), G_CALLBACK (edit_undo_cmd_callback),
GIMP_HELP_EDIT_UNDO }, GIMP_HELP_EDIT_UNDO },
{ "edit-redo", GTK_STOCK_REDO, { "edit-redo", GTK_STOCK_REDO,
N_("_Redo"), "<control>Y", NULL, N_("_Redo"), "<control>Y",
N_("Redo"),
G_CALLBACK (edit_redo_cmd_callback), G_CALLBACK (edit_redo_cmd_callback),
GIMP_HELP_EDIT_REDO }, GIMP_HELP_EDIT_REDO },
{ "edit-undo-clear", GTK_STOCK_CLEAR,
N_("_Clear Undo History"), "",
N_("Clear undo history"),
G_CALLBACK (edit_undo_clear_cmd_callback),
GIMP_HELP_EDIT_UNDO_CLEAR },
{ "edit-cut", GTK_STOCK_CUT, { "edit-cut", GTK_STOCK_CUT,
N_("Cu_t"), "<control>X", NULL, N_("Cu_t"), "<control>X", NULL,
G_CALLBACK (edit_cut_cmd_callback), G_CALLBACK (edit_cut_cmd_callback),
@ -116,12 +124,7 @@ static GimpActionEntry edit_actions[] =
{ "edit-clear", GTK_STOCK_CLEAR, { "edit-clear", GTK_STOCK_CLEAR,
N_("Cl_ear"), "<control>K", NULL, N_("Cl_ear"), "<control>K", NULL,
G_CALLBACK (edit_clear_cmd_callback), G_CALLBACK (edit_clear_cmd_callback),
GIMP_HELP_EDIT_CLEAR }, GIMP_HELP_EDIT_CLEAR }
{ "edit-stroke", GIMP_STOCK_SELECTION_STROKE,
N_("_Stroke Selection..."), NULL, NULL,
G_CALLBACK (edit_stroke_cmd_callback),
GIMP_HELP_SELECTION_STROKE }
}; };
static GimpEnumActionEntry edit_fill_actions[] = static GimpEnumActionEntry edit_fill_actions[] =
@ -207,6 +210,7 @@ edit_actions_update (GimpActionGroup *group,
{ {
gchar *undo_name = NULL; gchar *undo_name = NULL;
gchar *redo_name = NULL; gchar *redo_name = NULL;
gboolean enabled = FALSE;
if (gimage && gimp_image_undo_is_enabled (gimage)) if (gimage && gimp_image_undo_is_enabled (gimage))
{ {
@ -216,6 +220,8 @@ edit_actions_update (GimpActionGroup *group,
undo = gimp_undo_stack_peek (gimage->undo_stack); undo = gimp_undo_stack_peek (gimage->undo_stack);
redo = gimp_undo_stack_peek (gimage->redo_stack); redo = gimp_undo_stack_peek (gimage->redo_stack);
enabled = TRUE;
if (undo) if (undo)
undo_name = undo_name =
g_strdup_printf (_("_Undo %s"), g_strdup_printf (_("_Undo %s"),
@ -230,8 +236,9 @@ edit_actions_update (GimpActionGroup *group,
SET_LABEL ("edit-undo", undo_name ? undo_name : _("_Undo")); SET_LABEL ("edit-undo", undo_name ? undo_name : _("_Undo"));
SET_LABEL ("edit-redo", redo_name ? redo_name : _("_Redo")); SET_LABEL ("edit-redo", redo_name ? redo_name : _("_Redo"));
SET_SENSITIVE ("edit-undo", undo_name); SET_SENSITIVE ("edit-undo", enabled && undo_name);
SET_SENSITIVE ("edit-redo", redo_name); SET_SENSITIVE ("edit-redo", enabled && redo_name);
SET_SENSITIVE ("edit-undo-clear", enabled && (redo_name || redo_name));
g_free (undo_name); g_free (undo_name);
g_free (redo_name); g_free (redo_name);
@ -249,7 +256,6 @@ edit_actions_update (GimpActionGroup *group,
SET_SENSITIVE ("edit-fill-fg", drawable); SET_SENSITIVE ("edit-fill-fg", drawable);
SET_SENSITIVE ("edit-fill-bg", drawable); SET_SENSITIVE ("edit-fill-bg", drawable);
SET_SENSITIVE ("edit-fill-pattern", drawable); SET_SENSITIVE ("edit-fill-pattern", drawable);
SET_SENSITIVE ("edit-stroke", drawable && sel);
#undef SET_LABEL #undef SET_LABEL
#undef SET_SENSITIVE #undef SET_SENSITIVE

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

@ -33,7 +33,6 @@
#include "core/gimpdrawable.h" #include "core/gimpdrawable.h"
#include "core/gimpimage.h" #include "core/gimpimage.h"
#include "core/gimpimage-undo.h" #include "core/gimpimage-undo.h"
#include "core/gimptoolinfo.h"
#include "display/gimpdisplay.h" #include "display/gimpdisplay.h"
#include "display/gimpdisplayshell.h" #include "display/gimpdisplayshell.h"
@ -43,7 +42,6 @@
#include "widgets/gimpdialogfactory.h" #include "widgets/gimpdialogfactory.h"
#include "gui/dialogs.h" #include "gui/dialogs.h"
#include "gui/stroke-dialog.h"
#include "actions.h" #include "actions.h"
#include "edit-commands.h" #include "edit-commands.h"
@ -85,6 +83,44 @@ edit_redo_cmd_callback (GtkAction *action,
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
static void
edit_undo_clear_callback (GtkWidget *widget,
gboolean clear,
gpointer data)
{
if (clear)
{
GimpImage *gimage = data;
gimp_image_undo_disable (gimage);
gimp_image_undo_enable (gimage);
gimp_image_flush (gimage);
}
}
void
edit_undo_clear_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *gimage;
GtkWidget *widget;
GtkWidget *dialog;
return_if_no_image (gimage, data);
return_if_no_widget (widget, data);
dialog = gimp_query_boolean_box (_("Clear Undo History"), widget,
gimp_standard_help_func,
GIMP_HELP_EDIT_UNDO_CLEAR,
GIMP_STOCK_QUESTION,
_("Really clear image's undo history?"),
GTK_STOCK_CLEAR, GTK_STOCK_CANCEL,
G_OBJECT (gimage),
"disconnect",
edit_undo_clear_callback,
gimage);
gtk_widget_show (dialog);
}
void void
edit_cut_cmd_callback (GtkAction *action, edit_cut_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
@ -245,46 +281,6 @@ edit_fill_cmd_callback (GtkAction *action,
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
void
edit_stroke_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *gimage;
GimpDrawable *drawable;
GtkWidget *widget;
return_if_no_drawable (gimage, drawable, data);
return_if_no_widget (widget, data);
edit_stroke_selection (GIMP_ITEM (gimp_image_get_mask (gimage)), widget);
}
void
edit_stroke_selection (GimpItem *item,
GtkWidget *parent)
{
GimpImage *gimage;
GimpDrawable *active_drawable;
GtkWidget *dialog;
g_return_if_fail (GIMP_IS_ITEM (item));
g_return_if_fail (GTK_IS_WIDGET (parent));
gimage = gimp_item_get_image (item);
active_drawable = gimp_image_active_drawable (gimage);
if (! active_drawable)
{
g_message (_("There is no active layer or channel to stroke to."));
return;
}
dialog = stroke_dialog_new (item, GIMP_STOCK_SELECTION_STROKE,
GIMP_HELP_SELECTION_STROKE,
parent);
gtk_widget_show (dialog);
}
/* private functions */ /* private functions */

7
app/actions/edit-commands.h
View File

@ -24,6 +24,8 @@ void edit_undo_cmd_callback (GtkAction *action,
gpointer data); gpointer data);
void edit_redo_cmd_callback (GtkAction *action, void edit_redo_cmd_callback (GtkAction *action,
gpointer data); gpointer data);
void edit_undo_clear_cmd_callback (GtkAction *action,
gpointer data);
void edit_cut_cmd_callback (GtkAction *action, void edit_cut_cmd_callback (GtkAction *action,
gpointer data); gpointer data);
void edit_copy_cmd_callback (GtkAction *action, void edit_copy_cmd_callback (GtkAction *action,
@ -45,11 +47,6 @@ void edit_clear_cmd_callback (GtkAction *action,
void edit_fill_cmd_callback (GtkAction *action, void edit_fill_cmd_callback (GtkAction *action,
gint value, gint value,
gpointer data); gpointer data);
void edit_stroke_cmd_callback (GtkAction *action,
gpointer data);
void edit_stroke_selection (GimpItem *item,
GtkWidget *parent);
#endif /* __EDIT_COMMANDS_H__ */ #endif /* __EDIT_COMMANDS_H__ */

3
app/actions/layers-actions.c
View File

@ -119,7 +119,8 @@ static GimpActionEntry layers_actions[] =
GIMP_HELP_LAYER_LOWER_TO_BOTTOM }, GIMP_HELP_LAYER_LOWER_TO_BOTTOM },
{ "layers-anchor", GIMP_STOCK_ANCHOR, { "layers-anchor", GIMP_STOCK_ANCHOR,
N_("_Anchor Layer"), NULL, NULL, N_("_Anchor Layer"), NULL,
N_("Anchor floating layer"),
G_CALLBACK (layers_anchor_cmd_callback), G_CALLBACK (layers_anchor_cmd_callback),
GIMP_HELP_LAYER_ANCHOR }, GIMP_HELP_LAYER_ANCHOR },

149
app/actions/layers-commands.c
View File

@ -177,10 +177,10 @@ layers_raise_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
gimp_image_raise_layer (gimage, active_layer); gimp_image_raise_layer (gimage, layer);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
@ -189,10 +189,10 @@ layers_lower_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
gimp_image_lower_layer (gimage, active_layer); gimp_image_lower_layer (gimage, layer);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
@ -201,10 +201,10 @@ layers_raise_to_top_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
gimp_image_raise_layer_to_top (gimage, active_layer); gimp_image_raise_layer_to_top (gimage, layer);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
@ -213,10 +213,10 @@ layers_lower_to_bottom_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
gimp_image_lower_layer_to_bottom (gimage, active_layer); gimp_image_lower_layer_to_bottom (gimage, layer);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
@ -237,13 +237,13 @@ layers_duplicate_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
GimpLayer *new_layer; GimpLayer *new_layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
new_layer = new_layer =
GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (active_layer), GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (layer),
G_TYPE_FROM_INSTANCE (active_layer), G_TYPE_FROM_INSTANCE (layer),
TRUE)); TRUE));
gimp_image_add_layer (gimage, new_layer, -1); gimp_image_add_layer (gimage, new_layer, -1);
@ -255,12 +255,12 @@ layers_anchor_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
if (gimp_layer_is_floating_sel (active_layer)) if (gimp_layer_is_floating_sel (layer))
{ {
floating_sel_anchor (active_layer); floating_sel_anchor (layer);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
} }
@ -270,11 +270,10 @@ layers_merge_down_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
gimp_image_merge_down (gimage, active_layer, gimp_image_merge_down (gimage, layer, action_data_get_context (data),
gimp_get_user_context (gimage->gimp),
GIMP_EXPAND_AS_NECESSARY); GIMP_EXPAND_AS_NECESSARY);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
@ -284,13 +283,13 @@ layers_delete_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
if (gimp_layer_is_floating_sel (active_layer)) if (gimp_layer_is_floating_sel (layer))
floating_sel_remove (active_layer); floating_sel_remove (layer);
else else
gimp_image_remove_layer (gimage, active_layer); gimp_image_remove_layer (gimage, layer);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
@ -300,11 +299,11 @@ layers_text_discard_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
if (GIMP_IS_TEXT_LAYER (active_layer)) if (GIMP_IS_TEXT_LAYER (layer))
gimp_text_layer_discard (GIMP_TEXT_LAYER (active_layer)); gimp_text_layer_discard (GIMP_TEXT_LAYER (layer));
} }
void void
@ -312,12 +311,12 @@ layers_resize_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
GtkWidget *widget; GtkWidget *widget;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
return_if_no_widget (widget, data); return_if_no_widget (widget, data);
layers_resize_layer_query (gimage, active_layer, widget); layers_resize_layer_query (gimage, layer, widget);
} }
void void
@ -325,11 +324,10 @@ layers_resize_to_image_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
gimp_layer_resize_to_image (active_layer, gimp_layer_resize_to_image (layer, action_data_get_context (data));
gimp_get_user_context (gimage->gimp));
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
@ -338,13 +336,13 @@ layers_scale_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
GtkWidget *widget; GtkWidget *widget;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
return_if_no_widget (widget, data); return_if_no_widget (widget, data);
layers_scale_layer_query (GIMP_IS_DISPLAY (data) ? data : NULL, layers_scale_layer_query (GIMP_IS_DISPLAY (data) ? data : NULL,
gimage, active_layer, widget); gimage, layer, widget);
} }
void void
@ -352,10 +350,10 @@ layers_crop_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
gint x1, y1, x2, y2; gint x1, y1, x2, y2;
gint off_x, off_y; gint off_x, off_y;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
if (! gimp_channel_bounds (gimp_image_get_mask (gimage), if (! gimp_channel_bounds (gimp_image_get_mask (gimage),
&x1, &y1, &x2, &y2)) &x1, &y1, &x2, &y2))
@ -364,7 +362,7 @@ layers_crop_cmd_callback (GtkAction *action,
return; return;
} }
gimp_item_offsets (GIMP_ITEM (active_layer), &off_x, &off_y); gimp_item_offsets (GIMP_ITEM (layer), &off_x, &off_y);
off_x -= x1; off_x -= x1;
off_y -= y1; off_y -= y1;
@ -372,8 +370,7 @@ layers_crop_cmd_callback (GtkAction *action,
gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_ITEM_RESIZE, gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_ITEM_RESIZE,
_("Crop Layer")); _("Crop Layer"));
gimp_item_resize (GIMP_ITEM (active_layer), gimp_item_resize (GIMP_ITEM (layer), action_data_get_context (data),
gimp_get_user_context (gimage->gimp),
x2 - x1, y2 - y1, off_x, off_y); x2 - x1, y2 - y1, off_x, off_y);
gimp_image_undo_group_end (gimage); gimp_image_undo_group_end (gimage);
@ -386,12 +383,12 @@ layers_mask_add_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
GtkWidget *widget; GtkWidget *widget;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
return_if_no_widget (widget, data); return_if_no_widget (widget, data);
layers_add_mask_query (active_layer, widget); layers_add_mask_query (layer, widget);
} }
void void
@ -399,12 +396,12 @@ layers_mask_apply_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
if (gimp_layer_get_mask (active_layer)) if (gimp_layer_get_mask (layer))
{ {
gimp_layer_apply_mask (active_layer, GIMP_MASK_APPLY, TRUE); gimp_layer_apply_mask (layer, GIMP_MASK_APPLY, TRUE);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
} }
@ -414,12 +411,12 @@ layers_mask_delete_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
if (gimp_layer_get_mask (active_layer)) if (gimp_layer_get_mask (layer))
{ {
gimp_layer_apply_mask (active_layer, GIMP_MASK_DISCARD, TRUE); gimp_layer_apply_mask (layer, GIMP_MASK_DISCARD, TRUE);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
} }
@ -431,13 +428,13 @@ layers_mask_to_selection_cmd_callback (GtkAction *action,
{ {
GimpChannelOps op; GimpChannelOps op;
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
GimpLayerMask *mask; GimpLayerMask *mask;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
op = (GimpChannelOps) value; op = (GimpChannelOps) value;
mask = gimp_layer_get_mask (active_layer); mask = gimp_layer_get_mask (layer);
if (mask) if (mask)
{ {
@ -459,12 +456,12 @@ layers_alpha_add_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (active_layer))) if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
{ {
gimp_layer_add_alpha (active_layer); gimp_layer_add_alpha (layer);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
} }
@ -476,13 +473,13 @@ layers_alpha_to_selection_cmd_callback (GtkAction *action,
{ {
GimpChannelOps op; GimpChannelOps op;
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
op = (GimpChannelOps) value; op = (GimpChannelOps) value;
gimp_channel_select_alpha (gimp_image_get_mask (gimage), gimp_channel_select_alpha (gimp_image_get_mask (gimage),
GIMP_DRAWABLE (active_layer), GIMP_DRAWABLE (layer),
op, FALSE, 0.0, 0.0); op, FALSE, 0.0, 0.0);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
@ -506,7 +503,7 @@ layers_flatten_image_cmd_callback (GtkAction *action,
GimpImage *gimage; GimpImage *gimage;
return_if_no_image (gimage, data); return_if_no_image (gimage, data);
gimp_image_flatten (gimage, gimp_get_user_context (gimage->gimp)); gimp_image_flatten (gimage, action_data_get_context (data));
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
@ -515,12 +512,12 @@ layers_text_tool_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
GtkWidget *widget; GtkWidget *widget;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
return_if_no_widget (widget, data); return_if_no_widget (widget, data);
layers_text_tool (active_layer, widget); layers_text_tool (layer, widget);
} }
void void
@ -528,12 +525,12 @@ layers_edit_attributes_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpLayer *active_layer; GimpLayer *layer;
GtkWidget *widget; GtkWidget *widget;
return_if_no_layer (gimage, active_layer, data); return_if_no_layer (gimage, layer, data);
return_if_no_widget (widget, data); return_if_no_widget (widget, data);
layers_edit_layer_query (active_layer, widget); layers_edit_layer_query (layer, widget);
} }
void void

63
app/actions/select-actions.c
View File

@ -41,21 +41,27 @@
static GimpActionEntry select_actions[] = static GimpActionEntry select_actions[] =
{ {
{ "select-menu", NULL, { "selection-editor-popup", GIMP_STOCK_TOOL_RECT_SELECT,
N_("_Select") }, N_("Selection Editor Menu"), NULL, NULL, NULL,
GIMP_HELP_SELECTION_DIALOG },
{ "select-menu", NULL, N_("_Select") },
{ "select-all", GIMP_STOCK_SELECTION_ALL, { "select-all", GIMP_STOCK_SELECTION_ALL,
N_("_All"), "<control>A", NULL, N_("_All"), "<control>A",
N_("Select all"),
G_CALLBACK (select_all_cmd_callback), G_CALLBACK (select_all_cmd_callback),
GIMP_HELP_SELECTION_ALL }, GIMP_HELP_SELECTION_ALL },
{ "select-none", GIMP_STOCK_SELECTION_NONE, { "select-none", GIMP_STOCK_SELECTION_NONE,
N_("_None"), "<control><shift>A", NULL, N_("_None"), "<control><shift>A",
N_("Select none"),
G_CALLBACK (select_none_cmd_callback), G_CALLBACK (select_none_cmd_callback),
GIMP_HELP_SELECTION_NONE }, GIMP_HELP_SELECTION_NONE },
{ "select-invert", GIMP_STOCK_INVERT, { "select-invert", GIMP_STOCK_INVERT,
N_("_Invert"), "<control>I", NULL, N_("_Invert"), "<control>I",
N_("Invert selection"),
G_CALLBACK (select_invert_cmd_callback), G_CALLBACK (select_invert_cmd_callback),
GIMP_HELP_SELECTION_INVERT }, GIMP_HELP_SELECTION_INVERT },
@ -95,12 +101,20 @@ static GimpActionEntry select_actions[] =
GIMP_HELP_SELECTION_BORDER }, GIMP_HELP_SELECTION_BORDER },
{ "select-save", GIMP_STOCK_SELECTION_TO_CHANNEL, { "select-save", GIMP_STOCK_SELECTION_TO_CHANNEL,
N_("Save to _Channel"), NULL, NULL, N_("Save to _Channel"), NULL,
N_("Save selection to channel"),
G_CALLBACK (select_save_cmd_callback), G_CALLBACK (select_save_cmd_callback),
GIMP_HELP_SELECTION_TO_CHANNEL }, GIMP_HELP_SELECTION_TO_CHANNEL },
{ "select-stroke", GIMP_STOCK_SELECTION_STROKE,
N_("_Stroke Selection..."), NULL,
N_("Stroke selection"),
G_CALLBACK (select_stroke_cmd_callback),
GIMP_HELP_SELECTION_STROKE },
{ "select-to-vectors", GIMP_STOCK_SELECTION_TO_PATH, { "select-to-vectors", GIMP_STOCK_SELECTION_TO_PATH,
N_("To _Path"), NULL, NULL, N_("To _Path"), NULL,
N_("Selection to path"),
G_CALLBACK (vectors_selection_to_vectors_cmd_callback), G_CALLBACK (vectors_selection_to_vectors_cmd_callback),
GIMP_HELP_SELECTION_TO_PATH } GIMP_HELP_SELECTION_TO_PATH }
}; };
@ -119,39 +133,40 @@ select_actions_update (GimpActionGroup *group,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
GimpDrawable *drawable = NULL;
GimpVectors *vectors = NULL; GimpVectors *vectors = NULL;
gboolean fs = FALSE; gboolean fs = FALSE;
gboolean lp = FALSE;
gboolean sel = FALSE; gboolean sel = FALSE;
gimage = action_data_get_image (data); gimage = action_data_get_image (data);
if (gimage) if (gimage)
{ {
fs = (gimp_image_floating_sel (gimage) != NULL); drawable = gimp_image_active_drawable (gimage);
lp = ! gimp_image_is_empty (gimage);
sel = ! gimp_channel_is_empty (gimp_image_get_mask (gimage));
vectors = gimp_image_get_active_vectors (gimage); vectors = gimp_image_get_active_vectors (gimage);
fs = (gimp_image_floating_sel (gimage) != NULL);
sel = ! gimp_channel_is_empty (gimp_image_get_mask (gimage));
} }
#define SET_SENSITIVE(action,condition) \ #define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0) gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
SET_SENSITIVE ("select-all", lp); SET_SENSITIVE ("select-all", drawable);
SET_SENSITIVE ("select-none", lp && sel); SET_SENSITIVE ("select-none", drawable && sel);
SET_SENSITIVE ("select-invert", lp && sel); SET_SENSITIVE ("select-invert", drawable && sel);
SET_SENSITIVE ("select-from-vectors", lp && vectors); SET_SENSITIVE ("select-from-vectors", vectors);
SET_SENSITIVE ("select-float", lp && sel); SET_SENSITIVE ("select-float", drawable && sel);
SET_SENSITIVE ("select-feather", lp && sel); SET_SENSITIVE ("select-feather", drawable && sel);
SET_SENSITIVE ("select-sharpen", lp && sel); SET_SENSITIVE ("select-sharpen", drawable && sel);
SET_SENSITIVE ("select-shrink", lp && sel); SET_SENSITIVE ("select-shrink", drawable && sel);
SET_SENSITIVE ("select-grow", lp && sel); SET_SENSITIVE ("select-grow", drawable && sel);
SET_SENSITIVE ("select-border", lp && sel); SET_SENSITIVE ("select-border", drawable && sel);
SET_SENSITIVE ("select-save", sel && !fs); SET_SENSITIVE ("select-save", drawable && sel && !fs);
SET_SENSITIVE ("select-to-vectors", sel && !fs); SET_SENSITIVE ("select-stroke", drawable && sel);
SET_SENSITIVE ("select-to-vectors", drawable && sel && !fs);
#undef SET_SENSITIVE #undef SET_SENSITIVE
} }

41
app/actions/select-commands.c
View File

@ -38,6 +38,7 @@
#include "display/gimpdisplayshell.h" #include "display/gimpdisplayshell.h"
#include "gui/dialogs.h" #include "gui/dialogs.h"
#include "gui/stroke-dialog.h"
#include "actions.h" #include "actions.h"
#include "select-commands.h" #include "select-commands.h"
@ -274,6 +275,46 @@ select_save_cmd_callback (GtkAction *action,
"gimp-channel-list", -1); "gimp-channel-list", -1);
} }
void
select_stroke_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *gimage;
GimpDrawable *drawable;
GtkWidget *widget;
return_if_no_drawable (gimage, drawable, data);
return_if_no_widget (widget, data);
select_stroke (GIMP_ITEM (gimp_image_get_mask (gimage)), widget);
}
void
select_stroke (GimpItem *item,
GtkWidget *parent)
{
GimpImage *gimage;
GimpDrawable *active_drawable;
GtkWidget *dialog;
g_return_if_fail (GIMP_IS_ITEM (item));
g_return_if_fail (GTK_IS_WIDGET (parent));
gimage = gimp_item_get_image (item);
active_drawable = gimp_image_active_drawable (gimage);
if (! active_drawable)
{
g_message (_("There is no active layer or channel to stroke to."));
return;
}
dialog = stroke_dialog_new (item, GIMP_STOCK_SELECTION_STROKE,
GIMP_HELP_SELECTION_STROKE,
parent);
gtk_widget_show (dialog);
}
/* private functions */ /* private functions */

5
app/actions/select-commands.h
View File

@ -42,6 +42,11 @@ void select_grow_cmd_callback (GtkAction *action,
gpointer data); gpointer data);
void select_save_cmd_callback (GtkAction *action, void select_save_cmd_callback (GtkAction *action,
gpointer data); gpointer data);
void select_stroke_cmd_callback (GtkAction *action,
gpointer data);
void select_stroke (GimpItem *item,
GtkWidget *parent);
#endif /* __SELECT_COMMANDS_H__ */ #endif /* __SELECT_COMMANDS_H__ */

26
app/actions/vectors-actions.c
View File

@ -93,13 +93,9 @@ static GimpActionEntry vectors_actions[] =
G_CALLBACK (vectors_lower_to_bottom_cmd_callback), G_CALLBACK (vectors_lower_to_bottom_cmd_callback),
GIMP_HELP_PATH_LOWER_TO_BOTTOM }, GIMP_HELP_PATH_LOWER_TO_BOTTOM },
{ "vectors-selection-to-vectors", GIMP_STOCK_SELECTION_TO_PATH,
N_("Selecti_on to Path"), NULL, NULL,
G_CALLBACK (vectors_selection_to_vectors_cmd_callback),
GIMP_HELP_SELECTION_TO_PATH },
{ "vectors-stroke", GIMP_STOCK_PATH_STROKE, { "vectors-stroke", GIMP_STOCK_PATH_STROKE,
N_("Stro_ke Path..."), NULL, NULL, N_("Stro_ke Path..."), NULL,
N_("Stroke path"),
G_CALLBACK (vectors_stroke_cmd_callback), G_CALLBACK (vectors_stroke_cmd_callback),
GIMP_HELP_PATH_STROKE }, GIMP_HELP_PATH_STROKE },
@ -147,6 +143,19 @@ static GimpEnumActionEntry vectors_to_selection_actions[] =
GIMP_HELP_PATH_SELECTION_INTERSECT } GIMP_HELP_PATH_SELECTION_INTERSECT }
}; };
static GimpEnumActionEntry vectors_selection_to_vectors_actions[] =
{
{ "vectors-selection-to-vectors", GIMP_STOCK_SELECTION_TO_PATH,
N_("Selecti_on to Path"), NULL, NULL,
FALSE,
GIMP_HELP_SELECTION_TO_PATH },
{ "vectors-selection-to-vectors-advanced", GIMP_STOCK_SELECTION_TO_PATH,
N_("Selection to Path (_Advanced)"), NULL, NULL,
TRUE,
GIMP_HELP_SELECTION_TO_PATH }
};
void void
vectors_actions_setup (GimpActionGroup *group) vectors_actions_setup (GimpActionGroup *group)
@ -159,6 +168,11 @@ vectors_actions_setup (GimpActionGroup *group)
vectors_to_selection_actions, vectors_to_selection_actions,
G_N_ELEMENTS (vectors_to_selection_actions), G_N_ELEMENTS (vectors_to_selection_actions),
G_CALLBACK (vectors_to_selection_cmd_callback)); G_CALLBACK (vectors_to_selection_cmd_callback));
gimp_action_group_add_enum_actions (group,
vectors_selection_to_vectors_actions,
G_N_ELEMENTS (vectors_selection_to_vectors_actions),
G_CALLBACK (vectors_selection_to_vectors_cmd_callback));
} }
void void

3
app/actions/vectors-commands.c
View File

@ -194,12 +194,13 @@ vectors_to_selection_cmd_callback (GtkAction *action,
void void
vectors_selection_to_vectors_cmd_callback (GtkAction *action, vectors_selection_to_vectors_cmd_callback (GtkAction *action,
gint value,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
return_if_no_image (gimage, data); return_if_no_image (gimage, data);
vectors_selection_to_vectors (gimage, FALSE); vectors_selection_to_vectors (gimage, value);
} }
void void

1
app/actions/vectors-commands.h
View File

@ -40,6 +40,7 @@ void vectors_to_selection_cmd_callback (GtkAction *action,
gint value, gint value,
gpointer data); gpointer data);
void vectors_selection_to_vectors_cmd_callback (GtkAction *action, void vectors_selection_to_vectors_cmd_callback (GtkAction *action,
gint value,
gpointer data); gpointer data);
void vectors_stroke_cmd_callback (GtkAction *action, void vectors_stroke_cmd_callback (GtkAction *action,
gpointer data); gpointer data);

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

@ -411,7 +411,6 @@ dialogs_document_list_new (GimpDialogFactory *factory,
context->gimp->documents, context->gimp->documents,
context, context,
preview_size, 1, preview_size, 1,
file_file_open_dialog,
factory->menu_factory); factory->menu_factory);
return dialogs_dockable_new (view, return dialogs_dockable_new (view,
@ -614,7 +613,6 @@ dialogs_document_grid_new (GimpDialogFactory *factory,
context->gimp->documents, context->gimp->documents,
context, context,
preview_size, 1, preview_size, 1,
file_file_open_dialog,
factory->menu_factory); factory->menu_factory);
return dialogs_dockable_new (view, return dialogs_dockable_new (view,
@ -695,7 +693,6 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
GimpContext *context, GimpContext *context,
gint preview_size) gint preview_size)
{ {
GimpVectorsTreeView *vectors_view;
GtkWidget *view; GtkWidget *view;
GtkWidget *dockable; GtkWidget *dockable;
@ -713,11 +710,6 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
factory->menu_factory, "<Vectors>", factory->menu_factory, "<Vectors>",
"/vectors-popup"); "/vectors-popup");
vectors_view = GIMP_VECTORS_TREE_VIEW (view);
vectors_view->stroke_item_func = vectors_stroke_vectors;
vectors_view->selection_to_vectors_func = vectors_selection_to_vectors;
dockable = dialogs_dockable_new (view, dockable = dialogs_dockable_new (view,
_("Paths"), NULL, _("Paths"), NULL,
GIMP_STOCK_PATHS, GIMP_STOCK_PATHS,
@ -758,14 +750,11 @@ dialogs_histogram_editor_new (GimpDialogFactory *factory,
GimpContext *context, GimpContext *context,
gint preview_size) gint preview_size)
{ {
GimpHistogramEditor *histogram_editor;
GtkWidget *view; GtkWidget *view;
GtkWidget *dockable; GtkWidget *dockable;
view = gimp_histogram_editor_new (gimp_context_get_image (context)); view = gimp_histogram_editor_new (gimp_context_get_image (context));
histogram_editor = GIMP_HISTOGRAM_EDITOR (view);
dockable = dialogs_dockable_new (view, dockable = dialogs_dockable_new (view,
_("Histogram"), NULL, _("Histogram"), NULL,
GIMP_STOCK_HISTOGRAM, GIMP_STOCK_HISTOGRAM,
@ -781,16 +770,11 @@ dialogs_selection_editor_new (GimpDialogFactory *factory,
GimpContext *context, GimpContext *context,
gint preview_size) gint preview_size)
{ {
GimpSelectionEditor *selection_editor;
GtkWidget *view; GtkWidget *view;
GtkWidget *dockable; GtkWidget *dockable;
view = gimp_selection_editor_new (gimp_context_get_image (context)); view = gimp_selection_editor_new (gimp_context_get_image (context),
factory->menu_factory);
selection_editor = GIMP_SELECTION_EDITOR (view);
selection_editor->stroke_item_func = edit_stroke_selection;
selection_editor->selection_to_vectors_func = vectors_selection_to_vectors;
dockable = dialogs_dockable_new (view, dockable = dialogs_dockable_new (view,
_("Selection"), _("Selection Editor"), _("Selection"), _("Selection Editor"),
@ -811,7 +795,8 @@ dialogs_undo_history_new (GimpDialogFactory *factory,
GtkWidget *dockable; GtkWidget *dockable;
GimpImage *gimage; GimpImage *gimage;
editor = gimp_undo_editor_new (context->gimp->config); editor = gimp_undo_editor_new (context->gimp->config,
factory->menu_factory);
gimage = gimp_context_get_image (context); gimage = gimp_context_get_image (context);
if (gimage) if (gimage)

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

@ -411,7 +411,6 @@ dialogs_document_list_new (GimpDialogFactory *factory,
context->gimp->documents, context->gimp->documents,
context, context,
preview_size, 1, preview_size, 1,
file_file_open_dialog,
factory->menu_factory); factory->menu_factory);
return dialogs_dockable_new (view, return dialogs_dockable_new (view,
@ -614,7 +613,6 @@ dialogs_document_grid_new (GimpDialogFactory *factory,
context->gimp->documents, context->gimp->documents,
context, context,
preview_size, 1, preview_size, 1,
file_file_open_dialog,
factory->menu_factory); factory->menu_factory);
return dialogs_dockable_new (view, return dialogs_dockable_new (view,
@ -695,7 +693,6 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
GimpContext *context, GimpContext *context,
gint preview_size) gint preview_size)
{ {
GimpVectorsTreeView *vectors_view;
GtkWidget *view; GtkWidget *view;
GtkWidget *dockable; GtkWidget *dockable;
@ -713,11 +710,6 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
factory->menu_factory, "<Vectors>", factory->menu_factory, "<Vectors>",
"/vectors-popup"); "/vectors-popup");
vectors_view = GIMP_VECTORS_TREE_VIEW (view);
vectors_view->stroke_item_func = vectors_stroke_vectors;
vectors_view->selection_to_vectors_func = vectors_selection_to_vectors;
dockable = dialogs_dockable_new (view, dockable = dialogs_dockable_new (view,
_("Paths"), NULL, _("Paths"), NULL,
GIMP_STOCK_PATHS, GIMP_STOCK_PATHS,
@ -758,14 +750,11 @@ dialogs_histogram_editor_new (GimpDialogFactory *factory,
GimpContext *context, GimpContext *context,
gint preview_size) gint preview_size)
{ {
GimpHistogramEditor *histogram_editor;
GtkWidget *view; GtkWidget *view;
GtkWidget *dockable; GtkWidget *dockable;
view = gimp_histogram_editor_new (gimp_context_get_image (context)); view = gimp_histogram_editor_new (gimp_context_get_image (context));
histogram_editor = GIMP_HISTOGRAM_EDITOR (view);
dockable = dialogs_dockable_new (view, dockable = dialogs_dockable_new (view,
_("Histogram"), NULL, _("Histogram"), NULL,
GIMP_STOCK_HISTOGRAM, GIMP_STOCK_HISTOGRAM,
@ -781,16 +770,11 @@ dialogs_selection_editor_new (GimpDialogFactory *factory,
GimpContext *context, GimpContext *context,
gint preview_size) gint preview_size)
{ {
GimpSelectionEditor *selection_editor;
GtkWidget *view; GtkWidget *view;
GtkWidget *dockable; GtkWidget *dockable;
view = gimp_selection_editor_new (gimp_context_get_image (context)); view = gimp_selection_editor_new (gimp_context_get_image (context),
factory->menu_factory);
selection_editor = GIMP_SELECTION_EDITOR (view);
selection_editor->stroke_item_func = edit_stroke_selection;
selection_editor->selection_to_vectors_func = vectors_selection_to_vectors;
dockable = dialogs_dockable_new (view, dockable = dialogs_dockable_new (view,
_("Selection"), _("Selection Editor"), _("Selection"), _("Selection Editor"),
@ -811,7 +795,8 @@ dialogs_undo_history_new (GimpDialogFactory *factory,
GtkWidget *dockable; GtkWidget *dockable;
GimpImage *gimage; GimpImage *gimage;
editor = gimp_undo_editor_new (context->gimp->config); editor = gimp_undo_editor_new (context->gimp->config,
factory->menu_factory);
gimage = gimp_context_get_image (context); gimage = gimp_context_get_image (context);
if (gimage) if (gimage)

13
app/menus/menus.c
View File

@ -260,6 +260,19 @@ menus_init (Gimp *gimp)
"colormap-editor-menu.xml", NULL, "colormap-editor-menu.xml", NULL,
NULL); NULL);
gimp_menu_factory_manager_register (global_menu_factory, "<SelectionEditor>",
"select",
"vectors",
NULL,
"/selection-editor-popup",
"selection-editor-menu.xml", NULL,
NULL);
gimp_menu_factory_manager_register (global_menu_factory, "<UndoEditor>",
"edit",
NULL,
NULL);
gimp_menu_factory_manager_register (global_menu_factory, "<ErrorConsole>", gimp_menu_factory_manager_register (global_menu_factory, "<ErrorConsole>",
"error-console", "error-console",
NULL, NULL,

21
app/widgets/gimpbufferview.c
View File

@ -45,8 +45,6 @@
static void gimp_buffer_view_class_init (GimpBufferViewClass *klass); static void gimp_buffer_view_class_init (GimpBufferViewClass *klass);
static void gimp_buffer_view_init (GimpBufferView *view); static void gimp_buffer_view_init (GimpBufferView *view);
static void gimp_buffer_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static void gimp_buffer_view_activate_item (GimpContainerEditor *editor, static void gimp_buffer_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable); GimpViewable *viewable);
@ -89,7 +87,6 @@ gimp_buffer_view_class_init (GimpBufferViewClass *klass)
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
editor_class->select_item = gimp_buffer_view_select_item;
editor_class->activate_item = gimp_buffer_view_activate_item; editor_class->activate_item = gimp_buffer_view_activate_item;
} }
@ -131,19 +128,19 @@ gimp_buffer_view_new (GimpViewType view_type,
buffer_view->paste_button = buffer_view->paste_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers",
"buffers-paste"); "buffers-paste", NULL);
buffer_view->paste_into_button = buffer_view->paste_into_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers",
"buffers-paste-into"); "buffers-paste-into", NULL);
buffer_view->paste_as_new_button = buffer_view->paste_as_new_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers",
"buffers-paste-as-new"); "buffers-paste-as-new", NULL);
buffer_view->delete_button = buffer_view->delete_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers",
"buffers-delete"); "buffers-delete", NULL);
gimp_container_view_enable_dnd (editor->view, gimp_container_view_enable_dnd (editor->view,
GTK_BUTTON (buffer_view->paste_button), GTK_BUTTON (buffer_view->paste_button),
@ -163,16 +160,6 @@ gimp_buffer_view_new (GimpViewType view_type,
return GTK_WIDGET (buffer_view); return GTK_WIDGET (buffer_view);
} }
static void
gimp_buffer_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
}
static void static void
gimp_buffer_view_activate_item (GimpContainerEditor *editor, gimp_buffer_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable) GimpViewable *viewable)

144
app/widgets/gimpchanneltreeview.c
View File

@ -2,7 +2,7 @@
* Copyright (C) 1995 Spencer Kimball and Peter Mattis * Copyright (C) 1995 Spencer Kimball and Peter Mattis
* *
* gimpchanneltreeview.c * gimpchanneltreeview.c
* Copyright (C) 2001-2003 Michael Natterer <mitch@gimp.org> * Copyright (C) 2001-2004 Michael Natterer <mitch@gimp.org>
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
@ -23,13 +23,11 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "libgimpwidgets/gimpwidgets.h" #include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h" #include "widgets-types.h"
#include "core/gimpchannel.h" #include "core/gimpchannel.h"
#include "core/gimpchannel-select.h"
#include "core/gimpcontainer.h" #include "core/gimpcontainer.h"
#include "core/gimpimage.h" #include "core/gimpimage.h"
@ -48,22 +46,14 @@ static void gimp_channel_tree_view_init (GimpChannelTreeView *view)
static void gimp_channel_tree_view_view_iface_init (GimpContainerViewInterface *view_iface); static void gimp_channel_tree_view_view_iface_init (GimpContainerViewInterface *view_iface);
static GObject * gimp_channel_tree_view_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_channel_tree_view_set_image (GimpItemTreeView *item_view, static void gimp_channel_tree_view_set_image (GimpItemTreeView *item_view,
GimpImage *gimage); GimpImage *gimage);
static gboolean gimp_channel_tree_view_select_item (GimpContainerView *view,
GimpViewable *item,
gpointer insert_data);
static void gimp_channel_tree_view_set_preview_size (GimpContainerView *view); static void gimp_channel_tree_view_set_preview_size (GimpContainerView *view);
static void gimp_channel_tree_view_toselection_clicked
(GtkWidget *widget,
GimpChannelTreeView *view);
static void gimp_channel_tree_view_toselection_extended_clicked
(GtkWidget *widget,
guint state,
GimpChannelTreeView *view);
static GimpDrawableTreeViewClass *parent_class = NULL; static GimpDrawableTreeViewClass *parent_class = NULL;
static GimpContainerViewInterface *parent_view_iface = NULL; static GimpContainerViewInterface *parent_view_iface = NULL;
@ -110,10 +100,13 @@ gimp_channel_tree_view_get_type (void)
static void static void
gimp_channel_tree_view_class_init (GimpChannelTreeViewClass *klass) gimp_channel_tree_view_class_init (GimpChannelTreeViewClass *klass)
{ {
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpItemTreeViewClass *item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass); GimpItemTreeViewClass *item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass);
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
object_class->constructor = gimp_channel_tree_view_constructor;
item_view_class->set_image = gimp_channel_tree_view_set_image; item_view_class->set_image = gimp_channel_tree_view_set_image;
item_view_class->get_container = gimp_image_get_channels; item_view_class->get_container = gimp_image_get_channels;
@ -145,8 +138,31 @@ gimp_channel_tree_view_class_init (GimpChannelTreeViewClass *klass)
static void static void
gimp_channel_tree_view_init (GimpChannelTreeView *view) gimp_channel_tree_view_init (GimpChannelTreeView *view)
{ {
}
static void
gimp_channel_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
{
parent_view_iface = g_type_interface_peek_parent (view_iface);
view_iface->set_preview_size = gimp_channel_tree_view_set_preview_size;
}
static GObject *
gimp_channel_tree_view_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
GimpEditor *editor;
GimpChannelTreeView *view;
gchar *str; gchar *str;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
editor = GIMP_EDITOR (object);
view = GIMP_CHANNEL_TREE_VIEW (object);
str = g_strdup_printf (_("Channel to Selection\n" str = g_strdup_printf (_("Channel to Selection\n"
"%s Add\n" "%s Add\n"
"%s Subtract\n" "%s Subtract\n"
@ -158,12 +174,18 @@ gimp_channel_tree_view_init (GimpChannelTreeView *view)
gimp_get_mod_name_control ()); gimp_get_mod_name_control ());
view->toselection_button = view->toselection_button =
gimp_editor_add_button (GIMP_EDITOR (view), gimp_editor_add_action_button (GIMP_EDITOR (view), "channels",
GIMP_STOCK_SELECTION_REPLACE, str, "channels-selection-replace",
GIMP_HELP_CHANNEL_SELECTION_REPLACE, "channels-selection-intersect",
G_CALLBACK (gimp_channel_tree_view_toselection_clicked), GDK_SHIFT_MASK | GDK_CONTROL_MASK,
G_CALLBACK (gimp_channel_tree_view_toselection_extended_clicked), "channels-selection-subtract",
view); GDK_CONTROL_MASK,
"channels-selection-add",
GDK_SHIFT_MASK,
NULL);
gimp_help_set_help_data (view->toselection_button, str,
GIMP_HELP_CHANNEL_SELECTION_REPLACE);
g_free (str); g_free (str);
@ -174,16 +196,7 @@ gimp_channel_tree_view_init (GimpChannelTreeView *view)
GTK_BUTTON (view->toselection_button), GTK_BUTTON (view->toselection_button),
GIMP_TYPE_CHANNEL); GIMP_TYPE_CHANNEL);
gtk_widget_set_sensitive (view->toselection_button, FALSE); return object;
}
static void
gimp_channel_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
{
parent_view_iface = g_type_interface_peek_parent (view_iface);
view_iface->select_item = gimp_channel_tree_view_select_item;
view_iface->set_preview_size = gimp_channel_tree_view_set_preview_size;
} }
@ -226,32 +239,6 @@ gimp_channel_tree_view_set_image (GimpItemTreeView *item_view,
/* GimpContainerView methods */ /* GimpContainerView methods */
static gboolean
gimp_channel_tree_view_select_item (GimpContainerView *view,
GimpViewable *item,
gpointer insert_data)
{
GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view);
GimpChannelTreeView *tree_view = GIMP_CHANNEL_TREE_VIEW (view);
gboolean success;
success = parent_view_iface->select_item (view, item, insert_data);
if (item_view->gimage)
{
gboolean floating_sel;
floating_sel = (gimp_image_floating_sel (item_view->gimage) != NULL);
gtk_widget_set_sensitive (GIMP_EDITOR (view)->button_box, ! floating_sel);
}
gtk_widget_set_sensitive (tree_view->toselection_button,
success && item != NULL);
return success;
}
static void static void
gimp_channel_tree_view_set_preview_size (GimpContainerView *view) gimp_channel_tree_view_set_preview_size (GimpContainerView *view)
{ {
@ -266,48 +253,3 @@ gimp_channel_tree_view_set_preview_size (GimpContainerView *view)
gimp_component_editor_set_preview_size (GIMP_COMPONENT_EDITOR (channel_view->component_editor), gimp_component_editor_set_preview_size (GIMP_COMPONENT_EDITOR (channel_view->component_editor),
preview_size); preview_size);
} }
static void
gimp_channel_tree_view_toselection_clicked (GtkWidget *widget,
GimpChannelTreeView *view)
{
gimp_channel_tree_view_toselection_extended_clicked (widget, 0, view);
}
static void
gimp_channel_tree_view_toselection_extended_clicked (GtkWidget *widget,
guint state,
GimpChannelTreeView *view)
{
GimpImage *gimage;
GimpItem *item;
gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
if (item)
{
GimpChannelOps operation = GIMP_CHANNEL_OP_REPLACE;
if (state & GDK_SHIFT_MASK)
{
if (state & GDK_CONTROL_MASK)
operation = GIMP_CHANNEL_OP_INTERSECT;
else
operation = GIMP_CHANNEL_OP_ADD;
}
else if (state & GDK_CONTROL_MASK)
{
operation = GIMP_CHANNEL_OP_SUBTRACT;
}
gimp_channel_select_channel (gimp_image_get_mask (gimage),
_("Channel to Selection"),
GIMP_CHANNEL (item),
0, 0,
operation,
FALSE, 0.0, 0.0);
gimp_image_flush (gimage);
}
}

14
app/widgets/gimpcolormapeditor.c
View File

@ -333,14 +333,14 @@ gimp_colormap_editor_new (GimpImage *gimage,
GtkWidget *frame; GtkWidget *frame;
GtkWidget *table; GtkWidget *table;
g_return_val_if_fail (! gimage || GIMP_IS_IMAGE (gimage), NULL); g_return_val_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL); g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
editor = g_object_new (GIMP_TYPE_COLORMAP_EDITOR, NULL); editor = g_object_new (GIMP_TYPE_COLORMAP_EDITOR,
"menu-factory", menu_factory,
gimp_editor_create_menu (GIMP_EDITOR (editor), "menu-identifier", "<ColormapEditor>",
menu_factory, "<ColormapEditor>", "ui-path", "/colormap-editor-popup",
"/colormap-editor-popup", editor); NULL);
/* The palette frame */ /* The palette frame */
frame = gtk_frame_new (NULL); frame = gtk_frame_new (NULL);
@ -758,7 +758,7 @@ gimp_colormap_preview_button_press (GtkWidget *widget,
GIMP_EDITOR (editor)->popup_data); GIMP_EDITOR (editor)->popup_data);
gimp_ui_manager_ui_popup (GIMP_EDITOR (editor)->ui_manager, gimp_ui_manager_ui_popup (GIMP_EDITOR (editor)->ui_manager,
GIMP_EDITOR (editor)->ui_path, GIMP_EDITOR (editor)->ui_path,
GIMP_EDITOR (editor)->ui_manager, GIMP_EDITOR (editor)->popup_data,
GTK_WIDGET (editor), GTK_WIDGET (editor),
NULL, NULL, NULL); NULL, NULL, NULL);
return TRUE; return TRUE;

3
app/widgets/gimpcontainereditor.c
View File

@ -219,6 +219,9 @@ gimp_container_editor_select_item (GtkWidget *widget,
if (klass->select_item) if (klass->select_item)
klass->select_item (editor, viewable); klass->select_item (editor, viewable);
if (GIMP_EDITOR (editor->view)->ui_manager)
gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
return TRUE; return TRUE;
} }

1
app/widgets/gimpcontainergridview.c
View File

@ -234,7 +234,6 @@ gimp_container_grid_view_view_iface_init (GimpContainerViewInterface *view_iface
view_iface->select_item = gimp_container_grid_view_select_item; view_iface->select_item = gimp_container_grid_view_select_item;
view_iface->clear_items = gimp_container_grid_view_clear_items; view_iface->clear_items = gimp_container_grid_view_clear_items;
view_iface->set_preview_size = gimp_container_grid_view_set_preview_size; view_iface->set_preview_size = gimp_container_grid_view_set_preview_size;
} }
GtkWidget * GtkWidget *

35
app/widgets/gimpcontainerview.c
View File

@ -714,8 +714,19 @@ gimp_container_view_item_selected (GimpContainerView *view,
private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view); private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view);
/* HACK */
if (private->container && private->context)
{
gimp_context_set_by_type (private->context,
private->container->children_type,
GIMP_OBJECT (viewable));
return TRUE;
}
success = gimp_container_view_select_item (view, viewable); success = gimp_container_view_select_item (view, viewable);
#if 0
if (success && private->container && private->context) if (success && private->container && private->context)
{ {
GimpContext *context; GimpContext *context;
@ -739,6 +750,7 @@ gimp_container_view_item_selected (GimpContainerView *view,
g_object_unref (context); g_object_unref (context);
} }
#endif
return success; return success;
} }
@ -967,18 +979,8 @@ gimp_container_view_context_changed (GimpContext *context,
GimpViewable *viewable, GimpViewable *viewable,
GimpContainerView *view) GimpContainerView *view)
{ {
GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view); if (! gimp_container_view_select_item (view, viewable))
gpointer insert_data; g_warning ("%s: select_item() failed (should not happen)", G_STRFUNC);
gboolean success = FALSE;
insert_data = g_hash_table_lookup (private->hash_table, viewable);
g_signal_emit (view, view_signals[SELECT_ITEM], 0,
viewable, insert_data, &success);
if (! success)
g_warning ("gimp_container_view_context_changed(): select_item() failed "
"(should not happen)");
} }
static void static void
@ -989,10 +991,11 @@ gimp_container_view_viewable_dropped (GtkWidget *widget,
GimpContainerView *view = GIMP_CONTAINER_VIEW (data); GimpContainerView *view = GIMP_CONTAINER_VIEW (data);
GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view); GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view);
if (private->context && private->container) if (viewable && private->container &&
gimp_context_set_by_type (private->context, gimp_container_have (private->container, GIMP_OBJECT (viewable)))
private->container->children_type, {
GIMP_OBJECT (viewable)); gimp_container_view_item_selected (view, viewable);
}
} }
static void static void

23
app/widgets/gimpdatafactoryview.c
View File

@ -51,8 +51,6 @@
static void gimp_data_factory_view_class_init (GimpDataFactoryViewClass *klass); static void gimp_data_factory_view_class_init (GimpDataFactoryViewClass *klass);
static void gimp_data_factory_view_init (GimpDataFactoryView *view); static void gimp_data_factory_view_init (GimpDataFactoryView *view);
static void gimp_data_factory_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static void gimp_data_factory_view_activate_item (GimpContainerEditor *editor, static void gimp_data_factory_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable); GimpViewable *viewable);
static void gimp_data_factory_view_tree_name_edited (GtkCellRendererText *cell, static void gimp_data_factory_view_tree_name_edited (GtkCellRendererText *cell,
@ -99,7 +97,6 @@ gimp_data_factory_view_class_init (GimpDataFactoryViewClass *klass)
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
editor_class->select_item = gimp_data_factory_view_select_item;
editor_class->activate_item = gimp_data_factory_view_activate_item; editor_class->activate_item = gimp_data_factory_view_activate_item;
} }
@ -211,7 +208,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
factory_view->edit_button = factory_view->edit_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group, gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
str); str, NULL);
g_free (str); g_free (str);
} }
@ -222,7 +219,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
factory_view->new_button = factory_view->new_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group, gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
str); str, NULL);
g_free (str); g_free (str);
} }
@ -231,7 +228,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
factory_view->duplicate_button = factory_view->duplicate_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group, gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
str); str, NULL);
g_free (str); g_free (str);
@ -239,7 +236,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
factory_view->delete_button = factory_view->delete_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group, gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
str); str, NULL);
g_free (str); g_free (str);
@ -247,7 +244,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
factory_view->refresh_button = factory_view->refresh_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group, gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
str); str, NULL);
g_free (str); g_free (str);
@ -268,16 +265,6 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
return TRUE; return TRUE;
} }
static void
gimp_data_factory_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
}
static void static void
gimp_data_factory_view_activate_item (GimpContainerEditor *editor, gimp_data_factory_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable) GimpViewable *viewable)

4
app/widgets/gimpdockable.c
View File

@ -909,7 +909,7 @@ gimp_dockable_menu_end (GimpDockable *dockable)
&dialog_ui_path, &dialog_ui_path,
&dialog_popup_data); &dialog_popup_data);
if (dialog_ui_manager) if (dialog_ui_manager && dialog_ui_path)
{ {
GtkWidget *child_menu_widget; GtkWidget *child_menu_widget;
@ -942,7 +942,7 @@ gimp_dockable_show_menu (GimpDockable *dockable)
&dialog_ui_path, &dialog_ui_path,
&dialog_popup_data); &dialog_popup_data);
if (dialog_ui_manager) if (dialog_ui_manager && dialog_ui_path)
{ {
GtkWidget *child_menu_widget; GtkWidget *child_menu_widget;
GtkAction *child_menu_action; GtkAction *child_menu_action;

332
app/widgets/gimpdocumentview.c
View File

@ -21,35 +21,22 @@
#include "config.h" #include "config.h"
#include <string.h>
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "libgimpthumb/gimpthumb.h"
#include "libgimpwidgets/gimpwidgets.h" #include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h" #include "widgets-types.h"
#ifdef __GNUC__
#warning FIXME #include "display/display-types.h"
#endif
#include "display/display-types.h"
#include "core/gimp.h" #include "core/gimp.h"
#include "core/gimpcontainer.h" #include "core/gimpcontainer.h"
#include "core/gimpcontext.h" #include "core/gimpcontext.h"
#include "core/gimpimage.h"
#include "core/gimpimagefile.h" #include "core/gimpimagefile.h"
#include "file/file-open.h"
#include "file/file-utils.h"
#include "display/gimpdisplay.h"
#include "gimpcontainerview.h" #include "gimpcontainerview.h"
#include "gimpdocumentview.h" #include "gimpdocumentview.h"
#include "gimpdnd.h" #include "gimpdnd.h"
#include "gimphelp-ids.h" #include "gimphelp-ids.h"
#include "gimpuimanager.h"
#include "gimpwidgets-utils.h" #include "gimpwidgets-utils.h"
#include "gimp-intl.h" #include "gimp-intl.h"
@ -58,25 +45,8 @@
static void gimp_document_view_class_init (GimpDocumentViewClass *klass); static void gimp_document_view_class_init (GimpDocumentViewClass *klass);
static void gimp_document_view_init (GimpDocumentView *view); static void gimp_document_view_init (GimpDocumentView *view);
static void gimp_document_view_open_clicked (GtkWidget *widget,
GimpDocumentView *view);
static void gimp_document_view_open_extended_clicked (GtkWidget *widget,
guint state,
GimpDocumentView *view);
static void gimp_document_view_remove_clicked (GtkWidget *widget,
GimpDocumentView *view);
static void gimp_document_view_refresh_clicked (GtkWidget *widget,
GimpDocumentView *view);
static void gimp_document_view_refresh_extended_clicked (GtkWidget *widget,
guint state,
GimpDocumentView *view);
static void gimp_document_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static void gimp_document_view_activate_item (GimpContainerEditor *editor, static void gimp_document_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable); GimpViewable *viewable);
static void gimp_document_view_open_image (GimpDocumentView *view,
GimpImagefile *imagefile);
static GList * gimp_document_view_drag_file (GtkWidget *widget, static GList * gimp_document_view_drag_file (GtkWidget *widget,
gpointer data); gpointer data);
@ -119,7 +89,6 @@ gimp_document_view_class_init (GimpDocumentViewClass *klass)
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
editor_class->select_item = gimp_document_view_select_item;
editor_class->activate_item = gimp_document_view_activate_item; editor_class->activate_item = gimp_document_view_activate_item;
} }
@ -137,15 +106,12 @@ gimp_document_view_new (GimpViewType view_type,
GimpContext *context, GimpContext *context,
gint preview_size, gint preview_size,
gint preview_border_width, gint preview_border_width,
GimpFileOpenDialogFunc file_open_dialog_func,
GimpMenuFactory *menu_factory) GimpMenuFactory *menu_factory)
{ {
GimpDocumentView *document_view; GimpDocumentView *document_view;
GimpContainerEditor *editor; GimpContainerEditor *editor;
gchar *str; gchar *str;
g_return_val_if_fail (file_open_dialog_func != NULL, NULL);
document_view = g_object_new (GIMP_TYPE_DOCUMENT_VIEW, NULL); document_view = g_object_new (GIMP_TYPE_DOCUMENT_VIEW, NULL);
if (! gimp_container_editor_construct (GIMP_CONTAINER_EDITOR (document_view), if (! gimp_container_editor_construct (GIMP_CONTAINER_EDITOR (document_view),
@ -160,8 +126,6 @@ gimp_document_view_new (GimpViewType view_type,
return NULL; return NULL;
} }
document_view->file_open_dialog_func = file_open_dialog_func;
editor = GIMP_CONTAINER_EDITOR (document_view); editor = GIMP_CONTAINER_EDITOR (document_view);
str = g_strdup_printf (_("Open the selected entry\n" str = g_strdup_printf (_("Open the selected entry\n"
@ -171,22 +135,27 @@ gimp_document_view_new (GimpViewType view_type,
gimp_get_mod_name_control ()); gimp_get_mod_name_control ());
document_view->open_button = document_view->open_button =
gimp_editor_add_button (GIMP_EDITOR (editor->view), gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
GTK_STOCK_OPEN, str, "documents-open",
GIMP_HELP_DOCUMENT_OPEN, "documents-raise-or-open",
G_CALLBACK (gimp_document_view_open_clicked), GDK_SHIFT_MASK,
G_CALLBACK (gimp_document_view_open_extended_clicked), "documents-file-open-dialog",
editor); GDK_CONTROL_MASK,
NULL);
gimp_help_set_help_data (document_view->open_button, str,
GIMP_HELP_DOCUMENT_OPEN);
gimp_container_view_enable_dnd (editor->view,
GTK_BUTTON (document_view->open_button),
GIMP_TYPE_IMAGEFILE);
g_free (str); g_free (str);
document_view->remove_button = document_view->remove_button =
gimp_editor_add_button (GIMP_EDITOR (editor->view), gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
GTK_STOCK_REMOVE, _("Remove selected entry"), "documents-remove");
GIMP_HELP_DOCUMENT_REMOVE, gimp_container_view_enable_dnd (editor->view,
G_CALLBACK (gimp_document_view_remove_clicked), GTK_BUTTON (document_view->remove_button),
NULL, GIMP_TYPE_IMAGEFILE);
editor);
str = g_strdup_printf (_("Recreate preview\n" str = g_strdup_printf (_("Recreate preview\n"
"%s Reload all previews\n" "%s Reload all previews\n"
@ -195,27 +164,18 @@ gimp_document_view_new (GimpViewType view_type,
gimp_get_mod_name_control ()); gimp_get_mod_name_control ());
document_view->refresh_button = document_view->refresh_button =
gimp_editor_add_button (GIMP_EDITOR (editor->view), gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
GTK_STOCK_REFRESH, str, "documents-recreate-preview",
GIMP_HELP_DOCUMENT_REFRESH, "documents-reload-previews",
G_CALLBACK (gimp_document_view_refresh_clicked), GDK_SHIFT_MASK,
G_CALLBACK (gimp_document_view_refresh_extended_clicked), "documents-remove-dangling",
editor); GDK_CONTROL_MASK,
NULL);
gimp_help_set_help_data (document_view->refresh_button, str,
GIMP_HELP_DOCUMENT_REFRESH);
g_free (str); g_free (str);
/* set button sensitivity */
if (GIMP_CONTAINER_EDITOR_GET_CLASS (editor)->select_item)
GIMP_CONTAINER_EDITOR_GET_CLASS (editor)->select_item
(editor, (GimpViewable *) gimp_context_get_imagefile (context));
gimp_container_view_enable_dnd (editor->view,
GTK_BUTTON (document_view->open_button),
GIMP_TYPE_IMAGEFILE);
gimp_container_view_enable_dnd (editor->view,
GTK_BUTTON (document_view->remove_button),
GIMP_TYPE_IMAGEFILE);
if (view_type == GIMP_VIEW_TYPE_LIST) if (view_type == GIMP_VIEW_TYPE_LIST)
{ {
GtkWidget *dnd_widget; GtkWidget *dnd_widget;
@ -227,204 +187,11 @@ gimp_document_view_new (GimpViewType view_type,
editor); editor);
} }
gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
return GTK_WIDGET (document_view); return GTK_WIDGET (document_view);
} }
static void
gimp_document_view_open_clicked (GtkWidget *widget,
GimpDocumentView *view)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
gimp_document_view_open_image (view, imagefile);
}
else
{
view->file_open_dialog_func (context->gimp, NULL, GTK_WIDGET (view));
}
}
typedef struct _RaiseClosure RaiseClosure;
struct _RaiseClosure
{
const gchar *name;
gboolean found;
};
static void
gimp_document_view_raise_display (gpointer data,
gpointer user_data)
{
GimpDisplay *gdisp = (GimpDisplay *) data;
RaiseClosure *closure = (RaiseClosure *) user_data;
const gchar *uri;
uri = gimp_object_get_name (GIMP_OBJECT (gdisp->gimage));
if (uri && ! strcmp (closure->name, uri))
{
closure->found = TRUE;
gtk_window_present (GTK_WINDOW (gdisp->shell));
}
}
static void
gimp_document_view_open_extended_clicked (GtkWidget *widget,
guint state,
GimpDocumentView *view)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
if (state & GDK_CONTROL_MASK)
{
view->file_open_dialog_func (context->gimp,
gimp_object_get_name (GIMP_OBJECT (imagefile)),
GTK_WIDGET (view));
}
else if (state & GDK_SHIFT_MASK)
{
RaiseClosure closure;
closure.name = gimp_object_get_name (GIMP_OBJECT (imagefile));
closure.found = FALSE;
gimp_container_foreach (context->gimp->displays,
gimp_document_view_raise_display,
&closure);
if (! closure.found)
gimp_document_view_open_image (view, imagefile);
}
}
else
{
view->file_open_dialog_func (context->gimp, NULL, GTK_WIDGET (view));
}
}
static void
gimp_document_view_remove_clicked (GtkWidget *widget,
GimpDocumentView *view)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
gimp_container_remove (container, GIMP_OBJECT (imagefile));
}
}
static void
gimp_document_view_refresh_clicked (GtkWidget *widget,
GimpDocumentView *view)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
gint preview_size;
preview_size = gimp_container_view_get_preview_size (editor->view, NULL);
gimp_imagefile_create_thumbnail (imagefile, context, preview_size);
}
}
static void
gimp_document_view_delete_dangling_foreach (GimpImagefile *imagefile,
GimpContainerView *view)
{
if (gimp_thumbnail_peek_image (imagefile->thumbnail) ==
GIMP_THUMB_STATE_NOT_FOUND)
{
gimp_container_remove (gimp_container_view_get_container (view),
GIMP_OBJECT (imagefile));
}
}
static void
gimp_document_view_refresh_extended_clicked (GtkWidget *widget,
guint state,
GimpDocumentView *view)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
GimpContainer *container;
container = gimp_container_view_get_container (editor->view);
if (state & GDK_CONTROL_MASK)
{
gimp_container_foreach (container,
(GFunc) gimp_document_view_delete_dangling_foreach,
editor->view);
}
else if (state & GDK_SHIFT_MASK)
{
gimp_container_foreach (container,
(GFunc) gimp_imagefile_update,
editor->view);
}
}
static void
gimp_document_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
GimpDocumentView *view = GIMP_DOCUMENT_VIEW (editor);
GimpContainer *container;
gboolean remove_sensitive = FALSE;
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
container = gimp_container_view_get_container (editor->view);
if (viewable && gimp_container_have (container, GIMP_OBJECT (viewable)))
{
remove_sensitive = TRUE;
}
gtk_widget_set_sensitive (view->remove_button, remove_sensitive);
}
static void static void
gimp_document_view_activate_item (GimpContainerEditor *editor, gimp_document_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable) GimpViewable *viewable)
@ -439,39 +206,7 @@ gimp_document_view_activate_item (GimpContainerEditor *editor,
if (viewable && gimp_container_have (container, GIMP_OBJECT (viewable))) if (viewable && gimp_container_have (container, GIMP_OBJECT (viewable)))
{ {
gimp_document_view_open_clicked (NULL, view); gtk_button_clicked (GTK_BUTTON (view->open_button));
}
}
static void
gimp_document_view_open_image (GimpDocumentView *view,
GimpImagefile *imagefile)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
Gimp *gimp;
const gchar *uri;
GimpImage *gimage;
GimpPDBStatusType status;
GError *error = NULL;
gimp = gimp_container_view_get_context (editor->view)->gimp;
uri = gimp_object_get_name (GIMP_OBJECT (imagefile));
gimage = file_open_with_display (gimp, gimp_get_user_context (gimp),
uri, &status, &error);
if (! gimage && status != GIMP_PDB_CANCEL)
{
gchar *filename;
filename = file_utils_uri_to_utf8_filename (uri);
g_message (_("Opening '%s' failed:\n\n%s"),
filename, error->message);
g_clear_error (&error);
g_free (filename);
} }
} }
@ -482,8 +217,11 @@ gimp_document_view_drag_file (GtkWidget *widget,
GimpViewable *viewable = gimp_dnd_get_drag_data (widget); GimpViewable *viewable = gimp_dnd_get_drag_data (widget);
if (viewable) if (viewable)
return g_list_append (NULL, {
g_strdup (gimp_object_get_name (GIMP_OBJECT (viewable)))); const gchar *uri = gimp_object_get_name (GIMP_OBJECT (viewable));
return g_list_append (NULL, g_strdup (uri));
}
return NULL; return NULL;
} }

8
app/widgets/gimpdocumentview.h
View File

@ -26,11 +26,6 @@
#include "gimpcontainereditor.h" #include "gimpcontainereditor.h"
typedef void (* GimpFileOpenDialogFunc) (Gimp *gimp,
const gchar *uri,
GtkWidget *parent);
#define GIMP_TYPE_DOCUMENT_VIEW (gimp_document_view_get_type ()) #define GIMP_TYPE_DOCUMENT_VIEW (gimp_document_view_get_type ())
#define GIMP_DOCUMENT_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DOCUMENT_VIEW, GimpDocumentView)) #define GIMP_DOCUMENT_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DOCUMENT_VIEW, GimpDocumentView))
#define GIMP_DOCUMENT_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DOCUMENT_VIEW, GimpDocumentViewClass)) #define GIMP_DOCUMENT_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DOCUMENT_VIEW, GimpDocumentViewClass))
@ -45,8 +40,6 @@ struct _GimpDocumentView
{ {
GimpContainerEditor parent_instance; GimpContainerEditor parent_instance;
GimpFileOpenDialogFunc file_open_dialog_func;
GtkWidget *open_button; GtkWidget *open_button;
GtkWidget *remove_button; GtkWidget *remove_button;
GtkWidget *refresh_button; GtkWidget *refresh_button;
@ -65,7 +58,6 @@ GtkWidget * gimp_document_view_new (GimpViewType view_type,
GimpContext *context, GimpContext *context,
gint preview_size, gint preview_size,
gint preview_border_width, gint preview_border_width,
GimpFileOpenDialogFunc file_open_dialog_func,
GimpMenuFactory *menu_factory); GimpMenuFactory *menu_factory);

259
app/widgets/gimpeditor.c
View File

@ -2,7 +2,7 @@
* Copyright (C) 1995 Spencer Kimball and Peter Mattis * Copyright (C) 1995 Spencer Kimball and Peter Mattis
* *
* gimpeditor.c * gimpeditor.c
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org> * Copyright (C) 2001-2004 Michael Natterer <mitch@gimp.org>
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
@ -40,10 +40,31 @@
#define DEFAULT_BUTTON_ICON_SIZE GTK_ICON_SIZE_MENU #define DEFAULT_BUTTON_ICON_SIZE GTK_ICON_SIZE_MENU
enum
{
PROP_0,
PROP_MENU_FACTORY,
PROP_MENU_IDENTIFIER,
PROP_UI_PATH,
PROP_POPUP_DATA
};
static void gimp_editor_class_init (GimpEditorClass *klass); static void gimp_editor_class_init (GimpEditorClass *klass);
static void gimp_editor_init (GimpEditor *editor); static void gimp_editor_init (GimpEditor *editor);
static void gimp_editor_docked_iface_init (GimpDockedInterface *docked_iface); static void gimp_editor_docked_iface_init (GimpDockedInterface *docked_iface);
static GObject * gimp_editor_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_editor_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_editor_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_editor_destroy (GtkObject *object); static void gimp_editor_destroy (GtkObject *object);
static void gimp_editor_style_set (GtkWidget *widget, static void gimp_editor_style_set (GtkWidget *widget,
GtkStyle *prev_style); GtkStyle *prev_style);
@ -98,18 +119,47 @@ gimp_editor_get_type (void)
static void static void
gimp_editor_class_init (GimpEditorClass *klass) gimp_editor_class_init (GimpEditorClass *klass)
{ {
GtkObjectClass *object_class; GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class; GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
object_class = GTK_OBJECT_CLASS (klass);
widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_editor_destroy; object_class->constructor = gimp_editor_constructor;
object_class->set_property = gimp_editor_set_property;
object_class->get_property = gimp_editor_get_property;
gtk_object_class->destroy = gimp_editor_destroy;
widget_class->style_set = gimp_editor_style_set; widget_class->style_set = gimp_editor_style_set;
g_object_class_install_property (object_class, PROP_MENU_FACTORY,
g_param_spec_object ("menu-factory",
NULL, NULL,
GIMP_TYPE_MENU_FACTORY,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_MENU_IDENTIFIER,
g_param_spec_string ("menu-identifier",
NULL, NULL,
NULL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_UI_PATH,
g_param_spec_string ("ui-path",
NULL, NULL,
NULL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_POPUP_DATA,
g_param_spec_pointer ("popup-data",
NULL, NULL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
gtk_widget_class_install_style_property (widget_class, gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("content_spacing", g_param_spec_int ("content_spacing",
NULL, NULL, NULL, NULL,
@ -138,9 +188,10 @@ static void
gimp_editor_init (GimpEditor *editor) gimp_editor_init (GimpEditor *editor)
{ {
editor->menu_factory = NULL; editor->menu_factory = NULL;
editor->menu_identifier = NULL;
editor->ui_manager = NULL; editor->ui_manager = NULL;
editor->ui_path = NULL; editor->ui_path = NULL;
editor->popup_data = NULL; editor->popup_data = editor;
editor->button_box = NULL; editor->button_box = NULL;
} }
@ -150,11 +201,106 @@ gimp_editor_docked_iface_init (GimpDockedInterface *docked_iface)
docked_iface->get_menu = gimp_editor_get_menu; docked_iface->get_menu = gimp_editor_get_menu;
} }
static GObject *
gimp_editor_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
GimpEditor *editor;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
editor = GIMP_EDITOR (object);
if (! editor->popup_data)
editor->popup_data = editor;
if (editor->menu_factory && editor->menu_identifier)
{
editor->ui_manager =
gimp_menu_factory_manager_new (editor->menu_factory,
editor->menu_identifier,
editor->popup_data,
FALSE);
}
return object;
}
static void
gimp_editor_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpEditor *editor = GIMP_EDITOR (object);
switch (property_id)
{
case PROP_MENU_FACTORY:
editor->menu_factory = (GimpMenuFactory *) g_value_dup_object (value);
break;
case PROP_MENU_IDENTIFIER:
editor->menu_identifier = g_value_dup_string (value);
break;
case PROP_UI_PATH:
editor->ui_path = g_value_dup_string (value);
break;
case PROP_POPUP_DATA:
editor->popup_data = g_value_get_pointer (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_editor_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpEditor *editor = GIMP_EDITOR (object);
switch (property_id)
{
case PROP_MENU_FACTORY:
g_value_set_object (value, editor->menu_factory);
break;
case PROP_MENU_IDENTIFIER:
g_value_set_string (value, editor->menu_identifier);
break;
case PROP_UI_PATH:
g_value_set_string (value, editor->ui_path);
break;
case PROP_POPUP_DATA:
g_value_set_pointer (value, editor->popup_data);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void static void
gimp_editor_destroy (GtkObject *object) gimp_editor_destroy (GtkObject *object)
{ {
GimpEditor *editor = GIMP_EDITOR (object); GimpEditor *editor = GIMP_EDITOR (object);
if (editor->menu_factory)
{
g_object_unref (editor->menu_factory);
editor->menu_factory = NULL;
}
if (editor->menu_identifier)
{
g_free (editor->menu_identifier);
editor->menu_identifier = NULL;
}
if (editor->ui_manager) if (editor->ui_manager)
{ {
g_object_unref (editor->ui_manager); g_object_unref (editor->ui_manager);
@ -216,21 +362,24 @@ gimp_editor_create_menu (GimpEditor *editor,
GimpMenuFactory *menu_factory, GimpMenuFactory *menu_factory,
const gchar *menu_identifier, const gchar *menu_identifier,
const gchar *ui_path, const gchar *ui_path,
gpointer callback_data) gpointer popup_data)
{ {
g_return_if_fail (GIMP_IS_EDITOR (editor)); g_return_if_fail (GIMP_IS_EDITOR (editor));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory)); g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
g_return_if_fail (menu_identifier != NULL); g_return_if_fail (menu_identifier != NULL);
g_return_if_fail (ui_path != NULL); g_return_if_fail (ui_path != NULL);
editor->menu_factory = menu_factory; if (editor->menu_factory)
g_object_unref (editor->menu_factory);
editor->menu_factory = g_object_ref (menu_factory);
if (editor->ui_manager) if (editor->ui_manager)
g_object_unref (editor->ui_manager); g_object_unref (editor->ui_manager);
editor->ui_manager = gimp_menu_factory_manager_new (menu_factory, editor->ui_manager = gimp_menu_factory_manager_new (menu_factory,
menu_identifier, menu_identifier,
callback_data, popup_data,
FALSE); FALSE);
if (editor->ui_path) if (editor->ui_path)
@ -238,7 +387,7 @@ gimp_editor_create_menu (GimpEditor *editor,
editor->ui_path = g_strdup (ui_path); editor->ui_path = g_strdup (ui_path);
editor->popup_data = callback_data; editor->popup_data = popup_data;
} }
GtkWidget * GtkWidget *
@ -328,10 +477,47 @@ gimp_editor_add_stock_box (GimpEditor *editor,
return first_button; return first_button;
} }
typedef struct _ExtendedAction ExtendedAction;
struct _ExtendedAction
{
GdkModifierType mod_mask;
GtkAction *action;
};
static void
gimp_editor_button_extended_actions_free (GList *list)
{
g_list_foreach (list, (GFunc) g_free, NULL);
g_list_free (list);
}
static void
gimp_editor_button_extended_clicked (GtkWidget *button,
GdkModifierType mask,
gpointer data)
{
GList *extended = g_object_get_data (G_OBJECT (button), "extended-actions");
GList *list;
for (list = extended; list; list = g_list_next (list))
{
ExtendedAction *ext = list->data;
if ((ext->mod_mask & mask) == ext->mod_mask &&
gtk_action_get_sensitive (ext->action))
{
gtk_action_activate (ext->action);
break;
}
}
}
GtkWidget * GtkWidget *
gimp_editor_add_action_button (GimpEditor *editor, gimp_editor_add_action_button (GimpEditor *editor,
const gchar *group_name, const gchar *group_name,
const gchar *action_name) const gchar *action_name,
...)
{ {
GimpActionGroup *group; GimpActionGroup *group;
GtkAction *action; GtkAction *action;
@ -342,6 +528,8 @@ gimp_editor_add_action_button (GimpEditor *editor,
gchar *stock_id; gchar *stock_id;
gchar *tooltip; gchar *tooltip;
const gchar *help_id; const gchar *help_id;
GList *extended = NULL;
va_list args;
g_return_val_if_fail (GIMP_IS_EDITOR (editor), NULL); g_return_val_if_fail (GIMP_IS_EDITOR (editor), NULL);
g_return_val_if_fail (action_name != NULL, NULL); g_return_val_if_fail (action_name != NULL, NULL);
@ -373,13 +561,6 @@ gimp_editor_add_action_button (GimpEditor *editor,
if (tooltip || help_id) if (tooltip || help_id)
gimp_help_set_help_data (button, tooltip, help_id); gimp_help_set_help_data (button, tooltip, help_id);
#if 0
if (extended_callback)
g_signal_connect (button, "extended_clicked",
extended_callback,
callback_data);
#endif
old_child = gtk_bin_get_child (GTK_BIN (button)); old_child = gtk_bin_get_child (GTK_BIN (button));
if (old_child) if (old_child)
@ -392,6 +573,44 @@ gimp_editor_add_action_button (GimpEditor *editor,
g_free (stock_id); g_free (stock_id);
g_free (tooltip); g_free (tooltip);
va_start (args, action_name);
action_name = va_arg (args, const gchar *);
while (action_name)
{
GdkModifierType mod_mask;
mod_mask = va_arg (args, GdkModifierType);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
action_name);
if (action && mod_mask)
{
ExtendedAction *ext = g_new0 (ExtendedAction, 1);
ext->mod_mask = mod_mask;
ext->action = action;
extended = g_list_append (extended, ext);
}
action_name = va_arg (args, const gchar *);
}
va_end (args);
if (extended)
{
g_object_set_data_full (G_OBJECT (button), "extended-actions", extended,
(GDestroyNotify) gimp_editor_button_extended_actions_free);
g_signal_connect (button, "extended_clicked",
G_CALLBACK (gimp_editor_button_extended_clicked),
NULL);
}
return button; return button;
} }

6
app/widgets/gimpeditor.h
View File

@ -41,6 +41,7 @@ struct _GimpEditor
GtkVBox parent_instance; GtkVBox parent_instance;
GimpMenuFactory *menu_factory; GimpMenuFactory *menu_factory;
gchar *menu_identifier;
GimpUIManager *ui_manager; GimpUIManager *ui_manager;
gchar *ui_path; gchar *ui_path;
gpointer popup_data; gpointer popup_data;
@ -62,7 +63,7 @@ void gimp_editor_create_menu (GimpEditor *editor,
GimpMenuFactory *menu_factory, GimpMenuFactory *menu_factory,
const gchar *menu_identifier, const gchar *menu_identifier,
const gchar *ui_path, const gchar *ui_path,
gpointer callback_data); gpointer popup_data);
GtkWidget * gimp_editor_add_button (GimpEditor *editor, GtkWidget * gimp_editor_add_button (GimpEditor *editor,
const gchar *stock_id, const gchar *stock_id,
@ -79,7 +80,8 @@ GtkWidget * gimp_editor_add_stock_box (GimpEditor *editor,
GtkWidget * gimp_editor_add_action_button (GimpEditor *editor, GtkWidget * gimp_editor_add_action_button (GimpEditor *editor,
const gchar *group_name, const gchar *group_name,
const gchar *action_name); const gchar *action_name,
...);
void gimp_editor_set_box_style (GimpEditor *editor, void gimp_editor_set_box_style (GimpEditor *editor,
GtkBox *box); GtkBox *box);

15
app/widgets/gimpfontview.c
View File

@ -41,8 +41,6 @@
static void gimp_font_view_class_init (GimpFontViewClass *klass); static void gimp_font_view_class_init (GimpFontViewClass *klass);
static void gimp_font_view_init (GimpFontView *view); static void gimp_font_view_init (GimpFontView *view);
static void gimp_font_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static void gimp_font_view_activate_item (GimpContainerEditor *editor, static void gimp_font_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable); GimpViewable *viewable);
@ -85,7 +83,6 @@ gimp_font_view_class_init (GimpFontViewClass *klass)
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
editor_class->select_item = gimp_font_view_select_item;
editor_class->activate_item = gimp_font_view_activate_item; editor_class->activate_item = gimp_font_view_activate_item;
} }
@ -124,23 +121,13 @@ gimp_font_view_new (GimpViewType view_type,
font_view->refresh_button = font_view->refresh_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "fonts", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "fonts",
"fonts-refresh"); "fonts-refresh", NULL);
gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor); gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
return GTK_WIDGET (font_view); return GTK_WIDGET (font_view);
} }
static void
gimp_font_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
}
static void static void
gimp_font_view_activate_item (GimpContainerEditor *editor, gimp_font_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable) GimpViewable *viewable)

47
app/widgets/gimpimageeditor.c
View File

@ -27,6 +27,7 @@
#include "gimpdocked.h" #include "gimpdocked.h"
#include "gimpimageeditor.h" #include "gimpimageeditor.h"
#include "gimpuimanager.h"
static void gimp_image_editor_class_init (GimpImageEditorClass *klass); static void gimp_image_editor_class_init (GimpImageEditorClass *klass);
@ -38,10 +39,12 @@ static void gimp_image_editor_set_docked_context (GimpDocked *docked,
GimpContext *prev_context); GimpContext *prev_context);
static void gimp_image_editor_destroy (GtkObject *object); static void gimp_image_editor_destroy (GtkObject *object);
static void gimp_image_editor_real_set_image (GimpImageEditor *editor, static void gimp_image_editor_real_set_image (GimpImageEditor *editor,
GimpImage *gimage); GimpImage *gimage);
static void gimp_image_editor_image_flush (GimpImage *gimage,
GimpImageEditor *editor);
static GimpEditorClass *parent_class = NULL; static GimpEditorClass *parent_class = NULL;
@ -86,9 +89,7 @@ gimp_image_editor_get_type (void)
static void static void
gimp_image_editor_class_init (GimpImageEditorClass *klass) gimp_image_editor_class_init (GimpImageEditorClass *klass)
{ {
GtkObjectClass *object_class; GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
object_class = GTK_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
@ -147,9 +148,7 @@ gimp_image_editor_set_docked_context (GimpDocked *docked,
static void static void
gimp_image_editor_destroy (GtkObject *object) gimp_image_editor_destroy (GtkObject *object)
{ {
GimpImageEditor *editor; GimpImageEditor *editor = GIMP_IMAGE_EDITOR (object);
editor = GIMP_IMAGE_EDITOR (object);
if (editor->gimage) if (editor->gimage)
gimp_image_editor_set_image (editor, NULL); gimp_image_editor_set_image (editor, NULL);
@ -161,8 +160,18 @@ static void
gimp_image_editor_real_set_image (GimpImageEditor *editor, gimp_image_editor_real_set_image (GimpImageEditor *editor,
GimpImage *gimage) GimpImage *gimage)
{ {
if (editor->gimage)
g_signal_handlers_disconnect_by_func (editor->gimage,
gimp_image_editor_image_flush,
editor);
editor->gimage = gimage; editor->gimage = gimage;
if (editor->gimage)
g_signal_connect (editor->gimage, "flush",
G_CALLBACK (gimp_image_editor_image_flush),
editor);
gtk_widget_set_sensitive (GTK_WIDGET (editor), gimage != NULL); gtk_widget_set_sensitive (GTK_WIDGET (editor), gimage != NULL);
} }
@ -174,10 +183,26 @@ gimp_image_editor_set_image (GimpImageEditor *editor,
GimpImage *gimage) GimpImage *gimage)
{ {
g_return_if_fail (GIMP_IS_IMAGE_EDITOR (editor)); g_return_if_fail (GIMP_IS_IMAGE_EDITOR (editor));
g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage)); g_return_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage));
if (gimage == editor->gimage)
return;
if (gimage != editor->gimage)
{
GIMP_IMAGE_EDITOR_GET_CLASS (editor)->set_image (editor, gimage); GIMP_IMAGE_EDITOR_GET_CLASS (editor)->set_image (editor, gimage);
if (GIMP_EDITOR (editor)->ui_manager)
gimp_ui_manager_update (GIMP_EDITOR (editor)->ui_manager,
GIMP_EDITOR (editor)->popup_data);
}
}
/* private functions */
static void
gimp_image_editor_image_flush (GimpImage *gimage,
GimpImageEditor *editor)
{
if (GIMP_EDITOR (editor)->ui_manager)
gimp_ui_manager_update (GIMP_EDITOR (editor)->ui_manager,
GIMP_EDITOR (editor)->popup_data);
} }

19
app/widgets/gimpimageview.c
View File

@ -42,8 +42,6 @@
static void gimp_image_view_class_init (GimpImageViewClass *klass); static void gimp_image_view_class_init (GimpImageViewClass *klass);
static void gimp_image_view_init (GimpImageView *view); static void gimp_image_view_init (GimpImageView *view);
static void gimp_image_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static void gimp_image_view_activate_item (GimpContainerEditor *editor, static void gimp_image_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable); GimpViewable *viewable);
@ -86,7 +84,6 @@ gimp_image_view_class_init (GimpImageViewClass *klass)
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
editor_class->select_item = gimp_image_view_select_item;
editor_class->activate_item = gimp_image_view_activate_item; editor_class->activate_item = gimp_image_view_activate_item;
} }
@ -127,15 +124,15 @@ gimp_image_view_new (GimpViewType view_type,
image_view->raise_button = image_view->raise_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "images", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "images",
"images-raise-views"); "images-raise-views", NULL);
image_view->new_button = image_view->new_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "images", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "images",
"images-new-view"); "images-new-view", NULL);
image_view->delete_button = image_view->delete_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "images", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "images",
"images-delete"); "images-delete", NULL);
gimp_container_view_enable_dnd (editor->view, gimp_container_view_enable_dnd (editor->view,
GTK_BUTTON (image_view->raise_button), GTK_BUTTON (image_view->raise_button),
@ -153,16 +150,6 @@ gimp_image_view_new (GimpViewType view_type,
return GTK_WIDGET (image_view); return GTK_WIDGET (image_view);
} }
static void
gimp_image_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
}
static void static void
gimp_image_view_activate_item (GimpContainerEditor *editor, gimp_image_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable) GimpViewable *viewable)

17
app/widgets/gimpitemtreeview.c
View File

@ -625,7 +625,7 @@ gimp_item_tree_view_new (gint preview_size,
GimpActivateItemFunc activate_item_func, GimpActivateItemFunc activate_item_func,
GimpMenuFactory *menu_factory, GimpMenuFactory *menu_factory,
const gchar *menu_identifier, const gchar *menu_identifier,
const gchar *ui_identifier) const gchar *ui_path)
{ {
GimpItemTreeView *item_view; GimpItemTreeView *item_view;
GType view_type; GType view_type;
@ -642,7 +642,7 @@ gimp_item_tree_view_new (gint preview_size,
g_return_val_if_fail (activate_item_func != NULL, NULL); g_return_val_if_fail (activate_item_func != NULL, NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL); g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (menu_identifier != NULL, NULL); g_return_val_if_fail (menu_identifier != NULL, NULL);
g_return_val_if_fail (ui_identifier != NULL, NULL); g_return_val_if_fail (ui_path != NULL, NULL);
if (item_type == GIMP_TYPE_LAYER) if (item_type == GIMP_TYPE_LAYER)
{ {
@ -665,6 +665,9 @@ gimp_item_tree_view_new (gint preview_size,
item_view = g_object_new (view_type, item_view = g_object_new (view_type,
"reorderable", TRUE, "reorderable", TRUE,
"menu-factory", menu_factory,
"menu-identifier", menu_identifier,
"ui-path", ui_path,
"item-type", item_type, "item-type", item_type,
"signal-name", signal_name, "signal-name", signal_name,
NULL); NULL);
@ -676,10 +679,6 @@ gimp_item_tree_view_new (gint preview_size,
item_view->new_item_func = new_item_func; item_view->new_item_func = new_item_func;
item_view->activate_item_func = activate_item_func; item_view->activate_item_func = activate_item_func;
gimp_editor_create_menu (GIMP_EDITOR (item_view),
menu_factory, menu_identifier, ui_identifier,
item_view);
gimp_item_tree_view_set_image (item_view, gimage); gimp_item_tree_view_set_image (item_view, gimage);
return GTK_WIDGET (item_view); return GTK_WIDGET (item_view);
@ -734,6 +733,10 @@ gimp_item_tree_view_real_set_image (GimpItemTreeView *view,
gimp_item_tree_view_item_changed (view->gimage, view); gimp_item_tree_view_item_changed (view->gimage, view);
} }
else
{
gimp_ui_manager_update (GIMP_EDITOR (view)->ui_manager, view);
}
gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL));
} }
@ -856,6 +859,8 @@ gimp_item_tree_view_select_item (GimpContainerView *view,
gtk_widget_set_sensitive (tree_view->duplicate_button, duplicate_sensitive); gtk_widget_set_sensitive (tree_view->duplicate_button, duplicate_sensitive);
gtk_widget_set_sensitive (tree_view->delete_button, delete_sensitive); gtk_widget_set_sensitive (tree_view->delete_button, delete_sensitive);
gimp_ui_manager_update (GIMP_EDITOR (tree_view)->ui_manager, tree_view);
return success; return success;
} }

56
app/widgets/gimplayertreeview.c
View File

@ -45,6 +45,7 @@
#include "gimphelp-ids.h" #include "gimphelp-ids.h"
#include "gimplayertreeview.h" #include "gimplayertreeview.h"
#include "gimppreviewrenderer.h" #include "gimppreviewrenderer.h"
#include "gimpuimanager.h"
#include "gimpwidgets-constructors.h" #include "gimpwidgets-constructors.h"
#include "gimp-intl.h" #include "gimp-intl.h"
@ -89,9 +90,6 @@ static void gimp_layer_tree_view_floating_selection_changed
(GimpImage *gimage, (GimpImage *gimage,
GimpLayerTreeView *view); GimpLayerTreeView *view);
static void gimp_layer_tree_view_anchor_clicked (GtkWidget *widget,
GimpLayerTreeView *view);
static void gimp_layer_tree_view_paint_mode_menu_callback static void gimp_layer_tree_view_paint_mode_menu_callback
(GtkWidget *widget, (GtkWidget *widget,
GimpLayerTreeView *view); GimpLayerTreeView *view);
@ -319,25 +317,7 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view)
gtk_widget_hide (GIMP_ITEM_TREE_VIEW (view)->edit_button); gtk_widget_hide (GIMP_ITEM_TREE_VIEW (view)->edit_button);
/* Anchor button */
view->anchor_button =
gimp_editor_add_button (GIMP_EDITOR (view),
GIMP_STOCK_ANCHOR, _("Anchor Floating Layer"),
GIMP_HELP_LAYER_ANCHOR,
G_CALLBACK (gimp_layer_tree_view_anchor_clicked),
NULL,
view);
gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (view)->button_box),
view->anchor_button, 5);
gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (view),
GTK_BUTTON (view->anchor_button),
GIMP_TYPE_LAYER);
gtk_widget_set_sensitive (view->options_box, FALSE); gtk_widget_set_sensitive (view->options_box, FALSE);
gtk_widget_set_sensitive (view->anchor_button, FALSE);
view->italic_attrs = pango_attr_list_new (); view->italic_attrs = pango_attr_list_new ();
attr = pango_attr_style_new (PANGO_STYLE_ITALIC); attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
@ -404,6 +384,17 @@ gimp_layer_tree_view_constructor (GType type,
G_CALLBACK (gimp_layer_tree_view_mask_clicked), G_CALLBACK (gimp_layer_tree_view_mask_clicked),
layer_view); layer_view);
layer_view->anchor_button =
gimp_editor_add_action_button (GIMP_EDITOR (layer_view), "layers",
"layers-anchor", NULL);
gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (layer_view)->button_box),
layer_view->anchor_button, 5);
gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (layer_view),
GTK_BUTTON (layer_view->anchor_button),
GIMP_TYPE_LAYER);
return object; return object;
} }
@ -559,7 +550,6 @@ gimp_layer_tree_view_select_item (GimpContainerView *view,
GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view); GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view);
GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view); GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
gboolean options_sensitive = FALSE; gboolean options_sensitive = FALSE;
gboolean anchor_sensitive = FALSE;
gboolean raise_sensitive = FALSE; gboolean raise_sensitive = FALSE;
gboolean success; gboolean success;
@ -578,8 +568,6 @@ gimp_layer_tree_view_select_item (GimpContainerView *view,
if (! success || gimp_layer_is_floating_sel (GIMP_LAYER (item))) if (! success || gimp_layer_is_floating_sel (GIMP_LAYER (item)))
{ {
anchor_sensitive = TRUE;
gtk_widget_set_sensitive (item_view->edit_button, FALSE); gtk_widget_set_sensitive (item_view->edit_button, FALSE);
gtk_widget_set_sensitive (item_view->lower_button, FALSE); gtk_widget_set_sensitive (item_view->lower_button, FALSE);
gtk_widget_set_sensitive (item_view->duplicate_button, FALSE); gtk_widget_set_sensitive (item_view->duplicate_button, FALSE);
@ -600,7 +588,6 @@ gimp_layer_tree_view_select_item (GimpContainerView *view,
gtk_widget_set_sensitive (layer_view->options_box, options_sensitive); gtk_widget_set_sensitive (layer_view->options_box, options_sensitive);
gtk_widget_set_sensitive (item_view->raise_button, raise_sensitive); gtk_widget_set_sensitive (item_view->raise_button, raise_sensitive);
gtk_widget_set_sensitive (layer_view->anchor_button, anchor_sensitive);
return success; return success;
} }
@ -750,25 +737,6 @@ gimp_layer_tree_view_floating_selection_changed (GimpImage *gimage,
} }
} }
static void
gimp_layer_tree_view_anchor_clicked (GtkWidget *widget,
GimpLayerTreeView *view)
{
GimpImage *gimage;
GimpLayer *layer;
gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
layer = (GimpLayer *)
GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
if (layer && gimp_layer_is_floating_sel (layer))
{
floating_sel_anchor (layer);
gimp_image_flush (gimage);
}
}
/* Paint Mode, Opacity and Preserve trans. callbacks */ /* Paint Mode, Opacity and Preserve trans. callbacks */

240
app/widgets/gimpselectioneditor.c
View File

@ -45,6 +45,7 @@
#include "gimpselectioneditor.h" #include "gimpselectioneditor.h"
#include "gimpdnd.h" #include "gimpdnd.h"
#include "gimphelp-ids.h" #include "gimphelp-ids.h"
#include "gimpmenufactory.h"
#include "gimppreview.h" #include "gimppreview.h"
#include "gimppreviewrenderer.h" #include "gimppreviewrenderer.h"
#include "gimpwidgets-utils.h" #include "gimpwidgets-utils.h"
@ -55,25 +56,13 @@
static void gimp_selection_editor_class_init (GimpSelectionEditorClass *klass); static void gimp_selection_editor_class_init (GimpSelectionEditorClass *klass);
static void gimp_selection_editor_init (GimpSelectionEditor *selection_editor); static void gimp_selection_editor_init (GimpSelectionEditor *selection_editor);
static GObject * gimp_selection_editor_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_selection_editor_set_image (GimpImageEditor *editor, static void gimp_selection_editor_set_image (GimpImageEditor *editor,
GimpImage *gimage); GimpImage *gimage);
static void gimp_selection_editor_invert_clicked (GtkWidget *widget,
GimpImageEditor *editor);
static void gimp_selection_editor_all_clicked (GtkWidget *widget,
GimpImageEditor *editor);
static void gimp_selection_editor_none_clicked (GtkWidget *widget,
GimpImageEditor *editor);
static void gimp_selection_editor_save_clicked (GtkWidget *widget,
GimpImageEditor *editor);
static void gimp_selection_editor_path_clicked (GtkWidget *widget,
GimpImageEditor *editor);
static void gimp_selection_editor_path_extended_clicked (GtkWidget *widget,
guint state,
GimpImageEditor *editor);
static void gimp_selection_editor_stroke_clicked (GtkWidget *widget,
GimpImageEditor *editor);
static gboolean gimp_selection_preview_button_press(GtkWidget *widget, static gboolean gimp_selection_preview_button_press(GtkWidget *widget,
GdkEventButton *bevent, GdkEventButton *bevent,
GimpSelectionEditor *editor); GimpSelectionEditor *editor);
@ -119,104 +108,98 @@ gimp_selection_editor_get_type (void)
static void static void
gimp_selection_editor_class_init (GimpSelectionEditorClass* klass) gimp_selection_editor_class_init (GimpSelectionEditorClass* klass)
{ {
GimpImageEditorClass *image_editor_class; GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpImageEditorClass *image_editor_class = GIMP_IMAGE_EDITOR_CLASS (klass);
image_editor_class = GIMP_IMAGE_EDITOR_CLASS (klass);
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
object_class->constructor = gimp_selection_editor_constructor;
image_editor_class->set_image = gimp_selection_editor_set_image; image_editor_class->set_image = gimp_selection_editor_set_image;
} }
static void static void
gimp_selection_editor_init (GimpSelectionEditor *selection_editor) gimp_selection_editor_init (GimpSelectionEditor *editor)
{ {
GtkWidget *frame; GtkWidget *frame;
gchar *str;
frame = gtk_frame_new (NULL); frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (selection_editor), frame, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (editor), frame, TRUE, TRUE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);
selection_editor->selection_to_vectors_func = NULL; editor->preview = gimp_preview_new_by_types (GIMP_TYPE_PREVIEW,
selection_editor->preview = gimp_preview_new_by_types (GIMP_TYPE_PREVIEW,
GIMP_TYPE_SELECTION, GIMP_TYPE_SELECTION,
GIMP_PREVIEW_SIZE_HUGE, GIMP_PREVIEW_SIZE_HUGE,
0, TRUE); 0, TRUE);
gtk_widget_set_size_request (selection_editor->preview, gimp_preview_renderer_set_background (GIMP_PREVIEW (editor->preview)->renderer,
GIMP_STOCK_TEXTURE);
gtk_widget_set_size_request (editor->preview,
GIMP_PREVIEW_SIZE_HUGE, GIMP_PREVIEW_SIZE_HUGE); GIMP_PREVIEW_SIZE_HUGE, GIMP_PREVIEW_SIZE_HUGE);
gimp_preview_set_expand (GIMP_PREVIEW (selection_editor->preview), TRUE); gimp_preview_set_expand (GIMP_PREVIEW (editor->preview), TRUE);
gtk_container_add (GTK_CONTAINER (frame), selection_editor->preview); gtk_container_add (GTK_CONTAINER (frame), editor->preview);
gtk_widget_show (selection_editor->preview); gtk_widget_show (editor->preview);
g_signal_connect (selection_editor->preview, "button_press_event", g_signal_connect (editor->preview, "button_press_event",
G_CALLBACK (gimp_selection_preview_button_press), G_CALLBACK (gimp_selection_preview_button_press),
selection_editor); editor);
gimp_dnd_color_dest_add (selection_editor->preview, gimp_dnd_color_dest_add (editor->preview,
gimp_selection_editor_drop_color, gimp_selection_editor_drop_color,
selection_editor); editor);
selection_editor->all_button = gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
gimp_editor_add_button (GIMP_EDITOR (selection_editor), }
GIMP_STOCK_SELECTION_ALL, _("Select All"),
GIMP_HELP_SELECTION_ALL,
G_CALLBACK (gimp_selection_editor_all_clicked),
NULL,
selection_editor);
selection_editor->none_button = static GObject *
gimp_editor_add_button (GIMP_EDITOR (selection_editor), gimp_selection_editor_constructor (GType type,
GIMP_STOCK_SELECTION_NONE, _("Select None"), guint n_params,
GIMP_HELP_SELECTION_NONE, GObjectConstructParam *params)
G_CALLBACK (gimp_selection_editor_none_clicked), {
NULL, GObject *object;
selection_editor); GimpSelectionEditor *editor;
gchar *str;
selection_editor->invert_button = object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
gimp_editor_add_button (GIMP_EDITOR (selection_editor),
GIMP_STOCK_INVERT, _("Invert Selection"),
GIMP_HELP_SELECTION_INVERT,
G_CALLBACK (gimp_selection_editor_invert_clicked),
NULL,
selection_editor);
selection_editor->save_button = editor = GIMP_SELECTION_EDITOR (object);
gimp_editor_add_button (GIMP_EDITOR (selection_editor),
GIMP_STOCK_SELECTION_TO_CHANNEL,
_("Save Selection to Channel"),
GIMP_HELP_SELECTION_TO_CHANNEL,
G_CALLBACK (gimp_selection_editor_save_clicked),
NULL,
selection_editor);
str = g_strdup_printf (_("Selection to Path\n" editor->all_button =
"%s Advanced Options"), gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
"select-all", NULL);
editor->none_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
"select-none", NULL);
editor->invert_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
"select-invert", NULL);
editor->save_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
"select-save", NULL);
str = g_strdup_printf (_("Selection to path\n"
"%s Advanced options"),
gimp_get_mod_name_shift ()); gimp_get_mod_name_shift ());
selection_editor->path_button = editor->path_button =
gimp_editor_add_button (GIMP_EDITOR (selection_editor), gimp_editor_add_action_button (GIMP_EDITOR (editor), "vectors",
GIMP_STOCK_SELECTION_TO_PATH, str, "vectors-selection-to-vectors",
GIMP_HELP_SELECTION_TO_PATH, "vectors-selection-to-vectors-advanced",
G_CALLBACK (gimp_selection_editor_path_clicked), GDK_SHIFT_MASK,
G_CALLBACK (gimp_selection_editor_path_extended_clicked), NULL);
selection_editor); gimp_help_set_help_data (editor->path_button, str,
GIMP_HELP_SELECTION_TO_PATH);
g_free (str); g_free (str);
selection_editor->stroke_button = editor->stroke_button =
gimp_editor_add_button (GIMP_EDITOR (selection_editor), gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
GIMP_STOCK_SELECTION_STROKE, "select-stroke", NULL);
_("Stroke Selection"),
GIMP_HELP_SELECTION_STROKE,
G_CALLBACK (gimp_selection_editor_stroke_clicked),
NULL,
selection_editor);
return object;
gtk_widget_set_sensitive (GTK_WIDGET (selection_editor), FALSE);
} }
static void static void
@ -252,20 +235,20 @@ gimp_selection_editor_set_image (GimpImageEditor *image_editor,
/* public functions */ /* public functions */
#define PREVIEW_WIDTH 256
#define PREVIEW_HEIGHT 256
GtkWidget * GtkWidget *
gimp_selection_editor_new (GimpImage *gimage) gimp_selection_editor_new (GimpImage *gimage,
GimpMenuFactory *menu_factory)
{ {
GimpSelectionEditor *editor; GimpSelectionEditor *editor;
g_return_val_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage), NULL); g_return_val_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
editor = g_object_new (GIMP_TYPE_SELECTION_EDITOR, NULL); editor = g_object_new (GIMP_TYPE_SELECTION_EDITOR,
"menu-factory", menu_factory,
gimp_preview_renderer_set_background (GIMP_PREVIEW (editor->preview)->renderer, "menu-identifier", "<SelectionEditor>",
GIMP_STOCK_TEXTURE); "ui-path", "/selection-editor-popup",
NULL);
if (gimage) if (gimage)
gimp_image_editor_set_image (GIMP_IMAGE_EDITOR (editor), gimage); gimp_image_editor_set_image (GIMP_IMAGE_EDITOR (editor), gimage);
@ -273,85 +256,6 @@ gimp_selection_editor_new (GimpImage *gimage)
return GTK_WIDGET (editor); return GTK_WIDGET (editor);
} }
static void
gimp_selection_editor_invert_clicked (GtkWidget *widget,
GimpImageEditor *editor)
{
if (editor->gimage)
{
gimp_channel_invert (gimp_image_get_mask (editor->gimage), TRUE);
gimp_image_flush (editor->gimage);
}
}
static void
gimp_selection_editor_all_clicked (GtkWidget *widget,
GimpImageEditor *editor)
{
if (editor->gimage)
{
gimp_channel_all (gimp_image_get_mask (editor->gimage), TRUE);
gimp_image_flush (editor->gimage);
}
}
static void
gimp_selection_editor_none_clicked (GtkWidget *widget,
GimpImageEditor *editor)
{
if (editor->gimage)
{
gimp_channel_clear (gimp_image_get_mask (editor->gimage), NULL, TRUE);
gimp_image_flush (editor->gimage);
}
}
static void
gimp_selection_editor_save_clicked (GtkWidget *widget,
GimpImageEditor *editor)
{
if (editor->gimage)
{
gimp_selection_save (gimp_image_get_mask (editor->gimage));
}
}
static void
gimp_selection_editor_path_clicked (GtkWidget *widget,
GimpImageEditor *editor)
{
gimp_selection_editor_path_extended_clicked (widget, 0, editor);
}
static void
gimp_selection_editor_path_extended_clicked (GtkWidget *widget,
guint state,
GimpImageEditor *editor)
{
if (editor->gimage)
{
GimpSelectionEditor *sel_editor = GIMP_SELECTION_EDITOR (editor);
if (sel_editor->selection_to_vectors_func)
sel_editor->selection_to_vectors_func (editor->gimage,
(state & GDK_SHIFT_MASK) != 0);
}
}
static void
gimp_selection_editor_stroke_clicked (GtkWidget *widget,
GimpImageEditor *editor)
{
if (editor->gimage)
{
GimpSelectionEditor *sel_editor = GIMP_SELECTION_EDITOR (editor);
if (sel_editor->stroke_item_func)
sel_editor->stroke_item_func (GIMP_ITEM (gimp_image_get_mask (editor->gimage)),
GTK_WIDGET (editor));
}
}
static gboolean static gboolean
gimp_selection_preview_button_press (GtkWidget *widget, gimp_selection_preview_button_press (GtkWidget *widget,
GdkEventButton *bevent, GdkEventButton *bevent,

6
app/widgets/gimpselectioneditor.h
View File

@ -37,9 +37,6 @@ struct _GimpSelectionEditor
{ {
GimpImageEditor parent_instance; GimpImageEditor parent_instance;
GimpStrokeItemFunc stroke_item_func;
GimpSelectionToVectorsFunc selection_to_vectors_func;
GtkWidget *preview; GtkWidget *preview;
GtkWidget *all_button; GtkWidget *all_button;
@ -58,7 +55,8 @@ struct _GimpSelectionEditorClass
GType gimp_selection_editor_get_type (void) G_GNUC_CONST; GType gimp_selection_editor_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_selection_editor_new (GimpImage *gimage); GtkWidget * gimp_selection_editor_new (GimpImage *gimage,
GimpMenuFactory *menu_factory);
#endif /* __GIMP_SELECTION_EDITOR_H__ */ #endif /* __GIMP_SELECTION_EDITOR_H__ */

24
app/widgets/gimptemplateview.c
View File

@ -52,11 +52,8 @@
static void gimp_template_view_class_init (GimpTemplateViewClass *klass); static void gimp_template_view_class_init (GimpTemplateViewClass *klass);
static void gimp_template_view_init (GimpTemplateView *view); static void gimp_template_view_init (GimpTemplateView *view);
static void gimp_template_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable);
static void gimp_template_view_activate_item (GimpContainerEditor *editor, static void gimp_template_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable); GimpViewable *viewable);
static void gimp_template_view_tree_name_edited (GtkCellRendererText *cell, static void gimp_template_view_tree_name_edited (GtkCellRendererText *cell,
const gchar *path_str, const gchar *path_str,
const gchar *new_name, const gchar *new_name,
@ -101,7 +98,6 @@ gimp_template_view_class_init (GimpTemplateViewClass *klass)
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
editor_class->select_item = gimp_template_view_select_item;
editor_class->activate_item = gimp_template_view_activate_item; editor_class->activate_item = gimp_template_view_activate_item;
} }
@ -161,23 +157,23 @@ gimp_template_view_new (GimpViewType view_type,
template_view->create_button = template_view->create_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
"templates-create-image"); "templates-create-image", NULL);
template_view->new_button = template_view->new_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
"templates-new"); "templates-new", NULL);
template_view->duplicate_button = template_view->duplicate_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
"templates-duplicate"); "templates-duplicate", NULL);
template_view->edit_button = template_view->edit_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
"templates-edit"); "templates-edit", NULL);
template_view->delete_button = template_view->delete_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
"templates-delete"); "templates-delete", NULL);
gimp_container_view_enable_dnd (editor->view, gimp_container_view_enable_dnd (editor->view,
GTK_BUTTON (template_view->create_button), GTK_BUTTON (template_view->create_button),
@ -197,16 +193,6 @@ gimp_template_view_new (GimpViewType view_type,
return GTK_WIDGET (template_view); return GTK_WIDGET (template_view);
} }
static void
gimp_template_view_select_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
}
static void static void
gimp_template_view_activate_item (GimpContainerEditor *editor, gimp_template_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable) GimpViewable *viewable)

2
app/widgets/gimptoolview.c
View File

@ -125,7 +125,7 @@ gimp_tool_view_new (GimpViewType view_type,
tool_view->reset_button = tool_view->reset_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "tools", gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "tools",
"tools-reset"); "tools-reset", NULL);
gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor); gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);

134
app/widgets/gimpundoeditor.c
View File

@ -35,6 +35,7 @@
#include "gimpcontainertreeview.h" #include "gimpcontainertreeview.h"
#include "gimpcontainerview.h" #include "gimpcontainerview.h"
#include "gimphelp-ids.h" #include "gimphelp-ids.h"
#include "gimpmenufactory.h"
#include "gimpundoeditor.h" #include "gimpundoeditor.h"
#include "gimp-intl.h" #include "gimp-intl.h"
@ -63,13 +64,6 @@ static void gimp_undo_editor_set_image (GimpImageEditor *editor,
static void gimp_undo_editor_fill (GimpUndoEditor *editor); static void gimp_undo_editor_fill (GimpUndoEditor *editor);
static void gimp_undo_editor_clear (GimpUndoEditor *editor); static void gimp_undo_editor_clear (GimpUndoEditor *editor);
static void gimp_undo_editor_undo_clicked (GtkWidget *widget,
GimpImageEditor *editor);
static void gimp_undo_editor_redo_clicked (GtkWidget *widget,
GimpImageEditor *editor);
static void gimp_undo_editor_clear_clicked (GtkWidget *widget,
GimpImageEditor *editor);
static void gimp_undo_editor_undo_event (GimpImage *gimage, static void gimp_undo_editor_undo_event (GimpImage *gimage,
GimpUndoEvent event, GimpUndoEvent event,
GimpUndo *undo, GimpUndo *undo,
@ -80,8 +74,6 @@ static void gimp_undo_editor_select_item (GimpContainerView *view,
gpointer insert_data, gpointer insert_data,
GimpUndoEditor *editor); GimpUndoEditor *editor);
static void gimp_undo_editor_update_buttons (GimpUndoEditor *editor);
static GimpImageEditorClass *parent_class = NULL; static GimpImageEditorClass *parent_class = NULL;
@ -140,31 +132,6 @@ gimp_undo_editor_class_init (GimpUndoEditorClass *klass)
static void static void
gimp_undo_editor_init (GimpUndoEditor *undo_editor) gimp_undo_editor_init (GimpUndoEditor *undo_editor)
{ {
undo_editor->container = NULL;
undo_editor->undo_button =
gimp_editor_add_button (GIMP_EDITOR (undo_editor),
GTK_STOCK_UNDO, _("Undo"),
GIMP_HELP_EDIT_UNDO,
G_CALLBACK (gimp_undo_editor_undo_clicked),
NULL,
undo_editor);
undo_editor->redo_button =
gimp_editor_add_button (GIMP_EDITOR (undo_editor),
GTK_STOCK_REDO, _("Redo"),
GIMP_HELP_EDIT_REDO,
G_CALLBACK (gimp_undo_editor_redo_clicked),
NULL,
undo_editor);
undo_editor->clear_button =
gimp_editor_add_button (GIMP_EDITOR (undo_editor),
GTK_STOCK_CLEAR, _("Clear Undo History"),
GIMP_HELP_EDIT_UNDO_CLEAR,
G_CALLBACK (gimp_undo_editor_clear_clicked),
NULL,
undo_editor);
} }
static GObject * static GObject *
@ -189,6 +156,18 @@ gimp_undo_editor_constructor (GType type,
G_CALLBACK (gimp_undo_editor_select_item), G_CALLBACK (gimp_undo_editor_select_item),
undo_editor); undo_editor);
undo_editor->undo_button =
gimp_editor_add_action_button (GIMP_EDITOR (undo_editor), "edit",
"edit-undo", NULL);
undo_editor->redo_button =
gimp_editor_add_action_button (GIMP_EDITOR (undo_editor), "edit",
"edit-redo", NULL);
undo_editor->clear_button =
gimp_editor_add_action_button (GIMP_EDITOR (undo_editor), "edit",
"edit-undo-clear", NULL);
return object; return object;
} }
@ -243,15 +222,20 @@ gimp_undo_editor_set_image (GimpImageEditor *image_editor,
/* public functions */ /* public functions */
GtkWidget * GtkWidget *
gimp_undo_editor_new (GimpCoreConfig *config) gimp_undo_editor_new (GimpCoreConfig *config,
GimpMenuFactory *menu_factory)
{ {
g_return_val_if_fail (GIMP_IS_CORE_CONFIG (config), NULL); g_return_val_if_fail (GIMP_IS_CORE_CONFIG (config), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
return g_object_new (GIMP_TYPE_UNDO_EDITOR, return g_object_new (GIMP_TYPE_UNDO_EDITOR,
"menu-factory", menu_factory,
"menu-identifier", "<UndoEditor>",
"preview-size", config->undo_preview_size, "preview-size", config->undo_preview_size,
NULL); NULL);
} }
/* private functions */ /* private functions */
static void static void
@ -329,8 +313,6 @@ gimp_undo_editor_fill (GimpUndoEditor *editor)
g_signal_handlers_unblock_by_func (editor->view, g_signal_handlers_unblock_by_func (editor->view,
gimp_undo_editor_select_item, gimp_undo_editor_select_item,
editor); editor);
gimp_undo_editor_update_buttons (editor);
} }
static void static void
@ -351,66 +333,6 @@ gimp_undo_editor_clear (GimpUndoEditor *editor)
} }
} }
static void
gimp_undo_editor_undo_clicked (GtkWidget *widget,
GimpImageEditor *editor)
{
if (editor->gimage)
{
if (gimp_image_undo (editor->gimage))
gimp_image_flush (editor->gimage);
}
}
static void
gimp_undo_editor_redo_clicked (GtkWidget *widget,
GimpImageEditor *editor)
{
if (editor->gimage)
{
if (gimp_image_redo (editor->gimage))
gimp_image_flush (editor->gimage);
}
}
static void
gimp_undo_editor_clear_callback (GtkWidget *widget,
gboolean clear,
gpointer data)
{
if (clear)
{
GimpImage *gimage = data;
gimp_image_undo_disable (gimage);
gimp_image_undo_enable (gimage);
gimp_image_flush (gimage);
}
}
static void
gimp_undo_editor_clear_clicked (GtkWidget *widget,
GimpImageEditor *editor)
{
if (editor->gimage)
{
GtkWidget *dialog;
dialog = gimp_query_boolean_box (_("Clear Undo History"),
GTK_WIDGET (editor),
gimp_standard_help_func,
GIMP_HELP_EDIT_UNDO_CLEAR,
GIMP_STOCK_QUESTION,
_("Really clear image's undo history?"),
GTK_STOCK_CLEAR, GTK_STOCK_CANCEL,
G_OBJECT (editor->gimage),
"disconnect",
gimp_undo_editor_clear_callback,
editor->gimage);
gtk_widget_show (dialog);
}
}
static void static void
gimp_undo_editor_undo_event (GimpImage *gimage, gimp_undo_editor_undo_event (GimpImage *gimage,
GimpUndoEvent event, GimpUndoEvent event,
@ -480,8 +402,6 @@ gimp_undo_editor_undo_event (GimpImage *gimage,
gimp_undo_editor_fill (editor); gimp_undo_editor_fill (editor);
break; break;
} }
gimp_undo_editor_update_buttons (editor);
} }
static void static void
@ -537,20 +457,4 @@ gimp_undo_editor_select_item (GimpContainerView *view,
} }
gimp_image_flush (gimage); gimp_image_flush (gimage);
gimp_undo_editor_update_buttons (editor);
}
static void
gimp_undo_editor_update_buttons (GimpUndoEditor *editor)
{
GimpImage *gimage = GIMP_IMAGE_EDITOR (editor)->gimage;
GimpUndo *top_undo_item = gimp_undo_stack_peek (gimage->undo_stack);
GimpUndo *top_redo_item = gimp_undo_stack_peek (gimage->redo_stack);
gboolean enabled = gimp_image_undo_is_enabled (gimage);
gtk_widget_set_sensitive (editor->undo_button, enabled && top_undo_item);
gtk_widget_set_sensitive (editor->redo_button, enabled && top_redo_item);
gtk_widget_set_sensitive (editor->clear_button, enabled && (top_undo_item ||
top_redo_item));
} }

3
app/widgets/gimpundoeditor.h
View File

@ -56,7 +56,8 @@ struct _GimpUndoEditorClass
GType gimp_undo_editor_get_type (void) G_GNUC_CONST; GType gimp_undo_editor_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_undo_editor_new (GimpCoreConfig *config); GtkWidget * gimp_undo_editor_new (GimpCoreConfig *config,
GimpMenuFactory *menu_factory);
#endif /* __GIMP_UNDO_EDITOR_H__ */ #endif /* __GIMP_UNDO_EDITOR_H__ */

221
app/widgets/gimpvectorstreeview.c
View File

@ -2,7 +2,7 @@
* Copyright (C) 1995 Spencer Kimball and Peter Mattis * Copyright (C) 1995 Spencer Kimball and Peter Mattis
* *
* gimpvectorstreeview.c * gimpvectorstreeview.c
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org> * Copyright (C) 2001-2004 Michael Natterer <mitch@gimp.org>
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
@ -23,14 +23,11 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "libgimpwidgets/gimpwidgets.h" #include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h" #include "widgets-types.h"
#include "core/gimp.h" #include "core/gimp.h"
#include "core/gimpchannel.h"
#include "core/gimpchannel-select.h"
#include "core/gimpcontainer.h" #include "core/gimpcontainer.h"
#include "core/gimpcontext.h" #include "core/gimpcontext.h"
#include "core/gimpimage.h" #include "core/gimpimage.h"
@ -49,35 +46,12 @@
static void gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass); static void gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass);
static void gimp_vectors_tree_view_init (GimpVectorsTreeView *view); static void gimp_vectors_tree_view_init (GimpVectorsTreeView *view);
static void gimp_vectors_tree_view_view_iface_init (GimpContainerViewInterface *view_iface); static GObject * gimp_vectors_tree_view_constructor (GType type,
guint n_params,
static gboolean gimp_vectors_tree_view_select_item (GimpContainerView *view, GObjectConstructParam *params);
GimpViewable *item,
gpointer insert_data);
static void gimp_vectors_tree_view_set_image (GimpItemTreeView *view,
GimpImage *gimage);
static void gimp_vectors_tree_view_toselection_clicked
(GtkWidget *widget,
GimpVectorsTreeView *view);
static void gimp_vectors_tree_view_toselection_extended_clicked
(GtkWidget *widget,
guint state,
GimpVectorsTreeView *view);
static void gimp_vectors_tree_view_tovectors_clicked
(GtkWidget *widget,
GimpVectorsTreeView *view);
static void gimp_vectors_tree_view_tovectors_extended_clicked
(GtkWidget *widget,
guint state,
GimpVectorsTreeView *view);
static void gimp_vectors_tree_view_stroke_clicked (GtkWidget *widget,
GimpVectorsTreeView *view);
static GimpItemTreeViewClass *parent_class = NULL; static GimpItemTreeViewClass *parent_class = NULL;
static GimpContainerViewInterface *parent_view_iface = NULL;
GType GType
@ -100,19 +74,9 @@ gimp_vectors_tree_view_get_type (void)
(GInstanceInitFunc) gimp_vectors_tree_view_init, (GInstanceInitFunc) gimp_vectors_tree_view_init,
}; };
static const GInterfaceInfo view_iface_info =
{
(GInterfaceInitFunc) gimp_vectors_tree_view_view_iface_init,
NULL, /* iface_finalize */
NULL /* iface_data */
};
view_type = g_type_register_static (GIMP_TYPE_ITEM_TREE_VIEW, view_type = g_type_register_static (GIMP_TYPE_ITEM_TREE_VIEW,
"GimpVectorsTreeView", "GimpVectorsTreeView",
&view_info, 0); &view_info, 0);
g_type_add_interface_static (view_type, GIMP_TYPE_CONTAINER_VIEW,
&view_iface_info);
} }
return view_type; return view_type;
@ -121,11 +85,12 @@ gimp_vectors_tree_view_get_type (void)
static void static void
gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass) gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass)
{ {
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpItemTreeViewClass *item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass); GimpItemTreeViewClass *item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass);
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
item_view_class->set_image = gimp_vectors_tree_view_set_image; object_class->constructor = gimp_vectors_tree_view_constructor;
item_view_class->get_container = gimp_image_get_vectors; item_view_class->get_container = gimp_image_get_vectors;
item_view_class->get_active_item = (GimpGetItemFunc) gimp_image_get_active_vectors; item_view_class->get_active_item = (GimpGetItemFunc) gimp_image_get_active_vectors;
@ -156,9 +121,23 @@ gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass)
static void static void
gimp_vectors_tree_view_init (GimpVectorsTreeView *view) gimp_vectors_tree_view_init (GimpVectorsTreeView *view)
{ {
GimpEditor *editor = GIMP_EDITOR (view); }
static GObject *
gimp_vectors_tree_view_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
GimpEditor *editor;
GimpVectorsTreeView *view;
gchar *str; gchar *str;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
editor = GIMP_EDITOR (object);
view = GIMP_VECTORS_TREE_VIEW (object);
/* Hide basically useless Edit button */ /* Hide basically useless Edit button */
gtk_widget_hide (GIMP_ITEM_TREE_VIEW (view)->edit_button); gtk_widget_hide (GIMP_ITEM_TREE_VIEW (view)->edit_button);
@ -174,12 +153,18 @@ gimp_vectors_tree_view_init (GimpVectorsTreeView *view)
gimp_get_mod_name_control ()); gimp_get_mod_name_control ());
view->toselection_button = view->toselection_button =
gimp_editor_add_button (editor, gimp_editor_add_action_button (editor, "vectors",
GIMP_STOCK_SELECTION_REPLACE, str, "vectors-selection-replace",
GIMP_HELP_PATH_SELECTION_REPLACE, "vectors-selection-intersect",
G_CALLBACK (gimp_vectors_tree_view_toselection_clicked), GDK_SHIFT_MASK | GDK_CONTROL_MASK,
G_CALLBACK (gimp_vectors_tree_view_toselection_extended_clicked), "vectors-selection-subtract",
view); GDK_CONTROL_MASK,
"vectors-selection-add",
GDK_SHIFT_MASK,
NULL);
gimp_help_set_help_data (view->toselection_button, str,
GIMP_HELP_PATH_SELECTION_REPLACE);
g_free (str); g_free (str);
@ -188,22 +173,20 @@ gimp_vectors_tree_view_init (GimpVectorsTreeView *view)
gimp_get_mod_name_shift ()); gimp_get_mod_name_shift ());
view->tovectors_button = view->tovectors_button =
gimp_editor_add_button (editor, gimp_editor_add_action_button (editor, "vectors",
GIMP_STOCK_SELECTION_TO_PATH, str, "vectors-selection-to-vectors",
GIMP_HELP_SELECTION_TO_PATH, "vectors-selection-to-vectors-advanced",
G_CALLBACK (gimp_vectors_tree_view_tovectors_clicked), GDK_SHIFT_MASK,
G_CALLBACK (gimp_vectors_tree_view_tovectors_extended_clicked), NULL);
view);
gimp_help_set_help_data (view->tovectors_button, str,
GIMP_HELP_SELECTION_TO_PATH);
g_free (str); g_free (str);
view->stroke_button = view->stroke_button =
gimp_editor_add_button (editor, gimp_editor_add_action_button (editor, "vectors",
GIMP_STOCK_PATH_STROKE, _("Stroke Path"), "vectors-stroke", NULL);
GIMP_HELP_PATH_STROKE,
G_CALLBACK (gimp_vectors_tree_view_stroke_clicked),
NULL,
view);
gtk_box_reorder_child (GTK_BOX (editor->button_box), gtk_box_reorder_child (GTK_BOX (editor->button_box),
view->toselection_button, 5); view->toselection_button, 5);
@ -219,121 +202,5 @@ gimp_vectors_tree_view_init (GimpVectorsTreeView *view)
GTK_BUTTON (view->stroke_button), GTK_BUTTON (view->stroke_button),
GIMP_TYPE_VECTORS); GIMP_TYPE_VECTORS);
gtk_widget_set_sensitive (view->toselection_button, FALSE); return object;
gtk_widget_set_sensitive (view->tovectors_button, FALSE);
gtk_widget_set_sensitive (view->stroke_button, FALSE);
}
static void
gimp_vectors_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
{
parent_view_iface = g_type_interface_peek_parent (view_iface);
view_iface->select_item = gimp_vectors_tree_view_select_item;
}
/* GimpContainerView methods */
static gboolean
gimp_vectors_tree_view_select_item (GimpContainerView *view,
GimpViewable *item,
gpointer insert_data)
{
GimpVectorsTreeView *tree_view = GIMP_VECTORS_TREE_VIEW (view);
gboolean success;
success = parent_view_iface->select_item (view, item, insert_data);
gtk_widget_set_sensitive (tree_view->toselection_button, item != NULL);
gtk_widget_set_sensitive (tree_view->stroke_button, item != NULL);
return success;
}
static void
gimp_vectors_tree_view_set_image (GimpItemTreeView *view,
GimpImage *gimage)
{
GIMP_ITEM_TREE_VIEW_CLASS (parent_class)->set_image (view, gimage);
gtk_widget_set_sensitive (GIMP_VECTORS_TREE_VIEW (view)->tovectors_button,
gimage != NULL);
}
static void
gimp_vectors_tree_view_toselection_clicked (GtkWidget *widget,
GimpVectorsTreeView *view)
{
gimp_vectors_tree_view_toselection_extended_clicked (widget, 0, view);
}
static void
gimp_vectors_tree_view_toselection_extended_clicked (GtkWidget *widget,
guint state,
GimpVectorsTreeView *view)
{
GimpImage *gimage;
GimpItem *item;
gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
if (item)
{
GimpChannelOps operation = GIMP_CHANNEL_OP_REPLACE;
if (state & GDK_SHIFT_MASK)
{
if (state & GDK_CONTROL_MASK)
operation = GIMP_CHANNEL_OP_INTERSECT;
else
operation = GIMP_CHANNEL_OP_ADD;
}
else if (state & GDK_CONTROL_MASK)
{
operation = GIMP_CHANNEL_OP_SUBTRACT;
}
gimp_channel_select_vectors (gimp_image_get_mask (gimage),
_("Path to Selection"),
GIMP_VECTORS (item),
operation,
TRUE,
FALSE, 0, 0);
gimp_image_flush (gimage);
}
}
static void
gimp_vectors_tree_view_tovectors_clicked (GtkWidget *widget,
GimpVectorsTreeView *view)
{
gimp_vectors_tree_view_tovectors_extended_clicked (widget, 0, view);
}
static void
gimp_vectors_tree_view_tovectors_extended_clicked (GtkWidget *widget,
guint state,
GimpVectorsTreeView *view)
{
if (view->selection_to_vectors_func)
view->selection_to_vectors_func (GIMP_ITEM_TREE_VIEW (view)->gimage,
(state & GDK_SHIFT_MASK) != 0);
}
static void
gimp_vectors_tree_view_stroke_clicked (GtkWidget *widget,
GimpVectorsTreeView *view)
{
GimpImage *gimage;
GimpItem *item;
gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
if (item && view->stroke_item_func)
view->stroke_item_func (item, GTK_WIDGET (view));
} }

3
app/widgets/gimpvectorstreeview.h
View File

@ -40,9 +40,6 @@ struct _GimpVectorsTreeView
{ {
GimpItemTreeView parent_instance; GimpItemTreeView parent_instance;
GimpStrokeItemFunc stroke_item_func;
GimpSelectionToVectorsFunc selection_to_vectors_func;
GtkWidget *toselection_button; GtkWidget *toselection_button;
GtkWidget *tovectors_button; GtkWidget *tovectors_button;
GtkWidget *stroke_button; GtkWidget *stroke_button;

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

@ -159,10 +159,5 @@ typedef void (* GimpMenuPositionFunc) (GtkMenu *menu,
gint *y, gint *y,
gpointer data); gpointer data);
typedef void (* GimpStrokeItemFunc) (GimpItem *item,
GtkWidget *parent);
typedef void (* GimpSelectionToVectorsFunc) (GimpImage *gimage,
gboolean advanced);
#endif /* __WIDGETS_TYPES_H__ */ #endif /* __WIDGETS_TYPES_H__ */

1
menus/Makefile.am
View File

@ -28,6 +28,7 @@ menudata_DATA = \
palettes-menu.xml \ palettes-menu.xml \
patterns-menu.xml \ patterns-menu.xml \
qmask-menu.xml \ qmask-menu.xml \
selection-editor-menu.xml \
templates-menu.xml \ templates-menu.xml \
tool-options-menu.xml \ tool-options-menu.xml \
tools-menu.xml \ tools-menu.xml \

2
menus/image-menu.xml.in
View File

@ -65,7 +65,7 @@
<menuitem action="edit-fill-pattern" /> <menuitem action="edit-fill-pattern" />
</placeholder> </placeholder>
<placeholder name="Stroke"> <placeholder name="Stroke">
<menuitem action="edit-stroke" /> <menuitem action="select-stroke" />
<menuitem action="vectors-stroke" /> <menuitem action="vectors-stroke" />
</placeholder> </placeholder>
<separator /> <separator />

24
menus/selection-editor-menu.xml Normal file
View File

@ -0,0 +1,24 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ui SYSTEM "gtkuimanager.dtd">
<ui>
<popup action="selection-editor-popup">
<menuitem action="select-all" />
<menuitem action="select-none" />
<menuitem action="select-invert" />
<menuitem action="select-from-vectors" />
<menuitem action="select-float" />
<separator />
<placeholder name="Outline">
<menuitem action="select-feather" />
<menuitem action="select-sharpen" />
<menuitem action="select-shrink" />
<menuitem action="select-grow" />
<menuitem action="select-border" />
</placeholder>
<separator />
<menuitem action="select-save" />
<menuitem action="select-to-vectors" />
<menuitem action="select-stroke" />
</popup>
</ui>

24
menus/selection-menu.xml Normal file
View File

@ -0,0 +1,24 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ui SYSTEM "gtkuimanager.dtd">
<ui>
<popup action="selection-editor-popup">
<menuitem action="select-all" />
<menuitem action="select-none" />
<menuitem action="select-invert" />
<menuitem action="select-from-vectors" />
<menuitem action="select-float" />
<separator />
<placeholder name="Outline">
<menuitem action="select-feather" />
<menuitem action="select-sharpen" />
<menuitem action="select-shrink" />
<menuitem action="select-grow" />
<menuitem action="select-border" />
</placeholder>
<separator />
<menuitem action="select-save" />
<menuitem action="select-to-vectors" />
<menuitem action="select-stroke" />
</popup>
</ui>