[libgd] Add GdHeaderBar
- From: William Jon McCann <mccann src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [libgd] Add GdHeaderBar
- Date: Sun, 17 Feb 2013 15:12:42 +0000 (UTC)
commit b149a7bb86073b4d09080ad61ed1d83a740cfd46
Author: William Jon McCann <jmccann redhat com>
Date: Sat Feb 16 20:00:10 2013 -0500
Add GdHeaderBar
Makefile.am | 19 +
libgd.m4 | 6 +
libgd/gd-header-bar.c | 952 +++++++++++++++++++++++++++++++++++++++++++++++++
libgd/gd-header-bar.h | 66 ++++
libgd/gd.h | 4 +
5 files changed, 1047 insertions(+), 0 deletions(-)
---
diff --git a/Makefile.am b/Makefile.am
index 12e72b8..45a2f24 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -94,6 +94,25 @@ nodist_libgd_la_SOURCES += $(main_toolbar_sources)
EXTRA_DIST += $(main_toolbar_sources)
endif
+if LIBGD_HEADER_BAR
+header_bar_sources = \
+ libgd/gd-header-bar.c \
+ libgd/gd-header-bar.h \
+ $(NULL)
+
+nodist_libgd_la_SOURCES += $(header_bar_sources)
+EXTRA_DIST += $(header_bar_sources)
+
+noinst_PROGRAMS += test-header-bar
+test_header_bar_SOURCES = \
+ test-header-bar.c \
+ $(NULL)
+test_header_bar_LDADD = \
+ $(LIBGD_LIBS) \
+ libgd.la \
+ $(NULL)
+endif
+
if LIBGD_MARGIN_CONTAINER
margin_container_sources = \
libgd/gd-margin-container.c \
diff --git a/libgd.m4 b/libgd.m4
index 3b76f01..55ecb5f 100644
--- a/libgd.m4
+++ b/libgd.m4
@@ -84,6 +84,12 @@ AC_DEFUN([LIBGD_INIT], [
AC_DEFINE([LIBGD_MAIN_TOOLBAR], [1], [Description])
])
+ # header-bar:
+ AM_CONDITIONAL([LIBGD_HEADER_BAR],[_LIBGD_IF_OPTION_SET([header-bar],[true],[false])])
+ _LIBGD_IF_OPTION_SET([header-bar],[
+ AC_DEFINE([LIBGD_HEADER_BAR], [1], [Description])
+ ])
+
# margin-container:
AM_CONDITIONAL([LIBGD_MARGIN_CONTAINER],[_LIBGD_IF_OPTION_SET([margin-container],[true],[false])])
_LIBGD_IF_OPTION_SET([margin-container],[
diff --git a/libgd/gd-header-bar.c b/libgd/gd-header-bar.c
new file mode 100644
index 0000000..9ac6128
--- /dev/null
+++ b/libgd/gd-header-bar.c
@@ -0,0 +1,952 @@
+/*
+ * Copyright (c) 2013 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include "gd-header-bar.h"
+
+/* TODO
+ * - wm communication
+ */
+#define P_(s) s
+
+#define DEFAULT_SPACING 6
+#define DEFAULT_HPADDING 6
+#define DEFAULT_VPADDING 6
+
+struct _GdHeaderBarPrivate
+{
+ gchar *title;
+ GtkWidget *label;
+ GdkWindow *event_window;
+ gint spacing;
+ gint hpadding;
+ gint vpadding;
+
+ GList *children;
+};
+
+typedef struct _Child Child;
+struct _Child
+{
+ GtkWidget *widget;
+ GtkPackType pack_type;
+};
+
+enum {
+ PROP_0,
+ PROP_TITLE,
+ PROP_SPACING,
+ PROP_HPADDING,
+ PROP_VPADDING
+};
+
+enum {
+ CHILD_PROP_0,
+ CHILD_PROP_PACK_TYPE,
+ CHILD_PROP_POSITION
+};
+
+G_DEFINE_TYPE (GdHeaderBar, gd_header_bar, GTK_TYPE_CONTAINER);
+
+static void
+gd_header_bar_init (GdHeaderBar *bar)
+{
+ GtkStyleContext *context;
+ GdHeaderBarPrivate *priv;
+
+ priv = G_TYPE_INSTANCE_GET_PRIVATE (bar, GTK_TYPE_HEADER_BAR, GdHeaderBarPrivate);
+ bar->priv = priv;
+
+ gtk_widget_set_has_window (GTK_WIDGET (bar), FALSE);
+ gtk_widget_set_redraw_on_allocate (GTK_WIDGET (bar), FALSE);
+
+ priv->label = gtk_label_new ("");
+ gtk_widget_set_parent (priv->label, GTK_WIDGET (bar));
+ gtk_widget_set_valign (priv->label, GTK_ALIGN_CENTER);
+ gtk_label_set_line_wrap (GTK_LABEL (priv->label), FALSE);
+ gtk_label_set_single_line_mode (GTK_LABEL (priv->label), TRUE);
+ gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END);
+ gtk_widget_show (priv->label);
+
+ priv->title = NULL;
+ priv->children = NULL;
+ priv->spacing = DEFAULT_SPACING;
+ priv->hpadding = DEFAULT_HPADDING;
+ priv->vpadding = DEFAULT_VPADDING;
+
+ context = gtk_widget_get_style_context (GTK_WIDGET (bar));
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_TOOLBAR);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_HORIZONTAL);
+}
+
+static gint
+count_visible_children (GdHeaderBar *bar)
+{
+ GList *l;
+ Child *child;
+ gint n;
+
+ n = 0;
+ for (l = bar->priv->children; l; l = l->next)
+ {
+ child = l->data;
+ if (gtk_widget_get_visible (child->widget))
+ n++;
+ }
+
+ return n;
+}
+
+static void
+gd_header_bar_get_size (GtkWidget *widget,
+ GtkOrientation orientation,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (widget);
+ GdHeaderBarPrivate *priv = bar->priv;
+ GList *l;
+ gint nvis_children;
+ gint minimum, natural;
+ gint padding;
+
+ minimum = natural = 0;
+ nvis_children = 0;
+
+ for (l = priv->children; l; l = l->next)
+ {
+ Child *child = l->data;
+
+ if (gtk_widget_get_visible (child->widget))
+ {
+ gint child_minimum, child_natural;
+
+ if (orientation == GTK_ORIENTATION_HORIZONTAL)
+ gtk_widget_get_preferred_width (child->widget,
+ &child_minimum, &child_natural);
+ else
+ gtk_widget_get_preferred_height (child->widget,
+ &child_minimum, &child_natural);
+
+ if (GTK_ORIENTATION_HORIZONTAL == orientation)
+ {
+ minimum += child_minimum;
+ natural += child_natural;
+ }
+ else
+ {
+ minimum = MAX (minimum, child_minimum);
+ natural = MAX (natural, child_natural);
+ }
+ nvis_children += 1;
+ }
+ }
+
+ /* FIXME label size */
+
+ if (nvis_children > 0 && orientation == GTK_ORIENTATION_HORIZONTAL)
+ {
+ minimum += nvis_children * priv->spacing;
+ natural += nvis_children * priv->spacing;
+ }
+
+ if (GTK_ORIENTATION_HORIZONTAL == orientation)
+ padding = priv->hpadding;
+ else
+ padding = priv->vpadding;
+
+ minimum += 2 * padding;
+ natural += 2 * padding;
+
+ if (minimum_size)
+ *minimum_size = minimum;
+
+ if (natural_size)
+ *natural_size = natural;
+}
+
+static void
+gd_header_bar_compute_size_for_orientation (GtkWidget *widget,
+ gint avail_size,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (widget);
+ GdHeaderBarPrivate *priv = bar->priv;
+ GList *children;
+ gint required_size = 0;
+ gint required_natural = 0;
+ gint child_size;
+ gint child_natural;
+ gint nvis_children;
+
+ avail_size -= 2 * priv->vpadding;
+
+ nvis_children = 0;
+
+ for (children = priv->children; children != NULL; children = children->next)
+ {
+ Child *child = children->data;
+
+ if (gtk_widget_get_visible (child->widget))
+ {
+ gtk_widget_get_preferred_width_for_height (child->widget,
+ avail_size, &child_size, &child_natural);
+
+ required_size += child_size;
+ required_natural += child_natural;
+
+ nvis_children += 1;
+ }
+ }
+
+ /* FIXME label size */
+
+ if (nvis_children > 0)
+ {
+ required_size += nvis_children * priv->spacing;
+ required_natural += nvis_children * priv->spacing;
+ }
+
+ required_size += 2 * priv->hpadding;
+ required_natural += 2 * priv->hpadding;
+
+ if (minimum_size)
+ *minimum_size = required_size;
+
+ if (natural_size)
+ *natural_size = required_natural;
+}
+
+static void
+gd_header_bar_compute_size_for_opposing_orientation (GtkWidget *widget,
+ gint avail_size,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (widget);
+ GdHeaderBarPrivate *priv = bar->priv;
+ Child *child;
+ GList *children;
+ gint nvis_children;
+ gint nexpand_children;
+ gint computed_minimum = 0;
+ gint computed_natural = 0;
+ GtkRequestedSize *sizes;
+ GtkPackType packing;
+ gint size;
+ gint extra;
+ gint i;
+ gint child_size;
+ gint child_minimum;
+ gint child_natural;
+ gint n_extra_widgets = 0;
+
+ nvis_children = count_visible_children (bar);
+
+ if (nvis_children <= 0)
+ return;
+
+ sizes = g_newa (GtkRequestedSize, nvis_children);
+ size = avail_size - 2 * priv->hpadding;
+
+ /* Retrieve desired size for visible children */
+ for (i = 0, children = priv->children; children; children = children->next)
+ {
+ child = children->data;
+
+ if (gtk_widget_get_visible (child->widget))
+ {
+ gtk_widget_get_preferred_width (child->widget,
+ &sizes[i].minimum_size,
+ &sizes[i].natural_size);
+
+ size -= sizes[i].minimum_size;
+ sizes[i].data = child;
+ i += 1;
+ }
+ }
+
+ /* Bring children up to size first */
+ size = gtk_distribute_natural_allocation (MAX (0, size), nvis_children, sizes);
+
+ /* Allocate child positions. */
+ for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
+ {
+ for (i = 0, children = priv->children; children; children = children->next)
+ {
+ child = children->data;
+
+ /* If widget is not visible, skip it. */
+ if (!gtk_widget_get_visible (child->widget))
+ continue;
+
+ /* If widget is packed differently skip it, but still increment i,
+ * since widget is visible and will be handled in next loop
+ * iteration.
+ */
+ if (child->pack_type != packing)
+ {
+ i++;
+ continue;
+ }
+
+ child_size = sizes[i].minimum_size;
+
+ gtk_widget_get_preferred_height_for_width (child->widget,
+ child_size, &child_minimum, &child_natural);
+
+ computed_minimum = MAX (computed_minimum, child_minimum);
+ computed_natural = MAX (computed_natural, child_natural);
+ }
+ i += 1;
+ }
+
+ computed_minimum += 2 * priv->vpadding;
+ computed_natural += 2 * priv->vpadding;
+
+ if (minimum_size)
+ *minimum_size = computed_minimum;
+
+ if (natural_size)
+ *natural_size = computed_natural;
+}
+
+static void
+gd_header_bar_get_preferred_width (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ gd_header_bar_get_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
+}
+
+static void
+gd_header_bar_get_preferred_height (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ gd_header_bar_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
+}
+
+static void
+gd_header_bar_get_preferred_width_for_height (GtkWidget *widget,
+ gint height,
+ gint *minimum_width,
+ gint *natural_width)
+{
+ gd_header_bar_compute_size_for_orientation (widget, height, minimum_width, natural_width);
+}
+
+static void
+gd_header_bar_get_preferred_height_for_width (GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height)
+{
+ gd_header_bar_compute_size_for_opposing_orientation (widget, width, minimum_height, natural_height);
+}
+
+static void
+gd_header_bar_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (widget);
+ GdHeaderBarPrivate *priv = bar->priv;
+ GtkRequestedSize *sizes;
+ gint size;
+ gint nvis_children;
+ gint label_minimum_size;
+ gint label_natural_size;
+ gint side[2];
+ GList *l;
+ gint i;
+ Child *child;
+ GtkPackType packing;
+ GtkAllocation child_allocation;
+ gint x;
+ gint child_size;
+ GtkTextDirection direction;
+
+ gtk_widget_set_allocation (widget, allocation);
+
+ direction = gtk_widget_get_direction (widget);
+ nvis_children = count_visible_children (bar);
+ sizes = g_newa (GtkRequestedSize, nvis_children);
+
+ size = allocation->width - nvis_children * priv->spacing - 2 * priv->hpadding;
+ i = 0;
+ for (l = priv->children; l; l = l->next)
+ {
+ child = l->data;
+ if (!gtk_widget_get_visible (child->widget))
+ continue;
+
+ gtk_widget_get_preferred_width_for_height (child->widget,
+ allocation->height - 2 * priv->vpadding,
+ &sizes[i].minimum_size,
+ &sizes[i].natural_size);
+ size -= sizes[i].minimum_size;
+ i++;
+ }
+
+ gtk_widget_get_preferred_width_for_height (priv->label,
+ allocation->height - 2 * priv->vpadding,
+ &label_minimum_size,
+ &label_natural_size);
+ size -= label_natural_size;
+
+ size = gtk_distribute_natural_allocation (MAX (0, size), nvis_children, sizes);
+
+ side[0] = side[1] = 0;
+ for (packing = GTK_PACK_START; packing <= GTK_PACK_END; packing++)
+ {
+ child_allocation.y = allocation->y + priv->vpadding;
+ child_allocation.height = allocation->height - 2 * priv->vpadding;
+ if (packing == GTK_PACK_START)
+ x = allocation->x + priv->hpadding;
+ else
+ x = allocation->x + allocation->width - priv->hpadding;
+
+ i = 0;
+ for (l = priv->children; l; l = l->next)
+ {
+ child = l->data;
+ if (!gtk_widget_get_visible (child->widget))
+ continue;
+
+ if (child->pack_type != packing)
+ {
+ i++;
+ continue;
+ }
+
+ child_size = sizes[i].minimum_size;
+
+ child_allocation.width = child_size;
+
+ if (packing == GTK_PACK_START)
+ {
+ child_allocation.x = x;
+ x += child_size;
+ x += priv->spacing;
+ }
+ else
+ {
+ x -= child_size;
+ child_allocation.x = x;
+ x -= priv->spacing;
+ }
+
+ side[packing] += child_size + priv->spacing;
+
+ if (direction == GTK_TEXT_DIR_RTL)
+ child_allocation.x = allocation->x + allocation->width - (child_allocation.x - allocation->x) -
child_allocation.width;
+
+ gtk_widget_size_allocate (child->widget, &child_allocation);
+ i++;
+ }
+ }
+
+ child_allocation.y = allocation->y + priv->vpadding;
+ child_allocation.height = allocation->height - 2 * priv->vpadding;
+
+ size = MAX(side[0], side[1]);
+
+ if (allocation->width - 2 * size >= label_natural_size)
+ child_size = MIN (label_natural_size, allocation->width - 2 * size);
+ else if (allocation->width - side[0] - side[1] >= label_natural_size)
+ child_size = MIN (label_natural_size, allocation->width - side[0] - side[1]);
+ else
+ child_size = allocation->width - side[0] - side[1];
+
+ child_allocation.x = allocation->x + (allocation->width - child_size) / 2;
+ child_allocation.width = child_size;
+
+ if (allocation->x + side[0] > child_allocation.x)
+ child_allocation.x = allocation->x + side[0];
+ else if (allocation->x + allocation->width - side[1] < child_allocation.x + child_allocation.width)
+ child_allocation.x = allocation->x + allocation->width - side[1] - child_allocation.width;
+
+ if (direction == GTK_TEXT_DIR_RTL)
+ child_allocation.x = allocation->x + allocation->width - (child_allocation.x - allocation->x) -
child_allocation.width;
+
+ gtk_widget_size_allocate (priv->label, &child_allocation);
+}
+
+static void
+gd_header_bar_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (object);
+ GdHeaderBarPrivate *priv = bar->priv;
+
+ switch (prop_id)
+ {
+ case PROP_TITLE:
+ g_value_set_string (value, priv->title);
+ break;
+
+ case PROP_SPACING:
+ g_value_set_int (value, priv->spacing);
+ break;
+
+ case PROP_HPADDING:
+ g_value_set_int (value, priv->hpadding);
+ break;
+
+ case PROP_VPADDING:
+ g_value_set_int (value, priv->vpadding);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+gd_header_bar_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (object);
+ GdHeaderBarPrivate *priv = bar->priv;
+
+ switch (prop_id)
+ {
+ case PROP_TITLE:
+ g_free (priv->title);
+ priv->title = g_value_dup_string (value);
+ gtk_label_set_label (GTK_LABEL (priv->label), priv->title);
+ gtk_widget_queue_resize (GTK_WIDGET (bar));
+ break;
+
+ case PROP_SPACING:
+ priv->spacing = g_value_get_int (value);
+ gtk_widget_queue_resize (GTK_WIDGET (bar));
+ break;
+
+ case PROP_HPADDING:
+ priv->hpadding = g_value_get_int (value);
+ gtk_widget_queue_resize (GTK_WIDGET (bar));
+ break;
+
+ case PROP_VPADDING:
+ priv->vpadding = g_value_get_int (value);
+ gtk_widget_queue_resize (GTK_WIDGET (bar));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gd_header_bar_pack (GdHeaderBar *bar,
+ GtkWidget *widget,
+ GtkPackType pack_type)
+{
+ Child *child;
+
+ g_return_if_fail (gtk_widget_get_parent (widget) == NULL);
+
+ child = g_new (Child, 1);
+ child->widget = widget;
+ child->pack_type = pack_type;
+
+ bar->priv->children = g_list_append (bar->priv->children, child);
+
+ gtk_widget_freeze_child_notify (widget);
+ gtk_widget_set_parent (widget, GTK_WIDGET (bar));
+ gtk_widget_child_notify (widget, "pack-type");
+ gtk_widget_child_notify (widget, "position");
+ gtk_widget_thaw_child_notify (widget);
+}
+
+static void
+gd_header_bar_add (GtkContainer *container,
+ GtkWidget *child)
+{
+ gd_header_bar_pack (GD_HEADER_BAR (container), child, GTK_PACK_START);
+}
+
+static GList *
+find_child_link (GdHeaderBar *bar,
+ GtkWidget *widget)
+{
+ GList *l;
+ Child *child;
+
+ for (l = bar->priv->children; l; l = l->next)
+ {
+ child = l->data;
+ if (child->widget == widget)
+ return l;
+ }
+
+ return NULL;
+}
+
+static void
+gd_header_bar_remove (GtkContainer *container,
+ GtkWidget *widget)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (container);
+ GList *l;
+ Child *child;
+
+ l = find_child_link (bar, widget);
+ if (l)
+ {
+ child = l->data;
+ gtk_widget_unparent (child->widget);
+ bar->priv->children = g_list_remove_link (bar->priv->children, l);
+ g_free (child);
+ gtk_widget_queue_resize (GTK_WIDGET (container));
+ }
+}
+
+static void
+gd_header_bar_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (container);
+ GdHeaderBarPrivate *priv = bar->priv;
+ Child *child;
+ GList *children;
+
+ children = priv->children;
+ while (children)
+ {
+ child = children->data;
+ children = children->next;
+ if (child->pack_type == GTK_PACK_START)
+ (* callback) (child->widget, callback_data);
+ }
+
+ if (include_internals)
+ (* callback) (priv->label, callback_data);
+
+ children = g_list_last (priv->children);
+ while (children)
+ {
+ child = children->data;
+ children = children->prev;
+ if (child->pack_type == GTK_PACK_END)
+ (* callback) (child->widget, callback_data);
+ }
+}
+
+static GType
+gd_header_bar_child_type (GtkContainer *container)
+{
+ return GTK_TYPE_WIDGET;
+}
+
+static void
+gd_header_bar_get_child_property (GtkContainer *container,
+ GtkWidget *widget,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GList *l;
+ Child *child;
+
+ l = find_child_link (GD_HEADER_BAR (container), widget);
+ child = l->data;
+
+ switch (property_id)
+ {
+ case CHILD_PROP_PACK_TYPE:
+ g_value_set_enum (value, child->pack_type);
+ break;
+
+ case CHILD_PROP_POSITION:
+ g_value_set_int (value, g_list_position (GD_HEADER_BAR (container)->priv->children, l));
+ break;
+
+ default:
+ GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
+ break;
+ }
+}
+
+static void
+gd_header_bar_set_child_property (GtkContainer *container,
+ GtkWidget *widget,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GList *l;
+ Child *child;
+
+ l = find_child_link (GD_HEADER_BAR (container), widget);
+ child = l->data;
+
+ switch (property_id)
+ {
+ case CHILD_PROP_PACK_TYPE:
+ child->pack_type = g_value_get_enum (value);
+ break;
+ default:
+ GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
+ break;
+ }
+}
+
+static gboolean
+gd_header_bar_button_press (GtkWidget *toolbar,
+ GdkEventButton *event)
+{
+ GtkWidget *window;
+
+ if (gdk_event_triggers_context_menu ((GdkEvent *) event))
+ {
+
+ /* FIXME menu ? */
+
+ return FALSE;
+ }
+
+ if (event->type != GDK_BUTTON_PRESS)
+ return FALSE;
+
+ window = gtk_widget_get_toplevel (toolbar);
+
+ if (window)
+ {
+ gtk_window_begin_move_drag (GTK_WINDOW (window),
+ event->button,
+ event->x_root,
+ event->y_root,
+ event->time);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+gd_header_bar_realize (GtkWidget *widget)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (widget);
+ GdHeaderBarPrivate *priv = bar->priv;
+ GtkAllocation allocation;
+ GdkWindow *window;
+ GdkWindowAttr attributes;
+ gint attributes_mask;
+
+ gtk_widget_get_allocation (widget, &allocation);
+ gtk_widget_set_realized (widget, TRUE);
+
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.x = allocation.x;
+ attributes.y = allocation.y;
+ attributes.width = allocation.width;
+ attributes.height = allocation.height;
+ attributes.wclass = GDK_INPUT_ONLY;
+ attributes.event_mask = gtk_widget_get_events (widget);
+ attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_TOUCH_MASK);
+ attributes_mask = GDK_WA_X | GDK_WA_Y;
+
+ window = gtk_widget_get_parent_window (widget);
+ gtk_widget_set_window (widget, window);
+ g_object_ref (window);
+
+ priv->event_window = gdk_window_new (window,
+ &attributes, attributes_mask);
+ gdk_window_set_user_data (priv->event_window, widget);
+}
+static void
+gd_header_bar_unrealize (GtkWidget *widget)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (widget);
+ GdHeaderBarPrivate *priv = bar->priv;
+
+ if (priv->event_window)
+ {
+ gdk_window_set_user_data (priv->event_window, NULL);
+ gdk_window_destroy (priv->event_window);
+ priv->event_window = NULL;
+ }
+
+ GTK_WIDGET_CLASS (gd_header_bar_parent_class)->unrealize (widget);
+}
+
+static void
+gd_header_bar_map (GtkWidget *widget)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (widget);
+ GdHeaderBarPrivate *priv = bar->priv;
+
+ GTK_WIDGET_CLASS (gd_header_bar_parent_class)->map (widget);
+
+ if (priv->event_window)
+ gdk_window_show_unraised (priv->event_window);
+}
+
+static void
+gd_header_bar_unmap (GtkWidget *widget)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (widget);
+ GdHeaderBarPrivate *priv = bar->priv;
+
+ if (priv->event_window)
+ gdk_window_hide (priv->event_window);
+
+ GTK_WIDGET_CLASS (gd_header_bar_parent_class)->unmap (widget);
+}
+
+static gint
+gd_header_bar_draw (GtkWidget *widget,
+ cairo_t *cr)
+{
+ GdHeaderBar *bar = GD_HEADER_BAR (widget);
+ GdHeaderBarPrivate *priv = bar->priv;
+ GtkStyleContext *context;
+
+ context = gtk_widget_get_style_context (widget);
+
+ gtk_render_background (context, cr, 0, 0,
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
+ gtk_render_frame (context, cr, 0, 0,
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
+
+
+ GTK_WIDGET_CLASS (gd_header_bar_parent_class)->draw (widget, cr);
+
+ return TRUE;
+}
+
+static void
+gd_header_bar_class_init (GdHeaderBarClass *class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+ GtkContainerClass *container_class = GTK_CONTAINER_CLASS (class);
+
+ object_class->get_property = gd_header_bar_get_property;
+ object_class->set_property = gd_header_bar_set_property;
+
+ widget_class->size_allocate = gd_header_bar_size_allocate;
+ widget_class->get_preferred_width = gd_header_bar_get_preferred_width;
+ widget_class->get_preferred_height = gd_header_bar_get_preferred_height;
+ widget_class->get_preferred_height_for_width = gd_header_bar_get_preferred_height_for_width;
+ widget_class->get_preferred_width_for_height = gd_header_bar_get_preferred_width_for_height;
+ widget_class->button_press_event = gd_header_bar_button_press;
+ widget_class->realize = gd_header_bar_realize;
+ widget_class->unrealize = gd_header_bar_unrealize;
+ widget_class->map = gd_header_bar_map;
+ widget_class->unmap = gd_header_bar_unmap;
+ widget_class->draw = gd_header_bar_draw;
+
+ container_class->add = gd_header_bar_add;
+ container_class->remove = gd_header_bar_remove;
+ container_class->forall = gd_header_bar_forall;
+ container_class->child_type = gd_header_bar_child_type;
+ container_class->set_child_property = gd_header_bar_set_child_property;
+ container_class->get_child_property = gd_header_bar_get_child_property;
+ gtk_container_class_handle_border_width (container_class);
+
+ gtk_container_class_install_child_property (container_class,
+ CHILD_PROP_PACK_TYPE,
+ g_param_spec_enum ("pack-type",
+ P_("Pack type"),
+ P_("A GtkPackType indicating whether the
child is packed with reference to the start or end of the parent"),
+ GTK_TYPE_PACK_TYPE, GTK_PACK_START,
+ G_PARAM_READWRITE));
+ gtk_container_class_install_child_property (container_class,
+ CHILD_PROP_POSITION,
+ g_param_spec_int ("position",
+ P_("Position"),
+ P_("The index of the child in the parent"),
+ -1, G_MAXINT, 0,
+ G_PARAM_READABLE));
+
+ g_object_class_install_property (object_class,
+ PROP_TITLE,
+ g_param_spec_string ("title",
+ P_("Title"),
+ P_("The title to display"),
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_SPACING,
+ g_param_spec_int ("spacing",
+ P_("Spacing"),
+ P_("The amount of space between children"),
+ 0, G_MAXINT,
+ DEFAULT_SPACING,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_HPADDING,
+ g_param_spec_int ("hpadding",
+ P_("Horizontal padding"),
+ P_("The amount of space to the left and right of
children"),
+ 0, G_MAXINT,
+ DEFAULT_HPADDING,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_VPADDING,
+ g_param_spec_int ("vpadding",
+ P_("Vertical padding"),
+ P_("The amount of space to the above and below
children"),
+ 0, G_MAXINT,
+ DEFAULT_VPADDING,
+ G_PARAM_READWRITE));
+
+ g_type_class_add_private (object_class, sizeof (GdHeaderBarPrivate));
+}
+
+void
+gd_header_bar_pack_start (GdHeaderBar *bar,
+ GtkWidget *child)
+{
+ gd_header_bar_pack (bar, child, GTK_PACK_START);
+}
+
+void
+gd_header_bar_pack_end (GdHeaderBar *bar,
+ GtkWidget *child)
+{
+ gd_header_bar_pack (bar, child, GTK_PACK_END);
+}
+
+GtkWidget *
+gd_header_bar_new (const gchar *title)
+{
+ return GTK_WIDGET (g_object_new (GTK_TYPE_HEADER_BAR, "title", title, NULL));
+}
diff --git a/libgd/gd-header-bar.h b/libgd/gd-header-bar.h
new file mode 100644
index 0000000..685d56a
--- /dev/null
+++ b/libgd/gd-header-bar.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2013 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __GD_HEADER_BAR_H__
+#define __GD_HEADER_BAR_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_HEADER_BAR (gd_header_bar_get_type ())
+#define GD_HEADER_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HEADER_BAR, GdHeaderBar))
+#define GD_HEADER_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HEADER_BAR,
GdHeaderBarClass))
+#define GTK_IS_HEADER_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HEADER_BAR))
+#define GTK_IS_HEADER_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HEADER_BAR))
+#define GD_HEADER_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HEADER_BAR,
GdHeaderBarClass))
+
+typedef struct _GdHeaderBar GdHeaderBar;
+typedef struct _GdHeaderBarPrivate GdHeaderBarPrivate;
+typedef struct _GdHeaderBarClass GdHeaderBarClass;
+
+struct _GdHeaderBar
+{
+ GtkContainer container;
+
+ /*< private >*/
+ GdHeaderBarPrivate *priv;
+};
+
+struct _GdHeaderBarClass
+{
+ GtkContainerClass parent_class;
+
+ /* Padding for future expansion */
+ void (*_gd_reserved1) (void);
+ void (*_gd_reserved2) (void);
+ void (*_gd_reserved3) (void);
+ void (*_gd_reserved4) (void);
+};
+
+GType gd_header_bar_get_type (void) G_GNUC_CONST;
+GtkWidget *gd_header_bar_new (const gchar *title);
+void gd_header_bar_pack_start (GdHeaderBar *bar,
+ GtkWidget *child);
+void gd_header_bar_pack_end (GdHeaderBar *bar,
+ GtkWidget *child);
+
+G_END_DECLS
+
+#endif /* __GD_HEADER_BAR_H__ */
diff --git a/libgd/gd.h b/libgd/gd.h
index 9ec91a5..d1b7bd2 100644
--- a/libgd/gd.h
+++ b/libgd/gd.h
@@ -52,6 +52,10 @@ G_BEGIN_DECLS
# include <libgd/gd-main-toolbar.h>
#endif
+#ifdef LIBGD_HEADER_BAR
+# include <libgd/gd-header-bar.h>
+#endif
+
#ifdef LIBGD_MARGIN_CONTAINER
# include <libgd/gd-margin-container.h>
#endif
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
