static void
create_demo_table (GooCanvasItem *root,
gdouble x,
gdouble y,
gdouble width,
gdouble height)
{
GooCanvasItem *table, *square, *circle, *triangle;
table = goo_canvas_table_new (root,
"row-spacing", 4.0,
"column-spacing", 4.0,
"width", width,
"height", height,
NULL);
goo_canvas_item_translate (table, x, y);
square = goo_canvas_rect_new (table, 0.0, 0.0, 50.0, 50.0,
"fill-color", "red",
NULL);
goo_canvas_item_set_child_properties (table, square,
"row", 0,
"column", 0,
"x-shrink", TRUE,
NULL);
g_object_set_data (G_OBJECT (square), "id", "Red square");
g_signal_connect (square, "button_press_event",
G_CALLBACK (on_button_press), NULL);
circle = goo_canvas_ellipse_new (table, 0.0, 0.0, 25.0, 25.0,
"fill-color", "blue",
NULL);
goo_canvas_item_set_child_properties (table, circle,
"row", 0,
"column", 1,
"x-shrink", TRUE,
NULL);
g_object_set_data (G_OBJECT (circle), "id", "Blue circle");
g_signal_connect (circle, "button_press_event",
G_CALLBACK (on_button_press), NULL);
triangle = goo_canvas_polyline_new (table, TRUE, 3,
25.0, 0.0, 0.0, 50.0, 50.0, 50.0,
"fill-color", "yellow",
NULL);
goo_canvas_item_set_child_properties (table, triangle,
"row", 0,
"column", 2,
"x-shrink", TRUE,
NULL);
g_object_set_data (G_OBJECT (triangle), "id", "Yellow triangle");
g_signal_connect (triangle, "button_press_event",
G_CALLBACK (on_button_press), NULL);
}
static void
draw_a_line(GooCanvasItem *group,
int x1, int y1, int x2, int y2, guint32 color)
{
goo_canvas_polyline_new(group, FALSE, 2,
(double)x1, (double)y1,
(double)x2, (double)y2,
"fill_color_rgba", color,
"line-width", (double)thickness,
NULL);
}
static GooCanvasItem *
draw_Trapez(GooCanvasItem *group,
struct Trapez t,const char *c1, const char *c2)
{
GooCanvasPoints *pts=goo_canvas_points_new(4);
GooCanvasItem *res=NULL;
pts->coords[0]=t.x_left;
pts->coords[1]=t.y_left_top;
pts->coords[2]=t.x_right;
pts->coords[3]=t.y_right_top;
pts->coords[4]=t.x_right;
pts->coords[5]=t.y_right_bottom;
pts->coords[6]=t.x_left;
pts->coords[7]=t.y_left_bottom;
res=goo_canvas_polyline_new(group, FALSE, 0,
"points", (GooCanvasPoints*)pts,
"fill-color", c1,
"stroke-color", c2,
"line-width", 1.0,
NULL);
return res;
}
/* ==================================== */
static GooCanvasItem *superbrain_create_item(GooCanvasItem *parent)
{
int i, j;
double x;
double x1, x2;
GooCanvasItem *item = NULL;
Piece *piece = NULL;
listPiecesClear();
if(current_y_position < SCROLL_LIMIT)
{
goo_canvas_item_translate(boardRootItem, 0.0, Y_STEP);
}
x = (BOARDWIDTH - number_of_piece*(PIECE_WIDTH*2+PIECE_GAP))/2 + PLAYING_AREA_X;
/* Draw a line to separate cleanly */
x1 = x + PIECE_WIDTH;
x2 = (BOARDWIDTH + (number_of_piece-1)*(PIECE_WIDTH*2+PIECE_GAP))/2 - PIECE_WIDTH + PLAYING_AREA_X;
goo_canvas_polyline_new (boardRootItem, FALSE, 2,
x1, current_y_position + PIECE_HEIGHT + PIECE_GAP/2,
x2, current_y_position + PIECE_HEIGHT + PIECE_GAP/2,
"stroke-color", "white",
"line-width", 1.0,
NULL);
goo_canvas_polyline_new (boardRootItem, FALSE, 2,
x1 + 2, current_y_position + PIECE_HEIGHT + PIECE_GAP/2 + 1,
x2 + 2, current_y_position + PIECE_HEIGHT + PIECE_GAP/2 + 1,
"stroke-color", "black",
"line-width", 1.0,
NULL);
/* Continuing the line */
x1 = PLAYING_HELP_X;
x2 = x1 + number_of_piece*PIECE_WIDTH;
goo_canvas_polyline_new (boardRootItem, FALSE, 2,
x1, current_y_position + PIECE_HEIGHT + PIECE_GAP/2,
x2, current_y_position + PIECE_HEIGHT + PIECE_GAP/2,
"stroke-color", "white",
"line-width", 1.0,
NULL);
goo_canvas_polyline_new (boardRootItem, FALSE, 2,
x1 + 2, current_y_position + PIECE_HEIGHT + PIECE_GAP/2 + 1,
x2 + 2, current_y_position + PIECE_HEIGHT + PIECE_GAP/2 + 1,
"stroke-color", "black",
"line-width", 1.0,
NULL);
/* Draw the pieces */
for(i=0; i<number_of_piece; i++)
{
piece = g_new(Piece, 1);
piece->listitem = NULL;
listPieces = g_list_append(listPieces, piece);
piece->rootitem = goo_canvas_group_new (parent,
NULL);
// Good
piece->good = goo_canvas_rect_new (piece->rootitem,
x + i*(PIECE_WIDTH*2 + PIECE_GAP) - PIECE_WIDTH - PIECE_GAP_GOOD,
current_y_position - PIECE_HEIGHT - PIECE_GAP_GOOD,
PIECE_WIDTH*2 + PIECE_GAP_GOOD*2,
PIECE_HEIGHT*2 + PIECE_GAP_GOOD*2,
"fill_color_rgba", COLOR_GOOD,
"stroke-color", "white",
"line-width", 1.0,
"tooltip", _("This item is well placed"),
NULL);
g_object_set (piece->good, "visibility", GOO_CANVAS_ITEM_INVISIBLE, NULL);
// Misplaced
piece->misplaced = goo_canvas_rect_new (piece->rootitem,
x + i*(PIECE_WIDTH*2 + PIECE_GAP) - PIECE_WIDTH - PIECE_GAP_GOOD,
current_y_position - PIECE_HEIGHT - PIECE_GAP_GOOD,
PIECE_WIDTH*2 + PIECE_GAP_GOOD*2,
PIECE_HEIGHT*2 + PIECE_GAP_GOOD*2,
"fill_color_rgba", COLOR_MISPLACED,
"stroke-color", "black",
"line-width", 1.0,
"tooltip", _("This item is misplaced"),
NULL);
g_object_set (piece->misplaced, "visibility", GOO_CANVAS_ITEM_INVISIBLE, NULL);
for(j=0; j<number_of_color; j++)
{
item = goo_canvas_ellipse_new (piece->rootitem,
x + i*(PIECE_WIDTH*2 + PIECE_GAP),
current_y_position,
PIECE_WIDTH,
PIECE_HEIGHT,
"fill_color_rgba", colors[j],
"stroke-color", "white",
"line-width", (double)1,
NULL);
gc_item_focus_init(item, NULL);
g_object_set (item, "visibility", GOO_CANVAS_ITEM_INVISIBLE, NULL);
piece->listitem = g_list_append(piece->listitem, item);
g_signal_connect(item, "button-press-event",
(GCallback) item_event, piece);
}
piece->selecteditem = 0;
item = g_list_nth_data(piece->listitem,
piece->selecteditem);
g_object_set (item, "visibility", GOO_CANVAS_ITEM_VISIBLE, NULL);
}
return NULL;
}
WireItem *
wire_item_new (Sheet *sheet, Wire *wire)
{
GooCanvasItem *item;
WireItem *wire_item;
GooCanvasPoints *points;
WireItemPriv *priv;
SheetPos start_pos, length;
g_return_val_if_fail (sheet != NULL, NULL);
g_return_val_if_fail (IS_SHEET (sheet), NULL);
wire_get_pos_and_length (wire, &start_pos, &length);
item = g_object_new (TYPE_WIRE_ITEM, NULL);
g_object_set (item,
"parent", sheet->object_group,
NULL);
wire_item = WIRE_ITEM (item);
g_object_set (wire_item,
"data", wire,
NULL);
priv = wire_item->priv;
priv->resize1 = GOO_CANVAS_RECT (goo_canvas_rect_new (
GOO_CANVAS_ITEM (wire_item),
-RESIZER_SIZE,
-RESIZER_SIZE,
2 * RESIZER_SIZE,
2 * RESIZER_SIZE,
"stroke-color", "blue",
"fill-color", "green",
"line-width", 1.0,
NULL));
g_object_set (priv->resize1,
"visibility", GOO_CANVAS_ITEM_INVISIBLE,
NULL);
priv->resize2 = GOO_CANVAS_RECT (goo_canvas_rect_new (
GOO_CANVAS_ITEM (wire_item),
length.x - RESIZER_SIZE,
length.y - RESIZER_SIZE,
2 * RESIZER_SIZE,
2 * RESIZER_SIZE,
"stroke-color", "blue",
"fill-color", "green",
"line-width", 1.0,
NULL));
g_object_set (priv->resize2,
"visibility", GOO_CANVAS_ITEM_INVISIBLE,
NULL);
points = goo_canvas_points_new (2);
points->coords[0] = 0;
points->coords[1] = 0;
points->coords[2] = length.x;
points->coords[3] = length.y;
priv->line = GOO_CANVAS_POLYLINE (goo_canvas_polyline_new (
GOO_CANVAS_ITEM (wire_item),
FALSE, 0,
"points", points,
"stroke-color", "blue",
"line-width", 1.0,
NULL));
goo_canvas_points_unref (points);
ITEM_DATA (wire)->rotated_handler_id =
g_signal_connect_data (wire, "rotated",
G_CALLBACK (wire_rotated_callback), G_OBJECT (wire_item), NULL, 0);
g_signal_connect_data (wire, "flipped",
G_CALLBACK (wire_flipped_callback), G_OBJECT (wire_item), NULL, 0);
ITEM_DATA (wire)->moved_handler_id =
g_signal_connect_object (wire, "moved",
G_CALLBACK (wire_moved_callback), G_OBJECT (wire_item), 0);
g_signal_connect (wire, "changed",
G_CALLBACK (wire_changed_callback), wire_item);
g_signal_connect (wire, "delete",
G_CALLBACK (wire_delete_callback), wire_item);
wire_update_bbox (wire);
return wire_item;
}
// 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;
}
WireItem *wire_item_new (Sheet *sheet, Wire *wire)
{
GooCanvasItem *item;
WireItem *wire_item;
ItemData *item_data;
GooCanvasPoints *points;
WireItemPriv *priv;
Coords start_pos, length;
g_return_val_if_fail (sheet != NULL, NULL);
g_return_val_if_fail (IS_SHEET (sheet), NULL);
wire_get_pos_and_length (wire, &start_pos, &length);
item = g_object_new (TYPE_WIRE_ITEM, NULL);
g_object_set (item, "parent", sheet->object_group, NULL);
wire_item = WIRE_ITEM (item);
g_object_set (wire_item, "data", wire, NULL);
priv = wire_item->priv;
const int random_color_count = 9;
const char *random_color[] = {"blue", "red", "green" /*, "yellow"*/, "orange", "brown",
"purple", "pink", "lightblue", "lightgreen"};
priv->resize1 = GOO_CANVAS_RECT (
goo_canvas_rect_new (GOO_CANVAS_ITEM (wire_item), -RESIZER_SIZE, -RESIZER_SIZE,
2 * RESIZER_SIZE, 2 * RESIZER_SIZE, "stroke-color",
oregano_options_debug_wires ()
? random_color[g_random_int_range (0, random_color_count - 1)]
: "blue",
"fill-color", "green", "line-width", 1.0, NULL));
g_object_set (priv->resize1, "visibility", GOO_CANVAS_ITEM_INVISIBLE, NULL);
priv->resize2 = GOO_CANVAS_RECT (goo_canvas_rect_new (
GOO_CANVAS_ITEM (wire_item), length.x - RESIZER_SIZE, length.y - RESIZER_SIZE,
2 * RESIZER_SIZE, 2 * RESIZER_SIZE, "stroke-color",
oregano_options_debug_wires ()
? random_color[g_random_int_range (0, random_color_count - 1)]
: "blue",
"fill-color", "green", "line-width", 1.0, NULL));
g_object_set (priv->resize2, "visibility", GOO_CANVAS_ITEM_INVISIBLE, NULL);
points = goo_canvas_points_new (2);
points->coords[0] = 0;
points->coords[1] = 0;
points->coords[2] = length.x;
points->coords[3] = length.y;
priv->line = GOO_CANVAS_POLYLINE (goo_canvas_polyline_new (
GOO_CANVAS_ITEM (wire_item), FALSE, 0, "points", points, "stroke-color",
oregano_options_debug_wires ()
? random_color[g_random_int_range (0, random_color_count - 1)]
: "blue",
"line-width", 1.0, "start-arrow", oregano_options_debug_wires () ? TRUE : FALSE,
"end-arrow", oregano_options_debug_wires () ? TRUE : FALSE, NULL));
goo_canvas_points_unref (points);
item_data = ITEM_DATA (wire);
item_data->rotated_handler_id = g_signal_connect_object (
G_OBJECT (wire), "rotated", G_CALLBACK (wire_rotated_callback), G_OBJECT (wire_item), 0);
item_data->flipped_handler_id = g_signal_connect_object (
G_OBJECT (wire), "flipped", G_CALLBACK (wire_flipped_callback), G_OBJECT (wire_item), 0);
item_data->moved_handler_id = g_signal_connect_object (
G_OBJECT (wire), "moved", G_CALLBACK (wire_moved_callback), G_OBJECT (wire_item), 0);
item_data->changed_handler_id = g_signal_connect_object (
G_OBJECT (wire), "changed", G_CALLBACK (wire_changed_callback), G_OBJECT (wire_item), 0);
g_signal_connect (wire, "delete", G_CALLBACK (wire_delete_callback), wire_item);
wire_update_bbox (wire);
return wire_item;
}
static void
create_canvas_items (GooCanvasGroup *group, LibraryPart *library_part)
{
GooCanvasItem *item;
GooCanvasPoints *points;
GSList *objects;
LibrarySymbol *symbol;
SymbolObject *object;
gdouble height, width;
GooCanvasBounds bounds, group_bounds = {0,0,0,0};
g_return_if_fail (group != NULL);
g_return_if_fail (library_part != NULL);
symbol = library_get_symbol (library_part->symbol_name);
if (symbol == NULL) {
g_warning ("Couldn't find the requested symbol %s for part %s in "
"library.\n",
library_part->symbol_name,
library_part->name);
return;
}
for (objects = symbol->symbol_objects; objects; objects = objects->next) {
object = (SymbolObject *)(objects->data);
switch (object->type) {
case SYMBOL_OBJECT_LINE:
points = object->u.uline.line;
item = goo_canvas_polyline_new (GOO_CANVAS_ITEM (group),
FALSE,
0,
"points", points,
"stroke-color", NORMAL_COLOR,
"line-width", 0.5,
NULL);
if (object->u.uline.spline) {
g_object_set (item,
"smooth", TRUE,
"spline_steps", 5,
NULL);
}
break;
case SYMBOL_OBJECT_ARC:
item = goo_canvas_ellipse_new (GOO_CANVAS_ITEM (group),
(object->u.arc.x2 + object->u.arc.x1) / 2.0,
(object->u.arc.y1 + object->u.arc.y2) / 2.0,
(object->u.arc.x2 - object->u.arc.x1) / 2.0,
(object->u.arc.y1 - object->u.arc.y2) / 2.0,
"stroke-color", NORMAL_COLOR,
"line_width", 1.0,
NULL);
break;
case SYMBOL_OBJECT_TEXT:
item = goo_canvas_text_new (GOO_CANVAS_ITEM (group),
object->u.text.str,
(double) object->u.text.x,
(double) object->u.text.y,
-1,
GOO_CANVAS_ANCHOR_NORTH_EAST,
"fill_color", LABEL_COLOR,
"font", "Sans 8",
NULL);
break;
default:
g_warning ("Unknown symbol object.\n");
continue;
}
goo_canvas_item_get_bounds (item, &bounds);
if (group_bounds.x1 > bounds.x1) group_bounds.x1 = bounds.x1;
if (group_bounds.x2 < bounds.x2) group_bounds.x2 = bounds.x2;
if (group_bounds.y1 > bounds.y1) group_bounds.y1 = bounds.y1;
if (group_bounds.y2 < bounds.y2) group_bounds.y2 = bounds.y2;
}
g_object_get (group,
"width", &width,
"height", &height,
NULL);
width = group_bounds.x2 - group_bounds.x1;
height = group_bounds.y2 - group_bounds.y1;
g_object_set (group,
"width", width,
"height", height,
NULL);
g_slist_free_full (objects, g_object_unref);
}
/*
* Display a random wind speed
*/
static void display_windspeed()
{
guint second = 0;
guint needle_zoom = 15;
gchar *tmpstr;
GooCanvasPoints *canvasPoints;
canvasPoints = goo_canvas_points_new (2);
if(speedRootItem!=NULL)
goo_canvas_item_remove(speedRootItem);
speedRootItem = goo_canvas_group_new (goo_canvas_get_root_item(gcomprisBoard->canvas),
NULL);
/* Speed orientation */
second = g_random_int()%60;
ang = second * M_PI / 30;
/* Speed force */
wind_speed = targetDefinition[gcomprisBoard->level-1].target_min_wind_speed \
+ g_random_int()%(targetDefinition[gcomprisBoard->level-1].target_max_wind_speed \
- targetDefinition[gcomprisBoard->level-1].target_min_wind_speed);
canvasPoints->coords[0]=SPEED_CENTER_X;
canvasPoints->coords[1]=SPEED_CENTER_Y;
canvasPoints->coords[2]=SPEED_CENTER_X + wind_speed * sin(ang) * needle_zoom;
canvasPoints->coords[3]=SPEED_CENTER_Y - wind_speed * cos(ang) * needle_zoom;
double w = 4.0;
goo_canvas_polyline_new (speedRootItem, FALSE, 0,
"points", canvasPoints,
"stroke-color-rgba", 0Xa05a2cffL,
"fill-color-rgba", 0Xa05a2cffL,
"line-width", w,
"end-arrow", TRUE,
"arrow-tip-length", 7.0,
"arrow-length", 5.0,
"arrow-width", 4.0,
NULL);
goo_canvas_points_unref(canvasPoints);
/* Draw the center of the speedometer */
goo_canvas_ellipse_new (speedRootItem,
SPEED_CENTER_X,
SPEED_CENTER_Y,
10.0,
10.0,
"fill_color_rgba", 0Xa05a2cffL,
"stroke-color", "black",
"line-width", (double)2,
NULL);
tmpstr = g_strdup_printf(_("Wind speed = %d\nkilometers/hour"), (guint)wind_speed);
goo_canvas_text_new (speedRootItem,
tmpstr,
(double) SPEED_CENTER_X,
(double) SPEED_CENTER_Y + 110,
-1,
GTK_ANCHOR_CENTER,
"font", gc_skin_font_board_medium,
"fill-color", "white",
NULL);
g_free(tmpstr);
}
