summaryrefslogtreecommitdiff
path: root/liblogdiag/ld-library-toolbar.c
diff options
context:
space:
mode:
Diffstat (limited to 'liblogdiag/ld-library-toolbar.c')
-rw-r--r--liblogdiag/ld-library-toolbar.c773
1 files changed, 773 insertions, 0 deletions
diff --git a/liblogdiag/ld-library-toolbar.c b/liblogdiag/ld-library-toolbar.c
new file mode 100644
index 0000000..c809f1e
--- /dev/null
+++ b/liblogdiag/ld-library-toolbar.c
@@ -0,0 +1,773 @@
+/*
+ * ld-library-toolbar.c
+ *
+ * This file is a part of logdiag.
+ * Copyright Přemysl Janouch 2011. All rights reserved.
+ *
+ * See the file LICENSE for licensing information.
+ *
+ */
+
+#include "liblogdiag.h"
+#include "config.h"
+
+
+/**
+ * SECTION:ld-library-toolbar
+ * @short_description: A library toolbar.
+ * @see_also: #LdLibrary
+ *
+ * #LdLibraryToolbar enables the user to choose symbols from an #LdLibrary.
+ */
+
+#define LIBRARY_TOOLBAR_ICON_WIDTH 32
+
+/*
+ * SymbolMenuItem:
+ *
+ * Data related to a symbol in an open symbol menu.
+ */
+typedef struct _SymbolMenuItem SymbolMenuItem;
+
+struct _SymbolMenuItem
+{
+ LdSymbol *symbol;
+ gchar *klass;
+
+ gint width;
+ gdouble dx;
+ gdouble scale;
+};
+
+/*
+ * SymbolMenuData:
+ *
+ * Data related to the currently opened symbol menu.
+ */
+typedef struct _SymbolMenuData SymbolMenuData;
+
+struct _SymbolMenuData
+{
+ GtkToggleButton *active_button;
+
+ SymbolMenuItem *items;
+ gint n_items;
+ gint active_item;
+
+ gint menu_width;
+ gint menu_height;
+ gint menu_y;
+};
+
+enum
+{
+ CANVAS_HANDLER_EXPOSE,
+ CANVAS_HANDLER_MOTION_NOTIFY,
+ CANVAS_HANDLER_BUTTON_PRESS,
+ CANVAS_HANDLER_BUTTON_RELEASE,
+ CANVAS_HANDLER_COUNT
+};
+
+/*
+ * LdLibraryToolbarPrivate:
+ * @library: A library object assigned to this canvas as a model.
+ * @canvas: A canvas object for showing symbol menus.
+ * @canvas_handlers: Signal handlers that hook the canvas.
+ * @symbol_menu: Data related to menus.
+ */
+struct _LdLibraryToolbarPrivate
+{
+ LdLibrary *library;
+ LdCanvas *canvas;
+ gulong canvas_handlers[CANVAS_HANDLER_COUNT];
+ SymbolMenuData symbol_menu;
+};
+
+enum
+{
+ PROP_0,
+ PROP_LIBRARY,
+ PROP_CANVAS
+};
+
+static void ld_library_toolbar_get_property (GObject *object, guint property_id,
+ GValue *value, GParamSpec *pspec);
+static void ld_library_toolbar_set_property (GObject *object, guint property_id,
+ const GValue *value, GParamSpec *pspec);
+static void ld_library_toolbar_dispose (GObject *gobject);
+
+static void reload_library (LdLibraryToolbar *self);
+static void load_category_cb (gpointer data, gpointer user_data);
+static GdkPixbuf *recolor_pixbuf (GdkPixbuf *pbuf, GdkColor *color);
+
+static void redraw_symbol_menu (LdLibraryToolbar *self);
+static void emit_symbol_signal (LdLibraryToolbar *self,
+ guint signal_id, gint menu_index);
+static void on_category_toggle (GtkToggleButton *toggle_button,
+ gpointer user_data);
+
+static inline void block_canvas_handlers (LdLibraryToolbar *self);
+static inline void unblock_canvas_handlers (LdLibraryToolbar *self);
+static inline void disconnect_canvas_handlers (LdLibraryToolbar *self);
+static gboolean on_canvas_exposed (GtkWidget *widget,
+ GdkEventExpose *event, gpointer user_data);
+static gboolean on_canvas_motion_notify (GtkWidget *widget,
+ GdkEventMotion *event, gpointer user_data);
+static gboolean on_canvas_button_press (GtkWidget *widget,
+ GdkEventButton *event, gpointer user_data);
+static gboolean on_canvas_button_release (GtkWidget *widget,
+ GdkEventButton *event, gpointer user_data);
+
+
+G_DEFINE_TYPE (LdLibraryToolbar, ld_library_toolbar, GTK_TYPE_TOOLBAR);
+
+static void
+ld_library_toolbar_class_init (LdLibraryToolbarClass *klass)
+{
+ GObjectClass *object_class;
+ GtkWidgetClass *widget_class;
+ GParamSpec *pspec;
+
+ widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class = G_OBJECT_CLASS (klass);
+ object_class->get_property = ld_library_toolbar_get_property;
+ object_class->set_property = ld_library_toolbar_set_property;
+ object_class->dispose = ld_library_toolbar_dispose;
+
+/**
+ * LdLibraryToolbar:library:
+ *
+ * The #LdLibrary that this canvas retrieves symbols from.
+ */
+ pspec = g_param_spec_object ("library", "Library",
+ "The library that this canvas retrieves symbols from.",
+ LD_TYPE_LIBRARY, G_PARAM_READWRITE);
+ g_object_class_install_property (object_class, PROP_LIBRARY, pspec);
+
+/**
+ * LdLibraryToolbar:canvas:
+ *
+ * The #LdCanvas misused for showing symbol menus.
+ */
+ pspec = g_param_spec_object ("canvas", "Canvas",
+ "The canvas misused for showing symbol menus.",
+ LD_TYPE_CANVAS, G_PARAM_READWRITE);
+ g_object_class_install_property (object_class, PROP_CANVAS, pspec);
+
+/**
+ * LdLibraryToolbar::symbol-chosen:
+ * @self: An #LdLibraryToolbar object.
+ * @symbol: The chosen #LdSymbol object.
+ * @klass: Location of the symbol within the library.
+ *
+ * A symbol has been chosen.
+ */
+ klass->symbol_chosen_signal = g_signal_new
+ ("symbol-chosen", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, 0, NULL, NULL,
+ g_cclosure_user_marshal_VOID__OBJECT_STRING,
+ G_TYPE_NONE, 2, LD_TYPE_SYMBOL,
+ G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
+
+/**
+ * LdLibraryToolbar::symbol-selected:
+ * @self: An #LdLibraryToolbar object.
+ * @symbol: The selected #LdSymbol object.
+ * @klass: Location of the symbol within the library.
+ *
+ * A symbol has been selected.
+ */
+ klass->symbol_selected_signal = g_signal_new
+ ("symbol-selected", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, 0, NULL, NULL,
+ g_cclosure_user_marshal_VOID__OBJECT_STRING,
+ G_TYPE_NONE, 2, LD_TYPE_SYMBOL,
+ G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
+
+/**
+ * LdLibraryToolbar::symbol-deselected:
+ * @self: An #LdLibraryToolbar object.
+ * @symbol: The deselected #LdSymbol object.
+ * @klass: Location of the symbol within the library.
+ *
+ * A symbol has been deselected.
+ */
+ klass->symbol_deselected_signal = g_signal_new
+ ("symbol-deselected", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, 0, NULL, NULL,
+ g_cclosure_user_marshal_VOID__OBJECT_STRING,
+ G_TYPE_NONE, 2, LD_TYPE_SYMBOL,
+ G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
+
+ g_type_class_add_private (klass, sizeof (LdLibraryToolbarPrivate));
+}
+
+static void
+ld_library_toolbar_init (LdLibraryToolbar *self)
+{
+ self->priv = G_TYPE_INSTANCE_GET_PRIVATE
+ (self, LD_TYPE_LIBRARY_TOOLBAR, LdLibraryToolbarPrivate);
+}
+
+static void
+ld_library_toolbar_dispose (GObject *gobject)
+{
+ LdLibraryToolbar *self;
+
+ self = LD_LIBRARY_TOOLBAR (gobject);
+
+ ld_library_toolbar_set_library (self, NULL);
+ ld_library_toolbar_set_canvas (self, NULL);
+
+ /* Chain up to the parent class. */
+ G_OBJECT_CLASS (ld_library_toolbar_parent_class)->dispose (gobject);
+}
+
+static void
+ld_library_toolbar_get_property (GObject *object, guint property_id,
+ GValue *value, GParamSpec *pspec)
+{
+ LdLibraryToolbar *self;
+
+ self = LD_LIBRARY_TOOLBAR (object);
+ switch (property_id)
+ {
+ case PROP_LIBRARY:
+ g_value_set_object (value, ld_library_toolbar_get_library (self));
+ break;
+ case PROP_CANVAS:
+ g_value_set_object (value, ld_library_toolbar_get_canvas (self));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ }
+}
+
+static void
+ld_library_toolbar_set_property (GObject *object, guint property_id,
+ const GValue *value, GParamSpec *pspec)
+{
+ LdLibraryToolbar *self;
+
+ self = LD_LIBRARY_TOOLBAR (object);
+ switch (property_id)
+ {
+ case PROP_LIBRARY:
+ ld_library_toolbar_set_library (self,
+ LD_LIBRARY (g_value_get_object (value)));
+ break;
+ case PROP_CANVAS:
+ ld_library_toolbar_set_canvas (self,
+ LD_CANVAS (g_value_get_object (value)));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ }
+}
+
+
+/**
+ * ld_library_toolbar_new:
+ *
+ * Create an instance.
+ */
+GtkWidget *
+ld_library_toolbar_new (void)
+{
+ return g_object_new (LD_TYPE_LIBRARY_TOOLBAR, NULL);
+}
+
+/**
+ * ld_library_toolbar_set_library:
+ * @self: An #LdLibraryToolbar object.
+ * @library: (allow-none): The #LdLibrary to be assigned to the toolbar.
+ *
+ * Assign an #LdLibrary object to the toolbar.
+ */
+void
+ld_library_toolbar_set_library (LdLibraryToolbar *self, LdLibrary *library)
+{
+ g_return_if_fail (LD_IS_LIBRARY_TOOLBAR (self));
+ g_return_if_fail (LD_IS_LIBRARY (library) || library == NULL);
+
+ if (self->priv->library)
+ {
+ g_signal_handlers_disconnect_by_func (self->priv->library,
+ reload_library, self);
+ g_object_unref (self->priv->library);
+ }
+
+ self->priv->library = library;
+
+ if (library)
+ {
+ g_signal_connect_data (library, "changed",
+ G_CALLBACK (reload_library), self,
+ NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED);
+ g_object_ref (library);
+ }
+ reload_library (self);
+ g_object_notify (G_OBJECT (self), "library");
+}
+
+/**
+ * ld_library_toolbar_get_library:
+ * @self: An #LdLibraryToolbar object.
+ *
+ * Get the #LdLibrary object assigned to this toolbar.
+ * The reference count on the library is not incremented.
+ */
+LdLibrary *
+ld_library_toolbar_get_library (LdLibraryToolbar *self)
+{
+ g_return_val_if_fail (LD_IS_LIBRARY_TOOLBAR (self), NULL);
+ return self->priv->library;
+}
+
+/**
+ * ld_library_toolbar_set_canvas:
+ * @self: An #LdLibraryToolbar object.
+ * @canvas: (allow-none): The #LdCanvas to be assigned to the toolbar.
+ *
+ * Assign an #LdCanvas object to the toolbar.
+ */
+void
+ld_library_toolbar_set_canvas (LdLibraryToolbar *self, LdCanvas *canvas)
+{
+ g_return_if_fail (LD_IS_LIBRARY_TOOLBAR (self));
+ g_return_if_fail (LD_IS_CANVAS (canvas) || canvas == NULL);
+
+ if (self->priv->canvas)
+ {
+ disconnect_canvas_handlers (self);
+ g_object_unref (self->priv->canvas);
+ }
+
+ self->priv->canvas = canvas;
+
+ if (canvas)
+ {
+ self->priv->canvas_handlers[CANVAS_HANDLER_EXPOSE]
+ = g_signal_connect (canvas, "expose-event",
+ G_CALLBACK (on_canvas_exposed), self);
+ self->priv->canvas_handlers[CANVAS_HANDLER_MOTION_NOTIFY]
+ = g_signal_connect (canvas, "motion-notify-event",
+ G_CALLBACK (on_canvas_motion_notify), self);
+ self->priv->canvas_handlers[CANVAS_HANDLER_BUTTON_PRESS]
+ = g_signal_connect (canvas, "button-press-event",
+ G_CALLBACK (on_canvas_button_press), self);
+ self->priv->canvas_handlers[CANVAS_HANDLER_BUTTON_RELEASE]
+ = g_signal_connect (canvas, "button-release-event",
+ G_CALLBACK (on_canvas_button_release), self);
+
+ block_canvas_handlers (self);
+ g_object_ref (canvas);
+ }
+ g_object_notify (G_OBJECT (self), "canvas");
+}
+
+/**
+ * ld_library_toolbar_get_canvas:
+ * @self: An #LdLibraryToolbar object.
+ *
+ * Get the #LdLibrary object assigned to this toolbar.
+ * The reference count on the canvas is not incremented.
+ */
+LdCanvas *
+ld_library_toolbar_get_canvas (LdLibraryToolbar *self)
+{
+ g_return_val_if_fail (LD_IS_LIBRARY_TOOLBAR (self), NULL);
+ return self->priv->canvas;
+}
+
+static void
+reload_library (LdLibraryToolbar *self)
+{
+ g_return_if_fail (LD_IS_LIBRARY_TOOLBAR (self));
+
+ /* Clear the toolbar first, if there was already something in it. */
+ gtk_container_foreach (GTK_CONTAINER (self),
+ (GtkCallback) gtk_widget_destroy, NULL);
+
+ if (self->priv->library)
+ {
+ GSList *categories;
+
+ categories = (GSList *) ld_library_get_children (self->priv->library);
+ g_slist_foreach (categories, load_category_cb, self);
+ }
+}
+
+static void
+load_category_cb (gpointer data, gpointer user_data)
+{
+ LdLibraryToolbar *self;
+ LdSymbolCategory *cat;
+ const gchar *human_name;
+ GdkPixbuf *pbuf, *new_pbuf;
+ GtkWidget *img;
+ GtkToolItem *item;
+ GtkWidget *button;
+ GtkStyle *style;
+
+ g_return_if_fail (LD_IS_LIBRARY_TOOLBAR (user_data));
+ g_return_if_fail (LD_IS_SYMBOL_CATEGORY (data));
+
+ self = user_data;
+ cat = data;
+
+ pbuf = gdk_pixbuf_new_from_file_at_size (ld_symbol_category_get_image_path
+ (cat), LIBRARY_TOOLBAR_ICON_WIDTH, -1, NULL);
+ g_return_if_fail (pbuf != NULL);
+
+ button = gtk_toggle_button_new ();
+ style = gtk_rc_get_style (button);
+
+ /* TODO: Handle all states. */
+ new_pbuf = recolor_pixbuf (pbuf, &style->fg[GTK_STATE_NORMAL]);
+ if (new_pbuf)
+ {
+ g_object_unref (pbuf);
+ pbuf = new_pbuf;
+ }
+
+ img = gtk_image_new_from_pixbuf (pbuf);
+ g_object_unref (pbuf);
+
+ item = gtk_tool_item_new ();
+ gtk_container_add (GTK_CONTAINER (button), img);
+ gtk_container_add (GTK_CONTAINER (item), button);
+
+ /* Don't steal focus from the canvas. */
+ g_object_set (button, "can-focus", FALSE, NULL);
+
+ /* Assign the category to the toggle button. */
+ g_object_ref (cat);
+ g_object_set_data_full (G_OBJECT (button),
+ "category", cat, (GDestroyNotify) g_object_unref);
+
+ /* Hook toggling of the button. */
+ g_signal_connect (button, "toggled", G_CALLBACK (on_category_toggle), self);
+
+ human_name = ld_symbol_category_get_human_name (cat);
+ gtk_tool_item_set_tooltip_text (item, human_name);
+ gtk_toolbar_insert (GTK_TOOLBAR (self), item, 0);
+}
+
+static GdkPixbuf *
+recolor_pixbuf (GdkPixbuf *pbuf, GdkColor *color)
+{
+ gint width, height;
+ GdkPixbuf *new_pbuf;
+ cairo_surface_t *cr_surface;
+ cairo_t *cr;
+
+ width = gdk_pixbuf_get_width (pbuf);
+ height = gdk_pixbuf_get_height (pbuf);
+
+ new_pbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, width, height);
+ g_return_val_if_fail (new_pbuf != NULL, NULL);
+
+ cr_surface = cairo_image_surface_create_for_data
+ (gdk_pixbuf_get_pixels (new_pbuf), CAIRO_FORMAT_ARGB32,
+ width, height, gdk_pixbuf_get_rowstride (new_pbuf));
+ cr = cairo_create (cr_surface);
+
+ /* Change the color of all pixels but leave the alpha channel intact. */
+ gdk_cairo_set_source_color (cr, color);
+ cairo_paint (cr);
+
+ cairo_set_operator (cr, CAIRO_OPERATOR_DEST_IN);
+ gdk_cairo_set_source_pixbuf (cr, pbuf, 0, 0);
+ cairo_paint (cr);
+
+ cairo_destroy (cr);
+ cairo_surface_destroy (cr_surface);
+ return new_pbuf;
+}
+
+static void
+redraw_symbol_menu (LdLibraryToolbar *self)
+{
+ SymbolMenuData *data;
+
+ g_return_if_fail (LD_IS_LIBRARY_TOOLBAR (self));
+ data = &self->priv->symbol_menu;
+
+ gtk_widget_queue_draw_area (GTK_WIDGET (self->priv->canvas),
+ 0, data->menu_y - 1, data->menu_width + 2, data->menu_height + 2);
+}
+
+static void
+emit_symbol_signal (LdLibraryToolbar *self, guint signal_id, gint menu_index)
+{
+ SymbolMenuData *data;
+ SymbolMenuItem *item;
+
+ data = &self->priv->symbol_menu;
+ if (menu_index == -1)
+ menu_index = data->active_item;
+ if (menu_index != -1)
+ {
+ item = &data->items[menu_index];
+ g_signal_emit (self, signal_id, 0, item->symbol, item->klass);
+ }
+}
+
+static void
+on_category_toggle (GtkToggleButton *toggle_button, gpointer user_data)
+{
+ LdLibraryToolbar *self;
+ LdLibraryToolbarPrivate *priv;
+ LdSymbolCategory *cat;
+ SymbolMenuData *data;
+ const gchar *category_name, *symbol_name;
+
+ cat = g_object_get_data (G_OBJECT (toggle_button), "category");
+ self = LD_LIBRARY_TOOLBAR (user_data);
+ priv = self->priv;
+ data = &priv->symbol_menu;
+
+ /* First untoggle any active button. */
+ if (data->active_button)
+ gtk_toggle_button_set_active (data->active_button, FALSE);
+
+ /* And toggle signal handlers that enable the user to add a symbol. */
+ if (data->active_button == toggle_button)
+ {
+ gint i;
+
+ block_canvas_handlers (self);
+
+ g_object_unref (data->active_button);
+ data->active_button = NULL;
+
+ emit_symbol_signal (self, LD_LIBRARY_TOOLBAR_GET_CLASS (self)
+ ->symbol_deselected_signal, -1);
+
+ /* Ashes to ashes, NULL to NULL. */
+ for (i = 0; i < data->n_items; i++)
+ {
+ g_object_unref (data->items[i].symbol);
+ g_free (data->items[i].klass);
+ }
+
+ g_free (data->items);
+ data->items = NULL;
+
+ gtk_grab_remove (GTK_WIDGET (self->priv->canvas));
+ }
+ else
+ {
+ const GSList *children, *symbol_iter;
+ SymbolMenuItem *item;
+ gint x, y, menu_width;
+
+ g_return_if_fail (gtk_widget_translate_coordinates (GTK_WIDGET
+ (toggle_button), GTK_WIDGET (priv->canvas), 0, 0, &x, &y));
+
+ data->menu_y = y;
+ data->menu_height = GTK_WIDGET (toggle_button)->allocation.height;
+
+ unblock_canvas_handlers (self);
+
+ data->active_button = toggle_button;
+ g_object_ref (data->active_button);
+
+ category_name = ld_symbol_category_get_name (cat);
+ children = ld_symbol_category_get_children (cat);
+
+ data->n_items = g_slist_length ((GSList *) children);
+ data->items = g_new (SymbolMenuItem, data->n_items);
+ data->active_item = -1;
+
+ item = data->items;
+ menu_width = 0;
+ for (symbol_iter = children; symbol_iter;
+ symbol_iter = symbol_iter->next)
+ {
+ LdRectangle area;
+
+ item->symbol = LD_SYMBOL (symbol_iter->data);
+ g_object_ref (item->symbol);
+
+ symbol_name = ld_symbol_get_name (item->symbol);
+ item->klass = g_build_path (LD_LIBRARY_IDENTIFIER_SEPARATOR,
+ category_name, symbol_name, NULL);
+
+ ld_symbol_get_area (item->symbol, &area);
+
+ /* This is the height when the center of the symbol is
+ * in the center of it's symbol menu item.
+ */
+ item->scale = data->menu_height * 0.5
+ / MAX (ABS (area.y), ABS (area.y + area.height)) * 0.5;
+ item->width = data->menu_height * 0.5 + item->scale * area.width;
+ item->dx = item->width * 0.5 + item->scale * (area.width * 0.5
+ - MAX (ABS (area.x), ABS (area.x + area.width)));
+
+ menu_width += item++->width;
+ }
+ data->menu_width = menu_width;
+
+ gtk_grab_add (GTK_WIDGET (self->priv->canvas));
+ }
+ redraw_symbol_menu (self);
+}
+
+#define DEFINE_CANVAS_HANDLER_FUNC(name) \
+static inline void \
+name ## _canvas_handlers (LdLibraryToolbar *self) \
+{ \
+ gint i; \
+ g_return_if_fail (LD_IS_CANVAS (self->priv->canvas)); \
+ for (i = 0; i < CANVAS_HANDLER_COUNT; i++) \
+ g_signal_handler_ ## name (self->priv->canvas, \
+ self->priv->canvas_handlers[i]); \
+}
+
+DEFINE_CANVAS_HANDLER_FUNC (block)
+DEFINE_CANVAS_HANDLER_FUNC (unblock)
+DEFINE_CANVAS_HANDLER_FUNC (disconnect)
+
+static gboolean
+on_canvas_exposed (GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
+{
+ cairo_t *cr;
+ LdLibraryToolbar *self;
+ SymbolMenuData *data;
+ gint i, x;
+
+ cr = gdk_cairo_create (widget->window);
+ self = LD_LIBRARY_TOOLBAR (user_data);
+ data = &self->priv->symbol_menu;
+
+ /* Draw some border. */
+ cairo_set_line_width (cr, 1);
+
+ cairo_rectangle (cr, 0, data->menu_y, data->menu_width, data->menu_height);
+ cairo_set_source_rgb (cr, 1, 1, 1);
+ cairo_fill (cr);
+
+ /* Draw all symbols from that category. */
+ for (x = i = 0; i < data->n_items; i++)
+ {
+ SymbolMenuItem *item;
+
+ item = data->items + i;
+ cairo_save (cr);
+
+ cairo_rectangle (cr, x, data->menu_y, item->width, data->menu_height);
+ cairo_clip (cr);
+
+ if (i == data->active_item)
+ {
+ cairo_set_source_rgb (cr, 0.9, 0.9, 0.9);
+ cairo_paint (cr);
+ }
+
+ cairo_translate (cr, x + item->dx,
+ data->menu_y + data->menu_height * 0.5);
+ cairo_scale (cr, item->scale, item->scale);
+
+ cairo_set_source_rgb (cr, 0, 0, 0);
+ cairo_set_line_width (cr, 1 / item->scale);
+ ld_symbol_draw (item->symbol, cr);
+
+ cairo_restore (cr);
+ x += item->width;
+ }
+
+ cairo_rectangle (cr, 0, data->menu_y, data->menu_width, data->menu_height);
+ cairo_set_source_rgb (cr, 0, 0, 0);
+ cairo_stroke (cr);
+
+ cairo_destroy (cr);
+ return FALSE;
+}
+
+static gboolean
+on_canvas_motion_notify (GtkWidget *widget, GdkEventMotion *event,
+ gpointer user_data)
+{
+ LdLibraryToolbar *self;
+ SymbolMenuData *data;
+ gint i, x, at_cursor = -1;
+
+ self = LD_LIBRARY_TOOLBAR (user_data);
+ data = &self->priv->symbol_menu;
+
+ if (widget->window != event->window
+ || event->x < 0 || event->y < data->menu_y
+ || event->y >= data->menu_y + data->menu_height)
+ goto on_canvas_motion_notify_end;
+
+ for (x = i = 0; i < data->n_items; i++)
+ {
+ x += data->items[i].width;
+ if (event->x < x)
+ {
+ at_cursor = i;
+ break;
+ }
+ }
+
+on_canvas_motion_notify_end:
+ if (data->active_item != at_cursor)
+ {
+ emit_symbol_signal (self, LD_LIBRARY_TOOLBAR_GET_CLASS (self)
+ ->symbol_deselected_signal, -1);
+
+ if (at_cursor != -1)
+ emit_symbol_signal (self, LD_LIBRARY_TOOLBAR_GET_CLASS (self)
+ ->symbol_selected_signal, at_cursor);
+ }
+ data->active_item = at_cursor;
+ redraw_symbol_menu (self);
+ return FALSE;
+}
+
+static gboolean
+on_canvas_button_press (GtkWidget *widget, GdkEventButton *event,
+ gpointer user_data)
+{
+ LdLibraryToolbar *self;
+ SymbolMenuData *data;
+
+ self = LD_LIBRARY_TOOLBAR (user_data);
+ data = &self->priv->symbol_menu;
+
+ /* If the event occured elsewhere, cancel the menu and put the event
+ * back into the queue.
+ */
+ if (widget->window != event->window && data->active_button)
+ {
+ gtk_toggle_button_set_active (data->active_button, FALSE);
+ gdk_event_put ((GdkEvent *) event);
+ }
+ return FALSE;
+}
+
+static gboolean
+on_canvas_button_release (GtkWidget *widget, GdkEventButton *event,
+ gpointer user_data)
+{
+ LdLibraryToolbar *self;
+ SymbolMenuData *data;
+
+ self = LD_LIBRARY_TOOLBAR (user_data);
+ data = &self->priv->symbol_menu;
+
+ if (event->button != 1)
+ return FALSE;
+
+ emit_symbol_signal (self, LD_LIBRARY_TOOLBAR_GET_CLASS (self)
+ ->symbol_chosen_signal, -1);
+
+ /* We've either chosen a symbol or canceled the menu, so hide it. */
+ if (data->active_button)
+ gtk_toggle_button_set_active (data->active_button, FALSE);
+
+ return FALSE;
+}