summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Canvas.cpp1764
-rw-r--r--src/box.c12
-rw-r--r--src/canvas-base.c1728
-rw-r--r--src/circle.c9
-rw-r--r--src/edge.c31
-rw-r--r--src/ganv-private.h14
-rw-r--r--src/group.c2
-rw-r--r--src/item.c129
-rw-r--r--src/node.c5
-rw-r--r--src/text.c3
-rw-r--r--src/widget.c6
11 files changed, 1830 insertions, 1873 deletions
diff --git a/src/Canvas.cpp b/src/Canvas.cpp
index 1fdcfb3..a461a6e 100644
--- a/src/Canvas.cpp
+++ b/src/Canvas.cpp
@@ -13,38 +13,50 @@
* with Ganv. If not, see <http://www.gnu.org/licenses/>.
*/
+/* Parts based on GnomeCanvas, by Federico Mena <federico@nuclecu.unam.mx>
+ * and Raph Levien <raph@gimp.org>
+ * Copyright 1997-2000 Free Software Foundation
+ */
+
#define _POSIX_C_SOURCE 200809L // strdup
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
#include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
+#include <set>
#include <sstream>
#include <string>
#include <vector>
-#include <set>
+#include <cairo.h>
#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
#include <gtk/gtkstyle.h>
-
#include <gtkmm/widget.h>
-#include "ganv_config.h"
#include "ganv/Canvas.hpp"
-#include "ganv/Edge.hpp"
#include "ganv/Circle.hpp"
+#include "ganv/Edge.hpp"
#include "ganv/Module.hpp"
#include "ganv/Port.hpp"
#include "ganv/box.h"
#include "ganv/canvas.h"
#include "ganv/edge.h"
+#include "ganv/group.h"
#include "ganv/node.h"
+#include "ganv_config.h"
#include "./color.h"
#include "./ganv-marshal.h"
#include "./ganv-private.h"
+#include "./gettext.h"
#if defined(HAVE_AGRAPH_2_20) || defined(HAVE_AGRAPH_2_30)
# include <gvc.h>
@@ -53,6 +65,49 @@
# include "./fdgl.hpp"
#endif
+/*** GanvCanvas ***/
+
+#define CANVAS_IDLE_PRIORITY (GDK_PRIORITY_REDRAW - 5)
+
+typedef struct {
+ int x;
+ int y;
+ int width;
+ int height;
+} IRect;
+
+extern "C" {
+static void add_idle(GanvCanvas* canvas);
+static void ganv_canvas_destroy(GtkObject* object);
+static void ganv_canvas_map(GtkWidget* widget);
+static void ganv_canvas_unmap(GtkWidget* widget);
+static void ganv_canvas_realize(GtkWidget* widget);
+static void ganv_canvas_unrealize(GtkWidget* widget);
+static void ganv_canvas_size_allocate(GtkWidget* widget,
+ GtkAllocation* allocation);
+static gint ganv_canvas_button(GtkWidget* widget,
+ GdkEventButton* event);
+static gint ganv_canvas_motion(GtkWidget* widget,
+ GdkEventMotion* event);
+static gint ganv_canvas_expose(GtkWidget* widget,
+ GdkEventExpose* event);
+static gboolean ganv_canvas_key(GtkWidget* widget,
+ GdkEventKey* event);
+static gboolean ganv_canvas_scroll(GtkWidget* widget,
+ GdkEventScroll* event);
+static gint ganv_canvas_crossing(GtkWidget* widget,
+ GdkEventCrossing* event);
+static gint ganv_canvas_focus_in(GtkWidget* widget,
+ GdkEventFocus* event);
+static gint ganv_canvas_focus_out(GtkWidget* widget,
+ GdkEventFocus* event);
+static void ganv_canvas_request_update_real(GanvCanvas* canvas);
+
+static GtkLayoutClass* canvas_parent_class;
+}
+
+/*** end GanvCanvas ***/
+
static guint signal_connect;
static guint signal_disconnect;
@@ -148,7 +203,7 @@ struct GanvCanvasImpl {
_wrapper_key = g_quark_from_string("ganvmm");
_move_cursor = gdk_cursor_new(GDK_FLEUR);
- g_signal_connect(G_OBJECT(ganv_canvas_base_root(GANV_CANVAS_BASE(_gcanvas))),
+ g_signal_connect(G_OBJECT(ganv_canvas_root(GANV_CANVAS(_gcanvas))),
"event", G_CALLBACK(on_canvas_event), this);
}
@@ -180,7 +235,7 @@ struct GanvCanvasImpl {
#endif
GanvItem* root() {
- return ganv_canvas_base_root(GANV_CANVAS_BASE(_gcanvas));
+ return ganv_canvas_root(GANV_CANVAS(_gcanvas));
}
void resize(double width, double height);
@@ -1053,7 +1108,7 @@ GanvCanvasImpl::join_selection()
GanvNode*
GanvCanvasImpl::get_node_at(double x, double y)
{
- GanvItem* item = ganv_canvas_base_get_item_at(GANV_CANVAS_BASE(_gcanvas), x, y);
+ GanvItem* item = ganv_canvas_get_item_at(GANV_CANVAS(_gcanvas), x, y);
while (item) {
if (GANV_IS_NODE(item)) {
return GANV_NODE(item);
@@ -1075,7 +1130,7 @@ GanvCanvasImpl::on_event(GdkEvent* event)
switch (event->type) {
case GDK_KEY_PRESS:
handled = true;
- ganv_canvas_base_get_scroll_offsets(GANV_CANVAS_BASE(_gcanvas), &scroll_x, &scroll_y);
+ ganv_canvas_get_scroll_offsets(GANV_CANVAS(_gcanvas), &scroll_x, &scroll_y);
switch (event->key.keyval) {
case GDK_Up:
scroll_y -= scroll_increment;
@@ -1099,7 +1154,7 @@ GanvCanvasImpl::on_event(GdkEvent* event)
handled = false;
}
if (handled) {
- ganv_canvas_base_scroll_to(GANV_CANVAS_BASE(_gcanvas), scroll_x, scroll_y);
+ ganv_canvas_scroll_to(GANV_CANVAS(_gcanvas), scroll_x, scroll_y);
return true;
}
break;
@@ -1145,7 +1200,7 @@ GanvCanvasImpl::scroll_drag_handler(GdkEvent* event)
GANV_ITEM(root()),
GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
NULL, event->button.time);
- ganv_canvas_base_get_scroll_offsets(GANV_CANVAS_BASE(_gcanvas), &original_scroll_x, &original_scroll_y);
+ ganv_canvas_get_scroll_offsets(GANV_CANVAS(_gcanvas), &original_scroll_x, &original_scroll_y);
scroll_offset_x = 0;
scroll_offset_y = 0;
origin_x = event->button.x_root;
@@ -1166,7 +1221,7 @@ GanvCanvasImpl::scroll_drag_handler(GdkEvent* event)
scroll_offset_x += x_offset;
scroll_offset_y += y_offset;
- ganv_canvas_base_scroll_to(GANV_CANVAS_BASE(_gcanvas),
+ ganv_canvas_scroll_to(GANV_CANVAS(_gcanvas),
lrint(original_scroll_x + scroll_offset_x),
lrint(original_scroll_y + scroll_offset_y));
last_x = x;
@@ -1298,7 +1353,7 @@ GanvCanvasImpl::connect_drag_handler(GdkEvent* event)
_drag_node = GANV_NODE(
ganv_item_new(
- GANV_ITEM(ganv_canvas_base_root(GANV_CANVAS_BASE(_gcanvas))),
+ GANV_ITEM(ganv_canvas_root(GANV_CANVAS(_gcanvas))),
ganv_node_get_type(),
"x", x,
"y", y,
@@ -1697,7 +1752,7 @@ GanvCanvasImpl::resize(double width, double height)
if (width != _gcanvas->width || height != _gcanvas->height) {
_gcanvas->width = width;
_gcanvas->height = height;
- ganv_canvas_base_set_scroll_region(GANV_CANVAS_BASE(_gcanvas),
+ ganv_canvas_set_scroll_region(GANV_CANVAS(_gcanvas),
0.0, 0.0, width, height);
}
}
@@ -1728,7 +1783,7 @@ GanvCanvasImpl::set_zoom_and_font_size(double zoom, double points)
if (zoom != _zoom) {
_zoom = zoom;
- ganv_canvas_base_set_pixels_per_unit(GANV_CANVAS_BASE(_gcanvas), zoom);
+ ganv_canvas_set_pixels_per_unit(GANV_CANVAS(_gcanvas), zoom);
}
_font_size = points;
@@ -1836,7 +1891,7 @@ Canvas::for_each_selected_edge(GanvEdgeFunc f, void* data)
GanvItem*
Canvas::root()
{
- return ganv_canvas_base_root(GANV_CANVAS_BASE(impl()->_gcanvas));
+ return ganv_canvas_root(GANV_CANVAS(impl()->_gcanvas));
}
Gtk::Layout&
@@ -1848,13 +1903,13 @@ Canvas::widget()
void
Canvas::get_scroll_offsets(int& cx, int& cy) const
{
- ganv_canvas_base_get_scroll_offsets(GANV_CANVAS_BASE(impl()->_gcanvas), &cx, &cy);
+ ganv_canvas_get_scroll_offsets(GANV_CANVAS(impl()->_gcanvas), &cx, &cy);
}
void
Canvas::scroll_to(int x, int y)
{
- ganv_canvas_base_scroll_to(GANV_CANVAS_BASE(impl()->_gcanvas), x, y);
+ ganv_canvas_scroll_to(GANV_CANVAS(impl()->_gcanvas), x, y);
}
GQuark
@@ -1879,16 +1934,13 @@ Canvas::gobj() const
extern "C" {
-#include "ganv/canvas-base.h"
#include "ganv/canvas.h"
#include "./boilerplate.h"
#include "./color.h"
#include "./gettext.h"
-G_DEFINE_TYPE(GanvCanvas, ganv_canvas, GANV_TYPE_CANVAS_BASE)
-
-static GanvCanvasBaseClass* parent_class;
+G_DEFINE_TYPE(GanvCanvas, ganv_canvas, GTK_TYPE_LAYOUT)
enum {
PROP_0,
@@ -1896,12 +1948,59 @@ enum {
PROP_HEIGHT,
PROP_DIRECTION,
PROP_FONT_SIZE,
- PROP_LOCKED
+ PROP_LOCKED,
+ PROP_FOCUSED_ITEM
};
+/* Callback used when the root item of a canvas is destroyed. The user should
+ * never ever do this, so we panic if this happens.
+ */
+static void
+panic_root_destroyed(GtkObject* object, gpointer data)
+{
+ g_error("Eeeek, root item %p of canvas %p was destroyed!", (void*)object, data);
+}
+
static void
ganv_canvas_init(GanvCanvas* canvas)
{
+ GTK_WIDGET_SET_FLAGS(canvas, GTK_CAN_FOCUS);
+
+ canvas->need_update = FALSE;
+ canvas->need_redraw = FALSE;
+ canvas->redraw_region = NULL;
+ canvas->idle_id = 0;
+
+ canvas->scroll_x1 = 0.0;
+ canvas->scroll_y1 = 0.0;
+ canvas->scroll_x2 = canvas->layout.width;
+ canvas->scroll_y2 = canvas->layout.height;
+
+ canvas->pixels_per_unit = 1.0;
+
+ canvas->pick_event.type = GDK_LEAVE_NOTIFY;
+ canvas->pick_event.crossing.x = 0;
+ canvas->pick_event.crossing.y = 0;
+
+ canvas->center_scroll_region = TRUE;
+
+ gtk_layout_set_hadjustment(GTK_LAYOUT(canvas), NULL);
+ gtk_layout_set_vadjustment(GTK_LAYOUT(canvas), NULL);
+
+ /* Create the root item as a special case */
+ canvas->root = GANV_ITEM(g_object_new(ganv_group_get_type(), NULL));
+ canvas->root->canvas = canvas;
+
+ g_object_ref_sink(canvas->root);
+
+ canvas->root_destroy_id = g_signal_connect(canvas->root, "destroy",
+ G_CALLBACK(panic_root_destroyed),
+ canvas);
+
+ canvas->need_repick = TRUE;
+
+ /*************************/
+
canvas->direction = GANV_DIRECTION_RIGHT;
canvas->impl = new GanvCanvasImpl(canvas);
canvas->impl->_font_size = ganv_canvas_get_default_font_size(canvas);
@@ -1934,6 +2033,9 @@ ganv_canvas_set_property(GObject* object,
case PROP_LOCKED:
canvas->locked = g_value_get_boolean(value);
break;
+ case PROP_FOCUSED_ITEM:
+ canvas->focused_item = GANV_ITEM(g_value_get_object(value));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
@@ -1955,6 +2057,9 @@ ganv_canvas_get_property(GObject* object,
GET_CASE(WIDTH, double, canvas->width)
GET_CASE(HEIGHT, double, canvas->height)
GET_CASE(LOCKED, boolean, canvas->locked);
+ case PROP_FOCUSED_ITEM:
+ g_value_set_object(value, GANV_CANVAS(object)->focused_item);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
@@ -1964,13 +2069,44 @@ ganv_canvas_get_property(GObject* object,
static void
ganv_canvas_class_init(GanvCanvasClass* klass)
{
- GObjectClass* gobject_class = (GObjectClass*)klass;
+ GObjectClass* gobject_class = (GObjectClass*)klass;
+ GtkObjectClass* object_class = (GtkObjectClass*)klass;
+ GtkWidgetClass* widget_class = (GtkWidgetClass*)klass;
- parent_class = GANV_CANVAS_BASE_CLASS(g_type_class_peek_parent(klass));
+ canvas_parent_class = GTK_LAYOUT_CLASS(g_type_class_peek_parent(klass));
gobject_class->set_property = ganv_canvas_set_property;
gobject_class->get_property = ganv_canvas_get_property;
+ object_class->destroy = ganv_canvas_destroy;
+
+ widget_class->map = ganv_canvas_map;
+ widget_class->unmap = ganv_canvas_unmap;
+ widget_class->realize = ganv_canvas_realize;
+ widget_class->unrealize = ganv_canvas_unrealize;
+ widget_class->size_allocate = ganv_canvas_size_allocate;
+ widget_class->button_press_event = ganv_canvas_button;
+ widget_class->button_release_event = ganv_canvas_button;
+ widget_class->motion_notify_event = ganv_canvas_motion;
+ widget_class->expose_event = ganv_canvas_expose;
+ widget_class->key_press_event = ganv_canvas_key;
+ widget_class->key_release_event = ganv_canvas_key;
+ widget_class->enter_notify_event = ganv_canvas_crossing;
+ widget_class->leave_notify_event = ganv_canvas_crossing;
+ widget_class->focus_in_event = ganv_canvas_focus_in;
+ widget_class->focus_out_event = ganv_canvas_focus_out;
+ widget_class->scroll_event = ganv_canvas_scroll;
+
+ klass->request_update = ganv_canvas_request_update_real;
+
+ g_object_class_install_property(
+ gobject_class, PROP_FOCUSED_ITEM, g_param_spec_object(
+ "focused-item",
+ NULL,
+ NULL,
+ GANV_TYPE_ITEM,
+ (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE)));
+
g_object_class_install_property(
gobject_class, PROP_WIDTH, g_param_spec_double(
"width",
@@ -2047,18 +2183,10 @@ ganv_canvas_class_init(GanvCanvasClass* klass)
0);
}
-GanvCanvas*
-ganv_canvas_new(double width, double height)
-{
- GanvCanvas* canvas = GANV_CANVAS(g_object_new(ganv_canvas_get_type(),
- "width", width,
- "height", height,
- NULL));
- ganv_canvas_base_set_scroll_region(GANV_CANVAS_BASE(canvas),
- 0.0, 0.0, width, height);
- return canvas;
-}
-
+/**
+ * ganv_canvas_resize:
+ * Resize the canvas to the given dimensions.
+ */
void
ganv_canvas_resize(GanvCanvas* canvas, double width, double height)
{
@@ -2071,12 +2199,11 @@ ganv_canvas_contents_changed(GanvCanvas* canvas)
canvas->impl->contents_changed();
}
-GanvItem*
-ganv_canvas_get_root(const GanvCanvas* canvas)
-{
- return ganv_canvas_base_root(GANV_CANVAS_BASE(canvas->impl->_gcanvas));
-}
-
+/**
+ * ganv_canvas_get_default_font_size:
+ *
+ * Get the default font size in points.
+ */
double
ganv_canvas_get_default_font_size(const GanvCanvas* canvas)
{
@@ -2117,7 +2244,7 @@ ganv_canvas_zoom_full(GanvCanvas* canvas)
int win_width, win_height;
GdkWindow* win = gtk_widget_get_window(
- GTK_WIDGET(GANV_CANVAS_BASE(canvas->impl->_gcanvas)));
+ GTK_WIDGET(GANV_CANVAS(canvas->impl->_gcanvas)));
gdk_window_get_size(win, &win_width, &win_height);
// Box containing all canvas items
@@ -2153,11 +2280,11 @@ ganv_canvas_zoom_full(GanvCanvas* canvas)
ganv_canvas_set_zoom(canvas, new_zoom);
int scroll_x, scroll_y;
- ganv_canvas_base_w2c(GANV_CANVAS_BASE(canvas->impl->_gcanvas),
+ ganv_canvas_w2c(GANV_CANVAS(canvas->impl->_gcanvas),
lrintf(left - pad), lrintf(bottom - pad),
&scroll_x, &scroll_y);
- ganv_canvas_base_scroll_to(GANV_CANVAS_BASE(canvas->impl->_gcanvas),
+ ganv_canvas_scroll_to(GANV_CANVAS(canvas->impl->_gcanvas),
scroll_x, scroll_y);
}
@@ -2220,6 +2347,12 @@ ganv_canvas_add_node(GanvCanvas* canvas,
canvas->impl->add_item(node);
}
+/**
+ * ganv_canvas_get_edge:
+ * Get the edge between two nodes, or NULL if none exists.
+ *
+ * Return value: (transfer none): The root group of @canvas.
+ */
GanvEdge*
ganv_canvas_get_edge(GanvCanvas* canvas,
GanvNode* tail,
@@ -2413,7 +2546,7 @@ ganv_canvas_arrange(GanvCanvas* canvas)
// Arrange to graphviz coordinates
for (GVNodes::iterator i = nodes.begin(); i != nodes.end(); ++i) {
- if (GANV_ITEM(i->first)->parent != GANV_ITEM(ganv_canvas_get_root(canvas))) {
+ if (GANV_ITEM(i->first)->parent != GANV_ITEM(ganv_canvas_root(canvas))) {
continue;
}
const string pos = agget(i->second, (char*)"pos");
@@ -2469,7 +2602,7 @@ ganv_canvas_arrange(GanvCanvas* canvas)
static const double border_width = canvas->impl->_font_size * 2.0;
canvas->impl->move_contents_to_internal(border_width, border_width, least_x, least_y);
- ganv_canvas_base_scroll_to(GANV_CANVAS_BASE(canvas->impl->_gcanvas), 0, 0);
+ ganv_canvas_scroll_to(GANV_CANVAS(canvas->impl->_gcanvas), 0, 0);
FOREACH_ITEM(canvas->impl->_items, i) {
const double x = GANV_ITEM(*i)->x;
@@ -2479,6 +2612,11 @@ ganv_canvas_arrange(GanvCanvas* canvas)
#endif
}
+/**
+ * ganv_canvas_export_dot:
+ *
+ * Write a Graphviz DOT description of the canvas to a file.
+ */
void
ganv_canvas_export_dot(GanvCanvas* canvas, const char* filename)
{
@@ -2488,4 +2626,1536 @@ ganv_canvas_export_dot(GanvCanvas* canvas, const char* filename)
#endif
}
+
+/***************************************************************************/
+
+/* Convenience function to remove the idle handler of a canvas */
+static void
+remove_idle(GanvCanvas* canvas)
+{
+ if (canvas->idle_id == 0) {
+ return;
+ }
+
+ g_source_remove(canvas->idle_id);
+ canvas->idle_id = 0;
+}
+
+/* Removes the transient state of the canvas (idle handler, grabs). */
+static void
+shutdown_transients(GanvCanvas* canvas)
+{
+ /* We turn off the need_redraw flag, since if the canvas is mapped again
+ * it will request a redraw anyways. We do not turn off the need_update
+ * flag, though, because updates are not queued when the canvas remaps
+ * itself.
+ */
+ if (canvas->need_redraw) {
+ canvas->need_redraw = FALSE;
+ g_slist_foreach(canvas->redraw_region, (GFunc)g_free, NULL);
+ g_slist_free(canvas->redraw_region);
+ canvas->redraw_region = NULL;
+ canvas->redraw_x1 = 0;
+ canvas->redraw_y1 = 0;
+ canvas->redraw_x2 = 0;
+ canvas->redraw_y2 = 0;
+ }
+
+ if (canvas->grabbed_item) {
+ canvas->grabbed_item = NULL;
+ gdk_pointer_ungrab(GDK_CURRENT_TIME);
+ }
+
+ remove_idle(canvas);
+}
+
+/* Destroy handler for GanvCanvas */
+static void
+ganv_canvas_destroy(GtkObject* object)
+{
+ GanvCanvas* canvas;
+
+ g_return_if_fail(GANV_IS_CANVAS(object));
+
+ /* remember, destroy can be run multiple times! */
+
+ canvas = GANV_CANVAS(object);
+
+ if (canvas->root_destroy_id) {
+ g_signal_handler_disconnect(canvas->root, canvas->root_destroy_id);
+ canvas->root_destroy_id = 0;
+ }
+ if (canvas->root) {
+ gtk_object_destroy(GTK_OBJECT(canvas->root));
+ g_object_unref(G_OBJECT(canvas->root));
+ canvas->root = NULL;
+ }
+
+ shutdown_transients(canvas);
+
+ if (GTK_OBJECT_CLASS(canvas_parent_class)->destroy) {
+ (*GTK_OBJECT_CLASS(canvas_parent_class)->destroy)(object);
+ }
+}
+
+/**
+ * ganv_canvas_new:
+ *
+ * Return value: A newly-created canvas.
+ */
+GanvCanvas*
+ganv_canvas_new(double width, double height)
+{
+ GanvCanvas* canvas = GANV_CANVAS(
+ g_object_new(ganv_canvas_get_type(),
+ "width", width,
+ "height", height,
+ NULL));
+
+ ganv_canvas_set_scroll_region(GANV_CANVAS(canvas),
+ 0.0, 0.0, width, height);
+
+ return canvas;
+}
+
+/* Map handler for the canvas */
+static void
+ganv_canvas_map(GtkWidget* widget)
+{
+ GanvCanvas* canvas;
+
+ g_return_if_fail(GANV_IS_CANVAS(widget));
+
+ /* Normal widget mapping stuff */
+
+ if (GTK_WIDGET_CLASS(canvas_parent_class)->map) {
+ (*GTK_WIDGET_CLASS(canvas_parent_class)->map)(widget);
+ }
+
+ canvas = GANV_CANVAS(widget);
+
+ if (canvas->need_update) {
+ add_idle(canvas);
+ }
+
+ /* Map items */
+
+ if (GANV_ITEM_GET_CLASS(canvas->root)->map) {
+ (*GANV_ITEM_GET_CLASS(canvas->root)->map)(canvas->root);
+ }
+}
+
+/* Unmap handler for the canvas */
+static void
+ganv_canvas_unmap(GtkWidget* widget)
+{
+ GanvCanvas* canvas;
+
+ g_return_if_fail(GANV_IS_CANVAS(widget));
+
+ canvas = GANV_CANVAS(widget);
+
+ shutdown_transients(canvas);
+
+ /* Unmap items */
+
+ if (GANV_ITEM_GET_CLASS(canvas->root)->unmap) {
+ (*GANV_ITEM_GET_CLASS(canvas->root)->unmap)(canvas->root);
+ }
+
+ /* Normal widget unmapping stuff */
+
+ if (GTK_WIDGET_CLASS(canvas_parent_class)->unmap) {
+ (*GTK_WIDGET_CLASS(canvas_parent_class)->unmap)(widget);
+ }
+}
+
+/* Realize handler for the canvas */
+static void
+ganv_canvas_realize(GtkWidget* widget)
+{
+ GanvCanvas* canvas;
+
+ g_return_if_fail(GANV_IS_CANVAS(widget));
+
+ /* Normal widget realization stuff */
+
+ if (GTK_WIDGET_CLASS(canvas_parent_class)->realize) {
+ (*GTK_WIDGET_CLASS(canvas_parent_class)->realize)(widget);
+ }
+
+ canvas = GANV_CANVAS(widget);
+
+ gdk_window_set_events(
+ canvas->layout.bin_window,
+ (GdkEventMask)(gdk_window_get_events(canvas->layout.bin_window)
+ | GDK_EXPOSURE_MASK
+ | GDK_BUTTON_PRESS_MASK
+ | GDK_BUTTON_RELEASE_MASK
+ | GDK_POINTER_MOTION_MASK
+ | GDK_KEY_PRESS_MASK
+ | GDK_KEY_RELEASE_MASK
+ | GDK_ENTER_NOTIFY_MASK
+ | GDK_LEAVE_NOTIFY_MASK
+ | GDK_FOCUS_CHANGE_MASK));
+
+ /* Create our own temporary pixmap gc and realize all the items */
+
+ canvas->pixmap_gc = gdk_gc_new(canvas->layout.bin_window);
+
+ (*GANV_ITEM_GET_CLASS(canvas->root)->realize)(canvas->root);
+}
+
+/* Unrealize handler for the canvas */
+static void
+ganv_canvas_unrealize(GtkWidget* widget)
+{
+ GanvCanvas* canvas;
+
+ g_return_if_fail(GANV_IS_CANVAS(widget));
+
+ canvas = GANV_CANVAS(widget);
+
+ shutdown_transients(canvas);
+
+ /* Unrealize items and parent widget */
+
+ (*GANV_ITEM_GET_CLASS(canvas->root)->unrealize)(canvas->root);
+
+ g_object_unref(canvas->pixmap_gc);
+ canvas->pixmap_gc = NULL;
+
+ if (GTK_WIDGET_CLASS(canvas_parent_class)->unrealize) {
+ (*GTK_WIDGET_CLASS(canvas_parent_class)->unrealize)(widget);
+ }
+}
+
+/* Handles scrolling of the canvas. Adjusts the scrolling and zooming offset to
+ * keep as much as possible of the canvas scrolling region in view.
+ */
+static void
+scroll_to(GanvCanvas* canvas, int cx, int cy)
+{
+ int scroll_width, scroll_height;
+ int right_limit, bottom_limit;
+ int old_zoom_xofs, old_zoom_yofs;
+ int changed_x = FALSE, changed_y = FALSE;
+ int canvas_width, canvas_height;
+
+ canvas_width = GTK_WIDGET(canvas)->allocation.width;
+ canvas_height = GTK_WIDGET(canvas)->allocation.height;
+
+ scroll_width = floor((canvas->scroll_x2 - canvas->scroll_x1) * canvas->pixels_per_unit
+ + 0.5);
+ scroll_height = floor((canvas->scroll_y2 - canvas->scroll_y1) * canvas->pixels_per_unit
+ + 0.5);
+
+ right_limit = scroll_width - canvas_width;
+ bottom_limit = scroll_height - canvas_height;
+
+ old_zoom_xofs = canvas->zoom_xofs;
+ old_zoom_yofs = canvas->zoom_yofs;
+
+ if (right_limit < 0) {
+ cx = 0;
+
+ if (canvas->center_scroll_region) {
+ canvas->zoom_xofs = (canvas_width - scroll_width) / 2;
+ scroll_width = canvas_width;
+ } else {
+ canvas->zoom_xofs = 0;
+ }
+ } else if (cx < 0) {
+ cx = 0;
+ canvas->zoom_xofs = 0;
+ } else if (cx > right_limit) {
+ cx = right_limit;
+ canvas->zoom_xofs = 0;
+ } else {
+ canvas->zoom_xofs = 0;
+ }
+
+ if (bottom_limit < 0) {
+ cy = 0;
+
+ if (canvas->center_scroll_region) {
+ canvas->zoom_yofs = (canvas_height - scroll_height) / 2;
+ scroll_height = canvas_height;
+ } else {
+ canvas->zoom_yofs = 0;
+ }
+ } else if (cy < 0) {
+ cy = 0;
+ canvas->zoom_yofs = 0;
+ } else if (cy > bottom_limit) {
+ cy = bottom_limit;
+ canvas->zoom_yofs = 0;
+ } else {
+ canvas->zoom_yofs = 0;
+ }
+
+ if ((canvas->zoom_xofs != old_zoom_xofs) || (canvas->zoom_yofs != old_zoom_yofs)) {
+ ganv_canvas_request_update(canvas);
+ gtk_widget_queue_draw(GTK_WIDGET(canvas));
+ }
+
+ if (canvas->layout.hadjustment && ( ((int)canvas->layout.hadjustment->value) != cx) ) {
+ canvas->layout.hadjustment->value = cx;
+ changed_x = TRUE;
+ }
+
+ if (canvas->layout.vadjustment && ( ((int)canvas->layout.vadjustment->value) != cy) ) {
+ canvas->layout.vadjustment->value = cy;
+ changed_y = TRUE;
+ }
+
+ if ((scroll_width != (int)canvas->layout.width)
+ || (scroll_height != (int)canvas->layout.height)) {
+ gtk_layout_set_size(GTK_LAYOUT(canvas), scroll_width, scroll_height);
+ }
+
+ /* Signal GtkLayout that it should do a redraw. */
+
+ if (changed_x) {
+ g_signal_emit_by_name(canvas->layout.hadjustment, "value_changed");
+ }
+
+ if (changed_y) {
+ g_signal_emit_by_name(canvas->layout.vadjustment, "value_changed");
+ }
+}
+
+/* Size allocation handler for the canvas */
+static void
+ganv_canvas_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
+{
+ GanvCanvas* canvas;
+
+ g_return_if_fail(GANV_IS_CANVAS(widget));
+ g_return_if_fail(allocation != NULL);
+
+ if (GTK_WIDGET_CLASS(canvas_parent_class)->size_allocate) {
+ (*GTK_WIDGET_CLASS(canvas_parent_class)->size_allocate)(widget, allocation);
+ }
+
+ canvas = GANV_CANVAS(widget);
+
+ /* Recenter the view, if appropriate */
+
+ canvas->layout.hadjustment->page_size = allocation->width;
+ canvas->layout.hadjustment->page_increment = allocation->width / 2;
+
+ canvas->layout.vadjustment->page_size = allocation->height;
+ canvas->layout.vadjustment->page_increment = allocation->height / 2;
+
+ scroll_to(canvas,
+ canvas->layout.hadjustment->value,
+ canvas->layout.vadjustment->value);
+
+ g_signal_emit_by_name(canvas->layout.hadjustment, "changed");
+ g_signal_emit_by_name(canvas->layout.vadjustment, "changed");
+}
+
+/* Returns whether the item is an inferior of or is equal to the parent. */
+static gboolean
+is_descendant(GanvItem* item, GanvItem* parent)
+{
+ for (; item; item = item->parent) {
+ if (item == parent) {
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+
+/* Emits an event for an item in the canvas, be it the current item, grabbed
+ * item, or focused item, as appropriate.
+ */
+int
+ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event)
+{
+ GdkEvent* ev;
+ gint finished;
+ GanvItem* item;
+ GanvItem* parent;
+ guint mask;
+
+ /* Perform checks for grabbed items */
+
+ if (canvas->grabbed_item
+ && !is_descendant(canvas->current_item, canvas->grabbed_item)) {
+ /* I think this warning is annoying and I don't know what it's for
+ * so I'll disable it for now.
+ */
+ /* g_warning ("emit_event() returning FALSE!\n");*/
+ return FALSE;
+ }
+
+ if (canvas->grabbed_item) {
+ switch (event->type) {
+ case GDK_ENTER_NOTIFY:
+ mask = GDK_ENTER_NOTIFY_MASK;
+ break;
+
+ case GDK_LEAVE_NOTIFY:
+ mask = GDK_LEAVE_NOTIFY_MASK;
+ break;
+
+ case GDK_MOTION_NOTIFY:
+ mask = GDK_POINTER_MOTION_MASK;
+ break;
+
+ case GDK_BUTTON_PRESS:
+ case GDK_2BUTTON_PRESS:
+ case GDK_3BUTTON_PRESS:
+ mask = GDK_BUTTON_PRESS_MASK;
+ break;
+
+ case GDK_BUTTON_RELEASE:
+ mask = GDK_BUTTON_RELEASE_MASK;
+ break;
+
+ case GDK_KEY_PRESS:
+ mask = GDK_KEY_PRESS_MASK;
+ break;
+
+ case GDK_KEY_RELEASE:
+ mask = GDK_KEY_RELEASE_MASK;
+ break;
+
+ case GDK_SCROLL:
+ mask = GDK_SCROLL_MASK;
+ break;
+
+ default:
+ mask = 0;
+ break;
+ }
+
+ if (!(mask & canvas->grabbed_event_mask)) {
+ return FALSE;
+ }
+ }
+
+ /* Convert to world coordinates -- we have two cases because of diferent
+ * offsets of the fields in the event structures.
+ */
+
+ ev = gdk_event_copy(event);
+
+ switch (ev->type) {
+ case GDK_ENTER_NOTIFY:
+ case GDK_LEAVE_NOTIFY:
+ ganv_canvas_window_to_world(canvas,
+ ev->crossing.x, ev->crossing.y,
+ &ev->crossing.x, &ev->crossing.y);
+ break;
+
+ case GDK_MOTION_NOTIFY:
+ case GDK_BUTTON_PRESS:
+ case GDK_2BUTTON_PRESS:
+ case GDK_3BUTTON_PRESS:
+ case GDK_BUTTON_RELEASE:
+ ganv_canvas_window_to_world(canvas,
+ ev->motion.x, ev->motion.y,
+ &ev->motion.x, &ev->motion.y);
+ break;
+
+ default:
+ break;
+ }
+
+ /* Choose where we send the event */
+
+ item = canvas->current_item;
+
+ if (canvas->focused_item
+ && ((event->type == GDK_KEY_PRESS)
+ || (event->type == GDK_KEY_RELEASE)
+ || (event->type == GDK_FOCUS_CHANGE))) {
+ item = canvas->focused_item;
+ }
+
+ /* The event is propagated up the hierarchy (for if someone connected to
+ * a group instead of a leaf event), and emission is stopped if a
+ * handler returns TRUE, just like for GtkWidget events.
+ */
+
+ finished = FALSE;
+
+ while (item && !finished) {
+ g_object_ref(G_OBJECT(item));
+
+ ganv_item_emit_event(item, ev, &finished);
+
+ parent = item->parent;
+ g_object_unref(G_OBJECT(item));
+
+ item = parent;
+ }
+
+ gdk_event_free(ev);
+
+ return finished;
+}
+
+/* Re-picks the current item in the canvas, based on the event's coordinates.
+ * Also emits enter/leave events for items as appropriate.
+ */
+static int
+pick_current_item(GanvCanvas* canvas, GdkEvent* event)
+{
+ int button_down;
+ double x, y;
+ int cx, cy;
+ int retval;
+
+ retval = FALSE;
+
+ /* If a button is down, we'll perform enter and leave events on the
+ * current item, but not enter on any other item. This is more or less
+ * like X pointer grabbing for canvas items.
+ */
+ button_down = canvas->state & (GDK_BUTTON1_MASK
+ | GDK_BUTTON2_MASK
+ | GDK_BUTTON3_MASK
+ | GDK_BUTTON4_MASK
+ | GDK_BUTTON5_MASK);
+ if (!button_down) {
+ canvas->left_grabbed_item = FALSE;
+ }
+
+ /* Save the event in the canvas. This is used to synthesize enter and
+ * leave events in case the current item changes. It is also used to
+ * re-pick the current item if the current one gets deleted. Also,
+ * synthesize an enter event.
+ */
+ if (event != &canvas->pick_event) {
+ if ((event->type == GDK_MOTION_NOTIFY) || (event->type == GDK_BUTTON_RELEASE)) {
+ /* these fields have the same offsets in both types of events */
+
+ canvas->pick_event.crossing.type = GDK_ENTER_NOTIFY;
+ canvas->pick_event.crossing.window = event->motion.window;
+ canvas->pick_event.crossing.send_event = event->motion.send_event;
+ canvas->pick_event.crossing.subwindow = NULL;
+ canvas->pick_event.crossing.x = event->motion.x;
+ canvas->pick_event.crossing.y = event->motion.y;
+ canvas->pick_event.crossing.mode = GDK_CROSSING_NORMAL;
+ canvas->pick_event.crossing.detail = GDK_NOTIFY_NONLINEAR;
+ canvas->pick_event.crossing.focus = FALSE;
+ canvas->pick_event.crossing.state = event->motion.state;
+
+ /* these fields don't have the same offsets in both types of events */
+
+ if (event->type == GDK_MOTION_NOTIFY) {
+ canvas->pick_event.crossing.x_root = event->motion.x_root;
+ canvas->pick_event.crossing.y_root = event->motion.y_root;
+ } else {
+ canvas->pick_event.crossing.x_root = event->button.x_root;
+ canvas->pick_event.crossing.y_root = event->button.y_root;
+ }
+ } else {
+ canvas->pick_event = *event;
+ }
+ }
+
+ /* Don't do anything else if this is a recursive call */
+
+ if (canvas->in_repick) {
+ return retval;
+ }
+
+ /* LeaveNotify means that there is no current item, so we don't look for one */
+
+ if (canvas->pick_event.type != GDK_LEAVE_NOTIFY) {
+ /* these fields don't have the same offsets in both types of events */
+
+ if (canvas->pick_event.type == GDK_ENTER_NOTIFY) {
+ x = canvas->pick_event.crossing.x - canvas->zoom_xofs;
+ y = canvas->pick_event.crossing.y - canvas->zoom_yofs;
+ } else {
+ x = canvas->pick_event.motion.x - canvas->zoom_xofs;
+ y = canvas->pick_event.motion.y - canvas->zoom_yofs;
+ }
+
+ /* canvas pixel coords */
+
+ cx = (int)(x + 0.5);
+ cy = (int)(y + 0.5);
+
+ /* world coords */
+
+ x = canvas->scroll_x1 + x / canvas->pixels_per_unit;
+ y = canvas->scroll_y1 + y / canvas->pixels_per_unit;
+
+ /* find the closest item */
+
+ if (canvas->root->object.flags & GANV_ITEM_VISIBLE) {
+ GANV_ITEM_GET_CLASS(canvas->root)->point(
+ canvas->root,
+ x - canvas->root->x, y - canvas->root->y,
+ cx, cy,
+ &canvas->new_current_item);
+ } else {
+ canvas->new_current_item = NULL;
+ }
+ } else {
+ canvas->new_current_item = NULL;
+ }
+
+ if ((canvas->new_current_item == canvas->current_item) && !canvas->left_grabbed_item) {
+ return retval; /* current item did not change */
+
+ }
+ /* Synthesize events for old and new current items */
+
+ if ((canvas->new_current_item != canvas->current_item)
+ && (canvas->current_item != NULL)
+ && !canvas->left_grabbed_item) {
+ GdkEvent new_event;
+
+ new_event = canvas->pick_event;
+ new_event.type = GDK_LEAVE_NOTIFY;
+
+ new_event.crossing.detail = GDK_NOTIFY_ANCESTOR;
+ new_event.crossing.subwindow = NULL;
+ canvas->in_repick = TRUE;
+ retval = ganv_canvas_emit_event(canvas, &new_event);
+ canvas->in_repick = FALSE;
+ }
+
+ /* new_current_item may have been set to NULL during the call to ganv_canvas_emit_event() above */
+
+ if ((canvas->new_current_item != canvas->current_item) && button_down) {
+ canvas->left_grabbed_item = TRUE;
+ return retval;
+ }
+
+ /* Handle the rest of cases */
+
+ canvas->left_grabbed_item = FALSE;
+ canvas->current_item = canvas->new_current_item;
+
+ if (canvas->current_item != NULL) {
+ GdkEvent new_event;
+
+ new_event = canvas->pick_event;
+ new_event.type = GDK_ENTER_NOTIFY;
+ new_event.crossing.detail = GDK_NOTIFY_ANCESTOR;
+ new_event.crossing.subwindow = NULL;
+ retval = ganv_canvas_emit_event(canvas, &new_event);
+ }
+
+ return retval;
+}
+
+/* Button event handler for the canvas */
+static gint
+ganv_canvas_button(GtkWidget* widget, GdkEventButton* event)
+{
+ GanvCanvas* canvas;
+ int mask;
+ int retval;
+
+ g_return_val_if_fail(GANV_IS_CANVAS(widget), FALSE);
+ g_return_val_if_fail(event != NULL, FALSE);
+
+ retval = FALSE;
+
+ canvas = GANV_CANVAS(widget);
+
+ /*
+ * dispatch normally regardless of the event's window if an item has
+ * has a pointer grab in effect
+ */
+ if (!canvas->grabbed_item && ( event->window != canvas->layout.bin_window) ) {
+ return retval;
+ }
+
+ switch (event->button) {
+ case 1:
+ mask = GDK_BUTTON1_MASK;
+ break;
+ case 2:
+ mask = GDK_BUTTON2_MASK;
+ break;
+ case 3:
+ mask = GDK_BUTTON3_MASK;
+ break;
+ case 4:
+ mask = GDK_BUTTON4_MASK;
+ break;
+ case 5:
+ mask = GDK_BUTTON5_MASK;
+ break;
+ default:
+ mask = 0;
+ }
+
+ switch (event->type) {
+ case GDK_BUTTON_PRESS:
+ case GDK_2BUTTON_PRESS:
+ case GDK_3BUTTON_PRESS:
+ /* Pick the current item as if the button were not pressed, and
+ * then process the event.
+ */
+ canvas->state = event->state;
+ pick_current_item(canvas, (GdkEvent*)event);
+ canvas->state ^= mask;
+ retval = ganv_canvas_emit_event(canvas, (GdkEvent*)event);
+ break;
+
+ case GDK_BUTTON_RELEASE:
+ /* Process the event as if the button were pressed, then repick
+ * after the button has been released
+ */
+ canvas->state = event->state;
+ retval = ganv_canvas_emit_event(canvas, (GdkEvent*)event);
+ event->state ^= mask;
+ canvas->state = event->state;
+ pick_current_item(canvas, (GdkEvent*)event);
+ event->state ^= mask;
+ break;
+
+ default:
+ g_assert_not_reached();
+ }
+
+ return retval;
+}
+
+/* Motion event handler for the canvas */
+static gint
+ganv_canvas_motion(GtkWidget* widget, GdkEventMotion* event)
+{
+ GanvCanvas* canvas;
+
+ g_return_val_if_fail(GANV_IS_CANVAS(widget), FALSE);
+ g_return_val_if_fail(event != NULL, FALSE);
+
+ canvas = GANV_CANVAS(widget);
+
+ if (event->window != canvas->layout.bin_window) {
+ return FALSE;
+ }
+
+ canvas->state = event->state;
+ pick_current_item(canvas, (GdkEvent*)event);
+ return ganv_canvas_emit_event(canvas, (GdkEvent*)event);
+}
+
+static gboolean
+ganv_canvas_scroll(GtkWidget* widget, GdkEventScroll* event)
+{
+ GanvCanvas* canvas;
+
+ g_return_val_if_fail(GANV_IS_CANVAS(widget), FALSE);
+ g_return_val_if_fail(event != NULL, FALSE);
+
+ canvas = GANV_CANVAS(widget);
+
+ if (event->window != canvas->layout.bin_window) {
+ return FALSE;
+ }
+
+ canvas->state = event->state;
+ pick_current_item(canvas, (GdkEvent*)event);
+ return ganv_canvas_emit_event(canvas, (GdkEvent*)event);
+}
+
+/* Key event handler for the canvas */
+static gboolean
+ganv_canvas_key(GtkWidget* widget, GdkEventKey* event)
+{
+ GanvCanvas* canvas;
+
+ g_return_val_if_fail(GANV_IS_CANVAS(widget), FALSE);
+ g_return_val_if_fail(event != NULL, FALSE);
+
+ canvas = GANV_CANVAS(widget);
+
+ if (!ganv_canvas_emit_event(canvas, (GdkEvent*)event)) {
+ GtkWidgetClass* widget_class;
+
+ widget_class = GTK_WIDGET_CLASS(canvas_parent_class);
+
+ if (event->type == GDK_KEY_PRESS) {
+ if (widget_class->key_press_event) {
+ return (*widget_class->key_press_event)(widget, event);
+ }
+ } else if (event->type == GDK_KEY_RELEASE) {
+ if (widget_class->key_release_event) {
+ return (*widget_class->key_release_event)(widget, event);
+ }
+ } else {
+ g_assert_not_reached();
+ }
+
+ return FALSE;
+ } else {
+ return TRUE;
+ }
+}
+
+/* Crossing event handler for the canvas */
+static gint
+ganv_canvas_crossing(GtkWidget* widget, GdkEventCrossing* event)
+{
+ GanvCanvas* canvas;
+
+ g_return_val_if_fail(GANV_IS_CANVAS(widget), FALSE);
+ g_return_val_if_fail(event != NULL, FALSE);
+
+ canvas = GANV_CANVAS(widget);
+
+ if (event->window != canvas->layout.bin_window) {
+ return FALSE;
+ }
+
+ canvas->state = event->state;
+ return pick_current_item(canvas, (GdkEvent*)event);
+}
+
+/* Focus in handler for the canvas */
+static gint
+ganv_canvas_focus_in(GtkWidget* widget, GdkEventFocus* event)
+{
+ GanvCanvas* canvas;
+
+ GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
+
+ canvas = GANV_CANVAS(widget);
+
+ if (canvas->focused_item) {
+ return ganv_canvas_emit_event(canvas, (GdkEvent*)event);
+ } else {
+ return FALSE;
+ }
+}
+
+/* Focus out handler for the canvas */
+static gint
+ganv_canvas_focus_out(GtkWidget* widget, GdkEventFocus* event)
+{
+ GanvCanvas* canvas;
+
+ GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
+
+ canvas = GANV_CANVAS(widget);
+
+ if (canvas->focused_item) {
+ return ganv_canvas_emit_event(canvas, (GdkEvent*)event);
+ } else {
+ return FALSE;
+ }
+}
+
+#define REDRAW_QUANTUM_SIZE 512
+
+static void
+ganv_canvas_paint_rect(GanvCanvas* canvas, gint x0, gint y0, gint x1, gint y1)
+{
+ gint draw_x1, draw_y1;
+ gint draw_x2, draw_y2;
+ gint draw_width, draw_height;
+
+ g_return_if_fail(!canvas->need_update);
+
+ draw_x1 = MAX(x0, canvas->layout.hadjustment->value - canvas->zoom_xofs);
+ draw_y1 = MAX(y0, canvas->layout.vadjustment->value - canvas->zoom_yofs);
+ draw_x2 = MIN(draw_x1 + GTK_WIDGET(canvas)->allocation.width, x1);
+ draw_y2 = MIN(draw_y1 + GTK_WIDGET(canvas)->allocation.height, y1);
+
+ draw_width = draw_x2 - draw_x1;
+ draw_height = draw_y2 - draw_y1;
+
+ if ((draw_width < 1) || (draw_height < 1)) {
+ return;
+ }
+
+ canvas->redraw_x1 = draw_x1;
+ canvas->redraw_y1 = draw_y1;
+ canvas->redraw_x2 = draw_x2;
+ canvas->redraw_y2 = draw_y2;
+ canvas->draw_xofs = draw_x1;
+ canvas->draw_yofs = draw_y1;
+
+ cairo_t* cr = gdk_cairo_create(canvas->layout.bin_window);
+
+ double wx, wy;
+ ganv_canvas_window_to_world(canvas, 0, 0, &wx, &wy);
+ cairo_translate(cr, -wx, -wy);
+
+ if (canvas->root->object.flags & GANV_ITEM_VISIBLE) {
+ (*GANV_ITEM_GET_CLASS(canvas->root)->draw)(
+ canvas->root, cr,
+ draw_x1, draw_y1,
+ draw_width, draw_height);
+ }
+
+ cairo_destroy(cr);
+}
+
+/* Expose handler for the canvas */
+static gint
+ganv_canvas_expose(GtkWidget* widget, GdkEventExpose* event)
+{
+ GanvCanvas* canvas = GANV_CANVAS(widget);
+ if (!GTK_WIDGET_DRAWABLE(widget) ||
+ (event->window != canvas->layout.bin_window)) {
+ return FALSE;
+ }
+
+ /* Find a single bounding rectangle for all rectangles in the region.
+ Since drawing the root group is O(n) and thus very expensive for large
+ canvases, it's much faster to do a single paint than many, even though
+ more area may be painted that way. With a better group implementation,
+ it would likely be better to paint each changed rectangle separately. */
+ GdkRectangle clip;
+ gdk_region_get_clipbox(event->region, &clip);
+
+ const int x2 = clip.x + clip.width;
+ const int y2 = clip.y + clip.height;
+
+ if (canvas->need_update || canvas->need_redraw) {
+ /* Update or drawing is scheduled, so just mark exposed area as dirty */
+ ganv_canvas_request_redraw(canvas, clip.x, clip.y, x2, y2);
+ } else {
+ /* No pending updates, draw exposed area immediately */
+ ganv_canvas_paint_rect(canvas, clip.x, clip.y, x2, y2);
+
+ /* And call expose on parent container class */
+ if (GTK_WIDGET_CLASS(canvas_parent_class)->expose_event) {
+ (*GTK_WIDGET_CLASS(canvas_parent_class)->expose_event)(
+ widget, event);
+ }
+ }
+
+ return FALSE;
+}
+
+/* Repaints the areas in the canvas that need it */
+static void
+paint(GanvCanvas* canvas)
+{
+ for (GSList* l = canvas->redraw_region; l; l = l->next) {
+ IRect* rect = (IRect*)l->data;
+
+ const GdkRectangle gdkrect = {
+ rect->x + canvas->zoom_xofs,
+ rect->y + canvas->zoom_yofs,
+ rect->width,
+ rect->height
+ };
+
+ gdk_window_invalidate_rect(canvas->layout.bin_window, &gdkrect, FALSE);
+ g_free(rect);
+ }
+
+ g_slist_free(canvas->redraw_region);
+ canvas->redraw_region = NULL;
+ canvas->need_redraw = FALSE;
+
+ canvas->redraw_x1 = 0;
+ canvas->redraw_y1 = 0;
+ canvas->redraw_x2 = 0;
+ canvas->redraw_y2 = 0;
+}
+
+static void
+do_update(GanvCanvas* canvas)
+{
+ /* Cause the update if necessary */
+
+update_again:
+ if (canvas->need_update) {
+ ganv_item_invoke_update(canvas->root, 0);
+
+ canvas->need_update = FALSE;
+ }
+
+ /* Pick new current item */
+
+ while (canvas->need_repick) {
+ canvas->need_repick = FALSE;
+ pick_current_item(canvas, &canvas->pick_event);
+ }
+
+ /* it is possible that during picking we emitted an event in which
+ the user then called some function which then requested update
+ of something. Without this we'd be left in a state where
+ need_update would have been left TRUE and the canvas would have
+ been left unpainted. */
+ if (canvas->need_update) {
+ goto update_again;
+ }
+
+ /* Paint if able to */
+
+ if (GTK_WIDGET_DRAWABLE(canvas) && canvas->need_redraw) {
+ paint(canvas);
+ }
+}
+
+/* Idle handler for the canvas. It deals with pending updates and redraws. */
+static gboolean
+idle_handler(gpointer data)
+{
+ GanvCanvas* canvas;
+
+ GDK_THREADS_ENTER();
+
+ canvas = GANV_CANVAS(data);
+
+ do_update(canvas);
+
+ /* Reset idle id */
+ canvas->idle_id = 0;
+
+ GDK_THREADS_LEAVE();
+
+ return FALSE;
+}
+
+/* Convenience function to add an idle handler to a canvas */
+static void
+add_idle(GanvCanvas* canvas)
+{
+ g_assert(canvas->need_update || canvas->need_redraw);
+
+ if (!canvas->idle_id) {
+ canvas->idle_id = g_idle_add_full(CANVAS_IDLE_PRIORITY,
+ idle_handler,
+ canvas,
+ NULL);
+ }
+
+ /* canvas->idle_id = gtk_idle_add (idle_handler, canvas); */
+}
+
+/**
+ * ganv_canvas_root:
+ * @canvas: A canvas.
+ *
+ * Return value: (transfer none): The root group of the canvas.
+ */
+GanvItem*
+ganv_canvas_root(GanvCanvas* canvas)
+{
+ g_return_val_if_fail(GANV_IS_CANVAS(canvas), NULL);
+
+ return canvas->root;
+}
+
+/**
+ * ganv_canvas_set_scroll_region:
+ * @canvas: A canvas.
+ * @x1: Leftmost limit of the scrolling region.
+ * @y1: Upper limit of the scrolling region.
+ * @x2: Rightmost limit of the scrolling region.
+ * @y2: Lower limit of the scrolling region.
+ *
+ * Sets the scrolling region of a canvas to the specified rectangle. The canvas
+ * will then be able to scroll only within this region. The view of the canvas
+ * is adjusted as appropriate to display as much of the new region as possible.
+ **/
+void
+ganv_canvas_set_scroll_region(GanvCanvas* canvas, double x1, double y1, double x2,
+ double y2)
+{
+ double wxofs, wyofs;
+ int xofs, yofs;
+
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ /*
+ * Set the new scrolling region. If possible, do not move the visible contents of the
+ * canvas.
+ */
+
+ ganv_canvas_c2w(canvas,
+ GTK_LAYOUT(canvas)->hadjustment->value + canvas->zoom_xofs,
+ GTK_LAYOUT(canvas)->vadjustment->value + canvas->zoom_yofs,
+ /*canvas->zoom_xofs,
+ canvas->zoom_yofs,*/
+ &wxofs, &wyofs);
+
+ canvas->scroll_x1 = x1;
+ canvas->scroll_y1 = y1;
+ canvas->scroll_x2 = x2;
+ canvas->scroll_y2 = y2;
+
+ ganv_canvas_w2c(canvas, wxofs, wyofs, &xofs, &yofs);
+
+ scroll_to(canvas, xofs, yofs);
+
+ canvas->need_repick = TRUE;
+#if 0
+ /* todo: should be requesting update */
+ (*GANV_ITEM_CLASS(canvas->root->object.klass)->update)(
+ canvas->root, NULL, NULL, 0);
+#endif
+}
+
+/**
+ * ganv_canvas_get_scroll_region:
+ * @canvas: A canvas.
+ * @x1: Leftmost limit of the scrolling region (return value).
+ * @y1: Upper limit of the scrolling region (return value).
+ * @x2: Rightmost limit of the scrolling region (return value).
+ * @y2: Lower limit of the scrolling region (return value).
+ *
+ * Queries the scrolling region of a canvas.
+ **/
+void
+ganv_canvas_get_scroll_region(GanvCanvas* canvas, double* x1, double* y1, double* x2,
+ double* y2)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ if (x1) {
+ *x1 = canvas->scroll_x1;
+ }
+
+ if (y1) {
+ *y1 = canvas->scroll_y1;
+ }
+
+ if (x2) {
+ *x2 = canvas->scroll_x2;
+ }
+
+ if (y2) {
+ *y2 = canvas->scroll_y2;
+ }
+}
+
+/**
+ * ganv_canvas_set_center_scroll_region:
+ * @canvas: A canvas.
+ * @center_scroll_region: Whether to center the scrolling region in the canvas
+ * window when it is smaller than the canvas' allocation.
+ *
+ * When the scrolling region of the canvas is smaller than the canvas window,
+ * e.g. the allocation of the canvas, it can be either centered on the window
+ * or simply made to be on the upper-left corner on the window. This function
+ * lets you configure this property.
+ **/
+void
+ganv_canvas_set_center_scroll_region(GanvCanvas* canvas, gboolean center_scroll_region)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ canvas->center_scroll_region = center_scroll_region != 0;
+
+ scroll_to(canvas,
+ canvas->layout.hadjustment->value,
+ canvas->layout.vadjustment->value);
+}
+
+/**
+ * ganv_canvas_get_center_scroll_region:
+ * @canvas: A canvas.
+ *
+ * Returns whether the canvas is set to center the scrolling region in the window
+ * if the former is smaller than the canvas' allocation.
+ *
+ * Return value: Whether the scroll region is being centered in the canvas window.
+ **/
+gboolean
+ganv_canvas_get_center_scroll_region(GanvCanvas* canvas)
+{
+ g_return_val_if_fail(GANV_IS_CANVAS(canvas), FALSE);
+
+ return canvas->center_scroll_region ? TRUE : FALSE;
+}
+
+/**
+ * ganv_canvas_set_pixels_per_unit:
+ * @canvas: A canvas.
+ * @n: The number of pixels that correspond to one canvas unit.
+ *
+ * Sets the zooming factor of a canvas by specifying the number of pixels that
+ * correspond to one canvas unit.
+ *
+ * The anchor point for zooming, i.e. the point that stays fixed and all others
+ * zoom inwards or outwards from it, depends on whether the canvas is set to
+ * center the scrolling region or not. You can control this using the
+ * ganv_canvas_set_center_scroll_region() function. If the canvas is set to
+ * center the scroll region, then the center of the canvas window is used as the
+ * anchor point for zooming. Otherwise, the upper-left corner of the canvas
+ * window is used as the anchor point.
+ **/
+void
+ganv_canvas_set_pixels_per_unit(GanvCanvas* canvas, double n)
+{
+ double ax, ay;
+ int x1, y1;
+ int anchor_x, anchor_y;
+
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+ g_return_if_fail(n > 1e-10);
+
+ if (canvas->center_scroll_region) {
+ anchor_x = GTK_WIDGET(canvas)->allocation.width / 2;
+ anchor_y = GTK_WIDGET(canvas)->allocation.height / 2;
+ } else {
+ anchor_x = anchor_y = 0;
+ }
+
+ /* Find the coordinates of the anchor point in units. */
+ if (canvas->layout.hadjustment) {
+ ax
+ = (canvas->layout.hadjustment->value
+ + anchor_x) / canvas->pixels_per_unit + canvas->scroll_x1 + canvas->zoom_xofs;
+ } else {
+ ax = (0.0 + anchor_x) / canvas->pixels_per_unit + canvas->scroll_x1 + canvas->zoom_xofs;
+ }
+ if (canvas->layout.hadjustment) {
+ ay
+ = (canvas->layout.vadjustment->value
+ + anchor_y) / canvas->pixels_per_unit + canvas->scroll_y1 + canvas->zoom_yofs;
+ } else {
+ ay = (0.0 + anchor_y) / canvas->pixels_per_unit + canvas->scroll_y1 + canvas->zoom_yofs;
+ }
+
+ /* Now calculate the new offset of the upper left corner. */
+ x1 = ((ax - canvas->scroll_x1) * n) - anchor_x;
+ y1 = ((ay - canvas->scroll_y1) * n) - anchor_y;
+
+ canvas->pixels_per_unit = n;
+
+ scroll_to(canvas, x1, y1);
+
+ ganv_canvas_request_update(canvas);
+ canvas->need_repick = TRUE;
+}
+
+/**
+ * ganv_canvas_scroll_to:
+ * @canvas: A canvas.
+ * @cx: Horizontal scrolling offset in canvas pixel units.
+ * @cy: Vertical scrolling offset in canvas pixel units.
+ *
+ * Makes a canvas scroll to the specified offsets, given in canvas pixel units.
+ * The canvas will adjust the view so that it is not outside the scrolling
+ * region. This function is typically not used, as it is better to hook
+ * scrollbars to the canvas layout's scrolling adjusments.
+ **/
+void
+ganv_canvas_scroll_to(GanvCanvas* canvas, int cx, int cy)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ scroll_to(canvas, cx, cy);
+}
+
+/**
+ * ganv_canvas_get_scroll_offsets:
+ * @canvas: A canvas.
+ * @cx: Horizontal scrolling offset (return value).
+ * @cy: Vertical scrolling offset (return value).
+ *
+ * Queries the scrolling offsets of a canvas. The values are returned in canvas
+ * pixel units.
+ **/
+void
+ganv_canvas_get_scroll_offsets(GanvCanvas* canvas, int* cx, int* cy)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ if (cx) {
+ *cx = canvas->layout.hadjustment->value;
+ }
+
+ if (cy) {
+ *cy = canvas->layout.vadjustment->value;
+ }
+}
+
+/**
+ * ganv_canvas_get_item_at:
+ * @canvas: A canvas.
+ * @x: X position in world coordinates.
+ * @y: Y position in world coordinates.
+ *
+ * Looks for the item that is under the specified position, which must be
+ * specified in world coordinates.
+ *
+ * Return value: (transfer none): The sought item, or NULL if no item is at the
+ * specified coordinates.
+ **/
+GanvItem*
+ganv_canvas_get_item_at(GanvCanvas* canvas, double x, double y)
+{
+ GanvItem* item;
+ double dist;
+ int cx, cy;
+
+ g_return_val_if_fail(GANV_IS_CANVAS(canvas), NULL);
+
+ ganv_canvas_w2c(canvas, x, y, &cx, &cy);
+
+ dist = GANV_ITEM_GET_CLASS(canvas->root)->point(
+ canvas->root,
+ x - canvas->root->x, y - canvas->root->y,
+ cx, cy,
+ &item);
+ if ((int)(dist * canvas->pixels_per_unit + 0.5) <= canvas->close_enough) {
+ return item;
+ } else {
+ return NULL;
+ }
+}
+
+/* Queues an update of the canvas */
+void
+ganv_canvas_request_update(GanvCanvas* canvas)
+{
+ GANV_CANVAS_GET_CLASS(canvas)->request_update(canvas);
+}
+
+static void
+ganv_canvas_request_update_real(GanvCanvas* canvas)
+{
+ if (canvas->need_update) {
+ return;
+ }
+
+ canvas->need_update = TRUE;
+ if (GTK_WIDGET_MAPPED((GtkWidget*)canvas)) {
+ add_idle(canvas);
+ }
+}
+
+static inline gboolean
+rect_overlaps(const IRect* a, const IRect* b)
+{
+ if ((a->x > b->x + b->width) ||
+ (a->y > b->y + b->height) ||
+ (a->x + a->width < b->x) ||
+ (a->y + a->height < b->y)) {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static inline gboolean
+rect_is_visible(GanvCanvas* canvas, const IRect* r)
+{
+ const IRect rect = {
+ (int)(canvas->layout.hadjustment->value - canvas->zoom_xofs),
+ (int)(canvas->layout.vadjustment->value - canvas->zoom_yofs),
+ GTK_WIDGET(canvas)->allocation.width,
+ GTK_WIDGET(canvas)->allocation.height
+ };
+
+ return rect_overlaps(&rect, r);
+}
+
+/**
+ * ganv_canvas_request_redraw:
+ * @canvas: A canvas.
+ * @x1: Leftmost coordinate of the rectangle to be redrawn.
+ * @y1: Upper coordinate of the rectangle to be redrawn.
+ * @x2: Rightmost coordinate of the rectangle to be redrawn, plus 1.
+ * @y2: Lower coordinate of the rectangle to be redrawn, plus 1.
+ *
+ * Informs a canvas that the specified area needs to be repainted. To be used
+ * only by item implementations.
+ **/
+void
+ganv_canvas_request_redraw(GanvCanvas* canvas, int x1, int y1, int x2, int y2)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ if (!GTK_WIDGET_DRAWABLE(canvas) || (x1 >= x2) || (y1 >= y2)) {
+ return;
+ }
+
+ const IRect rect = { x1, y1, x2 - x1, y2 - y1 };
+
+ if (!rect_is_visible(canvas, &rect)) {
+ return;
+ }
+
+ IRect* r = (IRect*)g_malloc(sizeof(IRect));
+ *r = rect;
+
+ canvas->redraw_region = g_slist_prepend(canvas->redraw_region, r);
+ canvas->need_redraw = TRUE;
+
+ if (canvas->idle_id == 0) {
+ add_idle(canvas);
+ }
+}
+
+/**
+ * ganv_canvas_w2c_affine:
+ * @canvas: A canvas.
+ * @matrix: An affine transformation matrix (return value).
+ *
+ * Gets the affine transform that converts from world coordinates to canvas
+ * pixel coordinates.
+ **/
+void
+ganv_canvas_w2c_affine(GanvCanvas* canvas, cairo_matrix_t* matrix)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+ g_return_if_fail(matrix != NULL);
+
+ cairo_matrix_init_translate(matrix,
+ -canvas->scroll_x1,
+ -canvas->scroll_y1);
+
+ cairo_matrix_scale(matrix,
+ canvas->pixels_per_unit,
+ canvas->pixels_per_unit);
+}
+
+/**
+ * ganv_canvas_w2c:
+ * @canvas: A canvas.
+ * @wx: World X coordinate.
+ * @wy: World Y coordinate.
+ * @cx: X pixel coordinate (return value).
+ * @cy: Y pixel coordinate (return value).
+ *
+ * Converts world coordinates into canvas pixel coordinates.
+ **/
+void
+ganv_canvas_w2c(GanvCanvas* canvas, double wx, double wy, int* cx, int* cy)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ cairo_matrix_t matrix;
+ ganv_canvas_w2c_affine(canvas, &matrix);
+
+ cairo_matrix_transform_point(&matrix, &wx, &wy);
+
+ if (cx) {
+ *cx = floor(wx + 0.5);
+ }
+ if (cy) {
+ *cy = floor(wy + 0.5);
+ }
+}
+
+/**
+ * ganv_canvas_w2c_d:
+ * @canvas: A canvas.
+ * @wx: World X coordinate.
+ * @wy: World Y coordinate.
+ * @cx: X pixel coordinate (return value).
+ * @cy: Y pixel coordinate (return value).
+ *
+ * Converts world coordinates into canvas pixel coordinates. This
+ * version returns coordinates in floating point coordinates, for
+ * greater precision.
+ **/
+void
+ganv_canvas_w2c_d(GanvCanvas* canvas, double wx, double wy, double* cx, double* cy)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ cairo_matrix_t matrix;
+ ganv_canvas_w2c_affine(canvas, &matrix);
+
+ cairo_matrix_transform_point(&matrix, &wx, &wy);
+
+ if (cx) {
+ *cx = wx;
+ }
+ if (cy) {
+ *cy = wy;
+ }
+}
+
+/**
+ * ganv_canvas_c2w:
+ * @canvas: A canvas.
+ * @cx: Canvas pixel X coordinate.
+ * @cy: Canvas pixel Y coordinate.
+ * @wx: X world coordinate (return value).
+ * @wy: Y world coordinate (return value).
+ *
+ * Converts canvas pixel coordinates to world coordinates.
+ **/
+void
+ganv_canvas_c2w(GanvCanvas* canvas, int cx, int cy, double* wx, double* wy)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ cairo_matrix_t matrix;
+ ganv_canvas_w2c_affine(canvas, &matrix);
+ cairo_matrix_invert(&matrix);
+
+ double x = cx;
+ double y = cy;
+ cairo_matrix_transform_point(&matrix, &x, &y);
+
+ if (wx) {
+ *wx = x;
+ }
+ if (wy) {
+ *wy = y;
+ }
+}
+
+/**
+ * ganv_canvas_window_to_world:
+ * @canvas: A canvas.
+ * @winx: Window-relative X coordinate.
+ * @winy: Window-relative Y coordinate.
+ * @worldx: X world coordinate (return value).
+ * @worldy: Y world coordinate (return value).
+ *
+ * Converts window-relative coordinates into world coordinates. You can use
+ * this when you need to convert mouse coordinates into world coordinates, for
+ * example.
+ **/
+void
+ganv_canvas_window_to_world(GanvCanvas* canvas, double winx, double winy,
+ double* worldx, double* worldy)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ if (worldx) {
+ *worldx = canvas->scroll_x1 + ((winx - canvas->zoom_xofs)
+ / canvas->pixels_per_unit);
+ }
+
+ if (worldy) {
+ *worldy = canvas->scroll_y1 + ((winy - canvas->zoom_yofs)
+ / canvas->pixels_per_unit);
+ }
+}
+
+/**
+ * ganv_canvas_world_to_window:
+ * @canvas: A canvas.
+ * @worldx: World X coordinate.
+ * @worldy: World Y coordinate.
+ * @winx: X window-relative coordinate.
+ * @winy: Y window-relative coordinate.
+ *
+ * Converts world coordinates into window-relative coordinates.
+ **/
+void
+ganv_canvas_world_to_window(GanvCanvas* canvas, double worldx, double worldy,
+ double* winx, double* winy)
+{
+ g_return_if_fail(GANV_IS_CANVAS(canvas));
+
+ if (winx) {
+ *winx = (canvas->pixels_per_unit) * (worldx - canvas->scroll_x1) + canvas->zoom_xofs;
+ }
+
+ if (winy) {
+ *winy = (canvas->pixels_per_unit) * (worldy - canvas->scroll_y1) + canvas->zoom_yofs;
+ }
+}
+
} // extern "C"
diff --git a/src/box.c b/src/box.c
index 8847066..381eb9c 100644
--- a/src/box.c
+++ b/src/box.c
@@ -153,7 +153,7 @@ ganv_box_request_redraw(GanvItem* item,
ganv_item_i2w_pair(item, &x1, &y1, &x2, &y2);
}
- ganv_canvas_base_request_redraw(item->canvas, x1, y1, x2, y2);
+ ganv_canvas_request_redraw(item->canvas, x1, y1, x2, y2);
}
static void
@@ -198,8 +198,8 @@ ganv_box_update(GanvItem* item, int flags)
ganv_item_i2w_pair(item, &x1, &y1, &x2, &y2);
// Update item canvas coordinates
- ganv_canvas_base_w2c_d(GANV_CANVAS_BASE(item->canvas), x1, y1, &item->x1, &item->y1);
- ganv_canvas_base_w2c_d(GANV_CANVAS_BASE(item->canvas), x2, y2, &item->x2, &item->y2);
+ ganv_canvas_w2c_d(item->canvas, x1, y1, &item->x1, &item->y1);
+ ganv_canvas_w2c_d(item->canvas, x2, y2, &item->x2, &item->y2);
// Request redraw of new location
ganv_box_request_redraw(item, &impl->coords, FALSE);
@@ -337,9 +337,9 @@ ganv_box_is_within(const GanvNode* self,
ganv_item_i2w_pair(GANV_ITEM(self), &bx1, &by1, &bx2, &by2);
return ( bx1 >= x1
- && by2 >= y1
- && bx2 <= x2
- && by2 <= y2);
+ && by2 >= y1
+ && bx2 <= x2
+ && by2 <= y2);
}
static void
diff --git a/src/canvas-base.c b/src/canvas-base.c
deleted file mode 100644
index 9691bff..0000000
--- a/src/canvas-base.c
+++ /dev/null
@@ -1,1728 +0,0 @@
-/* This file is part of Ganv.
- * Copyright 2007-2013 David Robillard <http://drobilla.net>
- *
- * Ganv is free software: you can redistribute it and/or modify it under the
- * terms of the GNU General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or any later version.
- *
- * Ganv 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 General Public License for details.
- *
- * You should have received a copy of the GNU General Public License along
- * with Ganv. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/* Based on GnomeCanvas, by Federico Mena <federico@nuclecu.unam.mx>
- * and Raph Levien <raph@gimp.org>
- * Copyright 1997-2000 Free Software Foundation
- */
-
-#include <math.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <gtk/gtk.h>
-#include <cairo.h>
-
-#include "ganv/canvas-base.h"
-#include "ganv/group.h"
-
-#include "./ganv-marshal.h"
-#include "./ganv-private.h"
-#include "./gettext.h"
-
-/* We must run our idle update handler *before* GDK wants to redraw. */
-#define CANVAS_IDLE_PRIORITY (GDK_PRIORITY_REDRAW - 5)
-
-static void add_idle(GanvCanvasBase* canvas);
-
-typedef struct {
- int x;
- int y;
- int width;
- int height;
-} IRect;
-
-/*** GanvCanvasBase ***/
-
-static void ganv_canvas_base_destroy(GtkObject* object);
-static void ganv_canvas_base_map(GtkWidget* widget);
-static void ganv_canvas_base_unmap(GtkWidget* widget);
-static void ganv_canvas_base_realize(GtkWidget* widget);
-static void ganv_canvas_base_unrealize(GtkWidget* widget);
-static void ganv_canvas_base_size_allocate(GtkWidget* widget,
- GtkAllocation* allocation);
-static gint ganv_canvas_base_button(GtkWidget* widget,
- GdkEventButton* event);
-static gint ganv_canvas_base_motion(GtkWidget* widget,
- GdkEventMotion* event);
-static gint ganv_canvas_base_expose(GtkWidget* widget,
- GdkEventExpose* event);
-static gboolean ganv_canvas_base_key(GtkWidget* widget,
- GdkEventKey* event);
-static gboolean ganv_canvas_base_scroll(GtkWidget* widget,
- GdkEventScroll* event);
-static gint ganv_canvas_base_crossing(GtkWidget* widget,
- GdkEventCrossing* event);
-static gint ganv_canvas_base_focus_in(GtkWidget* widget,
- GdkEventFocus* event);
-static gint ganv_canvas_base_focus_out(GtkWidget* widget,
- GdkEventFocus* event);
-static void ganv_canvas_base_request_update_real(GanvCanvasBase* canvas);
-
-static GtkLayoutClass* canvas_parent_class;
-
-enum {
- PROP_FOCUSED_ITEM = 1
-};
-
-G_DEFINE_TYPE(GanvCanvasBase, ganv_canvas_base, GTK_TYPE_LAYOUT)
-
-static void
-ganv_canvas_base_get_property(GObject* object,
- guint prop_id,
- GValue* value,
- GParamSpec* pspec)
-{
- switch (prop_id) {
- case PROP_FOCUSED_ITEM:
- g_value_set_object(value, GANV_CANVAS_BASE(object)->focused_item);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
- break;
- }
-}
-
-static void
-ganv_canvas_base_set_property(GObject* object,
- guint prop_id,
- const GValue* value,
- GParamSpec* pspec)
-{
- switch (prop_id) {
- case PROP_FOCUSED_ITEM:
- GANV_CANVAS_BASE(object)->focused_item = g_value_get_object(value);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
- break;
- }
-}
-
-/* Class initialization function for GanvCanvasBaseClass */
-static void
-ganv_canvas_base_class_init(GanvCanvasBaseClass* klass)
-{
- GObjectClass* gobject_class;
- GtkObjectClass* object_class;
- GtkWidgetClass* widget_class;
-
- gobject_class = (GObjectClass*)klass;
- object_class = (GtkObjectClass*)klass;
- widget_class = (GtkWidgetClass*)klass;
-
- canvas_parent_class = g_type_class_peek_parent(klass);
-
- gobject_class->set_property = ganv_canvas_base_set_property;
- gobject_class->get_property = ganv_canvas_base_get_property;
-
- object_class->destroy = ganv_canvas_base_destroy;
-
- widget_class->map = ganv_canvas_base_map;
- widget_class->unmap = ganv_canvas_base_unmap;
- widget_class->realize = ganv_canvas_base_realize;
- widget_class->unrealize = ganv_canvas_base_unrealize;
- widget_class->size_allocate = ganv_canvas_base_size_allocate;
- widget_class->button_press_event = ganv_canvas_base_button;
- widget_class->button_release_event = ganv_canvas_base_button;
- widget_class->motion_notify_event = ganv_canvas_base_motion;
- widget_class->expose_event = ganv_canvas_base_expose;
- widget_class->key_press_event = ganv_canvas_base_key;
- widget_class->key_release_event = ganv_canvas_base_key;
- widget_class->enter_notify_event = ganv_canvas_base_crossing;
- widget_class->leave_notify_event = ganv_canvas_base_crossing;
- widget_class->focus_in_event = ganv_canvas_base_focus_in;
- widget_class->focus_out_event = ganv_canvas_base_focus_out;
- widget_class->scroll_event = ganv_canvas_base_scroll;
-
- klass->request_update = ganv_canvas_base_request_update_real;
-
- g_object_class_install_property(gobject_class, PROP_FOCUSED_ITEM,
- g_param_spec_object("focused_item", NULL, NULL,
- GANV_TYPE_ITEM,
- (G_PARAM_READABLE | G_PARAM_WRITABLE)));
-}
-
-/* Callback used when the root item of a canvas is destroyed. The user should
- * never ever do this, so we panic if this happens.
- */
-static void
-panic_root_destroyed(GtkObject* object, gpointer data)
-{
- g_error("Eeeek, root item %p of canvas %p was destroyed!", (void*)object, data);
-}
-
-/* Object initialization function for GanvCanvasBase */
-static void
-ganv_canvas_base_init(GanvCanvasBase* canvas)
-{
- GTK_WIDGET_SET_FLAGS(canvas, GTK_CAN_FOCUS);
-
- canvas->need_update = FALSE;
- canvas->need_redraw = FALSE;
- canvas->redraw_region = NULL;
- canvas->idle_id = 0;
-
- canvas->scroll_x1 = 0.0;
- canvas->scroll_y1 = 0.0;
- canvas->scroll_x2 = canvas->layout.width;
- canvas->scroll_y2 = canvas->layout.height;
-
- canvas->pixels_per_unit = 1.0;
-
- canvas->pick_event.type = GDK_LEAVE_NOTIFY;
- canvas->pick_event.crossing.x = 0;
- canvas->pick_event.crossing.y = 0;
-
- canvas->center_scroll_region = TRUE;
-
- gtk_layout_set_hadjustment(GTK_LAYOUT(canvas), NULL);
- gtk_layout_set_vadjustment(GTK_LAYOUT(canvas), NULL);
-
- /* Create the root item as a special case */
- canvas->root = GANV_ITEM(g_object_new(ganv_group_get_type(), NULL));
- canvas->root->canvas = canvas;
-
- g_object_ref_sink(canvas->root);
-
- canvas->root_destroy_id = g_signal_connect(canvas->root, "destroy",
- G_CALLBACK(panic_root_destroyed),
- canvas);
-
- canvas->need_repick = TRUE;
-}
-
-/* Convenience function to remove the idle handler of a canvas */
-static void
-remove_idle(GanvCanvasBase* canvas)
-{
- if (canvas->idle_id == 0) {
- return;
- }
-
- g_source_remove(canvas->idle_id);
- canvas->idle_id = 0;
-}
-
-/* Removes the transient state of the canvas (idle handler, grabs). */
-static void
-shutdown_transients(GanvCanvasBase* canvas)
-{
- /* We turn off the need_redraw flag, since if the canvas is mapped again
- * it will request a redraw anyways. We do not turn off the need_update
- * flag, though, because updates are not queued when the canvas remaps
- * itself.
- */
- if (canvas->need_redraw) {
- canvas->need_redraw = FALSE;
- g_slist_foreach(canvas->redraw_region, (GFunc)g_free, NULL);
- g_slist_free(canvas->redraw_region);
- canvas->redraw_region = NULL;
- canvas->redraw_x1 = 0;
- canvas->redraw_y1 = 0;
- canvas->redraw_x2 = 0;
- canvas->redraw_y2 = 0;
- }
-
- if (canvas->grabbed_item) {
- canvas->grabbed_item = NULL;
- gdk_pointer_ungrab(GDK_CURRENT_TIME);
- }
-
- remove_idle(canvas);
-}
-
-/* Destroy handler for GanvCanvasBase */
-static void
-ganv_canvas_base_destroy(GtkObject* object)
-{
- GanvCanvasBase* canvas;
-
- g_return_if_fail(GANV_IS_CANVAS_BASE(object));
-
- /* remember, destroy can be run multiple times! */
-
- canvas = GANV_CANVAS_BASE(object);
-
- if (canvas->root_destroy_id) {
- g_signal_handler_disconnect(canvas->root, canvas->root_destroy_id);
- canvas->root_destroy_id = 0;
- }
- if (canvas->root) {
- gtk_object_destroy(GTK_OBJECT(canvas->root));
- g_object_unref(G_OBJECT(canvas->root));
- canvas->root = NULL;
- }
-
- shutdown_transients(canvas);
-
- if (GTK_OBJECT_CLASS(canvas_parent_class)->destroy) {
- (*GTK_OBJECT_CLASS(canvas_parent_class)->destroy)(object);
- }
-}
-
-/**
- * ganv_canvas_base_new:
- *
- * Creates a new empty canvas in non-antialiased mode.
- *
- * Return value: A newly-created canvas.
- **/
-GtkWidget*
-ganv_canvas_base_new(void)
-{
- return GTK_WIDGET(g_object_new(ganv_canvas_base_get_type(), NULL));
-}
-
-/* Map handler for the canvas */
-static void
-ganv_canvas_base_map(GtkWidget* widget)
-{
- GanvCanvasBase* canvas;
-
- g_return_if_fail(GANV_IS_CANVAS_BASE(widget));
-
- /* Normal widget mapping stuff */
-
- if (GTK_WIDGET_CLASS(canvas_parent_class)->map) {
- (*GTK_WIDGET_CLASS(canvas_parent_class)->map)(widget);
- }
-
- canvas = GANV_CANVAS_BASE(widget);
-
- if (canvas->need_update) {
- add_idle(canvas);
- }
-
- /* Map items */
-
- if (GANV_ITEM_GET_CLASS(canvas->root)->map) {
- (*GANV_ITEM_GET_CLASS(canvas->root)->map)(canvas->root);
- }
-}
-
-/* Unmap handler for the canvas */
-static void
-ganv_canvas_base_unmap(GtkWidget* widget)
-{
- GanvCanvasBase* canvas;
-
- g_return_if_fail(GANV_IS_CANVAS_BASE(widget));
-
- canvas = GANV_CANVAS_BASE(widget);
-
- shutdown_transients(canvas);
-
- /* Unmap items */
-
- if (GANV_ITEM_GET_CLASS(canvas->root)->unmap) {
- (*GANV_ITEM_GET_CLASS(canvas->root)->unmap)(canvas->root);
- }
-
- /* Normal widget unmapping stuff */
-
- if (GTK_WIDGET_CLASS(canvas_parent_class)->unmap) {
- (*GTK_WIDGET_CLASS(canvas_parent_class)->unmap)(widget);
- }
-}
-
-/* Realize handler for the canvas */
-static void
-ganv_canvas_base_realize(GtkWidget* widget)
-{
- GanvCanvasBase* canvas;
-
- g_return_if_fail(GANV_IS_CANVAS_BASE(widget));
-
- /* Normal widget realization stuff */
-
- if (GTK_WIDGET_CLASS(canvas_parent_class)->realize) {
- (*GTK_WIDGET_CLASS(canvas_parent_class)->realize)(widget);
- }
-
- canvas = GANV_CANVAS_BASE(widget);
-
- gdk_window_set_events(canvas->layout.bin_window,
- (gdk_window_get_events(canvas->layout.bin_window)
- | GDK_EXPOSURE_MASK
- | GDK_BUTTON_PRESS_MASK
- | GDK_BUTTON_RELEASE_MASK
- | GDK_POINTER_MOTION_MASK
- | GDK_KEY_PRESS_MASK
- | GDK_KEY_RELEASE_MASK
- | GDK_ENTER_NOTIFY_MASK
- | GDK_LEAVE_NOTIFY_MASK
- | GDK_FOCUS_CHANGE_MASK));
-
- /* Create our own temporary pixmap gc and realize all the items */
-
- canvas->pixmap_gc = gdk_gc_new(canvas->layout.bin_window);
-
- (*GANV_ITEM_GET_CLASS(canvas->root)->realize)(canvas->root);
-}
-
-/* Unrealize handler for the canvas */
-static void
-ganv_canvas_base_unrealize(GtkWidget* widget)
-{
- GanvCanvasBase* canvas;
-
- g_return_if_fail(GANV_IS_CANVAS_BASE(widget));
-
- canvas = GANV_CANVAS_BASE(widget);
-
- shutdown_transients(canvas);
-
- /* Unrealize items and parent widget */
-
- (*GANV_ITEM_GET_CLASS(canvas->root)->unrealize)(canvas->root);
-
- g_object_unref(canvas->pixmap_gc);
- canvas->pixmap_gc = NULL;
-
- if (GTK_WIDGET_CLASS(canvas_parent_class)->unrealize) {
- (*GTK_WIDGET_CLASS(canvas_parent_class)->unrealize)(widget);
- }
-}
-
-/* Handles scrolling of the canvas. Adjusts the scrolling and zooming offset to
- * keep as much as possible of the canvas scrolling region in view.
- */
-static void
-scroll_to(GanvCanvasBase* canvas, int cx, int cy)
-{
- int scroll_width, scroll_height;
- int right_limit, bottom_limit;
- int old_zoom_xofs, old_zoom_yofs;
- int changed_x = FALSE, changed_y = FALSE;
- int canvas_width, canvas_height;
-
- canvas_width = GTK_WIDGET(canvas)->allocation.width;
- canvas_height = GTK_WIDGET(canvas)->allocation.height;
-
- scroll_width = floor((canvas->scroll_x2 - canvas->scroll_x1) * canvas->pixels_per_unit
- + 0.5);
- scroll_height = floor((canvas->scroll_y2 - canvas->scroll_y1) * canvas->pixels_per_unit
- + 0.5);
-
- right_limit = scroll_width - canvas_width;
- bottom_limit = scroll_height - canvas_height;
-
- old_zoom_xofs = canvas->zoom_xofs;
- old_zoom_yofs = canvas->zoom_yofs;
-
- if (right_limit < 0) {
- cx = 0;
-
- if (canvas->center_scroll_region) {
- canvas->zoom_xofs = (canvas_width - scroll_width) / 2;
- scroll_width = canvas_width;
- } else {
- canvas->zoom_xofs = 0;
- }
- } else if (cx < 0) {
- cx = 0;
- canvas->zoom_xofs = 0;
- } else if (cx > right_limit) {
- cx = right_limit;
- canvas->zoom_xofs = 0;
- } else {
- canvas->zoom_xofs = 0;
- }
-
- if (bottom_limit < 0) {
- cy = 0;
-
- if (canvas->center_scroll_region) {
- canvas->zoom_yofs = (canvas_height - scroll_height) / 2;
- scroll_height = canvas_height;
- } else {
- canvas->zoom_yofs = 0;
- }
- } else if (cy < 0) {
- cy = 0;
- canvas->zoom_yofs = 0;
- } else if (cy > bottom_limit) {
- cy = bottom_limit;
- canvas->zoom_yofs = 0;
- } else {
- canvas->zoom_yofs = 0;
- }
-
- if ((canvas->zoom_xofs != old_zoom_xofs) || (canvas->zoom_yofs != old_zoom_yofs)) {
- ganv_canvas_base_request_update(canvas);
- gtk_widget_queue_draw(GTK_WIDGET(canvas));
- }
-
- if (canvas->layout.hadjustment && ( ((int)canvas->layout.hadjustment->value) != cx) ) {
- canvas->layout.hadjustment->value = cx;
- changed_x = TRUE;
- }
-
- if (canvas->layout.vadjustment && ( ((int)canvas->layout.vadjustment->value) != cy) ) {
- canvas->layout.vadjustment->value = cy;
- changed_y = TRUE;
- }
-
- if ((scroll_width != (int)canvas->layout.width)
- || (scroll_height != (int)canvas->layout.height)) {
- gtk_layout_set_size(GTK_LAYOUT(canvas), scroll_width, scroll_height);
- }
-
- /* Signal GtkLayout that it should do a redraw. */
-
- if (changed_x) {
- g_signal_emit_by_name(canvas->layout.hadjustment, "value_changed");
- }
-
- if (changed_y) {
- g_signal_emit_by_name(canvas->layout.vadjustment, "value_changed");
- }
-}
-
-/* Size allocation handler for the canvas */
-static void
-ganv_canvas_base_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
-{
- GanvCanvasBase* canvas;
-
- g_return_if_fail(GANV_IS_CANVAS_BASE(widget));
- g_return_if_fail(allocation != NULL);
-
- if (GTK_WIDGET_CLASS(canvas_parent_class)->size_allocate) {
- (*GTK_WIDGET_CLASS(canvas_parent_class)->size_allocate)(widget, allocation);
- }
-
- canvas = GANV_CANVAS_BASE(widget);
-
- /* Recenter the view, if appropriate */
-
- canvas->layout.hadjustment->page_size = allocation->width;
- canvas->layout.hadjustment->page_increment = allocation->width / 2;
-
- canvas->layout.vadjustment->page_size = allocation->height;
- canvas->layout.vadjustment->page_increment = allocation->height / 2;
-
- scroll_to(canvas,
- canvas->layout.hadjustment->value,
- canvas->layout.vadjustment->value);
-
- g_signal_emit_by_name(canvas->layout.hadjustment, "changed");
- g_signal_emit_by_name(canvas->layout.vadjustment, "changed");
-}
-
-/* Returns whether the item is an inferior of or is equal to the parent. */
-static gboolean
-is_descendant(GanvItem* item, GanvItem* parent)
-{
- for (; item; item = item->parent) {
- if (item == parent) {
- return TRUE;
- }
- }
-
- return FALSE;
-}
-
-
-/* Emits an event for an item in the canvas, be it the current item, grabbed
- * item, or focused item, as appropriate.
- */
-int
-ganv_canvas_base_emit_event(GanvCanvasBase* canvas, GdkEvent* event)
-{
- GdkEvent* ev;
- gint finished;
- GanvItem* item;
- GanvItem* parent;
- guint mask;
-
- /* Perform checks for grabbed items */
-
- if (canvas->grabbed_item
- && !is_descendant(canvas->current_item, canvas->grabbed_item)) {
- /* I think this warning is annoying and I don't know what it's for
- * so I'll disable it for now.
- */
- /* g_warning ("emit_event() returning FALSE!\n");*/
- return FALSE;
- }
-
- if (canvas->grabbed_item) {
- switch (event->type) {
- case GDK_ENTER_NOTIFY:
- mask = GDK_ENTER_NOTIFY_MASK;
- break;
-
- case GDK_LEAVE_NOTIFY:
- mask = GDK_LEAVE_NOTIFY_MASK;
- break;
-
- case GDK_MOTION_NOTIFY:
- mask = GDK_POINTER_MOTION_MASK;
- break;
-
- case GDK_BUTTON_PRESS:
- case GDK_2BUTTON_PRESS:
- case GDK_3BUTTON_PRESS:
- mask = GDK_BUTTON_PRESS_MASK;
- break;
-
- case GDK_BUTTON_RELEASE:
- mask = GDK_BUTTON_RELEASE_MASK;
- break;
-
- case GDK_KEY_PRESS:
- mask = GDK_KEY_PRESS_MASK;
- break;
-
- case GDK_KEY_RELEASE:
- mask = GDK_KEY_RELEASE_MASK;
- break;
-
- case GDK_SCROLL:
- mask = GDK_SCROLL_MASK;
- break;
-
- default:
- mask = 0;
- break;
- }
-
- if (!(mask & canvas->grabbed_event_mask)) {
- return FALSE;
- }
- }
-
- /* Convert to world coordinates -- we have two cases because of diferent
- * offsets of the fields in the event structures.
- */
-
- ev = gdk_event_copy(event);
-
- switch (ev->type) {
- case GDK_ENTER_NOTIFY:
- case GDK_LEAVE_NOTIFY:
- ganv_canvas_base_window_to_world(canvas,
- ev->crossing.x, ev->crossing.y,
- &ev->crossing.x, &ev->crossing.y);
- break;
-
- case GDK_MOTION_NOTIFY:
- case GDK_BUTTON_PRESS:
- case GDK_2BUTTON_PRESS:
- case GDK_3BUTTON_PRESS:
- case GDK_BUTTON_RELEASE:
- ganv_canvas_base_window_to_world(canvas,
- ev->motion.x, ev->motion.y,
- &ev->motion.x, &ev->motion.y);
- break;
-
- default:
- break;
- }
-
- /* Choose where we send the event */
-
- item = canvas->current_item;
-
- if (canvas->focused_item
- && ((event->type == GDK_KEY_PRESS)
- || (event->type == GDK_KEY_RELEASE)
- || (event->type == GDK_FOCUS_CHANGE))) {
- item = canvas->focused_item;
- }
-
- /* The event is propagated up the hierarchy (for if someone connected to
- * a group instead of a leaf event), and emission is stopped if a
- * handler returns TRUE, just like for GtkWidget events.
- */
-
- finished = FALSE;
-
- while (item && !finished) {
- g_object_ref(G_OBJECT(item));
-
- ganv_item_emit_event(item, ev, &finished);
-
- parent = item->parent;
- g_object_unref(G_OBJECT(item));
-
- item = parent;
- }
-
- gdk_event_free(ev);
-
- return finished;
-}
-
-/* Re-picks the current item in the canvas, based on the event's coordinates.
- * Also emits enter/leave events for items as appropriate.
- */
-static int
-pick_current_item(GanvCanvasBase* canvas, GdkEvent* event)
-{
- int button_down;
- double x, y;
- int cx, cy;
- int retval;
-
- retval = FALSE;
-
- /* If a button is down, we'll perform enter and leave events on the
- * current item, but not enter on any other item. This is more or less
- * like X pointer grabbing for canvas items.
- */
- button_down = canvas->state & (GDK_BUTTON1_MASK
- | GDK_BUTTON2_MASK
- | GDK_BUTTON3_MASK
- | GDK_BUTTON4_MASK
- | GDK_BUTTON5_MASK);
- if (!button_down) {
- canvas->left_grabbed_item = FALSE;
- }
-
- /* Save the event in the canvas. This is used to synthesize enter and
- * leave events in case the current item changes. It is also used to
- * re-pick the current item if the current one gets deleted. Also,
- * synthesize an enter event.
- */
- if (event != &canvas->pick_event) {
- if ((event->type == GDK_MOTION_NOTIFY) || (event->type == GDK_BUTTON_RELEASE)) {
- /* these fields have the same offsets in both types of events */
-
- canvas->pick_event.crossing.type = GDK_ENTER_NOTIFY;
- canvas->pick_event.crossing.window = event->motion.window;
- canvas->pick_event.crossing.send_event = event->motion.send_event;
- canvas->pick_event.crossing.subwindow = NULL;
- canvas->pick_event.crossing.x = event->motion.x;
- canvas->pick_event.crossing.y = event->motion.y;
- canvas->pick_event.crossing.mode = GDK_CROSSING_NORMAL;
- canvas->pick_event.crossing.detail = GDK_NOTIFY_NONLINEAR;
- canvas->pick_event.crossing.focus = FALSE;
- canvas->pick_event.crossing.state = event->motion.state;
-
- /* these fields don't have the same offsets in both types of events */
-
- if (event->type == GDK_MOTION_NOTIFY) {
- canvas->pick_event.crossing.x_root = event->motion.x_root;
- canvas->pick_event.crossing.y_root = event->motion.y_root;
- } else {
- canvas->pick_event.crossing.x_root = event->button.x_root;
- canvas->pick_event.crossing.y_root = event->button.y_root;
- }
- } else {
- canvas->pick_event = *event;
- }
- }
-
- /* Don't do anything else if this is a recursive call */
-
- if (canvas->in_repick) {
- return retval;
- }
-
- /* LeaveNotify means that there is no current item, so we don't look for one */
-
- if (canvas->pick_event.type != GDK_LEAVE_NOTIFY) {
- /* these fields don't have the same offsets in both types of events */
-
- if (canvas->pick_event.type == GDK_ENTER_NOTIFY) {
- x = canvas->pick_event.crossing.x - canvas->zoom_xofs;
- y = canvas->pick_event.crossing.y - canvas->zoom_yofs;
- } else {
- x = canvas->pick_event.motion.x - canvas->zoom_xofs;
- y = canvas->pick_event.motion.y - canvas->zoom_yofs;
- }
-
- /* canvas pixel coords */
-
- cx = (int)(x + 0.5);
- cy = (int)(y + 0.5);
-
- /* world coords */
-
- x = canvas->scroll_x1 + x / canvas->pixels_per_unit;
- y = canvas->scroll_y1 + y / canvas->pixels_per_unit;
-
- /* find the closest item */
-
- if (canvas->root->object.flags & GANV_ITEM_VISIBLE) {
- GANV_ITEM_GET_CLASS(canvas->root)->point(
- canvas->root,
- x - canvas->root->x, y - canvas->root->y,
- cx, cy,
- &canvas->new_current_item);
- } else {
- canvas->new_current_item = NULL;
- }
- } else {
- canvas->new_current_item = NULL;
- }
-
- if ((canvas->new_current_item == canvas->current_item) && !canvas->left_grabbed_item) {
- return retval; /* current item did not change */
-
- }
- /* Synthesize events for old and new current items */
-
- if ((canvas->new_current_item != canvas->current_item)
- && (canvas->current_item != NULL)
- && !canvas->left_grabbed_item) {
- GdkEvent new_event;
-
- new_event = canvas->pick_event;
- new_event.type = GDK_LEAVE_NOTIFY;
-
- new_event.crossing.detail = GDK_NOTIFY_ANCESTOR;
- new_event.crossing.subwindow = NULL;
- canvas->in_repick = TRUE;
- retval = ganv_canvas_base_emit_event(canvas, &new_event);
- canvas->in_repick = FALSE;
- }
-
- /* new_current_item may have been set to NULL during the call to ganv_canvas_base_emit_event() above */
-
- if ((canvas->new_current_item != canvas->current_item) && button_down) {
- canvas->left_grabbed_item = TRUE;
- return retval;
- }
-
- /* Handle the rest of cases */
-
- canvas->left_grabbed_item = FALSE;
- canvas->current_item = canvas->new_current_item;
-
- if (canvas->current_item != NULL) {
- GdkEvent new_event;
-
- new_event = canvas->pick_event;
- new_event.type = GDK_ENTER_NOTIFY;
- new_event.crossing.detail = GDK_NOTIFY_ANCESTOR;
- new_event.crossing.subwindow = NULL;
- retval = ganv_canvas_base_emit_event(canvas, &new_event);
- }
-
- return retval;
-}
-
-/* Button event handler for the canvas */
-static gint
-ganv_canvas_base_button(GtkWidget* widget, GdkEventButton* event)
-{
- GanvCanvasBase* canvas;
- int mask;
- int retval;
-
- g_return_val_if_fail(GANV_IS_CANVAS_BASE(widget), FALSE);
- g_return_val_if_fail(event != NULL, FALSE);
-
- retval = FALSE;
-
- canvas = GANV_CANVAS_BASE(widget);
-
- /*
- * dispatch normally regardless of the event's window if an item has
- * has a pointer grab in effect
- */
- if (!canvas->grabbed_item && ( event->window != canvas->layout.bin_window) ) {
- return retval;
- }
-
- switch (event->button) {
- case 1:
- mask = GDK_BUTTON1_MASK;
- break;
- case 2:
- mask = GDK_BUTTON2_MASK;
- break;
- case 3:
- mask = GDK_BUTTON3_MASK;
- break;
- case 4:
- mask = GDK_BUTTON4_MASK;
- break;
- case 5:
- mask = GDK_BUTTON5_MASK;
- break;
- default:
- mask = 0;
- }
-
- switch (event->type) {
- case GDK_BUTTON_PRESS:
- case GDK_2BUTTON_PRESS:
- case GDK_3BUTTON_PRESS:
- /* Pick the current item as if the button were not pressed, and
- * then process the event.
- */
- canvas->state = event->state;
- pick_current_item(canvas, (GdkEvent*)event);
- canvas->state ^= mask;
- retval = ganv_canvas_base_emit_event(canvas, (GdkEvent*)event);
- break;
-
- case GDK_BUTTON_RELEASE:
- /* Process the event as if the button were pressed, then repick
- * after the button has been released
- */
- canvas->state = event->state;
- retval = ganv_canvas_base_emit_event(canvas, (GdkEvent*)event);
- event->state ^= mask;
- canvas->state = event->state;
- pick_current_item(canvas, (GdkEvent*)event);
- event->state ^= mask;
- break;
-
- default:
- g_assert_not_reached();
- }
-
- return retval;
-}
-
-/* Motion event handler for the canvas */
-static gint
-ganv_canvas_base_motion(GtkWidget* widget, GdkEventMotion* event)
-{
- GanvCanvasBase* canvas;
-
- g_return_val_if_fail(GANV_IS_CANVAS_BASE(widget), FALSE);
- g_return_val_if_fail(event != NULL, FALSE);
-
- canvas = GANV_CANVAS_BASE(widget);
-
- if (event->window != canvas->layout.bin_window) {
- return FALSE;
- }
-
- canvas->state = event->state;
- pick_current_item(canvas, (GdkEvent*)event);
- return ganv_canvas_base_emit_event(canvas, (GdkEvent*)event);
-}
-
-static gboolean
-ganv_canvas_base_scroll(GtkWidget* widget, GdkEventScroll* event)
-{
- GanvCanvasBase* canvas;
-
- g_return_val_if_fail(GANV_IS_CANVAS_BASE(widget), FALSE);
- g_return_val_if_fail(event != NULL, FALSE);
-
- canvas = GANV_CANVAS_BASE(widget);
-
- if (event->window != canvas->layout.bin_window) {
- return FALSE;
- }
-
- canvas->state = event->state;
- pick_current_item(canvas, (GdkEvent*)event);
- return ganv_canvas_base_emit_event(canvas, (GdkEvent*)event);
-}
-
-/* Key event handler for the canvas */
-static gboolean
-ganv_canvas_base_key(GtkWidget* widget, GdkEventKey* event)
-{
- GanvCanvasBase* canvas;
-
- g_return_val_if_fail(GANV_IS_CANVAS_BASE(widget), FALSE);
- g_return_val_if_fail(event != NULL, FALSE);
-
- canvas = GANV_CANVAS_BASE(widget);
-
- if (!ganv_canvas_base_emit_event(canvas, (GdkEvent*)event)) {
- GtkWidgetClass* widget_class;
-
- widget_class = GTK_WIDGET_CLASS(canvas_parent_class);
-
- if (event->type == GDK_KEY_PRESS) {
- if (widget_class->key_press_event) {
- return (*widget_class->key_press_event)(widget, event);
- }
- } else if (event->type == GDK_KEY_RELEASE) {
- if (widget_class->key_release_event) {
- return (*widget_class->key_release_event)(widget, event);
- }
- } else {
- g_assert_not_reached();
- }
-
- return FALSE;
- } else {
- return TRUE;
- }
-}
-
-/* Crossing event handler for the canvas */
-static gint
-ganv_canvas_base_crossing(GtkWidget* widget, GdkEventCrossing* event)
-{
- GanvCanvasBase* canvas;
-
- g_return_val_if_fail(GANV_IS_CANVAS_BASE(widget), FALSE);
- g_return_val_if_fail(event != NULL, FALSE);
-
- canvas = GANV_CANVAS_BASE(widget);
-
- if (event->window != canvas->layout.bin_window) {
- return FALSE;
- }
-
- canvas->state = event->state;
- return pick_current_item(canvas, (GdkEvent*)event);
-}
-
-/* Focus in handler for the canvas */
-static gint
-ganv_canvas_base_focus_in(GtkWidget* widget, GdkEventFocus* event)
-{
- GanvCanvasBase* canvas;
-
- GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
-
- canvas = GANV_CANVAS_BASE(widget);
-
- if (canvas->focused_item) {
- return ganv_canvas_base_emit_event(canvas, (GdkEvent*)event);
- } else {
- return FALSE;
- }
-}
-
-/* Focus out handler for the canvas */
-static gint
-ganv_canvas_base_focus_out(GtkWidget* widget, GdkEventFocus* event)
-{
- GanvCanvasBase* canvas;
-
- GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
-
- canvas = GANV_CANVAS_BASE(widget);
-
- if (canvas->focused_item) {
- return ganv_canvas_base_emit_event(canvas, (GdkEvent*)event);
- } else {
- return FALSE;
- }
-}
-
-#define REDRAW_QUANTUM_SIZE 512
-
-static void
-ganv_canvas_base_paint_rect(GanvCanvasBase* canvas, gint x0, gint y0, gint x1, gint y1)
-{
- gint draw_x1, draw_y1;
- gint draw_x2, draw_y2;
- gint draw_width, draw_height;
-
- g_return_if_fail(!canvas->need_update);
-
- draw_x1 = MAX(x0, canvas->layout.hadjustment->value - canvas->zoom_xofs);
- draw_y1 = MAX(y0, canvas->layout.vadjustment->value - canvas->zoom_yofs);
- draw_x2 = MIN(draw_x1 + GTK_WIDGET(canvas)->allocation.width, x1);
- draw_y2 = MIN(draw_y1 + GTK_WIDGET(canvas)->allocation.height, y1);
-
- draw_width = draw_x2 - draw_x1;
- draw_height = draw_y2 - draw_y1;
-
- if ((draw_width < 1) || (draw_height < 1)) {
- return;
- }
-
- canvas->redraw_x1 = draw_x1;
- canvas->redraw_y1 = draw_y1;
- canvas->redraw_x2 = draw_x2;
- canvas->redraw_y2 = draw_y2;
- canvas->draw_xofs = draw_x1;
- canvas->draw_yofs = draw_y1;
-
- cairo_t* cr = gdk_cairo_create(canvas->layout.bin_window);
-
- double wx, wy;
- ganv_canvas_base_window_to_world(canvas, 0, 0, &wx, &wy);
- cairo_translate(cr, -wx, -wy);
-
- if (canvas->root->object.flags & GANV_ITEM_VISIBLE) {
- (*GANV_ITEM_GET_CLASS(canvas->root)->draw)(
- canvas->root, cr,
- draw_x1, draw_y1,
- draw_width, draw_height);
- }
-
- cairo_destroy(cr);
-}
-
-/* Expose handler for the canvas */
-static gint
-ganv_canvas_base_expose(GtkWidget* widget, GdkEventExpose* event)
-{
- GanvCanvasBase* canvas = GANV_CANVAS_BASE(widget);
- if (!GTK_WIDGET_DRAWABLE(widget) ||
- (event->window != canvas->layout.bin_window)) {
- return FALSE;
- }
-
- /* Find a single bounding rectangle for all rectangles in the region.
- Since drawing the root group is O(n) and thus very expensive for large
- canvases, it's much faster to do a single paint than many, even though
- more area may be painted that way. With a better group implementation,
- it would likely be better to paint each changed rectangle separately. */
- GdkRectangle clip;
- gdk_region_get_clipbox(event->region, &clip);
-
- const int x2 = clip.x + clip.width;
- const int y2 = clip.y + clip.height;
-
- if (canvas->need_update || canvas->need_redraw) {
- /* Update or drawing is scheduled, so just mark exposed area as dirty */
- ganv_canvas_base_request_redraw(canvas, clip.x, clip.y, x2, y2);
- } else {
- /* No pending updates, draw exposed area immediately */
- ganv_canvas_base_paint_rect(canvas, clip.x, clip.y, x2, y2);
-
- /* And call expose on parent container class */
- if (GTK_WIDGET_CLASS(canvas_parent_class)->expose_event) {
- (*GTK_WIDGET_CLASS(canvas_parent_class)->expose_event)(
- widget, event);
- }
- }
-
- return FALSE;
-}
-
-/* Repaints the areas in the canvas that need it */
-static void
-paint(GanvCanvasBase* canvas)
-{
- for (GSList* l = canvas->redraw_region; l; l = l->next) {
- IRect* rect = (IRect*)l->data;
-
- const GdkRectangle gdkrect = {
- rect->x + canvas->zoom_xofs,
- rect->y + canvas->zoom_yofs,
- rect->width,
- rect->height
- };
-
- gdk_window_invalidate_rect(canvas->layout.bin_window, &gdkrect, FALSE);
- g_free(rect);
- }
-
- g_slist_free(canvas->redraw_region);
- canvas->redraw_region = NULL;
- canvas->need_redraw = FALSE;
-
- canvas->redraw_x1 = 0;
- canvas->redraw_y1 = 0;
- canvas->redraw_x2 = 0;
- canvas->redraw_y2 = 0;
-}
-
-static void
-do_update(GanvCanvasBase* canvas)
-{
- /* Cause the update if necessary */
-
-update_again:
- if (canvas->need_update) {
- ganv_item_invoke_update(canvas->root, 0);
-
- canvas->need_update = FALSE;
- }
-
- /* Pick new current item */
-
- while (canvas->need_repick) {
- canvas->need_repick = FALSE;
- pick_current_item(canvas, &canvas->pick_event);
- }
-
- /* it is possible that during picking we emitted an event in which
- the user then called some function which then requested update
- of something. Without this we'd be left in a state where
- need_update would have been left TRUE and the canvas would have
- been left unpainted. */
- if (canvas->need_update) {
- goto update_again;
- }
-
- /* Paint if able to */
-
- if (GTK_WIDGET_DRAWABLE(canvas) && canvas->need_redraw) {
- paint(canvas);
- }
-}
-
-/* Idle handler for the canvas. It deals with pending updates and redraws. */
-static gboolean
-idle_handler(gpointer data)
-{
- GanvCanvasBase* canvas;
-
- GDK_THREADS_ENTER();
-
- canvas = GANV_CANVAS_BASE(data);
-
- do_update(canvas);
-
- /* Reset idle id */
- canvas->idle_id = 0;
-
- GDK_THREADS_LEAVE();
-
- return FALSE;
-}
-
-/* Convenience function to add an idle handler to a canvas */
-static void
-add_idle(GanvCanvasBase* canvas)
-{
- g_assert(canvas->need_update || canvas->need_redraw);
-
- if (!canvas->idle_id) {
- canvas->idle_id = g_idle_add_full(CANVAS_IDLE_PRIORITY,
- idle_handler,
- canvas,
- NULL);
- }
-
- /* canvas->idle_id = gtk_idle_add (idle_handler, canvas); */
-}
-
-/**
- * ganv_canvas_base_root:
- * @canvas: A canvas.
- *
- * Queries the root group of a canvas.
- *
- * Return value: (transfer none): The root group of the specified canvas.
- **/
-GanvItem*
-ganv_canvas_base_root(GanvCanvasBase* canvas)
-{
- g_return_val_if_fail(GANV_IS_CANVAS_BASE(canvas), NULL);
-
- return canvas->root;
-}
-
-/**
- * ganv_canvas_base_set_scroll_region:
- * @canvas: A canvas.
- * @x1: Leftmost limit of the scrolling region.
- * @y1: Upper limit of the scrolling region.
- * @x2: Rightmost limit of the scrolling region.
- * @y2: Lower limit of the scrolling region.
- *
- * Sets the scrolling region of a canvas to the specified rectangle. The canvas
- * will then be able to scroll only within this region. The view of the canvas
- * is adjusted as appropriate to display as much of the new region as possible.
- **/
-void
-ganv_canvas_base_set_scroll_region(GanvCanvasBase* canvas, double x1, double y1, double x2,
- double y2)
-{
- double wxofs, wyofs;
- int xofs, yofs;
-
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- /*
- * Set the new scrolling region. If possible, do not move the visible contents of the
- * canvas.
- */
-
- ganv_canvas_base_c2w(canvas,
- GTK_LAYOUT(canvas)->hadjustment->value + canvas->zoom_xofs,
- GTK_LAYOUT(canvas)->vadjustment->value + canvas->zoom_yofs,
- /*canvas->zoom_xofs,
- canvas->zoom_yofs,*/
- &wxofs, &wyofs);
-
- canvas->scroll_x1 = x1;
- canvas->scroll_y1 = y1;
- canvas->scroll_x2 = x2;
- canvas->scroll_y2 = y2;
-
- ganv_canvas_base_w2c(canvas, wxofs, wyofs, &xofs, &yofs);
-
- scroll_to(canvas, xofs, yofs);
-
- canvas->need_repick = TRUE;
-#if 0
- /* todo: should be requesting update */
- (*GANV_ITEM_CLASS(canvas->root->object.klass)->update)(
- canvas->root, NULL, NULL, 0);
-#endif
-}
-
-/**
- * ganv_canvas_base_get_scroll_region:
- * @canvas: A canvas.
- * @x1: Leftmost limit of the scrolling region (return value).
- * @y1: Upper limit of the scrolling region (return value).
- * @x2: Rightmost limit of the scrolling region (return value).
- * @y2: Lower limit of the scrolling region (return value).
- *
- * Queries the scrolling region of a canvas.
- **/
-void
-ganv_canvas_base_get_scroll_region(GanvCanvasBase* canvas, double* x1, double* y1, double* x2,
- double* y2)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- if (x1) {
- *x1 = canvas->scroll_x1;
- }
-
- if (y1) {
- *y1 = canvas->scroll_y1;
- }
-
- if (x2) {
- *x2 = canvas->scroll_x2;
- }
-
- if (y2) {
- *y2 = canvas->scroll_y2;
- }
-}
-
-/**
- * ganv_canvas_base_set_center_scroll_region:
- * @canvas: A canvas.
- * @center_scroll_region: Whether to center the scrolling region in the canvas
- * window when it is smaller than the canvas' allocation.
- *
- * When the scrolling region of the canvas is smaller than the canvas window,
- * e.g. the allocation of the canvas, it can be either centered on the window
- * or simply made to be on the upper-left corner on the window. This function
- * lets you configure this property.
- **/
-void
-ganv_canvas_base_set_center_scroll_region(GanvCanvasBase* canvas, gboolean center_scroll_region)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- canvas->center_scroll_region = center_scroll_region != 0;
-
- scroll_to(canvas,
- canvas->layout.hadjustment->value,
- canvas->layout.vadjustment->value);
-}
-
-/**
- * ganv_canvas_base_get_center_scroll_region:
- * @canvas: A canvas.
- *
- * Returns whether the canvas is set to center the scrolling region in the window
- * if the former is smaller than the canvas' allocation.
- *
- * Return value: Whether the scroll region is being centered in the canvas window.
- **/
-gboolean
-ganv_canvas_base_get_center_scroll_region(GanvCanvasBase* canvas)
-{
- g_return_val_if_fail(GANV_IS_CANVAS_BASE(canvas), FALSE);
-
- return canvas->center_scroll_region ? TRUE : FALSE;
-}
-
-/**
- * ganv_canvas_base_set_pixels_per_unit:
- * @canvas: A canvas.
- * @n: The number of pixels that correspond to one canvas unit.
- *
- * Sets the zooming factor of a canvas by specifying the number of pixels that
- * correspond to one canvas unit.
- *
- * The anchor point for zooming, i.e. the point that stays fixed and all others
- * zoom inwards or outwards from it, depends on whether the canvas is set to
- * center the scrolling region or not. You can control this using the
- * ganv_canvas_base_set_center_scroll_region() function. If the canvas is set to
- * center the scroll region, then the center of the canvas window is used as the
- * anchor point for zooming. Otherwise, the upper-left corner of the canvas
- * window is used as the anchor point.
- **/
-void
-ganv_canvas_base_set_pixels_per_unit(GanvCanvasBase* canvas, double n)
-{
- double ax, ay;
- int x1, y1;
- int anchor_x, anchor_y;
-
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
- g_return_if_fail(n > 1e-10);
-
- if (canvas->center_scroll_region) {
- anchor_x = GTK_WIDGET(canvas)->allocation.width / 2;
- anchor_y = GTK_WIDGET(canvas)->allocation.height / 2;
- } else {
- anchor_x = anchor_y = 0;
- }
-
- /* Find the coordinates of the anchor point in units. */
- if (canvas->layout.hadjustment) {
- ax
- = (canvas->layout.hadjustment->value
- + anchor_x) / canvas->pixels_per_unit + canvas->scroll_x1 + canvas->zoom_xofs;
- } else {
- ax = (0.0 + anchor_x) / canvas->pixels_per_unit + canvas->scroll_x1 + canvas->zoom_xofs;
- }
- if (canvas->layout.hadjustment) {
- ay
- = (canvas->layout.vadjustment->value
- + anchor_y) / canvas->pixels_per_unit + canvas->scroll_y1 + canvas->zoom_yofs;
- } else {
- ay = (0.0 + anchor_y) / canvas->pixels_per_unit + canvas->scroll_y1 + canvas->zoom_yofs;
- }
-
- /* Now calculate the new offset of the upper left corner. */
- x1 = ((ax - canvas->scroll_x1) * n) - anchor_x;
- y1 = ((ay - canvas->scroll_y1) * n) - anchor_y;
-
- canvas->pixels_per_unit = n;
-
- scroll_to(canvas, x1, y1);
-
- ganv_canvas_base_request_update(canvas);
- canvas->need_repick = TRUE;
-}
-
-/**
- * ganv_canvas_base_scroll_to:
- * @canvas: A canvas.
- * @cx: Horizontal scrolling offset in canvas pixel units.
- * @cy: Vertical scrolling offset in canvas pixel units.
- *
- * Makes a canvas scroll to the specified offsets, given in canvas pixel units.
- * The canvas will adjust the view so that it is not outside the scrolling
- * region. This function is typically not used, as it is better to hook
- * scrollbars to the canvas layout's scrolling adjusments.
- **/
-void
-ganv_canvas_base_scroll_to(GanvCanvasBase* canvas, int cx, int cy)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- scroll_to(canvas, cx, cy);
-}
-
-/**
- * ganv_canvas_base_get_scroll_offsets:
- * @canvas: A canvas.
- * @cx: Horizontal scrolling offset (return value).
- * @cy: Vertical scrolling offset (return value).
- *
- * Queries the scrolling offsets of a canvas. The values are returned in canvas
- * pixel units.
- **/
-void
-ganv_canvas_base_get_scroll_offsets(GanvCanvasBase* canvas, int* cx, int* cy)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- if (cx) {
- *cx = canvas->layout.hadjustment->value;
- }
-
- if (cy) {
- *cy = canvas->layout.vadjustment->value;
- }
-}
-
-/**
- * ganv_canvas_base_get_item_at:
- * @canvas: A canvas.
- * @x: X position in world coordinates.
- * @y: Y position in world coordinates.
- *
- * Looks for the item that is under the specified position, which must be
- * specified in world coordinates.
- *
- * Return value: (transfer none): The sought item, or NULL if no item is at the
- * specified coordinates.
- **/
-GanvItem*
-ganv_canvas_base_get_item_at(GanvCanvasBase* canvas, double x, double y)
-{
- GanvItem* item;
- double dist;
- int cx, cy;
-
- g_return_val_if_fail(GANV_IS_CANVAS_BASE(canvas), NULL);
-
- ganv_canvas_base_w2c(canvas, x, y, &cx, &cy);
-
- dist = GANV_ITEM_GET_CLASS(canvas->root)->point(
- canvas->root,
- x - canvas->root->x, y - canvas->root->y,
- cx, cy,
- &item);
- if ((int)(dist * canvas->pixels_per_unit + 0.5) <= canvas->close_enough) {
- return item;
- } else {
- return NULL;
- }
-}
-
-/* Queues an update of the canvas */
-void
-ganv_canvas_base_request_update(GanvCanvasBase* canvas)
-{
- GANV_CANVAS_BASE_GET_CLASS(canvas)->request_update(canvas);
-}
-
-static void
-ganv_canvas_base_request_update_real(GanvCanvasBase* canvas)
-{
- if (canvas->need_update) {
- return;
- }
-
- canvas->need_update = TRUE;
- if (GTK_WIDGET_MAPPED((GtkWidget*)canvas)) {
- add_idle(canvas);
- }
-}
-
-static inline gboolean
-rect_overlaps(const IRect* a, const IRect* b)
-{
- if ((a->x > b->x + b->width) ||
- (a->y > b->y + b->height) ||
- (a->x + a->width < b->x) ||
- (a->y + a->height < b->y)) {
- return FALSE;
- }
- return TRUE;
-}
-
-static inline gboolean
-rect_is_visible(GanvCanvasBase* canvas, const IRect* r)
-{
- const IRect rect = {
- canvas->layout.hadjustment->value - canvas->zoom_xofs,
- canvas->layout.vadjustment->value - canvas->zoom_yofs,
- GTK_WIDGET(canvas)->allocation.width,
- GTK_WIDGET(canvas)->allocation.height
- };
-
- return rect_overlaps(&rect, r);
-}
-
-/**
- * ganv_canvas_base_request_redraw:
- * @canvas: A canvas.
- * @x1: Leftmost coordinate of the rectangle to be redrawn.
- * @y1: Upper coordinate of the rectangle to be redrawn.
- * @x2: Rightmost coordinate of the rectangle to be redrawn, plus 1.
- * @y2: Lower coordinate of the rectangle to be redrawn, plus 1.
- *
- * Informs a canvas that the specified area needs to be repainted. To be used
- * only by item implementations.
- **/
-void
-ganv_canvas_base_request_redraw(GanvCanvasBase* canvas, int x1, int y1, int x2, int y2)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- if (!GTK_WIDGET_DRAWABLE(canvas) || (x1 >= x2) || (y1 >= y2)) {
- return;
- }
-
- const IRect rect = { x1, y1, x2 - x1, y2 - y1 };
-
- if (!rect_is_visible(canvas, &rect)) {
- return;
- }
-
- IRect* r = (IRect*)g_malloc(sizeof(IRect));
- *r = rect;
-
- canvas->redraw_region = g_slist_prepend(canvas->redraw_region, r);
- canvas->need_redraw = TRUE;
-
- if (canvas->idle_id == 0) {
- add_idle(canvas);
- }
-}
-
-/**
- * ganv_canvas_base_w2c_affine:
- * @canvas: A canvas.
- * @matrix: An affine transformation matrix (return value).
- *
- * Gets the affine transform that converts from world coordinates to canvas
- * pixel coordinates.
- **/
-void
-ganv_canvas_base_w2c_affine(GanvCanvasBase* canvas, cairo_matrix_t* matrix)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
- g_return_if_fail(matrix != NULL);
-
- cairo_matrix_init_translate(matrix,
- -canvas->scroll_x1,
- -canvas->scroll_y1);
-
- cairo_matrix_scale(matrix,
- canvas->pixels_per_unit,
- canvas->pixels_per_unit);
-}
-
-/**
- * ganv_canvas_base_w2c:
- * @canvas: A canvas.
- * @wx: World X coordinate.
- * @wy: World Y coordinate.
- * @cx: X pixel coordinate (return value).
- * @cy: Y pixel coordinate (return value).
- *
- * Converts world coordinates into canvas pixel coordinates.
- **/
-void
-ganv_canvas_base_w2c(GanvCanvasBase* canvas, double wx, double wy, int* cx, int* cy)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- cairo_matrix_t matrix;
- ganv_canvas_base_w2c_affine(canvas, &matrix);
-
- cairo_matrix_transform_point(&matrix, &wx, &wy);
-
- if (cx) {
- *cx = floor(wx + 0.5);
- }
- if (cy) {
- *cy = floor(wy + 0.5);
- }
-}
-
-/**
- * ganv_canvas_base_w2c_d:
- * @canvas: A canvas.
- * @wx: World X coordinate.
- * @wy: World Y coordinate.
- * @cx: X pixel coordinate (return value).
- * @cy: Y pixel coordinate (return value).
- *
- * Converts world coordinates into canvas pixel coordinates. This
- * version returns coordinates in floating point coordinates, for
- * greater precision.
- **/
-void
-ganv_canvas_base_w2c_d(GanvCanvasBase* canvas, double wx, double wy, double* cx, double* cy)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- cairo_matrix_t matrix;
- ganv_canvas_base_w2c_affine(canvas, &matrix);
-
- cairo_matrix_transform_point(&matrix, &wx, &wy);
-
- if (cx) {
- *cx = wx;
- }
- if (cy) {
- *cy = wy;
- }
-}
-
-/**
- * ganv_canvas_base_c2w:
- * @canvas: A canvas.
- * @cx: Canvas pixel X coordinate.
- * @cy: Canvas pixel Y coordinate.
- * @wx: X world coordinate (return value).
- * @wy: Y world coordinate (return value).
- *
- * Converts canvas pixel coordinates to world coordinates.
- **/
-void
-ganv_canvas_base_c2w(GanvCanvasBase* canvas, int cx, int cy, double* wx, double* wy)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- cairo_matrix_t matrix;
- ganv_canvas_base_w2c_affine(canvas, &matrix);
- cairo_matrix_invert(&matrix);
-
- double x = cx;
- double y = cy;
- cairo_matrix_transform_point(&matrix, &x, &y);
-
- if (wx) {
- *wx = x;
- }
- if (wy) {
- *wy = y;
- }
-}
-
-/**
- * ganv_canvas_base_window_to_world:
- * @canvas: A canvas.
- * @winx: Window-relative X coordinate.
- * @winy: Window-relative Y coordinate.
- * @worldx: X world coordinate (return value).
- * @worldy: Y world coordinate (return value).
- *
- * Converts window-relative coordinates into world coordinates. You can use
- * this when you need to convert mouse coordinates into world coordinates, for
- * example.
- **/
-void
-ganv_canvas_base_window_to_world(GanvCanvasBase* canvas, double winx, double winy,
- double* worldx, double* worldy)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- if (worldx) {
- *worldx = canvas->scroll_x1 + ((winx - canvas->zoom_xofs)
- / canvas->pixels_per_unit);
- }
-
- if (worldy) {
- *worldy = canvas->scroll_y1 + ((winy - canvas->zoom_yofs)
- / canvas->pixels_per_unit);
- }
-}
-
-/**
- * ganv_canvas_base_world_to_window:
- * @canvas: A canvas.
- * @worldx: World X coordinate.
- * @worldy: World Y coordinate.
- * @winx: X window-relative coordinate.
- * @winy: Y window-relative coordinate.
- *
- * Converts world coordinates into window-relative coordinates.
- **/
-void
-ganv_canvas_base_world_to_window(GanvCanvasBase* canvas, double worldx, double worldy,
- double* winx, double* winy)
-{
- g_return_if_fail(GANV_IS_CANVAS_BASE(canvas));
-
- if (winx) {
- *winx = (canvas->pixels_per_unit) * (worldx - canvas->scroll_x1) + canvas->zoom_xofs;
- }
-
- if (winy) {
- *winy = (canvas->pixels_per_unit) * (worldy - canvas->scroll_y1) + canvas->zoom_yofs;
- }
-}
diff --git a/src/circle.c b/src/circle.c
index 0e0d096..c37d78c 100644
--- a/src/circle.c
+++ b/src/circle.c
@@ -17,7 +17,6 @@
#include <string.h>
#include "ganv/canvas.h"
-#include "ganv/canvas-base.h"
#include "ganv/circle.h"
#include "./color.h"
@@ -233,8 +232,8 @@ request_redraw(GanvItem* item,
ganv_item_i2w_pair(item, &x1, &y1, &x2, &y2);
}
- ganv_canvas_base_request_redraw(item->canvas, x1, y1, x2, y2);
- ganv_canvas_base_request_redraw(item->canvas, 0, 0, 10000, 10000);
+ ganv_canvas_request_redraw(item->canvas, x1, y1, x2, y2);
+ ganv_canvas_request_redraw(item->canvas, 0, 0, 10000, 10000);
}
static void
@@ -290,8 +289,8 @@ ganv_circle_update(GanvItem* item, int flags)
ganv_item_i2w_pair(item, &x1, &y1, &x2, &y2);
// Update item canvas coordinates
- ganv_canvas_base_w2c_d(GANV_CANVAS_BASE(item->canvas), x1, y1, &item->x1, &item->y1);
- ganv_canvas_base_w2c_d(GANV_CANVAS_BASE(item->canvas), x2, y2, &item->x2, &item->y2);
+ ganv_canvas_w2c_d(item->canvas, x1, y1, &item->x1, &item->y1);
+ ganv_canvas_w2c_d(item->canvas, x2, y2, &item->x2, &item->y2);
// Request redraw of new location
request_redraw(item, &impl->coords, FALSE);
diff --git a/src/edge.c b/src/edge.c
index 2743100..8f557b7 100644
--- a/src/edge.c
+++ b/src/edge.c
@@ -18,7 +18,6 @@
#include <cairo.h>
-#include "ganv/canvas-base.h"
#include "ganv/canvas.h"
#include "ganv/edge.h"
#include "ganv/node.h"
@@ -164,7 +163,7 @@ ganv_edge_get_property(GObject* object,
}
void
-ganv_edge_request_redraw(GanvCanvasBase* canvas,
+ganv_edge_request_redraw(GanvCanvas* canvas,
const GanvEdgeCoords* coords)
{
const double w = coords->width;
@@ -184,17 +183,17 @@ ganv_edge_request_redraw(GanvCanvasBase* canvas,
const double r1y1 = MIN(MIN(src_y, join_y), src_y1);
const double r1x2 = MAX(MAX(src_x, join_x), src_x1);
const double r1y2 = MAX(MAX(src_y, join_y), src_y1);
- ganv_canvas_base_request_redraw(canvas,
- r1x1 - w, r1y1 - w,
- r1x2 + w, r1y2 + w);
+ ganv_canvas_request_redraw(canvas,
+ r1x1 - w, r1y1 - w,
+ r1x2 + w, r1y2 + w);
const double r2x1 = MIN(MIN(dst_x, join_x), dst_x1);
const double r2y1 = MIN(MIN(dst_y, join_y), dst_y1);
const double r2x2 = MAX(MAX(dst_x, join_x), dst_x1);
const double r2y2 = MAX(MAX(dst_y, join_y), dst_y1);
- ganv_canvas_base_request_redraw(canvas,
- r2x1 - w, r2y1 - w,
- r2x2 + w, r2y2 + w);
+ ganv_canvas_request_redraw(canvas,
+ r2x1 - w, r2y1 - w,
+ r2x2 + w, r2y2 + w);
} else {
const double x1 = MIN(coords->x1, coords->x2);
@@ -202,13 +201,13 @@ ganv_edge_request_redraw(GanvCanvasBase* canvas,
const double x2 = MAX(coords->x1, coords->x2);
const double y2 = MAX(coords->y1, coords->y2);
- ganv_canvas_base_request_redraw(canvas,
- x1 - w, y1 - w,
- x2 + w, y2 + w);
+ ganv_canvas_request_redraw(canvas,
+ x1 - w, y1 - w,
+ x2 + w, y2 + w);
}
if (coords->handle_radius > 0.0) {
- ganv_canvas_base_request_redraw(
+ ganv_canvas_request_redraw(
canvas,
coords->handle_x - coords->handle_radius - w,
coords->handle_y - coords->handle_radius - w,
@@ -217,7 +216,7 @@ ganv_edge_request_redraw(GanvCanvasBase* canvas,
}
if (coords->arrowhead) {
- ganv_canvas_base_request_redraw(
+ ganv_canvas_request_redraw(
canvas,
coords->x2 - ARROW_DEPTH,
coords->y2 - ARROW_BREADTH,
@@ -308,8 +307,8 @@ ganv_edge_update(GanvItem* item, int flags)
}
// Update item canvas coordinates
- ganv_canvas_base_w2c_d(GANV_CANVAS_BASE(item->canvas), x1, y1, &item->x1, &item->y1);
- ganv_canvas_base_w2c_d(GANV_CANVAS_BASE(item->canvas), x2, y2, &item->x2, &item->y2);
+ ganv_canvas_w2c_d(item->canvas, x1, y1, &item->x1, &item->y1);
+ ganv_canvas_w2c_d(item->canvas, x2, y2, &item->x2, &item->y2);
// Request redraw of new location
ganv_edge_request_redraw(item->canvas, &impl->coords);
@@ -621,7 +620,7 @@ ganv_edge_new(GanvCanvas* canvas,
va_list args;
va_start(args, first_prop_name);
ganv_item_construct(&edge->item,
- GANV_ITEM(ganv_canvas_get_root(canvas)),
+ GANV_ITEM(ganv_canvas_root(canvas)),
first_prop_name, args);
va_end(args);
diff --git a/src/ganv-private.h b/src/ganv-private.h
index 227c46b..368e056 100644
--- a/src/ganv-private.h
+++ b/src/ganv-private.h
@@ -22,7 +22,7 @@ extern "C" {
#include <cairo.h>
-#include "ganv/canvas-base.h"
+#include "ganv/canvas.h"
#include "ganv/text.h"
#include "ganv/types.h"
@@ -210,21 +210,19 @@ ganv_item_invoke_update(GanvItem* item, int flags);
void
ganv_item_emit_event(GanvItem* item, GdkEvent* event, gint* finished);
-/* CanvasBase */
-
void
-ganv_canvas_base_request_update(GanvCanvasBase* canvas);
+ganv_canvas_request_update(GanvCanvas* canvas);
int
-ganv_canvas_base_emit_event(GanvCanvasBase* canvas, GdkEvent* event);
+ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event);
/* For use only by item type implementations. Request that the canvas
* eventually redraw the specified region, specified in canvas pixel
* coordinates. The region contains (x1, y1) but not (x2, y2).
*/
void
-ganv_canvas_base_request_redraw(GanvCanvasBase* canvas,
- int x1, int y1, int x2, int y2);
+ganv_canvas_request_redraw(GanvCanvas* canvas,
+ int x1, int y1, int x2, int y2);
/* Edge */
@@ -232,7 +230,7 @@ void
ganv_edge_get_coords(const GanvEdge* edge, GanvEdgeCoords* coords);
void
-ganv_edge_request_redraw(GanvCanvasBase* canvas,
+ganv_edge_request_redraw(GanvCanvas* canvas,
const GanvEdgeCoords* coords);
/* Box */
diff --git a/src/group.c b/src/group.c
index 2a05e5e..58f5007 100644
--- a/src/group.c
+++ b/src/group.c
@@ -20,7 +20,7 @@
#include <math.h>
-#include "ganv/canvas-base.h"
+#include "ganv/canvas.h"
#include "ganv/group.h"
#include "./gettext.h"
diff --git a/src/item.c b/src/item.c
index 05295bb..d3f9678 100644
--- a/src/item.c
+++ b/src/item.c
@@ -19,7 +19,6 @@
*/
#include "ganv/canvas.h"
-#include "ganv/canvas-base.h"
#include "ganv/node.h"
#include "./boilerplate.h"
@@ -27,9 +26,31 @@
#include "./ganv-private.h"
#include "./gettext.h"
-#define GCI_UPDATE_MASK (GANV_CANVAS_BASE_UPDATE_REQUESTED \
- | GANV_CANVAS_BASE_UPDATE_AFFINE \
- | GANV_CANVAS_BASE_UPDATE_VISIBILITY)
+/**
+ * #GanvItem: Base class for all canvas items.
+ *
+ * All canvas items are derived from GanvItem. The only information a GanvItem
+ * contains is its parent canvas, its parent canvas item, its bounding box in
+ * world coordinates, and its current affine transformation.
+ *
+ * Items inside a canvas are organized in a tree, where leaves are items
+ * without any children. Each canvas has a single root item, which can be
+ * obtained with the ganv_canvas_base_get_root() function.
+ *
+ * The abstract GanvItem class does not have any configurable or queryable
+ * attributes.
+ */
+
+/* Update flags for items */
+enum {
+ GANV_CANVAS_UPDATE_REQUESTED = 1 << 0,
+ GANV_CANVAS_UPDATE_AFFINE = 1 << 1,
+ GANV_CANVAS_UPDATE_VISIBILITY = 1 << 2,
+};
+
+#define GCI_UPDATE_MASK (GANV_CANVAS_UPDATE_REQUESTED \
+ | GANV_CANVAS_UPDATE_AFFINE \
+ | GANV_CANVAS_UPDATE_VISIBILITY)
enum {
ITEM_PROP_0,
@@ -48,7 +69,7 @@ static guint item_signals[ITEM_LAST_SIGNAL];
G_DEFINE_TYPE(GanvItem, ganv_item, GTK_TYPE_OBJECT)
-static GtkObjectClass * item_parent_class;
+static GtkObjectClass* item_parent_class;
/* Object initialization function for GanvItem */
static void
@@ -70,7 +91,7 @@ ganv_item_init(GanvItem* item)
* Creates a new canvas item with @parent as its parent group. The item is
* created at the top of its parent's stack, and starts up as visible. The item
* is of the specified @type, for example, it can be
- * ganv_canvas_base_rect_get_type(). The list of object arguments/value pairs is
+ * ganv_canvas_rect_get_type(). The list of object arguments/value pairs is
* used to configure the item. If you need to pass construct time parameters, you
* should use g_object_new() to pass the parameters and
* ganv_item_construct() to set up the canvas item.
@@ -108,9 +129,9 @@ item_post_create_setup(GanvItem* item)
g_warning("item added to non-parent item\n");
}
}
- ganv_canvas_base_request_redraw(item->canvas,
- item->x1, item->y1,
- item->x2 + 1, item->y2 + 1);
+ ganv_canvas_request_redraw(item->canvas,
+ item->x1, item->y1,
+ item->x2 + 1, item->y2 + 1);
item->canvas->need_repick = TRUE;
}
@@ -212,8 +233,8 @@ static void
redraw_if_visible(GanvItem* item)
{
if (item->object.flags & GANV_ITEM_VISIBLE) {
- ganv_canvas_base_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1,
- item->y2 + 1);
+ ganv_canvas_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1,
+ item->y2 + 1);
}
}
@@ -332,14 +353,14 @@ ganv_item_invoke_update(GanvItem* item, int flags)
/* apply object flags to child flags */
- child_flags &= ~GANV_CANVAS_BASE_UPDATE_REQUESTED;
+ child_flags &= ~GANV_CANVAS_UPDATE_REQUESTED;
if (item->object.flags & GANV_ITEM_NEED_UPDATE) {
- child_flags |= GANV_CANVAS_BASE_UPDATE_REQUESTED;
+ child_flags |= GANV_CANVAS_UPDATE_REQUESTED;
}
if (item->object.flags & GANV_ITEM_NEED_VIS) {
- child_flags |= GANV_CANVAS_BASE_UPDATE_VISIBILITY;
+ child_flags |= GANV_CANVAS_UPDATE_VISIBILITY;
}
if (child_flags & GCI_UPDATE_MASK) {
@@ -432,8 +453,8 @@ ganv_item_show(GanvItem* item)
if (!(item->object.flags & GANV_ITEM_VISIBLE)) {
item->object.flags |= GANV_ITEM_VISIBLE;
- ganv_canvas_base_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1,
- item->y2 + 1);
+ ganv_canvas_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1,
+ item->y2 + 1);
item->canvas->need_repick = TRUE;
}
}
@@ -452,8 +473,8 @@ ganv_item_hide(GanvItem* item)
if (item->object.flags & GANV_ITEM_VISIBLE) {
item->object.flags &= ~GANV_ITEM_VISIBLE;
- ganv_canvas_base_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1,
- item->y2 + 1);
+ ganv_canvas_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1,
+ item->y2 + 1);
item->canvas->need_repick = TRUE;
}
}
@@ -537,7 +558,7 @@ ganv_item_i2w_offset(GanvItem* item, double* px, double* py)
{
double x = 0.0;
double y = 0.0;
- while (item) {
+ while (item) {
x += item->x;
y += item->y;
item = item->parent;
@@ -559,8 +580,8 @@ void
ganv_item_i2w(GanvItem* item, double* x, double* y)
{
/*g_return_if_fail(GANV_IS_ITEM(item));
- g_return_if_fail(x != NULL);
- g_return_if_fail(y != NULL);*/
+ g_return_if_fail(x != NULL);
+ g_return_if_fail(y != NULL);*/
double off_x;
double off_y;
@@ -628,7 +649,7 @@ ganv_item_grab_focus(GanvItem* item)
ev.focus_change.send_event = FALSE;
ev.focus_change.in = FALSE;
- ganv_canvas_base_emit_event(item->canvas, &ev);
+ ganv_canvas_emit_event(item->canvas, &ev);
}
item->canvas->focused_item = item;
@@ -640,7 +661,7 @@ ganv_item_grab_focus(GanvItem* item)
ev.focus_change.send_event = FALSE;
ev.focus_change.in = TRUE;
- ganv_canvas_base_emit_event(item->canvas, &ev);
+ ganv_canvas_emit_event(item->canvas, &ev);
}
}
@@ -702,7 +723,7 @@ ganv_item_request_update(GanvItem* item)
ganv_item_request_update(item->parent);
} else {
/* Have reached the top of the tree, make sure the update call gets scheduled. */
- ganv_canvas_base_request_update(item->canvas);
+ ganv_canvas_request_update(item->canvas);
}
}
@@ -736,43 +757,43 @@ ganv_item_class_init(GanvItemClass* klass)
gobject_class->get_property = ganv_item_get_property;
g_object_class_install_property
- (gobject_class, ITEM_PROP_PARENT,
- g_param_spec_object("parent", NULL, NULL,
- GANV_TYPE_ITEM,
- (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ (gobject_class, ITEM_PROP_PARENT,
+ g_param_spec_object("parent", NULL, NULL,
+ GANV_TYPE_ITEM,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property
- (gobject_class, ITEM_PROP_X,
- g_param_spec_double("x",
- _("X"),
- _("X"),
- -G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
- (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ (gobject_class, ITEM_PROP_X,
+ g_param_spec_double("x",
+ _("X"),
+ _("X"),
+ -G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property
- (gobject_class, ITEM_PROP_Y,
- g_param_spec_double("y",
- _("Y"),
- _("Y"),
- -G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
- (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ (gobject_class, ITEM_PROP_Y,
+ g_param_spec_double("y",
+ _("Y"),
+ _("Y"),
+ -G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property
- (gobject_class, ITEM_PROP_MANAGED,
- g_param_spec_boolean("managed",
- _("Managed"),
- _("Whether the item is managed by its parent"),
- 0,
- (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ (gobject_class, ITEM_PROP_MANAGED,
+ g_param_spec_boolean("managed",
+ _("Managed"),
+ _("Whether the item is managed by its parent"),
+ 0,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
item_signals[ITEM_EVENT]
- = g_signal_new("event",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET(GanvItemClass, event),
- boolean_handled_accumulator, NULL,
- ganv_marshal_BOOLEAN__BOXED,
- G_TYPE_BOOLEAN, 1,
- GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
+ = g_signal_new("event",
+ G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET(GanvItemClass, event),
+ boolean_handled_accumulator, NULL,
+ ganv_marshal_BOOLEAN__BOXED,
+ G_TYPE_BOOLEAN, 1,
+ GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
gobject_class->dispose = ganv_item_dispose;
diff --git a/src/node.c b/src/node.c
index a728cb0..8e8e0ad 100644
--- a/src/node.c
+++ b/src/node.c
@@ -14,7 +14,6 @@
*/
#include "ganv/canvas.h"
-#include "ganv/canvas-base.h"
#include "ganv/node.h"
#include "./boilerplate.h"
@@ -169,8 +168,8 @@ ganv_node_set_property(GObject* object,
break;
case PROP_CANVAS:
if (!GANV_ITEM(object)->parent) {
- GanvCanvasBase* canvas = GANV_CANVAS_BASE(g_value_get_object(value));
- g_object_set(object, "parent", ganv_canvas_base_root(canvas), NULL);
+ GanvCanvas* canvas = GANV_CANVAS(g_value_get_object(value));
+ g_object_set(object, "parent", ganv_canvas_root(canvas), NULL);
ganv_canvas_add_node(GANV_CANVAS(canvas), node);
} else {
g_warning("Cannot change `canvas' property after construction");
diff --git a/src/text.c b/src/text.c
index 137bfa5..3d3f938 100644
--- a/src/text.c
+++ b/src/text.c
@@ -20,7 +20,6 @@
#include <gtk/gtkstyle.h>
-#include "ganv/canvas-base.h"
#include "ganv/canvas.h"
#include "ganv/text.h"
@@ -246,7 +245,7 @@ ganv_text_update(GanvItem* item, int flags)
parent_class->update(item, flags);
- ganv_canvas_base_request_redraw(item->canvas, x1, y1, x2, y2);
+ ganv_canvas_request_redraw(item->canvas, x1, y1, x2, y2);
}
static double
diff --git a/src/widget.c b/src/widget.c
index afbf56c..63c1dfd 100644
--- a/src/widget.c
+++ b/src/widget.c
@@ -21,7 +21,7 @@
#include <gtk/gtksignal.h>
-#include "ganv/canvas-base.h"
+#include "ganv/canvas.h"
#include "ganv/widget.h"
#include "./gettext.h"
@@ -85,7 +85,7 @@ recalc_bounds(GanvWidget* witem)
/* Get canvas pixel coordinates */
- ganv_canvas_base_w2c(item->canvas, wx, wy, &witem->cx, &witem->cy);
+ ganv_canvas_w2c(item->canvas, wx, wy, &witem->cx, &witem->cy);
/* Anchor widget item */
@@ -330,7 +330,7 @@ ganv_widget_point(GanvItem* item, double x, double y,
*actual_item = item;
double x1, y1;
- ganv_canvas_base_c2w(item->canvas, witem->cx, witem->cy, &x1, &y1);
+ ganv_canvas_c2w(item->canvas, witem->cx, witem->cy, &x1, &y1);
double x2 = x1 + (witem->cwidth - 1) / item->canvas->pixels_per_unit;
double y2 = y1 + (witem->cheight - 1) / item->canvas->pixels_per_unit;