[gnome-control-center/wip/animated-notebook] shell: CcNotebook bug fixes from ebassi

[Bastien Nocera <hadess src gnome org>]

commit 97cea241f5bc30dd743c26c51e88242e955d1aaa
Author: Bastien Nocera <hadess hadess net>
Date:   Wed May 2 17:42:24 2012 +0100

    shell: CcNotebook bug fixes from ebassi

 shell/cc-notebook.c |  439 +++++++++++++++++++++++----------------------------
 shell/cc-notebook.h |   59 ++++---
 2 files changed, 228 insertions(+), 270 deletions(-)
---
diff --git a/shell/cc-notebook.c b/shell/cc-notebook.c
index aa50f61..8094b07 100644
--- a/shell/cc-notebook.c
+++ b/shell/cc-notebook.c
@@ -29,332 +29,285 @@
 
 #define GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CC_TYPE_NOTEBOOK, CcNotebookPrivate))
 
-/* Structure is:
- * GtkClutterEmbed aka stage
- *     scroll_actor
- *         bin (with a ClutterFlowLayout layout
- *             ClutterActor (each page is 1 widget)
- *             ClutterActor...
+/*
+ * Structure:
+ *
+ *   Notebook
+ *   +---- GtkClutterEmbed
+ *         +---- ClutterStage
+ *               +---- ClutterScrollActor:scroll
+ *                     +---- ClutterActor:bin
+ *                           +---- ClutterActor:frame<ClutterBinLayout>
+ *                                 +---- GtkClutterActor:embed<GtkWidget>
+ *
+ * the frame element is needed to make the GtkClutterActor contents fill the allocation
  */
 
 struct _CcNotebookPrivate
 {
-	GtkWidget *embed;
+        GtkWidget *embed;
+
         ClutterActor *stage;
-        ClutterActor *scroll_actor;
+        ClutterActor *scroll;
         ClutterActor *bin;
-        GList *children; /* GList of ClutterActor */
 
-        GtkWidget *current_page;
-};
+        int last_width;
 
-enum {
-        PROP_0,
-        PROP_CURRENT_PAGE
+        int selected_index;
 };
 
-G_DEFINE_TYPE (CcNotebook, cc_notebook, GTK_TYPE_BOX);
-
-void
-cc_notebook_add (CcNotebook *notebook,
-		 GtkWidget  *widget)
+enum
 {
-	ClutterConstraint *constraint;
-	ClutterActor *child;
+        PROP_0,
+        PROP_CURRENT_PAGE,
+        LAST_PROP
+};
 
-	child = gtk_clutter_actor_new_with_contents (widget);
+static GParamSpec *obj_props[LAST_PROP] = { NULL, };
 
-	/* Make sure that the actor will be window sized */
-	clutter_actor_add_child (notebook->priv->bin, child);
-	constraint = clutter_bind_constraint_new (notebook->priv->stage, CLUTTER_BIND_SIZE, 0.f);
-	clutter_actor_add_constraint_with_name (child, "size", constraint);
+G_DEFINE_TYPE (CcNotebook, cc_notebook, GTK_TYPE_BOX)
 
-	notebook->priv->children = g_list_prepend (notebook->priv->children,
-						   child);
+static void
+cc_notebook_get_property (GObject    *gobject,
+                          guint       prop_id,
+                          GValue     *value,
+                          GParamSpec *pspec)
+{
+        CcNotebookPrivate *priv = CC_NOTEBOOK (gobject)->priv;
 
-	if (notebook->priv->current_page != NULL)
-		return;
+        switch (prop_id) {
+        case PROP_CURRENT_PAGE:
+                g_value_set_int (value, priv->selected_index);
+                break;
 
-	cc_notebook_set_current (notebook, widget);
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+        }
 }
 
-static int
-_cc_notebook_find_widget (GtkClutterActor *actor,
-			  GtkWidget       *widget)
+static void
+cc_notebook_class_init (CcNotebookClass *klass)
 {
-	if (gtk_clutter_actor_get_contents (actor) == widget)
-		return 0;
-	return -1;
-}
+        GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 
-static ClutterActor *
-_cc_notebook_actor_for_widget (CcNotebook *notebook,
-			       GtkWidget  *widget)
-{
-	GList *l;
-
-	l = g_list_find_custom (notebook->priv->children,
-				widget,
-				(GCompareFunc) _cc_notebook_find_widget);
-	if (!l)
-		return NULL;
-	return l->data;
-}
+        g_type_class_add_private (klass, sizeof (CcNotebookPrivate));
 
