AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
8f4f35b392
gtk2/gtk/gtknotebook.c
Tim Janik 9595c55184 documented necessary changes for 1.4 transition. 
Fri May 12 17:13:32 2000  Tim Janik  <timj@gtk.org>

	* docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.

	* gtk/gtktext.c: made the adjustments no-construct args, simply
	provide default adjustments.
	(gtk_text_destroy): release adjustments.

	* gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
	adjustment argument non-construct.

	* gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
	instead of in finalize.
	(gtk_progress_get_text_from_value):
	(gtk_progress_get_current_text):
	(gtk_progress_set_value):
	(gtk_progress_get_percentage_from_value):
	(gtk_progress_get_current_percentage):
	(gtk_progress_set_percentage):
	(gtk_progress_configure): ensure an adjustment is present.

Thu May 11 01:24:08 2000  Tim Janik  <timj@gtk.org>

	* gtk/gtkcolorsel.[hc]:
	* gtk/gtkcolorseldialog.[hc]:
	* gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
	their parent implementation, use bit fields for boolean values, don't
	create unused widgets, usage of glib types, braces go on their own
	lines, function argument alignment, #include directives etc. etc. etc..

	* gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.

Wed May 10 23:29:52 2000  Tim Janik  <timj@gtk.org>

	* gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.

	* gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
	of NULL.

	* gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
	to freed data.
	(gtk_combo_destroy): don't keep a pointer to a destroyed window.

	* gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
	to NULL when the toplevel is getting destroyed.
	(gtk_menu_set_tearoff_state): same here for the tearoff_window.
	(gtk_menu_destroy):
	(gtk_menu_init): store the information of whether we have to
	readd the initial child ref_count during destruction in a new
	GtkMenu field needs_destruction_ref_count.

	* gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
	here, those reading: learn from my mistake! ;)
	in order for set_?adjustment to support a default adjustemnt if
	invoked with an adjustment pointer of NULL, the code read (pseudo):
	if (v->adjustment) unref (v->adjustment);
	if (!adjustment) adjustment = adjustment_new ();
	if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
	now imagine the first unref to actually free the old adjustment and
	adjustment_new() creating a new adjustment from the very same memory
	portion. here, the latter comparision will unintendedly fail, and
	all hell breaks loose.
	(gtk_viewport_set_hadjustment):
	(gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
	after unreferencing it.

	* gtk/gtkcontainer.[hc]: removed toplevel registration
	functions: gtk_container_register_toplevel(),
	gtk_container_unregister_toplevel() and
	gtk_container_get_toplevels() which had wrong semantics
	anyways: it didn't reference and copy the list.

	* gtk/gtkwindow.c: we take over the container toplevel registration
	bussiness now. windows are registered across multiple destructions,
	untill they are finalized. the initial implicit reference count
	users are holding on windows is removed with the first destruction
	though.
	(gtk_window_init): ref & sink and set has_user_ref_count, got
	rid of gtk_container_register_toplevel() call. add window to
	toplevel_list.
	(gtk_window_destroy): unref the window if has_user_ref_count
	is still set, got rid of call to
	gtk_container_unregister_toplevel().
	(gtk_window_finalize): remove window from toplevel list.
	(gtk_window_list_toplevels): new function to return a newly
	created list with referenced toplevels.
	(gtk_window_read_rcfiles): use gtk_window_list_toplevels().

	* gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
	adjustment a non-construct arg.
	* gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
	* gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
	* gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.

	* gtk/gtkrange.c: added some realized checks.
	(gtk_range_destroy): get rid of the h/v adjustments in the
	destroy handler instead of finalize. remove timer.
	(gtk_range_get_adjustment): demand create adjustment.

	* gtk/gtkviewport.c: made h/v adjustment non-construct args.
	we simply create them on demand now and get rid of them in
	the destroy handler.
	(gtk_viewport_destroy): get rid of the h/v adjustments in the
	destroy handler instead of finalize.
	(gtk_viewport_get_hadjustment):
	(gtk_viewport_get_vadjustment):
	(gtk_viewport_size_allocate): demand create h/v adjustment
	if required.

	* gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
	gtk_widget_real_destroy () functionality.
	(gtk_widget_real_destroy): reinitialize with a new style, instead
	of setting widget->style to NULL.

Fri May  5 13:02:09 2000  Tim Janik  <timj@gtk.org>

	* gtk/gtkcalendar.c:
	* gtk/gtkbutton.c: ported _get_type() implementation over to
	GType, either to preserve memchunks allocation facilities,
	or because Gtk+ 1.0 GtkTypeInfo was still being used.

	* gtk/gtkobject.[hc]: derive from GObject. ported various functions
	over. prepare for ::destroy to be emitted multiple times.
	removed reference tracer magic. chain into GObjectClass.shutdown()
	to emit ::destroy signal.

	* gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
	fundamental.

	* gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
	cludge.

	* gtk/gtksocket.c:
	* gtk/gtkplug.c:
	* gtk/gtklayout.c:
	* gtk/gtklabel.c:
	* gtk/gtkargcollector.c:
	* gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
	not being a fundamental anymore, and to work with the new
	type system (nuked fundamental type varargs clutter).

	* gtk/*.c: install finalize handlers in the GObjectClass
	part of the class structure.
	changed direct GTK_OBJECT()->klass accesses to
	GTK_*_GET_CLASS().
	changed direct object_class->type accesses to GTK_CLASS_TYPE().

	* gtktypeutils.[hc]: use the reserved fundamental ids provided by
	GType. made most of the GTK_*() type macros and Gtk* typedefs
	simple wrappers around macros and types provided by GType.
	most notably, a significant portion of the old API vanished:
	GTK_TYPE_MAKE(),
	GTK_TYPE_SEQNO(),
	GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
	GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
	GTK_TYPE_ARGS,
	GTK_TYPE_CALLBACK,
	GTK_TYPE_C_CALLBACK,
	GTK_TYPE_FOREIGN,
	GtkTypeQuery,
	gtk_type_query(),
	gtk_type_set_varargs_type(),
	gtk_type_get_varargs_type(),
	gtk_type_check_object_cast(),
	gtk_type_check_class_cast(),
	gtk_type_describe_tree(),
	gtk_type_describe_heritage(),
	gtk_type_free(),
	gtk_type_children_types(),
	gtk_type_set_chunk_alloc(),
	gtk_type_register_enum(),
	gtk_type_register_flags(),
	gtk_type_parent_class().
	replacements, where available are described in ../docs/Changes-1.4.txt.
	implemented compatibility functions for the remaining API.

	* configure.in: depend on glib 1.3.1, use gobject module.
2000-05-12 15:25:50 +00:00

4377 lines
115 KiB
C
Raw Blame History

/* 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 Library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library 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-1999. 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
};
/** 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 void gtk_notebook_draw (GtkWidget *widget,
GdkRectangle *area);
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_expose_tabs (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 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,
GtkAllocation *allocation);
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);
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 (), &notebook_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 ());
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_NONE__POINTER_UINT,
GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER,
GTK_TYPE_UINT);
gtk_object_class_add_signals (object_class, notebook_signals, LAST_SIGNAL);
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->draw = gtk_notebook_draw;
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;
}
static void
gtk_notebook_init (GtkNotebook *notebook)
{
GTK_WIDGET_SET_FLAGS (notebook, GTK_CAN_FOCUS);
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;
}
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_draw
* 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, &(widget->allocation));
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->klass->xthickness * 2;
widget->requisition.height += widget->style->klass->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->klass->xthickness;
page->requisition.height =
child_requisition.height +
2 * widget->style->klass->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->klass->xthickness;
child_allocation.y += widget->style->klass->ythickness;
child_allocation.width = MAX (1, (gint)child_allocation.width -
(gint) widget->style->klass->xthickness * 2);
child_allocation.height = MAX (1, (gint)child_allocation.height -
(gint) widget->style->klass->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, allocation);
}
gtk_notebook_set_shape (notebook);
}
static void
gtk_notebook_draw (GtkWidget *widget,
GdkRectangle *area)
{
GtkNotebook *notebook;
GdkRectangle child_area;
GdkRectangle draw_area;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
g_return_if_fail (area != NULL);
notebook = GTK_NOTEBOOK (widget);
draw_area = *area;
if (GTK_WIDGET_DRAWABLE (widget))
{
gboolean have_visible_child;
have_visible_child = notebook->cur_page && GTK_WIDGET_VISIBLE (notebook->cur_page->child);
if (have_visible_child != notebook->have_visible_child)
{
notebook->have_visible_child = have_visible_child;
draw_area.x = 0;
draw_area.y = 0;
draw_area.width = widget->allocation.width;
draw_area.height = widget->allocation.height;
}
gtk_notebook_paint (widget, &draw_area);
gtk_widget_draw_focus (widget);
if (notebook->cur_page && GTK_WIDGET_VISIBLE (notebook->cur_page->child) &&
gtk_widget_intersect (notebook->cur_page->child, &draw_area, &child_area))
gtk_widget_draw (notebook->cur_page->child, &child_area);
}
else
notebook->have_visible_child = FALSE;
}
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 gint
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)
{
if (!GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
gtk_grab_add (widget);
notebook->button = event->button;
if (event->x <= ARROW_SIZE + ARROW_SPACING / 2)
{
notebook->click_child = GTK_ARROW_LEFT;
if (event->button == 1)
{
if (!notebook->focus_tab ||
gtk_notebook_search_page (notebook, notebook->focus_tab,
STEP_PREV, TRUE))
gtk_container_focus (GTK_CONTAINER (notebook), GTK_DIR_LEFT);
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 (GTK_NOTEBOOK (widget));
else if (event->button == 3)
gtk_notebook_switch_focus_tab (notebook,
gtk_notebook_search_page (notebook,
NULL,
STEP_NEXT,
TRUE));
gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
}
else
{
notebook->click_child = GTK_ARROW_RIGHT;
if (event->button == 1)
{
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->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 (GTK_NOTEBOOK (widget));
else if (event->button == 3)
gtk_notebook_switch_focus_tab
(notebook, gtk_notebook_search_page (notebook, NULL,
STEP_PREV, TRUE));
gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
}
}
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 FALSE;
}
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);
}
gtk_notebook_set_shape (notebook);
return FALSE;
}
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;
}
gtk_grab_remove (widget);
click_child = notebook->click_child;
notebook->click_child = 0;
notebook->button = 0;
gtk_notebook_draw_arrow (notebook, click_child);
}
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;
if (notebook->click_child == 0)
gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
}
else
{
notebook->in_child = GTK_ARROW_RIGHT;
if (notebook->click_child == 0)
gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
}
}
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 && !notebook->click_child)
{
if (notebook->in_child == GTK_ARROW_LEFT)
{
notebook->in_child = 0;
gtk_notebook_draw_arrow (notebook,GTK_ARROW_LEFT);
}
else
{
notebook->in_child = 0;
gtk_notebook_draw_arrow (notebook,GTK_ARROW_RIGHT);
}
}
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;
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_RIGHT)
{
notebook->in_child = GTK_ARROW_LEFT;
gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
}
else if (x > ARROW_SIZE + ARROW_SPACING / 2 &&
notebook->in_child == GTK_ARROW_LEFT)
{
notebook->in_child = GTK_ARROW_RIGHT;
gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
}
return FALSE;
}
return FALSE;
}
static gint
gtk_notebook_key_press (GtkWidget *widget,
GdkEventKey *event)
{
GtkNotebook *notebook;
GtkDirectionType direction = 0;
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_Up:
switch (notebook->tab_pos)
{
case GTK_POS_BOTTOM:
gtk_notebook_page_select (GTK_NOTEBOOK (widget));
return TRUE;
case GTK_POS_TOP:
return FALSE;
default:
direction = GTK_DIR_UP;
break;
}
break;
case GDK_Left:
switch (notebook->tab_pos)
{
case GTK_POS_RIGHT:
gtk_notebook_page_select (GTK_NOTEBOOK (widget));
return TRUE;
case GTK_POS_LEFT:
return FALSE;
default:
direction = GTK_DIR_LEFT;
break;
}
break;
case GDK_Down:
switch (notebook->tab_pos)
{
case GTK_POS_TOP:
gtk_notebook_page_select (GTK_NOTEBOOK (widget));
return TRUE;
case GTK_POS_BOTTOM:
return FALSE;
default:
direction = GTK_DIR_DOWN;
break;
}
break;
case GDK_Right:
switch (notebook->tab_pos)
{
case GTK_POS_LEFT:
gtk_notebook_page_select (GTK_NOTEBOOK (widget));
return TRUE;
case GTK_POS_RIGHT:
return FALSE;
default:
direction = GTK_DIR_RIGHT;
break;
}
break;
case GDK_Tab:
case GDK_ISO_Left_Tab:
if (event->state & GDK_SHIFT_MASK)
direction = GTK_DIR_TAB_BACKWARD;
else
direction = GTK_DIR_TAB_FORWARD;
break;
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:
case GDK_space:
gtk_notebook_page_select (GTK_NOTEBOOK (widget));
return TRUE;
default:
return FALSE;
}
return gtk_container_focus (GTK_CONTAINER (widget), direction);
}
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);
if (!(list = g_list_find_custom (notebook->children, child,
gtk_notebook_page_compare)))
{
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 gint
gtk_notebook_focus (GtkContainer *container,
GtkDirectionType direction)
{
GtkNotebook *notebook;
GtkNotebookPage *page = NULL;
GtkNotebookPage *old_page = NULL;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_NOTEBOOK (container), FALSE);
notebook = GTK_NOTEBOOK (container);
if (!GTK_WIDGET_DRAWABLE (notebook) ||
!GTK_WIDGET_IS_SENSITIVE (container) ||
!notebook->children ||
!notebook->cur_page)
return FALSE;
if (!notebook->show_tabs)
{
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))
{
if (!container->focus_child)
{
gtk_widget_grab_focus (notebook->cur_page->child);
return TRUE;
}
}
}
return FALSE;
}
if (notebook->focus_tab)
old_page = notebook->focus_tab->data;
if (container->focus_child && old_page &&
container->focus_child == old_page->child && notebook->child_has_focus)
{
if (GTK_WIDGET_DRAWABLE (container->focus_child))
{
if (GTK_IS_CONTAINER (container->focus_child) &&
!GTK_WIDGET_HAS_FOCUS (container->focus_child))
{
if (gtk_container_focus (GTK_CONTAINER (container->focus_child),
direction))
return TRUE;
}
gtk_widget_grab_focus (GTK_WIDGET(notebook));
return TRUE;
}
notebook->focus_tab = NULL;
return FALSE;
}
if (!GTK_WIDGET_HAS_FOCUS (container))
notebook->focus_tab = NULL;
switch (direction)
{
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_RIGHT:
case GTK_DIR_DOWN:
gtk_notebook_switch_focus_tab
(notebook, gtk_notebook_search_page (notebook, notebook->focus_tab,
STEP_NEXT, TRUE));
break;
case GTK_DIR_TAB_BACKWARD:
case GTK_DIR_LEFT:
case GTK_DIR_UP:
gtk_notebook_switch_focus_tab
(notebook, gtk_notebook_search_page (notebook, notebook->focus_tab,
STEP_PREV, TRUE));
break;
}
if (notebook->focus_tab)
{
if (!GTK_WIDGET_HAS_FOCUS (container))
gtk_widget_grab_focus (GTK_WIDGET (container));
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_WIDGET (notebook)->allocation));
gtk_notebook_expose_tabs (notebook);
}
return TRUE;
}
gtk_notebook_focus_changed (notebook, old_page);
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_expose_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_expose_tabs (GtkNotebook *notebook)
{
GtkWidget *widget;
GtkNotebookPage *page;
GdkEventExpose event;
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;
event.type = GDK_EXPOSE;
event.window = widget->window;
event.count = 0;
event.area.x = border;
event.area.y = border;
switch (notebook->tab_pos)
{
case GTK_POS_BOTTOM:
event.area.y = (widget->allocation.height - border -
page->allocation.height -
widget->style->klass->ythickness);
if (page != notebook->cur_page)
event.area.y -= widget->style->klass->ythickness;
case GTK_POS_TOP:
event.area.width = widget->allocation.width - 2 * border;
event.area.height = (page->allocation.height +
widget->style->klass->ythickness);
if (page != notebook->cur_page)
event.area.height += widget->style->klass->ythickness;
break;
case GTK_POS_RIGHT:
event.area.x = (widget->allocation.width - border -
page->allocation.width -
widget->style->klass->xthickness);
if (page != notebook->cur_page)
event.area.x -= widget->style->klass->xthickness;
case GTK_POS_LEFT:
event.area.width = (page->allocation.width +
widget->style->klass->xthickness);
event.area.height = widget->allocation.height - 2 * border;
if (page != notebook->cur_page)
event.area.width += widget->style->klass->xthickness;
break;
}
gtk_widget_event (widget, (GdkEvent *) &event);
}
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 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->klass->ythickness;
case GTK_POS_BOTTOM:
height -= page->allocation.height + widget->style->klass->ythickness;
break;
case GTK_POS_LEFT:
x += page->allocation.width + widget->style->klass->xthickness;
case GTK_POS_RIGHT:
width -= page->allocation.width + widget->style->klass->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_draw (page->tab_label, &child_area);
}
}
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->klass->ythickness;
case GTK_POS_BOTTOM:
height -= page->allocation.height +
widget->style->klass->ythickness;
break;
case GTK_POS_LEFT:
x += page->allocation.width +
widget->style->klass->xthickness;
case GTK_POS_RIGHT:
width -= page->allocation.width +
widget->style->klass->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->klass->xthickness * 2;
width += widget->style->klass->xthickness * 2;
}
else if (notebook->tab_pos == GTK_POS_RIGHT)
width += widget->style->klass->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 scrollign arrows draw the shape for them */
if (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,
GtkAllocation *allocation)
{
GtkWidget *widget;
GtkContainer *container;
GtkNotebookPage *page = NULL;
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;
widget = GTK_WIDGET (notebook);
container = GTK_CONTAINER (notebook);
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);
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);
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)
{
gtk_notebook_set_shape (notebook);
return;
children = NULL;
break;
}
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);
}
}
}
gtk_notebook_set_shape (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->klass->xthickness;
ythickness = widget->style->klass->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)
{
GtkNotebookPage *page;
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 (GTK_WIDGET_VISIBLE (page->child))
{
if (GTK_IS_CONTAINER (page->child))
{
if (gtk_container_focus (GTK_CONTAINER (page->child),
GTK_DIR_TAB_FORWARD))
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))
{
if ((new_child == NULL) != (old_child == NULL))
{
gdk_window_clear (notebook->panel);
gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
}
else
{
GList *olist;
GList *nlist;
olist = gtk_notebook_search_page (notebook, old_child,
STEP_PREV, TRUE);
nlist = gtk_notebook_search_page (notebook, new_child,
STEP_PREV, TRUE);
if ((olist == NULL) != (nlist == NULL))
{
gdk_window_clear_area (notebook->panel, 0, 0,
ARROW_SIZE, ARROW_SIZE);
gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
}
olist = gtk_notebook_search_page (notebook, old_child,
STEP_NEXT, TRUE);
nlist = gtk_notebook_search_page (notebook, new_child,
STEP_NEXT, TRUE);
if ((olist == NULL) != (nlist == NULL))
{
gdk_window_clear_area (notebook->panel,
ARROW_SIZE + ARROW_SPACING, 0,
ARROW_SIZE, ARROW_SIZE);
gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
}
}
}
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_WIDGET (notebook)->allocation));
gtk_notebook_expose_tabs (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_insert (GTK_MENU (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
*/
void
gtk_notebook_append_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label)
{
gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, -1);
}
void
gtk_notebook_append_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label)
{
gtk_notebook_insert_page_menu (notebook, child, tab_label, menu_label, -1);
}
void
gtk_notebook_prepend_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label)
{
gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, 0);
}
void
gtk_notebook_prepend_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label)
{
gtk_notebook_insert_page_menu (notebook, child, tab_label, menu_label, 0);
}
void
gtk_notebook_insert_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
gint position)
{
gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, position);
}
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 (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (child != NULL);
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);
}
}
}
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
*/
gint
gtk_notebook_get_current_page (GtkNotebook *notebook)
{
g_return_val_if_fail (notebook != NULL, -1);
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);
}
GtkWidget*
gtk_notebook_get_nth_page (GtkNotebook *notebook,
gint page_num)
{
GtkNotebookPage *page;
g_return_val_if_fail (notebook != NULL, NULL);
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;
}
gint
gtk_notebook_page_num (GtkNotebook *notebook,
GtkWidget *child)
{
GList *children;
gint num;
g_return_val_if_fail (notebook != NULL, -1);
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
num = 0;
children = notebook->children;
while (children)
{
GtkNotebookPage *page;
page = children->data;
if (page->child == child)
return num;
children = children->next;
num++;
}
return -1;
}
void
gtk_notebook_set_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);
else
{
list = g_list_last (notebook->children);
page_num = g_list_length (notebook->children) - 1;
}
if (list)
gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE (list), page_num);
}
void
gtk_notebook_next_page (GtkNotebook *notebook)
{
GList *list;
g_return_if_fail (notebook != NULL);
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);
}
void
gtk_notebook_prev_page (GtkNotebook *notebook)
{
GList *list;
g_return_if_fail (notebook != NULL);
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
*/
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));
}
}
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));
}
void
gtk_notebook_set_tab_pos (GtkNotebook *notebook,
GtkPositionType pos)
{
g_return_if_fail (notebook != NULL);
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));
}
}
void
gtk_notebook_set_homogeneous_tabs (GtkNotebook *notebook,
gboolean homogeneous)
{
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (homogeneous == notebook->homogeneous)
return;
notebook->homogeneous = homogeneous;
gtk_widget_queue_resize (GTK_WIDGET (notebook));
}
void
gtk_notebook_set_tab_border (GtkNotebook *notebook,
guint tab_border)
{
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
notebook->tab_hborder = tab_border;
notebook->tab_vborder = tab_border;
if (GTK_WIDGET_VISIBLE (notebook) && notebook->show_tabs)
gtk_widget_queue_resize (GTK_WIDGET (notebook));
}
void
gtk_notebook_set_tab_hborder (GtkNotebook *notebook,
guint tab_hborder)
{
g_return_if_fail (notebook != NULL);
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));
}
void
gtk_notebook_set_tab_vborder (GtkNotebook *notebook,
guint tab_vborder)
{
g_return_if_fail (notebook != NULL);
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));
}
void
gtk_notebook_set_scrollable (GtkNotebook *notebook,
gboolean scrollable)
{
g_return_if_fail (notebook != NULL);
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
*/
void
gtk_notebook_popup_enable (GtkNotebook *notebook)
{
GList *list;
g_return_if_fail (notebook != NULL);
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);
}
void
gtk_notebook_popup_disable (GtkNotebook *notebook)
{
g_return_if_fail (notebook != NULL);
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
*/
GtkWidget *
gtk_notebook_get_tab_label (GtkNotebook *notebook,
GtkWidget *child)
{
GList *list;
g_return_val_if_fail (notebook != NULL, NULL);
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
g_return_val_if_fail (child != NULL, NULL);
if (!(list = g_list_find_custom (notebook->children, child,
gtk_notebook_page_compare)))
return NULL;
if (GTK_NOTEBOOK_PAGE (list)->default_tab)
return NULL;
return GTK_NOTEBOOK_PAGE (list)->tab_label;
}
void
gtk_notebook_set_tab_label (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_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);
if (!(list = g_list_find_custom (notebook->children, child,
gtk_notebook_page_compare)))
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));
}
}
void
gtk_notebook_set_tab_label_text (GtkNotebook *notebook,
GtkWidget *child,
const gchar *tab_text)
{
GtkWidget *tab_label = NULL;
if (tab_text)
tab_label = gtk_label_new (tab_text);
gtk_notebook_set_tab_label (notebook, child, tab_label);
}
GtkWidget*
gtk_notebook_get_menu_label (GtkNotebook *notebook,
GtkWidget *child)
{
GList *list;
g_return_val_if_fail (notebook != NULL, NULL);
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
g_return_val_if_fail (child != NULL, NULL);
if (!(list = g_list_find_custom (notebook->children, child,
gtk_notebook_page_compare)))
return NULL;
if (GTK_NOTEBOOK_PAGE (list)->default_menu)
return NULL;
return GTK_NOTEBOOK_PAGE (list)->menu_label;
}
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);
if (!(list = g_list_find_custom (notebook->children, child,
gtk_notebook_page_compare)))
return;
page = list->data;
if (page->menu_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);
}
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);
}
void
gtk_notebook_set_menu_label_text (GtkNotebook *notebook,
GtkWidget *child,
const gchar *menu_text)
{
GtkWidget *menu_label = NULL;
if (menu_text)
menu_label = gtk_label_new (menu_text);
gtk_notebook_set_menu_label (notebook, child, menu_label);
}
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);
if (!(list = g_list_find_custom (notebook->children, child,
gtk_notebook_page_compare)))
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;
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, list);
gtk_widget_queue_resize (notebook->menu);
}
gtk_notebook_update_labels (notebook);
}
if (!notebook->show_tabs)
return;
gtk_notebook_pages_allocate (notebook, &(GTK_WIDGET (notebook)->allocation));
gtk_notebook_expose_tabs (notebook);
}
void
gtk_notebook_query_tab_label_packing (GtkNotebook *notebook,
GtkWidget *child,
gboolean *expand,
gboolean *fill,
GtkPackType *pack_type)
{
GList *list;
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (child != NULL);
if (!(list = g_list_find_custom (notebook->children, child,
gtk_notebook_page_compare)))
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;
}
void
gtk_notebook_reorder_child (GtkNotebook *notebook,
GtkWidget *child,
gint position)
{
GList *list;
GList *work;
GtkNotebookPage *page = NULL;
gint old_pos;
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (child != NULL);
g_return_if_fail (GTK_IS_WIDGET (child));
for (old_pos = 0, list = notebook->children; list;
list = list->next, old_pos++)
{
page = list->data;
if (page->child == child)
break;
}
if (!list || old_pos == position)
return;
notebook->children = g_list_remove_link (notebook->children, list);
if (position <= 0 || !notebook->children)
{
list->next = notebook->children;
if (list->next)
list->next->prev = list;
notebook->children = list;
}
else if (position > 0 && (work = g_list_nth (notebook->children, position)))
{
list->prev = work->prev;
if (list->prev)
list->prev->next = list;
list->next = work;
work->prev = list;
}
else
{
work = g_list_last (notebook->children);
work->next = list;
list->prev = work;
}
if (notebook->menu)
{
GtkWidget *menu_item;
g_assert(page != NULL);
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, list);
gtk_widget_queue_resize (notebook->menu);
}
gtk_notebook_update_labels (notebook);
if (notebook->show_tabs)
{
gtk_notebook_pages_allocate (notebook,
&(GTK_WIDGET (notebook)->allocation));
gtk_notebook_expose_tabs (notebook);
}
}
Reference in New Issue View Git Blame Copy Permalink