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

Merge commit 'origin/master' into soc-2009-dynamics

This commit is contained in:
Alexia Death 2009-09-28 20:30:17 +03:00
parent bb18654483 c39b8758d5
commit e75d44c77c
58 changed files with 1361 additions and 608 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
app/actions/context-commands.c
View File

@ -871,8 +871,8 @@ context_get_palette_editor (void)
info = gimp_dialog_factory_find_session_info (dialog_factory,
"gimp-palette-editor");
if (info && info->widget)
return GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget)));
if (info && gimp_session_info_get_widget (info))
return GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (info))));
return NULL;
}
@ -889,8 +889,8 @@ context_get_colormap_editor (void)
info = gimp_dialog_factory_find_session_info (dialog_factory,
"gimp-indexed-palette");
if (info && info->widget)
return GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget)));
if (info && gimp_session_info_get_widget (info))
return GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (info))));
return NULL;
}

31
app/actions/dock-actions.c
View File

@ -24,6 +24,7 @@
#include "actions-types.h"
#include "widgets/gimpactiongroup.h"
#include "widgets/gimpdockwindow.h"
#include "widgets/gimphelp-ids.h"
#include "widgets/gimpmenudock.h"
@ -99,24 +100,26 @@ dock_actions_update (GimpActionGroup *group,
#define SET_VISIBLE(action,active) \
gimp_action_group_set_action_visible (group, action, (active) != 0)
if (GIMP_IS_MENU_DOCK (toplevel))
if (GIMP_IS_DOCK_WINDOW (toplevel))
{
GimpMenuDock *menu_dock = GIMP_MENU_DOCK (toplevel);
GimpDock *dock = gimp_dock_window_get_dock (GIMP_DOCK_WINDOW (toplevel));
if (GIMP_IS_MENU_DOCK (dock))
{
GimpMenuDock *menu_dock = GIMP_MENU_DOCK (dock);
SET_VISIBLE ("dock-show-image-menu", TRUE);
SET_VISIBLE ("dock-auto-follow-active", TRUE);
SET_VISIBLE ("dock-show-image-menu", TRUE);
SET_VISIBLE ("dock-auto-follow-active", TRUE);
SET_ACTIVE ("dock-show-image-menu", menu_dock->show_image_menu);
SET_ACTIVE ("dock-auto-follow-active", menu_dock->auto_follow_active);
}
else
{
SET_VISIBLE ("dock-show-image-menu", FALSE);
SET_VISIBLE ("dock-auto-follow-active", FALSE);
}
SET_ACTIVE ("dock-show-image-menu", menu_dock->show_image_menu);
SET_ACTIVE ("dock-auto-follow-active", menu_dock->auto_follow_active);
}
else
{
SET_VISIBLE ("dock-show-image-menu", FALSE);
SET_VISIBLE ("dock-auto-follow-active", FALSE);
}
if (GIMP_IS_DOCK (toplevel))
{
/* update the window actions only in the context of their
* own window (not in the context of some display or NULL)
* (see view-actions.c)

51
app/actions/dock-commands.c
View File

@ -23,44 +23,63 @@
#include "actions-types.h"
#include "widgets/gimpdockwindow.h"
#include "widgets/gimpmenudock.h"
#include "actions.h"
#include "dock-commands.h"
static GimpMenuDock *
dock_commands_get_menudock_from_widget (GtkWidget *widget)
{
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
GimpMenuDock *menu_dock = NULL;
if (GIMP_IS_DOCK_WINDOW (toplevel))
{
GimpDock *dock = gimp_dock_window_get_dock (GIMP_DOCK_WINDOW (toplevel));
if (GIMP_IS_MENU_DOCK (dock))
menu_dock = GIMP_MENU_DOCK (dock);
}
return menu_dock;
}
/* public functions */
void
dock_toggle_image_menu_cmd_callback (GtkAction *action,
gpointer data)
{
GtkWidget *widget;
gboolean active;
GtkWidget *widget = NULL;
GimpMenuDock *menu_dock = NULL;
return_if_no_widget (widget, data);
if (! GTK_WIDGET_TOPLEVEL (widget))
widget = gtk_widget_get_toplevel (widget);
menu_dock = dock_commands_get_menudock_from_widget (widget);
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (GIMP_IS_MENU_DOCK (widget))
gimp_menu_dock_set_show_image_menu (GIMP_MENU_DOCK (widget), active);
if (menu_dock)
{
gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
gimp_menu_dock_set_show_image_menu (menu_dock, active);
}
}
void
dock_toggle_auto_cmd_callback (GtkAction *action,
gpointer data)
{
GtkWidget *widget;
gboolean active;
GtkWidget *widget = NULL;
GimpMenuDock *menu_dock = NULL;
return_if_no_widget (widget, data);
if (! GTK_WIDGET_TOPLEVEL (widget))
widget = gtk_widget_get_toplevel (widget);
menu_dock = dock_commands_get_menudock_from_widget (widget);
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (GIMP_IS_MENU_DOCK (widget))
gimp_menu_dock_set_auto_follow_active (GIMP_MENU_DOCK (widget), active);
if (menu_dock)
{
gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
gimp_menu_dock_set_auto_follow_active (menu_dock, active);
}
}

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

@ -152,6 +152,12 @@ static const GimpActionEntry layers_actions[] =
G_CALLBACK (layers_merge_down_cmd_callback),
GIMP_HELP_LAYER_MERGE_DOWN },
{ "layers-merge-group", NULL,
NC_("layers-action", "Merge Layer Group"), NULL,
NC_("layers-action", "Merge the layer group's layers into one normal layer"),
G_CALLBACK (layers_merge_group_cmd_callback),
GIMP_HELP_LAYER_MERGE_GROUP },
{ "layers-merge-layers", NULL,
NC_("layers-action", "Merge _Visible Layers..."), NULL,
NC_("layers-action", "Merge all visible layers into one layer"),
@ -590,8 +596,9 @@ layers_actions_update (GimpActionGroup *group,
SET_SENSITIVE ("layers-lower-to-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-anchor", layer && fs && !ac);
SET_SENSITIVE ("layers-merge-down", layer && !fs && !ac &&
!children && next_visible);
SET_SENSITIVE ("layers-merge-down", layer && !fs && !ac && next_visible);
SET_VISIBLE ("layers-merge-group", children);
SET_SENSITIVE ("layers-merge-group", layer && !fs && !ac && children);
SET_SENSITIVE ("layers-merge-layers", layer && !fs && !ac);
SET_SENSITIVE ("layers-flatten-image", layer && !fs && !ac);

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

@ -505,6 +505,18 @@ layers_merge_down_cmd_callback (GtkAction *action,
gimp_image_flush (image);
}
void
layers_merge_group_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GimpLayer *layer;
return_if_no_layer (image, layer, data);
gimp_image_merge_group_layer (image, GIMP_GROUP_LAYER (layer));
gimp_image_flush (image);
}
void
layers_delete_cmd_callback (GtkAction *action,
gpointer data)

2
app/actions/layers-commands.h
View File

@ -53,6 +53,8 @@ void layers_anchor_cmd_callback (GtkAction *action,
gpointer data);
void layers_merge_down_cmd_callback (GtkAction *action,
gpointer data);
void layers_merge_group_cmd_callback (GtkAction *action,
gpointer data);
void layers_delete_cmd_callback (GtkAction *action,
gpointer data);
void layers_text_discard_cmd_callback (GtkAction *action,

148
app/actions/windows-actions.c
View File

@ -25,6 +25,9 @@
#include "actions-types.h"
#include "config/gimpdisplayconfig.h"
#include "config/gimpguiconfig.h"
#include "core/gimp.h"
#include "core/gimpimage.h"
#include "core/gimplist.h"
@ -47,32 +50,33 @@
#include "gimp-intl.h"
static void windows_actions_display_add (GimpContainer *container,
GimpDisplay *display,
GimpActionGroup *group);
static void windows_actions_display_remove (GimpContainer *container,
GimpDisplay *display,
GimpActionGroup *group);
static void windows_actions_image_notify (GimpDisplay *display,
const GParamSpec *unused,
GimpActionGroup *group);
static void windows_actions_dock_added (GimpDialogFactory *factory,
GimpDock *dock,
GimpActionGroup *group);
static void windows_actions_dock_removed (GimpDialogFactory *factory,
GimpDock *dock,
GimpActionGroup *group);
static void windows_actions_dock_notify (GimpDock *dock,
const GParamSpec *pspec,
GimpActionGroup *group);
static void windows_actions_recent_add (GimpContainer *container,
GimpSessionInfo *info,
GimpActionGroup *group);
static void windows_actions_recent_remove (GimpContainer *container,
GimpSessionInfo *info,
GimpActionGroup *group);
static void windows_actions_display_add (GimpContainer *container,
GimpDisplay *display,
GimpActionGroup *group);
static void windows_actions_display_remove (GimpContainer *container,
GimpDisplay *display,
GimpActionGroup *group);
static void windows_actions_image_notify (GimpDisplay *display,
const GParamSpec *unused,
GimpActionGroup *group);
static void windows_actions_dock_window_added (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpActionGroup *group);
static void windows_actions_dock_window_removed (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpActionGroup *group);
static void windows_actions_dock_window_notify (GimpDockWindow *dock,
const GParamSpec *pspec,
GimpActionGroup *group);
static void windows_actions_recent_add (GimpContainer *container,
GimpSessionInfo *info,
GimpActionGroup *group);
static void windows_actions_recent_remove (GimpContainer *container,
GimpSessionInfo *info,
GimpActionGroup *group);
static void windows_actions_single_window_mode_notify (GimpDisplayConfig *config,
GParamSpec *pspec,
GimpActionGroup *group);
static const GimpActionEntry windows_actions[] =
@ -91,6 +95,16 @@ static const GimpActionEntry windows_actions[] =
GIMP_HELP_TOOLBOX }
};
static const GimpToggleActionEntry windows_toggle_actions[] =
{
{ "windows-use-single-window-mode", NULL,
NC_("windows-action", "Single-window mode"), NULL,
NC_("windows-action", "When enabled GIMP is in a single-window mode. Far from completely implemented!"),
G_CALLBACK (windows_use_single_window_mode_cmd_callback),
FALSE,
GIMP_HELP_WINDOWS_USE_SINGLE_WINDOW_MODE }
};
void
windows_actions_setup (GimpActionGroup *group)
@ -101,6 +115,10 @@ windows_actions_setup (GimpActionGroup *group)
windows_actions,
G_N_ELEMENTS (windows_actions));
gimp_action_group_add_toggle_actions (group, "windows-action",
windows_toggle_actions,
G_N_ELEMENTS (windows_toggle_actions));
gimp_action_group_set_action_hide_empty (group, "windows-docks-menu", FALSE);
g_signal_connect_object (group->gimp->displays, "add",
@ -119,21 +137,21 @@ windows_actions_setup (GimpActionGroup *group)
windows_actions_display_add (group->gimp->displays, display, group);
}
g_signal_connect_object (global_dock_factory, "dock-added",
G_CALLBACK (windows_actions_dock_added),
g_signal_connect_object (global_dock_factory, "dock-window-added",
G_CALLBACK (windows_actions_dock_window_added),
group, 0);
g_signal_connect_object (global_dock_factory, "dock-removed",
G_CALLBACK (windows_actions_dock_removed),
g_signal_connect_object (global_dock_factory, "dock-window-removed",
G_CALLBACK (windows_actions_dock_window_removed),
group, 0);
for (list = global_dock_factory->open_dialogs;
list;
list = g_list_next (list))
{
GimpDock *dock = list->data;
GimpDockWindow *dock_window = list->data;
if (GIMP_IS_DOCK (dock))
windows_actions_dock_added (global_dock_factory, dock, group);
if (GIMP_IS_DOCK_WINDOW (dock_window))
windows_actions_dock_window_added (global_dock_factory, dock_window, group);
}
g_signal_connect_object (global_recent_docks, "add",
@ -151,19 +169,29 @@ windows_actions_setup (GimpActionGroup *group)
windows_actions_recent_add (global_recent_docks, info, group);
}
g_signal_connect_object (group->gimp->config, "notify::single-window-mode",
G_CALLBACK (windows_actions_single_window_mode_notify),
group, 0);
}
void
windows_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpGuiConfig *config = GIMP_GUI_CONFIG (group->gimp->config);
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
SET_ACTIVE ("windows-use-single-window-mode", config->single_window_mode);
#undef SET_ACTIVE
}
gchar *
windows_actions_dock_to_action_name (GimpDock *dock)
windows_actions_dock_window_to_action_name (GimpDockWindow *dock_window)
{
GimpDockWindow *dock_window = gimp_dock_window_from_dock (dock);
return g_strdup_printf ("windows-dock-%04d",
gimp_dock_window_get_id (dock_window));
}
@ -275,13 +303,13 @@ windows_actions_image_notify (GimpDisplay *display,
}
static void
windows_actions_dock_added (GimpDialogFactory *factory,
GimpDock *dock,
GimpActionGroup *group)
windows_actions_dock_window_added (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpActionGroup *group)
{
GtkAction *action;
GimpActionEntry entry;
gchar *action_name = windows_actions_dock_to_action_name (dock);
gchar *action_name = windows_actions_dock_window_to_action_name (dock_window);
entry.name = action_name;
entry.stock_id = NULL;
@ -300,25 +328,25 @@ windows_actions_dock_added (GimpDialogFactory *factory,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL);
g_object_set_data (G_OBJECT (action), "dock", dock);
g_object_set_data (G_OBJECT (action), "dock-window", dock_window);
g_free (action_name);
g_signal_connect_object (dock, "notify::title",
G_CALLBACK (windows_actions_dock_notify),
g_signal_connect_object (dock_window, "notify::title",
G_CALLBACK (windows_actions_dock_window_notify),
group, 0);
if (gtk_window_get_title (GTK_WINDOW (dock)))
windows_actions_dock_notify (dock, NULL, group);
if (gtk_window_get_title (GTK_WINDOW (dock_window)))
windows_actions_dock_window_notify (dock_window, NULL, group);
}
static void
windows_actions_dock_removed (GimpDialogFactory *factory,
GimpDock *dock,
GimpActionGroup *group)
windows_actions_dock_window_removed (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpActionGroup *group)
{
GtkAction *action;
gchar *action_name = windows_actions_dock_to_action_name (dock);
gchar *action_name = windows_actions_dock_window_to_action_name (dock_window);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name);
@ -329,21 +357,21 @@ windows_actions_dock_removed (GimpDialogFactory *factory,
}
static void
windows_actions_dock_notify (GimpDock *dock,
const GParamSpec *pspec,
GimpActionGroup *group)
windows_actions_dock_window_notify (GimpDockWindow *dock_window,
const GParamSpec *pspec,
GimpActionGroup *group)
{
GtkAction *action;
gchar *action_name;
action_name = windows_actions_dock_to_action_name (dock);
action_name = windows_actions_dock_window_to_action_name (dock_window);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name);
g_free (action_name);
if (action)
g_object_set (action,
"label", gtk_window_get_title (GTK_WINDOW (dock)),
"tooltip", gtk_window_get_title (GTK_WINDOW (dock)),
"label", gtk_window_get_title (GTK_WINDOW (dock_window)),
"tooltip", gtk_window_get_title (GTK_WINDOW (dock_window)),
NULL);
}
@ -415,3 +443,13 @@ windows_actions_recent_remove (GimpContainer *container,
g_free (action_name);
}
static void
windows_actions_single_window_mode_notify (GimpDisplayConfig *config,
GParamSpec *pspec,
GimpActionGroup *group)
{
gimp_action_group_set_action_active (group,
"windows-use-single-window-mode",
GIMP_GUI_CONFIG (config)->single_window_mode);
}