-void
-cc_notebook_remove (CcNotebook *notebook,
-		    GtkWidget  *widget)
-{
-	ClutterActor *actor;
+        obj_props[PROP_CURRENT_PAGE] =
+                g_param_spec_int (g_intern_static_string ("current-page"),
+                                  "Current Page",
+                                  "The index of the currently selected page",
+                                  -1, G_MAXINT,
+                                  -1,
+                                  G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 
-	actor = _cc_notebook_actor_for_widget (notebook, widget);
-	if (actor == NULL)
-		return;
-	clutter_actor_remove_child (notebook->priv->bin, actor);
-	notebook->priv->children = g_list_remove (notebook->priv->children, actor);
+        gobject_class->get_property = cc_notebook_get_property;
+        g_object_class_install_properties (gobject_class, LAST_PROP, obj_props);
 }
 
 static void
-cc_notebook_set_property (GObject      *object,
-			  guint         prop_id,
-			  const GValue *value,
-			  GParamSpec   *pspec)
+on_embed_size_allocate (GtkWidget     *embed,
+                        GtkAllocation *allocation,
+                        CcNotebook  *self)
 {
-        switch (prop_id) {
-        case PROP_CURRENT_PAGE:
-                cc_notebook_set_current (CC_NOTEBOOK (object),
-					      g_value_get_pointer (value));
-                break;
-        default:
-                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-                break;
+        ClutterActorIter iter;
+        ClutterActor *child;
+        float page_w, page_h;
+        float offset = 0.f;
+
+        /* we only care about the width changes, since we need to recompute the
+         * offset of the pages
+         */
+        if (allocation->width == self->priv->last_width)
+                return;
+
+        page_w = allocation->width;
+        page_h = allocation->height;
+
+        clutter_actor_iter_init (&iter, self->priv->bin);
+        while (clutter_actor_iter_next (&iter, &child)) {
+                clutter_actor_set_x (child, offset);
+                clutter_actor_set_size (child, page_w, page_h);
+
+                offset += page_w;
         }
 }
 
 static void
-cc_notebook_get_property (GObject    *object,
-			  guint       prop_id,
-			  GValue     *value,
-			  GParamSpec *pspec)
+cc_notebook_init (CcNotebook *self)
 {
-        switch (prop_id) {
-        case PROP_CURRENT_PAGE:
-                g_value_set_pointer (value, cc_notebook_get_current (CC_NOTEBOOK (object)));
-                break;
-        default:
-                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-                break;
-        }
-}
+        self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CC_TYPE_NOTEBOOK, CcNotebookPrivate);
 
-static GtkSizeRequestMode
-cc_notebook_get_request_mode (GtkWidget *widget)
-{
-	CcNotebook *notebook;
-	GtkWidget *target;
+        self->priv->embed = gtk_clutter_embed_new ();
+        gtk_widget_push_composite_child ();
+        gtk_container_add (GTK_CONTAINER (self), self->priv->embed);
+        gtk_widget_pop_composite_child ();
+        g_signal_connect (self->priv->embed, "size-allocate", G_CALLBACK (on_embed_size_allocate), self);
+        gtk_widget_show (self->priv->embed);
+
+        self->priv->stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (self->priv->embed));
+        clutter_actor_set_background_color (self->priv->stage, CLUTTER_COLOR_Red);
 
-	notebook = CC_NOTEBOOK (widget);
+        self->priv->scroll = clutter_scroll_actor_new ();
+        clutter_scroll_actor_set_scroll_mode (CLUTTER_SCROLL_ACTOR (self->priv->scroll),
+                                                CLUTTER_SCROLL_HORIZONTALLY);
+        clutter_actor_add_constraint (self->priv->scroll, clutter_bind_constraint_new (self->priv->stage, CLUTTER_BIND_SIZE, 0.f));
+        clutter_actor_add_child (self->priv->stage, self->priv->scroll);
 
-	target = notebook->priv->current_page ? notebook->priv->current_page : GTK_WIDGET (notebook);
+        self->priv->bin = clutter_actor_new ();
+        clutter_actor_add_child (self->priv->scroll, self->priv->bin);
 
-	return gtk_widget_get_request_mode (target);
+        self->priv->selected_index = -1;
 }
 
