From 1277b6eaaffc08076f9d9440693f201fb61072e3 Mon Sep 17 00:00:00 2001 From: Přemysl Janouch Date: Mon, 7 Feb 2011 01:10:17 +0100 Subject: Add support for LdDiagramConnection to LdCanvas. Heavy LdCanvas refactoring, some modifications to ld-types. It just wasn't possible for me to further work with an old, 2000 lines long file without shuffling everything around at the same time. --- liblogdiag/ld-canvas.c | 758 ++++++++++++++++++++++++++++++++++++------------- liblogdiag/ld-types.c | 52 ++-- liblogdiag/ld-types.h | 10 +- 3 files changed, 608 insertions(+), 212 deletions(-) diff --git a/liblogdiag/ld-canvas.c b/liblogdiag/ld-canvas.c index 564a838..f89cbfd 100644 --- a/liblogdiag/ld-canvas.c +++ b/liblogdiag/ld-canvas.c @@ -61,11 +61,13 @@ enum { OPER_0, OPER_ADD_OBJECT, + OPER_CONNECT, OPER_SELECT, OPER_MOVE_SELECTION }; typedef struct _AddObjectData AddObjectData; +typedef struct _ConnectData ConnectData; typedef struct _SelectData SelectData; typedef struct _MoveSelectionData MoveSelectionData; @@ -75,6 +77,12 @@ struct _AddObjectData gboolean visible; }; +struct _ConnectData +{ + LdDiagramConnection *connection; + LdPoint origin; +}; + struct _SelectData { LdPoint drag_last_pos; @@ -115,7 +123,7 @@ struct _LdCanvasColor * @y: the Y coordinate of the center of view. * @zoom: the current zoom of the canvas. * @terminal: position of the highlighted terminal. - * @terminal_highlighted: whether a terminal is highlighted. + * @terminal_hovered: whether a terminal is hovered. * @drag_start_pos: position of the mouse pointer when dragging started. * @drag_operation: the operation to start when dragging starts. * @operation: the current operation. @@ -136,7 +144,7 @@ struct _LdCanvasPrivate gdouble zoom; LdPoint terminal; - gboolean terminal_highlighted; + gboolean terminal_hovered; LdPoint drag_start_pos; gint drag_operation; @@ -145,6 +153,7 @@ struct _LdCanvasPrivate union { AddObjectData add_object; + ConnectData connect; SelectData select; MoveSelectionData move_selection; } @@ -203,46 +212,76 @@ static void diagram_disconnect_signals (LdCanvas *self); static gdouble ld_canvas_get_base_unit_in_px (GtkWidget *self); static gdouble ld_canvas_get_scale_in_px (LdCanvas *self); +/* Helper functions. */ static void ld_canvas_color_set (LdCanvasColor *color, gdouble r, gdouble g, gdouble b, gdouble a); static void ld_canvas_color_apply (LdCanvasColor *color, cairo_t *cr); +static gdouble point_to_line_segment_distance + (const LdPoint *point, const LdPoint *p1, const LdPoint *p2); + +/* Generic functions. */ +static gboolean object_hit_test (LdCanvas *self, + LdDiagramObject *object, const LdPoint *point); +static gboolean get_object_clip_area (LdCanvas *self, + LdDiagramObject *object, LdRectangle *rect); + +static void move_object_to_point (LdCanvas *self, LdDiagramObject *object, + const LdPoint *point); +static LdDiagramObject *get_object_at_point (LdCanvas *self, + const LdPoint *point); + static void move_selection (LdCanvas *self, gdouble dx, gdouble dy); -static void move_object_to_coords (LdCanvas *self, LdDiagramObject *object, - gdouble x, gdouble y); -static LdDiagramObject *get_object_at_coords (LdCanvas *self, - gdouble x, gdouble y); static gboolean is_object_selected (LdCanvas *self, LdDiagramObject *object); -static LdSymbol *resolve_diagram_symbol (LdCanvas *self, - LdDiagramSymbol *diagram_symbol); -static gboolean get_symbol_area (LdCanvas *self, LdDiagramSymbol *symbol, - LdRectangle *rect); -static gboolean get_symbol_clip_area (LdCanvas *self, LdDiagramSymbol *symbol, - LdRectangle *rect); -static gboolean get_object_area (LdCanvas *self, LdDiagramObject *object, - LdRectangle *rect); -static gboolean object_hit_test (LdCanvas *self, LdDiagramObject *object, - gdouble x, gdouble y); -static void check_terminals (LdCanvas *self, gdouble x, gdouble y); -static void hide_terminals (LdCanvas *self); + static void queue_draw (LdCanvas *self, LdRectangle *rect); static void queue_object_draw (LdCanvas *self, LdDiagramObject *object); + +/* Symbol terminals. */ +static void check_terminals (LdCanvas *self, const LdPoint *point); +static void hide_terminals (LdCanvas *self); static void queue_terminal_draw (LdCanvas *self, LdPoint *terminal); +/* Diagram symbol. */ +static gboolean symbol_hit_test (LdCanvas *self, + LdDiagramSymbol *symbol, const LdPoint *point); +static gboolean get_symbol_clip_area (LdCanvas *self, + LdDiagramSymbol *symbol, LdRectangle *rect); + +static gboolean get_symbol_area (LdCanvas *self, + LdDiagramSymbol *symbol, LdRectangle *rect); +static LdSymbol *resolve_symbol (LdCanvas *self, + LdDiagramSymbol *diagram_symbol); + +/* Diagram connection. */ +static gboolean connection_hit_test (LdCanvas *self, + LdDiagramConnection *connection, const LdPoint *point); +static gboolean get_connection_clip_area (LdCanvas *self, + LdDiagramConnection *connection, LdRectangle *rect); + +static gboolean get_connection_area (LdCanvas *self, + LdDiagramConnection *connection, LdRectangle *rect); + +/* Operations. */ static void ld_canvas_real_cancel_operation (LdCanvas *self); static void oper_add_object_end (LdCanvas *self); -static void oper_select_begin (LdCanvas *self, gdouble x, gdouble y); +static void oper_connect_begin (LdCanvas *self, const LdPoint *point); +static void oper_connect_end (LdCanvas *self); +static void oper_connect_motion (LdCanvas *self, const LdPoint *point); + +static void oper_select_begin (LdCanvas *self, const LdPoint *point); static void oper_select_end (LdCanvas *self); static void oper_select_get_rectangle (LdCanvas *self, LdRectangle *rect); static void oper_select_queue_draw (LdCanvas *self); static void oper_select_draw (GtkWidget *widget, DrawData *data); -static void oper_select_motion (LdCanvas *self, gdouble x, gdouble y); +static void oper_select_motion (LdCanvas *self, const LdPoint *point); -static void oper_move_selection_begin (LdCanvas *self, gdouble x, gdouble y); +static void oper_move_selection_begin (LdCanvas *self, const LdPoint *point); static void oper_move_selection_end (LdCanvas *self); -static void oper_move_selection_motion (LdCanvas *self, gdouble x, gdouble y); +static void oper_move_selection_motion (LdCanvas *self, const LdPoint *point); +/* Events, rendering. */ static void simulate_motion (LdCanvas *self); static gboolean on_motion_notify (GtkWidget *widget, GdkEventMotion *event, gpointer user_data); @@ -262,6 +301,7 @@ static void draw_diagram (GtkWidget *widget, DrawData *data); static void draw_terminal (GtkWidget *widget, DrawData *data); static void draw_object (LdDiagramObject *diagram_object, DrawData *data); static void draw_symbol (LdDiagramSymbol *diagram_symbol, DrawData *data); +static void draw_connection (LdDiagramConnection *connection, DrawData *data); G_DEFINE_TYPE (LdCanvas, ld_canvas, GTK_TYPE_DRAWING_AREA); @@ -957,45 +997,76 @@ ld_canvas_color_apply (LdCanvasColor *color, cairo_t *cr) cairo_set_source_rgba (cr, color->r, color->g, color->b, color->a); } -static void -move_selection (LdCanvas *self, gdouble dx, gdouble dy) +static gdouble +point_to_line_segment_distance + (const LdPoint *point, const LdPoint *p1, const LdPoint *p2) { - LdDiagram *diagram; - GList *selection, *iter; + gdouble dx, dy, u; - diagram = self->priv->diagram; - if (!diagram) - return; + dx = p2->x - p1->x; + dy = p2->y - p1->y; - selection = ld_diagram_get_selection (diagram); - if (!selection) - return; + if (dx == 0. && dy == 0.) + return ld_point_distance (point, p1->x, p1->y); - ld_diagram_begin_user_action (diagram); - for (iter = selection; iter; iter = g_list_next (iter)) - { - gdouble x, y; + /* Find projection of the point onto the line. */ + u = ((point->x - p1->x) * dx + (point->y - p1->y) * dy) + / (dx * dx + dy * dy); - g_object_get (iter->data, "x", &x, "y", &y, NULL); - x += dx; - y += dy; - g_object_set (iter->data, "x", x, "y", y, NULL); - } - ld_diagram_end_user_action (diagram); + /* The projection is beyond the line segment. */ + if (u < 0.) + return ld_point_distance (point, p1->x, p1->y); + else if (u > 1.) + return ld_point_distance (point, p2->x, p2->y); + + /* The projection is on the line segment. */ + return ld_point_distance (point, p1->x + u * dx, p1->y + u * dy); +} + + +/* ===== Generic functions ================================================= */ + +static gboolean +object_hit_test (LdCanvas *self, LdDiagramObject *object, const LdPoint *point) +{ + if (LD_IS_DIAGRAM_SYMBOL (object)) + return symbol_hit_test (self, + LD_DIAGRAM_SYMBOL (object), point); + if (LD_IS_DIAGRAM_CONNECTION (object)) + return connection_hit_test (self, + LD_DIAGRAM_CONNECTION (object), point); + return FALSE; +} + +static gboolean +get_object_clip_area (LdCanvas *self, + LdDiagramObject *object, LdRectangle *rect) +{ + if (LD_IS_DIAGRAM_SYMBOL (object)) + return get_symbol_clip_area (self, + LD_DIAGRAM_SYMBOL (object), rect); + if (LD_IS_DIAGRAM_CONNECTION (object)) + return get_connection_clip_area (self, + LD_DIAGRAM_CONNECTION (object), rect); + return FALSE; } static void -move_object_to_coords (LdCanvas *self, LdDiagramObject *object, - gdouble x, gdouble y) +move_object_to_point (LdCanvas *self, LdDiagramObject *object, + const LdPoint *point) { - gdouble dx, dy; + gdouble diagram_x, diagram_y; - ld_canvas_widget_to_diagram_coords (self, x, y, &dx, &dy); - g_object_set (object, "x", floor (dx + 0.5), "y", floor (dy + 0.5), NULL); + ld_canvas_widget_to_diagram_coords (self, + point->x, point->y, &diagram_x, &diagram_y); + g_object_set (object, + "x", floor (diagram_x + 0.5), + "y", floor (diagram_y + 0.5), + NULL); } static LdDiagramObject * -get_object_at_coords (LdCanvas *self, gdouble x, gdouble y) +get_object_at_point (LdCanvas *self, const LdPoint *point) { GList *objects, *iter; @@ -1006,108 +1077,72 @@ get_object_at_coords (LdCanvas *self, gdouble x, gdouble y) LdDiagramObject *object; object = LD_DIAGRAM_OBJECT (iter->data); - if (object_hit_test (self, object, x, y)) + if (object_hit_test (self, object, point)) return object; } return NULL; } -static gboolean -is_object_selected (LdCanvas *self, LdDiagramObject *object) -{ - return g_list_find (ld_diagram_get_selection (self->priv->diagram), - object) != NULL; -} - -static LdSymbol * -resolve_diagram_symbol (LdCanvas *self, LdDiagramSymbol *diagram_symbol) -{ - LdSymbol *symbol; - gchar *klass; - - if (!self->priv->library) - return NULL; - - klass = ld_diagram_symbol_get_class (diagram_symbol); - symbol = ld_library_find_symbol (self->priv->library, klass); - g_free (klass); - return symbol; -} - -static gboolean -get_symbol_area (LdCanvas *self, LdDiagramSymbol *symbol, LdRectangle *rect) +static void +move_selection (LdCanvas *self, gdouble dx, gdouble dy) { - gdouble object_x, object_y; - LdSymbol *library_symbol; - LdRectangle area; - gdouble x1, x2; - gdouble y1, y2; - - g_object_get (symbol, "x", &object_x, "y", &object_y, NULL); + LdDiagram *diagram; + GList *selection, *iter; - library_symbol = resolve_diagram_symbol (self, symbol); - if (library_symbol) - ld_symbol_get_area (library_symbol, &area); - else - return FALSE; + diagram = self->priv->diagram; + if (!diagram) + return; - /* TODO: Rotate the rectangle for other orientations. */ - ld_canvas_diagram_to_widget_coords (self, - object_x + area.x, - object_y + area.y, - &x1, &y1); - ld_canvas_diagram_to_widget_coords (self, - object_x + area.x + area.width, - object_y + area.y + area.height, - &x2, &y2); + selection = ld_diagram_get_selection (diagram); + if (!selection) + return; - x1 = floor (x1); - y1 = floor (y1); - x2 = ceil (x2); - y2 = ceil (y2); + ld_diagram_begin_user_action (diagram); + for (iter = selection; iter; iter = g_list_next (iter)) + { + gdouble x, y; - rect->x = x1; - rect->y = y1; - rect->width = x2 - x1; - rect->height = y2 - y1; - return TRUE; + g_object_get (iter->data, "x", &x, "y", &y, NULL); + x += dx; + y += dy; + g_object_set (iter->data, "x", x, "y", y, NULL); + } + ld_diagram_end_user_action (diagram); } static gboolean -get_symbol_clip_area (LdCanvas *self, LdDiagramSymbol *symbol, - LdRectangle *rect) +is_object_selected (LdCanvas *self, LdDiagramObject *object) { - LdRectangle object_rect; - - if (!get_object_area (self, LD_DIAGRAM_OBJECT (symbol), &object_rect)) - return FALSE; - - *rect = object_rect; - ld_rectangle_extend (rect, SYMBOL_CLIP_TOLERANCE); - return TRUE; + return g_list_find (ld_diagram_get_selection (self->priv->diagram), + object) != NULL; } -static gboolean -get_object_area (LdCanvas *self, LdDiagramObject *object, LdRectangle *rect) +static void +queue_draw (LdCanvas *self, LdRectangle *rect) { - if (LD_IS_DIAGRAM_SYMBOL (object)) - return get_symbol_area (self, LD_DIAGRAM_SYMBOL (object), rect); - return FALSE; + LdRectangle area; + + area = *rect; + ld_rectangle_extend (&area, QUEUE_DRAW_EXTEND); + gtk_widget_queue_draw_area (GTK_WIDGET (self), + area.x, area.y, area.width, area.height); } -static gboolean -object_hit_test (LdCanvas *self, LdDiagramObject *object, gdouble x, gdouble y) +static void +queue_object_draw (LdCanvas *self, LdDiagramObject *object) { LdRectangle rect; - if (!get_object_area (self, object, &rect)) - return FALSE; - ld_rectangle_extend (&rect, OBJECT_BORDER_TOLERANCE); - return ld_rectangle_contains (&rect, x, y); + if (!get_object_clip_area (self, object, &rect)) + return; + queue_draw (self, &rect); } + +/* ===== Symbol terminals ================================================== */ + static void -check_terminals (LdCanvas *self, gdouble x, gdouble y) +check_terminals (LdCanvas *self, const LdPoint *point) { GList *objects, *iter; LdDiagramSymbol *closest_symbol = NULL; @@ -1128,7 +1163,7 @@ check_terminals (LdCanvas *self, gdouble x, gdouble y) continue; diagram_symbol = LD_DIAGRAM_SYMBOL (iter->data); - symbol = resolve_diagram_symbol (self, diagram_symbol); + symbol = resolve_symbol (self, diagram_symbol); if (!symbol) continue; @@ -1139,16 +1174,16 @@ check_terminals (LdCanvas *self, gdouble x, gdouble y) for (i = 0; i < terminals->length; i++) { - LdPoint cur_term; + LdPoint cur_term, widget_coords; gdouble distance; cur_term = terminals->points[i]; cur_term.x += object_x; cur_term.y += object_y; - ld_canvas_diagram_to_widget_coords (self, - cur_term.x, cur_term.y, &cur_term.x, &cur_term.y); - distance = ld_point_distance (&cur_term, x, y); + ld_canvas_diagram_to_widget_coords (self, + cur_term.x, cur_term.y, &widget_coords.x, &widget_coords.y); + distance = ld_point_distance (&widget_coords, point->x, point->y); if (distance <= closest_distance) { closest_symbol = diagram_symbol; @@ -1162,7 +1197,7 @@ check_terminals (LdCanvas *self, gdouble x, gdouble y) if (closest_symbol) { - self->priv->terminal_highlighted = TRUE; + self->priv->terminal_hovered = TRUE; self->priv->terminal = closest_terminal; queue_terminal_draw (self, &closest_terminal); } @@ -1171,47 +1206,213 @@ check_terminals (LdCanvas *self, gdouble x, gdouble y) static void hide_terminals (LdCanvas *self) { - if (self->priv->terminal_highlighted) + if (self->priv->terminal_hovered) { - self->priv->terminal_highlighted = FALSE; + self->priv->terminal_hovered = FALSE; queue_terminal_draw (self, &self->priv->terminal); } } static void -queue_draw (LdCanvas *self, LdRectangle *rect) +queue_terminal_draw (LdCanvas *self, LdPoint *terminal) +{ + LdRectangle rect; + LdPoint widget_coords; + + ld_canvas_diagram_to_widget_coords (self, + terminal->x, terminal->y, &widget_coords.x, &widget_coords.y); + + rect.x = widget_coords.x - TERMINAL_RADIUS; + rect.y = widget_coords.y - TERMINAL_RADIUS; + rect.width = 2 * TERMINAL_RADIUS; + rect.height = 2 * TERMINAL_RADIUS; + + queue_draw (self, &rect); +} + + +/* ===== Diagram symbol ==================================================== */ + +static gboolean +symbol_hit_test (LdCanvas *self, LdDiagramSymbol *symbol, const LdPoint *point) +{ + LdRectangle rect; + + if (!get_symbol_area (self, symbol, &rect)) + return FALSE; + ld_rectangle_extend (&rect, OBJECT_BORDER_TOLERANCE); + return ld_rectangle_contains_point (&rect, point); +} + +static gboolean +get_symbol_clip_area (LdCanvas *self, + LdDiagramSymbol *symbol, LdRectangle *rect) { + LdRectangle object_rect; + + if (!get_symbol_area (self, symbol, &object_rect)) + return FALSE; + + *rect = object_rect; + ld_rectangle_extend (rect, SYMBOL_CLIP_TOLERANCE); + return TRUE; +} + +static gboolean +get_symbol_area (LdCanvas *self, LdDiagramSymbol *symbol, LdRectangle *rect) +{ + gdouble object_x, object_y; + LdSymbol *library_symbol; LdRectangle area; + gdouble x1, x2; + gdouble y1, y2; - area = *rect; - ld_rectangle_extend (&area, QUEUE_DRAW_EXTEND); - gtk_widget_queue_draw_area (GTK_WIDGET (self), - area.x, area.y, area.width, area.height); + g_object_get (symbol, "x", &object_x, "y", &object_y, NULL); + + library_symbol = resolve_symbol (self, symbol); + if (library_symbol) + ld_symbol_get_area (library_symbol, &area); + else + return FALSE; + + /* TODO: Rotate the rectangle for other orientations. */ + ld_canvas_diagram_to_widget_coords (self, + object_x + area.x, + object_y + area.y, + &x1, &y1); + ld_canvas_diagram_to_widget_coords (self, + object_x + area.x + area.width, + object_y + area.y + area.height, + &x2, &y2); + + x1 = floor (x1); + y1 = floor (y1); + x2 = ceil (x2); + y2 = ceil (y2); + + rect->x = x1; + rect->y = y1; + rect->width = x2 - x1; + rect->height = y2 - y1; + return TRUE; } -static void -queue_object_draw (LdCanvas *self, LdDiagramObject *object) +static LdSymbol * +resolve_symbol (LdCanvas *self, LdDiagramSymbol *diagram_symbol) { - if (LD_IS_DIAGRAM_SYMBOL (object)) + LdSymbol *symbol; + gchar *klass; + + if (!self->priv->library) + return NULL; + + klass = ld_diagram_symbol_get_class (diagram_symbol); + symbol = ld_library_find_symbol (self->priv->library, klass); + g_free (klass); + return symbol; +} + + +/* ===== Diagram connection ================================================ */ + +static gboolean +connection_hit_test (LdCanvas *self, LdDiagramConnection *connection, + const LdPoint *point) +{ + gdouble object_x, object_y, length; + LdPointArray *points; + guint i; + + g_object_get (connection, "x", &object_x, "y", &object_y, NULL); + + points = ld_diagram_connection_get_points (connection); + if (points->length < 2) { - LdRectangle rect; + ld_point_array_free (points); + return FALSE; + } - if (!get_symbol_clip_area (self, LD_DIAGRAM_SYMBOL (object), &rect)) - return; - queue_draw (self, &rect); + for (i = 0; i < points->length; i++) + { + ld_canvas_diagram_to_widget_coords (self, + points->points[i].x + object_x, + points->points[i].y + object_y, + &points->points[i].x, + &points->points[i].y); + + if (!i) + continue; + + length = point_to_line_segment_distance + (point, &points->points[i - 1], &points->points[i]); + if (length <= OBJECT_BORDER_TOLERANCE) + { + ld_point_array_free (points); + return TRUE; + } } + ld_point_array_free (points); + return FALSE; } -static void -queue_terminal_draw (LdCanvas *self, LdPoint *terminal) +static gboolean +get_connection_clip_area (LdCanvas *self, + LdDiagramConnection *connection, LdRectangle *rect) { - LdRectangle rect; + return get_connection_area (self, connection, rect); +} - rect.x = terminal->x - TERMINAL_RADIUS; - rect.y = terminal->y - TERMINAL_RADIUS; - rect.width = 2 * TERMINAL_RADIUS; - rect.height = 2 * TERMINAL_RADIUS; - queue_draw (self, &rect); +static gboolean +get_connection_area (LdCanvas *self, + LdDiagramConnection *connection, LdRectangle *rect) +{ + gdouble x_origin, y_origin; + gdouble x, y, x_min, x_max, y_min, y_max; + LdPointArray *points; + guint i; + + points = ld_diagram_connection_get_points (connection); + if (!points->length) + { + ld_point_array_free (points); + return FALSE; + } + + g_object_get (connection, "x", &x_origin, "y", &y_origin, NULL); + + ld_canvas_diagram_to_widget_coords (self, + x_origin + points->points[0].x, + y_origin + points->points[0].y, + &x, &y); + + x_max = x_min = x; + y_max = y_min = y; + + for (i = 1; i < points->length; i++) + { + ld_canvas_diagram_to_widget_coords (self, + x_origin + points->points[i].x, + y_origin + points->points[i].y, + &x, &y); + + if (x < x_min) + x_min = x; + else if (x > x_max) + x_max = x; + + if (y < y_min) + y_min = y; + else if (y > y_max) + y_max = y; + } + + rect->x = x_min; + rect->y = y_min; + rect->width = x_max - x_min; + rect->height = y_max - y_min; + + ld_point_array_free (points); + return TRUE; } @@ -1270,7 +1471,94 @@ oper_add_object_end (LdCanvas *self) } static void -oper_select_begin (LdCanvas *self, gdouble x, gdouble y) +oper_connect_begin (LdCanvas *self, const LdPoint *point) +{ + ConnectData *data; + + ld_canvas_real_cancel_operation (self); + + self->priv->operation = OPER_CONNECT; + self->priv->operation_end = oper_connect_end; + + data = &OPER_DATA (self, connect); + data->connection = ld_diagram_connection_new (NULL); + + data->origin = self->priv->terminal; + g_object_set (data->connection, + "x", data->origin.x, + "y", data->origin.y, + NULL); + + self->priv->terminal_hovered = FALSE; + + oper_connect_motion (self, point); +} + +static void +oper_connect_end (LdCanvas *self) +{ + ConnectData *data; + + data = &OPER_DATA (self, connect); + queue_object_draw (self, LD_DIAGRAM_OBJECT (data->connection)); + + ld_diagram_insert_object (self->priv->diagram, + LD_DIAGRAM_OBJECT (data->connection), -1); + + g_object_unref (data->connection); +} + +static void +oper_connect_motion (LdCanvas *self, const LdPoint *point) +{ + ConnectData *data; + LdPointArray *points; + gdouble diagram_x, diagram_y; + + data = &OPER_DATA (self, connect); + + /* Find an orthogonal path between the points. */ + /* TODO: This alghorithm is pretty lame, needs to be improved. */ + points = ld_point_array_sized_new (4); + points->length = 4; + + points->points[0].x = 0; + points->points[0].y = 0; + + ld_canvas_widget_to_diagram_coords (self, + point->x, point->y, &diagram_x, &diagram_y); + points->points[3].x = floor (diagram_x - data->origin.x + 0.5); + points->points[3].y = floor (diagram_y - data->origin.y + 0.5); + + if (ABS (points->points[3].x) > ABS (points->points[3].y)) + { + points->points[1].x = points->points[3].x / 2; + points->points[1].y = 0; + points->points[2].x = points->points[3].x / 2; + points->points[2].y = points->points[3].y; + } + else + { + points->points[1].x = 0; + points->points[1].y = points->points[3].y / 2; + points->points[2].x = points->points[3].x; + points->points[2].y = points->points[3].y / 2; + } + + queue_object_draw (self, LD_DIAGRAM_OBJECT (data->connection)); + ld_diagram_connection_set_points (data->connection, points); + queue_object_draw (self, LD_DIAGRAM_OBJECT (data->connection)); + ld_point_array_free (points); + + check_terminals (self, point); + + if (self->priv->terminal.x == data->origin.x + && self->priv->terminal.y == data->origin.y) + self->priv->terminal_hovered = FALSE; +} + +static void +oper_select_begin (LdCanvas *self, const LdPoint *point) { SelectData *data; @@ -1283,7 +1571,7 @@ oper_select_begin (LdCanvas *self, gdouble x, gdouble y) data->drag_last_pos.x = self->priv->drag_start_pos.x; data->drag_last_pos.y = self->priv->drag_start_pos.y; - oper_select_motion (self, x, y); + oper_select_motion (self, point); } static void @@ -1339,17 +1627,16 @@ oper_select_draw (GtkWidget *widget, DrawData *data) } static void -oper_select_motion (LdCanvas *self, gdouble x, gdouble y) +oper_select_motion (LdCanvas *self, const LdPoint *point) { SelectData *data; GList *objects, *iter; - LdRectangle selection_rect, object_rect; + LdRectangle selection_rect, rect; data = &OPER_DATA (self, select); oper_select_queue_draw (self); - data->drag_last_pos.x = x; - data->drag_last_pos.y = y; + data->drag_last_pos = *point; oper_select_queue_draw (self); oper_select_get_rectangle (self, &selection_rect); @@ -1360,11 +1647,21 @@ oper_select_motion (LdCanvas *self, gdouble x, gdouble y) LdDiagramObject *object; object = LD_DIAGRAM_OBJECT (iter->data); - if (!get_object_area (self, object, &object_rect)) - continue; + if (LD_IS_DIAGRAM_SYMBOL (object)) + { + if (!get_symbol_area (self, + LD_DIAGRAM_SYMBOL (object), &rect)) + continue; + } + else if (LD_IS_DIAGRAM_CONNECTION (object)) + { + if (!get_connection_area (self, + LD_DIAGRAM_CONNECTION (object), &rect)) + continue; + } - ld_rectangle_extend (&object_rect, OBJECT_BORDER_TOLERANCE); - if (ld_rectangle_intersects (&object_rect, &selection_rect)) + ld_rectangle_extend (&rect, OBJECT_BORDER_TOLERANCE); + if (ld_rectangle_contains (&selection_rect, &rect)) ld_diagram_select (self->priv->diagram, object); else ld_diagram_unselect (self->priv->diagram, object); @@ -1372,7 +1669,7 @@ oper_select_motion (LdCanvas *self, gdouble x, gdouble y) } static void -oper_move_selection_begin (LdCanvas *self, gdouble x, gdouble y) +oper_move_selection_begin (LdCanvas *self, const LdPoint *point) { MoveSelectionData *data; @@ -1384,10 +1681,9 @@ oper_move_selection_begin (LdCanvas *self, gdouble x, gdouble y) ld_diagram_begin_user_action (self->priv->diagram); data = &OPER_DATA (self, move_selection); - data->move_origin.x = self->priv->drag_start_pos.x; - data->move_origin.y = self->priv->drag_start_pos.y; + data->move_origin = self->priv->drag_start_pos; - oper_move_selection_motion (self, x, y); + oper_move_selection_motion (self, point); } static void @@ -1397,7 +1693,7 @@ oper_move_selection_end (LdCanvas *self) } static void -oper_move_selection_motion (LdCanvas *self, gdouble x, gdouble y) +oper_move_selection_motion (LdCanvas *self, const LdPoint *point) { MoveSelectionData *data; gdouble scale, dx, dy, move_x, move_y; @@ -1406,8 +1702,8 @@ oper_move_selection_motion (LdCanvas *self, gdouble x, gdouble y) scale = ld_canvas_get_scale_in_px (self); data = &OPER_DATA (self, move_selection); - dx = x - data->move_origin.x; - dy = y - data->move_origin.y; + dx = point->x - data->move_origin.x; + dy = point->y - data->move_origin.y; move_x = dx < 0 ? ceil (dx / scale) : floor (dx / scale); move_y = dy < 0 ? ceil (dy / scale) : floor (dy / scale); @@ -1457,9 +1753,13 @@ simulate_motion (LdCanvas *self) static gboolean on_motion_notify (GtkWidget *widget, GdkEventMotion *event, gpointer user_data) { + LdPoint point; LdCanvas *self; AddObjectData *add_data; + point.x = event->x; + point.y = event->y; + self = LD_CANVAS (widget); switch (self->priv->operation) { @@ -1468,14 +1768,17 @@ on_motion_notify (GtkWidget *widget, GdkEventMotion *event, gpointer user_data) add_data->visible = TRUE; queue_object_draw (self, add_data->object); - move_object_to_coords (self, add_data->object, event->x, event->y); + move_object_to_point (self, add_data->object, &point); queue_object_draw (self, add_data->object); break; + case OPER_CONNECT: + oper_connect_motion (self, &point); + break; case OPER_SELECT: - oper_select_motion (self, event->x, event->y); + oper_select_motion (self, &point); break; case OPER_MOVE_SELECTION: - oper_move_selection_motion (self, event->x, event->y); + oper_move_selection_motion (self, &point); break; case OPER_0: if (event->state & GDK_BUTTON1_MASK @@ -1484,15 +1787,18 @@ on_motion_notify (GtkWidget *widget, GdkEventMotion *event, gpointer user_data) { switch (self->priv->drag_operation) { + case OPER_CONNECT: + oper_connect_begin (self, &point); + break; case OPER_SELECT: - oper_select_begin (self, event->x, event->y); + oper_select_begin (self, &point); break; case OPER_MOVE_SELECTION: - oper_move_selection_begin (self, event->x, event->y); + oper_move_selection_begin (self, &point); break; } } - check_terminals (self, event->x, event->y); + check_terminals (self, &point); break; } return FALSE; @@ -1521,6 +1827,7 @@ on_leave_notify (GtkWidget *widget, GdkEventCrossing *event, gpointer user_data) static gboolean on_button_press (GtkWidget *widget, GdkEventButton *event, gpointer user_data) { + LdPoint point; LdCanvas *self; AddObjectData *data; LdDiagramObject *object; @@ -1530,6 +1837,9 @@ on_button_press (GtkWidget *widget, GdkEventButton *event, gpointer user_data) if (!gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); + point.x = event->x; + point.y = event->y; + self = LD_CANVAS (widget); if (!self->priv->diagram) return FALSE; @@ -1541,17 +1851,22 @@ on_button_press (GtkWidget *widget, GdkEventButton *event, gpointer user_data) data = &OPER_DATA (self, add_object); queue_object_draw (self, data->object); - move_object_to_coords (self, data->object, event->x, event->y); + move_object_to_point (self, data->object, &point); ld_diagram_insert_object (self->priv->diagram, data->object, -1); /* XXX: "cancel" causes confusion. */ ld_canvas_real_cancel_operation (self); break; case OPER_0: - self->priv->drag_start_pos.x = event->x; - self->priv->drag_start_pos.y = event->y; + self->priv->drag_start_pos = point; - object = get_object_at_coords (self, event->x, event->y); + if (self->priv->terminal_hovered) + { + self->priv->drag_operation = OPER_CONNECT; + break; + } + + object = get_object_at_point (self, &point); if (!object) { ld_diagram_unselect_all (self->priv->diagram); @@ -1574,12 +1889,16 @@ on_button_press (GtkWidget *widget, GdkEventButton *event, gpointer user_data) static gboolean on_button_release (GtkWidget *widget, GdkEventButton *event, gpointer user_data) { + LdPoint point; LdCanvas *self; LdDiagramObject *object; if (event->button != 1) return FALSE; + point.x = event->x; + point.y = event->y; + self = LD_CANVAS (widget); if (!self->priv->diagram) return FALSE; @@ -1588,10 +1907,11 @@ on_button_release (GtkWidget *widget, GdkEventButton *event, gpointer user_data) { case OPER_SELECT: case OPER_MOVE_SELECTION: + case OPER_CONNECT: ld_canvas_real_cancel_operation (self); break; case OPER_0: - object = get_object_at_coords (self, event->x, event->y); + object = get_object_at_point (self, &point); if (object && is_object_selected (self, object)) { if (!(event->state & GDK_SHIFT_MASK)) @@ -1608,8 +1928,11 @@ on_scroll (GtkWidget *widget, GdkEventScroll *event, gpointer user_data) { gdouble prev_x, prev_y; gdouble new_x, new_y; + LdPoint point; LdCanvas *self; + point.x = event->x; + point.y = event->y; self = LD_CANVAS (widget); ld_canvas_widget_to_diagram_coords (self, @@ -1634,7 +1957,7 @@ on_scroll (GtkWidget *widget, GdkEventScroll *event, gpointer user_data) self->priv->x += prev_x - new_x; self->priv->y += prev_y - new_y; - check_terminals (self, event->x, event->y); + check_terminals (self, &point); return TRUE; } @@ -1721,16 +2044,20 @@ static void draw_terminal (GtkWidget *widget, DrawData *data) { LdCanvasPrivate *priv; + LdPoint widget_coords; priv = data->self->priv; - if (!priv->terminal_highlighted) + if (!priv->terminal_hovered) return; ld_canvas_color_apply (COLOR_GET (data->self, COLOR_TERMINAL), data->cr); cairo_set_line_width (data->cr, 1); cairo_new_path (data->cr); - cairo_arc (data->cr, priv->terminal.x, priv->terminal.y, + ld_canvas_diagram_to_widget_coords (data->self, + priv->terminal.x, priv->terminal.y, + &widget_coords.x, &widget_coords.y); + cairo_arc (data->cr, widget_coords.x, widget_coords.y, TERMINAL_RADIUS, 0, 2 * G_PI); cairo_stroke (data->cr); } @@ -1753,12 +2080,17 @@ draw_diagram (GtkWidget *widget, DrawData *data) switch (data->self->priv->operation) { - AddObjectData *op_data; + AddObjectData *add_data; + ConnectData *connect_data; case OPER_ADD_OBJECT: - op_data = &OPER_DATA (data->self, add_object); - if (op_data->visible) - draw_object (op_data->object, data); + add_data = &OPER_DATA (data->self, add_object); + if (add_data->visible) + draw_object (add_data->object, data); + break; + case OPER_CONNECT: + connect_data = &OPER_DATA (data->self, connect); + draw_object (LD_DIAGRAM_OBJECT (connect_data->connection), data); break; } @@ -1780,6 +2112,8 @@ draw_object (LdDiagramObject *diagram_object, DrawData *data) if (LD_IS_DIAGRAM_SYMBOL (diagram_object)) draw_symbol (LD_DIAGRAM_SYMBOL (diagram_object), data); + else if (LD_IS_DIAGRAM_CONNECTION (diagram_object)) + draw_connection (LD_DIAGRAM_CONNECTION (diagram_object), data); } static void @@ -1789,7 +2123,7 @@ draw_symbol (LdDiagramSymbol *diagram_symbol, DrawData *data) LdRectangle clip_rect; gdouble x, y; - symbol = resolve_diagram_symbol (data->self, diagram_symbol); + symbol = resolve_symbol (data->self, diagram_symbol); /* TODO: Resolve this better; draw a cross or whatever. */ if (!symbol) @@ -1813,13 +2147,51 @@ draw_symbol (LdDiagramSymbol *diagram_symbol, DrawData *data) cairo_clip (data->cr); /* TODO: Rotate the space for other orientations. */ - ld_canvas_diagram_to_widget_coords (data->self, - ld_diagram_object_get_x (LD_DIAGRAM_OBJECT (diagram_symbol)), - ld_diagram_object_get_y (LD_DIAGRAM_OBJECT (diagram_symbol)), - &x, &y); + g_object_get (diagram_symbol, "x", &x, "y", &y, NULL); + ld_canvas_diagram_to_widget_coords (data->self, x, y, &x, &y); cairo_translate (data->cr, x, y); cairo_scale (data->cr, data->scale, data->scale); + ld_symbol_draw (symbol, data->cr); + cairo_restore (data->cr); +} + +static void +draw_connection (LdDiagramConnection *connection, DrawData *data) +{ + LdRectangle clip_rect; + LdPointArray *points; + gdouble x, y; + guint i; + + if (!get_connection_clip_area (data->self, connection, &clip_rect) + || !ld_rectangle_intersects (&clip_rect, &data->exposed_rect)) + return; + + points = ld_diagram_connection_get_points (connection); + if (points->length < 2) + goto draw_connection_end; + cairo_save (data->cr); + + g_object_get (connection, "x", &x, "y", &y, NULL); + ld_canvas_diagram_to_widget_coords (data->self, x, y, &x, &y); + cairo_translate (data->cr, x, y); + cairo_scale (data->cr, data->scale, data->scale); + + for (i = 1; i < points->length; i++) + { + cairo_move_to (data->cr, + points->points[i - 1].x, + points->points[i - 1].y); + cairo_line_to (data->cr, + points->points[i].x, + points->points[i].y); + cairo_stroke (data->cr); + } cairo_restore (data->cr); + +draw_connection_end: + ld_point_array_free (points); + return; } diff --git a/liblogdiag/ld-types.c b/liblogdiag/ld-types.c index 7721e36..d7e3dfb 100644 --- a/liblogdiag/ld-types.c +++ b/liblogdiag/ld-types.c @@ -90,7 +90,7 @@ DEFINE_BOXED_TRIVIAL_FREE (LdPoint, ld_point) * Compute the distance between two points. */ gdouble -ld_point_distance (LdPoint *self, gdouble x, gdouble y) +ld_point_distance (const LdPoint *self, gdouble x, gdouble y) { gdouble dx, dy; @@ -292,38 +292,58 @@ DEFINE_BOXED_TRIVIAL_COPY (LdRectangle, ld_rectangle) DEFINE_BOXED_TRIVIAL_FREE (LdRectangle, ld_rectangle) /** - * ld_rectangle_contains: + * ld_rectangle_intersects: * @self: an #LdRectangle structure. - * @x: the X coordinate of the point to be checked. - * @y: the Y coordinate of the point to be checked. + * @rect: an #LdRectangle to be checked for intersection. * - * Return value: %TRUE if the rectangle contains the specified point. + * Return value: %TRUE if the two rectangles intersect. */ gboolean -ld_rectangle_contains (LdRectangle *self, gdouble x, gdouble y) +ld_rectangle_intersects (const LdRectangle *self, const LdRectangle *rect) { g_return_val_if_fail (self != NULL, FALSE); - return (x >= self->x && x <= self->x + self->width - && y >= self->y && y <= self->y + self->height); + g_return_val_if_fail (rect != NULL, FALSE); + + return !(self->x > rect->x + rect->width + || self->y > rect->y + rect->height + || self->x + self->width < rect->x + || self->y + self->height < rect->y); } /** - * ld_rectangle_intersects: + * ld_rectangle_contains: * @self: an #LdRectangle structure. - * @rect: an #LdRectangle to be checked for intersection. + * @rect: an #LdRectangle to be checked for containment. * - * Return value: %TRUE if the two rectangles intersect. + * Return value: %TRUE if @self fully contains @rect. */ gboolean -ld_rectangle_intersects (LdRectangle *self, LdRectangle *rect) +ld_rectangle_contains (const LdRectangle *self, const LdRectangle *rect) { g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (rect != NULL, FALSE); - return !(self->x > rect->x + rect->width - || self->y > rect->y + rect->height - || self->x + self->width < rect->x - || self->y + self->height < rect->y); + return (self->x <= rect->x + && self->y <= rect->y + && self->x + self->width >= rect->x + rect->width + && self->y + self->height >= rect->y + rect->height); +} + +/** + * ld_rectangle_contains_point: + * @self: an #LdRectangle structure. + * @point: the point to be checked. + * + * Return value: %TRUE if the rectangle contains the specified point. + */ +gboolean +ld_rectangle_contains_point (const LdRectangle *self, const LdPoint *point) +{ + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (point != NULL, FALSE); + + return (point->x >= self->x && point->x <= self->x + self->width + && point->y >= self->y && point->y <= self->y + self->height); } /** diff --git a/liblogdiag/ld-types.h b/liblogdiag/ld-types.h index 29c0acc..30590e7 100644 --- a/liblogdiag/ld-types.h +++ b/liblogdiag/ld-types.h @@ -39,7 +39,7 @@ GType ld_point_get_type (void) G_GNUC_CONST; LdPoint *ld_point_copy (const LdPoint *self); void ld_point_free (LdPoint *self); -gdouble ld_point_distance (LdPoint *self, gdouble x, gdouble y); +gdouble ld_point_distance (const LdPoint *self, gdouble x, gdouble y); /** @@ -88,8 +88,12 @@ GType ld_rectangle_get_type (void) G_GNUC_CONST; LdRectangle *ld_rectangle_copy (const LdRectangle *self); void ld_rectangle_free (LdRectangle *self); -gboolean ld_rectangle_contains (LdRectangle *self, gdouble x, gdouble y); -gboolean ld_rectangle_intersects (LdRectangle *self, LdRectangle *rect); +gboolean ld_rectangle_intersects (const LdRectangle *self, + const LdRectangle *rect); +gboolean ld_rectangle_contains (const LdRectangle *self, + const LdRectangle *rect); +gboolean ld_rectangle_contains_point (const LdRectangle *self, + const LdPoint *point); void ld_rectangle_extend (LdRectangle *self, gdouble border); -- cgit v1.2.3-70-g09d2