/* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* * Gnumeric's extended canvas used to display a pane * * Author: * Miguel de Icaza (miguel@kernel.org) * Jody Goldberg (jody@gnome.org) */ #include #include #include "gnumeric.h" #include "gnm-pane-impl.h" #include "gnm-pane.h" #include "sheet-control-gui-priv.h" #include "gui-util.h" #include "gutils.h" #include "mstyle.h" #include "selection.h" #include "parse-util.h" #include "ranges.h" #include "sheet.h" #include "sheet-view.h" #include "application.h" #include "workbook-view.h" #include "wbc-gtk-impl.h" #include "workbook.h" #include "workbook-cmd-format.h" #include "commands.h" #include "cmd-edit.h" #include "clipboard.h" #include "sheet-filter-combo.h" #include "widgets/gnm-cell-combo-view.h" #include "item-bar.h" #include "item-cursor.h" #include "item-edit.h" #include "item-grid.h" #include "gnumeric-conf.h" #include #include #include #include #define SCROLL_LOCK_MASK GDK_MOD5_MASK typedef GocCanvasClass GnmPaneClass; static GocCanvasClass *parent_klass; static void cb_pane_popup_menu (GnmPane *pane); static void gnm_pane_clear_obj_size_tip (GnmPane *pane); static void gnm_pane_display_obj_size_tip (GnmPane *pane, GocItem *ctrl_pt); /* * For now, application/x-gnumeric is disabled. It handles neither * images nor graphs correctly. */ static GtkTargetEntry const drag_types_in[] = { {(char *) "GNUMERIC_SAME_PROC", GTK_TARGET_SAME_APP, 0}, /* {(char *) "application/x-gnumeric", 0, 0}, */ }; static GtkTargetEntry const drag_types_out[] = { {(char *) "GNUMERIC_SAME_PROC", GTK_TARGET_SAME_APP, 0}, {(char *) "application/x-gnumeric", 0, 0}, }; static gboolean gnm_pane_guru_key (WBCGtk const *wbcg, GdkEvent *event) { GtkWidget *entry, *guru = wbc_gtk_get_guru (wbcg); if (guru == NULL) return FALSE; entry = wbcg_get_entry_underlying (wbcg); gtk_widget_event (entry ? entry : guru, event); return TRUE; } static gboolean gnm_pane_object_key_press (GnmPane *pane, GdkEventKey *ev) { SheetControlGUI *scg = pane->simple.scg; SheetControl *sc = SHEET_CONTROL (scg); gboolean const shift = 0 != (ev->state & GDK_SHIFT_MASK); gboolean const control = 0 != (ev->state & GDK_CONTROL_MASK); gboolean const alt = 0 != (ev->state & GDK_MOD1_MASK); gboolean const symmetric = control && alt; double const delta = 1.0 / GOC_CANVAS (pane)->pixels_per_unit; switch (ev->keyval) { case GDK_KEY_Escape: scg_mode_edit (scg); gnm_app_clipboard_unant (); return TRUE; case GDK_KEY_BackSpace: /* Ick! */ case GDK_KEY_KP_Delete: case GDK_KEY_Delete: if (scg->selected_objects != NULL) { cmd_objects_delete (sc->wbc, go_hash_keys (scg->selected_objects), NULL); return TRUE; } sc_mode_edit (sc); break; case GDK_KEY_Tab: case GDK_KEY_ISO_Left_Tab: case GDK_KEY_KP_Tab: if ((scg_sheet (scg))->sheet_objects != NULL) { scg_object_select_next (scg, (ev->state & GDK_SHIFT_MASK) != 0); return TRUE; } break; case GDK_KEY_KP_Left: case GDK_KEY_Left: scg_objects_nudge (scg, pane, (alt ? 4 : (control ? 3 : 8)), -delta , 0, symmetric, shift); gnm_pane_display_obj_size_tip (pane, NULL); return TRUE; case GDK_KEY_KP_Right: case GDK_KEY_Right: scg_objects_nudge (scg, pane, (alt ? 4 : (control ? 3 : 8)), delta, 0, symmetric, shift); gnm_pane_display_obj_size_tip (pane, NULL); return TRUE; case GDK_KEY_KP_Up: case GDK_KEY_Up: scg_objects_nudge (scg, pane, (alt ? 6 : (control ? 1 : 8)), 0, -delta, symmetric, shift); gnm_pane_display_obj_size_tip (pane, NULL); return TRUE; case GDK_KEY_KP_Down: case GDK_KEY_Down: scg_objects_nudge (scg, pane, (alt ? 6 : (control ? 1 : 8)), 0, delta, symmetric, shift); gnm_pane_display_obj_size_tip (pane, NULL); return TRUE; default: break; } return FALSE; } static gboolean gnm_pane_key_mode_sheet (GnmPane *pane, GdkEventKey *kevent, gboolean allow_rangesel) { GdkEvent *event = (GdkEvent *)kevent; SheetControlGUI *scg = pane->simple.scg; SheetControl *sc = (SheetControl *) scg; SheetView *sv = sc->view; Sheet *sheet = sv->sheet; WBCGtk *wbcg = scg->wbcg; WorkbookControl * wbc = scg_wbc(scg); Workbook * wb = wb_control_get_workbook(wbc); gboolean delayed_movement = FALSE; gboolean jump_to_bounds; gboolean is_enter = FALSE; int first_tab_col; int state; void (*movefn) (SheetControlGUI *, int n, gboolean jump, gboolean horiz); gboolean transition_keys = gnm_conf_get_core_gui_editing_transitionkeys (); gboolean const end_mode = wbcg->last_key_was_end; GdkModifierType event_state; (void)gdk_event_get_state (event, &event_state); state = gnumeric_filter_modifiers (event_state); jump_to_bounds = (event_state & GDK_CONTROL_MASK) != 0; /* Update end-mode for magic end key stuff. */ if (kevent->keyval != GDK_KEY_End && kevent->keyval != GDK_KEY_KP_End) wbcg_set_end_mode (wbcg, FALSE); if (allow_rangesel) movefn = (event_state & GDK_SHIFT_MASK) ? scg_rangesel_extend : scg_rangesel_move; else movefn = (event_state & GDK_SHIFT_MASK) ? scg_cursor_extend : scg_cursor_move; switch (kevent->keyval) { case GDK_KEY_a: scg_select_all (scg); break; case GDK_KEY_KP_Left: case GDK_KEY_Left: if (event_state & GDK_MOD1_MASK) return TRUE; /* Alt is used for accelerators */ if (event_state & SCROLL_LOCK_MASK) scg_set_left_col (scg, pane->first.col - 1); else if (transition_keys && jump_to_bounds) { delayed_movement = TRUE; scg_queue_movement (scg, movefn, -(pane->last_visible.col - pane->first.col), FALSE, TRUE); } else (*movefn) (scg, sheet->text_is_rtl ? 1 : -1, jump_to_bounds || end_mode, TRUE); break; case GDK_KEY_KP_Right: case GDK_KEY_Right: if (event_state & GDK_MOD1_MASK) return TRUE; /* Alt is used for accelerators */ if (event_state & SCROLL_LOCK_MASK) scg_set_left_col (scg, pane->first.col + 1); else if (transition_keys && jump_to_bounds) { delayed_movement = TRUE; scg_queue_movement (scg, movefn, pane->last_visible.col - pane->first.col, FALSE, TRUE); } else (*movefn) (scg, sheet->text_is_rtl ? -1 : 1, jump_to_bounds || end_mode, TRUE); break; case GDK_KEY_KP_Up: case GDK_KEY_Up: if (event_state & SCROLL_LOCK_MASK) scg_set_top_row (scg, pane->first.row - 1); else if (transition_keys && jump_to_bounds) { delayed_movement = TRUE; scg_queue_movement (scg, movefn, -(pane->last_visible.row - pane->first.row), FALSE, FALSE); } else (*movefn) (scg, -1, jump_to_bounds || end_mode, FALSE); break; case GDK_KEY_KP_Down: case GDK_KEY_Down: if (gnumeric_filter_modifiers (event_state) == GDK_MOD1_MASK) { /* 1) Any in cell combos ? */ SheetObject *so = sv_wbv (sv)->in_cell_combo; /* 2) How about any autofilters ? */ if (NULL == so) { GnmRange r; GSList *objs = sheet_objects_get (sheet, range_init_cellpos (&r, &sv->edit_pos), GNM_FILTER_COMBO_TYPE); if (objs != NULL) so = objs->data, g_slist_free (objs); } if (NULL != so) { SheetObjectView *sov = sheet_object_get_view (so, (SheetObjectViewContainer *)pane); gnm_cell_combo_view_popdown (sov, gdk_event_get_time (event)); break; } } if (event_state & SCROLL_LOCK_MASK) scg_set_top_row (scg, pane->first.row + 1); else if (transition_keys && jump_to_bounds) { delayed_movement = TRUE; scg_queue_movement (scg, movefn, pane->last_visible.row - pane->first.row, FALSE, FALSE); } else (*movefn) (scg, 1, jump_to_bounds || end_mode, FALSE); break; case GDK_KEY_KP_Page_Up: case GDK_KEY_Page_Up: if (event_state & GDK_CONTROL_MASK) { if (event_state & GDK_SHIFT_MASK) { WorkbookSheetState * old_state = workbook_sheet_state_new(wb); int old_pos = sheet->index_in_wb; if (old_pos > 0){ workbook_sheet_move(sheet, -1); cmd_reorganize_sheets (wbc, old_state, sheet); } } else { gnm_notebook_prev_page (wbcg->bnotebook); } } else if ((event_state & GDK_MOD1_MASK) == 0) { delayed_movement = TRUE; scg_queue_movement (scg, movefn, -(pane->last_visible.row - pane->first.row), FALSE, FALSE); } else { delayed_movement = TRUE; scg_queue_movement (scg, movefn, -(pane->last_visible.col - pane->first.col), FALSE, TRUE); } break; case GDK_KEY_KP_Page_Down: case GDK_KEY_Page_Down: if ((event_state & GDK_CONTROL_MASK) != 0){ if ((event_state & GDK_SHIFT_MASK) != 0){ WorkbookSheetState * old_state = workbook_sheet_state_new(wb); int num_sheets = workbook_sheet_count(wb); gint old_pos = sheet->index_in_wb; if (old_pos < num_sheets - 1){ workbook_sheet_move(sheet, 1); cmd_reorganize_sheets (wbc, old_state, sheet); } } else { gnm_notebook_next_page (wbcg->bnotebook); } } else if ((event_state & GDK_MOD1_MASK) == 0) { delayed_movement = TRUE; scg_queue_movement (scg, movefn, pane->last_visible.row - pane->first.row, FALSE, FALSE); } else { delayed_movement = TRUE; scg_queue_movement (scg, movefn, pane->last_visible.col - pane->first.col, FALSE, TRUE); } break; case GDK_KEY_KP_Home: case GDK_KEY_Home: if (event_state & SCROLL_LOCK_MASK) { scg_set_left_col (scg, sv->edit_pos.col); scg_set_top_row (scg, sv->edit_pos.row); } else if (end_mode) { /* Same as ctrl-end. */ GnmRange r = sheet_get_extent (sheet, FALSE, TRUE); (*movefn) (scg, r.end.col - sv->edit_pos.col, FALSE, TRUE); (*movefn)(scg, r.end.row - sv->edit_pos.row, FALSE, FALSE); } else { /* do the ctrl-home jump to A1 in 2 steps */ (*movefn)(scg, -gnm_sheet_get_max_cols (sheet), FALSE, TRUE); if ((event_state & GDK_CONTROL_MASK) || transition_keys) (*movefn)(scg, -gnm_sheet_get_max_rows (sheet), FALSE, FALSE); } break; case GDK_KEY_KP_End: case GDK_KEY_End: if (event_state & SCROLL_LOCK_MASK) { int new_col = sv->edit_pos.col - (pane->last_full.col - pane->first.col); int new_row = sv->edit_pos.row - (pane->last_full.row - pane->first.row); scg_set_left_col (scg, new_col); scg_set_top_row (scg, new_row); } else if ((event_state & GDK_CONTROL_MASK)) { GnmRange r = sheet_get_extent (sheet, FALSE, TRUE); /* do the ctrl-end jump to the extent in 2 steps */ (*movefn)(scg, r.end.col - sv->edit_pos.col, FALSE, TRUE); (*movefn)(scg, r.end.row - sv->edit_pos.row, FALSE, FALSE); } else /* toggle end mode */ wbcg_set_end_mode (wbcg, !end_mode); break; case GDK_KEY_KP_Insert : case GDK_KEY_Insert : if (gnm_pane_guru_key (wbcg, event)) break; if (state == GDK_CONTROL_MASK) sv_selection_copy (sv, WORKBOOK_CONTROL (wbcg)); else if (state == GDK_SHIFT_MASK) cmd_paste_to_selection (WORKBOOK_CONTROL (wbcg), sv, PASTE_DEFAULT); break; case GDK_KEY_BackSpace: if (wbcg_is_editing (wbcg)) goto forward; else if (!wbcg_is_editing (wbcg) && (event_state & GDK_CONTROL_MASK) != 0) { /* Re-center the view on the active cell */ scg_make_cell_visible (scg, sv->edit_pos.col, sv->edit_pos.row, FALSE, TRUE); break; } /* Fall through */ case GDK_KEY_KP_Delete: case GDK_KEY_Delete: if (wbcg_is_editing (wbcg)) { /* stop auto-completion. then do a quick and cheesy update */ wbcg_auto_complete_destroy (wbcg); SCG_FOREACH_PANE (scg, pane, { if (pane->editor) goc_item_invalidate (GOC_ITEM (pane->editor)); }); return TRUE; } if (gnm_pane_guru_key (wbcg, event)) break; if (state == GDK_SHIFT_MASK) { scg_mode_edit (scg); sv_selection_cut (sv, WORKBOOK_CONTROL (wbcg)); } else cmd_selection_clear (WORKBOOK_CONTROL (wbcg), CLEAR_VALUES); break; /* * NOTE : Keep these in sync with the condition * for tabs. */ case GDK_KEY_KP_Enter: case GDK_KEY_Return: if (wbcg_is_editing (wbcg) && (state == GDK_CONTROL_MASK || state == (GDK_CONTROL_MASK|GDK_SHIFT_MASK) || gnumeric_filter_modifiers (event_state) == GDK_MOD1_MASK)) /* Forward the keystroke to the input line */ return gtk_widget_event ( wbcg_get_entry_underlying (wbcg), (GdkEvent *) event); is_enter = TRUE; /* fall down */ case GDK_KEY_Tab: case GDK_KEY_ISO_Left_Tab: case GDK_KEY_KP_Tab: if (gnm_pane_guru_key (wbcg, event)) break; /* Be careful to restore the editing sheet if we are editing */ if (wbcg_is_editing (wbcg)) sheet = wbcg->editing_sheet; /* registering the cmd clears it, restore it afterwards */ first_tab_col = sv->first_tab_col; if (wbcg_edit_finish (wbcg, WBC_EDIT_ACCEPT, NULL)) { GODirection dir = gnm_conf_get_core_gui_editing_enter_moves_dir (); sv->first_tab_col = first_tab_col; if ((event_state & GDK_MOD1_MASK) && (event_state & GDK_CONTROL_MASK) && !is_enter) { if (event_state & GDK_SHIFT_MASK) workbook_cmd_dec_indent (sc->wbc); else workbook_cmd_inc_indent (sc->wbc); } else if (!is_enter || dir != GO_DIRECTION_NONE) { gboolean forward = TRUE; gboolean horizontal = TRUE; if (is_enter) { horizontal = go_direction_is_horizontal (dir); forward = go_direction_is_forward (dir); } else if ((event_state & GDK_CONTROL_MASK) && ((sc_sheet (sc))->sheet_objects != NULL)) { scg_object_select_next (scg, (event_state & GDK_SHIFT_MASK) != 0); break; } if (event_state & GDK_SHIFT_MASK) forward = !forward; sv_selection_walk_step (sv, forward, horizontal); /* invalidate, in case Enter direction changes */ if (is_enter) sv->first_tab_col = -1; } } break; case GDK_KEY_Escape: wbcg_edit_finish (wbcg, WBC_EDIT_REJECT, NULL); gnm_app_clipboard_unant (); break; case GDK_KEY_F4: if (wbcg_is_editing (wbcg)) return gtk_widget_event ( wbcg_get_entry_underlying (wbcg), (GdkEvent *) event); return TRUE; case GDK_KEY_F2: if (gnm_pane_guru_key (wbcg, event)) break; if (wbcg_is_editing (wbcg)) { GtkWidget *entry = (GtkWidget *) wbcg_get_entry (wbcg); GtkWindow *top = wbcg_toplevel (wbcg); if (entry != gtk_window_get_focus (top)) { gtk_window_set_focus (top, entry); return TRUE; } } if (!wbcg_edit_start (wbcg, FALSE, FALSE)) return FALSE; /* attempt to edit failed */ /* fall through */ default: if (!wbcg_is_editing (wbcg)) { if ((event_state & (GDK_MOD1_MASK|GDK_CONTROL_MASK)) != 0) return FALSE; /* If the character is not printable do not start editing */ if (kevent->length == 0) return FALSE; if (!wbcg_edit_start (wbcg, TRUE, TRUE)) return FALSE; /* attempt to edit failed */ } scg_rangesel_stop (scg, FALSE); forward: /* Forward the keystroke to the input line */ return gtk_widget_event (wbcg_get_entry_underlying (wbcg), (GdkEvent *) event); } if (!delayed_movement) { if (wbcg_is_editing (wbcg)) sheet_update_only_grid (sheet); else sheet_update (sheet); } return TRUE; } static gboolean gnm_pane_colrow_key_press (SheetControlGUI *scg, GdkEventKey *event, gboolean allow_rangesel) { SheetControl *sc = (SheetControl *) scg; SheetView *sv = sc->view; GnmRange target; if (allow_rangesel) { if (scg->rangesel.active) target = scg->rangesel.displayed; else target.start = target.end = sv->edit_pos_real; } else { GnmRange const *r = selection_first_range (sv, NULL, NULL); if (NULL == r) return FALSE; target = *r; } if (event->state & GDK_SHIFT_MASK) { if (event->state & GDK_CONTROL_MASK) /* full sheet */ /* TODO : How to handle ctrl-A too ? */ range_init_full_sheet (&target, sv->sheet); else { /* full row */ target.start.col = 0; target.end.col = gnm_sheet_get_last_col (sv->sheet); } } else if (event->state & GDK_CONTROL_MASK) { /* full col */ target.start.row = 0; target.end.row = gnm_sheet_get_last_row (sv->sheet); } else return FALSE; /* Accept during rangesel */ if (allow_rangesel) scg_rangesel_bound (scg, target.start.col, target.start.row, target.end.col, target.end.row); /* actually want the ctrl/shift space keys handled by the input module * filters during an edit */ else if (!wbcg_is_editing (scg->wbcg)) sv_selection_set (sv, &sv->edit_pos, target.start.col, target.start.row, target.end.col, target.end.row); else return FALSE; return TRUE; } static gint gnm_pane_key_press (GtkWidget *widget, GdkEventKey *event) { GnmPane *pane = GNM_PANE (widget); SheetControlGUI *scg = pane->simple.scg; gboolean allow_rangesel; switch (event->keyval) { case GDK_KEY_Shift_L: case GDK_KEY_Shift_R: case GDK_KEY_Alt_L: case GDK_KEY_Alt_R: case GDK_KEY_Control_L: case GDK_KEY_Control_R: return (*GTK_WIDGET_CLASS (parent_klass)->key_press_event) (widget, event); } /* Object manipulation */ if (scg->selected_objects != NULL || scg->wbcg->new_object != NULL) { if (wbc_gtk_get_guru (scg->wbcg) == NULL && gnm_pane_object_key_press (pane, event)) return TRUE; } /* handle grabs after object keys to allow Esc to cancel, and arrows to * fine tune position even while dragging */ if (scg->grab_stack > 0) return TRUE; allow_rangesel = wbcg_rangesel_possible (scg->wbcg); /* handle ctrl/shift space before input-method filter steals it */ if (event->keyval == GDK_KEY_space && gnm_pane_colrow_key_press (scg, event, allow_rangesel)) return TRUE; pane->insert_decimal = event->keyval == GDK_KEY_KP_Decimal || event->keyval == GDK_KEY_KP_Separator; if (gtk_im_context_filter_keypress (pane->im_context, event)) return TRUE; gtk_im_context_reset (pane->im_context); if (gnm_pane_key_mode_sheet (pane, event, allow_rangesel)) return TRUE; return (*GTK_WIDGET_CLASS (parent_klass)->key_press_event) (widget, event); } static gint gnm_pane_key_release (GtkWidget *widget, GdkEventKey *event) { GnmPane *pane = GNM_PANE (widget); SheetControl *sc = (SheetControl *) pane->simple.scg; if (pane->simple.scg->grab_stack > 0) return TRUE; if (gtk_im_context_filter_keypress (pane->im_context, event)) return TRUE; /* * The status_region normally displays the current edit_pos * When we extend the selection it changes to displaying the size of * the selected region while we are selecting. When the shift key * is released, or the mouse button is release we need to reset * to displaying the edit pos. */ if (pane->simple.scg->selected_objects == NULL && (event->keyval == GDK_KEY_Shift_L || event->keyval == GDK_KEY_Shift_R)) wb_view_selection_desc (wb_control_view (sc->wbc), TRUE, NULL); return (*GTK_WIDGET_CLASS (parent_klass)->key_release_event) (widget, event); } static gint gnm_pane_focus_in (GtkWidget *widget, GdkEventFocus *event) { GnmPane *pane = GNM_PANE (widget); gtk_im_context_focus_in (pane->im_context); return (*GTK_WIDGET_CLASS (parent_klass)->focus_in_event) (widget, event); } static gint gnm_pane_focus_out (GtkWidget *widget, GdkEventFocus *event) { gnm_pane_clear_obj_size_tip (GNM_PANE (widget)); gtk_im_context_focus_out (GNM_PANE (widget)->im_context); return (*GTK_WIDGET_CLASS (parent_klass)->focus_out_event) (widget, event); } static void gnm_pane_realize (GtkWidget *w) { if (GTK_WIDGET_CLASS (parent_klass)->realize) (*GTK_WIDGET_CLASS (parent_klass)->realize) (w); gtk_im_context_set_client_window (GNM_PANE (w)->im_context, gtk_widget_get_window (gtk_widget_get_toplevel (w))); } static void gnm_pane_unrealize (GtkWidget *widget) { GnmPane *pane; pane = GNM_PANE (widget); g_return_if_fail (pane != NULL); if (pane->im_context) { gtk_im_context_set_client_window (pane->im_context, NULL); } (*GTK_WIDGET_CLASS (parent_klass)->unrealize)(widget); } static void gnm_pane_size_allocate (GtkWidget *w, GtkAllocation *allocation) { GnmPane *pane = GNM_PANE (w); (*GTK_WIDGET_CLASS (parent_klass)->size_allocate) (w, allocation); gnm_pane_compute_visible_region (pane, TRUE); } static GtkEditable * gnm_pane_get_editable (GnmPane const *pane) { GnmExprEntry *gee = wbcg_get_entry_logical (pane->simple.scg->wbcg); GtkEntry *entry = gnm_expr_entry_get_entry (gee); return GTK_EDITABLE (entry); } static void cb_gnm_pane_commit (GtkIMContext *context, char const *str, GnmPane *pane) { gint tmp_pos, length; WBCGtk *wbcg = pane->simple.scg->wbcg; GtkEditable *editable = gnm_pane_get_editable (pane); if (!wbcg_is_editing (wbcg) && !wbcg_edit_start (wbcg, TRUE, TRUE)) return; if (pane->insert_decimal) { GString const *s = go_locale_get_decimal (); str = s->str; length = s->len; } else length = strlen (str); if (gtk_editable_get_selection_bounds (editable, NULL, NULL)) gtk_editable_delete_selection (editable); else { tmp_pos = gtk_editable_get_position (editable); if (gtk_entry_get_overwrite_mode (GTK_ENTRY (editable))) gtk_editable_delete_text (editable,tmp_pos,tmp_pos+1); } tmp_pos = gtk_editable_get_position (editable); gtk_editable_insert_text (editable, str, length, &tmp_pos); gtk_editable_set_position (editable, tmp_pos); } static void cb_gnm_pane_preedit_start (GtkIMContext *context, GnmPane *pane) { WBCGtk *wbcg = pane->simple.scg->wbcg; pane->im_preedit_started = TRUE; if (!wbcg_is_editing (wbcg)) wbcg_edit_start (wbcg, TRUE, TRUE); } static void cb_gnm_pane_preedit_changed (GtkIMContext *context, GnmPane *pane) { gchar *preedit_string; int tmp_pos; int cursor_pos; WBCGtk *wbcg = pane->simple.scg->wbcg; GtkEditable *editable = gnm_pane_get_editable (pane); if (!pane->im_preedit_started) return; tmp_pos = gtk_editable_get_position (editable); if (pane->preedit_attrs) pango_attr_list_unref (pane->preedit_attrs); gtk_im_context_get_preedit_string (pane->im_context, &preedit_string, &pane->preedit_attrs, &cursor_pos); if (!wbcg_is_editing (wbcg) && !wbcg_edit_start (wbcg, FALSE, TRUE)) { gtk_im_context_reset (pane->im_context); pane->preedit_length = 0; if (pane->preedit_attrs) pango_attr_list_unref (pane->preedit_attrs); pane->preedit_attrs = NULL; g_free (preedit_string); return; } if (pane->preedit_length) gtk_editable_delete_text (editable,tmp_pos,tmp_pos+pane->preedit_length); pane->preedit_length = strlen (preedit_string); if (pane->preedit_length) gtk_editable_insert_text (editable, preedit_string, pane->preedit_length, &tmp_pos); g_free (preedit_string); } static void cb_gnm_pane_preedit_end (GtkIMContext *context, GnmPane *pane) { pane->im_preedit_started = FALSE; } static gboolean cb_gnm_pane_retrieve_surrounding (GtkIMContext *context, GnmPane *pane) { GtkEditable *editable = gnm_pane_get_editable (pane); gchar *surrounding = gtk_editable_get_chars (editable, 0, -1); gint cur_pos = gtk_editable_get_position (editable); gtk_im_context_set_surrounding (context, surrounding, strlen (surrounding), g_utf8_offset_to_pointer (surrounding, cur_pos) - surrounding); g_free (surrounding); return TRUE; } static gboolean cb_gnm_pane_delete_surrounding (GtkIMContext *context, gint offset, gint n_chars, GnmPane *pane) { GtkEditable *editable = gnm_pane_get_editable (pane); gint cur_pos = gtk_editable_get_position (editable); gtk_editable_delete_text (editable, cur_pos + offset, cur_pos + offset + n_chars); return TRUE; } /* create views for the sheet objects now that we exist */ static void cb_pane_init_objs (GnmPane *pane) { Sheet *sheet = scg_sheet (pane->simple.scg); GSList *ptr, *list; if (sheet != NULL) { /* List is stored in reverse stacking order. Top of stack is * first. On creation new foocanvas item get added to * the front, so we need to create the views in reverse order */ list = g_slist_reverse (g_slist_copy (sheet->sheet_objects)); for (ptr = list; ptr != NULL ; ptr = ptr->next) sheet_object_new_view (ptr->data, (SheetObjectViewContainer *)pane); g_slist_free (list); } } static void cb_ctrl_pts_free (GocItem **ctrl_pts) { int i = 10; while (i-- > 0) if (ctrl_pts[i] != NULL) g_object_unref (ctrl_pts[i]); g_free (ctrl_pts); } static void gnm_pane_dispose (GObject *obj) { GnmPane *pane = GNM_PANE (obj); if (pane->col.canvas != NULL) { gtk_widget_destroy (GTK_WIDGET (pane->col.canvas)); g_object_unref (pane->col.canvas); pane->col.canvas = NULL; } if (pane->row.canvas != NULL) { gtk_widget_destroy (GTK_WIDGET (pane->row.canvas)); g_object_unref (pane->row.canvas); pane->row.canvas = NULL; } if (pane->im_context) { GtkIMContext *imc = pane->im_context; pane->im_context = NULL; g_signal_handlers_disconnect_by_func (imc, cb_gnm_pane_commit, pane); g_signal_handlers_disconnect_by_func (imc, cb_gnm_pane_preedit_start, pane); g_signal_handlers_disconnect_by_func (imc, cb_gnm_pane_preedit_changed, pane); g_signal_handlers_disconnect_by_func (imc, cb_gnm_pane_preedit_end, pane); g_signal_handlers_disconnect_by_func (imc, cb_gnm_pane_retrieve_surrounding, pane); g_signal_handlers_disconnect_by_func (imc, cb_gnm_pane_delete_surrounding, pane); gtk_im_context_set_client_window (imc, NULL); g_object_unref (imc); } g_slist_free (pane->cursor.animated); pane->cursor.animated = NULL; g_slist_free_full (pane->cursor.expr_range, g_object_unref); pane->cursor.expr_range = NULL; g_clear_object (&pane->mouse_cursor); gnm_pane_clear_obj_size_tip (pane); if (pane->drag.ctrl_pts) { g_hash_table_destroy (pane->drag.ctrl_pts); pane->drag.ctrl_pts = NULL; } /* Be anal just in case we somehow manage to remove a pane * unexpectedly. */ pane->grid = NULL; pane->editor = NULL; pane->cursor.std = pane->cursor.rangesel = pane->cursor.special = NULL; pane->size_guide.guide = NULL; pane->size_guide.start = NULL; pane->size_guide.points = NULL; G_OBJECT_CLASS (parent_klass)->dispose (obj); } static void gnm_pane_init (GnmPane *pane) { GocCanvas *canvas = GOC_CANVAS (pane); GocGroup *root_group = goc_canvas_get_root (canvas); pane->grid_items = goc_group_new (root_group); pane->object_views = goc_group_new (root_group); pane->action_items = goc_group_new (root_group); pane->first.col = pane->last_full.col = pane->last_visible.col = 0; pane->first.row = pane->last_full.row = pane->last_visible.row = 0; pane->first_offset.x = 0; pane->first_offset.y = 0; pane->editor = NULL; pane->mouse_cursor = NULL; pane->cursor.rangesel = NULL; pane->cursor.special = NULL; pane->cursor.expr_range = NULL; pane->cursor.animated = NULL; pane->size_tip = NULL; pane->slide_handler = NULL; pane->slide_data = NULL; pane->sliding_timer = 0; pane->sliding_x = pane->sliding_dx = -1; pane->sliding_y = pane->sliding_dy = -1; pane->sliding_adjacent_h = pane->sliding_adjacent_v = FALSE; pane->drag.button = 0; pane->drag.ctrl_pts = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) cb_ctrl_pts_free); pane->im_context = gtk_im_multicontext_new (); pane->preedit_length = 0; pane->preedit_attrs = NULL; pane->im_preedit_started = FALSE; gtk_widget_set_can_focus (GTK_WIDGET (canvas), TRUE); gtk_widget_set_can_default (GTK_WIDGET (canvas), TRUE); g_signal_connect (G_OBJECT (pane->im_context), "commit", G_CALLBACK (cb_gnm_pane_commit), pane); g_signal_connect (G_OBJECT (pane->im_context), "preedit_start", G_CALLBACK (cb_gnm_pane_preedit_start), pane); g_signal_connect (G_OBJECT (pane->im_context), "preedit_changed", G_CALLBACK (cb_gnm_pane_preedit_changed), pane); g_signal_connect (G_OBJECT (pane->im_context), "preedit_end", G_CALLBACK (cb_gnm_pane_preedit_end), pane); g_signal_connect (G_OBJECT (pane->im_context), "retrieve_surrounding", G_CALLBACK (cb_gnm_pane_retrieve_surrounding), pane); g_signal_connect (G_OBJECT (pane->im_context), "delete_surrounding", G_CALLBACK (cb_gnm_pane_delete_surrounding), pane); } static void gnm_pane_class_init (GnmPaneClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = (GtkWidgetClass *) klass; parent_klass = g_type_class_peek_parent (klass); gobject_class->dispose = gnm_pane_dispose; widget_class->realize = gnm_pane_realize; widget_class->unrealize = gnm_pane_unrealize; widget_class->size_allocate = gnm_pane_size_allocate; widget_class->key_press_event = gnm_pane_key_press; widget_class->key_release_event = gnm_pane_key_release; widget_class->focus_in_event = gnm_pane_focus_in; widget_class->focus_out_event = gnm_pane_focus_out; gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("function-indicator-size", P_("Function Indicator Size"), P_("Size of function indicator"), 0, G_MAXINT, 10, G_PARAM_READABLE)); gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("comment-indicator-size", P_("comment Indicator Size"), P_("Size of comment indicator"), 0, G_MAXINT, 6, G_PARAM_READABLE)); gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("resize-guide-width", P_("Resize Guide Width"), P_("With of the guides used for resizing columns and rows"), 0, G_MAXINT, 1, G_PARAM_READABLE)); gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("pane-resize-guide-width", P_("Pane Resize Guide Width"), P_("With of the guides used for resizing panes"), 0, G_MAXINT, 7, G_PARAM_READABLE)); gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("control-circle-size", P_("Control Circle Size"), P_("Size of control circle for sizing sheet objects"), 0, G_MAXINT, 4, G_PARAM_READABLE)); gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("control-circle-outline", P_("Control Circle Outline"), P_("Width of outline of control circle for sizing sheet objects"), 0, G_MAXINT, 1, G_PARAM_READABLE)); } GSF_CLASS (GnmPane, gnm_pane, gnm_pane_class_init, gnm_pane_init, GNM_SIMPLE_CANVAS_TYPE) #if 0 ; #endif static void gnm_pane_header_init (GnmPane *pane, SheetControlGUI *scg, gboolean is_col_header) { Sheet *sheet = scg_sheet (scg); GocCanvas *canvas = gnm_simple_canvas_new (scg); GocGroup *group = goc_canvas_get_root (canvas); GocItem *item = goc_item_new (group, gnm_item_bar_get_type (), "pane", pane, "IsColHeader", is_col_header, NULL); /* give a non-constraining default in case something scrolls before we * are realized */ if (is_col_header) { if (sheet && sheet->text_is_rtl) goc_canvas_set_direction (canvas, GOC_DIRECTION_RTL); pane->col.canvas = g_object_ref_sink (canvas); pane->col.item = GNM_ITEM_BAR (item); } else { pane->row.canvas = g_object_ref_sink (canvas); pane->row.item = GNM_ITEM_BAR (item); } pane->size_guide.points = NULL; pane->size_guide.start = NULL; pane->size_guide.guide = NULL; if (NULL != scg && NULL != sheet && fabs (1. - sheet->last_zoom_factor_used) > 1e-6) goc_canvas_set_pixels_per_unit (canvas, sheet->last_zoom_factor_used); } static void cb_pane_drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection_data, guint info, guint time, GnmPane *pane) { double wx, wy; if (gnm_debug_flag ("dnd")) { gchar *target_name = gdk_atom_name (gtk_selection_data_get_target (selection_data)); g_printerr ("drag-data-received - %s\n", target_name); g_free (target_name); } goc_canvas_w2c (GOC_CANVAS (pane), x, y, &wx, &wy); scg_drag_data_received (pane->simple.scg, gtk_drag_get_source_widget (context), wx, wy, selection_data); } static void cb_pane_drag_data_get (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint time, SheetControlGUI *scg) { if (gnm_debug_flag ("dnd")) { gchar *target_name = gdk_atom_name (gtk_selection_data_get_target (selection_data)); g_printerr ("drag-data-get - %s \n", target_name); g_free (target_name); } scg_drag_data_get (scg, selection_data); } /* Move the rubber bands if we are the source */ static gboolean cb_pane_drag_motion (GtkWidget *widget, GdkDragContext *context, int x, int y, guint32 time, GnmPane *pane) { GtkWidget *source_widget = gtk_drag_get_source_widget (context); SheetControlGUI *scg = GNM_PANE (widget)->simple.scg; if ((IS_GNM_PANE (source_widget) && GNM_PANE (source_widget)->simple.scg == scg)) { /* same scg */ GocCanvas *canvas = GOC_CANVAS (widget); GdkModifierType mask; GdkWindow *window = gtk_widget_get_parent_window (source_widget); double wx, wy; g_object_set_data (G_OBJECT (context), "wbcg", scg_wbcg (scg)); goc_canvas_w2c (canvas, x, y, &wx, &wy); wx *= goc_canvas_get_pixels_per_unit (canvas); wy *= goc_canvas_get_pixels_per_unit (canvas); gdk_window_get_device_position (window, gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gdk_window_get_display (window))), NULL, NULL, &mask); gnm_pane_objects_drag (GNM_PANE (source_widget), NULL, wx, wy, 8, FALSE, (mask & GDK_SHIFT_MASK) != 0); gdk_drag_status (context, (mask & GDK_CONTROL_MASK) != 0 ? GDK_ACTION_COPY : GDK_ACTION_MOVE, time); } return TRUE; } static void cb_pane_drag_end (GtkWidget *widget, GdkDragContext *context, GnmPane *source_pane) { /* ungrab any grabbed item */ GocItem *item = goc_canvas_get_grabbed_item (GOC_CANVAS (source_pane)); if (item) gnm_simple_canvas_ungrab (item, gtk_get_current_event_time ()); /* sync the ctrl-pts with the object in case the drag was canceled. */ gnm_pane_objects_drag (source_pane, NULL, source_pane->drag.origin_x, source_pane->drag.origin_y, 8, FALSE, FALSE); source_pane->drag.had_motion = FALSE; source_pane->drag.button = 0; } /* * Move the rubber bands back to original position when curser leaves * the scg, but not when it moves to another pane. We use object data, * and rely on gtk sending drag_move to the new widget before sending * drag_leave to the old one. */ static void cb_pane_drag_leave (GtkWidget *widget, GdkDragContext *context, guint32 time, GnmPane *pane) { GtkWidget *source_widget = gtk_drag_get_source_widget (context); GnmPane *source_pane; WBCGtk *wbcg; if (!source_widget || !IS_GNM_PANE (source_widget)) return; source_pane = GNM_PANE (source_widget); wbcg = scg_wbcg (source_pane->simple.scg); if (wbcg == g_object_get_data (G_OBJECT (context), "wbcg")) return; gnm_pane_objects_drag (source_pane, NULL, source_pane->drag.origin_x, source_pane->drag.origin_y, 8, FALSE, FALSE); source_pane->drag.had_motion = FALSE; } static void gnm_pane_drag_dest_init (GnmPane *pane, SheetControlGUI *scg) { GtkWidget *widget = GTK_WIDGET (pane); gtk_drag_dest_set (widget, GTK_DEST_DEFAULT_ALL, drag_types_in, G_N_ELEMENTS (drag_types_in), GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_drag_dest_add_uri_targets (widget); gtk_drag_dest_add_image_targets (widget); gtk_drag_dest_add_text_targets (widget); g_object_connect (G_OBJECT (widget), "signal::drag-data-received", G_CALLBACK (cb_pane_drag_data_received), pane, "signal::drag-data-get", G_CALLBACK (cb_pane_drag_data_get), scg, "signal::drag-motion", G_CALLBACK (cb_pane_drag_motion), pane, "signal::drag-leave", G_CALLBACK (cb_pane_drag_leave), pane, "signal::drag-end", G_CALLBACK (cb_pane_drag_end), pane, NULL); } GnmPane * gnm_pane_new (SheetControlGUI *scg, gboolean col_headers, gboolean row_headers, int index) { GocItem *item; GnmPane *pane; Sheet *sheet; g_return_val_if_fail (IS_SHEET_CONTROL_GUI (scg), NULL); pane = g_object_new (GNM_PANE_TYPE, NULL); pane->index = index; pane->simple.scg = scg; goc_canvas_set_document (GOC_CANVAS (pane), wb_control_get_doc (scg_wbc (scg))); if (NULL != (sheet = scg_sheet (scg)) && fabs (1. - sheet->last_zoom_factor_used) > 1e-6) goc_canvas_set_pixels_per_unit (GOC_CANVAS (pane), sheet->last_zoom_factor_used); gnm_pane_drag_dest_init (pane, scg); item = goc_item_new (pane->grid_items, gnm_item_grid_get_type (), "SheetControlGUI", scg, NULL); pane->grid = GNM_ITEM_GRID (item); item = goc_item_new (pane->grid_items, gnm_item_cursor_get_type (), "SheetControlGUI", scg, NULL); pane->cursor.std = GNM_ITEM_CURSOR (item); if (col_headers) gnm_pane_header_init (pane, scg, TRUE); else pane->col.canvas = NULL; if (row_headers) gnm_pane_header_init (pane, scg, FALSE); else pane->row.canvas = NULL; g_signal_connect_swapped (pane, "popup-menu", G_CALLBACK (cb_pane_popup_menu), pane); g_signal_connect_swapped (G_OBJECT (pane), "realize", G_CALLBACK (cb_pane_init_objs), pane); return pane; } /** * gnm_pane_find_col: * @pane: * @x: In canvas coords * @col_origin: optionally return the canvas coord of the col * * Returns the column containing canvas coord @x **/ int gnm_pane_find_col (GnmPane const *pane, gint64 x, gint64 *col_origin) { Sheet const *sheet = scg_sheet (pane->simple.scg); int col = pane->first.col; gint64 pixel = pane->first_offset.x; if (x < pixel) { while (col > 0) { ColRowInfo const *ci = sheet_col_get_info (sheet, --col); if (ci->visible) { pixel -= ci->size_pixels; if (x >= pixel) { if (col_origin) *col_origin = pixel; return col; } } } if (col_origin) *col_origin = 0; return 0; } do { ColRowInfo const *ci = sheet_col_get_info (sheet, col); if (ci->visible) { int const tmp = ci->size_pixels; if (x <= pixel + tmp) { if (col_origin) *col_origin = pixel; return col; } pixel += tmp; } } while (++col < gnm_sheet_get_last_col (sheet)); if (col_origin) *col_origin = pixel; return gnm_sheet_get_last_col (sheet); } /** * gnm_pane_find_row: * @pane: * @y: In canvas coords * @row_origin: optionally return the canvas coord of the row * * Returns the column containing canvas coord @y **/ int gnm_pane_find_row (GnmPane const *pane, gint64 y, gint64 *row_origin) { Sheet const *sheet = scg_sheet (pane->simple.scg); int row = pane->first.row; gint64 pixel = pane->first_offset.y; if (y < pixel) { while (row > 0) { ColRowInfo const *ri = sheet_row_get_info (sheet, --row); if (ri->visible) { pixel -= ri->size_pixels; if (y >= pixel) { if (row_origin) *row_origin = pixel; return row; } } } if (row_origin) *row_origin = 0; return 0; } do { ColRowInfo const *ri = sheet_row_get_info (sheet, row); if (ri->visible) { int const tmp = ri->size_pixels; if (pixel <= y && y <= pixel + tmp) { if (row_origin) *row_origin = pixel; return row; } pixel += tmp; } } while (++row < gnm_sheet_get_last_row (sheet)); if (row_origin) *row_origin = pixel; return gnm_sheet_get_last_row (sheet); } /* * gnm_pane_compute_visible_region : Keeps the top left col/row the same and * recalculates the visible boundaries. * * @full_recompute: * if TRUE recompute the pixel offsets of the top left row/col * else assumes that the pixel offsets of the top left have not changed. */ void gnm_pane_compute_visible_region (GnmPane *pane, gboolean const full_recompute) { SheetControlGUI const * const scg = pane->simple.scg; Sheet const *sheet = scg_sheet (scg); GocCanvas *canvas = GOC_CANVAS (pane); gint64 pixels; int col, row, width, height; GtkAllocation ca; gtk_widget_get_allocation (GTK_WIDGET (canvas), &ca); /* When col/row sizes change we need to do a full recompute */ if (full_recompute) { gint64 col_offset = pane->first_offset.x = scg_colrow_distance_get (scg, TRUE, 0, pane->first.col); if (NULL != pane->col.canvas) goc_canvas_scroll_to (pane->col.canvas, col_offset / canvas->pixels_per_unit, 0); pane->first_offset.y = scg_colrow_distance_get (scg, FALSE, 0, pane->first.row); if (NULL != pane->row.canvas) goc_canvas_scroll_to (pane->row.canvas, 0, pane->first_offset.y / canvas->pixels_per_unit); goc_canvas_scroll_to (GOC_CANVAS (pane), col_offset / canvas->pixels_per_unit, pane->first_offset.y / canvas->pixels_per_unit); } /* Find out the last visible col and the last full visible column */ pixels = 0; col = pane->first.col; width = ca.width; do { ColRowInfo const * const ci = sheet_col_get_info (sheet, col); if (ci->visible) { int const bound = pixels + ci->size_pixels; if (bound == width) { pane->last_visible.col = col; pane->last_full.col = col; break; } if (bound > width) { pane->last_visible.col = col; if (col == pane->first.col) pane->last_full.col = pane->first.col; else pane->last_full.col = col - 1; break; } pixels = bound; } ++col; } while (pixels < width && col < gnm_sheet_get_max_cols (sheet)); if (col >= gnm_sheet_get_max_cols (sheet)) { pane->last_visible.col = gnm_sheet_get_last_col (sheet); pane->last_full.col = gnm_sheet_get_last_col (sheet); } /* Find out the last visible row and the last fully visible row */ pixels = 0; row = pane->first.row; height = ca.height; do { ColRowInfo const * const ri = sheet_row_get_info (sheet, row); if (ri->visible) { int const bound = pixels + ri->size_pixels; if (bound == height) { pane->last_visible.row = row; pane->last_full.row = row; break; } if (bound > height) { pane->last_visible.row = row; if (row == pane->first.row) pane->last_full.row = pane->first.row; else pane->last_full.row = row - 1; break; } pixels = bound; } ++row; } while (pixels < height && row < gnm_sheet_get_max_rows (sheet)); if (row >= gnm_sheet_get_max_rows (sheet)) { pane->last_visible.row = gnm_sheet_get_last_row (sheet); pane->last_full.row = gnm_sheet_get_last_row (sheet); } /* Update the scrollbar sizes for the primary pane */ if (pane->index == 0) sc_scrollbar_config (SHEET_CONTROL (scg)); /* Force the cursor to update its bounds relative to the new visible region */ gnm_pane_reposition_cursors (pane); } void gnm_pane_redraw_range (GnmPane *pane, GnmRange const *r) { SheetControlGUI *scg; gint64 x1, y1, x2, y2; GnmRange tmp; Sheet *sheet; double scale = goc_canvas_get_pixels_per_unit (GOC_CANVAS (pane)); g_return_if_fail (IS_GNM_PANE (pane)); scg = pane->simple.scg; sheet = scg_sheet (scg); if ((r->end.col < pane->first.col) || (r->end.row < pane->first.row) || (r->start.col > pane->last_visible.col) || (r->start.row > pane->last_visible.row)) return; /* Only draw those regions that are visible */ tmp.start.col = MAX (pane->first.col, r->start.col); tmp.start.row = MAX (pane->first.row, r->start.row); tmp.end.col = MIN (pane->last_visible.col, r->end.col); tmp.end.row = MIN (pane->last_visible.row, r->end.row); /* redraw a border of 2 pixels around the region to handle thick borders * NOTE the 2nd coordinates are excluded so add 1 extra (+2border +1include) */ x1 = scg_colrow_distance_get (scg, TRUE, pane->first.col, tmp.start.col) + pane->first_offset.x; y1 = scg_colrow_distance_get (scg, FALSE, pane->first.row, tmp.start.row) + pane->first_offset.y; x2 = (tmp.end.col < gnm_sheet_get_last_col (sheet)) ? 4 + 1 + x1 + scg_colrow_distance_get (scg, TRUE, tmp.start.col, tmp.end.col+1) : G_MAXINT64; y2 = (tmp.end.row < gnm_sheet_get_last_row (sheet)) ? 4 + 1 + y1 + scg_colrow_distance_get (scg, FALSE, tmp.start.row, tmp.end.row+1) : G_MAXINT64; goc_canvas_invalidate (&pane->simple.canvas, (x1-2) / scale, (y1-2) / scale, x2 / scale, y2 / scale); } /*****************************************************************************/ void gnm_pane_slide_stop (GnmPane *pane) { if (pane->sliding_timer == 0) return; g_source_remove (pane->sliding_timer); pane->slide_handler = NULL; pane->slide_data = NULL; pane->sliding_timer = 0; } static int col_scroll_step (int dx, Sheet *sheet) { /* FIXME: get from gdk. */ int dpi_x_this_screen = 90; int start_x = dpi_x_this_screen / 3; double double_dx = dpi_x_this_screen / 3.0; double step = pow (2.0, (dx - start_x) / double_dx); return (int) (CLAMP (step, 1.0, gnm_sheet_get_max_cols (sheet) / 15.0)); } static int row_scroll_step (int dy, Sheet *sheet) { /* FIXME: get from gdk. */ int dpi_y_this_screen = 90; int start_y = dpi_y_this_screen / 4; double double_dy = dpi_y_this_screen / 8.0; double step = pow (2.0, (dy - start_y) / double_dy); return (int) (CLAMP (step, 1.0, gnm_sheet_get_max_rows (sheet) / 15.0)); } static gint cb_pane_sliding (GnmPane *pane) { int const pane_index = pane->index; GnmPane *pane0 = scg_pane (pane->simple.scg, 0); GnmPane *pane1 = scg_pane (pane->simple.scg, 1); GnmPane *pane3 = scg_pane (pane->simple.scg, 3); gboolean slide_x = FALSE, slide_y = FALSE; int col = -1, row = -1; Sheet *sheet = scg_sheet (pane->simple.scg); GnmPaneSlideInfo info; GtkAllocation pa; gtk_widget_get_allocation (GTK_WIDGET (pane), &pa); if (pane->sliding_dx > 0) { GnmPane *target_pane = pane; slide_x = TRUE; if (pane_index == 1 || pane_index == 2) { if (!pane->sliding_adjacent_h) { int width = pa.width; int x = pane->first_offset.x + width + pane->sliding_dx; /* in case pane is narrow */ col = gnm_pane_find_col (pane, x, NULL); if (col > pane0->last_full.col) { pane->sliding_adjacent_h = TRUE; pane->sliding_dx = 1; /* good enough */ } else slide_x = FALSE; } else target_pane = pane0; } else pane->sliding_adjacent_h = FALSE; if (slide_x) { col = target_pane->last_full.col + col_scroll_step (pane->sliding_dx, sheet); if (col >= gnm_sheet_get_last_col (sheet)) { col = gnm_sheet_get_last_col (sheet); slide_x = FALSE; } } } else if (pane->sliding_dx < 0) { slide_x = TRUE; col = pane0->first.col - col_scroll_step (-pane->sliding_dx, sheet); if (pane1 != NULL) { if (pane_index == 0 || pane_index == 3) { GtkAllocation p1a; int width; gtk_widget_get_allocation (GTK_WIDGET (pane1), &p1a); width = p1a.width; if (pane->sliding_dx > (-width) && col <= pane1->last_visible.col) { int x = pane1->first_offset.x + width + pane->sliding_dx; col = gnm_pane_find_col (pane, x, NULL); slide_x = FALSE; } } if (col <= pane1->first.col) { col = pane1->first.col; slide_x = FALSE; } } else if (col <= 0) { col = 0; slide_x = FALSE; } } if (pane->sliding_dy > 0) { GnmPane *target_pane = pane; slide_y = TRUE; if (pane_index == 3 || pane_index == 2) { if (!pane->sliding_adjacent_v) { int height = pa.height; int y = pane->first_offset.y + height + pane->sliding_dy; /* in case pane is short */ row = gnm_pane_find_row (pane, y, NULL); if (row > pane0->last_full.row) { pane->sliding_adjacent_v = TRUE; pane->sliding_dy = 1; /* good enough */ } else slide_y = FALSE; } else target_pane = pane0; } else pane->sliding_adjacent_v = FALSE; if (slide_y) { row = target_pane->last_full.row + row_scroll_step (pane->sliding_dy, sheet); if (row >= gnm_sheet_get_last_row (sheet)) { row = gnm_sheet_get_last_row (sheet); slide_y = FALSE; } } } else if (pane->sliding_dy < 0) { slide_y = TRUE; row = pane0->first.row - row_scroll_step (-pane->sliding_dy, sheet); if (pane3 != NULL) { if (pane_index == 0 || pane_index == 1) { GtkAllocation p3a; int height; gtk_widget_get_allocation (GTK_WIDGET (pane3), &p3a); height = p3a.height; if (pane->sliding_dy > (-height) && row <= pane3->last_visible.row) { int y = pane3->first_offset.y + height + pane->sliding_dy; row = gnm_pane_find_row (pane3, y, NULL); slide_y = FALSE; } } if (row <= pane3->first.row) { row = pane3->first.row; slide_y = FALSE; } } else if (row <= 0) { row = 0; slide_y = FALSE; } } if (col < 0 && row < 0) { gnm_pane_slide_stop (pane); return TRUE; } if (col < 0) { col = gnm_pane_find_col (pane, pane->sliding_x, NULL); } else if (row < 0) row = gnm_pane_find_row (pane, pane->sliding_y, NULL); info.col = col; info.row = row; info.user_data = pane->slide_data; if (pane->slide_handler == NULL || (*pane->slide_handler) (pane, &info)) scg_make_cell_visible (pane->simple.scg, col, row, FALSE, TRUE); if (!slide_x && !slide_y) gnm_pane_slide_stop (pane); else if (pane->sliding_timer == 0) pane->sliding_timer = g_timeout_add (300, (GSourceFunc)cb_pane_sliding, pane); return TRUE; } /** * gnm_pane_handle_motion: * @pane: The GnmPane managing the scroll * @canvas: The Canvas the event comes from * @slide_flags: * @handler: (scope call): The handler when sliding * @user_data: closure data * * Handle a motion event from a @canvas and scroll the @pane * depending on how far outside the bounds of @pane the @event is. * Usually @canvas == @pane however as long as the canvases share a basis * space they can be different. **/ gboolean gnm_pane_handle_motion (GnmPane *pane, GocCanvas *canvas, gint64 x, gint64 y, GnmPaneSlideFlags slide_flags, GnmPaneSlideHandler slide_handler, gpointer user_data) { GnmPane *pane0, *pane1, *pane3; int pindex, width, height; gint64 dx = 0, dy = 0, left, top; GtkAllocation pa, p0a, p1a, p3a; g_return_val_if_fail (IS_GNM_PANE (pane), FALSE); g_return_val_if_fail (GOC_IS_CANVAS (canvas), FALSE); g_return_val_if_fail (slide_handler != NULL, FALSE); pindex = pane->index; left = pane->first_offset.x; top = pane->first_offset.y; gtk_widget_get_allocation (GTK_WIDGET (pane), &pa); width = pa.width; height = pa.height; pane0 = scg_pane (pane->simple.scg, 0); gtk_widget_get_allocation (GTK_WIDGET (pane0), &p0a); pane1 = scg_pane (pane->simple.scg, 1); if (pane1) gtk_widget_get_allocation (GTK_WIDGET (pane1), &p1a); pane3 = scg_pane (pane->simple.scg, 3); if (pane3) gtk_widget_get_allocation (GTK_WIDGET (pane3), &p3a); if (slide_flags & GNM_PANE_SLIDE_X) { if (x < left) dx = x - left; else if (x >= left + width) dx = x - width - left; } if (slide_flags & GNM_PANE_SLIDE_Y) { if (y < top) dy = y - top; else if (y >= top + height) dy = y - height - top; } if (pane->sliding_adjacent_h) { if (pindex == 0 || pindex == 3) { if (dx < 0) { x = pane1->first_offset.x; dx += p1a.width; if (dx > 0) x += dx; dx = 0; } else pane->sliding_adjacent_h = FALSE; } else { if (dx > 0) { x = pane0->first_offset.x + dx; dx -= p0a.width; if (dx < 0) dx = 0; } else if (dx == 0) { /* initiate a reverse scroll of panes 0,3 */ if ((pane1->last_visible.col+1) != pane0->first.col) dx = x - (left + width); } else dx = 0; } } if (pane->sliding_adjacent_v) { if (pindex == 0 || pindex == 1) { if (dy < 0) { y = pane3->first_offset.y; dy += p3a.height; if (dy > 0) y += dy; dy = 0; } else pane->sliding_adjacent_v = FALSE; } else { if (dy > 0) { y = pane0->first_offset.y + dy; dy -= p0a.height; if (dy < 0) dy = 0; } else if (dy == 0) { /* initiate a reverse scroll of panes 0,1 */ if ((pane3->last_visible.row+1) != pane0->first.row) dy = y - (top + height); } else dy = 0; } } /* Movement is inside the visible region */ if (dx == 0 && dy == 0) { if (!(slide_flags & GNM_PANE_SLIDE_EXTERIOR_ONLY)) { GnmPaneSlideInfo info; info.row = gnm_pane_find_row (pane, y, NULL); info.col = gnm_pane_find_col (pane, x, NULL); info.user_data = user_data; (*slide_handler) (pane, &info); } gnm_pane_slide_stop (pane); return TRUE; } pane->sliding_x = x; pane->sliding_dx = dx; pane->sliding_y = y; pane->sliding_dy = dy; pane->slide_handler = slide_handler; pane->slide_data = user_data; if (pane->sliding_timer == 0) cb_pane_sliding (pane); return FALSE; } /* TODO : All the slide_* members of GnmPane really ought to be in * SheetControlGUI, most of these routines also belong there. However, since * the primary point of access is via GnmPane and SCG is very large * already I'm leaving them here for now. Move them when we return to * investigate how to do reverse scrolling for pseudo-adjacent panes. */ void gnm_pane_slide_init (GnmPane *pane) { GnmPane *pane0, *pane1, *pane3; g_return_if_fail (IS_GNM_PANE (pane)); pane0 = scg_pane (pane->simple.scg, 0); pane1 = scg_pane (pane->simple.scg, 1); pane3 = scg_pane (pane->simple.scg, 3); pane->sliding_adjacent_h = (pane1 != NULL) ? (pane1->last_full.col == (pane0->first.col - 1)) : FALSE; pane->sliding_adjacent_v = (pane3 != NULL) ? (pane3->last_full.row == (pane0->first.row - 1)) : FALSE; } static gboolean cb_obj_autoscroll (GnmPane *pane, GnmPaneSlideInfo const *info) { SheetControlGUI *scg = pane->simple.scg; GdkModifierType mask; GdkWindow *window = gtk_widget_get_parent_window (GTK_WIDGET (pane)); /* Cheesy hack calculate distance we move the screen, this loses the * mouse position */ double dx = pane->first_offset.x; double dy = pane->first_offset.y; scg_make_cell_visible (scg, info->col, info->row, FALSE, TRUE); dx = pane->first_offset.x - dx; dy = pane->first_offset.y - dy; pane->drag.had_motion = TRUE; gdk_window_get_device_position (window, gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gdk_window_get_display (window))), NULL, NULL, &mask); scg_objects_drag (pane->simple.scg, pane, NULL, &dx, &dy, 8, FALSE, (mask & GDK_SHIFT_MASK) != 0, TRUE); pane->drag.last_x += dx; pane->drag.last_y += dy; return FALSE; } void gnm_pane_object_autoscroll (GnmPane *pane, GdkDragContext *context, gint x, gint y, guint time) { int const pane_index = pane->index; SheetControlGUI *scg = pane->simple.scg; GnmPane *pane0 = scg_pane (scg, 0); GnmPane *pane1 = scg_pane (scg, 1); GnmPane *pane3 = scg_pane (scg, 3); GtkWidget *w = GTK_WIDGET (pane); GtkAllocation wa; gint dx, dy; gtk_widget_get_allocation (w, &wa); if (y < wa.y) { if (pane_index < 2 && pane3 != NULL) { w = GTK_WIDGET (pane3); gtk_widget_get_allocation (w, &wa); } dy = y - wa.y; g_return_if_fail (dy <= 0); } else if (y >= (wa.y + wa.height)) { if (pane_index >= 2) { w = GTK_WIDGET (pane0); gtk_widget_get_allocation (w, &wa); } dy = y - (wa.y + wa.height); g_return_if_fail (dy >= 0); } else dy = 0; if (x < wa.x) { if ((pane_index == 0 || pane_index == 3) && pane1 != NULL) { w = GTK_WIDGET (pane1); gtk_widget_get_allocation (w, &wa); } dx = x - wa.x; g_return_if_fail (dx <= 0); } else if (x >= (wa.x + wa.width)) { if (pane_index >= 2) { w = GTK_WIDGET (pane0); gtk_widget_get_allocation (w, &wa); } dx = x - (wa.x + wa.width); g_return_if_fail (dx >= 0); } else dx = 0; g_object_set_data (G_OBJECT (context), "wbcg", scg_wbcg (scg)); pane->sliding_dx = dx; pane->sliding_dy = dy; pane->slide_handler = &cb_obj_autoscroll; pane->slide_data = NULL; pane->sliding_x = x; pane->sliding_y = y; if (pane->sliding_timer == 0) cb_pane_sliding (pane); } /** * gnm_pane_object_group: * @pane: #GnmPane * * Returns: (transfer none): the #GocGroup including all #SheetObjectView * instances in @pane. **/ GocGroup * gnm_pane_object_group (GnmPane *pane) { return pane->object_views; } static void gnm_pane_clear_obj_size_tip (GnmPane *pane) { if (pane->size_tip) { gtk_widget_destroy (gtk_widget_get_toplevel (pane->size_tip)); pane->size_tip = NULL; } } static void gnm_pane_display_obj_size_tip (GnmPane *pane, GocItem *ctrl_pt) { SheetControlGUI *scg = pane->simple.scg; double const *coords; double pts[4]; char *msg; SheetObjectAnchor anchor; if (pane->size_tip == NULL) { GtkWidget *cw = GTK_WIDGET (pane); GtkWidget *top; int x, y; if (ctrl_pt == NULL) { /* * Keyboard navigation when we are not displaying * a tooltip already. */ return; } pane->size_tip = gnumeric_create_tooltip (cw); top = gtk_widget_get_toplevel (pane->size_tip); gnm_canvas_get_screen_position (ctrl_pt->canvas, ctrl_pt->x1, ctrl_pt->y1, &x, &y); gtk_window_move (GTK_WINDOW (top), x + 10, y + 10); gtk_widget_show_all (top); } g_return_if_fail (pane->cur_object != NULL); g_return_if_fail (pane->size_tip != NULL); coords = g_hash_table_lookup (scg->selected_objects, pane->cur_object); anchor = *sheet_object_get_anchor (pane->cur_object); scg_object_coords_to_anchor (scg, coords, &anchor); sheet_object_anchor_to_pts (&anchor, scg_sheet (scg), pts); msg = g_strdup_printf (_("%.1f x %.1f pts\n%d x %d pixels"), MAX (fabs (pts[2] - pts[0]), 0), MAX (fabs (pts[3] - pts[1]), 0), MAX ((int)floor (fabs (coords [2] - coords [0]) + 0.5), 0), MAX ((int)floor (fabs (coords [3] - coords [1]) + 0.5), 0)); gtk_label_set_text (GTK_LABEL (pane->size_tip), msg); g_free (msg); } void gnm_pane_bound_set (GnmPane *pane, int start_col, int start_row, int end_col, int end_row) { GnmRange r; g_return_if_fail (pane != NULL); range_init (&r, start_col, start_row, end_col, end_row); goc_item_set (GOC_ITEM (pane->grid), "bound", &r, NULL); } /****************************************************************************/ void gnm_pane_size_guide_start (GnmPane *pane, gboolean vert, int colrow, gboolean is_colrow_resize) { SheetControlGUI const *scg; double x0, y0, x1, y1, pos; double zoom; GOStyle *style; GdkRGBA rgba; GtkStyleContext *context; const char *guide_class = is_colrow_resize ? "resize-guide" : "pane-resize-guide"; const char *colrow_class = vert ? "col" : "row"; const char *width_prop_name = is_colrow_resize ? "resize-guide-width" : "pane-resize-guide-width"; int width; g_return_if_fail (pane != NULL); g_return_if_fail (pane->size_guide.guide == NULL); g_return_if_fail (pane->size_guide.start == NULL); g_return_if_fail (pane->size_guide.points == NULL); zoom = GOC_CANVAS (pane)->pixels_per_unit; scg = pane->simple.scg; pos = scg_colrow_distance_get (scg, vert, 0, colrow) / zoom; if (vert) { x0 = pos; y0 = scg_colrow_distance_get (scg, FALSE, 0, pane->first.row) / zoom; x1 = pos; y1 = scg_colrow_distance_get (scg, FALSE, 0, pane->last_visible.row+1) / zoom; } else { x0 = scg_colrow_distance_get (scg, TRUE, 0, pane->first.col) / zoom; y0 = pos; x1 = scg_colrow_distance_get (scg, TRUE, 0, pane->last_visible.col+1) / zoom; y1 = pos; } gtk_widget_style_get (GTK_WIDGET (pane), width_prop_name, &width, NULL); /* Guideline positioning is done in gnm_pane_size_guide_motion */ pane->size_guide.guide = goc_item_new (pane->action_items, GOC_TYPE_LINE, "x0", x0, "y0", y0, "x1", x1, "y1", y1, NULL); style = go_styled_object_get_style (GO_STYLED_OBJECT (pane->size_guide.guide)); style->line.width = width; context = goc_item_get_style_context (pane->size_guide.guide); gtk_style_context_add_class (context, guide_class); gtk_style_context_add_class (context, colrow_class); if (is_colrow_resize) gtk_style_context_add_class (context, "end"); gtk_style_context_get_color (context, GTK_STATE_FLAG_SELECTED, &rgba); go_color_from_gdk_rgba (&rgba, &style->line.color); if (is_colrow_resize) { pane->size_guide.start = goc_item_new (pane->action_items, GOC_TYPE_LINE, "x0", x0, "y0", y0, "x1", x1, "y1", y1, NULL); style = go_styled_object_get_style (GO_STYLED_OBJECT (pane->size_guide.start)); context = goc_item_get_style_context (pane->size_guide.start); gtk_style_context_add_class (context, guide_class); gtk_style_context_add_class (context, colrow_class); gtk_style_context_add_class (context, "start"); gtk_style_context_get_color (context, GTK_STATE_FLAG_SELECTED, &rgba); go_color_from_gdk_rgba (&rgba, &style->line.color); style->line.width = width; } } void gnm_pane_size_guide_stop (GnmPane *pane) { g_return_if_fail (pane != NULL); g_clear_object (&pane->size_guide.start); g_clear_object (&pane->size_guide.guide); } /** * gnm_pane_size_guide_motion: * @p: #GnmPane * @vert: TRUE for a vertical guide, FALSE for horizontal * @guide_pos: in unscaled sheet pixel coords * * Moves the guide line to @guide_pos. * NOTE : gnm_pane_size_guide_start must be called before any calls to * gnm_pane_size_guide_motion **/ void gnm_pane_size_guide_motion (GnmPane *pane, gboolean vert, gint64 guide_pos) { GocItem *resize_guide = GOC_ITEM (pane->size_guide.guide); double const scale = 1. / resize_guide->canvas->pixels_per_unit; double x; x = scale * (guide_pos - .5); if (vert) goc_item_set (resize_guide, "x0", x, "x1", x, NULL); else goc_item_set (resize_guide, "y0", x, "y1", x, NULL); } /****************************************************************************/ static void cb_update_ctrl_pts (SheetObject *so, GocItem **ctrl_pts, GnmPane *pane) { double *coords = g_hash_table_lookup ( pane->simple.scg->selected_objects, so); scg_object_anchor_to_coords (pane->simple.scg, sheet_object_get_anchor (so), coords); gnm_pane_object_update_bbox (pane, so); } /* Called when the zoom changes */ void gnm_pane_reposition_cursors (GnmPane *pane) { GSList *l; gnm_item_cursor_reposition (pane->cursor.std); if (NULL != pane->cursor.rangesel) gnm_item_cursor_reposition (pane->cursor.rangesel); if (NULL != pane->cursor.special) gnm_item_cursor_reposition (pane->cursor.special); for (l = pane->cursor.expr_range; l; l = l->next) gnm_item_cursor_reposition (GNM_ITEM_CURSOR (l->data)); for (l = pane->cursor.animated; l; l = l->next) gnm_item_cursor_reposition (GNM_ITEM_CURSOR (l->data)); /* ctrl pts do not scale with the zoom, compensate */ if (pane->drag.ctrl_pts != NULL) g_hash_table_foreach (pane->drag.ctrl_pts, (GHFunc) cb_update_ctrl_pts, pane); } gboolean gnm_pane_cursor_bound_set (GnmPane *pane, GnmRange const *r) { return gnm_item_cursor_bound_set (pane->cursor.std, r); } /****************************************************************************/ gboolean gnm_pane_rangesel_bound_set (GnmPane *pane, GnmRange const *r) { return gnm_item_cursor_bound_set (pane->cursor.rangesel, r); } void gnm_pane_rangesel_start (GnmPane *pane, GnmRange const *r) { GocItem *item; SheetControlGUI *scg = pane->simple.scg; g_return_if_fail (pane->cursor.rangesel == NULL); /* Hide the primary cursor while the range selection cursor is visible * and we are selecting on a different sheet than the expr being edited */ if (scg_sheet (scg) != wb_control_cur_sheet (scg_wbc (scg))) gnm_item_cursor_set_visibility (pane->cursor.std, FALSE); item = goc_item_new (pane->grid_items, gnm_item_cursor_get_type (), "SheetControlGUI", scg, "style", GNM_ITEM_CURSOR_ANTED, NULL); pane->cursor.rangesel = GNM_ITEM_CURSOR (item); gnm_item_cursor_bound_set (pane->cursor.rangesel, r); } void gnm_pane_rangesel_stop (GnmPane *pane) { g_return_if_fail (pane->cursor.rangesel != NULL); g_clear_object (&pane->cursor.rangesel); /* Make the primary cursor visible again */ gnm_item_cursor_set_visibility (pane->cursor.std, TRUE); gnm_pane_slide_stop (pane); } /****************************************************************************/ gboolean gnm_pane_special_cursor_bound_set (GnmPane *pane, GnmRange const *r) { return gnm_item_cursor_bound_set (pane->cursor.special, r); } void gnm_pane_special_cursor_start (GnmPane *pane, int style, int button) { GocItem *item; GocCanvas *canvas = GOC_CANVAS (pane); g_return_if_fail (pane->cursor.special == NULL); item = goc_item_new ( GOC_GROUP (canvas->root), gnm_item_cursor_get_type (), "SheetControlGUI", pane->simple.scg, "style", style, "button", button, NULL); pane->cursor.special = GNM_ITEM_CURSOR (item); } void gnm_pane_special_cursor_stop (GnmPane *pane) { g_return_if_fail (pane->cursor.special != NULL); g_clear_object (&pane->cursor.special); } void gnm_pane_mouse_cursor_set (GnmPane *pane, GdkCursor *c) { g_object_ref (c); if (pane->mouse_cursor) g_object_unref (pane->mouse_cursor); pane->mouse_cursor = c; } /****************************************************************************/ void gnm_pane_expr_cursor_bound_set (GnmPane *pane, GnmRange const *r, GOColor color) { GnmItemCursor *cursor; cursor = (GnmItemCursor *) goc_item_new (GOC_GROUP (GOC_CANVAS (pane)->root), gnm_item_cursor_get_type (), "SheetControlGUI", pane->simple.scg, "style", GNM_ITEM_CURSOR_EXPR_RANGE, "color", color, NULL); gnm_item_cursor_bound_set (cursor, r); pane->cursor.expr_range = g_slist_prepend (pane->cursor.expr_range, cursor); } void gnm_pane_expr_cursor_stop (GnmPane *pane) { g_slist_free_full (pane->cursor.expr_range, g_object_unref); pane->cursor.expr_range = NULL; } /****************************************************************************/ void gnm_pane_edit_start (GnmPane *pane) { GocCanvas *canvas = GOC_CANVAS (pane); g_return_if_fail (pane->editor == NULL); /* edit item handles visibility checks */ pane->editor = (GnmItemEdit *) goc_item_new ( GOC_GROUP (canvas->root), gnm_item_edit_get_type (), "SheetControlGUI", pane->simple.scg, NULL); } void gnm_pane_edit_stop (GnmPane *pane) { g_clear_object (&pane->editor); } void gnm_pane_objects_drag (GnmPane *pane, SheetObject *so, gdouble new_x, gdouble new_y, int drag_type, gboolean symmetric,gboolean snap_to_grid) { double dx, dy; dx = new_x - pane->drag.last_x; dy = new_y - pane->drag.last_y; pane->drag.had_motion = TRUE; scg_objects_drag (pane->simple.scg, pane, so, &dx, &dy, drag_type, symmetric, snap_to_grid, TRUE); pane->drag.last_x += dx; pane->drag.last_y += dy; } /* new_x and new_y are in world coords */ static void gnm_pane_object_move (GnmPane *pane, GObject *ctrl_pt, gdouble new_x, gdouble new_y, gboolean symmetric, gboolean snap_to_grid) { int const idx = GPOINTER_TO_INT (g_object_get_data (ctrl_pt, "index")); pane->cur_object = g_object_get_data (G_OBJECT (ctrl_pt), "so"); gnm_pane_objects_drag (pane, pane->cur_object, new_x, new_y, idx, symmetric, snap_to_grid); if (idx != 8) gnm_pane_display_obj_size_tip (pane, GOC_ITEM (ctrl_pt)); } static gboolean cb_slide_handler (GnmPane *pane, GnmPaneSlideInfo const *info) { guint64 x, y; SheetControlGUI const *scg = pane->simple.scg; double const scale = 1. / GOC_CANVAS (pane)->pixels_per_unit; x = scg_colrow_distance_get (scg, TRUE, pane->first.col, info->col); x += pane->first_offset.x; y = scg_colrow_distance_get (scg, FALSE, pane->first.row, info->row); y += pane->first_offset.y; gnm_pane_object_move (pane, info->user_data, x * scale, y * scale, FALSE, FALSE); return TRUE; } static void cb_ptr_array_free (GPtrArray *actions) { g_ptr_array_free (actions, TRUE); } /* event and so can be NULL */ void gnm_pane_display_object_menu (GnmPane *pane, SheetObject *so, GdkEvent *event) { SheetControlGUI *scg = pane->simple.scg; GPtrArray *actions = g_ptr_array_new (); GtkWidget *menu; unsigned i = 0; if (NULL != so && (!scg->selected_objects || NULL == g_hash_table_lookup (scg->selected_objects, so))) scg_object_select (scg, so); sheet_object_populate_menu (so, actions); if (actions->len == 0) { g_ptr_array_free (actions, TRUE); return; } menu = sheet_object_build_menu (sheet_object_get_view (so, (SheetObjectViewContainer *) pane), actions, &i); g_object_set_data_full (G_OBJECT (menu), "actions", actions, (GDestroyNotify)cb_ptr_array_free); gtk_widget_show_all (menu); gnumeric_popup_menu (GTK_MENU (menu), event); } static void cb_collect_selected_objs (SheetObject *so, double *coords, GSList **accum) { *accum = g_slist_prepend (*accum, so); } static void cb_pane_popup_menu (GnmPane *pane) { SheetControlGUI *scg = pane->simple.scg; /* ignore new_object, it is not visible, and should not create a * context menu */ if (NULL != scg->selected_objects) { GSList *accum = NULL; g_hash_table_foreach (scg->selected_objects, (GHFunc) cb_collect_selected_objs, &accum); if (NULL != accum && NULL == accum->next) gnm_pane_display_object_menu (pane, accum->data, NULL); g_slist_free (accum); } else { /* the popup-menu signal is a binding. the grid almost always * has focus we need to cheat to find out if the user * realllllly wants a col/row header menu */ gboolean is_col = FALSE; gboolean is_row = FALSE; GdkWindow *gdk_win = gdk_device_get_window_at_position ( gtk_get_current_event_device (), NULL, NULL); if (gdk_win != NULL) { gpointer gtk_win_void = NULL; GtkWindow *gtk_win = NULL; gdk_window_get_user_data (gdk_win, >k_win_void); gtk_win = gtk_win_void; if (gtk_win != NULL) { if (gtk_win == (GtkWindow *)pane->col.canvas) is_col = TRUE; else if (gtk_win == (GtkWindow *)pane->row.canvas) is_row = TRUE; } } scg_context_menu (scg, NULL, is_col, is_row); } } static void control_point_set_cursor (SheetControlGUI const *scg, GocItem *ctrl_pt) { SheetObject *so = g_object_get_data (G_OBJECT (ctrl_pt), "so"); int idx = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (ctrl_pt), "index")); double const *coords = g_hash_table_lookup (scg->selected_objects, so); gboolean invert_h = coords [0] > coords [2]; gboolean invert_v = coords [1] > coords [3]; GdkCursorType cursor; if (goc_canvas_get_direction (ctrl_pt->canvas) == GOC_DIRECTION_RTL) invert_h = !invert_h; switch (idx) { case 1: invert_v = !invert_v; /* fallthrough */ case 6: cursor = invert_v ? GDK_TOP_SIDE : GDK_BOTTOM_SIDE; break; case 3: invert_h = !invert_h; /* fallthrough */ case 4: cursor = invert_h ? GDK_LEFT_SIDE : GDK_RIGHT_SIDE; break; case 2: invert_h = !invert_h; /* fallthrough */ case 0: cursor = invert_v ? (invert_h ? GDK_BOTTOM_RIGHT_CORNER : GDK_BOTTOM_LEFT_CORNER) : (invert_h ? GDK_TOP_RIGHT_CORNER : GDK_TOP_LEFT_CORNER); break; case 7: invert_h = !invert_h; /* fallthrough */ case 5: cursor = invert_v ? (invert_h ? GDK_TOP_RIGHT_CORNER : GDK_TOP_LEFT_CORNER) : (invert_h ? GDK_BOTTOM_RIGHT_CORNER : GDK_BOTTOM_LEFT_CORNER); break; case 8: default : cursor = GDK_FLEUR; } gnm_widget_set_cursor_type (GTK_WIDGET (ctrl_pt->canvas), cursor); } static void target_list_add_list (GtkTargetList *targets, GtkTargetList *added_targets) { unsigned n; GtkTargetEntry *gte; g_return_if_fail (targets != NULL); if (added_targets == NULL) return; gte = gtk_target_table_new_from_list (added_targets, &n); gtk_target_list_add_table (targets, gte, n); gtk_target_table_free (gte, n); } /* * Drag one or more sheet objects using GTK drag and drop, to the same * sheet, another workbook, another gnumeric or a different application. */ static void gnm_pane_drag_begin (GnmPane *pane, SheetObject *so, GdkEvent *event) { GtkTargetList *targets, *im_targets; GocCanvas *canvas = GOC_CANVAS (pane); SheetControlGUI *scg = pane->simple.scg; GSList *objects; SheetObject *imageable = NULL, *exportable = NULL; GSList *ptr; SheetObject *candidate; targets = gtk_target_list_new (drag_types_out, G_N_ELEMENTS (drag_types_out)); objects = go_hash_keys (scg->selected_objects); for (ptr = objects; ptr != NULL; ptr = ptr->next) { candidate = SHEET_OBJECT (ptr->data); if (exportable == NULL && IS_SHEET_OBJECT_EXPORTABLE (candidate)) exportable = candidate; if (imageable == NULL && IS_SHEET_OBJECT_IMAGEABLE (candidate)) imageable = candidate; } if (exportable) { im_targets = sheet_object_exportable_get_target_list (exportable); if (im_targets != NULL) { target_list_add_list (targets, im_targets); gtk_target_list_unref (im_targets); } } if (imageable) { im_targets = sheet_object_get_target_list (imageable); if (im_targets != NULL) { target_list_add_list (targets, im_targets); gtk_target_list_unref (im_targets); } } if (gnm_debug_flag ("dnd")) { unsigned i, n; GtkTargetEntry *gte = gtk_target_table_new_from_list (targets, &n); g_printerr ("%u offered formats:\n", n); for (i = 0; i < n; i++) g_printerr ("%s\n", gte[n].target); gtk_target_table_free (gte, n); } gtk_drag_begin (GTK_WIDGET (canvas), targets, GDK_ACTION_COPY | GDK_ACTION_MOVE, pane->drag.button, event); gtk_target_list_unref (targets); g_slist_free (objects); } void gnm_pane_object_start_resize (GnmPane *pane, int button, guint64 x, gint64 y, SheetObject *so, int drag_type, gboolean is_creation) { GocItem **ctrl_pts; GdkEvent *event; g_return_if_fail (IS_SHEET_OBJECT (so)); g_return_if_fail (0 <= drag_type); g_return_if_fail (drag_type < 9); event = goc_canvas_get_cur_event (GOC_CANVAS (pane)); ctrl_pts = g_hash_table_lookup (pane->drag.ctrl_pts, so); g_return_if_fail (NULL != ctrl_pts); if (is_creation && !sheet_object_can_resize (so)) { scg_objects_drag_commit (pane->simple.scg, 9, TRUE, NULL, NULL, NULL); return; } gnm_simple_canvas_grab (ctrl_pts[drag_type], GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK, NULL, gdk_event_get_time (event)); pane->drag.created_objects = is_creation; pane->drag.button = button; pane->drag.last_x = pane->drag.origin_x = x; pane->drag.last_y = pane->drag.origin_y = y; pane->drag.had_motion = FALSE; gnm_pane_slide_init (pane); gnm_widget_set_cursor_type (GTK_WIDGET (pane), GDK_HAND2); } /* GnmControlCircleItem */ typedef GocCircle GnmControlCircle; typedef GocCircleClass GnmControlCircleClass; #define CONTROL_TYPE_CIRCLE (control_circle_get_type ()) #define CONTROL_CIRCLE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), CONTROL_TYPE_CIRCLE, GnmControlCircle)) #define CONTROL_IS_CIRCLE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), CONTROL_TYPE_CIRCLE)) static GType control_circle_get_type (void); static gboolean control_point_button_pressed (GocItem *item, int button, double x, double y) { GnmPane *pane = GNM_PANE (item->canvas); GdkEventButton *event = (GdkEventButton *) goc_canvas_get_cur_event (item->canvas); SheetObject *so; int idx; if (0 != pane->drag.button) return TRUE; x *= goc_canvas_get_pixels_per_unit (item->canvas); y *= goc_canvas_get_pixels_per_unit (item->canvas); so = g_object_get_data (G_OBJECT (item), "so"); idx = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "index")); switch (event->button) { case 1: case 2: gnm_pane_object_start_resize (pane, button, x, y, so, idx, FALSE); break; case 3: gnm_pane_display_object_menu (pane, so, (GdkEvent *) event); break; default: /* Ignore mouse wheel events */ return FALSE; } return TRUE; } static gboolean control_point_button_released (GocItem *item, int button, G_GNUC_UNUSED double x, G_GNUC_UNUSED double y) { GnmPane *pane = GNM_PANE (item->canvas); GdkEvent *event = goc_canvas_get_cur_event (item->canvas); SheetControlGUI *scg = pane->simple.scg; SheetObject *so; int idx; if (pane->drag.button != button) return TRUE; so = g_object_get_data (G_OBJECT (item), "so"); idx = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "index")); pane->drag.button = 0; gnm_simple_canvas_ungrab (item, gdk_event_get_time (event)); gnm_pane_slide_stop (pane); control_point_set_cursor (scg, item); if (idx == 8) ; /* ignore fake event generated by the dnd code */ else if (pane->drag.had_motion) scg_objects_drag_commit (scg, idx, pane->drag.created_objects, NULL, NULL, NULL); else if (pane->drag.created_objects && idx == 7) { double w, h; sheet_object_default_size (so, &w, &h); scg_objects_drag (scg, NULL, NULL, &w, &h, 7, FALSE, FALSE, FALSE); scg_objects_drag_commit (scg, 7, TRUE, NULL, NULL, NULL); } gnm_pane_clear_obj_size_tip (pane); return TRUE; } static gboolean control_point_motion (GocItem *item, double x, double y) { GnmPane *pane = GNM_PANE (item->canvas); GdkEventMotion *event = (GdkEventMotion *) goc_canvas_get_cur_event (item->canvas); SheetObject *so; int idx; if (0 == pane->drag.button) return TRUE; x *= goc_canvas_get_pixels_per_unit (item->canvas); y *= goc_canvas_get_pixels_per_unit (item->canvas); /* TODO : motion is still too granular along the internal axis * when the other axis is external. * eg drag from middle of sheet down. The x axis is still internal * onlt the y is external, however, since we are autoscrolling * we are limited to moving with col/row coords, not x,y. * Possible solution would be to change the EXTERIOR_ONLY flag * to something like USE_PIXELS_INSTEAD_OF_COLROW and change * the semantics of the col,row args in the callback. However, * that is more work than I want to do right now. */ so = g_object_get_data (G_OBJECT (item), "so"); idx = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "index")); if (idx == 8) gnm_pane_drag_begin (pane, so, (GdkEvent *) event); else if (gnm_pane_handle_motion (pane, item->canvas, x, y, GNM_PANE_SLIDE_X | GNM_PANE_SLIDE_Y | GNM_PANE_SLIDE_EXTERIOR_ONLY, cb_slide_handler, item)) gnm_pane_object_move (pane, G_OBJECT (item), x, y, (event->state & GDK_CONTROL_MASK) != 0, (event->state & GDK_SHIFT_MASK) != 0); return TRUE; } static gboolean control_point_button2_pressed (GocItem *item, int button, G_GNUC_UNUSED double x, G_GNUC_UNUSED double y) { GnmPane *pane = GNM_PANE (item->canvas); SheetControlGUI *scg = pane->simple.scg; SheetObject *so; so = g_object_get_data (G_OBJECT (item), "so"); if (pane->drag.button == 1) sheet_object_get_editor (so, SHEET_CONTROL (scg)); return TRUE; } static void update_control_point_colors (GocItem *item, GtkStateFlags flags) { GtkStyleContext *context = goc_item_get_style_context (item); GOStyle *style = go_styled_object_get_style (GO_STYLED_OBJECT (item)); GdkRGBA rgba; gtk_style_context_get_color (context, flags, &rgba); go_color_from_gdk_rgba (&rgba, &style->line.color); gtk_style_context_get_background_color (context, flags, &rgba); go_color_from_gdk_rgba (&rgba, &style->fill.pattern.back); goc_item_invalidate (item); } static gboolean control_point_enter_notify (GocItem *item, G_GNUC_UNUSED double x, G_GNUC_UNUSED double y) { GnmPane *pane = GNM_PANE (item->canvas); SheetControlGUI *scg = pane->simple.scg; int idx; control_point_set_cursor (scg, item); pane->cur_object = g_object_get_data (G_OBJECT (item), "so"); idx = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "index")); if (idx != 8) { update_control_point_colors (item, GTK_STATE_FLAG_PRELIGHT); gnm_pane_display_obj_size_tip (pane, item); } return TRUE; } static gboolean control_point_leave_notify (GocItem *item, G_GNUC_UNUSED double x, G_GNUC_UNUSED double y) { GnmPane *pane = GNM_PANE (item->canvas); SheetControlGUI *scg = pane->simple.scg; int idx; control_point_set_cursor (scg, item); idx = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "index")); if (idx != 8) { update_control_point_colors (item, GTK_STATE_FLAG_NORMAL); gnm_pane_clear_obj_size_tip (pane); } pane->cur_object = NULL; return TRUE; } static void control_circle_class_init (GocItemClass *item_klass) { item_klass->button_pressed = control_point_button_pressed; item_klass->button_released = control_point_button_released; item_klass->motion = control_point_motion; item_klass->button2_pressed = control_point_button2_pressed; item_klass->enter_notify = control_point_enter_notify; item_klass->leave_notify = control_point_leave_notify; } static GSF_CLASS (GnmControlCircle, control_circle, control_circle_class_init, NULL, GOC_TYPE_CIRCLE) #define ITEM_ACETATE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), item_acetate_get_type (), ItemAcetate)) #define IS_ITEM_ACETATE(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), item_acetate_get_type ())) #define MARGIN 10 static GType item_acetate_get_type (void); typedef GocRectangle ItemAcetate; typedef GocRectangleClass ItemAcetateClass; static double item_acetate_distance (GocItem *item, double x, double y, GocItem **actual_item) { if (x < (item->x0 - MARGIN) || x > (item->x1 + MARGIN) || y < (item->y0 - MARGIN) || y > (item->y1 + MARGIN)) return DBL_MAX; *actual_item = item; return 0.; } static void item_acetate_class_init (GocItemClass *item_class) { item_class->distance = item_acetate_distance; item_class->button_pressed = control_point_button_pressed; item_class->button_released = control_point_button_released; item_class->motion = control_point_motion; item_class->button2_pressed = control_point_button2_pressed; item_class->enter_notify = control_point_enter_notify; item_class->leave_notify = control_point_leave_notify; } static GSF_CLASS (ItemAcetate, item_acetate, item_acetate_class_init, NULL, GOC_TYPE_RECTANGLE) /** * new_control_point: * @pane: #GnmPane * @idx: control point index to be created * @x: x coordinate of control point * @y: y coordinate of control point * * This is used to create a number of control points in a sheet * object, the meaning of them is used in other parts of the code * to belong to the following locations: * * 0 -------- 1 -------- 2 * | | * 3 4 * | | * 5 -------- 6 -------- 7 * * 8 == a clear overlay that extends slightly beyond the region * 9 == an optional stippled rectangle for moving/resizing expensive * objects **/ static GocItem * new_control_point (GnmPane *pane, SheetObject *so, int idx, double x, double y) { GOStyle *style; GocItem *item; int radius, outline; double scale = GOC_CANVAS (pane)->pixels_per_unit; gtk_widget_style_get (GTK_WIDGET (pane), "control-circle-size", &radius, "control-circle-outline", &outline, NULL); style = go_style_new (); style->line.width = outline; style->line.auto_color = FALSE; style->line.dash_type = GO_LINE_SOLID; /* anything but 0 */ style->line.pattern = GO_PATTERN_SOLID; item = goc_item_new ( pane->action_items, CONTROL_TYPE_CIRCLE, "x", x, "y", y, "radius", radius / scale, NULL); g_object_unref (style); update_control_point_colors (item, GTK_STATE_FLAG_NORMAL); g_object_set_data (G_OBJECT (item), "index", GINT_TO_POINTER (idx)); g_object_set_data (G_OBJECT (item), "so", so); return item; } /** * set_item_x_y: * Changes the x and y position of the idx-th control point, * creating the control point if necessary. **/ static void set_item_x_y (GnmPane *pane, SheetObject *so, GocItem **ctrl_pts, int idx, double x, double y, gboolean visible) { double scale = GOC_CANVAS (pane)->pixels_per_unit; if (ctrl_pts[idx] == NULL) ctrl_pts[idx] = new_control_point (pane, so, idx, x / scale, y / scale); else goc_item_set (ctrl_pts[idx], "x", x / scale, "y", y / scale, NULL); if (visible) goc_item_show (ctrl_pts[idx]); else goc_item_hide (ctrl_pts[idx]); } #define normalize_high_low(d1,d2) if (d1action_items, GOC_TYPE_RECTANGLE, NULL); context = goc_item_get_style_context (item); gtk_style_context_add_class (context, "object-size"); gtk_style_context_add_class (context, "rubber-band"); style->fill.auto_type = FALSE; style->fill.type = GO_STYLE_FILL_PATTERN; style->fill.auto_back = FALSE; style->fill.pattern.back = 0; style->fill.auto_fore = FALSE; style->fill.pattern.fore = 0; style->line.pattern = GO_PATTERN_FOREGROUND_SOLID; style->line.width = 0.; style->line.auto_color = FALSE; style->line.color = 0; gtk_style_context_get_color (context, GTK_STATE_FLAG_NORMAL, &rgba); go_color_from_gdk_rgba (&rgba, &style->line.fore); go_styled_object_set_style (GO_STYLED_OBJECT (item), style); g_object_unref (style); goc_item_lower_to_bottom (item); } normalize_high_low (r, l); normalize_high_low (b, t); goc_item_set (ctrl_pts[9], "x", l / scale, "y", t / scale, "width", (r - l) / scale, "height", (b - t) / scale, NULL); } else { double coords[4]; SheetObjectView *sov = sheet_object_get_view (so, (SheetObjectViewContainer *)pane); if (NULL == sov) sov = sheet_object_new_view (so, (SheetObjectViewContainer *)pane); coords [0] = l; coords [2] = r; coords [1] = t; coords [3] = b; if (NULL != sov) sheet_object_view_set_bounds (sov, coords, TRUE); normalize_high_low (r, l); normalize_high_low (b, t); } gtk_widget_style_get (GTK_WIDGET (pane), "control-circle-size", &radius, "control-circle-outline", &outline, NULL); l -= (radius + outline) / 2 - 1; r += (radius + outline) / 2; t -= (radius + outline) / 2 - 1; b += (radius + outline) / 2; if (NULL == ctrl_pts[8]) { GOStyle *style = go_style_new (); GocItem *item; style->fill.auto_type = FALSE; style->fill.type = GO_STYLE_FILL_PATTERN; style->fill.auto_back = FALSE; go_pattern_set_solid (&style->fill.pattern, 0); style->line.auto_dash = FALSE; style->line.dash_type = GO_LINE_NONE; /* work around the screwup in shapes that adds a large * border to anything that uses miter (is this required for * a rectangle in goc-canvas? */ style->line.join = CAIRO_LINE_JOIN_ROUND; item = goc_item_new ( pane->action_items, item_acetate_get_type (), "style", style, NULL); g_object_unref (style); g_object_set_data (G_OBJECT (item), "index", GINT_TO_POINTER (8)); g_object_set_data (G_OBJECT (item), "so", so); ctrl_pts[8] = item; } goc_item_set (ctrl_pts[8], "x", l / scale, "y", t / scale, "width", (r - l) / scale, "height", (b - t) / scale, NULL); } void gnm_pane_object_unselect (GnmPane *pane, SheetObject *so) { gnm_pane_clear_obj_size_tip (pane); g_hash_table_remove (pane->drag.ctrl_pts, so); } /** * gnm_pane_object_update_bbox: * @pane: #GnmPane * @so: #SheetObject * * Updates the position and potentially creates control points * for manipulating the size/position of @so. **/ void gnm_pane_object_update_bbox (GnmPane *pane, SheetObject *so) { GocItem **ctrl_pts = g_hash_table_lookup (pane->drag.ctrl_pts, so); double const *pts = g_hash_table_lookup ( pane->simple.scg->selected_objects, so); int radius, outline, total_size; if (ctrl_pts == NULL) { ctrl_pts = g_new0 (GocItem *, 10); g_hash_table_insert (pane->drag.ctrl_pts, so, ctrl_pts); } g_return_if_fail (ctrl_pts != NULL); gtk_widget_style_get (GTK_WIDGET (pane), "control-circle-size", &radius, "control-circle-outline", &outline, NULL); /* space for 2 halves and a full */ total_size = radius * 4 + outline * 2; /* set the acetate 1st so that the other points will override it */ set_acetate_coords (pane, so, ctrl_pts, pts[0], pts[1], pts[2], pts[3]); if (sheet_object_can_resize (so)) { set_item_x_y (pane, so, ctrl_pts, 0, pts[0], pts[1], TRUE); set_item_x_y (pane, so, ctrl_pts, 1, (pts[0] + pts[2]) / 2, pts[1], fabs (pts[2]-pts[0]) >= total_size); set_item_x_y (pane, so, ctrl_pts, 2, pts[2], pts[1], TRUE); set_item_x_y (pane, so, ctrl_pts, 3, pts[0], (pts[1] + pts[3]) / 2, fabs (pts[3]-pts[1]) >= total_size); set_item_x_y (pane, so, ctrl_pts, 4, pts[2], (pts[1] + pts[3]) / 2, fabs (pts[3]-pts[1]) >= total_size); set_item_x_y (pane, so, ctrl_pts, 5, pts[0], pts[3], TRUE); set_item_x_y (pane, so, ctrl_pts, 6, (pts[0] + pts[2]) / 2, pts[3], fabs (pts[2]-pts[0]) >= total_size); set_item_x_y (pane, so, ctrl_pts, 7, pts[2], pts[3], TRUE); } } static void cb_bounds_changed (SheetObject *so, GocItem *sov) { double coords[4], *cur; SheetControlGUI *scg = GNM_SIMPLE_CANVAS (sov->canvas)->scg; if (GNM_PANE (sov->canvas)->drag.button != 0) return; /* do not reset bounds during drag */ scg_object_anchor_to_coords (scg, sheet_object_get_anchor (so), coords); if (NULL != scg->selected_objects && NULL != (cur = g_hash_table_lookup (scg->selected_objects, so))) { int i; for (i = 4; i-- > 0 ;) cur[i] = coords[i]; gnm_pane_object_update_bbox (GNM_PANE (sov->canvas), so); } sheet_object_view_set_bounds (SHEET_OBJECT_VIEW (sov), coords, so->flags & SHEET_OBJECT_IS_VISIBLE); } /** * gnm_pane_object_register: * @so: A sheet object * @view: A canvas item acting as a view for @so * @selectable: Add handlers for selecting and editing the object * * Setup some standard callbacks for manipulating a view of a sheet object. * Returns: (transfer none): @view set to a #SheetObjectView. **/ SheetObjectView * gnm_pane_object_register (SheetObject *so, GocItem *view, gboolean selectable) { g_signal_connect_object (so, "bounds-changed", G_CALLBACK (cb_bounds_changed), view, 0); return SHEET_OBJECT_VIEW (view); } /** * gnm_pane_object_widget_register: * @so: A sheet object * @widget: The widget for the sheet object view * @view: A canvas item acting as a view for @so * * Setup some standard callbacks for manipulating widgets as views of sheet * objects. **/ void gnm_pane_widget_register (SheetObject *so, GtkWidget *w, GocItem *view) { if (GTK_IS_CONTAINER (w)) { GList *ptr, *children = gtk_container_get_children (GTK_CONTAINER (w)); for (ptr = children ; ptr != NULL; ptr = ptr->next) gnm_pane_widget_register (so, ptr->data, view); g_list_free (children); } } void gnm_pane_set_direction (GnmPane *pane, GocDirection direction) { goc_canvas_set_direction (GOC_CANVAS (pane), direction); if (pane->col.canvas != NULL) goc_canvas_set_direction (pane->col.canvas, direction); }