/* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /** * dialog-printer-setup.c: Printer setup dialog box * * Authors: * Wayne Schuller (k_wayne@linuxpower.org) * Miguel de Icaza (miguel@gnu.org) * Andreas J. Guelzow (aguelzow@pyrshep.ca) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include "dialogs.h" #include "help.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define PREVIEW_MARGIN_X 20 #define PREVIEW_MARGIN_Y 20 #define MARGIN_COLOR_DEFAULT 0xa9a9a9ff /* dark gray */ #define MARGIN_COLOR_ACTIVE GO_COLOR_RED /* FIXME: do not hardcode pixel counts. */ #define HF_PREVIEW_X 350 #define HF_PREVIEW_Y 75 #define HF_PREVIEW_SHADOW 2 #define HF_PREVIEW_PADDING 5 #define HF_PREVIEW_MARGIN 10 #define PRINTER_SETUP_KEY "printer-setup-dialog" #define PAPER_PAGE 0 #define SCALE_PAGE 1 #define HF_PAGE 2 #define HF_TAG_NAME "field_tag" typedef struct { /* The Canvas object */ GtkWidget *canvas; /* Objects in the Preview Canvas */ GocItem *group; /* Values for the scaling of the nice preview */ int width, height; int offset_x, offset_y; /* For centering the small page preview */ double scale; } MarginPreviewInfo; typedef struct { /* The available width and height for the nice preview page */ guint height, width; } MarginPreviewPageAvailableSize; typedef struct { /* The Canvas object for the header/footer sample preview */ GtkWidget *canvas; /* Objects in the Preview Canvas */ GocItem *left; GocItem *middle; GocItem *right; } HFPreviewInfo; typedef struct _PrinterSetupState PrinterSetupState; typedef struct { double value; GtkSpinButton *spin; GocItem *line; double bound_x1, bound_y1, bound_x2, bound_y2; MarginPreviewInfo *pi; PrinterSetupState *state; } UnitInfo; struct _PrinterSetupState { WBCGtk *wbcg; Sheet *sheet; GtkBuilder *gui; PrintInformation *pi; GtkWidget *dialog; GtkWidget *sheet_selector; GtkWidget *scale_percent_radio; GtkWidget *scale_fit_to_radio; GtkWidget *scale_no_radio; GtkWidget *portrait_radio; GtkWidget *landscape_radio; GtkWidget *rev_portrait_radio; GtkWidget *rev_landscape_radio; GtkWidget *unit_selector; GtkTreeModel *unit_model; GtkUnit display_unit; struct { UnitInfo top, bottom, left, right; UnitInfo header, footer; } margins; MarginPreviewInfo preview; double height, width; GtkWidget * check_center_v; GtkWidget * check_center_h; GtkWidget *icon_rd; GtkWidget *icon_dr; GnmExprEntry *area_entry; GnmExprEntry *top_entry; GnmExprEntry *left_entry; /* The header and footer data. */ PrintHF *header; PrintHF *footer; /* The header and footer customize dialogs. */ GtkWidget *customize_header; GtkWidget *customize_footer; /* The header and footer preview widgets. */ HFPreviewInfo *pi_header; HFPreviewInfo *pi_footer; /* Error Display */ struct { GtkListStore *store; GtkWidget *combo; } error_display; /* Comment Display */ struct { GtkListStore *store; GtkWidget *combo; } comment_display; }; typedef struct _HFCustomizeState HFCustomizeState; typedef struct _HFDTFormatState HFDTFormatState; struct _HFDTFormatState { GtkWidget *dialog; GtkBuilder *gui; HFCustomizeState *hf_state; char *format_string; GtkWidget *format_sel; }; struct _HFCustomizeState { GtkWidget *dialog; GtkBuilder *gui; PrinterSetupState *printer_setup_state; PrintHF **hf; gboolean is_header; GtkTextBuffer *left_buffer; GtkTextBuffer *middle_buffer; GtkTextBuffer *right_buffer; GList *marks; }; typedef enum { HF_FIELD_UNKNOWN, HF_FIELD_FILE, HF_FIELD_PATH, HF_FIELD_DATE, HF_FIELD_TIME, HF_FIELD_PAGE, HF_FIELD_PAGES, HF_FIELD_SHEET, HF_FIELD_CELL } HFFieldType; typedef struct _HFMarkInfo HFMarkInfo; struct _HFMarkInfo { GtkTextMark *mark; HFFieldType type; char *options; }; static void dialog_gtk_printer_setup_cb (PrinterSetupState *state); static void fetch_settings (PrinterSetupState *state); static void do_update_page (PrinterSetupState *state); static void do_fetch_margins (PrinterSetupState *state); static void do_hf_customize (gboolean header, PrinterSetupState *state); static char *do_hf_dt_format_customize (gboolean date, HFCustomizeState *hf_state); static double get_conversion_factor (GtkUnit unit) { switch (unit) { case GTK_UNIT_MM: return (72./25.4); case GTK_UNIT_INCH: return 72.; case GTK_UNIT_PIXEL: case GTK_UNIT_POINTS: default: return 1.0; } } static void margin_preview_page_destroy (PrinterSetupState *state) { if (state->preview.group) { g_object_unref (state->preview.group); state->preview.group = NULL; } } static void move_line (GocItem *item, double x1, double y1, double x2, double y2) { if (item != NULL) goc_item_set (item, "x0", floor (x1) + .5, "y0", floor (y1) + .5, "x1", floor (x2) + .5, "y1", floor (y2) + .5, NULL); } static GocItem * make_line (GocGroup *g, double x1, double y1, double x2, double y2) { GocItem *item; GOStyle *style; item = goc_item_new ( g, goc_line_get_type (), "x0", floor (x1) + .5, "y0", floor (y1) + .5, "x1", floor (x2) + .5, "y1", floor (y2) + .5, NULL); style = go_styled_object_get_style (GO_STYLED_OBJECT (item)); style->line.width = 1.; style->line.color = MARGIN_COLOR_DEFAULT; return item; } static void draw_margin_top (UnitInfo *uinfo) { double x1, x2, y1; x1 = uinfo->bound_x1; x2 = uinfo->bound_x2; y1 = uinfo->bound_y1; y1 += uinfo->pi->scale * uinfo->value; move_line (uinfo->line, x1, y1, x2, y1); } static void draw_margin_bottom (UnitInfo *uinfo) { double x1, x2, y2; x1 = uinfo->bound_x1; x2 = uinfo->bound_x2; y2 = uinfo->bound_y2; y2 -= uinfo->pi->scale * uinfo->value; move_line (uinfo->line, x1, y2, x2, y2); } static void draw_margin_left (UnitInfo *uinfo) { double x1, y1, y2; x1 = uinfo->bound_x1; y1 = uinfo->bound_y1; y2 = uinfo->bound_y2; x1 += uinfo->pi->scale * uinfo->value; move_line (uinfo->line, x1, y1, x1, y2); } static void draw_margin_right (UnitInfo *uinfo) { double y1, x2, y2; y1 = uinfo->bound_y1; x2 = uinfo->bound_x2; y2 = uinfo->bound_y2; x2 -= uinfo->pi->scale * uinfo->value; move_line (uinfo->line, x2, y1, x2, y2); } static void draw_margin_header (UnitInfo *uinfo) { double x1, y1, x2; double outside = uinfo->pi->scale * uinfo->state->margins.top.value; double inside = uinfo->pi->scale * uinfo->value; x1 = uinfo->bound_x1; y1 = uinfo->bound_y1; x2 = uinfo->bound_x2; if (inside < 1.0) inside = 1.0; y1 += outside + inside ; move_line (uinfo->line, x1, y1, x2, y1); } static void draw_margin_footer (UnitInfo *uinfo) { double x1, x2, y2; double outside = uinfo->pi->scale * uinfo->state->margins.bottom.value; double inside = uinfo->pi->scale * uinfo->value; x1 = uinfo->bound_x1; x2 = uinfo->bound_x2; y2 = uinfo->bound_y2; if (inside < 1.0) inside = 1.0; y2 -= outside + inside ; move_line (uinfo->line, x1, y2, x2, y2); } static void create_margin (UnitInfo *uinfo, double x1, double y1, double x2, double y2) { GocGroup *g = GOC_GROUP (uinfo->state->preview.group); uinfo->line = make_line (g, x1 + 8, y1, x1 + 8, y2); uinfo->bound_x1 = x1; uinfo->bound_y1 = y1; uinfo->bound_x2 = x2; uinfo->bound_y2 = y2; } static void draw_margins (PrinterSetupState *state, double x1, double y1, double x2, double y2) { /* Margins */ create_margin (&state->margins.left, x1, y1, x2, y2); create_margin (&state->margins.right, x1, y1, x2, y2); create_margin (&state->margins.top, x1, y1, x2, y2); create_margin (&state->margins.bottom, x1, y1, x2, y2); /* Headers & footers */ create_margin (&state->margins.header, x1, y1, x2, y2); create_margin (&state->margins.footer, x1, y1, x2, y2); /* Margins */ draw_margin_left (&state->margins.left); draw_margin_right (&state->margins.right); draw_margin_top (&state->margins.top); draw_margin_bottom (&state->margins.bottom); /* Headers & footers */ draw_margin_header (&state->margins.header); draw_margin_footer (&state->margins.footer); } static void margin_preview_page_available_size (PrinterSetupState *state, MarginPreviewPageAvailableSize *available_size) { GList *children, *l; GtkWidget *grid; unsigned *widths, *heights; GtkRequisition requisition; unsigned top, left, width, height, i; unsigned nrows, ncols, first_col, first_row; /* Reset available size to zero*/ available_size->width = 0; available_size->height = 0; grid = go_gtk_builder_get_widget (state->gui, "paper-selector-grid"); gtk_container_child_get (GTK_CONTAINER (grid), go_gtk_builder_get_widget (state->gui, "container-paper-sample"), "top-attach", &first_row, "left-attach", &first_col, "width", &ncols, "height", &nrows, NULL); widths = g_new0 (guint, ncols); heights = g_new0 (guint, nrows); /* Iterate through all child widgets in the grid */ children = gtk_container_get_children (GTK_CONTAINER (grid)); for (l = children; l; l = l->next) { GtkWidget *child_widget = l->data; /* Determine which cells the align widget spans across */ gtk_container_child_get (GTK_CONTAINER (grid), GTK_WIDGET (child_widget), "top-attach", &top, "left-attach", &left, "width", &width, "height", &height, NULL); /* Determine the requisition size for the widget */ gtk_widget_get_preferred_size (GTK_WIDGET(child_widget), &requisition, NULL); /* Find largest widget in each table column */ /* Exclude widgets that expand across more than one grid cells * or are not in a relevant column */ if (left >= first_col && width == 1 && left < first_col + ncols) { if ((guint) requisition.width > widths[left - first_col]) { widths[left - first_col] = (guint) requisition.width; } } /* Find largest widget in each table row */ /* Exclude widgets that expand across more than one grid cells * or are not in a relevant column */ if (top >= first_row && height == 1 && top < first_row + nrows) { if ((guint) requisition.height > heights[top - first_row]) { heights[top - first_row] = (guint) requisition.height; } } } g_list_free (children); /* Calculate width of container widget using maximum */ /* widget widths from above */ for (i = 0; i < ncols; i++){ available_size->width = available_size->width + widths[i]; } /* Calculate height of container widget using maximum */ /* widget heights from above */ for (i = 0; i < nrows; i++){ available_size->height = available_size->height + heights[i]; } g_free(widths); g_free(heights); /* Account for the spacing between table cells */ available_size->width = available_size->width + gtk_grid_get_column_spacing (GTK_GRID (grid)) * (ncols - 1); available_size->height = available_size->height + gtk_grid_get_row_spacing (GTK_GRID (grid)) * (nrows - 1); } static void margin_preview_page_create (PrinterSetupState *state) { double x1, y1, x2, y2; double width, height; MarginPreviewInfo *pi = &state->preview; GOStyle *style; MarginPreviewPageAvailableSize margin_available_size; margin_preview_page_available_size (state, &margin_available_size); gtk_widget_set_size_request (state->preview.canvas, margin_available_size.width, margin_available_size.height); width = state->width; height = state->height; x1 = (margin_available_size.width - PREVIEW_MARGIN_X) / width; x2 = (margin_available_size.height - PREVIEW_MARGIN_Y) / height; pi->scale = MIN (x1, x2); pi->offset_x = (margin_available_size.width - (width * pi->scale)) / 2; pi->offset_y = (margin_available_size.height - (height * pi->scale)) / 2; x1 = pi->offset_x; y1 = pi->offset_y; x2 = pi->offset_x + width * pi->scale; y2 = pi->offset_y + height * pi->scale; pi->group = goc_item_new ( goc_canvas_get_root (GOC_CANVAS (pi->canvas)), goc_group_get_type (), "x", 0.0, "y", 0.0, NULL); style = go_styled_object_get_style ( GO_STYLED_OBJECT (goc_item_new (GOC_GROUP (pi->group), GOC_TYPE_RECTANGLE, "x", (double) x1+2, "y", (double) y1+2, "width", (double) x2-x1, "height", (double) y2-y1, NULL))); style->fill.pattern.back = GO_COLOR_BLACK; style->line.color = GO_COLOR_BLACK; style->line.width = 1.; style = go_styled_object_get_style ( GO_STYLED_OBJECT (goc_item_new (GOC_GROUP (pi->group), GOC_TYPE_RECTANGLE, "x", (double) x1, "y", (double) y1, "width", (double) x2-x1, "height", (double) y2-y1, NULL))); style->fill.pattern.back = GO_COLOR_WHITE; style->line.color = GO_COLOR_BLACK; style->line.width = 1.; goc_item_invalidate (pi->group); draw_margins (state, x1, y1, x2, y2); } static void canvas_update (PrinterSetupState *state) { margin_preview_page_destroy (state); margin_preview_page_create (state); } static gboolean cb_spin_activated (UnitInfo *target) { GOStyle *style = go_styled_object_get_style (GO_STYLED_OBJECT (target->line)); style->fill.pattern.back = MARGIN_COLOR_ACTIVE, goc_item_invalidate (target->line); return FALSE; } static gboolean cb_spin_deactivated (UnitInfo *target) { GOStyle *style = go_styled_object_get_style (GO_STYLED_OBJECT (target->line)); style->fill.pattern.back = MARGIN_COLOR_DEFAULT, goc_item_invalidate (target->line); return FALSE; return FALSE; } static void configure_bounds_header (PrinterSetupState *state) { double max = state->height - state->margins.top.value - state->margins.footer.value - state->margins.bottom.value; gtk_spin_button_set_range (state->margins.header.spin, 0., max); } static void configure_bounds_footer (PrinterSetupState *state) { double max = state->height - state->margins.header.value - state->margins.top.value - state->margins.bottom.value; gtk_spin_button_set_range (state->margins.footer.spin, 0., max); } static void configure_bounds_bottom (PrinterSetupState *state) { double max = state->height - state->margins.header.value - state->margins.footer.value - state->margins.top.value; gtk_spin_button_set_range (state->margins.bottom.spin, 0., max); } static void configure_bounds_top (PrinterSetupState *state) { double max = state->height - state->margins.header.value - state->margins.footer.value - state->margins.bottom.value; gtk_spin_button_set_range (state->margins.top.spin, 0., max); } static void configure_bounds_left (PrinterSetupState *state) { double max = state->width - state->margins.right.value; gtk_spin_button_set_range (state->margins.left.spin, 0., max); } static void configure_bounds_right (PrinterSetupState *state) { double max = state->width - state->margins.left.value; gtk_spin_button_set_range (state->margins.right.spin, 0., max); } static void value_changed_header_cb (gpointer user_data) { UnitInfo *target = user_data; target->value = gtk_spin_button_get_value (target->spin); configure_bounds_top (target->state); configure_bounds_bottom (target->state); configure_bounds_footer (target->state); draw_margin_header (target); } static void value_changed_footer_cb (gpointer user_data) { UnitInfo *target = user_data; target->value = gtk_spin_button_get_value (target->spin); configure_bounds_top (target->state); configure_bounds_bottom (target->state); configure_bounds_header (target->state); draw_margin_footer (target); } static void value_changed_top_cb (gpointer user_data) { UnitInfo *target = user_data; target->value = gtk_spin_button_get_value (target->spin); configure_bounds_header (target->state); configure_bounds_bottom (target->state); configure_bounds_footer (target->state); draw_margin_top (target); draw_margin_header (&target->state->margins.header); } static void value_changed_bottom_cb (gpointer user_data) { UnitInfo *target = user_data; target->value = gtk_spin_button_get_value (target->spin); configure_bounds_header (target->state); configure_bounds_top (target->state); configure_bounds_footer (target->state); draw_margin_bottom (target); draw_margin_footer (&target->state->margins.footer); } static void value_changed_left_cb (gpointer user_data) { UnitInfo *target = user_data; target->value = gtk_spin_button_get_value (target->spin); configure_bounds_right (target->state); draw_margin_left (target); } static void value_changed_right_cb (gpointer user_data) { UnitInfo *target = user_data; target->value = gtk_spin_button_get_value (target->spin); configure_bounds_left (target->state); draw_margin_right (target); } static void margin_spin_configure (UnitInfo *target, PrinterSetupState *state, const char *spin_name, void (*value_changed_cb) (gpointer user_data)) { target->value = 0.; target->pi = &state->preview; target->spin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, spin_name)); target->state = state; gtk_spin_button_set_update_policy (target->spin, GTK_UPDATE_IF_VALID); g_signal_connect_swapped (G_OBJECT (target->spin), "value_changed", G_CALLBACK (value_changed_cb), target); g_signal_connect_swapped (G_OBJECT (target->spin), "focus_in_event", G_CALLBACK (cb_spin_activated), target); g_signal_connect_swapped (G_OBJECT (target->spin), "focus_out_event", G_CALLBACK (cb_spin_deactivated), target); } static void cb_unit_selector_changed (G_GNUC_UNUSED GtkComboBox *widget, PrinterSetupState *state) { GtkTreeIter iter; GtkUnit unit; g_return_if_fail (state != NULL); if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (state->unit_selector), &iter)) { gtk_tree_model_get (state->unit_model, &iter, 1, &unit, -1); do_fetch_margins (state); state->display_unit = unit; do_update_page (state); } } static gint unit_sort_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, G_GNUC_UNUSED gpointer user_data) { char *str_a; char *str_b; gint result; gtk_tree_model_get (model, a, 0, &str_a, -1); gtk_tree_model_get (model, b, 0, &str_b, -1); result = g_utf8_collate (str_a, str_b); g_free (str_a); g_free (str_b); return result; } /** * Header and footer are stored with Excel semantics, but displayed with * more natural semantics. In Excel, both top margin and header are measured * from top of sheet. The Gnumeric user interface presents header as the * band between top margin and the print area. Bottom margin and footer are * handled likewise. See illustration at top of src/print.c */ static void do_setup_margin (PrinterSetupState *state) { GtkWidget *grid, *container; MarginPreviewPageAvailableSize margin_available_size; { GtkListStore *list_store; GtkTreeIter iter; GtkTreeIter current; GtkCellRenderer *text_renderer; list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, 0, (_("points")), 1, GTK_UNIT_POINTS, -1); if (GTK_UNIT_POINTS == state->display_unit) current = iter; gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, 0, (_("inches")), 1, GTK_UNIT_INCH, -1); if (GTK_UNIT_INCH == state->display_unit) current = iter; gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, 0, (_("mm")), 1, GTK_UNIT_MM, -1); if (GTK_UNIT_MM == state->display_unit) current = iter; gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (list_store), unit_sort_func, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); state->unit_selector = gtk_combo_box_new_with_model (GTK_TREE_MODEL (list_store)); state->unit_model = GTK_TREE_MODEL (list_store); text_renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(state->unit_selector), text_renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(state->unit_selector), text_renderer, "text", 0); gtk_combo_box_set_active_iter (GTK_COMBO_BOX (state->unit_selector), ¤t); } grid = go_gtk_builder_get_widget (state->gui, "paper-selector-grid"); gtk_widget_set_hexpand (state->unit_selector, TRUE); gtk_grid_attach (GTK_GRID (grid), state->unit_selector, 3, 8, 1, 1); g_signal_connect (G_OBJECT (state->unit_selector), "changed", G_CALLBACK (cb_unit_selector_changed), state); gtk_widget_show (state->unit_selector); margin_preview_page_available_size (state, &margin_available_size); g_return_if_fail (state && state->pi); state->preview.canvas = GTK_WIDGET (g_object_new (GOC_TYPE_CANVAS, NULL)); gtk_widget_set_size_request (state->preview.canvas, margin_available_size.width, margin_available_size.height); gtk_widget_show (state->preview.canvas); margin_spin_configure (&state->margins.header, state, "spin-header", value_changed_header_cb); margin_spin_configure (&state->margins.footer, state, "spin-footer", value_changed_footer_cb); margin_spin_configure (&state->margins.top, state, "spin-top", value_changed_top_cb); margin_spin_configure (&state->margins.bottom, state, "spin-bottom", value_changed_bottom_cb); margin_spin_configure (&state->margins.left, state, "spin-left", value_changed_left_cb); margin_spin_configure (&state->margins.right, state, "spin-right", value_changed_right_cb); state->check_center_h = go_gtk_builder_get_widget (state->gui, "check_center_h"); state->check_center_v = go_gtk_builder_get_widget (state->gui, "check_center_v"); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (state->check_center_v), state->pi->center_vertically == 1); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (state->check_center_h), state->pi->center_horizontally == 1); container = go_gtk_builder_get_widget (state->gui, "container-paper-sample"); gtk_container_add (GTK_CONTAINER (container), state->preview.canvas); } /* Display the header or footer preview in the print setup dialog. * Use the canvas widget in the HFPreviewInfo struct. * */ static void display_hf_preview (PrinterSetupState *state, gboolean header) { gchar *text = NULL; PrintHF *sample = NULL; HFRenderInfo *hfi; HFPreviewInfo *pi; g_return_if_fail (state != NULL); hfi = hf_render_info_new (); hfi->page = 1; hfi->pages = 99; hfi->sheet = state->sheet; if (header) { pi = state->pi_header; sample = state->header; } else { pi = state->pi_footer; sample = state->footer; } text = hf_format_render (sample->left_format, hfi, HF_RENDER_PRINT); goc_item_set (pi->left, "text", text ? text : "", NULL); g_free (text); text = hf_format_render (sample->middle_format, hfi, HF_RENDER_PRINT); goc_item_set (pi->middle, "text", text ? text : "", NULL); g_free (text); text = hf_format_render (sample->right_format, hfi, HF_RENDER_PRINT); goc_item_set (pi->right, "text", text ? text : "", NULL); g_free (text); hf_render_info_destroy (hfi); } static void do_header_customize (PrinterSetupState *state) { do_hf_customize (TRUE, state); } static void do_footer_customize (PrinterSetupState *state) { do_hf_customize (FALSE, state); } static void header_changed (GtkComboBox *menu, PrinterSetupState *state) { GList *selection = g_list_nth (hf_formats, gtk_combo_box_get_active (menu)); PrintHF *format = (selection)? selection->data: NULL; if (format == NULL) { do_header_customize (state); } else { print_hf_free (state->header); state->header = print_hf_copy (format); } display_hf_preview (state, TRUE); } static void footer_changed (GtkComboBox *menu, PrinterSetupState *state) { GList *selection = g_list_nth (hf_formats, gtk_combo_box_get_active (menu)); PrintHF *format = (selection)? selection->data: NULL; if (format == NULL) { do_footer_customize (state); } else { print_hf_free (state->footer); state->footer = print_hf_copy (format); } display_hf_preview (state, FALSE); } static char * create_hf_name (char const *left, char const *middle, char const *right) { char *this, *res; res = g_strdup_printf ("%s%s%s%s%s", left," \xe2\x90\xa3 ", middle, " \xe2\x90\xa3 ", right); this = res; while (*this) { if (*this == '\n') { char *newstring; *this = 0; newstring = g_strconcat (res, "\xe2\x90\xa4", this + 1, NULL); this = newstring + (this - res); g_free (res); res = newstring; } else this = g_utf8_find_next_char (this, NULL); } return res; } static void append_hf_item (GtkListStore *store, PrintHF *format, HFRenderInfo *hfi) { GtkTreeIter iter; char *left, *middle, *right; char *res; left = hf_format_render (format->left_format, hfi, HF_RENDER_PRINT); middle = hf_format_render (format->middle_format, hfi, HF_RENDER_PRINT); right = hf_format_render (format->right_format, hfi, HF_RENDER_PRINT); res = create_hf_name (left, middle, right); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, res, -1); g_free (res); g_free (left); g_free (middle); g_free (right); } /* * Fills one of the GtkCombos for headers or footers with the list * of existing header/footer formats */ static void fill_hf (PrinterSetupState *state, GtkComboBox *om, GCallback callback, gboolean header) { GList *l; HFRenderInfo *hfi; GtkListStore *store; PrintHF *select = header ? state->header : state->footer; int i, idx = -1; hfi = hf_render_info_new (); hfi->page = 1; hfi->pages = 99; store = gtk_list_store_new (1, G_TYPE_STRING); gtk_combo_box_set_model (om, GTK_TREE_MODEL (store)); g_object_unref (store); for (i = 0, l = hf_formats; l; l = l->next, i++) { PrintHF *format = l->data; if (print_hf_same (format, select)) idx = i; append_hf_item (store, format, hfi); } if (idx < 0) g_critical ("Current format is not registered!"); gtk_combo_box_set_active (om, idx); g_signal_connect (G_OBJECT (om), "changed", callback, state); hf_render_info_destroy (hfi); } static void do_setup_hf_menus (PrinterSetupState *state) { GtkComboBox *header; GtkComboBox *footer; g_return_if_fail (state != NULL); header = GTK_COMBO_BOX (go_gtk_builder_get_widget (state->gui, "option-menu-header")); footer = GTK_COMBO_BOX (go_gtk_builder_get_widget (state->gui, "option-menu-footer")); if (state->header) print_hf_register (state->header); if (state->footer) print_hf_register (state->footer); if (state->header) fill_hf (state, header, G_CALLBACK (header_changed), TRUE); if (state->footer) fill_hf (state, footer, G_CALLBACK (footer_changed), FALSE); } /************* Header Footer Customization *********** Start *************/ static void hf_delete_tag_cb (HFCustomizeState *hf_state) { GtkWidget* focus; focus = gtk_window_get_focus (GTK_WINDOW (hf_state->dialog)); if (GTK_IS_TEXT_VIEW (focus)) { GtkTextBuffer *textbuffer; GtkTextTag *tag; GtkTextIter start; GtkTextIter end; textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focus)); tag = gtk_text_tag_table_lookup (gtk_text_buffer_get_tag_table (textbuffer), HF_TAG_NAME); gtk_text_buffer_get_selection_bounds (textbuffer, &start, &end); if (gtk_text_iter_has_tag (&start, tag) && !gtk_text_iter_begins_tag (&start, tag)) gtk_text_iter_backward_to_tag_toggle (&start, tag); if (gtk_text_iter_has_tag (&end, tag) && !gtk_text_iter_toggles_tag (&end, tag)) gtk_text_iter_forward_to_tag_toggle (&end, tag); gtk_text_buffer_delete (textbuffer, &start, &end); } } static void hf_insert_hf_stock_tag (HFCustomizeState *hf_state, GtkTextBuffer *buffer, HFFieldType type, const char *options) { GtkTextIter iter; gchar const *stock_id; GdkPixbuf* pix; GtkTextMark *new_mark; HFMarkInfo *mark_info; switch (type) { case HF_FIELD_FILE: stock_id = GTK_STOCK_FILE; break; case HF_FIELD_PATH: stock_id = GTK_STOCK_DIRECTORY; break; case HF_FIELD_PAGE: stock_id = "Gnumeric_Pagesetup_HF_Page"; break; case HF_FIELD_PAGES: stock_id = "Gnumeric_Pagesetup_HF_Pages"; break; case HF_FIELD_DATE: stock_id = "Gnumeric_Pagesetup_HF_Date"; break; case HF_FIELD_TIME: stock_id = "Gnumeric_Pagesetup_HF_Time"; break; case HF_FIELD_SHEET: stock_id = "Gnumeric_Pagesetup_HF_Sheet"; break; case HF_FIELD_CELL: stock_id = "Gnumeric_Pagesetup_HF_Cell"; break; default: return; } hf_delete_tag_cb (hf_state); if (gtk_text_buffer_insert_interactive_at_cursor (buffer, "", -1, TRUE)) { gtk_text_buffer_get_iter_at_mark (buffer, &iter, gtk_text_buffer_get_insert (buffer)); pix = gtk_widget_render_icon_pixbuf (GTK_WIDGET (hf_state->dialog), stock_id, GTK_ICON_SIZE_MENU); gtk_text_buffer_insert_pixbuf (buffer, &iter, pix); gtk_text_iter_backward_char (&iter); new_mark = gtk_text_buffer_create_mark (buffer, NULL, &iter, FALSE); g_object_ref (new_mark); mark_info = g_new0 (HFMarkInfo, 1); mark_info->mark = new_mark; mark_info->type = type; mark_info->options = g_strdup (options); hf_state->marks = g_list_append (hf_state->marks, mark_info); } } static void hf_insert_hf_tag (HFCustomizeState *hf_state, HFFieldType type, const char *options) { GtkWidget* focus; focus = gtk_window_get_focus (GTK_WINDOW (hf_state->dialog)); if (GTK_IS_TEXT_VIEW (focus)) { GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focus)); hf_insert_hf_stock_tag (hf_state, buffer, type, options); } } static void hf_insert_date_cb (GtkWidget *widget, HFCustomizeState *hf_state) { hf_insert_hf_tag (hf_state, HF_FIELD_DATE, g_object_get_data (G_OBJECT (widget), "options")); } static void hf_insert_custom_date_cb (G_GNUC_UNUSED GtkWidget *widget, HFCustomizeState *hf_state) { char *format; format = do_hf_dt_format_customize (TRUE, hf_state); if (format != NULL) { hf_insert_hf_tag (hf_state, HF_FIELD_DATE, format); g_free (format); } } static void hf_insert_time_cb (GtkWidget *widget, HFCustomizeState *hf_state) { hf_insert_hf_tag (hf_state, HF_FIELD_TIME, g_object_get_data (G_OBJECT (widget), "options")); } static void hf_insert_custom_time_cb (G_GNUC_UNUSED GtkWidget *widget, HFCustomizeState *hf_state) { char *format; format = do_hf_dt_format_customize (FALSE, hf_state); if (format != NULL) { hf_insert_hf_tag (hf_state, HF_FIELD_TIME, format); g_free (format); } } static void hf_insert_cell_cb (GtkWidget *widget, HFCustomizeState *hf_state) { const char *options; options = g_object_get_data (G_OBJECT (widget), "options"); if (options == NULL) options = "A1"; hf_insert_hf_tag (hf_state, HF_FIELD_CELL, options); } static void hf_insert_page_cb (HFCustomizeState *hf_state) { hf_insert_hf_tag (hf_state, HF_FIELD_PAGE, NULL); } static void hf_insert_pages_cb (HFCustomizeState *hf_state) { hf_insert_hf_tag (hf_state, HF_FIELD_PAGES, NULL); } static void hf_insert_sheet_cb (HFCustomizeState *hf_state) { hf_insert_hf_tag (hf_state, HF_FIELD_SHEET, NULL); } static void hf_insert_file_cb (HFCustomizeState *hf_state) { hf_insert_hf_tag (hf_state, HF_FIELD_FILE, NULL); } static void hf_insert_path_cb (HFCustomizeState *hf_state) { hf_insert_hf_tag (hf_state, HF_FIELD_PATH, NULL); } static void buffer_delete_range_cb (GtkTextBuffer *textbuffer, GtkTextIter *start, GtkTextIter *end, HFCustomizeState *hf_state) { GtkTextTag *tag; GtkTextIter iter; GList *l = hf_state->marks; tag = gtk_text_tag_table_lookup (gtk_text_buffer_get_tag_table (textbuffer), HF_TAG_NAME); gtk_text_iter_order (start, end); if (gtk_text_iter_has_tag (start, tag) && !gtk_text_iter_begins_tag (start, tag)) gtk_text_iter_backward_to_tag_toggle (start, tag); if (gtk_text_iter_has_tag (end, tag) && !gtk_text_iter_toggles_tag (end, tag)) gtk_text_iter_forward_to_tag_toggle (end, tag); /* Deleting all of our marks from this range */ while (l) { HFMarkInfo *info = l->data; if (gtk_text_mark_get_buffer (info->mark) == textbuffer) { gtk_text_buffer_get_iter_at_mark (textbuffer, &iter, info->mark); if (gtk_text_iter_in_range (&iter, start, end)) gtk_text_buffer_delete_mark (textbuffer, info->mark); } l = l->next; } } static int mark_info_compare (HFMarkInfo *a, HFMarkInfo *b) { GtkTextIter iter_a, iter_b; GtkTextBuffer *buffer; buffer = gtk_text_mark_get_buffer (a->mark); gtk_text_buffer_get_iter_at_mark (buffer, &iter_a, a->mark); gtk_text_buffer_get_iter_at_mark (buffer, &iter_b, b->mark); return gtk_text_iter_compare (&iter_a, &iter_b); } static void append_tag_descriptor (GString* string, HFFieldType type, char const *options) { char const *code; switch (type) { case HF_FIELD_FILE: code = "&[FILE"; break; case HF_FIELD_PATH: code = "&[PATH"; break; case HF_FIELD_DATE: code = "&[DATE"; break; case HF_FIELD_TIME: code = "&[TIME"; break; case HF_FIELD_PAGE: code = "&[PAGE"; break; case HF_FIELD_PAGES: code = "&[PAGES"; break; case HF_FIELD_SHEET: code = "&[TAB"; break; case HF_FIELD_CELL: code = "&[CELL"; break; default: return; } g_string_append (string, code); if (options) { g_string_append_c (string, ':'); g_string_append (string, options); } g_string_append_c (string, ']'); } static char * text_get (HFCustomizeState *hf_state, GtkTextBuffer *buffer) { GtkTextIter start; GtkTextIter end; GList *l, *sorted_marks = NULL; gchar *text; GString* string; string = g_string_new (""); l = hf_state->marks; while (l) { HFMarkInfo *m = l->data; if (gtk_text_mark_get_buffer (m->mark) == buffer) sorted_marks = g_list_insert_sorted (sorted_marks, m, (GCompareFunc) mark_info_compare); l = l->next; } gtk_text_buffer_get_bounds (buffer, &start, &end); l = sorted_marks; while (l) { HFMarkInfo *m = l->data; GtkTextIter mark_position; gtk_text_buffer_get_iter_at_mark (buffer, &mark_position, m->mark); text = gtk_text_buffer_get_text (buffer, &start, &mark_position, FALSE); g_string_append (string, text); g_free (text); append_tag_descriptor (string, m->type, m->options); start = mark_position; l = l->next; } g_list_free (sorted_marks); text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE); g_string_append (string, text); g_free (text); return g_string_free (string, FALSE); } static void hf_customize_apply (HFCustomizeState *hf_state) { char *left_format, *right_format, *middle_format; g_return_if_fail (hf_state != NULL); left_format = text_get (hf_state, hf_state->left_buffer); middle_format = text_get (hf_state, hf_state->middle_buffer); right_format = text_get (hf_state, hf_state->right_buffer); print_hf_free (*(hf_state->hf)); *(hf_state->hf) = print_hf_new (left_format, middle_format, right_format); g_free (left_format); g_free (middle_format); g_free (right_format); print_hf_register (*(hf_state->hf)); do_setup_hf_menus (hf_state->printer_setup_state); display_hf_preview (hf_state->printer_setup_state, hf_state->is_header); gtk_text_buffer_set_modified (hf_state->left_buffer, FALSE); gtk_text_buffer_set_modified (hf_state->middle_buffer, FALSE); gtk_text_buffer_set_modified (hf_state->right_buffer, FALSE); gtk_widget_set_sensitive (go_gtk_builder_get_widget (hf_state->gui, "apply_button"), FALSE); gtk_widget_set_sensitive (go_gtk_builder_get_widget (hf_state->gui, "ok_button"), FALSE); } static void hf_customize_ok (HFCustomizeState *hf_state) { hf_customize_apply (hf_state); gtk_widget_destroy (hf_state->dialog); } static gboolean cb_hf_changed (GtkBuilder *gui) { gtk_widget_set_sensitive (go_gtk_builder_get_widget (gui, "apply_button"), TRUE); gtk_widget_set_sensitive (go_gtk_builder_get_widget (gui, "ok_button"), TRUE); return FALSE; } static void add_named_tags (GtkTextBuffer *buffer) { GtkTextTag *tag; tag = gtk_text_tag_new (HF_TAG_NAME); g_object_set(tag, "editable", FALSE, "underline", TRUE, "underline-set", TRUE, "weight", PANGO_WEIGHT_BOLD, "weight-set", TRUE, "stretch", PANGO_STRETCH_CONDENSED, "stretch-set", TRUE, NULL); gtk_text_tag_table_add (gtk_text_buffer_get_tag_table (buffer), tag); } static gboolean check_hf_tag (char const *unknown_tag, char const *known_tag, gchar **options, gint length) { int len; char const *closing = unknown_tag + length; if (0 != g_ascii_strncasecmp (unknown_tag, "&[", 2)) return FALSE; unknown_tag += 2; len = strlen (known_tag); if (0 != g_ascii_strncasecmp (unknown_tag, known_tag, len)) return FALSE; unknown_tag += len; if (*unknown_tag == ']') return TRUE; if (*unknown_tag != ':') return FALSE; unknown_tag++; len = closing - unknown_tag - 1; if ((len > 0) && (options != NULL)) { *options = g_strndup (unknown_tag, len); } return TRUE; } static gboolean is_known_tag (HFCustomizeState* hf_state, GtkTextBuffer *buffer, char const *tag, gint length) { gchar *options = NULL; if (check_hf_tag (tag, "FILE", &options, length)) hf_insert_hf_stock_tag (hf_state, buffer, HF_FIELD_FILE, options); else if (check_hf_tag (tag, "PATH", &options, length)) hf_insert_hf_stock_tag (hf_state, buffer, HF_FIELD_PATH, options); else if (check_hf_tag (tag, "PAGES", &options, length)) hf_insert_hf_stock_tag (hf_state, buffer, HF_FIELD_PAGES, options); else if (check_hf_tag (tag, "PAGE", &options, length)) hf_insert_hf_stock_tag (hf_state, buffer, HF_FIELD_PAGE, options); else if (check_hf_tag (tag, "TAB", &options, length)) hf_insert_hf_stock_tag (hf_state, buffer, HF_FIELD_SHEET, options); else if (check_hf_tag (tag, "DATE", &options, length)) hf_insert_hf_stock_tag (hf_state, buffer, HF_FIELD_DATE, options); else if (check_hf_tag (tag, "TIME", &options, length)) hf_insert_hf_stock_tag (hf_state, buffer, HF_FIELD_TIME, options); else if (check_hf_tag (tag, "CELL", &options, length)) hf_insert_hf_stock_tag (hf_state, buffer, HF_FIELD_CELL, options); else return FALSE; g_free (options); return TRUE; } static void add_text_to_buffer (HFCustomizeState* hf_state, GtkTextBuffer *buffer, char const *text) { gchar const *here = text, *end; gunichar closing = g_utf8_get_char ("]"); gunichar ambersand = g_utf8_get_char ("&"); GtkTextIter iter; g_return_if_fail (here != NULL); while (*here) { if (here[0] == '&' && here[1] == '[') { end = g_utf8_strchr (here, -1, closing); if (end == NULL) { gtk_text_buffer_insert (buffer, &iter, here, -1); break; } else { if (!is_known_tag ( hf_state, buffer, here, end - here + 1)) { gtk_text_buffer_get_end_iter (buffer, &iter); gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, here, end - here + 1, HF_TAG_NAME, NULL); } here = end + 1; } } else { end = g_utf8_strchr (g_utf8_find_next_char (here, NULL), -1, ambersand); gtk_text_buffer_get_end_iter (buffer, &iter); if (end == NULL) { gtk_text_buffer_insert (buffer, &iter, here, -1); break; } else { gtk_text_buffer_insert (buffer, &iter, here, end - here); here = end; } } } gtk_text_buffer_set_modified (buffer, FALSE); } static void free_hf_mark_info (HFMarkInfo *info) { if (info->mark) g_object_unref (info->mark); g_free (info->options); g_free (info); } static void free_hf_state (HFCustomizeState *hf_state) { g_return_if_fail (hf_state != NULL); g_list_free_full (hf_state->marks, (GDestroyNotify) free_hf_mark_info); g_free (hf_state); } static void hf_attach_insert_date_menu (GtkMenuToolButton *button, HFCustomizeState* hf_state) { GtkWidget *menu = NULL; GtkWidget *item = NULL; g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (hf_insert_date_cb), hf_state); menu = gtk_menu_new (); item = gtk_menu_item_new_with_label (_("Default date format")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (hf_insert_date_cb), hf_state); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_menu_item_new_with_label (_("Custom date format")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (hf_insert_custom_date_cb), hf_state); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_menu_item_new_with_label (("YYYY/MM/DD")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (hf_insert_date_cb), hf_state); g_object_set_data_full (G_OBJECT (item), "options", g_strdup("YYYY/MM/DD"), g_free); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_menu_tool_button_set_menu (button, menu); gtk_widget_show_all (menu); } static void hf_attach_insert_time_menu (GtkMenuToolButton *button, HFCustomizeState* hf_state) { GtkWidget *menu = NULL; GtkWidget *item = NULL; g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (hf_insert_time_cb), hf_state); menu = gtk_menu_new (); item = gtk_menu_item_new_with_label (_("Default time format")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (hf_insert_time_cb), hf_state); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_menu_item_new_with_label (_("Custom time format")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (hf_insert_custom_time_cb), hf_state); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_menu_item_new_with_label (("HH:MM:SS")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (hf_insert_time_cb), hf_state); g_object_set_data_full (G_OBJECT (item), "options", g_strdup("HH:MM:SS"), g_free); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_menu_tool_button_set_menu (button, menu); gtk_widget_show_all (menu); } static void hf_attach_insert_cell_menu (GtkMenuToolButton *button, HFCustomizeState* hf_state) { GtkWidget *menu = NULL; GtkWidget *item = NULL; g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (hf_insert_cell_cb), hf_state); menu = gtk_menu_new (); item = gtk_menu_item_new_with_label (_("A1 (first cell of the page area)")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (hf_insert_cell_cb), hf_state); g_object_set_data_full (G_OBJECT (item), "options", g_strdup("A1"), g_free); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_menu_item_new_with_label (_("$A$1 (first cell of this worksheet)")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (hf_insert_cell_cb), hf_state); g_object_set_data_full (G_OBJECT (item), "options", g_strdup("$A$1"), g_free); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_menu_item_new_with_label (_("First Printed Cell Of The Page")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (hf_insert_cell_cb), hf_state); g_object_set_data_full (G_OBJECT (item), "options", g_strdup("rep|A1"), g_free); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_menu_tool_button_set_menu (button, menu); gtk_widget_show_all (menu); } static void cb_hf_destroyed (GObject *obj) { g_object_set_data (obj, "gui", NULL); } /* * Open up a DIALOG to allow the user to customize the header * or the footer. */ static void do_hf_customize (gboolean header, PrinterSetupState *state) { GtkBuilder *gui; GtkTextView *left, *middle, *right; GtkTextBuffer *left_buffer, *middle_buffer, *right_buffer; GtkWidget *dialog; HFCustomizeState* hf_state; GtkToolButton *button; /* Check if this dialog isn't already created. */ if (header) dialog = state->customize_header; else dialog = state->customize_footer; if (dialog != NULL) { gdk_window_show (gtk_widget_get_window (dialog)); gdk_window_raise (gtk_widget_get_window (dialog)); return; } gui = gnm_gtk_builder_load ("hf-config.ui", NULL, GO_CMD_CONTEXT (state->wbcg)); if (gui == NULL) return; hf_state = g_new0 (HFCustomizeState, 1); hf_state->gui = gui; hf_state->printer_setup_state = state; hf_state->is_header = header; left = GTK_TEXT_VIEW (go_gtk_builder_get_widget (gui, "left-format")); middle = GTK_TEXT_VIEW (go_gtk_builder_get_widget (gui, "middle-format")); right = GTK_TEXT_VIEW (go_gtk_builder_get_widget (gui, "right-format")); dialog = go_gtk_builder_get_widget (gui, "hf-config"); hf_state->dialog = dialog; if (header) { hf_state->hf = &state->header; state->customize_header = dialog; gtk_window_set_title (GTK_WINDOW (dialog), _("Custom header configuration")); } else { hf_state->hf = &state->footer; state->customize_footer = dialog; gtk_window_set_title (GTK_WINDOW (dialog), _("Custom footer configuration")); } hf_state->left_buffer = left_buffer = gtk_text_view_get_buffer (left); hf_state->middle_buffer = middle_buffer = gtk_text_view_get_buffer (middle); hf_state->right_buffer = right_buffer = gtk_text_view_get_buffer (right); add_named_tags (left_buffer); add_named_tags (middle_buffer); add_named_tags (right_buffer); add_text_to_buffer (hf_state, left_buffer, (*(hf_state->hf))->left_format); add_text_to_buffer (hf_state, middle_buffer, (*(hf_state->hf))->middle_format); add_text_to_buffer (hf_state, right_buffer, (*(hf_state->hf))->right_format); g_signal_connect (G_OBJECT (left_buffer), "delete-range", G_CALLBACK (buffer_delete_range_cb), hf_state); g_signal_connect (G_OBJECT (middle_buffer), "delete-range", G_CALLBACK (buffer_delete_range_cb), hf_state); g_signal_connect (G_OBJECT (right_buffer), "delete-range", G_CALLBACK (buffer_delete_range_cb), hf_state); g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "apply_button")), "clicked", G_CALLBACK (hf_customize_apply), hf_state); g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "ok_button")), "clicked", G_CALLBACK (hf_customize_ok), hf_state); g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "cancel_button")), "clicked", G_CALLBACK (gtk_widget_destroy), dialog); gtk_widget_set_sensitive (go_gtk_builder_get_widget (gui, "apply_button"), FALSE); gtk_widget_set_sensitive (go_gtk_builder_get_widget (gui, "ok_button"), FALSE); if (header) g_signal_connect (G_OBJECT (dialog), "destroy", G_CALLBACK (gtk_widget_destroyed), &state->customize_header); else g_signal_connect (G_OBJECT (dialog), "destroy", G_CALLBACK (gtk_widget_destroyed), &state->customize_footer); g_object_set_data_full (G_OBJECT (dialog), "hfstate", hf_state, (GDestroyNotify) free_hf_state); /* Setup bindings to mark when the entries are modified. */ g_signal_connect_swapped (G_OBJECT (left_buffer), "modified-changed", G_CALLBACK (cb_hf_changed), gui); g_signal_connect_swapped (G_OBJECT (middle_buffer), "modified-changed", G_CALLBACK (cb_hf_changed), gui); g_signal_connect_swapped (G_OBJECT (right_buffer), "modified-changed", G_CALLBACK (cb_hf_changed), gui); gnumeric_init_help_button (go_gtk_builder_get_widget (gui, "help_button"), header ? GNUMERIC_HELP_LINK_PRINTER_SETUP_HEADER_CUSTOMIZATION : GNUMERIC_HELP_LINK_PRINTER_SETUP_FOOTER_CUSTOMIZATION); g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "delete-button")), "clicked", G_CALLBACK (hf_delete_tag_cb), hf_state); button = GTK_TOOL_BUTTON (go_gtk_builder_get_widget (gui, "insert-date-button")); gtk_tool_button_set_stock_id (button, "Gnumeric_Pagesetup_HF_Date"); hf_attach_insert_date_menu (GTK_MENU_TOOL_BUTTON (button), hf_state); button = GTK_TOOL_BUTTON (go_gtk_builder_get_widget (gui, "insert-page-button")); gtk_tool_button_set_stock_id (button, "Gnumeric_Pagesetup_HF_Page"); g_signal_connect_swapped (G_OBJECT (button), "clicked", G_CALLBACK (hf_insert_page_cb), hf_state); button = GTK_TOOL_BUTTON (go_gtk_builder_get_widget (gui, "insert-pages-button")); gtk_tool_button_set_stock_id (button, "Gnumeric_Pagesetup_HF_Pages"); g_signal_connect_swapped (G_OBJECT (button), "clicked", G_CALLBACK (hf_insert_pages_cb), hf_state); button = GTK_TOOL_BUTTON (go_gtk_builder_get_widget (gui, "insert-sheet-button")); gtk_tool_button_set_stock_id (button, "Gnumeric_Pagesetup_HF_Sheet"); g_signal_connect_swapped (G_OBJECT (button), "clicked", G_CALLBACK (hf_insert_sheet_cb), hf_state); button = GTK_TOOL_BUTTON (go_gtk_builder_get_widget (gui, "insert-time-button")); gtk_tool_button_set_stock_id (button, "Gnumeric_Pagesetup_HF_Time"); hf_attach_insert_time_menu (GTK_MENU_TOOL_BUTTON (button), hf_state); g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "insert-file-button")), "clicked", G_CALLBACK (hf_insert_file_cb), hf_state); g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "insert-path-button")), "clicked", G_CALLBACK (hf_insert_path_cb), hf_state); button = GTK_TOOL_BUTTON (go_gtk_builder_get_widget (gui, "insert-cell-button")); gtk_tool_button_set_stock_id (button, "Gnumeric_Pagesetup_HF_Cell"); hf_attach_insert_cell_menu (GTK_MENU_TOOL_BUTTON (button), hf_state); /* Let them begin typing into the first entry widget. */ gtk_widget_grab_focus (GTK_WIDGET (left)); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (state->dialog)); /* The following would cause the dialog to be below the page setup dialog: */ /* go_gtk_window_set_transient (GTK_WINDOW (dialog), GTK_WINDOW (state->dialog)); */ g_object_set_data_full (G_OBJECT (dialog), "gui", gui, g_object_unref); g_signal_connect (G_OBJECT (dialog), "destroy", G_CALLBACK (cb_hf_destroyed), NULL); gtk_widget_show_all (dialog); } /************* Header Footer Customization *********** End *************/ /************* Date/Time Format Customization ******** Start ***********/ static void hf_dt_customize_ok (HFDTFormatState *hf_dt_state) { GOFormat const *format = go_format_sel_get_fmt (GO_FORMAT_SEL (hf_dt_state->format_sel)); hf_dt_state->format_string = g_strdup (go_format_as_XL (format)); } static char * do_hf_dt_format_customize (gboolean date, HFCustomizeState *hf_state) { GtkBuilder *gui; GtkWidget *dialog, *format_sel, *grid; HFDTFormatState* hf_dt_state; gint result; char *result_string = NULL; gui = gnm_gtk_builder_load ("hf-dt-format.ui", NULL, GO_CMD_CONTEXT (hf_state->printer_setup_state->wbcg)); if (gui == NULL) return NULL; hf_dt_state = g_new0 (HFDTFormatState, 1); hf_dt_state->gui = gui; hf_dt_state->hf_state = hf_state; hf_dt_state->format_string = NULL; dialog = go_gtk_builder_get_widget (gui, "hf-dt-format"); hf_dt_state->dialog = dialog; if (date) { gtk_window_set_title (GTK_WINDOW (dialog), _("Date format selection")); } else { gtk_window_set_title (GTK_WINDOW (dialog), _("Time format selection")); } g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "ok_button")), "clicked", G_CALLBACK (hf_dt_customize_ok), hf_dt_state); g_object_set_data_full (G_OBJECT (dialog), "hfdtstate", hf_dt_state, (GDestroyNotify) g_free); gnumeric_init_help_button (go_gtk_builder_get_widget (gui, "help_button"), GNUMERIC_HELP_LINK_PRINTER_SETUP_GENERAL); grid = go_gtk_builder_get_widget (gui, "layout-grid"); if (grid == NULL) { /* how can this happen? */ gtk_widget_destroy (dialog); return NULL; } hf_dt_state->format_sel = format_sel = go_format_sel_new_full (TRUE); go_format_sel_set_style_format (GO_FORMAT_SEL (format_sel), date ? go_format_default_date () : go_format_default_time ()); gtk_widget_show_all (dialog); gtk_grid_attach (GTK_GRID (grid), format_sel, 0, 1, 2, 1); gtk_widget_show (format_sel); result = gtk_dialog_run (GTK_DIALOG (dialog)); switch (result) { case GTK_RESPONSE_OK: result_string = hf_dt_state->format_string; break; default: gtk_widget_destroy (dialog); return NULL; } gtk_widget_destroy (dialog); g_object_unref (hf_dt_state->gui); hf_dt_state->gui = NULL; return result_string; } /************* Date/Time Format Customization ******** End *************/ /* header/footer_preview_event * If the user double clicks on a header/footer preview canvas, we will * open up the dialog to modify the header or footer. * They can also do this from the option menu. */ static gboolean header_preview_event (G_GNUC_UNUSED GocCanvas *canvas, GdkEvent *event, PrinterSetupState *state) { if (event == NULL || event->type != GDK_2BUTTON_PRESS || event->button.button != 1) return FALSE; do_hf_customize (TRUE, state); return TRUE; } static gboolean footer_preview_event (G_GNUC_UNUSED GocCanvas *canvas, GdkEvent *event, PrinterSetupState *state) { if (event == NULL || event->type != GDK_2BUTTON_PRESS || event->button.button != 1) return FALSE; do_hf_customize (FALSE, state); return TRUE; } /* create_hf_preview_canvas * Creates the canvas to do a header or footer preview in the print setup. * */ static void create_hf_preview_canvas (PrinterSetupState *state, gboolean header) { GtkWidget *wid; HFPreviewInfo *pi; PangoFontDescription *font_desc; GnmStyle *style; gdouble width = HF_PREVIEW_X; gdouble height = HF_PREVIEW_Y; gdouble shadow = HF_PREVIEW_SHADOW; gdouble padding = HF_PREVIEW_PADDING; gdouble margin = HF_PREVIEW_MARGIN; gdouble bottom_margin = height - margin; GOStyle *gostyle; pi = g_new (HFPreviewInfo, 1); if (header) state->pi_header = pi; else state->pi_footer = pi; pi->canvas = GTK_WIDGET (g_object_new (GOC_TYPE_CANVAS, NULL)); gostyle = go_styled_object_get_style ( GO_STYLED_OBJECT (goc_item_new (goc_canvas_get_root (GOC_CANVAS (pi->canvas)), GOC_TYPE_RECTANGLE, "x", 1. + shadow, "y", (header ? shadow : 0.), "width", width, "height", height + (header ? -shadow: shadow), NULL))); gostyle->fill.pattern.back = GO_COLOR_BLACK; gostyle->line.width = 0.; gostyle->line.color = 0; gostyle = go_styled_object_get_style ( GO_STYLED_OBJECT (goc_item_new (goc_canvas_get_root (GOC_CANVAS (pi->canvas)), GOC_TYPE_RECTANGLE, "x", 1.0, "y", (header? 1.0: 0.), "width", width, "height", height, NULL))); gostyle->fill.pattern.back = GO_COLOR_WHITE; gostyle->line.width = 0.; gostyle->line.color = 0; style = gnm_conf_get_printer_decoration_font (); font_desc = pango_font_description_new (); pango_font_description_set_family (font_desc, gnm_style_get_font_name (style)); pango_font_description_set_style (font_desc, gnm_style_get_font_italic (style) ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL); pango_font_description_set_variant (font_desc, PANGO_VARIANT_NORMAL); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_NORMAL); pango_font_description_set_size (font_desc, 8 * PANGO_SCALE); gnm_style_unref (style); pi->left = goc_item_new ( goc_canvas_get_root (GOC_CANVAS (pi->canvas)), goc_text_get_type (), "x", padding, "y", header ? margin : bottom_margin, "anchor", header ? GO_ANCHOR_NORTH_WEST : GO_ANCHOR_SOUTH_WEST, "text", "Left", NULL); gostyle = go_styled_object_get_style (GO_STYLED_OBJECT (pi->left)); go_style_set_font_desc (gostyle, pango_font_description_copy (font_desc)); pi->middle = goc_item_new ( goc_canvas_get_root (GOC_CANVAS (pi->canvas)), goc_text_get_type (), "x", width / 2, "y", header ? margin : bottom_margin, "anchor", header ? GO_ANCHOR_NORTH : GO_ANCHOR_SOUTH, "text", "Center", NULL); gostyle = go_styled_object_get_style (GO_STYLED_OBJECT (pi->left)); go_style_set_font_desc (gostyle, pango_font_description_copy (font_desc)); pi->right = goc_item_new ( goc_canvas_get_root (GOC_CANVAS (pi->canvas)), goc_text_get_type (), "x", width - padding, "y", header ? margin : bottom_margin, "anchor", header ? GO_ANCHOR_NORTH_EAST : GO_ANCHOR_SOUTH_EAST, "text", "Right", NULL); gostyle = go_styled_object_get_style (GO_STYLED_OBJECT (pi->left)); go_style_set_font_desc (gostyle, pango_font_description_copy (font_desc)); pango_font_description_free (font_desc); gtk_widget_show_all (pi->canvas); if (header) { g_signal_connect (G_OBJECT (pi->canvas), "event", G_CALLBACK (header_preview_event), state); wid = go_gtk_builder_get_widget (state->gui, "container-header-sample"); } else { g_signal_connect (G_OBJECT (pi->canvas), "event", G_CALLBACK (footer_preview_event), state); wid = go_gtk_builder_get_widget (state->gui, "container-footer-sample"); } gtk_widget_set_size_request (pi->canvas, width + shadow + 1, height + (header ? 1: shadow)); gtk_container_add (GTK_CONTAINER (wid), GTK_WIDGET (pi->canvas)); } /* * Setup the widgets for the header and footer tab. * * Creates the two preview canvas's for the header and footer. */ static void do_setup_hf (PrinterSetupState *state) { GtkComboBox *header; GtkComboBox *footer; GtkCellRenderer *renderer; GtkWidget *w; g_return_if_fail (state != NULL); header = GTK_COMBO_BOX (go_gtk_builder_get_widget (state->gui, "option-menu-header")); renderer = (GtkCellRenderer*) gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (header), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (header), renderer, "text", 0, NULL); footer = GTK_COMBO_BOX (go_gtk_builder_get_widget (state->gui, "option-menu-footer")); renderer = (GtkCellRenderer*) gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (footer), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (footer), renderer, "text", 0, NULL); state->header = print_hf_copy (state->pi->header ? state->pi->header : hf_formats->data); state->footer = print_hf_copy (state->pi->footer ? state->pi->footer : hf_formats->data); do_setup_hf_menus (state); w = go_gtk_builder_get_widget (state->gui, "configure-header-button"); g_signal_connect_swapped (G_OBJECT (w), "clicked", G_CALLBACK (do_header_customize), state); w = go_gtk_builder_get_widget (state->gui, "configure-footer-button"); g_signal_connect_swapped (G_OBJECT (w), "clicked", G_CALLBACK (do_footer_customize), state); create_hf_preview_canvas (state, TRUE); create_hf_preview_canvas (state, FALSE); display_hf_preview (state, TRUE); display_hf_preview (state, FALSE); } static void display_order_icon (GtkToggleButton *toggle, PrinterSetupState *state) { GtkWidget *show, *hide; if (gtk_toggle_button_get_active (toggle)){ show = state->icon_rd; hide = state->icon_dr; } else { hide = state->icon_rd; show = state->icon_dr; } gtk_widget_show (show); gtk_widget_hide (hide); } static void load_print_area (PrinterSetupState *state) { GnmRange *print_area; print_area = sheet_get_nominal_printarea (wb_control_cur_sheet (WORKBOOK_CONTROL (state->wbcg))); if (print_area != NULL) gnm_expr_entry_load_from_range (state->area_entry, wb_control_cur_sheet (WORKBOOK_CONTROL (state->wbcg)), print_area); else gnm_expr_entry_load_from_text (state->area_entry, ""); g_free (print_area); } static void do_setup_error_display (PrinterSetupState *state) { static struct { char const *label; guint type; } display_types[] = { {N_("Print as displayed"), GNM_PRINT_ERRORS_AS_DISPLAYED}, {N_("Print as spaces"), GNM_PRINT_ERRORS_AS_BLANK}, {N_("Print as dashes"), GNM_PRINT_ERRORS_AS_DASHES}, {N_("Print as #N/A"), GNM_PRINT_ERRORS_AS_NA} }; gint i; GtkCellRenderer *cell; gint item = GNM_PRINT_ERRORS_AS_DISPLAYED; GtkTreeIter iter; for (i = 0; i < (int)G_N_ELEMENTS (display_types); i++) { gtk_list_store_insert_with_values (state->error_display.store, NULL, G_MAXINT, 0, _(display_types[i].label), 1, display_types[i].type, -1); if (display_types[i].type == state->pi->error_display) item = i; } cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(state->error_display.combo), cell, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(state->error_display.combo), cell, "text", 0, NULL); if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (state->error_display.store), &iter, NULL, item)) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (state->error_display.combo), &iter); } static void do_setup_comment_display (PrinterSetupState *state) { static struct { char const *label; guint type; } display_types[] = { {N_("Do not print"), GNM_PRINT_COMMENTS_NONE}, {N_("Print in place"), GNM_PRINT_COMMENTS_IN_PLACE}, {N_("Print at end"), GNM_PRINT_COMMENTS_AT_END} }; gint i; GtkCellRenderer *cell; gint item = GNM_PRINT_COMMENTS_NONE; GtkTreeIter iter; for (i = 0; i < (int)G_N_ELEMENTS (display_types); i++) { gtk_list_store_insert_with_values (state->comment_display.store, NULL, G_MAXINT, 0, _(display_types[i].label), 1, display_types[i].type, -1); if (display_types[i].type == state->pi->comment_placement) item = i; } cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(state->comment_display.combo), cell, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(state->comment_display.combo), cell, "text", 0, NULL); if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (state->comment_display.store), &iter, NULL, item)) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (state->comment_display.combo), &iter); gtk_widget_set_sensitive (state->comment_display.combo, FALSE); } static void do_setup_page_area (PrinterSetupState *state) { GtkWidget *pa_grid = go_gtk_builder_get_widget (state->gui, "print-area-grid"); GtkWidget *repeat_grid = go_gtk_builder_get_widget (state->gui, "area-grid"); state->area_entry = gnm_expr_entry_new (state->wbcg, FALSE); gnm_expr_entry_set_flags (state->area_entry, GNM_EE_SHEET_OPTIONAL, GNM_EE_SHEET_OPTIONAL); gtk_container_add (GTK_CONTAINER (pa_grid), GTK_WIDGET (state->area_entry)); gtk_widget_set_hexpand (GTK_WIDGET (state->area_entry), TRUE); gtk_widget_show (GTK_WIDGET (state->area_entry)); state->top_entry = gnm_expr_entry_new (state->wbcg, TRUE); gnm_expr_entry_set_flags (state->top_entry, GNM_EE_SINGLE_RANGE | GNM_EE_FULL_ROW | GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK); gtk_widget_set_hexpand (GTK_WIDGET (state->top_entry), TRUE); gtk_grid_attach (GTK_GRID (repeat_grid), GTK_WIDGET (state->top_entry), 1, 2, 1, 1); gtk_widget_show (GTK_WIDGET (state->top_entry)); state->left_entry = gnm_expr_entry_new (state->wbcg, TRUE); gnm_expr_entry_set_flags (state->left_entry, GNM_EE_SINGLE_RANGE | GNM_EE_FULL_COL | GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK); gtk_widget_set_hexpand (GTK_WIDGET (state->left_entry), TRUE); gtk_grid_attach (GTK_GRID (repeat_grid), GTK_WIDGET (state->left_entry), 1, 3, 1, 1); gtk_widget_show (GTK_WIDGET (state->left_entry)); gnumeric_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (gnm_expr_entry_get_entry (state->area_entry))); gnumeric_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (gnm_expr_entry_get_entry (state->top_entry))); gnumeric_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (gnm_expr_entry_get_entry (state->left_entry))); gnm_expr_entry_load_from_text (state->top_entry, state->pi->repeat_top); gnm_expr_entry_load_from_text (state->left_entry, state->pi->repeat_left); load_print_area (state); } static void do_setup_page_info (PrinterSetupState *state) { GtkWidget *gridlines = go_gtk_builder_get_widget (state->gui, "check-grid-lines"); GtkWidget *onlystyles= go_gtk_builder_get_widget (state->gui, "check-only-styles"); GtkWidget *bw = go_gtk_builder_get_widget (state->gui, "check-black-white"); GtkWidget *titles = go_gtk_builder_get_widget (state->gui, "check-print-titles"); GtkWidget *do_not_print = go_gtk_builder_get_widget (state->gui, "check-do-not-print"); GtkWidget *order_rd = go_gtk_builder_get_widget (state->gui, "radio-order-right"); GtkWidget *order_dr = go_gtk_builder_get_widget (state->gui, "radio-order-down"); GtkWidget *order_grid = go_gtk_builder_get_widget (state->gui, "page-order-grid"); GtkWidget *order; state->error_display.combo = go_gtk_builder_get_widget (state->gui, "error-box"); state->error_display.store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (state->error_display.combo))); do_setup_error_display (state); state->comment_display.combo = go_gtk_builder_get_widget (state->gui, "comments-box"); state->comment_display.store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (state->comment_display.combo))); do_setup_comment_display (state); state->icon_rd = gnumeric_load_image ("res:gnm:pixmaps/right-down.png"); state->icon_dr = gnumeric_load_image ("res:gnm:pixmaps/down-right.png"); gtk_widget_hide (state->icon_dr); gtk_widget_hide (state->icon_rd); gtk_grid_attach (GTK_GRID (order_grid), state->icon_rd, 1, 0, 1, 2); gtk_grid_attach (GTK_GRID (order_grid), state->icon_dr, 1, 0, 1, 2); g_signal_connect (G_OBJECT (order_rd), "toggled", G_CALLBACK (display_order_icon), state); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gridlines), state->pi->print_grid_lines); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (onlystyles), state->pi->print_even_if_only_styles); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (bw), state->pi->print_black_and_white); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (titles), state->pi->print_titles); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (do_not_print), state->pi->do_not_print); order = state->pi->print_across_then_down ? order_rd : order_dr; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (order), TRUE); display_order_icon (GTK_TOGGLE_BUTTON (order_rd), state); } static void do_update_margin (UnitInfo *margin, double value, GtkUnit unit) { margin->value = value; gtk_spin_button_set_range (margin->spin, 0. , 2. * value); gtk_spin_button_set_value (margin->spin, value); switch (unit) { case GTK_UNIT_MM: gtk_spin_button_set_digits (margin->spin, 1); gtk_spin_button_set_increments (margin->spin, 1., 0.); break; case GTK_UNIT_INCH: gtk_spin_button_set_digits (margin->spin, 3); gtk_spin_button_set_increments (margin->spin, 0.125, 0.); break; case GTK_UNIT_POINTS: gtk_spin_button_set_digits (margin->spin, 1); gtk_spin_button_set_increments (margin->spin, 1., 0.); break; case GTK_UNIT_PIXEL: break; } } static void do_update_page (PrinterSetupState *state) { PrintInformation *pi = state->pi; GtkBuilder *gui; double top, bottom; double left, right; double edge_to_below_header, edge_to_above_footer; char *text; char const *format; double scale; gui = state->gui; gtk_label_set_text (GTK_LABEL (go_gtk_builder_get_widget (gui, "paper-type-label")), print_info_get_paper_display_name (pi)); state->height = print_info_get_paper_height (pi,state->display_unit); state->width = print_info_get_paper_width (pi,state->display_unit); switch (state->display_unit) { case GTK_UNIT_PIXEL: format = _("%.0f pixels wide by %.0f pixels tall"); break; case GTK_UNIT_POINTS: format = _("%.0f points wide by %.0f points tall"); break; case GTK_UNIT_INCH: format = _("%.1f in wide by %.1f in tall"); break; case GTK_UNIT_MM: format = _("%.0f mm wide by %.0f mm tall"); break; default: format = _("%.1f wide by %.1f tall"); break; } text = g_strdup_printf (format, state->width, state->height); gtk_label_set_text (GTK_LABEL (go_gtk_builder_get_widget (gui, "paper-size-label")), text); g_free (text); print_info_get_margins (state->pi, &top, &bottom, &left, &right, &edge_to_below_header, &edge_to_above_footer); scale = get_conversion_factor (state->display_unit); do_update_margin (&state->margins.header, (edge_to_below_header - top) / scale, state->display_unit); do_update_margin (&state->margins.footer, (edge_to_above_footer - bottom) / scale, state->display_unit); do_update_margin (&state->margins.top, top / scale, state->display_unit); do_update_margin (&state->margins.bottom, bottom / scale, state->display_unit); do_update_margin (&state->margins.left, left / scale, state->display_unit); do_update_margin (&state->margins.right, right / scale, state->display_unit); configure_bounds_top (state); configure_bounds_header (state); configure_bounds_left (state); configure_bounds_right (state); configure_bounds_footer (state); configure_bounds_bottom (state); canvas_update (state); switch (print_info_get_paper_orientation (state->pi)) { case GTK_PAGE_ORIENTATION_PORTRAIT: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->portrait_radio), TRUE); break; case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->rev_portrait_radio), TRUE); break; case GTK_PAGE_ORIENTATION_LANDSCAPE: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->landscape_radio), TRUE); break; default: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->rev_landscape_radio), TRUE); break; } } static void orientation_changed_cb (PrinterSetupState *state) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (state->portrait_radio))) print_info_set_paper_orientation (state->pi, GTK_PAGE_ORIENTATION_PORTRAIT); else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (state->rev_portrait_radio))) print_info_set_paper_orientation (state->pi, GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT); else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (state->landscape_radio))) print_info_set_paper_orientation (state->pi, GTK_PAGE_ORIENTATION_LANDSCAPE); else print_info_set_paper_orientation (state->pi, GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE); do_update_page (state); } static void do_setup_page (PrinterSetupState *state) { GtkBuilder *gui; gui = state->gui; g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "paper-button")), "clicked", G_CALLBACK (dialog_gtk_printer_setup_cb), state); state->portrait_radio = go_gtk_builder_get_widget (gui, "portrait-button"); state->landscape_radio = go_gtk_builder_get_widget (gui, "landscape-button"); state->rev_portrait_radio = go_gtk_builder_get_widget (gui, "r-portrait-button"); state->rev_landscape_radio = go_gtk_builder_get_widget (gui, "r-landscape-button"); g_signal_connect_swapped (G_OBJECT (state->portrait_radio), "toggled", G_CALLBACK (orientation_changed_cb), state); g_signal_connect_swapped (G_OBJECT (state->rev_portrait_radio), "toggled", G_CALLBACK (orientation_changed_cb), state); g_signal_connect_swapped (G_OBJECT (state->landscape_radio), "toggled", G_CALLBACK (orientation_changed_cb), state); do_setup_margin (state); do_update_page (state); } static void scaling_percent_changed (GtkToggleButton *toggle, PrinterSetupState *state) { gboolean scale_percent = gtk_toggle_button_get_active (toggle); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "scale-percent-spin")), scale_percent); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "scale-percent-label")), scale_percent); } static void scaling_fit_to_h_changed (GtkToggleButton *toggle, PrinterSetupState *state) { gboolean scale_fit_to_h = gtk_toggle_button_get_active (toggle); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "scale-h-spin")), scale_fit_to_h); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "fit-h-check-label")), scale_fit_to_h); } static void scaling_fit_to_v_changed (GtkToggleButton *toggle, PrinterSetupState *state) { gboolean scale_fit_to_v = gtk_toggle_button_get_active (toggle); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "scale-v-spin")), scale_fit_to_v); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "fit-v-check-label")), scale_fit_to_v); } static void scaling_fit_to_changed (GtkToggleButton *toggle, PrinterSetupState *state) { gboolean scale_fit_to = gtk_toggle_button_get_active (toggle); if (scale_fit_to) { scaling_fit_to_h_changed (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "fit-h-check")), state); scaling_fit_to_v_changed (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "fit-v-check")), state); } else { gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "scale-v-spin")), FALSE); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "fit-v-check-label")), FALSE); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "scale-h-spin")), FALSE); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "fit-h-check-label")), FALSE); } gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "fit-h-check")), scale_fit_to); gtk_widget_set_sensitive (GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "fit-v-check")), scale_fit_to); } static void do_setup_scale (PrinterSetupState *state) { PrintInformation *pi = state->pi; GtkWidget *scale_percent_spin, *scale_width_spin, *scale_height_spin; GtkBuilder *gui; gui = state->gui; state->scale_percent_radio = go_gtk_builder_get_widget (gui, "scale-percent-radio"); state->scale_fit_to_radio = go_gtk_builder_get_widget (gui, "scale-fit-to-radio"); state->scale_no_radio = go_gtk_builder_get_widget (gui, "scale-no-radio"); g_signal_connect (G_OBJECT (state->scale_percent_radio), "toggled", G_CALLBACK (scaling_percent_changed), state); g_signal_connect (G_OBJECT (state->scale_fit_to_radio), "toggled", G_CALLBACK (scaling_fit_to_changed), state); g_signal_connect (G_OBJECT (go_gtk_builder_get_widget (state->gui, "fit-h-check")), "toggled", G_CALLBACK (scaling_fit_to_h_changed), state); g_signal_connect (G_OBJECT (go_gtk_builder_get_widget (state->gui, "fit-v-check")), "toggled", G_CALLBACK (scaling_fit_to_v_changed), state); scaling_percent_changed (GTK_TOGGLE_BUTTON (state->scale_percent_radio), state); scaling_fit_to_changed (GTK_TOGGLE_BUTTON (state->scale_fit_to_radio), state); if (pi->scaling.type == PRINT_SCALE_PERCENTAGE) { if (pi->scaling.percentage.x == 100.) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->scale_no_radio), TRUE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->scale_percent_radio), TRUE); } else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->scale_fit_to_radio), TRUE); } scale_percent_spin = go_gtk_builder_get_widget (gui, "scale-percent-spin"); gtk_spin_button_set_value ( GTK_SPIN_BUTTON (scale_percent_spin), pi->scaling.percentage.x); gnumeric_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (scale_percent_spin)); scale_width_spin = go_gtk_builder_get_widget (gui, "scale-h-spin"); gtk_spin_button_set_value ( GTK_SPIN_BUTTON (scale_width_spin), pi->scaling.dim.cols); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "fit-h-check")), pi->scaling.dim.cols > 0); gnumeric_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (scale_width_spin)); scale_height_spin = go_gtk_builder_get_widget (gui, "scale-v-spin"); gtk_spin_button_set_value ( GTK_SPIN_BUTTON (scale_height_spin), pi->scaling.dim.rows); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "fit-v-check")), pi->scaling.dim.rows > 0); gnumeric_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (scale_height_spin)); } static Sheet * print_setup_get_sheet (PrinterSetupState *state) { GtkWidget *w = go_gtk_builder_get_widget (state->gui, "apply-to-all"); gboolean apply_all_sheets = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)); gnm_conf_set_printsetup_all_sheets (apply_all_sheets); if (apply_all_sheets) return NULL; return workbook_sheet_by_index (state->sheet->workbook, gtk_combo_box_get_active (GTK_COMBO_BOX (state->sheet_selector))); } static void cb_do_print_preview (PrinterSetupState *state) { PrintInformation *old_pi; double width, height; GogGraph *graph = NULL; fetch_settings (state); old_pi = state->sheet->print_info; state->sheet->print_info = state->pi; if (state->sheet->sheet_type == GNM_SHEET_OBJECT) { graph = GOG_GRAPH (sheet_object_graph_get_gog (SHEET_OBJECT (state->sheet->sheet_objects->data))); if (graph) { double top, bottom, left, right, edge_to_below_header, edge_to_above_footer, w, h; gog_graph_get_size (graph, &width, &height); w = print_info_get_paper_width (state->pi, GTK_UNIT_POINTS); h = print_info_get_paper_height (state->pi, GTK_UNIT_POINTS); print_info_get_margins (state->pi, &top, &bottom, &left, &right, &edge_to_below_header, &edge_to_above_footer); w -= left + right; h -= top + bottom + edge_to_above_footer + edge_to_below_header; gog_graph_set_size (graph, w, h); } } gnm_print_sheet (WORKBOOK_CONTROL (state->wbcg), state->sheet, TRUE, GNM_PRINT_ACTIVE_SHEET, NULL); if (graph) gog_graph_set_size (graph, width, height); state->sheet->print_info = old_pi; } static void cb_do_print_cancel (PrinterSetupState *state) { gtk_widget_destroy (state->dialog); } static void cb_do_print_ok (PrinterSetupState *state) { fetch_settings (state); if (gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( go_gtk_builder_get_widget (state->gui, "is_default_check")))) { print_info_save (state->pi); } cmd_print_setup (WORKBOOK_CONTROL (state->wbcg), print_setup_get_sheet (state), state->pi); gtk_widget_destroy (state->dialog); } static void cb_do_print (PrinterSetupState *state) { Sheet *sheet = state->sheet; WorkbookControl *wbc = WORKBOOK_CONTROL (state->wbcg); cb_do_print_ok (state); gnm_print_sheet (wbc, sheet, FALSE, GNM_PRINT_SAVED_INFO, NULL); } static void cb_do_print_destroy (PrinterSetupState *state) { if (state->customize_header) gtk_widget_destroy (state->customize_header); if (state->customize_footer) gtk_widget_destroy (state->customize_footer); g_object_unref (state->gui); print_hf_free (state->header); print_hf_free (state->footer); print_info_free (state->pi); g_free (state->pi_header); g_free (state->pi_footer); g_object_unref (state->unit_model); g_free (state); } static void cb_do_sheet_selector_toggled (GtkToggleButton *togglebutton, PrinterSetupState *state) { gboolean all_sheets = gtk_toggle_button_get_active (togglebutton); gtk_widget_set_sensitive (state->sheet_selector, !all_sheets); } static void do_setup_sheet_selector (PrinterSetupState *state) { GtkWidget *grid, *w; int i, n, n_this = 0; g_return_if_fail (state != NULL); g_return_if_fail (state->sheet != NULL); grid = go_gtk_builder_get_widget (state->gui, "sheet-grid"); state->sheet_selector = gtk_combo_box_text_new (); n = workbook_sheet_count (state->sheet->workbook); for (i = 0 ; i < n ; i++) { Sheet * a_sheet = workbook_sheet_by_index (state->sheet->workbook, i); if (a_sheet == state->sheet) n_this = i; gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (state->sheet_selector), a_sheet->name_unquoted); } gtk_combo_box_set_active (GTK_COMBO_BOX (state->sheet_selector), n_this); gtk_widget_set_hexpand (state->sheet_selector, TRUE); gtk_grid_attach (GTK_GRID (grid), state->sheet_selector, 1, 1, 1, 1); w = go_gtk_builder_get_widget (state->gui, "apply-to-all"); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (cb_do_sheet_selector_toggled), state); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), gnm_conf_get_printsetup_all_sheets ()); cb_do_sheet_selector_toggled (GTK_TOGGLE_BUTTON (w), state); w = go_gtk_builder_get_widget (state->gui, "apply-to-selected"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !gnm_conf_get_printsetup_all_sheets ()); gtk_widget_show_all (grid); } static void do_setup_main_dialog (PrinterSetupState *state) { GtkWidget *w; g_return_if_fail (state != NULL); g_return_if_fail (state->sheet != NULL); g_return_if_fail (state->wbcg != NULL); state->dialog = go_gtk_builder_get_widget (state->gui, "print-setup"); w = go_gtk_builder_get_widget (state->gui, "ok"); g_signal_connect_swapped (G_OBJECT (w), "clicked", G_CALLBACK (cb_do_print_ok), state); w = go_gtk_builder_get_widget (state->gui, "print"); g_signal_connect_swapped (G_OBJECT (w), "clicked", G_CALLBACK (cb_do_print), state); w = go_gtk_builder_get_widget (state->gui, "preview"); g_signal_connect_swapped (G_OBJECT (w), "clicked", G_CALLBACK (cb_do_print_preview), state); w = go_gtk_builder_get_widget (state->gui, "cancel"); g_signal_connect_swapped (G_OBJECT (w), "clicked", G_CALLBACK (cb_do_print_cancel), state); w = go_gtk_builder_get_widget (state->gui, "print-setup-notebook"); gtk_notebook_set_current_page (GTK_NOTEBOOK (w), 0); g_object_set_data_full (G_OBJECT (state->dialog), "state", state, (GDestroyNotify) cb_do_print_destroy); wbc_gtk_attach_guru (state->wbcg, state->dialog); } static PrinterSetupState * printer_setup_state_new (WBCGtk *wbcg, Sheet *sheet) { PrinterSetupState *state; GtkBuilder *gui; gui = gnm_gtk_builder_load ("print.ui", NULL, GO_CMD_CONTEXT (wbcg)); if (gui == NULL) return NULL; state = g_new0 (PrinterSetupState, 1); state->wbcg = wbcg; state->sheet = sheet; state->gui = gui; state->pi = print_info_dup (sheet->print_info); state->display_unit = state->pi->desired_display.top; state->customize_header = NULL; state->customize_footer = NULL; do_setup_main_dialog (state); do_setup_sheet_selector (state); do_setup_hf (state); do_setup_page_area (state); do_setup_page_info (state); do_setup_page (state); do_setup_scale (state); return state; } static void do_fetch_page (PrinterSetupState *state) { state->pi->center_horizontally = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (state->check_center_h)); state->pi->center_vertically = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (state->check_center_v)); } static void do_fetch_unit (PrinterSetupState *state) { if (state->display_unit != state->pi->desired_display.top) { state->pi->desired_display.top = state->display_unit; state->pi->desired_display.bottom = state->display_unit; state->pi->desired_display.header = state->display_unit; state->pi->desired_display.footer = state->display_unit; state->pi->desired_display.left = state->display_unit; state->pi->desired_display.right = state->display_unit; } } static void do_fetch_scale (PrinterSetupState *state) { GtkWidget *w; GtkBuilder *gui = state->gui; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (state->scale_no_radio))) { state->pi->scaling.percentage.x = state->pi->scaling.percentage.y = 100.; state->pi->scaling.type = PRINT_SCALE_PERCENTAGE; } else { w = go_gtk_builder_get_widget (gui, "scale-percent-spin"); state->pi->scaling.percentage.x = state->pi->scaling.percentage.y = gtk_spin_button_get_value (GTK_SPIN_BUTTON (w)); state->pi->scaling.type = ((gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (state->scale_percent_radio))) ? PRINT_SCALE_PERCENTAGE : PRINT_SCALE_FIT_PAGES); } w = go_gtk_builder_get_widget (gui, "fit-h-check"); if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))) state->pi->scaling.dim.cols = 0; else { w = go_gtk_builder_get_widget (gui, "scale-h-spin"); state->pi->scaling.dim.cols = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (w)); } w = go_gtk_builder_get_widget (gui, "fit-v-check"); if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))) state->pi->scaling.dim.rows = 0; else { w = go_gtk_builder_get_widget (gui, "scale-v-spin"); state->pi->scaling.dim.rows = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (w)); } } /** * Header and footer are stored with Excel semantics, but displayed with * more natural semantics. In Excel, both top margin and header are measured * from top of sheet. See illustration at start of src/print.c. The Gnumeric * user interface presents header as the band between top margin and the * print area. Bottom margin and footer are handled likewise. */ static void do_fetch_margins (PrinterSetupState *state) { double header, footer, top, bottom, left, right; GtkPageSetup *ps = print_info_get_page_setup (state->pi); double factor = get_conversion_factor (state->display_unit); header = state->margins.header.value; footer = state->margins.footer.value; top = state->margins.top.value; bottom = state->margins.bottom.value; left = state->margins.left.value; right = state->margins.right.value; gtk_page_setup_set_top_margin (ps, top, state->display_unit); gtk_page_setup_set_bottom_margin (ps, bottom, state->display_unit); gtk_page_setup_set_left_margin (ps, left, state->display_unit); gtk_page_setup_set_right_margin (ps, right, state->display_unit); header += top; footer += bottom; print_info_set_edge_to_above_footer (state->pi, footer * factor); print_info_set_edge_to_below_header (state->pi, header * factor); } static void do_fetch_hf (PrinterSetupState *state) { print_hf_free (state->pi->header); print_hf_free (state->pi->footer); state->pi->header = print_hf_copy (state->header); state->pi->footer = print_hf_copy (state->footer); } static void do_fetch_page_info (PrinterSetupState *state) { PrintInformation *pi = state->pi; GtkTreeIter iter; pi->print_grid_lines = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "check-grid-lines"))); pi->print_even_if_only_styles = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "check-only-styles"))); pi->print_black_and_white = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "check-black-white"))); pi->print_titles = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "check-print-titles"))); pi->print_across_then_down = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "radio-order-right"))); pi->do_not_print = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "check-do-not-print"))); g_free (pi->repeat_top); pi->repeat_top = g_strdup (gnm_expr_entry_get_text (state->top_entry)); g_free (pi->repeat_left); pi->repeat_left = g_strdup (gnm_expr_entry_get_text (state->left_entry)); if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (state->error_display.combo), &iter)) gtk_tree_model_get (GTK_TREE_MODEL (state->error_display.store), &iter, 1, &(pi->error_display), -1); if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (state->comment_display.combo), &iter)) gtk_tree_model_get (GTK_TREE_MODEL (state->comment_display.store), &iter, 1, &(pi->comment_placement), -1); } static void fetch_settings (PrinterSetupState *state) { do_fetch_page (state); do_fetch_scale (state); do_fetch_margins (state); do_fetch_unit (state); do_fetch_hf (state); do_fetch_page_info (state); } static void dialog_printer_setup_done_cb (GtkPageSetup *page_setup, gpointer data) { if (page_setup) { PrinterSetupState *state = data; print_info_set_page_setup (state->pi, gtk_page_setup_copy (page_setup)); do_update_page (state); } } static void dialog_gtk_printer_setup_cb (PrinterSetupState *state) { GtkPageSetup *page_setup = print_info_get_page_setup (state->pi); gtk_print_run_page_setup_dialog_async (GTK_WINDOW (state->dialog), page_setup, NULL, dialog_printer_setup_done_cb, state); } void dialog_printer_setup (WBCGtk *wbcg, Sheet *sheet) { PrinterSetupState *state; /* Only one guru per workbook. */ if (wbc_gtk_get_guru (wbcg)) return; /* Only pop up one copy per workbook */ if (gnumeric_dialog_raise_if_exists (wbcg, PRINTER_SETUP_KEY)) return; state = printer_setup_state_new (wbcg, sheet); if (!state) return; gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog), state->wbcg, GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED); gnumeric_init_help_button ( go_gtk_builder_get_widget (state->gui, "help_button"), GNUMERIC_HELP_LINK_PRINTER_SETUP_GENERAL); gnumeric_keyed_dialog ( wbcg, GTK_WINDOW (state->dialog), PRINTER_SETUP_KEY); gtk_widget_show (state->dialog); }