Commits

Anonymous committed 630c2fa

renamme all moo gtypes to internal to avoid api races

Comments (0)

Files changed (9)

contrib/moo/moobigpaned.c

     int size;
     int sticky;
     char *active;
-} MooPanedConfig;
+} MooInternalPanedConfig;
 
 typedef struct {
-    MooPanedConfig paned[4];
+    MooInternalPanedConfig paned[4];
     GHashTable *panes;
-} MooBigPanedConfig;
+} MooInternalBigPanedConfig;
 
-struct MooBigPanedPrivate {
-    MooPanePosition order[4]; /* inner is paned[order[3]] */
+struct MooInternalBigPanedPrivate {
+    MooInternalPanePosition order[4]; /* inner is paned[order[3]] */
     GtkWidget   *inner;
     GtkWidget   *outer;
 
-    MooBigPanedConfig *config;
+    MooInternalBigPanedConfig *config;
     GHashTable  *panes;
 
     int          drop_pos;
 
 static gboolean moo_big_paned_expose        (GtkWidget      *widget,
                                              GdkEventExpose *event,
-                                             MooBigPaned    *paned);
+                                             MooInternalBigPaned    *paned);
 
 static void     child_set_pane_size         (GtkWidget      *child,
                                              int             size,
-                                             MooBigPaned    *paned);
+                                             MooInternalBigPaned    *paned);
 static void     sticky_pane_notify          (GtkWidget      *child,
                                              GParamSpec     *pspec,
-                                             MooBigPaned    *paned);
+                                             MooInternalBigPaned    *paned);
 static void     active_pane_notify          (GtkWidget      *child,
                                              GParamSpec     *pspec,
-                                             MooBigPaned    *paned);
+                                             MooInternalBigPaned    *paned);
 
-static gboolean check_children_order        (MooBigPaned    *paned);
+static gboolean check_children_order        (MooInternalBigPaned    *paned);
 
-static void     handle_drag_start           (MooPaned       *child,
+static void     handle_drag_start           (MooInternalPaned       *child,
                                              GtkWidget      *pane_widget,
-                                             MooBigPaned    *paned);
-static void     handle_drag_motion          (MooPaned       *child,
+                                             MooInternalBigPaned    *paned);
+static void     handle_drag_motion          (MooInternalPaned       *child,
                                              GtkWidget      *pane_widget,
-                                             MooBigPaned    *paned);
-static void     handle_drag_end             (MooPaned       *child,
+                                             MooInternalBigPaned    *paned);
+static void     handle_drag_end             (MooInternalPaned       *child,
                                              GtkWidget      *pane_widget,
                                              gboolean        drop,
-                                             MooBigPaned    *paned);
+                                             MooInternalBigPaned    *paned);
 
-static void     config_changed              (MooBigPaned    *paned);
+static void     config_changed              (MooInternalBigPaned    *paned);
 
