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);
}
static gint
e_minicard_view_drag_begin (EAddressbookReflowAdapter *adapter,
GdkEvent *event,
EMinicardView *view)
{
GdkDragContext *context;
GtkTargetList *target_list;
GdkDragAction actions = GDK_ACTION_MOVE | GDK_ACTION_COPY;
clear_drag_data (view);
view->drag_list = e_minicard_view_get_card_list (view);
target_list = gtk_target_list_new (drag_types, G_N_ELEMENTS (drag_types));
context = gtk_drag_begin (
GTK_WIDGET (GNOME_CANVAS_ITEM (view)->canvas),
target_list, actions, 1/*XXX */, event);
if (!view->canvas_drag_data_get_id)
view->canvas_drag_data_get_id = g_signal_connect (
GNOME_CANVAS_ITEM (view)->canvas, "drag_data_get",
G_CALLBACK (e_minicard_view_drag_data_get), view);
gtk_drag_set_icon_default (context);
return TRUE;
}
/* Starts the selection state in the icon text item */
static void
iti_start_selecting (GnomeIconTextItem *iti, int idx, guint32 event_time)
{
GnomeIconTextItemPrivate *priv;
GtkEditable *e;
GdkCursor *ibeam;
priv = iti->_priv;
e = GTK_EDITABLE (priv->entry);
gtk_editable_select_region (e, idx, idx);
gtk_editable_set_position (e, idx);
ibeam = gdk_cursor_new (GDK_XTERM);
gnome_canvas_item_grab (GNOME_CANVAS_ITEM (iti),
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
ibeam, event_time);
gdk_cursor_unref (ibeam);
gtk_editable_select_region (e, idx, idx);
priv->selecting = TRUE;
priv->selection_start = idx;
gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
g_signal_emit (iti, iti_signals[SELECTION_STARTED], 0);
}
void
ghack_map_cursor_to(GtkWidget *win, int x, int y, gpointer data)
{
GnomeCanvasGroup *group;
static GnomeCanvasRE *cursor = NULL;
double x1, y1, x2, y2;
float hp;
guint r, g, b;
x1 = x * ghack_glyph_width() - 1;
y1 = y * ghack_glyph_height() - 1;
x2 = x1 + ghack_glyph_width() + 2;
y2 = y1 + ghack_glyph_height() + 2;
hp = u.mtimedone ? (u.mhmax ? (float) u.mh / u.mhmax : 1)
: (u.uhpmax ? (float) u.uhp / u.uhpmax : 1);
r = 255;
g = (hp >= 0.75) ? 255 : (hp >= 0.25 ? 255 * 2 * (hp - 0.25) : 0);
b = (hp >= 0.75) ? 255 * 4 * (hp - 0.75)
: (hp >= 0.25 ? 0 : 255 * 4 * (0.25 - hp));
group = gnome_canvas_root(GNOME_CANVAS(ghack_map.canvas));
if (!cursor) {
cursor = GNOME_CANVAS_RE(gnome_canvas_item_new(
group, gnome_canvas_rect_get_type(), "width_units", 1.0, NULL));
}
gnome_canvas_item_set(GNOME_CANVAS_ITEM(cursor), "outline_color_rgba",
GNOME_CANVAS_COLOR(r, g, b), "x1", x1, "y1", y1,
"x2", x2, "y2", y2, NULL);
gnome_canvas_item_raise_to_top(GNOME_CANVAS_ITEM(cursor));
gnome_canvas_item_show(GNOME_CANVAS_ITEM(cursor));
}
void
ghack_map_print_glyph(GtkObject *win, guint x, guint y, GdkImlibImage *im,
gpointer data)
{
GnomeCanvasGroup *group;
int i = y * COLNO + x;
int glyph = glyph_at(x, y);
GnomeCanvasImage *canvas_image = GNOME_CANVAS_IMAGE(ghack_map.map[i]);
group = gnome_canvas_root(GNOME_CANVAS(ghack_map.canvas));
gnome_canvas_item_set(GNOME_CANVAS_ITEM(canvas_image), "image", im, NULL);
gnome_canvas_item_show(GNOME_CANVAS_ITEM(canvas_image));
canvas_image = GNOME_CANVAS_IMAGE(ghack_map.overlay[i]);
if (x == u.ux && y == u.uy)
ghack_map_cliparound(NULL, x, y, NULL);
if (glyph_is_pet(glyph)
#ifdef TEXTCOLOR
&& iflags.hilite_pet
#endif
) {
gnome_canvas_item_raise_to_top(GNOME_CANVAS_ITEM(canvas_image));
gnome_canvas_item_show(GNOME_CANVAS_ITEM(canvas_image));
} else {
gnome_canvas_item_hide(GNOME_CANVAS_ITEM(canvas_image));
}
}
static gboolean
gal_a11y_e_cell_grab_focus (AtkComponent *component)
{
GalA11yECell *a11y;
gint index;
GtkWidget *toplevel;
GalA11yETableItem *a11yTableItem;
a11y = GAL_A11Y_E_CELL (component);
/* for e_cell_vbox's children, we just grab the e_cell_vbox */
if (GAL_A11Y_IS_E_CELL_VBOX (a11y->parent)) {
return atk_component_grab_focus (ATK_COMPONENT (a11y->parent));
}
a11yTableItem = GAL_A11Y_E_TABLE_ITEM (a11y->parent);
index = atk_object_get_index_in_parent (ATK_OBJECT (a11y));
atk_selection_clear_selection (ATK_SELECTION (a11yTableItem));
atk_selection_add_selection (ATK_SELECTION (a11yTableItem), index);
gtk_widget_grab_focus (
GTK_WIDGET (GNOME_CANVAS_ITEM (a11y->item)->canvas));
toplevel = gtk_widget_get_toplevel (
GTK_WIDGET (GNOME_CANVAS_ITEM (a11y->item)->canvas));
if (toplevel && gtk_widget_is_toplevel (toplevel))
gtk_window_present (GTK_WINDOW (toplevel));
return TRUE;
}
static void
relation_arrow_predecessor_visibility_changed (PlannerGanttRow *row,
gboolean visible,
PlannerRelationArrow *arrow)
{
arrow->priv->predecessor_visible = visible;
if (!visible) {
gnome_canvas_item_hide (GNOME_CANVAS_ITEM (arrow));
} else if (arrow->priv->successor_visible) {
gnome_canvas_item_show (GNOME_CANVAS_ITEM (arrow));
}
}
static void
selection_changed(WireItem *item, gboolean select, gpointer user_data)
{
g_object_ref(G_OBJECT(item));
if (select) {
gtk_idle_add ((gpointer) select_idle_callback, item);
gnome_canvas_item_show (GNOME_CANVAS_ITEM (item->priv->resize1));
gnome_canvas_item_show (GNOME_CANVAS_ITEM (item->priv->resize2));
} else {
gtk_idle_add ((gpointer) deselect_idle_callback, item);
gnome_canvas_item_hide (GNOME_CANVAS_ITEM (item->priv->resize1));
gnome_canvas_item_hide (GNOME_CANVAS_ITEM (item->priv->resize2));
}
}
void
ghack_map_clear(GtkWidget *win, gpointer data)
{
int i;
for (i = 0; i < ROWNO * COLNO; i++) {
if (GNOME_IS_CANVAS_IMAGE(ghack_map.map[i])) {
gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ghack_map.map[i]));
}
if (GNOME_IS_CANVAS_IMAGE(ghack_map.overlay[i])) {
gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ghack_map.overlay[i]));
}
}
gnome_canvas_update_now(GNOME_CANVAS(ghack_map.canvas));
}
/* Stops the selection state in the icon text item */
static void
iti_stop_selecting (GnomeIconTextItem *iti, guint32 event_time)
{
GnomeIconTextItemPrivate *priv;
GnomeCanvasItem *item;
priv = iti->_priv;
item = GNOME_CANVAS_ITEM (iti);
gnome_canvas_item_ungrab (item, event_time);
priv->selecting = FALSE;
gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
g_signal_emit (iti, iti_signals[SELECTION_STOPPED], 0);
}
/* Recomputes the bounding box of an icon text item */
static void
recompute_bounding_box (GnomeIconTextItem *iti)
{
GnomeCanvasItem *item;
double x1, y1, x2, y2;
int width_c, height_c;
int width_w, height_w;
int max_width_w;
item = GNOME_CANVAS_ITEM (iti);
width_c = iti->_priv->layout_width + 2 * MARGIN_X;
height_c = iti->_priv->layout_height + 2 * MARGIN_Y;
width_w = ROUND (width_c / item->canvas->pixels_per_unit);
height_w = ROUND (height_c / item->canvas->pixels_per_unit);
max_width_w = ROUND (iti->width / item->canvas->pixels_per_unit);
x1 = iti->x;
y1 = iti->y;
gnome_canvas_item_i2w (item, &x1, &y1);
x1 += ROUND ((max_width_w - width_w) / 2);
x2 = x1 + width_w;
y2 = y1 + height_w;
gnome_canvas_w2c_d (item->canvas, x1, y1, &item->x1, &item->y1);
gnome_canvas_w2c_d (item->canvas, x2, y2, &item->x2, &item->y2);
}
static void
e_canvas_item_invoke_reflow (GnomeCanvasItem *item, int flags)
{
GnomeCanvasGroup *group;
GList *list;
GnomeCanvasItem *child;
if (GNOME_IS_CANVAS_GROUP (item)) {
group = GNOME_CANVAS_GROUP (item);
for (list = group->item_list; list; list = list->next) {
child = GNOME_CANVAS_ITEM (list->data);
if (child->object.flags & E_CANVAS_ITEM_DESCENDENT_NEEDS_REFLOW)
e_canvas_item_invoke_reflow (child, flags);
}
}
if (item->object.flags & E_CANVAS_ITEM_NEEDS_REFLOW) {
ECanvasItemReflowFunc func;
func = (ECanvasItemReflowFunc)
g_object_get_data (G_OBJECT (item),
"ECanvasItem::reflow_callback");
if (func)
func (item, flags);
}
item->object.flags &= ~E_CANVAS_ITEM_NEEDS_REFLOW;
item->object.flags &= ~E_CANVAS_ITEM_DESCENDENT_NEEDS_REFLOW;
}
static gboolean
gnc_date_cell_enter (BasicCell *bcell,
int *cursor_position,
int *start_selection,
int *end_selection)
{
DateCell *cell = (DateCell *) bcell;
PopBox *box = bcell->gui_private;
gnc_item_edit_set_popup (box->item_edit, GNOME_CANVAS_ITEM (box->date_picker),
get_popup_height, NULL, popup_set_focus,
NULL, NULL, NULL);
block_picker_signals (cell);
gnc_date_picker_set_date (box->date_picker,
box->date.tm_mday,
box->date.tm_mon,
box->date.tm_year + 1900);
unblock_picker_signals (cell);
date_picker_connect_signals ((DateCell *) bcell);
*start_selection = 0;
*end_selection = -1;
return TRUE;
}
/**
* e_table_group_container_construct
* @parent: The %GnomeCanvasGroup to create a child of.
* @etgc: The %ETableGroupContainer.
* @full_header: The full header of the %ETable.
* @header: The current header of the %ETable.
* @model: The %ETableModel of the %ETable.
* @sort_info: The %ETableSortInfo of the %ETable.
* @n: Which grouping level this is (Starts at 0 and sends n + 1 to any child %ETableGroups.
*
* This routine constructs the new %ETableGroupContainer.
*/
void
e_table_group_container_construct (GnomeCanvasGroup *parent, ETableGroupContainer *etgc,
ETableHeader *full_header,
ETableHeader *header,
ETableModel *model, ETableSortInfo *sort_info, int n)
{
ETableCol *col;
ETableSortColumn column = e_table_sort_info_grouping_get_nth(sort_info, n);
GtkStyle *style;
col = e_table_header_get_column_by_col_idx(full_header, column.column);
if (col == NULL)
col = e_table_header_get_column (full_header, e_table_header_count (full_header) - 1);
e_table_group_construct (parent, E_TABLE_GROUP (etgc), full_header, header, model);
etgc->ecol = col;
g_object_ref (etgc->ecol);
etgc->sort_info = sort_info;
g_object_ref (etgc->sort_info);
etgc->n = n;
etgc->ascending = column.ascending;
style = GTK_WIDGET (GNOME_CANVAS_ITEM (etgc)->canvas)->style;
etgc->font_desc = pango_font_description_copy (style->font_desc);
etgc->open = TRUE;
}
static gboolean
ea_addressbook_focus_watcher (GSignalInvocationHint *ihint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
GObject *object;
GdkEvent *event;
AtkObject *ea_event = NULL;
object = g_value_get_object (param_values + 0);
event = g_value_get_boxed (param_values + 1);
if (E_IS_MINICARD (object)) {
GnomeCanvasItem *item = GNOME_CANVAS_ITEM (object);
ea_event = atk_gobject_accessible_for_object (object);
if (event->type == GDK_FOCUS_CHANGE) {
if (E_IS_MINICARD (item->canvas->focused_item))
atk_object_notify_state_change (ea_event,
ATK_STATE_FOCUSED,
event->focus_change.in);
}
}
return TRUE;
}
static void
etcta_style_updated (ETableClickToAdd *etcta)
{
GtkWidget *widget;
GdkColor fg, bg, text;
widget = GTK_WIDGET (GNOME_CANVAS_ITEM (etcta)->canvas);
e_utils_get_theme_color_color (widget, "theme_fg_color", E_UTILS_DEFAULT_THEME_FG_COLOR, &fg);
e_utils_get_theme_color_color (widget, "theme_bg_color", E_UTILS_DEFAULT_THEME_BG_COLOR, &bg);
e_utils_get_theme_color_color (widget, "theme_text_color,theme_fg_color", E_UTILS_DEFAULT_THEME_TEXT_COLOR, &text);
if (etcta->rect)
gnome_canvas_item_set (
etcta->rect,
"outline_color_gdk", &fg,
"fill_color_gdk", &bg,
NULL);
if (etcta->text)
gnome_canvas_item_set (
etcta->text,
"fill_color_gdk", &text,
NULL);
}
static gboolean
week_view_event_item_button_release (EWeekViewEventItem *event_item,
GdkEvent *event)
{
EWeekView *week_view;
GnomeCanvasItem *item;
GtkWidget *parent;
item = GNOME_CANVAS_ITEM (event_item);
parent = gtk_widget_get_parent (GTK_WIDGET (item->canvas));
g_return_val_if_fail (E_IS_WEEK_VIEW (parent), FALSE);
week_view = E_WEEK_VIEW (parent);
if (week_view->pressed_event_num != -1
&& week_view->pressed_event_num == event_item->priv->event_num
&& week_view->pressed_span_num == event_item->priv->span_num) {
e_week_view_start_editing_event (week_view,
event_item->priv->event_num,
event_item->priv->span_num,
NULL);
week_view->pressed_event_num = -1;
return TRUE;
}
week_view->pressed_event_num = -1;
return FALSE;
}
static gboolean
do_adjustment (gpointer user_data)
{
int row;
GtkAdjustment *adj ;
gfloat value, min_value, max_value;
EReflow *reflow = user_data;
row = reflow->cursor_row;
if (row == -1)
return FALSE;
adj = gtk_layout_get_hadjustment (GTK_LAYOUT (GNOME_CANVAS_ITEM (reflow)->canvas));
value = adj->value;
if ((!reflow->items) || (!reflow->items[row]))
return TRUE;
min_value = reflow->items[row]->x2 - adj->page_size;
max_value = reflow->items[row]->x1;
if (value < min_value)
value = min_value;
if (value > max_value)
value = max_value;
if (value != adj->value) {
adj->value = value;
gtk_adjustment_value_changed (adj);
}
reflow->do_adjustment_idle_id = 0;
return FALSE;
}
void
gnucash_cursor_set (GnucashCursor *cursor, VirtualLocation virt_loc)
{
GnucashSheet *sheet;
g_return_if_fail (cursor != NULL);
g_return_if_fail (GNUCASH_IS_CURSOR (cursor));
sheet = cursor->sheet;
gnucash_cursor_request_redraw (cursor);
gnucash_cursor_set_block (cursor, virt_loc.vcell_loc);
gnucash_cursor_set_cell (cursor,
virt_loc.phys_row_offset,
virt_loc.phys_col_offset);
gnucash_cursor_configure (cursor);
gnome_canvas_item_set (GNOME_CANVAS_ITEM(sheet->header_item),
"cursor_name",
cursor->style->cursor->cursor_name,
NULL);
gnucash_cursor_request_redraw (cursor);
}
static gboolean
etgc_remove (ETableGroup *etg, gint row)
{
ETableGroupContainer *etgc = E_TABLE_GROUP_CONTAINER(etg);
GList *list;
for (list = etgc->children ; list; list = g_list_next (list)) {
ETableGroupContainerChildNode *child_node = list->data;
ETableGroup *child = child_node->child;
if (e_table_group_remove (child, row)) {
child_node->count --;
if (child_node->count == 0) {
e_table_group_container_child_node_free (etgc, child_node);
etgc->children = g_list_remove (etgc->children, child_node);
g_free (child_node);
} else
compute_text (etgc, child_node);
e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (etgc));
return TRUE;
}
}
return FALSE;
}
static ECalendarViewPosition
week_view_event_item_get_position (EWeekViewEventItem *event_item,
gdouble x,
gdouble y)
{
EWeekView *week_view;
GnomeCanvasItem *item;
GtkWidget *parent;
item = GNOME_CANVAS_ITEM (event_item);
parent = gtk_widget_get_parent (GTK_WIDGET (item->canvas));
g_return_val_if_fail (E_IS_WEEK_VIEW (parent), E_CALENDAR_VIEW_POS_NONE);
week_view = E_WEEK_VIEW (parent);
if (x < item->x1 + E_WEEK_VIEW_EVENT_L_PAD
|| x >= item->x2 - E_WEEK_VIEW_EVENT_R_PAD)
return E_CALENDAR_VIEW_POS_NONE;
/* Support left/right edge for long events only. */
if (!e_week_view_is_one_day_event (week_view, event_item->priv->event_num)) {
if (x < item->x1 + E_WEEK_VIEW_EVENT_L_PAD
+ E_WEEK_VIEW_EVENT_BORDER_WIDTH
+ E_WEEK_VIEW_EVENT_EDGE_X_PAD)
return E_CALENDAR_VIEW_POS_LEFT_EDGE;
if (x >= item->x2 + 1 - E_WEEK_VIEW_EVENT_R_PAD
- E_WEEK_VIEW_EVENT_BORDER_WIDTH
- E_WEEK_VIEW_EVENT_EDGE_X_PAD)
return E_CALENDAR_VIEW_POS_RIGHT_EDGE;
}
return E_CALENDAR_VIEW_POS_EVENT;
}
/* Hide the userlist if there are no users displayed */
void
greeter_item_ulist_check_show_userlist (void)
{
/*
* If there are no users,
* then hide the rectangle used to contain the userlist. The
* userlist-rect id allows a rectangle to be defined with alpha
* behind the userlist that also goes away when the list is empty.
*/
if (num_users == 0) {
GreeterItemInfo *urinfo = greeter_lookup_id ("userlist-rect");
if (user_list != NULL)
gtk_widget_hide (user_list);
if (urinfo) {
GnomeCanvasItem *item;
if (urinfo->group_item != NULL)
item = GNOME_CANVAS_ITEM (urinfo->group_item);
else
item = urinfo->item;
gnome_canvas_item_hide (item);
}
}
}
static void
create_rect_and_text (ETableClickToAdd *etcta)
{
GtkWidget *widget;
GdkColor fg, bg;
widget = GTK_WIDGET (GNOME_CANVAS_ITEM (etcta)->canvas);
e_utils_get_theme_color_color (widget, "theme_selected_fg_color", E_UTILS_DEFAULT_THEME_SELECTED_FG_COLOR, &fg);
e_utils_get_theme_color_color (widget, "theme_selected_bg_color", E_UTILS_DEFAULT_THEME_SELECTED_BG_COLOR, &bg);
if (!etcta->rect)
etcta->rect = gnome_canvas_item_new (
GNOME_CANVAS_GROUP (etcta),
gnome_canvas_rect_get_type (),
"x1", (gdouble) 0,
"y1", (gdouble) 1,
"x2", (gdouble) etcta->width,
"y2", (gdouble) etcta->height,
"fill_color_gdk", &bg,
NULL);
if (!etcta->text)
etcta->text = gnome_canvas_item_new (
GNOME_CANVAS_GROUP (etcta),
e_text_get_type (),
"text", etcta->message ? etcta->message : "",
"width", etcta->width - 4,
"fill_color_gdk", &fg,
NULL);
}
/* Accepts the text in the off-screen entry of an icon text item */
static void
iti_edition_accept (GnomeIconTextItem *iti)
{
GnomeIconTextItemPrivate *priv;
gboolean accept;
priv = iti->_priv;
accept = TRUE;
g_signal_emit (iti, iti_signals [TEXT_CHANGED], 0, &accept);
if (iti->editing){
if (accept) {
if (iti->is_text_allocated)
g_free (iti->text);
iti->text = g_strdup (gtk_entry_get_text (GTK_ENTRY(priv->entry)));
iti->is_text_allocated = 1;
}
iti_stop_editing (iti);
}
update_pango_layout (iti);
priv->need_text_update = TRUE;
gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
}
static void
etfci_reflow (GnomeCanvasItem *item,
gint flags)
{
ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
gdouble old_height;
gint i;
gint count;
gdouble height = 0;
etfci_rebuild_combined (etfci);
old_height = etfci->height;
count = e_table_header_count (etfci->combined_header);
for (i = 0; i < count; i++) {
ETableCol *ecol;
ecol = e_table_header_get_column (etfci->combined_header, i);
if (ecol->spec->disabled)
continue;
height += e_table_header_compute_height (
ecol, GTK_WIDGET (GNOME_CANVAS_ITEM (etfci)->canvas));
}
etfci->height = height;
if (old_height != etfci->height)
e_canvas_item_request_parent_reflow (item);
gnome_canvas_item_request_update (item);
}
static void
table_header_dimension_changed (ETableHeader *header,
gint col,
ETableFieldChooserItem *etfci)
{
e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (etfci));
}
static void
gnc_header_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GncHeader *header = GNC_HEADER (object);
GtkLayout *layout = GTK_LAYOUT (GNOME_CANVAS_ITEM (header)->canvas);
gboolean needs_update = FALSE;
gchar *old_name;
switch (param_id)
{
case PROP_SHEET:
header->sheet = GNUCASH_SHEET (g_value_get_object (value));
gtk_layout_set_hadjustment (layout, header->sheet->hadj);
needs_update = TRUE;
break;
case PROP_CURSOR_NAME:
old_name = header->cursor_name;
header->cursor_name = g_value_dup_string (value);
needs_update = !old_name || !header->cursor_name ||
strcmp (old_name, header->cursor_name) != 0;
g_free (old_name);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
if ((header->sheet != NULL) && needs_update)
gnc_header_reconfigure (header);
}
static void
etfci_start_drag (ETableFieldChooserItem *etfci,
GdkEvent *event,
gdouble x,
gdouble y)
{
GtkWidget *widget = GTK_WIDGET (GNOME_CANVAS_ITEM (etfci)->canvas);
GtkTargetList *list;
GdkDragContext *context;
ETableCol *ecol;
cairo_surface_t *cs;
cairo_t *cr;
gint drag_col;
gint button_height;
GtkTargetEntry etfci_drag_types[] = {
{ (gchar *) TARGET_ETABLE_COL_TYPE, 0, TARGET_ETABLE_COL_HEADER },
};
if (etfci->combined_header == NULL)
return;
drag_col = etfci_find_button (etfci, y);
if (drag_col < 0 || drag_col > e_table_header_count (etfci->combined_header))
return;
ecol = e_table_header_get_column (etfci->combined_header, drag_col);
if (ecol->spec->disabled)
return;
etfci->drag_col = ecol->spec->model_col;
etfci_drag_types[0].target = g_strdup_printf (
"%s-%s", etfci_drag_types[0].target, etfci->dnd_code);
d (g_print ("etfci - %s\n", etfci_drag_types[0].target));
list = gtk_target_list_new (etfci_drag_types, G_N_ELEMENTS (etfci_drag_types));
context = gtk_drag_begin (widget, list, GDK_ACTION_MOVE, 1, event);
g_free ((gpointer) etfci_drag_types[0].target);
button_height = e_table_header_compute_height (ecol, widget);
cs = cairo_image_surface_create (
CAIRO_FORMAT_ARGB32,
etfci->width, button_height);
cr = cairo_create (cs);
e_table_header_draw_button (
cr, ecol,
widget, 0, 0,
etfci->width, button_height,
etfci->width, button_height,
E_TABLE_COL_ARROW_NONE);
gtk_drag_set_icon_surface (context, cs);
cairo_surface_destroy (cs);
cairo_destroy (cr);
etfci->maybe_drag = FALSE;
}
static gboolean
idle_move_item (gpointer data)
{
BstCanvasSource *self = data;
GnomeCanvasItem *item = GNOME_CANVAS_ITEM (self);
GDK_THREADS_ENTER ();
if (self->source && item->canvas)
{
SfiReal x, y;
bse_proxy_get (self->source,
"pos-x", &x,
"pos-y", &y,
NULL);
x *= BST_CANVAS_SOURCE_PIXEL_SCALE;
y *= -BST_CANVAS_SOURCE_PIXEL_SCALE;
gnome_canvas_item_w2i (item, &x, &y);
g_object_freeze_notify (G_OBJECT (self));
gnome_canvas_item_move (item, x, y);
/* canvas notification bug workaround */
g_object_notify (self, "x");
g_object_notify (self, "y");
g_object_thaw_notify (G_OBJECT (self));
}
self->idle_reposition = FALSE;
g_object_unref (self);
GDK_THREADS_LEAVE ();
return FALSE;
}
static gboolean
idle_do_action (gpointer data)
{
GtkLayout *layout;
GdkEventButton event;
ETableClickToAdd * etcta;
gint finished;
g_return_val_if_fail (data!= NULL, FALSE);
etcta = E_TABLE_CLICK_TO_ADD (
atk_gobject_accessible_get_object (
ATK_GOBJECT_ACCESSIBLE (data)));
g_return_val_if_fail (etcta, FALSE);
layout = GTK_LAYOUT (GNOME_CANVAS_ITEM (etcta)->canvas);
event.x = 0;
event.y = 0;
event.type = GDK_BUTTON_PRESS;
event.window = gtk_layout_get_bin_window (layout);
event.button = 1;
event.send_event = TRUE;
event.time = GDK_CURRENT_TIME;
event.axes = NULL;
g_signal_emit_by_name (etcta, "event", &event, &finished);
return FALSE;
}
