static void
e_canvas_show_area (GnomeCanvas *canvas,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
GtkAdjustment *h, *v;
gint dx = 0, dy = 0;
gdouble page_size;
gdouble lower;
gdouble upper;
gdouble value;
g_return_if_fail (canvas != NULL);
g_return_if_fail (GNOME_IS_CANVAS (canvas));
h = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (h);
lower = gtk_adjustment_get_lower (h);
upper = gtk_adjustment_get_upper (h);
value = gtk_adjustment_get_value (h);
dx = compute_offset (x1, x2, value, value + page_size);
if (dx)
gtk_adjustment_set_value (h, CLAMP (value + dx, lower, upper - page_size));
v = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (v);
lower = gtk_adjustment_get_lower (v);
upper = gtk_adjustment_get_upper (v);
value = gtk_adjustment_get_value (v);
dy = compute_offset (y1, y2, value, value + page_size);
if (dy)
gtk_adjustment_set_value (v, CLAMP (value + dy, lower, upper - page_size));
}
static void
drag_begin_callback (GtkWidget *widget,
GdkDragContext *context,
gpointer data)
{
NemoIconContainer *container;
cairo_surface_t *surface;
double x1, y1, x2, y2, winx, winy;
int x_offset, y_offset;
int start_x, start_y;
container = NEMO_ICON_CONTAINER (widget);
start_x = container->details->dnd_info->drag_info.start_x +
gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (container)));
start_y = container->details->dnd_info->drag_info.start_y +
gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (container)));
/* create a pixmap and mask to drag with */
surface = nemo_icon_canvas_item_get_drag_surface (container->details->drag_icon->item);
/* compute the image's offset */
eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (container->details->drag_icon->item),
&x1, &y1, &x2, &y2);
eel_canvas_world_to_window (EEL_CANVAS (container),
x1, y1, &winx, &winy);
x_offset = start_x - winx;
y_offset = start_y - winy;
cairo_surface_set_device_offset (surface, -x_offset, -y_offset);
gtk_drag_set_icon_surface (context, surface);
cairo_surface_destroy (surface);
}
static void
nemo_icon_container_receive_dropped_icons (NemoIconContainer *container,
GdkDragContext *context,
int x, int y)
{
char *drop_target;
gboolean local_move_only;
double world_x, world_y;
gboolean icon_hit;
GdkDragAction action, real_action;
drop_target = NULL;
if (container->details->dnd_info->drag_info.selection_list == NULL) {
return;
}
real_action = gdk_drag_context_get_selected_action (context);
if (real_action == GDK_ACTION_ASK) {
/* FIXME bugzilla.gnome.org 42485: This belongs in FMDirectoryView, not here. */
/* Check for special case items in selection list */
if (nemo_drag_selection_includes_special_link (container->details->dnd_info->drag_info.selection_list)) {
/* We only want to move the trash */
action = GDK_ACTION_MOVE;
} else {
action = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;
}
real_action = nemo_drag_drop_action_ask (GTK_WIDGET (container), action);
}
if (real_action > 0) {
eel_canvas_window_to_world (EEL_CANVAS (container),
x + gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (container))),
y + gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (container))),
&world_x, &world_y);
drop_target = nemo_icon_container_find_drop_target (container,
context, x, y, &icon_hit, FALSE);
local_move_only = FALSE;
if (!icon_hit && real_action == GDK_ACTION_MOVE) {
/* we can just move the icon positions if the move ended up in
* the item's parent container
*/
local_move_only = nemo_icon_container_selection_items_local
(container, container->details->dnd_info->drag_info.selection_list);
}
if (local_move_only) {
handle_local_move (container, world_x, world_y);
} else {
handle_nonlocal_move (container, real_action, world_x, world_y, drop_target, icon_hit);
}
}
g_free (drop_target);
nemo_drag_destroy_selection_list (container->details->dnd_info->drag_info.selection_list);
container->details->dnd_info->drag_info.selection_list = NULL;
}
static void
cainteoir_document_view_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
CainteoirDocumentViewPrivate *priv = CAINTEOIR_DOCUMENT_VIEW_PRIVATE(object);
GtkScrollable *scroll = GTK_SCROLLABLE(priv->text_view);
switch (prop_id)
{
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
// GtkScrollable interface:
case PROP_HADJUSTMENT:
g_value_set_object(value, gtk_scrollable_get_hadjustment(scroll));
break;
case PROP_VADJUSTMENT:
g_value_set_object(value, gtk_scrollable_get_vadjustment(scroll));
break;
case PROP_HSCROLL_POLICY:
g_value_set_enum(value, gtk_scrollable_get_hscroll_policy(scroll));
break;
case PROP_VSCROLL_POLICY:
g_value_set_enum(value, gtk_scrollable_get_vscroll_policy(scroll));
break;
}
}
void
nemo_icon_dnd_begin_drag (NemoIconContainer *container,
GdkDragAction actions,
int button,
GdkEventMotion *event,
int start_x,
int start_y)
{
NemoIconDndInfo *dnd_info;
g_return_if_fail (NEMO_IS_ICON_CONTAINER (container));
g_return_if_fail (event != NULL);
dnd_info = container->details->dnd_info;
g_return_if_fail (dnd_info != NULL);
/* Notice that the event is in bin_window coordinates, because of
the way the canvas handles events.
*/
dnd_info->drag_info.start_x = start_x -
gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (container)));
dnd_info->drag_info.start_y = start_y -
gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (container)));
/* start the drag */
gtk_drag_begin (GTK_WIDGET (container),
dnd_info->drag_info.target_list,
actions,
button,
(GdkEvent *) event);
}
static void
get_adjustments (SoliPrintPreview *preview,
GtkAdjustment **hadj,
GtkAdjustment **vadj)
{
*hadj = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (preview->layout));
*vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (preview->layout));
}
GtkAdjustment *nsgtk_layout_get_hadjustment(GtkLayout *layout)
{
#if GTK_CHECK_VERSION(3,0,0)
return gtk_scrollable_get_hadjustment(GTK_SCROLLABLE(layout));
#else
return gtk_layout_get_hadjustment(layout);
#endif
}
static gboolean
scroll_layout (gpointer data)
{
GtkWidget *layout = data;
GtkAdjustment *adj;
adj = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
gtk_adjustment_set_value (adj, gtk_adjustment_get_value (adj) + 5.0);
return G_SOURCE_CONTINUE;
}
static void
canvas_widget_to_world (EelCanvas *canvas,
double widget_x, double widget_y,
double *world_x, double *world_y)
{
eel_canvas_window_to_world (canvas,
widget_x + gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas))),
widget_y + gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas))),
world_x, world_y);
}
static void
_gtk_text_handle_set_scrollable (GtkTextHandle *handle,
GtkScrollable *scrollable)
{
GtkTextHandlePrivate *priv;
priv = handle->priv;
if (priv->parent_scrollable)
{
if (priv->vadj)
{
g_signal_handlers_disconnect_by_data (priv->vadj, handle);
g_object_unref (priv->vadj);
priv->vadj = NULL;
}
if (priv->hadj)
{
g_signal_handlers_disconnect_by_data (priv->hadj, handle);
g_object_unref (priv->hadj);
priv->hadj = NULL;
}
g_object_remove_weak_pointer (G_OBJECT (priv->parent_scrollable), (gpointer *) &priv->parent_scrollable);
}
priv->parent_scrollable = scrollable;
if (scrollable)
{
g_object_add_weak_pointer (G_OBJECT (priv->parent_scrollable), (gpointer *) &priv->parent_scrollable);
priv->vadj = gtk_scrollable_get_vadjustment (scrollable);
priv->hadj = gtk_scrollable_get_hadjustment (scrollable);
if (priv->vadj)
{
g_object_ref (priv->vadj);
g_signal_connect (priv->vadj, "changed",
G_CALLBACK (adjustment_changed_cb), handle);
g_signal_connect (priv->vadj, "value-changed",
G_CALLBACK (adjustment_changed_cb), handle);
}
if (priv->hadj)
{
g_object_ref (priv->hadj);
g_signal_connect (priv->hadj, "changed",
G_CALLBACK (adjustment_changed_cb), handle);
g_signal_connect (priv->hadj, "value-changed",
G_CALLBACK (adjustment_changed_cb), handle);
}
}
}
/*
* More or less a copy of gtk_tree_view_clamp_column_visible.
*/
static void
tree_view_clamp_column_visible (GtkTreeView *tree_view,
GtkTreeViewColumn *column)
{
GtkAdjustment *hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (tree_view));
double hval = gtk_adjustment_get_value (hadjustment);
double hps = gtk_adjustment_get_page_size (hadjustment);
GtkWidget *button = gtk_tree_view_column_get_button (column);
GtkAllocation ba;
gtk_widget_get_allocation (button, &ba);
if (hval + hps < ba.x + ba.width)
gtk_adjustment_set_value (hadjustment,
ba.x + ba.width - hps);
else if (hval > ba.x)
gtk_adjustment_set_value (hadjustment, ba.x);
}
static void
canvas_rect_world_to_widget (EelCanvas *canvas,
EelDRect *world_rect,
EelIRect *widget_rect)
{
EelDRect window_rect;
GtkAdjustment *hadj, *vadj;
hadj = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));
eel_canvas_world_to_window (canvas,
world_rect->x0, world_rect->y0,
&window_rect.x0, &window_rect.y0);
eel_canvas_world_to_window (canvas,
world_rect->x1, world_rect->y1,
&window_rect.x1, &window_rect.y1);
widget_rect->x0 = (int) window_rect.x0 - gtk_adjustment_get_value (hadj);
widget_rect->y0 = (int) window_rect.y0 - gtk_adjustment_get_value (vadj);
widget_rect->x1 = (int) window_rect.x1 - gtk_adjustment_get_value (hadj);
widget_rect->y1 = (int) window_rect.y1 - gtk_adjustment_get_value (vadj);
}
static void
force_scroll_to_top (IdeSourceView *source_view)
{
GtkAdjustment *vadj;
GtkAdjustment *hadj;
gdouble lower;
/*
* FIXME:
*
* See the comment in gb_editor_view__buffer_changed_on_volume()
*/
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (source_view));
hadj = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (source_view));
lower = gtk_adjustment_get_lower (vadj);
gtk_adjustment_set_value (vadj, lower);
lower = gtk_adjustment_get_lower (hadj);
gtk_adjustment_set_value (hadj, lower);
}
gboolean
scroll_viewport (GtkWidget *viewport,
GdkFrameClock *frame_clock,
gpointer user_data)
{
static gint64 start_time;
gint64 now = gdk_frame_clock_get_frame_time (frame_clock);
gdouble elapsed;
GtkAdjustment *hadjustment, *vadjustment;
if (start_time == 0)
start_time = now;
elapsed = (now - start_time) / 1000000.;
hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (viewport));
vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (viewport));
set_adjustment_to_fraction (hadjustment, 0.5 + 0.5 * sin (elapsed));
set_adjustment_to_fraction (vadjustment, 0.5 + 0.5 * cos (elapsed));
return TRUE;
}
static gboolean
e_canvas_area_shown (GnomeCanvas *canvas,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
GtkAdjustment *h, *v;
gint dx = 0, dy = 0;
gdouble page_size;
gdouble lower;
gdouble upper;
gdouble value;
g_return_val_if_fail (canvas != NULL, FALSE);
g_return_val_if_fail (GNOME_IS_CANVAS (canvas), FALSE);
h = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (h);
lower = gtk_adjustment_get_lower (h);
upper = gtk_adjustment_get_upper (h);
value = gtk_adjustment_get_value (h);
dx = compute_offset (x1, x2, value, value + page_size);
if (CLAMP (value + dx, lower, upper - page_size) - value != 0)
return FALSE;
v = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (v);
lower = gtk_adjustment_get_lower (v);
upper = gtk_adjustment_get_upper (v);
value = gtk_adjustment_get_value (v);
dy = compute_offset (y1, y2, value, value + page_size);
if (CLAMP (value + dy, lower, upper - page_size) - value != 0)
return FALSE;
return TRUE;
}
/**
* gnm_cell_combo_view_popdown:
* @sov: #SheetObjectView
* @activate_time: event time
*
* Open the popup window associated with @sov
**/
void
gnm_cell_combo_view_popdown (SheetObjectView *sov, guint32 activate_time)
{
GocItem *view = GOC_ITEM (sov);
GnmPane *pane = GNM_PANE (view->canvas);
SheetControlGUI *scg = pane->simple.scg;
SheetObject *so = sheet_object_view_get_so (sov);
Sheet const *sheet = sheet_object_get_sheet (so);
GtkWidget *frame, *popup, *list, *container;
int root_x, root_y;
gboolean make_buttons = FALSE;
GtkTreePath *clip = NULL, *select = NULL;
GtkWindow *toplevel = wbcg_toplevel (scg_wbcg (scg));
GdkWindow *popup_window;
GdkDevice *device;
GnmRange const *merge;
popup = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_type_hint (GTK_WINDOW (popup), GDK_WINDOW_TYPE_HINT_COMBO);
gtk_window_group_add_window (gtk_window_get_group (toplevel), GTK_WINDOW (popup));
go_gtk_window_set_transient (toplevel, GTK_WINDOW (popup));
gtk_window_set_resizable (GTK_WINDOW (popup), FALSE);
gtk_window_set_decorated (GTK_WINDOW (popup), FALSE);
gtk_window_set_screen (GTK_WINDOW (popup),
gtk_widget_get_screen (GTK_WIDGET (toplevel)));
list = ccombo_create_list (GNM_CCOMBO_VIEW (sov), so, &clip, &select, &make_buttons);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list), FALSE);
g_object_set_data (G_OBJECT (list), SOV_ID, sov);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
#if 0
range_dump (&so->anchor.cell_bound, "");
g_printerr (" : so = %p, view = %p\n", so, view);
#endif
if (clip != NULL) {
GtkWidget *sw = gtk_scrolled_window_new (
gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (list)),
gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (list)));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
g_object_set_data_full (G_OBJECT (list),
"clip", clip,
(GDestroyNotify)gtk_tree_path_free);
gtk_container_add (GTK_CONTAINER (sw), list);
/*
* Do the sizing in a realize handler as newer versions of
* gtk+ give us zero sizes until then.
*/
g_signal_connect_after (list, "realize",
G_CALLBACK (cb_realize_treeview),
sw);
container = sw;
} else
container = list;
if (make_buttons) {
GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *button;
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (cb_ccombo_cancel_button), list);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 6);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (cb_ccombo_ok_button), list);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 6);
gtk_box_pack_start (GTK_BOX (vbox), container, FALSE, TRUE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6);
container = vbox;
}
gtk_container_add (GTK_CONTAINER (frame), container);
/* do the popup */
gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (pane)),
&root_x, &root_y);
if (sheet->text_is_rtl) {
GtkAllocation pa;
gtk_widget_get_allocation (GTK_WIDGET (pane), &pa);
root_x += pa.width;
root_x -= scg_colrow_distance_get (scg, TRUE,
pane->first.col,
so->anchor.cell_bound.start.col + 1);
} else
root_x += scg_colrow_distance_get (scg, TRUE,
pane->first.col,
so->anchor.cell_bound.start.col);
merge = gnm_sheet_merge_is_corner (sheet, &(so->anchor.cell_bound.start));
gtk_window_move (GTK_WINDOW (popup), root_x,
root_y + scg_colrow_distance_get
(scg, FALSE,
pane->first.row,
so->anchor.cell_bound.start.row +
((merge == NULL) ? 1 : range_height (merge))));
gtk_container_add (GTK_CONTAINER (popup), frame);
g_signal_connect (popup, "key_press_event",
G_CALLBACK (cb_ccombo_key_press), list);
g_signal_connect (popup, "button_press_event",
G_CALLBACK (cb_ccombo_button_press), list);
g_signal_connect_after (popup, "button_release_event",
G_CALLBACK (cb_ccombo_button_release), list);
g_signal_connect (list, "motion_notify_event",
G_CALLBACK (cb_ccombo_list_motion), list);
g_signal_connect (list, "button_press_event",
G_CALLBACK (cb_ccombo_list_button_press), popup);
gtk_widget_show_all (popup);
/* after we show the window setup the selection (showing the list
* clears the selection) */
if (select != NULL) {
gtk_tree_selection_select_path (
gtk_tree_view_get_selection (GTK_TREE_VIEW (list)),
select);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (list),
select, NULL, FALSE);
gtk_tree_path_free (select);
}
gtk_widget_grab_focus (popup);
gtk_widget_grab_focus (GTK_WIDGET (list));
ccombo_focus_change (GTK_WIDGET (list), TRUE);
popup_window = gtk_widget_get_window (popup);
device = gtk_get_current_event_device ();
if (0 == gdk_device_grab (device, popup_window,
GDK_OWNERSHIP_APPLICATION, TRUE,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
NULL, activate_time)) {
if (0 == gdk_device_grab (gdk_device_get_associated_device (device),
popup_window,
GDK_OWNERSHIP_APPLICATION, TRUE,
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK,
NULL, activate_time))
gtk_grab_add (popup);
else
gdk_device_ungrab (device, activate_time);
}
}
static void
create_layout (GtkWidget *vbox)
{
GtkAdjustment *hadjustment, *vadjustment;
GtkLayout *layout;
GtkWidget *layout_widget;
GtkWidget *scrolledwindow;
GtkWidget *button;
gchar buf[16];
gint i, j;
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_SHADOW_IN);
gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_CORNER_TOP_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), scrolledwindow, TRUE, TRUE, 0);
layout_widget = gtk_layout_new (NULL, NULL);
layout = GTK_LAYOUT (layout_widget);
gtk_container_add (GTK_CONTAINER (scrolledwindow), layout_widget);
/* We set step sizes here since GtkLayout does not set
* them itself.
*/
hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (layout));
gtk_adjustment_set_step_increment (hadjustment, 10.0);
gtk_adjustment_set_step_increment (vadjustment, 10.0);
gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (layout), hadjustment);
gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (layout), vadjustment);
gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
g_signal_connect (layout, "draw",
G_CALLBACK (layout_draw_handler),
NULL);
gtk_layout_set_size (layout, 1600, 128000);
for (i = 0 ; i < 16 ; i++)
for (j = 0 ; j < 16 ; j++)
{
g_snprintf (buf, sizeof (buf), "Button %d, %d", i, j);
if ((i + j) % 2)
button = gtk_button_new_with_label (buf);
else
button = gtk_label_new (buf);
gtk_layout_put (layout, button, j * 100, i * 100);
}
for (i = 16; i < 1280; i++)
{
g_snprintf (buf, sizeof (buf), "Button %d, %d", i, 0);
if (i % 2)
button = gtk_button_new_with_label (buf);
else
button = gtk_label_new (buf);
gtk_layout_put (layout, button, 0, i * 100);
}
layout_timeout = g_timeout_add (1000, scroll_layout, layout);
}
static gboolean
goc_canvas_draw (GtkWidget *widget, cairo_t *cr)
{
double x0, y0, x1, y1;
double ax0, ay0, ax1, ay1;
double clip_x1, clip_y1, clip_x2, clip_y2;
GocCanvas *canvas = GOC_CANVAS (widget);
GdkEventExpose *event = (GdkEventExpose *) gtk_get_current_event ();
GocCanvasPrivate *priv = (GocCanvasPrivate *) canvas->priv;
cairo_rectangle_list_t *l = cairo_copy_clip_rectangle_list (cr);
int i, x, y;
if (GOC_IS_ITEM (priv->invalidated_item) && priv->invalid_region) {
/* evaluate the cairo clipped region and compare with the saved one */
cairo_region_t *region;
cairo_rectangle_int_t rect[l->num_rectangles];
for (i= 0; i < l->num_rectangles; i++) {
rect[i].x = l->rectangles[i].x;
rect[i].y = l->rectangles[i].y;
rect[i].width = l->rectangles[i].width;
rect[i].height = l->rectangles[i].height;
}
region = cairo_region_create_rectangles (rect, l->num_rectangles);
if (cairo_region_equal (priv->invalid_region, region)) {
cairo_rectangle_list_destroy (l);
cairo_region_destroy (region);
/* looks like each time we call gtk_widget_queue_draw*,
the draw event is fired twice */
if (priv->done) {
priv->invalidated_item = NULL;
cairo_region_destroy (priv->invalid_region);
priv->invalid_region = NULL;
} else {
goc_item_draw (priv->invalidated_item, cr);
priv->done = TRUE;
}
return TRUE;
}
cairo_region_destroy (region);
}
x = gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas)));
y = gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas)));
cairo_translate (cr, -x, -y);
goc_item_get_bounds (GOC_ITEM (canvas->root),&x0, &y0, &x1, &y1);
for (i= 0; i < l->num_rectangles; i++) {
cairo_save (cr);
cairo_rectangle (cr, l->rectangles[i].x, l->rectangles[i].y,
l->rectangles[i].width, l->rectangles[i].height);
cairo_clip (cr);
clip_x1 = l->rectangles[i].x;
clip_y1 = l->rectangles[i].y;
clip_x2 = clip_x1 + l->rectangles[i].width;
clip_y2 = clip_y1 + l->rectangles[i].height;
if (canvas->direction == GOC_DIRECTION_RTL) {
ax1 = (double) (canvas->width - clip_x1) / canvas->pixels_per_unit + canvas->scroll_x1;
ax0 = (double) (canvas->width - clip_x2) / canvas->pixels_per_unit + canvas->scroll_x1;
} else {
ax0 = (double) clip_x1 / canvas->pixels_per_unit + canvas->scroll_x1;
ax1 = ((double) clip_x1 + event->area.width) / canvas->pixels_per_unit + canvas->scroll_x1;
}
ay0 = (double) clip_y1 / canvas->pixels_per_unit + canvas->scroll_y1;
ay1 = (double) clip_y2 / canvas->pixels_per_unit + canvas->scroll_y1;
if (x0 <= ax1 && x1 >= ax0 && y0 <= ay1 && y1 >= ay0) {
canvas->cur_event = (GdkEvent *) event;
goc_item_draw_region (GOC_ITEM (canvas->root), cr, ax0, ay0, ax1, ay1);
}
cairo_restore (cr);
}
cairo_rectangle_list_destroy (l);
return TRUE;
}
void
gnc_item_edit_show_popup (GncItemEdit *item_edit)
{
GtkToggleButton *toggle;
GtkAdjustment *vadj, *hadj;
GtkAllocation alloc;
GnucashSheet *sheet;
gint x, y, w, h;
gint y_offset, x_offset;
gint popup_x, popup_y;
gint popup_w = -1, popup_h = -1;
gint popup_max_width, popup_max_height;
gint view_width, view_height;
gint down_height, up_height;
gint sheet_width;
g_return_if_fail (item_edit != NULL);
g_return_if_fail (GNC_IS_ITEM_EDIT(item_edit));
if (!item_edit->is_popup)
return;
sheet = item_edit->sheet;
sheet_width = sheet->width;
gtk_widget_get_allocation (GTK_WIDGET (sheet), &alloc);
view_height = alloc.height;
view_width = alloc.width;
vadj = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(sheet));
hadj = gtk_scrollable_get_hadjustment(GTK_SCROLLABLE(sheet));
y_offset = gtk_adjustment_get_value(vadj);
x_offset = gtk_adjustment_get_value(hadj);
gnc_item_edit_get_pixel_coords (item_edit, &x, &y, &w, &h);
popup_x = x;
up_height = y - y_offset;
down_height = view_height - (up_height + h);
popup_max_height = MAX (up_height, down_height);
popup_max_width = sheet_width - popup_x + x_offset; // always pops to the right
if (item_edit->popup_get_height)
popup_h = item_edit->popup_get_height
(item_edit->popup_item, popup_max_height, h,
item_edit->popup_user_data);
if (item_edit->popup_autosize)
popup_w =
item_edit->popup_autosize (item_edit->popup_item,
popup_max_width,
item_edit->popup_user_data);
else
popup_w = 0;
// Adjust the popup_y point based on popping above or below
if (up_height > down_height)
popup_y = y - popup_h;
else
popup_y = y + h;
if (!gtk_widget_get_parent (item_edit->popup_item))
gtk_layout_put (GTK_LAYOUT(sheet), item_edit->popup_item, popup_x, popup_y);
gtk_widget_set_size_request (item_edit->popup_item, popup_w - 1, popup_h);
toggle = GTK_TOGGLE_BUTTON(item_edit->popup_toggle.tbutton);
if (!gtk_toggle_button_get_active (toggle))
{
block_toggle_signals (item_edit);
gtk_toggle_button_set_active (toggle, TRUE);
unblock_toggle_signals (item_edit);
}
// set the popup arrow direction up
item_edit->popup_toggle.arrow_down = FALSE;
if (item_edit->popup_set_focus)
item_edit->popup_set_focus (item_edit->popup_item,
item_edit->popup_user_data);
if (item_edit->popup_post_show)
item_edit->popup_post_show (item_edit->popup_item,
item_edit->popup_user_data);
if (item_edit->popup_get_width)
{
int popup_width;
popup_width = item_edit->popup_get_width
(item_edit->popup_item,
item_edit->popup_user_data);
if (popup_width > popup_w)
popup_width = popup_w;
if (popup_width > popup_max_width)
{
popup_x -= popup_width - popup_max_width;
popup_x = MAX (0, popup_x);
}
else
popup_x = x;
gtk_layout_move (GTK_LAYOUT(sheet), item_edit->popup_item, popup_x, popup_y);
}
}