-static MooBigPanedConfig *config_new        (void);
-static void               config_free       (MooBigPanedConfig *config);
-static MooBigPanedConfig *config_parse      (const char        *string);
-static char              *config_serialize  (MooBigPanedConfig *config);
+static MooInternalBigPanedConfig *config_new        (void);
+static void               config_free       (MooInternalBigPanedConfig *config);
+static MooInternalBigPanedConfig *config_parse      (const char        *string);
+static char              *config_serialize  (MooInternalBigPanedConfig *config);
 
 
-/* MOO_TYPE_BIG_PANED */
-G_DEFINE_TYPE (MooBigPaned, moo_big_paned, GTK_TYPE_FRAME)
+/* MOO_TYPE_INTERNAL_BIG_PANED */
+G_DEFINE_TYPE (MooInternalBigPaned, moo_big_paned, GTK_TYPE_FRAME)
 
 enum {
     PROP_0,
 static guint signals[NUM_SIGNALS];
 
 static void
-moo_big_paned_class_init (MooBigPanedClass *klass)
+moo_big_paned_class_init (MooInternalBigPanedClass *klass)
 {
     GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 
-    g_type_class_add_private (klass, sizeof (MooBigPanedPrivate));
+    g_type_class_add_private (klass, sizeof (MooInternalBigPanedPrivate));
 
     gobject_class->finalize = moo_big_paned_finalize;
     gobject_class->set_property = moo_big_paned_set_property;
 #define NTH_CHILD(paned,n) paned->paned[paned->priv->order[n]]
 
 static void
-moo_big_paned_init (MooBigPaned *paned)
+moo_big_paned_init (MooInternalBigPaned *paned)
 {
     int i;
 
     paned->priv = G_TYPE_INSTANCE_GET_PRIVATE (paned,
-                                               MOO_TYPE_BIG_PANED,
-                                               MooBigPanedPrivate);
+                                               MOO_TYPE_INTERNAL_BIG_PANED,
+                                               MooInternalBigPanedPrivate);
 
     paned->priv->panes = g_hash_table_new_full (g_str_hash, g_str_equal,
                                                 g_free, g_object_unref);
         GtkWidget *child;
 
         paned->paned[i] = child =
-                g_object_new (MOO_TYPE_PANED,
-                              "pane-position", (MooPanePosition) i,
+                g_object_new (MOO_TYPE_INTERNAL_PANED,
+                              "pane-position", (MooInternalPanePosition) i,
                               NULL);
 
         MOO_OBJECT_REF_SINK (child);
                           paned);
     }
 
-    paned->priv->order[0] = MOO_PANE_POS_LEFT;
-    paned->priv->order[1] = MOO_PANE_POS_RIGHT;
-    paned->priv->order[2] = MOO_PANE_POS_TOP;
-    paned->priv->order[3] = MOO_PANE_POS_BOTTOM;
+    paned->priv->order[0] = MOO_INTERNAL_PANE_POS_LEFT;
+    paned->priv->order[1] = MOO_INTERNAL_PANE_POS_RIGHT;
+    paned->priv->order[2] = MOO_INTERNAL_PANE_POS_TOP;
+    paned->priv->order[3] = MOO_INTERNAL_PANE_POS_BOTTOM;
 
     paned->priv->inner = NTH_CHILD (paned, 3);
     paned->priv->outer = NTH_CHILD (paned, 0);
 
 
 static gboolean
-check_children_order (MooBigPaned *paned)
+check_children_order (MooInternalBigPaned *paned)
 {
     int i;
 
 
 
 void
-moo_big_paned_set_pane_order (MooBigPaned *paned,
+moo_big_paned_set_pane_order (MooInternalBigPaned *paned,
                               int         *order)
 {
-    MooPanePosition new_order[4] = {8, 8, 8, 8};
+    MooInternalPanePosition new_order[4] = {8, 8, 8, 8};
     int i;
     GtkWidget *child;
 
 static void
 moo_big_paned_finalize (GObject *object)
 {
-    MooBigPaned *paned = MOO_BIG_PANED (object);
+    MooInternalBigPaned *paned = MOO_INTERNAL_BIG_PANED (object);
     int i;
 
     g_hash_table_destroy (paned->priv->panes);
 GtkWidget*
 moo_big_paned_new (void)
 {
-    return g_object_new (MOO_TYPE_BIG_PANED, NULL);
+    return g_object_new (MOO_TYPE_INTERNAL_BIG_PANED, NULL);
 }
 
 
 static void
-config_changed (MooBigPaned *paned)
+config_changed (MooInternalBigPaned *paned)
 {
     g_signal_emit (paned, signals[CONFIG_CHANGED], 0);
 }
 static void
 child_set_pane_size (GtkWidget   *child,
                      int          size,
-                     MooBigPaned *paned)
+                     MooInternalBigPaned *paned)
 {
-    MooPanePosition pos;
+    MooInternalPanePosition pos;
 
     g_object_get (child, "pane-position", &pos, NULL);
     g_return_if_fail (paned->paned[pos] == child);
 static void
 sticky_pane_notify (GtkWidget   *child,
                     G_GNUC_UNUSED GParamSpec *pspec,
-                    MooBigPaned *paned)
+                    MooInternalBigPaned *paned)
 {
-    MooPanePosition pos;
+    MooInternalPanePosition pos;
     gboolean sticky;
 
     g_object_get (child, "pane-position", &pos,
 static void
 active_pane_notify (GtkWidget   *child,
                     G_GNUC_UNUSED GParamSpec *pspec,
-                    MooBigPaned *paned)
+                    MooInternalBigPaned *paned)
 {
-    MooPanePosition pos;
-    MooPane *pane = NULL;
+    MooInternalPanePosition pos;
+    MooInternalPane *pane = NULL;
     const char *id = NULL;
-    MooPanedConfig *pc;
+    MooInternalPanedConfig *pc;
 
     g_object_get (child, "pane-position", &pos,
                   "active-pane", &pane, NULL);
 }
 
 static void
-pane_params_changed (MooPane       *pane,
+pane_params_changed (MooInternalPane       *pane,
                      G_GNUC_UNUSED GParamSpec *pspec,
-                     MooBigPaned   *paned)
+                     MooInternalBigPaned   *paned)
 {
     const char *id;
-    MooPaneParams *params;
+    MooInternalPaneParams *params;
 
     id = moo_pane_get_id (pane);
     g_return_if_fail (id != NULL);
 }
 
 
-static MooPaneParams *
-get_pane_config (MooBigPaned     *paned,
+static MooInternalPaneParams *
+get_pane_config (MooInternalBigPaned     *paned,
                  const char      *id,
-                 MooPanePosition *position,
+                 MooInternalPanePosition *position,
                  int             *index)
 {
-    MooPaneParams *params;
+    MooInternalPaneParams *params;
     int pos;
     gboolean found = FALSE;
 
 }
 
 static void
-add_pane_id_to_list (MooBigPaned    *paned,
-                     MooPanedConfig *pc,
+add_pane_id_to_list (MooInternalBigPaned    *paned,
+                     MooInternalPanedConfig *pc,
                      const char     *id,
                      int             index)
 {
 }
 
 static void
-add_pane_config (MooBigPaned     *paned,
+add_pane_config (MooInternalBigPaned     *paned,
                  const char      *id,
-                 MooPane         *pane,
-                 MooPanePosition  pos,
+                 MooInternalPane         *pane,
+                 MooInternalPanePosition  pos,
                  int              index)
 {
-    MooPaneParams *params;
+    MooInternalPaneParams *params;
 
     g_return_if_fail (index >= 0);
     g_return_if_fail (!g_hash_table_lookup (paned->priv->config->panes, id));
 }
 
 static void
-move_pane_config (MooBigPaned     *paned,
+move_pane_config (MooInternalBigPaned     *paned,
                   const char      *id,
-                  MooPanePosition  old_pos,
-                  MooPanePosition  new_pos,
+                  MooInternalPanePosition  old_pos,
+                  MooInternalPanePosition  new_pos,
                   int              new_index)
 {
     GSList *old_link;
-    MooBigPanedConfig *config = paned->priv->config;
-    MooPanedConfig *old_pc, *new_pc;
+    MooInternalBigPanedConfig *config = paned->priv->config;
+    MooInternalPanedConfig *old_pc, *new_pc;
 
     g_return_if_fail (new_index >= 0);
     g_return_if_fail (g_hash_table_lookup (config->panes, id) != NULL);
 
 
 void
-moo_big_paned_set_config (MooBigPaned *paned,
+moo_big_paned_set_config (MooInternalBigPaned *paned,
                           const char  *string)
 {
-    MooBigPanedConfig *config;
+    MooInternalBigPanedConfig *config;
     int pos;
 
     g_return_if_fail (MOO_IS_BIG_PANED (paned));
     for (pos = 0; pos < 4; ++pos)
     {
         if (config->paned[pos].size > 0)
-            moo_paned_set_pane_size (MOO_PANED (paned->paned[pos]),
+            moo_paned_set_pane_size (MOO_INTERNAL_PANED (paned->paned[pos]),
                                      config->paned[pos].size);
         if (config->paned[pos].sticky >= 0)
-            moo_paned_set_sticky_pane (MOO_PANED (paned->paned[pos]),
+            moo_paned_set_sticky_pane (MOO_INTERNAL_PANED (paned->paned[pos]),
                                        config->paned[pos].sticky);
     }
 }
 
 char *
-moo_big_paned_get_config (MooBigPaned *paned)
+moo_big_paned_get_config (MooInternalBigPaned *paned)
 {
     g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
     return config_serialize (paned->priv->config);
 }
 
 
-MooPane *
-moo_big_paned_insert_pane (MooBigPaned        *paned,
+MooInternalPane *
+moo_big_paned_insert_pane (MooInternalBigPaned        *paned,
                            GtkWidget          *pane_widget,
                            const char         *id,
-                           MooPaneLabel       *pane_label,
-                           MooPanePosition     position,
+                           MooInternalPaneLabel       *pane_label,
+                           MooInternalPanePosition     position,
                            int                 index)
 {
-    MooPane *pane;
-    MooPaneParams *params = NULL;
+    MooInternalPane *pane;
+    MooInternalPaneParams *params = NULL;
 
     g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
     g_return_val_if_fail (GTK_IS_WIDGET (pane_widget), NULL);
         params = get_pane_config (paned, id, &position, &index);
 
     if (index < 0)
-        index = moo_paned_n_panes (MOO_PANED (paned->paned[position]));
+        index = moo_paned_n_panes (MOO_INTERNAL_PANED (paned->paned[position]));
 
-    pane = moo_paned_insert_pane (MOO_PANED (paned->paned[position]),
+    pane = moo_paned_insert_pane (MOO_INTERNAL_PANED (paned->paned[position]),
                                   pane_widget, pane_label, index);
 
     if (pane && id)
 
 
 void
-moo_big_paned_reorder_pane (MooBigPaned    *paned,
+moo_big_paned_reorder_pane (MooInternalBigPaned    *paned,
                             GtkWidget      *pane_widget,
-                            MooPanePosition new_position,
+                            MooInternalPanePosition new_position,
                             int             new_index)
 {
-    MooPane *pane;
-    MooPaned *child;
-    MooPanePosition old_position;
+    MooInternalPane *pane;
+    MooInternalPaned *child;
+    MooInternalPanePosition old_position;
     int old_index;
     const char *id;
 
         if (old_position == new_position)
             new_index = (int) moo_paned_n_panes (child) - 1;
         else
-            new_index = moo_paned_n_panes (MOO_PANED (paned->paned[new_position]));
+            new_index = moo_paned_n_panes (MOO_INTERNAL_PANED (paned->paned[new_position]));
     }
 
     if (old_position == new_position && old_index == new_index)
         g_object_ref (pane);
 
         moo_paned_remove_pane (child, pane_widget);
-        _moo_paned_insert_pane (MOO_PANED (paned->paned[new_position]), pane, new_index);
+        _moo_paned_insert_pane (MOO_INTERNAL_PANED (paned->paned[new_position]), pane, new_index);
         moo_pane_open (pane);
 
         g_object_unref (pane);
 
 
 void
-moo_big_paned_add_child (MooBigPaned *paned,
+moo_big_paned_add_child (MooInternalBigPaned *paned,
                          GtkWidget   *child)
 {
     g_return_if_fail (MOO_IS_BIG_PANED (paned));
 
 
 void
-moo_big_paned_remove_child (MooBigPaned *paned)
+moo_big_paned_remove_child (MooInternalBigPaned *paned)
 {
     g_return_if_fail (MOO_IS_BIG_PANED (paned));
     gtk_container_remove (GTK_CONTAINER (paned->priv->inner),
 
 
 GtkWidget *
-moo_big_paned_get_child (MooBigPaned *paned)
+moo_big_paned_get_child (MooInternalBigPaned *paned)
 {
     g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
     return GTK_BIN(paned->priv->inner)->child;
 
 
 gboolean
-moo_big_paned_remove_pane (MooBigPaned *paned,
+moo_big_paned_remove_pane (MooInternalBigPaned *paned,
                            GtkWidget   *widget)
 {
-    MooPaned *child;
-    MooPane *pane;
+    MooInternalPaned *child;
+    MooInternalPane *pane;
     const char *id;
 
     g_return_val_if_fail (MOO_IS_BIG_PANED (paned), FALSE);
 }
 
 
-MooPane *
-moo_big_paned_lookup_pane (MooBigPaned *paned,
+MooInternalPane *
+moo_big_paned_lookup_pane (MooInternalBigPaned *paned,
                            const char  *pane_id)
 {
     g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
 
 #define PROXY_FUNC(name)                                    \
 void                                                        \
-moo_big_paned_##name (MooBigPaned *paned,                   \
+moo_big_paned_##name (MooInternalBigPaned *paned,                   \
                       GtkWidget   *widget)                  \
 {                                                           \
-    MooPane *pane;                                          \
-    MooPaned *child = NULL;                                 \
+    MooInternalPane *pane;                                          \
+    MooInternalPaned *child = NULL;                                 \
                                                             \
     g_return_if_fail (MOO_IS_BIG_PANED (paned));            \
     g_return_if_fail (GTK_IS_WIDGET (widget));              \
 #undef PROXY_FUNC
 
 void
-moo_big_paned_hide_pane (MooBigPaned *paned,
+moo_big_paned_hide_pane (MooInternalBigPaned *paned,
                          GtkWidget   *widget)
 {
-    MooPaned *child = NULL;
+    MooInternalPaned *child = NULL;
 
     g_return_if_fail (MOO_IS_BIG_PANED (paned));
     g_return_if_fail (GTK_IS_WIDGET (widget));
 }
 
 
-MooPaned *
-moo_big_paned_get_paned (MooBigPaned    *paned,
-                         MooPanePosition position)
+MooInternalPaned *
+moo_big_paned_get_paned (MooInternalBigPaned    *paned,
+                         MooInternalPanePosition position)
 {
     g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
     g_return_val_if_fail (position < 4, NULL);
-    return MOO_PANED (paned->paned[position]);
+    return MOO_INTERNAL_PANED (paned->paned[position]);
 }
 
 
-MooPane *
-moo_big_paned_find_pane (MooBigPaned    *paned,
+MooInternalPane *
+moo_big_paned_find_pane (MooInternalBigPaned    *paned,
                          GtkWidget      *widget,
-                         MooPaned      **child_paned)
+                         MooInternalPaned      **child_paned)
 {
     int i;
-    MooPane *pane;
+    MooInternalPane *pane;
 
     g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
     g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
 
     for (i = 0; i < 4; ++i)
     {
-        pane = moo_paned_get_pane (MOO_PANED (paned->paned[i]), widget);
+        pane = moo_paned_get_pane (MOO_INTERNAL_PANED (paned->paned[i]), widget);
 
         if (pane)
         {
             if (child_paned)
-                *child_paned = MOO_PANED (paned->paned[i]);
+                *child_paned = MOO_INTERNAL_PANED (paned->paned[i]);
             return pane;
         }
     }
                             const GValue *value,
                             GParamSpec   *pspec)
 {
-    MooBigPaned *paned = MOO_BIG_PANED (object);
+    MooInternalBigPaned *paned = MOO_INTERNAL_BIG_PANED (object);
     int i;
 
     switch (prop_id)
                             GValue     *value,
                             GParamSpec *pspec)
 {
-    MooBigPaned *paned = MOO_BIG_PANED (object);
+    MooInternalBigPaned *paned = MOO_INTERNAL_BIG_PANED (object);
     GdkCursorType cursor_type;
 
     switch (prop_id)
 
 
 GtkWidget *
-moo_big_paned_get_pane (MooBigPaned    *paned,
-                        MooPanePosition position,
+moo_big_paned_get_pane (MooInternalBigPaned    *paned,
+                        MooInternalPanePosition position,
                         int             index_)
 {
     g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
     g_return_val_if_fail (position < 4, NULL);
-    return moo_pane_get_child (moo_paned_get_nth_pane (MOO_PANED (paned->paned[position]), index_));
+    return moo_pane_get_child (moo_paned_get_nth_pane (MOO_INTERNAL_PANED (paned->paned[position]), index_));
 }
 
 
 /* rearranging panes
  */
 
-static void         create_drop_outline     (MooBigPaned    *paned);
-static void         get_drop_area           (MooBigPaned    *paned,
-                                             MooPaned       *active_child,
-                                             MooPanePosition position,
+static void         create_drop_outline     (MooInternalBigPaned    *paned);
+static void         get_drop_area           (MooInternalBigPaned    *paned,
+                                             MooInternalPaned       *active_child,
+                                             MooInternalPanePosition position,
                                              int             index,
                                              GdkRectangle   *rect,
                                              GdkRectangle   *button_rect);
-// static void         invalidate_drop_outline (MooBigPaned    *paned);
+// static void         invalidate_drop_outline (MooInternalBigPaned    *paned);
 
 
 static GdkRegion *
 #define BOTTOM(rect) ((rect).y + (rect).height - 1)
 
 static void
-get_drop_zones (MooBigPaned *paned)
+get_drop_zones (MooInternalBigPaned *paned)
 {
     int pos;
     GdkRectangle parent;
 
     for (pos = 0; pos < 4; ++pos)
     {
-        bbox_size[pos] = moo_paned_get_button_box_size (MOO_PANED (paned->paned[pos]));
+        bbox_size[pos] = moo_paned_get_button_box_size (MOO_INTERNAL_PANED (paned->paned[pos]));
         if (bbox_size[pos] <= 0)
             bbox_size[pos] = 30;
         paned->priv->dz[pos].bbox_size = bbox_size[pos];
     parent = paned->priv->outer->allocation;
 
     child_rect = parent;
-    child_rect.x += bbox_size[MOO_PANE_POS_LEFT];
-    child_rect.width -= bbox_size[MOO_PANE_POS_LEFT] +
-                        bbox_size[MOO_PANE_POS_RIGHT];
-    child_rect.y += bbox_size[MOO_PANE_POS_TOP];
-    child_rect.height -= bbox_size[MOO_PANE_POS_TOP] +
-                         bbox_size[MOO_PANE_POS_BOTTOM];
+    child_rect.x += bbox_size[MOO_INTERNAL_PANE_POS_LEFT];
+    child_rect.width -= bbox_size[MOO_INTERNAL_PANE_POS_LEFT] +
+                        bbox_size[MOO_INTERNAL_PANE_POS_RIGHT];
+    child_rect.y += bbox_size[MOO_INTERNAL_PANE_POS_TOP];
+    child_rect.height -= bbox_size[MOO_INTERNAL_PANE_POS_TOP] +
+                         bbox_size[MOO_INTERNAL_PANE_POS_BOTTOM];
 
     button_rect = parent;
-    button_rect.x += 2*bbox_size[MOO_PANE_POS_LEFT];
-    button_rect.width -= 2*bbox_size[MOO_PANE_POS_LEFT] +
-                         2*bbox_size[MOO_PANE_POS_RIGHT];
-    button_rect.y += 2*bbox_size[MOO_PANE_POS_TOP];
-    button_rect.height -= 2*bbox_size[MOO_PANE_POS_TOP] +
-                          2*bbox_size[MOO_PANE_POS_BOTTOM];
+    button_rect.x += 2*bbox_size[MOO_INTERNAL_PANE_POS_LEFT];
+    button_rect.width -= 2*bbox_size[MOO_INTERNAL_PANE_POS_LEFT] +
+                         2*bbox_size[MOO_INTERNAL_PANE_POS_RIGHT];
+    button_rect.y += 2*bbox_size[MOO_INTERNAL_PANE_POS_TOP];
+    button_rect.height -= 2*bbox_size[MOO_INTERNAL_PANE_POS_TOP] +
+                          2*bbox_size[MOO_INTERNAL_PANE_POS_BOTTOM];
 
     drop_rect = button_rect;
     drop_rect.x += button_rect.width / 3;
     drop_rect.width -= 2 * button_rect.width / 3;
     drop_rect.height -= 2 * button_rect.height / 3;
 
-    paned->priv->dz[MOO_PANE_POS_TOP].bbox_region =
+    paned->priv->dz[MOO_INTERNAL_PANE_POS_TOP].bbox_region =
         region_6 (LEFT (child_rect), TOP (parent),
                   RIGHT (child_rect), TOP (parent),
                   RIGHT (child_rect), TOP (child_rect),
                   RIGHT (button_rect), TOP (button_rect),
                   LEFT (button_rect), TOP (button_rect),
                   LEFT (child_rect), TOP (child_rect));
-    paned->priv->dz[MOO_PANE_POS_TOP].def_region =
+    paned->priv->dz[MOO_INTERNAL_PANE_POS_TOP].def_region =
         region_4 (LEFT (button_rect), TOP (button_rect),
                   RIGHT (button_rect), TOP (button_rect),
                   RIGHT (drop_rect), TOP (drop_rect),
                   LEFT (drop_rect), TOP (drop_rect));
 
-    paned->priv->dz[MOO_PANE_POS_LEFT].bbox_region =
+    paned->priv->dz[MOO_INTERNAL_PANE_POS_LEFT].bbox_region =
         region_6 (LEFT (parent), TOP (child_rect),
                   LEFT (child_rect), TOP (child_rect),
                   LEFT (button_rect), TOP (button_rect),
                   LEFT (button_rect), BOTTOM (button_rect),
                   LEFT (child_rect), BOTTOM (child_rect),
                   LEFT (parent), BOTTOM (child_rect));
-    paned->priv->dz[MOO_PANE_POS_LEFT].def_region =
+    paned->priv->dz[MOO_INTERNAL_PANE_POS_LEFT].def_region =
         region_4 (LEFT (button_rect), TOP (button_rect),
                   LEFT (drop_rect), TOP (drop_rect),
                   LEFT (drop_rect), BOTTOM (drop_rect),
                   LEFT (button_rect), BOTTOM (button_rect));
 
-    paned->priv->dz[MOO_PANE_POS_BOTTOM].bbox_region =
+    paned->priv->dz[MOO_INTERNAL_PANE_POS_BOTTOM].bbox_region =
         region_6 (LEFT (child_rect), BOTTOM (parent),
                   LEFT (child_rect), BOTTOM (child_rect),
                   LEFT (button_rect), BOTTOM (button_rect),
                   RIGHT (button_rect), BOTTOM (button_rect),
                   RIGHT (child_rect), BOTTOM (child_rect),
                   RIGHT (child_rect), BOTTOM (parent));
-    paned->priv->dz[MOO_PANE_POS_BOTTOM].def_region =
+    paned->priv->dz[MOO_INTERNAL_PANE_POS_BOTTOM].def_region =
         region_4 (LEFT (button_rect), BOTTOM (button_rect),
                   LEFT (drop_rect), BOTTOM (drop_rect),
                   RIGHT (drop_rect), BOTTOM (drop_rect),
                   RIGHT (button_rect), BOTTOM (button_rect));
 
-    paned->priv->dz[MOO_PANE_POS_RIGHT].bbox_region =
+    paned->priv->dz[MOO_INTERNAL_PANE_POS_RIGHT].bbox_region =
         region_6 (RIGHT (parent), TOP (child_rect),
                   RIGHT (child_rect), TOP (child_rect),
                   RIGHT (button_rect), TOP (button_rect),
                   RIGHT (button_rect), BOTTOM (button_rect),
                   RIGHT (child_rect), BOTTOM (child_rect),
                   RIGHT (parent), BOTTOM (child_rect));
-    paned->priv->dz[MOO_PANE_POS_RIGHT].def_region =
+    paned->priv->dz[MOO_INTERNAL_PANE_POS_RIGHT].def_region =
         region_4 (RIGHT (button_rect), TOP (button_rect),
                   RIGHT (drop_rect), TOP (drop_rect),
                   RIGHT (drop_rect), BOTTOM (drop_rect),
 
 
 static void
-handle_drag_start (G_GNUC_UNUSED MooPaned *child,
+handle_drag_start (G_GNUC_UNUSED MooInternalPaned *child,
                    G_GNUC_UNUSED GtkWidget *pane_widget,
-                   MooBigPaned *paned)
+                   MooInternalBigPaned *paned)
 {
     g_return_if_fail (GTK_WIDGET_REALIZED (paned->priv->outer));
 
 
 
 static gboolean
-get_new_button_index (MooBigPaned *paned,
-                      MooPaned    *active_child,
+get_new_button_index (MooInternalBigPaned *paned,
+                      MooInternalPaned    *active_child,
                       int          x,
                       int          y)
 {
     int new_button;
-    MooPaned *child;
+    MooInternalPaned *child;
 
     g_assert (paned->priv->drop_pos >= 0);
-    child = MOO_PANED (paned->paned[paned->priv->drop_pos]);
+    child = MOO_INTERNAL_PANED (paned->paned[paned->priv->drop_pos]);
 
     new_button = _moo_paned_get_button (child, x, y,
                                         paned->priv->outer->window);
 }
 
 static void
-get_default_button_index (MooBigPaned *paned,
-                          MooPaned    *active_child)
+get_default_button_index (MooInternalBigPaned *paned,
+                          MooInternalPaned    *active_child)
 {
-    MooPaned *child;
+    MooInternalPaned *child;
 
     g_assert (paned->priv->drop_pos >= 0);
-    child = MOO_PANED (paned->paned[paned->priv->drop_pos]);
+    child = MOO_INTERNAL_PANED (paned->paned[paned->priv->drop_pos]);
 
     if (child == active_child)
         paned->priv->drop_button_index =
 }
 
 static gboolean
-get_new_drop_position (MooBigPaned *paned,
-                       MooPaned    *active_child,
+get_new_drop_position (MooInternalBigPaned *paned,
+                       MooInternalPaned    *active_child,
                        int          x,
                        int          y)
 {
 }
 
 static void
-handle_drag_motion (MooPaned       *child,
+handle_drag_motion (MooInternalPaned       *child,
                     G_GNUC_UNUSED GtkWidget *pane_widget,
-                    MooBigPaned    *paned)
+                    MooInternalBigPaned    *paned)
 {
     int x, y;
 
 
 
 static void
-cleanup_drag (MooBigPaned *paned)
+cleanup_drag (MooInternalBigPaned *paned)
 {
     int pos;
 
 }
 
 static void
-handle_drag_end (MooPaned    *child,
+handle_drag_end (MooInternalPaned    *child,
                  GtkWidget   *pane_widget,
                  gboolean     drop,
-                 MooBigPaned *paned)
+                 MooInternalBigPaned *paned)
 {
     int x, y;
-    MooPanePosition new_pos;
+    MooInternalPanePosition new_pos;
     int new_index;
 
     g_return_if_fail (GTK_WIDGET_REALIZED (paned->priv->outer));
 
 
 static void
-get_drop_area (MooBigPaned    *paned,
-               MooPaned       *active_child,
-               MooPanePosition position,
+get_drop_area (MooInternalBigPaned    *paned,
+               MooInternalPaned       *active_child,
+               MooInternalPanePosition position,
                int             index,
                GdkRectangle   *rect,
                GdkRectangle   *button_rect)
 {
     int width, height, size = 0;
-    MooPanePosition active_position;
+    MooInternalPanePosition active_position;
 
     width = paned->priv->outer->allocation.width;
     height = paned->priv->outer->allocation.height;
     {
         switch (position)
         {
-            case MOO_PANE_POS_LEFT:
-            case MOO_PANE_POS_RIGHT:
+            case MOO_INTERNAL_PANE_POS_LEFT:
+            case MOO_INTERNAL_PANE_POS_RIGHT:
                 size = width / 3;
                 break;
-            case MOO_PANE_POS_TOP:
-            case MOO_PANE_POS_BOTTOM:
+            case MOO_INTERNAL_PANE_POS_TOP:
+            case MOO_INTERNAL_PANE_POS_BOTTOM:
                 size = height / 3;
                 break;
         }
 
     switch (position)
     {
-        case MOO_PANE_POS_LEFT:
-        case MOO_PANE_POS_RIGHT:
+        case MOO_INTERNAL_PANE_POS_LEFT:
+        case MOO_INTERNAL_PANE_POS_RIGHT:
             rect->y = paned->priv->outer->allocation.y;
             rect->width = size;
             rect->height = height;
             break;
-        case MOO_PANE_POS_TOP:
-        case MOO_PANE_POS_BOTTOM:
+        case MOO_INTERNAL_PANE_POS_TOP:
+        case MOO_INTERNAL_PANE_POS_BOTTOM:
             rect->x = paned->priv->outer->allocation.x;
             rect->width = width;
             rect->height = size;
 
     switch (position)
     {
-        case MOO_PANE_POS_LEFT:
+        case MOO_INTERNAL_PANE_POS_LEFT:
             rect->x = paned->priv->outer->allocation.x;
             break;
-        case MOO_PANE_POS_RIGHT:
+        case MOO_INTERNAL_PANE_POS_RIGHT:
             rect->x = paned->priv->outer->allocation.x + width - size;
             break;
-        case MOO_PANE_POS_TOP:
+        case MOO_INTERNAL_PANE_POS_TOP:
             rect->y = paned->priv->outer->allocation.y;
             break;
-        case MOO_PANE_POS_BOTTOM:
+        case MOO_INTERNAL_PANE_POS_BOTTOM:
             rect->y = paned->priv->outer->allocation.y + height - size;
             break;
     }
 
-    _moo_paned_get_button_position (MOO_PANED (paned->paned[position]),
+    _moo_paned_get_button_position (MOO_INTERNAL_PANED (paned->paned[position]),
                                     index, button_rect,
                                     paned->priv->outer->window);
 }
                                  x >= (rect)->x && y >= (rect)->y)
 
 // static int
-// get_drop_position (MooBigPaned *paned,
-//                    MooPaned    *child,
+// get_drop_position (MooInternalBigPaned *paned,
+//                    MooInternalPaned    *child,
 //                    int          x,
 //                    int          y,
 //                    int         *button_index)
 // {
 //     int width, height, i;
-//     MooPanePosition position;
+//     MooInternalPanePosition position;
 //     GdkRectangle rect, button_rect;
 //
 //     *button_index = -1;
 
 
 // static void
-// invalidate_drop_outline (MooBigPaned *paned)
+// invalidate_drop_outline (MooInternalBigPaned *paned)
 // {
 //     GdkRectangle line;
 //     GdkRegion *outline;
 static gboolean
 moo_big_paned_expose (GtkWidget      *widget,
                       GdkEventExpose *event,
-                      MooBigPaned    *paned)
+                      MooInternalBigPaned    *paned)
 {
     GTK_WIDGET_CLASS(G_OBJECT_GET_CLASS (widget))->expose_event (widget, event);
 
 }
 
 static void
-create_drop_outline (MooBigPaned *paned)
+create_drop_outline (MooInternalBigPaned *paned)
 {
     static GdkWindowAttr attributes;
     int attributes_mask;
 #define CONFIG_STRING_MAGIC "mbpconfig-1.0 "
 #define CONFIG_STRING_MAGIC_LEN strlen (CONFIG_STRING_MAGIC)
 
-static MooBigPanedConfig *
+static MooInternalBigPanedConfig *
 config_new (void)
 {
-    MooBigPanedConfig *config;
+    MooInternalBigPanedConfig *config;
     int pos;
 
-    config = g_new0 (MooBigPanedConfig, 1);
+    config = g_new0 (MooInternalBigPanedConfig, 1);
 
     for (pos = 0; pos < 4; pos++)
     {
 }
 
 static void
-config_free (MooBigPanedConfig *config)
+config_free (MooInternalBigPanedConfig *config)
 {
     if (config)
     {
 
 static gboolean
 parse_paned_config (const char     *string,
-                    MooPanedConfig *config)
+                    MooInternalPanedConfig *config)
 {
     char **tokens, **p;
 
 }
 
 static void
-paned_config_serialize (MooPanedConfig *config,
+paned_config_serialize (MooInternalPanedConfig *config,
                         GString        *string)
 {
     GSList *l;
 {
     char **tokens = NULL;
     const char *colon;
-    MooPaneParams params = {{-1, -1, -1, -1}, 0, 0, 0};
+    MooInternalPaneParams params = {{-1, -1, -1, -1}, 0, 0, 0};
     gboolean value[3];
 
     if (!(colon = strchr (string, ':')) || colon == string)
 
 static void
 pane_config_serialize (const char    *id,
-                       MooPaneParams *params,
+                       MooInternalPaneParams *params,
                        GString       *string)
 {
     g_string_append_printf (string, ";%s:%d,%d,%d,%d,%s,%s,%s",
 }
 
 
-static MooBigPanedConfig *
+static MooInternalBigPanedConfig *
 config_parse (const char *string)
 {
-    MooBigPanedConfig *config = NULL;
+    MooInternalBigPanedConfig *config = NULL;
     char **tokens = NULL;
     char **p;
     int pos;
 }
 
 static char *
-config_serialize (MooBigPanedConfig *config)
+config_serialize (MooInternalBigPanedConfig *config)
 {
     GString *string;
     int pos;

contrib/moo/moobigpaned.h

  *   License along with medit.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef MOO_BIG_PANED_H
-#define MOO_BIG_PANED_H
+#ifndef MOO_INTERNAL_BIG_PANED_H
+#define MOO_INTERNAL_BIG_PANED_H
 
 #include <gtk/gtkframe.h>
 #include "moopaned.h"
 G_BEGIN_DECLS
 
 
-#define MOO_TYPE_BIG_PANED              (moo_big_paned_get_type ())
-#define MOO_BIG_PANED(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_BIG_PANED, MooBigPaned))
-#define MOO_BIG_PANED_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_BIG_PANED, MooBigPanedClass))
-#define MOO_IS_BIG_PANED(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_BIG_PANED))
-#define MOO_IS_BIG_PANED_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_BIG_PANED))
-#define MOO_BIG_PANED_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_BIG_PANED, MooBigPanedClass))
+#define MOO_TYPE_INTERNAL_BIG_PANED              (moo_big_paned_get_type ())
+#define MOO_INTERNAL_BIG_PANED(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_INTERNAL_BIG_PANED, MooInternalBigPaned))
+#define MOO_INTERNAL_BIG_PANED_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_INTERNAL_BIG_PANED, MooInternalBigPanedClass))
+#define MOO_IS_BIG_PANED(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_INTERNAL_BIG_PANED))
+#define MOO_IS_BIG_PANED_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_INTERNAL_BIG_PANED))
+#define MOO_INTERNAL_BIG_PANED_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_INTERNAL_BIG_PANED, MooInternalBigPanedClass))
 
 
-typedef struct MooBigPaned        MooBigPaned;
-typedef struct MooBigPanedPrivate MooBigPanedPrivate;
-typedef struct MooBigPanedClass   MooBigPanedClass;
+typedef struct MooInternalBigPaned        MooInternalBigPaned;
+typedef struct MooInternalBigPanedPrivate MooInternalBigPanedPrivate;
+typedef struct MooInternalBigPanedClass   MooInternalBigPanedClass;
 
-struct MooBigPaned
+struct MooInternalBigPaned
 {
     GtkFrame base;
-    MooBigPanedPrivate *priv;
+    MooInternalBigPanedPrivate *priv;
     GtkWidget *paned[4]; /* indexed by PanePos */
 };
 
-struct MooBigPanedClass
+struct MooInternalBigPanedClass
 {
     GtkFrameClass base_class;
 };
 
 GtkWidget      *moo_big_paned_new               (void);
 
-void            moo_big_paned_set_pane_order    (MooBigPaned    *paned,
+void            moo_big_paned_set_pane_order    (MooInternalBigPaned    *paned,
                                                  int            *order);
-void            moo_big_paned_set_config        (MooBigPaned    *paned,
+void            moo_big_paned_set_config        (MooInternalBigPaned    *paned,
                                                  const char     *config_string);
-char           *moo_big_paned_get_config        (MooBigPaned    *paned);
+char           *moo_big_paned_get_config        (MooInternalBigPaned    *paned);
 
-MooPane        *moo_big_paned_find_pane         (MooBigPaned    *paned,
+MooInternalPane        *moo_big_paned_find_pane         (MooInternalBigPaned    *paned,
                                                  GtkWidget      *pane_widget,
-                                                 MooPaned      **child_paned);
+                                                 MooInternalPaned      **child_paned);
 
-void            moo_big_paned_add_child         (MooBigPaned    *paned,
+void            moo_big_paned_add_child         (MooInternalBigPaned    *paned,
                                                  GtkWidget      *widget);
-void            moo_big_paned_remove_child      (MooBigPaned    *paned);
-GtkWidget      *moo_big_paned_get_child         (MooBigPaned    *paned);
+void            moo_big_paned_remove_child      (MooInternalBigPaned    *paned);
+GtkWidget      *moo_big_paned_get_child         (MooInternalBigPaned    *paned);
 
-MooPane        *moo_big_paned_insert_pane       (MooBigPaned    *paned,
+MooInternalPane        *moo_big_paned_insert_pane       (MooInternalBigPaned    *paned,
                                                  GtkWidget      *pane_widget,
                                                  const char     *pane_id,
-                                                 MooPaneLabel   *pane_label,
-                                                 MooPanePosition position,
+                                                 MooInternalPaneLabel   *pane_label,
+                                                 MooInternalPanePosition position,
                                                  int             index_);
-gboolean        moo_big_paned_remove_pane       (MooBigPaned    *paned,
+gboolean        moo_big_paned_remove_pane       (MooInternalBigPaned    *paned,
                                                  GtkWidget      *pane_widget);
-MooPane        *moo_big_paned_lookup_pane       (MooBigPaned    *paned,
+MooInternalPane        *moo_big_paned_lookup_pane       (MooInternalBigPaned    *paned,
                                                  const char     *pane_id);
 
-GtkWidget      *moo_big_paned_get_pane          (MooBigPaned    *paned,
-                                                 MooPanePosition position,
+GtkWidget      *moo_big_paned_get_pane          (MooInternalBigPaned    *paned,
+                                                 MooInternalPanePosition position,
                                                  int             index_);
-void            moo_big_paned_reorder_pane      (MooBigPaned    *paned,
+void            moo_big_paned_reorder_pane      (MooInternalBigPaned    *paned,
                                                  GtkWidget      *pane_widget,
-                                                 MooPanePosition new_position,
+                                                 MooInternalPanePosition new_position,
                                                  int             new_index);
 
-MooPaned       *moo_big_paned_get_paned         (MooBigPaned    *paned,
-                                                 MooPanePosition position);
+MooInternalPaned       *moo_big_paned_get_paned         (MooInternalBigPaned    *paned,
+                                                 MooInternalPanePosition position);
 
-void            moo_big_paned_open_pane         (MooBigPaned    *paned,
+void            moo_big_paned_open_pane         (MooInternalBigPaned    *paned,
                                                  GtkWidget      *pane_widget);
-void            moo_big_paned_hide_pane         (MooBigPaned    *paned,
+void            moo_big_paned_hide_pane         (MooInternalBigPaned    *paned,
                                                  GtkWidget      *pane_widget);
-void            moo_big_paned_present_pane      (MooBigPaned    *paned,
+void            moo_big_paned_present_pane      (MooInternalBigPaned    *paned,
                                                  GtkWidget      *pane_widget);
-void            moo_big_paned_attach_pane       (MooBigPaned    *paned,
+void            moo_big_paned_attach_pane       (MooInternalBigPaned    *paned,
                                                  GtkWidget      *pane_widget);
-void            moo_big_paned_detach_pane       (MooBigPaned    *paned,
+void            moo_big_paned_detach_pane       (MooInternalBigPaned    *paned,
                                                  GtkWidget      *pane_widget);
 
 
 G_END_DECLS
 
-#endif /* MOO_BIG_PANED_H */
+#endif /* MOO_INTERNAL_BIG_PANED_H */

contrib/moo/moopane.c

 #endif
 
 
-struct MooPane {
+struct MooInternalPane {
     GtkObject base;
 
     char         *id;
-    MooPaned     *parent;
+    MooInternalPaned     *parent;
     GtkWidget    *child;
 
     GtkWidget    *child_holder;
-    MooPaneLabel *label;
+    MooInternalPaneLabel *label;
     GtkWidget    *frame;
     GtkWidget    *handle;
     GtkWidget    *small_handle;
     GtkWidget    *keep_on_top_button;
     GtkWidget    *window_child_holder;
 
-    MooPaneParams *params;
+    MooInternalPaneParams *params;
 
     guint         open_timeout;
     guint         button_highlight : 1;
     guint         params_changed_blocked : 1;
 };
 
-struct MooPaneClass {
+struct MooInternalPaneClass {
     GtkObjectClass base_class;
-    gboolean (*remove) (MooPane *pane);
+    gboolean (*remove) (MooInternalPane *pane);
 };
 
-G_DEFINE_TYPE (MooPane, moo_pane, GTK_TYPE_OBJECT)
+G_DEFINE_TYPE (MooInternalPane, moo_pane, GTK_TYPE_OBJECT)
 
 enum {
     PROP_0,
 
 
 static void
-set_pane_window_icon_and_title (MooPane *pane)
+set_pane_window_icon_and_title (MooInternalPane *pane)
 {
     if (pane->window && pane->label)
     {
 }
 
 static void
-update_label_widgets (MooPane *pane)
+update_label_widgets (MooInternalPane *pane)
 {
     if (pane->label && pane->label_widget)
     {
 }
 
 void
-moo_pane_set_label (MooPane      *pane,
-                    MooPaneLabel *label)
+moo_pane_set_label (MooInternalPane      *pane,
+                    MooInternalPaneLabel *label)
 {
-    MooPaneLabel *tmp;
+    MooInternalPaneLabel *tmp;
 
     g_return_if_fail (MOO_IS_PANE (pane));
     g_return_if_fail (label != NULL);
 }
 
 
-MooPaneParams *
-moo_pane_get_params (MooPane *pane)
+MooInternalPaneParams *
+moo_pane_get_params (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
     return moo_pane_params_copy (pane->params);
 }
 
-MooPaneLabel *
-moo_pane_get_label (MooPane *pane)
+MooInternalPaneLabel *
+moo_pane_get_label (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
     return moo_pane_label_copy (pane->label);
 
 
 void
-moo_pane_set_params (MooPane       *pane,
-                     MooPaneParams *params)
+moo_pane_set_params (MooInternalPane       *pane,
+                     MooInternalPaneParams *params)
 {
-    MooPaneParams *old_params;
+    MooInternalPaneParams *old_params;
 
     g_return_if_fail (MOO_IS_PANE (pane));
     g_return_if_fail (params != NULL);
 
 
 void
-moo_pane_set_detachable (MooPane  *pane,
+moo_pane_set_detachable (MooInternalPane  *pane,
                          gboolean  detachable)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
 
 
 void
-moo_pane_set_removable (MooPane  *pane,
+moo_pane_set_removable (MooInternalPane  *pane,
                         gboolean  removable)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
 
 
 gboolean
-moo_pane_get_detachable (MooPane *pane)
+moo_pane_get_detachable (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
     return pane->detachable;
 }
 
 gboolean
-moo_pane_get_removable (MooPane *pane)
+moo_pane_get_removable (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
     return pane->removable;
                        const GValue *value,
                        GParamSpec   *pspec)
 {
-    MooPane *pane = MOO_PANE (object);
+    MooInternalPane *pane = MOO_INTERNAL_PANE (object);
 
     switch (prop_id)
     {
                        GValue     *value,
                        GParamSpec *pspec)
 {
-    MooPane *pane = MOO_PANE (object);
+    MooInternalPane *pane = MOO_INTERNAL_PANE (object);
 
     switch (prop_id)
     {
 
 
 static void
-moo_pane_init (MooPane *pane)
+moo_pane_init (MooInternalPane *pane)
 {
     pane->detachable = TRUE;
     pane->removable = TRUE;
 static void
 moo_pane_finalize (GObject *object)
 {
-    MooPane *pane = MOO_PANE (object);
+    MooInternalPane *pane = MOO_INTERNAL_PANE (object);
 
     g_free (pane->id);
     moo_pane_label_free (pane->label);
 static void
 moo_pane_dispose (GObject *object)
 {
-    MooPane *pane = MOO_PANE (object);
+    MooInternalPane *pane = MOO_INTERNAL_PANE (object);
 
     if (pane->child)
     {
 }
 
 static void
-moo_pane_class_init (MooPaneClass *klass)
+moo_pane_class_init (MooInternalPaneClass *klass)
 {
     GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 
 
     g_object_class_install_property (gobject_class, PROP_LABEL,
         g_param_spec_boxed ("label", "label", "label",
-                            MOO_TYPE_PANE_LABEL, G_PARAM_READWRITE));
+                            MOO_TYPE_INTERNAL_PANE_LABEL, G_PARAM_READWRITE));
 
     g_object_class_install_property (gobject_class, PROP_PARAMS,
         g_param_spec_boxed ("params", "params", "params",
-                            MOO_TYPE_PANE_PARAMS, G_PARAM_READWRITE));
+                            MOO_TYPE_INTERNAL_PANE_PARAMS, G_PARAM_READWRITE));
 
     g_object_class_install_property (gobject_class, PROP_DETACHABLE,
         g_param_spec_boolean ("detachable", "detachable", "detachable",
             g_signal_new ("remove",
                           G_OBJECT_CLASS_TYPE (klass),
                           G_SIGNAL_RUN_LAST,
-                          G_STRUCT_OFFSET (MooPaneClass, remove),
+                          G_STRUCT_OFFSET (MooInternalPaneClass, remove),
                           g_signal_accumulator_true_handled, NULL,
                           _moo_marshal_BOOL__VOID,
                           G_TYPE_BOOLEAN, 0);
 
 
 static void
-close_button_clicked (MooPane *pane)
+close_button_clicked (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     if (pane->parent)
 }
 
 static void
-hide_button_clicked (MooPane *pane)
+hide_button_clicked (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     if (pane->parent)
 }
 
 static void
-attach_button_clicked (MooPane *pane)
+attach_button_clicked (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     if (pane->parent)
 }
 
 static void
-detach_button_clicked (MooPane *pane)
+detach_button_clicked (MooInternalPane *pane)
 {
     moo_paned_detach_pane (pane->parent, pane);
 }
 
 static void
 sticky_button_toggled (GtkToggleButton *button,
-                       MooPane         *pane)
+                       MooInternalPane         *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     moo_paned_set_sticky_pane (pane->parent, gtk_toggle_button_get_active (button));
 
 
 static void
-update_sticky_button (MooPane *pane)
+update_sticky_button (MooInternalPane *pane)
 {
     if (pane->parent)
     {
 
 
 void
-moo_pane_set_frame_markup (MooPane    *pane,
+moo_pane_set_frame_markup (MooInternalPane    *pane,
                            const char *text)
 {
     char *tmp;
 }
 
 void
-moo_pane_set_frame_text (MooPane    *pane,
+moo_pane_set_frame_text (MooInternalPane    *pane,
                          const char *text)
 {
     char *tmp;
 
 
 static GtkWidget *
-create_button (MooPane      *pane,
+create_button (MooInternalPane      *pane,
                GtkWidget    *toolbar,
                const char   *tip,
                gboolean      toggle,
 }
 
 static GtkWidget *
-create_frame_widget (MooPane        *pane,
-                     MooPanePosition position,
+create_frame_widget (MooInternalPane        *pane,
+                     MooInternalPanePosition position,
                      gboolean        embedded)
 {
     GtkWidget *vbox, *toolbar, *separator, *handle, *table, *child_holder;
 
     switch (position)
     {
-        case MOO_PANE_POS_LEFT:
-        case MOO_PANE_POS_RIGHT:
+        case MOO_INTERNAL_PANE_POS_LEFT:
+        case MOO_INTERNAL_PANE_POS_RIGHT:
             separator = gtk_vseparator_new ();
             break;
-        case MOO_PANE_POS_TOP:
-        case MOO_PANE_POS_BOTTOM:
+        case MOO_INTERNAL_PANE_POS_TOP:
+        case MOO_INTERNAL_PANE_POS_BOTTOM:
             separator = gtk_hseparator_new ();
             break;
     }
 
     switch (position)
     {
-        case MOO_PANE_POS_LEFT:
+        case MOO_INTERNAL_PANE_POS_LEFT:
             gtk_table_attach (GTK_TABLE (table), separator,
                               0, 1, 0, 1,
                               0, GTK_FILL, 0, 0);
                               1, 2, 0, 1,
                               GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
             break;
-        case MOO_PANE_POS_TOP:
+        case MOO_INTERNAL_PANE_POS_TOP:
             gtk_table_attach (GTK_TABLE (table), separator,
                               0, 1, 0, 1,
                               0, GTK_FILL, 0, 0);
                               0, 1, 1, 2,
                               GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
             break;
-        case MOO_PANE_POS_RIGHT:
+        case MOO_INTERNAL_PANE_POS_RIGHT:
             gtk_table_attach (GTK_TABLE (table), separator,
                               1, 2, 0, 1,
                               0, GTK_FILL, 0, 0);
                               0, 1, 0, 1,
                               GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
             break;
-        case MOO_PANE_POS_BOTTOM:
+        case MOO_INTERNAL_PANE_POS_BOTTOM:
             gtk_table_attach (GTK_TABLE (table), separator,
                               0, 1, 1, 2,
                               0, GTK_FILL, 0, 0);
 }
 
 static GtkWidget *
-create_label_widget (MooPanePosition position,
+create_label_widget (MooInternalPanePosition position,
                      GtkWidget     **label_widget,
                      GtkWidget     **icon_widget)
 {
 
     switch (position)
     {
-        case MOO_PANE_POS_LEFT:
+        case MOO_INTERNAL_PANE_POS_LEFT:
             gtk_label_set_angle (GTK_LABEL (*label_widget), 90);
             break;
-        case MOO_PANE_POS_RIGHT:
+        case MOO_INTERNAL_PANE_POS_RIGHT:
             gtk_label_set_angle (GTK_LABEL (*label_widget), 270);
             break;
         default:
 
     switch (position)
     {
-        case MOO_PANE_POS_LEFT:
-        case MOO_PANE_POS_RIGHT:
+        case MOO_INTERNAL_PANE_POS_LEFT:
+        case MOO_INTERNAL_PANE_POS_RIGHT:
             box = gtk_vbox_new (FALSE, SPACING_IN_BUTTON);
             break;
         default:
 
     switch (position)
     {
-        case MOO_PANE_POS_LEFT:
+        case MOO_INTERNAL_PANE_POS_LEFT:
             gtk_box_pack_start (GTK_BOX (box), *label_widget, FALSE, FALSE, 0);
             gtk_box_pack_start (GTK_BOX (box), *icon_widget, FALSE, FALSE, 0);
             break;
 
 
 static void
-paned_enable_detaching_notify (MooPane *pane)
+paned_enable_detaching_notify (MooInternalPane *pane)
 {
     gboolean enable;
     g_object_get (pane->parent, "enable-detaching", &enable, NULL);
 }
 
 static void
-paned_sticky_pane_notify (MooPane *pane)
+paned_sticky_pane_notify (MooInternalPane *pane)
 {
     update_sticky_button (pane);
 }
 button_drag_leave (GtkWidget      *button,
                    G_GNUC_UNUSED GdkDragContext *context,
                    G_GNUC_UNUSED guint time,
-                   MooPane        *pane)
+                   MooInternalPane        *pane)
 {
     if (pane->open_timeout)
         g_source_remove (pane->open_timeout);
 }
 
 static gboolean
-drag_open_pane (MooPane *pane)
+drag_open_pane (MooInternalPane *pane)
 {
     moo_pane_open (pane);
 
                     G_GNUC_UNUSED int x,
                     G_GNUC_UNUSED int y,
                     guint           time,
-                    MooPane        *pane)
+                    MooInternalPane        *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
 
 }
 
 static void
-setup_button_dnd (MooPane *pane)
+setup_button_dnd (MooInternalPane *pane)
 {
     gtk_drag_dest_set (pane->button, 0, NULL, 0, GDK_ACTION_COPY | GDK_ACTION_MOVE);
     g_signal_connect (pane->button, "drag-motion",
 }
 
 void
-moo_pane_set_drag_dest (MooPane *pane)
+moo_pane_set_drag_dest (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
 
 }
 
 void
-moo_pane_unset_drag_dest (MooPane *pane)
+moo_pane_unset_drag_dest (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
 
 
 
 static void
-create_widgets (MooPane         *pane,
-                MooPanePosition  position,
+create_widgets (MooInternalPane         *pane,
+                MooInternalPanePosition  position,
                 GdkWindow       *pane_window)
 {
     GtkWidget *label;
                       G_CALLBACK (sticky_button_toggled), pane);
 }
 
-MooPane *
+MooInternalPane *
 _moo_pane_new (GtkWidget    *child,
-               MooPaneLabel *label)
+               MooInternalPaneLabel *label)
 {
-    MooPane *pane;
+    MooInternalPane *pane;
 
     g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
 
-    pane = g_object_new (MOO_TYPE_PANE, NULL);
+    pane = g_object_new (MOO_TYPE_INTERNAL_PANE, NULL);
     pane->child = g_object_ref (child);
     gtk_widget_show (pane->child);
     g_object_set_data (G_OBJECT (pane->child), "moo-pane", pane);
 }
 
 const char *
-moo_pane_get_id (MooPane *pane)
+moo_pane_get_id (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
     return pane->id;
 }
 
 void
-_moo_pane_set_id (MooPane    *pane,
+_moo_pane_set_id (MooInternalPane    *pane,
                   const char *id)
 {
     char *tmp;
 }
 
 void
-_moo_pane_set_parent (MooPane   *pane,
+_moo_pane_set_parent (MooInternalPane   *pane,
                       gpointer   parent,
                       GdkWindow *pane_window)
 {
 
 
 void
-_moo_pane_size_request (MooPane        *pane,
+_moo_pane_size_request (MooInternalPane        *pane,
                         GtkRequisition *req)
 {
     g_return_if_fail (MOO_IS_PANE (pane) && pane->frame != NULL);
 }
 
 void
-_moo_pane_size_allocate (MooPane       *pane,
+_moo_pane_size_allocate (MooInternalPane       *pane,
                          GtkAllocation *allocation)
 {
     g_return_if_fail (MOO_IS_PANE (pane) && pane->frame != NULL);
 }
 
 void
-_moo_pane_get_size_request (MooPane        *pane,
+_moo_pane_get_size_request (MooInternalPane        *pane,
                             GtkRequisition *req)
 {
     g_return_if_fail (MOO_IS_PANE (pane) && pane->frame != NULL);
 }
 
 GtkWidget *
-_moo_pane_get_frame (MooPane *pane)
+_moo_pane_get_frame (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
     return pane->frame;
 }
 
 GtkWidget *
-_moo_pane_get_focus_child (MooPane *pane)
+_moo_pane_get_focus_child (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
     return pane->focus_child;
 }
 
 GtkWidget *
-_moo_pane_get_button (MooPane *pane)
+_moo_pane_get_button (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
     return pane->button;
 }
 
 void
-_moo_pane_get_handle (MooPane    *pane,
+_moo_pane_get_handle (MooInternalPane    *pane,
                       GtkWidget **big,
                       GtkWidget **small)
 {
 }
 
 GtkWidget *
-_moo_pane_get_window (MooPane *pane)
+_moo_pane_get_window (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
     return pane->window;
 }
 
 GtkWidget *
-moo_pane_get_child (MooPane *pane)
+moo_pane_get_child (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
     return pane->child;
 }
 
 gpointer
-_moo_pane_get_parent (MooPane *pane)
+_moo_pane_get_parent (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
     return pane->parent;
 
 
 void
-_moo_pane_params_changed (MooPane *pane)
+_moo_pane_params_changed (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     if (!pane->params_changed_blocked)
 }
 
 void
-_moo_pane_freeze_params (MooPane *pane)
+_moo_pane_freeze_params (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     pane->params_changed_blocked = TRUE;
 }
 
 void
-_moo_pane_thaw_params (MooPane *pane)
+_moo_pane_thaw_params (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     pane->params_changed_blocked = FALSE;
 }
 
 gboolean
-_moo_pane_get_detached (MooPane *pane)
+_moo_pane_get_detached (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
     return pane->params->detached;
 
 
 void
-_moo_pane_unparent (MooPane *pane)
+_moo_pane_unparent (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
 
 }
 
 void
-_moo_pane_update_focus_child (MooPane *pane)
+_moo_pane_update_focus_child (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
 
 
 
 static gboolean
-pane_window_delete_event (MooPane *pane)
+pane_window_delete_event (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
     moo_paned_attach_pane (pane->parent, pane);
 
 static void
 keep_on_top_button_toggled (GtkToggleButton *button,
-                            MooPane         *pane)
+                            MooInternalPane         *pane)
 {
     gboolean active;
 
 static gboolean
 pane_window_configure (GtkWidget         *window,
                        GdkEventConfigure *event,
-                       MooPane           *pane)
+                       MooInternalPane           *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
     g_return_val_if_fail (pane->window == window, FALSE);
 }
 
 static void
-create_pane_window (MooPane *pane)
+create_pane_window (MooInternalPane *pane)
 {
     int width = -1;
     int height = -1;
 
     switch (_moo_paned_get_position (pane->parent))
     {
-        case MOO_PANE_POS_LEFT:
-        case MOO_PANE_POS_RIGHT:
+        case MOO_INTERNAL_PANE_POS_LEFT:
+        case MOO_INTERNAL_PANE_POS_RIGHT:
             width = moo_paned_get_pane_size (pane->parent);
             height = GTK_WIDGET(pane->parent)->allocation.height;
             break;
-        case MOO_PANE_POS_TOP:
-        case MOO_PANE_POS_BOTTOM:
+        case MOO_INTERNAL_PANE_POS_TOP:
+        case MOO_INTERNAL_PANE_POS_BOTTOM:
             height = moo_paned_get_pane_size (pane->parent);
             width = GTK_WIDGET(pane->parent)->allocation.width;
             break;
 }
 
 void
-_moo_pane_detach (MooPane *pane)
+_moo_pane_detach (MooInternalPane *pane)
 {
     gboolean visible;
 
 
 
 void
-_moo_pane_attach (MooPane *pane)
+_moo_pane_attach (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
 
 
 
 void
-_moo_pane_try_remove (MooPane *pane)
+_moo_pane_try_remove (MooInternalPane *pane)
 {
     gboolean ret;
 
 
 
 void
-moo_pane_open (MooPane *pane)
+moo_pane_open (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     g_return_if_fail (pane->parent != NULL);
 }
 
 void
-moo_pane_present (MooPane *pane)
+moo_pane_present (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     g_return_if_fail (pane->parent != NULL);
 }
 
 void
-moo_pane_attach (MooPane *pane)
+moo_pane_attach (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     g_return_if_fail (pane->parent != NULL);
 }
 
 void
-moo_pane_detach (MooPane *pane)
+moo_pane_detach (MooInternalPane *pane)
 {
     g_return_if_fail (MOO_IS_PANE (pane));
     g_return_if_fail (pane->parent != NULL);
 
 
 int
-moo_pane_get_index (MooPane *pane)
+moo_pane_get_index (MooInternalPane *pane)
 {
     g_return_val_if_fail (MOO_IS_PANE (pane), -1);
     if (pane->parent)

contrib/moo/moopane.h

  *   License along with medit.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef MOO_PANE_H
-#define MOO_PANE_H
+#ifndef MOO_INTERNAL_PANE_H
+#define MOO_INTERNAL_PANE_H
 
 #include <gtk/gtkwidget.h>
 
 G_BEGIN_DECLS
 
 
-#define MOO_TYPE_PANE               (moo_pane_get_type ())
-#define MOO_PANE(object)            (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_PANE, MooPane))
-#define MOO_PANE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_PANE, MooPaneClass))
-#define MOO_IS_PANE(object)         (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_PANE))
-#define MOO_IS_PANE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_PANE))
-#define MOO_PANE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_PANE, MooPaneClass))
+#define MOO_TYPE_INTERNAL_PANE               (moo_pane_get_type ())
+#define MOO_INTERNAL_PANE(object)            (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_INTERNAL_PANE, MooInternalPane))
+#define MOO_INTERNAL_PANE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_INTERNAL_PANE, MooInternalPaneClass))
+#define MOO_IS_PANE(object)         (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_INTERNAL_PANE))
+#define MOO_IS_PANE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_INTERNAL_PANE))
+#define MOO_INTERNAL_PANE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_INTERNAL_PANE, MooInternalPaneClass))
 
-#define MOO_TYPE_PANE_LABEL         (moo_pane_label_get_type ())
-#define MOO_TYPE_PANE_PARAMS        (moo_pane_params_get_type ())
+#define MOO_TYPE_INTERNAL_PANE_LABEL         (moo_pane_label_get_type ())
+#define MOO_TYPE_INTERNAL_PANE_PARAMS        (moo_pane_params_get_type ())
 
-typedef struct MooPane          MooPane;
-typedef struct MooPaneClass     MooPaneClass;
-typedef struct MooPaneLabel     MooPaneLabel;
-typedef struct MooPaneParams    MooPaneParams;
+typedef struct MooInternalPane          MooInternalPane;
+typedef struct MooInternalPaneClass     MooInternalPaneClass;
+typedef struct MooInternalPaneLabel     MooInternalPaneLabel;
+typedef struct MooInternalPaneParams    MooInternalPaneParams;
 
-struct MooPaneLabel {
+struct MooInternalPaneLabel {
     char *icon_stock_id;
     GdkPixbuf *icon_pixbuf;
     char *label;
     char *window_title;
 };
 
-struct MooPaneParams
+struct MooInternalPaneParams
 {
     GdkRectangle window_position;
     guint detached : 1;
 GType           moo_pane_label_get_type     (void) G_GNUC_CONST;
 GType           moo_pane_params_get_type    (void) G_GNUC_CONST;
 
-const char     *moo_pane_get_id             (MooPane        *pane);
+const char     *moo_pane_get_id             (MooInternalPane        *pane);
 
-void            moo_pane_set_label          (MooPane        *pane,
-                                             MooPaneLabel   *label);
+void            moo_pane_set_label          (MooInternalPane        *pane,
+                                             MooInternalPaneLabel   *label);
 /* result must be freed with moo_pane_label_free() */
-MooPaneLabel   *moo_pane_get_label          (MooPane        *pane);
-void            moo_pane_set_frame_markup   (MooPane        *pane,
+MooInternalPaneLabel   *moo_pane_get_label          (MooInternalPane        *pane);
+void            moo_pane_set_frame_markup   (MooInternalPane        *pane,
                                              const char     *markup);
-void            moo_pane_set_frame_text     (MooPane        *pane,
+void            moo_pane_set_frame_text     (MooInternalPane        *pane,
                                              const char     *text);
-void            moo_pane_set_params         (MooPane        *pane,
-                                             MooPaneParams  *params);
+void            moo_pane_set_params         (MooInternalPane        *pane,
+                                             MooInternalPaneParams  *params);
 /* result must be freed with moo_pane_params_free() */
-MooPaneParams  *moo_pane_get_params         (MooPane        *pane);
-void            moo_pane_set_detachable     (MooPane        *pane,
+MooInternalPaneParams  *moo_pane_get_params         (MooInternalPane        *pane);
+void            moo_pane_set_detachable     (MooInternalPane        *pane,
                                              gboolean        detachable);
-gboolean        moo_pane_get_detachable     (MooPane        *pane);
-void            moo_pane_set_removable      (MooPane        *pane,
+gboolean        moo_pane_get_detachable     (MooInternalPane        *pane);
+void            moo_pane_set_removable      (MooInternalPane        *pane,
                                              gboolean        removable);
-gboolean        moo_pane_get_removable      (MooPane        *pane);
+gboolean        moo_pane_get_removable      (MooInternalPane        *pane);
 
-GtkWidget      *moo_pane_get_child          (MooPane        *pane);
-int             moo_pane_get_index          (MooPane        *pane);
+GtkWidget      *moo_pane_get_child          (MooInternalPane        *pane);
+int             moo_pane_get_index          (MooInternalPane        *pane);
 
-void            moo_pane_open               (MooPane        *pane);
-void            moo_pane_present            (MooPane        *pane);
-void            moo_pane_attach             (MooPane        *pane);
-void            moo_pane_detach             (MooPane        *pane);
+void            moo_pane_open               (MooInternalPane        *pane);
+void            moo_pane_present            (MooInternalPane        *pane);
+void            moo_pane_attach             (MooInternalPane        *pane);
+void            moo_pane_detach             (MooInternalPane        *pane);
 
-void            moo_pane_set_drag_dest      (MooPane        *pane);
-void            moo_pane_unset_drag_dest    (MooPane        *pane);
+void            moo_pane_set_drag_dest      (MooInternalPane        *pane);
+void            moo_pane_unset_drag_dest    (MooInternalPane        *pane);
 
-MooPaneParams  *moo_pane_params_new         (GdkRectangle   *window_position,
+MooInternalPaneParams  *moo_pane_params_new         (GdkRectangle   *window_position,
                                              gboolean        detached,
                                              gboolean        maximized,
                                              gboolean        keep_on_top);
-MooPaneParams  *moo_pane_params_copy        (MooPaneParams  *params);
-void            moo_pane_params_free        (MooPaneParams  *params);
+MooInternalPaneParams  *moo_pane_params_copy        (MooInternalPaneParams  *params);
+void            moo_pane_params_free        (MooInternalPaneParams  *params);
 
-MooPaneLabel   *moo_pane_label_new          (const char     *icon_stock_id,
+MooInternalPaneLabel   *moo_pane_label_new          (const char     *icon_stock_id,
                                              GdkPixbuf      *pixbuf,
                                              const char     *label,
                                              const char     *window_title);
-MooPaneLabel   *moo_pane_label_copy         (MooPaneLabel   *label);
-void            moo_pane_label_free         (MooPaneLabel   *label);
+MooInternalPaneLabel   *moo_pane_label_copy         (MooInternalPaneLabel   *label);
+void            moo_pane_label_free         (MooInternalPaneLabel   *label);
 
-MooPane        *_moo_pane_new               (GtkWidget      *child,
-                                             MooPaneLabel   *label);
-void            _moo_pane_set_id            (MooPane        *pane,
+MooInternalPane        *_moo_pane_new               (GtkWidget      *child,
+                                             MooInternalPaneLabel   *label);
+void            _moo_pane_set_id            (MooInternalPane        *pane,
                                              const char     *id);
 
-gpointer        _moo_pane_get_parent        (MooPane        *pane);
-GtkWidget      *_moo_pane_get_frame         (MooPane        *pane);
-void            _moo_pane_update_focus_child (MooPane       *pane);
-GtkWidget      *_moo_pane_get_focus_child   (MooPane        *pane);
-GtkWidget      *_moo_pane_get_button        (MooPane        *pane);
-void            _moo_pane_get_handle        (MooPane        *pane,
+gpointer        _moo_pane_get_parent        (MooInternalPane        *pane);
+GtkWidget      *_moo_pane_get_frame         (MooInternalPane        *pane);
+void            _moo_pane_update_focus_child (MooInternalPane       *pane);
+GtkWidget      *_moo_pane_get_focus_child   (MooInternalPane        *pane);
+GtkWidget      *_moo_pane_get_button        (MooInternalPane        *pane);
+void            _moo_pane_get_handle        (MooInternalPane        *pane,
                                              GtkWidget     **big,
                                              GtkWidget     **small);
-GtkWidget      *_moo_pane_get_window        (MooPane        *pane);
+GtkWidget      *_moo_pane_get_window        (MooInternalPane        *pane);
 
-void            _moo_pane_params_changed    (MooPane        *pane);
-void            _moo_pane_freeze_params     (MooPane        *pane);
-void            _moo_pane_thaw_params       (MooPane        *pane);
-void            _moo_pane_size_request      (MooPane        *pane,