// Create a SheetItem from an ItemData object. This is a bit ugly.
// It could be beautified by having a method that creates the item.
// E.g. sheet_item->new_from_data (data);
SheetItem *
sheet_item_factory_create_sheet_item (Sheet *sheet, ItemData *data)
{
SheetItem *item;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (IS_ITEM_DATA (data), NULL);
g_return_val_if_fail (sheet != NULL, NULL);
g_return_val_if_fail (IS_SHEET (sheet), NULL);
item = NULL;
// Pick the right model.
if (IS_PART (data)) {
NG_DEBUG ("sheet_item_factory_create_sheet_item part\n\n");
item = SHEET_ITEM (part_item_new (sheet, PART (data)));
}
else if (IS_WIRE (data)) {
NG_DEBUG ("sheet_item_factory_create_sheet_item wire\n\n");
item = SHEET_ITEM (wire_item_new (sheet, WIRE (data)));
}
else if (IS_TEXTBOX (data)) {
NG_DEBUG ("sheet_item_factory_create_sheet_item text\n\n");
item = SHEET_ITEM (textbox_item_new (sheet, TEXTBOX (data)));
}
else
g_warning ("Unknown Item type.");
return item;
}
/**
* position within the sheet in pixel coordinates
*
* coordinates are clamped to grid if grid is enabled
* see snap_to_grid
* zero point : top left corner of the window (not widget!)
*
* @param x horizontal, left to right
* @param y vertical, top to bottom
* @returns wether the position could be detected properly
*
* @attention never call in event handlers!
*/
gboolean sheet_get_pointer_pixel (Sheet *sheet, gdouble *x, gdouble *y)
{
GtkAdjustment *hadj = NULL, *vadj = NULL;
gdouble x1, y1;
gint _x, _y;
GdkDeviceManager *device_manager;
GdkDevice *device_pointer;
GdkRectangle allocation;
GdkDisplay *display;
GdkWindow *window;
// deprecated gtk_widget_get_pointer (GTK_WIDGET (sheet), &_x, &_y);
// replaced by a code copied from evince
if (G_UNLIKELY (!sheet || !gtk_widget_get_realized (GTK_WIDGET (sheet)))) {
NG_DEBUG ("Widget is not realized.");
return FALSE;
}
display = gtk_widget_get_display (GTK_WIDGET (sheet));
device_manager = gdk_display_get_device_manager (display);
// gdk_device_manager_get_client_pointer
// shall not be used within events
device_pointer = gdk_device_manager_get_client_pointer (device_manager);
window = gtk_widget_get_window (GTK_WIDGET (sheet));
if (!window) {
NG_DEBUG ("Window is not realized.");
return FALSE;
}
// even though above is all defined the below will always return NUL for
// unknown reason and _x and _y are populated as expected
gdk_window_get_device_position (window, device_pointer, &_x, &_y, NULL);
#if 0
if (!window) { //fails always
NG_DEBUG ("Window does not seem to be realized yet?");
return FALSE;
}
#else
NG_DEBUG ("\n%p %p %p %p %i %i\n\n", display, device_manager, device_pointer, window, _x, _y);
#endif
gtk_widget_get_allocation (GTK_WIDGET (sheet), &allocation);
_x -= allocation.x;
_y -= allocation.y;
x1 = (gdouble)_x;
y1 = (gdouble)_y;
if (!sheet_get_adjustments (sheet, &hadj, &vadj))
return FALSE;
x1 += gtk_adjustment_get_value (hadj);
y1 += gtk_adjustment_get_value (vadj);
*x = x1;
*y = y1;
return TRUE;
}
RubberbandInfo *
rubberband_info_new (Sheet *sheet)
{
RubberbandInfo *rubberband_info;
cairo_pattern_t *pattern;
cairo_matrix_t matrix;
NG_DEBUG ("0x%x A", COLOR_A);
NG_DEBUG ("0x%x B", COLOR_B);
NG_DEBUG ("0x%x A PRE", COLOR_A_PRE);
NG_DEBUG ("0x%x B PRE", COLOR_B_PRE);
static guint32 stipple_data[8*8] = {
COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE,COLOR_B_PRE,COLOR_A_PRE,
COLOR_A_PRE, COLOR_A_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE,COLOR_A_PRE,COLOR_A_PRE,
COLOR_A_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_A_PRE,COLOR_A_PRE,COLOR_A_PRE,
COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_A_PRE, COLOR_A_PRE,COLOR_A_PRE,COLOR_A_PRE,
COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE,COLOR_A_PRE,COLOR_B_PRE,
COLOR_B_PRE, COLOR_B_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE,COLOR_B_PRE,COLOR_B_PRE,
COLOR_B_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_B_PRE,COLOR_B_PRE,COLOR_B_PRE,
COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_B_PRE, COLOR_B_PRE,COLOR_B_PRE,COLOR_B_PRE};
/* the stipple patten should look like that
* 1 1 1 0 0 0 0 1
* 1 1 0 0 0 0 1 1
* 1 0 0 0 0 1 1 1
* 0 0 0 0 1 1 1 1
*
* 0 0 0 1 1 1 1 0
* 0 0 1 1 1 1 0 0
* 0 1 1 1 1 0 0 0
* 1 1 1 1 0 0 0 0
*/
rubberband_info = g_new (RubberbandInfo, 1);
rubberband_info->state = RUBBERBAND_START;
pattern = create_stipple ("lightgrey", (guchar*)stipple_data);
//scale 5x, see http://cairographics.org/manual/cairo-cairo-pattern-t.html#cairo-pattern-t
cairo_matrix_init_scale (&matrix, 1.0, 1.0);
cairo_pattern_set_matrix (pattern, &matrix);
rubberband_info->rectangle = GOO_CANVAS_RECT (goo_canvas_rect_new (
GOO_CANVAS_ITEM (sheet->object_group),
10.0, 10.0,
10.0, 10.0,
"stroke-color", "black",
"line-width", 0.2,
"fill-pattern", pattern,
"visibility", GOO_CANVAS_ITEM_INVISIBLE,
NULL));
cairo_pattern_destroy (pattern);
return rubberband_info;
}
/*
* position within the sheet in pixel coordinates
* coordinates are clamped to grid if grid is enabled
* see snap_to_grid
* zero point : top left corner of the window (not widget!)
* x : horizontal, left to right
* y : vertical, top to bottom
* returns wether the position could be detected properly
*/
gboolean
sheet_get_pointer_pixel (Sheet *sheet, gdouble *x, gdouble *y)
{
GtkAdjustment *hadj, *vadj;
gdouble x1, y1;
gint _x, _y;
GdkDeviceManager *device_manager;
GdkDevice *device_pointer;
GdkRectangle allocation;
// deprecated gtk_widget_get_pointer (GTK_WIDGET (sheet), &_x, &_y);
// replaced by a code copied from evince
if (G_UNLIKELY (!sheet || !gtk_widget_get_realized (GTK_WIDGET (sheet)))) {
NG_DEBUG ("widget not realized");
return FALSE;
}
device_manager = gdk_display_get_device_manager (
gtk_widget_get_display (GTK_WIDGET (sheet)));
device_pointer = gdk_device_manager_get_client_pointer (device_manager);
//FIXME add another check based on the following functions return val
//FIXME gtkdoc says this shall not be used in event handlers
gdk_window_get_device_position (gtk_widget_get_window (GTK_WIDGET (sheet)),
device_pointer,
&_x, &_y, NULL);
if (!gtk_widget_get_has_window (GTK_WIDGET (sheet))) {
NG_DEBUG ("some weird gtk window shit failed");
return FALSE;
}
gtk_widget_get_allocation (GTK_WIDGET (sheet), &allocation);
_x -= allocation.x;
_y -= allocation.y;
x1 = (gdouble) _x;
y1 = (gdouble) _y;
if (!sheet_get_adjustments (sheet, &hadj, &vadj))
return FALSE;
x1 += gtk_adjustment_get_value (hadj);
y1 += gtk_adjustment_get_value (vadj);
*x = x1;
*y = y1;
return TRUE;
}
inline static cairo_pattern_t *
create_stipple (const char *color_name, guchar stipple_data[])
{
cairo_surface_t *surface;
cairo_pattern_t *pattern;
GdkColor color;
int stride;
const int width = 8;
const int height = 8;
gdk_color_parse (color_name, &color);
/* stipple_data[2] = stipple_data[14] = color.red >> 8;
stipple_data[1] = stipple_data[13] = color.green >> 8;
stipple_data[0] = stipple_data[12] = color.blue >> 8;
*/
stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, width);
g_assert (stride>0);
NG_DEBUG ("stride = %i", stride);
surface = cairo_image_surface_create_for_data (stipple_data,
CAIRO_FORMAT_ARGB32,
width, height, stride);
pattern = cairo_pattern_create_for_surface (surface);
cairo_surface_destroy (surface);
cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
return pattern;
}
/**
* lookup node at specified position
*
* @param store which store to check
* @param pos where to check in that store
* @returns the node pointer if there is a node, else NULL
*/
Node *node_store_get_node (NodeStore *store, Coords pos)
{
Node *node;
g_return_val_if_fail (store != NULL, NULL);
g_return_val_if_fail (IS_NODE_STORE (store), NULL);
node = g_hash_table_lookup (store->nodes, &pos);
if (!node) {
NG_DEBUG ("No node at (%g, %g)", pos.x, pos.y);
} else {
NG_DEBUG ("Found node at (%g, %g)", pos.x, pos.y);
}
return node;
}
static int
is_wire_at_pos (double x1, double y1, double x2, double y2, SheetPos pos)
{
double k, x0, y0;
x0 = pos.x;
y0 = pos.y;
if (!IS_EQ (x1, x2) && !IS_EQ (y1, y2)) {
k = ((y2 - y1)) / ((x2 - x1));
if (IS_EQ (y0, (y1 + k * (x0 - x1)))) {
return TRUE;
}
}
else if (IS_EQ (x2, x1) && IS_EQ (x1, x0)) {
if (y0 >= y1 && y0 <= y2) {
return TRUE;
}
}
else if (IS_EQ (y2, y1) && IS_EQ (y1, y0)) {
if (x0 >= x1 && x0 <= x2) {
return TRUE;
}
}
NG_DEBUG ("no match: (%g %g) -> (%g %g), (%g %g)\n", x1, y1, x2, y2, pos.x, pos.y);
return FALSE;
}
void wire_dbg_print (Wire *w)
{
Coords pos;
item_data_get_pos (ITEM_DATA (w), &pos);
NG_DEBUG ("Wire %p is defined by (%lf,%lf) + lambda * (%lf,%lf)\n", w, pos.x, pos.y,
w->priv->length.x, w->priv->length.y);
}
gint
node_remove_wire (Node *node, Wire *wire)
{
gboolean dot;
g_return_val_if_fail (node != NULL, FALSE);
g_return_val_if_fail (IS_NODE (node), FALSE);
g_return_val_if_fail (wire != NULL, FALSE);
g_return_val_if_fail (IS_WIRE (wire), FALSE);
if (node->wire_count == 0)
return FALSE;
if (!g_slist_find (node->wires, wire)) {
NG_DEBUG ("node_remove_wire: not there.\n");
return FALSE;
}
dot = node_needs_dot (node);
node->wires = g_slist_remove (node->wires, wire);
node->wire_count--;
if (dot && (!node_needs_dot (node)))
g_signal_emit_by_name (G_OBJECT (node), "node_dot_removed", &node->key);
return TRUE;
}
gint
node_add_wire (Node *node, Wire *wire)
{
gboolean dot;
g_return_val_if_fail (node != NULL, FALSE);
g_return_val_if_fail (IS_NODE (node), FALSE);
g_return_val_if_fail (wire != NULL, FALSE);
g_return_val_if_fail (IS_WIRE (wire), FALSE);
if (g_slist_find (node->wires, wire)) {
NG_DEBUG ("node_add_wire: wire already there.\n");
return FALSE;
}
dot = node_needs_dot (node);
node->wires = g_slist_prepend (node->wires, wire);
node->wire_count++;
if (!dot && node_needs_dot (node))
g_signal_emit_by_name (G_OBJECT (node), "node_dot_added", &node->key);
return TRUE;
}
int
node_store_add_part (NodeStore *self, Part *part)
{
GSList *wire_list, *list;
Node *node;
SheetPos lookup_key;
SheetPos part_pos;
gdouble x, y;
int i, num_pins;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (IS_NODE_STORE (self), FALSE);
g_return_val_if_fail (part != NULL, FALSE);
g_return_val_if_fail (IS_PART (part), FALSE);
num_pins = part_get_num_pins (part);
item_data_get_pos (ITEM_DATA (part), &part_pos);
for (i = 0; i < num_pins; i++) {
Pin *pins;
pins = part_get_pins (part);
x = part_pos.x + pins[i].offset.x;
y = part_pos.y + pins[i].offset.y;
//Use the position of the pin as hash key.
lookup_key.x = x;
lookup_key.y = y;
// Retrieve a node for this position.
node = node_store_get_or_create_node (self, lookup_key);
// Add all the wires that intersect this pin to the node store.
wire_list = wires_at_pos (self, lookup_key);
for (list = wire_list; list; list = list->next) {
Wire *wire = list->data;
NG_DEBUG ("Add pin to wire.\n");
node_add_wire (node, wire);
wire_add_node (wire, node);
}
g_slist_free (wire_list);
node_add_pin (node, &pins[i]);
}
g_object_set (G_OBJECT (part), "store", self, NULL);
self->parts = g_list_prepend (self->parts, part);
self->items = g_list_prepend (self->items, part);
return TRUE;
}
gboolean
rubberband_update (Sheet *sheet, GdkEvent *event)
{
GList *iter;
Coords cur, cmin, cmax;
double dx, dy; // TODO maybe keep track of subpixel changes, make em global/part of the rubberband_info struct and reset on finish
double width, height,
width_ng, height_ng;
RubberbandInfo *rubberband_info;
rubberband_info = sheet->priv->rubberband_info;
g_assert (event->type == GDK_MOTION_NOTIFY);
cur.x = event->motion.x;
cur.y = event->motion.y;
goo_canvas_convert_from_pixels (GOO_CANVAS (sheet), &cur.x, &cur.y);
width = fabs(rubberband_info->end.x - rubberband_info->start.x);
height = fabs(rubberband_info->end.y - rubberband_info->start.y);
width_ng = fabs(cur.x - rubberband_info->start.x);
height_ng = fabs(cur.y - rubberband_info->start.y);
dx = fabs (width_ng - width);
dy = fabs (height_ng - height);
NG_DEBUG ("motion :: dx=%lf, dy=%lf :: x=%lf, y=%lf :: w_ng=%lf, h_ng=%lf", dx, dy, cur.x, cur.y, width_ng, height_ng);
// TODO FIXME scroll window if needed (use http://developer.gnome.org/goocanvas/stable/GooCanvas.html#goo-canvas-scroll-to)
if (dx > 0.1 || dy > 0.1) { //a 0.1 change in pixel coords would be the least visible, silently ignore everything else
rubberband_info->end.x = cur.x;
rubberband_info->end.y = cur.y;
cmin.x = MIN(rubberband_info->start.x, rubberband_info->end.x);
cmin.y = MIN(rubberband_info->start.y, rubberband_info->end.y);
cmax.x = cmin.x + width_ng;
cmax.y = cmin.y + height_ng;
#if 1
for (iter = sheet->priv->items; iter; iter = iter->next) {
sheet_item_select_in_area (iter->data,
&cmin,
&cmax);
}
#endif
g_object_set (GOO_CANVAS_ITEM (rubberband_info->rectangle),
"x", cmin.x,
"y", cmin.y,
"width", width_ng,
"height", height_ng,
"visibility", GOO_CANVAS_ITEM_VISIBLE,
NULL);
goo_canvas_item_raise (GOO_CANVAS_ITEM (rubberband_info->rectangle), NULL);
}
return TRUE;
}
static int
node_equal (gconstpointer a, gconstpointer b)
{
SheetPos *spa, *spb;
spa = (SheetPos *) a;
spb = (SheetPos *) b;
if (fabs (spa->y - spb->y) > HASH_EPSILON) {
if (fabs (spa->y - spb->y) < 2.0)
NG_DEBUG ("A neighbour of B in Y\n");
return 0;
}
if (fabs (spa->x - spb->x) > HASH_EPSILON) {
if (fabs (spa->x - spb->x) < 5.0)
NG_DEBUG ("A neighbour of B in X\n\n");
return 0;
}
return 1;
}
/**
* register a part to the nodestore
*/
gboolean node_store_add_part (NodeStore *self, Part *part)
{
NG_DEBUG ("-0-");
g_return_val_if_fail (self, FALSE);
g_return_val_if_fail (IS_NODE_STORE (self), FALSE);
g_return_val_if_fail (part, FALSE);
g_return_val_if_fail (IS_PART (part), FALSE);
GSList *iter, *copy;
Node *node;
Coords pin_pos;
Coords part_pos;
int i, num_pins;
Pin *pins;
num_pins = part_get_num_pins (part);
pins = part_get_pins (part);
item_data_get_pos (ITEM_DATA (part), &part_pos);
for (i = 0; i < num_pins; i++) {
// Use the position of the pin as hash key.
pin_pos.x = part_pos.x + pins[i].offset.x;
pin_pos.y = part_pos.y + pins[i].offset.y;
// Retrieve a node for this position.
node = node_store_get_or_create_node (self, pin_pos);
// Add all the wires that intersect this pin to the node store.
copy = get_wires_at_pos (self, pin_pos);
for (iter = copy; iter; iter = iter->next) {
Wire *wire = copy->data;
node_add_wire (node, wire);
wire_add_node (wire, node);
}
g_slist_free (copy);
node_add_pin (node, &pins[i]);
}
g_object_set (G_OBJECT (part), "store", self, NULL);
self->parts = g_list_prepend (self->parts, part);
self->items = g_list_prepend (self->items, part);
return TRUE;
}
gint
node_add_pin (Node *node, Pin *pin)
{
gboolean dot;
g_return_val_if_fail (node != NULL, FALSE);
g_return_val_if_fail (IS_NODE (node), FALSE);
g_return_val_if_fail (pin != NULL, FALSE);
if (g_slist_find (node->pins, pin)) {
NG_DEBUG ("node_add_pin: pin already there.\n");
return FALSE;
}
dot = node_needs_dot (node);
node->pins = g_slist_prepend (node->pins, pin);
node->pin_count++;
if (!dot && node_needs_dot (node))
g_signal_emit_by_name (G_OBJECT (node), "node_dot_added", &node->key);
return TRUE;
}
/**
* add/register the wire to the nodestore
*
* @param store
* @param wire
* @returns TRUE if the wire was added or merged, else FALSE
*/
gboolean node_store_add_wire (NodeStore *store, Wire *wire)
{
GList *list;
Node *node;
int i = 0;
g_return_val_if_fail (store, FALSE);
g_return_val_if_fail (IS_NODE_STORE (store), FALSE);
g_return_val_if_fail (wire, FALSE);
g_return_val_if_fail (IS_WIRE (wire), FALSE);
// Check for intersection with other wires.
for (list = store->wires; list; list = list->next) {
g_assert (list->data != NULL);
g_assert (IS_WIRE (list->data));
Coords where = {-77.77, -77.77};
Wire *other = list->data;
if (do_wires_intersect (wire, other, &where)) {
if (is_t_crossing (wire, other, &where) || is_t_crossing (other, wire, &where)) {
node = node_store_get_or_create_node (store, where);
node_add_wire (node, wire);
node_add_wire (node, other);
wire_add_node (wire, node);
wire_add_node (other, node);
NG_DEBUG ("Add wire %p to wire %p @ %lf,%lf.\n", wire, other, where.x, where.y);
} else {
// magic node removal if a x crossing is overlapped with another wire
node = node_store_get_node (store, where);
NG_DEBUG ("Nuke that node [ %p ] at coords inbetween", node);
if (node) {
Coords c[4];
wire_get_start_and_end_pos (other, c + 0, c + 1);
wire_get_start_and_end_pos (wire, c + 2, c + 3);
if (!coords_equal (&where, c + 0) && !coords_equal (&where, c + 1) &&
!coords_equal (&where, c + 2) && !coords_equal (&where, c + 3)) {
wire_remove_node (wire, node);
wire_remove_node (other, node);
node_remove_wire (node, wire);
node_remove_wire (node, other);
}
}
}
}
}
// Check for overlapping with other wires.
do {
for (list = store->wires; list; list = list->next) {
g_assert (list->data != NULL);
g_assert (IS_WIRE (list->data));
Wire *other = list->data;
Coords so, eo;
const gboolean overlap = do_wires_overlap (wire, other, &so, &eo);
NG_DEBUG ("overlap [ %p] and [ %p ] -- %s", wire, other,
overlap == TRUE ? "YES" : "NO");
if (overlap) {
Node *sn = node_store_get_node (store, eo);
Node *en = node_store_get_node (store, so);
#if 1
wire = vulcanize_wire (store, wire, other, &so, &eo);
node_store_remove_wire (store, g_object_ref (other)); // equiv
// wire_unregister
// XXX FIXME this
// modifies the list
// we iterate over!
// delay this until idle, so all handlers like adding view
// representation are completed so existing wire-items can be deleted
// properly
// this is not fancy nor nice but seems to work fairly nicly
g_idle_add (delayed_wire_delete, other);
break;
NG_DEBUG ("overlapping of %p with %p ", wire, other);
#else
if (!sn && !en) {
wire = vulcanize_wire (store, wire, other, &so, &eo);
} else if (!sn) {
NG_DEBUG ("do_something(TM) : %p sn==NULL ", other);
} else if (!en) {
NG_DEBUG ("do_something(TM) : %p en==NULL ", other);
} else {
NG_DEBUG ("do_something(TM) : %p else ", other);
}
#endif
} else {
NG_DEBUG ("not of %p with %p ", wire, other);
}
}
} while (list);
// Check for intersection with parts (pins).
for (list = store->parts; list; list = list->next) {
g_assert (list->data != NULL);
g_assert (IS_PART (list->data));
Coords part_pos;
gint num_pins = -1;
Part *part = list->data;
num_pins = part_get_num_pins (part);
item_data_get_pos (ITEM_DATA (part), &part_pos);
// Go through all the parts and see which of their
// pins that intersect the wire.
for (i = 0; i < num_pins; i++) {
Pin *pins;
Coords lookup_pos;
pins = part_get_pins (part);
lookup_pos.x = part_pos.x + pins[i].offset.x;
lookup_pos.y = part_pos.y + pins[i].offset.y;
// If there is a wire at this pin's position,
// add it to the return list.
if (is_point_on_wire (wire, &lookup_pos)) {
Node *node;
node = node_store_get_node (store, lookup_pos);
if (node != NULL) {
// Add the wire to the node (pin) that it intersected.
node_add_wire (node, wire);
wire_add_node (wire, node);
NG_DEBUG ("Add wire %p to pin (node) %p.\n", wire, node);
} else {
g_warning ("Bug: Found no node at pin at (%g %g).\n", lookup_pos.x,
lookup_pos.y);
}
}
}
}
g_object_set (G_OBJECT (wire), "store", store, NULL);
store->wires = g_list_prepend (store->wires, wire);
store->items = g_list_prepend (store->items, wire);
return TRUE;
}
gboolean
node_needs_dot (Node *node)
{
Wire *wire1, *wire2;
Coords start_pos1, length1, end_pos1;
Coords start_pos2, length2, end_pos2;
NG_DEBUG ("\nnode: %p --- pins: %i --- wires: %i", node, node->pin_count, node->wire_count);
// always display a black dot if a part hits a wire
if (node->pin_count >= 1 && node->wire_count >= 1) {
NG_DEBUG (" TRUE (pins>=1 && wires>=1)");
return TRUE;
// FIXME this can create sparse knots, because of overlaying wires o===xxxx===o
// TODO can be fixed by optimizing away/fuzing duplicate/overlaying wires
} else if ((node->pin_count + node->wire_count) > 2) {
NG_DEBUG (" TRUE (pins+wires>2)");
return TRUE;
} else if (node->wire_count == 2) {
// Check that we don't have two wire endpoints.
wire1 = node->wires->data;
wire2 = node->wires->next->data;
wire_get_pos_and_length (wire1, &start_pos1, &length1);
wire_get_pos_and_length (wire2, &start_pos2, &length2);
end_pos1.x = start_pos1.x + length1.x;
end_pos1.y = start_pos1.y + length1.y;
end_pos2.x = start_pos2.x + length2.x;
end_pos2.y = start_pos2.y + length2.y;
if (!(SEP (start_pos1, start_pos2) ||
SEP (start_pos1, end_pos2) ||
SEP (end_pos1, end_pos2) ||
SEP (end_pos1, start_pos2))) {
// The dot is only needed when the end/start-point of
// one of the wires in on the other wire.
if (ON_THE_WIRE (start_pos1, start_pos2, end_pos2) ||
ON_THE_WIRE ( end_pos1, start_pos2, end_pos2) ||
ON_THE_WIRE (start_pos2, start_pos1, end_pos1) ||
ON_THE_WIRE ( end_pos2, start_pos1, end_pos1)
) {
NG_DEBUG (" TRUE (wires>2 && endpoint on wire)");
return TRUE;
} else {
NG_DEBUG (" FALSE (wires>2 && crossing)");
return FALSE;
}
}
return FALSE;
} else if (node->pin_count == 1 && node->wire_count == 1) {
// TODO this is most likely obsolete and is never entered
// Check if we have one wire with a pin in the 'middle'.
wire1 = node->wires->data;
wire_get_pos_and_length (wire1, &start_pos1, &length1);
end_pos1.x = start_pos1.x + length1.x;
end_pos1.y = start_pos1.y + length1.y;
if (!SEP (node->key, start_pos1) && !SEP (node->key, end_pos1)) {
NG_DEBUG (" FALSE (pins==1 && wires==1) pin in the middle of a wire");
return TRUE;
}
}
NG_DEBUG (" FALSE (else)");
return FALSE;
}
NetlistEditor *
netlist_editor_new (GtkSourceBuffer * textbuffer) {
NetlistEditor * nle;
GtkBuilder *gui;
GError *perror = NULL;
GtkWidget * toplevel;
GtkScrolledWindow * scroll;
GtkSourceView * source_view;
GtkSourceLanguageManager * lm;
GtkButton * save, * close;
GtkSourceLanguage *lang=NULL;
if (!textbuffer)
return NULL;
if ((gui = gtk_builder_new ()) == NULL) {
oregano_error (_("Could not create the netlist dialog"));
return NULL;
}
gtk_builder_set_translation_domain (gui, NULL);
nle = NETLIST_EDITOR (g_object_new (netlist_editor_get_type (), NULL));
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/view-netlist.ui",
&perror) <= 0) {
gchar *msg;
msg = perror->message;
oregano_error_with_title (_("Could not create the netlist dialog"), msg);
g_error_free (perror);
return NULL;
}
toplevel = GTK_WIDGET (gtk_builder_get_object (gui, "toplevel"));
gtk_window_set_default_size (GTK_WINDOW (toplevel), 800, 600);
gtk_window_set_title (GTK_WINDOW (toplevel), "Net List Editor\n");
scroll = GTK_SCROLLED_WINDOW (gtk_builder_get_object (gui, "netlist-scrolled-window"));
source_view = GTK_SOURCE_VIEW (gtk_source_view_new ());
lm = GTK_SOURCE_LANGUAGE_MANAGER (gtk_source_language_manager_new ());
setup_language_manager_path (lm);
g_object_set_data_full (G_OBJECT (source_view), "language-manager",
lm, (GDestroyNotify) g_object_unref);
lang = gtk_source_language_manager_get_language (lm, "netlist");
if (lang) {
NG_DEBUG ("\"%s\" from \"%s\"", gtk_source_language_get_name (lang), OREGANO_LANGDIR "/netlist.lang");
gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (textbuffer), lang);
gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (textbuffer), TRUE);
gtk_source_buffer_set_highlight_matching_brackets (GTK_SOURCE_BUFFER (textbuffer), TRUE);
}
else {
g_warning ("Can't load netlist.lang in %s", OREGANO_LANGDIR "/netlist.lang");
}
gtk_text_view_set_editable (GTK_TEXT_VIEW (source_view), TRUE);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (source_view), GTK_TEXT_BUFFER (textbuffer));
gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET (source_view));
close = GTK_BUTTON (gtk_builder_get_object (gui, "btn_close"));
g_signal_connect_swapped (G_OBJECT (close), "clicked",
G_CALLBACK (g_object_unref), G_OBJECT (nle));
save = GTK_BUTTON (gtk_builder_get_object (gui, "btn_save"));
g_signal_connect (G_OBJECT (save), "clicked",
G_CALLBACK (netlist_editor_save), nle);
// Set tab, fonts, wrap mode, colors, etc. according
// to preferences
nle->priv->view = GTK_TEXT_VIEW (source_view);
nle->priv->toplevel = GTK_WINDOW (toplevel);
nle->priv->save = save;
nle->priv->close = close;
nle->priv->buffer = textbuffer;
gtk_widget_show_all (GTK_WIDGET (toplevel));
return nle;
}
int
node_store_add_wire (NodeStore *store, Wire *wire)
{
gdouble x1, y1, x2, y2;
GSList *ip_list, *list;
IntersectionPoint *ipoint;
Node *node;
SheetPos pos, length;
g_return_val_if_fail (store != NULL, FALSE);
g_return_val_if_fail (IS_NODE_STORE (store), FALSE);
g_return_val_if_fail (wire != NULL, FALSE);
g_return_val_if_fail (IS_WIRE (wire), FALSE);
wire_get_pos_and_length (wire, &pos, &length);
x1 = pos.x;
y1 = pos.y;
x2 = x1 + length.x;
y2 = y1 + length.y;
// Check for intersection with other wires.
ip_list = wires_intersect (store, x1, y1, x2, y2);
for (list = ip_list; list; list = list->next) {
ipoint = list->data;
if (IS_EQ (x1, x2) && ((ipoint->pos.y == y1) || (ipoint->pos.y == y2))) {
SheetPos w_pos, w_length;
gboolean can_join;
GSList *nodes;
wire_get_pos_and_length (ipoint->wire, &w_pos, &w_length);
gdouble _x1, _x2, _y1, _y2;
_x1 = w_pos.x;
_y1 = w_pos.y;
_x2 = _x1 + w_length.x;
_y2 = _y1 + w_length.y;
can_join = TRUE;
nodes = wire_get_nodes (wire);
for (; nodes; nodes = nodes->next) {
SheetPos p1;
Node *node = (Node *)nodes->data;
p1.x = _x1;
p1.y = _y1;
if ((fabs (node->key.x - p1.x) < 1e-3) &&
(fabs (node->key.y - p1.y) < 1e-3)){
can_join = FALSE;
break;
}
p1.x = _x2;
p1.y = _y2;
if ((fabs (node->key.x - p1.x) < 1e-3) &&
(fabs (node->key.y - p1.y) < 1e-3)){
can_join = FALSE;
break;
}
}
if (IS_EQ(_x1, _x2) && can_join) {
if (w_pos.x < pos.x) pos.x = w_pos.x;
if (w_pos.y < pos.y) pos.y = w_pos.y;
length.x += w_length.x;
length.y += w_length.y;
// Update the new size and pos of the wire
item_data_unregister (ITEM_DATA (ipoint->wire));
wire_set_length (ipoint->wire, &length);
item_data_set_pos (ITEM_DATA (ipoint->wire), &pos);
wire_update_bbox (ipoint->wire);
item_data_register (ITEM_DATA (ipoint->wire));
// Done!, return -1 so wire is deleted
return -1;
}
}
else if (IS_EQ (y1, y2) &&
((ipoint->pos.x == x1) ||
(ipoint->pos.x == x2))) {
SheetPos w_pos, w_length;
gboolean can_join;
GSList *nodes;
wire_get_pos_and_length (ipoint->wire, &w_pos, &w_length);
gdouble _x1, _x2, _y1, _y2;
_x1 = w_pos.x;
_y1 = w_pos.y;
_x2 = _x1 + w_length.x;
_y2 = _y1 + w_length.y;
can_join = TRUE;
nodes = wire_get_nodes (wire);
for (; nodes; nodes = nodes->next) {
SheetPos p;
Node *node = (Node *)nodes->data;
p.x = _x1;
p.y = _y1;
if ((fabs (node->key.x - p.x) < 1e-3) &&
(fabs (node->key.y - p.y) < 1e-3)){
can_join = FALSE;
break;
}
p.x = _x2;
p.y = _y2;
if ((fabs (node->key.x - p.x) < 1e-3) &&
(fabs (node->key.y - p.y) < 1e-3)){
can_join = FALSE;
break;
}
}
if (IS_EQ(_y1, _y2) && can_join) {
if (w_pos.x < pos.x) pos.x = w_pos.x;
if (w_pos.y < pos.y) pos.y = w_pos.y;
length.x += w_length.x;
length.y += w_length.y;
// Update the new size and pos of the wire
item_data_unregister (ITEM_DATA (ipoint->wire));
wire_set_length (ipoint->wire, &length);
item_data_set_pos (ITEM_DATA (ipoint->wire), &pos);
wire_update_bbox (ipoint->wire);
item_data_register (ITEM_DATA (ipoint->wire));
// Done!, return -1 so wire si deleted
return -1;
}
}
node = node_store_get_or_create_node (store, ipoint->pos);
// Add the wire, and also the wire that is intersected.
node_add_wire (node, wire);
node_add_wire (node, ipoint->wire);
wire_add_node (wire, node);
wire_add_node (ipoint->wire, node);
NG_DEBUG ("Add wire to wire.\n");
g_free (ipoint);
}
g_slist_free (ip_list);
// Check for intersection with parts (pins).
ip_list = wire_intersect_parts (store, wire);
for (list = ip_list; list; list = list->next) {
node = list->data;
// Add the wire to the node (pin) that it intersected.
node_add_wire (node, wire);
wire_add_node (wire, node);
NG_DEBUG ("Add wire to pin.\n");
}
g_slist_free (ip_list);
g_object_set (G_OBJECT (wire), "store", store, NULL);
store->wires = g_list_prepend (store->wires, wire);
store->items = g_list_prepend (store->items, wire);
return TRUE;
}
/**
* rotate an item by an @angle increment (may be negative)
* @angle the increment the item will be rotated (usually 90° steps)
* @center_pos if rotated as part of a group, this is the center to rotate around
* FIXME XXX TODO an issue arises as the center changes with part_rotate
* FIXME XXX TODO the view callback needs to compensate this somehow
*/
static void
part_rotate (ItemData *data, int angle, Coords *center_pos)
{
cairo_matrix_t affine;
double x, y;
Part *part;
PartPriv *priv;
int i, tot_rotation;
Coords b1, b2;
Coords part_center_before, part_center_after, delta;
Coords delta_cp_before, delta_cp_after;
gboolean handler_connected;
g_return_if_fail (data);
g_return_if_fail (IS_PART (data));
if (angle == 0)
return;
part = PART (data);
priv = part->priv;
tot_rotation = (priv->rotation + angle + 360) % 360;
NG_DEBUG ("rotation: angle=%i tot_rotation=%i", angle, tot_rotation);
// use the cairo matrix funcs to transform the pin
// positions relative to the item center
// this is only indirectly related to displaying
cairo_matrix_init_rotate (&affine, (double)angle * M_PI / 180.);
if (center_pos) {
delta_cp_before = coords_sub (&part_center_before, center_pos);
delta_cp_after = delta_cp_before;
cairo_matrix_transform_point (&affine, &delta_cp_after.x, &delta_cp_after.y);
}
priv->rotation = tot_rotation;
angle = tot_rotation;
// Rotate the pins.
for (i = 0; i < priv->num_pins; i++) {
x = priv->pins[i].offset.x;
y = priv->pins[i].offset.y;
cairo_matrix_transform_point (&affine, &x, &y);
if (fabs (x) < 1e-2)
x = 0.0;
if (fabs (y) < 1e-2)
y = 0.0;
priv->pins[i].offset.x = x;
priv->pins[i].offset.y = y;
}
// Rotate the bounding box, recenter to old center
item_data_get_relative_bbox (ITEM_DATA (part), &b1, &b2);
part_center_before = coords_average (&b1, &b2);
cairo_matrix_transform_point (&affine, &b1.x, &b1.y);
cairo_matrix_transform_point (&affine, &b2.x, &b2.y);
item_data_set_relative_bbox (ITEM_DATA (part), &b1, &b2);
part_center_after = coords_average (&b1, &b2);
delta = coords_sub (&part_center_before, &part_center_after);
if (center_pos) {
Coords diff = coords_sub (&delta_cp_after, &delta_cp_before);
coords_add (&delta, &diff);
}
item_data_move (data, &delta);
item_data_snap (data);
handler_connected = g_signal_handler_is_connected (G_OBJECT (part),
ITEM_DATA (part)->rotated_handler_id);
if (handler_connected) {
g_signal_emit_by_name (G_OBJECT (part),
"rotated", tot_rotation);
}
handler_connected = g_signal_handler_is_connected (G_OBJECT (part),
ITEM_DATA (part)->changed_handler_id);
if (handler_connected) {
g_signal_emit_by_name (G_OBJECT (part),
"changed");
}
}
/**
* \brief rotate an item by an @angle increment (may be negative)
*
* @angle the increment the item will be rotated (usually 90° steps)
* @center_pos if rotated as part of a group, this is the center to rotate
*around
*/
static void part_rotate (ItemData *data, int angle, Coords *center_pos)
{
g_return_if_fail (data);
g_return_if_fail (IS_PART (data));
cairo_matrix_t morph, morph_rot, local_rot;
Part *part;
PartPriv *priv;
gboolean handler_connected;
// Coords b1, b2;
part = PART (data);
priv = part->priv;
// FIXME store vanilla coords, apply the morph
// FIXME to these and store the result in the
// FIXME instance then everything will be fine
// XXX also prevents rounding yiggle up downs
angle /= 90;
angle *= 90;
cairo_matrix_init_rotate (&local_rot, (double)angle * M_PI / 180.);
cairo_matrix_multiply (item_data_get_rotate (data), item_data_get_rotate (data), &local_rot);
morph_rot = *(item_data_get_rotate (data));
cairo_matrix_multiply (&morph, &morph_rot, item_data_get_translate (data));
Coords delta_to_center, delta_to_center_transformed;
Coords delta_to_apply, delta_bbox;
Coords bbox_center, bbox_center_transformed;
Coords item_pos;
// get bbox
#if 0 // this causes #115 to reappear
item_data_get_relative_bbox (ITEM_DATA (part), &b1, &b2);
bbox_center = coords_average (&b1, &b2);
#endif
item_data_get_pos (ITEM_DATA (part), &item_pos);
Coords rotation_center;
if (center_pos == NULL) {
rotation_center = coords_sum (&bbox_center, &item_pos);
} else {
rotation_center = *center_pos;
}
delta_to_center_transformed = delta_to_center = coords_sub (&rotation_center, &item_pos);
cairo_matrix_transform_point (&local_rot, &(delta_to_center_transformed.x),
&(delta_to_center_transformed.y));
delta_to_apply = coords_sub (&delta_to_center, &delta_to_center_transformed);
#define DEBUG_THIS 0
// use the cairo matrix funcs to transform the pin
// positions relative to the item center
// this is only indirectly related to displayin
// HINT: we need to modify the actual pins to make the
// pin tests work being used to detect connections
gint i;
gdouble x, y;
// Rotate the pins.
for (i = 0; i < priv->num_pins; i++) {
x = priv->pins_orig[i].offset.x;
y = priv->pins_orig[i].offset.y;
cairo_matrix_transform_point (&morph_rot, &x, &y);
if (fabs (x) < 1e-2)
x = 0.0;
if (fabs (y) < 1e-2)
y = 0.0;
priv->pins[i].offset.x = x;
priv->pins[i].offset.y = y;
}
item_data_move (data, &delta_to_apply);
handler_connected = g_signal_handler_is_connected (G_OBJECT (data), data->changed_handler_id);
if (handler_connected) {
g_signal_emit_by_name (G_OBJECT (data), "changed");
} else {
NG_DEBUG ("handler not yet registerd.");
}
NG_DEBUG ("\n\n");
}
// This function defines the drawing sheet on which schematic will be drawn
GtkWidget *
sheet_new (int width, int height)
{
GooCanvas *sheet_canvas;
GooCanvasGroup *sheet_group;
GooCanvasPoints *points;
Sheet *sheet;
GtkWidget *sheet_widget;
GooCanvasItem *root;
// Creation of the Canvas
sheet = SHEET (g_object_new (TYPE_SHEET, NULL));
sheet_canvas = GOO_CANVAS (sheet);
g_object_set (G_OBJECT (sheet_canvas),
"bounds-from-origin", FALSE,
"bounds-padding", 4.0,
"background-color-rgb", 0xFFFFFF,
NULL);
root = goo_canvas_get_root_item (sheet_canvas);
sheet_group = GOO_CANVAS_GROUP (goo_canvas_group_new (
root,
NULL));
sheet_widget = GTK_WIDGET (sheet);
goo_canvas_set_bounds (GOO_CANVAS (sheet_canvas), 0, 0,
width + 20, height + 20);
// Define vicinity around GooCanvasItem
//sheet_canvas->close_enough = 6.0;
sheet->priv->width = width;
sheet->priv->height = height;
// Create the dot grid.
sheet->grid = grid_create (GOO_CANVAS_ITEM (sheet_group),
width,
height);
// Everything outside the sheet should be gray.
// top //
goo_canvas_rect_new (GOO_CANVAS_ITEM (sheet_group),
0.0,
0.0,
(double) width + 20.0,
20.0,
"fill_color", "gray",
"line-width", 0.0,
NULL);
goo_canvas_rect_new (GOO_CANVAS_ITEM (sheet_group),
0.0,
(double) height,
(double) width + 20.0,
(double) height + 20.0,
"fill_color", "gray",
"line-width", 0.0,
NULL);
// right //
goo_canvas_rect_new (GOO_CANVAS_ITEM (sheet_group),
0.0,
0.0,
20.0,
(double) height + 20.0,
"fill_color", "gray",
"line-width", 0.0,
NULL);
goo_canvas_rect_new (GOO_CANVAS_ITEM (sheet_group),
(double) width,
0.0,
(double) width + 20.0,
(double) height + 20.0,
"fill_color", "gray",
"line-width", 0.0,
NULL);
// Draw a thin black border around the sheet.
points = goo_canvas_points_new (5);
points->coords[0] = 20.0;
points->coords[1] = 20.0;
points->coords[2] = width;
points->coords[3] = 20.0;
points->coords[4] = width;
points->coords[5] = height;
points->coords[6] = 20.0;
points->coords[7] = height;
points->coords[8] = 20.0;
points->coords[9] = 20.0;
goo_canvas_polyline_new (GOO_CANVAS_ITEM (sheet_group),
FALSE, 0,
"line-width", 1.0,
"points", points,
NULL);
goo_canvas_points_unref (points);
// Finally, create the object group that holds all objects.
sheet->object_group = GOO_CANVAS_GROUP (goo_canvas_group_new (
root,
"x", 0.0,
"y", 0.0,
NULL));
NG_DEBUG ("root group %p", sheet->object_group);
sheet->priv->selected_group = GOO_CANVAS_GROUP (goo_canvas_group_new (
GOO_CANVAS_ITEM (sheet->object_group),
"x", 0.0,
"y", 0.0,
NULL));
NG_DEBUG ("selected group %p", sheet->priv->selected_group);
sheet->priv->floating_group = GOO_CANVAS_GROUP (goo_canvas_group_new (
GOO_CANVAS_ITEM (sheet->object_group),
"x", 0.0,
"y", 0.0,
NULL));
NG_DEBUG ("floating group %p", sheet->priv->floating_group);
// Hash table that keeps maps coordinate to a specific dot.
sheet->priv->node_dots = g_hash_table_new_full (dot_hash, dot_equal, g_free, NULL);
//this requires object_group to be setup properly
sheet->priv->rubberband_info = rubberband_info_new (sheet);
sheet->priv->create_wire_info = create_wire_info_new (sheet);
return sheet_widget;
}
/*
* change the zoom by factor <rate>
* zoom origin when zooming in is the cursor
* zoom origin when zooming out is the center of the current viewport
* sane <rate> values are in range of [0.5 .. 2]
*/
void
sheet_change_zoom (Sheet *sheet, gdouble rate)
{
g_return_if_fail (sheet);
g_return_if_fail (IS_SHEET (sheet));
//////////////////////////////////////////////7
gdouble x, y;
gdouble rx, ry;
gdouble px, py;
gdouble dx, dy;
gdouble cx, cy;
gdouble dcx, dcy;
GtkAdjustment *hadj, *vadj;
GooCanvas *canvas;
canvas = GOO_CANVAS (sheet);
// if we scroll out, just scroll to the center
if (rate < 1.) {
goo_canvas_set_scale (canvas, rate * goo_canvas_get_scale (canvas));
return;
}
// top left corner in pixels
if (sheet_get_adjustments (sheet, &hadj, &vadj)) {
x = gtk_adjustment_get_value (hadj);
y = gtk_adjustment_get_value (vadj);
} else {
x = y = 0.;
}
// get pointer position in pixels
sheet_get_pointer_pixel (sheet, &px, &py);
// get the page size in pixels
dx = gtk_adjustment_get_page_size (hadj);
dy = gtk_adjustment_get_page_size (vadj);
// calculate the center of the widget in pixels
cx = x + dx/2;
cy = y + dy/2;
// calculate the delta between the center and the pointer in pixels
// this is required as the center is the zoom target
dcx = px - cx;
dcy = py - cy;
// increase the top left position in pixels by our calculated delta
x += dcx;
y += dcy;
//convert to canvas coords
goo_canvas_convert_from_pixels (canvas, &x, &y);
//the center of the canvas is now our cursor position
goo_canvas_scroll_to (canvas, x, y);
//calculate a correction term
//for the case that we can not scroll the pane far enough to
//compensate the whole off-due-to-wrong-center-error
rx = gtk_adjustment_get_value (hadj);
ry = gtk_adjustment_get_value (vadj);
goo_canvas_convert_from_pixels (canvas, &rx, &ry);
//the correction term in goo coordinates, to be subtracted from the backscroll distance
rx -= x;
ry -= y;
// no the center is our cursor position and we can safely call scale
goo_canvas_set_scale (canvas, rate * goo_canvas_get_scale (canvas));
// top left corner in pixels after scaling
if (sheet_get_adjustments (sheet, &hadj, &vadj)) {
x = gtk_adjustment_get_value (hadj);
y = gtk_adjustment_get_value (vadj);
} else {
x = y = 0.;
}
// not sure if the below part is required, could be zer0
NG_DEBUG ("rx %lf\n", rx);
NG_DEBUG ("ry %lf\n", ry);
NG_DEBUG ("dcx %lf\n", dcx);
NG_DEBUG ("dcy %lf\n", dcy);
NG_DEBUG ("\n\n");
// gtk_adjustment_get_page_size is constant
x -= (dcx) / sheet->priv->zoom;
y -= (dcy) / sheet->priv->zoom;
goo_canvas_convert_from_pixels (canvas, &x, &y);
goo_canvas_scroll_to (canvas, x-rx, y-ry);
gtk_widget_queue_draw (GTK_WIDGET (canvas));
}
// Event handler for a "floating" group of objects.
int sheet_item_floating_event (Sheet *sheet, const GdkEvent *event)
{
SheetPriv *priv;
GList *list;
static gboolean keep = FALSE;
// Remember the start position of the mouse cursor.
static Coords last = {0., 0.};
// Mouse cursor position in window coordinates, snapped to the grid spacing.
static Coords snapped = {0., 0.};
// Move the selected item(s) by this movement.
Coords delta = {0., 0.};
g_return_val_if_fail (sheet != NULL, FALSE);
g_return_val_if_fail (IS_SHEET (sheet), FALSE);
g_return_val_if_fail (sheet->priv->floating_objects != NULL, FALSE);
priv = sheet->priv;
switch (event->type) {
case GDK_BUTTON_RELEASE:
g_signal_stop_emission_by_name (sheet, "event");
break;
case GDK_BUTTON_PRESS:
if (sheet->state != SHEET_STATE_FLOAT)
return TRUE;
switch (event->button.button) {
case 2:
case 4:
case 5:
return FALSE;
case 1:
// do not free the floating items, but use them like a stamp
keep = event->button.state & GDK_CONTROL_MASK;
// Continue adding if CTRL is pressed
if (!keep) {
sheet->state = SHEET_STATE_NONE;
g_signal_stop_emission_by_name (sheet, "event");
if (g_signal_handler_is_connected (sheet, sheet->priv->float_handler_id))
g_signal_handler_disconnect (sheet, sheet->priv->float_handler_id);
sheet->priv->float_handler_id = 0;
}
// FIXME assert that `Coords current` has been set by now!
for (list = priv->floating_objects; list; list = list->next) {
SheetItem *floating_item;
ItemData *floating_data;
// Create a real item.
floating_item = list->data;
if (!keep) {
floating_data = sheet_item_get_data (floating_item);
g_object_set (floating_item, "visibility", GOO_CANVAS_ITEM_INVISIBLE, NULL);
} else {
// FIXME the bounding box of the clone is wrong
floating_data = item_data_clone (sheet_item_get_data (floating_item));
}
g_object_ref (G_OBJECT (floating_data));
NG_DEBUG ("Item Data Pos will be %lf %lf", snapped.x, snapped.y)
item_data_set_pos (floating_data, &snapped);
item_data_snap (floating_data, sheet->grid);
schematic_add_item (schematic_view_get_schematic_from_sheet (sheet), floating_data);
if (!keep)
g_object_unref (G_OBJECT (floating_item));
}
if (keep) {
g_object_set (G_OBJECT (priv->floating_group), "x", snapped.x, "y", snapped.y,
NULL);
} else {
g_list_free (priv->floating_objects);
priv->floating_objects = NULL;
}
break;
case 3:
// Cancel the "float-placement" for button-3 clicks.
g_signal_stop_emission_by_name (sheet, "event");
sheet_item_cancel_floating (sheet);
break;
}
break;
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
g_signal_stop_emission_by_name (sheet, "event");
return TRUE;
case GDK_MOTION_NOTIFY:
// keep track of the position, as `sheet_get_pointer*()` does not work
// in other events than MOTION_NOTIFY
#if 0
{
Coords tmp;
last = current;
if (sheet_get_pointer (sheet, &tmp.x, &tmp.y)) {
snapped_current = current = tmp;
snap_to_grid (sheet->grid, &snapped_current.x, &snapped_current.y);
}
}
#endif
if (sheet->state != SHEET_STATE_FLOAT && sheet->state != SHEET_STATE_FLOAT_START)
return FALSE;
g_signal_stop_emission_by_name (sheet, "event");
// Get pointer position independantly of the zoom
if (sheet->state == SHEET_STATE_FLOAT_START) {
sheet->state = SHEET_STATE_FLOAT;
last.x = last.y = 0.;
// Reparent the selected objects so that we can move them
// efficiently.
for (list = priv->floating_objects; list; list = list->next) {
sheet_item_reparent (SHEET_ITEM (list->data), priv->floating_group);
// Set the floating item visible
g_object_set (G_OBJECT (list->data), "visibility", GOO_CANVAS_ITEM_VISIBLE, NULL);
}
#if 0
GooCanvasBounds box;
goo_canvas_item_get_bounds (priv->floating_group, &box);
#endif
NG_DEBUG ("\n\n\nFLOAT ### START\n\n\n\n");
}
sheet_get_pointer_snapped (sheet, &snapped.x, &snapped.y);
delta = coords_sub (&snapped, &last);
NG_DEBUG ("drag floating current sx=%lf sy=%lf \n", snapped.x, snapped.y);
NG_DEBUG ("drag floating last lx=%lf ly=%lf \n", last.x, last.y);
NG_DEBUG ("drag floating delta -> dx=%lf dy=%lf \n", delta.x, delta.y);
#if !FIXME_INCREMENTAL_MOVMENT_DOES_NOT_WORK
last = snapped;
#else
goo_canvas_item_set_transform (GOO_CANVAS_ITEM (priv->floating_group), NULL);
#endif
goo_canvas_item_translate (GOO_CANVAS_ITEM (priv->floating_group), delta.x, delta.y);
break;
case GDK_KEY_PRESS:
switch (event->key.keyval) {
case GDK_KEY_r:
case GDK_KEY_R: {
Coords bbdelta;
GooCanvasBounds bounds;
// Center the objects around the mouse pointer.
goo_canvas_item_get_bounds (GOO_CANVAS_ITEM (priv->floating_group), &bounds);
bbdelta.x = (bounds.x2 - bounds.x1) / 2.;
bbdelta.y = (bounds.y2 - bounds.y1) / 2.;
sheet_rotate_ghosts (sheet);
// Center the objects around the mouse pointer.
goo_canvas_item_get_bounds (GOO_CANVAS_ITEM (priv->floating_group), &bounds);
bbdelta.x -= (bounds.x2 - bounds.x1) / 2.;
bbdelta.y -= (bounds.y2 - bounds.y1) / 2.;
snap_to_grid (sheet->grid, &bbdelta.x, &bbdelta.y);
goo_canvas_item_translate (GOO_CANVAS_ITEM (priv->floating_group), bbdelta.x,
bbdelta.y);
} break;
default:
return FALSE;
}
default:
return FALSE;
}
return TRUE;
}