static gboolean
on_button_press (GooCanvasItem *item,
GooCanvasItem *target,
GdkEventButton *event,
gpointer data)
{
GooCanvasItem *parent1, *parent2, *parent;
if (event->button != 1 || event->type != GDK_BUTTON_PRESS)
return FALSE;
g_print ("In on_button_press\n");
parent1 = g_object_get_data (G_OBJECT (item), "parent1");
parent2 = g_object_get_data (G_OBJECT (item), "parent2");
parent = goo_canvas_item_get_parent (item);
g_object_ref (item);
goo_canvas_item_remove (item);
if (parent == parent1)
goo_canvas_item_add_child (parent2, item, -1);
else
goo_canvas_item_add_child (parent1, item, -1);
g_object_unref (item);
return TRUE;
}
/* The convenience function to create new items. This should start with a
parent argument and end with a variable list of object properties to fit
in with the standard canvas items. */
GooCanvasItem*
goo_demo_large_line_new (GooCanvasItem *parent,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
...)
{
GooCanvasItem *item;
GooDemoLargeLine *demo_large_line;
const char *first_property;
va_list var_args;
item = g_object_new (GOO_TYPE_DEMO_LARGE_LINE, NULL);
demo_large_line = (GooDemoLargeLine*) item;
demo_large_line->x1 = x1;
demo_large_line->y1 = y1;
demo_large_line->x2 = x2;
demo_large_line->y2 = y2;
va_start (var_args, y2);
first_property = va_arg (var_args, char*);
if (first_property)
g_object_set_valist ((GObject*) item, first_property, var_args);
va_end (var_args);
if (parent)
{
goo_canvas_item_add_child (parent, item, -1);
g_object_unref (item);
}
return item;
}
/* The convenience function to create new items. This should start with a
parent argument and end with a variable list of object properties to fit
in with the standard canvas items. */
GooCanvasItem*
goo_demo_item_new (GooCanvasItem *parent,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
...)
{
GooCanvasItem *item;
GooDemoItem *demo_item;
const char *first_property;
va_list var_args;
item = g_object_new (GOO_TYPE_DEMO_ITEM, NULL);
demo_item = (GooDemoItem*) item;
demo_item->x = x;
demo_item->y = y;
demo_item->width = width;
demo_item->height = height;
va_start (var_args, height);
first_property = va_arg (var_args, char*);
if (first_property)
g_object_set_valist ((GObject*) item, first_property, var_args);
va_end (var_args);
if (parent)
{
goo_canvas_item_add_child (parent, item, -1);
g_object_unref (item);
}
return item;
}
/**
* goo_canvas_path_new:
* @parent: the parent item, or %NULL. If a parent is specified, it will assume
* ownership of the item, and the item will automatically be freed when it is
* removed from the parent. Otherwise call g_object_unref() to free it.
* @path_data: the sequence of path commands, specified as a string using the
* same syntax as in the <ulink url="http://www.w3.org/Graphics/SVG/">Scalable
* Vector Graphics (SVG)</ulink> path element.
* @...: optional pairs of property names and values, and a terminating %NULL.
*
* Creates a new path item.
*
* <!--PARAMETERS-->
*
* Here's an example showing how to create a red line from (20,20) to (40,40):
*
* <informalexample><programlisting>
* GooCanvasItem *path = goo_canvas_path_new (mygroup,
* "M 20 20 L 40 40",
* "stroke-color", "red",
* NULL);
* </programlisting></informalexample>
*
* This example creates a cubic bezier curve from (20,100) to (100,100) with
* the control points at (20,50) and (100,50):
*
* <informalexample><programlisting>
* GooCanvasItem *path = goo_canvas_path_new (mygroup,
* "M20,100 C20,50 100,50 100,100",
* "stroke-color", "blue",
* NULL);
* </programlisting></informalexample>
*
* This example uses an elliptical arc to create a filled circle with one
* quarter missing:
*
* <informalexample><programlisting>
* GooCanvasItem *path = goo_canvas_path_new (mygroup,
* "M200,500 h-150 a150,150 0 1,0 150,-150 z",
* "fill-color", "red",
* "stroke-color", "blue",
* "line-width", 5.0,
* NULL);
* </programlisting></informalexample>
*
* Returns: a new path item.
**/
GooCanvasItem*
goo_canvas_path_new (GooCanvasItem *parent,
const gchar *path_data,
...)
{
GooCanvasItem *item;
GooCanvasPath *path;
const char *first_property;
va_list var_args;
item = g_object_new (GOO_TYPE_CANVAS_PATH, NULL);
path = (GooCanvasPath*) item;
path->path_data->path_commands = goo_canvas_parse_path_data (path_data);
va_start (var_args, path_data);
first_property = va_arg (var_args, char*);
if (first_property)
g_object_set_valist ((GObject*) item, first_property, var_args);
va_end (var_args);
if (parent)
{
goo_canvas_item_add_child (parent, item, -1);
g_object_unref (item);
}
return item;
}
// Reparent a sheet object without moving it on the sheet.
void sheet_item_reparent (SheetItem *item, GooCanvasGroup *group)
{
g_return_if_fail (item != NULL);
g_return_if_fail (IS_SHEET_ITEM (item));
g_return_if_fail (group != NULL);
g_object_ref (item);
goo_canvas_item_remove (GOO_CANVAS_ITEM (item));
goo_canvas_item_add_child (GOO_CANVAS_ITEM (group), GOO_CANVAS_ITEM (item), -1);
// FIXME are we leaking a ref here?
}
/**
* goo_canvas_widget_new:
* @parent: the parent item, or %NULL. If a parent is specified, it will assume
* ownership of the item, and the item will automatically be freed when it is
* removed from the parent. Otherwise call g_object_unref() to free it.
* @widget: the widget.
* @x: the x coordinate of the item.
* @y: the y coordinate of the item.
* @width: the width of the item, or -1 to use the widget's requested width.
* @height: the height of the item, or -1 to use the widget's requested height.
* @...: optional pairs of property names and values, and a terminating %NULL.
*
* Creates a new widget item.
*
* <!--PARAMETERS-->
*
* Here's an example showing how to create an entry widget centered at (100.0,
* 100.0):
*
* <informalexample><programlisting>
* GtkWidget *entry = gtk_entry_new ();
* GooCanvasItem *witem = goo_canvas_widget_new (mygroup, entry,
* 100, 100, -1, -1,
* "anchor", GTK_ANCHOR_CENTER,
* NULL);
* </programlisting></informalexample>
*
* Returns: a new widget item.
**/
GooCanvasItem*
goo_canvas_widget_new (GooCanvasItem *parent,
GtkWidget *widget,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
...)
{
GooCanvasItem *item;
GooCanvasWidget *witem;
const char *first_property;
va_list var_args;
item = g_object_new (GOO_TYPE_CANVAS_WIDGET, NULL);
witem = (GooCanvasWidget*) item;
witem->widget = widget;
g_object_ref (witem->widget);
g_object_set_data (G_OBJECT (witem->widget), "goo-canvas-item", witem);
witem->x = x;
witem->y = y;
witem->width = width;
witem->height = height;
/* The widget defaults to being visible, like the canvas item, but this
can be overridden by the object property below. */
if (widget)
gtk_widget_show (widget);
va_start (var_args, height);
first_property = va_arg (var_args, char*);
if (first_property)
g_object_set_valist ((GObject*) item, first_property, var_args);
va_end (var_args);
if (parent)
{
goo_canvas_item_add_child (parent, item, -1);
g_object_unref (item);
}
return item;
}
/**
* goo_canvas_polyline_new_line:
* @parent: the parent item, or %NULL.
* @x1: the x coordinate of the start of the line.
* @y1: the y coordinate of the start of the line.
* @x2: the x coordinate of the end of the line.
* @y2: the y coordinate of the end of the line.
* @...: optional pairs of property names and values, and a terminating %NULL.
*
* Creates a new polyline item with a single line.
*
* <!--PARAMETERS-->
*
* Here's an example showing how to create a line from (100,100) to (300,300).
*
* <informalexample><programlisting>
* GooCanvasItem *polyline = goo_canvas_polyline_new_line (mygroup,
* 100.0, 100.0,
* 300.0, 300.0,
* "stroke-color", "red",
* "line-width", 5.0,
* NULL);
* </programlisting></informalexample>
*
* Returns: a new polyline item.
**/
GooCanvasItem*
goo_canvas_polyline_new_line (GooCanvasItem *parent,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
...)
{
GooCanvasItem *item;
GooCanvasPolyline *polyline;
GooCanvasPolylineData *polyline_data;
const char *first_property;
va_list var_args;
item = g_object_new (GOO_TYPE_CANVAS_POLYLINE, NULL);
polyline = (GooCanvasPolyline*) item;
polyline_data = polyline->polyline_data;
polyline_data->close_path = FALSE;
polyline_data->num_points = 2;
polyline_data->coords = g_slice_alloc (4 * sizeof (gdouble));
polyline_data->coords[0] = x1;
polyline_data->coords[1] = y1;
polyline_data->coords[2] = x2;
polyline_data->coords[3] = y2;
va_start (var_args, y2);
first_property = va_arg (var_args, char*);
if (first_property)
g_object_set_valist ((GObject*) item, first_property, var_args);
va_end (var_args);
if (parent)
{
goo_canvas_item_add_child (parent, item, -1);
g_object_unref (item);
}
return item;
}
/**
* goo_canvas_rect_new:
* @parent: the parent item, or %NULL. If a parent is specified, it will assume
* ownership of the item, and the item will automatically be freed when it is
* removed from the parent. Otherwise call g_object_unref() to free it.
* @x: the x coordinate of the left of the rectangle.
* @y: the y coordinate of the top of the rectangle.
* @width: the width of the rectangle.
* @height: the height of the rectangle.
* @...: optional pairs of property names and values, and a terminating %NULL.
*
* Creates a new rectangle item.
*
* <!--PARAMETERS-->
*
* Here's an example showing how to create a rectangle at (100,100) with a
* width of 200 and a height of 100.
*
* <informalexample><programlisting>
* GooCanvasItem *rect = goo_canvas_rect_new (mygroup, 100.0, 100.0, 200.0, 100.0,
* "stroke-color", "red",
* "line-width", 5.0,
* "fill-color", "blue",
* NULL);
* </programlisting></informalexample>
*
* Returns: a new rectangle item.
**/
GooCanvasItem*
goo_canvas_rect_new (GooCanvasItem *parent,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
...)
{
GooCanvasItem *item;
GooCanvasRect *rect;
GooCanvasRectData *rect_data;
const char *first_property;
va_list var_args;
item = g_object_new (GOO_TYPE_CANVAS_RECT, NULL);
rect = (GooCanvasRect*) item;
rect_data = rect->rect_data;
rect_data->x = x;
rect_data->y = y;
rect_data->width = width;
rect_data->height = height;
rect_data->radius_x = 0;
rect_data->radius_y = 0;
va_start (var_args, height);
first_property = va_arg (var_args, char*);
if (first_property)
g_object_set_valist ((GObject*) item, first_property, var_args);
va_end (var_args);
if (parent)
{
goo_canvas_item_add_child (parent, item, -1);
g_object_unref (item);
}
return item;
}
/**
* goo_canvas_polyline_new:
* @parent: the parent item, or %NULL. If a parent is specified, it will assume
* ownership of the item, and the item will automatically be freed when it is
* removed from the parent. Otherwise call g_object_unref() to free it.
* @close_path: if the last point should be connected to the first.
* @num_points: the number of points in the polyline.
* @...: the pairs of coordinates for each point in the line, followed by
* optional pairs of property names and values, and a terminating %NULL.
*
* Creates a new polyline item.
*
* <!--PARAMETERS-->
*
* Here's an example showing how to create a filled triangle with vertices
* at (100,100), (300,100), and (200,300).
*
* <informalexample><programlisting>
* GooCanvasItem *polyline = goo_canvas_polyline_new (mygroup, TRUE, 3,
* 100.0, 100.0,
* 300.0, 100.0,
* 200.0, 300.0,
* "stroke-color", "red",
* "line-width", 5.0,
* "fill-color", "blue",
* NULL);
* </programlisting></informalexample>
*
* Returns: a new polyline item.
**/
GooCanvasItem*
goo_canvas_polyline_new (GooCanvasItem *parent,
gboolean close_path,
gint num_points,
...)
{
GooCanvasItem *item;
GooCanvasPolyline *polyline;
GooCanvasPolylineData *polyline_data;
const char *first_property;
va_list var_args;
gint i;
item = g_object_new (GOO_TYPE_CANVAS_POLYLINE, NULL);
polyline = (GooCanvasPolyline*) item;
polyline_data = polyline->polyline_data;
polyline_data->close_path = close_path;
polyline_data->num_points = num_points;
if (num_points)
polyline_data->coords = g_slice_alloc (num_points * 2 * sizeof (gdouble));
va_start (var_args, num_points);
for (i = 0; i < num_points * 2; i++)
polyline_data->coords[i] = va_arg (var_args, gdouble);
first_property = va_arg (var_args, char*);
if (first_property)
g_object_set_valist ((GObject*) item, first_property, var_args);
va_end (var_args);
if (parent)
{
goo_canvas_item_add_child (parent, item, -1);
g_object_unref (item);
}
return item;
}
/**
* goo_canvas_ellipse_new:
* @parent: the parent item, or %NULL. If a parent is specified, it will assume
* ownership of the item, and the item will automatically be freed when it is
* removed from the parent. Otherwise call g_object_unref() to free it.
* @center_x: the x coordinate of the center of the ellipse.
* @center_y: the y coordinate of the center of the ellipse.
* @radius_x: the horizontal radius of the ellipse.
* @radius_y: the vertical radius of the ellipse.
* @...: optional pairs of property names and values, and a terminating %NULL.
*
* Creates a new ellipse item.
*
* <!--PARAMETERS-->
*
* Here's an example showing how to create an ellipse centered at (100.0,
* 100.0), with a horizontal radius of 50.0 and a vertical radius of 30.0.
* It is drawn with a red outline with a width of 5.0 and filled with blue:
*
* <informalexample><programlisting>
* GooCanvasItem *ellipse = goo_canvas_ellipse_new (mygroup, 100.0, 100.0, 50.0, 30.0,
* "stroke-color", "red",
* "line-width", 5.0,
* "fill-color", "blue",
* NULL);
* </programlisting></informalexample>
*
* Returns: a new ellipse item.
**/
GooCanvasItem*
goo_canvas_ellipse_new (GooCanvasItem *parent,
gdouble center_x,
gdouble center_y,
gdouble radius_x,
gdouble radius_y,
...)
{
GooCanvasItem *item;
GooCanvasEllipse *ellipse;
GooCanvasEllipseData *ellipse_data;
const char *first_property;
va_list var_args;
item = g_object_new (GOO_TYPE_CANVAS_ELLIPSE, NULL);
ellipse = (GooCanvasEllipse*) item;
ellipse_data = ellipse->ellipse_data;
ellipse_data->center_x = center_x;
ellipse_data->center_y = center_y;
ellipse_data->radius_x = radius_x;
ellipse_data->radius_y = radius_y;
va_start (var_args, radius_y);
first_property = va_arg (var_args, char*);
if (first_property)
g_object_set_valist ((GObject*) item, first_property, var_args);
va_end (var_args);
if (parent)
{
goo_canvas_item_add_child (parent, item, -1);
g_object_unref (item);
}
return item;
}
// if plate = 1 , move to plate g (left)
// if plate = -1, move to plate d (right)
// if plate = 0 , move to the item list
void
scale_item_move_to(ScaleItem *item, int plate)
{
ScaleItem *scale;
GList *list;
gboolean found;
int index;
if(plate != 0)
{
if(item->plate)
item->plate_index = -1;
else
gc_sound_play_ogg ("sounds/eraser1.wav", NULL);
// find the first free place in the plate
for(index=0; index < 2 * PLATE_SIZE; index++)
{
found = FALSE;
for(list = item_list; list; list = list->next)
{
scale = list->data;
if(scale->plate_index == index && scale->plate == plate)
found=TRUE;
}
if(!found)
{ // move to the plate
gdouble x = (plate == 1 ? balance_left_x : balance_right_x);
gdouble y = (plate == 1
? balance_left_y + last_delta
: balance_right_y - last_delta);
item->plate = plate;
item->plate_index = index;
/* Reparent */
g_object_ref(item->item);
goo_canvas_item_remove(item->item);
goo_canvas_item_add_child ((plate == 1 ? group_g : group_d),
item->item, -1);
g_object_unref(item->item);
gc_item_absolute_move(item->item,
x + (index % PLATE_SIZE) * ITEM_W,
y + PLATE_Y - ITEM_H + 5 - (index >= PLATE_SIZE ? ITEM_H : 0));
break;
}
}
if(found) // can't find place
plate=0;
}
if(plate==0)
{ // move the item to the list
if(item->plate)
gc_sound_play_ogg ("sounds/eraser1.wav", NULL);
item->plate = 0;
/* Reparent */
g_object_ref(item->item);
goo_canvas_item_remove(item->item);
goo_canvas_item_add_child (group_m,
item->item, -1);
g_object_unref(item->item);
gc_item_absolute_move(item->item,
item->x,
item->y);
goo_canvas_item_raise(item->item, NULL);
}
scale_anim_plate();
if (!gamewon)
gc_item_focus_init(item->item, NULL);
}
