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

1685 lines
56 KiB
C
Raw Blame History

/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpdockbook.c
* Copyright (C) 2001-2007 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/>.
*/
#include "config.h"
#include <string.h>
#include <gegl.h>
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "core/gimpcontext.h"
#include "core/gimpmarshal.h"
#include "gimpdialogfactory.h"
#include "gimpdnd.h"
#include "gimpdock.h"
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimpdocked.h"
#include "gimpdockcontainer.h"
#include "gimpdockwindow.h"
#include "gimphelp-ids.h"
#include "gimpmenufactory.h"
#include "gimppanedbox.h"
#include "gimpstringaction.h"
#include "gimpuimanager.h"
#include "gimpview.h"
#include "gimpwidgets-utils.h"
#include "gimp-log.h"
#include "gimp-intl.h"
#define DEFAULT_TAB_BORDER 0
#define DEFAULT_TAB_ICON_SIZE GTK_ICON_SIZE_BUTTON
#define DND_WIDGET_ICON_SIZE GTK_ICON_SIZE_BUTTON
#define MENU_WIDGET_ICON_SIZE GTK_ICON_SIZE_MENU
#define MENU_WIDGET_SPACING 4
#define TAB_HOVER_TIMEOUT 500
#define GIMP_DOCKABLE_DETACH_REF_KEY "gimp-dockable-detach-ref"
enum
{
DOCKABLE_ADDED,
DOCKABLE_REMOVED,
DOCKABLE_REORDERED,
LAST_SIGNAL
};
/* List of candidates for the automatic style, starting with the
* biggest first
*/
static const GimpTabStyle gimp_tab_style_candidates[] =
{
GIMP_TAB_STYLE_PREVIEW_BLURB,
GIMP_TAB_STYLE_PREVIEW_NAME,
GIMP_TAB_STYLE_PREVIEW
};
struct _GimpDockbookPrivate
{
GimpDock *dock;
GimpUIManager *ui_manager;
guint tab_hover_timeout;
GimpDockable *tab_hover_dockable;
GimpPanedBox *drag_handler;
/* Cache for "what actual tab style for automatic styles can we use
* for a given dockbook width
*/
gint min_width_for_style[G_N_ELEMENTS (gimp_tab_style_candidates)];
/* We need a list separate from the GtkContainer children list,
* because we need to do calculations for all dockables before we
* can add a dockable as a child, namely automatic tab style
* calculations
*/
GList *dockables;
GtkWidget *menu_button;
};
static void gimp_dockbook_dispose (GObject *object);
static void gimp_dockbook_finalize (GObject *object);
static void gimp_dockbook_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static void gimp_dockbook_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static void gimp_dockbook_drag_leave (GtkWidget *widget,
GdkDragContext *context,
guint time);
static gboolean gimp_dockbook_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time);
static gboolean gimp_dockbook_drag_drop (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time);
static gboolean gimp_dockbook_popup_menu (GtkWidget *widget);
static gboolean gimp_dockbook_menu_button_press (GimpDockbook *dockbook,
GdkEventButton *bevent,
GtkWidget *button);
static gboolean gimp_dockbook_show_menu (GimpDockbook *dockbook);
static void gimp_dockbook_menu_end (GimpDockable *dockable);
static void gimp_dockbook_dockable_added (GimpDockbook *dockbook,
GimpDockable *dockable);
static void gimp_dockbook_dockable_removed (GimpDockbook *dockbook,
GimpDockable *dockable);
static void gimp_dockbook_recreate_tab_widgets (GimpDockbook *dockbook,
gboolean only_auto);
static void gimp_dockbook_tab_drag_source_setup (GtkWidget *widget,
GimpDockable *dockable);
static void gimp_dockbook_tab_drag_begin (GtkWidget *widget,
GdkDragContext *context,
GimpDockable *dockable);
static void gimp_dockbook_tab_drag_end (GtkWidget *widget,
GdkDragContext *context,
GimpDockable *dockable);
static void gimp_dockbook_tab_drag_leave (GtkWidget *widget,
GdkDragContext *context,
guint time,
GimpDockable *dockable);
static gboolean gimp_dockbook_tab_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time,
GimpDockable *dockable);
static gboolean gimp_dockbook_tab_drag_drop (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time);
static GimpTabStyle gimp_dockbook_tab_style_to_preferred (GimpTabStyle tab_style,
GimpDockable *dockable);
static void gimp_dockbook_refresh_tab_layout_lut (GimpDockbook *dockbook);
static void gimp_dockbook_update_automatic_tab_style (GimpDockbook *dockbook);
static GtkWidget * gimp_dockable_create_event_box_tab_widget (GimpDockable *dockable,
GimpContext *context,
GimpTabStyle tab_style,
GtkIconSize size);
static GtkIconSize gimp_dockbook_get_tab_icon_size (GimpDockbook *dockbook);
static void gimp_dockbook_add_tab_timeout (GimpDockbook *dockbook,
GimpDockable *dockable);
static void gimp_dockbook_remove_tab_timeout (GimpDockbook *dockbook);
static gboolean gimp_dockbook_tab_timeout (GimpDockbook *dockbook);
static void gimp_dockbook_tab_locked_notify (GimpDockable *dockable,
GParamSpec *pspec,
GimpDockbook *dockbook);
static void gimp_dockbook_help_func (const gchar *help_id,
gpointer help_data);
static const gchar *gimp_dockbook_get_tab_style_name (GimpTabStyle tab_style);
G_DEFINE_TYPE (GimpDockbook, gimp_dockbook, GTK_TYPE_NOTEBOOK)
#define parent_class gimp_dockbook_parent_class
static guint dockbook_signals[LAST_SIGNAL] = { 0 };
static const GtkTargetEntry dialog_target_table[] = { GIMP_TARGET_DIALOG };
static void
gimp_dockbook_class_init (GimpDockbookClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
dockbook_signals[DOCKABLE_ADDED] =
g_signal_new ("dockable-added",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpDockbookClass, dockable_added),
NULL, NULL,
gimp_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_DOCKABLE);
dockbook_signals[DOCKABLE_REMOVED] =
g_signal_new ("dockable-removed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpDockbookClass, dockable_removed),
NULL, NULL,
gimp_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_DOCKABLE);
dockbook_signals[DOCKABLE_REORDERED] =
g_signal_new ("dockable-reordered",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpDockbookClass, dockable_reordered),
NULL, NULL,
gimp_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_DOCKABLE);
object_class->dispose = gimp_dockbook_dispose;
object_class->finalize = gimp_dockbook_finalize;
widget_class->size_allocate = gimp_dockbook_size_allocate;
widget_class->style_set = gimp_dockbook_style_set;
widget_class->drag_leave = gimp_dockbook_drag_leave;
widget_class->drag_motion = gimp_dockbook_drag_motion;
widget_class->drag_drop = gimp_dockbook_drag_drop;
widget_class->popup_menu = gimp_dockbook_popup_menu;
klass->dockable_added = gimp_dockbook_dockable_added;
klass->dockable_removed = gimp_dockbook_dockable_removed;
klass->dockable_reordered = NULL;
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("tab-border",
NULL, NULL,
0, G_MAXINT,
DEFAULT_TAB_BORDER,
GIMP_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_enum ("tab-icon-size",
NULL, NULL,
GTK_TYPE_ICON_SIZE,
DEFAULT_TAB_ICON_SIZE,
GIMP_PARAM_READABLE));
g_type_class_add_private (klass, sizeof (GimpDockbookPrivate));
}
static void
gimp_dockbook_init (GimpDockbook *dockbook)
{
GtkNotebook *notebook = GTK_NOTEBOOK (dockbook);
GtkWidget *image = NULL;
dockbook->p = G_TYPE_INSTANCE_GET_PRIVATE (dockbook,
GIMP_TYPE_DOCKBOOK,
GimpDockbookPrivate);
/* Various init */
gtk_notebook_popup_enable (notebook);
gtk_notebook_set_scrollable (notebook, TRUE);
gtk_notebook_set_show_border (notebook, FALSE);
gtk_notebook_set_show_tabs (notebook, TRUE);
gtk_drag_dest_set (GTK_WIDGET (dockbook),
0,
dialog_target_table, G_N_ELEMENTS (dialog_target_table),
GDK_ACTION_MOVE);
/* Menu button */
dockbook->p->menu_button = gtk_button_new ();
gtk_widget_set_can_focus (dockbook->p->menu_button, FALSE);
gtk_button_set_relief (GTK_BUTTON (dockbook->p->menu_button),
GTK_RELIEF_NONE);
gtk_notebook_set_action_widget (notebook,
dockbook->p->menu_button,
GTK_PACK_END);
gtk_widget_show (dockbook->p->menu_button);
image = gtk_image_new_from_stock (GIMP_STOCK_MENU_LEFT, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (dockbook->p->menu_button), image);
gtk_widget_show (image);
gimp_help_set_help_data (dockbook->p->menu_button, _("Configure this tab"),
GIMP_HELP_DOCK_TAB_MENU);
g_signal_connect_swapped (dockbook->p->menu_button, "button-press-event",
G_CALLBACK (gimp_dockbook_menu_button_press),
dockbook);
}
static void
gimp_dockbook_dispose (GObject *object)
{
GimpDockbook *dockbook = GIMP_DOCKBOOK (object);
gimp_dockbook_remove_tab_timeout (dockbook);
while (dockbook->p->dockables)
{
GimpDockable *dockable = dockbook->p->dockables->data;
g_object_ref (dockable);
gimp_dockbook_remove (dockbook, dockable);
gtk_widget_destroy (GTK_WIDGET (dockable));
g_object_unref (dockable);
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gimp_dockbook_finalize (GObject *object)
{
GimpDockbook *dockbook = GIMP_DOCKBOOK (object);
if (dockbook->p->ui_manager)
{
g_object_unref (dockbook->p->ui_manager);
dockbook->p->ui_manager = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_dockbook_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GimpDockbook *dockbook = GIMP_DOCKBOOK (widget);
GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
/* Update tab styles, also recreates if changed */
gimp_dockbook_update_automatic_tab_style (dockbook);
}
static void
gimp_dockbook_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
gint tab_border;
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
/* Don't attempt to construct widgets that require a GimpContext if
* we are detached from a top-level, we're either on our way to
* destruction, in which case we don't care, or we will be given a
* new parent, in which case the widget style will be reset again
* anyway, i.e. this function will be called again
*/
if (! gtk_widget_is_toplevel (gtk_widget_get_toplevel (widget)))
return;
gtk_widget_style_get (widget,
"tab-border", &tab_border,
NULL);
g_object_set (widget,
"tab-border", tab_border,
NULL);
gimp_dockbook_recreate_tab_widgets (GIMP_DOCKBOOK (widget),
FALSE /*only_auto*/);
}
static void
gimp_dockbook_drag_leave (GtkWidget *widget,
GdkDragContext *context,
guint time)
{
gimp_highlight_widget (widget, FALSE);
}
static gboolean
gimp_dockbook_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time)
{
GimpDockbook *dockbook = GIMP_DOCKBOOK (widget);
gboolean other_will_handle = FALSE;
other_will_handle = gimp_paned_box_will_handle_drag (dockbook->p->drag_handler,
widget,
context,
x, y,
time);
gdk_drag_status (context, other_will_handle ? 0 : GDK_ACTION_MOVE, time);
gimp_highlight_widget (widget, ! other_will_handle);
return other_will_handle ? FALSE : TRUE;
}
static gboolean
gimp_dockbook_drag_drop (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time)
{
GimpDockbook *dockbook = GIMP_DOCKBOOK (widget);
gboolean handled = FALSE;
if (gimp_paned_box_will_handle_drag (dockbook->p->drag_handler,
widget,
context,
x, y,
time))
{
/* Make event fall through to the drag handler */
handled = FALSE;
}
else
{
handled =
gimp_dockbook_drop_dockable (dockbook,
gtk_drag_get_source_widget (context));
}
/* We must call gtk_drag_finish() ourselves */
if (handled)
gtk_drag_finish (context, TRUE, TRUE, time);
return handled;
}
static gboolean
gimp_dockbook_popup_menu (GtkWidget *widget)
{
return gimp_dockbook_show_menu (GIMP_DOCKBOOK (widget));
}
static gboolean
gimp_dockbook_menu_button_press (GimpDockbook *dockbook,
GdkEventButton *bevent,
GtkWidget *button)
{
gboolean handled = FALSE;
if (bevent->button == 1 && bevent->type == GDK_BUTTON_PRESS)
handled = gimp_dockbook_show_menu (dockbook);
return handled;
}
static void
gimp_dockbook_menu_position (GtkMenu *menu,
gint *x,
gint *y,
gpointer data)
{
GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
gimp_button_menu_position (dockbook->p->menu_button, menu, GTK_POS_LEFT, x, y);
}
static gboolean
gimp_dockbook_show_menu (GimpDockbook *dockbook)
{
GimpUIManager *dockbook_ui_manager = NULL;
GimpUIManager *dialog_ui_manager = NULL;
const gchar *dialog_ui_path = NULL;
gpointer dialog_popup_data = FALSE;
GtkWidget *parent_menu_widget = NULL;
GtkAction *parent_menu_action = NULL;
GimpDockable *dockable = NULL;
gint page_num = -1;
dockbook_ui_manager = gimp_dockbook_get_ui_manager (dockbook);
if (! dockbook_ui_manager)
return FALSE;
parent_menu_widget =
gtk_ui_manager_get_widget (GTK_UI_MANAGER (dockbook_ui_manager),
"/dockable-popup/dockable-menu");
parent_menu_action =
gtk_ui_manager_get_action (GTK_UI_MANAGER (dockbook_ui_manager),
"/dockable-popup/dockable-menu");
if (! parent_menu_widget || ! parent_menu_action)
return FALSE;
page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
dockable = GIMP_DOCKABLE (gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook),
page_num));
if (! dockable)
return FALSE;
dialog_ui_manager = gimp_dockable_get_menu (dockable,
&dialog_ui_path,
&dialog_popup_data);
if (dialog_ui_manager && dialog_ui_path)
{
GtkWidget *child_menu_widget;
GtkAction *child_menu_action;
gchar *label;
child_menu_widget =
gtk_ui_manager_get_widget (GTK_UI_MANAGER (dialog_ui_manager),
dialog_ui_path);
if (! child_menu_widget)
{
g_warning ("%s: UI manager '%s' has now widget at path '%s'",
G_STRFUNC, dialog_ui_manager->name, dialog_ui_path);
return FALSE;
}
child_menu_action =
gtk_ui_manager_get_action (GTK_UI_MANAGER (dialog_ui_manager),
dialog_ui_path);
if (! child_menu_action)
{
g_warning ("%s: UI manager '%s' has no action at path '%s'",
G_STRFUNC, dialog_ui_manager->name, dialog_ui_path);
return FALSE;
}
g_object_get (child_menu_action,
"label", &label,
NULL);
g_object_set (parent_menu_action,
"label", label,
"stock-id", gimp_dockable_get_stock_id (dockable),
"visible", TRUE,
NULL);
g_free (label);
if (gimp_dockable_get_stock_id (dockable))
{
if (gtk_icon_theme_has_icon (gtk_icon_theme_get_default (),
gimp_dockable_get_stock_id (dockable)))
{
gtk_action_set_icon_name (parent_menu_action,
gimp_dockable_get_stock_id (dockable));
}
}
if (! GTK_IS_MENU (child_menu_widget))
{
g_warning ("%s: child_menu_widget (%p) is not a GtkMenu",
G_STRFUNC, child_menu_widget);
return FALSE;
}
{
GtkWidget *image = gimp_dockable_get_icon (dockable,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (parent_menu_widget),
image);
gtk_widget_show (image);
}
gtk_menu_item_set_submenu (GTK_MENU_ITEM (parent_menu_widget),
child_menu_widget);
gimp_ui_manager_update (dialog_ui_manager, dialog_popup_data);
}
else
{
g_object_set (parent_menu_action, "visible", FALSE, NULL);
}
/* an action callback may destroy both dockable and dockbook, so
* reference them for gimp_dockbook_menu_end()
*/
g_object_ref (dockable);
g_object_set_data_full (G_OBJECT (dockable), GIMP_DOCKABLE_DETACH_REF_KEY,
g_object_ref (dockbook),
g_object_unref);
gimp_ui_manager_update (dockbook_ui_manager, dockable);
gimp_ui_manager_ui_popup (dockbook_ui_manager, "/dockable-popup",
GTK_WIDGET (dockable),
gimp_dockbook_menu_position, dockbook,
(GDestroyNotify) gimp_dockbook_menu_end, dockable);
return TRUE;
}
static void
gimp_dockbook_menu_end (GimpDockable *dockable)
{
GimpUIManager *dialog_ui_manager;
const gchar *dialog_ui_path;
gpointer dialog_popup_data;
dialog_ui_manager = gimp_dockable_get_menu (dockable,
&dialog_ui_path,
&dialog_popup_data);
if (dialog_ui_manager && dialog_ui_path)
{
GtkWidget *child_menu_widget =
gtk_ui_manager_get_widget (GTK_UI_MANAGER (dialog_ui_manager),
dialog_ui_path);
if (child_menu_widget)
gtk_menu_detach (GTK_MENU (child_menu_widget));
}
/* release gimp_dockbook_show_menu()'s references */
g_object_set_data (G_OBJECT (dockable), GIMP_DOCKABLE_DETACH_REF_KEY, NULL);
g_object_unref (dockable);
}
static void
gimp_dockbook_dockable_added (GimpDockbook *dockbook,
GimpDockable *dockable)
{
gtk_notebook_set_current_page (GTK_NOTEBOOK (dockbook),
gtk_notebook_page_num (GTK_NOTEBOOK (dockbook),
GTK_WIDGET (dockable)));
}
static void
gimp_dockbook_dockable_removed (GimpDockbook *dockbook,
GimpDockable *dockable)
{
}
/**
* gimp_dockbook_get_dockable_tab_width:
* @dockable:
* @tab_style:
*
* Returns: Width of tab when the dockable is using the specified tab
* style.
**/
static gint
gimp_dockbook_get_dockable_tab_width (GimpDockbook *dockbook,
GimpDockable *dockable,
GimpTabStyle tab_style)
{
GtkRequisition dockable_request;
GtkWidget *tab_widget;
tab_widget =
gimp_dockable_create_event_box_tab_widget (dockable,
gimp_dock_get_context (dockbook->p->dock),
tab_style,
gimp_dockbook_get_tab_icon_size (dockbook));
/* So font-scale is applied. We can't apply styles without having a
* GdkScreen :(
*/
gimp_dock_temp_add (dockbook->p->dock, tab_widget);
gtk_widget_size_request (tab_widget, &dockable_request);
/* Also destroys the widget */
gimp_dock_temp_remove (dockbook->p->dock, tab_widget);
return dockable_request.width;
}
/**
* gimp_dockbook_tab_style_to_preferred:
* @tab_style:
* @dockable:
*
* The list of tab styles to try in automatic mode only consists of
* preview styles. For some dockables, like the tool options dockable,
* we rather want to use the icon tab styles for the automatic
* mode. This function is used to convert tab styles for such
* dockables.
*
* Returns: An icon tab style if the dockable prefers icon tab styles
* in automatic mode.
**/
static GimpTabStyle
gimp_dockbook_tab_style_to_preferred (GimpTabStyle tab_style,
GimpDockable *dockable)
{
GimpDocked *docked = GIMP_DOCKED (gtk_bin_get_child (GTK_BIN (dockable)));
if (gimp_docked_get_prefer_icon (docked))
tab_style = gimp_preview_tab_style_to_icon (tab_style);
return tab_style;
}
/**
* gimp_dockbook_refresh_tab_layout_lut:
* @dockbook:
*
* For each given set of tab widgets, there is a fixed mapping between
* the width of the dockbook and the actual tab style to use for auto
* tab widgets. This function refreshes that look-up table.
**/
static void
gimp_dockbook_refresh_tab_layout_lut (GimpDockbook *dockbook)
{
GList *auto_dockables = NULL;
GList *iter = NULL;
gint fixed_tab_style_space = 0;
int i = 0;
/* Calculate space taken by dockables with fixed tab styles */
fixed_tab_style_space = 0;
for (iter = dockbook->p->dockables; iter; iter = g_list_next (iter))
{
GimpDockable *dockable = GIMP_DOCKABLE (iter->data);
GimpTabStyle tab_style = gimp_dockable_get_tab_style (dockable);
if (tab_style == GIMP_TAB_STYLE_AUTOMATIC)
auto_dockables = g_list_prepend (auto_dockables, dockable);
else
fixed_tab_style_space +=
gimp_dockbook_get_dockable_tab_width (dockbook,
dockable,
tab_style);
}
/* Calculate space taken with auto tab style for all candidates */
for (i = 0; i < G_N_ELEMENTS (gimp_tab_style_candidates); i++)
{
gint size_with_candidate = 0;
GimpTabStyle candidate = gimp_tab_style_candidates[i];
for (iter = auto_dockables; iter; iter = g_list_next (iter))
{
GimpDockable *dockable = GIMP_DOCKABLE (iter->data);
GimpTabStyle style_to_use;
style_to_use = gimp_dockbook_tab_style_to_preferred (candidate,
dockable);
size_with_candidate +=
gimp_dockbook_get_dockable_tab_width (dockbook,
dockable,
style_to_use);
}
dockbook->p->min_width_for_style[i] =
fixed_tab_style_space + size_with_candidate;
GIMP_LOG (AUTO_TAB_STYLE, "Total tab space taken for auto tab style %s = %d",
gimp_dockbook_get_tab_style_name (candidate),
dockbook->p->min_width_for_style[i]);
}
g_list_free (auto_dockables);
}
/**
* gimp_dockbook_update_automatic_tab_style:
* @dockbook:
*
* Based on widget allocation, sets actual tab style for dockables
* with automatic tab styles. Takes care of recreating tab widgets if
* necessary.
**/
static void
gimp_dockbook_update_automatic_tab_style (GimpDockbook *dockbook)
{
GtkWidget *widget = GTK_WIDGET (dockbook);
gboolean changed = FALSE;
GList *iter = NULL;
GtkAllocation dockbook_allocation = { 0, };
GtkAllocation button_allocation = { 0, };
GimpTabStyle tab_style = 0;
int i = 0;
gint available_space = 0;
guint tab_hborder = 0;
gint xthickness = 0;
gint tab_curvature = 0;
gint focus_width = 0;
gint tab_overlap = 0;
gint tab_padding = 0;
gint border_loss = 0;
gint action_widget_size = 0;
xthickness = gtk_widget_get_style (widget)->xthickness;
g_object_get (widget,
"tab-hborder", &tab_hborder,
NULL);
gtk_widget_style_get (widget,
"tab-curvature", &tab_curvature,
"focus-line-width", &focus_width,
"tab-overlap", &tab_overlap,
NULL);
gtk_widget_get_allocation (dockbook->p->menu_button,
&button_allocation);
/* Calculate available space. Based on code in GTK+ internal
* functions gtk_notebook_size_request() and
* gtk_notebook_pages_allocate()
*/
gtk_widget_get_allocation (widget, &dockbook_allocation);
/* Border on both sides */
border_loss = gtk_container_get_border_width (GTK_CONTAINER (dockbook)) * 2;
/* Space taken by action widget */
action_widget_size = button_allocation.width + xthickness;
/* Space taken by the tabs but not the tab widgets themselves */
tab_padding = gtk_notebook_get_n_pages (GTK_NOTEBOOK (dockbook)) *
(2 * (xthickness + tab_curvature + focus_width + tab_hborder) -
tab_overlap);
available_space = dockbook_allocation.width
- border_loss
- action_widget_size
- tab_padding
- tab_overlap;
GIMP_LOG (AUTO_TAB_STYLE, "\n"
" available_space = %d where\n"
" dockbook_allocation.width = %d\n"
" border_loss = %d\n"
" action_widget_size = %d\n"
" tab_padding = %d\n"
" tab_overlap = %d\n",
available_space,
dockbook_allocation.width,
border_loss,
action_widget_size,
tab_padding,
tab_overlap);
/* Try all candidates, if we don't get any hit we still end up on
* the smallest style (which we always fall back to if we don't get
* a better match)
*/
for (i = 0; i < G_N_ELEMENTS (gimp_tab_style_candidates); i++)
{
tab_style = gimp_tab_style_candidates[i];
if (available_space > dockbook->p->min_width_for_style[i])
{
GIMP_LOG (AUTO_TAB_STYLE, "Choosing tab style %s",
gimp_dockbook_get_tab_style_name (tab_style));
break;
}
}
for (iter = dockbook->p->dockables; iter; iter = g_list_next (iter))
{
GimpDockable *dockable = GIMP_DOCKABLE (iter->data);
GimpTabStyle actual_tab_style = tab_style;
if (gimp_dockable_get_tab_style (dockable) != GIMP_TAB_STYLE_AUTOMATIC)
continue;
actual_tab_style = gimp_dockbook_tab_style_to_preferred (tab_style,
dockable);
if (gimp_dockable_set_actual_tab_style (dockable, actual_tab_style))
changed = TRUE;
}
if (changed)
gimp_dockbook_recreate_tab_widgets (dockbook,
TRUE /*only_auto*/);
}
GtkWidget *
gimp_dockbook_new (GimpMenuFactory *menu_factory)
{
GimpDockbook *dockbook;
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
dockbook = g_object_new (GIMP_TYPE_DOCKBOOK, NULL);
dockbook->p->ui_manager = gimp_menu_factory_manager_new (menu_factory,
"<Dockable>",
dockbook,
FALSE);
gimp_help_connect (GTK_WIDGET (dockbook), gimp_dockbook_help_func,
GIMP_HELP_DOCK, dockbook);
return GTK_WIDGET (dockbook);
}
GimpDock *
gimp_dockbook_get_dock (GimpDockbook *dockbook)
{
g_return_val_if_fail (GIMP_IS_DOCKBOOK (dockbook), NULL);
return dockbook->p->dock;
}
void
gimp_dockbook_set_dock (GimpDockbook *dockbook,
GimpDock *dock)
{
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
g_return_if_fail (dock == NULL || GIMP_IS_DOCK (dock));
dockbook->p->dock = dock;
}
GimpUIManager *
gimp_dockbook_get_ui_manager (GimpDockbook *dockbook)
{
g_return_val_if_fail (GIMP_IS_DOCKBOOK (dockbook), NULL);
return dockbook->p->ui_manager;
}
void
gimp_dockbook_add (GimpDockbook *dockbook,
GimpDockable *dockable,
gint position)
{
GtkWidget *tab_widget;
GtkWidget *menu_widget;
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
g_return_if_fail (dockbook->p->dock != NULL);
g_return_if_fail (GIMP_IS_DOCKABLE (dockable));
g_return_if_fail (gimp_dockable_get_dockbook (dockable) == NULL);
GIMP_LOG (DND, "Adding GimpDockable %p to GimpDockbook %p", dockable, dockbook);
/* Add to internal list before doing automatic tab style
* calculations
*/
dockbook->p->dockables = g_list_insert (dockbook->p->dockables,
dockable,
position);
gimp_dockbook_update_auto_tab_style (dockbook);
/* Create the new tab widget, it will get the correct tab style now */
tab_widget = gimp_dockbook_create_tab_widget (dockbook, dockable);
g_return_if_fail (GTK_IS_WIDGET (tab_widget));
gimp_dockable_set_drag_handler (dockable, dockbook->p->drag_handler);
/* For the notebook right-click menu, always use the icon style */
menu_widget =
gimp_dockable_create_tab_widget (dockable,
gimp_dock_get_context (dockbook->p->dock),
GIMP_TAB_STYLE_ICON_BLURB,
MENU_WIDGET_ICON_SIZE);
g_return_if_fail (GTK_IS_WIDGET (menu_widget));
if (position == -1)
{
gtk_notebook_append_page_menu (GTK_NOTEBOOK (dockbook),
GTK_WIDGET (dockable),
tab_widget,
menu_widget);
}
else
{
gtk_notebook_insert_page_menu (GTK_NOTEBOOK (dockbook),
GTK_WIDGET (dockable),
tab_widget,
menu_widget,
position);
}
gtk_widget_show (GTK_WIDGET (dockable));
gimp_dockable_set_dockbook (dockable, dockbook);
gimp_dockable_set_context (dockable, gimp_dock_get_context (dockbook->p->dock));
g_signal_connect (dockable, "notify::locked",
G_CALLBACK (gimp_dockbook_tab_locked_notify),
dockbook);
g_signal_emit (dockbook, dockbook_signals[DOCKABLE_ADDED], 0, dockable);
}
/**
* gimp_dockbook_add_from_dialog_factory:
* @dockbook: The #DockBook
* @identifiers: The dockable identifier(s)
* @position: The insert position
*
* Add a dockable from the dialog factory associated wth the dockbook.
**/
GtkWidget *
gimp_dockbook_add_from_dialog_factory (GimpDockbook *dockbook,
const gchar *identifiers,
gint position)
{
GtkWidget *dockable;
GimpDock *dock;
gchar *identifier;
gchar *p;
g_return_val_if_fail (GIMP_IS_DOCKBOOK (dockbook), NULL);
g_return_val_if_fail (identifiers != NULL, NULL);
identifier = g_strdup (identifiers);
p = strchr (identifier, '|');
if (p)
*p = '\0';
dock = gimp_dockbook_get_dock (dockbook);
dockable = gimp_dialog_factory_dockable_new (gimp_dock_get_dialog_factory (dock),
dock,
identifier, -1);
g_free (identifier);
/* Maybe gimp_dialog_factory_dockable_new() returned an already
* existing singleton dockable, so check if it already is
* attached to a dockbook.
*/
if (dockable && ! gimp_dockable_get_dockbook (GIMP_DOCKABLE (dockable)))
gimp_dockbook_add (dockbook, GIMP_DOCKABLE (dockable), position);
return dockable;
}
void
gimp_dockbook_remove (GimpDockbook *dockbook,
GimpDockable *dockable)
{
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
g_return_if_fail (GIMP_IS_DOCKABLE (dockable));
g_return_if_fail (gimp_dockable_get_dockbook (dockable) == dockbook);
GIMP_LOG (DND, "Removing GimpDockable %p from GimpDockbook %p", dockable, dockbook);
gimp_dockable_set_drag_handler (dockable, NULL);
g_object_ref (dockable);
g_signal_handlers_disconnect_by_func (dockable,
G_CALLBACK (gimp_dockbook_tab_locked_notify),
dockbook);
if (dockbook->p->tab_hover_dockable == dockable)
gimp_dockbook_remove_tab_timeout (dockbook);
gimp_dockable_set_dockbook (dockable, NULL);
gimp_dockable_set_context (dockable, NULL);
gtk_container_remove (GTK_CONTAINER (dockbook), GTK_WIDGET (dockable));
dockbook->p->dockables = g_list_remove (dockbook->p->dockables,
dockable);
g_signal_emit (dockbook, dockbook_signals[DOCKABLE_REMOVED], 0, dockable);
g_object_unref (dockable);
if (dockbook->p->dock)
{
GList *children = gtk_container_get_children (GTK_CONTAINER (dockbook));
if (children)
gimp_dockbook_update_auto_tab_style (dockbook);
else
gimp_dock_remove_book (dockbook->p->dock, dockbook);
g_list_free (children);
}
}
/**
* gimp_dockbook_update_with_context:
* @dockbook:
* @context:
*
* Set @context on all dockables in @dockbook.
**/
void
gimp_dockbook_update_with_context (GimpDockbook *dockbook,
GimpContext *context)
{
GList *children = gtk_container_get_children (GTK_CONTAINER (dockbook));
GList *iter = NULL;
for (iter = children;
iter;
iter = g_list_next (iter))
{
GimpDockable *dockable = GIMP_DOCKABLE (iter->data);
gimp_dockable_set_context (dockable, context);
}
g_list_free (children);
}
GtkWidget *
gimp_dockbook_create_tab_widget (GimpDockbook *dockbook,
GimpDockable *dockable)
{
GtkWidget *tab_widget;
GimpDockWindow *dock_window;
GtkAction *action = NULL;
tab_widget =
gimp_dockable_create_event_box_tab_widget (dockable,
gimp_dock_get_context (dockbook->p->dock),
gimp_dockable_get_actual_tab_style (dockable),
gimp_dockbook_get_tab_icon_size (dockbook));
/* EEK */
dock_window = gimp_dock_window_from_dock (dockbook->p->dock);
if (dock_window &&
gimp_dock_container_get_ui_manager (GIMP_DOCK_CONTAINER (dock_window)))
{
const gchar *dialog_id;
dialog_id = g_object_get_data (G_OBJECT (dockable),
"gimp-dialog-identifier");
if (dialog_id)
{
GimpDockContainer *dock_container;
GimpActionGroup *group;
dock_container = GIMP_DOCK_CONTAINER (dock_window);
group = gimp_ui_manager_get_action_group
(gimp_dock_container_get_ui_manager (dock_container), "dialogs");
if (group)
{
GList *actions;
GList *list;
actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group));
for (list = actions; list; list = g_list_next (list))
{
if (GIMP_IS_STRING_ACTION (list->data) &&
strstr (GIMP_STRING_ACTION (list->data)->value,
dialog_id))
{
action = list->data;
break;
}
}
g_list_free (actions);
}
}
}
if (action)
gimp_widget_set_accel_help (tab_widget, action);
else
gimp_help_set_help_data (tab_widget,
gimp_dockable_get_blurb (dockable),
gimp_dockable_get_help_id (dockable));
g_object_set_data (G_OBJECT (tab_widget), "gimp-dockable", dockable);
gimp_dockbook_tab_drag_source_setup (tab_widget, dockable);
g_signal_connect_object (tab_widget, "drag-begin",
G_CALLBACK (gimp_dockbook_tab_drag_begin),
dockable, 0);
g_signal_connect_object (tab_widget, "drag-end",
G_CALLBACK (gimp_dockbook_tab_drag_end),
dockable, 0);
g_signal_connect_object (dockable, "drag-begin",
G_CALLBACK (gimp_dockbook_tab_drag_begin),
dockable, 0);
g_signal_connect_object (dockable, "drag-end",
G_CALLBACK (gimp_dockbook_tab_drag_end),
dockable, 0);
gtk_drag_dest_set (tab_widget,
0,
dialog_target_table, G_N_ELEMENTS (dialog_target_table),
GDK_ACTION_MOVE);
g_signal_connect_object (tab_widget, "drag-leave",
G_CALLBACK (gimp_dockbook_tab_drag_leave),
dockable, 0);
g_signal_connect_object (tab_widget, "drag-motion",
G_CALLBACK (gimp_dockbook_tab_drag_motion),
dockable, 0);
g_signal_connect_object (tab_widget, "drag-drop",
G_CALLBACK (gimp_dockbook_tab_drag_drop),
dockbook, 0);
return tab_widget;
}
/**
* gimp_dockbook_update_auto_tab_style:
* @dockbook:
*
* Refresh the table that we use to map dockbook width to actual auto
* tab style, then update auto tabs (also recreate tab widgets if
* necessary).
**/
void
gimp_dockbook_update_auto_tab_style (GimpDockbook *dockbook)
{
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
gimp_dockbook_refresh_tab_layout_lut (dockbook);
gimp_dockbook_update_automatic_tab_style (dockbook);
}
gboolean
gimp_dockbook_drop_dockable (GimpDockbook *dockbook,
GtkWidget *drag_source)
{
g_return_val_if_fail (GIMP_IS_DOCKBOOK (dockbook), FALSE);
if (drag_source)
{
GimpDockable *dockable =
gimp_dockbook_drag_source_to_dockable (drag_source);
if (dockable)
{
if (gimp_dockable_get_dockbook (dockable) == dockbook)
{
gtk_notebook_reorder_child (GTK_NOTEBOOK (dockbook),
GTK_WIDGET (dockable), -1);
}
else
{
g_object_ref (dockable);
gimp_dockbook_remove (gimp_dockable_get_dockbook (dockable), dockable);
gimp_dockbook_add (dockbook, dockable, -1);
g_object_unref (dockable);
}
return TRUE;
}
}
return FALSE;
}
/**
* gimp_dockable_set_drag_handler:
* @dockable:
* @handler:
*
* Set a drag handler that will be asked if it will handle drag events
* before the dockbook handles the event itself.
**/
void
gimp_dockbook_set_drag_handler (GimpDockbook *dockbook,
GimpPanedBox *drag_handler)
{
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
dockbook->p->drag_handler = drag_handler;
}
/**
* gimp_dockbook_drag_source_to_dockable:
* @drag_source: A drag-and-drop source widget
*
* Gets the dockable associated with a drag-and-drop source. If
* successful, the function will also cleanup the dockable.
*
* Returns: The dockable
**/
GimpDockable *
gimp_dockbook_drag_source_to_dockable (GtkWidget *drag_source)
{
GimpDockable *dockable = NULL;
if (GIMP_IS_DOCKABLE (drag_source))
dockable = GIMP_DOCKABLE (drag_source);
else
dockable = g_object_get_data (G_OBJECT (drag_source),
"gimp-dockable");
if (dockable)
g_object_set_data (G_OBJECT (dockable),
"gimp-dock-drag-widget", NULL);
return dockable;
}
/* tab DND source side */
static void
gimp_dockbook_recreate_tab_widgets (GimpDockbook *dockbook,
gboolean only_auto)
{
GList *dockables = gtk_container_get_children (GTK_CONTAINER (dockbook));
GList *iter = NULL;
for (iter = dockables; iter; iter = g_list_next (iter))
{
GimpDockable *dockable = GIMP_DOCKABLE (iter->data);
GtkWidget *tab_widget;
if (only_auto &&
! gimp_dockable_get_tab_style (dockable) == GIMP_TAB_STYLE_AUTOMATIC)
continue;
tab_widget = gimp_dockbook_create_tab_widget (dockbook, dockable);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (dockbook),
GTK_WIDGET (dockable),
tab_widget);
}
g_list_free (dockables);
}
static void
gimp_dockbook_tab_drag_source_setup (GtkWidget *widget,
GimpDockable *dockable)
{
if (gimp_dockable_is_locked (dockable))
{
if (widget)
gtk_drag_source_unset (widget);
gtk_drag_source_unset (GTK_WIDGET (dockable));
}
else
{
if (widget)
gtk_drag_source_set (widget,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
dialog_target_table,
G_N_ELEMENTS (dialog_target_table),
GDK_ACTION_MOVE);
gtk_drag_source_set (GTK_WIDGET (dockable),
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
dialog_target_table,
G_N_ELEMENTS (dialog_target_table),
GDK_ACTION_MOVE);
}
}
static void
gimp_dockbook_tab_drag_begin (GtkWidget *widget,
GdkDragContext *context,
GimpDockable *dockable)
{
GtkAllocation allocation;
GtkWidget *window;
GtkWidget *view;
GtkRequisition requisition;
gint drag_x;
gint drag_y;
gtk_widget_get_allocation (widget, &allocation);
window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DND);
gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (widget));
view = gimp_dockable_create_drag_widget (dockable);
gtk_container_add (GTK_CONTAINER (window), view);
gtk_widget_show (view);
gtk_widget_size_request (view, &requisition);
if (requisition.width < allocation.width)
gtk_widget_set_size_request (view, allocation.width, -1);
gtk_widget_show (window);
g_object_set_data_full (G_OBJECT (dockable), "gimp-dock-drag-widget",
window,
(GDestroyNotify) gtk_widget_destroy);
gimp_dockable_get_drag_pos (dockable, &drag_x, &drag_y);
gtk_drag_set_icon_widget (context, window, drag_x, drag_y);
/*
* Set the source dockable insensitive to give a visual clue that
* it's the dockable that's being dragged around
*/
gtk_widget_set_sensitive (GTK_WIDGET (dockable), FALSE);
}
static void
gimp_dockbook_tab_drag_end (GtkWidget *widget,
GdkDragContext *context,
GimpDockable *dockable)
{
GtkWidget *drag_widget;
drag_widget = g_object_get_data (G_OBJECT (dockable),
"gimp-dock-drag-widget");
/* finding the drag_widget means the drop was not successful, so
* pop up a new dock and move the dockable there
*/
if (drag_widget)
{
g_object_set_data (G_OBJECT (dockable), "gimp-dock-drag-widget", NULL);
gimp_dockable_detach (dockable);
}
gimp_dockable_set_drag_pos (dockable,
GIMP_DOCKABLE_DRAG_OFFSET,
GIMP_DOCKABLE_DRAG_OFFSET);
gtk_widget_set_sensitive (GTK_WIDGET (dockable), TRUE);
}
/* tab DND target side */
static void
gimp_dockbook_tab_drag_leave (GtkWidget *widget,
GdkDragContext *context,
guint time,
GimpDockable *dockable)
{
GimpDockbook *dockbook = gimp_dockable_get_dockbook (dockable);
gimp_dockbook_remove_tab_timeout (dockbook);
gimp_highlight_widget (widget, FALSE);
}
static gboolean
gimp_dockbook_tab_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time,
GimpDockable *dockable)
{
GimpDockbook *dockbook = gimp_dockable_get_dockbook (dockable);
GtkTargetList *target_list;
GdkAtom target_atom;
gboolean handle = FALSE;
/* If the handler will handle the drag, return FALSE */
if (gimp_paned_box_will_handle_drag (dockbook->p->drag_handler,
widget,
context,
x, y,
time))
{
handle = FALSE;
goto finish;
}
if (! dockbook->p->tab_hover_timeout ||
dockbook->p->tab_hover_dockable != dockable)
{
gint page_num;
gimp_dockbook_remove_tab_timeout (dockbook);
page_num = gtk_notebook_page_num (GTK_NOTEBOOK (dockbook),
GTK_WIDGET (dockable));
if (page_num != gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook)))
gimp_dockbook_add_tab_timeout (dockbook, dockable);
}
target_list = gtk_drag_dest_get_target_list (widget);
target_atom = gtk_drag_dest_find_target (widget, context, target_list);
handle = gtk_target_list_find (target_list, target_atom, NULL);
finish:
gdk_drag_status (context, handle ? GDK_ACTION_MOVE : 0, time);
gimp_highlight_widget (widget, handle);
return handle;
}
static gboolean
gimp_dockbook_tab_drag_drop (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time)
{
GimpDockable *dest_dockable;
GtkWidget *source;
gboolean handle = FALSE;
dest_dockable = g_object_get_data (G_OBJECT (widget), "gimp-dockable");
source = gtk_drag_get_source_widget (context);
/* If the handler will handle the drag, return FALSE */
if (gimp_paned_box_will_handle_drag (gimp_dockable_get_drag_handler (dest_dockable),
widget,
context,
x, y,
time))
{
handle = FALSE;
goto finish;
}
if (dest_dockable && source)
{
GimpDockable *src_dockable =
gimp_dockbook_drag_source_to_dockable (source);
if (src_dockable)
{
gint dest_index;
dest_index =
gtk_notebook_page_num (GTK_NOTEBOOK (gimp_dockable_get_dockbook (dest_dockable)),
GTK_WIDGET (dest_dockable));
if (gimp_dockable_get_dockbook (src_dockable) !=
gimp_dockable_get_dockbook (dest_dockable))
{
g_object_ref (src_dockable);
gimp_dockbook_remove (gimp_dockable_get_dockbook (src_dockable), src_dockable);
gimp_dockbook_add (gimp_dockable_get_dockbook (dest_dockable), src_dockable,
dest_index);
g_object_unref (src_dockable);
handle = TRUE;
}
else if (src_dockable != dest_dockable)
{
gtk_notebook_reorder_child (GTK_NOTEBOOK (gimp_dockable_get_dockbook (src_dockable)),
GTK_WIDGET (src_dockable),
dest_index);
g_signal_emit (gimp_dockable_get_dockbook (src_dockable),
dockbook_signals[DOCKABLE_REORDERED], 0,
src_dockable);
handle = TRUE;
}
}
}
finish:
if (handle)
gtk_drag_finish (context, TRUE, TRUE, time);
return handle;
}
static GtkWidget *
gimp_dockable_create_event_box_tab_widget (GimpDockable *dockable,
GimpContext *context,
GimpTabStyle tab_style,
GtkIconSize size)
{
GtkWidget *tab_widget;
tab_widget =
gimp_dockable_create_tab_widget (dockable,
context,
tab_style,
size);
if (! GIMP_IS_VIEW (tab_widget))
{
GtkWidget *event_box;
event_box = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
gtk_event_box_set_above_child (GTK_EVENT_BOX (event_box), TRUE);
gtk_container_add (GTK_CONTAINER (event_box), tab_widget);
gtk_widget_show (tab_widget);
tab_widget = event_box;
}
return tab_widget;
}
static GtkIconSize
gimp_dockbook_get_tab_icon_size (GimpDockbook *dockbook)
{
GtkIconSize tab_size = DEFAULT_TAB_ICON_SIZE;
gtk_widget_style_get (GTK_WIDGET (dockbook),
"tab-icon-size", &tab_size,
NULL);
return tab_size;
}
static void
gimp_dockbook_add_tab_timeout (GimpDockbook *dockbook,
GimpDockable *dockable)
{
dockbook->p->tab_hover_timeout =
g_timeout_add (TAB_HOVER_TIMEOUT,
(GSourceFunc) gimp_dockbook_tab_timeout,
dockbook);
dockbook->p->tab_hover_dockable = dockable;
}
static void
gimp_dockbook_remove_tab_timeout (GimpDockbook *dockbook)
{
if (dockbook->p->tab_hover_timeout)
{
g_source_remove (dockbook->p->tab_hover_timeout);
dockbook->p->tab_hover_timeout = 0;
dockbook->p->tab_hover_dockable = NULL;
}
}
static gboolean
gimp_dockbook_tab_timeout (GimpDockbook *dockbook)
{
gint page_num;
GDK_THREADS_ENTER ();
page_num = gtk_notebook_page_num (GTK_NOTEBOOK (dockbook),
GTK_WIDGET (dockbook->p->tab_hover_dockable));
gtk_notebook_set_current_page (GTK_NOTEBOOK (dockbook), page_num);
dockbook->p->tab_hover_timeout = 0;
dockbook->p->tab_hover_dockable = NULL;
GDK_THREADS_LEAVE ();
return FALSE;
}
static void
gimp_dockbook_tab_locked_notify (GimpDockable *dockable,
GParamSpec *pspec,
GimpDockbook *dockbook)
{
GtkWidget *tab_widget;
tab_widget = gtk_notebook_get_tab_label (GTK_NOTEBOOK (dockbook),
GTK_WIDGET (dockable));
gimp_dockbook_tab_drag_source_setup (tab_widget, dockable);
}
static void
gimp_dockbook_help_func (const gchar *help_id,
gpointer help_data)
{
GimpDockbook *dockbook = GIMP_DOCKBOOK (help_data);
GtkWidget *dockable;
gint page_num;
page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
dockable = gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook), page_num);
if (GIMP_IS_DOCKABLE (dockable))
gimp_standard_help_func (gimp_dockable_get_help_id (GIMP_DOCKABLE (dockable)),
NULL);
else
gimp_standard_help_func (GIMP_HELP_DOCK, NULL);
}
static const gchar *
gimp_dockbook_get_tab_style_name (GimpTabStyle tab_style)
{
return g_enum_get_value (g_type_class_peek (GIMP_TYPE_TAB_STYLE),
tab_style)->value_name;
}
Reference in New Issue View Git Blame Copy Permalink