8
app/actions/windows-actions.h
View File

@ -19,10 +19,10 @@
#define __WINDOWS_ACTIONS_H__
void windows_actions_setup (GimpActionGroup *group);
void windows_actions_update (GimpActionGroup *group,
gpointer data);
gchar * windows_actions_dock_to_action_name (GimpDock *dock);
void windows_actions_setup (GimpActionGroup *group);
void windows_actions_update (GimpActionGroup *group,
gpointer data);
gchar * windows_actions_dock_window_to_action_name (GimpDockWindow *dock_window);
#endif /* __WINDOWS_ACTIONS_H__ */

26
app/actions/windows-commands.c
View File

@ -23,15 +23,21 @@
#include "actions-types.h"
#include "config/gimpdisplayconfig.h"
#include "config/gimpguiconfig.h"
#include "core/gimp.h"
#include "core/gimpcontainer.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpsessioninfo.h"
#include "display/gimpdisplay.h"
#include "display/gimpdisplayshell.h"
#include "dialogs/dialogs.h"
#include "actions.h"
#include "windows-commands.h"
@ -44,6 +50,22 @@ windows_show_toolbox_cmd_callback (GtkAction *action,
windows_show_toolbox ();
}
void
windows_use_single_window_mode_cmd_callback (GtkAction *action,
gpointer data)
{
gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
Gimp *gimp = NULL;
return_if_no_gimp (gimp, data);
if (GIMP_GUI_CONFIG (gimp->config)->single_window_mode == active)
return;
g_object_set (gimp->config,
"single-window-mode", active,
NULL);
}
void
windows_show_display_cmd_callback (GtkAction *action,
gpointer data)
@ -57,9 +79,9 @@ void
windows_show_dock_cmd_callback (GtkAction *action,
gpointer data)
{
GtkWindow *dock = g_object_get_data (G_OBJECT (action), "dock");
GtkWindow *dock_window = g_object_get_data (G_OBJECT (action), "dock-window");
gtk_window_present (dock);
gtk_window_present (dock_window);
}
void

21
app/actions/windows-commands.h
View File

@ -19,16 +19,17 @@
#define __WINDOWS_COMMANDS_H__
void windows_show_toolbox_cmd_callback (GtkAction *action,
gpointer data);
void windows_show_display_cmd_callback (GtkAction *action,
gpointer data);
void windows_show_dock_cmd_callback (GtkAction *action,
gpointer data);
void windows_open_recent_cmd_callback (GtkAction *action,
gpointer data);
void windows_show_toolbox (void);
void windows_show_toolbox_cmd_callback (GtkAction *action,
gpointer data);
void windows_use_single_window_mode_cmd_callback (GtkAction *action,
gpointer data);
void windows_show_display_cmd_callback (GtkAction *action,
gpointer data);
void windows_show_dock_cmd_callback (GtkAction *action,
gpointer data);
void windows_open_recent_cmd_callback (GtkAction *action,
gpointer data);
void windows_show_toolbox (void);
#endif /* __WINDOWS_COMMANDS_H__ */

12
app/config/gimpguiconfig.c
View File

