static double
e_reflow_point (GnomeCanvasItem *item,
double x, double y, int cx, int cy,
GnomeCanvasItem **actual_item)
{
double distance = 1;
*actual_item = NULL;
if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->point)
distance = GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->point (item, x, y, cx, cy, actual_item);
if ((int) (distance * item->canvas->pixels_per_unit + 0.5) <= item->canvas->close_enough && *actual_item)
return distance;
*actual_item = item;
return 0;
#if 0
if (y >= E_REFLOW_BORDER_WIDTH && y <= reflow->height - E_REFLOW_BORDER_WIDTH) {
float n_x;
n_x = x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x, (reflow->column_width + E_REFLOW_FULL_GUTTER));
if (n_x < E_REFLOW_FULL_GUTTER) {
*actual_item = item;
return 0;
}
}
return distance;
#endif
}
static void
gnucash_grid_realize (GnomeCanvasItem *item)
{
GdkWindow *window;
GnucashGrid *gnucash_grid;
GdkGC *gc;
if (GNOME_CANVAS_ITEM_CLASS (gnucash_grid_parent_class)->realize)
(GNOME_CANVAS_ITEM_CLASS
(gnucash_grid_parent_class)->realize)(item);
gnucash_grid = GNUCASH_GRID (item);
window = gtk_widget_get_window (GTK_WIDGET (item->canvas));
/* Configure the default grid gc */
gnucash_grid->grid_gc = gc = gdk_gc_new (window);
gnucash_grid->fill_gc = gdk_gc_new (window);
gnucash_grid->gc = gdk_gc_new (window);
/* Allocate the default colors */
gnucash_grid->background = gn_white;
gnucash_grid->grid_color = gn_black;
gnucash_grid->default_color = gn_black;
gdk_gc_set_foreground (gc, &gnucash_grid->grid_color);
gdk_gc_set_background (gc, &gnucash_grid->background);
gdk_gc_set_foreground (gnucash_grid->fill_gc,
&gnucash_grid->background);
gdk_gc_set_background (gnucash_grid->fill_gc,
&gnucash_grid->grid_color);
}
static void
gnucash_grid_unrealize (GnomeCanvasItem *item)
{
GnucashGrid *gnucash_grid = GNUCASH_GRID (item);
if (gnucash_grid->grid_gc != NULL)
{
g_object_unref(gnucash_grid->grid_gc);
gnucash_grid->grid_gc = NULL;
}
if (gnucash_grid->fill_gc != NULL)
{
g_object_unref(gnucash_grid->fill_gc);
gnucash_grid->fill_gc = NULL;
}
if (gnucash_grid->gc != NULL)
{
g_object_unref(gnucash_grid->gc);
gnucash_grid->gc = NULL;
}
if (GNOME_CANVAS_ITEM_CLASS (gnucash_grid_parent_class)->unrealize)
(*GNOME_CANVAS_ITEM_CLASS
(gnucash_grid_parent_class)->unrealize)(item);
}
static void
etgl_realize (GnomeCanvasItem *item)
{
ETableGroupLeaf *etgl = E_TABLE_GROUP_LEAF (item);
if (GNOME_CANVAS_ITEM_CLASS (e_table_group_leaf_parent_class)->realize)
GNOME_CANVAS_ITEM_CLASS (e_table_group_leaf_parent_class)->realize (item);
etgl->item = E_TABLE_ITEM (gnome_canvas_item_new (
GNOME_CANVAS_GROUP (etgl),
e_table_item_get_type (),
"ETableHeader", E_TABLE_GROUP (etgl)->header,
"ETableModel", etgl->ets,
"alternating_row_colors", etgl->alternating_row_colors,
"horizontal_draw_grid", etgl->horizontal_draw_grid,
"vertical_draw_grid", etgl->vertical_draw_grid,
"drawfocus", etgl->draw_focus,
"cursor_mode", etgl->cursor_mode,
"minimum_width", etgl->minimum_width,
"length_threshold", etgl->length_threshold,
"selection_model", etgl->selection_model,
"uniform_row_height", etgl->uniform_row_height,
NULL));
etgl->etgl_cursor_change_id = g_signal_connect (
etgl->item, "cursor_change",
G_CALLBACK (etgl_cursor_change), etgl);
etgl->etgl_cursor_activated_id = g_signal_connect (
etgl->item, "cursor_activated",
G_CALLBACK (etgl_cursor_activated), etgl);
etgl->etgl_double_click_id = g_signal_connect (
etgl->item, "double_click",
G_CALLBACK (etgl_double_click), etgl);
etgl->etgl_right_click_id = g_signal_connect (
etgl->item, "right_click",
G_CALLBACK (etgl_right_click), etgl);
etgl->etgl_click_id = g_signal_connect (
etgl->item, "click",
G_CALLBACK (etgl_click), etgl);
etgl->etgl_key_press_id = g_signal_connect (
etgl->item, "key_press",
G_CALLBACK (etgl_key_press), etgl);
etgl->etgl_start_drag_id = g_signal_connect (
etgl->item, "start_drag",
G_CALLBACK (etgl_start_drag), etgl);
etgl->notify_is_editing_id = e_signal_connect_notify (
etgl->item, "notify::is-editing",
G_CALLBACK (etgl_item_is_editing_changed_cb), etgl);
e_canvas_item_request_reflow (item);
}
/* Realize handler for the text item */
static void
etgc_realize (GnomeCanvasItem *item)
{
ETableGroupContainer *etgc;
if (GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->realize)
(* GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->realize) (item);
etgc = E_TABLE_GROUP_CONTAINER (item);
e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (etgc));
}
static void
e_minicard_label_realize (GnomeCanvasItem *item)
{
EMinicardLabel *e_minicard_label;
GnomeCanvasGroup *group;
e_minicard_label = E_MINICARD_LABEL (item);
group = GNOME_CANVAS_GROUP ( item );
if (GNOME_CANVAS_ITEM_CLASS ( parent_class )->realize)
(* GNOME_CANVAS_ITEM_CLASS ( parent_class )->realize) (item);
e_canvas_item_request_reflow (item);
e_minicard_label->rect =
gnome_canvas_item_new ( group,
gnome_canvas_rect_get_type (),
"x1", (double) 0,
"y1", (double) 0,
"x2", (double) e_minicard_label->width - 1,
"y2", (double) e_minicard_label->height - 1,
"outline_color", NULL,
NULL );
e_minicard_label->fieldname =
gnome_canvas_item_new ( group,
e_text_get_type (),
"clip_width", (double) ( e_minicard_label->width / 2 - 4 ),
"clip", TRUE,
"use_ellipsis", TRUE,
"fill_color", "black",
"draw_background", FALSE,
"im_context", E_CANVAS (item->canvas)->im_context,
NULL );
e_canvas_item_move_absolute (e_minicard_label->fieldname, 2, 1);
e_minicard_label->field =
gnome_canvas_item_new ( group,
e_text_get_type (),
"clip_width", (double) ( ( e_minicard_label->width + 1 ) / 2 - 4 ),
"clip", TRUE,
"use_ellipsis", TRUE,
"fill_color", "black",
"editable", FALSE, /* e_minicard_label->editable, */
"draw_background", FALSE,
"im_context", E_CANVAS (item->canvas)->im_context,
NULL );
e_canvas_item_move_absolute (e_minicard_label->field, ( e_minicard_label->width / 2 + 2), 1);
set_colors (e_minicard_label);
e_canvas_item_request_reflow (item);
}
static void
gnc_header_realize (GnomeCanvasItem *item)
{
GncHeader *header = GNC_HEADER (item);
GdkWindow *window;
if (GNOME_CANVAS_ITEM_CLASS (parent_class)->realize)
GNOME_CANVAS_ITEM_CLASS (parent_class)->realize (item);
window = GTK_WIDGET (item->canvas)->window;
header->gc = gdk_gc_new (window);
}
static void
gnc_header_update (GnomeCanvasItem *item, double *affine,
ArtSVP *clip_path, int flags)
{
if (GNOME_CANVAS_ITEM_CLASS (parent_class)->update)
(*GNOME_CANVAS_ITEM_CLASS (parent_class)->update)
(item, affine, clip_path, flags);
item->x1 = 0;
item->y1 = 0;
item->x2 = (INT_MAX / 2) - 1;
item->y2 = (INT_MAX / 2) - 1;
}
static void
etcta_realize (GnomeCanvasItem *item)
{
ETableClickToAdd *etcta = E_TABLE_CLICK_TO_ADD (item);
create_rect_and_text (etcta);
e_canvas_item_move_absolute (etcta->text, 2, 2);
if (GNOME_CANVAS_ITEM_CLASS (e_table_click_to_add_parent_class)->realize)
(*GNOME_CANVAS_ITEM_CLASS (e_table_click_to_add_parent_class)->realize)(item);
e_canvas_item_request_reflow (item);
}
static void
gnucash_cursor_realize (GnomeCanvasItem *item)
{
GnucashCursor *cursor = GNUCASH_CURSOR (item);
GdkWindow *window;
if (GNOME_CANVAS_ITEM_CLASS (gnucash_cursor_parent_class)->realize)
(*GNOME_CANVAS_ITEM_CLASS
(gnucash_cursor_parent_class)->realize)(item);
window = GTK_WIDGET (item->canvas)->window;
cursor->gc = gdk_gc_new (window);
}
static gboolean
e_minicard_label_event (GnomeCanvasItem *item,
GdkEvent *event)
{
EMinicardLabel *e_minicard_label;
e_minicard_label = E_MINICARD_LABEL (item);
switch (event->type) {
case GDK_KEY_PRESS:
if (event->key.keyval == GDK_KEY_Escape) {
GnomeCanvasItem *parent;
e_text_cancel_editing (E_TEXT (e_minicard_label->field));
parent = GNOME_CANVAS_ITEM (e_minicard_label)->parent;
if (parent)
e_canvas_item_grab_focus (parent, FALSE);
}
break;
case GDK_FOCUS_CHANGE: {
GdkEventFocus *focus_event = (GdkEventFocus *) event;
e_minicard_label->has_focus = focus_event->in;
set_colors (e_minicard_label);
g_object_set (e_minicard_label->field,
"handle_popup", e_minicard_label->has_focus,
NULL);
break;
}
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
case GDK_MOTION_NOTIFY:
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY: {
gboolean return_val;
g_signal_emit_by_name(e_minicard_label->field, "event", event, &return_val);
return return_val;
}
default:
break;
}
if (GNOME_CANVAS_ITEM_CLASS ( parent_class )->event)
return (* GNOME_CANVAS_ITEM_CLASS ( parent_class )->event) (item, event);
else
return 0;
}
static void
gnucash_cursor_unrealize (GnomeCanvasItem *item)
{
GnucashCursor *cursor = GNUCASH_CURSOR (item);
if (cursor->gc != NULL)
{
g_object_unref (cursor->gc);
cursor->gc = NULL;
}
if (GNOME_CANVAS_ITEM_CLASS (gnucash_cursor_parent_class)->unrealize)
(*GNOME_CANVAS_ITEM_CLASS
(gnucash_cursor_parent_class)->unrealize)(item);
}
static void
gnc_header_class_init (GncHeaderClass *header_class)
{
GObjectClass *object_class = G_OBJECT_CLASS (header_class);
GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (header_class);
parent_class = g_type_class_peek_parent (header_class);
object_class->finalize = gnc_header_finalize;
object_class->get_property = gnc_header_get_property;
object_class->set_property = gnc_header_set_property;
g_object_class_install_property (object_class,
PROP_SHEET,
g_param_spec_object ("sheet",
"Sheet Value",
"Sheet Value",
GNUCASH_TYPE_SHEET,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_CURSOR_NAME,
g_param_spec_string ("cursor_name",
"Cursor Name",
"Cursor Name",
CURSOR_HEADER,
G_PARAM_READWRITE));
item_class->realize = gnc_header_realize;
item_class->unrealize = gnc_header_unrealize;
item_class->update = gnc_header_update;
item_class->draw = gnc_header_draw;
item_class->event = gnc_header_event;
item_class->point = gnc_header_point;
}
static void
relation_arrow_class_init (PlannerRelationArrowClass *klass)
{
GnomeCanvasItemClass *item_class;
GObjectClass *o_class;
parent_class = g_type_class_peek_parent (klass);
item_class = GNOME_CANVAS_ITEM_CLASS (klass);
o_class = G_OBJECT_CLASS (klass);
o_class->set_property = relation_arrow_set_property;
o_class->finalize = relation_arrow_finalize;
item_class->update = relation_arrow_update;
item_class->draw = relation_arrow_draw;
item_class->bounds = NULL;
item_class->point = relation_arrow_point;
/* Properties. */
g_object_class_install_property (o_class,
PROP_TYPE,
g_param_spec_enum ("type",
NULL,
NULL,
MRP_TYPE_RELATION_TYPE,
MRP_RELATION_FS,
G_PARAM_WRITABLE));
}
static void
etfci_unrealize (GnomeCanvasItem *item)
{
ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
if (etfci->font_desc)
pango_font_description_free (etfci->font_desc);
etfci->font_desc = NULL;
g_signal_handler_disconnect (item->canvas, etfci->drag_end_id);
etfci->drag_end_id = 0;
g_signal_handler_disconnect (item->canvas, etfci->drag_data_get_id);
etfci->drag_data_get_id = 0;
if (GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->unrealize)
(*GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->unrealize)(item);
}
static void
etfci_realize (GnomeCanvasItem *item)
{
ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
if (GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)-> realize)
(*GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->realize)(item);
if (!etfci->font_desc)
etfci_font_load (etfci);
etfci->drag_end_id = g_signal_connect (
item->canvas, "drag_end",
G_CALLBACK (etfci_drag_end), etfci);
etfci->drag_data_get_id = g_signal_connect (
item->canvas, "drag_data_get",
G_CALLBACK (etfci_drag_data_get), etfci);
e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (etfci));
}
static void
e_reflow_realize (GnomeCanvasItem *item)
{
EReflow *reflow;
GtkAdjustment *adjustment;
int count;
int i;
reflow = E_REFLOW (item);
if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->realize)
(* GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->realize) (item);
reflow->arrow_cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
reflow->default_cursor = gdk_cursor_new (GDK_LEFT_PTR);
count = reflow->count;
for(i = 0; i < count; i++) {
if (reflow->items[i])
gnome_canvas_item_set(reflow->items[i],
"width", reflow->column_width,
NULL);
}
set_empty(reflow);
reflow->need_reflow_columns = TRUE;
e_canvas_item_request_reflow(item);
adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
#if 0
connect_set_adjustment (reflow);
#endif
connect_adjustment (reflow, adjustment);
adjustment->step_increment = (reflow->column_width + E_REFLOW_FULL_GUTTER) / 2;
adjustment->page_increment = adjustment->page_size - adjustment->step_increment;
gtk_adjustment_changed(adjustment);
if (!item->canvas->aa) {
}
}
static void
gnucash_item_cursor_class_init (GnucashItemCursorClass *klass)
{
GnomeCanvasItemClass *item_class;
item_class = GNOME_CANVAS_ITEM_CLASS (klass);
gnucash_item_cursor_parent_class = g_type_class_peek_parent (klass);
/* GnomeCanvasItem method overrides */
item_class->draw = gnucash_item_cursor_draw;
}
static void
etfci_update (GnomeCanvasItem *item,
const cairo_matrix_t *i2c,
gint flags)
{
ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
gdouble x1, y1, x2, y2;
if (GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->update)
GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->update (
item, i2c, flags);
x1 = y1 = 0;
x2 = etfci->width;
y2 = etfci->height;
gnome_canvas_matrix_transform_rect (i2c, &x1, &y1, &x2, &y2);
if (item->x1 != x1 ||
item->y1 != y1 ||
item->x2 != x2 ||
item->y2 != y2)
{
gnome_canvas_request_redraw (
item->canvas, item->x1,
item->y1, item->x2, item->y2);
item->x1 = x1;
item->y1 = y1;
item->x2 = x2;
item->y2 = y2;
/* FIXME: Group Child bounds !? */
#if 0
gnome_canvas_group_child_bounds (
GNOME_CANVAS_GROUP (item->parent), item);
#endif
}
gnome_canvas_request_redraw (
item->canvas, item->x1, item->y1, item->x2, item->y2);
}
static void
gnc_header_unrealize (GnomeCanvasItem *item)
{
GncHeader *header = GNC_HEADER (item);
if (header->gc != NULL)
{
g_object_unref (header->gc);
header->gc = NULL;
}
if (header->resize_cursor != NULL)
gdk_cursor_unref (header->resize_cursor);
header->resize_cursor = NULL;
if (header->normal_cursor != NULL)
gdk_cursor_unref (header->normal_cursor);
header->normal_cursor = NULL;
if (GNOME_CANVAS_ITEM_CLASS (parent_class)->unrealize)
GNOME_CANVAS_ITEM_CLASS (parent_class)->unrealize (item);
}
static void
e_reflow_unrealize (GnomeCanvasItem *item)
{
EReflow *reflow;
reflow = E_REFLOW (item);
if (!item->canvas->aa) {
}
gdk_cursor_unref (reflow->arrow_cursor);
gdk_cursor_unref (reflow->default_cursor);
reflow->arrow_cursor = NULL;
reflow->default_cursor = NULL;
g_free (reflow->columns);
reflow->columns = NULL;
disconnect_set_adjustment (reflow);
disconnect_adjustment (reflow);
if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->unrealize)
(* GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->unrealize) (item);
}
static void
relation_arrow_update (GnomeCanvasItem *item,
double *affine,
ArtSVP *clip_path,
gint flags)
{
PlannerRelationArrow *arrow;
gdouble x1, y1, x2, y2;
arrow = PLANNER_RELATION_ARROW (item);
GNOME_CANVAS_ITEM_CLASS (parent_class)->update (item,
affine,
clip_path,
flags);
relation_arrow_get_bounds (arrow, &x1, &y1, &x2, &y2);
gnome_canvas_update_bbox (item, x1, y1, x2, y2);
}
static void
week_view_event_item_update (GnomeCanvasItem *item,
const cairo_matrix_t *i2c,
gint flags)
{
GnomeCanvasItemClass *canvas_item_class;
EWeekViewEventItem *event_item;
EWeekView *week_view;
GtkWidget *parent;
gint event_num, span_num;
gint span_x, span_y, span_w;
event_item = E_WEEK_VIEW_EVENT_ITEM (item);
parent = gtk_widget_get_parent (GTK_WIDGET (item->canvas));
g_return_if_fail (E_IS_WEEK_VIEW (parent));
week_view = E_WEEK_VIEW (parent);
/* Chain up to parent's update() method. */
canvas_item_class = GNOME_CANVAS_ITEM_CLASS (parent_class);
canvas_item_class->update (item, i2c, flags);
item->x1 = 0;
item->y1 = 0;
item->x2 = 0;
item->y2 = 0;
event_num = e_week_view_event_item_get_event_num (event_item);
span_num = e_week_view_event_item_get_span_num (event_item);
if (event_num != -1 && span_num != -1) {
if (e_week_view_get_span_position (
week_view, event_num, span_num,
&span_x, &span_y, &span_w)) {
item->x1 = span_x;
item->y1 = span_y;
item->x2 = span_x + span_w - 1;
item->y2 = span_y + week_view->row_height - 1;
}
}
}
static gboolean
e_minicard_view_event (GnomeCanvasItem *item,
GdkEvent *event)
{
EMinicardView *view;
guint event_button = 0;
view = E_MINICARD_VIEW (item);
switch (event->type) {
case GDK_2BUTTON_PRESS:
gdk_event_get_button (event, &event_button);
if (event_button == 1) {
gboolean editable;
g_object_get (view->adapter, "editable", &editable, NULL);
if (editable)
e_minicard_view_create_contact (view);
return TRUE;
}
case GDK_BUTTON_PRESS:
gdk_event_get_button (event, &event_button);
if (event_button == 3)
e_minicard_view_right_click (view, event);
break;
case GDK_KEY_PRESS:
if (((event->key.state & GDK_SHIFT_MASK) != 0 && event->key.keyval == GDK_KEY_F10) ||
((event->key.state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == 0 && event->key.keyval == GDK_KEY_Menu)) {
e_minicard_view_right_click (view, event);
}
break;
default:
break;
}
return GNOME_CANVAS_ITEM_CLASS (e_minicard_view_parent_class)->
event (item, event);
}
static void
gnucash_cursor_class_init (GnucashCursorClass *klass)
{
GObjectClass *object_class;
GnomeCanvasItemClass *item_class;
object_class = G_OBJECT_CLASS (klass);
item_class = GNOME_CANVAS_ITEM_CLASS (klass);
gnucash_cursor_parent_class = g_type_class_peek_parent (klass);
/* GObject method overrides */
object_class->set_property = gnucash_cursor_set_property;
object_class->get_property = gnucash_cursor_get_property;
/* GnomeCanvasItem method overrides */
item_class->realize = gnucash_cursor_realize;
item_class->unrealize = gnucash_cursor_unrealize;
/* properties */
g_object_class_install_property
(object_class,
PROP_SHEET,
g_param_spec_object ("sheet",
"Sheet Value",
"Sheet Value",
GNUCASH_TYPE_SHEET,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class,
PROP_GRID,
g_param_spec_object ("grid",
"Grid Value",
"Grid Value",
GNUCASH_TYPE_GRID,
G_PARAM_READWRITE));
}
static double
gnome_canvas_item_invoke_point (GnomeCanvasItem *item, double x, double y, int cx, int cy,
GnomeCanvasItem **actual_item)
{
#ifdef HACKISH_AFFINE
double i2w[6], w2c[6], i2c[6], c2i[6];
ArtPoint c, i;
#endif
#ifdef HACKISH_AFFINE
gnome_canvas_item_i2w_affine (item, i2w);
gnome_canvas_w2c_affine (item->canvas, w2c);
art_affine_multiply (i2c, i2w, w2c);
art_affine_invert (c2i, i2c);
c.x = cx;
c.y = cy;
art_affine_point (&i, &c, c2i);
x = i.x;
y = i.y;
#endif
return (* GNOME_CANVAS_ITEM_CLASS (GTK_OBJECT_GET_CLASS (item))->point) (
item, x, y, cx, cy, actual_item);
}
static gboolean
bst_canvas_source_event (GnomeCanvasItem *item,
GdkEvent *event)
{
BstCanvasSource *csource = BST_CANVAS_SOURCE (item);
gboolean handled = FALSE;
switch (event->type)
{
case GDK_BUTTON_PRESS:
if (!csource->in_move && event->button.button == 2)
{
GdkCursor *fleur = gdk_cursor_new (GDK_FLEUR);
if (gnome_canvas_item_grab (item,
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
fleur,
event->button.time) == 0)
{
gdouble x = event->button.x, y = event->button.y;
gnome_canvas_item_w2i (item, &x, &y);
csource->move_dx = x;
csource->move_dy = y;
csource->in_move = TRUE;
bse_item_group_undo (csource->source, "Move");
}
gdk_cursor_destroy (fleur);
handled = TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if (csource->in_move)
{
gdouble x = event->motion.x, y = event->motion.y;
gnome_canvas_item_w2i (item, &x, &y);
gnome_canvas_item_move (item, x - csource->move_dx, y - csource->move_dy);
GNOME_CANVAS_NOTIFY (item);
handled = TRUE;
}
else
{
guint channel;
const gchar *label = NULL, *prefix = NULL, *ident = NULL;
/* set i/o channel hints */
channel = bst_canvas_source_ichannel_at (csource, event->motion.x, event->motion.y);
if (channel != ~0)
{
label = bse_source_ichannel_label (csource->source, channel);
ident = bse_source_ichannel_ident (csource->source, channel);
prefix = _("Input");
}
else
{
channel = bst_canvas_source_ochannel_at (csource, event->motion.x, event->motion.y);
if (channel != ~0)
{
label = bse_source_ochannel_label (csource->source, channel);
ident = bse_source_ochannel_ident (csource->source, channel);
prefix = _("Output");
}
}
if (label)
gxk_status_printf (GXK_STATUS_IDLE_HINT, _("(Hint)"), "%s[%s]: %s", prefix, ident, label);
else
gxk_status_set (GXK_STATUS_IDLE_HINT, NULL, NULL);
}
break;
case GDK_BUTTON_RELEASE:
if (event->button.button == 2 && csource->in_move)
{
bse_item_ungroup_undo (csource->source);
csource->in_move = FALSE;
gnome_canvas_item_ungrab (item, event->button.time);
handled = TRUE;
}
break;
default:
break;
}
if (!handled && GNOME_CANVAS_ITEM_CLASS (bst_canvas_source_parent_class)->event)
handled = GNOME_CANVAS_ITEM_CLASS (bst_canvas_source_parent_class)->event (item, event);
return handled;
}
static void
e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags)
{
EReflow *reflow;
double x0, x1, y0, y1;
reflow = E_REFLOW (item);
if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->update)
GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->update (item, affine, clip_path, flags);
x0 = item->x1;
y0 = item->y1;
x1 = item->x2;
y1 = item->y2;
if ( x1 < x0 + reflow->width )
x1 = x0 + reflow->width;
if ( y1 < y0 + reflow->height )
y1 = y0 + reflow->height;
item->x2 = x1;
item->y2 = y1;
if (reflow->need_height_update) {
x0 = item->x1;
y0 = item->y1;
x1 = item->x2;
y1 = item->y2;
if ( x0 > 0 )
x0 = 0;
if ( y0 > 0 )
y0 = 0;
if ( x1 < E_REFLOW(item)->width )
x1 = E_REFLOW(item)->width;
if ( x1 < E_REFLOW(item)->height )
x1 = E_REFLOW(item)->height;
gnome_canvas_request_redraw(item->canvas, x0, y0, x1, y1);
reflow->need_height_update = FALSE;
} else if (reflow->need_column_resize) {
int x_rect, y_rect, width_rect, height_rect;
int start_line = e_reflow_pick_line(reflow,
gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas))->value);
gdouble running_width;
int i;
double column_width;
if ( reflow->previous_temp_column_width != -1 ) {
running_width = start_line * (reflow->column_width + E_REFLOW_FULL_GUTTER);
column_width = reflow->previous_temp_column_width;
running_width -= start_line * (column_width + E_REFLOW_FULL_GUTTER);
running_width += E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
y_rect = E_REFLOW_BORDER_WIDTH;
width_rect = E_REFLOW_DIVIDER_WIDTH;
height_rect = reflow->height - (E_REFLOW_BORDER_WIDTH * 2);
for ( i = 0; i < reflow->column_count; i++) {
x_rect = running_width;
gnome_canvas_request_redraw(item->canvas, x_rect, y_rect, x_rect + width_rect, y_rect + height_rect);
running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
}
}
if ( reflow->temp_column_width != -1 ) {
running_width = start_line * (reflow->column_width + E_REFLOW_FULL_GUTTER);
column_width = reflow->temp_column_width;
running_width -= start_line * (column_width + E_REFLOW_FULL_GUTTER);
running_width += E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
y_rect = E_REFLOW_BORDER_WIDTH;
width_rect = E_REFLOW_DIVIDER_WIDTH;
height_rect = reflow->height - (E_REFLOW_BORDER_WIDTH * 2);
for ( i = 0; i < reflow->column_count; i++) {
x_rect = running_width;
gnome_canvas_request_redraw(item->canvas, x_rect, y_rect, x_rect + width_rect, y_rect + height_rect);
running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
}
}
reflow->previous_temp_column_width = reflow->temp_column_width;
reflow->need_column_resize = FALSE;
}
}
static gboolean
e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
{
EReflow *reflow;
int return_val = FALSE;
reflow = E_REFLOW (item);
switch( event->type )
{
case GDK_KEY_PRESS:
return_val = e_selection_model_key_press(reflow->selection, (GdkEventKey *) event);
break;
#if 0
if (event->key.keyval == GDK_Tab ||
event->key.keyval == GDK_KP_Tab ||
event->key.keyval == GDK_ISO_Left_Tab) {
int i;
int count;
count = reflow->count;
for (i = 0; i < count; i++) {
int unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i);
GnomeCanvasItem *item = reflow->items[unsorted];
EFocus has_focus;
if (item) {
g_object_get(item,
"has_focus", &has_focus,
NULL);
if (has_focus) {
if (event->key.state & GDK_SHIFT_MASK) {
if (i == 0)
return FALSE;
i--;
} else {
if (i == count - 1)
return FALSE;
i++;
}
unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i);
if (reflow->items[unsorted] == NULL) {
reflow->items[unsorted] = e_reflow_model_incarnate (reflow->model, unsorted, GNOME_CANVAS_GROUP (reflow));
}
item = reflow->items[unsorted];
gnome_canvas_item_set(item,
"has_focus", (event->key.state & GDK_SHIFT_MASK) ? E_FOCUS_END : E_FOCUS_START,
NULL);
return TRUE;
}
}
}
}
#endif
case GDK_BUTTON_PRESS:
switch(event->button.button)
{
case 1:
{
GdkEventButton *button = (GdkEventButton *) event;
double n_x, max_x;
n_x = button->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(reflow->column_width + E_REFLOW_FULL_GUTTER));
max_x = E_REFLOW_BORDER_WIDTH;
max_x += (reflow->column_width + E_REFLOW_FULL_GUTTER) * reflow->column_count;
if ( button->y >= E_REFLOW_BORDER_WIDTH && button->y <= reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER && max_x > button->x ) {
/* don't allow to drag the first line*/
if (e_reflow_pick_line(reflow, button->x) == 0)
return TRUE;
reflow->which_column_dragged = e_reflow_pick_line(reflow, button->x);
reflow->start_x = reflow->which_column_dragged * (reflow->column_width + E_REFLOW_FULL_GUTTER) - E_REFLOW_DIVIDER_WIDTH / 2;
reflow->temp_column_width = reflow->column_width;
reflow->column_drag = TRUE;
gnome_canvas_item_grab (item,
GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
reflow->arrow_cursor,
button->time);
reflow->previous_temp_column_width = -1;
reflow->need_column_resize = TRUE;
gnome_canvas_item_request_update(item);
return TRUE;
}
}
break;
case 4:
{
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
gdouble new_value = adjustment->value;
new_value -= adjustment->step_increment;
gtk_adjustment_set_value(adjustment, new_value);
}
break;
case 5:
{
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
gdouble new_value = adjustment->value;
new_value += adjustment->step_increment;
if ( new_value > adjustment->upper - adjustment->page_size )
new_value = adjustment->upper - adjustment->page_size;
gtk_adjustment_set_value(adjustment, new_value);
}
break;
}
break;
case GDK_BUTTON_RELEASE:
if (reflow->column_drag) {
gdouble old_width = reflow->column_width;
GdkEventButton *button = (GdkEventButton *) event;
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
reflow->temp_column_width = reflow->column_width +
(button->x - reflow->start_x)/(reflow->which_column_dragged - e_reflow_pick_line(reflow, adjustment->value));
if ( reflow->temp_column_width < 50 )
reflow->temp_column_width = 50;
reflow->column_drag = FALSE;
if ( old_width != reflow->temp_column_width ) {
gtk_adjustment_set_value(adjustment, adjustment->value + e_reflow_pick_line(reflow, adjustment->value) * (reflow->temp_column_width - reflow->column_width));
reflow->column_width = reflow->temp_column_width;
adjustment->step_increment = (reflow->column_width + E_REFLOW_FULL_GUTTER) / 2;
adjustment->page_increment = adjustment->page_size - adjustment->step_increment;
gtk_adjustment_changed(adjustment);
e_reflow_resize_children(item);
e_canvas_item_request_reflow(item);
gnome_canvas_request_redraw(item->canvas, 0, 0, reflow->width, reflow->height);
column_width_changed (reflow);
}
reflow->need_column_resize = TRUE;
gnome_canvas_item_request_update(item);
gnome_canvas_item_ungrab (item, button->time);
return TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if (reflow->column_drag) {
double old_width = reflow->temp_column_width;
GdkEventMotion *motion = (GdkEventMotion *) event;
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
reflow->temp_column_width = reflow->column_width +
(motion->x - reflow->start_x)/(reflow->which_column_dragged - e_reflow_pick_line(reflow, adjustment->value));
if (reflow->temp_column_width < 50)
reflow->temp_column_width = 50;
if (old_width != reflow->temp_column_width) {
reflow->need_column_resize = TRUE;
gnome_canvas_item_request_update(item);
}
return TRUE;
} else {
GdkEventMotion *motion = (GdkEventMotion *) event;
double n_x, max_x;
n_x = motion->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(reflow->column_width + E_REFLOW_FULL_GUTTER));
max_x = E_REFLOW_BORDER_WIDTH;
max_x += (reflow->column_width + E_REFLOW_FULL_GUTTER) * reflow->column_count;
if ( motion->y >= E_REFLOW_BORDER_WIDTH && motion->y <= reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER && max_x > motion->x) {
if ( reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, reflow->arrow_cursor);
reflow->default_cursor_shown = FALSE;
}
} else
if ( ! reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, reflow->default_cursor);
reflow->default_cursor_shown = TRUE;
}
}
break;
case GDK_ENTER_NOTIFY:
if (!reflow->column_drag) {
GdkEventCrossing *crossing = (GdkEventCrossing *) event;
double n_x, max_x;
n_x = crossing->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(reflow->column_width + E_REFLOW_FULL_GUTTER));
max_x = E_REFLOW_BORDER_WIDTH;
max_x += (reflow->column_width + E_REFLOW_FULL_GUTTER) * reflow->column_count;
if ( crossing->y >= E_REFLOW_BORDER_WIDTH && crossing->y <= reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER && max_x > crossing->x) {
if ( reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, reflow->arrow_cursor);
reflow->default_cursor_shown = FALSE;
}
}
}
break;
case GDK_LEAVE_NOTIFY:
if (!reflow->column_drag) {
GdkEventCrossing *crossing = (GdkEventCrossing *) event;
double n_x;
n_x = crossing->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(reflow->column_width + E_REFLOW_FULL_GUTTER));
if ( !( crossing->y >= E_REFLOW_BORDER_WIDTH && crossing->y <= reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER ) ) {
if ( ! reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, reflow->default_cursor);
reflow->default_cursor_shown = TRUE;
}
}
}
break;
default:
break;
}
if (return_val)
return return_val;
else if (GNOME_CANVAS_ITEM_CLASS( e_reflow_parent_class )->event)
return (* GNOME_CANVAS_ITEM_CLASS( e_reflow_parent_class )->event) (item, event);
else
return FALSE;
}
static void
etcta_unrealize (GnomeCanvasItem *item)
{
if (GNOME_CANVAS_ITEM_CLASS (e_table_click_to_add_parent_class)->unrealize)
(*GNOME_CANVAS_ITEM_CLASS (e_table_click_to_add_parent_class)->unrealize)(item);
}
