#include "config.h"
+#include "gtknotebook.h"
+
#include <stdio.h>
#include <string.h>
#include <gdk/gdkkeysyms.h>
-#include "gtknotebook.h"
#include "gtkmain.h"
#include "gtkmenu.h"
#include "gtkmenuitem.h"
#include "gtkdnd.h"
#include "gtkbuildable.h"
+
+/**
+ * SECTION:gtknotebook
+ * @Short_description: A tabbed notebook container
+ * @Title: GtkNotebook
+ * @See_also: #GtkContainer
+ *
+ * The #GtkNotebook widget is a #GtkContainer whose children are pages that
+ * can be switched between using tab labels along one edge.
+ *
+ * There are many configuration options for GtkNotebook. Among other
+ * things, you can choose on which edge the tabs appear
+ * (see gtk_notebook_set_tab_pos()), whether, if there are too many
+ * tabs to fit the notebook should be made bigger or scrolling
+ * arrows added (see gtk_notebook_set_scrollable()), and whether there
+ * will be a popup menu allowing the users to switch pages.
+ * (see gtk_notebook_popup_enable(), gtk_notebook_popup_disable())
+ *
+ * <refsect2 id="GtkNotebook-BUILDER-UI">
+ * <title>GtkNotebook as GtkBuildable</title>
+ * <para>
+ * The GtkNotebook implementation of the #GtkBuildable interface
+ * supports placing children into tabs by specifying "tab" as the
+ * "type" attribute of a <child> element. Note that the content
+ * of the tab must be created before the tab can be filled.
+ * A tab child can be specified without specifying a <child>
+ * type attribute.
+ *
+ * To add a child widget in the notebooks action area, specify
+ * "action-start" or "action-end" as the "type" attribute of the <child>
+ * element.
+ * </para>
+ * <example>
+ * <title>A UI definition fragment with GtkNotebook</title>
+ * <programlisting><![CDATA[
+ * <object class="GtkNotebook">
+ * <child>
+ * <object class="GtkLabel" id="notebook-content">
+ * <property name="label">Content</property>
+ * </object>
+ * </child>
+ * <child type="tab">
+ * <object class="GtkLabel" id="notebook-tab">
+ * <property name="label">Tab</property>
+ * </object>
+ * </child>
+ * </object>
+ * ]]></programlisting>
+ * </example>
+ * </refsect2>
+ */
+
+
#define SCROLL_DELAY_FACTOR 5
#define SCROLL_THRESHOLD 12
#define DND_THRESHOLD_MULTIPLIER 4
N_ACTION_WIDGETS
};
-struct _GtkNotebookPriv
+struct _GtkNotebookPrivate
{
GtkNotebookDragOperation operation;
GtkNotebookPage *cur_page;
gint mouse_y;
gint pressed_button;
- gpointer group;
+ GQuark group;
guint dnd_timer;
guint switch_tab_timer;
PROP_SCROLLABLE,
PROP_PAGE,
PROP_ENABLE_POPUP,
- PROP_GROUP,
+ PROP_GROUP_NAME
};
enum {
#define PAGE_TOP_Y(_page_) (((GtkNotebookPage *) (_page_))->allocation.y)
#define PAGE_BOTTOM_Y(_page_) (((GtkNotebookPage *) (_page_))->allocation.y + ((GtkNotebookPage *) (_page_))->allocation.height)
#define PAGE_MIDDLE_Y(_page_) (((GtkNotebookPage *) (_page_))->allocation.y + ((GtkNotebookPage *) (_page_))->allocation.height / 2)
-#define NOTEBOOK_IS_TAB_LABEL_PARENT(_notebook_,_page_) (((GtkNotebookPage *) (_page_))->tab_label->parent == ((GtkWidget *) (_notebook_)))
+#define NOTEBOOK_IS_TAB_LABEL_PARENT(_notebook_,_page_) (gtk_widget_get_parent (((GtkNotebookPage *) (_page_))->tab_label) == ((GtkWidget *) (_notebook_)))
struct _GtkNotebookPage
{
gboolean *fill,
GtkPackType *pack_type);
-/*** GtkObject Methods ***/
-static void gtk_notebook_destroy (GtkObject *object);
+/*** GObject Methods ***/
static void gtk_notebook_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
/*** GtkWidget Methods ***/
+static void gtk_notebook_destroy (GtkWidget *widget);
static void gtk_notebook_map (GtkWidget *widget);
static void gtk_notebook_unmap (GtkWidget *widget);
static void gtk_notebook_realize (GtkWidget *widget);
static void gtk_notebook_unrealize (GtkWidget *widget);
static void gtk_notebook_size_request (GtkWidget *widget,
GtkRequisition *requisition);
+static void gtk_notebook_get_preferred_width (GtkWidget *widget,
+ gint *minimum,
+ gint *natural);
+static void gtk_notebook_get_preferred_height(GtkWidget *widget,
+ gint *minimum,
+ gint *natural);
static void gtk_notebook_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-static gint gtk_notebook_expose (GtkWidget *widget,
- GdkEventExpose *event);
-static gboolean gtk_notebook_scroll (GtkWidget *widget,
- GdkEventScroll *event);
+static gint gtk_notebook_draw (GtkWidget *widget,
+ cairo_t *cr);
static gint gtk_notebook_button_press (GtkWidget *widget,
GdkEventButton *event);
static gint gtk_notebook_button_release (GtkWidget *widget,
GdkEventFocus *event);
static void gtk_notebook_grab_notify (GtkWidget *widget,
gboolean was_grabbed);
-static void gtk_notebook_state_changed (GtkWidget *widget,
- GtkStateType previous_state);
-static void gtk_notebook_draw_focus (GtkWidget *widget,
- GdkEventExpose *event);
+static void gtk_notebook_state_flags_changed (GtkWidget *widget,
+ GtkStateFlags previous_state);
static gint gtk_notebook_focus (GtkWidget *widget,
GtkDirectionType direction);
-static void gtk_notebook_style_set (GtkWidget *widget,
- GtkStyle *previous);
+static void gtk_notebook_style_updated (GtkWidget *widget);
/*** Drag and drop Methods ***/
static void gtk_notebook_drag_begin (GtkWidget *widget,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
+static GtkWidgetPath * gtk_notebook_get_path_for_child (GtkContainer *container,
+ GtkWidget *widget);
/*** GtkNotebook Methods ***/
static gint gtk_notebook_real_insert_page (GtkNotebook *notebook,
/*** GtkNotebook Drawing Functions ***/
static void gtk_notebook_paint (GtkWidget *widget,
- GdkRectangle *area);
+ cairo_t *cr);
static void gtk_notebook_draw_tab (GtkNotebook *notebook,
GtkNotebookPage *page,
- GdkRectangle *area);
+ cairo_t *cr,
+ GtkRegionFlags flags);
static void gtk_notebook_draw_arrow (GtkNotebook *notebook,
+ cairo_t *cr,
GtkNotebookArrow arrow);
/*** GtkNotebook Size Allocate Functions ***/
GObject *child,
const gchar *type);
-static GtkNotebookWindowCreationFunc window_creation_hook = NULL;
-static gpointer window_creation_hook_data;
-static GDestroyNotify window_creation_hook_destroy = NULL;
-
static guint notebook_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE_WITH_CODE (GtkNotebook, gtk_notebook, GTK_TYPE_CONTAINER,
GdkModifierType modifiers,
GtkDirectionType direction)
{
- gtk_binding_entry_add_signal (binding_set, GDK_Tab, modifiers,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Tab, modifiers,
"move_focus_out", 1,
GTK_TYPE_DIRECTION_TYPE, direction);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, modifiers,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Tab, modifiers,
"move_focus_out", 1,
GTK_TYPE_DIRECTION_TYPE, direction);
}
guint keysym,
GtkDirectionType direction)
{
- guint keypad_keysym = keysym - GDK_Left + GDK_KP_Left;
+ guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;
gtk_binding_entry_add_signal (binding_set, keysym, GDK_CONTROL_MASK,
"move_focus_out", 1,
GtkDirectionType direction,
gboolean move_to_last)
{
- guint keypad_keysym = keysym - GDK_Left + GDK_KP_Left;
+ guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;
gtk_binding_entry_add_signal (binding_set, keysym, GDK_MOD1_MASK,
"reorder_tab", 2,
return continue_emission;
}
+static void
+gtk_notebook_compute_expand (GtkWidget *widget,
+ gboolean *hexpand_p,
+ gboolean *vexpand_p)
+{
+ GtkNotebook *notebook = GTK_NOTEBOOK (widget);
+ GtkNotebookPrivate *priv = notebook->priv;
+ gboolean hexpand;
+ gboolean vexpand;
+ GList *list;
+ GtkNotebookPage *page;
+
+ hexpand = FALSE;
+ vexpand = FALSE;
+
+ for (list = priv->children; list; list = list->next)
+ {
+ page = list->data;
+
+ hexpand = hexpand ||
+ gtk_widget_compute_expand (page->child, GTK_ORIENTATION_HORIZONTAL);
+
+ vexpand = vexpand ||
+ gtk_widget_compute_expand (page->child, GTK_ORIENTATION_VERTICAL);
+
+ if (hexpand & vexpand)
+ break;
+ }
+
+ *hexpand_p = hexpand;
+ *vexpand_p = vexpand;
+}
+
static void
gtk_notebook_class_init (GtkNotebookClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
- GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
GtkContainerClass *container_class = GTK_CONTAINER_CLASS (class);
GtkBindingSet *binding_set;
gobject_class->set_property = gtk_notebook_set_property;
gobject_class->get_property = gtk_notebook_get_property;
- object_class->destroy = gtk_notebook_destroy;
+ widget_class->destroy = gtk_notebook_destroy;
widget_class->map = gtk_notebook_map;
widget_class->unmap = gtk_notebook_unmap;
widget_class->realize = gtk_notebook_realize;
widget_class->unrealize = gtk_notebook_unrealize;
- widget_class->size_request = gtk_notebook_size_request;
+ widget_class->get_preferred_width = gtk_notebook_get_preferred_width;
+ widget_class->get_preferred_height = gtk_notebook_get_preferred_height;
widget_class->size_allocate = gtk_notebook_size_allocate;
- widget_class->expose_event = gtk_notebook_expose;
- widget_class->scroll_event = gtk_notebook_scroll;
+ widget_class->draw = gtk_notebook_draw;
widget_class->button_press_event = gtk_notebook_button_press;
widget_class->button_release_event = gtk_notebook_button_release;
widget_class->popup_menu = gtk_notebook_popup_menu;
widget_class->leave_notify_event = gtk_notebook_leave_notify;
widget_class->motion_notify_event = gtk_notebook_motion_notify;
widget_class->grab_notify = gtk_notebook_grab_notify;
- widget_class->state_changed = gtk_notebook_state_changed;
+ widget_class->state_flags_changed = gtk_notebook_state_flags_changed;
widget_class->focus_in_event = gtk_notebook_focus_in;
widget_class->focus_out_event = gtk_notebook_focus_out;
widget_class->focus = gtk_notebook_focus;
- widget_class->style_set = gtk_notebook_style_set;
+ widget_class->style_updated = gtk_notebook_style_updated;
widget_class->drag_begin = gtk_notebook_drag_begin;
widget_class->drag_end = gtk_notebook_drag_end;
widget_class->drag_motion = gtk_notebook_drag_motion;
widget_class->drag_drop = gtk_notebook_drag_drop;
widget_class->drag_data_get = gtk_notebook_drag_data_get;
widget_class->drag_data_received = gtk_notebook_drag_data_received;
+ widget_class->compute_expand = gtk_notebook_compute_expand;
container_class->add = gtk_notebook_add;
container_class->remove = gtk_notebook_remove;
container_class->get_child_property = gtk_notebook_get_child_property;
container_class->set_child_property = gtk_notebook_set_child_property;
container_class->child_type = gtk_notebook_child_type;
+ container_class->get_path_for_child = gtk_notebook_get_path_for_child;
class->switch_page = gtk_notebook_real_switch_page;
class->insert_page = gtk_notebook_real_insert_page;
PROP_SHOW_TABS,
g_param_spec_boolean ("show-tabs",
P_("Show Tabs"),
- P_("Whether tabs should be shown or not"),
+ P_("Whether tabs should be shown"),
TRUE,
GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHOW_BORDER,
g_param_spec_boolean ("show-border",
P_("Show Border"),
- P_("Whether the border should be shown or not"),
+ P_("Whether the border should be shown"),
TRUE,
GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
GTK_PARAM_READWRITE));
/**
- * GtkNotebook:group:
- *
- * Group for tabs drag and drop.
+ * GtkNotebook:group-name:
*
- * Since: 2.12
- */
+ * Group name for tab drag and drop.
+ *
+ * Since: 2.24
+ */
g_object_class_install_property (gobject_class,
- PROP_GROUP,
- g_param_spec_pointer ("group",
- P_("Group"),
- P_("Group for tabs drag and drop"),
- GTK_PARAM_READWRITE));
+ PROP_GROUP_NAME,
+ g_param_spec_string ("group-name",
+ P_("Group Name"),
+ P_("Group name for tab drag and drop"),
+ NULL,
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_TAB_LABEL,
CHILD_PROP_TAB_EXPAND,
g_param_spec_boolean ("tab-expand",
P_("Tab expand"),
- P_("Whether to expand the child's tab or not"),
+ P_("Whether to expand the child's tab"),
FALSE,
GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_TAB_FILL,
g_param_spec_boolean ("tab-fill",
P_("Tab fill"),
- P_("Whether the child's tab should fill the allocated area or not"),
+ P_("Whether the child's tab should fill the allocated area"),
TRUE,
GTK_PARAM_READWRITE));
+
+ /**
+ * GtkNotebook:tab-pack:
+ *
+ * Deprecated: 2.20: The tab packing functionality of children should not
+ * be used anymore and support will be removed in the future.
+ */
gtk_container_class_install_child_property (container_class,
CHILD_PROP_TAB_PACK,
g_param_spec_enum ("tab-pack",
CHILD_PROP_REORDERABLE,
g_param_spec_boolean ("reorderable",
P_("Tab reorderable"),
- P_("Whether the tab is reorderable by user action or not"),
+ P_("Whether the tab is reorderable by user action"),
FALSE,
GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
0,
GTK_PARAM_READABLE));
+ /**
+ * GtkNotebook::switch-page:
+ * @notebook: the object which received the signal.
+ * @page: the new current page
+ * @page_num: the index of the page
+ *
+ * Emitted when the user or a function changes the current page.
+ */
notebook_signals[SWITCH_PAGE] =
g_signal_new (I_("switch-page"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkNotebookClass, switch_page),
NULL, NULL,
- _gtk_marshal_VOID__POINTER_UINT,
+ _gtk_marshal_VOID__OBJECT_UINT,
G_TYPE_NONE, 2,
GTK_TYPE_WIDGET,
G_TYPE_UINT);
g_signal_new (I_("page-reordered"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
- 0, NULL, NULL,
- _gtk_marshal_VOID__OBJECT_UINT,
+ G_STRUCT_OFFSET (GtkNotebookClass, page_reordered),
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT_UINT,
G_TYPE_NONE, 2,
- GTK_TYPE_WIDGET,
- G_TYPE_UINT);
+ GTK_TYPE_WIDGET,
+ G_TYPE_UINT);
/**
* GtkNotebook::page-removed:
* @notebook: the #GtkNotebook
g_signal_new (I_("page-removed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
- 0, NULL, NULL,
- _gtk_marshal_VOID__OBJECT_UINT,
+ G_STRUCT_OFFSET (GtkNotebookClass, page_removed),
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT_UINT,
G_TYPE_NONE, 2,
- GTK_TYPE_WIDGET,
- G_TYPE_UINT);
+ GTK_TYPE_WIDGET,
+ G_TYPE_UINT);
/**
* GtkNotebook::page-added:
* @notebook: the #GtkNotebook
g_signal_new (I_("page-added"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
- 0, NULL, NULL,
- _gtk_marshal_VOID__OBJECT_UINT,
+ G_STRUCT_OFFSET (GtkNotebookClass, page_added),
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT_UINT,
G_TYPE_NONE, 2,
- GTK_TYPE_WIDGET,
- G_TYPE_UINT);
+ GTK_TYPE_WIDGET,
+ G_TYPE_UINT);
/**
* GtkNotebook::create-window:
* necessary properties to the notebook (e.g. the
* #GtkNotebook:group ).
*
- * The default handler uses the global window creation hook,
- * if one has been set with gtk_notebook_set_window_creation_hook().
- *
* Returns: a #GtkNotebook that @page should be added to, or %NULL.
*
* Since: 2.12
binding_set = gtk_binding_set_by_class (class);
gtk_binding_entry_add_signal (binding_set,
- GDK_space, 0,
+ GDK_KEY_space, 0,
"select-page", 1,
G_TYPE_BOOLEAN, FALSE);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Space, 0,
+ GDK_KEY_KP_Space, 0,
"select-page", 1,
G_TYPE_BOOLEAN, FALSE);
gtk_binding_entry_add_signal (binding_set,
- GDK_Home, 0,
+ GDK_KEY_Home, 0,
"focus-tab", 1,
GTK_TYPE_NOTEBOOK_TAB, GTK_NOTEBOOK_TAB_FIRST);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Home, 0,
+ GDK_KEY_KP_Home, 0,
"focus-tab", 1,
GTK_TYPE_NOTEBOOK_TAB, GTK_NOTEBOOK_TAB_FIRST);
gtk_binding_entry_add_signal (binding_set,
- GDK_End, 0,
+ GDK_KEY_End, 0,
"focus-tab", 1,
GTK_TYPE_NOTEBOOK_TAB, GTK_NOTEBOOK_TAB_LAST);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_End, 0,
+ GDK_KEY_KP_End, 0,
"focus-tab", 1,
GTK_TYPE_NOTEBOOK_TAB, GTK_NOTEBOOK_TAB_LAST);
gtk_binding_entry_add_signal (binding_set,
- GDK_Page_Up, GDK_CONTROL_MASK,
+ GDK_KEY_Page_Up, GDK_CONTROL_MASK,
"change-current-page", 1,
G_TYPE_INT, -1);
gtk_binding_entry_add_signal (binding_set,
- GDK_Page_Down, GDK_CONTROL_MASK,
+ GDK_KEY_Page_Down, GDK_CONTROL_MASK,
"change-current-page", 1,
G_TYPE_INT, 1);
gtk_binding_entry_add_signal (binding_set,
- GDK_Page_Up, GDK_CONTROL_MASK | GDK_MOD1_MASK,
+ GDK_KEY_Page_Up, GDK_CONTROL_MASK | GDK_MOD1_MASK,
"change-current-page", 1,
G_TYPE_INT, -1);
gtk_binding_entry_add_signal (binding_set,
- GDK_Page_Down, GDK_CONTROL_MASK | GDK_MOD1_MASK,
+ GDK_KEY_Page_Down, GDK_CONTROL_MASK | GDK_MOD1_MASK,
"change-current-page", 1,
G_TYPE_INT, 1);
- add_arrow_bindings (binding_set, GDK_Up, GTK_DIR_UP);
- add_arrow_bindings (binding_set, GDK_Down, GTK_DIR_DOWN);
- add_arrow_bindings (binding_set, GDK_Left, GTK_DIR_LEFT);
- add_arrow_bindings (binding_set, GDK_Right, GTK_DIR_RIGHT);
+ add_arrow_bindings (binding_set, GDK_KEY_Up, GTK_DIR_UP);
+ add_arrow_bindings (binding_set, GDK_KEY_Down, GTK_DIR_DOWN);
+ add_arrow_bindings (binding_set, GDK_KEY_Left, GTK_DIR_LEFT);
+ add_arrow_bindings (binding_set, GDK_KEY_Right, GTK_DIR_RIGHT);
- add_reorder_bindings (binding_set, GDK_Up, GTK_DIR_UP, FALSE);
- add_reorder_bindings (binding_set, GDK_Down, GTK_DIR_DOWN, FALSE);
- add_reorder_bindings (binding_set, GDK_Left, GTK_DIR_LEFT, FALSE);
- add_reorder_bindings (binding_set, GDK_Right, GTK_DIR_RIGHT, FALSE);
- add_reorder_bindings (binding_set, GDK_Home, GTK_DIR_LEFT, TRUE);
- add_reorder_bindings (binding_set, GDK_Home, GTK_DIR_UP, TRUE);
- add_reorder_bindings (binding_set, GDK_End, GTK_DIR_RIGHT, TRUE);
- add_reorder_bindings (binding_set, GDK_End, GTK_DIR_DOWN, TRUE);
+ add_reorder_bindings (binding_set, GDK_KEY_Up, GTK_DIR_UP, FALSE);
+ add_reorder_bindings (binding_set, GDK_KEY_Down, GTK_DIR_DOWN, FALSE);
+ add_reorder_bindings (binding_set, GDK_KEY_Left, GTK_DIR_LEFT, FALSE);
+ add_reorder_bindings (binding_set, GDK_KEY_Right, GTK_DIR_RIGHT, FALSE);
+ add_reorder_bindings (binding_set, GDK_KEY_Home, GTK_DIR_LEFT, TRUE);
+ add_reorder_bindings (binding_set, GDK_KEY_Home, GTK_DIR_UP, TRUE);
+ add_reorder_bindings (binding_set, GDK_KEY_End, GTK_DIR_RIGHT, TRUE);
+ add_reorder_bindings (binding_set, GDK_KEY_End, GTK_DIR_DOWN, TRUE);
add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
- g_type_class_add_private (class, sizeof (GtkNotebookPriv));
+ g_type_class_add_private (class, sizeof (GtkNotebookPrivate));
}
static void
gtk_notebook_init (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
+ GtkStyleContext *context;
gtk_widget_set_can_focus (GTK_WIDGET (notebook), TRUE);
gtk_widget_set_has_window (GTK_WIDGET (notebook), FALSE);
notebook->priv = G_TYPE_INSTANCE_GET_PRIVATE (notebook,
GTK_TYPE_NOTEBOOK,
- GtkNotebookPriv);
+ GtkNotebookPrivate);
priv = notebook->priv;
priv->cur_page = NULL;
priv->has_after_previous = 0;
priv->has_after_next = 1;
- priv->group = NULL;
+ priv->group = 0;
priv->pressed_button = -1;
priv->dnd_timer = 0;
priv->switch_tab_timer = 0;
G_CALLBACK (gtk_notebook_drag_failed), NULL);
gtk_drag_dest_set_track_motion (GTK_WIDGET (notebook), TRUE);
+
+ context = gtk_widget_get_style_context (GTK_WIDGET (notebook));
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_NOTEBOOK);
}
static void
gtk_notebook_select_page (GtkNotebook *notebook,
gboolean move_focus)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (gtk_widget_is_focus (GTK_WIDGET (notebook)) && priv->show_tabs)
{
gtk_notebook_focus_tab (GtkNotebook *notebook,
GtkNotebookTab type)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
if (gtk_widget_is_focus (GTK_WIDGET (notebook)) && priv->show_tabs)
gtk_notebook_change_current_page (GtkNotebook *notebook,
gint offset)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *current = NULL;
if (!priv->show_tabs)
get_effective_direction (GtkNotebook *notebook,
GtkDirectionType direction)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
/* Remap the directions into the effective direction it would be for a
* GTK_POS_TOP notebook
static gint
get_effective_tab_pos (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (gtk_widget_get_direction (GTK_WIDGET (notebook)) == GTK_TEXT_DIR_RTL)
{
gtk_notebook_move_focus_out (GtkNotebook *notebook,
GtkDirectionType direction_type)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkDirectionType effective_direction = get_effective_direction (notebook, direction_type);
GtkWidget *toplevel;
- if (GTK_CONTAINER (notebook)->focus_child && effective_direction == GTK_DIR_UP)
+ if (gtk_container_get_focus_child (GTK_CONTAINER (notebook)) && effective_direction == GTK_DIR_UP)
if (focus_tabs_in (notebook))
return;
if (gtk_widget_is_focus (GTK_WIDGET (notebook)) && effective_direction == GTK_DIR_DOWN)
static gint
reorder_tab (GtkNotebook *notebook, GList *position, GList *tab)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *elem;
if (position == tab)
GtkDirectionType direction_type,
gboolean move_to_last)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkDirectionType effective_direction = get_effective_direction (notebook, direction_type);
GtkNotebookPage *page;
GList *last, *child;
return g_object_new (GTK_TYPE_NOTEBOOK, NULL);
}
-/* Private GtkObject Methods :
- *
- * gtk_notebook_destroy
- * gtk_notebook_set_arg
- * gtk_notebook_get_arg
+/* Private GObject Methods :
+ *
+ * gtk_notebook_set_property
+ * gtk_notebook_get_property
*/
-static void
-gtk_notebook_destroy (GtkObject *object)
-{
- GtkNotebook *notebook = GTK_NOTEBOOK (object);
- GtkNotebookPriv *priv = notebook->priv;
-
- if (priv->menu)
- gtk_notebook_popup_disable (notebook);
-
- if (priv->source_targets)
- {
- gtk_target_list_unref (priv->source_targets);
- priv->source_targets = NULL;
- }
-
- if (priv->switch_tab_timer)
- {
- g_source_remove (priv->switch_tab_timer);
- priv->switch_tab_timer = 0;
- }
-
- GTK_OBJECT_CLASS (gtk_notebook_parent_class)->destroy (object);
-}
-
static void
gtk_notebook_set_property (GObject *object,
guint prop_id,
case PROP_TAB_POS:
gtk_notebook_set_tab_pos (notebook, g_value_get_enum (value));
break;
- case PROP_GROUP:
- gtk_notebook_set_group (notebook, g_value_get_pointer (value));
+ case PROP_GROUP_NAME:
+ gtk_notebook_set_group_name (notebook, g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
GParamSpec *pspec)
{
GtkNotebook *notebook = GTK_NOTEBOOK (object);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
switch (prop_id)
{
case PROP_TAB_POS:
g_value_set_enum (value, priv->tab_pos);
break;
- case PROP_GROUP:
- g_value_set_pointer (value, priv->group);
+ case PROP_GROUP_NAME:
+ g_value_set_string (value, gtk_notebook_get_group_name (notebook));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
/* Private GtkWidget Methods :
- *
+ *
+ * gtk_notebook_destroy
* gtk_notebook_map
* gtk_notebook_unmap
* gtk_notebook_realize
* gtk_notebook_size_request
* gtk_notebook_size_allocate
- * gtk_notebook_expose
+ * gtk_notebook_draw
* gtk_notebook_scroll
* gtk_notebook_button_press
* gtk_notebook_button_release
* gtk_notebook_motion_notify
* gtk_notebook_focus_in
* gtk_notebook_focus_out
- * gtk_notebook_draw_focus
- * gtk_notebook_style_set
+ * gtk_notebook_style_updated
* gtk_notebook_drag_begin
* gtk_notebook_drag_end
* gtk_notebook_drag_failed
* gtk_notebook_drag_data_get
* gtk_notebook_drag_data_received
*/
+static void
+gtk_notebook_destroy (GtkWidget *widget)
+{
+ GtkNotebook *notebook = GTK_NOTEBOOK (widget);
+ GtkNotebookPrivate *priv = notebook->priv;
+
+ if (priv->menu)
+ gtk_notebook_popup_disable (notebook);
+
+ if (priv->source_targets)
+ {
+ gtk_target_list_unref (priv->source_targets);
+ priv->source_targets = NULL;
+ }
+
+ if (priv->switch_tab_timer)
+ {
+ g_source_remove (priv->switch_tab_timer);
+ priv->switch_tab_timer = 0;
+ }
+
+ GTK_WIDGET_CLASS (gtk_notebook_parent_class)->destroy (widget);
+}
+
static gboolean
gtk_notebook_get_event_window_position (GtkNotebook *notebook,
GdkRectangle *rectangle)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkAllocation allocation, action_allocation;
GtkWidget *widget = GTK_WIDGET (notebook);
- gint border_width = GTK_CONTAINER (notebook)->border_width;
+ guint border_width = gtk_container_get_border_width (GTK_CONTAINER (notebook));
GtkNotebookPage *visible_page = NULL;
GList *tmp_list;
gint tab_pos = get_effective_tab_pos (notebook);
{
if (rectangle)
{
+ gtk_widget_get_allocation (widget, &allocation);
+
is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
- rectangle->x = widget->allocation.x + border_width;
- rectangle->y = widget->allocation.y + border_width;
+ rectangle->x = allocation.x + border_width;
+ rectangle->y = allocation.y + border_width;
switch (tab_pos)
{
case GTK_POS_TOP:
case GTK_POS_BOTTOM:
- rectangle->width = widget->allocation.width - 2 * border_width;
+ rectangle->width = allocation.width - 2 * border_width;
rectangle->height = visible_page->requisition.height;
if (tab_pos == GTK_POS_BOTTOM)
- rectangle->y += widget->allocation.height - 2 * border_width - rectangle->height;
+ rectangle->y += allocation.height - 2 * border_width - rectangle->height;
for (i = 0; i < N_ACTION_WIDGETS; i++)
{
if (priv->action_widget[i] &&
gtk_widget_get_visible (priv->action_widget[i]))
{
- rectangle->width -= priv->action_widget[i]->allocation.width;
+ gtk_widget_get_allocation (priv->action_widget[i], &action_allocation);
+
+ rectangle->width -= action_allocation.width;
if ((!is_rtl && i == ACTION_WIDGET_START) ||
(is_rtl && i == ACTION_WIDGET_END))
- rectangle->x += priv->action_widget[i]->allocation.width;
+ rectangle->x += action_allocation.width;
}
}
break;
case GTK_POS_LEFT:
case GTK_POS_RIGHT:
rectangle->width = visible_page->requisition.width;
- rectangle->height = widget->allocation.height - 2 * border_width;
+ rectangle->height = allocation.height - 2 * border_width;
if (tab_pos == GTK_POS_RIGHT)
- rectangle->x += widget->allocation.width - 2 * border_width - rectangle->width;
+ rectangle->x += allocation.width - 2 * border_width - rectangle->width;
for (i = 0; i < N_ACTION_WIDGETS; i++)
{
if (priv->action_widget[i] &&
gtk_widget_get_visible (priv->action_widget[i]))
{
- rectangle->height -= priv->action_widget[i]->allocation.height;
+ gtk_widget_get_allocation (priv->action_widget[i], &action_allocation);
+
+ rectangle->height -= action_allocation.height;
if (i == ACTION_WIDGET_START)
- rectangle->y += priv->action_widget[i]->allocation.height;
+ rectangle->y += action_allocation.height;
}
}
break;
gtk_notebook_map (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *children;
gint i;
{
if (priv->action_widget[i] &&
gtk_widget_get_visible (priv->action_widget[i]) &&
- GTK_WIDGET_CHILD_VISIBLE (priv->action_widget[i]) &&
+ gtk_widget_get_child_visible (priv->action_widget[i]) &&
!gtk_widget_get_mapped (priv->action_widget[i]))
gtk_widget_map (priv->action_widget[i]);
}
gtk_notebook_unmap (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
stop_scrolling (notebook);
gtk_notebook_realize (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GdkWindow *window;
GdkWindowAttr attributes;
gint attributes_mask;
GdkRectangle event_window_pos;
gtk_widget_set_realized (widget, TRUE);
gtk_notebook_get_event_window_position (notebook, &event_window_pos);
-
- widget->window = gtk_widget_get_parent_window (widget);
- g_object_ref (widget->window);
-
+
+ window = gtk_widget_get_parent_window (widget);
+ gtk_widget_set_window (widget, window);
+ g_object_ref (window);
+
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = event_window_pos.x;
attributes.y = event_window_pos.y;
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK |
- GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK |
- GDK_SCROLL_MASK);
+ GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK);
attributes_mask = GDK_WA_X | GDK_WA_Y;
priv->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (priv->event_window, notebook);
- widget->style = gtk_style_attach (widget->style, widget->window);
+ gtk_widget_style_attach (widget);
}
static void
gtk_notebook_unrealize (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gdk_window_set_user_data (priv->event_window, NULL);
gdk_window_destroy (priv->event_window);
GTK_WIDGET_CLASS (gtk_notebook_parent_class)->unrealize (widget);
}
+static GtkRegionFlags
+_gtk_notebook_get_tab_flags (GtkNotebook *notebook,
+ GtkNotebookPage *page)
+{
+ GtkNotebookPrivate *priv = notebook->priv;
+ gint i = 0, page_num = -1;
+ GtkRegionFlags flags = 0;
+ gboolean is_last = FALSE;
+ GList *pages;
+
+ if (page->pack == GTK_PACK_START)
+ {
+ gint last = -1;
+
+ for (pages = priv->children; pages; pages = pages->next)
+ {
+ GtkNotebookPage *p = pages->data;
+
+ if (!gtk_widget_get_visible (p->tab_label))
+ continue;
+
+ if (p->pack == GTK_PACK_END)
+ last = i;
+
+ if (page->pack == p->pack)
+ i++;
+
+ /* No need to keep counting tabs after it */
+ if (page == p)
+ {
+ page_num = i;
+ is_last = (last == -1 && pages->next == NULL);
+ break;
+ }
+ }
+ }
+ else
+ {
+ gboolean found = FALSE;
+
+ is_last = TRUE;
+
+ /* Count all pack_start tabs from the beginning
+ * of the list until we find the page, then all
+ * items until the end, that should give us the
+ * tab position
+ */
+ for (pages = priv->children; pages; pages = pages->next)
+ {
+ GtkNotebookPage *p = pages->data;
+
+ if (!gtk_widget_get_visible (p->tab_label))
+ continue;
+
+ if (p->pack == GTK_PACK_START || p == page || found)
+ i++;
+
+ if (page == p)
+ found = TRUE;
+ else if (p->pack == GTK_PACK_END && !found)
+ is_last = FALSE;
+ }
+
+ page_num = i;
+ }
+
+ if (page_num < 0)
+ return 0;
+
+ if ((page_num) % 2 == 0)
+ flags |= GTK_REGION_EVEN;
+ else
+ flags |= GTK_REGION_ODD;
+
+ if (page_num == 1)
+ flags |= GTK_REGION_FIRST;
+
+ if (is_last)
+ flags |= GTK_REGION_LAST;
+
+ return flags;
+}
+
static void
gtk_notebook_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *children;
GtkRequisition child_requisition;
gint arrow_spacing;
gint scroll_arrow_hlength;
gint scroll_arrow_vlength;
+ guint border_width;
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"scroll-arrow-vlength", &scroll_arrow_vlength,
NULL);
- widget->requisition.width = 0;
- widget->requisition.height = 0;
+ requisition->width = 0;
+ requisition->height = 0;
for (children = priv->children, vis_pages = 0; children;
children = children->next)
{
+ GtkWidget *parent;
page = children->data;
if (gtk_widget_get_visible (page->child))
{
vis_pages++;
- gtk_widget_size_request (page->child, &child_requisition);
-
- widget->requisition.width = MAX (widget->requisition.width,
+ gtk_widget_get_preferred_size (page->child,
+ &child_requisition, NULL);
+
+ requisition->width = MAX (requisition->width,
child_requisition.width);
- widget->requisition.height = MAX (widget->requisition.height,
+ requisition->height = MAX (requisition->height,
child_requisition.height);
- if (priv->menu && page->menu_label->parent &&
- !gtk_widget_get_visible (page->menu_label->parent))
- gtk_widget_show (page->menu_label->parent);
+ if (priv->menu && page->menu_label)
+ {
+ parent = gtk_widget_get_parent (page->menu_label);
+ if (parent && !gtk_widget_get_visible (parent))
+ gtk_widget_show (parent);
+ }
}
else
{
if (page == priv->cur_page)
switch_page = TRUE;
- if (priv->menu && page->menu_label->parent &&
- gtk_widget_get_visible (page->menu_label->parent))
- gtk_widget_hide (page->menu_label->parent);
+
+ if (priv->menu && page->menu_label)
+ {
+ parent = gtk_widget_get_parent (page->menu_label);
+ if (parent && gtk_widget_get_visible (parent))
+ gtk_widget_hide (parent);
+ }
}
}
if (priv->show_border || priv->show_tabs)
{
- widget->requisition.width += widget->style->xthickness * 2;
- widget->requisition.height += widget->style->ythickness * 2;
+ GtkStyleContext *context;
+ GtkBorder notebook_padding;
+
+ context = gtk_widget_get_style_context (widget);
+ gtk_style_context_get_padding (context, 0, ¬ebook_padding);
+
+ requisition->width += notebook_padding.left + notebook_padding.right;
+ requisition->height += notebook_padding.top + notebook_padding.bottom;
if (priv->show_tabs)
{
if (gtk_widget_get_visible (page->child))
{
+ GtkBorder tab_padding;
+
if (!gtk_widget_get_visible (page->tab_label))
gtk_widget_show (page->tab_label);
- gtk_widget_size_request (page->tab_label,
- &child_requisition);
+ gtk_widget_get_preferred_size (page->tab_label,
+ &child_requisition, NULL);
+
+ /* Get border/padding for tab */
+ gtk_style_context_save (context);
+ gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB,
+ _gtk_notebook_get_tab_flags (notebook, page));
+ gtk_style_context_get_padding (context, 0, &tab_padding);
+ gtk_style_context_restore (context);
+
+ page->requisition.width = child_requisition.width +
+ tab_padding.left + tab_padding.right;
- page->requisition.width =
- child_requisition.width +
- 2 * widget->style->xthickness;
- page->requisition.height =
- child_requisition.height +
- 2 * widget->style->ythickness;
+ page->requisition.height = child_requisition.height +
+ tab_padding.top + tab_padding.bottom;
switch (priv->tab_pos)
{
{
if (priv->action_widget[i])
{
- gtk_widget_size_request (priv->action_widget[i], &action_widget_requisition[i]);
- action_widget_requisition[i].width += widget->style->xthickness;
- action_widget_requisition[i].height += widget->style->ythickness;
+ gtk_widget_get_preferred_size (priv->action_widget[i],
+ &action_widget_requisition[i], NULL);
+ action_widget_requisition[i].width += notebook_padding.left;
+ action_widget_requisition[i].height += notebook_padding.top;
}
}
break;
if (priv->scrollable && vis_pages > 1 &&
- widget->requisition.width < tab_width)
+ requisition->width < tab_width)
tab_height = MAX (tab_height, scroll_arrow_hlength);
tab_height = MAX (tab_height, action_widget_requisition[ACTION_WIDGET_START].height);
}
if (priv->scrollable && vis_pages > 1 &&
- widget->requisition.width < tab_width)
+ requisition->width < tab_width)
tab_width = tab_max + 2 * (scroll_arrow_hlength + arrow_spacing);
action_width += action_widget_requisition[ACTION_WIDGET_START].width;
action_width += action_widget_requisition[ACTION_WIDGET_END].width;
if (priv->homogeneous && !priv->scrollable)
- widget->requisition.width = MAX (widget->requisition.width,
+ requisition->width = MAX (requisition->width,
vis_pages * tab_max +
tab_overlap + action_width);
else
- widget->requisition.width = MAX (widget->requisition.width,
+ requisition->width = MAX (requisition->width,
tab_width + tab_overlap + action_width);
- widget->requisition.height += tab_height;
+ requisition->height += tab_height;
break;
case GTK_POS_LEFT:
case GTK_POS_RIGHT:
break;
if (priv->scrollable && vis_pages > 1 &&
- widget->requisition.height < tab_height)
+ requisition->height < tab_height)
tab_width = MAX (tab_width,
arrow_spacing + 2 * scroll_arrow_vlength);
}
if (priv->scrollable && vis_pages > 1 &&
- widget->requisition.height < tab_height)
+ requisition->height < tab_height)
tab_height = tab_max + (2 * scroll_arrow_vlength + arrow_spacing);
action_height += action_widget_requisition[ACTION_WIDGET_START].height;
action_height += action_widget_requisition[ACTION_WIDGET_END].height;
if (priv->homogeneous && !priv->scrollable)
- widget->requisition.height =
- MAX (widget->requisition.height,
+ requisition->height =
+ MAX (requisition->height,
vis_pages * tab_max + tab_overlap + action_height);
else
- widget->requisition.height =
- MAX (widget->requisition.height,
+ requisition->height =
+ MAX (requisition->height,
tab_height + tab_overlap + action_height);
if (!priv->homogeneous || priv->scrollable)
vis_pages = 1;
- widget->requisition.height = MAX (widget->requisition.height,
- vis_pages * tab_max +
- tab_overlap);
+ requisition->height = MAX (requisition->height,
+ vis_pages * tab_max +
+ tab_overlap);
- widget->requisition.width += tab_width;
+ requisition->width += tab_width;
break;
}
}
}
}
- widget->requisition.width += GTK_CONTAINER (widget)->border_width * 2;
- widget->requisition.height += GTK_CONTAINER (widget)->border_width * 2;
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+
+ requisition->width += border_width * 2;
+ requisition->height += border_width * 2;
if (switch_page)
{
}
else if (gtk_widget_get_visible (widget))
{
- widget->requisition.width = GTK_CONTAINER (widget)->border_width * 2;
- widget->requisition.height= GTK_CONTAINER (widget)->border_width * 2;
+ requisition->width = border_width * 2;
+ requisition->height = border_width * 2;
}
}
if (vis_pages && !priv->cur_page)
}
}
+
+static void
+gtk_notebook_get_preferred_width (GtkWidget *widget,
+ gint *minimum,
+ gint *natural)
+{
+ GtkRequisition requisition;
+
+ gtk_notebook_size_request (widget, &requisition);
+
+ *minimum = *natural = requisition.width;
+}
+
+static void
+gtk_notebook_get_preferred_height (GtkWidget *widget,
+ gint *minimum,
+ gint *natural)
+{
+ GtkRequisition requisition;
+
+ gtk_notebook_size_request (widget, &requisition);
+
+ *minimum = *natural = requisition.height;
+}
+
static void
gtk_notebook_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkStyleContext *context;
gint tab_pos = get_effective_tab_pos (notebook);
gboolean is_rtl;
gint focus_width;
+ context = gtk_widget_get_style_context (widget);
+
gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
-
- widget->allocation = *allocation;
+
+ gtk_widget_set_allocation (widget, allocation);
+
if (gtk_widget_get_realized (widget))
{
GdkRectangle position;
if (priv->children)
{
- gint border_width = GTK_CONTAINER (widget)->border_width;
+ guint border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
GtkNotebookPage *page;
GtkAllocation child_allocation;
GList *children;
gint i;
-
- child_allocation.x = widget->allocation.x + border_width;
- child_allocation.y = widget->allocation.y + border_width;
+
+ child_allocation.x = allocation->x + border_width;
+ child_allocation.y = allocation->y + border_width;
child_allocation.width = MAX (1, allocation->width - border_width * 2);
child_allocation.height = MAX (1, allocation->height - border_width * 2);
if (priv->show_tabs || priv->show_border)
{
- child_allocation.x += widget->style->xthickness;
- child_allocation.y += widget->style->ythickness;
- child_allocation.width = MAX (1, child_allocation.width -
- widget->style->xthickness * 2);
- child_allocation.height = MAX (1, child_allocation.height -
- widget->style->ythickness * 2);
+ GtkStyleContext *context;
+ GtkBorder padding;
+
+ context = gtk_widget_get_style_context (widget);
+ gtk_style_context_get_padding (context, 0, &padding);
+
+ child_allocation.x += padding.left;
+ child_allocation.y += padding.top;
+ child_allocation.width = MAX (1, child_allocation.width - padding.left - padding.right);
+ child_allocation.height = MAX (1, child_allocation.height - padding.top - padding.bottom);
if (priv->show_tabs && priv->children && priv->cur_page)
{
for (i = 0; i < N_ACTION_WIDGETS; i++)
{
GtkAllocation widget_allocation;
-
+ GtkRequisition requisition;
+
if (!priv->action_widget[i])
continue;
- widget_allocation.x = widget->allocation.x + border_width;
- widget_allocation.y = widget->allocation.y + border_width;
+ widget_allocation.x = allocation->x + border_width;
+ widget_allocation.y = allocation->y + border_width;
is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
+ gtk_widget_get_preferred_size (priv->action_widget[i],
+ &requisition, NULL);
+
switch (tab_pos)
{
case GTK_POS_BOTTOM:
- widget_allocation.y +=
- widget->allocation.height - 2 * border_width - priv->cur_page->requisition.height;
+ widget_allocation.y += allocation->height - 2 * border_width - priv->cur_page->requisition.height;
/* fall through */
case GTK_POS_TOP:
- widget_allocation.width = priv->action_widget[i]->requisition.width;
- widget_allocation.height = priv->cur_page->requisition.height - widget->style->ythickness;
+ widget_allocation.width = requisition.width;
+ widget_allocation.height = priv->cur_page->requisition.height - padding.top;
if ((i == ACTION_WIDGET_START && is_rtl) ||
(i == ACTION_WIDGET_END && !is_rtl))
- widget_allocation.x +=
- widget->allocation.width - 2 * border_width -
- priv->action_widget[i]->requisition.width;
+ widget_allocation.x += allocation->width - 2 * border_width - requisition.width;
if (tab_pos == GTK_POS_TOP) /* no fall through */
widget_allocation.y += 2 * focus_width;
break;
case GTK_POS_RIGHT:
- widget_allocation.x +=
- widget->allocation.width - 2 * border_width - priv->cur_page->requisition.width;
+ widget_allocation.x += allocation->width - 2 * border_width - priv->cur_page->requisition.width;
/* fall through */
case GTK_POS_LEFT:
- widget_allocation.height = priv->action_widget[i]->requisition.height;
- widget_allocation.width = priv->cur_page->requisition.width - widget->style->xthickness;
+ widget_allocation.height = requisition.height;
+ widget_allocation.width = priv->cur_page->requisition.width - padding.left;
if (i == ACTION_WIDGET_END)
- widget_allocation.y +=
- widget->allocation.height - 2 * border_width -
- priv->action_widget[i]->requisition.height;
+ widget_allocation.y += allocation->height - 2 * border_width - requisition.height;
if (tab_pos == GTK_POS_LEFT) /* no fall through */
widget_allocation.x += 2 * focus_width;
break;
}
static gint
-gtk_notebook_expose (GtkWidget *widget,
- GdkEventExpose *event)
+gtk_notebook_draw (GtkWidget *widget,
+ cairo_t *cr)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkAllocation allocation;
+ GdkWindow *window;
gint i;
- if (event->window == priv->drag_window)
+ gtk_widget_get_allocation (widget, &allocation);
+
+ window = gtk_widget_get_window (widget);
+ if (gtk_cairo_should_draw_window (cr, window))
{
- GdkRectangle area = { 0, };
- cairo_t *cr;
+ cairo_save (cr);
- /* FIXME: This is a workaround to make tabs reordering work better
- * with engines with rounded tabs. If the drag window background
- * isn't set, the rounded corners would be black.
- *
- * Ideally, these corners should be made transparent, Either by using
- * ARGB visuals or shape windows.
- */
- cr = gdk_cairo_create (priv->drag_window);
- gdk_cairo_set_source_color (cr, &widget->style->bg [GTK_STATE_NORMAL]);
- cairo_paint (cr);
- cairo_destroy (cr);
+ cairo_translate (cr, -allocation.x, -allocation.y);
+ gtk_notebook_paint (widget, cr);
+
+ cairo_restore (cr);
- gdk_drawable_get_size (priv->drag_window,
- &area.width, &area.height);
- gtk_notebook_draw_tab (notebook,
- priv->cur_page,
- &area);
- gtk_notebook_draw_focus (widget, event);
- gtk_container_propagate_expose (GTK_CONTAINER (notebook),
- priv->cur_page->tab_label, event);
- }
- else if (gtk_widget_is_drawable (widget))
- {
- gtk_notebook_paint (widget, &event->area);
if (priv->show_tabs)
{
GtkNotebookPage *page;
GList *pages;
- gtk_notebook_draw_focus (widget, event);
- pages = priv->children;
-
- while (pages)
- {
+ for (pages = priv->children; pages; pages = pages->next)
+ {
page = GTK_NOTEBOOK_PAGE (pages);
- pages = pages->next;
- if (page->tab_label->window == event->window &&
- gtk_widget_is_drawable (page->tab_label))
- gtk_container_propagate_expose (GTK_CONTAINER (notebook),
- page->tab_label, event);
+ if (gtk_widget_get_parent (page->tab_label) == widget)
+ gtk_container_propagate_draw (GTK_CONTAINER (notebook),
+ page->tab_label, cr);
}
}
- if (priv->cur_page)
- gtk_container_propagate_expose (GTK_CONTAINER (notebook),
- priv->cur_page->child,
- event);
+ if (priv->cur_page && priv->operation != DRAG_OPERATION_REORDER)
+ gtk_container_propagate_draw (GTK_CONTAINER (notebook),
+ priv->cur_page->child,
+ cr);
if (priv->show_tabs)
{
for (i = 0; i < N_ACTION_WIDGETS; i++)
{
- if (priv->action_widget[i] &&
- gtk_widget_is_drawable (priv->action_widget[i]))
- gtk_container_propagate_expose (GTK_CONTAINER (notebook),
- priv->action_widget[i], event);
+ if (priv->action_widget[i])
+ gtk_container_propagate_draw (GTK_CONTAINER (notebook),
+ priv->action_widget[i], cr);
}
}
}
+ if (priv->operation == DRAG_OPERATION_REORDER &&
+ gtk_cairo_should_draw_window (cr, priv->drag_window))
+ {
+ GtkStyleContext *context;
+ GdkRGBA bg_color;
+
+ cairo_save (cr);
+ gtk_cairo_transform_to_window (cr, widget, priv->drag_window);
+ context = gtk_widget_get_style_context (widget);
+
+ /* FIXME: This is a workaround to make tabs reordering work better
+ * with engines with rounded tabs. If the drag window background
+ * isn't set, the rounded corners would be black.
+ *
+ * Ideally, these corners should be made transparent, Either by using
+ * ARGB visuals or shape windows.
+ */
+ gtk_style_context_get_background_color (context, 0, &bg_color);
+ gdk_cairo_set_source_rgba (cr, &bg_color);
+ cairo_paint (cr);
+
+ gtk_notebook_draw_tab (notebook,
+ priv->cur_page,
+ cr, 0);
+
+ cairo_restore (cr);
+
+ gtk_container_propagate_draw (GTK_CONTAINER (notebook),
+ priv->cur_page->tab_label, cr);
+ }
+
return FALSE;
}
static gboolean
gtk_notebook_show_arrows (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gboolean show_arrow = FALSE;
GList *children;
GdkRectangle *rectangle,
GtkNotebookArrow arrow)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GdkRectangle event_window_pos;
gboolean before = ARROW_IS_BEFORE (arrow);
gboolean left = ARROW_IS_LEFT (arrow);
gint x,
gint y)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GdkRectangle arrow_rect;
GdkRectangle event_window_pos;
gint i;
gtk_notebook_do_arrow (GtkNotebook *notebook,
GtkNotebookArrow arrow)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget = GTK_WIDGET (notebook);
gboolean is_rtl, left;
GtkNotebookArrow arrow,
gint button)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget = GTK_WIDGET (notebook);
gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
gboolean left = (ARROW_IS_LEFT (arrow) && !is_rtl) ||
if (!gdk_event_get_coords (event, &tx, &ty))
return FALSE;
- while (window && window != widget->window)
+ while (window && window != gtk_widget_get_window (widget))
{
gint window_x, window_y;
return FALSE;
}
-static gboolean
-gtk_notebook_scroll (GtkWidget *widget,
- GdkEventScroll *event)
-{
- GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
- GtkWidget *child, *event_widget;
- gint i;
-
- if (!priv->cur_page)
- return FALSE;
-
- child = priv->cur_page->child;
- event_widget = gtk_get_event_widget ((GdkEvent *)event);
-
- /* ignore scroll events from the content of the page */
- if (!event_widget || gtk_widget_is_ancestor (event_widget, child) || event_widget == child)
- return FALSE;
-
- /* nor from the action area */
- for (i = 0; i < 2; i++)
- {
- if (event_widget == priv->action_widget[i] ||
- gtk_widget_is_ancestor (event_widget, priv->action_widget[i]))
- return FALSE;
- }
-
- switch (event->direction)
- {
- case GDK_SCROLL_RIGHT:
- case GDK_SCROLL_DOWN:
- gtk_notebook_next_page (notebook);
- break;
- case GDK_SCROLL_LEFT:
- case GDK_SCROLL_UP:
- gtk_notebook_prev_page (notebook);
- break;
- }
-
- return TRUE;
-}
-
static GList*
get_tab_at_pos (GtkNotebook *notebook, gint x, gint y)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *children;
GdkEventButton *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *tab;
GtkNotebookArrow arrow;
gpointer data)
{
GtkNotebook *notebook = data;
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkAllocation allocation;
GtkWidget *w;
GtkRequisition requisition;
w = GTK_WIDGET (notebook);
}
- gdk_window_get_origin (w->window, x, y);
- gtk_widget_size_request (GTK_WIDGET (menu), &requisition);
+ gdk_window_get_origin (gtk_widget_get_window (w), x, y);
+
+ gtk_widget_get_allocation (w, &allocation);
+ gtk_widget_get_preferred_size (GTK_WIDGET (menu),
+ &requisition, NULL);
if (gtk_widget_get_direction (w) == GTK_TEXT_DIR_RTL)
- *x += w->allocation.x + w->allocation.width - requisition.width;
+ *x += allocation.x + allocation.width - requisition.width;
else
- *x += w->allocation.x;
+ *x += allocation.x;
- *y += w->allocation.y + w->allocation.height;
+ *y += allocation.y + allocation.height;
*push_in = FALSE;
}
gtk_notebook_popup_menu (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->menu)
{
static void
stop_scrolling (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->timer)
{
get_drop_position (GtkNotebook *notebook,
guint pack)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *children, *last_child;
GtkNotebookPage *page;
gboolean is_rtl;
static void
show_drag_window (GtkNotebook *notebook,
- GtkNotebookPriv *priv,
+ GtkNotebookPrivate *priv,
GtkNotebookPage *page,
GdkDevice *device)
{
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
priv->drag_window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes,
*/
static void
hide_drag_window (GtkNotebook *notebook,
- GtkNotebookPriv *priv,
+ GtkNotebookPrivate *priv,
GtkNotebookPage *page)
{
GtkWidget *widget = GTK_WIDGET (notebook);
- GtkWidget *parent = page->tab_label->parent;
+ GtkWidget *parent = gtk_widget_get_parent (page->tab_label);
- if (page->tab_label->window != widget->window ||
+ if (gtk_widget_get_window (page->tab_label) != gtk_widget_get_window (widget) ||
!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page))
{
g_object_ref (page->tab_label);
static void
gtk_notebook_stop_reorder (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
if (priv->operation == DRAG_OPERATION_DETACH)
GdkEventButton *event)
{
GtkNotebook *notebook;
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
if (event->type != GDK_BUTTON_RELEASE)
GdkEventCrossing *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gint x, y;
if (!get_widget_coordinates (widget, (GdkEvent *)event, &x, &y))
static GtkNotebookPointerPosition
get_pointer_position (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget = GTK_WIDGET (notebook);
gint wx, wy, width, height;
gboolean is_rtl;
return POINTER_BETWEEN;
gdk_window_get_position (priv->event_window, &wx, &wy);
- gdk_drawable_get_size (GDK_DRAWABLE (priv->event_window), &width, &height);
+ width = gdk_window_get_width (priv->event_window);
+ height = gdk_window_get_height (priv->event_window);
if (priv->tab_pos == GTK_POS_TOP ||
priv->tab_pos == GTK_POS_BOTTOM)
scroll_notebook_timer (gpointer data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (data);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPointerPosition pointer_position;
GList *element, *first_tab;
gint current_x,
gint current_y)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget;
gint dnd_threshold;
GdkRectangle rectangle = { 0, }; /* shut up gcc */
dnd_threshold *= DND_THRESHOLD_MULTIPLIER;
gdk_window_get_position (priv->event_window, &rectangle.x, &rectangle.y);
- gdk_drawable_get_size (GDK_DRAWABLE (priv->event_window), &rectangle.width, &rectangle.height);
+ rectangle.width = gdk_window_get_width (priv->event_window);
+ rectangle.height = gdk_window_get_height (priv->event_window);
rectangle.x -= dnd_threshold;
rectangle.width += 2 * dnd_threshold;
GdkEventMotion *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GtkNotebookArrow arrow;
GtkNotebookPointerPosition pointer_position;
* (priv->drag_window has a pointer grab), but we need coordinates relative to
* the notebook widget.
*/
- gdk_window_get_origin (widget->window, &x_win, &y_win);
+ gdk_window_get_origin (gtk_widget_get_window (widget), &x_win, &y_win);
priv->mouse_x = event->x_root - x_win;
priv->mouse_y = event->y_root - y_win;
}
static void
-gtk_notebook_state_changed (GtkWidget *widget,
- GtkStateType previous_state)
+gtk_notebook_state_flags_changed (GtkWidget *widget,
+ GtkStateFlags previous_state)
{
if (!gtk_widget_is_sensitive (widget))
stop_scrolling (GTK_NOTEBOOK (widget));
}
static void
-gtk_notebook_draw_focus (GtkWidget *widget,
- GdkEventExpose *event)
-{
- GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
-
- if (gtk_widget_has_focus (widget) && gtk_widget_is_drawable (widget) &&
- priv->show_tabs && priv->cur_page &&
- priv->cur_page->tab_label->window == event->window)
- {
- GtkNotebookPage *page;
-
- page = priv->cur_page;
-
- if (gtk_widget_intersect (page->tab_label, &event->area, NULL))
- {
- GdkRectangle area;
- gint focus_width;
-
- gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
-
- area.x = page->tab_label->allocation.x - focus_width;
- area.y = page->tab_label->allocation.y - focus_width;
- area.width = page->tab_label->allocation.width + 2 * focus_width;
- area.height = page->tab_label->allocation.height + 2 * focus_width;
-
- gtk_paint_focus (widget->style, event->window,
- gtk_widget_get_state (widget), NULL, widget, "tab",
- area.x, area.y, area.width, area.height);
- }
- }
-}
-
-static void
-gtk_notebook_style_set (GtkWidget *widget,
- GtkStyle *previous)
+gtk_notebook_style_updated (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gboolean has_before_previous;
gboolean has_before_next;
priv->has_after_previous = has_after_previous;
priv->has_after_next = has_after_next;
- GTK_WIDGET_CLASS (gtk_notebook_parent_class)->style_set (widget, previous);
+ GTK_WIDGET_CLASS (gtk_notebook_parent_class)->style_updated (widget);
}
static gboolean
-on_drag_icon_expose (GtkWidget *widget,
- GdkEventExpose *event,
- gpointer data)
+on_drag_icon_draw (GtkWidget *widget,
+ cairo_t *cr,
+ gpointer data)
{
- GtkWidget *notebook, *child = GTK_WIDGET (data);
+ GtkWidget *notebook, *child;
GtkRequisition requisition;
+ GtkStyleContext *context;
gint gap_pos;
notebook = GTK_WIDGET (data);
- child = GTK_BIN (widget)->child;
- gtk_widget_size_request (widget, &requisition);
+ child = gtk_bin_get_child (GTK_BIN (widget));
+ context = gtk_widget_get_style_context (widget);
+
+ gtk_style_context_save (context);
+ gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB, 0);
+
+ gtk_widget_get_preferred_size (widget,
+ &requisition, NULL);
gap_pos = get_tab_gap_pos (GTK_NOTEBOOK (notebook));
- gtk_paint_extension (gtk_widget_get_style (notebook),
- gtk_widget_get_window (widget),
- GTK_STATE_NORMAL, GTK_SHADOW_OUT,
- NULL, widget, "tab",
- 0, 0,
- requisition.width, requisition.height,
- gap_pos);
+ gtk_render_extension (context, cr, 0, 0,
+ requisition.width, requisition.height,
+ gap_pos);
+
if (child)
- gtk_container_propagate_expose (GTK_CONTAINER (widget), child, event);
+ gtk_container_propagate_draw (GTK_CONTAINER (widget), child, cr);
+
+ gtk_style_context_restore (context);
return TRUE;
}
GdkDragContext *context)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *tab_label;
if (priv->dnd_timer)
priv->detached_tab->allocation.height);
g_object_unref (tab_label);
- g_signal_connect (G_OBJECT (priv->dnd_window), "expose-event",
- G_CALLBACK (on_drag_icon_expose), notebook);
+ g_signal_connect (G_OBJECT (priv->dnd_window), "draw",
+ G_CALLBACK (on_drag_icon_draw), notebook);
gtk_drag_set_icon_widget (context, priv->dnd_window, -2, -2);
}
GdkDragContext *context)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gtk_notebook_stop_reorder (notebook);
if (priv->detached_tab)
gtk_notebook_switch_page (notebook, priv->detached_tab);
- GTK_BIN (priv->dnd_window)->child = NULL;
+ _gtk_bin_set_child (GTK_BIN (priv->dnd_window), NULL);
gtk_widget_destroy (priv->dnd_window);
priv->dnd_window = NULL;
gint x,
gint y)
{
- if (window_creation_hook)
- return (* window_creation_hook) (notebook, page, x, y, window_creation_hook_data);
-
return NULL;
}
if (result == GTK_DRAG_RESULT_NO_TARGET)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebook *dest_notebook = NULL;
GdkDisplay *display;
gint x, y;
gtk_notebook_switch_tab_timeout (gpointer data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (data);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *tab;
gint x, y;
guint time)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkAllocation allocation;
GdkRectangle position;
GtkSettings *settings;
GtkNotebookArrow arrow;
guint timeout;
GdkAtom target, tab_target;
+ gtk_widget_get_allocation (widget, &allocation);
+
arrow = gtk_notebook_get_arrow (notebook,
- x + widget->allocation.x,
- y + widget->allocation.y);
+ x + allocation.x,
+ y + allocation.y);
if (arrow)
{
priv->click_child = arrow;
if (target == tab_target)
{
- gpointer widget_group, source_widget_group;
- GtkWidget *source_widget;
+ GQuark group, source_group;
+ GtkNotebook *source;
+ GtkWidget *source_child;
- source_widget = gtk_drag_get_source_widget (context);
- g_assert (source_widget);
+ source = GTK_NOTEBOOK (gtk_drag_get_source_widget (context));
+ source_child = source->priv->cur_page->child;
- widget_group = gtk_notebook_get_group (notebook);
- source_widget_group = gtk_notebook_get_group (GTK_NOTEBOOK (source_widget));
+ group = notebook->priv->group;
+ source_group = source->priv->group;
- if (widget_group && source_widget_group &&
- widget_group == source_widget_group &&
- !(widget == GTK_NOTEBOOK (source_widget)->priv->cur_page->child ||
- gtk_widget_is_ancestor (widget, GTK_NOTEBOOK (source_widget)->priv->cur_page->child)))
+ if (group != 0 && group == source_group &&
+ !(widget == source_child ||
+ gtk_widget_is_ancestor (widget, source_child)))
{
gdk_drag_status (context, GDK_ACTION_MOVE, time);
return TRUE;
}
}
- x += widget->allocation.x;
- y += widget->allocation.y;
+ x += allocation.x;
+ y += allocation.y;
if (gtk_notebook_get_event_window_position (notebook, &position) &&
x >= position.x && x <= position.x + position.width &&
guint time)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->switch_tab_timer)
{
gint x,
gint y)
{
- GtkNotebookPriv *to_priv = to->priv;
+ GtkNotebookPrivate *to_priv = to->priv;
+ GtkAllocation to_allocation;
GtkWidget *tab_label, *menu_label;
gboolean tab_expand, tab_fill, reorderable, detachable;
GList *element;
gtk_container_remove (GTK_CONTAINER (from), child);
- to_priv->mouse_x = x + GTK_WIDGET (to)->allocation.x;
- to_priv->mouse_y = y + GTK_WIDGET (to)->allocation.y;
+ gtk_widget_get_allocation (GTK_WIDGET (to), &to_allocation);
+ to_priv->mouse_x = x + to_allocation.x;
+ to_priv->mouse_y = y + to_allocation.y;
element = get_drop_position (to, tab_pack);
page_num = g_list_position (to_priv->children, element);
guint info,
guint time)
{
- if (data->target == gdk_atom_intern_static_string ("GTK_NOTEBOOK_TAB"))
+ GdkAtom target;
+
+ target = gtk_selection_data_get_target (data);
+ if (target == gdk_atom_intern_static_string ("GTK_NOTEBOOK_TAB"))
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gtk_selection_data_set (data,
- data->target,
+ target,
8,
(void*) &priv->detached_tab->child,
sizeof (gpointer));
source_widget = gtk_drag_get_source_widget (context);
if (source_widget &&
- data->target == gdk_atom_intern_static_string ("GTK_NOTEBOOK_TAB"))
+ gtk_selection_data_get_target (data) == gdk_atom_intern_static_string ("GTK_NOTEBOOK_TAB"))
{
- child = (void*) data->data;
+ child = (void*) gtk_selection_data_get_data (data);
do_detach_tab (GTK_NOTEBOOK (source_widget), notebook, *child, x, y);
gtk_drag_finish (context, TRUE, FALSE, time);
GParamSpec *pspec)
{
GtkNotebook *notebook = GTK_NOTEBOOK (container);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
GtkWidget *label;
gboolean expand;
GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (container);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *children;
gint page_num = 0;
static gboolean
focus_tabs_in (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->show_tabs && priv->cur_page)
{
GtkDirectionType direction,
gint search_direction)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *new_page;
new_page = gtk_notebook_search_page (notebook, priv->focus_tab,
focus_child_in (GtkNotebook *notebook,
GtkDirectionType direction)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->cur_page)
return gtk_widget_child_focus (priv->cur_page->child, direction);
gint action,
GtkDirectionType direction)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->action_widget[action] &&
gtk_widget_get_visible (priv->action_widget[action]))
GtkDirectionType direction)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *old_focus_child;
GtkDirectionType effective_direction;
gint first_action;
}
widget_is_focus = gtk_widget_is_focus (widget);
- old_focus_child = container->focus_child;
+ old_focus_child = gtk_container_get_focus_child (container);
effective_direction = get_effective_direction (notebook, direction);
GtkWidget *child)
{
GtkNotebook *notebook = GTK_NOTEBOOK (container);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *page_child;
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (container));
if (toplevel && gtk_widget_is_toplevel (toplevel))
{
- page_child = GTK_WINDOW (toplevel)->focus_widget;
+ page_child = gtk_window_get_focus (GTK_WINDOW (toplevel));
while (page_child)
{
- if (page_child->parent == GTK_WIDGET (container))
+ if (gtk_widget_get_parent (page_child) == GTK_WIDGET (container))
{
GList *list = gtk_notebook_find_child (notebook, page_child, NULL);
if (list != NULL)
if (page->last_focus_child)
g_object_remove_weak_pointer (G_OBJECT (page->last_focus_child), (gpointer *)&page->last_focus_child);
-
- page->last_focus_child = GTK_WINDOW (toplevel)->focus_widget;
+
+ page->last_focus_child = gtk_window_get_focus (GTK_WINDOW (toplevel));
g_object_add_weak_pointer (G_OBJECT (page->last_focus_child), (gpointer *)&page->last_focus_child);
break;
}
}
- page_child = page_child->parent;
+ page_child = gtk_widget_get_parent (page_child);
}
}
gpointer callback_data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (container);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *children;
gint i;
}
}
+static GtkWidgetPath *
+gtk_notebook_get_path_for_child (GtkContainer *container,
+ GtkWidget *widget)
+{
+ GtkNotebookPrivate *priv;
+ GtkNotebook *notebook;
+ GtkNotebookPage *page;
+ GtkWidgetPath *path;
+ GtkRegionFlags flags;
+ GList *c;
+
+ path = GTK_CONTAINER_CLASS (gtk_notebook_parent_class)->get_path_for_child (container, widget);
+
+ notebook = GTK_NOTEBOOK (container);
+ priv = notebook->priv;
+
+ for (c = priv->children; c; c = c->next)
+ {
+ page = c->data;
+
+ if (page->tab_label == widget)
+ break;
+ }
+
+ /* Widget is not a tab label */
+ if (!c)
+ return path;
+
+ flags = _gtk_notebook_get_tab_flags (notebook, page);
+ gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_TAB, flags);
+
+ return path;
+}
+
static GType
gtk_notebook_child_type (GtkContainer *container)
{
gpointer data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (data);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
GList *next = NULL;
GtkWidget *menu_label,
gint position)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
gint nchildren;
static void
gtk_notebook_redraw_tabs (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkAllocation allocation;
GtkWidget *widget;
GtkNotebookPage *page;
+ GtkStyleContext *context;
GdkRectangle redraw_rect;
gint border;
gint tab_pos = get_effective_tab_pos (notebook);
+ GtkBorder padding;
widget = GTK_WIDGET (notebook);
- border = GTK_CONTAINER (notebook)->border_width;
+ border = gtk_container_get_border_width (GTK_CONTAINER (notebook));
if (!gtk_widget_get_mapped (widget) || !priv->first_tab)
return;
redraw_rect.x = border;
redraw_rect.y = border;
+ gtk_widget_get_allocation (widget, &allocation);
+
+ context = gtk_widget_get_style_context (widget);
+ gtk_style_context_get_padding (context, 0, &padding);
+
switch (tab_pos)
{
case GTK_POS_BOTTOM:
- redraw_rect.y = widget->allocation.height - border -
- page->allocation.height - widget->style->ythickness;
+ redraw_rect.y = allocation.height - border -
+ page->allocation.height - padding.bottom;
if (page != priv->cur_page)
- redraw_rect.y -= widget->style->ythickness;
+ redraw_rect.y -= padding.bottom;
/* fall through */
case GTK_POS_TOP:
- redraw_rect.width = widget->allocation.width - 2 * border;
- redraw_rect.height = page->allocation.height + widget->style->ythickness;
+ redraw_rect.width = allocation.width - 2 * border;
+ redraw_rect.height = page->allocation.height + padding.top;
if (page != priv->cur_page)
- redraw_rect.height += widget->style->ythickness;
+ redraw_rect.height += padding.top;
break;
case GTK_POS_RIGHT:
- redraw_rect.x = widget->allocation.width - border -
- page->allocation.width - widget->style->xthickness;
+ redraw_rect.x = allocation.width - border -
+ page->allocation.width - padding.right;
if (page != priv->cur_page)
- redraw_rect.x -= widget->style->xthickness;
+ redraw_rect.x -= padding.right;
/* fall through */
case GTK_POS_LEFT:
- redraw_rect.width = page->allocation.width + widget->style->xthickness;
- redraw_rect.height = widget->allocation.height - 2 * border;
+ redraw_rect.width = page->allocation.width + padding.left;
+ redraw_rect.height = allocation.height - 2 * border;
if (page != priv->cur_page)
- redraw_rect.width += widget->style->xthickness;
+ redraw_rect.width += padding.left;
break;
}
- redraw_rect.x += widget->allocation.x;
- redraw_rect.y += widget->allocation.y;
+ redraw_rect.x += allocation.x;
+ redraw_rect.y += allocation.y;
- gdk_window_invalidate_rect (widget->window, &redraw_rect, TRUE);
+ gdk_window_invalidate_rect (gtk_widget_get_window (widget),
+ &redraw_rect, TRUE);
}
static void
gtk_notebook_redraw_arrows (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (gtk_widget_get_mapped (GTK_WIDGET (notebook)) &&
gtk_notebook_show_arrows (notebook))
continue;
gtk_notebook_get_arrow_rect (notebook, &rect, arrow[i]);
- gdk_window_invalidate_rect (GTK_WIDGET (notebook)->window,
+ gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET (notebook)),
&rect, FALSE);
}
}
static gboolean
gtk_notebook_timer (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gboolean retval = FALSE;
if (priv->timer)
static void
gtk_notebook_set_scroll_timer (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget = GTK_WIDGET (notebook);
if (!priv->timer)
GtkWidget *child,
const gchar *function)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list = g_list_find_custom (priv->children, child,
gtk_notebook_page_compare);
page->mnemonic_activate_signal);
page->mnemonic_activate_signal = 0;
- gtk_widget_set_state (page->tab_label, GTK_STATE_NORMAL);
+ gtk_widget_set_state_flags (page->tab_label, 0, TRUE);
gtk_widget_unparent (page->tab_label);
page->tab_label = NULL;
}
gtk_notebook_real_remove (GtkNotebook *notebook,
GList *list)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList * next_list;
gint need_resize = FALSE;
GtkWidget *tab_label;
-
gboolean destroying;
- destroying = GTK_OBJECT_FLAGS (notebook) & GTK_IN_DESTRUCTION;
+ destroying = gtk_widget_in_destruction (GTK_WIDGET (notebook));
next_list = gtk_notebook_search_page (notebook, list, STEP_NEXT, TRUE);
if (!next_list)
if (priv->menu)
{
- GtkWidget *parent = page->menu_label->parent;
+ GtkWidget *parent = gtk_widget_get_parent (page->menu_label);
gtk_notebook_menu_label_unparent (parent, NULL);
gtk_container_remove (GTK_CONTAINER (priv->menu), parent);
static void
gtk_notebook_update_labels (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *list;
gchar string[32];
else
gtk_label_set_text (GTK_LABEL (page->menu_label), string);
}
- }
+ }
}
static gint
gtk_notebook_real_page_position (GtkNotebook *notebook,
GList *list)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *work;
gint count_start;
gint direction,
gboolean find_visible)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page = NULL;
GList *old_list = NULL;
gint flag = 0;
*/
static void
gtk_notebook_paint (GtkWidget *widget,
- GdkRectangle *area)
+ cairo_t *cr)
{
GtkNotebook *notebook;
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
+ GtkAllocation allocation;
GList *children;
gboolean showarrow;
gint width, height;
gint x, y;
- gint border_width = GTK_CONTAINER (widget)->border_width;
+ guint border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
gint gap_x = 0, gap_width = 0, step = STEP_PREV;
gboolean is_rtl;
gint tab_pos;
-
- if (!gtk_widget_is_drawable (widget))
- return;
+ GtkStyleContext *context;
+ GtkRegionFlags tab_flags;
+ gboolean has_pack_start, has_pack_end;
notebook = GTK_NOTEBOOK (widget);
priv = notebook->priv;
is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
tab_pos = get_effective_tab_pos (notebook);
+ context = gtk_widget_get_style_context (widget);
+ showarrow = has_pack_start = has_pack_end = FALSE;
if ((!priv->show_tabs && !priv->show_border) ||
!priv->cur_page || !gtk_widget_get_visible (priv->cur_page->child))
return;
- x = widget->allocation.x + border_width;
- y = widget->allocation.y + border_width;
- width = widget->allocation.width - border_width * 2;
- height = widget->allocation.height - border_width * 2;
+ gtk_widget_get_allocation (widget, &allocation);
+
+ x = allocation.x + border_width;
+ y = allocation.y + border_width;
+ width = allocation.width - border_width * 2;
+ height = allocation.height - border_width * 2;
if (priv->show_border && (!priv->show_tabs || !priv->children))
{
- gtk_paint_box (widget->style, widget->window,
- GTK_STATE_NORMAL, GTK_SHADOW_OUT,
- area, widget, "notebook",
- x, y, width, height);
+ gtk_render_background (context, cr,
+ x, y, width, height);
+ gtk_render_frame (context, cr,
+ x, y, width, height);
return;
}
case GTK_POS_TOP:
case GTK_POS_BOTTOM:
if (priv->operation == DRAG_OPERATION_REORDER)
- gap_x = priv->drag_window_x - widget->allocation.x - border_width;
+ gap_x = priv->drag_window_x - allocation.x - border_width;
else
- gap_x = priv->cur_page->allocation.x - widget->allocation.x - border_width;
+ gap_x = priv->cur_page->allocation.x - allocation.x - border_width;
gap_width = priv->cur_page->allocation.width;
- step = is_rtl ? STEP_NEXT : STEP_PREV;
+ step = is_rtl ? STEP_PREV : STEP_NEXT;
break;
case GTK_POS_LEFT:
case GTK_POS_RIGHT:
if (priv->operation == DRAG_OPERATION_REORDER)
- gap_x = priv->drag_window_y - border_width - widget->allocation.y;
+ gap_x = priv->drag_window_y - border_width - allocation.y;
else
- gap_x = priv->cur_page->allocation.y - widget->allocation.y - border_width;
+ gap_x = priv->cur_page->allocation.y - allocation.y - border_width;
gap_width = priv->cur_page->allocation.height;
step = STEP_PREV;
break;
}
}
- gtk_paint_box_gap (widget->style, widget->window,
- GTK_STATE_NORMAL, GTK_SHADOW_OUT,
- area, widget, "notebook",
- x, y, width, height,
- tab_pos, gap_x, gap_width);
- showarrow = FALSE;
+ for (children = priv->children; children; children = children->next)
+ {
+ page = children->data;
+
+ if (!gtk_widget_get_visible (page->child))
+ continue;
+
+ if (page->pack == GTK_PACK_START)
+ has_pack_start = TRUE;
+ else
+ has_pack_end = TRUE;
+
+ if (!gtk_widget_get_mapped (page->tab_label))
+ showarrow = TRUE;
+
+ /* No point in keeping searching */
+ if (has_pack_start && has_pack_end && showarrow)
+ break;
+ }
+
+ gtk_style_context_save (context);
+
+ if (!showarrow || !priv->scrollable)
+ {
+ GtkJunctionSides junction = 0;
+
+ /* Apply junction sides, if no arrows are shown,
+ * then make corners with connecting tabs square.
+ */
+ switch (tab_pos)
+ {
+ case GTK_POS_TOP:
+ if (has_pack_start)
+ junction |= (is_rtl) ? GTK_JUNCTION_CORNER_TOPRIGHT : GTK_JUNCTION_CORNER_TOPLEFT;
+
+ if (has_pack_end)
+ junction |= (is_rtl) ? GTK_JUNCTION_CORNER_TOPLEFT : GTK_JUNCTION_CORNER_TOPRIGHT;
+ break;
+ case GTK_POS_BOTTOM:
+ if (has_pack_start)
+ junction |= (is_rtl) ? GTK_JUNCTION_CORNER_BOTTOMRIGHT : GTK_JUNCTION_CORNER_BOTTOMLEFT;
+
+ if (has_pack_end)
+ junction |= (is_rtl) ? GTK_JUNCTION_CORNER_BOTTOMLEFT : GTK_JUNCTION_CORNER_BOTTOMRIGHT;
+ break;
+ case GTK_POS_LEFT:
+ if (has_pack_start)
+ junction |= GTK_JUNCTION_CORNER_TOPLEFT;
+
+ if (has_pack_end)
+ junction |= GTK_JUNCTION_CORNER_BOTTOMLEFT;
+ break;
+ case GTK_POS_RIGHT:
+ if (has_pack_start)
+ junction |= GTK_JUNCTION_CORNER_TOPRIGHT;
+
+ if (has_pack_end)
+ junction |= GTK_JUNCTION_CORNER_BOTTOMRIGHT;
+ break;
+ }
+
+ gtk_style_context_set_junction_sides (context, junction);
+ }
+
+ gtk_render_background (context, cr,
+ x, y, width, height);
+ gtk_render_frame_gap (context, cr,
+ x, y, width, height,
+ tab_pos, gap_x, gap_x + gap_width);
+
+ gtk_style_context_restore (context);
+
children = gtk_notebook_search_page (notebook, NULL, step, TRUE);
+
while (children)
{
page = children->data;
children = gtk_notebook_search_page (notebook, children,
step, TRUE);
- if (!gtk_widget_get_visible (page->child))
+ if (!gtk_widget_get_visible (page->child) ||
+ !gtk_widget_get_mapped (page->tab_label))
continue;
- if (!gtk_widget_get_mapped (page->tab_label))
- showarrow = TRUE;
- else if (page != priv->cur_page)
- gtk_notebook_draw_tab (notebook, page, area);
+
+ tab_flags = _gtk_notebook_get_tab_flags (notebook, page);
+ gtk_notebook_draw_tab (notebook, page, cr, tab_flags);
}
if (showarrow && priv->scrollable)
{
if (priv->has_before_previous)
- gtk_notebook_draw_arrow (notebook, ARROW_LEFT_BEFORE);
+ gtk_notebook_draw_arrow (notebook, cr, ARROW_LEFT_BEFORE);
if (priv->has_before_next)
- gtk_notebook_draw_arrow (notebook, ARROW_RIGHT_BEFORE);
+ gtk_notebook_draw_arrow (notebook, cr, ARROW_RIGHT_BEFORE);
if (priv->has_after_previous)
- gtk_notebook_draw_arrow (notebook, ARROW_LEFT_AFTER);
+ gtk_notebook_draw_arrow (notebook, cr, ARROW_LEFT_AFTER);
if (priv->has_after_next)
- gtk_notebook_draw_arrow (notebook, ARROW_RIGHT_AFTER);
+ gtk_notebook_draw_arrow (notebook, cr, ARROW_RIGHT_AFTER);
+ }
+
+ if (priv->operation != DRAG_OPERATION_REORDER)
+ {
+ tab_flags = _gtk_notebook_get_tab_flags (notebook, priv->cur_page);
+ gtk_notebook_draw_tab (notebook, priv->cur_page, cr, tab_flags);
}
- gtk_notebook_draw_tab (notebook, priv->cur_page, area);
}
static void
gtk_notebook_draw_tab (GtkNotebook *notebook,
GtkNotebookPage *page,
- GdkRectangle *area)
+ cairo_t *cr,
+ GtkRegionFlags flags)
{
- GtkNotebookPriv *priv;
- GdkRectangle child_area;
- GdkRectangle page_area;
- GtkStateType state_type;
- GtkPositionType gap_side;
- GdkWindow *window;
+ GtkNotebookPrivate *priv;
+ GtkStateFlags state = 0;
GtkWidget *widget;
-
+ GtkStyleContext *context;
+
if (!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) ||
!gtk_widget_get_mapped (page->tab_label) ||
(page->allocation.width == 0) || (page->allocation.height == 0))
widget = GTK_WIDGET (notebook);
priv = notebook->priv;
- if (priv->operation == DRAG_OPERATION_REORDER && page == priv->cur_page)
- window = priv->drag_window;
- else
- window = widget->window;
+ if (priv->cur_page == page)
+ state = GTK_STATE_FLAG_ACTIVE;
- page_area.x = page->allocation.x;
- page_area.y = page->allocation.y;
- page_area.width = page->allocation.width;
- page_area.height = page->allocation.height;
+ context = gtk_widget_get_style_context (widget);
+ gtk_style_context_save (context);
+ gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB, flags);
+ gtk_style_context_set_state (context, state);
- if (gdk_rectangle_intersect (&page_area, area, &child_area))
+ gtk_render_extension (context, cr,
+ page->allocation.x,
+ page->allocation.y,
+ page->allocation.width,
+ page->allocation.height,
+ get_tab_gap_pos (notebook));
+
+ if (gtk_widget_has_focus (widget) &&
+ priv->cur_page == page)
{
- gap_side = get_tab_gap_pos (notebook);
+ gint focus_width;
+ GtkAllocation allocation;
- if (priv->cur_page == page)
- state_type = GTK_STATE_NORMAL;
- else
- state_type = GTK_STATE_ACTIVE;
+ gtk_widget_get_allocation (page->tab_label, &allocation);
+ gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
- gtk_paint_extension (widget->style, window,
- state_type, GTK_SHADOW_OUT,
- area, widget, "tab",
- page_area.x, page_area.y,
- page_area.width, page_area.height,
- gap_side);
+ gtk_render_focus (context, cr,
+ allocation.x - focus_width,
+ allocation.y - focus_width,
+ allocation.width + 2 * focus_width,
+ allocation.height + 2 * focus_width);
}
+
+ gtk_style_context_restore (context);
}
static void
gtk_notebook_draw_arrow (GtkNotebook *notebook,
+ cairo_t *cr,
GtkNotebookArrow nbarrow)
{
- GtkNotebookPriv *priv = notebook->priv;
- GtkStateType state_type;
- GtkShadowType shadow_type;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkStyleContext *context;
+ GtkStateFlags state = 0;
GtkWidget *widget;
GdkRectangle arrow_rect;
- GtkArrowType arrow;
gboolean is_rtl, left;
+ gint scroll_arrow_hlength;
+ gint scroll_arrow_vlength;
+ gint arrow_size;
+ gdouble angle;
widget = GTK_WIDGET (notebook);
+ context = gtk_widget_get_style_context (widget);
- if (gtk_widget_is_drawable (widget))
- {
- gint scroll_arrow_hlength;
- gint scroll_arrow_vlength;
- gint arrow_size;
+ gtk_notebook_get_arrow_rect (notebook, &arrow_rect, nbarrow);
- gtk_notebook_get_arrow_rect (notebook, &arrow_rect, nbarrow);
-
- is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
- left = (ARROW_IS_LEFT (nbarrow) && !is_rtl) ||
- (!ARROW_IS_LEFT (nbarrow) && is_rtl);
+ is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
+ left = (ARROW_IS_LEFT (nbarrow) && !is_rtl) ||
+ (!ARROW_IS_LEFT (nbarrow) && is_rtl);
- gtk_widget_style_get (widget,
- "scroll-arrow-hlength", &scroll_arrow_hlength,
- "scroll-arrow-vlength", &scroll_arrow_vlength,
- NULL);
+ gtk_widget_style_get (widget,
+ "scroll-arrow-hlength", &scroll_arrow_hlength,
+ "scroll-arrow-vlength", &scroll_arrow_vlength,
+ NULL);
- if (priv->in_child == nbarrow)
- {
- if (priv->click_child == nbarrow)
- state_type = GTK_STATE_ACTIVE;
- else
- state_type = GTK_STATE_PRELIGHT;
- }
- else
- state_type = gtk_widget_get_state (widget);
+ if (priv->in_child == nbarrow)
+ {
+ state |= GTK_STATE_FLAG_PRELIGHT;
if (priv->click_child == nbarrow)
- shadow_type = GTK_SHADOW_IN;
- else
- shadow_type = GTK_SHADOW_OUT;
+ state |= GTK_STATE_FLAG_ACTIVE;
+ }
+ else
+ state = gtk_widget_get_state_flags (widget);
- if (priv->focus_tab &&
- !gtk_notebook_search_page (notebook, priv->focus_tab,
- left ? STEP_PREV : STEP_NEXT, TRUE))
- {
- shadow_type = GTK_SHADOW_ETCHED_IN;
- state_type = GTK_STATE_INSENSITIVE;
- }
-
- if (priv->tab_pos == GTK_POS_LEFT ||
- priv->tab_pos == GTK_POS_RIGHT)
- {
- arrow = (ARROW_IS_LEFT (nbarrow) ? GTK_ARROW_UP : GTK_ARROW_DOWN);
- arrow_size = scroll_arrow_vlength;
- }
- else
- {
- arrow = (ARROW_IS_LEFT (nbarrow) ? GTK_ARROW_LEFT : GTK_ARROW_RIGHT);
- arrow_size = scroll_arrow_hlength;
- }
-
- gtk_paint_arrow (widget->style, widget->window, state_type,
- shadow_type, NULL, widget, "notebook",
- arrow, TRUE, arrow_rect.x, arrow_rect.y,
- arrow_size, arrow_size);
+ if (priv->focus_tab &&
+ !gtk_notebook_search_page (notebook, priv->focus_tab,
+ left ? STEP_PREV : STEP_NEXT, TRUE))
+ state = GTK_STATE_FLAG_INSENSITIVE;
+
+ if (priv->tab_pos == GTK_POS_LEFT ||
+ priv->tab_pos == GTK_POS_RIGHT)
+ {
+ angle = (ARROW_IS_LEFT (nbarrow)) ? 0 : G_PI;
+ arrow_size = scroll_arrow_vlength;
+ }
+ else
+ {
+ angle = (ARROW_IS_LEFT (nbarrow)) ? 3 * (G_PI / 2) : G_PI / 2;
+ arrow_size = scroll_arrow_hlength;
}
+
+ gtk_style_context_save (context);
+ gtk_style_context_set_state (context, state);
+
+ gtk_render_arrow (context, cr, angle,
+ arrow_rect.x, arrow_rect.y,
+ arrow_size);
+
+ gtk_style_context_restore (context);
}
/* Private GtkNotebook Size Allocate Functions:
gint *max,
gint *tab_space)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkAllocation allocation, action_allocation;
GtkWidget *widget;
+ GtkStyleContext *context;
GList *children;
gint tab_pos = get_effective_tab_pos (notebook);
gint tab_overlap;
gint scroll_arrow_vlength;
gboolean is_rtl;
gint i;
+ guint border_width;
+ GtkBorder padding;
widget = GTK_WIDGET (notebook);
children = priv->children;
is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
+ context = gtk_widget_get_style_context (widget);
+
gtk_widget_style_get (GTK_WIDGET (notebook),
"arrow-spacing", &arrow_spacing,
"scroll-arrow-hlength", &scroll_arrow_hlength,
"scroll-arrow-vlength", &scroll_arrow_vlength,
NULL);
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (notebook));
+ gtk_style_context_get_padding (context, 0, &padding);
+
+ gtk_widget_get_allocation (widget, &allocation);
+
switch (tab_pos)
{
case GTK_POS_TOP:
case GTK_POS_BOTTOM:
- *min = widget->allocation.x + GTK_CONTAINER (notebook)->border_width;
- *max = widget->allocation.x + widget->allocation.width - GTK_CONTAINER (notebook)->border_width;
+ *min = allocation.x + border_width;
+ *max = allocation.x + allocation.width - border_width;
for (i = 0; i < N_ACTION_WIDGETS; i++)
{
if (priv->action_widget[i])
{
+ gtk_widget_get_allocation (priv->action_widget[i], &action_allocation);
+
if ((i == ACTION_WIDGET_START && !is_rtl) ||
(i == ACTION_WIDGET_END && is_rtl))
- *min += priv->action_widget[i]->allocation.width + widget->style->xthickness;
+ *min += action_allocation.width + padding.left;
else
- *max -= priv->action_widget[i]->allocation.width + widget->style->xthickness;
+ *max -= action_allocation.width + padding.right;
}
}
break;
case GTK_POS_RIGHT:
case GTK_POS_LEFT:
- *min = widget->allocation.y + GTK_CONTAINER (notebook)->border_width;
- *max = widget->allocation.y + widget->allocation.height - GTK_CONTAINER (notebook)->border_width;
+ *min = allocation.y + border_width;
+ *max = allocation.y + allocation.height - border_width;
for (i = 0; i < N_ACTION_WIDGETS; i++)
{
if (priv->action_widget[i])
{
+ gtk_widget_get_allocation (priv->action_widget[i], &action_allocation);
+
if (i == ACTION_WIDGET_START)
- *min += priv->action_widget[i]->allocation.height + widget->style->ythickness;
+ *min += action_allocation.height + padding.top;
else
- *max -= priv->action_widget[i]->allocation.height + widget->style->ythickness;
+ *max -= action_allocation.height + padding.bottom;
}
}
gint *n,
gint *remaining_space)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget;
GtkContainer *container;
GList *children;
}
else /* !show_arrows */
{
+ GtkOrientation tab_expand_orientation;
gint c = 0;
*n = 0;
+ if (priv->tab_pos == GTK_POS_TOP || priv->tab_pos == GTK_POS_BOTTOM)
+ tab_expand_orientation = GTK_ORIENTATION_HORIZONTAL;
+ else
+ tab_expand_orientation = GTK_ORIENTATION_VERTICAL;
*remaining_space = max - min - tab_overlap - tab_space;
children = priv->children;
priv->first_tab = gtk_notebook_search_page (notebook, NULL,
c++;
- if (page->expand)
+ if (page->expand ||
+ (gtk_widget_compute_expand (page->tab_label, tab_expand_orientation)))
(*n)++;
}
gint min,
gint max)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkAllocation allocation;
GtkWidget *widget;
GtkContainer *container;
GtkNotebookPage *page;
+ GtkStyleContext *context;
gboolean allocate_at_bottom;
gint tab_overlap, tab_pos, tab_extra_space;
gint left_x, right_x, top_y, bottom_y, anchor;
- gint xthickness, ythickness;
+ guint border_width;
gboolean gap_left, packing_changed;
GtkAllocation child_allocation = { 0, };
+ GtkOrientation tab_expand_orientation;
+ GtkBorder padding;
widget = GTK_WIDGET (notebook);
container = GTK_CONTAINER (notebook);
allocate_at_bottom = get_allocate_at_bottom (widget, direction);
anchor = 0;
- child_allocation.x = widget->allocation.x + container->border_width;
- child_allocation.y = widget->allocation.y + container->border_width;
+ gtk_widget_get_allocation (widget, &allocation);
+
+ border_width = gtk_container_get_border_width (container);
+ child_allocation.x = allocation.x + border_width;
+ child_allocation.y = allocation.y + border_width;
- xthickness = widget->style->xthickness;
- ythickness = widget->style->ythickness;
+ context = gtk_widget_get_style_context (widget);
switch (tab_pos)
{
case GTK_POS_BOTTOM:
- child_allocation.y = widget->allocation.y + widget->allocation.height -
- priv->cur_page->requisition.height - container->border_width;
+ child_allocation.y = allocation.y + allocation.height -
+ priv->cur_page->requisition.height - border_width;
/* fall through */
case GTK_POS_TOP:
child_allocation.x = (allocate_at_bottom) ? max : min;
break;
case GTK_POS_RIGHT:
- child_allocation.x = widget->allocation.x + widget->allocation.width -
- priv->cur_page->requisition.width - container->border_width;
+ child_allocation.x = allocation.x + allocation.width -
+ priv->cur_page->requisition.width - border_width;
/* fall through */
case GTK_POS_LEFT:
child_allocation.y = (allocate_at_bottom) ? max : min;
bottom_y = top_y + priv->cur_page->allocation.height;
gap_left = packing_changed = FALSE;
+ if (priv->tab_pos == GTK_POS_TOP || priv->tab_pos == GTK_POS_BOTTOM)
+ tab_expand_orientation = GTK_ORIENTATION_HORIZONTAL;
+ else
+ tab_expand_orientation = GTK_ORIENTATION_VERTICAL;
+
+ gtk_style_context_save (context);
+
while (*children && *children != last_child)
{
page = (*children)->data;
+ gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB,
+ _gtk_notebook_get_tab_flags (notebook, page));
+ gtk_style_context_get_padding (context, 0, &padding);
+
if (direction == STEP_NEXT && page->pack != GTK_PACK_START)
{
if (!showarrow)
continue;
tab_extra_space = 0;
- if (*expanded_tabs && (showarrow || page->expand || priv->homogeneous))
+ if (*expanded_tabs && (showarrow || page->expand || gtk_widget_compute_expand (page->tab_label, tab_expand_orientation) || priv->homogeneous))
{
tab_extra_space = *remaining_space / *expanded_tabs;
*remaining_space -= tab_extra_space;
switch (tab_pos)
{
case GTK_POS_TOP:
- page->allocation.y += ythickness;
+ page->allocation.y += padding.top;
/* fall through */
case GTK_POS_BOTTOM:
- page->allocation.height = MAX (1, page->allocation.height - ythickness);
+ page->allocation.height = MAX (1, page->allocation.height - padding.top);
break;
case GTK_POS_LEFT:
- page->allocation.x += xthickness;
+ page->allocation.x += padding.left;
/* fall through */
case GTK_POS_RIGHT:
- page->allocation.width = MAX (1, page->allocation.width - xthickness);
+ page->allocation.width = MAX (1, page->allocation.width - padding.left);
break;
}
}
gtk_widget_set_child_visible (page->tab_label, TRUE);
}
+ gtk_style_context_restore (context);
+
/* Don't move the current tab past the last position during tabs reordering */
if (children &&
priv->operation == DRAG_OPERATION_REORDER &&
static void
gtk_notebook_pages_allocate (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *children = NULL;
GList *last_child = NULL;
gboolean showarrow = FALSE;
GtkNotebookPage *page)
{
GtkWidget *widget = GTK_WIDGET (notebook);
- GtkNotebookPriv *priv = notebook->priv;
- GtkAllocation child_allocation;
+ GtkNotebookPrivate *priv = notebook->priv;
+ GtkAllocation child_allocation, label_allocation;
GtkRequisition tab_requisition;
- gint xthickness;
- gint ythickness;
+ GtkStyleContext *context;
gint padding;
gint focus_width;
gint tab_curvature;
gint tab_pos = get_effective_tab_pos (notebook);
gboolean tab_allocation_changed;
gboolean was_visible = page->tab_allocated_visible;
+ GtkBorder tab_padding;
if (!page->tab_label ||
!gtk_widget_get_visible (page->tab_label) ||
return was_visible;
}
- xthickness = widget->style->xthickness;
- ythickness = widget->style->ythickness;
+ context = gtk_widget_get_style_context (widget);
+
+ gtk_style_context_save (context);
+ gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB,
+ _gtk_notebook_get_tab_flags (notebook, page));
+
+ gtk_style_context_get_padding (context, 0, &tab_padding);
- gtk_widget_get_child_requisition (page->tab_label, &tab_requisition);
+ gtk_widget_get_preferred_size (page->tab_label, &tab_requisition, NULL);
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"tab-curvature", &tab_curvature,
padding = tab_curvature + focus_width + priv->tab_hborder;
if (page->fill)
{
- child_allocation.x = xthickness + focus_width + priv->tab_hborder;
- child_allocation.width = MAX (1, page->allocation.width - 2 * child_allocation.x);
+ child_allocation.x = tab_padding.left + focus_width + priv->tab_hborder;
+ child_allocation.width = MAX (1, (page->allocation.width -
+ tab_padding.left - tab_padding.right -
+ 2 * (focus_width + priv->tab_hborder)));
child_allocation.x += page->allocation.x;
}
else
child_allocation.y = priv->tab_vborder + focus_width + page->allocation.y;
if (tab_pos == GTK_POS_TOP)
- child_allocation.y += ythickness;
+ child_allocation.y += tab_padding.top;
- child_allocation.height = MAX (1, (page->allocation.height - ythickness -
+ child_allocation.height = MAX (1, (page->allocation.height -
+ tab_padding.top - tab_padding.bottom -
2 * (priv->tab_vborder + focus_width)));
break;
case GTK_POS_LEFT:
padding = tab_curvature + focus_width + priv->tab_vborder;
if (page->fill)
{
- child_allocation.y = ythickness + padding;
+ child_allocation.y = tab_padding.top + padding;
child_allocation.height = MAX (1, (page->allocation.height -
- 2 * child_allocation.y));
+ tab_padding.bottom - tab_padding.top -
+ 2 * padding));
child_allocation.y += page->allocation.y;
}
else
child_allocation.x = priv->tab_hborder + focus_width + page->allocation.x;
if (tab_pos == GTK_POS_LEFT)
- child_allocation.x += xthickness;
+ child_allocation.x += tab_padding.left;
- child_allocation.width = MAX (1, (page->allocation.width - xthickness -
+ child_allocation.width = MAX (1, (page->allocation.width - tab_padding.right -
2 * (priv->tab_hborder + focus_width)));
break;
}
- tab_allocation_changed = (child_allocation.x != page->tab_label->allocation.x ||
- child_allocation.y != page->tab_label->allocation.y ||
- child_allocation.width != page->tab_label->allocation.width ||
- child_allocation.height != page->tab_label->allocation.height);
+ gtk_widget_get_allocation (page->tab_label, &label_allocation);
+ tab_allocation_changed = (child_allocation.x != label_allocation.x ||
+ child_allocation.y != label_allocation.y ||
+ child_allocation.width != label_allocation.width ||
+ child_allocation.height != label_allocation.height);
gtk_widget_size_allocate (page->tab_label, &child_allocation);
tab_allocation_changed = TRUE;
}
+ gtk_style_context_restore (context);
+
return tab_allocation_changed;
}
static void
gtk_notebook_update_tab_states (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
for (list = priv->children; list != NULL; list = list->next)
if (page->tab_label)
{
if (page == priv->cur_page)
- gtk_widget_set_state (page->tab_label, GTK_STATE_NORMAL);
- else
- gtk_widget_set_state (page->tab_label, GTK_STATE_ACTIVE);
+ gtk_widget_set_state_flags (page->tab_label, GTK_STATE_FLAG_ACTIVE, TRUE);
+ else
+ gtk_widget_set_state_flags (page->tab_label, 0, TRUE);
+
+ gtk_widget_reset_style (page->tab_label);
}
}
}
GtkWidget* child,
guint page_num)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list = gtk_notebook_find_child (notebook, GTK_WIDGET (child), NULL);
GtkNotebookPage *page = GTK_NOTEBOOK_PAGE (list);
gboolean child_has_focus;
gtk_notebook_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
guint page_num;
if (priv->cur_page == page)
gtk_notebook_page_select (GtkNotebook *notebook,
gboolean move_focus)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GtkDirectionType dir = GTK_DIR_DOWN; /* Quiet GCC */
gint tab_pos = get_effective_tab_pos (notebook);
gtk_notebook_switch_focus_tab (GtkNotebook *notebook,
GList *new_child)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *old_child;
GtkNotebookPage *page;
gtk_notebook_menu_switch_page (GtkWidget *widget,
GtkNotebookPage *page)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebook *notebook;
+ GtkWidget *parent;
GList *children;
guint page_num;
- notebook = GTK_NOTEBOOK (gtk_menu_get_attach_widget
- (GTK_MENU (widget->parent)));
+ parent = gtk_widget_get_parent (widget);
+ notebook = GTK_NOTEBOOK (gtk_menu_get_attach_widget (GTK_MENU (parent)));
priv = notebook->priv;
if (priv->cur_page == page)
g_signal_emit (notebook,
notebook_signals[SWITCH_PAGE],
0,
- page,
+ page->child,
page_num);
}
gtk_notebook_menu_item_create (GtkNotebook *notebook,
GList *list)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GtkWidget *menu_item;
gtk_notebook_menu_label_unparent (GtkWidget *widget,
gpointer data)
{
- gtk_widget_unparent (GTK_BIN (widget)->child);
- GTK_BIN (widget)->child = NULL;
+ gtk_widget_unparent (gtk_bin_get_child (GTK_BIN (widget)));
+ _gtk_bin_set_child (GTK_BIN (widget), NULL);
}
static void
GtkMenu *menu)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
g_return_if_fail (priv->menu == (GtkWidget*) menu);
gpointer data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (data);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
list = g_list_find_custom (priv->children, child,
gtk_notebook_remove_page (GtkNotebook *notebook,
gint page_num)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list = NULL;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
gint
gtk_notebook_get_current_page (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
gtk_notebook_get_nth_page (GtkNotebook *notebook,
gint page_num)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *list;
gint
gtk_notebook_get_n_pages (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), 0);
gtk_notebook_page_num (GtkNotebook *notebook,
GtkWidget *child)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *children;
gint num;
gtk_notebook_set_current_page (GtkNotebook *notebook,
gint page_num)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
void
gtk_notebook_next_page (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
void
gtk_notebook_prev_page (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
/* Public GtkNotebook/Tab Style Functions
*
* gtk_notebook_set_show_border
+ * gtk_notebook_get_show_border
* gtk_notebook_set_show_tabs
+ * gtk_notebook_get_show_tabs
* gtk_notebook_set_tab_pos
- * gtk_notebook_set_homogeneous_tabs
- * gtk_notebook_set_tab_border
- * gtk_notebook_set_tab_hborder
- * gtk_notebook_set_tab_vborder
+ * gtk_notebook_get_tab_pos
* gtk_notebook_set_scrollable
+ * gtk_notebook_get_scrollable
+ * gtk_notebook_get_tab_hborder
+ * gtk_notebook_get_tab_vborder
*/
/**
* gtk_notebook_set_show_border:
gtk_notebook_set_show_border (GtkNotebook *notebook,
gboolean show_border)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
gtk_notebook_set_show_tabs (GtkNotebook *notebook,
gboolean show_tabs)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *children;
gint i;
gtk_notebook_set_tab_pos (GtkNotebook *notebook,
GtkPositionType pos)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
gtk_notebook_set_scrollable (GtkNotebook *notebook,
gboolean scrollable)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
return notebook->priv->scrollable;
}
+/**
+ * gtk_notebook_get_tab_hborder:
+ * @notebook: a #GtkNotebook
+ *
+ * Returns the horizontal width of a tab border.
+ *
+ * Return value: horizontal width of a tab border
+ *
+ * Since: 2.22
+ */
+guint16
+gtk_notebook_get_tab_hborder (GtkNotebook *notebook)
+{
+ g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), FALSE);
+
+ return notebook->priv->tab_hborder;
+}
+
+/**
+ * gtk_notebook_get_tab_vborder:
+ * @notebook: a #GtkNotebook
+ *
+ * Returns the vertical width of a tab border.
+ *
+ * Return value: vertical width of a tab border
+ *
+ * Since: 2.22
+ */
+guint16
+gtk_notebook_get_tab_vborder (GtkNotebook *notebook)
+{
+ g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), FALSE);
+
+ return notebook->priv->tab_vborder;
+}
+
+
/* Public GtkNotebook Popup Menu Methods:
*
* gtk_notebook_popup_enable
void
gtk_notebook_popup_enable (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
void
gtk_notebook_popup_disable (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
* gtk_notebook_get_menu_label
* gtk_notebook_set_menu_label
* gtk_notebook_set_menu_label_text
- * gtk_notebook_set_tab_label_packing
- * gtk_notebook_query_tab_label_packing
* gtk_notebook_get_tab_reorderable
* gtk_notebook_set_tab_reorderable
* gtk_notebook_get_tab_detachable
GtkWidget *child,
GtkWidget *tab_label)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *list;
* gtk_notebook_get_menu_label:
* @notebook: a #GtkNotebook
* @child: a widget contained in a page of @notebook
- *
+ *
* Retrieves the menu label widget of the page containing @child.
- *
- * Return value: the menu label, or %NULL if the
- * notebook page does not have a menu label other
- * than the default (the tab label).
+ *
+ * Return value: (transfer none): the menu label, or %NULL if the
+ * notebook page does not have a menu label other than the
+ * default (the tab label).
**/
GtkWidget*
gtk_notebook_get_menu_label (GtkNotebook *notebook,
g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
list = CHECK_FIND_CHILD (notebook, child);
- if (!list)
+ if (!list)
return NULL;
if (GTK_NOTEBOOK_PAGE (list)->default_menu)
return NULL;
return GTK_NOTEBOOK_PAGE (list)->menu_label;
-}
+}
/**
* gtk_notebook_set_menu_label:
GtkWidget *child,
GtkWidget *menu_label)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *list;
{
if (priv->menu)
gtk_container_remove (GTK_CONTAINER (priv->menu),
- page->menu_label->parent);
+ gtk_widget_get_parent (page->menu_label));
if (!page->default_menu)
g_object_unref (page->menu_label);
gtk_notebook_child_reordered (GtkNotebook *notebook,
GtkNotebookPage *page)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->menu)
{
GtkWidget *menu_item;
-
- menu_item = page->menu_label->parent;
+
+ menu_item = gtk_widget_get_parent (page->menu_label);
gtk_container_remove (GTK_CONTAINER (menu_item), page->menu_label);
gtk_container_remove (GTK_CONTAINER (priv->menu), menu_item);
gtk_notebook_menu_item_create (notebook, g_list_find (priv->children, page));
gboolean fill,
GtkPackType pack_type)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *list;
GtkWidget *child,
gint position)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list, *new_list;
GtkNotebookPage *page;
gint old_pos;
}
/**
- * gtk_notebook_set_window_creation_hook:
- * @func: (allow-none): the #GtkNotebookWindowCreationFunc, or %NULL
- * @data: user data for @func
- * @destroy: (allow-none): Destroy notifier for @data, or %NULL
- *
- * Installs a global function used to create a window
- * when a detached tab is dropped in an empty area.
- *
- * Since: 2.10
- **/
-void
-gtk_notebook_set_window_creation_hook (GtkNotebookWindowCreationFunc func,
- gpointer data,
- GDestroyNotify destroy)
-{
- if (window_creation_hook_destroy)
- window_creation_hook_destroy (window_creation_hook_data);
-
- window_creation_hook = func;
- window_creation_hook_data = data;
- window_creation_hook_destroy = destroy;
-}
-
-/**
- * gtk_notebook_set_group:
+ * gtk_notebook_set_group_name:
* @notebook: a #GtkNotebook
- * @group: (allow-none): a pointer to identify the notebook group, or %NULL to unset it
+ * @group_name: (allow-none): the name of the notebook group,
+ * or %NULL to unset it
+ *
+ * Sets a group name for @notebook.
*
- * Sets a group identificator pointer for @notebook, notebooks sharing
- * the same group identificator pointer will be able to exchange tabs
- * via drag and drop. A notebook with a %NULL group identificator will
+ * Notebooks with the same name will be able to exchange tabs
+ * via drag and drop. A notebook with a %NULL group name will
* not be able to exchange tabs with any other notebook.
- *
- * Since: 2.12
+ *
+ * Since: 2.24
*/
void
-gtk_notebook_set_group (GtkNotebook *notebook,
- gpointer group)
+gtk_notebook_set_group_name (GtkNotebook *notebook,
+ const gchar *group_name)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
+ GQuark group;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
priv = notebook->priv;
+ group = g_quark_from_string (group_name);
+
if (priv->group != group)
{
priv->group = group;
- g_object_notify (G_OBJECT (notebook), "group");
+ g_object_notify (G_OBJECT (notebook), "group-name");
}
}
/**
- * gtk_notebook_get_group:
+ * gtk_notebook_get_group_name:
* @notebook: a #GtkNotebook
- *
- * Gets the current group identificator pointer for @notebook.
- *
- * Return Value: the group identificator, or %NULL if none is set.
*
- * Since: 2.12
+ * Gets the current group name for @notebook.
+ *
+ * Return Value: (transfer none): the group name,
+ * or %NULL if none is set.
+ *
+ * Since: 2.24
**/
-gpointer
-gtk_notebook_get_group (GtkNotebook *notebook)
+const gchar *
+gtk_notebook_get_group_name (GtkNotebook *notebook)
{
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
- return notebook->priv->group;
+ return g_quark_to_string (notebook->priv->group);
}
/**
* notebook or widget.
*
* Note that 2 notebooks must share a common group identificator
- * (see gtk_notebook_set_group_id ()) to allow automatic tabs
+ * (see gtk_notebook_set_group()) to allow automatic tabs
* interchange between them.
*
* If you want a widget to interact with a notebook through DnD
* GtkWidget **child;
*
* notebook = gtk_drag_get_source_widget (context);
- * child = (void*) selection_data->data;
- *
+ * child = (void*) gtk_selection_data_get_data (selection_data);
+ *
* process_widget (*child);
* gtk_container_remove (GTK_CONTAINER (notebook), *child);
* }
*
* Gets one of the action widgets. See gtk_notebook_set_action_widget().
*
- * Returns: The action widget with the given @pack_type or
- * %NULL when this action widget has not been set
+ * Returns: (transfer none): The action widget with the given @pack_type
+ * or %NULL when this action widget has not been set
*
* Since: 2.20
*/
GtkWidget *widget,
GtkPackType pack_type)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (!widget || GTK_IS_WIDGET (widget));
- g_return_if_fail (!widget || widget->parent == NULL);
+ g_return_if_fail (!widget || gtk_widget_get_parent (widget) == NULL);
priv = notebook->priv;
projects / ~andy / gtk / blobdiff