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

app: Merge 'global_toolbox_factory' into 'global_dock_factory'

Browse Source 
Get rid of 'global_toolbox_factory' and manage everything dock-related
with 'global_dock_factory'. The whole of 'global_toolbox_factory' was
a big special-case and getting rid of it makes it easier to extend the
session management with e.g. single-window mode dock functionality.

To get rid of 'global_toolbox_factory' we, roughly, have to
 * Replace 'global_toolbox_factory' with 'global_dock_factory'
   everywhere. We can also get rid of lots of code that did special
   things for the "toolbox" factory.
 * Make the use or interaction with the toolbox explicit in some
   places. For example, a function gimp_dock_window_has_toolbox() has
   been introduced.
 * Make GimpSessionInfoDock have an 'identifier' parameter so we can
   differentiate between the "gimp-dock" and "gimp-toolbox" dock
   types.
This commit is contained in:
Martin Nordholts
2010-01-20 18:29:54 +01:00
parent dd8b867852
commit 1093462ae9
17 changed files with 167 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -102,10 +102,11 @@ windows_show_toolbox (void)
{ {
GtkWidget *toolbox = NULL; GtkWidget *toolbox = NULL;
if (! gimp_dialog_factory_get_open_dialogs (global_toolbox_factory)) if (! dialogs_get_toolbox ())
{ {
toolbox = gimp_dialog_factory_dock_with_window_new (global_toolbox_factory, toolbox = gimp_dialog_factory_dock_with_window_new (global_dock_factory,
gdk_screen_get_default ()); gdk_screen_get_default (),
TRUE /*toolbox*/);
gtk_widget_show (toolbox); gtk_widget_show (toolbox);
} }

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

@ -235,11 +235,7 @@ dialogs_toolbox_new (GimpDialogFactory *factory,
GimpUIManager *ui_manager, GimpUIManager *ui_manager,
gint view_size) gint view_size)
{ {
/* we pass "global_dock_factory", _not_ "global_toolbox_factory" to return gimp_toolbox_new (factory,
* the toolbox constructor, because the global_toolbox_factory has
* no dockables registered
*/
return gimp_toolbox_new (global_dock_factory,
context, context,
ui_manager); ui_manager);
} }

54
app/dialogs/dialogs.c
View File

