//FIXME this looks weird
void
sheet_release_selected_objects (Sheet *sheet)
{
GList *list, *copy;
GooCanvasGroup *group;
gint item_nbr;
g_return_if_fail (sheet != NULL);
g_return_if_fail (IS_SHEET (sheet));
group = sheet->priv->selected_group;
copy = g_list_copy (sheet->priv->selected_objects);
// Remove all the selected_objects into selected_group
for (list = copy; list; list = list->next) {
item_nbr = goo_canvas_item_find_child (GOO_CANVAS_ITEM (group),
GOO_CANVAS_ITEM (list->data));
goo_canvas_item_remove_child (GOO_CANVAS_ITEM (group),
item_nbr);
}
g_list_free (copy);
g_list_free (sheet->priv->selected_objects);
sheet->priv->selected_objects = NULL;
}
// Cancel the placement of floating items and remove them.
void sheet_item_cancel_floating (Sheet *sheet)
{
GooCanvasGroup *group;
GList *list;
g_return_if_fail (sheet != NULL);
g_return_if_fail (IS_SHEET (sheet));
group = GOO_CANVAS_GROUP (sheet->priv->floating_group);
if (group == NULL)
return;
if (sheet->state != SHEET_STATE_FLOAT && sheet->state != SHEET_STATE_FLOAT_START)
return;
if (g_signal_handler_is_connected (sheet, sheet->priv->float_handler_id))
g_signal_handler_disconnect (sheet, sheet->priv->float_handler_id);
// TODO verfiy that the following has no nasty sideffects
for (list = sheet->priv->floating_objects; list; list = list->next) {
goo_canvas_item_remove (list->data); // remove from canvas and free
}
g_list_free (sheet->priv->floating_objects);
sheet->priv->floating_objects = NULL;
goo_canvas_item_remove (GOO_CANVAS_ITEM (group));
// Create a new empty group to prepare next floating 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));
// sheet_clear_ghosts (sheet);
sheet->priv->float_handler_id = 0;
sheet->state = SHEET_STATE_NONE;
}
static void
make_dynamic_link (GstEditorLink * link)
{
GstElement *srce, *sinke;
GstPadTemplate *src = NULL, *sink = NULL;
if (GST_IS_EDITOR_PAD_SOMETIMES (link->srcpad))
src = GST_PAD_TEMPLATE (link->srcpad->object);
if (GST_IS_EDITOR_PAD_SOMETIMES (link->sinkpad))
sink = GST_PAD_TEMPLATE (link->sinkpad->object);
srce =
GST_ELEMENT (GST_EDITOR_ITEM (goo_canvas_item_get_parent (GOO_CANVAS_ITEM
(link->srcpad)))->object);
sinke =
GST_ELEMENT (GST_EDITOR_ITEM (goo_canvas_item_get_parent (GOO_CANVAS_ITEM
(link->sinkpad)))->object);
g_return_if_fail (src || sink);
if (src)
g_signal_connect_after (srce, "pad-added", G_CALLBACK (on_new_pad), link);
if (sink)
g_signal_connect_after (sinke, "pad-added", G_CALLBACK (on_new_pad), link);
g_print ("dynamic link\n");
}
static void
gst_editor_link_resize (GstEditorLink * link)
{
gdouble x1, y1, x2, y2;
GooCanvas * canvas;
g_object_get (link, "x1", &x1, "y1", &y1, "x2", &x2, "y2", &y2, NULL);
canvas = goo_canvas_item_get_canvas (GOO_CANVAS_ITEM (link));
if (!canvas) {
g_print ("Warning: gst_editor_link_resize canvas null\n");
return;
}
goo_canvas_convert_from_pixels (canvas, &x1, &y1);
goo_canvas_convert_to_item_space (canvas, GOO_CANVAS_ITEM (link), &x1, &y1);
// goo_canvas_item_get_parent(GOO_CANVAS_ITEM (link)),&x1, &y1);
goo_canvas_convert_from_pixels (canvas, &x2, &y2);
goo_canvas_convert_to_item_space (canvas, GOO_CANVAS_ITEM (link), &x2, &y2);
// goo_canvas_item_get_parent(GOO_CANVAS_ITEM (link)), &x2, &y2);
/* we do this in reverse so that with dot-dash lines it gives the illusion of
pulling out a rope from the element */
link->points->coords[2] = x1;
link->points->coords[3] = y1;
link->points->coords[0] = x2;
link->points->coords[1] = y2;
g_object_set (G_OBJECT (link), "points", link->points, NULL);
}
PartItem *
part_item_canvas_new (Sheet *sheet, Part *part)
{
PartItem *part_item;
PartItemPriv *priv;
GooCanvasItem *item;
ItemData *item_data;
g_return_val_if_fail (sheet != NULL, NULL);
g_return_val_if_fail (IS_SHEET (sheet), NULL);
g_return_val_if_fail (part != NULL, NULL);
g_return_val_if_fail (IS_PART (part), NULL);
item = g_object_new (TYPE_PART_ITEM, NULL);
g_object_set (item,
"parent", sheet->object_group,
NULL);
part_item = PART_ITEM (item);
g_object_set (part_item,
"data", part,
NULL);
priv = part_item->priv;
priv->label_group = GOO_CANVAS_ITEM (goo_canvas_group_new (
GOO_CANVAS_ITEM (part_item),
"width", -1.0,
"height", -1.0,
NULL));
g_object_unref (item);
priv->node_group = GOO_CANVAS_ITEM (goo_canvas_group_new (
GOO_CANVAS_ITEM (part_item),
NULL));
g_object_set (GOO_CANVAS_ITEM (priv->node_group),
"visibility", GOO_CANVAS_ITEM_INVISIBLE,
NULL);
item_data = ITEM_DATA (part);
item_data->rotated_handler_id = g_signal_connect_object (G_OBJECT (part),
"rotated",
G_CALLBACK (part_rotated_callback),
G_OBJECT (part_item), 0);
item_data->flipped_handler_id = g_signal_connect_object (G_OBJECT (part),
"flipped",
G_CALLBACK (part_flipped_callback),
G_OBJECT (part_item), 0);
item_data->moved_handler_id = g_signal_connect_object (G_OBJECT (part),
"moved",
G_CALLBACK (part_moved_callback),
G_OBJECT (part_item), 0);
item_data->changed_handler_id = g_signal_connect_object (G_OBJECT (part),
"changed",
G_CALLBACK (part_changed_callback),
G_OBJECT (part_item), 0);
return part_item;
}
void
gst_editor_link_destroy (GstEditorLink * link)
{
// g_print ("trying to destroy this half link");
GstEditorBin * padbin;
if (link->srcpad)
padbin = GST_EDITOR_BIN (goo_canvas_item_get_parent (
goo_canvas_item_get_parent (GOO_CANVAS_ITEM (link->srcpad))));
else
padbin = GST_EDITOR_BIN (goo_canvas_item_get_parent (
goo_canvas_item_get_parent (GOO_CANVAS_ITEM (link->sinkpad))));
padbin->links = g_list_remove (padbin->links, link);
if (link->srcpad)
GST_EDITOR_PAD (link->srcpad)->link = NULL;
if (link->sinkpad)
GST_EDITOR_PAD (link->sinkpad)->link = NULL;
// int killnumber;
// killnumber=goo_canvas_item_find_child(goo_canvas_item_get_parent(GOO_CANVAS_ITEM(link)),GOO_CANVAS_ITEM(link));
// g_print ("found child at %d",killnumber);
// ARGH, what am I doing here
// g_realloc(link,sizeof(GooCanvasPolyline));
// g_realloc(link,sizeof(GooCanvasPolyline));
// goo_canvas_item_remove_child(goo_canvas_item_get_parent(GOO_CANVAS_ITEM(link)),killnumber);
goo_canvas_item_remove (GOO_CANVAS_ITEM (link));
if (link->points)
goo_canvas_points_unref (link->points);
// g_print ("ready to crash:)");
// g_free(link);
// g_print ("no warnings until now");
return;
}
static void
wire_changed_callback (Wire *wire, WireItem *item)
{
Coords start_pos, length;
GooCanvasPoints *points;
g_return_if_fail (wire != NULL);
g_return_if_fail (IS_ITEM_DATA (wire));
g_return_if_fail (item != NULL);
g_return_if_fail (IS_WIRE_ITEM (item));
wire_get_pos_and_length (wire, &start_pos, &length);
Sheet *sheet = SHEET (goo_canvas_item_get_canvas (GOO_CANVAS_ITEM (item)));
if (G_UNLIKELY(!sheet)) {
g_warning ("Failed to determine the Sheet the item is glued to. This should never happen. Ever!");
} else {
item_data_snap (ITEM_DATA (wire), sheet->grid);
}
// Move the canvas item and invalidate the bbox cache.
goo_canvas_item_set_simple_transform (GOO_CANVAS_ITEM (item),
start_pos.x,
start_pos.y,
1.0,
0.0);
item->priv->cache_valid = FALSE;
points = goo_canvas_points_new (2);
points->coords[0] = 0;
points->coords[1] = 0;
points->coords[2] = length.x;
points->coords[3] = length.y;
// this does handle cleanup of previous points internally
g_object_set (item->priv->line,
"points", points,
NULL);
goo_canvas_points_unref (points);
g_object_set (item->priv->resize1,
"x", -RESIZER_SIZE,
"y", -RESIZER_SIZE,
"width", 2 * RESIZER_SIZE,
"height", 2 * RESIZER_SIZE,
NULL);
g_object_set (item->priv->resize2,
"x", length.x-RESIZER_SIZE,
"y", length.y-RESIZER_SIZE,
"width", 2 * RESIZER_SIZE,
"height", 2 * RESIZER_SIZE,
NULL);
goo_canvas_item_request_update (GOO_CANVAS_ITEM (item->priv->line));
}
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;
}
// 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?
}
static void node_item_init (NodeItem *item)
{
item->priv = g_new0 (NodeItemPriv, 1);
item->priv->dot_item =
goo_canvas_ellipse_new (GOO_CANVAS_ITEM (item), 0.0, 0.0, 2.0, 2.0, "fill-color", "black",
"visibility", GOO_CANVAS_ITEM_INVISIBLE, NULL);
item->priv->circle_item = goo_canvas_ellipse_new (
GOO_CANVAS_ITEM (item), 0.0, 0.0, 3.0, 3.0, "stroke-color-rgba", 0x3399FFFF, "line-width",
1.0, "visibility",
oregano_options_debug_dots () ? GOO_CANVAS_ITEM_VISIBLE : GOO_CANVAS_ITEM_INVISIBLE, NULL);
}
static AtkObject*
goo_canvas_item_accessible_ref_child (AtkObject *accessible,
gint child_num)
{
GooCanvasItem *item, *child;
AtkObject *atk_object;
GObject *object;
g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (accessible), NULL);
object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));
if (object == NULL)
return NULL;
item = GOO_CANVAS_ITEM (object);
child = goo_canvas_item_get_child (item, child_num);
if (!child)
return NULL;
atk_object = atk_gobject_accessible_for_object (G_OBJECT (child));
g_object_ref (atk_object);
return atk_object;
}
static void
wire_changed_callback (Wire *wire, WireItem *item)
{
SheetPos start_pos, length;
GooCanvasPoints *points;
wire_get_pos_and_length (wire, &start_pos, &length);
points = goo_canvas_points_new (2);
points->coords[0] = 0;
points->coords[1] = 0;
points->coords[2] = length.x;
points->coords[3] = length.y;
g_object_set (item->priv->line,
"points", points,
NULL);
goo_canvas_points_unref (points);
g_object_set (item->priv->resize1,
"x", -RESIZER_SIZE,
"y", -RESIZER_SIZE,
"width", 2 * RESIZER_SIZE,
"height", 2 * RESIZER_SIZE,
NULL);
g_object_set (item->priv->resize2,
"x", length.x-RESIZER_SIZE,
"y", length.y-RESIZER_SIZE,
"width", 2 * RESIZER_SIZE,
"height", 2 * RESIZER_SIZE,
NULL);
goo_canvas_item_request_update (GOO_CANVAS_ITEM (item->priv->line));
}
static AtkObject*
goo_canvas_item_accessible_get_parent (AtkObject *accessible)
{
GooCanvasItem *item, *parent;
GooCanvas *canvas;
GObject *object;
g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (accessible), NULL);
if (accessible->accessible_parent)
return accessible->accessible_parent;
object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));
if (object == NULL)
return NULL;
item = GOO_CANVAS_ITEM (object);
parent = goo_canvas_item_get_parent (item);
if (parent)
return atk_gobject_accessible_for_object (G_OBJECT (parent));
canvas = goo_canvas_item_get_canvas (item);
if (canvas)
return gtk_widget_get_accessible (GTK_WIDGET (canvas));
return NULL;
}
static gboolean
goo_canvas_item_accessible_grab_focus (AtkComponent *component)
{
GooCanvasItem *item;
GooCanvas *canvas;
GtkWidget *toplevel;
GObject *object;
g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (component), FALSE);
object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (component));
if (!object)
return FALSE;
item = GOO_CANVAS_ITEM (object);
canvas = goo_canvas_item_get_canvas (item);
if (!canvas)
return FALSE;
goo_canvas_grab_focus (canvas, item);
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (canvas));
if (GTK_WIDGET_TOPLEVEL (toplevel))
gtk_window_present (GTK_WINDOW (toplevel));
return TRUE;
}
// Retrieves the bounding box. We use a caching scheme for this
// since it's too expensive to calculate it every time we need it.
inline static void
get_cached_bounds (PartItem *item, Coords *p1, Coords *p2)
{
PartItemPriv *priv;
priv = item->priv;
if (!priv->cache_valid) {
Coords start_pos, end_pos;
GooCanvasBounds bounds;
goo_canvas_item_get_bounds (GOO_CANVAS_ITEM (item), &bounds);
start_pos.x = bounds.x1;
start_pos.y = bounds.y1;
end_pos.x = bounds.x2;
end_pos.y = bounds.y2;
priv->bbox_start = start_pos;
priv->bbox_end = end_pos;
priv->cache_valid = TRUE;
}
memcpy (p1, &priv->bbox_start, sizeof (Coords));
memcpy (p2, &priv->bbox_end, sizeof (Coords));
}
Sheet *sheet_item_get_sheet (SheetItem *item)
{
g_return_val_if_fail (item != NULL, NULL);
g_return_val_if_fail (IS_SHEET_ITEM (item), NULL);
return SHEET (goo_canvas_item_get_canvas (GOO_CANVAS_ITEM (item)));
}
// Retrieves the bounding box. We use a caching scheme for this
// since it's too expensive to calculate it every time we need it.
inline static void get_boundingbox (WireItem *item, Coords *p1, Coords *p2)
{
g_return_if_fail (item != NULL);
g_return_if_fail (IS_WIRE_ITEM (item));
WireItemPriv *priv;
priv = item->priv;
if (!priv->cache_valid) {
Coords start_pos, end_pos;
GooCanvasBounds bounds; //, canvas_bounds;
goo_canvas_item_get_bounds (GOO_CANVAS_ITEM (item), &bounds);
priv->bbox_start.x = bounds.x1;
priv->bbox_start.y = bounds.y1;
priv->bbox_end.x = bounds.x2;
priv->bbox_end.y = bounds.y2;
priv->cache_valid = TRUE;
}
if (p1)
*p1 = priv->bbox_start;
if (p2)
*p2 = priv->bbox_end;
}
void
rubberband_info_destroy (RubberbandInfo *rubberband_info)
{
g_return_if_fail (rubberband_info!=NULL);
goo_canvas_item_remove (GOO_CANVAS_ITEM (rubberband_info->rectangle));
g_free (rubberband_info);
}
/*
* remove the currently selected items from the sheet
* (especially their goocanvas representators)
*/
void
sheet_delete_selection (Sheet *sheet)
{
GList *copy, *iter;
g_return_if_fail (sheet != NULL);
g_return_if_fail (IS_SHEET (sheet));
if (sheet->state != SHEET_STATE_NONE)
return;
copy = g_list_copy (sheet->priv->selected_objects);
for (iter = copy; iter; iter = iter->next) {
sheet_remove_item_in_sheet (SHEET_ITEM (iter->data), sheet);
goo_canvas_item_remove (GOO_CANVAS_ITEM (iter->data));
}
g_list_free (copy);
// we need to it like this as <sheet_remove_item_in_sheet>
// requires selected_objects, items, floating_objects
// to be not NULL!
g_list_free (sheet->priv->selected_objects);
sheet->priv->selected_objects = NULL;
}
static void wire_delete_callback (Wire *wire, WireItem *item)
{
// no clue why does work but canvas item does not disappear
// g_clear_object (&item);
// g_assert (item==NULL);
goo_canvas_item_remove (GOO_CANVAS_ITEM (item));
// g_object_unref (wire); //FIXME this causes a segfault
}
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;
}
void
sheet_stop_rubberband (Sheet *sheet, GdkEventButton *event)
{
GList *list = NULL;
sheet->priv->rubberband->state = RUBBER_NO;
if (sheet->priv->preserve_selection_items != NULL) {
for (list = sheet->priv->preserve_selection_items; list; list = list->next)
sheet_item_set_preserve_selection (SHEET_ITEM (list->data), FALSE);
g_list_free (sheet->priv->preserve_selection_items);
sheet->priv->preserve_selection_items = NULL;
}
goo_canvas_pointer_ungrab (GOO_CANVAS (sheet),
GOO_CANVAS_ITEM (sheet->grid), event->time);
goo_canvas_item_remove (GOO_CANVAS_ITEM (sheet->priv->rubberband->rectangle));
//g_list_free_full (list, g_object_unref); //FIXME
}
void sheet_keyboard_ungrab (Sheet *sheet, GdkEvent *event)
{
g_return_if_fail (sheet);
g_return_if_fail (IS_SHEET (sheet));
#ifndef DEBUG_DISABLE_GRABBING
if (sheet->priv->keyboard_grabbed) {
sheet->priv->keyboard_grabbed = FALSE;
goo_canvas_keyboard_ungrab (GOO_CANVAS (sheet), GOO_CANVAS_ITEM (sheet->grid),
extract_time (event));
}
#endif
}
/* this function is only linked for dynamic links */
static void
on_new_pad (GstElement * element, GstPad * pad, GstEditorLink * link)
{
GstPadTemplate *src = NULL, *sink = NULL;
if (GST_IS_EDITOR_PAD_SOMETIMES (link->srcpad))
src = GST_PAD_TEMPLATE (link->srcpad->object);
if (GST_IS_EDITOR_PAD_SOMETIMES (link->sinkpad))
sink = GST_PAD_TEMPLATE (link->sinkpad->object);
g_message ("new pad");
if (pad->padtemplate) {
g_message ("from a template");
/* can't do pointer comparison -- some templates appear to be from the
elementfactories, some from template factories... have to compare
names */
if (src &&
g_ascii_strcasecmp (
pad->padtemplate->name_template, src->name_template) == 0)
g_object_set (G_OBJECT (GOO_CANVAS_ITEM (link)), "src-pad",
gst_editor_item_get (GST_OBJECT (pad)), NULL);
else if (sink &&
g_ascii_strcasecmp (
pad->padtemplate->name_template, sink->name_template) == 0)
g_object_set (G_OBJECT (GOO_CANVAS_ITEM (link)), "sink-pad",
gst_editor_item_get (GST_OBJECT (pad)), NULL);
else
return;
g_message ("we made it, now let's link");
/*gst_element_set_state ((GstElement *)
gst_element_get_managing_bin (element), GST_STATE_PAUSED); */
gst_editor_link_link (link);
/*gst_element_set_state ((GstElement *)
gst_element_get_managing_bin (element), GST_STATE_PLAYING); */
}
}
void
sheet_setup_rubberband (Sheet *sheet, GdkEventButton *event)
{
double x, y;
cairo_pattern_t *pattern;
static guchar stipple_data[16] =
{0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255 };
x = event->x; //the x coordinate of the pointer relative to the window.
y = event->y; //the y coordinate of the pointer relative to the window.
goo_canvas_convert_from_pixels (GOO_CANVAS (sheet), &x, &y);
sheet->priv->rubberband->start_x = x;
sheet->priv->rubberband->start_y = y;
sheet->priv->rubberband->state = RUBBER_YES;
sheet->priv->rubberband->click_start_state = event->state;
pattern = create_stipple ("lightgrey", stipple_data);
sheet->priv->rubberband->rectangle = goo_canvas_rect_new (
GOO_CANVAS_ITEM (sheet->object_group),
x, y, 0.0, 0.0,
"stroke-color", "black",
"line-width", 0.2,
"fill-pattern", pattern,
NULL);
goo_canvas_pointer_grab (GOO_CANVAS (sheet), GOO_CANVAS_ITEM (sheet->grid),
(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK),
NULL, event->time);
// Mark all the selected objects to preserve their selected state
// if SHIFT is pressed while rubberbanding.
if (event->state & GDK_SHIFT_MASK) {
sheet->priv->preserve_selection_items =
g_list_copy (sheet_preserve_selection (sheet));
}
}
static void
goo_canvas_item_accessible_get_extents (AtkComponent *component,
gint *x,
gint *y,
gint *width,
gint *height,
AtkCoordType coord_type)
{
GooCanvasItem *item;
GooCanvas *canvas;
GObject *object;
gint window_x, window_y;
gint toplevel_x, toplevel_y;
GdkRectangle rect;
GdkWindow *window;
g_return_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (component));
*x = *y = G_MININT;
object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (component));
if (!object)
return;
item = GOO_CANVAS_ITEM (object);
canvas = goo_canvas_item_get_canvas (item);
if (!canvas || !GTK_WIDGET (canvas)->window)
return;
goo_canvas_item_accessible_get_item_extents (item, &rect);
*width = rect.width;
*height = rect.height;
if (!goo_canvas_item_accessible_is_item_in_window (item, &rect))
return;
gdk_window_get_origin (GTK_WIDGET (canvas)->window,
&window_x, &window_y);
*x = rect.x + window_x;
*y = rect.y + window_y;
if (coord_type == ATK_XY_WINDOW)
{
window = gdk_window_get_toplevel (GTK_WIDGET (canvas)->window);
gdk_window_get_origin (window, &toplevel_x, &toplevel_y);
*x -= toplevel_x;
*y -= toplevel_y;
}
}
static void textbox_text_changed_callback (ItemData *data, gchar *new_text, SheetItem *item)
{
TextboxItem *textbox_item;
g_return_if_fail (data != NULL);
g_return_if_fail (IS_ITEM_DATA (data));
g_return_if_fail (item != NULL);
g_return_if_fail (IS_TEXTBOX_ITEM (item));
textbox_item = TEXTBOX_ITEM (item);
g_object_set (textbox_item->priv->text_canvas_item, "text", new_text, NULL);
goo_canvas_item_ensure_updated (GOO_CANVAS_ITEM (textbox_item));
}
static gint
goo_canvas_item_accessible_get_n_children (AtkObject *accessible)
{
GooCanvasItem *item;
GObject *object;
g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (accessible), 0);
object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));
if (object == NULL)
return 0;
item = GOO_CANVAS_ITEM (object);
return goo_canvas_item_get_n_children (item);
}
gboolean sheet_keyboard_grab (Sheet *sheet, GdkEvent *event)
{
g_return_val_if_fail (sheet, FALSE);
g_return_val_if_fail (IS_SHEET (sheet), FALSE);
#ifndef DEBUG_DISABLE_GRABBING
if (sheet->priv->keyboard_grabbed == FALSE &&
goo_canvas_keyboard_grab (GOO_CANVAS (sheet), GOO_CANVAS_ITEM (sheet->grid),
TRUE, /*do not reroute signals through sheet->grid*/
extract_time (event)) == GDK_GRAB_SUCCESS) {
sheet->priv->keyboard_grabbed = TRUE;
}
return (sheet->priv->keyboard_grabbed == TRUE);
#else
return TRUE;
#endif
}
static AtkStateSet*
goo_canvas_item_accessible_ref_state_set (AtkObject *accessible)
{
GooCanvasItem *item;
GooCanvas *canvas;
AtkStateSet *state_set;
GObject *object;
gboolean can_focus = FALSE;
g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (accessible), NULL);
state_set = ATK_OBJECT_CLASS (goo_canvas_item_accessible_parent_class)->ref_state_set (accessible);
object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));
if (!object)
{
atk_state_set_add_state (state_set, ATK_STATE_DEFUNCT);
return state_set;
}
item = GOO_CANVAS_ITEM (object);
canvas = goo_canvas_item_get_canvas (item);
if (!canvas)
return state_set;
if (goo_canvas_item_is_visible (item))
{
atk_state_set_add_state (state_set, ATK_STATE_VISIBLE);
if (goo_canvas_item_accessible_is_item_on_screen (item))
atk_state_set_add_state (state_set, ATK_STATE_SHOWING);
}
g_object_get (item, "can-focus", &can_focus, NULL);
if (GTK_WIDGET_CAN_FOCUS (GTK_WIDGET (canvas)) && can_focus)
{
atk_state_set_add_state (state_set, ATK_STATE_FOCUSABLE);
if (GTK_WIDGET_HAS_FOCUS (canvas)
&& canvas->focused_item == item)
atk_state_set_add_state (state_set, ATK_STATE_FOCUSED);
}
return state_set;
}
