Squashed 'waflib/' changes from 6e726eb..5ea8f99

5ea8f99 Improve test output spacing
0e23b29 Raise exception when test suite fails to ensure non-zero exit status
d6de073 Show run time of unit tests
5b65554 Add short configure option for ultra-strict flags
4687ba6 Use gtest-like test output
258903d Fix failure count in test group summaries
da07e73 Fix verbose tests with Python 3

git-subtree-dir: waflib
git-subtree-split: 5ea8f99f6e1246079c1fe6bb590c38a53aadd40d

1 files changed, 0 insertions, 897 deletions

diff --git a/src/node.c b/src/node.c
deleted file mode 100644
index 4955f36..0000000
--- a/src/node.c
+++ /dev/null
@@ -1,897 +0,0 @@
-/* This file is part of Ganv.
- * Copyright 2007-2016 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/>.
- */
-
-#include "ganv/canvas.h"
-#include "ganv/node.h"
-
-#include "./boilerplate.h"
-#include "./color.h"
-#include "./ganv-marshal.h"
-#include "./ganv-private.h"
-#include "./gettext.h"
-
-guint signal_moved;
-
-G_DEFINE_TYPE_WITH_CODE(GanvNode, ganv_node, GANV_TYPE_ITEM,
-                        G_ADD_PRIVATE(GanvNode))
-
-static GanvItemClass* parent_class;
-
-enum {
-	PROP_0,
-	PROP_CANVAS,
-	PROP_PARTNER,
-	PROP_LABEL,
-	PROP_SHOW_LABEL,
-	PROP_DASH_LENGTH,
-	PROP_DASH_OFFSET,
-	PROP_BORDER_WIDTH,
-	PROP_FILL_COLOR,
-	PROP_BORDER_COLOR,
-	PROP_CAN_TAIL,
-	PROP_CAN_HEAD,
-	PROP_IS_SOURCE,
-	PROP_SELECTED,
-	PROP_HIGHLIGHTED,
-	PROP_DRAGGABLE,
-	PROP_GRABBED
-};
-
-static void
-ganv_node_init(GanvNode* node)
-{
-	GanvNodePrivate* impl = ganv_node_get_instance_private(node);
-
-	node->impl = impl;
-
-	impl->partner      = NULL;
-	impl->label        = NULL;
-	impl->dash_length  = 0.0;
-	impl->dash_offset  = 0.0;
-	impl->border_width = 2.0;
-	impl->fill_color   = DEFAULT_FILL_COLOR;
-	impl->border_color = DEFAULT_BORDER_COLOR;
-	impl->can_tail     = FALSE;
-	impl->can_head     = FALSE;
-	impl->is_source    = FALSE;
-	impl->selected     = FALSE;
-	impl->highlighted  = FALSE;
-	impl->draggable    = FALSE;
-	impl->show_label   = TRUE;
-	impl->grabbed      = FALSE;
-	impl->must_resize  = FALSE;
-#ifdef GANV_FDGL
-	impl->force.x       = 0.0;
-	impl->force.y       = 0.0;
-	impl->vel.x         = 0.0;
-	impl->vel.y         = 0.0;
-	impl->connected     = FALSE;
-#endif
-}
-
-static void
-ganv_node_realize(GanvItem* item)
-{
-	GANV_ITEM_CLASS(parent_class)->realize(item);
-	ganv_canvas_add_node(ganv_item_get_canvas(item), GANV_NODE(item));
-}
-
-static void
-ganv_node_destroy(GtkObject* object)
-{
-	g_return_if_fail(object != NULL);
-	g_return_if_fail(GANV_IS_NODE(object));
-
-	GanvNode*        node = GANV_NODE(object);
-	GanvNodePrivate* impl = node->impl;
-	if (impl->label) {
-		g_object_unref(impl->label);
-		impl->label = NULL;
-	}
-
-	GanvItem* item = GANV_ITEM(object);
-	ganv_node_disconnect(node);
-	if (item->impl->canvas) {
-		ganv_canvas_remove_node(item->impl->canvas, node);
-	}
-
-	if (GTK_OBJECT_CLASS(parent_class)->destroy) {
-		(*GTK_OBJECT_CLASS(parent_class)->destroy)(object);
-	}
-
-	impl->partner      = NULL;
-	item->impl->canvas = NULL;
-}
-
-static void
-ganv_node_update(GanvItem* item, int flags)
-{
-	GanvNode* node = GANV_NODE(item);
-	if (node->impl->must_resize) {
-		ganv_node_resize(node);
-		node->impl->must_resize = FALSE;
-	}
-
-	if (node->impl->label) {
-		ganv_item_invoke_update(GANV_ITEM(node->impl->label), flags);
-	}
-
-	GANV_ITEM_CLASS(parent_class)->update(item, flags);
-}
-
-static void
-ganv_node_draw(GanvItem* item,
-               cairo_t* cr, double cx, double cy, double cw, double ch)
-{
-	/* TODO: Label is not drawn here because ports need to draw control
-	   rects then the label on top.  I can't see a way of solving this since
-	   there's no single time parent class draw needs to be called, so perhaps
-	   label shouldn't be part of this class... */
-}
-
-static void
-ganv_node_set_property(GObject*      object,
-                       guint         prop_id,
-                       const GValue* value,
-                       GParamSpec*   pspec)
-{
-	g_return_if_fail(object != NULL);
-	g_return_if_fail(GANV_IS_NODE(object));
-
-	GanvNode*        node = GANV_NODE(object);
-	GanvNodePrivate* impl = node->impl;
-
-	switch (prop_id) {
-		SET_CASE(DASH_LENGTH, double, impl->dash_length);
-		SET_CASE(DASH_OFFSET, double, impl->dash_offset);
-		SET_CASE(BORDER_WIDTH, double, impl->border_width);
-		SET_CASE(FILL_COLOR, uint, impl->fill_color);
-		SET_CASE(BORDER_COLOR, uint, impl->border_color);
-		SET_CASE(CAN_TAIL, boolean, impl->can_tail);
-		SET_CASE(CAN_HEAD, boolean, impl->can_head);
-		SET_CASE(IS_SOURCE, boolean, impl->is_source);
-		SET_CASE(HIGHLIGHTED, boolean, impl->highlighted);
-		SET_CASE(DRAGGABLE, boolean, impl->draggable);
-		SET_CASE(GRABBED, boolean, impl->grabbed);
-	case PROP_PARTNER:
-		impl->partner = (GanvNode*)g_value_get_object(value);
-		break;
-	case PROP_SELECTED:
-		if (impl->selected != g_value_get_boolean(value)) {
-			GanvItem* item = GANV_ITEM(object);
-			impl->selected = g_value_get_boolean(value);
-			if (item->impl->canvas) {
-				if (impl->selected) {
-					ganv_canvas_select_node(ganv_item_get_canvas(item), node);
-				} else {
-					ganv_canvas_unselect_node(ganv_item_get_canvas(item), node);
-				}
-				ganv_item_request_update(item);
-			}
-		}
-		break;
-	case PROP_CANVAS:
-		if (!GANV_ITEM(object)->impl->parent) {
-			GanvCanvas* canvas = GANV_CANVAS(g_value_get_object(value));
-			g_object_set(object, "parent", ganv_canvas_root(canvas), NULL);
-			ganv_canvas_add_node(canvas, node);
-		} else {
-			g_warning("Cannot change `canvas' property after construction");
-		}
-		break;
-	case PROP_LABEL:
-		ganv_node_set_label(node, g_value_get_string(value));
-		break;
-	case PROP_SHOW_LABEL:
-		ganv_node_set_show_label(node, g_value_get_boolean(value));
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
-		break;
-	}
-}
-
-static void
-ganv_node_get_property(GObject*    object,
-                       guint       prop_id,
-                       GValue*     value,
-                       GParamSpec* pspec)
-{
-	g_return_if_fail(object != NULL);
-	g_return_if_fail(GANV_IS_NODE(object));
-
-	GanvNode*        node = GANV_NODE(object);
-	GanvNodePrivate* impl = node->impl;
-
-	switch (prop_id) {
-		GET_CASE(PARTNER, object, impl->partner);
-		GET_CASE(LABEL, string, impl->label ? impl->label->impl->text : NULL);
-		GET_CASE(DASH_LENGTH, double, impl->dash_length);
-		GET_CASE(DASH_OFFSET, double, impl->dash_offset);
-		GET_CASE(BORDER_WIDTH, double, impl->border_width);
-		GET_CASE(FILL_COLOR, uint, impl->fill_color);
-		GET_CASE(BORDER_COLOR, uint, impl->border_color);
-		GET_CASE(CAN_TAIL, boolean, impl->can_tail);
-		GET_CASE(CAN_HEAD, boolean, impl->can_head);
-		GET_CASE(IS_SOURCE, boolean, impl->is_source);
-		GET_CASE(SELECTED, boolean, impl->selected);
-		GET_CASE(HIGHLIGHTED, boolean, impl->highlighted);
-		GET_CASE(DRAGGABLE, boolean, impl->draggable);
-		GET_CASE(GRABBED, boolean, impl->grabbed);
-	case PROP_CANVAS:
-		g_value_set_object(value, ganv_item_get_canvas(GANV_ITEM(object)));
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
-		break;
-	}
-}
-
-static void
-ganv_node_default_tail_vector(const GanvNode* self,
-                              const GanvNode* head,
-                              double*         x,
-                              double*         y,
-                              double*         dx,
-                              double*         dy)
-{
-	GanvCanvas* canvas = ganv_item_get_canvas(GANV_ITEM(self));
-
-	*x = GANV_ITEM(self)->impl->x;
-	*y = GANV_ITEM(self)->impl->y;
-
-	switch (ganv_canvas_get_direction(canvas)) {
-	case GANV_DIRECTION_RIGHT:
-		*dx = 1.0;
-		*dy = 0.0;
-		break;
-	case GANV_DIRECTION_DOWN:
-		*dx = 0.0;
-		*dy = 1.0;
-		break;
-	}
-
-	ganv_item_i2w(GANV_ITEM(self)->impl->parent, x, y);
-}
-
-static void
-ganv_node_default_head_vector(const GanvNode* self,
-                              const GanvNode* tail,
-                              double*         x,
-                              double*         y,
-                              double*         dx,
-                              double*         dy)
-{
-	GanvCanvas* canvas = ganv_item_get_canvas(GANV_ITEM(self));
-
-	*x = GANV_ITEM(self)->impl->x;
-	*y = GANV_ITEM(self)->impl->y;
-
-	switch (ganv_canvas_get_direction(canvas)) {
-	case GANV_DIRECTION_RIGHT:
-		*dx = -1.0;
-		*dy = 0.0;
-		break;
-	case GANV_DIRECTION_DOWN:
-		*dx = 0.0;
-		*dy = -1.0;
-		break;
-	}
-
-	ganv_item_i2w(GANV_ITEM(self)->impl->parent, x, y);
-}
-
-void
-ganv_node_get_draw_properties(const GanvNode* node,
-                              double*         dash_length,
-                              double*         border_color,
-                              double*         fill_color)
-{
-	GanvNodePrivate* impl = node->impl;
-
-	*dash_length  = impl->dash_length;
-	*border_color = impl->border_color;
-	*fill_color   = impl->fill_color;
-
-	if (impl->selected) {
-		*dash_length  = 4.0;
-		*border_color = highlight_color(impl->border_color, 0x40);
-	}
-
-	if (impl->highlighted) {
-		*border_color = highlight_color(impl->border_color, 0x40);
-		*fill_color   = impl->fill_color;
-	}
-}
-
-void
-ganv_node_set_label(GanvNode* node, const char* str)
-{
-	GanvNodePrivate* impl = node->impl;
-	if (!str || str[0] == '\0') {
-		if (impl->label) {
-			gtk_object_destroy(GTK_OBJECT(impl->label));
-			impl->label = NULL;
-		}
-	} else if (impl->label) {
-		ganv_item_set(GANV_ITEM(impl->label),
-		              "text", str,
-		              NULL);
-	} else {
-		impl->label = GANV_TEXT(ganv_item_new(GANV_ITEM(node),
-		                                      ganv_text_get_type(),
-		                                      "text", str,
-		                                      "color", DEFAULT_TEXT_COLOR,
-		                                      "managed", TRUE,
-		                                      NULL));
-	}
-
-	impl->must_resize = TRUE;
-	ganv_item_request_update(GANV_ITEM(node));
-}
-
-void
-ganv_node_set_show_label(GanvNode* node, gboolean show)
-{
-	if (node->impl->label) {
-		if (show) {
-			ganv_item_show(GANV_ITEM(node->impl->label));
-		} else {
-			ganv_item_hide(GANV_ITEM(node->impl->label));
-		}
-	}
-	node->impl->show_label = show;
-	ganv_item_request_update(GANV_ITEM(node));
-}
-
-static void
-ganv_node_default_tick(GanvNode* self,
-                       double    seconds)
-{
-	GanvNode* node = GANV_NODE(self);
-	node->impl->dash_offset = seconds * 8.0;
-	ganv_item_request_update(GANV_ITEM(self));
-}
-
-static void
-ganv_node_default_disconnect(GanvNode* node)
-{
-	GanvCanvas* canvas = ganv_item_get_canvas(GANV_ITEM(node));
-	if (canvas) {
-		ganv_canvas_for_each_edge_on(
-			canvas, node, (GanvEdgeFunc)ganv_edge_disconnect, NULL);
-	}
-}
-
-static void
-ganv_node_default_move(GanvNode* node,
-                       double    dx,
-                       double    dy)
-{
-	GanvCanvas* canvas = ganv_item_get_canvas(GANV_ITEM(node));
-	ganv_item_move(GANV_ITEM(node), dx, dy);
-	ganv_canvas_for_each_edge_on(
-		canvas, node, (GanvEdgeFunc)ganv_edge_update_location, NULL);
-	ganv_item_request_update(GANV_ITEM(node));
-}
-
-static void
-ganv_node_default_move_to(GanvNode* node,
-                          double    x,
-                          double    y)
-{
-	GanvItem*   item   = GANV_ITEM(node);
-	GanvCanvas* canvas = ganv_item_get_canvas(item);
-	item->impl->x = x;
-	item->impl->y = y;
-	if (node->impl->can_tail) {
-		ganv_canvas_for_each_edge_from(
-			canvas, node, (GanvEdgeFunc)ganv_edge_update_location, NULL);
-	} else if (node->impl->can_head) {
-		ganv_canvas_for_each_edge_to(
-			canvas, node, (GanvEdgeFunc)ganv_edge_update_location, NULL);
-	}
-	ganv_item_request_update(GANV_ITEM(node));
-}
-
-static void
-ganv_node_default_resize(GanvNode* node)
-{
-	GanvItem* item = GANV_ITEM(node);
-	if (GANV_IS_NODE(item->impl->parent)) {
-		ganv_node_resize(GANV_NODE(item->impl->parent));
-	}
-	node->impl->must_resize = FALSE;
-}
-
-static void
-ganv_node_default_redraw_text(GanvNode* node)
-{
-	if (node->impl->label) {
-		ganv_text_layout(node->impl->label);
-		node->impl->must_resize = TRUE;
-		ganv_item_request_update(GANV_ITEM(node));
-	}
-}
-
-static gboolean
-ganv_node_default_event(GanvItem* item,
-                        GdkEvent* event)
-{
-	GanvNode*   node   = GANV_NODE(item);
-	GanvCanvas* canvas = ganv_item_get_canvas(GANV_ITEM(node));
-
-	// FIXME: put these somewhere better
-	static double last_x, last_y;
-	static double drag_start_x, drag_start_y;
-	static gboolean dragging = FALSE;
-
-	switch (event->type) {
-	case GDK_ENTER_NOTIFY:
-		ganv_item_raise(GANV_ITEM(node));
-		node->impl->highlighted = TRUE;
-		ganv_item_request_update(item);
-		return TRUE;
-
-	case GDK_LEAVE_NOTIFY:
-		ganv_item_lower(GANV_ITEM(node));
-		node->impl->highlighted = FALSE;
-		ganv_item_request_update(item);
-		return TRUE;
-
-	case GDK_BUTTON_PRESS:
-		drag_start_x = event->button.x;
-		drag_start_y = event->button.y;
-		last_x       = event->button.x;
-		last_y       = event->button.y;
-		if (!ganv_canvas_get_locked(canvas) && node->impl->draggable && event->button.button == 1) {
-			ganv_canvas_grab_item(
-				GANV_ITEM(node),
-				GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_PRESS_MASK,
-				ganv_canvas_get_move_cursor(canvas),
-				event->button.time);
-			node->impl->grabbed = TRUE;
-			dragging = TRUE;
-			return TRUE;
-		}
-		break;
-
-	case GDK_BUTTON_RELEASE:
-		if (dragging) {
-			gboolean selected;
-			g_object_get(G_OBJECT(node), "selected", &selected, NULL);
-			ganv_canvas_ungrab_item(GANV_ITEM(node), event->button.time);
-			node->impl->grabbed = FALSE;
-			dragging = FALSE;
-			if (event->button.x != drag_start_x || event->button.y != drag_start_y) {
-				ganv_canvas_contents_changed(canvas);
-				if (selected) {
-					ganv_canvas_selection_move_finished(canvas);
-				} else {
-					const double x = GANV_ITEM(node)->impl->x;
-					const double y = GANV_ITEM(node)->impl->y;
-					g_signal_emit(node, signal_moved, 0, x, y, NULL);
-				}
-			} else {
-				// Clicked
-				if (selected) {
-					ganv_canvas_unselect_node(canvas, node);
-				} else {
-					if (!(event->button.state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK))) {
-						ganv_canvas_clear_selection(canvas);
-					}
-					ganv_canvas_select_node(canvas, node);
-				}
-			}
-			return TRUE;
-		}
-		break;
-
-	case GDK_MOTION_NOTIFY:
-		if ((dragging && (event->motion.state & GDK_BUTTON1_MASK))) {
-			gboolean selected;
-			g_object_get(G_OBJECT(node), "selected", &selected, NULL);
-
-			double new_x = event->motion.x;
-			double new_y = event->motion.y;
-
-			if (event->motion.is_hint) {
-				int t_x;
-				int t_y;
-				GdkModifierType state;
-				gdk_window_get_pointer(event->motion.window, &t_x, &t_y, &state);
-				new_x = t_x;
-				new_y = t_y;
-			}
-
-			const double dx = new_x - last_x;
-			const double dy = new_y - last_y;
-			if (selected) {
-				ganv_canvas_move_selected_items(canvas, dx, dy);
-			} else {
-				ganv_node_move(node, dx, dy);
-			}
-
-			last_x = new_x;
-			last_y = new_y;
-			return TRUE;
-		}
-
-	default:
-		break;
-	}
-
-	return FALSE;
-}
-
-static void
-ganv_node_class_init(GanvNodeClass* klass)
-{
-	GObjectClass*   gobject_class = (GObjectClass*)klass;
-	GtkObjectClass* object_class  = (GtkObjectClass*)klass;
-	GanvItemClass*  item_class    = (GanvItemClass*)klass;
-
-	parent_class = GANV_ITEM_CLASS(g_type_class_peek_parent(klass));
-
-	gobject_class->set_property = ganv_node_set_property;
-	gobject_class->get_property = ganv_node_get_property;
-
-	g_object_class_install_property(
-		gobject_class, PROP_CANVAS, g_param_spec_object(
-			"canvas",
-			_("Canvas"),
-			_("The canvas this node is on."),
-			GANV_TYPE_CANVAS,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_PARTNER, g_param_spec_object(
-			"partner",
-			_("Partner"),
-			_("Partners are nodes that should be visually aligned to correspond"
-			  " to each other, even if they are not necessarily connected (e.g."
-			  " for separate modules representing the inputs and outputs of a"
-			  " single thing).  When the canvas is arranged, the partner will"
-			  " be aligned as if there was an edge from this node to its"
-			  " partner."),
-			GANV_TYPE_NODE,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_LABEL, g_param_spec_string(
-			"label",
-			_("Label"),
-			_("The text to display as a label on this node."),
-			NULL,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_SHOW_LABEL, g_param_spec_boolean(
-			"show-label",
-			_("Show label"),
-			_("Whether or not to show the label."),
-			0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_DASH_LENGTH, g_param_spec_double(
-			"dash-length",
-			_("Border dash length"),
-			_("Length of border dashes, or zero for no dashing."),
-			0.0, G_MAXDOUBLE,
-			0.0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_DASH_OFFSET, g_param_spec_double(
-			"dash-offset",
-			_("Border dash offset"),
-			_("Start offset for border dashes, used for selected animation."),
-			0.0, G_MAXDOUBLE,
-			0.0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_BORDER_WIDTH, g_param_spec_double(
-			"border-width",
-			_("Border width"),
-			_("Width of the border line."),
-			0.0, G_MAXDOUBLE,
-			2.0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_FILL_COLOR, g_param_spec_uint(
-			"fill-color",
-			_("Fill color"),
-			_("Color of internal area."),
-			0, G_MAXUINT,
-			DEFAULT_FILL_COLOR,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_BORDER_COLOR, g_param_spec_uint(
-			"border-color",
-			_("Border color"),
-			_("Color of border line."),
-			0, G_MAXUINT,
-			DEFAULT_BORDER_COLOR,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_CAN_TAIL, g_param_spec_boolean(
-			"can-tail",
-			_("Can tail"),
-			_("Whether this node can be the tail of an edge."),
-			0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_CAN_HEAD, g_param_spec_boolean(
-			"can-head",
-			_("Can head"),
-			_("Whether this object can be the head of an edge."),
-			0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_IS_SOURCE, g_param_spec_boolean(
-			"is-source",
-			_("Is source"),
-			_("Whether this object should be positioned at the start of signal flow."),
-			0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_SELECTED, g_param_spec_boolean(
-			"selected",
-			_("Selected"),
-			_("Whether this object is selected."),
-			0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_HIGHLIGHTED, g_param_spec_boolean(
-			"highlighted",
-			_("Highlighted"),
-			_("Whether this object is highlighted."),
-			0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_DRAGGABLE, g_param_spec_boolean(
-			"draggable",
-			_("Draggable"),
-			_("Whether this object is draggable."),
-			0,
-			G_PARAM_READWRITE));
-
-	g_object_class_install_property(
-		gobject_class, PROP_GRABBED, g_param_spec_boolean(
-			"grabbed",
-			_("Grabbed"),
-			_("Whether this object is grabbed by the user."),
-			0,
-			G_PARAM_READWRITE));
-
-	signal_moved = g_signal_new("moved",
-	                            ganv_node_get_type(),
-	                            G_SIGNAL_RUN_FIRST,
-	                            0, NULL, NULL,
-	                            ganv_marshal_VOID__DOUBLE_DOUBLE,
-	                            G_TYPE_NONE,
-	                            2,
-	                            G_TYPE_DOUBLE,
-	                            G_TYPE_DOUBLE,
-	                            0);
-
-	object_class->destroy = ganv_node_destroy;
-
-	item_class->realize = ganv_node_realize;
-	item_class->event   = ganv_node_default_event;
-	item_class->update  = ganv_node_update;
-	item_class->draw    = ganv_node_draw;
-
-	klass->disconnect  = ganv_node_default_disconnect;
-	klass->move        = ganv_node_default_move;
-	klass->move_to     = ganv_node_default_move_to;
-	klass->resize      = ganv_node_default_resize;
-	klass->redraw_text = ganv_node_default_redraw_text;
-	klass->tick        = ganv_node_default_tick;
-	klass->tail_vector = ganv_node_default_tail_vector;
-	klass->head_vector = ganv_node_default_head_vector;
-}
-
-gboolean
-ganv_node_can_tail(const GanvNode* self)
-{
-	return self->impl->can_tail;
-}
-
-gboolean
-ganv_node_can_head(const GanvNode* self)
-{
-	return self->impl->can_head;
-}
-
-void
-ganv_node_set_is_source(const GanvNode* node, gboolean is_source)
-{
-	node->impl->is_source = is_source;
-}
-
-gboolean
-ganv_node_is_within(const GanvNode* node,
-                    double          x1,
-                    double          y1,
-                    double          x2,
-                    double          y2)
-{
-	return GANV_NODE_GET_CLASS(node)->is_within(node, x1, y1, x2, y2);
-}
-
-void
-ganv_node_tick(GanvNode* node,
-               double    seconds)
-{
-	GanvNodeClass* klass = GANV_NODE_GET_CLASS(node);
-	if (klass->tick) {
-		klass->tick(node, seconds);
-	}
-}
-
-void
-ganv_node_tail_vector(const GanvNode* self,
-                      const GanvNode* head,
-                      double*         x1,
-                      double*         y1,
-                      double*         x2,
-                      double*         y2)
-{
-	GANV_NODE_GET_CLASS(self)->tail_vector(
-		self, head, x1, y1, x2, y2);
-}
-
-void
-ganv_node_head_vector(const GanvNode* self,
-                      const GanvNode* tail,
-                      double*         x1,
-                      double*         y1,
-                      double*         x2,
-                      double*         y2)
-{
-	GANV_NODE_GET_CLASS(self)->head_vector(
-		self, tail, x1, y1, x2, y2);
-}
-
-const char*
-ganv_node_get_label(const GanvNode* node)
-{
-	return node->impl->label ? node->impl->label->impl->text : NULL;
-}
-
-double
-ganv_node_get_border_width(const GanvNode* node)
-{
-	return node->impl->border_width;
-}
-
-void
-ganv_node_set_border_width(const GanvNode* node, double border_width)
-{
-	node->impl->border_width = border_width;
-	ganv_item_request_update(GANV_ITEM(node));
-}
-
-double
-ganv_node_get_dash_length(const GanvNode* node)
-{
-	return node->impl->dash_length;
-}
-
-void
-ganv_node_set_dash_length(const GanvNode* node, double dash_length)
-{
-	node->impl->dash_length = dash_length;
-	ganv_item_request_update(GANV_ITEM(node));
-}
-
-double
-ganv_node_get_dash_offset(const GanvNode* node)
-{
-	return node->impl->dash_offset;
-}
-
-void
-ganv_node_set_dash_offset(const GanvNode* node, double dash_offset)
-{
-	node->impl->dash_offset = dash_offset;
-	ganv_item_request_update(GANV_ITEM(node));
-}
-
-guint
-ganv_node_get_fill_color(const GanvNode* node)
-{
-	return node->impl->fill_color;
-}
-
-void
-ganv_node_set_fill_color(const GanvNode* node, guint fill_color)
-{
-	node->impl->fill_color = fill_color;
-	ganv_item_request_update(GANV_ITEM(node));
-}
-
-guint
-ganv_node_get_border_color(const GanvNode* node)
-{
-	return node->impl->border_color;
-}
-
-void
-ganv_node_set_border_color(const GanvNode* node, guint border_color)
-{
-	node->impl->border_color = border_color;
-	ganv_item_request_update(GANV_ITEM(node));
-}
-
-GanvNode*
-ganv_node_get_partner(const GanvNode* node)
-{
-	return node->impl->partner;
-}
-
-void
-ganv_node_move(GanvNode* node,
-               double    dx,
-               double    dy)
-{
-	GANV_NODE_GET_CLASS(node)->move(node, dx, dy);
-}
-
-void
-ganv_node_move_to(GanvNode* node,
-                  double    x,
-                  double    y)
-{
-	GANV_NODE_GET_CLASS(node)->move_to(node, x, y);
-}
-
-void
-ganv_node_resize(GanvNode* node)
-{
-	GANV_NODE_GET_CLASS(node)->resize(node);
-	node->impl->must_resize = FALSE;
-}
-
-void
-ganv_node_redraw_text(GanvNode* node)
-{
-	GANV_NODE_GET_CLASS(node)->redraw_text(node);
-}
-
-void
-ganv_node_disconnect(GanvNode* node)
-{
-	GANV_NODE_GET_CLASS(node)->disconnect(node);
-}
-
-gboolean
-ganv_node_is_selected(GanvNode* node)
-{
-	gboolean selected = FALSE;
-	g_object_get(node, "selected", &selected, NULL);
-	return selected;
-}