static void
wire_changed_callback (Wire *wire, WireItem *item)
{
SheetPos start_pos, length;
GnomeCanvasPoints *points;
wire_get_pos_and_length (wire, &start_pos, &length);
points = gnome_canvas_points_new (2);
points->coords[0] = 0;
points->coords[1] = 0;
points->coords[2] = length.x;
points->coords[3] = length.y;
gnome_canvas_item_set (GNOME_CANVAS_ITEM (item->priv->line),
"points", points,
NULL);
gnome_canvas_points_unref (points);
gnome_canvas_item_set (GNOME_CANVAS_ITEM (item->priv->resize1),
"x1", -RESIZER_SIZE,
"y1", -RESIZER_SIZE,
"x2", RESIZER_SIZE,
"y2", RESIZER_SIZE,
NULL);
gnome_canvas_item_set (GNOME_CANVAS_ITEM (item->priv->resize2),
"x1", length.x-RESIZER_SIZE,
"y1", length.y-RESIZER_SIZE,
"x2", length.x+RESIZER_SIZE,
"y2", length.y+RESIZER_SIZE,
NULL);
}
struct Item *insert_recognized_curpath(void)
{
struct Item *item;
int i;
struct UndoErasureData *erasure;
erasure = (struct UndoErasureData *)(undo->erasurelist->data);
item = g_new(struct Item, 1);
item->type = ITEM_STROKE;
g_memmove(&(item->brush), &(erasure->item->brush), sizeof(struct Brush));
item->brush.variable_width = FALSE;
subdivide_cur_path();
item->path = gnome_canvas_points_new(ui.cur_path.num_points);
g_memmove(item->path->coords, ui.cur_path.coords, 2*ui.cur_path.num_points*sizeof(double));
item->widths = NULL;
update_item_bbox(item);
ui.cur_path.num_points = 0;
erasure->nrepl++;
erasure->replacement_items = g_list_append(erasure->replacement_items, item);
ui.cur_layer->items = g_list_append(ui.cur_layer->items, item);
ui.cur_layer->nitems++;
make_canvas_item_one(ui.cur_layer->group, item);
return item;
}
void GfxSquareBrush::drawStyle(GnomeCanvasItem *rb, GdkBitmap *stipple,
GdkBitmap *stubble, const guint32 &black,
const guint32 &white, const Coord ¤t) {
GnomeCanvasPoints *pts = gnome_canvas_points_new(4);
pts->coords[0] = current(0) - size;
pts->coords[1] = current(1) + size;
pts->coords[2] = current(0) - size;
pts->coords[3] = current(1) - size;
pts->coords[4] = current(0) + size;
pts->coords[5] = current(1) - size;
pts->coords[6] = current(0) + size;
pts->coords[7] = current(1) + size;
gnome_canvas_item_new(GNOME_CANVAS_GROUP(rb),
gnome_canvas_polygon_get_type(),
"points", pts,
"outline_color_rgba", black,
"width_pixels", 0,
"outline_stipple", stipple,
NULL);
gnome_canvas_item_new(GNOME_CANVAS_GROUP(rb),
gnome_canvas_polygon_get_type(),
"points", pts,
"outline_color_rgba", white,
"width_pixels", 0,
"outline_stipple", stubble,
NULL);
}
static int
gnomecanvaspoints_to_value(GValue *value, PyObject *object)
{
GnomeCanvasPoints *points;
gint i, len;
if (!PySequence_Check(object))
return -1;
len = PySequence_Length(object);
if (len % 2 != 0)
return -1;
points = gnome_canvas_points_new(len / 2);
for (i = 0; i < len; i++) {
PyObject *item = PySequence_GetItem(object, i);
points->coords[i] = PyFloat_AsDouble(item);
if (PyErr_Occurred()) {
gnome_canvas_points_unref(points);
PyErr_Clear();
Py_DECREF(item);
return -1;
}
Py_DECREF(item);
}
g_value_set_boxed(value, points);
gnome_canvas_points_unref(points);
return 0;
}
/* Goes through all known links and checks whether there already exists
* a corresponding canvas_link. If not, create it.*/
static gint
check_new_link (link_id_t * link_id, link_t * link, GtkWidget * canvas)
{
canvas_link_t *new_canvas_link;
GnomeCanvasGroup *group;
GnomeCanvasPoints *points;
guint i = 0;
if (!g_tree_lookup (canvas_links, link_id))
{
group = gnome_canvas_root (GNOME_CANVAS (canvas));
new_canvas_link = g_malloc (sizeof (canvas_link_t));
g_assert(new_canvas_link);
new_canvas_link->canvas_link_id = *link_id;
/* We set the lines position using groups positions */
points = gnome_canvas_points_new (3);
for (; i <= 5; i++)
points->coords[i] = 0.0;
new_canvas_link->src_item
= gnome_canvas_item_new (group,
gnome_canvas_polygon_get_type (),
"points", points, "fill_color", "tan", NULL);
addref_canvas_obj(G_OBJECT (new_canvas_link->src_item));
new_canvas_link->dst_item
= gnome_canvas_item_new (group,
gnome_canvas_polygon_get_type (),
"points", points, "fill_color", "tan", NULL);
addref_canvas_obj(G_OBJECT (new_canvas_link->dst_item));
g_tree_insert (canvas_links,
&new_canvas_link->canvas_link_id, new_canvas_link);
gnome_canvas_item_lower_to_bottom (new_canvas_link->src_item);
gnome_canvas_item_lower_to_bottom (new_canvas_link->dst_item);
gnome_canvas_points_unref (points);
g_signal_connect (G_OBJECT (new_canvas_link->src_item), "event",
(GtkSignalFunc) link_item_event, new_canvas_link);
g_signal_connect (G_OBJECT (new_canvas_link->dst_item), "event",
(GtkSignalFunc) link_item_event, new_canvas_link);
}
return FALSE;
} /* check_new_link */
static void
bst_canvas_link_adjust_arrow (BstCanvasLink *clink)
{
GnomeCanvasPoints *gpoints;
gdouble dx, dy, l, x, y, px, py, cos_theta, sin_theta, *points;
if (!clink->line)
return;
gtk_object_get (GTK_OBJECT (clink->line), "points", &gpoints, NULL);
if (!gpoints)
gpoints = gnome_canvas_points_new0 (2);
points = gpoints->coords;
dx = points[0] - points[2];
dy = points[1] - points[3];
l = sqrt (dx * dx + dy * dy);
x = (points[2] + points[0]) / 2;
y = (points[3] + points[1]) / 2;
gnome_canvas_points_free (gpoints);
sin_theta = l ? dy / l : 0;
cos_theta = l ? dx / l : 0;
px = x - ARROW_LENGTH / 2.0 * cos_theta;
py = y - ARROW_LENGTH / 2.0 * sin_theta;
x += ARROW_LENGTH / 2.0 * cos_theta;
y += ARROW_LENGTH / 2.0 * sin_theta;
gpoints = gnome_canvas_points_new (4);
points = gpoints->coords;
*(points++) = px;
*(points++) = py;
*(points++) = x - ARROW_WIDTH * sin_theta;
*(points++) = y + ARROW_WIDTH * cos_theta;
*(points++) = x + ARROW_WIDTH * sin_theta;
*(points++) = y - ARROW_WIDTH * cos_theta;
*(points++) = px;
*(points++) = py;
if (clink->arrow)
g_object_set (clink->arrow, "points", gpoints, NULL);
gnome_canvas_points_free (gpoints);
}
static void
wire_rotated_callback (ItemData *data, int angle, SheetItem *sheet_item)
{
WireItem *wire_item;
GnomeCanvasPoints *points;
SheetPos start_pos, length;
g_return_if_fail (sheet_item != NULL);
g_return_if_fail (IS_WIRE_ITEM (sheet_item));
wire_item = WIRE_ITEM (sheet_item);
wire_get_pos_and_length (WIRE (data), &start_pos, &length);
points = gnome_canvas_points_new (2);
points->coords[0] = 0;
points->coords[1] = 0;
points->coords[2] = length.x;
points->coords[3] = length.y;
gnome_canvas_item_set (GNOME_CANVAS_ITEM (wire_item->priv->line),
"points", points,
NULL);
gnome_canvas_points_unref (points);
gnome_canvas_item_set (GNOME_CANVAS_ITEM (wire_item),
"x", start_pos.x,
"y", start_pos.y,
NULL);
gnome_canvas_item_set (
GNOME_CANVAS_ITEM (wire_item-> priv->resize2),
"x1", length.x-RESIZER_SIZE,
"y1", length.y-RESIZER_SIZE,
"x2", length.x+RESIZER_SIZE,
"y2", length.y+RESIZER_SIZE,
NULL
);
/*
* Invalidate the bounding box cache.
*/
wire_item->priv->cache_valid = FALSE;
}
static void
wire_flipped_callback (ItemData *data,
gboolean horizontal, SheetItem *sheet_item)
{
GnomeCanvasPoints *points;
WireItem *item;
WireItemPriv *priv;
SheetPos start_pos, length;
g_return_if_fail (sheet_item != NULL);
g_return_if_fail (IS_WIRE_ITEM (sheet_item));
item = WIRE_ITEM (sheet_item);
priv = item->priv;
wire_get_pos_and_length (WIRE (data), &start_pos, &length);
points = gnome_canvas_points_new (2);
points->coords[0] = 0;
points->coords[1] = 0;
points->coords[2] = length.x;
points->coords[3] = length.y;
gnome_canvas_item_set (GNOME_CANVAS_ITEM (item->priv->line),
"points", points,
NULL);
gnome_canvas_points_unref (points);
gnome_canvas_item_set (GNOME_CANVAS_ITEM (item),
"x", start_pos.x,
"y", start_pos.y,
NULL);
/*
* Invalidate the bounding box cache.
*/
priv->cache_valid = FALSE;
}
static void
bst_canvas_link_update (BstCanvasLink *clink)
{
GnomeCanvasItem *item = GNOME_CANVAS_ITEM (clink);
if (clink->line)
{
gdouble start_x = 0, start_y = 0, end_x = 10, end_y = 10;
if (clink->ocsource)
{
bst_canvas_source_ochannel_pos (clink->ocsource, clink->ochannel, &start_x, &start_y);
gnome_canvas_item_w2i (item, &start_x, &start_y);
}
if (clink->icsource)
{
bst_canvas_source_ichannel_pos (clink->icsource, clink->ichannel, &end_x, &end_y);
gnome_canvas_item_w2i (item, &end_x, &end_y);
}
GnomeCanvasPoints *gpoints = gnome_canvas_points_new (2);
gpoints->coords[0] = start_x;
gpoints->coords[1] = start_y;
gpoints->coords[2] = end_x;
gpoints->coords[3] = end_y;
g_object_set (clink->line,
"points", gpoints,
NULL);
gnome_canvas_points_free (gpoints);
}
if (clink->tag_start)
gnome_canvas_item_raise_to_top (clink->tag_start);
if (clink->tag_end)
gnome_canvas_item_raise_to_top (clink->tag_end);
if (clink->ocsource && clink->icsource)
gnome_canvas_item_keep_above (GNOME_CANVAS_ITEM (clink),
GNOME_CANVAS_ITEM (clink->ocsource),
GNOME_CANVAS_ITEM (clink->icsource));
bst_canvas_link_adjust_tags (clink);
bst_canvas_link_adjust_arrow (clink);
}
/* given the src and dst node centers, plus a size, draws a triangle in the
* specified color on the provided canvas item*/
static void draw_oneside_link(double xs, double ys, double xd, double yd,
const basic_stats_t *link_stats,
guint32 scaledColor, GnomeCanvasItem *item)
{
GnomeCanvasPoints *points;
gdouble versorx, versory, modulus, link_size;
link_size = get_link_size(link_stats) / 2;
/* limit the maximum size to avoid overload */
if (link_size > MAX_LINK_SIZE)
link_size = MAX_LINK_SIZE;
versorx = -(yd - ys);
versory = xd - xs;
modulus = sqrt (pow (versorx, 2) + pow (versory, 2));
if (modulus == 0)
{
link_size = 0;
modulus = 1;
}
points = gnome_canvas_points_new (3);
points->coords[0] = xd;
points->coords[1] = yd;
points->coords[2] = xs + versorx * link_size / modulus;
points->coords[3] = ys + versory * link_size / modulus;
points->coords[4] = xs - versorx * link_size / modulus;
points->coords[5] = ys - versory * link_size / modulus;
gnome_canvas_item_set (item,
"points", points,
"fill_color_rgba", scaledColor, NULL);
/* If we got this far, the link can be shown. Make sure it is */
gnome_canvas_item_show (item);
gnome_canvas_points_unref (points);
}
static void midi_section_init(MidiSection* self)
{
MidiSectionPrivate* p = MIDI_SECTION_GET_PRIVATE(self);
GtkBox* box = GTK_BOX(self);
GtkWidget* pad;
GtkWidget* view;
GtkWidget* scroll;
GnomeCanvas* canvas;
GnomeCanvasPoints* points;
int x1, x2, y1, y2;
p->patch = -1;
p->ignore = FALSE;
x1 = 0;
y1 = 0;
x2 = (PHIN_KEYBOARD_KEY_WIDTH * MIDI_NOTES);
y2 = HEIGHT;
/* adjustment */
p->adj = (GtkAdjustment*) gtk_adjustment_new(0, 0, 0, 0, 0, 0);
/* viewport */
view = gtk_viewport_new(p->adj, NULL);
gtk_box_pack_start(box, view, FALSE, FALSE, 0);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(view), GTK_SHADOW_NONE);
gtk_widget_set_size_request(view, 0, y2);
gtk_widget_show(view);
/* canvas */
canvas = (GnomeCanvas*) gnome_canvas_new();
gtk_widget_set_size_request(GTK_WIDGET(canvas), x2, y2);
gnome_canvas_set_scroll_region(canvas, 0, 0, x2 - 1, y2 -1);
gtk_container_add(GTK_CONTAINER(view), GTK_WIDGET(canvas));
g_signal_connect(G_OBJECT(canvas), "event",
G_CALLBACK(range_cb), (gpointer)p);
gtk_widget_show(GTK_WIDGET(canvas));
/* range display backdrop */
gnome_canvas_item_new(gnome_canvas_root(canvas),
gnome_canvas_rect_get_type(),
"x1", (gdouble)0,
"y1", (gdouble)0,
"x2", (gdouble)x2,
"y2", (gdouble)y2,
"fill-color-rgba", BG_COLOR,
NULL);
/* range */
p->range = gnome_canvas_item_new(gnome_canvas_root(canvas),
gnome_canvas_rect_get_type(),
"x1", (gdouble)x1,
"y1", (gdouble)y1,
"x2", (gdouble)PHIN_KEYBOARD_KEY_WIDTH,
"y2", (gdouble)y2,
"fill-color-rgba", RANGE_COLOR,
"outline-color", "black",
NULL);
gnome_canvas_item_hide(p->range);
/* range root note */
p->note = gnome_canvas_item_new(gnome_canvas_root(canvas),
gnome_canvas_rect_get_type(),
"x1", (gdouble)x1,
"y1", (gdouble)y1,
"x2", (gdouble)PHIN_KEYBOARD_KEY_WIDTH,
"y2", (gdouble)y2,
"fill-color-rgba", NOTE_COLOR,
"outline-color", "black",
NULL);
gnome_canvas_item_hide(p->note);
p->canvas = canvas;
/* range display border */
points = gnome_canvas_points_new(4);
points->coords[0] = x1;
points->coords[1] = y2;
points->coords[2] = x1;
points->coords[3] = y1;
points->coords[4] = x2-1;
points->coords[5] = y1;
points->coords[6] = x2-1;
points->coords[7] = y2;
gnome_canvas_item_new(gnome_canvas_root(canvas),
gnome_canvas_line_get_type(),
"points", points,
"width-units", (gdouble)1,
"fill-color-rgba", 0,
NULL);
gnome_canvas_points_unref(points);
/* keyboard */
p->keyboard = phin_hkeyboard_new(p->adj, MIDI_NOTES, TRUE);
gtk_box_pack_start(box, p->keyboard, FALSE, FALSE, 0);
gtk_widget_show(p->keyboard);
/* vpad */
pad = gui_vpad_new(GUI_SCROLLSPACE);
gtk_box_pack_start(box, pad, FALSE, FALSE, 0);
gtk_widget_show(pad);
/* scrollbar */
scroll = gtk_hscrollbar_new(p->adj);
gtk_box_pack_start(box, scroll, FALSE, FALSE, 0);
gtk_widget_show(scroll);
/* done */
connect(p);
}
// paste xournal native data
void clipboard_paste_from_xournal(GtkSelectionData *sel_data)
{
unsigned char *p;
int nitems, npts, i, len;
struct Item *item;
double hoffset, voffset, cx, cy;
double *pf;
int sx, sy, wx, wy;
reset_selection();
ui.selection = g_new(struct Selection, 1);
p = sel_data->data + sizeof(int);
g_memmove(&nitems, p, sizeof(int)); p+= sizeof(int);
ui.selection->type = ITEM_SELECTRECT;
ui.selection->layer = ui.cur_layer;
g_memmove(&ui.selection->bbox, p, sizeof(struct BBox)); p+= sizeof(struct BBox);
ui.selection->items = NULL;
// find by how much we translate the pasted selection
gnome_canvas_get_scroll_offsets(canvas, &sx, &sy);
gdk_window_get_geometry(GTK_WIDGET(canvas)->window, NULL, NULL, &wx, &wy, NULL);
gnome_canvas_window_to_world(canvas, sx + wx/2, sy + wy/2, &cx, &cy);
cx -= ui.cur_page->hoffset;
cy -= ui.cur_page->voffset;
if (cx + (ui.selection->bbox.right-ui.selection->bbox.left)/2 > ui.cur_page->width)
cx = ui.cur_page->width - (ui.selection->bbox.right-ui.selection->bbox.left)/2;
if (cx - (ui.selection->bbox.right-ui.selection->bbox.left)/2 < 0)
cx = (ui.selection->bbox.right-ui.selection->bbox.left)/2;
if (cy + (ui.selection->bbox.bottom-ui.selection->bbox.top)/2 > ui.cur_page->height)
cy = ui.cur_page->height - (ui.selection->bbox.bottom-ui.selection->bbox.top)/2;
if (cy - (ui.selection->bbox.bottom-ui.selection->bbox.top)/2 < 0)
cy = (ui.selection->bbox.bottom-ui.selection->bbox.top)/2;
hoffset = cx - (ui.selection->bbox.right+ui.selection->bbox.left)/2;
voffset = cy - (ui.selection->bbox.top+ui.selection->bbox.bottom)/2;
ui.selection->bbox.left += hoffset;
ui.selection->bbox.right += hoffset;
ui.selection->bbox.top += voffset;
ui.selection->bbox.bottom += voffset;
ui.selection->canvas_item = gnome_canvas_item_new(ui.cur_layer->group,
gnome_canvas_rect_get_type(), "width-pixels", 1,
"outline-color-rgba", 0x000000ff,
"fill-color-rgba", 0x80808040,
"x1", ui.selection->bbox.left, "x2", ui.selection->bbox.right,
"y1", ui.selection->bbox.top, "y2", ui.selection->bbox.bottom, NULL);
make_dashed(ui.selection->canvas_item);
while (nitems-- > 0) {
item = g_new(struct Item, 1);
ui.selection->items = g_list_append(ui.selection->items, item);
ui.cur_layer->items = g_list_append(ui.cur_layer->items, item);
ui.cur_layer->nitems++;
g_memmove(&item->type, p, sizeof(int)); p+= sizeof(int);
if (item->type == ITEM_STROKE) {
g_memmove(&item->brush, p, sizeof(struct Brush)); p+= sizeof(struct Brush);
g_memmove(&npts, p, sizeof(int)); p+= sizeof(int);
item->path = gnome_canvas_points_new(npts);
pf = (double *)p;
for (i=0; i<npts; i++) {
item->path->coords[2*i] = pf[2*i] + hoffset;
item->path->coords[2*i+1] = pf[2*i+1] + voffset;
}
p+= 2*item->path->num_points*sizeof(double);
if (item->brush.variable_width) {
item->widths = g_memdup(p, (item->path->num_points-1)*sizeof(double));
p+= (item->path->num_points-1)*sizeof(double);
}
else item->widths = NULL;
update_item_bbox(item);
make_canvas_item_one(ui.cur_layer->group, item);
}
if (item->type == ITEM_TEXT) {
g_memmove(&item->brush, p, sizeof(struct Brush)); p+= sizeof(struct Brush);
g_memmove(&item->bbox.left, p, sizeof(double)); p+= sizeof(double);
g_memmove(&item->bbox.top, p, sizeof(double)); p+= sizeof(double);
item->bbox.left += hoffset;
item->bbox.top += voffset;
g_memmove(&len, p, sizeof(int)); p+= sizeof(int);
item->text = g_malloc(len+1);
g_memmove(item->text, p, len+1); p+= len+1;
g_memmove(&len, p, sizeof(int)); p+= sizeof(int);
item->font_name = g_malloc(len+1);
g_memmove(item->font_name, p, len+1); p+= len+1;
g_memmove(&item->font_size, p, sizeof(double)); p+= sizeof(double);
make_canvas_item_one(ui.cur_layer->group, item);
}
if (item->type == ITEM_IMAGE) {
item->canvas_item = NULL;
item->image_png = NULL;
item->image_png_len = 0;
g_memmove(&item->bbox, p, sizeof(struct BBox)); p+= sizeof(struct BBox);
item->bbox.left += hoffset;
item->bbox.right += hoffset;
item->bbox.top += voffset;
item->bbox.bottom += voffset;
g_memmove(&item->image_png_len, p, sizeof(gsize)); p+= sizeof(gsize);
if (item->image_png_len > 0) {
item->image_png = g_memdup(p, item->image_png_len);
item->image = pixbuf_from_buffer(item->image_png, item->image_png_len);
p+= item->image_png_len;
} else {
item->image = NULL;
}
make_canvas_item_one(ui.cur_layer->group, item);
}
}
prepare_new_undo();
undo->type = ITEM_PASTE;
undo->layer = ui.cur_layer;
undo->itemlist = g_list_copy(ui.selection->items);
gtk_selection_data_free(sel_data);
update_copy_paste_enabled();
update_color_menu();
update_thickness_buttons();
update_color_buttons();
update_font_button();
update_cursor(); // FIXME: can't know if pointer is within selection!
}
void *create_new(Quote *quote_vector,int *quote_counter,xmlNodePtr node) {
GnomeCanvasGroup *temp_group;
struct channel_data *data;
// struct channel_pdata *pdata=(struct channel_pdata *)_pdata;
int i;
channel_counter++;
data=(struct channel_data *)malloc(sizeof(struct channel_data));
if (node!=NULL) {
data->t1=atof(xmlGetProp(node,"t1"));
data->v1=atof(xmlGetProp(node,"v1"));
data->t2=atof(xmlGetProp(node,"t2"));
data->v2=atof(xmlGetProp(node,"v2"));
data->dist=atof(xmlGetProp(node,"dist"));
data->old_cx=CHARTER_X(1);
data->old_cy=CHARTER_Y(1);
data->day=atoi(xmlGetProp(node,"day"));
data->month=atoi(xmlGetProp(node,"month"));
data->year=atoi(xmlGetProp(node,"year"));
i=1;
while (quote_vector[i].year!=data->year && i<*quote_counter) i++;
while (quote_vector[i].month!=data->month && i<*quote_counter) i++;
while (quote_vector[i].day!=data->day && i<*quote_counter) i++;
data->time_offset=i-1;
data->t1+=data->time_offset;
data->t2+=data->time_offset;
} else {
data->t1=CHARTER_RX(-100);
data->v1=CHARTER_RY(-100);
data->t2=CHARTER_RX(0);
data->v2=CHARTER_RY(0);
data->dist=10;
data->old_cx=CHARTER_X(1);
data->old_cy=CHARTER_Y(1);
data->day=quote_vector[1].day;
data->month=quote_vector[1].month;
data->year=quote_vector[1].year;
data->time_offset=0;
}
temp_group=(GnomeCanvasGroup *)gnome_canvas_item_new(gnome_canvas_root(chart_canvas),
GNOME_TYPE_CANVAS_GROUP,
"x",0.0,
"y",0.0,
NULL);
data->group=temp_group;
data->line1_points=gnome_canvas_points_new(2);
data->line3_points=gnome_canvas_points_new(2);
data->line2_points=gnome_canvas_points_new(2);
data->line1=gnome_canvas_item_new(temp_group,
GNOME_TYPE_CANVAS_LINE,
"points",data->line1_points,
"width_units",1.0,
"fill_color", "Blue",
NULL);
data->line2=gnome_canvas_item_new(temp_group,
GNOME_TYPE_CANVAS_LINE,
"points",data->line2_points,
"width_units",1.0,
"fill_color", "Blue",
NULL);
data->line3=gnome_canvas_item_new(temp_group,
GNOME_TYPE_CANVAS_LINE,
"points",data->line3_points,
"width_units",0.5,
"fill_color", "#909090",
NULL);
data->handle1=gnome_canvas_item_new(temp_group,
GNOME_TYPE_CANVAS_RECT,
"x1",CHARTER_X(data->t1)-2.0,
"y1",CHARTER_Y(data->v1)-2.0,
"x2",CHARTER_X(data->t1)+2.0,
"y2",CHARTER_Y(data->v1)+2.0,
"outline_color",NULL,
"width_pixels",1,
"fill_color",NULL,
NULL);
gtk_signal_connect(GTK_OBJECT(data->handle1),"event",(GtkSignalFunc)handle_callback,data);
data->handle2=gnome_canvas_item_new(temp_group,
GNOME_TYPE_CANVAS_RECT,
"x1",CHARTER_X(data->t2)-2.0,
"y1",CHARTER_Y(data->v2)-2.0,
"x2",CHARTER_X(data->t2)+2.0,
"y2",CHARTER_Y(data->v2)+2.0,
"outline_color",NULL,
"width_pixels",1,
"fill_color",NULL,
NULL);
gtk_signal_connect(GTK_OBJECT(data->handle2),"event",(GtkSignalFunc)handle_callback,data);
data->handle3=gnome_canvas_item_new(temp_group,
GNOME_TYPE_CANVAS_RECT,
"x1",data->line3_points->coords[2]-2.0,
"y1",data->line3_points->coords[3]-2.0,
"x2",data->line3_points->coords[2]+2.0,
"y2",data->line3_points->coords[3]+2.0,
"outline_color",NULL,
"width_pixels",1,
"fill_color",NULL,
NULL);
gtk_signal_connect(GTK_OBJECT(data->handle3),"event",(GtkSignalFunc)handle_callback,data);
gtk_signal_connect(GTK_OBJECT(data->line1),"event",(GtkSignalFunc)channel_callback,data);
gtk_signal_connect(GTK_OBJECT(data->line2),"event",(GtkSignalFunc)channel_callback,data);
gtk_signal_connect(GTK_OBJECT(data->line3),"event",(GtkSignalFunc)channel_callback,data);
reset_from_data(data);
return data;
}
static void create_buysell(ChartInstance *ci) {
char color_string[8];
struct tm *tm_time;
int i;
char text_string[20];
double text_offset;
struct buysell_data *data=(struct buysell_data *)ci->instance_data;
ci->fixed_group=NULL;
ci->move_group=NULL;
data->arrow=NULL;
if (ci->quote_count>1) {
tm_time=localtime(&data->time);
data->day=-1;
for (i=1;i<ci->quote_count+1;i++) {
if ( (ci->quote_vector[i].year==tm_time->tm_year) &&
(ci->quote_vector[i].month==tm_time->tm_mon) &&
(ci->quote_vector[i].day==tm_time->tm_mday)) {
data->day=i-1;
break;
}
}
if (data->day==-1) {
data->time=ci->quote_vector[1].timestamp;
data->day=0;
}
sprintf(color_string,"#%.2X%.2X%.2X",data->r,data->g,data->b);
ci->fixed_group=(GnomeCanvasGroup *)gnome_canvas_item_new(gnome_canvas_root(chart_canvas),
GNOME_TYPE_CANVAS_GROUP,
"x",0.0,
"y",0.0,
NULL);
bs_points=gnome_canvas_points_new(2);
bs_points->coords[0]=CHARTER_X(data->day);
bs_points->coords[1]=CHARTER_Y(data->price);
bs_points->coords[2]=CHARTER_X(data->day);
bs_points->coords[3]=CHARTER_Y(data->price);
if (data->buy) {
bs_points->coords[3]+=10;
text_offset=10;
} else {
bs_points->coords[3]-=10;
text_offset=-30;
}
data->arrow=gnome_canvas_item_new(ci->fixed_group,
GNOME_TYPE_CANVAS_LINE,
"points",bs_points,
"width_units",1.0,
"fill_color", color_string,
"first_arrowhead",TRUE,
"last_arrowhead",FALSE,
"arrow_shape_a",5.0,
"arrow_shape_b",5.0,
"arrow_shape_c",2.5,
NULL);
sprintf(text_string,"%.2f",data->amount);
data->text=gnome_canvas_item_new (ci->fixed_group,
GNOME_TYPE_CANVAS_TEXT,
"text",text_string,
"x", CHARTER_X(data->day),
"y", CHARTER_Y(data->price)+text_offset,
"font", "-b&h-lucida-medium-r-normal-*-*-100-*-*-p-*-iso8859-1",
"anchor", GTK_ANCHOR_N,
"fill_color", "black",
NULL);
sprintf(text_string,"%.2f",data->price);
data->text2=gnome_canvas_item_new (ci->fixed_group,
GNOME_TYPE_CANVAS_TEXT,
"text",text_string,
"x", CHARTER_X(data->day),
"y", CHARTER_Y(data->price)+text_offset+10,
"font", "-b&h-lucida-medium-r-normal-*-*-100-*-*-p-*-iso8859-1",
"anchor", GTK_ANCHOR_N,
"fill_color", "black",
NULL);
gnome_canvas_points_free(bs_points);
}
}
void ui_common_study_preferences_widgets(GtkWidget * packing_table,
gint table_row,
GtkWidget ** proi_width_spin,
GnomeCanvasItem ** proi_item,
#ifdef AMIDE_LIBGNOMECANVAS_AA
GtkWidget ** proi_transparency_spin,
#else
GtkWidget ** pline_style_menu,
GtkWidget ** pfill_roi_button,
#endif
GtkWidget ** playout_button1,
GtkWidget ** playout_button2,
GtkWidget ** ppanel_layout_button1,
GtkWidget ** ppanel_layout_button2,
GtkWidget ** ppanel_layout_button3,
GtkWidget ** pmaintain_size_button,
GtkWidget ** ptarget_size_spin) {
GtkWidget * label;
GtkObject * adjustment;
GtkWidget * roi_canvas;
GnomeCanvasPoints * roi_line_points;
GtkWidget * image;
GtkWidget * hseparator;
#ifndef AMIDE_LIBGNOMECANVAS_AA
GdkLineStyle i_line_style;
#endif
/* widgets to change the roi's size */
label = gtk_label_new(_("ROI Width (pixels)"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_ROI_WIDTH,
AMITK_PREFERENCES_MIN_ROI_WIDTH,
AMITK_PREFERENCES_MAX_ROI_WIDTH,1.0, 1.0, 0.0);
*proi_width_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*proi_width_spin),FALSE);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*proi_width_spin), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_width_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*proi_width_spin), GTK_UPDATE_ALWAYS);
gtk_table_attach(GTK_TABLE(packing_table), *proi_width_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*proi_width_spin);
/* a little canvas indicator thingie to show the user who the new preferences will look */
#ifdef AMIDE_LIBGNOMECANVAS_AA
roi_canvas = gnome_canvas_new_aa();
#else
roi_canvas = gnome_canvas_new();
#endif
gtk_widget_set_size_request(roi_canvas, 100, 100);
gnome_canvas_set_scroll_region(GNOME_CANVAS(roi_canvas), 0.0, 0.0, 100.0, 100.0);
gtk_table_attach(GTK_TABLE(packing_table), roi_canvas, 2,3,table_row,table_row+2,
GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(roi_canvas);
/* the box */
roi_line_points = gnome_canvas_points_new(5);
roi_line_points->coords[0] = 25.0; /* x1 */
roi_line_points->coords[1] = 25.0; /* y1 */
roi_line_points->coords[2] = 75.0; /* x2 */
roi_line_points->coords[3] = 25.0; /* y2 */
roi_line_points->coords[4] = 75.0; /* x3 */
roi_line_points->coords[5] = 75.0; /* y3 */
roi_line_points->coords[6] = 25.0; /* x4 */
roi_line_points->coords[7] = 75.0; /* y4 */
roi_line_points->coords[8] = 25.0; /* x4 */
roi_line_points->coords[9] = 25.0; /* y4 */
*proi_item = gnome_canvas_item_new(gnome_canvas_root(GNOME_CANVAS(roi_canvas)),
#ifdef AMIDE_LIBGNOMECANVAS_AA
gnome_canvas_polygon_get_type(),
#else
gnome_canvas_line_get_type(),
#endif
"points", roi_line_points,
NULL);
gnome_canvas_points_unref(roi_line_points);
table_row++;
#ifdef AMIDE_LIBGNOMECANVAS_AA
/* widget to change the transparency level */
/* only works for anti-aliased canvases */
/* widgets to change the roi's size */
label = gtk_label_new(_("ROI Transparency"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0, 1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*proi_transparency_spin = gtk_spin_button_new_with_range(0.0,1.0,AMITK_PREFERENCES_DEFAULT_CANVAS_ROI_TRANSPARENCY);
gtk_spin_button_set_increments(GTK_SPIN_BUTTON(*proi_transparency_spin),0.1,0.1);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_transparency_spin),FALSE);
gtk_table_attach(GTK_TABLE(packing_table), *proi_transparency_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*proi_transparency_spin);
table_row++;
#else
/* widgets to change the roi's line style */
/* Anti-aliased canvas doesn't yet support this */
/* also need to remove #ifndef for relevant lines in amitk_canvas_object.c and other locations */
label = gtk_label_new(_("ROI Line Style:"));
gtk_table_attach(GTK_TABLE(packing_table), label, 0,1,
table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pline_style_menu = gtk_combo_box_new_text();
for (i_line_style=0; i_line_style<=GDK_LINE_DOUBLE_DASH; i_line_style++)
gtk_combo_box_append_text(GTK_COMBO_BOX(*pline_style_menu),
line_style_names[i_line_style]);
gtk_widget_set_size_request (*pline_style_menu, 125, -1);
gtk_table_attach(GTK_TABLE(packing_table), *pline_style_menu, 1,2,
table_row,table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pline_style_menu);
table_row++;
/* do we want to fill in isocontour roi's */
label = gtk_label_new(_("Draw Isocontours/Freehands Filled:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pfill_roi_button = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(packing_table), *pfill_roi_button,
1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pfill_roi_button);
table_row++;
#endif
hseparator = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(packing_table), hseparator,
0, 3, table_row, table_row+1,
GTK_FILL, 0, X_PADDING, Y_PADDING);
table_row++;
gtk_widget_show(hseparator);
label = gtk_label_new(_("Canvas Layout:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
/* the radio buttons */
*playout_button1 = gtk_radio_button_new(NULL);
image = gtk_image_new_from_stock("amide_icon_layout_linear",GTK_ICON_SIZE_DIALOG);
gtk_button_set_image(GTK_BUTTON(*playout_button1), image);
gtk_table_attach(GTK_TABLE(packing_table), *playout_button1,
1,2, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*playout_button1), "layout", GINT_TO_POINTER(AMITK_LAYOUT_LINEAR));
gtk_widget_show(*playout_button1);
*playout_button2 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*playout_button2),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*playout_button1)));
image = gtk_image_new_from_stock("amide_icon_layout_orthogonal",GTK_ICON_SIZE_DIALOG);
gtk_button_set_image(GTK_BUTTON(*playout_button2), image);
gtk_table_attach(GTK_TABLE(packing_table), *playout_button2, 2,3, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*playout_button2), "layout", GINT_TO_POINTER(AMITK_LAYOUT_ORTHOGONAL));
gtk_widget_show(*playout_button2);
table_row++;
label = gtk_label_new(_("Multiple Canvases Layout:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
/* the radio buttons */
*ppanel_layout_button1 = gtk_radio_button_new(NULL);
image = gtk_image_new_from_stock("amide_icon_panels_mixed", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button1), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button1,
1,2, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button1), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_MIXED));
gtk_widget_show(*ppanel_layout_button1);
*ppanel_layout_button2 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button2),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1)));
image = gtk_image_new_from_stock("amide_icon_panels_linear_x", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button2), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button2,
2,3, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button2), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_X));
gtk_widget_show(*ppanel_layout_button2);
*ppanel_layout_button3 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button3),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1)));
image = gtk_image_new_from_stock("amide_icon_panels_linear_y", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button3), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button3,
3,4, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button3), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_Y));
gtk_widget_show(*ppanel_layout_button3);
table_row++;
/* do we want the size of the canvas to not resize */
label = gtk_label_new(_("Maintain view size constant:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pmaintain_size_button = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(packing_table), *pmaintain_size_button,
1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pmaintain_size_button);
table_row++;
/* widgets to change the amount of empty space in the center of the target */
label = gtk_label_new(_("Target Empty Area (pixels)"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA,
AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA,
AMITK_PREFERENCES_MAX_TARGET_EMPTY_AREA, 1.0, 1.0, 0.0);
*ptarget_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*ptarget_size_spin),FALSE);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*ptarget_size_spin), GTK_UPDATE_ALWAYS);
gtk_table_attach(GTK_TABLE(packing_table), *ptarget_size_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*ptarget_size_spin);
return;
}
void ui_common_draw_view_axis(GnomeCanvas * canvas, gint row, gint column,
AmitkView view, AmitkLayout layout,
gint axis_width, gint axis_height) {
const gchar * x_axis_label;
gdouble x_axis_label_x_location;
gdouble x_axis_label_y_location;
GtkAnchorType x_axis_label_anchor;
GnomeCanvasPoints * x_axis_line_points;
const gchar * y_axis_label;
gdouble y_axis_label_x_location;
gdouble y_axis_label_y_location;
GtkAnchorType y_axis_label_anchor;
GnomeCanvasPoints * y_axis_line_points;
x_axis_line_points = gnome_canvas_points_new(2);
x_axis_line_points->coords[0] = column*axis_width + AXIS_MARGIN; /* x1 */
y_axis_line_points = gnome_canvas_points_new(2);
y_axis_line_points->coords[0] = column*axis_width + AXIS_MARGIN; /* x1 */
switch(view) {
case AMITK_VIEW_CORONAL:
/* the x axis */
x_axis_line_points->coords[1] = row*axis_height + AXIS_HEADER; /* y1 */
x_axis_line_points->coords[2] = column*axis_width + axis_width-AXIS_MARGIN; /* x2 */
x_axis_line_points->coords[3] = row*axis_height + AXIS_HEADER; /* y2 */
/* the x label */
x_axis_label = amitk_axis_get_name(AMITK_AXIS_X);
x_axis_label_x_location = column*axis_width + axis_width-AXIS_MARGIN-AXIS_TEXT_MARGIN;
x_axis_label_y_location = row*axis_height + AXIS_HEADER+AXIS_TEXT_MARGIN;
x_axis_label_anchor = GTK_ANCHOR_NORTH_EAST;
/* the z axis */
y_axis_line_points->coords[1] = row*axis_height + AXIS_HEADER; /* y1 */
y_axis_line_points->coords[2] = column*axis_width + AXIS_MARGIN; /* x2 */
y_axis_line_points->coords[3] = row*axis_height + axis_height-AXIS_MARGIN; /* y2 */
/* the z label */
y_axis_label = amitk_axis_get_name(AMITK_AXIS_Z);
y_axis_label_x_location = column*axis_width + AXIS_MARGIN+AXIS_TEXT_MARGIN;
y_axis_label_y_location = row*axis_height + axis_height-AXIS_MARGIN-AXIS_TEXT_MARGIN;
y_axis_label_anchor = GTK_ANCHOR_NORTH_WEST;
break;
case AMITK_VIEW_SAGITTAL:
/* the y axis */
x_axis_line_points->coords[3] = row*axis_height + AXIS_HEADER; /* y2 */
if (layout == AMITK_LAYOUT_ORTHOGONAL) {
x_axis_line_points->coords[1] = row*axis_height + axis_height-AXIS_MARGIN; /* y1 */
x_axis_line_points->coords[2] = column*axis_width + AXIS_MARGIN; /* x2 */
} else { /* AMITK_LAYOUT_LINEAR */
x_axis_line_points->coords[1] = row*axis_height + AXIS_HEADER; /* y1 */
x_axis_line_points->coords[2] = column*axis_width + axis_width-AXIS_MARGIN; /* x2 */
}
/* the y label */
x_axis_label = amitk_axis_get_name(AMITK_AXIS_Y);
x_axis_label_y_location = row*axis_height + AXIS_HEADER+AXIS_TEXT_MARGIN;
if (layout == AMITK_LAYOUT_ORTHOGONAL) {
x_axis_label_x_location = column*axis_width + AXIS_MARGIN+AXIS_TEXT_MARGIN;
x_axis_label_anchor = GTK_ANCHOR_NORTH_WEST;
} else {/* AMITK_LAYOUT_LINEAR */
x_axis_label_x_location = column*axis_width + axis_width-AXIS_MARGIN-AXIS_TEXT_MARGIN;
x_axis_label_anchor = GTK_ANCHOR_NORTH_EAST;
}
/* the z axis */
y_axis_line_points->coords[3] = row*axis_height + axis_height-AXIS_MARGIN; /* y2 */
if (layout == AMITK_LAYOUT_ORTHOGONAL) {
y_axis_line_points->coords[1] = row*axis_height + axis_height-AXIS_MARGIN; /* y1 */
y_axis_line_points->coords[2] = column*axis_width + axis_width-AXIS_MARGIN; /* x2 */
} else { /* AMITK_LAYOUT_LINEAR */
y_axis_line_points->coords[1] = row*axis_height + AXIS_HEADER; /* y1 */
y_axis_line_points->coords[2] = column*axis_width + AXIS_MARGIN; /* x2 */
}
/* the z label */
y_axis_label = amitk_axis_get_name(AMITK_AXIS_Z);
y_axis_label_y_location = row*axis_height + axis_height-AXIS_MARGIN-AXIS_TEXT_MARGIN;
if (layout == AMITK_LAYOUT_ORTHOGONAL) {
y_axis_label_x_location = column*axis_width + axis_width-AXIS_MARGIN-AXIS_TEXT_MARGIN;
y_axis_label_anchor = GTK_ANCHOR_SOUTH_EAST;
} else {
y_axis_label_x_location = column*axis_width + AXIS_MARGIN+AXIS_TEXT_MARGIN;
y_axis_label_anchor = GTK_ANCHOR_NORTH_WEST;
}
break;
case AMITK_VIEW_TRANSVERSE:
default:
/* the x axis */
x_axis_line_points->coords[1] = row*axis_height + axis_height-AXIS_MARGIN; /* y1 */
x_axis_line_points->coords[2] = column*axis_width + axis_width-AXIS_MARGIN; /* x2 */
x_axis_line_points->coords[3] = row*axis_height + axis_height-AXIS_MARGIN; /* y2 */
/* the x label */
x_axis_label = amitk_axis_get_name(AMITK_AXIS_X);
x_axis_label_x_location = column*axis_width + axis_width-AXIS_MARGIN-AXIS_TEXT_MARGIN;
x_axis_label_y_location = row*axis_height + axis_height-AXIS_MARGIN-AXIS_TEXT_MARGIN;
x_axis_label_anchor = GTK_ANCHOR_SOUTH_EAST;
/* the y axis */
y_axis_line_points->coords[1] = row*axis_height + axis_height-AXIS_MARGIN; /* y1 */
y_axis_line_points->coords[2] = column*axis_width + AXIS_MARGIN; /* x2 */
y_axis_line_points->coords[3] = row*axis_height + AXIS_HEADER; /* y2 */
/* the y label */
y_axis_label = amitk_axis_get_name(AMITK_AXIS_Y);
y_axis_label_x_location = column*axis_width + AXIS_MARGIN+AXIS_TEXT_MARGIN;
y_axis_label_y_location = row*axis_height + AXIS_HEADER+AXIS_TEXT_MARGIN;
y_axis_label_anchor = GTK_ANCHOR_NORTH_WEST;
break;
}
/* the view label */
gnome_canvas_item_new(gnome_canvas_root(canvas), gnome_canvas_text_get_type(),
"anchor", GTK_ANCHOR_NORTH, "text", amitk_view_get_name(view),
"x", (gdouble) (column+0.5)*axis_width,
"y", (gdouble) (row+0.5)*axis_height,
"fill_color", "black",
"font_desc", amitk_fixed_font_desc, NULL);
/* the x axis */
gnome_canvas_item_new(gnome_canvas_root(canvas), gnome_canvas_line_get_type(),
"points", x_axis_line_points, "fill_color", "black",
"width_pixels", 3, "last_arrowhead", TRUE,
"arrow_shape_a", (gdouble) AXIS_ARROW_LENGTH,
"arrow_shape_b", (gdouble) AXIS_ARROW_EDGE,
"arrow_shape_c", (gdouble) AXIS_ARROW_WIDTH,
NULL);
/* the x label */
gnome_canvas_item_new(gnome_canvas_root(canvas), gnome_canvas_text_get_type(),
"anchor", x_axis_label_anchor,"text", x_axis_label,
"x", x_axis_label_x_location, "y", x_axis_label_y_location,
"fill_color", "black", "font_desc", amitk_fixed_font_desc, NULL);
/* the y axis */
gnome_canvas_item_new(gnome_canvas_root(canvas), gnome_canvas_line_get_type(),
"points", y_axis_line_points, "fill_color", "black",
"width_pixels", 3, "last_arrowhead", TRUE,
"arrow_shape_a", (gdouble) AXIS_ARROW_LENGTH,
"arrow_shape_b", (gdouble) AXIS_ARROW_EDGE,
"arrow_shape_c", (gdouble) AXIS_ARROW_WIDTH,
NULL);
gnome_canvas_points_unref(x_axis_line_points);
gnome_canvas_points_unref(y_axis_line_points);
/* the y label */
gnome_canvas_item_new(gnome_canvas_root(canvas),gnome_canvas_text_get_type(),
"anchor", y_axis_label_anchor, "text", y_axis_label,
"x", y_axis_label_x_location,"y", y_axis_label_y_location,
"fill_color", "black", "font_desc", amitk_fixed_font_desc, NULL);
return;
}
/* so much gayness in here, either I suck or gnome-canvas does; most
* likely, we both do */
static void draw_key(PhatKeyboard* self, gint index, gint pos, guint bg,
guint hi, guint low, guint pre, guint on, guint shad)
{
_Key* key = &self->keys[index];
GnomeCanvasPoints* points;
gint x1;
gint y1;
gint x2;
gint y2;
if (self->orientation == GTK_ORIENTATION_VERTICAL)
{
x1 = 0;
y1 = pos + 1; /* teh gayz0r */
x2 = PHAT_KEYBOARD_KEY_LENGTH - 1;
y2 = pos - PHAT_KEYBOARD_KEY_WIDTH + 1;
}
else
{
x1 = pos + PHAT_KEYBOARD_KEY_WIDTH - 1;
y1 = 0;
x2 = pos;
y2 = PHAT_KEYBOARD_KEY_LENGTH - 1;
}
/* key group */
key->group = (GnomeCanvasGroup*) gnome_canvas_item_new(gnome_canvas_root(self->canvas),
gnome_canvas_group_get_type(),
NULL);
g_signal_connect(G_OBJECT(key->group), "event",
G_CALLBACK(key_press_cb), (gpointer)key);
key->index = index;
key->hold = 0;
key->keyboard = self;
/* draw main key rect */
gnome_canvas_item_new(key->group,
gnome_canvas_rect_get_type(),
"x1", (gdouble)x1,
"y1", (gdouble)y1,
"x2", (gdouble)x2,
"y2", (gdouble)y2,
"fill-color-rgba", bg,
NULL);
/* draw prelight rect */
key->pre = gnome_canvas_item_new(key->group,
gnome_canvas_rect_get_type(),
"x1", (gdouble)x1,
"y1", (gdouble)y1,
"x2", (gdouble)x2,
"y2", (gdouble)y2,
"fill-color-rgba", pre,
NULL);
gnome_canvas_item_hide(key->pre);
/* draw key highlight */
points = gnome_canvas_points_new(3);
if (self->orientation == GTK_ORIENTATION_VERTICAL)
{
points->coords[0] = x1+1;
points->coords[1] = y1;
points->coords[2] = x1+1;
points->coords[3] = y2+1;
points->coords[4] = x2;
points->coords[5] = y2+1;
}
else
{
points->coords[0] = x1;
points->coords[1] = y1+1;
points->coords[2] = x2;
points->coords[3] = y1+1;
points->coords[4] = x2;
points->coords[5] = y2;
}
gnome_canvas_item_new(key->group,
gnome_canvas_line_get_type(),
"points", points,
"width-units", (gdouble)1,
"fill-color-rgba", hi,
NULL);
gnome_canvas_points_unref(points);
/* draw key border */
points = gnome_canvas_points_new(4);
if (self->orientation == GTK_ORIENTATION_VERTICAL)
{
points->coords[0] = x1;
points->coords[1] = y1;
points->coords[2] = x1;
points->coords[3] = y2;
points->coords[4] = x2;
points->coords[5] = y2;
points->coords[6] = x2;
points->coords[7] = y1;
}
else
{
points->coords[0] = x2;
points->coords[1] = y1;
points->coords[2] = x1;
points->coords[3] = y1;
points->coords[4] = x1;
points->coords[5] = y2;
points->coords[6] = x2;
points->coords[7] = y2;
}
gnome_canvas_item_new(key->group,
gnome_canvas_line_get_type(),
"points", points,
"width-units", (gdouble)1,
"fill-color-rgba", low,
NULL);
gnome_canvas_points_unref(points);
if (self->orientation == GTK_ORIENTATION_VERTICAL)
{
/* draw active rect */
key->on = gnome_canvas_item_new(key->group,
gnome_canvas_rect_get_type(),
"x1", (gdouble)x1+1,
"y1", (gdouble)y1,
"x2", (gdouble)x2,
"y2", (gdouble)y2+1,
"fill-color-rgba", on,
NULL);
}
else
{
/* draw active rect */
key->on = gnome_canvas_item_new(key->group,
gnome_canvas_rect_get_type(),
"x1", (gdouble)x1,
"y1", (gdouble)y1+1,
"x2", (gdouble)x2,
"y2", (gdouble)y2,
"fill-color-rgba", on,
NULL);
}
gnome_canvas_item_hide(key->on);
/* draw active shadow */
points = gnome_canvas_points_new(6);
if (self->orientation == GTK_ORIENTATION_VERTICAL)
{
points->coords[0] = x1+1;
points->coords[1] = y1;
points->coords[2] = x1+1;
points->coords[3] = y2+1;
points->coords[4] = x2;
points->coords[5] = y2+1;
points->coords[6] = x2;
points->coords[7] = y2 + 3;
points->coords[8] = x1 + 3;
points->coords[9] = y2 + 3;
points->coords[10] = x1 + 3;
points->coords[11] = y1;
}
else
{
points->coords[0] = x1;
points->coords[1] = y1 + 1;
points->coords[2] = x2;
points->coords[3] = y1 + 1;
points->coords[4] = x2;
points->coords[5] = y2;
points->coords[6] = x2 + 2;
points->coords[7] = y2;
points->coords[8] = x2 + 2;
points->coords[9] = y1 + 3;
points->coords[10] = x1;
points->coords[11] = y1 + 3;
}
key->shad = gnome_canvas_item_new(key->group,
gnome_canvas_polygon_get_type(),
"points", points,
"fill-color-rgba", shad,
NULL);
gnome_canvas_item_hide(key->shad);
gnome_canvas_points_unref(points);
/* draw label if applicable */
if (self->label && (index % 12) == 0)
{
gchar* s = g_strdup_printf("%d", index / 12 + 1);
if (self->orientation == GTK_ORIENTATION_VERTICAL)
{
gnome_canvas_item_new(key->group,
gnome_canvas_text_get_type(),
"text", s,
"x", (gdouble)(x2 - 2),
"y", (gdouble)(y1 - (PHAT_KEYBOARD_KEY_WIDTH / 2)),
"anchor", GTK_ANCHOR_EAST,
"fill-color-rgba", (gint)KEY_TEXT_BG,
"font", "sans",
"size-points", (gdouble)TEXT_POINTS,
NULL);
}
else
{
gnome_canvas_item_new(key->group,
gnome_canvas_text_get_type(),
"text", s,
"x", (gdouble)(x1 - (PHAT_KEYBOARD_KEY_WIDTH / 2)),
"y", (gdouble)(y2 - 2),
"anchor", GTK_ANCHOR_SOUTH,
"fill-color-rgba", (gint)KEY_TEXT_BG,
"font", "sans",
"size-points", (gdouble)TEXT_POINTS,
"justification", GTK_JUSTIFY_CENTER,
NULL);
}
g_free(s);
}
}
WireItem *
wire_item_new (Sheet *sheet, Wire *wire)
{
WireItem *item;
GnomeCanvasPoints *points;
WireItemPriv *priv;
SheetPos start_pos, length;
g_return_val_if_fail (sheet != NULL, NULL);
g_return_val_if_fail (IS_SHEET (sheet), NULL);
//g_object_ref (G_OBJECT(wire));
/* XXX Ver si hay equivalente gtk_object_sink (GTK_OBJECT (wire)); */
wire_get_pos_and_length (wire, &start_pos, &length);
/*
* Because of the GnomeCanvasGroup inheritance, a small hack is needed
* here. The group starts at the startpoint of the wire, and the line
* goes from (0,0) to (length.x, length.y).
*/
item = WIRE_ITEM (gnome_canvas_item_new (
sheet->object_group,
wire_item_get_type (),
"data", wire,
"x", (double) start_pos.x,
"y", (double) start_pos.y,
NULL));
priv = item->priv;
priv->resize1 = GNOME_CANVAS_RECT (gnome_canvas_item_new (
GNOME_CANVAS_GROUP (item),
gnome_canvas_rect_get_type (),
"x1", -RESIZER_SIZE,
"y1", -RESIZER_SIZE,
"x2", RESIZER_SIZE,
"y2", RESIZER_SIZE,
"fill_color", "red",
"fill_color_rgba", 0x3cb37180,
"outline_color", "blue",
"width_pixels", 1,
NULL));
priv->resize2 = GNOME_CANVAS_RECT (gnome_canvas_item_new (
GNOME_CANVAS_GROUP (item),
gnome_canvas_rect_get_type (),
"x1", length.x-RESIZER_SIZE,
"y1", length.y-RESIZER_SIZE,
"x2", length.x+RESIZER_SIZE,
"y2", length.y+RESIZER_SIZE,
"fill_color", "red",
"fill_color_rgba", 0x3cb37180,
"outline_color", "blue",
"width_pixels", 1,
NULL));
gnome_canvas_item_hide (GNOME_CANVAS_ITEM (priv->resize1));
gnome_canvas_item_hide (GNOME_CANVAS_ITEM (priv->resize2));
points = gnome_canvas_points_new (2);
points->coords[0] = 0;
points->coords[1] = 0;
points->coords[2] = length.x;
points->coords[3] = length.y;
priv->line = GNOME_CANVAS_LINE (gnome_canvas_item_new (
GNOME_CANVAS_GROUP (item),
gnome_canvas_line_get_type (),
"points", points,
"fill_color", "blue",
"width_pixels", 1,
NULL));
gnome_canvas_points_free (points);
g_signal_connect_object(G_OBJECT(wire), "rotated",
G_CALLBACK(wire_rotated_callback), G_OBJECT(item), 0);
g_signal_connect_object(G_OBJECT(wire), "flipped",
G_CALLBACK(wire_flipped_callback), G_OBJECT(item), 0);
g_signal_connect_object(G_OBJECT(wire), "moved",
G_CALLBACK(wire_moved_callback), G_OBJECT(item), 0);
g_signal_connect (G_OBJECT (wire), "changed", G_CALLBACK (wire_changed_callback), item);
g_signal_connect (G_OBJECT (wire), "delete", G_CALLBACK (wire_delete_callback), item);
wire_update_bbox (wire);
return item;
}