@ -52,6 +52,7 @@ enum
PROP_RESTORE_SESSION,
PROP_SAVE_TOOL_OPTIONS,
PROP_SHOW_TOOLTIPS,
PROP_SINGLE_WINDOW_MODE,
PROP_TEAROFF_MENUS,
PROP_CAN_CHANGE_ACCELS,
PROP_SAVE_ACCELS,
@ -153,6 +154,11 @@ gimp_gui_config_class_init (GimpGuiConfigClass *klass)
TRUE,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_RESTART);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SINGLE_WINDOW_MODE,
"single-window-mode", SINGLE_WINDOW_MODE_BLURB,
FALSE,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_RESTART);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_TEAROFF_MENUS,
"tearoff-menus", TEAROFF_MENUS_BLURB,
TRUE,
@ -347,6 +353,9 @@ gimp_gui_config_set_property (GObject *object,
case PROP_SHOW_TOOLTIPS:
gui_config->show_tooltips = g_value_get_boolean (value);
break;
case PROP_SINGLE_WINDOW_MODE:
gui_config->single_window_mode = g_value_get_boolean (value);
break;
case PROP_TEAROFF_MENUS:
gui_config->tearoff_menus = g_value_get_boolean (value);
break;
@ -465,6 +474,9 @@ gimp_gui_config_get_property (GObject *object,
case PROP_SHOW_TOOLTIPS:
g_value_set_boolean (value, gui_config->show_tooltips);
break;
case PROP_SINGLE_WINDOW_MODE:
g_value_set_boolean (value, gui_config->single_window_mode);
break;
case PROP_TEAROFF_MENUS:
g_value_set_boolean (value, gui_config->tearoff_menus);
break;

1
app/config/gimpguiconfig.h
View File

@ -48,6 +48,7 @@ struct _GimpGuiConfig
gboolean restore_session;
gboolean save_tool_options;
gboolean show_tooltips;
gboolean single_window_mode;
gboolean tearoff_menus;
gboolean can_change_accels;
gboolean save_accels;

3
app/config/gimprc-blurbs.h
View File

@ -343,6 +343,9 @@ N_("When enabled, the sample points are visible by default. This can also be " \
#define SHOW_TOOLTIPS_BLURB \
N_("Show a tooltip when the pointer hovers over an item.")
#define SINGLE_WINDOW_MODE_BLURB \
N_("Use GIMP in a single-window mode.")
#define SPACE_BAR_ACTION_BLURB \
N_("What to do when the space bar is pressed in the image window.")

13
app/core/gimpgrouplayer.c
View File

@ -326,7 +326,7 @@ gimp_group_layer_duplicate (GimpItem *item,
{
GimpItem *new_item;
g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_GROUP_LAYER), NULL);
g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_DRAWABLE), NULL);
new_item = GIMP_ITEM_CLASS (parent_class)->duplicate (item, new_type);
@ -337,6 +337,8 @@ gimp_group_layer_duplicate (GimpItem *item,
gint position = 0;
GList *list;
gimp_group_layer_suspend_resize (new_group, FALSE);
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (group->children));
list;
list = g_list_next (list))
@ -369,6 +371,13 @@ gimp_group_layer_duplicate (GimpItem *item,
GIMP_OBJECT (new_child),
position++);
}
/* FIXME: need to change the item's extents to resume_resize()
* will actually reallocate the projection's pyramid
*/
GIMP_ITEM (new_group)->width++;
gimp_group_layer_resume_resize (new_group, FALSE);
}
return new_item;
@ -1002,7 +1011,7 @@ gimp_group_layer_update_size (GimpGroupLayer *group)
{
gimp_item_set_offset (item, x, y);
/* invalidate the entire projection since the poition of
/* invalidate the entire projection since the position of
* the children relative to each other might have changed
* in a way that happens to leave the group's width and
* height the same

117
app/core/gimpimage-merge.c
View File

@ -34,14 +34,14 @@
#include "vectors/gimpvectors.h"
#include "gimp.h"
#include "gimpcontainer.h"
#include "gimpcontext.h"
#include "gimperror.h"
#include "gimpgrouplayer.h"
#include "gimpimage.h"
#include "gimpimage-colorhash.h"
#include "gimpimage-merge.h"
#include "gimpimage-undo.h"
#include "gimplayer.h"
#include "gimpitemstack.h"
#include "gimplayer-floating-sel.h"
#include "gimplayermask.h"
#include "gimpmarshal.h"
@ -66,19 +66,28 @@ gimp_image_merge_visible_layers (GimpImage *image,
GimpMergeType merge_type,
gboolean discard_invisible)
{
GList *list;
GSList *merge_list = NULL;
GSList *invisible_list = NULL;
GimpLayer *layer = NULL;
GimpLayer *active_layer;
GimpContainer *container;
GList *list;
GSList *merge_list = NULL;
GSList *invisible_list = NULL;
GimpLayer *layer = NULL;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
active_layer = gimp_image_get_active_layer (image);
if (active_layer)
container = gimp_item_get_container (GIMP_ITEM (active_layer));
else
container = gimp_image_get_layers (image);
/* if there's a floating selection, anchor it */
if (gimp_image_get_floating_selection (image))
floating_sel_anchor (gimp_image_get_floating_selection (image));
for (list = gimp_image_get_layer_iter (image);
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (container));
list;
list = g_list_next (list))
{
@ -108,7 +117,7 @@ gimp_image_merge_visible_layers (GimpImage *image,
}
layer = gimp_image_merge_layers (image,
gimp_image_get_layers (image),
container,
merge_list, context, merge_type,
_("Merge Visible Layers"));
g_slist_free (merge_list);
@ -121,6 +130,7 @@ gimp_image_merge_visible_layers (GimpImage *image,
gimp_image_remove_layer (image, list->data, TRUE, NULL);
gimp_image_undo_group_end (image);
g_slist_free (invisible_list);
}
@ -191,13 +201,6 @@ gimp_image_merge_down (GimpImage *image,
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (gimp_viewable_get_children (GIMP_VIEWABLE (current_layer)))
{
g_set_error_literal (error, 0, 0,
_("Cannot merge down a layer group."));
return NULL;
}
for (list = gimp_item_get_container_iter (GIMP_ITEM (current_layer));
list;
list = g_list_next (list))
@ -257,19 +260,48 @@ gimp_image_merge_down (GimpImage *image,
return layer;
}
GimpLayer *
gimp_image_merge_group_layer (GimpImage *image,
GimpGroupLayer *group)
{
GimpLayer *parent;
GimpLayer *layer;
gint index;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_GROUP_LAYER (group), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (group)), NULL);
g_return_val_if_fail (gimp_item_get_image (GIMP_ITEM (group)) == image, NULL);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE,
_("Merge Layer Group"));
parent = GIMP_LAYER (gimp_viewable_get_parent (GIMP_VIEWABLE (group)));
index = gimp_item_get_index (GIMP_ITEM (group));
layer = GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (group),
GIMP_TYPE_LAYER));
gimp_object_set_name (GIMP_OBJECT (layer), gimp_object_get_name (group));
gimp_image_remove_layer (image, GIMP_LAYER (group), TRUE, NULL);
gimp_image_add_layer (image, layer, parent, index, TRUE);
gimp_image_undo_group_end (image);
return layer;
}
/* merging vectors */
GimpVectors *
gimp_image_merge_visible_vectors (GimpImage *image,
GError **error)
{
GList *list = NULL;
GSList *merge_list = NULL;
GSList *cur_item = NULL;
GimpVectors *vectors = NULL;
GimpVectors *target_vectors = NULL;
gchar *name = NULL;
gint pos = 0;
GList *list;
GList *merge_list = NULL;
GimpVectors *vectors;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
@ -281,38 +313,44 @@ gimp_image_merge_visible_vectors (GimpImage *image,
vectors = list->data;
if (gimp_item_get_visible (GIMP_ITEM (vectors)))
merge_list = g_slist_append (merge_list, vectors);
merge_list = g_list_prepend (merge_list, vectors);
}
merge_list = g_list_reverse (merge_list);
if (merge_list && merge_list->next)
{
GimpVectors *target_vectors;
gchar *name;
gint pos;
gimp_set_busy (image->gimp);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE,
_("Merge Visible Paths"));
cur_item = merge_list;
vectors = GIMP_VECTORS (cur_item->data);
vectors = GIMP_VECTORS (merge_list->data);
name = g_strdup (gimp_object_get_name (vectors));
pos = gimp_item_get_index (GIMP_ITEM (vectors));
target_vectors = GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (vectors),
GIMP_TYPE_VECTORS));
pos = gimp_item_get_index (GIMP_ITEM (vectors));
gimp_image_remove_vectors (image, vectors, TRUE, NULL);
cur_item = cur_item->next;
while (cur_item)
for (list = g_list_next (merge_list);
list;
list = g_list_next (list))
{
vectors = GIMP_VECTORS (cur_item->data);
vectors = list->data;
gimp_vectors_add_strokes (vectors, target_vectors);
gimp_image_remove_vectors (image, vectors, TRUE, NULL);
cur_item = g_slist_next (cur_item);
}
gimp_object_take_name (GIMP_OBJECT (target_vectors), name);
g_slist_free (merge_list);
g_list_free (merge_list);
/* FIXME tree */
gimp_image_add_vectors (image, target_vectors, NULL, pos, TRUE);
@ -359,14 +397,10 @@ gimp_image_merge_layers (GimpImage *image,
GimpLayer *merge_layer;
GimpLayer *layer;
GimpLayer *bottom_layer;
GimpImageType type;
gint count;
gint x1, y1, x2, y2;
gint x3, y3, x4, y4;
CombinationMode operation;
gint position;
gboolean active[MAX_CHANNELS] = { TRUE, TRUE, TRUE, TRUE };
gint off_x, off_y;
gint position;
gchar *name;
GimpLayer *parent;
@ -374,7 +408,6 @@ gimp_image_merge_layers (GimpImage *image,
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
layer = NULL;
type = GIMP_RGBA_IMAGE;
x1 = y1 = 0;
x2 = y2 = 0;
bottom_layer = NULL;
@ -460,7 +493,8 @@ gimp_image_merge_layers (GimpImage *image,
if (merge_type == GIMP_FLATTEN_IMAGE ||
gimp_drawable_type (GIMP_DRAWABLE (layer)) == GIMP_INDEXED_IMAGE)
{
guchar bg[4] = { 0, 0, 0, 0 };
GimpImageType type;
guchar bg[4] = { 0, 0, 0, 0 };
type = GIMP_IMAGE_TYPE_FROM_BASE_TYPE (gimp_image_base_type (image));
@ -542,7 +576,10 @@ gimp_image_merge_layers (GimpImage *image,
while (reverse_list)
{
GimpLayerModeEffects mode;
CombinationMode operation;
GimpLayerModeEffects mode;
gint x3, y3, x4, y4;
gboolean active[MAX_CHANNELS] = { TRUE, TRUE, TRUE, TRUE };
layer = reverse_list->data;

4
app/core/gimpimage-merge.h
View File

@ -28,8 +28,12 @@ GimpLayer * gimp_image_merge_down (GimpImage *image,
GimpContext *context,
GimpMergeType merge_type,
GError **error);
GimpLayer * gimp_image_merge_group_layer (GimpImage *image,
GimpGroupLayer *group);
GimpLayer * gimp_image_flatten (GimpImage *image,
GimpContext *context);
GimpVectors * gimp_image_merge_visible_vectors (GimpImage *image,
GError **error);

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

@ -45,6 +45,7 @@
#include "widgets/gimpdevicestatus.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpdockable.h"
#include "widgets/gimpdockwindow.h"
#include "widgets/gimpdocumentview.h"
#include "widgets/gimperrorconsole.h"
#include "widgets/gimperrordialog.h"
@ -216,25 +217,55 @@ dialogs_quit_get (GimpDialogFactory *factory,
GtkWidget *
dialogs_toolbox_get (GimpDialogFactory *factory,
GimpContext *context,
gint view_size)
GimpUIManager *ui_manager)
{
/* we pass "global_dock_factory", _not_ "global_toolbox_factory" to
* the toolbox constructor, because the global_toolbox_factory has no
* dockables registered
*/
return gimp_toolbox_new (global_dock_factory, context);
return gimp_toolbox_new (global_dock_factory,
context,
ui_manager);
}
GtkWidget *
dialogs_toolbox_dock_window_new (GimpDialogFactory *factory,
GimpContext *context,
gint view_size)
{
return g_object_new (GIMP_TYPE_DOCK_WINDOW,
"role", "gimp-toolbox",
"ui-manager-name", "<Toolbox>",
"allow-dockbook-absence", TRUE,
"dialog-factory", factory,
"context", context,
NULL);
}
GtkWidget *
dialogs_dock_new (GimpDialogFactory *factory,
GimpContext *context,
gint view_size)
GimpUIManager *ui_manager)
{
return gimp_menu_dock_new (factory,
context->gimp->images,
context->gimp->displays);
}
GtkWidget *
dialogs_dock_window_new (GimpDialogFactory *factory,
GimpContext *context,
gint view_size)
{
return g_object_new (GIMP_TYPE_DOCK_WINDOW,
"role", "gimp-dock",
"ui-manager-name", "<Dock>",
"allow-dockbook-absence", FALSE,
"dialog-factory", factory,
"context", context,
NULL);
}
/***************/
/* dockables */

7
app/dialogs/dialogs-constructors.h
View File

@ -68,9 +68,16 @@ GtkWidget * dialogs_quit_get (GimpDialogFactory *factory,
/* docks */
GtkWidget * dialogs_toolbox_get (GimpDialogFactory *factory,
GimpContext *context,
GimpUIManager *ui_manager);
GtkWidget * dialogs_toolbox_dock_window_new
(GimpDialogFactory *factory,
GimpContext *context,
gint view_size);
GtkWidget * dialogs_dock_new (GimpDialogFactory *factory,
GimpContext *context,
GimpUIManager *ui_manager);
GtkWidget * dialogs_dock_window_new (GimpDialogFactory *factory,
GimpContext *context,
gint view_size);

19
app/dialogs/dialogs.c
View File

@ -50,11 +50,11 @@ GimpContainer *global_recent_docks = NULL;
#define FOREIGN(id, singleton, remember_size) \
{ id, NULL, NULL, NULL, NULL, \
NULL, 0, singleton, TRUE, remember_size, FALSE }
NULL, 0, singleton, TRUE, remember_size, FALSE, FALSE }
#define TOPLEVEL(id, new_func, singleton, session_managed, remember_size) \
{ id, NULL, NULL, NULL, NULL, \
new_func, 0, singleton, session_managed, remember_size, FALSE }
new_func, 0, singleton, session_managed, remember_size, FALSE, FALSE }
static const GimpDialogFactoryEntry toplevel_entries[] =
@ -123,14 +123,14 @@ static const GimpDialogFactoryEntry toplevel_entries[] =
#define DOCKABLE(id,name,blurb,stock_id,help_id,\
new_func,view_size,singleton) \
{ id, name, blurb, stock_id, help_id, \
new_func, view_size, singleton, FALSE, FALSE, TRUE }
new_func, view_size, singleton, FALSE, FALSE, TRUE, TRUE }
#define LISTGRID(id,name,blurb,stock_id,help_id,\
view_size) \
{ "gimp-"#id"-list", name, blurb, stock_id, help_id, \
dialogs_##id##_list_view_new, view_size, FALSE, FALSE, FALSE, TRUE }, \
dialogs_##id##_list_view_new, view_size, FALSE, FALSE, FALSE, TRUE, TRUE }, \
{ "gimp-"#id"-grid", name, blurb, stock_id, help_id, \
dialogs_##id##_grid_view_new, view_size, FALSE, FALSE, FALSE, TRUE }
dialogs_##id##_grid_view_new, view_size, FALSE, FALSE, FALSE, TRUE, TRUE }
static const GimpDialogFactoryEntry dock_entries[] =
{
@ -249,12 +249,14 @@ dialogs_init (Gimp *gimp,
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
/* Toplevel */
global_dialog_factory = gimp_dialog_factory_new ("toplevel",
gimp_get_user_context (gimp),
menu_factory,
NULL,
TRUE);
/* Toolbox */
global_toolbox_factory = gimp_dialog_factory_new ("toolbox",
gimp_get_user_context (gimp),
menu_factory,
@ -262,7 +264,10 @@ dialogs_init (Gimp *gimp,
TRUE);
gimp_dialog_factory_set_constructor (global_toolbox_factory,
dialogs_dockable_constructor);
gimp_dialog_factory_set_dock_window_func (global_toolbox_factory,
dialogs_toolbox_dock_window_new);
/* Dock */
global_dock_factory = gimp_dialog_factory_new ("dock",
gimp_get_user_context (gimp),
menu_factory,
@ -270,13 +275,17 @@ dialogs_init (Gimp *gimp,
TRUE);
gimp_dialog_factory_set_constructor (global_dock_factory,
dialogs_dockable_constructor);
gimp_dialog_factory_set_dock_window_func (global_dock_factory,
dialogs_dock_window_new);
/* Display */
global_display_factory = gimp_dialog_factory_new ("display",
gimp_get_user_context (gimp),
menu_factory,
NULL,
FALSE);
for (i = 0; i < G_N_ELEMENTS (toplevel_entries); i++)
gimp_dialog_factory_register_entry (global_dialog_factory,
toplevel_entries[i].identifier,

6
app/dialogs/resize-dialog.c
View File

@ -174,7 +174,7 @@ resize_dialog_new (GimpViewable *viewable,
"unit", unit,
"xresolution", xres,
"yresolution", yres,
"keep-aspect", TRUE,
"keep-aspect", FALSE,
"edit-resolution", FALSE,
NULL);
@ -363,10 +363,6 @@ resize_dialog_reset (ResizeDialog *private)
"height", private->old_height,
"unit", private->old_unit,
NULL);
g_object_set (private->box,
"keep-aspect", TRUE,
NULL);
}
static void

8
app/display/gimpdisplayshell-cursor.c
View File

@ -165,11 +165,11 @@ gimp_display_shell_update_cursor (GimpDisplayShell *shell,
factory = gimp_dialog_factory_from_name ("dock");
session_info = gimp_dialog_factory_find_session_info (factory,
"gimp-cursor-view");
if (session_info && session_info->widget)
if (session_info && gimp_session_info_get_widget (session_info))
{
GtkWidget *cursor_view;
cursor_view = gtk_bin_get_child (GTK_BIN (session_info->widget));
cursor_view = gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (session_info)));
if (cursor_view)
{
@ -201,11 +201,11 @@ gimp_display_shell_clear_cursor (GimpDisplayShell *shell)
factory = gimp_dialog_factory_from_name ("dock");
session_info = gimp_dialog_factory_find_session_info (factory,
"gimp-cursor-view");
if (session_info && session_info->widget)
if (session_info && gimp_session_info_get_widget (session_info))
{
GtkWidget *cursor_view;
cursor_view = gtk_bin_get_child (GTK_BIN (session_info->widget));
cursor_view = gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (session_info)));
if (cursor_view)
gimp_cursor_view_clear_cursor (GIMP_CURSOR_VIEW (cursor_view));

4
app/display/gimpdisplayshell.c
View File

@ -1428,8 +1428,8 @@ gimp_display_shell_empty (GimpDisplayShell *shell)
if (session_info)
{
width = session_info->width;
height = session_info->height;
width = gimp_session_info_get_width (session_info);
height = gimp_session_info_get_height (session_info);
}
else
{

4
app/gui/gui-message.c
View File

@ -105,8 +105,8 @@ gui_message_error_console (GimpMessageSeverity severity,
info = gimp_dialog_factory_find_session_info (global_dock_factory,
"gimp-error-console");
if (info && GIMP_IS_DOCKABLE (info->widget))
dockable = info->widget;
if (info && GIMP_IS_DOCKABLE (gimp_session_info_get_widget (info)))
dockable = gimp_session_info_get_widget (info);
}
if (! dockable)

4
app/gui/gui.c
View File

@ -675,11 +675,11 @@ gui_device_change_notify (Gimp *gimp)
session_info = gimp_dialog_factory_find_session_info (global_dock_factory,
"gimp-device-status");
if (session_info && session_info->widget)
if (session_info && gimp_session_info_get_widget (session_info))
{
GtkWidget *device_status;
device_status = gtk_bin_get_child (GTK_BIN (session_info->widget));
device_status = gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (session_info)));
gimp_device_status_update (GIMP_DEVICE_STATUS (device_status));
}

32
app/gui/session.c
View File

@ -50,6 +50,7 @@
#include "dialogs/dialogs.h"
#include "session.h"
#include "gimp-log.h"
#include "gimp-intl.h"
@ -151,15 +152,22 @@ session_init (Gimp *gimp)
* entries and don't have any dialog factory entry, so
* don't bother looking for entires for them
*/
if (!g_str_equal (entry_name, "dock"))
if (strcmp (entry_name, "dock"))
{
info->toplevel_entry = gimp_dialog_factory_find_entry (factory,
entry_name);
/* If we expected a dialog factory entry but failed
* to find one, skip to add this session info object
*/
skip = (info->toplevel_entry == NULL);
GimpDialogFactoryEntry *entry =
gimp_dialog_factory_find_entry (factory,
entry_name);
if (entry)
{
gimp_session_info_set_factory_entry (info, entry);
}
else
{
/* If we expected a dialog factory entry but failed
* to find one, skip to add this session info object
*/
skip = TRUE;
}
}
g_free (entry_name);
@ -168,11 +176,19 @@ session_init (Gimp *gimp)
{
if (! skip)
{
GIMP_LOG (DIALOG_FACTORY,
"successfully parsed and added session info %p",
info);
factory->session_infos =
g_list_append (factory->session_infos, info);
}
else
{
GIMP_LOG (DIALOG_FACTORY,
"failed to parse session info %p, not adding",
info);
g_object_unref (info);
}
}

92
app/menus/windows-menu.c
View File

@ -46,34 +46,34 @@
#include "windows-menu.h"
static void windows_menu_display_add (GimpContainer *container,
GimpDisplay *display,
GimpUIManager *manager);
static void windows_menu_display_remove (GimpContainer *container,
GimpDisplay *display,
GimpUIManager *manager);
static void windows_menu_image_notify (GimpDisplay *display,
const GParamSpec *unused,
GimpUIManager *manager);
static void windows_menu_dock_added (GimpDialogFactory *factory,
GimpDock *dock,
GimpUIManager *manager);
static void windows_menu_dock_removed (GimpDialogFactory *factory,
GimpDock *dock,
GimpUIManager *manager);
static gchar * windows_menu_dock_to_merge_id (GimpDock *dock);
static void windows_menu_recent_add (GimpContainer *container,
GimpSessionInfo *info,
GimpUIManager *manager);
static void windows_menu_recent_remove (GimpContainer *container,
GimpSessionInfo *info,
GimpUIManager *manager);
static gboolean windows_menu_display_query_tooltip (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
GimpAction *action);
static void windows_menu_display_add (GimpContainer *container,
GimpDisplay *display,
GimpUIManager *manager);
static void windows_menu_display_remove (GimpContainer *container,
GimpDisplay *display,
GimpUIManager *manager);
static void windows_menu_image_notify (GimpDisplay *display,
const GParamSpec *unused,
GimpUIManager *manager);
static void windows_menu_dock_window_added (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpUIManager *manager);
static void windows_menu_dock_window_removed (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpUIManager *manager);
static gchar * windows_menu_dock_window_to_merge_id (GimpDockWindow *dock_window);
static void windows_menu_recent_add (GimpContainer *container,
GimpSessionInfo *info,
GimpUIManager *manager);
static void windows_menu_recent_remove (GimpContainer *container,
GimpSessionInfo *info,
GimpUIManager *manager);
static gboolean windows_menu_display_query_tooltip (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
GimpAction *action);
void
@ -104,21 +104,21 @@ windows_menu_setup (GimpUIManager *manager,
windows_menu_display_add (manager->gimp->displays, display, manager);
}
g_signal_connect_object (global_dock_factory, "dock-added",
G_CALLBACK (windows_menu_dock_added),
g_signal_connect_object (global_dock_factory, "dock-window-added",
G_CALLBACK (windows_menu_dock_window_added),
manager, 0);
g_signal_connect_object (global_dock_factory, "dock-removed",
G_CALLBACK (windows_menu_dock_removed),
g_signal_connect_object (global_dock_factory, "dock-window-removed",
G_CALLBACK (windows_menu_dock_window_removed),
manager, 0);
for (list = global_dock_factory->open_dialogs;
list;
list = g_list_next (list))
{
GimpDock *dock = list->data;
GimpDockWindow *dock_window = list->data;
if (GIMP_IS_DOCK (dock))
windows_menu_dock_added (global_dock_factory, dock, manager);
if (GIMP_IS_DOCK_WINDOW (dock_window))
windows_menu_dock_window_added (global_dock_factory, dock_window, manager);
}
g_signal_connect_object (global_recent_docks, "add",
@ -244,9 +244,9 @@ windows_menu_image_notify (GimpDisplay *display,
}
static void
windows_menu_dock_added (GimpDialogFactory *factory,
GimpDock *dock,
GimpUIManager *manager)
windows_menu_dock_window_added (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpUIManager *manager)
{
const gchar *ui_path;
gchar *action_name;
@ -256,11 +256,11 @@ windows_menu_dock_added (GimpDialogFactory *factory,
ui_path = g_object_get_data (G_OBJECT (manager), "image-menu-ui-path");
action_name = windows_actions_dock_to_action_name (dock);
action_name = windows_actions_dock_window_to_action_name (dock_window);
action_path = g_strdup_printf ("%s/Windows/Docks",
ui_path);
merge_key = windows_menu_dock_to_merge_id (dock);
merge_key = windows_menu_dock_window_to_merge_id (dock_window);
merge_id = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager));
g_object_set_data (G_OBJECT (manager), merge_key,
@ -277,11 +277,11 @@ windows_menu_dock_added (GimpDialogFactory *factory,
}
static void
windows_menu_dock_removed (GimpDialogFactory *factory,
GimpDock *dock,
GimpUIManager *manager)
windows_menu_dock_window_removed (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpUIManager *manager)
{
gchar *merge_key = windows_menu_dock_to_merge_id (dock);
gchar *merge_key = windows_menu_dock_window_to_merge_id (dock_window);
guint merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager),
merge_key));
if (merge_id)
@ -293,10 +293,8 @@ windows_menu_dock_removed (GimpDialogFactory *factory,
}
static gchar *
windows_menu_dock_to_merge_id (GimpDock *dock)
windows_menu_dock_window_to_merge_id (GimpDockWindow *dock_window)
{
GimpDockWindow *dock_window = gimp_dock_window_from_dock (dock);
return g_strdup_printf ("windows-dock-%04d-merge-id",
gimp_dock_window_get_id (dock_window));
}

23
app/tests/test-window-management.c
View File

@ -23,6 +23,8 @@
#include "dialogs/dialogs.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpdock.h"
#include "widgets/gimpdockwindow.h"
#include "core/gimp.h"
#include "core/gimpcontext.h"
@ -85,15 +87,22 @@ static void
gimp_test_window_roles (GimpTestFixture *fixture,
gconstpointer data)
{
GtkWidget *dock = gimp_dialog_factory_dock_new (global_dock_factory,
gdk_screen_get_default ());
GtkWidget *toolbox = gimp_dialog_factory_dock_new (global_toolbox_factory,
gdk_screen_get_default ());
GtkWidget *dock = NULL;
GtkWidget *toolbox = NULL;
GimpDockWindow *dock_window = NULL;
GimpDockWindow *toolbox_window = NULL;
g_assert_cmpstr (gtk_window_get_role (GTK_WINDOW (toolbox)), ==,
"gimp-toolbox");
g_assert_cmpstr (gtk_window_get_role (GTK_WINDOW (dock)), ==,
dock = gimp_dialog_factory_dock_new (global_dock_factory,
gdk_screen_get_default ());
toolbox = gimp_dialog_factory_dock_new (global_toolbox_factory,
gdk_screen_get_default ());
dock_window = gimp_dock_window_from_dock (GIMP_DOCK (dock));
toolbox_window = gimp_dock_window_from_dock (GIMP_DOCK (toolbox));
g_assert_cmpstr (gtk_window_get_role (GTK_WINDOW (dock_window)), ==,
"gimp-dock");
g_assert_cmpstr (gtk_window_get_role (GTK_WINDOW (toolbox_window)), ==,
"gimp-toolbox");
/* When we get here we have a ref count of one, but the signals we
* emit cause the reference count to become less than zero for some

8
app/tools/gimpcolortool.c
View File

@ -646,11 +646,11 @@ gimp_color_tool_real_picked (GimpColorTool *color_tool,
{
info = gimp_dialog_factory_find_session_info (dialog_factory,
"gimp-indexed-palette");
if (info && info->widget)
if (info && gimp_session_info_get_widget (info))
{
GimpColormapEditor *editor;
editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget)));
editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (info))));
gimp_colormap_editor_set_index (editor, color_index, NULL);
}
@ -660,12 +660,12 @@ gimp_color_tool_real_picked (GimpColorTool *color_tool,
{
info = gimp_dialog_factory_find_session_info (dialog_factory,
"gimp-palette-editor");
if (info && info->widget)
if (info && gimp_session_info_get_widget (info))
{
GimpPaletteEditor *editor;
gint index;
editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget)));
editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (info))));
index = gimp_palette_editor_get_index (editor, color);
if (index != -1)

3
app/widgets/Makefile.am
View File

@ -128,6 +128,8 @@ libappwidgets_a_sources = \
gimpdnd-xds.h \
gimpdock.c \
gimpdock.h \
gimpdockcolumns.c \
gimpdockcolumns.h \
gimpdockable.c \
gimpdockable.h \
gimpdockbook.c \
@ -259,6 +261,7 @@ libappwidgets_a_sources = \
gimpsessioninfo-dock.h \
gimpsessioninfo-dockable.c \
gimpsessioninfo-dockable.h \
gimpsessioninfo-private.h \
gimpsettingsbox.c \
gimpsettingsbox.h \
gimpsettingseditor.c \

311
app/widgets/gimpdialogfactory.c
View File

@ -38,6 +38,7 @@
#include "gimpdock.h"
#include "gimpdockbook.h"
#include "gimpdockable.h"
#include "gimpdockwindow.h"
#include "gimpmenufactory.h"
#include "gimpsessioninfo.h"
@ -53,8 +54,8 @@ typedef enum
enum
{
DOCK_ADDED,
DOCK_REMOVED,
DOCK_WINDOW_ADDED,
DOCK_WINDOW_REMOVED,
LAST_SIGNAL
};
@ -122,25 +123,25 @@ gimp_dialog_factory_class_init (GimpDialogFactoryClass *klass)
klass->factories = g_hash_table_new (g_str_hash, g_str_equal);
factory_signals[DOCK_ADDED] =
g_signal_new ("dock-added",
factory_signals[DOCK_WINDOW_ADDED] =
g_signal_new ("dock-window-added",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpDialogFactoryClass, dock_added),
G_STRUCT_OFFSET (GimpDialogFactoryClass, dock_window_added),
NULL, NULL,
gimp_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_DOCK);
GIMP_TYPE_DOCK_WINDOW);
factory_signals[DOCK_REMOVED] =
g_signal_new ("dock-removed",
factory_signals[DOCK_WINDOW_REMOVED] =
g_signal_new ("dock-window-removed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpDialogFactoryClass, dock_removed),
G_STRUCT_OFFSET (GimpDialogFactoryClass, dock_window_removed),
NULL, NULL,
gimp_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_DOCK);
GIMP_TYPE_DOCK_WINDOW);
}
static void
@ -241,11 +242,11 @@ gimp_dialog_factory_finalize (GObject *object)
}
GimpDialogFactory *
gimp_dialog_factory_new (const gchar *name,
GimpContext *context,
GimpMenuFactory *menu_factory,
GimpDialogNewFunc new_dock_func,
gboolean toggle_visibility)
gimp_dialog_factory_new (const gchar *name,
GimpContext *context,
GimpMenuFactory *menu_factory,
GimpDialogNewDockFunc new_dock_func,
gboolean toggle_visibility)
{
GimpDialogFactory *factory;
gpointer key;
@ -317,6 +318,16 @@ gimp_dialog_factory_set_constructor (GimpDialogFactory *factory,
factory->constructor = constructor;
}
void
gimp_dialog_factory_set_dock_window_func (GimpDialogFactory *factory,
GimpDialogNewFunc new_dock_window_func)
{
g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory));
g_return_if_fail (new_dock_window_func != NULL);
factory->new_dock_window_func = new_dock_window_func;
}
void
gimp_dialog_factory_register_entry (GimpDialogFactory *factory,
const gchar *identifier,
@ -387,10 +398,9 @@ gimp_dialog_factory_find_session_info (GimpDialogFactory *factory,
{
GimpSessionInfo *info = list->data;
if ((info->toplevel_entry &&
! strcmp (identifier, info->toplevel_entry->identifier)) ||
(info->dockable_entry &&
! strcmp (identifier, info->dockable_entry->identifier)))
if (gimp_session_info_get_factory_entry (info) &&
g_str_equal (identifier,
gimp_session_info_get_factory_entry (info)->identifier))
{
return info;
}
@ -399,6 +409,42 @@ gimp_dialog_factory_find_session_info (GimpDialogFactory *factory,
return NULL;
}
/**
* gimp_dialog_factory_dialog_sane:
* @factory:
* @widget_factory:
* @widget_entry:
* @widget:
*
* Makes sure that the @widget with the given @widget_entry that was
* created by the given @widget_factory belongs to @efactory.
*
* Returns: %TRUE if that is the case, %FALSE otherwise.
**/
static gboolean
gimp_dialog_factory_dialog_sane (GimpDialogFactory *factory,
GimpDialogFactory *widget_factory,
GimpDialogFactoryEntry *widget_entry,
GtkWidget *widget)
{
/* Note that GimpDockWindows don't have any entry */
if (! widget_factory || (! widget_entry && ! GIMP_IS_DOCK_WINDOW (widget)))
{
g_warning ("%s: dialog was not created by a GimpDialogFactory",
G_STRFUNC);
return FALSE;
}
if (widget_factory != factory)
{
g_warning ("%s: dialog was created by a different GimpDialogFactory",
G_STRFUNC);
return FALSE;
}
return TRUE;
}
static GtkWidget *
gimp_dialog_factory_dialog_new_internal (GimpDialogFactory *factory,
GdkScreen *screen,
@ -438,7 +484,7 @@ gimp_dialog_factory_dialog_new_internal (GimpDialogFactory *factory,
info = gimp_dialog_factory_find_session_info (factory, identifier);
if (info)
dialog = info->widget;
dialog = gimp_session_info_get_widget (info);
}
/* create the dialog if it was not found */
@ -648,7 +694,7 @@ gimp_dialog_factory_dialog_raise (GimpDialogFactory *factory,
GimpSessionInfo *info;
info = gimp_dialog_factory_find_session_info (factory, ids[i]);
if (info && info->widget)
if (info && gimp_session_info_get_widget (info))
break;
}
@ -728,21 +774,36 @@ GtkWidget *
gimp_dialog_factory_dock_new (GimpDialogFactory *factory,
GdkScreen *screen)
{
GtkWidget *dock;
GtkWidget *dock_window = NULL;
GtkWidget *dock = NULL;
GimpUIManager *ui_manager = NULL;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL);
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
g_return_val_if_fail (factory->new_dock_func != NULL, NULL);
dock = factory->new_dock_func (factory, factory->context, 0);
/* Create a dock window to put the dock in. We need to create the
* dock window before the dock because the dock has a dependnecy to
* the ui manager in the dock window
*/
dock_window = factory->new_dock_window_func (factory,
factory->context,
0);
gtk_window_set_screen (GTK_WINDOW (dock_window), screen);
gimp_dialog_factory_set_widget_data (dock_window, factory, NULL);
/* Create the dock */
ui_manager = gimp_dock_window_get_ui_manager (GIMP_DOCK_WINDOW (dock_window));
dock = factory->new_dock_func (factory, factory->context, ui_manager);
if (dock)
{
gtk_window_set_screen (GTK_WINDOW (dock), screen);
/* Put the dock in the dock window */
gimp_dock_window_set_dock (GIMP_DOCK_WINDOW (dock_window),
GIMP_DOCK (dock));
gimp_dialog_factory_set_widget_data (dock, factory, NULL);
gimp_dialog_factory_add_dialog (factory, dock);
/* Add the dock window to the dialog factory */
gimp_dialog_factory_add_dialog (factory, dock_window);
}
return dock;
@ -752,10 +813,11 @@ void
gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
GtkWidget *dialog)
{
GimpDialogFactory *dialog_factory;
GimpDialogFactoryEntry *entry;
GList *list;
gboolean toplevel;
GimpDialogFactory *dialog_factory = NULL;
GimpDialogFactoryEntry *entry = NULL;
GimpSessionInfo *info = NULL;
GList *list = NULL;
gboolean toplevel = FALSE;
g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory));
g_return_if_fail (GTK_IS_WIDGET (dialog));
@ -768,23 +830,15 @@ gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
dialog_factory = gimp_dialog_factory_from_widget (dialog, &entry);
if (! (dialog_factory && (entry || GIMP_IS_DOCK (dialog))))
{
g_warning ("%s: dialog was not created by a GimpDialogFactory",
G_STRFUNC);
return;
}
if (dialog_factory != factory)
{
g_warning ("%s: dialog was created by a different GimpDialogFactory",
G_STRFUNC);
return;
}
if (! gimp_dialog_factory_dialog_sane (factory,
dialog_factory,
entry,
dialog))
return;
toplevel = GTK_WIDGET_TOPLEVEL (dialog);
if (entry) /* dialog is a toplevel (but not a GimpDock) or a GimpDockable */
if (entry) /* dialog is a toplevel (but not a GimpDockWindow) or a GimpDockable */
{
GIMP_LOG (DIALOG_FACTORY, "adding %s \"%s\"",
toplevel ? "toplevel" : "dockable",
@ -792,21 +846,21 @@ gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
for (list = factory->session_infos; list; list = g_list_next (list))
{
GimpSessionInfo *info = list->data;
GimpSessionInfo *current_info = list->data;
if ((info->toplevel_entry == entry) ||
(info->dockable_entry == entry))
if (gimp_session_info_get_factory_entry (current_info) == entry)
{
if (info->widget)
if (gimp_session_info_get_widget (current_info))
{
if (entry->singleton)
if (gimp_session_info_is_singleton (current_info))
{
g_warning ("%s: singleton dialog \"%s\" created twice",
G_STRFUNC, entry->identifier);
GIMP_LOG (DIALOG_FACTORY,
"corrupt session info: %p (widget %p)",
info, info->widget);
current_info,
gimp_session_info_get_widget (current_info));
return;
}
@ -814,98 +868,94 @@ gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
continue;
}
info->widget = dialog;
gimp_session_info_set_widget (current_info, dialog);
GIMP_LOG (DIALOG_FACTORY,
"updating session info %p (widget %p) for %s \"%s\"",
info, info->widget,
current_info, gimp_session_info_get_widget (current_info),
toplevel ? "toplevel" : "dockable",
entry->identifier);
if (toplevel && entry->session_managed &&
if (toplevel &&
gimp_session_info_is_session_managed (current_info) &&
! GTK_WIDGET_VISIBLE (dialog))
{
gimp_session_info_set_geometry (info);
gimp_session_info_apply_geometry (current_info);
}
info = current_info;
break;
}
}
if (! list) /* didn't find a session info */
if (! info)
{
GimpSessionInfo *info = gimp_session_info_new ();
info = gimp_session_info_new ();
info->widget = dialog;
gimp_session_info_set_widget (info, dialog);
GIMP_LOG (DIALOG_FACTORY,
"creating session info %p (widget %p) for %s \"%s\"",
info, info->widget,
info, gimp_session_info_get_widget (info),
toplevel ? "toplevel" : "dockable",
entry->identifier);
if (toplevel)
{
info->toplevel_entry = entry;
gimp_session_info_set_factory_entry (info, entry);
/* if we create a new session info, we never call
* gimp_session_info_set_geometry(), but still the
* dialog needs GDK_HINT_USER_POS so it keeps its
* position when hidden/shown within this(!) session.
*/
if (entry->session_managed)
g_signal_connect (dialog, "configure-event",
G_CALLBACK (gimp_dialog_factory_set_user_pos),
NULL);
}
else
{
info->dockable_entry = entry;
}
/* if we create a new session info, we never call
* gimp_session_info_apply_geometry(), but still the
* dialog needs GDK_HINT_USER_POS so it keeps its
* position when hidden/shown within this(!) session.
*/
if (gimp_session_info_is_session_managed (info))
g_signal_connect (dialog, "configure-event",
G_CALLBACK (gimp_dialog_factory_set_user_pos),
NULL);
factory->session_infos = g_list_append (factory->session_infos, info);
}
}
else /* dialog is a GimpDock */
else /* dialog is a GimpDockWindow */
{
GIMP_LOG (DIALOG_FACTORY, "adding dock");
for (list = factory->session_infos; list; list = g_list_next (list))
{
GimpSessionInfo *info = list->data;
GimpSessionInfo *current_info = list->data;
/* take the first empty slot */
if (! info->toplevel_entry &&
! info->dockable_entry &&
! info->widget)
if (! gimp_session_info_get_factory_entry (current_info) &&
! gimp_session_info_get_widget (current_info))
{
info->widget = dialog;
gimp_session_info_set_widget (current_info, dialog);
GIMP_LOG (DIALOG_FACTORY,
"updating session info %p (widget %p) for dock",
info, info->widget);
current_info, gimp_session_info_get_widget (current_info));
gimp_session_info_set_geometry (info);
gimp_session_info_apply_geometry (current_info);
info = current_info;
break;
}
}
if (! list) /* didn't find a session info */
if (! info)
{
GimpSessionInfo *info = gimp_session_info_new ();
info = gimp_session_info_new ();
info->widget = dialog;
gimp_session_info_set_widget (info, dialog);
GIMP_LOG (DIALOG_FACTORY,
"creating session info %p (widget %p) for dock",
info, info->widget);
info, gimp_session_info_get_widget (info));
/* let new docks appear at the pointer position */
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
/* if we create a new session info, we never call
* gimp_session_info_set_geometry(), but still the
* gimp_session_info_apply_geometry(), but still the
* dialog needs GDK_HINT_USER_POS so it keeps its
* position when hidden/shown within this(!) session.
*/
@ -916,7 +966,7 @@ gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
factory->session_infos = g_list_append (factory->session_infos, info);
}
g_signal_emit (factory, factory_signals[DOCK_ADDED], 0, dialog);
g_signal_emit (factory, factory_signals[DOCK_WINDOW_ADDED], 0, dialog);
}
factory->open_dialogs = g_list_prepend (factory->open_dialogs, dialog);
@ -926,7 +976,7 @@ gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
factory,
G_CONNECT_SWAPPED);
if ((entry && entry->session_managed && toplevel) || GIMP_IS_DOCK (dialog))
if (gimp_session_info_is_session_managed (info))
g_signal_connect_object (dialog, "configure-event",
G_CALLBACK (gimp_dialog_factory_dialog_configure),
factory,
@ -997,19 +1047,11 @@ gimp_dialog_factory_remove_dialog (GimpDialogFactory *factory,
dialog_factory = gimp_dialog_factory_from_widget (dialog, &entry);
if (! (dialog_factory && (entry || GIMP_IS_DOCK (dialog))))
{
g_warning ("%s: dialog was not created by a GimpDialogFactory",
G_STRFUNC);
return;
}
if (dialog_factory != factory)
{
g_warning ("%s: dialog was created by a different GimpDialogFactory",
G_STRFUNC);
return;
}
if (! gimp_dialog_factory_dialog_sane (factory,
dialog_factory,
entry,
dialog))
return;
GIMP_LOG (DIALOG_FACTORY, "removing \"%s\"",
entry ? entry->identifier : "dock");
@ -1018,14 +1060,14 @@ gimp_dialog_factory_remove_dialog (GimpDialogFactory *factory,
{
GimpSessionInfo *session_info = list->data;
if (session_info->widget == dialog)
if (gimp_session_info_get_widget (session_info) == dialog)
{
GIMP_LOG (DIALOG_FACTORY,
"clearing session info %p (widget %p) for \"%s\"",
session_info, session_info->widget,
session_info, gimp_session_info_get_widget (session_info),
entry ? entry->identifier : "dock");
session_info->widget = NULL;
gimp_session_info_set_widget (session_info, NULL);
gimp_dialog_factory_unset_widget_data (dialog);
@ -1036,19 +1078,19 @@ gimp_dialog_factory_remove_dialog (GimpDialogFactory *factory,
gimp_dialog_factory_remove_dialog,
factory);
if (entry && entry->session_managed && GTK_WIDGET_TOPLEVEL (dialog))
if (gimp_session_info_is_session_managed (session_info))
g_signal_handlers_disconnect_by_func (dialog,
gimp_dialog_factory_dialog_configure,
factory);
if (GIMP_IS_DOCK (dialog))
if (GIMP_IS_DOCK_WINDOW (dialog))
{
/* don't save session info for empty docks */
factory->session_infos = g_list_remove (factory->session_infos,
session_info);
g_object_unref (session_info);
g_signal_emit (factory, factory_signals[DOCK_REMOVED], 0,
g_signal_emit (factory, factory_signals[DOCK_WINDOW_REMOVED], 0,
dialog);
}
@ -1351,34 +1393,28 @@ gimp_dialog_factory_dialog_configure (GtkWidget *dialog,
dialog_factory = gimp_dialog_factory_from_widget (dialog, &entry);
if (! dialog_factory || (! entry && ! GIMP_IS_DOCK (dialog)))
{
g_warning ("%s: dialog was not created by a GimpDialogFactory",
G_STRFUNC);
return FALSE;
}
if (dialog_factory != factory)
{
g_warning ("%s: dialog was created by a different GimpDialogFactory",
G_STRFUNC);
return FALSE;
}
if (! gimp_dialog_factory_dialog_sane (factory,
dialog_factory,
entry,
dialog))
return FALSE;
for (list = factory->session_infos; list; list = g_list_next (list))
{
GimpSessionInfo *session_info = list->data;
if (session_info->widget == dialog)
if (gimp_session_info_get_widget (session_info) == dialog)
{
gimp_session_info_get_geometry (session_info);
gimp_session_info_read_geometry (session_info);
GIMP_LOG (DIALOG_FACTORY,
"updated session info for \"%s\" from window geometry "
"(x=%d y=%d %dx%d)",
entry ? entry->identifier : "dock",
session_info->x, session_info->y,
session_info->width, session_info->height);
gimp_session_info_get_x (session_info),
gimp_session_info_get_y (session_info),
gimp_session_info_get_width (session_info),
gimp_session_info_get_height (session_info));
break;
}
@ -1402,19 +1438,18 @@ gimp_dialog_factories_save_foreach (gconstpointer key,
* by the factory but don't save them if they don't want to be
* managed
*/
if (info->dockable_entry ||
(info->toplevel_entry && ! info->toplevel_entry->session_managed))
if (! gimp_session_info_is_session_managed (info))
continue;
if (info->widget)
if (gimp_session_info_get_widget (info))
gimp_session_info_get_info (info);
gimp_config_writer_open (writer, "session-info");
gimp_config_writer_string (writer,
gimp_object_get_name (factory));
gimp_config_writer_string (writer,
info->toplevel_entry ?
info->toplevel_entry->identifier :
gimp_session_info_get_factory_entry (info) ?
gimp_session_info_get_factory_entry (info)->identifier :
"dock");
GIMP_CONFIG_GET_INTERFACE (info)->serialize (GIMP_CONFIG (info),
@ -1423,7 +1458,7 @@ gimp_dialog_factories_save_foreach (gconstpointer key,
gimp_config_writer_close (writer);
if (info->widget)
if (gimp_session_info_get_widget (info))
gimp_session_info_clear_info (info);
}
}
@ -1439,11 +1474,17 @@ gimp_dialog_factories_restore_foreach (gconstpointer key,
{
GimpSessionInfo *info = infos->data;
if (info->open)
if (gimp_session_info_get_open (info))
{
gimp_session_info_restore (info, factory);
gimp_session_info_clear_info (info);
}
else
{
GIMP_LOG (DIALOG_FACTORY,
"skipping to restore session info %p, not open",
info);
}
}
}
@ -1458,7 +1499,7 @@ gimp_dialog_factories_clear_foreach (gconstpointer key,
{
GimpSessionInfo *info = list->data;
if (info->widget)
if (gimp_session_info_get_widget (info))
continue;
/* FIXME: implement session info deletion */

24
app/widgets/gimpdialogfactory.h
View File

@ -37,6 +37,9 @@ typedef enum
typedef GtkWidget * (* GimpDialogNewFunc) (GimpDialogFactory *factory,
GimpContext *context,
gint view_size);
typedef GtkWidget * (* GimpDialogNewDockFunc) (GimpDialogFactory *factory,
GimpContext *context,
GimpUIManager *ui_manager);
typedef GtkWidget * (* GimpDialogConstructor) (GimpDialogFactory *factory,
GimpDialogFactoryEntry *entry,
GimpContext *context,
@ -58,6 +61,11 @@ struct _GimpDialogFactoryEntry
gboolean session_managed;
gboolean remember_size;
gboolean remember_if_open;
/* If TRUE the entry is for a dockable, otherwise it is for a
* toplevel
*/
gboolean dockable;
};
@ -79,7 +87,8 @@ struct _GimpDialogFactory
GimpMenuFactory *menu_factory;
/*< private >*/
GimpDialogNewFunc new_dock_func;
GimpDialogNewFunc new_dock_window_func;
GimpDialogNewDockFunc new_dock_func;
GimpDialogConstructor constructor;
GList *registered_dialogs;
@ -95,10 +104,10 @@ struct _GimpDialogFactoryClass
GHashTable *factories;
void (* dock_added) (GimpDialogFactory *factory,
GimpDock *dock);
void (* dock_removed) (GimpDialogFactory *factory,
GimpDock *dock);
void (* dock_window_added) (GimpDialogFactory *factory,
GimpDockWindow *dock_window);
void (* dock_window_removed) (GimpDialogFactory *factory,
GimpDockWindow *dock_window);
};
@ -107,13 +116,16 @@ GType gimp_dialog_factory_get_type (void) G_GNUC_CONST;
GimpDialogFactory * gimp_dialog_factory_new (const gchar *name,
GimpContext *context,
GimpMenuFactory *menu_factory,
GimpDialogNewFunc new_dock_func,
GimpDialogNewDockFunc
new_dock_func,
gboolean toggle_visibility);
GimpDialogFactory * gimp_dialog_factory_from_name (const gchar *name);
void gimp_dialog_factory_set_constructor (GimpDialogFactory *factory,
GimpDialogConstructor constructor);
void gimp_dialog_factory_set_dock_window_func(GimpDialogFactory *factory,
GimpDialogNewFunc new_dock_window_func);
void gimp_dialog_factory_register_entry (GimpDialogFactory *factory,
const gchar *identifier,

38
app/widgets/gimpdock.c
View File

@ -35,6 +35,7 @@
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimpdockseparator.h"
#include "gimpuimanager.h"
#include "gimp-intl.h"
@ -43,7 +44,8 @@ enum
{
PROP_0,
PROP_CONTEXT,
PROP_DIALOG_FACTORY
PROP_DIALOG_FACTORY,
PROP_UI_MANAGER
};
enum
@ -60,6 +62,7 @@ struct _GimpDockPrivate
{
GimpDialogFactory *dialog_factory;
GimpContext *context;
GimpUIManager *ui_manager;
GtkWidget *main_vbox;
GtkWidget *vbox;
@ -85,7 +88,7 @@ static void gimp_dock_real_book_removed (GimpDock *dock,
GimpDockbook *dockbook);
G_DEFINE_TYPE (GimpDock, gimp_dock, GIMP_TYPE_DOCK_WINDOW)
G_DEFINE_TYPE (GimpDock, gimp_dock, GTK_TYPE_VBOX)
#define parent_class gimp_dock_parent_class
@ -161,6 +164,13 @@ gimp_dock_class_init (GimpDockClass *klass)
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_UI_MANAGER,
g_param_spec_object ("ui-manager",
NULL, NULL,
GIMP_TYPE_UI_MANAGER,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (klass, sizeof (GimpDockPrivate));
}
@ -207,6 +217,10 @@ gimp_dock_set_property (GObject *object,
dock->p->dialog_factory = g_value_get_object (value);
break;
case PROP_UI_MANAGER:
dock->p->ui_manager = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
@ -231,6 +245,10 @@ gimp_dock_get_property (GObject *object,
g_value_set_object (value, dock->p->dialog_factory);
break;
case PROP_UI_MANAGER:
g_value_set_object (value, dock->p->ui_manager);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
@ -245,6 +263,12 @@ gimp_dock_destroy (GtkObject *object)
while (dock->p->dockbooks)
gimp_dock_remove_book (dock, GIMP_DOCKBOOK (dock->p->dockbooks->data));
if (dock->p->ui_manager)
{
g_object_unref (dock->p->ui_manager);
dock->p->ui_manager = NULL;
}
if (dock->p->context)
{
g_object_unref (dock->p->context);
@ -264,8 +288,6 @@ static void
gimp_dock_real_book_removed (GimpDock *dock,
GimpDockbook *dockbook)
{
if (dock->p->dockbooks == NULL)
gtk_widget_destroy (GTK_WIDGET (dock));
}
@ -373,6 +395,14 @@ gimp_dock_get_dialog_factory (GimpDock *dock)
return dock->p->dialog_factory;
}
GimpUIManager *
gimp_dock_get_ui_manager (GimpDock *dock)
{
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
return dock->p->ui_manager;
}
GList *
gimp_dock_get_dockbooks (GimpDock *dock)
{

10
app/widgets/gimpdock.h
View File

@ -22,9 +22,6 @@
#define __GIMP_DOCK_H__
#include "widgets/gimpdockwindow.h"
#define GIMP_TYPE_DOCK (gimp_dock_get_type ())
#define GIMP_DOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DOCK, GimpDock))
#define GIMP_DOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DOCK, GimpDockClass))
@ -37,18 +34,18 @@ typedef struct _GimpDockClass GimpDockClass;
typedef struct _GimpDockPrivate GimpDockPrivate;
/**
* A top-level window containing GimpDockbooks.
* Contains a column of GimpDockbooks.
*/
struct _GimpDock
{
GimpDockWindow parent_instance;
GtkVBox parent_instance;
GimpDockPrivate *p;
};
struct _GimpDockClass
{
GimpDockWindowClass parent_class;
GtkVBoxClass parent_class;
/* virtual functions */
void (* setup) (GimpDock *dock,
@ -85,6 +82,7 @@ void gimp_dock_set_host_geometry_hints
void gimp_dock_invalidate_geometry(GimpDock *dock);
GimpContext * gimp_dock_get_context (GimpDock *dock);
GimpDialogFactory * gimp_dock_get_dialog_factory (GimpDock *dock);
GimpUIManager * gimp_dock_get_ui_manager (GimpDock *dock);
GList * gimp_dock_get_dockbooks (GimpDock *dock);
gint gimp_dock_get_n_dockables (GimpDock *dock);
GtkWidget * gimp_dock_get_main_vbox (GimpDock *dock);

12
app/widgets/gimpdockable.c
View File

@ -36,6 +36,7 @@
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimpdocked.h"
#include "gimpdockwindow.h"
#include "gimphelp-ids.h"
#include "gimpsessioninfo-aux.h"
#include "gimpuimanager.h"
@ -991,9 +992,10 @@ gimp_dockable_get_menu (GimpDockable *dockable,
void
gimp_dockable_detach (GimpDockable *dockable)
{
GimpDock *src_dock;
GtkWidget *dock;
GtkWidget *dockbook;
GimpDock *src_dock = NULL;
GtkWidget *dock = NULL;
GtkWidget *dockbook = NULL;
GimpDockWindow *dock_window = NULL;
g_return_if_fail (GIMP_IS_DOCKABLE (dockable));
g_return_if_fail (GIMP_IS_DOCKBOOK (dockable->dockbook));
@ -1002,7 +1004,8 @@ gimp_dockable_detach (GimpDockable *dockable)
dock = gimp_dialog_factory_dock_new (gimp_dock_get_dialog_factory (src_dock),
gtk_widget_get_screen (GTK_WIDGET (dockable)));
gtk_window_set_position (GTK_WINDOW (dock), GTK_WIN_POS_MOUSE);
dock_window = gimp_dock_window_from_dock (GIMP_DOCK (dock));
gtk_window_set_position (GTK_WINDOW (dock_window), GTK_WIN_POS_MOUSE);
gimp_dock_setup (GIMP_DOCK (dock), src_dock);
dockbook = gimp_dockbook_new (gimp_dock_get_dialog_factory (GIMP_DOCK (dock))->menu_factory);
@ -1016,6 +1019,7 @@ gimp_dockable_detach (GimpDockable *dockable)
g_object_unref (dockable);
gtk_widget_show (GTK_WIDGET (dock_window));
gtk_widget_show (dock);
}

54
app/widgets/gimpdockcolumns.c Normal file
View File

@ -0,0 +1,54 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpdockcolumns.c
* Copyright (C) 2009 Martin Nordholts <martinn@src.gnome.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <gtk/gtk.h>
#include "widgets-types.h"
#include "gimpdockcolumns.h"
struct _GimpDockColumnsPrivate
{
int dummy;
};
G_DEFINE_TYPE (GimpDockColumns, gimp_dock_columns, GTK_TYPE_HBOX)
#define parent_class gimp_dock_columns_parent_class
static void
gimp_dock_columns_class_init (GimpDockColumnsClass *klass)
{
g_type_class_add_private (klass, sizeof (GimpDockColumnsPrivate));
}
static void
gimp_dock_columns_init (GimpDockColumns *dock_columns)
{
dock_columns->p = G_TYPE_INSTANCE_GET_PRIVATE (dock_columns,
GIMP_TYPE_DOCK_COLUMNS,
GimpDockColumnsPrivate);
}

56
app/widgets/gimpdockcolumns.h Normal file
View File

@ -0,0 +1,56 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpdockcolumns.h
* Copyright (C) 2009 Martin Nordholts <martinn@src.gnome.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_DOCK_COLUMNS_H__
#define __GIMP_DOCK_COLUMNS_H__
#define GIMP_TYPE_DOCK_COLUMNS (gimp_dock_columns_get_type ())
#define GIMP_DOCK_COLUMNS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DOCK_COLUMNS, GimpDockColumns))
#define GIMP_DOCK_COLUMNS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DOCK_COLUMNS, GimpDockColumnsClass))
#define GIMP_IS_DOCK_COLUMNS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DOCK_COLUMNS))
#define GIMP_IS_DOCK_COLUMNS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DOCK_COLUMNS))
#define GIMP_DOCK_COLUMNS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DOCK_COLUMNS, GimpDockColumnsClass))
typedef struct _GimpDockColumnsClass GimpDockColumnsClass;
typedef struct _GimpDockColumnsPrivate GimpDockColumnsPrivate;
/**
* A widget containing GimpDocks so that dockables are arranged in
* columns.
*/
struct _GimpDockColumns
{
GtkHBox parent_instance;
GimpDockColumnsPrivate *p;
};
struct _GimpDockColumnsClass
{
GtkHBoxClass parent_class;
};
GType gimp_dock_columns_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_DOCK_COLUMNS_H__ */

125
app/widgets/gimpdockwindow.c
View File

@ -59,6 +59,7 @@ enum
PROP_CONTEXT,
PROP_DIALOG_FACTORY,
PROP_UI_MANAGER_NAME,
PROP_ALLOW_DOCKBOOK_ABSENCE
};
@ -72,6 +73,8 @@ struct _GimpDockWindowPrivate
GimpUIManager *ui_manager;
GQuark image_flush_handler_id;
gboolean allow_dockbook_absence;
guint update_title_idle_id;
gint ID;
@ -93,7 +96,6 @@ static void gimp_dock_window_style_set (GtkWidget *wid
GtkStyle *prev_style);
static gboolean gimp_dock_window_delete_event (GtkWidget *widget,
GdkEventAny *event);
static GimpDock * gimp_dock_window_get_dock (GimpDockWindow *dock_window);
static void gimp_dock_window_display_changed (GimpDockWindow *dock_window,
GimpObject *display,
GimpContext *context);
@ -105,6 +107,9 @@ static void gimp_dock_window_image_flush (GimpImage *ima
GimpDockWindow *dock_window);
static void gimp_dock_window_update_title (GimpDockWindow *dock_window);
static gboolean gimp_dock_window_update_title_idle (GimpDockWindow *dock_window);
static void gimp_dock_window_dock_book_removed (GimpDockWindow *dock_window,
GimpDockbook *dockbook,
GimpDock *dock);
G_DEFINE_TYPE (GimpDockWindow, gimp_dock_window, GIMP_TYPE_WINDOW)
@ -126,13 +131,13 @@ gimp_dock_window_class_init (GimpDockWindowClass *klass)
widget_class->delete_event = gimp_dock_window_delete_event;
g_object_class_install_property (object_class, PROP_CONTEXT,
g_param_spec_object ("gimp-context", NULL, NULL,
g_param_spec_object ("context", NULL, NULL,
GIMP_TYPE_CONTEXT,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_DIALOG_FACTORY,
g_param_spec_object ("gimp-dialog-factory",
g_param_spec_object ("dialog-factory",
NULL, NULL,
GIMP_TYPE_DIALOG_FACTORY,
GIMP_PARAM_READWRITE |
@ -145,6 +150,13 @@ gimp_dock_window_class_init (GimpDockWindowClass *klass)
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_ALLOW_DOCKBOOK_ABSENCE,
g_param_spec_boolean ("allow-dockbook-absence",
NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("default-height",
NULL, NULL,
@ -199,7 +211,6 @@ gimp_dock_window_constructor (GType type,
GimpDockWindow *dock_window;
GimpGuiConfig *config;
GtkAccelGroup *accel_group;
GimpDock *dock;
/* Init */
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
@ -236,22 +247,6 @@ gimp_dock_window_constructor (GType type,
G_CALLBACK (gimp_dock_window_image_flush),
dock_window);
/* Update window title now and when docks title is invalidated */
gimp_dock_window_update_title (dock_window);
dock = gimp_dock_window_get_dock (dock_window);
g_signal_connect_object (dock, "title-invalidated",
G_CALLBACK (gimp_dock_window_update_title),
dock_window,
G_CONNECT_SWAPPED);
/* Some docks like the toolbox dock needs to maintain special hints
* on its container GtkWindow, allow those to do so
*/
gimp_dock_set_host_geometry_hints (dock, GTK_WINDOW (dock_window));
g_signal_connect_object (dock, "geometry-invalidated",
G_CALLBACK (gimp_dock_set_host_geometry_hints),
dock_window, 0);
/* Done! */
return object;
}
@ -318,6 +313,10 @@ gimp_dock_window_set_property (GObject *object,
dock_window->p->ui_manager_name = g_value_dup_string (value);
break;
case PROP_ALLOW_DOCKBOOK_ABSENCE:
dock_window->p->allow_dockbook_absence = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
@ -346,6 +345,10 @@ gimp_dock_window_get_property (GObject *object,
g_value_set_string (value, dock_window->p->ui_manager_name);
break;
case PROP_ALLOW_DOCKBOOK_ABSENCE:
g_value_set_boolean (value, dock_window->p->allow_dockbook_absence);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
@ -434,9 +437,9 @@ gimp_dock_window_delete_event (GtkWidget *widget,
gimp_object_set_name (GIMP_OBJECT (info),
gtk_window_get_title (GTK_WINDOW (dock_window)));
info->widget = GTK_WIDGET (dock);
gimp_session_info_set_widget (info, GTK_WIDGET (dock_window));
gimp_session_info_get_info (info);
info->widget = NULL;
gimp_session_info_set_widget (info, NULL);
gimp_container_add (global_recent_docks, GIMP_OBJECT (info));
g_object_unref (info);
@ -444,15 +447,6 @@ gimp_dock_window_delete_event (GtkWidget *widget,
return FALSE;
}
static GimpDock *
gimp_dock_window_get_dock (GimpDockWindow *dock_window)
{
/* Change this to return the GimpDock *inside* the GimpDockWindow
* once GimpDock is not a subclass of GimpDockWindow any longer
*/
return GIMP_DOCK (dock_window);
}
static void
gimp_dock_window_display_changed (GimpDockWindow *dock_window,
GimpObject *display,
@ -499,8 +493,15 @@ gimp_dock_window_update_title (GimpDockWindow *dock_window)
static gboolean
gimp_dock_window_update_title_idle (GimpDockWindow *dock_window)
{
GimpDock *dock = gimp_dock_window_get_dock (dock_window);
gchar *title = gimp_dock_get_title (dock);
GimpDock *dock = NULL;
gchar *title = NULL;
dock = gimp_dock_window_get_dock (dock_window);
if (! dock)
return FALSE;
title = gimp_dock_get_title (dock);
if (title)
gtk_window_set_title (GTK_WINDOW (dock_window), title);
@ -512,6 +513,50 @@ gimp_dock_window_update_title_idle (GimpDockWindow *dock_window)
return FALSE;
}
static void
gimp_dock_window_dock_book_removed (GimpDockWindow *dock_window,
GimpDockbook *dockbook,
GimpDock *dock)
{
g_return_if_fail (GIMP_IS_DOCK (dock));
if (gimp_dock_get_dockbooks (dock) == NULL &&
! dock_window->p->allow_dockbook_absence)
gtk_widget_destroy (GTK_WIDGET (dock_window));
}
void
gimp_dock_window_set_dock (GimpDockWindow *dock_window,
GimpDock *dock)
{
g_return_if_fail (GIMP_IS_DOCK_WINDOW (dock_window));
g_return_if_fail (GIMP_IS_DOCK (dock));
/* FIXME: Handle more than one call to this function */
gtk_container_add (GTK_CONTAINER (dock_window), GTK_WIDGET (dock));
/* Update window title now and when docks title is invalidated */
gimp_dock_window_update_title (dock_window);
g_signal_connect_object (dock, "title-invalidated",
G_CALLBACK (gimp_dock_window_update_title),
dock_window,
G_CONNECT_SWAPPED);
/* Some docks like the toolbox dock needs to maintain special hints
* on its container GtkWindow, allow those to do so
*/
gimp_dock_set_host_geometry_hints (dock, GTK_WINDOW (dock_window));
g_signal_connect_object (dock, "geometry-invalidated",
G_CALLBACK (gimp_dock_set_host_geometry_hints),
dock_window, 0);
/* Destroy the dock window when the last book is removed */
g_signal_connect_object (dock, "book-removed",
G_CALLBACK (gimp_dock_window_dock_book_removed),
dock_window,
G_CONNECT_SWAPPED);
}
gint
gimp_dock_window_get_id (GimpDockWindow *dock_window)
{
@ -551,3 +596,17 @@ gimp_dock_window_from_dock (GimpDock *dock)
else
return NULL;
}
/**
* gimp_dock_window_get_dock:
* @dock_window:
*
* Get the #GimpDock within the #GimpDockWindow.
*
* Returns:
**/
GimpDock *
gimp_dock_window_get_dock (GimpDockWindow *dock_window)
{
return GIMP_DOCK (gtk_bin_get_child (GTK_BIN (dock_window)));
}

5
app/widgets/gimpdockwindow.h
View File

@ -55,8 +55,11 @@ struct _GimpDockWindowClass
GType gimp_dock_window_get_type (void) G_GNUC_CONST;
gint gimp_dock_window_get_id (GimpDockWindow *dock_window);
GimpUIManager * gimp_dock_window_get_ui_manager (GimpDockWindow *dock_window);
void gimp_dock_window_set_dock (GimpDockWindow *dock_window,
GimpDock *dock);
GimpUIManager * gimp_dock_window_get_ui_manager (GimpDockWindow *dock_window);
GimpDockWindow * gimp_dock_window_from_dock (GimpDock *dock);
GimpDock * gimp_dock_window_get_dock (GimpDockWindow *dock_window);
#endif /* __GIMP_DOCK_WINDOW_H__ */

2
app/widgets/gimphelp-ids.h
View File

@ -144,6 +144,7 @@
#define GIMP_HELP_LAYER_DUPLICATE "gimp-layer-duplicate"
#define GIMP_HELP_LAYER_ANCHOR "gimp-layer-anchor"
#define GIMP_HELP_LAYER_MERGE_DOWN "gimp-layer-merge-down"
#define GIMP_HELP_LAYER_MERGE_GROUP "gimp-layer-merge-group"
#define GIMP_HELP_LAYER_DELETE "gimp-layer-delete"
#define GIMP_HELP_LAYER_TEXT_DISCARD "gimp-layer-text-discard"
#define GIMP_HELP_LAYER_TEXT_TO_PATH "gimp-layer-text-to-path"
@ -484,6 +485,7 @@
#define GIMP_HELP_UNIT_DIALOG "gimp-unit-dialog"
#define GIMP_HELP_WINDOWS_SHOW_DOCK "gimp-windows-show-dock"
#define GIMP_HELP_WINDOWS_USE_SINGLE_WINDOW_MODE "gimp-windows-use-single-window-mode"
#define GIMP_HELP_WINDOWS_OPEN_RECENT_DOCK "gimp-windows-open-recent-dock"
#define GIMP_HELP_HELP "gimp-help"

3
app/widgets/gimplayertreeview.c
View File

@ -1206,9 +1206,10 @@ gimp_layer_tree_view_mask_update (GimpLayerTreeView *layer_view,
layer_view->priv->model_column_mask_visible, mask_visible,
-1);
gimp_layer_tree_view_update_borders (layer_view, iter);
if (renderer)
{
gimp_layer_tree_view_update_borders (layer_view, iter);
gimp_view_renderer_remove_idle (renderer);
g_object_unref (renderer);
}

4
app/widgets/gimpmenudock.c
View File

@ -383,12 +383,8 @@ gimp_menu_dock_new (GimpDialogFactory *dialog_factory,
"Dock Context", NULL);
menu_dock = g_object_new (GIMP_TYPE_MENU_DOCK,
"role", "gimp-dock",
"context", context,
"dialog-factory", dialog_factory,
"ui-manager-name", "<Dock>",
"gimp-context", context,
"gimp-dialog-factory", dialog_factory,
NULL);
g_object_unref (context);

9
app/widgets/gimpsessioninfo-aux.c
View File

@ -30,6 +30,7 @@
#include "gimpdock.h"
#include "gimpdockable.h"
#include "gimpdockwindow.h"
#include "gimpsessioninfo-aux.h"
@ -287,8 +288,8 @@ gimp_session_info_aux_set_list (GtkWidget *dialog,
{
/* FIXME: make the aux-info stuff generic */
if (GIMP_IS_DOCK (dialog))
gimp_dock_set_aux_info (GIMP_DOCK (dialog), aux_list);
if (GIMP_IS_DOCK_WINDOW (dialog))
gimp_dock_set_aux_info (gimp_dock_window_get_dock (GIMP_DOCK_WINDOW (dialog)), aux_list);
else if (GIMP_IS_DOCKABLE (dialog))
gimp_dockable_set_aux_info (GIMP_DOCKABLE (dialog), aux_list);
}
@ -298,8 +299,8 @@ gimp_session_info_aux_get_list (GtkWidget *dialog)
{
/* FIXME: make the aux-info stuff generic */
if (GIMP_IS_DOCK (dialog))
return gimp_dock_get_aux_info (GIMP_DOCK (dialog));
if (GIMP_IS_DOCK_WINDOW (dialog))
return gimp_dock_get_aux_info (gimp_dock_window_get_dock (GIMP_DOCK_WINDOW (dialog)));
else if (GIMP_IS_DOCKABLE (dialog))
return gimp_dockable_get_aux_info (GIMP_DOCKABLE (dialog));

4
app/widgets/gimpsessioninfo-aux.h
View File

@ -22,6 +22,10 @@
#define __GIMP_SESSION_INFO_AUX_H__
/**
* Contains arbitrary data in the session management system, used for
* example by dockables to manage dockable-specific data.
*/
struct _GimpSessionInfoAux
{
gchar *name;

4
app/widgets/gimpsessioninfo-book.h
View File

@ -22,6 +22,10 @@
#define __GIMP_SESSION_INFO_BOOK_H__
/**
* Contains information about a book (a GtkNotebook of dockables) in
* the interface.
*/
struct _GimpSessionInfoBook
{
gint position;

19
app/widgets/gimpsessioninfo-dock.c
View File

@ -28,10 +28,12 @@
#include "gimpdialogfactory.h"
#include "gimpdock.h"
#include "gimpdockwindow.h"
#include "gimpsessioninfo.h"
#include "gimpsessioninfo-aux.h"
#include "gimpsessioninfo-book.h"
#include "gimpsessioninfo-dock.h"
#include "gimpsessioninfo-private.h"
enum
@ -96,7 +98,7 @@ gimp_session_info_dock_deserialize (GScanner *scanner,
if (token == G_TOKEN_LEFT_PAREN)
{
info->books = g_list_append (info->books, book);
info->p->books = g_list_append (info->p->books, book);
g_scanner_set_scope (scanner, scope);
}
else
@ -174,19 +176,21 @@ gimp_session_info_dock_restore (GimpSessionInfo *info,
GimpDialogFactory *factory,
GdkScreen *screen)
{
GimpDock *dock;
GList *books;
GimpDock *dock = NULL;
GimpDockWindow *dock_window = NULL;
GList *books = NULL;
g_return_if_fail (info != NULL);
g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory));
g_return_if_fail (GDK_IS_SCREEN (screen));
dock = GIMP_DOCK (gimp_dialog_factory_dock_new (factory, screen));
dock = GIMP_DOCK (gimp_dialog_factory_dock_new (factory, screen));
dock_window = gimp_dock_window_from_dock (GIMP_DOCK (dock));
if (dock && info->aux_info)
gimp_session_info_aux_set_list (GTK_WIDGET (dock), info->aux_info);
if (dock && info->p->aux_info)
gimp_session_info_aux_set_list (GTK_WIDGET (dock_window), info->p->aux_info);
for (books = info->books; books; books = g_list_next (books))
for (books = info->p->books; books; books = g_list_next (books))
{
GimpSessionInfoBook *book_info = books->data;
GtkWidget *dockbook;
@ -207,5 +211,6 @@ gimp_session_info_dock_restore (GimpSessionInfo *info,
}
}
gtk_widget_show (GTK_WIDGET (dock_window));
gtk_widget_show (GTK_WIDGET (dock));
}

3
app/widgets/gimpsessioninfo-dockable.h
View File

@ -22,6 +22,9 @@
#define __GIMP_SESSION_INFO_DOCKABLE_H__
/**
* Contains information about a dockable in the interface.
*/
struct _GimpSessionInfoDockable
{
gchar *identifier;

53
app/widgets/gimpsessioninfo-private.h Normal file
View File

@ -0,0 +1,53 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpsessioninfo-private.h
* Copyright (C) 2001-2008 Michael Natterer <mitch@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_SESSION_INFO_PRIVATE_H__
#define __GIMP_SESSION_INFO_PRIVATE_H__
struct _GimpSessionInfoPrivate
{
gint x;
gint y;
gint width;
gint height;
gboolean right_align;
gboolean bottom_align;
/* only valid while restoring and saving the session */
gboolean open;
gint screen;
/* dialog specific list of GimpSessionInfoAux */
GList *aux_info;
GtkWidget *widget;
/* the dialog factory entry for object we have session info for
* note that pure "dock" entries don't have any factory entry
*/
GimpDialogFactoryEntry *factory_entry;
/* list of GimpSessionInfoBook */
GList *books;
};
#endif /* __GIMP_SESSION_INFO_PRIVATE_H__ */

375
app/widgets/gimpsessioninfo.c
View File

@ -30,10 +30,14 @@
#include "gimpdialogfactory.h"
#include "gimpdock.h"
#include "gimpdockwindow.h"
#include "gimpsessioninfo.h"
#include "gimpsessioninfo-aux.h"
#include "gimpsessioninfo-book.h"
#include "gimpsessioninfo-dock.h"
#include "gimpsessioninfo-private.h"
#include "gimp-log.h"
enum
@ -48,20 +52,18 @@ enum
#define DEFAULT_SCREEN -1
static void gimp_session_info_config_iface_init (GimpConfigInterface *iface);
static void gimp_session_info_finalize (GObject *object);
static gint64 gimp_session_info_get_memsize (GimpObject *object,
gint64 *gui_size);
static gboolean gimp_session_info_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_session_info_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data);
static void gimp_session_info_config_iface_init (GimpConfigInterface *iface);
static void gimp_session_info_finalize (GObject *object);
static gint64 gimp_session_info_get_memsize (GimpObject *object,
gint64 *gui_size);
static gboolean gimp_session_info_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_session_info_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data);
static gboolean gimp_session_info_is_for_dock_window (GimpSessionInfo *info);
G_DEFINE_TYPE_WITH_CODE (GimpSessionInfo, gimp_session_info, GIMP_TYPE_OBJECT,
@ -80,12 +82,17 @@ gimp_session_info_class_init (GimpSessionInfoClass *klass)
object_class->finalize = gimp_session_info_finalize;
gimp_object_class->get_memsize = gimp_session_info_get_memsize;
g_type_class_add_private (klass, sizeof (GimpSessionInfoPrivate));
}
static void
gimp_session_info_init (GimpSessionInfo *info)
{
info->screen = DEFAULT_SCREEN;
info->p = G_TYPE_INSTANCE_GET_PRIVATE (info,
GIMP_TYPE_SESSION_INFO,
GimpSessionInfoPrivate);
info->p->screen = DEFAULT_SCREEN;
}
static void
@ -126,31 +133,31 @@ gimp_session_info_serialize (GimpConfig *config,
GimpSessionInfo *info = GIMP_SESSION_INFO (config);
gimp_config_writer_open (writer, "position");
gimp_config_writer_printf (writer, "%d %d", info->x, info->y);
gimp_config_writer_printf (writer, "%d %d", info->p->x, info->p->y);
gimp_config_writer_close (writer);
if (info->width > 0 && info->height > 0)
if (info->p->width > 0 && info->p->height > 0)
{
gimp_config_writer_open (writer, "size");
gimp_config_writer_printf (writer, "%d %d", info->width, info->height);
gimp_config_writer_printf (writer, "%d %d", info->p->width, info->p->height);
gimp_config_writer_close (writer);
}
if (info->open)
if (info->p->open)
{
gimp_config_writer_open (writer, "open-on-exit");
if (info->screen != DEFAULT_SCREEN)
gimp_config_writer_printf (writer, "%d", info->screen);
if (info->p->screen != DEFAULT_SCREEN)
gimp_config_writer_printf (writer, "%d", info->p->screen);
gimp_config_writer_close (writer);
}
if (info->aux_info)
gimp_session_info_aux_serialize (writer, info->aux_info);
if (info->p->aux_info)
gimp_session_info_aux_serialize (writer, info->p->aux_info);
if (info->books)
gimp_session_info_dock_serialize (writer, info->books);
if (info->p->books)
gimp_session_info_dock_serialize (writer, info->p->books);
return TRUE;
}
@ -230,44 +237,44 @@ gimp_session_info_deserialize (GimpConfig *config,
case SESSION_INFO_POSITION:
token = G_TOKEN_INT;
if (! gimp_session_info_parse_offset (scanner,
&info->x,
&info->right_align))
&info->p->x,
&info->p->right_align))
goto error;
if (! gimp_session_info_parse_offset (scanner,
&info->y,
&info->bottom_align))
&info->p->y,
&info->p->bottom_align))
goto error;
break;
case SESSION_INFO_SIZE:
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &info->width))
if (! gimp_scanner_parse_int (scanner, &info->p->width))
goto error;
if (! gimp_scanner_parse_int (scanner, &info->height))
if (! gimp_scanner_parse_int (scanner, &info->p->height))
goto error;
break;
case SESSION_INFO_OPEN:
info->open = TRUE;
info->p->open = TRUE;
/* the screen number is optional */
if (g_scanner_peek_next_token (scanner) == G_TOKEN_RIGHT_PAREN)
break;
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &info->screen))
if (! gimp_scanner_parse_int (scanner, &info->p->screen))
goto error;
break;
case SESSION_INFO_AUX:
token = gimp_session_info_aux_deserialize (scanner,
&info->aux_info);
&info->p->aux_info);
if (token != G_TOKEN_LEFT_PAREN)
goto error;
break;
case SESSION_INFO_DOCK:
if (info->toplevel_entry)
if (info->p->factory_entry)
goto error;
g_scanner_set_scope (scanner, scope_id + 1);
@ -309,6 +316,26 @@ gimp_session_info_deserialize (GimpConfig *config,
return gimp_config_deserialize_return (scanner, token, nest_level);
}
/**
* gimp_session_info_is_for_dock_window:
* @info:
*
* Helper function to determine if the session info is for a dock. It
* uses the dialog factory entry state and the associated widget state
* if any to determine that.
*
* Returns: %TRUE if session info is for a dock, %FALSE otherwise.
**/
static gboolean
gimp_session_info_is_for_dock_window (GimpSessionInfo *info)
{
gboolean entry_state_for_dock = info->p->factory_entry == NULL;
gboolean widget_state_for_dock = (info->p->widget == NULL ||
GIMP_IS_DOCK_WINDOW (info->p->widget));
return entry_state_for_dock && widget_state_for_dock;
}
/* public functions */
@ -330,30 +357,37 @@ gimp_session_info_restore (GimpSessionInfo *info,
display = gdk_display_get_default ();
if (info->screen != DEFAULT_SCREEN)
screen = gdk_display_get_screen (display, info->screen);
if (info->p->screen != DEFAULT_SCREEN)
screen = gdk_display_get_screen (display, info->p->screen);
if (! screen)
screen = gdk_display_get_default_screen (display);
info->open = FALSE;
info->screen = DEFAULT_SCREEN;
info->p->open = FALSE;
info->p->screen = DEFAULT_SCREEN;
if (info->toplevel_entry)
if (info->p->factory_entry && ! info->p->factory_entry->dockable)
{
GtkWidget *dialog;
GIMP_LOG (DIALOG_FACTORY, "restoring toplevel \"%s\" (info %p)",
info->p->factory_entry->identifier,
info);
dialog =
gimp_dialog_factory_dialog_new (factory, screen,
info->toplevel_entry->identifier,
info->toplevel_entry->view_size,
info->p->factory_entry->identifier,
info->p->factory_entry->view_size,
TRUE);
if (dialog && info->aux_info)
gimp_session_info_aux_set_list (dialog, info->aux_info);
if (dialog && info->p->aux_info)
gimp_session_info_aux_set_list (dialog, info->p->aux_info);
}
else
{
GIMP_LOG (DIALOG_FACTORY, "restoring dock (info %p)",
info);
gimp_session_info_dock_restore (info, factory, screen);
}
}
@ -403,8 +437,15 @@ gimp_session_info_get_appropriate_monitor (GdkScreen *screen,
rect.y + rect.height / 2);
}
/**
* gimp_session_info_apply_geometry:
* @info:
*
* Apply the geometry stored in the session info object to the
* associated widget.
**/
void
gimp_session_info_set_geometry (GimpSessionInfo *info)
gimp_session_info_apply_geometry (GimpSessionInfo *info)
{
GdkScreen *screen;
GdkRectangle rect;
@ -413,70 +454,77 @@ gimp_session_info_set_geometry (GimpSessionInfo *info)
gboolean use_size;
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
g_return_if_fail (GTK_IS_WINDOW (info->widget));
g_return_if_fail (GTK_IS_WINDOW (info->p->widget));
screen = gtk_widget_get_screen (info->widget);
screen = gtk_widget_get_screen (info->p->widget);
use_size = ((! info->toplevel_entry || info->toplevel_entry->remember_size) &&
(info->width > 0 && info->height > 0));
use_size = (gimp_session_info_get_remember_size (info) &&
info->p->width > 0 &&
info->p->height > 0);
if (use_size)
{
monitor = gimp_session_info_get_appropriate_monitor (screen,
info->x,
info->y,
info->width,
info->height);
info->p->x,
info->p->y,
info->p->width,
info->p->height);
}
else
{
monitor = gdk_screen_get_monitor_at_point (screen, info->x, info->y);
monitor = gdk_screen_get_monitor_at_point (screen, info->p->x, info->p->y);
}
gdk_screen_get_monitor_geometry (screen, monitor, &rect);
info->x = CLAMP (info->x,
info->p->x = CLAMP (info->p->x,
rect.x,
rect.x + rect.width - (info->width > 0 ?
info->width : 128));
info->y = CLAMP (info->y,
rect.x + rect.width - (info->p->width > 0 ?
info->p->width : 128));
info->p->y = CLAMP (info->p->y,
rect.y,
rect.y + rect.height - (info->height > 0 ?
info->height : 128));
rect.y + rect.height - (info->p->height > 0 ?
info->p->height : 128));
if (info->right_align && info->bottom_align)
if (info->p->right_align && info->p->bottom_align)
{
g_strlcpy (geom, "-0-0", sizeof (geom));
}
else if (info->right_align)
else if (info->p->right_align)
{
g_snprintf (geom, sizeof (geom), "-0%+d", info->y);
g_snprintf (geom, sizeof (geom), "-0%+d", info->p->y);
}
else if (info->bottom_align)
else if (info->p->bottom_align)
{
g_snprintf (geom, sizeof (geom), "%+d-0", info->x);
g_snprintf (geom, sizeof (geom), "%+d-0", info->p->x);
}
else
{
g_snprintf (geom, sizeof (geom), "%+d%+d", info->x, info->y);
g_snprintf (geom, sizeof (geom), "%+d%+d", info->p->x, info->p->y);
}
gtk_window_parse_geometry (GTK_WINDOW (info->widget), geom);
gtk_window_parse_geometry (GTK_WINDOW (info->p->widget), geom);
if (use_size)
gtk_window_set_default_size (GTK_WINDOW (info->widget),
info->width, info->height);
gtk_window_set_default_size (GTK_WINDOW (info->p->widget),
info->p->width, info->p->height);
}
/**
* gimp_session_info_read_geometry:
* @info:
*
* Read geometry related information from the associated widget.
**/
void
gimp_session_info_get_geometry (GimpSessionInfo *info)
gimp_session_info_read_geometry (GimpSessionInfo *info)
{
GdkWindow *window;
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
g_return_if_fail (GTK_IS_WINDOW (info->widget));
g_return_if_fail (GTK_IS_WINDOW (info->p->widget));
window = gtk_widget_get_window (info->widget);
window = gtk_widget_get_window (info->p->widget);
if (window)
{
@ -488,56 +536,56 @@ gimp_session_info_get_geometry (GimpSessionInfo *info)
* interpreted as relative to the right, respective bottom edge
* of the screen.
*/
info->x = MAX (0, x);
info->y = MAX (0, y);
info->p->x = MAX (0, x);
info->p->y = MAX (0, y);
if (! info->toplevel_entry || info->toplevel_entry->remember_size)
if (gimp_session_info_get_remember_size (info))
{
gdk_drawable_get_size (GDK_DRAWABLE (window),
&info->width, &info->height);
&info->p->width, &info->p->height);
}
else
{
info->width = 0;
info->height = 0;
info->p->width = 0;
info->p->height = 0;
}
}
info->open = FALSE;
info->p->open = FALSE;
if (! info->toplevel_entry || info->toplevel_entry->remember_if_open)
if (gimp_session_info_get_remember_if_open (info))
{
GimpDialogVisibilityState visibility;
visibility =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info->widget),
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info->p->widget),
GIMP_DIALOG_VISIBILITY_KEY));
switch (visibility)
{
case GIMP_DIALOG_VISIBILITY_UNKNOWN:
info->open = GTK_WIDGET_VISIBLE (info->widget);
info->p->open = GTK_WIDGET_VISIBLE (info->p->widget);
break;
case GIMP_DIALOG_VISIBILITY_INVISIBLE:
info->open = FALSE;
info->p->open = FALSE;
break;
case GIMP_DIALOG_VISIBILITY_VISIBLE:
info->open = TRUE;
info->p->open = TRUE;
break;
}
}
info->screen = DEFAULT_SCREEN;
info->p->screen = DEFAULT_SCREEN;
if (info->open)
if (info->p->open)
{
GdkDisplay *display = gtk_widget_get_display (info->widget);
GdkScreen *screen = gtk_widget_get_screen (info->widget);
GdkDisplay *display = gtk_widget_get_display (info->p->widget);
GdkScreen *screen = gtk_widget_get_screen (info->p->widget);
if (screen != gdk_display_get_default_screen (display))
info->screen = gdk_screen_get_number (screen);
info->p->screen = gdk_screen_get_number (screen);
}
}
@ -545,14 +593,22 @@ void
gimp_session_info_get_info (GimpSessionInfo *info)
{
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
g_return_if_fail (GTK_IS_WIDGET (info->widget));
g_return_if_fail (GTK_IS_WIDGET (info->p->widget));
gimp_session_info_get_geometry (info);
gimp_session_info_read_geometry (info);
info->aux_info = gimp_session_info_aux_get_list (info->widget);
info->p->aux_info = gimp_session_info_aux_get_list (info->p->widget);
if (! info->toplevel_entry)
info->books = gimp_session_info_dock_from_widget (GIMP_DOCK (info->widget));
if (info->p->factory_entry == NULL ||
(info->p->factory_entry &&
info->p->factory_entry->dockable))
{
GimpDock *dock = NULL;
dock = gimp_dock_window_get_dock (GIMP_DOCK_WINDOW (info->p->widget));
info->p->books = gimp_session_info_dock_from_widget (dock);
}
}
void
@ -560,19 +616,134 @@ gimp_session_info_clear_info (GimpSessionInfo *info)
{
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
if (info->aux_info)
if (info->p->aux_info)
{
g_list_foreach (info->aux_info,
g_list_foreach (info->p->aux_info,
(GFunc) gimp_session_info_aux_free, NULL);
g_list_free (info->aux_info);
info->aux_info = NULL;
g_list_free (info->p->aux_info);
info->p->aux_info = NULL;
}
if (info->books)
if (info->p->books)
{
g_list_foreach (info->books,
g_list_foreach (info->p->books,
(GFunc) gimp_session_info_book_free, NULL);
g_list_free (info->books);
info->books = NULL;
g_list_free (info->p->books);
info->p->books = NULL;
}
}
gboolean
gimp_session_info_is_singleton (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), FALSE);
return (! gimp_session_info_is_for_dock_window (info) &&
info->p->factory_entry &&
info->p->factory_entry->singleton);
}
gboolean
gimp_session_info_is_session_managed (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), FALSE);
return (gimp_session_info_is_for_dock_window (info) ||
(info->p->factory_entry &&
info->p->factory_entry->session_managed));
}
gboolean
gimp_session_info_get_remember_size (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), FALSE);
return (gimp_session_info_is_for_dock_window (info) ||
(info->p->factory_entry &&
info->p->factory_entry->remember_size));
}
gboolean
gimp_session_info_get_remember_if_open (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), FALSE);
return (gimp_session_info_is_for_dock_window (info) ||
(info->p->factory_entry &&
info->p->factory_entry->remember_if_open));
}
GtkWidget *
gimp_session_info_get_widget (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), FALSE);
return info->p->widget;
}
void
gimp_session_info_set_widget (GimpSessionInfo *info,
GtkWidget *widget)
{
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
info->p->widget = widget;
}
GimpDialogFactoryEntry *
gimp_session_info_get_factory_entry (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), FALSE);
return info->p->factory_entry;
}
void
gimp_session_info_set_factory_entry (GimpSessionInfo *info,
GimpDialogFactoryEntry *entry)
{
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
info->p->factory_entry = entry;
}
gboolean
gimp_session_info_get_open (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), FALSE);
return info->p->open;
}
gint
gimp_session_info_get_x (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), 0);
return info->p->x;
}
gint
gimp_session_info_get_y (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), 0);
return info->p->y;
}
gint
gimp_session_info_get_width (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), 0);
return info->p->width;
}
gint
gimp_session_info_get_height (GimpSessionInfo *info)
{
g_return_val_if_fail (GIMP_IS_SESSION_INFO (info), 0);
return info->p->height;
}

69
app/widgets/gimpsessioninfo.h
View File

@ -33,34 +33,18 @@
#define GIMP_SESSION_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_SESSION_INFO, GimpSessionInfoClass))
typedef struct _GimpSessionInfoClass GimpSessionInfoClass;
typedef struct _GimpSessionInfoPrivate GimpSessionInfoPrivate;
typedef struct _GimpSessionInfoClass GimpSessionInfoClass;
/**
* Contains session info for one toplevel window in the interface such
* as a dock, the empty-image-window, or the open/save dialog.
*/
struct _GimpSessionInfo
{
GimpObject parent_instance;
GimpObject parent_instance;
gint x;
gint y;
gint width;
gint height;
gboolean right_align;
gboolean bottom_align;
/* only valid while restoring and saving the session */
gboolean open;
gint screen;
/* dialog specific list of GimpSessionInfoAux */
GList *aux_info;
GtkWidget *widget;
/* only one of these is valid */
GimpDialogFactoryEntry *toplevel_entry;
GimpDialogFactoryEntry *dockable_entry;
/* list of GimpSessionInfoBook */
GList *books;
GimpSessionInfoPrivate *p;
};
struct _GimpSessionInfoClass
@ -69,18 +53,31 @@ struct _GimpSessionInfoClass
};
GType gimp_session_info_get_type (void) G_GNUC_CONST;
GimpSessionInfo * gimp_session_info_new (void);
void gimp_session_info_restore (GimpSessionInfo *info,
GimpDialogFactory *factory);
void gimp_session_info_set_geometry (GimpSessionInfo *info);
void gimp_session_info_get_geometry (GimpSessionInfo *info);
void gimp_session_info_get_info (GimpSessionInfo *info);
void gimp_session_info_clear_info (GimpSessionInfo *info);
GType gimp_session_info_get_type (void) G_GNUC_CONST;
GimpSessionInfo * gimp_session_info_new (void);
void gimp_session_info_restore (GimpSessionInfo *info,
GimpDialogFactory *factory);
void gimp_session_info_apply_geometry (GimpSessionInfo *info);
void gimp_session_info_read_geometry (GimpSessionInfo *info);
void gimp_session_info_get_info (GimpSessionInfo *info);
void gimp_session_info_clear_info (GimpSessionInfo *info);
gboolean gimp_session_info_is_singleton (GimpSessionInfo *info);
gboolean gimp_session_info_is_session_managed (GimpSessionInfo *info);
gboolean gimp_session_info_get_remember_size (GimpSessionInfo *info);
gboolean gimp_session_info_get_remember_if_open (GimpSessionInfo *info);
GtkWidget * gimp_session_info_get_widget (GimpSessionInfo *info);
void gimp_session_info_set_widget (GimpSessionInfo *info,
GtkWidget *widget);
GimpDialogFactoryEntry * gimp_session_info_get_factory_entry (GimpSessionInfo *info);
void gimp_session_info_set_factory_entry (GimpSessionInfo *info,
GimpDialogFactoryEntry *entry);
gboolean gimp_session_info_get_open (GimpSessionInfo *info);
void gimp_session_info_append_book (GimpSessionInfo *info,
GimpSessionInfoBook *book);
gint gimp_session_info_get_x (GimpSessionInfo *info);
gint gimp_session_info_get_y (GimpSessionInfo *info);
gint gimp_session_info_get_width (GimpSessionInfo *info);
gint gimp_session_info_get_height (GimpSessionInfo *info);
#endif /* __GIMP_SESSION_INFO_H__ */

35
app/widgets/gimptoolbox.c
View File

@ -108,7 +108,7 @@ static void toolbox_wilber_notify (GimpGuiConfig *config,
static void toolbox_tool_changed (GimpContext *context,
GimpToolInfo *tool_info,
gpointer data);
GimpToolbox *toolbox);
static void toolbox_tool_reorder (GimpContainer *container,
GimpToolInfo *tool_info,
@ -119,7 +119,7 @@ static void toolbox_tool_visible_notify (GimpToolInfo *tool_info,
GtkWidget *button);
static void toolbox_tool_button_toggled (GtkWidget *widget,
GimpToolInfo *tool_info);
GimpToolbox *toolbox);
static gboolean toolbox_tool_button_press (GtkWidget *widget,
GdkEventButton *bevent,
GimpToolbox *toolbox);
@ -300,7 +300,7 @@ gimp_toolbox_constructor (GType type,
g_signal_connect_object (context, "tool-changed",
G_CALLBACK (toolbox_tool_changed),
toolbox->tool_wbox,
toolbox,
0);
gimp_toolbox_dnd_init (GIMP_TOOLBOX (toolbox));
@ -623,7 +623,8 @@ gimp_toolbox_set_host_geometry_hints (GimpDock *dock,
GtkWidget *
gimp_toolbox_new (GimpDialogFactory *dialog_factory,
GimpContext *context)
GimpContext *context,
GimpUIManager *ui_manager)
{
GimpToolbox *toolbox;
@ -631,12 +632,9 @@ gimp_toolbox_new (GimpDialogFactory *dialog_factory,
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
toolbox = g_object_new (GIMP_TYPE_TOOLBOX,
"role", "gimp-toolbox",
"context", context,
"dialog-factory", dialog_factory,
"ui-manager-name", "<Toolbox>",
"gimp-context", context,
"gimp-dialog-factory", dialog_factory,
"ui-manager", ui_manager,
NULL);
return GTK_WIDGET (toolbox);
@ -694,7 +692,6 @@ toolbox_create_tools (GimpToolbox *toolbox,
GimpToolInfo *tool_info = list->data;
GtkWidget *button;
GtkWidget *image;
GimpDockWindow *dock_window;
const gchar *stock_id;
button = gtk_radio_button_new (group);
@ -724,14 +721,13 @@ toolbox_create_tools (GimpToolbox *toolbox,
g_signal_connect (button, "toggled",
G_CALLBACK (toolbox_tool_button_toggled),
tool_info);
toolbox);
g_signal_connect (button, "button-press-event",
G_CALLBACK (toolbox_tool_button_press),
toolbox);
dock_window = gimp_dock_window_from_dock (GIMP_DOCK (toolbox));
if (gimp_dock_window_get_ui_manager (dock_window))
if (gimp_dock_get_ui_manager (GIMP_DOCK (toolbox)))
{
GimpUIManager *ui_manager;
GtkAction *action;
@ -746,7 +742,7 @@ toolbox_create_tools (GimpToolbox *toolbox,
name = g_strdup_printf ("tools-%s", tmp);
g_free (tmp);
ui_manager = gimp_dock_window_get_ui_manager (dock_window);
ui_manager = gimp_dock_get_ui_manager (GIMP_DOCK (toolbox));
action = gimp_ui_manager_find_action (ui_manager, "tools", name);
g_free (name);
@ -864,7 +860,7 @@ toolbox_wilber_notify (GimpGuiConfig *config,
static void
toolbox_tool_changed (GimpContext *context,
GimpToolInfo *tool_info,
gpointer data)
GimpToolbox *toolbox)
{
if (tool_info)
{
@ -876,14 +872,14 @@ toolbox_tool_changed (GimpContext *context,
{
g_signal_handlers_block_by_func (toolbox_button,
toolbox_tool_button_toggled,
tool_info);
toolbox);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toolbox_button),
TRUE);
g_signal_handlers_unblock_by_func (toolbox_button,
toolbox_tool_button_toggled,
tool_info);
toolbox);
}
}
}
@ -915,10 +911,11 @@ toolbox_tool_visible_notify (GimpToolInfo *tool_info,
}
static void
toolbox_tool_button_toggled (GtkWidget *widget,
GimpToolInfo *tool_info)
toolbox_tool_button_toggled (GtkWidget *widget,
GimpToolbox *toolbox)
{
GtkWidget *toolbox = gtk_widget_get_toplevel (widget);
GimpToolInfo *tool_info = g_object_get_data (G_OBJECT (widget),
TOOL_INFO_DATA_KEY);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
gimp_context_set_tool (gimp_dock_get_context (GIMP_DOCK (toolbox)), tool_info);

3
app/widgets/gimptoolbox.h
View File

@ -61,7 +61,8 @@ struct _GimpToolboxClass
GType gimp_toolbox_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_toolbox_new (GimpDialogFactory *factory,
GimpContext *context);
GimpContext *context,
GimpUIManager *ui_manager);
#endif /* __GIMP_TOOLBOX_H__ */

20
app/widgets/gimpviewrendererimagefile.c
View File

@ -165,9 +165,8 @@ gimp_view_renderer_imagefile_get_icon (GimpImagefile *imagefile,
if (! pixbuf)
{
GFile *file;
GFileInfo *file_info;
GtkIconInfo *info;
GFile *file;
GFileInfo *file_info;
file = g_file_new_for_uri (gimp_object_get_name (imagefile));
file_info = g_file_query_info (file, "standard::icon", 0, NULL, NULL);
@ -176,8 +175,19 @@ gimp_view_renderer_imagefile_get_icon (GimpImagefile *imagefile,
{
GIcon *icon = g_file_info_get_icon (file_info);
info = gtk_icon_theme_lookup_by_gicon (icon_theme, icon, size, 0);
pixbuf = gtk_icon_info_load_icon (info, NULL);
if (icon)
{
GtkIconInfo *info;
info = gtk_icon_theme_lookup_by_gicon (icon_theme, icon, size, 0);
pixbuf = gtk_icon_info_load_icon (info, NULL);
}
else
{
#ifdef GIMP_UNSTABLE
g_printerr ("no icon for: %s\n", gimp_object_get_name (imagefile));
#endif
}
g_object_unref (file_info);
}

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

@ -37,6 +37,7 @@ typedef struct _GimpControllerWheel GimpControllerWheel;
/* docks */
typedef struct _GimpDock GimpDock;
typedef struct _GimpDockColumns GimpDockColumns;
typedef struct _GimpDockSeparator GimpDockSeparator; /* not a dock */
typedef struct _GimpDockWindow GimpDockWindow;
typedef struct _GimpMenuDock GimpMenuDock;

4
devel-docs/app/app-sections.txt
View File

@ -593,6 +593,7 @@ gimp_parasiterc_save
<SECTION>
<FILE>gimp-tags</FILE>
<TITLE>Gimp-tags</TITLE>
gimp_tags_user_install
</SECTION>
@ -914,6 +915,7 @@ gimp_channel_combine_mask
<SECTION>
<FILE>gimpchannel-project</FILE>
<TITLE>GimpChannel-project</TITLE>
gimp_channel_project_region
</SECTION>
@ -1948,6 +1950,7 @@ floating_sel_invalidate
<SECTION>
<FILE>gimplayer-project</FILE>
<TITLE>GimpLayer-project</TITLE>
gimp_layer_project_region
</SECTION>
@ -9527,6 +9530,7 @@ gimp_preview_cache_get_memsize
<SECTION>
<FILE>gimpprojectable</FILE>
<TITLE>GimpProjectable</TITLE>
GIMP_PROJECTABLE_GET_INTERFACE
GimpProjectable
gimp_projectable_invalidate

2
libgimpconfig/gimpconfig.def
View File

@ -6,6 +6,7 @@ EXPORTS
gimp_config_build_plug_in_path
gimp_config_build_writable_path
gimp_config_copy
gimp_config_deserialize
gimp_config_deserialize_file
gimp_config_deserialize_properties
gimp_config_deserialize_property
@ -21,6 +22,7 @@ EXPORTS
gimp_config_reset
gimp_config_reset_properties
gimp_config_reset_property
gimp_config_serialize
gimp_config_serialize_changed_properties
gimp_config_serialize_properties
gimp_config_serialize_property

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

@ -372,6 +372,7 @@
<placeholder name="Structure">
<menuitem action="layers-anchor" />
<menuitem action="layers-merge-down" />
<menuitem action="layers-merge-group" />
<menuitem action="layers-delete" />
</placeholder>
<separator />
@ -640,6 +641,9 @@
<placeholder name="Docks">
<menuitem action="windows-show-toolbox" />
</placeholder>
<separator />
<menuitem action="windows-use-single-window-mode" />
<separator />
</menu>
<menu action="help-menu" name="Help">

1
menus/layers-menu.xml
View File

@ -18,6 +18,7 @@
<menuitem action="layers-duplicate" />
<menuitem action="layers-anchor" />
<menuitem action="layers-merge-down" />
<menuitem action="layers-merge-group" />
<menuitem action="layers-delete" />
<separator />
<menuitem action="layers-text-discard" />

4
po-plug-ins/vi.po
View File

@ -2280,7 +2280,7 @@ msgstr "Đang tự động kéo giãn HSV"
#: ../plug-ins/common/autostretch_hsv.c:193
msgid "autostretch_hsv: cmap was NULL! Quitting...\n"
msgstr "autostretch_hsv: cmap VÔ GIÁ TRỊ nên thoạt...\n"
msgstr "autostretch_hsv: cmap VÔ GIÁ TRỊ nên thoát...\n"
#: ../plug-ins/common/blinds.c:116
msgid "Simulate an image painted on window blinds"
@ -12078,4 +12078,4 @@ msgstr "Lỗi: không thể đọc tập tin thuộc tính XJT « %s »."
#: ../plug-ins/xjt/xjt.c:3204
#, c-format
msgid "Error: XJT property file '%s' is empty."
msgstr "Lỗi: tập tin thuộc tính XJT « %s » là rỗng"
msgstr "Lỗi: tập tin thuộc tính XJT « %s » là rỗng"