-static void
-cc_notebook_get_preferred_height (GtkWidget       *widget,
-				  gint            *minimum_height,
-				  gint            *natural_height)
+GtkWidget *
+cc_notebook_new (void)
 {
-	CcNotebook *notebook;
-	GtkWidget *target;
-
-	notebook = CC_NOTEBOOK (widget);
-
-	target = notebook->priv->current_page ? notebook->priv->current_page : GTK_WIDGET (notebook);
-
-	gtk_widget_get_preferred_height (target, minimum_height, natural_height);
+        return g_object_new (CC_TYPE_NOTEBOOK, NULL);
 }
 
-static void
-cc_notebook_get_preferred_width_for_height (GtkWidget       *widget,
-					    gint             height,
-					    gint            *minimum_width,
-					    gint            *natural_width)
+void
+cc_notebook_select_page (CcNotebook *self,
+                         GtkWidget  *widget)
 {
-	CcNotebook *notebook;
-	GtkWidget *target;
+        ClutterActorIter iter;
+        ClutterActor *child;
+        int index_ = 0;
+
+        g_return_if_fail (CC_IS_NOTEBOOK (self));
+        g_return_if_fail (GTK_IS_WIDGET (widget));
 
-	notebook = CC_NOTEBOOK (widget);
+        clutter_actor_iter_init (&iter, self->priv->bin);
+        while (clutter_actor_iter_next (&iter, &child)) {
+                ClutterActor *embed = clutter_actor_get_child_at_index (child, 0);
 
-	target = notebook->priv->current_page ? notebook->priv->current_page : GTK_WIDGET (notebook);
+                if (gtk_clutter_actor_get_contents (GTK_CLUTTER_ACTOR (embed)) == widget) {
+                        cc_notebook_select_page_at_index (self, index_);
+                        return;
+                }
 
-	gtk_widget_get_preferred_width_for_height (target, height, minimum_width, natural_width);
+                index_ += 1;
+        }
 }
 
-static void
-cc_notebook_get_preferred_width (GtkWidget       *widget,
-				 gint            *minimum_width,
-				 gint            *natural_width)
+void
+cc_notebook_select_page_at_index (CcNotebook *self,
+                                  int         index_)
 {
-	CcNotebook *notebook;
-	GtkWidget *target;
+        ClutterActor *item;
+        ClutterPoint pos;
+        int n_children;
 
-	notebook = CC_NOTEBOOK (widget);
+        g_return_if_fail (CC_IS_NOTEBOOK (self));
 
-	target = notebook->priv->current_page ? notebook->priv->current_page : GTK_WIDGET (notebook);
+        n_children = clutter_actor_get_n_children (self->priv->bin);
+        if (index_ >= n_children)
+                index_ = 0;
+        else if (index_ < 0)
+                index_ = n_children - 1;
 
-	gtk_widget_get_preferred_width (target, minimum_width, natural_width);
-}
+        if (self->priv->selected_index == index_)
+                return;
 
-static void
-cc_notebook_get_preferred_height_for_width (GtkWidget       *widget,
-					    gint             width,
-					    gint            *minimum_height,
-					    gint            *natural_height)
-{
-	CcNotebook *notebook;
-	GtkWidget *target;
+        self->priv->selected_index = index_;
 
-	notebook = CC_NOTEBOOK (widget);
+        item = clutter_actor_get_child_at_index (self->priv->bin, index_);
+        g_assert (item != NULL);
 
-	target = notebook->priv->current_page ? notebook->priv->current_page : GTK_WIDGET (notebook);
+        clutter_actor_get_position (item, &pos.x, &pos.y);
+        g_message ("scrolling to %lfx%lf (item %d)", pos.x, pos.y, index_);
+        clutter_scroll_actor_scroll_to_point (CLUTTER_SCROLL_ACTOR (self->priv->scroll), &pos);
 
-	gtk_widget_get_preferred_height_for_width (target, width, minimum_height, natural_height);
+        g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_CURRENT_PAGE]);
 }
 
