forked from AuroraMiddleware/gtk
a1a252ce46
Fri Feb 2 12:26:50 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkrc.c (gtk_rc_add_initial_default_files): Get rid of a bunch of g_strdup_printf("%s%s") in favor of g_strconcat(). * gtk/gtkrc.c Makefile.am: Use $(libdir), not $(exe_prefix), since some people set $(libdir) separately. (#1290, David Kaelbling) Thu Feb 1 18:25:46 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkfilesel.c: If PATH_MAX and MAXPATHLEN are not defined, define MAXPATHLEN to 2048. (The Hurd doesn't have MAXPATHLEN, but the code here depends on a fixed value.) (#4524) Wed Jan 31 22:01:04 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkhandlebox.c (gtk_handle_box_button_changed): Handle the case where child == NULL and handle_position == RIGHT or BOTTOM. (#8041g) Wed Jan 31 21:20:39 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkctree.c (real_tree_move): If the node being moved isn't viewable there is no way that moving the node will cause the focus row to become not viewable, so omit check on the visibility of new_sibling, which is irrelevant. (Fixes #8002, David Helder) Wed Jan 31 20:38:17 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkentry.c (gtk_entry_commit_cb): Delete the current selection before inserting new text. Wed Jan 31 18:49:33 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkoptionmenu.c (gtk_option_menu_item_state_changed_cb): Make the sensitivity of the reparented child track that of the original parent menu item. (#34218, David Hodson) * gtk/gtkoptionmenu.c (gtk_option_menu_item_destroy_cb): Handle the case where the current item is destroyed properly. * gtk/gtkoptionmenu.c: Some additional code cleanups and fix some edge cases with child-less menuitems. Wed Jan 31 17:16:13 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkcombo.c (gtk_combo_window_key_press): Make Return key pop down window. (#12074, Jon K Hellan) Wed Jan 31 16:21:42 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtklist.c (gtk_list_signal_item_toggle): Don't allow toggling of rows off in BROWSE or EXTENDED mode. (#12072, Jon K Hellan) The solution here isn't perfect - you get an extraneous emission of "toggle", which could conceivably confuse an app, but better than the current situation. LXR search seems to indicate that no apps in GNOME CVS connect to "toggle". Wed Jan 31 15:46:13 2001 Owen Taylor <otaylor@redhat.com> * gtk/Makefile.am (libgtkinclude_HEADERS): Move gtkcompat.h from gtk_public_h_sources to directly here to avoid warning when building srcdir != builddir. (#9656) Tue Jan 30 19:49:02 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkrange.c: Patch from Kipp Hickman to make the event handlers in gtkrange.c return the proper values (TRUE == handled) (#10316). This is just the tip of the iceberg, but gtkrange.c is the most common place where the propagation is problematical, and also a place where it is almost certainly safe to change this in the stable branch. (You don't want right click popups on a range control or anything...) Tue Jan 30 18:57:59 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtktext.c (clear_focus_area): We need to clear the focus area on focus out, even if a background pixmap isn't set. (#13941) Tue Jan 30 18:24:10 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtknotebook.c (gtk_notebook_set_shape): Fix from Sean Cunningham to deal with setting the shape properly when scrolling arrows are turned on, but not visible because there is sufficient space. (#13432) Tue Jan 30 16:39:25 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkitemfactory.c (gtk_item_factory_delete_item): For menu items with submenus, destroy the item along with the submenu. (#7841, Brian Masney(?)) Also, handle paths of the form '<foo>/abcd...' properly. * gtk/testgtk.c (menu_items): Add a dummy branch that we delete later. Tue Jan 30 15:51:25 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkwindow.c (gtk_window_real_set_focus): Fix a problem where the focus widget sometimes wasn't drawn with the default if there was no default widget. * gtk/gtkstyle.c (gtk_style_real_unrealize): free colors, unreference pixmaps. * gtk/gtkstyle.c (gtk_style_realize): Reference colormap for some extra safety. Mon Jan 29 19:00:01 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtk{ctree.c,clist.c} (set_cell_contents): Handle setting the text of a cell to the old pointer value better, by copying the new text before freeing the old text. Some code cleanup. (#8079, Karl Nelson) Mon Jan 29 16:50:19 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtklabel.[ch] gtk/gtkframe.[ch]: Make gtk_label_get_text() gtk_frame_get_label() non strdup'ing, and G_CONST_RETURN. Mon Jan 29 15:22:51 2001 Owen Taylor <otaylor@redhat.com> * gtk/gtkmenu.c (gtk_menu_remove): When removing an item from a menu, check to see if it matches menu->old_active_menu_item, and if so, unref and clear old_active_menu_item (Patch from Pavel Cisler) * gtk/gtkmenushell.c (gtk_menu_shell_remove): Unset menu_shell->active_menu_item, if it is the child being removed. (Patch based on that of Gene Ragan, #50337)
4640 lines
124 KiB
C
4640 lines
124 KiB
C
/* GTK - The GIMP Toolkit
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
/*
|
|
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
|
|
* file for a list of people on the GTK+ Team. See the ChangeLog
|
|
* files for a list of changes. These files are distributed with
|
|
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
|
|
*/
|
|
|
|
#include "gtknotebook.h"
|
|
#include "gtksignal.h"
|
|
#include "gtkmain.h"
|
|
#include "gtkmenu.h"
|
|
#include "gtkmenuitem.h"
|
|
#include "gtklabel.h"
|
|
#include <gdk/gdkkeysyms.h>
|
|
#include <stdio.h>
|
|
#include "gtkintl.h"
|
|
|
|
|
|
#define TAB_OVERLAP 2
|
|
#define TAB_CURVATURE 1
|
|
#define ARROW_SIZE 12
|
|
#define ARROW_SPACING 0
|
|
#define FOCUS_WIDTH 1
|
|
#define NOTEBOOK_INIT_SCROLL_DELAY (200)
|
|
#define NOTEBOOK_SCROLL_DELAY (100)
|
|
|
|
|
|
enum {
|
|
SWITCH_PAGE,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum {
|
|
STEP_PREV,
|
|
STEP_NEXT
|
|
};
|
|
|
|
enum {
|
|
ARG_0,
|
|
ARG_TAB_POS,
|
|
ARG_SHOW_TABS,
|
|
ARG_SHOW_BORDER,
|
|
ARG_SCROLLABLE,
|
|
ARG_TAB_BORDER,
|
|
ARG_TAB_HBORDER,
|
|
ARG_TAB_VBORDER,
|
|
ARG_PAGE,
|
|
ARG_ENABLE_POPUP,
|
|
ARG_HOMOGENEOUS
|
|
};
|
|
|
|
enum {
|
|
CHILD_ARG_0,
|
|
CHILD_ARG_TAB_LABEL,
|
|
CHILD_ARG_MENU_LABEL,
|
|
CHILD_ARG_POSITION,
|
|
CHILD_ARG_TAB_EXPAND,
|
|
CHILD_ARG_TAB_FILL,
|
|
CHILD_ARG_TAB_PACK
|
|
};
|
|
|
|
#define GTK_NOTEBOOK_PAGE(_glist_) ((GtkNotebookPage *)((GList *)(_glist_))->data)
|
|
|
|
struct _GtkNotebookPage
|
|
{
|
|
GtkWidget *child;
|
|
GtkWidget *tab_label;
|
|
GtkWidget *menu_label;
|
|
|
|
guint default_menu : 1; /* If true, we create the menu label ourself */
|
|
guint default_tab : 1; /* If true, we create the tab label ourself */
|
|
guint expand : 1;
|
|
guint fill : 1;
|
|
guint pack : 1;
|
|
|
|
GtkRequisition requisition;
|
|
GtkAllocation allocation;
|
|
};
|
|
|
|
#ifdef G_DISABLE_CHECKS
|
|
#define CHECK_FIND_CHILD(notebook, child) \
|
|
gtk_notebook_find_child(notebook, child, \
|
|
G_GNUC_PRETTY_FUNCTION)
|
|
#else
|
|
#define CHECK_FIND_CHILD(notebook, child) \
|
|
gtk_notebook_find_child(notebook, child, NULL)
|
|
#endif
|
|
|
|
/*** GtkNotebook Methods ***/
|
|
static void gtk_notebook_class_init (GtkNotebookClass *klass);
|
|
static void gtk_notebook_init (GtkNotebook *notebook);
|
|
|
|
/*** GtkObject Methods ***/
|
|
static void gtk_notebook_destroy (GtkObject *object);
|
|
static void gtk_notebook_set_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint arg_id);
|
|
static void gtk_notebook_get_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint arg_id);
|
|
|
|
/*** GtkWidget Methods ***/
|
|
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_size_allocate (GtkWidget *widget,
|
|
GtkAllocation *allocation);
|
|
static gint gtk_notebook_expose (GtkWidget *widget,
|
|
GdkEventExpose *event);
|
|
static gint gtk_notebook_button_press (GtkWidget *widget,
|
|
GdkEventButton *event);
|
|
static gint gtk_notebook_button_release (GtkWidget *widget,
|
|
GdkEventButton *event);
|
|
static gint gtk_notebook_enter_notify (GtkWidget *widget,
|
|
GdkEventCrossing *event);
|
|
static gint gtk_notebook_leave_notify (GtkWidget *widget,
|
|
GdkEventCrossing *event);
|
|
static gint gtk_notebook_motion_notify (GtkWidget *widget,
|
|
GdkEventMotion *event);
|
|
static gint gtk_notebook_key_press (GtkWidget *widget,
|
|
GdkEventKey *event);
|
|
static gint gtk_notebook_focus_in (GtkWidget *widget,
|
|
GdkEventFocus *event);
|
|
static gint gtk_notebook_focus_out (GtkWidget *widget,
|
|
GdkEventFocus *event);
|
|
static void gtk_notebook_draw_focus (GtkWidget *widget);
|
|
static void gtk_notebook_style_set (GtkWidget *widget,
|
|
GtkStyle *previous_style);
|
|
|
|
/*** GtkContainer Methods ***/
|
|
static void gtk_notebook_set_child_arg (GtkContainer *container,
|
|
GtkWidget *child,
|
|
GtkArg *arg,
|
|
guint arg_id);
|
|
static void gtk_notebook_get_child_arg (GtkContainer *container,
|
|
GtkWidget *child,
|
|
GtkArg *arg,
|
|
guint arg_id);
|
|
static void gtk_notebook_add (GtkContainer *container,
|
|
GtkWidget *widget);
|
|
static void gtk_notebook_remove (GtkContainer *container,
|
|
GtkWidget *widget);
|
|
static gint gtk_notebook_focus (GtkContainer *container,
|
|
GtkDirectionType direction);
|
|
static void gtk_notebook_set_focus_child (GtkContainer *container,
|
|
GtkWidget *child);
|
|
static GtkType gtk_notebook_child_type (GtkContainer *container);
|
|
static void gtk_notebook_forall (GtkContainer *container,
|
|
gboolean include_internals,
|
|
GtkCallback callback,
|
|
gpointer callback_data);
|
|
|
|
/*** GtkNotebook Private Functions ***/
|
|
static void gtk_notebook_panel_realize (GtkNotebook *notebook);
|
|
static void gtk_notebook_redraw_tabs (GtkNotebook *notebook);
|
|
static void gtk_notebook_redraw_arrows (GtkNotebook *notebook);
|
|
static void gtk_notebook_focus_changed (GtkNotebook *notebook,
|
|
GtkNotebookPage *old_page);
|
|
static void gtk_notebook_real_remove (GtkNotebook *notebook,
|
|
GList *list);
|
|
static void gtk_notebook_update_labels (GtkNotebook *notebook);
|
|
static gint gtk_notebook_timer (GtkNotebook *notebook);
|
|
static gint gtk_notebook_page_compare (gconstpointer a,
|
|
gconstpointer b);
|
|
static GList *gtk_notebook_find_child (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
const gchar *function);
|
|
static gint gtk_notebook_real_page_position (GtkNotebook *notebook,
|
|
GList *list);
|
|
static GList * gtk_notebook_search_page (GtkNotebook *notebook,
|
|
GList *list,
|
|
gint direction,
|
|
gboolean find_visible);
|
|
|
|
/*** GtkNotebook Drawing Functions ***/
|
|
static void gtk_notebook_paint (GtkWidget *widget,
|
|
GdkRectangle *area);
|
|
static void gtk_notebook_draw_tab (GtkNotebook *notebook,
|
|
GtkNotebookPage *page,
|
|
GdkRectangle *area);
|
|
static void gtk_notebook_draw_arrow (GtkNotebook *notebook,
|
|
guint arrow);
|
|
static void gtk_notebook_set_shape (GtkNotebook *notebook);
|
|
|
|
/*** GtkNotebook Size Allocate Functions ***/
|
|
static void gtk_notebook_pages_allocate (GtkNotebook *notebook);
|
|
static void gtk_notebook_page_allocate (GtkNotebook *notebook,
|
|
GtkNotebookPage *page,
|
|
GtkAllocation *allocation);
|
|
static void gtk_notebook_calc_tabs (GtkNotebook *notebook,
|
|
GList *start,
|
|
GList **end,
|
|
gint *tab_space,
|
|
guint direction);
|
|
|
|
/*** GtkNotebook Page Switch Methods ***/
|
|
static void gtk_notebook_real_switch_page (GtkNotebook *notebook,
|
|
GtkNotebookPage *page,
|
|
guint page_num);
|
|
|
|
/*** GtkNotebook Page Switch Functions ***/
|
|
static void gtk_notebook_switch_page (GtkNotebook *notebook,
|
|
GtkNotebookPage *page,
|
|
gint page_num);
|
|
static gint gtk_notebook_page_select (GtkNotebook *notebook,
|
|
gboolean move_focus);
|
|
static void gtk_notebook_switch_focus_tab (GtkNotebook *notebook,
|
|
GList *new_child);
|
|
static void gtk_notebook_menu_switch_page (GtkWidget *widget,
|
|
GtkNotebookPage *page);
|
|
|
|
/*** GtkNotebook Menu Functions ***/
|
|
static void gtk_notebook_menu_item_create (GtkNotebook *notebook,
|
|
GList *list);
|
|
static void gtk_notebook_menu_label_unparent (GtkWidget *widget,
|
|
gpointer data);
|
|
static void gtk_notebook_menu_detacher (GtkWidget *widget,
|
|
GtkMenu *menu);
|
|
|
|
|
|
static GtkContainerClass *parent_class = NULL;
|
|
static guint notebook_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
GtkType
|
|
gtk_notebook_get_type (void)
|
|
{
|
|
static GtkType notebook_type = 0;
|
|
|
|
if (!notebook_type)
|
|
{
|
|
static const GtkTypeInfo notebook_info =
|
|
{
|
|
"GtkNotebook",
|
|
sizeof (GtkNotebook),
|
|
sizeof (GtkNotebookClass),
|
|
(GtkClassInitFunc) gtk_notebook_class_init,
|
|
(GtkObjectInitFunc) gtk_notebook_init,
|
|
/* reserved_1 */ NULL,
|
|
/* reserved_2 */ NULL,
|
|
(GtkClassInitFunc) NULL,
|
|
};
|
|
|
|
notebook_type = gtk_type_unique (gtk_container_get_type (), ¬ebook_info);
|
|
}
|
|
|
|
return notebook_type;
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_class_init (GtkNotebookClass *class)
|
|
{
|
|
GtkObjectClass *object_class;
|
|
GtkWidgetClass *widget_class;
|
|
GtkContainerClass *container_class;
|
|
|
|
object_class = (GtkObjectClass*) class;
|
|
widget_class = (GtkWidgetClass*) class;
|
|
container_class = (GtkContainerClass*) class;
|
|
parent_class = gtk_type_class (gtk_container_get_type ());
|
|
|
|
|
|
object_class->set_arg = gtk_notebook_set_arg;
|
|
object_class->get_arg = gtk_notebook_get_arg;
|
|
object_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->size_allocate = gtk_notebook_size_allocate;
|
|
widget_class->expose_event = gtk_notebook_expose;
|
|
widget_class->button_press_event = gtk_notebook_button_press;
|
|
widget_class->button_release_event = gtk_notebook_button_release;
|
|
widget_class->enter_notify_event = gtk_notebook_enter_notify;
|
|
widget_class->leave_notify_event = gtk_notebook_leave_notify;
|
|
widget_class->motion_notify_event = gtk_notebook_motion_notify;
|
|
widget_class->key_press_event = gtk_notebook_key_press;
|
|
widget_class->focus_in_event = gtk_notebook_focus_in;
|
|
widget_class->focus_out_event = gtk_notebook_focus_out;
|
|
widget_class->draw_focus = gtk_notebook_draw_focus;
|
|
widget_class->style_set = gtk_notebook_style_set;
|
|
|
|
container_class->add = gtk_notebook_add;
|
|
container_class->remove = gtk_notebook_remove;
|
|
container_class->forall = gtk_notebook_forall;
|
|
container_class->focus = gtk_notebook_focus;
|
|
container_class->set_focus_child = gtk_notebook_set_focus_child;
|
|
container_class->get_child_arg = gtk_notebook_get_child_arg;
|
|
container_class->set_child_arg = gtk_notebook_set_child_arg;
|
|
container_class->child_type = gtk_notebook_child_type;
|
|
|
|
class->switch_page = gtk_notebook_real_switch_page;
|
|
|
|
gtk_object_add_arg_type ("GtkNotebook::page", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_PAGE);
|
|
gtk_object_add_arg_type ("GtkNotebook::tab_pos", GTK_TYPE_POSITION_TYPE, GTK_ARG_READWRITE, ARG_TAB_POS);
|
|
gtk_object_add_arg_type ("GtkNotebook::tab_border", GTK_TYPE_UINT, GTK_ARG_WRITABLE, ARG_TAB_BORDER);
|
|
gtk_object_add_arg_type ("GtkNotebook::tab_hborder", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_TAB_HBORDER);
|
|
gtk_object_add_arg_type ("GtkNotebook::tab_vborder", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_TAB_VBORDER);
|
|
gtk_object_add_arg_type ("GtkNotebook::show_tabs", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SHOW_TABS);
|
|
gtk_object_add_arg_type ("GtkNotebook::show_border", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SHOW_BORDER);
|
|
gtk_object_add_arg_type ("GtkNotebook::scrollable", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SCROLLABLE);
|
|
gtk_object_add_arg_type ("GtkNotebook::enable_popup", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ENABLE_POPUP);
|
|
gtk_object_add_arg_type ("GtkNotebook::homogeneous", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HOMOGENEOUS);
|
|
|
|
gtk_container_add_child_arg_type ("GtkNotebook::tab_label", GTK_TYPE_STRING, GTK_ARG_READWRITE, CHILD_ARG_TAB_LABEL);
|
|
gtk_container_add_child_arg_type ("GtkNotebook::menu_label", GTK_TYPE_STRING, GTK_ARG_READWRITE, CHILD_ARG_MENU_LABEL);
|
|
gtk_container_add_child_arg_type ("GtkNotebook::position", GTK_TYPE_INT, GTK_ARG_READWRITE, CHILD_ARG_POSITION);
|
|
gtk_container_add_child_arg_type ("GtkNotebook::tab_fill", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_TAB_FILL);
|
|
gtk_container_add_child_arg_type ("GtkNotebook::tab_pack", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_TAB_PACK);
|
|
|
|
notebook_signals[SWITCH_PAGE] =
|
|
gtk_signal_new ("switch_page",
|
|
GTK_RUN_LAST,
|
|
GTK_CLASS_TYPE (object_class),
|
|
GTK_SIGNAL_OFFSET (GtkNotebookClass, switch_page),
|
|
gtk_marshal_VOID__POINTER_UINT,
|
|
GTK_TYPE_NONE, 2,
|
|
GTK_TYPE_POINTER,
|
|
GTK_TYPE_UINT);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_init (GtkNotebook *notebook)
|
|
{
|
|
GTK_WIDGET_SET_FLAGS (notebook, GTK_CAN_FOCUS | GTK_RECEIVES_DEFAULT);
|
|
GTK_WIDGET_UNSET_FLAGS (notebook, GTK_NO_WINDOW);
|
|
|
|
notebook->cur_page = NULL;
|
|
notebook->children = NULL;
|
|
notebook->first_tab = NULL;
|
|
notebook->focus_tab = NULL;
|
|
notebook->panel = NULL;
|
|
notebook->menu = NULL;
|
|
|
|
notebook->tab_hborder = 2;
|
|
notebook->tab_vborder = 2;
|
|
|
|
notebook->show_tabs = TRUE;
|
|
notebook->show_border = TRUE;
|
|
notebook->tab_pos = GTK_POS_TOP;
|
|
notebook->scrollable = FALSE;
|
|
notebook->in_child = 0;
|
|
notebook->click_child = 0;
|
|
notebook->button = 0;
|
|
notebook->need_timer = 0;
|
|
notebook->child_has_focus = FALSE;
|
|
notebook->have_visible_child = FALSE;
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_new:
|
|
*
|
|
* Creates a new #GtkNotebook widget with no pages.
|
|
|
|
* Return value: the newly created #GtkNotebook
|
|
**/
|
|
GtkWidget*
|
|
gtk_notebook_new (void)
|
|
{
|
|
return GTK_WIDGET (gtk_type_new (gtk_notebook_get_type ()));
|
|
}
|
|
|
|
/* Private GtkObject Methods :
|
|
*
|
|
* gtk_notebook_destroy
|
|
* gtk_notebook_set_arg
|
|
* gtk_notebook_get_arg
|
|
*/
|
|
static void
|
|
gtk_notebook_destroy (GtkObject *object)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
g_return_if_fail (object != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (object));
|
|
|
|
notebook = GTK_NOTEBOOK (object);
|
|
|
|
if (notebook->menu)
|
|
gtk_notebook_popup_disable (notebook);
|
|
|
|
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_set_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint arg_id)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
notebook = GTK_NOTEBOOK (object);
|
|
|
|
switch (arg_id)
|
|
{
|
|
case ARG_SHOW_TABS:
|
|
gtk_notebook_set_show_tabs (notebook, GTK_VALUE_BOOL (*arg));
|
|
break;
|
|
case ARG_SHOW_BORDER:
|
|
gtk_notebook_set_show_border (notebook, GTK_VALUE_BOOL (*arg));
|
|
break;
|
|
case ARG_SCROLLABLE:
|
|
gtk_notebook_set_scrollable (notebook, GTK_VALUE_BOOL (*arg));
|
|
break;
|
|
case ARG_ENABLE_POPUP:
|
|
if (GTK_VALUE_BOOL (*arg))
|
|
gtk_notebook_popup_enable (notebook);
|
|
else
|
|
gtk_notebook_popup_disable (notebook);
|
|
break;
|
|
case ARG_HOMOGENEOUS:
|
|
gtk_notebook_set_homogeneous_tabs (notebook, GTK_VALUE_BOOL (*arg));
|
|
break;
|
|
case ARG_PAGE:
|
|
gtk_notebook_set_page (notebook, GTK_VALUE_INT (*arg));
|
|
break;
|
|
case ARG_TAB_POS:
|
|
gtk_notebook_set_tab_pos (notebook, GTK_VALUE_ENUM (*arg));
|
|
break;
|
|
case ARG_TAB_BORDER:
|
|
gtk_notebook_set_tab_border (notebook, GTK_VALUE_UINT (*arg));
|
|
break;
|
|
case ARG_TAB_HBORDER:
|
|
gtk_notebook_set_tab_hborder (notebook, GTK_VALUE_UINT (*arg));
|
|
break;
|
|
case ARG_TAB_VBORDER:
|
|
gtk_notebook_set_tab_vborder (notebook, GTK_VALUE_UINT (*arg));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_get_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint arg_id)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
notebook = GTK_NOTEBOOK (object);
|
|
|
|
switch (arg_id)
|
|
{
|
|
case ARG_SHOW_TABS:
|
|
GTK_VALUE_BOOL (*arg) = notebook->show_tabs;
|
|
break;
|
|
case ARG_SHOW_BORDER:
|
|
GTK_VALUE_BOOL (*arg) = notebook->show_border;
|
|
break;
|
|
case ARG_SCROLLABLE:
|
|
GTK_VALUE_BOOL (*arg) = notebook->scrollable;
|
|
break;
|
|
case ARG_ENABLE_POPUP:
|
|
GTK_VALUE_BOOL (*arg) = notebook->menu != NULL;
|
|
break;
|
|
case ARG_HOMOGENEOUS:
|
|
GTK_VALUE_BOOL (*arg) = notebook->homogeneous;
|
|
break;
|
|
case ARG_PAGE:
|
|
GTK_VALUE_INT (*arg) = gtk_notebook_get_current_page (notebook);
|
|
break;
|
|
case ARG_TAB_POS:
|
|
GTK_VALUE_ENUM (*arg) = notebook->tab_pos;
|
|
break;
|
|
case ARG_TAB_HBORDER:
|
|
GTK_VALUE_UINT (*arg) = notebook->tab_hborder;
|
|
break;
|
|
case ARG_TAB_VBORDER:
|
|
GTK_VALUE_UINT (*arg) = notebook->tab_vborder;
|
|
break;
|
|
default:
|
|
arg->type = GTK_TYPE_INVALID;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Private GtkWidget Methods :
|
|
*
|
|
* gtk_notebook_map
|
|
* gtk_notebook_unmap
|
|
* gtk_notebook_realize
|
|
* gtk_notebook_size_request
|
|
* gtk_notebook_size_allocate
|
|
* gtk_notebook_expose
|
|
* gtk_notebook_button_press
|
|
* gtk_notebook_button_release
|
|
* gtk_notebook_enter_notify
|
|
* gtk_notebook_leave_notify
|
|
* gtk_notebook_motion_notify
|
|
* gtk_notebook_key_press
|
|
* gtk_notebook_focus_in
|
|
* gtk_notebook_focus_out
|
|
* gtk_notebook_draw_focus
|
|
* gtk_notebook_style_set
|
|
*/
|
|
static void
|
|
gtk_notebook_map (GtkWidget *widget)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GtkNotebookPage *page;
|
|
GList *children;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
|
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if (notebook->cur_page &&
|
|
GTK_WIDGET_VISIBLE (notebook->cur_page->child) &&
|
|
!GTK_WIDGET_MAPPED (notebook->cur_page->child))
|
|
gtk_widget_map (notebook->cur_page->child);
|
|
|
|
if (notebook->scrollable)
|
|
gtk_notebook_pages_allocate (notebook);
|
|
else
|
|
{
|
|
children = notebook->children;
|
|
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
|
|
if (page->tab_label &&
|
|
GTK_WIDGET_VISIBLE (page->tab_label) &&
|
|
!GTK_WIDGET_MAPPED (page->tab_label))
|
|
gtk_widget_map (page->tab_label);
|
|
}
|
|
}
|
|
|
|
gdk_window_show (widget->window);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_unmap (GtkWidget *widget)
|
|
{
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
|
|
gdk_window_hide (widget->window);
|
|
if (GTK_NOTEBOOK (widget)->panel)
|
|
gdk_window_hide (GTK_NOTEBOOK (widget)->panel);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_realize (GtkWidget *widget)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GdkWindowAttr attributes;
|
|
gint attributes_mask;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
GTK_WIDGET_SET_FLAGS (notebook, GTK_REALIZED);
|
|
|
|
attributes.window_type = GDK_WINDOW_CHILD;
|
|
attributes.x = widget->allocation.x;
|
|
attributes.y = widget->allocation.y;
|
|
attributes.width = widget->allocation.width;
|
|
attributes.height = widget->allocation.height;
|
|
attributes.wclass = GDK_INPUT_OUTPUT;
|
|
attributes.visual = gtk_widget_get_visual (widget);
|
|
attributes.colormap = gtk_widget_get_colormap (widget);
|
|
attributes.event_mask = gtk_widget_get_events (widget);
|
|
attributes.event_mask |= (GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
|
|
GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK);
|
|
|
|
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
|
|
|
|
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
|
|
gdk_window_set_user_data (widget->window, notebook);
|
|
|
|
widget->style = gtk_style_attach (widget->style, widget->window);
|
|
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
|
|
|
|
gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
|
|
if (notebook->scrollable)
|
|
gtk_notebook_panel_realize (notebook);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_unrealize (GtkWidget *widget)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if (notebook->panel)
|
|
{
|
|
gdk_window_set_user_data (notebook->panel, NULL);
|
|
gdk_window_destroy (notebook->panel);
|
|
notebook->panel = NULL;
|
|
}
|
|
|
|
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
|
|
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_size_request (GtkWidget *widget,
|
|
GtkRequisition *requisition)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GtkNotebookPage *page;
|
|
GList *children;
|
|
GtkRequisition child_requisition;
|
|
gboolean switch_page = FALSE;
|
|
gint vis_pages;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
|
|
g_return_if_fail (requisition != NULL);
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
widget->requisition.width = 0;
|
|
widget->requisition.height = 0;
|
|
|
|
for (children = notebook->children, vis_pages = 0; children;
|
|
children = children->next)
|
|
{
|
|
page = children->data;
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
{
|
|
vis_pages++;
|
|
gtk_widget_size_request (page->child, &child_requisition);
|
|
|
|
widget->requisition.width = MAX (widget->requisition.width,
|
|
child_requisition.width);
|
|
widget->requisition.height = MAX (widget->requisition.height,
|
|
child_requisition.height);
|
|
|
|
if (GTK_WIDGET_MAPPED (page->child) && page != notebook->cur_page)
|
|
gtk_widget_unmap (page->child);
|
|
if (notebook->menu && page->menu_label->parent &&
|
|
!GTK_WIDGET_VISIBLE (page->menu_label->parent))
|
|
gtk_widget_show (page->menu_label->parent);
|
|
}
|
|
else
|
|
{
|
|
if (page == notebook->cur_page)
|
|
switch_page = TRUE;
|
|
if (notebook->menu && page->menu_label->parent &&
|
|
GTK_WIDGET_VISIBLE (page->menu_label->parent))
|
|
gtk_widget_hide (page->menu_label->parent);
|
|
}
|
|
}
|
|
|
|
if (notebook->show_border || notebook->show_tabs)
|
|
{
|
|
widget->requisition.width += widget->style->xthickness * 2;
|
|
widget->requisition.height += widget->style->ythickness * 2;
|
|
|
|
if (notebook->show_tabs)
|
|
{
|
|
gint tab_width = 0;
|
|
gint tab_height = 0;
|
|
gint tab_max = 0;
|
|
gint padding;
|
|
|
|
for (children = notebook->children; children;
|
|
children = children->next)
|
|
{
|
|
page = children->data;
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
{
|
|
if (!GTK_WIDGET_VISIBLE (page->tab_label))
|
|
gtk_widget_show (page->tab_label);
|
|
|
|
gtk_widget_size_request (page->tab_label,
|
|
&child_requisition);
|
|
|
|
page->requisition.width =
|
|
child_requisition.width +
|
|
2 * widget->style->xthickness;
|
|
page->requisition.height =
|
|
child_requisition.height +
|
|
2 * widget->style->ythickness;
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
page->requisition.height += 2 * (notebook->tab_vborder +
|
|
FOCUS_WIDTH);
|
|
tab_height = MAX (tab_height, page->requisition.height);
|
|
tab_max = MAX (tab_max, page->requisition.width);
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
page->requisition.width += 2 * (notebook->tab_hborder +
|
|
FOCUS_WIDTH);
|
|
tab_width = MAX (tab_width, page->requisition.width);
|
|
tab_max = MAX (tab_max, page->requisition.height);
|
|
break;
|
|
}
|
|
}
|
|
else if (GTK_WIDGET_VISIBLE (page->tab_label))
|
|
gtk_widget_hide (page->tab_label);
|
|
}
|
|
|
|
children = notebook->children;
|
|
|
|
if (vis_pages)
|
|
{
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
if (tab_height == 0)
|
|
break;
|
|
|
|
if (notebook->scrollable && vis_pages > 1 &&
|
|
widget->requisition.width < tab_width)
|
|
tab_height = MAX (tab_height, ARROW_SIZE);
|
|
|
|
padding = 2 * (TAB_CURVATURE + FOCUS_WIDTH +
|
|
notebook->tab_hborder) - TAB_OVERLAP;
|
|
tab_max += padding;
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
|
|
if (!GTK_WIDGET_VISIBLE (page->child))
|
|
continue;
|
|
|
|
if (notebook->homogeneous)
|
|
page->requisition.width = tab_max;
|
|
else
|
|
page->requisition.width += padding;
|
|
|
|
tab_width += page->requisition.width;
|
|
page->requisition.height = tab_height;
|
|
}
|
|
|
|
if (notebook->scrollable && vis_pages > 1 &&
|
|
widget->requisition.width < tab_width)
|
|
tab_width = tab_max + 2 * (ARROW_SIZE + ARROW_SPACING);
|
|
|
|
if (notebook->homogeneous && !notebook->scrollable)
|
|
widget->requisition.width = MAX (widget->requisition.width,
|
|
vis_pages * tab_max +
|
|
TAB_OVERLAP);
|
|
else
|
|
widget->requisition.width = MAX (widget->requisition.width,
|
|
tab_width + TAB_OVERLAP);
|
|
|
|
widget->requisition.height += tab_height;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
if (tab_width == 0)
|
|
break;
|
|
|
|
if (notebook->scrollable && vis_pages > 1 &&
|
|
widget->requisition.height < tab_height)
|
|
tab_width = MAX (tab_width, ARROW_SPACING +2 * ARROW_SIZE);
|
|
|
|
padding = 2 * (TAB_CURVATURE + FOCUS_WIDTH +
|
|
notebook->tab_vborder) - TAB_OVERLAP;
|
|
tab_max += padding;
|
|
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
|
|
if (!GTK_WIDGET_VISIBLE (page->child))
|
|
continue;
|
|
|
|
page->requisition.width = tab_width;
|
|
|
|
if (notebook->homogeneous)
|
|
page->requisition.height = tab_max;
|
|
else
|
|
page->requisition.height += padding;
|
|
|
|
tab_height += page->requisition.height;
|
|
}
|
|
|
|
if (notebook->scrollable && vis_pages > 1 &&
|
|
widget->requisition.height < tab_height)
|
|
tab_height = tab_max + ARROW_SIZE + ARROW_SPACING;
|
|
|
|
widget->requisition.width += tab_width;
|
|
|
|
if (notebook->homogeneous && !notebook->scrollable)
|
|
widget->requisition.height =
|
|
MAX (widget->requisition.height,
|
|
vis_pages * tab_max + TAB_OVERLAP);
|
|
else
|
|
widget->requisition.height =
|
|
MAX (widget->requisition.height,
|
|
tab_height + TAB_OVERLAP);
|
|
|
|
if (!notebook->homogeneous || notebook->scrollable)
|
|
vis_pages = 1;
|
|
widget->requisition.height = MAX (widget->requisition.height,
|
|
vis_pages * tab_max +
|
|
TAB_OVERLAP);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (children = notebook->children; children;
|
|
children = children->next)
|
|
{
|
|
page = children->data;
|
|
|
|
if (page->tab_label && GTK_WIDGET_VISIBLE (page->tab_label))
|
|
gtk_widget_hide (page->tab_label);
|
|
}
|
|
}
|
|
}
|
|
|
|
widget->requisition.width += GTK_CONTAINER (widget)->border_width * 2;
|
|
widget->requisition.height += GTK_CONTAINER (widget)->border_width * 2;
|
|
|
|
if (switch_page)
|
|
{
|
|
if (vis_pages)
|
|
{
|
|
for (children = notebook->children; children;
|
|
children = children->next)
|
|
{
|
|
page = children->data;
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
{
|
|
gtk_notebook_switch_page (notebook, page, -1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (GTK_WIDGET_VISIBLE (widget))
|
|
{
|
|
widget->requisition.width = GTK_CONTAINER (widget)->border_width * 2;
|
|
widget->requisition.height= GTK_CONTAINER (widget)->border_width * 2;
|
|
}
|
|
}
|
|
if (vis_pages && !notebook->cur_page)
|
|
{
|
|
children = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, TRUE);
|
|
if (children)
|
|
{
|
|
notebook->first_tab = children;
|
|
gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE (children),-1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_size_allocate (GtkWidget *widget,
|
|
GtkAllocation *allocation)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GtkNotebookPage *page;
|
|
GtkAllocation child_allocation;
|
|
GList *children;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
|
|
g_return_if_fail (allocation != NULL);
|
|
|
|
widget->allocation = *allocation;
|
|
if (GTK_WIDGET_REALIZED (widget))
|
|
gdk_window_move_resize (widget->window,
|
|
allocation->x, allocation->y,
|
|
allocation->width, allocation->height);
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
if (notebook->children)
|
|
{
|
|
child_allocation.x = GTK_CONTAINER (widget)->border_width;
|
|
child_allocation.y = GTK_CONTAINER (widget)->border_width;
|
|
child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
|
|
child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
|
|
|
|
if (notebook->show_tabs || notebook->show_border)
|
|
{
|
|
child_allocation.x += widget->style->xthickness;
|
|
child_allocation.y += widget->style->ythickness;
|
|
child_allocation.width = MAX (1, (gint)child_allocation.width -
|
|
(gint) widget->style->xthickness * 2);
|
|
child_allocation.height = MAX (1, (gint)child_allocation.height -
|
|
(gint) widget->style->ythickness * 2);
|
|
|
|
if (notebook->show_tabs && notebook->children && notebook->cur_page)
|
|
{
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
child_allocation.y += notebook->cur_page->requisition.height;
|
|
case GTK_POS_BOTTOM:
|
|
child_allocation.height =
|
|
MAX (1, (gint)child_allocation.height -
|
|
(gint)notebook->cur_page->requisition.height);
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
child_allocation.x += notebook->cur_page->requisition.width;
|
|
case GTK_POS_RIGHT:
|
|
child_allocation.width =
|
|
MAX (1, (gint)child_allocation.width -
|
|
(gint)notebook->cur_page->requisition.width);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
children = notebook->children;
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
gtk_widget_size_allocate (page->child, &child_allocation);
|
|
}
|
|
|
|
gtk_notebook_pages_allocate (notebook);
|
|
}
|
|
gtk_notebook_set_shape (notebook);
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_expose (GtkWidget *widget,
|
|
GdkEventExpose *event)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GdkEventExpose child_event;
|
|
GdkRectangle child_area;
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
if (GTK_WIDGET_DRAWABLE (widget))
|
|
{
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
gtk_notebook_paint (widget, &event->area);
|
|
if (notebook->show_tabs)
|
|
{
|
|
if (notebook->cur_page &&
|
|
gtk_widget_intersect (notebook->cur_page->tab_label,
|
|
&event->area, &child_area))
|
|
gtk_widget_draw_focus (widget);
|
|
}
|
|
|
|
child_event = *event;
|
|
if (notebook->cur_page &&
|
|
GTK_WIDGET_NO_WINDOW (notebook->cur_page->child) &&
|
|
gtk_widget_intersect (notebook->cur_page->child, &event->area,
|
|
&child_event.area))
|
|
gtk_widget_event (notebook->cur_page->child, (GdkEvent*) &child_event);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
gtk_notebook_arrow_button_press (GtkNotebook *notebook,
|
|
GdkEventButton *event)
|
|
{
|
|
GtkWidget *widget = GTK_WIDGET (notebook);
|
|
|
|
GtkArrowType arrow = event->x <= ARROW_SIZE + ARROW_SPACING / 2 ? GTK_ARROW_LEFT : GTK_ARROW_RIGHT;
|
|
|
|
if (!GTK_WIDGET_HAS_FOCUS (widget))
|
|
gtk_widget_grab_focus (widget);
|
|
|
|
notebook->button = event->button;
|
|
notebook->click_child = arrow;
|
|
|
|
if (event->button == 1)
|
|
{
|
|
if (!notebook->focus_tab ||
|
|
gtk_notebook_search_page (notebook, notebook->focus_tab,
|
|
arrow == GTK_ARROW_LEFT ? STEP_PREV : STEP_NEXT,
|
|
TRUE))
|
|
gtk_container_focus (GTK_CONTAINER (notebook),
|
|
arrow == GTK_ARROW_LEFT ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
|
|
|
|
if (!notebook->timer)
|
|
{
|
|
notebook->timer = gtk_timeout_add
|
|
(NOTEBOOK_INIT_SCROLL_DELAY,
|
|
(GtkFunction) gtk_notebook_timer, (gpointer) notebook);
|
|
notebook->need_timer = TRUE;
|
|
}
|
|
}
|
|
else if (event->button == 2)
|
|
gtk_notebook_page_select (notebook, TRUE);
|
|
else if (event->button == 3)
|
|
gtk_notebook_switch_focus_tab (notebook,
|
|
gtk_notebook_search_page (notebook,
|
|
NULL,
|
|
arrow == GTK_ARROW_LEFT ? STEP_NEXT : STEP_PREV,
|
|
TRUE));
|
|
gtk_notebook_redraw_arrows (notebook);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gtk_notebook_button_press (GtkWidget *widget,
|
|
GdkEventButton *event)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GtkNotebookPage *page;
|
|
GList *children;
|
|
gint num;
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if (event->type != GDK_BUTTON_PRESS || !notebook->children ||
|
|
notebook->button)
|
|
return FALSE;
|
|
|
|
if (event->window == notebook->panel)
|
|
{
|
|
return gtk_notebook_arrow_button_press (notebook, event);
|
|
}
|
|
else if (event->window == widget->window)
|
|
{
|
|
if (event->button == 3 && notebook->menu)
|
|
{
|
|
gtk_menu_popup (GTK_MENU (notebook->menu), NULL, NULL,
|
|
NULL, NULL, 3, event->time);
|
|
return TRUE;
|
|
}
|
|
|
|
num = 0;
|
|
children = notebook->children;
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child) &&
|
|
page->tab_label && GTK_WIDGET_MAPPED (page->tab_label) &&
|
|
(event->x >= page->allocation.x) &&
|
|
(event->y >= page->allocation.y) &&
|
|
(event->x <= (page->allocation.x + page->allocation.width)) &&
|
|
(event->y <= (page->allocation.y + page->allocation.height)))
|
|
{
|
|
if (page == notebook->cur_page && notebook->focus_tab &&
|
|
notebook->focus_tab != children &&
|
|
GTK_WIDGET_HAS_FOCUS (notebook))
|
|
{
|
|
GtkNotebookPage *old_page;
|
|
|
|
notebook->child_has_focus = FALSE;
|
|
old_page = (GtkNotebookPage *)
|
|
(notebook->focus_tab->data);
|
|
gtk_notebook_switch_focus_tab (notebook, children);
|
|
gtk_notebook_focus_changed (notebook, old_page);
|
|
}
|
|
else
|
|
{
|
|
gtk_notebook_switch_focus_tab (notebook, children);
|
|
gtk_widget_grab_focus (widget);
|
|
gtk_notebook_switch_page (notebook, page, num);
|
|
}
|
|
break;
|
|
}
|
|
children = children->next;
|
|
num++;
|
|
}
|
|
if (!children && !GTK_WIDGET_HAS_FOCUS (widget))
|
|
gtk_widget_grab_focus (widget);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_button_release (GtkWidget *widget,
|
|
GdkEventButton *event)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
if (event->type != GDK_BUTTON_RELEASE)
|
|
return FALSE;
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if (event->button == notebook->button)
|
|
{
|
|
guint click_child;
|
|
|
|
if (notebook->timer)
|
|
{
|
|
gtk_timeout_remove (notebook->timer);
|
|
notebook->timer = 0;
|
|
notebook->need_timer = FALSE;
|
|
}
|
|
click_child = notebook->click_child;
|
|
notebook->click_child = 0;
|
|
notebook->button = 0;
|
|
gtk_notebook_redraw_arrows (notebook);
|
|
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_enter_notify (GtkWidget *widget,
|
|
GdkEventCrossing *event)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if (event->window == notebook->panel)
|
|
{
|
|
gint x;
|
|
gint y;
|
|
|
|
gdk_window_get_pointer (notebook->panel, &x, &y, NULL);
|
|
|
|
if (x <= ARROW_SIZE + ARROW_SPACING / 2)
|
|
notebook->in_child = GTK_ARROW_LEFT;
|
|
else
|
|
notebook->in_child = GTK_ARROW_RIGHT;
|
|
|
|
gtk_notebook_redraw_arrows (notebook);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_leave_notify (GtkWidget *widget,
|
|
GdkEventCrossing *event)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if (event->window == notebook->panel)
|
|
gtk_notebook_redraw_arrows (notebook);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_motion_notify (GtkWidget *widget,
|
|
GdkEventMotion *event)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if (notebook->button)
|
|
return FALSE;
|
|
|
|
if (event->window == notebook->panel)
|
|
{
|
|
gint x;
|
|
GtkArrowType old_child = notebook->in_child;
|
|
|
|
x = event->x;
|
|
if (event->is_hint)
|
|
gdk_window_get_pointer (notebook->panel, &x, NULL, NULL);
|
|
|
|
if (x <= ARROW_SIZE + ARROW_SPACING / 2)
|
|
notebook->in_child = GTK_ARROW_LEFT;
|
|
else
|
|
notebook->in_child = GTK_ARROW_RIGHT;
|
|
|
|
if (old_child != notebook->in_child)
|
|
gtk_notebook_redraw_arrows (notebook);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_key_press (GtkWidget *widget,
|
|
GdkEventKey *event)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GList *list;
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if (!notebook->children || !notebook->show_tabs)
|
|
return FALSE;
|
|
|
|
switch (event->keyval)
|
|
{
|
|
case GDK_Home:
|
|
list = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, TRUE);
|
|
if (list)
|
|
gtk_notebook_switch_focus_tab (notebook, list);
|
|
return TRUE;
|
|
case GDK_End:
|
|
list = gtk_notebook_search_page (notebook, NULL, STEP_PREV, TRUE);
|
|
if (list)
|
|
gtk_notebook_switch_focus_tab (notebook, list);
|
|
return TRUE;
|
|
case GDK_Return:
|
|
gtk_notebook_page_select (GTK_NOTEBOOK (widget), TRUE);
|
|
return TRUE;
|
|
case GDK_space:
|
|
gtk_notebook_page_select (GTK_NOTEBOOK (widget), FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_focus_in (GtkWidget *widget,
|
|
GdkEventFocus *event)
|
|
{
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
GTK_NOTEBOOK (widget)->child_has_focus = FALSE;
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
|
|
gtk_widget_draw_focus (widget);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_focus_out (GtkWidget *widget,
|
|
GdkEventFocus *event)
|
|
{
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
|
|
gtk_widget_draw_focus (widget);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_draw_focus (GtkWidget *widget)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if (GTK_WIDGET_DRAWABLE (widget) && notebook->show_tabs &&
|
|
notebook->focus_tab)
|
|
{
|
|
GtkNotebookPage *page;
|
|
GdkRectangle area;
|
|
|
|
page = notebook->focus_tab->data;
|
|
|
|
area.x = page->tab_label->allocation.x - 1;
|
|
area.y = page->tab_label->allocation.y - 1;
|
|
area.width = page->tab_label->allocation.width + 2;
|
|
area.height = page->tab_label->allocation.height + 2;
|
|
|
|
gtk_notebook_draw_tab (GTK_NOTEBOOK (widget), page, &area);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_style_set (GtkWidget *widget,
|
|
GtkStyle *previous_style)
|
|
{
|
|
if (GTK_WIDGET_REALIZED (widget) &&
|
|
!GTK_WIDGET_NO_WINDOW (widget))
|
|
{
|
|
gtk_style_set_background (widget->style, widget->window, widget->state);
|
|
if (GTK_WIDGET_DRAWABLE (widget))
|
|
gdk_window_clear (widget->window);
|
|
}
|
|
|
|
gtk_notebook_set_shape (GTK_NOTEBOOK(widget));
|
|
}
|
|
|
|
/* Private GtkContainer Methods :
|
|
*
|
|
* gtk_notebook_set_child_arg
|
|
* gtk_notebook_get_child_arg
|
|
* gtk_notebook_add
|
|
* gtk_notebook_remove
|
|
* gtk_notebook_focus
|
|
* gtk_notebook_set_focus_child
|
|
* gtk_notebook_child_type
|
|
* gtk_notebook_forall
|
|
*/
|
|
static void
|
|
gtk_notebook_set_child_arg (GtkContainer *container,
|
|
GtkWidget *child,
|
|
GtkArg *arg,
|
|
guint arg_id)
|
|
{
|
|
gboolean expand;
|
|
gboolean fill;
|
|
GtkPackType pack_type;
|
|
|
|
switch (arg_id)
|
|
{
|
|
case CHILD_ARG_TAB_LABEL:
|
|
/* a NULL pointer indicates a default_tab setting, otherwise
|
|
* we need to set the associated label
|
|
*/
|
|
gtk_notebook_set_tab_label_text (GTK_NOTEBOOK (container), child,
|
|
GTK_VALUE_STRING(*arg));
|
|
break;
|
|
case CHILD_ARG_MENU_LABEL:
|
|
gtk_notebook_set_menu_label_text (GTK_NOTEBOOK (container), child,
|
|
GTK_VALUE_STRING (*arg));
|
|
break;
|
|
case CHILD_ARG_POSITION:
|
|
gtk_notebook_reorder_child (GTK_NOTEBOOK (container), child,
|
|
GTK_VALUE_INT (*arg));
|
|
break;
|
|
case CHILD_ARG_TAB_EXPAND:
|
|
gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (container), child,
|
|
&expand, &fill, &pack_type);
|
|
gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (container), child,
|
|
GTK_VALUE_BOOL (*arg),
|
|
fill, pack_type);
|
|
break;
|
|
case CHILD_ARG_TAB_FILL:
|
|
gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (container), child,
|
|
&expand, &fill, &pack_type);
|
|
gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (container), child,
|
|
expand,
|
|
GTK_VALUE_BOOL (*arg),
|
|
pack_type);
|
|
break;
|
|
case CHILD_ARG_TAB_PACK:
|
|
gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (container), child,
|
|
&expand, &fill, &pack_type);
|
|
gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (container), child,
|
|
expand, fill,
|
|
GTK_VALUE_BOOL (*arg));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_get_child_arg (GtkContainer *container,
|
|
GtkWidget *child,
|
|
GtkArg *arg,
|
|
guint arg_id)
|
|
{
|
|
GList *list;
|
|
GtkNotebook *notebook;
|
|
GtkWidget *label;
|
|
gboolean expand;
|
|
gboolean fill;
|
|
GtkPackType pack_type;
|
|
|
|
notebook = GTK_NOTEBOOK (container);
|
|
|
|
arg->type = GTK_TYPE_INVALID;
|
|
|
|
list = CHECK_FIND_CHILD (notebook, child);
|
|
if (!list)
|
|
{
|
|
arg->type = GTK_TYPE_INVALID;
|
|
return;
|
|
}
|
|
|
|
switch (arg_id)
|
|
{
|
|
case CHILD_ARG_TAB_LABEL:
|
|
label = gtk_notebook_get_tab_label (notebook, child);
|
|
|
|
if (label && GTK_IS_LABEL (label))
|
|
GTK_VALUE_STRING (*arg) = g_strdup (GTK_LABEL (label)->label);
|
|
else
|
|
GTK_VALUE_STRING (*arg) = NULL;
|
|
break;
|
|
case CHILD_ARG_MENU_LABEL:
|
|
label = gtk_notebook_get_menu_label (notebook, child);
|
|
|
|
if (label && GTK_IS_LABEL (label))
|
|
GTK_VALUE_STRING (*arg) = g_strdup (GTK_LABEL (label)->label);
|
|
else
|
|
GTK_VALUE_STRING (*arg) = NULL;
|
|
break;
|
|
case CHILD_ARG_POSITION:
|
|
GTK_VALUE_INT (*arg) = g_list_position (notebook->children, list);
|
|
break;
|
|
case CHILD_ARG_TAB_EXPAND:
|
|
gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (container), child,
|
|
&expand, NULL, NULL);
|
|
GTK_VALUE_BOOL (*arg) = expand;
|
|
break;
|
|
case CHILD_ARG_TAB_FILL:
|
|
gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (container), child,
|
|
NULL, &fill, NULL);
|
|
GTK_VALUE_BOOL (*arg) = fill;
|
|
break;
|
|
case CHILD_ARG_TAB_PACK:
|
|
gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (container), child,
|
|
NULL, NULL, &pack_type);
|
|
GTK_VALUE_BOOL (*arg) = pack_type;
|
|
break;
|
|
default:
|
|
arg->type = GTK_TYPE_INVALID;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_add (GtkContainer *container,
|
|
GtkWidget *widget)
|
|
{
|
|
g_return_if_fail (container != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (container));
|
|
|
|
gtk_notebook_insert_page_menu (GTK_NOTEBOOK (container), widget,
|
|
NULL, NULL, -1);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_remove (GtkContainer *container,
|
|
GtkWidget *widget)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GtkNotebookPage *page;
|
|
GList *children;
|
|
guint page_num;
|
|
|
|
g_return_if_fail (container != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (container));
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
notebook = GTK_NOTEBOOK (container);
|
|
|
|
children = notebook->children;
|
|
page_num = 0;
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
if (page->child == widget)
|
|
{
|
|
gtk_notebook_real_remove (notebook, children);
|
|
break;
|
|
}
|
|
page_num++;
|
|
children = children->next;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
focus_tabs_in (GtkNotebook *notebook)
|
|
{
|
|
if (notebook->cur_page)
|
|
{
|
|
gtk_widget_grab_focus (GTK_WIDGET (notebook));
|
|
|
|
gtk_notebook_switch_focus_tab (notebook,
|
|
g_list_find (notebook->children,
|
|
notebook->cur_page));
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
focus_tabs_move (GtkNotebook *notebook,
|
|
GtkDirectionType direction,
|
|
gint search_direction)
|
|
{
|
|
GList *new_page;
|
|
|
|
new_page = gtk_notebook_search_page (notebook, notebook->focus_tab,
|
|
search_direction, TRUE);
|
|
if (!new_page)
|
|
new_page = (search_direction == STEP_NEXT) ?
|
|
notebook->children :
|
|
g_list_last (notebook->children);
|
|
|
|
gtk_notebook_switch_focus_tab (notebook, new_page);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
focus_child_in (GtkNotebook *notebook,
|
|
GtkDirectionType direction)
|
|
{
|
|
if (GTK_WIDGET_DRAWABLE (notebook->cur_page->child) &&
|
|
GTK_WIDGET_IS_SENSITIVE (notebook->cur_page->child))
|
|
{
|
|
if (GTK_IS_CONTAINER (notebook->cur_page->child))
|
|
{
|
|
if (gtk_container_focus (GTK_CONTAINER (notebook->cur_page->child), direction))
|
|
return TRUE;
|
|
}
|
|
else if (GTK_WIDGET_CAN_FOCUS (notebook->cur_page->child))
|
|
{
|
|
gtk_widget_grab_focus (notebook->cur_page->child);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/* Focus in the notebook can either be on the pages, or on
|
|
* the tabs.
|
|
*/
|
|
static gint
|
|
gtk_notebook_focus (GtkContainer *container,
|
|
GtkDirectionType direction)
|
|
{
|
|
GtkWidget *old_focus_child;
|
|
GtkNotebook *notebook;
|
|
GtkDirectionType effective_direction;
|
|
|
|
/* Remap the directions into the effective direction it would be for a
|
|
* GTK_POS_TOP notebook
|
|
*/
|
|
#define D(rest) GTK_DIR_##rest
|
|
|
|
static const GtkDirectionType translate_direction[4][6] = {
|
|
/* LEFT */ { D(TAB_FORWARD), D(TAB_BACKWARD), D(LEFT), D(RIGHT), D(UP), D(DOWN) },
|
|
/* RIGHT */ { D(TAB_BACKWARD), D(TAB_FORWARD), D(LEFT), D(RIGHT), D(DOWN), D(UP) },
|
|
/* TOP */ { D(TAB_FORWARD), D(TAB_BACKWARD), D(UP), D(DOWN), D(LEFT), D(RIGHT) },
|
|
/* BOTTOM */ { D(TAB_BACKWARD), D(TAB_FORWARD), D(DOWN), D(UP), D(LEFT), D(RIGHT) },
|
|
};
|
|
|
|
#undef D
|
|
|
|
gboolean widget_is_focus;
|
|
|
|
g_return_val_if_fail (container != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (container), FALSE);
|
|
|
|
notebook = GTK_NOTEBOOK (container);
|
|
|
|
widget_is_focus = gtk_widget_is_focus (GTK_WIDGET (container));
|
|
old_focus_child = container->focus_child;
|
|
|
|
effective_direction = translate_direction[notebook->tab_pos][direction];
|
|
|
|
if (old_focus_child &&
|
|
GTK_IS_CONTAINER (old_focus_child) &&
|
|
GTK_WIDGET_DRAWABLE (old_focus_child) &&
|
|
GTK_WIDGET_IS_SENSITIVE (old_focus_child) &&
|
|
gtk_container_focus (GTK_CONTAINER (old_focus_child), direction))
|
|
return TRUE;
|
|
|
|
if (old_focus_child) /* Focus on page child */
|
|
{
|
|
switch (effective_direction)
|
|
{
|
|
case GTK_DIR_TAB_BACKWARD:
|
|
case GTK_DIR_UP:
|
|
/* Focus onto the tabs */
|
|
if (notebook->show_tabs)
|
|
return focus_tabs_in (notebook);
|
|
else
|
|
return FALSE;
|
|
case GTK_DIR_DOWN:
|
|
case GTK_DIR_TAB_FORWARD:
|
|
case GTK_DIR_LEFT:
|
|
case GTK_DIR_RIGHT:
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if (widget_is_focus) /* Focus was on tabs */
|
|
{
|
|
switch (effective_direction)
|
|
{
|
|
case GTK_DIR_TAB_BACKWARD:
|
|
case GTK_DIR_UP:
|
|
return FALSE;
|
|
case GTK_DIR_TAB_FORWARD:
|
|
case GTK_DIR_DOWN:
|
|
return focus_child_in (notebook, direction);
|
|
case GTK_DIR_LEFT:
|
|
return focus_tabs_move (notebook, direction, STEP_PREV);
|
|
case GTK_DIR_RIGHT:
|
|
return focus_tabs_move (notebook, direction, STEP_NEXT);
|
|
}
|
|
}
|
|
else /* Focus was not on widget */
|
|
{
|
|
switch (effective_direction)
|
|
{
|
|
case GTK_DIR_TAB_FORWARD:
|
|
case GTK_DIR_DOWN:
|
|
if (focus_tabs_in (notebook))
|
|
return TRUE;
|
|
if (focus_child_in (notebook, direction))
|
|
return TRUE;
|
|
return FALSE;
|
|
case GTK_DIR_TAB_BACKWARD:
|
|
case GTK_DIR_UP:
|
|
if (focus_child_in (notebook, direction))
|
|
return TRUE;
|
|
if (focus_tabs_in (notebook))
|
|
return TRUE;
|
|
return FALSE;
|
|
case GTK_DIR_LEFT:
|
|
case GTK_DIR_RIGHT:
|
|
return focus_child_in (notebook, direction);
|
|
}
|
|
}
|
|
|
|
g_assert_not_reached ();
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_set_focus_child (GtkContainer *container,
|
|
GtkWidget *child)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
g_return_if_fail (container != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (container));
|
|
|
|
if (child)
|
|
{
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
|
|
notebook = GTK_NOTEBOOK (container);
|
|
|
|
notebook->child_has_focus = TRUE;
|
|
if (!notebook->focus_tab)
|
|
{
|
|
GList *children;
|
|
GtkNotebookPage *page;
|
|
|
|
children = notebook->children;
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
if (page->child == child || page->tab_label == child)
|
|
gtk_notebook_switch_focus_tab (notebook, children);
|
|
children = children->next;
|
|
}
|
|
}
|
|
}
|
|
parent_class->set_focus_child (container, child);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_forall (GtkContainer *container,
|
|
gboolean include_internals,
|
|
GtkCallback callback,
|
|
gpointer callback_data)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GList *children;
|
|
|
|
g_return_if_fail (container != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (container));
|
|
g_return_if_fail (callback != NULL);
|
|
|
|
notebook = GTK_NOTEBOOK (container);
|
|
|
|
children = notebook->children;
|
|
while (children)
|
|
{
|
|
GtkNotebookPage *page;
|
|
|
|
page = children->data;
|
|
children = children->next;
|
|
(* callback) (page->child, callback_data);
|
|
if (include_internals)
|
|
{
|
|
if (page->tab_label)
|
|
(* callback) (page->tab_label, callback_data);
|
|
if (page->menu_label)
|
|
(* callback) (page->menu_label, callback_data);
|
|
}
|
|
}
|
|
}
|
|
|
|
static GtkType
|
|
gtk_notebook_child_type (GtkContainer *container)
|
|
{
|
|
return GTK_TYPE_WIDGET;
|
|
}
|
|
|
|
/* Private GtkNotebook Functions:
|
|
*
|
|
* gtk_notebook_panel_realize
|
|
* gtk_notebook_redraw_tabs
|
|
* gtk_notebook_focus_changed
|
|
* gtk_notebook_real_remove
|
|
* gtk_notebook_update_labels
|
|
* gtk_notebook_timer
|
|
* gtk_notebook_page_compare
|
|
* gtk_notebook_real_page_position
|
|
* gtk_notebook_search_page
|
|
*/
|
|
static void
|
|
gtk_notebook_panel_realize (GtkNotebook *notebook)
|
|
{
|
|
GtkWidget *widget;
|
|
GdkWindowAttr attributes;
|
|
gint attributes_mask;
|
|
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
widget = GTK_WIDGET (notebook);
|
|
|
|
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 = gtk_widget_get_events (widget);
|
|
attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK
|
|
| GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK
|
|
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK;
|
|
|
|
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
|
|
|
|
attributes.width = 2 * ARROW_SIZE + ARROW_SPACING;
|
|
attributes.height = ARROW_SIZE;
|
|
|
|
attributes.x = (widget->allocation.width - attributes.width -
|
|
GTK_CONTAINER (notebook)->border_width);
|
|
attributes.y = (widget->allocation.height - ARROW_SIZE -
|
|
GTK_CONTAINER (notebook)->border_width);
|
|
if (notebook->tab_pos == GTK_POS_TOP)
|
|
attributes.y = GTK_CONTAINER (notebook)->border_width;
|
|
else if (notebook->tab_pos == GTK_POS_LEFT)
|
|
attributes.x = (widget->allocation.x +
|
|
GTK_CONTAINER (notebook)->border_width);
|
|
|
|
notebook->panel = gdk_window_new (widget->window, &attributes,
|
|
attributes_mask);
|
|
gtk_style_set_background (widget->style, notebook->panel,
|
|
GTK_STATE_NORMAL);
|
|
gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
|
|
gdk_window_set_user_data (notebook->panel, widget);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_redraw_tabs (GtkNotebook *notebook)
|
|
{
|
|
GtkWidget *widget;
|
|
GtkNotebookPage *page;
|
|
GdkRectangle redraw_rect;
|
|
gint border;
|
|
|
|
widget = GTK_WIDGET (notebook);
|
|
border = GTK_CONTAINER (notebook)->border_width;
|
|
|
|
if (!GTK_WIDGET_MAPPED (notebook) || !notebook->first_tab)
|
|
return;
|
|
|
|
page = notebook->first_tab->data;
|
|
|
|
redraw_rect.x = border;
|
|
redraw_rect.y = border;
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_BOTTOM:
|
|
redraw_rect.y = (widget->allocation.height - border -
|
|
page->allocation.height -
|
|
widget->style->ythickness);
|
|
if (page != notebook->cur_page)
|
|
redraw_rect.y -= widget->style->ythickness;
|
|
/* fall through */
|
|
case GTK_POS_TOP:
|
|
redraw_rect.width = widget->allocation.width - 2 * border;
|
|
redraw_rect.height = (page->allocation.height +
|
|
widget->style->ythickness);
|
|
if (page != notebook->cur_page)
|
|
redraw_rect.height += widget->style->ythickness;
|
|
break;
|
|
case GTK_POS_RIGHT:
|
|
redraw_rect.x = (widget->allocation.width - border -
|
|
page->allocation.width -
|
|
widget->style->xthickness);
|
|
if (page != notebook->cur_page)
|
|
redraw_rect.x -= widget->style->xthickness;
|
|
/* fall through */
|
|
case GTK_POS_LEFT:
|
|
redraw_rect.width = (page->allocation.width +
|
|
widget->style->xthickness);
|
|
redraw_rect.height = widget->allocation.height - 2 * border;
|
|
if (page != notebook->cur_page)
|
|
redraw_rect.width += widget->style->xthickness;
|
|
break;
|
|
}
|
|
|
|
gdk_window_invalidate_rect (widget->window, &redraw_rect, TRUE);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_redraw_arrows (GtkNotebook *notebook)
|
|
{
|
|
if (GTK_WIDGET_MAPPED (notebook) && notebook->panel)
|
|
gdk_window_invalidate_rect (notebook->panel, NULL, FALSE);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_focus_changed (GtkNotebook *notebook,
|
|
GtkNotebookPage *old_page)
|
|
{
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (GTK_WIDGET_DRAWABLE (notebook) && notebook->show_tabs)
|
|
{
|
|
GdkRectangle area;
|
|
|
|
if (notebook->focus_tab)
|
|
{
|
|
GtkNotebookPage *page;
|
|
|
|
page = notebook->focus_tab->data;
|
|
|
|
area.x = page->tab_label->allocation.x - 1;
|
|
area.y = page->tab_label->allocation.y - 1;
|
|
area.width = page->tab_label->allocation.width + 2;
|
|
area.height = page->tab_label->allocation.height + 2;
|
|
|
|
gtk_notebook_draw_tab (notebook, page, &area);
|
|
}
|
|
|
|
if (old_page)
|
|
{
|
|
area.x = old_page->tab_label->allocation.x - 1;
|
|
area.y = old_page->tab_label->allocation.y - 1;
|
|
area.width = old_page->tab_label->allocation.width + 2;
|
|
area.height = old_page->tab_label->allocation.height + 2;
|
|
|
|
gtk_notebook_draw_tab (notebook, old_page, &area);
|
|
}
|
|
}
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_timer (GtkNotebook *notebook)
|
|
{
|
|
gboolean retval = FALSE;
|
|
|
|
GDK_THREADS_ENTER ();
|
|
|
|
if (notebook->timer)
|
|
{
|
|
if (notebook->click_child == GTK_ARROW_LEFT)
|
|
{
|
|
if (!notebook->focus_tab ||
|
|
gtk_notebook_search_page (notebook, notebook->focus_tab,
|
|
STEP_PREV, TRUE))
|
|
gtk_container_focus (GTK_CONTAINER (notebook), GTK_DIR_LEFT);
|
|
}
|
|
else if (notebook->click_child == GTK_ARROW_RIGHT)
|
|
{
|
|
if (!notebook->focus_tab ||
|
|
gtk_notebook_search_page (notebook, notebook->focus_tab,
|
|
STEP_NEXT, TRUE))
|
|
gtk_container_focus (GTK_CONTAINER (notebook), GTK_DIR_RIGHT);
|
|
}
|
|
if (notebook->need_timer)
|
|
{
|
|
notebook->need_timer = FALSE;
|
|
notebook->timer = gtk_timeout_add (NOTEBOOK_SCROLL_DELAY,
|
|
(GtkFunction) gtk_notebook_timer,
|
|
(gpointer) notebook);
|
|
}
|
|
else
|
|
retval = TRUE;
|
|
}
|
|
|
|
GDK_THREADS_LEAVE ();
|
|
|
|
return retval;
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_page_compare (gconstpointer a,
|
|
gconstpointer b)
|
|
{
|
|
return (((GtkNotebookPage *) a)->child != b);
|
|
}
|
|
|
|
static GList *
|
|
gtk_notebook_find_child (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
const gchar *function)
|
|
{
|
|
GList *list = g_list_find_custom (notebook->children, child,
|
|
gtk_notebook_page_compare);
|
|
|
|
#ifndef G_DISABLE_CHECKS
|
|
if (!list)
|
|
g_warning ("child argument to '%s' does not refer to the contents of a notebook page",
|
|
function);
|
|
#endif
|
|
|
|
return list;
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_real_remove (GtkNotebook *notebook,
|
|
GList *list)
|
|
{
|
|
GtkNotebookPage *page;
|
|
GList * next_list;
|
|
gint need_resize = FALSE;
|
|
|
|
next_list = gtk_notebook_search_page (notebook, list, STEP_PREV, TRUE);
|
|
if (!next_list)
|
|
next_list = gtk_notebook_search_page (notebook, list, STEP_NEXT, TRUE);
|
|
|
|
if (notebook->cur_page == list->data)
|
|
{
|
|
notebook->cur_page = NULL;
|
|
if (next_list)
|
|
gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE (next_list), -1);
|
|
}
|
|
|
|
if (list == notebook->first_tab)
|
|
notebook->first_tab = next_list;
|
|
if (list == notebook->focus_tab)
|
|
gtk_notebook_switch_focus_tab (notebook, next_list);
|
|
|
|
page = list->data;
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child) && GTK_WIDGET_VISIBLE (notebook))
|
|
need_resize = TRUE;
|
|
|
|
gtk_widget_unparent (page->child);
|
|
|
|
if (page->tab_label)
|
|
gtk_widget_unparent (page->tab_label);
|
|
|
|
if (notebook->menu)
|
|
{
|
|
gtk_container_remove (GTK_CONTAINER (notebook->menu),
|
|
page->menu_label->parent);
|
|
gtk_widget_queue_resize (notebook->menu);
|
|
}
|
|
if (!page->default_menu)
|
|
gtk_widget_unref (page->menu_label);
|
|
|
|
notebook->children = g_list_remove_link (notebook->children, list);
|
|
g_list_free (list);
|
|
g_free (page);
|
|
|
|
gtk_notebook_update_labels (notebook);
|
|
if (need_resize)
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_update_labels (GtkNotebook *notebook)
|
|
{
|
|
GtkNotebookPage *page;
|
|
GList *list;
|
|
gchar string[32];
|
|
gint page_num = 1;
|
|
|
|
for (list = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, FALSE);
|
|
list;
|
|
list = gtk_notebook_search_page (notebook, list, STEP_NEXT, FALSE))
|
|
{
|
|
page = list->data;
|
|
g_snprintf (string, sizeof(string), _("Page %u"), page_num++);
|
|
if (notebook->show_tabs)
|
|
{
|
|
if (page->default_tab)
|
|
{
|
|
if (!page->tab_label)
|
|
{
|
|
page->tab_label = gtk_label_new (string);
|
|
gtk_widget_set_parent (page->tab_label,
|
|
GTK_WIDGET (notebook));
|
|
}
|
|
else
|
|
gtk_label_set_text (GTK_LABEL (page->tab_label), string);
|
|
}
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child) &&
|
|
!GTK_WIDGET_VISIBLE (page->tab_label))
|
|
gtk_widget_show (page->tab_label);
|
|
else if (!GTK_WIDGET_VISIBLE (page->child) &&
|
|
GTK_WIDGET_VISIBLE (page->tab_label))
|
|
gtk_widget_hide (page->tab_label);
|
|
}
|
|
if (notebook->menu && page->default_menu)
|
|
{
|
|
if (page->tab_label && GTK_IS_LABEL (page->tab_label))
|
|
gtk_label_set_text (GTK_LABEL (page->menu_label),
|
|
GTK_LABEL (page->tab_label)->label);
|
|
else
|
|
gtk_label_set_text (GTK_LABEL (page->menu_label), string);
|
|
}
|
|
}
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_real_page_position (GtkNotebook *notebook,
|
|
GList *list)
|
|
{
|
|
GList *work;
|
|
gint count_start;
|
|
|
|
g_return_val_if_fail (notebook != NULL, -1);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
|
|
g_return_val_if_fail (list != NULL, -1);
|
|
|
|
for (work = notebook->children, count_start = 0;
|
|
work && work != list; work = work->next)
|
|
if (GTK_NOTEBOOK_PAGE (work)->pack == GTK_PACK_START)
|
|
count_start++;
|
|
|
|
if (!work)
|
|
return -1;
|
|
|
|
if (GTK_NOTEBOOK_PAGE (list)->pack == GTK_PACK_START)
|
|
return count_start;
|
|
|
|
return (count_start + g_list_length (list) - 1);
|
|
}
|
|
|
|
static GList *
|
|
gtk_notebook_search_page (GtkNotebook *notebook,
|
|
GList *list,
|
|
gint direction,
|
|
gboolean find_visible)
|
|
{
|
|
GtkNotebookPage *page = NULL;
|
|
GList *old_list = NULL;
|
|
gint flag = 0;
|
|
|
|
g_return_val_if_fail (notebook != NULL, NULL);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
|
|
|
|
switch (direction)
|
|
{
|
|
case STEP_PREV:
|
|
flag = GTK_PACK_END;
|
|
break;
|
|
|
|
case STEP_NEXT:
|
|
flag = GTK_PACK_START;
|
|
break;
|
|
}
|
|
|
|
if (list)
|
|
page = list->data;
|
|
|
|
if (!page || page->pack == flag)
|
|
{
|
|
if (list)
|
|
{
|
|
old_list = list;
|
|
list = list->next;
|
|
}
|
|
else
|
|
list = notebook->children;
|
|
|
|
while (list)
|
|
{
|
|
page = list->data;
|
|
if (page->pack == flag &&
|
|
(!find_visible || GTK_WIDGET_VISIBLE (page->child)))
|
|
return list;
|
|
old_list = list;
|
|
list = list->next;
|
|
}
|
|
list = old_list;
|
|
}
|
|
else
|
|
{
|
|
old_list = list;
|
|
list = list->prev;
|
|
}
|
|
while (list)
|
|
{
|
|
page = list->data;
|
|
if (page->pack != flag &&
|
|
(!find_visible || GTK_WIDGET_VISIBLE (page->child)))
|
|
return list;
|
|
old_list = list;
|
|
list = list->prev;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* Private GtkNotebook Drawing Functions:
|
|
*
|
|
* gtk_notebook_paint
|
|
* gtk_notebook_draw_tab
|
|
* gtk_notebook_draw_arrow
|
|
* gtk_notebook_set_shape
|
|
*/
|
|
static void
|
|
gtk_notebook_paint (GtkWidget *widget,
|
|
GdkRectangle *area)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GtkNotebookPage *page;
|
|
GList *children;
|
|
gboolean showarrow;
|
|
gint width, height;
|
|
gint x, y;
|
|
gint gap_x = 0, gap_width = 0;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
|
|
g_return_if_fail (area != NULL);
|
|
|
|
if (!GTK_WIDGET_DRAWABLE (widget))
|
|
return;
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
|
|
if ((!notebook->show_tabs && !notebook->show_border) ||
|
|
!notebook->cur_page || !GTK_WIDGET_VISIBLE (notebook->cur_page->child))
|
|
{
|
|
gdk_window_clear_area (widget->window,
|
|
area->x, area->y,
|
|
area->width, area->height);
|
|
return;
|
|
}
|
|
|
|
x = GTK_CONTAINER (widget)->border_width;
|
|
y = GTK_CONTAINER (widget)->border_width;
|
|
width = widget->allocation.width - x * 2;
|
|
height = widget->allocation.height - y * 2;
|
|
|
|
if (notebook->show_border && (!notebook->show_tabs || !notebook->children))
|
|
{
|
|
gtk_paint_box (widget->style, widget->window,
|
|
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
|
|
area, widget, "notebook",
|
|
x, y, width, height);
|
|
return;
|
|
}
|
|
|
|
|
|
if (!GTK_WIDGET_MAPPED (notebook->cur_page->tab_label))
|
|
{
|
|
page = notebook->first_tab->data;
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
y += page->allocation.height + widget->style->ythickness;
|
|
case GTK_POS_BOTTOM:
|
|
height -= page->allocation.height + widget->style->ythickness;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
x += page->allocation.width + widget->style->xthickness;
|
|
case GTK_POS_RIGHT:
|
|
width -= page->allocation.width + widget->style->xthickness;
|
|
break;
|
|
}
|
|
gtk_paint_box (widget->style, widget->window,
|
|
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
|
|
area, widget, "notebook",
|
|
x, y, width, height);
|
|
}
|
|
else
|
|
{
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
y += notebook->cur_page->allocation.height;
|
|
case GTK_POS_BOTTOM:
|
|
height -= notebook->cur_page->allocation.height;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
x += notebook->cur_page->allocation.width;
|
|
case GTK_POS_RIGHT:
|
|
width -= notebook->cur_page->allocation.width;
|
|
break;
|
|
}
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
gap_x = (notebook->cur_page->allocation.x -
|
|
GTK_CONTAINER(notebook)->border_width);
|
|
gap_width = notebook->cur_page->allocation.width;
|
|
break;
|
|
case GTK_POS_BOTTOM:
|
|
gap_x = (notebook->cur_page->allocation.x -
|
|
GTK_CONTAINER(notebook)->border_width);
|
|
gap_width = notebook->cur_page->allocation.width;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
gap_x = (notebook->cur_page->allocation.y -
|
|
GTK_CONTAINER(notebook)->border_width);
|
|
gap_width = notebook->cur_page->allocation.height;
|
|
break;
|
|
case GTK_POS_RIGHT:
|
|
gap_x = (notebook->cur_page->allocation.y -
|
|
GTK_CONTAINER(notebook)->border_width);
|
|
gap_width = notebook->cur_page->allocation.height;
|
|
break;
|
|
}
|
|
gtk_paint_box_gap(widget->style, widget->window,
|
|
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
|
|
area, widget, "notebook",
|
|
x, y, width, height,
|
|
notebook->tab_pos, gap_x, gap_width);
|
|
}
|
|
|
|
showarrow = FALSE;
|
|
children = gtk_notebook_search_page (notebook, NULL, STEP_PREV, TRUE);
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = gtk_notebook_search_page (notebook, children,
|
|
STEP_PREV, TRUE);
|
|
if (!GTK_WIDGET_VISIBLE (page->child))
|
|
continue;
|
|
if (!GTK_WIDGET_MAPPED (page->tab_label))
|
|
showarrow = TRUE;
|
|
else if (page != notebook->cur_page)
|
|
gtk_notebook_draw_tab (notebook, page, area);
|
|
}
|
|
|
|
if (showarrow && notebook->scrollable)
|
|
{
|
|
gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
|
|
gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
|
|
}
|
|
gtk_notebook_draw_tab (notebook, notebook->cur_page, area);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_draw_tab (GtkNotebook *notebook,
|
|
GtkNotebookPage *page,
|
|
GdkRectangle *area)
|
|
{
|
|
GdkRectangle child_area;
|
|
GdkRectangle page_area;
|
|
GtkStateType state_type;
|
|
GtkPositionType gap_side;
|
|
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (page != NULL);
|
|
g_return_if_fail (area != NULL);
|
|
|
|
if (!GTK_WIDGET_MAPPED (page->tab_label) ||
|
|
(page->allocation.width == 0) || (page->allocation.height == 0))
|
|
return;
|
|
|
|
page_area.x = page->allocation.x;
|
|
page_area.y = page->allocation.y;
|
|
page_area.width = page->allocation.width;
|
|
page_area.height = page->allocation.height;
|
|
|
|
if (gdk_rectangle_intersect (&page_area, area, &child_area))
|
|
{
|
|
GtkWidget *widget;
|
|
|
|
widget = GTK_WIDGET (notebook);
|
|
gap_side = 0;
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
gap_side = GTK_POS_BOTTOM;
|
|
break;
|
|
case GTK_POS_BOTTOM:
|
|
gap_side = GTK_POS_TOP;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
gap_side = GTK_POS_RIGHT;
|
|
break;
|
|
case GTK_POS_RIGHT:
|
|
gap_side = GTK_POS_LEFT;
|
|
break;
|
|
}
|
|
|
|
if (notebook->cur_page == page)
|
|
state_type = GTK_STATE_NORMAL;
|
|
else
|
|
state_type = GTK_STATE_ACTIVE;
|
|
gtk_paint_extension(widget->style, widget->window,
|
|
state_type, GTK_SHADOW_OUT,
|
|
area, widget, "tab",
|
|
page_area.x, page_area.y,
|
|
page_area.width, page_area.height,
|
|
gap_side);
|
|
if ((GTK_WIDGET_HAS_FOCUS (widget)) &&
|
|
notebook->focus_tab && (notebook->focus_tab->data == page))
|
|
{
|
|
gtk_paint_focus (widget->style, widget->window,
|
|
area, widget, "tab",
|
|
page->tab_label->allocation.x - 1,
|
|
page->tab_label->allocation.y - 1,
|
|
page->tab_label->allocation.width + 1,
|
|
page->tab_label->allocation.height + 1);
|
|
}
|
|
if (gtk_widget_intersect (page->tab_label, area, &child_area) &&
|
|
GTK_WIDGET_DRAWABLE (page->tab_label))
|
|
{
|
|
GdkEventExpose expose_event;
|
|
|
|
/* This is a lame hack since all this code needs rewriting anyhow */
|
|
|
|
expose_event.window = page->tab_label->window;
|
|
expose_event.area = child_area;
|
|
expose_event.send_event = TRUE;
|
|
expose_event.type = GDK_EXPOSE;
|
|
expose_event.count = 0;
|
|
|
|
gtk_widget_event (page->tab_label,
|
|
(GdkEvent*)&expose_event);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_draw_arrow (GtkNotebook *notebook,
|
|
guint arrow)
|
|
{
|
|
GtkStateType state_type;
|
|
GtkShadowType shadow_type;
|
|
GtkWidget *widget;
|
|
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
widget = GTK_WIDGET(notebook);
|
|
|
|
if (GTK_WIDGET_DRAWABLE (notebook))
|
|
{
|
|
if (notebook->in_child == arrow)
|
|
{
|
|
if (notebook->click_child == arrow)
|
|
state_type = GTK_STATE_ACTIVE;
|
|
else
|
|
state_type = GTK_STATE_PRELIGHT;
|
|
}
|
|
else
|
|
state_type = GTK_STATE_NORMAL;
|
|
|
|
if (notebook->click_child == arrow)
|
|
shadow_type = GTK_SHADOW_IN;
|
|
else
|
|
shadow_type = GTK_SHADOW_OUT;
|
|
|
|
if (arrow == GTK_ARROW_LEFT)
|
|
{
|
|
if (notebook->focus_tab &&
|
|
!gtk_notebook_search_page (notebook, notebook->focus_tab,
|
|
STEP_PREV, TRUE))
|
|
{
|
|
shadow_type = GTK_SHADOW_ETCHED_IN;
|
|
state_type = GTK_STATE_NORMAL;
|
|
}
|
|
|
|
if (notebook->tab_pos == GTK_POS_LEFT ||
|
|
notebook->tab_pos == GTK_POS_RIGHT)
|
|
arrow = GTK_ARROW_UP;
|
|
|
|
gdk_window_clear_area (notebook->panel, 0, 0, ARROW_SIZE, ARROW_SIZE);
|
|
gtk_paint_arrow (widget->style, notebook->panel, state_type,
|
|
shadow_type, NULL, GTK_WIDGET(notebook), "notebook",
|
|
arrow, TRUE,
|
|
0, 0, ARROW_SIZE, ARROW_SIZE);
|
|
}
|
|
else
|
|
{
|
|
if (notebook->focus_tab &&
|
|
!gtk_notebook_search_page (notebook, notebook->focus_tab,
|
|
STEP_NEXT, TRUE))
|
|
{
|
|
shadow_type = GTK_SHADOW_ETCHED_IN;
|
|
state_type = GTK_STATE_NORMAL;
|
|
}
|
|
|
|
if (notebook->tab_pos == GTK_POS_LEFT ||
|
|
notebook->tab_pos == GTK_POS_RIGHT)
|
|
arrow = GTK_ARROW_DOWN;
|
|
|
|
gdk_window_clear_area(notebook->panel, ARROW_SIZE + ARROW_SPACING,
|
|
0, ARROW_SIZE, ARROW_SIZE);
|
|
gtk_paint_arrow (widget->style, notebook->panel, state_type,
|
|
shadow_type, NULL, GTK_WIDGET(notebook), "notebook",
|
|
arrow, TRUE, ARROW_SIZE + ARROW_SPACING,
|
|
0, ARROW_SIZE, ARROW_SIZE);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_set_shape (GtkNotebook *notebook)
|
|
{
|
|
GtkWidget *widget = NULL;
|
|
GdkPixmap *pm = NULL;
|
|
GdkGC *pmgc = NULL;
|
|
GdkColor col;
|
|
gint x, y, width, height, w, h, depth;
|
|
GtkNotebookPage *page;
|
|
GList *children;
|
|
|
|
if (!GTK_WIDGET(notebook)->window)
|
|
return;
|
|
|
|
widget = GTK_WIDGET(notebook);
|
|
|
|
w = widget->allocation.width;
|
|
h = widget->allocation.height;
|
|
|
|
pm = gdk_pixmap_new (widget->window, w, h, 1);
|
|
pmgc = gdk_gc_new (pm);
|
|
|
|
/* clear the shape mask */
|
|
col.pixel = 0;
|
|
gdk_gc_set_foreground(pmgc, &col);
|
|
gdk_draw_rectangle(pm, pmgc, TRUE, 0, 0, w, h);
|
|
|
|
col.pixel = 1;
|
|
gdk_gc_set_foreground(pmgc, &col);
|
|
|
|
/* draw the shape for the notebook page itself */
|
|
x = GTK_CONTAINER(notebook)->border_width;
|
|
y = GTK_CONTAINER(notebook)->border_width;
|
|
width = widget->allocation.width - x * 2;
|
|
height = widget->allocation.height - y * 2;
|
|
|
|
if (notebook->show_tabs && notebook->children)
|
|
{
|
|
if (!(notebook->show_tabs))
|
|
{
|
|
page = notebook->first_tab->data;
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
y += page->allocation.height +
|
|
widget->style->ythickness;
|
|
case GTK_POS_BOTTOM:
|
|
height -= page->allocation.height +
|
|
widget->style->ythickness;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
x += page->allocation.width +
|
|
widget->style->xthickness;
|
|
case GTK_POS_RIGHT:
|
|
width -= page->allocation.width +
|
|
widget->style->xthickness;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (notebook->cur_page)
|
|
page = notebook->cur_page;
|
|
else
|
|
page = notebook->children->data;
|
|
|
|
if (!GTK_WIDGET_MAPPED (page->tab_label))
|
|
{
|
|
if (notebook->tab_pos == GTK_POS_LEFT)
|
|
{
|
|
x -= widget->style->xthickness * 2;
|
|
width += widget->style->xthickness * 2;
|
|
}
|
|
else if (notebook->tab_pos == GTK_POS_RIGHT)
|
|
width += widget->style->xthickness * 2;
|
|
}
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
y += page->allocation.height;
|
|
case GTK_POS_BOTTOM:
|
|
height -= page->allocation.height;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
x += page->allocation.width;
|
|
case GTK_POS_RIGHT:
|
|
width -= page->allocation.width;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
gdk_draw_rectangle(pm, pmgc, TRUE, x, y, width, height);
|
|
|
|
/* if theres an area for scrolling arrows draw the shape for them */
|
|
if (notebook->panel && gdk_window_is_visible (notebook->panel))
|
|
{
|
|
gdk_window_get_geometry(notebook->panel, &x, &y, &width, &height, &depth);
|
|
gdk_draw_rectangle(pm, pmgc, TRUE, x, y, width, height);
|
|
}
|
|
|
|
/* draw the shapes of all the children */
|
|
if (notebook->show_tabs)
|
|
{
|
|
children = notebook->children;
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
if (GTK_WIDGET_MAPPED (page->tab_label))
|
|
{
|
|
x = page->allocation.x;
|
|
y = page->allocation.y;
|
|
width = page->allocation.width;
|
|
height = page->allocation.height;
|
|
gdk_draw_rectangle(pm, pmgc, TRUE, x, y, width, height);
|
|
}
|
|
children = children->next;
|
|
}
|
|
}
|
|
|
|
/* set the mask */
|
|
gdk_window_shape_combine_mask(widget->window, pm, 0, 0);
|
|
gdk_pixmap_unref(pm);
|
|
gdk_gc_destroy(pmgc);
|
|
}
|
|
|
|
/* Private GtkNotebook Size Allocate Functions:
|
|
*
|
|
* gtk_notebook_pages_allocate
|
|
* gtk_notebook_page_allocate
|
|
* gtk_notebook_calc_tabs
|
|
*/
|
|
static void
|
|
gtk_notebook_pages_allocate (GtkNotebook *notebook)
|
|
{
|
|
GtkWidget *widget = GTK_WIDGET (notebook);
|
|
GtkContainer *container = GTK_CONTAINER (notebook);
|
|
GtkNotebookPage *page = NULL;
|
|
GtkAllocation *allocation = &widget->allocation;
|
|
GtkAllocation child_allocation;
|
|
GList *children = NULL;
|
|
GList *last_child = NULL;
|
|
gboolean showarrow = FALSE;
|
|
gint tab_space = 0;
|
|
gint delta;
|
|
gint x = 0;
|
|
gint y = 0;
|
|
gint i;
|
|
gint n = 1;
|
|
gint old_fill = 0;
|
|
gint new_fill = 0;
|
|
|
|
if (!notebook->show_tabs || !notebook->children || !notebook->cur_page)
|
|
return;
|
|
|
|
child_allocation.x = container->border_width;
|
|
child_allocation.y = container->border_width;
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_BOTTOM:
|
|
child_allocation.y = (allocation->height -
|
|
notebook->cur_page->requisition.height -
|
|
container->border_width);
|
|
/* fall through */
|
|
case GTK_POS_TOP:
|
|
child_allocation.height = notebook->cur_page->requisition.height;
|
|
break;
|
|
|
|
case GTK_POS_RIGHT:
|
|
child_allocation.x = (allocation->width -
|
|
notebook->cur_page->requisition.width -
|
|
container->border_width);
|
|
/* fall through */
|
|
case GTK_POS_LEFT:
|
|
child_allocation.width = notebook->cur_page->requisition.width;
|
|
break;
|
|
}
|
|
|
|
if (notebook->scrollable)
|
|
{
|
|
GList *focus_tab;
|
|
|
|
children = notebook->children;
|
|
|
|
if (notebook->focus_tab)
|
|
focus_tab = notebook->focus_tab;
|
|
else if (notebook->first_tab)
|
|
focus_tab = notebook->first_tab;
|
|
else
|
|
focus_tab = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, TRUE);
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
tab_space += page->requisition.width;
|
|
}
|
|
if (tab_space >
|
|
allocation->width - 2 * container->border_width - TAB_OVERLAP)
|
|
{
|
|
showarrow = TRUE;
|
|
page = focus_tab->data;
|
|
|
|
tab_space = (allocation->width - TAB_OVERLAP -
|
|
page->requisition.width -
|
|
2 * (container->border_width + ARROW_SPACING +
|
|
ARROW_SIZE));
|
|
x = (allocation->width - 2 * ARROW_SIZE - ARROW_SPACING -
|
|
container->border_width);
|
|
|
|
page = notebook->children->data;
|
|
if (notebook->tab_pos == GTK_POS_TOP)
|
|
y = (container->border_width +
|
|
(page->requisition.height - ARROW_SIZE) / 2);
|
|
else
|
|
y = (allocation->height - container->border_width -
|
|
ARROW_SIZE - (page->requisition.height - ARROW_SIZE) / 2);
|
|
}
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
tab_space += page->requisition.height;
|
|
}
|
|
if (tab_space >
|
|
(allocation->height - 2 * container->border_width - TAB_OVERLAP))
|
|
{
|
|
showarrow = TRUE;
|
|
page = focus_tab->data;
|
|
tab_space = (allocation->height -
|
|
ARROW_SIZE - ARROW_SPACING - TAB_OVERLAP -
|
|
2 * container->border_width -
|
|
page->requisition.height);
|
|
y = allocation->height - container->border_width - ARROW_SIZE;
|
|
|
|
page = notebook->children->data;
|
|
if (notebook->tab_pos == GTK_POS_LEFT)
|
|
x = (container->border_width +
|
|
(page->requisition.width -
|
|
(2 * ARROW_SIZE - ARROW_SPACING)) / 2);
|
|
else
|
|
x = (allocation->width - container->border_width -
|
|
(2 * ARROW_SIZE - ARROW_SPACING) -
|
|
(page->requisition.width -
|
|
(2 * ARROW_SIZE - ARROW_SPACING)) / 2);
|
|
}
|
|
break;
|
|
}
|
|
if (showarrow) /* first_tab <- focus_tab */
|
|
{
|
|
if (tab_space <= 0)
|
|
{
|
|
notebook->first_tab = focus_tab;
|
|
last_child = gtk_notebook_search_page (notebook, focus_tab,
|
|
STEP_NEXT, TRUE);
|
|
}
|
|
else
|
|
{
|
|
children = NULL;
|
|
if (notebook->first_tab && notebook->first_tab != focus_tab)
|
|
{
|
|
/* Is first_tab really predecessor of focus_tab ? */
|
|
page = notebook->first_tab->data;
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
for (children = focus_tab;
|
|
children && children != notebook->first_tab;
|
|
children = gtk_notebook_search_page (notebook,
|
|
children,
|
|
STEP_PREV,
|
|
TRUE));
|
|
}
|
|
if (!children)
|
|
notebook->first_tab = focus_tab;
|
|
else
|
|
gtk_notebook_calc_tabs (notebook,
|
|
gtk_notebook_search_page (notebook,
|
|
focus_tab,
|
|
STEP_PREV,
|
|
TRUE),
|
|
&(notebook->first_tab), &tab_space,
|
|
STEP_PREV);
|
|
|
|
if (tab_space <= 0)
|
|
{
|
|
notebook->first_tab =
|
|
gtk_notebook_search_page (notebook, notebook->first_tab,
|
|
STEP_NEXT, TRUE);
|
|
if (!notebook->first_tab)
|
|
notebook->first_tab = focus_tab;
|
|
last_child = gtk_notebook_search_page (notebook, focus_tab,
|
|
STEP_NEXT, TRUE);
|
|
}
|
|
else /* focus_tab -> end */
|
|
{
|
|
if (!notebook->first_tab)
|
|
notebook->first_tab = gtk_notebook_search_page (notebook,
|
|
NULL,
|
|
STEP_NEXT,
|
|
TRUE);
|
|
children = NULL;
|
|
gtk_notebook_calc_tabs (notebook,
|
|
gtk_notebook_search_page (notebook,
|
|
focus_tab,
|
|
STEP_NEXT,
|
|
TRUE),
|
|
&children, &tab_space, STEP_NEXT);
|
|
|
|
if (tab_space <= 0)
|
|
last_child = children;
|
|
else /* start <- first_tab */
|
|
{
|
|
last_child = NULL;
|
|
children = NULL;
|
|
gtk_notebook_calc_tabs
|
|
(notebook,
|
|
gtk_notebook_search_page (notebook,
|
|
notebook->first_tab,
|
|
STEP_PREV,
|
|
TRUE),
|
|
&children, &tab_space, STEP_PREV);
|
|
notebook->first_tab = gtk_notebook_search_page(notebook,
|
|
children,
|
|
STEP_NEXT,
|
|
TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GTK_WIDGET_REALIZED (notebook))
|
|
{
|
|
gdk_window_move (notebook->panel, x, y);
|
|
gdk_window_show (notebook->panel);
|
|
}
|
|
|
|
if (tab_space < 0)
|
|
{
|
|
tab_space = -tab_space;
|
|
n = 0;
|
|
for (children = notebook->first_tab;
|
|
children && children != last_child;
|
|
children = gtk_notebook_search_page (notebook, children,
|
|
STEP_NEXT, TRUE))
|
|
n++;
|
|
}
|
|
else
|
|
tab_space = 0;
|
|
|
|
/*unmap all non-visible tabs*/
|
|
for (children = gtk_notebook_search_page (notebook, NULL,
|
|
STEP_NEXT, TRUE);
|
|
children && children != notebook->first_tab;
|
|
children = gtk_notebook_search_page (notebook, children,
|
|
STEP_NEXT, TRUE))
|
|
{
|
|
page = children->data;
|
|
if (page->tab_label && GTK_WIDGET_MAPPED (page->tab_label))
|
|
gtk_widget_unmap (page->tab_label);
|
|
}
|
|
for (children = last_child; children;
|
|
children = gtk_notebook_search_page (notebook, children,
|
|
STEP_NEXT, TRUE))
|
|
{
|
|
page = children->data;
|
|
if (page->tab_label && GTK_WIDGET_MAPPED (page->tab_label))
|
|
gtk_widget_unmap (page->tab_label);
|
|
}
|
|
}
|
|
else /* !showarrow */
|
|
{
|
|
notebook->first_tab = gtk_notebook_search_page (notebook, NULL,
|
|
STEP_NEXT, TRUE);
|
|
tab_space = 0;
|
|
if (GTK_WIDGET_REALIZED (notebook))
|
|
gdk_window_hide (notebook->panel);
|
|
}
|
|
}
|
|
|
|
if (!showarrow)
|
|
{
|
|
gint c = 0;
|
|
|
|
n = 0;
|
|
children = notebook->children;
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
{
|
|
c++;
|
|
tab_space += page->requisition.width;
|
|
if (page->expand)
|
|
n++;
|
|
}
|
|
}
|
|
tab_space -= allocation->width;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
{
|
|
c++;
|
|
tab_space += page->requisition.height;
|
|
if (page->expand)
|
|
n++;
|
|
}
|
|
}
|
|
tab_space -= allocation->height;
|
|
}
|
|
tab_space += 2 * container->border_width + TAB_OVERLAP;
|
|
tab_space *= -1;
|
|
notebook->first_tab = gtk_notebook_search_page (notebook, NULL,
|
|
STEP_NEXT, TRUE);
|
|
if (notebook->homogeneous && n)
|
|
n = c;
|
|
}
|
|
|
|
children = notebook->first_tab;
|
|
i = 1;
|
|
while (children)
|
|
{
|
|
if (children == last_child)
|
|
{
|
|
/* FIXME double check */
|
|
goto done;
|
|
}
|
|
|
|
page = children->data;
|
|
if (!showarrow && page->pack != GTK_PACK_START)
|
|
break;
|
|
children = gtk_notebook_search_page (notebook, children, STEP_NEXT,TRUE);
|
|
|
|
delta = 0;
|
|
if (n && (showarrow || page->expand || notebook->homogeneous))
|
|
{
|
|
new_fill = (tab_space * i++) / n;
|
|
delta = new_fill - old_fill;
|
|
old_fill = new_fill;
|
|
}
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
child_allocation.width = (page->requisition.width +
|
|
TAB_OVERLAP + delta);
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
child_allocation.height = (page->requisition.height +
|
|
TAB_OVERLAP + delta);
|
|
break;
|
|
}
|
|
|
|
gtk_notebook_page_allocate (notebook, page, &child_allocation);
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
child_allocation.x += child_allocation.width - TAB_OVERLAP;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
child_allocation.y += child_allocation.height - TAB_OVERLAP;
|
|
break;
|
|
}
|
|
|
|
if (GTK_WIDGET_REALIZED (notebook) &&
|
|
page->tab_label && !GTK_WIDGET_MAPPED (page->tab_label))
|
|
{
|
|
if (GTK_WIDGET_VISIBLE (page->tab_label))
|
|
gtk_widget_map (page->tab_label);
|
|
else
|
|
gtk_widget_show (page->tab_label);
|
|
}
|
|
}
|
|
|
|
if (children)
|
|
{
|
|
children = notebook->children;
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
child_allocation.x = (allocation->x + allocation->width -
|
|
container->border_width);
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
child_allocation.y = (allocation->y + allocation->height -
|
|
container->border_width);
|
|
break;
|
|
}
|
|
|
|
while (children != last_child)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
|
|
if (page->pack != GTK_PACK_END || !GTK_WIDGET_VISIBLE (page->child))
|
|
continue;
|
|
|
|
delta = 0;
|
|
if (n && (page->expand || notebook->homogeneous))
|
|
{
|
|
new_fill = (tab_space * i++) / n;
|
|
delta = new_fill - old_fill;
|
|
old_fill = new_fill;
|
|
}
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
child_allocation.width = (page->requisition.width +
|
|
TAB_OVERLAP + delta);
|
|
child_allocation.x -= child_allocation.width;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
child_allocation.height = (page->requisition.height +
|
|
TAB_OVERLAP + delta);
|
|
child_allocation.y -= child_allocation.height;
|
|
break;
|
|
}
|
|
|
|
gtk_notebook_page_allocate (notebook, page, &child_allocation);
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
child_allocation.x += TAB_OVERLAP;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
child_allocation.y += TAB_OVERLAP;
|
|
break;
|
|
}
|
|
|
|
if (GTK_WIDGET_REALIZED (notebook) && page->tab_label &&
|
|
!GTK_WIDGET_MAPPED (page->tab_label))
|
|
{
|
|
if (GTK_WIDGET_VISIBLE (page->tab_label))
|
|
gtk_widget_map (page->tab_label);
|
|
else
|
|
gtk_widget_show (page->tab_label);
|
|
}
|
|
}
|
|
}
|
|
|
|
done:
|
|
gtk_notebook_set_shape (notebook);
|
|
gtk_notebook_redraw_tabs (notebook);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_page_allocate (GtkNotebook *notebook,
|
|
GtkNotebookPage *page,
|
|
GtkAllocation *allocation)
|
|
{
|
|
GtkWidget *widget;
|
|
GtkAllocation child_allocation;
|
|
GtkRequisition tab_requisition;
|
|
gint xthickness;
|
|
gint ythickness;
|
|
gint padding;
|
|
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (page != NULL);
|
|
g_return_if_fail (allocation != NULL);
|
|
|
|
widget = GTK_WIDGET (notebook);
|
|
|
|
xthickness = widget->style->xthickness;
|
|
ythickness = widget->style->ythickness;
|
|
|
|
/* If the size of the notebook tabs change, we need to queue
|
|
* a redraw on the tab area
|
|
*/
|
|
if ((allocation->width != page->allocation.width) ||
|
|
(allocation->height != page->allocation.height))
|
|
{
|
|
gint x, y, width, height, border_width;
|
|
|
|
border_width = GTK_CONTAINER (notebook)->border_width;
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
width = widget->allocation.width;
|
|
height = MAX (page->allocation.height, allocation->height) + ythickness;
|
|
x = 0;
|
|
y = border_width;
|
|
break;
|
|
|
|
case GTK_POS_BOTTOM:
|
|
width = widget->allocation.width + xthickness;
|
|
height = MAX (page->allocation.height, allocation->height) + ythickness;
|
|
x = 0;
|
|
y = widget->allocation.height - height - border_width;
|
|
break;
|
|
|
|
case GTK_POS_LEFT:
|
|
width = MAX (page->allocation.width, allocation->width) + xthickness;
|
|
height = widget->allocation.height;
|
|
x = border_width;
|
|
y = 0;
|
|
break;
|
|
|
|
case GTK_POS_RIGHT:
|
|
default: /* quiet gcc */
|
|
width = MAX (page->allocation.width, allocation->width) + xthickness;
|
|
height = widget->allocation.height;
|
|
x = widget->allocation.width - width - border_width;
|
|
y = 0;
|
|
break;
|
|
}
|
|
|
|
gtk_widget_queue_clear_area (widget, x, y, width, height);
|
|
}
|
|
|
|
page->allocation = *allocation;
|
|
gtk_widget_get_child_requisition (page->tab_label, &tab_requisition);
|
|
|
|
if (notebook->cur_page != page)
|
|
{
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
page->allocation.y += ythickness;
|
|
case GTK_POS_BOTTOM:
|
|
if (page->allocation.height > ythickness)
|
|
page->allocation.height -= ythickness;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
page->allocation.x += xthickness;
|
|
case GTK_POS_RIGHT:
|
|
if (page->allocation.width > xthickness)
|
|
page->allocation.width -= xthickness;
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
padding = TAB_CURVATURE + FOCUS_WIDTH + notebook->tab_hborder;
|
|
if (page->fill)
|
|
{
|
|
child_allocation.x = (xthickness + FOCUS_WIDTH +
|
|
notebook->tab_hborder);
|
|
child_allocation.width = MAX (1, (((gint) page->allocation.width) -
|
|
2 * child_allocation.x));
|
|
child_allocation.x += page->allocation.x;
|
|
}
|
|
else
|
|
{
|
|
child_allocation.x = (page->allocation.x +
|
|
(page->allocation.width -
|
|
tab_requisition.width) / 2);
|
|
child_allocation.width = tab_requisition.width;
|
|
}
|
|
child_allocation.y = (notebook->tab_vborder + FOCUS_WIDTH +
|
|
page->allocation.y);
|
|
if (notebook->tab_pos == GTK_POS_TOP)
|
|
child_allocation.y += ythickness;
|
|
child_allocation.height = MAX (1, (((gint) page->allocation.height) - ythickness -
|
|
2 * (notebook->tab_vborder + FOCUS_WIDTH)));
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
padding = TAB_CURVATURE + FOCUS_WIDTH + notebook->tab_vborder;
|
|
if (page->fill)
|
|
{
|
|
child_allocation.y = ythickness + padding;
|
|
child_allocation.height = MAX (1, (((gint) page->allocation.height) -
|
|
2 * child_allocation.y));
|
|
child_allocation.y += page->allocation.y;
|
|
}
|
|
else
|
|
{
|
|
child_allocation.y = (page->allocation.y + (page->allocation.height -
|
|
tab_requisition.height) / 2);
|
|
child_allocation.height = tab_requisition.height;
|
|
}
|
|
child_allocation.x = page->allocation.x + notebook->tab_hborder + FOCUS_WIDTH;
|
|
if (notebook->tab_pos == GTK_POS_LEFT)
|
|
child_allocation.x += xthickness;
|
|
child_allocation.width = MAX (1, (((gint) page->allocation.width) - xthickness -
|
|
2 * (notebook->tab_hborder + FOCUS_WIDTH)));
|
|
break;
|
|
}
|
|
|
|
if (page->tab_label)
|
|
gtk_widget_size_allocate (page->tab_label, &child_allocation);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_calc_tabs (GtkNotebook *notebook,
|
|
GList *start,
|
|
GList **end,
|
|
gint *tab_space,
|
|
guint direction)
|
|
{
|
|
GtkNotebookPage *page = NULL;
|
|
GList *children;
|
|
GList *last_list = NULL;
|
|
gboolean pack;
|
|
|
|
if (!start)
|
|
return;
|
|
|
|
children = start;
|
|
pack = GTK_NOTEBOOK_PAGE (start)->pack;
|
|
if (pack == GTK_PACK_END)
|
|
direction = (direction == STEP_PREV) ? STEP_NEXT : STEP_PREV;
|
|
|
|
while (1)
|
|
{
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
case GTK_POS_BOTTOM:
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
{
|
|
if (page->pack == pack)
|
|
{
|
|
*tab_space -= page->requisition.width;
|
|
if (*tab_space < 0 || children == *end)
|
|
{
|
|
if (*tab_space < 0)
|
|
{
|
|
*tab_space = - (*tab_space +
|
|
page->requisition.width);
|
|
*end = children;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
last_list = children;
|
|
}
|
|
if (direction == STEP_NEXT)
|
|
children = children->next;
|
|
else
|
|
children = children->prev;
|
|
}
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
case GTK_POS_RIGHT:
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
{
|
|
if (page->pack == pack)
|
|
{
|
|
*tab_space -= page->requisition.height;
|
|
if (*tab_space < 0 || children == *end)
|
|
{
|
|
if (*tab_space < 0)
|
|
{
|
|
*tab_space = - (*tab_space +
|
|
page->requisition.height);
|
|
*end = children;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
last_list = children;
|
|
}
|
|
if (direction == STEP_NEXT)
|
|
children = children->next;
|
|
else
|
|
children = children->prev;
|
|
}
|
|
break;
|
|
}
|
|
if (direction == STEP_PREV)
|
|
return;
|
|
pack = (pack == GTK_PACK_END) ? GTK_PACK_START : GTK_PACK_END;
|
|
direction = STEP_PREV;
|
|
children = last_list;
|
|
}
|
|
}
|
|
|
|
/* Private GtkNotebook Page Switch Methods:
|
|
*
|
|
* gtk_notebook_real_switch_page
|
|
*/
|
|
static void
|
|
gtk_notebook_real_switch_page (GtkNotebook *notebook,
|
|
GtkNotebookPage *page,
|
|
guint page_num)
|
|
{
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (page != NULL);
|
|
|
|
if (notebook->cur_page == page || !GTK_WIDGET_VISIBLE (page->child))
|
|
return;
|
|
|
|
if (notebook->cur_page && GTK_WIDGET_MAPPED (notebook->cur_page->child))
|
|
gtk_widget_unmap (notebook->cur_page->child);
|
|
|
|
notebook->cur_page = page;
|
|
|
|
if (!notebook->focus_tab ||
|
|
notebook->focus_tab->data != (gpointer) notebook->cur_page)
|
|
notebook->focus_tab =
|
|
g_list_find (notebook->children, notebook->cur_page);
|
|
|
|
if (GTK_WIDGET_MAPPED (notebook))
|
|
gtk_widget_map (notebook->cur_page->child);
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
|
|
/* Private GtkNotebook Page Switch Functions:
|
|
*
|
|
* gtk_notebook_switch_page
|
|
* gtk_notebook_page_select
|
|
* gtk_notebook_switch_focus_tab
|
|
* gtk_notebook_menu_switch_page
|
|
*/
|
|
static void
|
|
gtk_notebook_switch_page (GtkNotebook *notebook,
|
|
GtkNotebookPage *page,
|
|
gint page_num)
|
|
{
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (page != NULL);
|
|
|
|
if (notebook->cur_page == page)
|
|
return;
|
|
|
|
if (page_num < 0)
|
|
page_num = g_list_index (notebook->children, page);
|
|
|
|
gtk_signal_emit (GTK_OBJECT (notebook),
|
|
notebook_signals[SWITCH_PAGE],
|
|
page,
|
|
page_num);
|
|
}
|
|
|
|
static gint
|
|
gtk_notebook_page_select (GtkNotebook *notebook,
|
|
gboolean move_focus)
|
|
{
|
|
GtkNotebookPage *page;
|
|
GtkDirectionType dir = GTK_DIR_DOWN; /* Quiet GCC */
|
|
|
|
g_return_val_if_fail (notebook != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), FALSE);
|
|
|
|
if (!notebook->focus_tab)
|
|
return FALSE;
|
|
|
|
page = notebook->focus_tab->data;
|
|
gtk_notebook_switch_page (notebook, page, -1);
|
|
|
|
if (move_focus)
|
|
{
|
|
switch (notebook->tab_pos)
|
|
{
|
|
case GTK_POS_TOP:
|
|
dir = GTK_DIR_DOWN;
|
|
break;
|
|
case GTK_POS_BOTTOM:
|
|
dir = GTK_DIR_UP;
|
|
break;
|
|
case GTK_POS_LEFT:
|
|
dir = GTK_DIR_RIGHT;
|
|
break;
|
|
case GTK_POS_RIGHT:
|
|
dir = GTK_DIR_LEFT;
|
|
break;
|
|
}
|
|
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
{
|
|
if (GTK_IS_CONTAINER (page->child))
|
|
{
|
|
if (gtk_container_focus (GTK_CONTAINER (page->child),
|
|
dir))
|
|
return TRUE;
|
|
}
|
|
else if (GTK_WIDGET_CAN_FOCUS (page->child))
|
|
{
|
|
gtk_widget_grab_focus (page->child);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_switch_focus_tab (GtkNotebook *notebook,
|
|
GList *new_child)
|
|
{
|
|
GList *old_child;
|
|
GtkNotebookPage *old_page = NULL;
|
|
GtkNotebookPage *page;
|
|
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (notebook->focus_tab == new_child)
|
|
return;
|
|
|
|
old_child = notebook->focus_tab;
|
|
notebook->focus_tab = new_child;
|
|
|
|
if (notebook->scrollable && GTK_WIDGET_DRAWABLE (notebook))
|
|
gtk_notebook_redraw_arrows (notebook);
|
|
|
|
if (!notebook->show_tabs || !notebook->focus_tab)
|
|
return;
|
|
|
|
if (old_child)
|
|
old_page = old_child->data;
|
|
|
|
page = notebook->focus_tab->data;
|
|
if (GTK_WIDGET_MAPPED (page->tab_label))
|
|
gtk_notebook_focus_changed (notebook, old_page);
|
|
else
|
|
gtk_notebook_pages_allocate (notebook);
|
|
|
|
gtk_notebook_set_shape (notebook);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_menu_switch_page (GtkWidget *widget,
|
|
GtkNotebookPage *page)
|
|
{
|
|
GtkNotebook *notebook;
|
|
GList *children;
|
|
guint page_num;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (page != NULL);
|
|
|
|
notebook = GTK_NOTEBOOK (gtk_menu_get_attach_widget
|
|
(GTK_MENU (widget->parent)));
|
|
|
|
if (notebook->cur_page == page)
|
|
return;
|
|
|
|
page_num = 0;
|
|
children = notebook->children;
|
|
while (children && children->data != page)
|
|
{
|
|
children = children->next;
|
|
page_num++;
|
|
}
|
|
|
|
gtk_signal_emit (GTK_OBJECT (notebook),
|
|
notebook_signals[SWITCH_PAGE],
|
|
page,
|
|
page_num);
|
|
}
|
|
|
|
/* Private GtkNotebook Menu Functions:
|
|
*
|
|
* gtk_notebook_menu_item_create
|
|
* gtk_notebook_menu_label_unparent
|
|
* gtk_notebook_menu_detacher
|
|
*/
|
|
static void
|
|
gtk_notebook_menu_item_create (GtkNotebook *notebook,
|
|
GList *list)
|
|
{
|
|
GtkNotebookPage *page;
|
|
GtkWidget *menu_item;
|
|
|
|
page = list->data;
|
|
if (page->default_menu)
|
|
{
|
|
if (page->tab_label && GTK_IS_LABEL (page->tab_label))
|
|
page->menu_label = gtk_label_new (GTK_LABEL (page->tab_label)->label);
|
|
else
|
|
page->menu_label = gtk_label_new ("");
|
|
gtk_misc_set_alignment (GTK_MISC (page->menu_label), 0.0, 0.5);
|
|
}
|
|
|
|
gtk_widget_show (page->menu_label);
|
|
menu_item = gtk_menu_item_new ();
|
|
gtk_widget_lock_accelerators (menu_item);
|
|
gtk_container_add (GTK_CONTAINER (menu_item), page->menu_label);
|
|
gtk_menu_shell_insert (GTK_MENU_SHELL (notebook->menu), menu_item,
|
|
gtk_notebook_real_page_position (notebook, list));
|
|
gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
|
|
GTK_SIGNAL_FUNC (gtk_notebook_menu_switch_page), page);
|
|
if (GTK_WIDGET_VISIBLE (page->child))
|
|
gtk_widget_show (menu_item);
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_menu_label_unparent (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
gtk_widget_unparent (GTK_BIN(widget)->child);
|
|
GTK_BIN(widget)->child = NULL;
|
|
}
|
|
|
|
static void
|
|
gtk_notebook_menu_detacher (GtkWidget *widget,
|
|
GtkMenu *menu)
|
|
{
|
|
GtkNotebook *notebook;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
|
|
|
|
notebook = GTK_NOTEBOOK (widget);
|
|
g_return_if_fail (notebook->menu == (GtkWidget*) menu);
|
|
|
|
notebook->menu = NULL;
|
|
}
|
|
|
|
/* Public GtkNotebook Page Insert/Remove Methods :
|
|
*
|
|
* gtk_notebook_append_page
|
|
* gtk_notebook_append_page_menu
|
|
* gtk_notebook_prepend_page
|
|
* gtk_notebook_prepend_page_menu
|
|
* gtk_notebook_insert_page
|
|
* gtk_notebook_insert_page_menu
|
|
* gtk_notebook_remove_page
|
|
*/
|
|
/**
|
|
* gtk_notebook_append_page:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the #GtkWidget to use as the contents of the page.
|
|
* @tab_label: the #GtkWidget to be used as the label for the page,
|
|
* or %NULL to use the default label, 'page N'.
|
|
*
|
|
* Appends a page to @notebook.
|
|
**/
|
|
void
|
|
gtk_notebook_append_page (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
GtkWidget *tab_label)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
|
|
|
|
gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, -1);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_append_page_menu:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the #GtkWidget to use as the contents of the page.
|
|
* @tab_label: the #GtkWidget to be used as the label for the page,
|
|
* or %NULL to use the default label, 'page N'.
|
|
* @menu_label: the widget to use as a label for the page-switch
|
|
* menu, if that is enabled. If %NULL, and @tab_label
|
|
* is a #GtkLabel or %NULL, then the menu label will be
|
|
* a newly created label with the same text as @tab_label;
|
|
* If @tab_label is not a #GtkLabel, @menu_label must be
|
|
* specified if the page-switch menu is to be used.
|
|
*
|
|
* Appends a page to @notebook, specifying the widget to use as the
|
|
* label in the popup menu.
|
|
**/
|
|
void
|
|
gtk_notebook_append_page_menu (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
GtkWidget *tab_label,
|
|
GtkWidget *menu_label)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
|
|
g_return_if_fail (menu_label == NULL || GTK_IS_WIDGET (menu_label));
|
|
|
|
gtk_notebook_insert_page_menu (notebook, child, tab_label, menu_label, -1);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_prepend_page:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the #GtkWidget to use as the contents of the page.
|
|
* @tab_label: the #GtkWidget to be used as the label for the page,
|
|
* or %NULL to use the default label, 'page N'.
|
|
*
|
|
* Prepends a page to @noteobook.
|
|
**/
|
|
void
|
|
gtk_notebook_prepend_page (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
GtkWidget *tab_label)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
|
|
|
|
gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, 0);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_prepend_page_menu:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the #GtkWidget to use as the contents of the page.
|
|
* @tab_label: the #GtkWidget to be used as the label for the page,
|
|
* or %NULL to use the default label, 'page N'.
|
|
* @menu_label: the widget to use as a label for the page-switch
|
|
* menu, if that is enabled. If %NULL, and @tab_label
|
|
* is a #GtkLabel or %NULL, then the menu label will be
|
|
* a newly created label with the same text as @tab_label;
|
|
* If @tab_label is not a #GtkLabel, @menu_label must be
|
|
* specified if the page-switch menu is to be used.
|
|
*
|
|
* Prepends a page to @notebook, specifying the widget to use as the
|
|
* label in the popup menu.
|
|
**/
|
|
void
|
|
gtk_notebook_prepend_page_menu (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
GtkWidget *tab_label,
|
|
GtkWidget *menu_label)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
|
|
g_return_if_fail (menu_label == NULL || GTK_IS_WIDGET (menu_label));
|
|
|
|
gtk_notebook_insert_page_menu (notebook, child, tab_label, menu_label, 0);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_insert_page:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the #GtkWidget to use as the contents of the page.
|
|
* @tab_label: the #GtkWidget to be used as the label for the page,
|
|
* or %NULL to use the default label, 'page N'.
|
|
* @position: the index (starting at 0) at which to insert the page,
|
|
* or -1 to append the page after all other pages.
|
|
*
|
|
* Insert a page into @notebook at the given position
|
|
**/
|
|
void
|
|
gtk_notebook_insert_page (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
GtkWidget *tab_label,
|
|
gint position)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
|
|
|
|
gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, position);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_insert_page_menu:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the #GtkWidget to use as the contents of the page.
|
|
* @tab_label: the #GtkWidget to be used as the label for the page,
|
|
* or %NULL to use the default label, 'page N'.
|
|
* @menu_label: the widget to use as a label for the page-switch
|
|
* menu, if that is enabled. If %NULL, and @tab_label
|
|
* is a #GtkLabel or %NULL, then the menu label will be
|
|
* a newly created label with the same text as @tab_label;
|
|
* If @tab_label is not a #GtkLabel, @menu_label must be
|
|
* specified if the page-switch menu is to be used.
|
|
* @position: the index (starting at 0) at which to insert the page,
|
|
* or -1 to append the page after all other pages.
|
|
*
|
|
* Insert a page into @notebook at the given position, specifying
|
|
* the widget to use as the label in the popup menu.
|
|
**/
|
|
void
|
|
gtk_notebook_insert_page_menu (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
GtkWidget *tab_label,
|
|
GtkWidget *menu_label,
|
|
gint position)
|
|
{
|
|
GtkNotebookPage *page;
|
|
gint nchildren;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
|
|
g_return_if_fail (menu_label == NULL || GTK_IS_WIDGET (menu_label));
|
|
|
|
page = g_new (GtkNotebookPage, 1);
|
|
page->child = child;
|
|
page->requisition.width = 0;
|
|
page->requisition.height = 0;
|
|
page->allocation.x = 0;
|
|
page->allocation.y = 0;
|
|
page->allocation.width = 0;
|
|
page->allocation.height = 0;
|
|
page->default_menu = FALSE;
|
|
page->default_tab = FALSE;
|
|
|
|
nchildren = g_list_length (notebook->children);
|
|
if ((position < 0) || (position > nchildren))
|
|
position = nchildren;
|
|
|
|
notebook->children = g_list_insert (notebook->children, page, position);
|
|
|
|
if (!tab_label)
|
|
{
|
|
page->default_tab = TRUE;
|
|
if (notebook->show_tabs)
|
|
tab_label = gtk_label_new ("");
|
|
}
|
|
page->tab_label = tab_label;
|
|
page->menu_label = menu_label;
|
|
page->expand = FALSE;
|
|
page->fill = TRUE;
|
|
page->pack = GTK_PACK_START;
|
|
|
|
if (!menu_label)
|
|
page->default_menu = TRUE;
|
|
else
|
|
{
|
|
gtk_widget_ref (page->menu_label);
|
|
gtk_object_sink (GTK_OBJECT (page->menu_label));
|
|
}
|
|
|
|
if (notebook->menu)
|
|
gtk_notebook_menu_item_create (notebook,
|
|
g_list_find (notebook->children, page));
|
|
|
|
gtk_notebook_update_labels (notebook);
|
|
|
|
if (!notebook->first_tab)
|
|
notebook->first_tab = notebook->children;
|
|
|
|
gtk_widget_set_parent (child, GTK_WIDGET (notebook));
|
|
if (tab_label)
|
|
gtk_widget_set_parent (tab_label, GTK_WIDGET (notebook));
|
|
|
|
if (!notebook->cur_page)
|
|
{
|
|
gtk_notebook_switch_page (notebook, page, 0);
|
|
gtk_notebook_switch_focus_tab (notebook, NULL);
|
|
}
|
|
|
|
if (GTK_WIDGET_REALIZED (child->parent))
|
|
gtk_widget_realize (child);
|
|
|
|
if (GTK_WIDGET_VISIBLE (notebook))
|
|
{
|
|
if (GTK_WIDGET_VISIBLE (child))
|
|
{
|
|
if (GTK_WIDGET_MAPPED (notebook) &&
|
|
!GTK_WIDGET_MAPPED (child) &&
|
|
notebook->cur_page == page)
|
|
gtk_widget_map (child);
|
|
|
|
gtk_widget_queue_resize (child);
|
|
}
|
|
|
|
if (tab_label)
|
|
{
|
|
if (notebook->show_tabs && GTK_WIDGET_VISIBLE (child))
|
|
{
|
|
if (!GTK_WIDGET_VISIBLE (tab_label))
|
|
gtk_widget_show (tab_label);
|
|
|
|
if (GTK_WIDGET_REALIZED (notebook) &&
|
|
!GTK_WIDGET_REALIZED (tab_label))
|
|
gtk_widget_realize (tab_label);
|
|
|
|
if (GTK_WIDGET_MAPPED (notebook) &&
|
|
!GTK_WIDGET_MAPPED (tab_label))
|
|
gtk_widget_map (tab_label);
|
|
}
|
|
else if (GTK_WIDGET_VISIBLE (tab_label))
|
|
gtk_widget_hide (tab_label);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_remove_page:
|
|
* @notebook: a #GtkNotebook.
|
|
* @page_num: the index of a notebook page, starting
|
|
* from 0. If -1, the last page will
|
|
* be removed.
|
|
*
|
|
* Removes a page from the notebook given its index
|
|
* in the notebook.
|
|
**/
|
|
void
|
|
gtk_notebook_remove_page (GtkNotebook *notebook,
|
|
gint page_num)
|
|
{
|
|
GList *list;
|
|
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (page_num >= 0)
|
|
{
|
|
list = g_list_nth (notebook->children, page_num);
|
|
if (list)
|
|
gtk_notebook_real_remove (notebook, list);
|
|
}
|
|
else
|
|
{
|
|
list = g_list_last (notebook->children);
|
|
if (list)
|
|
gtk_notebook_real_remove (notebook, list);
|
|
}
|
|
}
|
|
|
|
/* Public GtkNotebook Page Switch Methods :
|
|
* gtk_notebook_get_current_page
|
|
* gtk_notebook_page_num
|
|
* gtk_notebook_set_page
|
|
* gtk_notebook_next_page
|
|
* gtk_notebook_prev_page
|
|
*/
|
|
/**
|
|
* gtk_notebook_get_current_page:
|
|
* @notebook: a #GtkNotebook
|
|
*
|
|
* Returns the page number of the current page.
|
|
*
|
|
* Return value: the index (starting from 0) of the current
|
|
* page in the notebook. If the notebook has no pages, then
|
|
* -1 will be returned.
|
|
**/
|
|
gint
|
|
gtk_notebook_get_current_page (GtkNotebook *notebook)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
|
|
|
|
if (!notebook->cur_page)
|
|
return -1;
|
|
|
|
return g_list_index (notebook->children, notebook->cur_page);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_get_nth_page:
|
|
* @notebook: a #GtkNotebook
|
|
* @page_num: the index of a page in the noteobok
|
|
*
|
|
* Returns the child widget contained in page number @page_num.
|
|
*
|
|
* Return value: the child widget, or %NULL if @page_num is
|
|
* out of bounds.
|
|
**/
|
|
GtkWidget*
|
|
gtk_notebook_get_nth_page (GtkNotebook *notebook,
|
|
gint page_num)
|
|
{
|
|
GtkNotebookPage *page;
|
|
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
|
|
|
|
page = g_list_nth_data (notebook->children, page_num);
|
|
|
|
if (page)
|
|
return page->child;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_page_num:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: a #GtkWidget
|
|
*
|
|
* Finds the index of the page which contains the given child
|
|
* widget.
|
|
*
|
|
* Return value: the index of the page containing @child, or
|
|
* -1 if @child is not in the notebook.
|
|
**/
|
|
gint
|
|
gtk_notebook_page_num (GtkNotebook *notebook,
|
|
GtkWidget *child)
|
|
{
|
|
GList *children;
|
|
gint num;
|
|
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
|
|
|
|
num = 0;
|
|
children = notebook->children;
|
|
while (children)
|
|
{
|
|
GtkNotebookPage *page = children->data;
|
|
|
|
if (page->child == child)
|
|
return num;
|
|
|
|
children = children->next;
|
|
num++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_page:
|
|
* @notebook: a #GtkNotebook
|
|
* @page_num: index of the page to switch to, starting from 0.
|
|
* If negative, or greater than the number of pages
|
|
* in the notebook the last page will be used.
|
|
*
|
|
* Switches to the page number @page_num.
|
|
**/
|
|
void
|
|
gtk_notebook_set_page (GtkNotebook *notebook,
|
|
gint page_num)
|
|
{
|
|
GList *list;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (page_num >= 0)
|
|
list = g_list_nth (notebook->children, page_num);
|
|
else
|
|
list = g_list_last (notebook->children);
|
|
|
|
page_num = g_list_index (notebook->children, list);
|
|
|
|
if (list)
|
|
gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE (list), page_num);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_next_page:
|
|
* @notebook: a #GtkNotebook
|
|
*
|
|
* Switches to the next page. Nothing happens if the current page is
|
|
* the last page.
|
|
**/
|
|
void
|
|
gtk_notebook_next_page (GtkNotebook *notebook)
|
|
{
|
|
GList *list;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
list = g_list_find (notebook->children, notebook->cur_page);
|
|
if (!list)
|
|
return;
|
|
|
|
list = gtk_notebook_search_page (notebook, list, STEP_NEXT, TRUE);
|
|
if (!list)
|
|
return;
|
|
|
|
gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE (list), -1);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_prev_page:
|
|
* @notebook: a #GtkNotebook
|
|
*
|
|
* Switches to the previous page. Nothing happens if the current page
|
|
* is the first page.
|
|
**/
|
|
void
|
|
gtk_notebook_prev_page (GtkNotebook *notebook)
|
|
{
|
|
GList *list;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
list = g_list_find (notebook->children, notebook->cur_page);
|
|
if (!list)
|
|
return;
|
|
|
|
list = gtk_notebook_search_page (notebook, list, STEP_PREV, TRUE);
|
|
if (!list)
|
|
return;
|
|
|
|
gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE (list), -1);
|
|
}
|
|
|
|
/* Public GtkNotebook/Tab Style Functions
|
|
*
|
|
* gtk_notebook_set_show_border
|
|
* gtk_notebook_set_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_set_scrollable
|
|
*/
|
|
/**
|
|
* gtk_notebook_set_show_border:
|
|
* @notebook: a #GtkNotebook
|
|
* @show_border: %TRUE if a bevel should be drawn around the notebook.
|
|
*
|
|
* Sets whether a bevel will be drawn around the notebook pages.
|
|
* this is only has an effect when the tabs are not shown.
|
|
* See gtk_notebook_set_show_tabs().
|
|
**/
|
|
void
|
|
gtk_notebook_set_show_border (GtkNotebook *notebook,
|
|
gboolean show_border)
|
|
{
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (notebook->show_border != show_border)
|
|
{
|
|
notebook->show_border = show_border;
|
|
|
|
if (GTK_WIDGET_VISIBLE (notebook))
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_show_tabs:
|
|
* @notebook: a #GtkNotebook
|
|
* @show_tabs: %TRUE if the tabs should be shown.
|
|
*
|
|
* Sets whether to show the tabs for the notebook or not.
|
|
**/
|
|
void
|
|
gtk_notebook_set_show_tabs (GtkNotebook *notebook,
|
|
gboolean show_tabs)
|
|
{
|
|
GtkNotebookPage *page;
|
|
GList *children;
|
|
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
show_tabs = show_tabs != FALSE;
|
|
|
|
if (notebook->show_tabs == show_tabs)
|
|
return;
|
|
|
|
notebook->show_tabs = show_tabs;
|
|
children = notebook->children;
|
|
|
|
if (!show_tabs)
|
|
{
|
|
GTK_WIDGET_UNSET_FLAGS (notebook, GTK_CAN_FOCUS);
|
|
|
|
while (children)
|
|
{
|
|
page = children->data;
|
|
children = children->next;
|
|
if (page->default_tab)
|
|
{
|
|
gtk_widget_destroy (page->tab_label);
|
|
page->tab_label = NULL;
|
|
}
|
|
else
|
|
gtk_widget_hide (page->tab_label);
|
|
}
|
|
|
|
if (notebook->panel)
|
|
gdk_window_hide (notebook->panel);
|
|
}
|
|
else
|
|
{
|
|
GTK_WIDGET_SET_FLAGS (notebook, GTK_CAN_FOCUS);
|
|
gtk_notebook_update_labels (notebook);
|
|
}
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_tab_pos:
|
|
* @notebook:
|
|
* @pos:
|
|
*
|
|
* Sets the edge at which the tabs for switching pages in the
|
|
* notebook are drawn.
|
|
**/
|
|
void
|
|
gtk_notebook_set_tab_pos (GtkNotebook *notebook,
|
|
GtkPositionType pos)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (notebook->tab_pos != pos)
|
|
{
|
|
notebook->tab_pos = pos;
|
|
if (GTK_WIDGET_VISIBLE (notebook))
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_homogeneous_tabs:
|
|
* @notebook: a #GtkNotebook
|
|
* @homogeneous: %TRUE if all tabs should be the same size.
|
|
*
|
|
* Sets whether the tabs must have all the same size or not.
|
|
**/
|
|
void
|
|
gtk_notebook_set_homogeneous_tabs (GtkNotebook *notebook,
|
|
gboolean homogeneous)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (homogeneous == notebook->homogeneous)
|
|
return;
|
|
|
|
notebook->homogeneous = homogeneous;
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_tab_border:
|
|
* @notebook: a #GtkNotebook
|
|
* @border_width: width of the border around the tab labels.
|
|
*
|
|
* Sets the width the border around the tab labels
|
|
* in a notebook. This is equivalent to calling
|
|
* gtk_notebook_set_tab_hborder (@notebook, @border_width) followed
|
|
* by gtk_noteobok_set_tab_vborder (@notebook, @border_width).
|
|
**/
|
|
void
|
|
gtk_notebook_set_tab_border (GtkNotebook *notebook,
|
|
guint border_width)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
notebook->tab_hborder = border_width;
|
|
notebook->tab_vborder = border_width;
|
|
|
|
if (GTK_WIDGET_VISIBLE (notebook) && notebook->show_tabs)
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_tab_hborder:
|
|
* @notebook: a #GtkNotebook
|
|
* @tab_hborder: width of the horizontal border of tab labels.
|
|
*
|
|
* Sets the width of the horizontal border of tab labels.
|
|
**/
|
|
void
|
|
gtk_notebook_set_tab_hborder (GtkNotebook *notebook,
|
|
guint tab_hborder)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (notebook->tab_hborder == tab_hborder)
|
|
return;
|
|
|
|
notebook->tab_hborder = tab_hborder;
|
|
|
|
if (GTK_WIDGET_VISIBLE (notebook) && notebook->show_tabs)
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_tab_vborder:
|
|
* @notebook: a #GtkNotebook
|
|
* @tab_vborder: width of the vertical border of tab labels.
|
|
*
|
|
* Sets the width of the vertical border of tab labels.
|
|
**/
|
|
void
|
|
gtk_notebook_set_tab_vborder (GtkNotebook *notebook,
|
|
guint tab_vborder)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (notebook->tab_vborder == tab_vborder)
|
|
return;
|
|
|
|
notebook->tab_vborder = tab_vborder;
|
|
|
|
if (GTK_WIDGET_VISIBLE (notebook) && notebook->show_tabs)
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_scrollable:
|
|
* @notebook: a #GtkNotebook
|
|
* @scrollable: %TRUE if scroll arrows should be added
|
|
*
|
|
* Sets whether the tab label area will have arrows for scrolling if
|
|
* there are too many tabs to fit in the area.
|
|
|
|
**/
|
|
void
|
|
gtk_notebook_set_scrollable (GtkNotebook *notebook,
|
|
gboolean scrollable)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
scrollable = (scrollable != FALSE);
|
|
|
|
if (scrollable != notebook->scrollable)
|
|
{
|
|
notebook->scrollable = scrollable;
|
|
|
|
if (GTK_WIDGET_REALIZED (notebook))
|
|
{
|
|
if (scrollable)
|
|
{
|
|
gtk_notebook_panel_realize (notebook);
|
|
}
|
|
else if (notebook->panel)
|
|
{
|
|
gdk_window_set_user_data (notebook->panel, NULL);
|
|
gdk_window_destroy (notebook->panel);
|
|
notebook->panel = NULL;
|
|
}
|
|
}
|
|
|
|
if (GTK_WIDGET_VISIBLE (notebook))
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
}
|
|
|
|
/* Public GtkNotebook Popup Menu Methods:
|
|
*
|
|
* gtk_notebook_popup_enable
|
|
* gtk_notebook_popup_disable
|
|
*/
|
|
|
|
|
|
/**
|
|
* gtk_notebook_popup_enable:
|
|
* @notebook: a #GtkNotebook
|
|
*
|
|
* Enables the popup menu: if the user clicks with the right mouse button on
|
|
* the bookmarks, a menu with all the pages will be popped up.
|
|
**/
|
|
void
|
|
gtk_notebook_popup_enable (GtkNotebook *notebook)
|
|
{
|
|
GList *list;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (notebook->menu)
|
|
return;
|
|
|
|
notebook->menu = gtk_menu_new ();
|
|
for (list = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, FALSE);
|
|
list;
|
|
list = gtk_notebook_search_page (notebook, list, STEP_NEXT, FALSE))
|
|
gtk_notebook_menu_item_create (notebook, list);
|
|
|
|
gtk_notebook_update_labels (notebook);
|
|
gtk_menu_attach_to_widget (GTK_MENU (notebook->menu),
|
|
GTK_WIDGET (notebook),
|
|
gtk_notebook_menu_detacher);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_popup_disable:
|
|
* @notebook: a #GtkNotebook
|
|
*
|
|
* Disables the popup menu.
|
|
**/
|
|
void
|
|
gtk_notebook_popup_disable (GtkNotebook *notebook)
|
|
{
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (!notebook->menu)
|
|
return;
|
|
|
|
gtk_container_foreach (GTK_CONTAINER (notebook->menu),
|
|
(GtkCallback) gtk_notebook_menu_label_unparent, NULL);
|
|
gtk_widget_destroy (notebook->menu);
|
|
}
|
|
|
|
/* Public GtkNotebook Page Properties Functions:
|
|
*
|
|
* gtk_notebook_get_tab_label
|
|
* gtk_notebook_set_tab_label
|
|
* gtk_notebook_set_tab_label_text
|
|
* 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_label:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the page
|
|
*
|
|
* Returns the tab label widget for the page @child. %NULL is returned
|
|
* if @child is not in @notebook or if no tab label has specifically
|
|
* been set for @child.
|
|
*
|
|
* Return value: the tab label
|
|
**/
|
|
GtkWidget *
|
|
gtk_notebook_get_tab_label (GtkNotebook *notebook,
|
|
GtkWidget *child)
|
|
{
|
|
GList *list;
|
|
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
|
|
g_return_val_if_fail (child != NULL, NULL);
|
|
|
|
list = CHECK_FIND_CHILD (notebook, child);
|
|
if (!list)
|
|
return NULL;
|
|
|
|
if (GTK_NOTEBOOK_PAGE (list)->default_tab)
|
|
return NULL;
|
|
|
|
return GTK_NOTEBOOK_PAGE (list)->tab_label;
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_tab_label:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the page
|
|
* @tab_label: the tab label widget to use, or %NULL for default tab
|
|
* label.
|
|
*
|
|
* Changes the tab label for @child. If %NULL is specified
|
|
* for @tab_label, then the page will have the label 'page N'.
|
|
**/
|
|
void
|
|
gtk_notebook_set_tab_label (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
GtkWidget *tab_label)
|
|
{
|
|
GtkNotebookPage *page;
|
|
GList *list;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (child != NULL);
|
|
|
|
list = CHECK_FIND_CHILD (notebook, child);
|
|
if (!list)
|
|
return;
|
|
|
|
/* a NULL pointer indicates a default_tab setting, otherwise
|
|
* we need to set the associated label
|
|
*/
|
|
page = list->data;
|
|
if (page->tab_label)
|
|
gtk_widget_unparent (page->tab_label);
|
|
|
|
if (tab_label)
|
|
{
|
|
page->default_tab = FALSE;
|
|
page->tab_label = tab_label;
|
|
gtk_widget_set_parent (page->tab_label, GTK_WIDGET (notebook));
|
|
}
|
|
else
|
|
{
|
|
page->default_tab = TRUE;
|
|
page->tab_label = NULL;
|
|
|
|
if (notebook->show_tabs)
|
|
{
|
|
gchar string[32];
|
|
|
|
g_snprintf (string, sizeof(string), _("Page %u"),
|
|
gtk_notebook_real_page_position (notebook, list));
|
|
page->tab_label = gtk_label_new (string);
|
|
gtk_widget_set_parent (page->tab_label, GTK_WIDGET (notebook));
|
|
}
|
|
}
|
|
|
|
if (notebook->show_tabs && GTK_WIDGET_VISIBLE (child))
|
|
{
|
|
gtk_widget_show (page->tab_label);
|
|
gtk_widget_queue_resize (GTK_WIDGET (notebook));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_tab_label_text:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the page
|
|
* @tab_text: the label text
|
|
*
|
|
* Creates a new label and sets it as the tab label for the page
|
|
* containing @child.
|
|
**/
|
|
void
|
|
gtk_notebook_set_tab_label_text (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
const gchar *tab_text)
|
|
{
|
|
GtkWidget *tab_label = NULL;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (tab_text)
|
|
tab_label = gtk_label_new (tab_text);
|
|
gtk_notebook_set_tab_label (notebook, child, tab_label);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_get_menu_label:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the page
|
|
*
|
|
* Returns the menu label of the page containing @child. NULL is
|
|
* returned if @child is not in @notebook or NULL if it has the
|
|
* default menu label.
|
|
*
|
|
* Return value: the menu label
|
|
**/
|
|
GtkWidget*
|
|
gtk_notebook_get_menu_label (GtkNotebook *notebook,
|
|
GtkWidget *child)
|
|
{
|
|
GList *list;
|
|
|
|
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
|
|
g_return_val_if_fail (child != NULL, NULL);
|
|
|
|
list = CHECK_FIND_CHILD (notebook, child);
|
|
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:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the child widget
|
|
* @menu_label: the menu label, or NULL for default
|
|
*
|
|
* Changes the menu label for the page containing @child.
|
|
**/
|
|
void
|
|
gtk_notebook_set_menu_label (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
GtkWidget *menu_label)
|
|
{
|
|
GtkNotebookPage *page;
|
|
GList *list;
|
|
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (child != NULL);
|
|
|
|
list = CHECK_FIND_CHILD (notebook, child);
|
|
if (!list)
|
|
return;
|
|
|
|
page = list->data;
|
|
if (page->menu_label)
|
|
{
|
|
if (notebook->menu)
|
|
gtk_container_remove (GTK_CONTAINER (notebook->menu),
|
|
page->menu_label->parent);
|
|
|
|
if (!page->default_menu)
|
|
gtk_widget_unref (page->menu_label);
|
|
}
|
|
|
|
if (menu_label)
|
|
{
|
|
page->menu_label = menu_label;
|
|
gtk_widget_ref (page->menu_label);
|
|
gtk_object_sink (GTK_OBJECT(page->menu_label));
|
|
page->default_menu = FALSE;
|
|
}
|
|
else
|
|
page->default_menu = TRUE;
|
|
|
|
if (notebook->menu)
|
|
gtk_notebook_menu_item_create (notebook, list);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_menu_label_text:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the child widget
|
|
* @menu_text: the label text
|
|
*
|
|
* Creates a new label and sets it as the menu label of @child.
|
|
**/
|
|
void
|
|
gtk_notebook_set_menu_label_text (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
const gchar *menu_text)
|
|
{
|
|
GtkWidget *menu_label = NULL;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
|
|
if (menu_text)
|
|
menu_label = gtk_label_new (menu_text);
|
|
gtk_notebook_set_menu_label (notebook, child, menu_label);
|
|
}
|
|
|
|
/* Helper function called when pages are reordered
|
|
*/
|
|
static void
|
|
gtk_notebook_child_reordered (GtkNotebook *notebook,
|
|
GtkNotebookPage *page)
|
|
{
|
|
if (notebook->menu)
|
|
{
|
|
GtkWidget *menu_item;
|
|
|
|
menu_item = page->menu_label->parent;
|
|
gtk_container_remove (GTK_CONTAINER (menu_item), page->menu_label);
|
|
gtk_container_remove (GTK_CONTAINER (notebook->menu), menu_item);
|
|
gtk_notebook_menu_item_create (notebook, g_list_find (notebook->children, page));
|
|
}
|
|
|
|
gtk_notebook_update_labels (notebook);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_set_tab_label_packing:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the child widget
|
|
* @expand: whether to expand the bookmark or not
|
|
* @fill: whether the bookmark should fill the allocated area or not
|
|
* @pack_type: the position of the bookmark
|
|
*
|
|
* Sets the packing parameters for the tab label of the page
|
|
* containing @child. See gtk_box_pack_start() for the exact meaning
|
|
* of the parameters.
|
|
**/
|
|
void
|
|
gtk_notebook_set_tab_label_packing (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
gboolean expand,
|
|
gboolean fill,
|
|
GtkPackType pack_type)
|
|
{
|
|
GtkNotebookPage *page;
|
|
GList *list;
|
|
|
|
g_return_if_fail (notebook != NULL);
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (child != NULL);
|
|
|
|
list = CHECK_FIND_CHILD (notebook, child);
|
|
if (!list)
|
|
return;
|
|
|
|
page = list->data;
|
|
if (page->pack == pack_type && page->expand == expand && page->fill == fill)
|
|
return;
|
|
|
|
page->expand = expand;
|
|
page->fill = fill;
|
|
|
|
if (page->pack != pack_type)
|
|
{
|
|
page->pack = pack_type;
|
|
gtk_notebook_child_reordered (notebook, page);
|
|
}
|
|
|
|
if (!notebook->show_tabs)
|
|
return;
|
|
|
|
gtk_notebook_pages_allocate (notebook);
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_query_tab_label_packing:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the page
|
|
* @expand: location to store the expand value (or NULL)
|
|
* @fill: location to store the fill value (or NULL)
|
|
* @pack_type: location to store the pack_type (or NULL)
|
|
*
|
|
* Query the packing attributes for the tab label of the page
|
|
* containing @child.
|
|
**/
|
|
void
|
|
gtk_notebook_query_tab_label_packing (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
gboolean *expand,
|
|
gboolean *fill,
|
|
GtkPackType *pack_type)
|
|
{
|
|
GList *list;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (child != NULL);
|
|
|
|
list = CHECK_FIND_CHILD (notebook, child);
|
|
if (!list)
|
|
return;
|
|
|
|
if (expand)
|
|
*expand = GTK_NOTEBOOK_PAGE (list)->expand;
|
|
if (fill)
|
|
*fill = GTK_NOTEBOOK_PAGE (list)->fill;
|
|
if (pack_type)
|
|
*pack_type = GTK_NOTEBOOK_PAGE (list)->pack;
|
|
}
|
|
|
|
/**
|
|
* gtk_notebook_reorder_child:
|
|
* @notebook: a #GtkNotebook
|
|
* @child: the child to move
|
|
* @position: the new position
|
|
*
|
|
* Reorders the page containing @child, so that it appears in position
|
|
* @position. Out of bounds @position will be clamped.
|
|
**/
|
|
void
|
|
gtk_notebook_reorder_child (GtkNotebook *notebook,
|
|
GtkWidget *child,
|
|
gint position)
|
|
{
|
|
GList *list, *new_list;
|
|
GtkNotebookPage *page;
|
|
gint old_pos;
|
|
|
|
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
|
|
list = CHECK_FIND_CHILD (notebook, child);
|
|
if (!list)
|
|
return;
|
|
|
|
old_pos = g_list_position (notebook->children, list);
|
|
|
|
if (old_pos == position)
|
|
return;
|
|
|
|
page = list->data;
|
|
notebook->children = g_list_delete_link (notebook->children, list);
|
|
|
|
position = CLAMP (position, 0, g_list_length (notebook->children));
|
|
|
|
notebook->children = g_list_insert (notebook->children, page, position);
|
|
new_list = g_list_nth (notebook->children, position);
|
|
|
|
/* Fix up GList references in GtkNotebook structure */
|
|
if (notebook->first_tab == list)
|
|
notebook->first_tab = new_list;
|
|
if (notebook->focus_tab == list)
|
|
notebook->focus_tab = new_list;
|
|
|
|
/* Move around the menu items if necesary */
|
|
gtk_notebook_child_reordered (notebook, page);
|
|
|
|
if (notebook->show_tabs)
|
|
gtk_notebook_pages_allocate (notebook);
|
|
}
|