@ -30,9 +30,11 @@
#include "core/gimplist.h" #include "core/gimplist.h"
#include "widgets/gimpdialogfactory.h" #include "widgets/gimpdialogfactory.h"
#include "widgets/gimpdockwindow.h"
#include "widgets/gimphelp-ids.h" #include "widgets/gimphelp-ids.h"
#include "widgets/gimpmenufactory.h" #include "widgets/gimpmenufactory.h"
#include "widgets/gimpsessioninfo.h" #include "widgets/gimpsessioninfo.h"
#include "widgets/gimptoolbox.h"
#include "dialogs.h" #include "dialogs.h"
#include "dialogs-constructors.h" #include "dialogs-constructors.h"
@ -42,7 +44,6 @@
GimpDialogFactory *global_dialog_factory = NULL; GimpDialogFactory *global_dialog_factory = NULL;
GimpDialogFactory *global_dock_factory = NULL; GimpDialogFactory *global_dock_factory = NULL;
GimpDialogFactory *global_toolbox_factory = NULL;
GimpDialogFactory *global_display_factory = NULL; GimpDialogFactory *global_display_factory = NULL;
GimpContainer *global_recent_docks = NULL; GimpContainer *global_recent_docks = NULL;
@ -343,17 +344,6 @@ static const GimpDialogFactoryEntry dock_entries[] =
dialogs_palette_editor_get, 0, TRUE) dialogs_palette_editor_get, 0, TRUE)
}; };
static const GimpDialogFactoryEntry toolbox_entries[] =
{
/* docks */
DOCK ("gimp-toolbox",
dialogs_toolbox_new),
/* dock windows */
DOCK_WINDOW ("gimp-toolbox-window",
dialogs_toolbox_dock_window_new)
};
/* public functions */ /* public functions */
@ -372,12 +362,6 @@ dialogs_init (Gimp *gimp,
menu_factory, menu_factory,
TRUE); TRUE);
/* Toolbox */
global_toolbox_factory = gimp_dialog_factory_new ("toolbox",
gimp_get_user_context (gimp),
menu_factory,
TRUE);
/* Dock windows and docks */ /* Dock windows and docks */
global_dock_factory = gimp_dialog_factory_new ("dock", global_dock_factory = gimp_dialog_factory_new ("dock",
gimp_get_user_context (gimp), gimp_get_user_context (gimp),
@ -421,21 +405,6 @@ dialogs_init (Gimp *gimp,
dock_entries[i].remember_if_open, dock_entries[i].remember_if_open,
dock_entries[i].dockable); dock_entries[i].dockable);
for (i = 0; i < G_N_ELEMENTS (toolbox_entries); i++)
gimp_dialog_factory_register_entry (global_toolbox_factory,
toolbox_entries[i].identifier,
gettext (toolbox_entries[i].name),
gettext (toolbox_entries[i].blurb),
toolbox_entries[i].stock_id,
toolbox_entries[i].help_id,
toolbox_entries[i].new_func,
toolbox_entries[i].view_size,
toolbox_entries[i].singleton,
toolbox_entries[i].session_managed,
toolbox_entries[i].remember_size,
toolbox_entries[i].remember_if_open,
toolbox_entries[i].dockable);
gimp_dialog_factory_register_entry (global_display_factory, gimp_dialog_factory_register_entry (global_display_factory,
"gimp-empty-image-window", "gimp-empty-image-window",
NULL, NULL, NULL, NULL,
@ -462,18 +431,6 @@ dialogs_exit (Gimp *gimp)
global_dialog_factory = NULL; global_dialog_factory = NULL;
} }
/* destroy the "global_toolbox_factory" _before_ destroying the
* "global_dock_factory" because the "global_toolbox_factory" owns
* dockables which were created by the "global_dock_factory". This
* way they are properly removed from the "global_dock_factory",
* which would complain about stale entries otherwise.
*/
if (global_toolbox_factory)
{
g_object_unref (global_toolbox_factory);
global_toolbox_factory = NULL;
}
if (global_dock_factory) if (global_dock_factory)
{ {
g_object_unref (global_dock_factory); g_object_unref (global_dock_factory);
@ -552,13 +509,14 @@ dialogs_get_toolbox (void)
{ {
GList *list; GList *list;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (global_toolbox_factory), NULL); g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (global_dock_factory), NULL);
for (list = gimp_dialog_factory_get_open_dialogs (global_toolbox_factory); for (list = gimp_dialog_factory_get_open_dialogs (global_dock_factory);
list; list;
list = g_list_next (list)) list = g_list_next (list))
{ {
if (gtk_widget_is_toplevel (list->data)) if (GIMP_IS_DOCK_WINDOW (list->data) &&
gimp_dock_window_has_toolbox (list->data))
return list->data; return list->data;
} }

1
app/dialogs/dialogs.h
View File

@ -21,7 +21,6 @@
extern GimpDialogFactory *global_dialog_factory; extern GimpDialogFactory *global_dialog_factory;
extern GimpDialogFactory *global_dock_factory; extern GimpDialogFactory *global_dock_factory;
extern GimpDialogFactory *global_toolbox_factory;
extern GimpDialogFactory *global_display_factory; extern GimpDialogFactory *global_display_factory;
extern GimpContainer *global_recent_docks; extern GimpContainer *global_recent_docks;

38
app/gui/gimpuiconfigurer.c
View File

@ -66,8 +66,8 @@ static void gimp_ui_configurer_get_property (GObject
GValue *value, GValue *value,
GParamSpec *pspec); GParamSpec *pspec);
static void gimp_ui_configurer_move_docks_to_columns (GimpUIConfigurer *ui_configurer, static void gimp_ui_configurer_move_docks_to_columns (GimpUIConfigurer *ui_configurer,
GimpDialogFactory *dialog_factory, GimpDockColumns *dock_columns,
GimpDockColumns *dock_columns); gboolean only_toolbox);
static void gimp_ui_configurer_move_shells (GimpUIConfigurer *ui_configurer, static void gimp_ui_configurer_move_shells (GimpUIConfigurer *ui_configurer,
GimpImageWindow *source_image_window, GimpImageWindow *source_image_window,
GimpImageWindow *target_image_window); GimpImageWindow *target_image_window);
@ -154,12 +154,15 @@ gimp_ui_configurer_get_property (GObject *object,
static void static void
gimp_ui_configurer_move_docks_to_columns (GimpUIConfigurer *ui_configurer, gimp_ui_configurer_move_docks_to_columns (GimpUIConfigurer *ui_configurer,
GimpDialogFactory *dialog_factory, GimpDockColumns *dock_columns,
GimpDockColumns *dock_columns) gboolean only_toolbox)
{ {
GList *dialogs = g_list_copy (gimp_dialog_factory_get_open_dialogs (dialog_factory)); GList *dialogs = NULL;
GList *dialog_iter = NULL; GList *dialog_iter = NULL;
dialogs =
g_list_copy (gimp_dialog_factory_get_open_dialogs (global_dock_factory));
for (dialog_iter = dialogs; dialog_iter; dialog_iter = dialog_iter->next) for (dialog_iter = dialogs; dialog_iter; dialog_iter = dialog_iter->next)
{ {
GimpDockWindow *dock_window = NULL; GimpDockWindow *dock_window = NULL;
@ -176,6 +179,10 @@ gimp_ui_configurer_move_docks_to_columns (GimpUIConfigurer *ui_configurer,
{ {
GimpDock *dock = GIMP_DOCK (dock_iter->data); GimpDock *dock = GIMP_DOCK (dock_iter->data);
if (only_toolbox &&
! GIMP_IS_TOOLBOX (dock))
continue;
/* Move the dock from the image window to the dock columns /* Move the dock from the image window to the dock columns
* widget. Note that we need a ref while the dock is parentless * widget. Note that we need a ref while the dock is parentless
*/ */
@ -189,9 +196,14 @@ gimp_ui_configurer_move_docks_to_columns (GimpUIConfigurer *ui_configurer,
/* Kill the window if removing the dock didn't destroy it /* Kill the window if removing the dock didn't destroy it
* already. This will be the case for the toolbox dock window * already. This will be the case for the toolbox dock window
*/ */
if (GTK_IS_WIDGET (dock_window)) /* FIXME: We should solve this in a more elegant way, valgrind
* complains about invalid reads when the dock window already is
* destroyed
*/
if (GTK_IS_WIDGET (dock_window) &&
g_list_length (gimp_dock_window_get_docks (dock_window)) == 0)
{ {
gimp_dialog_factory_remove_dialog (dialog_factory, gimp_dialog_factory_remove_dialog (global_dock_factory,
GTK_WIDGET (dock_window)); GTK_WIDGET (dock_window));
gtk_widget_destroy (GTK_WIDGET (dock_window)); gtk_widget_destroy (GTK_WIDGET (dock_window));
} }
@ -271,9 +283,7 @@ gimp_ui_configurer_move_docks_to_window (GimpUIConfigurer *ui_configurer,
* toolbox * toolbox
*/ */
dock_window = dock_window =
gimp_dialog_factory_dialog_new ((GIMP_IS_TOOLBOX (dock) ? gimp_dialog_factory_dialog_new (global_dock_factory,
global_toolbox_factory :
global_dock_factory),
screen, screen,
(GIMP_IS_TOOLBOX (dock) ? (GIMP_IS_TOOLBOX (dock) ?
"gimp-toolbox-window" : "gimp-toolbox-window" :
@ -362,15 +372,15 @@ gimp_ui_configurer_configure_for_single_window (GimpUIConfigurer *ui_configurer)
* window * window
*/ */
gimp_ui_configurer_move_docks_to_columns (ui_configurer, gimp_ui_configurer_move_docks_to_columns (ui_configurer,
global_toolbox_factory, left_docks,
left_docks); TRUE /*only_toolbox*/);
/* Then move the other docks to the right side of the image /* Then move the other docks to the right side of the image
* window * window
*/ */
gimp_ui_configurer_move_docks_to_columns (ui_configurer, gimp_ui_configurer_move_docks_to_columns (ui_configurer,
global_dock_factory, right_docks,
right_docks); FALSE /*only_toolbox*/);
/* Show the docks in the window */ /* Show the docks in the window */
gimp_image_window_set_show_docks (uber_image_window, TRUE); gimp_image_window_set_show_docks (uber_image_window, TRUE);

10
app/gui/session.c
View File

@ -138,7 +138,15 @@ session_init (Gimp *gimp)
if (! gimp_scanner_parse_string (scanner, &factory_name)) if (! gimp_scanner_parse_string (scanner, &factory_name))
break; break;
factory = gimp_dialog_factory_from_name (factory_name); /* In versions <= GIMP 2.6 there was a "toolbox" and a
* "dock" factory. These are now merged so if the
* factory name is "toolbox", get the "dock" factory
* instead. We don't change factory_name because we need
* it below
*/
factory = gimp_dialog_factory_from_name (strcmp ("toolbox", factory_name) == 0 ?
"dock" :
factory_name);
if (! factory) if (! factory)
break; break;

4
app/tests/gimpdir/dockrc
View File

@ -7,7 +7,7 @@
(aux-info (aux-info
(show-image-menu "false") (show-image-menu "false")
(follow-active-image "true")) (follow-active-image "true"))
(dock (gimp-dock
(book (book
(current-page 0) (current-page 0)
(dockable "gimp-palette-list" (dockable "gimp-palette-list"
@ -31,7 +31,7 @@
(aux-info (aux-info
(show-image-menu "false") (show-image-menu "false")
(follow-active-image "true")) (follow-active-image "true"))
(dock (gimp-dock
(book (book
(current-page 1) (current-page 1)
(dockable "gimp-selection-editor" (dockable "gimp-selection-editor"

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

@ -94,9 +94,11 @@ gimp_test_window_roles (GimpTestFixture *fixture,
GimpDockWindow *toolbox_window = NULL; GimpDockWindow *toolbox_window = NULL;
dock = gimp_dialog_factory_dock_with_window_new (global_dock_factory, dock = gimp_dialog_factory_dock_with_window_new (global_dock_factory,
gdk_screen_get_default ()); gdk_screen_get_default (),
toolbox = gimp_dialog_factory_dock_with_window_new (global_toolbox_factory, FALSE /*toolbox*/);
gdk_screen_get_default ()); toolbox = gimp_dialog_factory_dock_with_window_new (global_dock_factory,
gdk_screen_get_default (),
TRUE /*toolbox*/);
dock_window = gimp_dock_window_from_dock (GIMP_DOCK (dock)); dock_window = gimp_dock_window_from_dock (GIMP_DOCK (dock));
toolbox_window = gimp_dock_window_from_dock (GIMP_DOCK (toolbox)); toolbox_window = gimp_dock_window_from_dock (GIMP_DOCK (toolbox));

55
app/widgets/gimpdialogfactory.c
View File

@ -210,10 +210,7 @@ gimp_dialog_factory_dispose (GObject *object)
factory->p->session_infos = NULL; factory->p->session_infos = NULL;
} }
if (strcmp (gimp_object_get_name (factory), "toolbox") == 0) key = (gpointer)gimp_object_get_name (factory);
key = "";
else
key = (gpointer)gimp_object_get_name (factory);
g_hash_table_remove (GIMP_DIALOG_FACTORY_GET_CLASS (object)->factories, g_hash_table_remove (GIMP_DIALOG_FACTORY_GET_CLASS (object)->factories,
key); key);
@ -274,11 +271,7 @@ gimp_dialog_factory_new (const gchar *name,
gimp_object_set_name (GIMP_OBJECT (factory), name); gimp_object_set_name (GIMP_OBJECT (factory), name);
/* hack to keep the toolbox on the pool position */ key = (gpointer)gimp_object_get_name (factory);
if (strcmp (name, "toolbox") == 0)
key = "";
else
key = (gpointer)gimp_object_get_name (factory);
g_hash_table_insert (GIMP_DIALOG_FACTORY_GET_CLASS (factory)->factories, g_hash_table_insert (GIMP_DIALOG_FACTORY_GET_CLASS (factory)->factories,
key, factory); key, factory);
@ -302,10 +295,6 @@ gimp_dialog_factory_from_name (const gchar *name)
if (! factory_class) if (! factory_class)
return NULL; return NULL;
/* hack to keep the toolbox on the pool position */
if (strcmp (name, "toolbox") == 0)
name = "";
factory = factory =
(GimpDialogFactory *) g_hash_table_lookup (factory_class->factories, name); (GimpDialogFactory *) g_hash_table_lookup (factory_class->factories, name);
@ -490,7 +479,9 @@ gimp_dialog_factory_dialog_new_internal (GimpDialogFactory *factory,
* dialog. We do this because the new dockable needs to be * dialog. We do this because the new dockable needs to be
* created in its dock's context. * created in its dock's context.
*/ */
dock = gimp_dialog_factory_dock_with_window_new (factory, screen); dock = gimp_dialog_factory_dock_with_window_new (factory,
screen,
FALSE /*toolbox*/);
dockbook = gimp_dockbook_new (factory->p->menu_factory); dockbook = gimp_dockbook_new (factory->p->menu_factory);
gimp_dock_add_book (GIMP_DOCK (dock), gimp_dock_add_book (GIMP_DOCK (dock),
@ -813,10 +804,10 @@ gimp_dialog_factory_dockable_new (GimpDialogFactory *factory,
**/ **/
GtkWidget * GtkWidget *
gimp_dialog_factory_dock_with_window_new (GimpDialogFactory *factory, gimp_dialog_factory_dock_with_window_new (GimpDialogFactory *factory,
GdkScreen *screen) GdkScreen *screen,
gboolean toolbox)
{ {
GtkWidget *dock_window = NULL; GtkWidget *dock_window = NULL;
gchar *dock_id = NULL;
GtkWidget *dock = NULL; GtkWidget *dock = NULL;
GimpUIManager *ui_manager = NULL; GimpUIManager *ui_manager = NULL;
@ -830,7 +821,7 @@ gimp_dialog_factory_dock_with_window_new (GimpDialogFactory *factory,
dock_window = dock_window =
gimp_dialog_factory_dialog_new (factory, gimp_dialog_factory_dialog_new (factory,
screen, screen,
(strcmp ("toolbox", gimp_object_get_name (factory)) == 0 ? (toolbox ?
"gimp-toolbox-window" : "gimp-toolbox-window" :
"gimp-dock-window"), "gimp-dock-window"),
-1 /*view_size*/, -1 /*view_size*/,
@ -838,17 +829,13 @@ gimp_dialog_factory_dock_with_window_new (GimpDialogFactory *factory,
/* Create the dock */ /* Create the dock */
ui_manager = gimp_dock_window_get_ui_manager (GIMP_DOCK_WINDOW (dock_window)); ui_manager = gimp_dock_window_get_ui_manager (GIMP_DOCK_WINDOW (dock_window));
dock = gimp_dialog_factory_dialog_new (factory,
dock_id = g_strconcat ("gimp-", gimp_object_get_name (factory), NULL); screen,
dock = gimp_dialog_factory_dialog_new (factory, (toolbox ?
screen, "gimp-toolbox" :
(strcmp ("toolbox", gimp_object_get_name (factory)) == 0 ? "gimp-dock"),
"gimp-toolbox" : -1 /*view_size*/,
"gimp-dock"), FALSE /*present*/);
-1 /*view_size*/,
FALSE /*present*/);
g_free (dock_id);
if (dock) if (dock)
{ {
/* Put the dock in the dock window */ /* Put the dock in the dock window */
@ -1453,8 +1440,7 @@ gimp_dialog_factories_save_foreach (gconstpointer key,
for (infos = factory->p->session_infos; infos; infos = g_list_next (infos)) for (infos = factory->p->session_infos; infos; infos = g_list_next (infos))
{ {
GimpSessionInfo *info = infos->data; GimpSessionInfo *info = infos->data;
const gchar *identifier = NULL;
/* we keep session info entries for all toplevel dialogs created /* we keep session info entries for all toplevel dialogs created
* by the factory but don't save them if they don't want to be * by the factory but don't save them if they don't want to be
@ -1470,13 +1456,8 @@ gimp_dialog_factories_save_foreach (gconstpointer key,
gimp_config_writer_open (writer, "session-info"); gimp_config_writer_open (writer, "session-info");
gimp_config_writer_string (writer, gimp_config_writer_string (writer,
gimp_object_get_name (factory)); gimp_object_get_name (factory));
gimp_config_writer_string (writer,
/* Some special casing to be avoid changing sessionrc */ gimp_session_info_get_factory_entry (info)->identifier);
identifier = gimp_session_info_get_factory_entry (info)->identifier;
if (strcmp (identifier, "gimp-dock-window") == 0 ||
strcmp (identifier, "gimp-toolbox-window") == 0)
identifier = "dock";
gimp_config_writer_string (writer, identifier);
GIMP_CONFIG_GET_INTERFACE (info)->serialize (GIMP_CONFIG (info), GIMP_CONFIG_GET_INTERFACE (info)->serialize (GIMP_CONFIG (info),
writer, writer,

3
app/widgets/gimpdialogfactory.h
View File

@ -148,7 +148,8 @@ GtkWidget * gimp_dialog_factory_dockable_new (GimpDialogFactory
const gchar *identifier, const gchar *identifier,
gint view_size); gint view_size);
GtkWidget * gimp_dialog_factory_dock_with_window_new (GimpDialogFactory *factory, GtkWidget * gimp_dialog_factory_dock_with_window_new (GimpDialogFactory *factory,
GdkScreen *screen); GdkScreen *screen,
gboolean toolbox);
void gimp_dialog_factory_add_dialog (GimpDialogFactory *factory, void gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
GtkWidget *dialog); GtkWidget *dialog);
void gimp_dialog_factory_add_foreign (GimpDialogFactory *factory, void gimp_dialog_factory_add_foreign (GimpDialogFactory *factory,

3
app/widgets/gimpdockable.c
View File

@ -1206,7 +1206,8 @@ gimp_dockable_detach (GimpDockable *dockable)
src_dock_window = gimp_dock_window_from_dock (src_dock); src_dock_window = gimp_dock_window_from_dock (src_dock);
dock = gimp_dialog_factory_dock_with_window_new (global_dock_factory, dock = gimp_dialog_factory_dock_with_window_new (global_dock_factory,
gtk_widget_get_screen (GTK_WIDGET (dockable))); gtk_widget_get_screen (GTK_WIDGET (dockable)),
FALSE /*toolbox*/);
dock_window = gimp_dock_window_from_dock (GIMP_DOCK (dock)); dock_window = gimp_dock_window_from_dock (GIMP_DOCK (dock));
gtk_window_set_position (GTK_WINDOW (dock_window), GTK_WIN_POS_MOUSE); gtk_window_set_position (GTK_WINDOW (dock_window), GTK_WIN_POS_MOUSE);
if (src_dock_window) if (src_dock_window)

26
app/widgets/gimpdockwindow.c
View File

@ -53,6 +53,7 @@
#include "gimpmenufactory.h" #include "gimpmenufactory.h"
#include "gimpsessioninfo-aux.h" #include "gimpsessioninfo-aux.h"
#include "gimpsessioninfo.h" #include "gimpsessioninfo.h"
#include "gimptoolbox.h"
#include "gimpuimanager.h" #include "gimpuimanager.h"
#include "gimpwidgets-utils.h" #include "gimpwidgets-utils.h"
#include "gimpwindow.h" #include "gimpwindow.h"
@ -1066,6 +1067,31 @@ gimp_dock_window_get_aux_info (GimpDockWindow *dock_window)
return aux_info; return aux_info;
} }
/**
* gimp_dock_window_has_toolbox:
* @dock_window:
*
* Returns: %TRUE if the dock window has a GimpToolbox dock, %FALSE
* otherwise.
**/
gboolean
gimp_dock_window_has_toolbox (GimpDockWindow *dock_window)
{
GList *iter = NULL;
g_return_val_if_fail (GIMP_IS_DOCK_WINDOW (dock_window), FALSE);
for (iter = gimp_dock_columns_get_docks (dock_window->p->dock_columns);
iter;
iter = g_list_next (iter))
{
if (GIMP_IS_TOOLBOX (iter->data))
return TRUE;
}
return FALSE;
}
/** /**
* gimp_dock_window_from_dock: * gimp_dock_window_from_dock:

2
app/widgets/gimpdockwindow.h
View File

@ -83,8 +83,10 @@ void gimp_dock_window_setup (GimpDockWindow *
void gimp_dock_window_set_aux_info (GimpDockWindow *dock, void gimp_dock_window_set_aux_info (GimpDockWindow *dock,
GList *aux_info); GList *aux_info);
GList * gimp_dock_window_get_aux_info (GimpDockWindow *dock); GList * gimp_dock_window_get_aux_info (GimpDockWindow *dock);
gboolean gimp_dock_window_has_toolbox (GimpDockWindow *dock_window);
GimpDockWindow * gimp_dock_window_from_dock (GimpDock *dock); GimpDockWindow * gimp_dock_window_from_dock (GimpDock *dock);
#endif /* __GIMP_DOCK_WINDOW_H__ */ #endif /* __GIMP_DOCK_WINDOW_H__ */

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

@ -34,6 +34,7 @@
#include "gimpsessioninfo-book.h" #include "gimpsessioninfo-book.h"
#include "gimpsessioninfo-dock.h" #include "gimpsessioninfo-dock.h"
#include "gimpsessioninfo-private.h" #include "gimpsessioninfo-private.h"
#include "gimptoolbox.h"
enum enum
@ -45,9 +46,14 @@ enum
/* public functions */ /* public functions */
GimpSessionInfoDock * GimpSessionInfoDock *
gimp_session_info_dock_new (void) gimp_session_info_dock_new (const gchar *identifier)
{ {
return g_slice_new0 (GimpSessionInfoDock); GimpSessionInfoDock *dock_info = NULL;
dock_info = g_slice_new0 (GimpSessionInfoDock);
dock_info->identifier = g_strdup (identifier);
return dock_info;
} }
void void
@ -55,6 +61,12 @@ gimp_session_info_dock_free (GimpSessionInfoDock *dock_info)
{ {
g_return_if_fail (dock_info != NULL); g_return_if_fail (dock_info != NULL);
if (dock_info->identifier)
{
g_free (dock_info->identifier);
dock_info->identifier = NULL;
}
if (dock_info->books) if (dock_info->books)
{ {
g_list_foreach (dock_info->books, g_list_foreach (dock_info->books,
@ -76,7 +88,7 @@ gimp_session_info_dock_serialize (GimpConfigWriter *writer,
g_return_if_fail (writer != NULL); g_return_if_fail (writer != NULL);
g_return_if_fail (dock_info != NULL); g_return_if_fail (dock_info != NULL);
gimp_config_writer_open (writer, "dock"); gimp_config_writer_open (writer, dock_info->identifier);
for (list = dock_info->books; list; list = g_list_next (list)) for (list = dock_info->books; list; list = g_list_next (list))
gimp_session_info_book_serialize (writer, list->data); gimp_session_info_book_serialize (writer, list->data);
@ -87,7 +99,8 @@ gimp_session_info_dock_serialize (GimpConfigWriter *writer,
GTokenType GTokenType
gimp_session_info_dock_deserialize (GScanner *scanner, gimp_session_info_dock_deserialize (GScanner *scanner,
gint scope, gint scope,
GimpSessionInfoDock **dock_info) GimpSessionInfoDock **dock_info,
const gchar *identifier)
{ {
GTokenType token; GTokenType token;
@ -97,7 +110,7 @@ gimp_session_info_dock_deserialize (GScanner *scanner,
g_scanner_scope_add_symbol (scanner, scope, "book", g_scanner_scope_add_symbol (scanner, scope, "book",
GINT_TO_POINTER (SESSION_INFO_BOOK)); GINT_TO_POINTER (SESSION_INFO_BOOK));
*dock_info = gimp_session_info_dock_new (); *dock_info = gimp_session_info_dock_new (identifier);
token = G_TOKEN_LEFT_PAREN; token = G_TOKEN_LEFT_PAREN;
@ -159,7 +172,9 @@ gimp_session_info_dock_from_widget (GimpDock *dock)
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL); g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
dock_info = gimp_session_info_dock_new (); dock_info = gimp_session_info_dock_new (GIMP_IS_TOOLBOX (dock) ?
"gimp-toolbox" :
"gimp-dock");
for (list = gimp_dock_get_dockbooks (dock); list; list = g_list_next (list)) for (list = gimp_dock_get_dockbooks (dock); list; list = g_list_next (list))
{ {
@ -206,7 +221,6 @@ gimp_session_info_dock_restore (GimpSessionInfoDock *dock_info,
GdkScreen *screen, GdkScreen *screen,
GimpDockWindow *dock_window) GimpDockWindow *dock_window)
{ {
gchar *dock_id = NULL;
GtkWidget *dock = NULL; GtkWidget *dock = NULL;
GList *iter = NULL; GList *iter = NULL;
GimpUIManager *ui_manager = NULL; GimpUIManager *ui_manager = NULL;
@ -215,18 +229,11 @@ gimp_session_info_dock_restore (GimpSessionInfoDock *dock_info,
g_return_if_fail (GDK_IS_SCREEN (screen)); g_return_if_fail (GDK_IS_SCREEN (screen));
ui_manager = gimp_dock_window_get_ui_manager (GIMP_DOCK_WINDOW (dock_window)); ui_manager = gimp_dock_window_get_ui_manager (GIMP_DOCK_WINDOW (dock_window));
/* Create the dock. Always use the dock window factory for it (but
* we want to refactor away that hard-coding eventually) but the
* type of dock depends on the factory
*/
dock_id = g_strconcat ("gimp-", gimp_object_get_name (factory), NULL);
dock = gimp_dialog_factory_dialog_new (factory, dock = gimp_dialog_factory_dialog_new (factory,
screen, screen,
dock_id, dock_info->identifier,
-1 /*view_size*/, -1 /*view_size*/,
FALSE /*present*/); FALSE /*present*/);
g_free (dock_id);
g_return_if_fail (GIMP_IS_DOCK (dock)); g_return_if_fail (GIMP_IS_DOCK (dock));

8
app/widgets/gimpsessioninfo-dock.h
View File

@ -29,17 +29,21 @@
*/ */
struct _GimpSessionInfoDock struct _GimpSessionInfoDock
{ {
/* Identifier written to/read from sessionrc */
gchar *identifier;
/* list of GimpSessionInfoBook */ /* list of GimpSessionInfoBook */
GList *books; GList *books;
}; };
GimpSessionInfoDock * gimp_session_info_dock_new (void); GimpSessionInfoDock * gimp_session_info_dock_new (const gchar *identifier);
void gimp_session_info_dock_free (GimpSessionInfoDock *dock_info); void gimp_session_info_dock_free (GimpSessionInfoDock *dock_info);
void gimp_session_info_dock_serialize (GimpConfigWriter *writer, void gimp_session_info_dock_serialize (GimpConfigWriter *writer,
GimpSessionInfoDock *dock); GimpSessionInfoDock *dock);
GTokenType gimp_session_info_dock_deserialize (GScanner *scanner, GTokenType gimp_session_info_dock_deserialize (GScanner *scanner,
gint scope, gint scope,
GimpSessionInfoDock **info); GimpSessionInfoDock **info,
const gchar *identifier);
GimpSessionInfoDock * gimp_session_info_dock_from_widget (GimpDock *dock); GimpSessionInfoDock * gimp_session_info_dock_from_widget (GimpDock *dock);
void gimp_session_info_dock_restore (GimpSessionInfoDock *dock_info, void gimp_session_info_dock_restore (GimpSessionInfoDock *dock_info,
GimpDialogFactory *factory, GimpDialogFactory *factory,

14
app/widgets/gimpsessioninfo-dockable.c
View File

@ -282,15 +282,11 @@ gimp_session_info_dockable_restore (GimpSessionInfoDockable *info,
info->view_size > GIMP_VIEW_SIZE_GIGANTIC) info->view_size > GIMP_VIEW_SIZE_GIGANTIC)
info->view_size = -1; info->view_size = -1;
/* FIXME: Merge global_dock_factory and global_toolbox_factory dockable =
* somehow so we don't need this hack gimp_dialog_factory_dockable_new (gimp_dock_get_dialog_factory (dock),
*/ dock,
dockable = gimp_dialog_factory_dockable_new ((GIMP_IS_TOOLBOX (dock) ? info->identifier,
gimp_toolbox_get_dialog_factory (GIMP_TOOLBOX (dock)) : info->view_size);
gimp_dock_get_dialog_factory (dock)),
dock,
info->identifier,
info->view_size);
if (dockable) if (dockable)
{ {

36
app/widgets/gimpsessioninfo.c
View File

@ -48,7 +48,9 @@ enum
SESSION_INFO_SIZE, SESSION_INFO_SIZE,
SESSION_INFO_OPEN, SESSION_INFO_OPEN,
SESSION_INFO_AUX, SESSION_INFO_AUX,
SESSION_INFO_DOCK SESSION_INFO_DOCK,
SESSION_INFO_GIMP_DOCK,
SESSION_INFO_GIMP_TOOLBOX
}; };
#define DEFAULT_SCREEN -1 #define DEFAULT_SCREEN -1
@ -219,6 +221,12 @@ gimp_session_info_deserialize (GimpConfig *config,
GINT_TO_POINTER (SESSION_INFO_OPEN)); GINT_TO_POINTER (SESSION_INFO_OPEN));
g_scanner_scope_add_symbol (scanner, scope_id, "aux-info", g_scanner_scope_add_symbol (scanner, scope_id, "aux-info",
GINT_TO_POINTER (SESSION_INFO_AUX)); GINT_TO_POINTER (SESSION_INFO_AUX));
g_scanner_scope_add_symbol (scanner, scope_id, "gimp-dock",
GINT_TO_POINTER (SESSION_INFO_GIMP_DOCK));
g_scanner_scope_add_symbol (scanner, scope_id, "gimp-toolbox",
GINT_TO_POINTER (SESSION_INFO_GIMP_TOOLBOX));
/* For sessionrc files from version <= GIMP 2.6 */
g_scanner_scope_add_symbol (scanner, scope_id, "dock", g_scanner_scope_add_symbol (scanner, scope_id, "dock",
GINT_TO_POINTER (SESSION_INFO_DOCK)); GINT_TO_POINTER (SESSION_INFO_DOCK));
@ -276,13 +284,33 @@ gimp_session_info_deserialize (GimpConfig *config,
goto error; goto error;
break; break;
case SESSION_INFO_GIMP_TOOLBOX:
case SESSION_INFO_GIMP_DOCK:
case SESSION_INFO_DOCK: case SESSION_INFO_DOCK:
{ {
GimpSessionInfoDock *dock_info = NULL; GimpSessionInfoDock *dock_info = NULL;
const gchar *identifier = NULL;
/* Handle old sessionrc:s from versions <= GIMP 2.6 */
if (GPOINTER_TO_INT (scanner->value.v_symbol) == SESSION_INFO_DOCK &&
info->p->factory_entry &&
info->p->factory_entry->identifier &&
strcmp ("gimp-toolbox-window", info->p->factory_entry->identifier) == 0)
{
identifier = "gimp-toolbox";
}
else
{
identifier = ((GPOINTER_TO_INT (scanner->value.v_symbol) ==
SESSION_INFO_GIMP_TOOLBOX) ?
"gimp-toolbox" :
"gimp-dock");
}
g_scanner_set_scope (scanner, scope_id + 1); g_scanner_set_scope (scanner, scope_id + 1);
token = gimp_session_info_dock_deserialize (scanner, scope_id + 1, token = gimp_session_info_dock_deserialize (scanner, scope_id + 1,
&dock_info); &dock_info,
identifier);
if (token == G_TOKEN_LEFT_PAREN) if (token == G_TOKEN_LEFT_PAREN)
{ {
@ -315,6 +343,8 @@ gimp_session_info_deserialize (GimpConfig *config,
g_scanner_scope_remove_symbol (scanner, scope_id, "size"); g_scanner_scope_remove_symbol (scanner, scope_id, "size");
g_scanner_scope_remove_symbol (scanner, scope_id, "open-on-exit"); g_scanner_scope_remove_symbol (scanner, scope_id, "open-on-exit");
g_scanner_scope_remove_symbol (scanner, scope_id, "aux-info"); g_scanner_scope_remove_symbol (scanner, scope_id, "aux-info");
g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-dock");
g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-toolbox");
g_scanner_scope_remove_symbol (scanner, scope_id, "dock"); g_scanner_scope_remove_symbol (scanner, scope_id, "dock");
g_scanner_set_scope (scanner, old_scope_id); g_scanner_set_scope (scanner, old_scope_id);