-static void
-cc_notebook_size_allocate (GtkWidget     *widget,
-			   GtkAllocation *allocation)
+void
+cc_notebook_select_previous_page (CcNotebook *self)
 {
-	CcNotebook *notebook;
-	GtkWidget *target;
+        g_return_if_fail (CC_IS_NOTEBOOK (self));
 
-	notebook = CC_NOTEBOOK (widget);
-
-	target = notebook->priv->current_page ? notebook->priv->current_page : GTK_WIDGET (notebook);
-
-	gtk_widget_size_allocate (target, allocation);
+        cc_notebook_select_page_at_index (self, self->priv->selected_index - 1);
 }
 
-static void
-cc_notebook_configure_event (GtkWidget         *widget,
-			     GdkEventConfigure *event)
+void
+cc_notebook_select_next_page (CcNotebook *self)
 {
-	CcNotebook *notebook;
-	ClutterActor *actor;
-
-	GTK_WIDGET_CLASS (cc_notebook_parent_class)->configure_event (widget, event);
+        g_return_if_fail (CC_IS_NOTEBOOK (self));
 
-	notebook = CC_NOTEBOOK (widget);
-	actor = _cc_notebook_actor_for_widget (notebook, notebook->priv->current_page);
-	if (actor == NULL)
-		return;
-	clutter_actor_set_size (actor, event->width, event->height);
+        cc_notebook_select_page_at_index (self, self->priv->selected_index + 1);
 }
 
-static void
-cc_notebook_class_init (CcNotebookClass *class)
+int
+cc_notebook_add_page (CcNotebook *self,
+                      GtkWidget  *widget)
 {
-        GObjectClass *gobject_class;
-        GtkWidgetClass *widget_class;
+        ClutterActor *frame;
+        ClutterActor *embed;
+        int res;
 
-        gobject_class = (GObjectClass*)class;
-        widget_class = (GtkWidgetClass*)class;
+        g_return_val_if_fail (CC_IS_NOTEBOOK (self), -1);
+        g_return_val_if_fail (GTK_IS_WIDGET (widget), -1);
 
-        gobject_class->set_property = cc_notebook_set_property;
-        gobject_class->get_property = cc_notebook_get_property;
+        frame = clutter_actor_new ();
+        clutter_actor_set_layout_manager (frame, clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FILL,
+                                                                         CLUTTER_BIN_ALIGNMENT_FILL));
 
-	g_object_class_install_property (gobject_class,
-					 PROP_CURRENT_PAGE,
-					 g_param_spec_pointer ("current-page",
-							      "Current Page",
-							      "Current Page",
-							      G_PARAM_READWRITE));
-
-	widget_class->get_request_mode = cc_notebook_get_request_mode;
-	widget_class->get_preferred_height = cc_notebook_get_preferred_height;
-	widget_class->get_preferred_width_for_height = cc_notebook_get_preferred_width_for_height;
-	widget_class->get_preferred_width = cc_notebook_get_preferred_width;
-	widget_class->get_preferred_height_for_width = cc_notebook_get_preferred_height_for_width;
-//	widget_class->size_allocate = cc_notebook_size_allocate;
-//	widget_class->configure_event = cc_notebook_configure_event;
-
-        g_type_class_add_private (class, sizeof (CcNotebookPrivate));
-}
+        embed = gtk_clutter_actor_new_with_contents (widget);
+        clutter_actor_add_child (frame, embed);
+        gtk_widget_show_all (widget);
 
-static void
-cc_notebook_init (CcNotebook *notebook)
-{
-	CcNotebookPrivate *priv;
-	ClutterLayoutManager *layout;
-
-	priv = GET_PRIVATE (notebook);
-	notebook->priv = priv;
-
-	priv->embed = gtk_clutter_embed_new ();
-	gtk_widget_push_composite_child ();
-	gtk_box_pack_start (GTK_BOX (notebook), priv->embed, TRUE, TRUE, 0);
-	gtk_widget_pop_composite_child ();
-	gtk_widget_show (priv->embed);
-	priv->stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (priv->embed));
-
-	clutter_actor_set_background_color (CLUTTER_ACTOR (priv->stage), CLUTTER_COLOR_Red);
-
-	/* Scroll actor */
-	priv->scroll_actor = clutter_scroll_actor_new ();
-	clutter_actor_add_child (priv->stage, priv->scroll_actor);
-	clutter_scroll_actor_set_scroll_mode (CLUTTER_SCROLL_ACTOR (priv->scroll_actor),
-					      CLUTTER_SCROLL_HORIZONTALLY);
-
-	/* Horizontal flow, inside the scroll */
-	priv->bin = clutter_actor_new ();
-	layout = clutter_flow_layout_new (CLUTTER_FLOW_HORIZONTAL);
-	clutter_flow_layout_set_homogeneous (CLUTTER_FLOW_LAYOUT (layout), TRUE);
-	clutter_actor_set_layout_manager (priv->bin, layout);
-	clutter_actor_add_child (priv->scroll_actor, priv->bin);
-}
+        res = clutter_actor_get_n_children (self->priv->bin);
+        clutter_actor_insert_child_at_index (self->priv->bin, frame, res);
 
-GtkWidget *
-cc_notebook_new (void)
-{
-        return (GtkWidget*) g_object_new (CC_TYPE_NOTEBOOK, NULL);
+        if (self->priv->selected_index < 0)
+                cc_notebook_select_page_at_index (self, 0);
+
+        return res;
 }
 
 void
-cc_notebook_set_current (CcNotebook *notebook,
-			 GtkWidget  *widget)
+cc_notebook_remove_page (CcNotebook *self,
+                           GtkWidget    *widget)
 {
-	ClutterPoint pos;
-	ClutterActor *actor;
+        ClutterActorIter iter;
+        ClutterActor *child;
 
-	g_return_if_fail (CC_IS_NOTEBOOK (notebook));
-	g_return_if_fail (GTK_IS_WIDGET (widget));
+        g_return_if_fail (CC_IS_NOTEBOOK (self));
+        g_return_if_fail (GTK_IS_WIDGET (widget));
 
-	if (widget == notebook->priv->current_page)
-		return;
+        clutter_actor_iter_init (&iter, self->priv->bin);
+        while (clutter_actor_iter_next (&iter, &child)) {
+                ClutterActor *embed = clutter_actor_get_child_at_index (child, 0);
 
-	actor = _cc_notebook_actor_for_widget (notebook, widget);
-	g_return_if_fail (actor != NULL);
+                if (gtk_clutter_actor_get_contents (GTK_CLUTTER_ACTOR (embed)) == widget) {
+                        clutter_actor_iter_remove (&iter);
+                        return;
+                }
+        }
+}
 
-	clutter_actor_get_position (actor, &pos.x, &pos.y);
+int
+cc_notebook_get_selected_index (CcNotebook *self)
+{
+        g_return_val_if_fail (CC_IS_NOTEBOOK (self), -1);
 
-	clutter_actor_save_easing_state (notebook->priv->scroll_actor);
-	clutter_actor_set_easing_duration (notebook->priv->scroll_actor, 500);
+        return self->priv->selected_index;
+}
 
-	clutter_scroll_actor_scroll_to_point (CLUTTER_SCROLL_ACTOR (notebook->priv->scroll_actor), &pos);
+GtkWidget *
+cc_notebook_get_selected_page (CcNotebook *self)
+{
+        ClutterActor *frame, *embed;
 
-	clutter_actor_restore_easing_state (notebook->priv->scroll_actor);
+        g_return_val_if_fail (CC_IS_NOTEBOOK (self), NULL);
 
-	notebook->priv->current_page = widget;
-	g_object_notify (G_OBJECT (notebook), "current-page");
+        if (self->priv->selected_index < 0)
+                return NULL;
 
-	gtk_widget_queue_resize (GTK_WIDGET (notebook));
-}
+        frame = clutter_actor_get_child_at_index (self->priv->bin, self->priv->selected_index);
+        if (frame == NULL)
+                return NULL;
 
-GtkWidget *
-cc_notebook_get_current (CcNotebook *notebook)
-{
-	g_return_val_if_fail (CC_IS_NOTEBOOK (notebook), NULL);
+        embed = clutter_actor_get_child_at_index (frame, 0);
 
-	return notebook->priv->current_page;
+        return gtk_clutter_actor_get_contents (GTK_CLUTTER_ACTOR (embed));
 }
diff --git a/shell/cc-notebook.h b/shell/cc-notebook.h
index 4f102ed..7a5a768 100644
--- a/shell/cc-notebook.h
+++ b/shell/cc-notebook.h
@@ -22,47 +22,52 @@
 #ifndef _CC_NOTEBOOK_H_
 #define _CC_NOTEBOOK_H_
 
-#include <glib-object.h>
 #include <gtk/gtk.h>
 #include <clutter-gtk/clutter-gtk.h>
 
 G_BEGIN_DECLS
 
-#define CC_TYPE_NOTEBOOK            (cc_notebook_get_type ())
-#define CC_NOTEBOOK(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CC_TYPE_NOTEBOOK, \
-                                                                           CcNotebook))
-#define CC_NOTEBOOK_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), CC_TYPE_NOTEBOOK, \
-                                                                        CcNotebookClass))
-#define CC_IS_NOTEBOOK(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CC_TYPE_NOTEBOOK))
-#define CC_IS_NOTEBOOK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CC_TYPE_NOTEBOOK))
-#define CC_NOTEBOOK_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CC_TYPE_NOTEBOOK, \
-                                                                          CcNotebookClass))
+#define CC_TYPE_NOTEBOOK                (cc_notebook_get_type ())
+#define CC_NOTEBOOK(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), CC_TYPE_NOTEBOOK, CcNotebook))
+#define CC_IS_NOTEBOOK(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CC_TYPE_NOTEBOOK))
+#define CC_NOTEBOOK_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), CC_TYPE_NOTEBOOK, CcNotebookClass))
+#define CC_IS_NOTEBOOK_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), CC_TYPE_NOTEBOOK))
+#define CC_NOTEBOOK_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), CC_TYPE_NOTEBOOK, CcNotebookClass))
 
-typedef struct _CcNotebookClass CcNotebookClass;
-typedef struct _CcNotebook CcNotebook;
-typedef struct _CcNotebookPrivate CcNotebookPrivate;
+typedef struct _CcNotebook            CcNotebook;
+typedef struct _CcNotebookPrivate     CcNotebookPrivate;
+typedef struct _CcNotebookClass       CcNotebookClass;
 
-struct _CcNotebookClass {
-        GtkBoxClass parent_class;
-};
+struct _CcNotebook
+{
+        GtkBox parent_class;
 
-struct _CcNotebook {
-        GtkBox parent_instance;
         CcNotebookPrivate *priv;
 };
 
-GType      cc_notebook_get_type             (void) G_GNUC_CONST;
+struct _CcNotebookClass
+{
+        GtkBoxClass parent_class;
+};
+
+GType           cc_notebook_get_type                    (void) G_GNUC_CONST;
+
+GtkWidget *     cc_notebook_new                         (void);
 
-GtkWidget *cc_notebook_new                  (void);
+int             cc_notebook_add_page                    (CcNotebook *self,
+                                                         GtkWidget  *widget);
+void            cc_notebook_remove_page                 (CcNotebook *self,
+                                                         GtkWidget  *widget);
 
-void       cc_notebook_add                  (CcNotebook *notebook,
-					     GtkWidget  *widget);
-void       cc_notebook_remove               (CcNotebook *notebook,
-					     GtkWidget  *widget);
+void            cc_notebook_select_page                 (CcNotebook *self,
+                                                         GtkWidget  *widget);
+void            cc_notebook_select_page_at_index        (CcNotebook *self,
+                                                         int         index_);
+void            cc_notebook_select_previous_page        (CcNotebook *self);
+void            cc_notebook_select_next_page            (CcNotebook *self);
 
-void       cc_notebook_set_current          (CcNotebook *notebook,
-					     GtkWidget  *widget);
-GtkWidget *cc_notebook_get_current          (CcNotebook *notebook);
+int             cc_notebook_get_selected_index          (CcNotebook *self);
+GtkWidget *     cc_notebook_get_selected_page           (CcNotebook *self);
 
 G_END_DECLS