static void
gnm_dao_init (GnmDao *gdao)
{
GtkWidget *toplevel;
gdao->gui = gnm_gtk_builder_load ("dao.ui", NULL, NULL);
if (gdao->gui == NULL)
return;
toplevel = go_gtk_builder_get_widget (gdao->gui, "output-grid");
gdao->new_sheet = go_gtk_builder_get_widget (gdao->gui,
"newsheet-button");
gdao->new_workbook = go_gtk_builder_get_widget (gdao->gui,
"newworkbook-button");
gdao->output_range = go_gtk_builder_get_widget (gdao->gui,
"outputrange-button");
gdao->in_place = go_gtk_builder_get_widget (gdao->gui,
"inplace-button");
gdao->clear_outputrange_button = go_gtk_builder_get_widget
(gdao->gui, "clear_outputrange_button");
gdao->retain_format_button = go_gtk_builder_get_widget
(gdao->gui, "retain_format_button");
gdao->retain_comments_button = go_gtk_builder_get_widget
(gdao->gui, "retain_comments_button");
gdao->put_menu = go_gtk_builder_get_widget
(gdao->gui, "put_menu");
gtk_combo_box_set_active
(GTK_COMBO_BOX (gdao->put_menu), 1);
gdao->output_entry = NULL;
gdao->wbcg = NULL;
gtk_container_add (GTK_CONTAINER (gdao), toplevel);
}
void
dialog_goto_cell (WBCGtk *wbcg)
{
GotoState* state;
GtkBuilder *gui;
g_return_if_fail (wbcg != NULL);
if (gnm_dialog_raise_if_exists (wbcg, GOTO_KEY))
return;
gui = gnm_gtk_builder_load ("goto.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (GotoState, 1);
state->wbcg = wbcg;
state->wb = wb_control_get_workbook (GNM_WBC (wbcg));
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (state->gui, "goto_dialog");
if (dialog_goto_init (state)) {
go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR,
_("Could not create the goto dialog."));
g_free (state);
return;
}
gnm_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
GOTO_KEY);
gtk_widget_show_all (state->dialog);
}
static gboolean
data_table_init (GnmDialogDataTable *state, WBCGtk *wbcg)
{
state->gui = gnm_gtk_builder_load ("data-table.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (state->gui == NULL)
return TRUE;
state->dialog = go_gtk_builder_get_widget (state->gui, "DataTable");
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
state->row_entry = init_entry (state, 0);
state->col_entry = init_entry (state, 1);
g_signal_connect (G_OBJECT (state->dialog), "response",
G_CALLBACK (cb_data_table_response), state);
gnm_init_help_button (
go_gtk_builder_get_widget (state->gui, "help"),
GNUMERIC_HELP_LINK_DATA_TABLE);
/* a candidate for merging into attach guru */
gnm_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
DIALOG_DATA_TABLE_KEY);
go_gtk_nonmodal_dialog (wbcg_toplevel (state->wbcg),
GTK_WINDOW (state->dialog));
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify)cb_data_table_destroy);
gtk_widget_show_all (GTK_WIDGET (state->dialog));
return FALSE;
}
void
dialog_workbook_attr (WBCGtk *wbcg)
{
GtkBuilder *gui;
AttrState *state;
g_return_if_fail (wbcg != NULL);
if (gnm_dialog_raise_if_exists (wbcg, WORKBOOK_ATTRIBUTE_KEY))
return;
gui = gnm_gtk_builder_load ("res:ui/workbook-attr.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
/* Initialize */
state = g_new (AttrState, 1);
state->gui = gui;
state->wbcg = wbcg;
state->wbv = wb_control_view (GNM_WBC (wbcg));
state->wb = wb_control_get_workbook (GNM_WBC (wbcg));
attr_dialog_impl (state);
/* Select the same page the last invocation used */
attr_dialog_select_page (state, attr_dialog_page);
}
static gboolean
so_list_init (GnmDialogSOList *state, WBCGtk *wbcg, SheetObject *so)
{
GnmExprTop const *texpr;
GtkBuilder *gui;
gui = gnm_gtk_builder_load ("res:ui/so-list.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return TRUE;
state->wbcg = wbcg;
state->so = so;
state->dialog = go_gtk_builder_get_widget (gui, "SOList");
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
texpr = sheet_widget_list_base_get_content_link (so);
state->content_entry = init_entry (state, gui, 1, 4, texpr);
if (texpr) gnm_expr_top_unref (texpr);
texpr = sheet_widget_list_base_get_result_link (so);
state->link_entry = init_entry (state, gui, 1, 0, texpr);
if (texpr) gnm_expr_top_unref (texpr);
state->as_index_radio = go_gtk_builder_get_widget (gui, "as-index-radio");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->as_index_radio),
sheet_widget_list_base_result_type_is_index (so));
g_signal_connect (G_OBJECT (state->dialog), "response",
G_CALLBACK (cb_so_list_response), state);
gnm_init_help_button (
go_gtk_builder_get_widget (gui, "help"),
GNUMERIC_HELP_LINK_SO_LIST);
/* a candidate for merging into attach guru */
gnm_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
DIALOG_SO_LIST_KEY);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, g_free);
go_gtk_nonmodal_dialog (wbcg_toplevel (state->wbcg),
GTK_WINDOW (state->dialog));
wbc_gtk_attach_guru (state->wbcg, state->dialog);
gtk_widget_show_all (GTK_WIDGET (state->dialog));
g_object_unref (gui);
return FALSE;
}
void
dialog_col_row (WBCGtk *wbcg, char const *operation,
ColRowCallback_t callback,
gpointer data)
{
GtkBuilder *gui;
ColRowState *state;
g_return_if_fail (wbcg != NULL);
if (gnm_dialog_raise_if_exists (wbcg, COL_ROW_DIALOG_KEY))
return;
gui = gnm_gtk_builder_load ("colrow.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (ColRowState, 1);
state->wbcg = wbcg;
state->callback = callback;
state->data = data;
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (state->gui, "dialog");
state->ok_button = go_gtk_builder_get_widget (state->gui, "ok_button");
g_signal_connect (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_dialog_col_row_ok_clicked), state);
state->cancel_button = go_gtk_builder_get_widget (state->gui, "cancel_button");
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_dialog_col_row_cancel_clicked), state);
gnm_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_GROUP_UNGROUP);
gtk_window_set_title (GTK_WINDOW (state->dialog), operation);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_col_row_destroy);
gnm_keyed_dialog (wbcg, GTK_WINDOW (state->dialog),
COL_ROW_DIALOG_KEY);
gtk_widget_show (state->dialog);
}
void
dialog_recent_used (WBCGtk *wbcg)
{
GtkBuilder *gui;
GtkDialog *dialog;
/* Only pop up one copy per workbook */
if (gnumeric_dialog_raise_if_exists (wbcg, RECENT_KEY))
return;
gui = gnm_gtk_builder_load ("recent.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
dialog = GTK_DIALOG (go_gtk_builder_get_widget (gui, "recent_dialog"));
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (cb_response), wbcg);
{
GtkWidget *w = GTK_WIDGET (wbcg_toplevel (wbcg));
int width, height, vsep;
PangoLayout *layout =
gtk_widget_create_pango_layout (w, "Mg19");
gtk_widget_style_get (go_gtk_builder_get_widget (gui, "docs_treeview"),
"vertical_separator", &vsep,
NULL);
pango_layout_get_pixel_size (layout, &width, &height);
gtk_widget_set_size_request (go_gtk_builder_get_widget (gui, "docs_scrolledwindow"),
width * 60 / 4,
(2 * height + vsep) * (5 + 1));
g_object_unref (layout);
}
g_signal_connect_swapped (gtk_builder_get_object (gui, "existing_only_button"),
"toggled", G_CALLBACK (populate_recent_model), gui);
g_signal_connect_swapped (gtk_builder_get_object (gui, "gnumeric_only_button"),
"toggled", G_CALLBACK (populate_recent_model), gui);
populate_recent_model (gui);
gtk_tree_view_column_set_cell_data_func
(GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (gui, "url_column")),
GTK_CELL_RENDERER (gtk_builder_get_object (gui, "url_renderer")),
url_renderer_func,
NULL,
NULL);
gtk_tree_view_column_set_cell_data_func
(GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (gui, "age_column")),
GTK_CELL_RENDERER (gtk_builder_get_object (gui, "age_renderer")),
age_renderer_func,
g_date_time_new_now_local (),
(GDestroyNotify)g_date_time_unref);
/* ---------------------------------------- */
g_object_set_data_full (G_OBJECT (dialog), "gui", gui, g_object_unref);
go_gtk_nonmodal_dialog (wbcg_toplevel (wbcg), GTK_WINDOW (dialog));
gtk_widget_show_all (GTK_WIDGET (dialog));
}
/**
* stf_dialog
* @wbcg: a Commandcontext (can be NULL)
* @source: name of the file we are importing (or data) in UTF-8
* @data: the data itself
*
* This will start the import.
* (NOTE: you have to free the DialogStfResult_t that this function returns yourself)
*
* returns: A DialogStfResult_t struct on success, NULL otherwise.
**/
DialogStfResult_t*
stf_dialog (WBCGtk *wbcg,
const char *opt_encoding,
gboolean fixed_encoding,
const char *opt_locale,
gboolean fixed_locale,
const char *source,
const char *data,
int data_len)
{
GtkBuilder *gui;
DialogStfResult_t *dialogresult;
StfDialogData pagedata;
GtkResponseType resp;
g_return_val_if_fail (opt_encoding != NULL || !fixed_encoding, NULL);
g_return_val_if_fail (opt_locale != NULL || !fixed_locale, NULL);
g_return_val_if_fail (source != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
gui = gnm_gtk_builder_load ("dialog-stf.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return NULL;
pagedata.encoding = g_strdup (opt_encoding);
pagedata.fixed_encoding = fixed_encoding;
pagedata.locale = g_strdup (opt_locale);
pagedata.fixed_locale = fixed_locale;
pagedata.wbcg = wbcg;
pagedata.source = source;
pagedata.raw_data = data;
pagedata.raw_data_len = data_len < 0 ? (int)strlen (data) : data_len;
pagedata.utf8_data = NULL;
pagedata.cur = NULL;
pagedata.dialog = GTK_DIALOG (go_gtk_builder_get_widget (gui, "stf_dialog"));
pagedata.notebook = GTK_NOTEBOOK (go_gtk_builder_get_widget (gui, "stf_notebook"));
pagedata.next_button = go_gtk_builder_get_widget (gui, "forward_button");
pagedata.back_button = go_gtk_builder_get_widget (gui, "back_button");
pagedata.cancel_button = go_gtk_builder_get_widget (gui, "cancel_button");
pagedata.help_button = go_gtk_builder_get_widget (gui, "help_button");
pagedata.finish_button = go_gtk_builder_get_widget (gui, "finish_button");
pagedata.parseoptions = NULL;
gtk_widget_set_name (GTK_WIDGET (pagedata.dialog), "stf-import");
stf_dialog_main_page_init (gui, &pagedata);
stf_dialog_csv_page_init (gui, &pagedata);
stf_dialog_fixed_page_init (gui, &pagedata);
stf_dialog_format_page_init (gui, &pagedata);
stf_dialog_attach_page_signals (gui, &pagedata);
stf_dialog_editables_enter (&pagedata);
stf_dialog_set_initial_keyboard_focus (&pagedata);
prepare_page (&pagedata);
frob_buttons (&pagedata);
resp = go_gtk_dialog_run (pagedata.dialog, wbcg_toplevel (wbcg));
if (resp == GTK_RESPONSE_OK) {
dialogresult = g_new (DialogStfResult_t, 1);
dialogresult->text = pagedata.utf8_data;
*((char *)pagedata.cur_end) = 0;
if (dialogresult->text != pagedata.cur)
strcpy (dialogresult->text, pagedata.cur);
pagedata.cur = pagedata.utf8_data = NULL;
dialogresult->encoding = pagedata.encoding;
pagedata.encoding = NULL;
dialogresult->colcount = pagedata.format.col_import_count;
dialogresult->rowcount = pagedata.rowcount;
dialogresult->parseoptions = pagedata.parseoptions;
pagedata.parseoptions = NULL;
g_free (dialogresult->parseoptions->locale);
dialogresult->parseoptions->locale = pagedata.locale;
pagedata.locale = NULL;
dialogresult->parseoptions->formats = pagedata.format.formats;
pagedata.format.formats = NULL;
dialogresult->parseoptions->col_import_array
= pagedata.format.col_import_array;
dialogresult->parseoptions->col_import_array_len
= pagedata.format.col_import_array_len;
pagedata.format.col_import_array = NULL;
dialogresult->parseoptions->col_autofit_array
= pagedata.format.col_autofit_array;
pagedata.format.col_autofit_array = NULL;
pagedata.format.col_import_count = 0;
pagedata.format.col_import_array_len = 0;
} else {
dialogresult = NULL;
}
stf_dialog_main_page_cleanup (&pagedata);
stf_dialog_csv_page_cleanup (&pagedata);
stf_dialog_fixed_page_cleanup (&pagedata);
stf_dialog_format_page_cleanup (&pagedata);
g_object_unref (gui);
g_free (pagedata.encoding);
g_free (pagedata.locale);
g_free (pagedata.utf8_data);
if (pagedata.parseoptions)
stf_parse_options_free (pagedata.parseoptions);
return dialogresult;
}
void
dialog_delete_cells (WBCGtk *wbcg)
{
DeleteCellState *state;
WorkbookControl *wbc = GNM_WBC (wbcg);
SheetView *sv = wb_control_cur_sheet_view (wbc);
Sheet *sheet = sv_sheet (sv);
GnmRange const *sel;
GtkBuilder *gui;
GtkWidget *w;
int cols, rows;
g_return_if_fail (wbcg != NULL);
if (!(sel = selection_first_range (sv, GO_CMD_CONTEXT (wbc), _("Delete"))))
return;
cols = sel->end.col - sel->start.col + 1;
rows = sel->end.row - sel->start.row + 1;
if (range_is_full (sel, sheet, FALSE)) {
cmd_delete_cols (wbc, sheet, sel->start.col, cols);
return;
}
if (range_is_full (sel, sheet, TRUE)) {
cmd_delete_rows (wbc, sheet, sel->start.row, rows);
return;
}
if (gnm_dialog_raise_if_exists (wbcg, DELETE_CELL_DIALOG_KEY))
return;
gui = gnm_gtk_builder_load ("res:ui/delete-cells.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (DeleteCellState, 1);
state->wbcg = wbcg;
state->sel = sel;
state->gui = gui;
state->sheet = sv_sheet (sv);
state->dialog = go_gtk_builder_get_widget (state->gui, "Delete_cells");
if (state->dialog == NULL) {
go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR,
_("Could not create the Delete Cell dialog."));
g_free (state);
return ;
}
w = go_gtk_builder_get_widget (state->gui, "okbutton");
g_signal_connect_swapped (G_OBJECT (w), "clicked",
G_CALLBACK (cb_delete_cell_ok_clicked), state);
w = go_gtk_builder_get_widget (state->gui, "cancelbutton");
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (cb_delete_cell_cancel_clicked), state);
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
gnm_init_help_button (
go_gtk_builder_get_widget (state->gui, "helpbutton"),
GNUMERIC_HELP_LINK_DELETE_CELLS);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget
(state->gui, cols < rows
? "radio_0" : "radio_1")),
TRUE);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_delete_cell_destroy);
gnm_keyed_dialog (wbcg, GTK_WINDOW (state->dialog),
DELETE_CELL_DIALOG_KEY);
gtk_widget_show (state->dialog);
}
void
dialog_tabulate (WBCGtk *wbcg, Sheet *sheet)
{
GtkBuilder *gui;
GtkDialog *dialog;
DialogState *dd;
int i;
g_return_if_fail (wbcg != NULL);
/* Only one guru per workbook. */
if (wbc_gtk_get_guru (wbcg))
return;
if (gnm_dialog_raise_if_exists (wbcg, TABULATE_KEY))
return;
gui = gnm_gtk_builder_load ("tabulate.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
dialog = GTK_DIALOG (go_gtk_builder_get_widget (gui, "tabulate_dialog"));
dd = g_new (DialogState, 1);
dd->wbcg = wbcg;
dd->gui = gui;
dd->dialog = dialog;
dd->sheet = sheet;
dd->grid = GTK_GRID (go_gtk_builder_get_widget (gui, "main-grid"));
/* we might get the 4 below from the positon of some of the widgets inside the grid */
for (i = 1; i < 4; i++) {
GnmExprEntry *ge = gnm_expr_entry_new (wbcg, TRUE);
gnm_expr_entry_set_flags (ge,
GNM_EE_SINGLE_RANGE | GNM_EE_SHEET_OPTIONAL,
GNM_EE_MASK);
gtk_grid_attach (dd->grid, GTK_WIDGET (ge), COL_CELL, i + 1, 1, 1);
gtk_widget_set_margin_left (GTK_WIDGET (ge), 18);
gtk_widget_show (GTK_WIDGET (ge));
}
dd->resultrangetext = gnm_expr_entry_new (wbcg, TRUE);
gnm_expr_entry_set_flags (dd->resultrangetext,
GNM_EE_SINGLE_RANGE | GNM_EE_SHEET_OPTIONAL,
GNM_EE_MASK);
gtk_grid_attach (dd->grid, GTK_WIDGET (dd->resultrangetext), 0, 6, 4, 1);
gtk_widget_set_margin_left (GTK_WIDGET (dd->resultrangetext), 18);
gtk_widget_show (GTK_WIDGET (dd->resultrangetext));
g_signal_connect (G_OBJECT (go_gtk_builder_get_widget (gui, "ok_button")),
"clicked",
G_CALLBACK (tabulate_ok_clicked), dd);
g_signal_connect (G_OBJECT (go_gtk_builder_get_widget (gui, "cancel_button")),
"clicked",
G_CALLBACK (cancel_clicked), dd);
/* FIXME: Add correct helpfile address */
gnm_init_help_button (
go_gtk_builder_get_widget (gui, "help_button"),
GNUMERIC_HELP_LINK_TABULATE);
g_object_set_data_full (G_OBJECT (dialog),
"state", dd, (GDestroyNotify) cb_dialog_destroy);
gnm_dialog_setup_destroy_handlers (dialog, wbcg,
GNM_DIALOG_DESTROY_SHEET_REMOVED);
gtk_widget_show_all (gtk_dialog_get_content_area (dialog));
wbc_gtk_attach_guru (wbcg, GTK_WIDGET (dialog));
non_model_dialog (wbcg, dialog, TABULATE_KEY);
}
void
dialog_row_height (WBCGtk *wbcg, gboolean use_default)
{
RowHeightState *state;
g_return_if_fail (wbcg != NULL);
if (gnm_dialog_raise_if_exists (wbcg, ROW_HEIGHT_DIALOG_KEY))
return;
state = g_new (RowHeightState, 1);
state->wbcg = wbcg;
state->sv = wb_control_cur_sheet_view (GNM_WBC (wbcg));
state->sheet = sv_sheet (state->sv);
state->adjusting = FALSE;
state->gui = gnm_gtk_builder_load ("row-height.ui", NULL, GO_CMD_CONTEXT (wbcg));
g_return_if_fail (state->gui != NULL);
state->dialog = go_gtk_builder_get_widget (state->gui, "dialog");
state->description = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "description"));
state->points = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "pts-label"));
state->spin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "spin"));
gtk_adjustment_set_lower (gtk_spin_button_get_adjustment (state->spin),
GNM_ROW_MARGIN + GNM_ROW_MARGIN + 1);
g_signal_connect (G_OBJECT (state->spin),
"value-changed",
G_CALLBACK (cb_dialog_row_height_value_changed), state);
state->default_check = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "default_check"));
g_signal_connect (G_OBJECT (state->default_check),
"clicked",
G_CALLBACK (cb_dialog_row_height_default_check_toggled), state);
state->ok_button = go_gtk_builder_get_widget (state->gui, "ok_button");
g_signal_connect (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_dialog_row_height_ok_clicked), state);
state->apply_button = go_gtk_builder_get_widget (state->gui, "apply_button");
g_signal_connect (G_OBJECT (state->apply_button),
"clicked",
G_CALLBACK (cb_dialog_row_height_apply_clicked), state);
state->cancel_button = go_gtk_builder_get_widget (state->gui, "cancel_button");
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_dialog_row_height_cancel_clicked), state);
gnm_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_ROW_HEIGHT);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_row_height_destroy);
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
dialog_row_height_set_mode (use_default, state);
dialog_row_height_load_value (state);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
gnm_keyed_dialog (wbcg, GTK_WINDOW (state->dialog),
ROW_HEIGHT_DIALOG_KEY);
gtk_widget_show (state->dialog);
}
void
dialog_preferences (WBCGtk *wbcg, gchar const *page)
{
PrefState *state;
GtkBuilder *gui;
GtkWidget *w;
gint i;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
w = g_object_get_data (gnm_app_get_app (), PREF_DIALOG_KEY);
if (w) {
gtk_widget_show (w);
gdk_window_raise (gtk_widget_get_window (w));
return;
}
gui = gnm_gtk_builder_load ("preferences.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new0 (PrefState, 1);
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (gui, "preferences");
state->notebook = (GtkNotebook*)go_gtk_builder_get_widget (gui, "notebook");
state->view = GTK_TREE_VIEW(go_gtk_builder_get_widget (gui, "itemlist"));
state->store = gtk_tree_store_new (NUM_COLUMNS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_INT);
gtk_tree_view_set_model (state->view, GTK_TREE_MODEL(state->store));
selection = gtk_tree_view_get_selection (state->view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
column = gtk_tree_view_column_new_with_attributes ("",
gtk_cell_renderer_pixbuf_new (),
"pixbuf", ITEM_ICON,
NULL);
gtk_tree_view_append_column (state->view, column);
column = gtk_tree_view_column_new_with_attributes ("",
gtk_cell_renderer_text_new (),
"text", ITEM_NAME,
NULL);
gtk_tree_view_append_column (state->view, column);
gtk_tree_view_set_expander_column (state->view, column);
g_signal_connect (selection,
"changed",
G_CALLBACK (cb_dialog_pref_selection_changed), state);
g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "close_button")),
"clicked",
G_CALLBACK (cb_close_clicked), state);
gnumeric_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_PREFERENCES);
g_signal_connect_swapped (G_OBJECT (state->dialog),
"destroy",
G_CALLBACK(cb_preferences_destroy),
state);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state,
(GDestroyNotify)g_free);
g_object_set_data (gnm_app_get_app (), PREF_DIALOG_KEY, state->dialog);
state->app_wb_removed_sig =
g_signal_connect_swapped (gnm_app_get_app (),
"workbook_removed",
G_CALLBACK (cb_workbook_removed),
state);
for (i = 0; page_info[i].page_initializer; i++) {
const page_info_t *this_page = &page_info[i];
GtkWidget *page_widget =
this_page->page_initializer (state, NULL,
state->notebook, i);
gtk_notebook_append_page (state->notebook, page_widget, NULL);
dialog_pref_add_item (state, this_page->page_name,
this_page->icon_name, i,
this_page->parent_path);
}
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (state->store),
ITEM_NAME, GTK_SORT_ASCENDING);
go_gtk_nonmodal_dialog (wbcg_toplevel (wbcg),
GTK_WINDOW (state->dialog));
gtk_widget_show (GTK_WIDGET (state->dialog));
dialog_pref_select_page (state, page);
}
void
dialog_sheet_order (WBCGtk *wbcg)
{
SheetManager *state;
GtkBuilder *gui;
GtkGrid *grid;
GOColorGroup *cg;
Workbook *wb;
GtkWidget *widget;
GdkPixbuf *icon;
g_return_if_fail (wbcg != NULL);
widget = GTK_WIDGET (wbcg_toplevel (wbcg));
gui = gnm_gtk_builder_load ("res:ui/sheet-order.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
wb = wb_control_get_workbook (GNM_WBC (wbcg));
if (g_object_get_data (G_OBJECT (wb), SHEET_ORDER_KEY)) {
GtkWidget *dialog = gtk_message_dialog_new
(wbcg_toplevel (wbcg),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_CLOSE,
_("Another view is already managing sheets"));
go_gtk_dialog_run (GTK_DIALOG (dialog), wbcg_toplevel (wbcg));
return;
}
g_object_set_data (G_OBJECT (wb), SHEET_ORDER_KEY, (gpointer) gui);
state = g_new0 (SheetManager, 1);
state->gui = gui;
state->wbcg = wbcg;
state->dialog = go_gtk_builder_get_widget (gui, "sheet-order-dialog");
state->warning = go_gtk_builder_get_widget (gui, "warning");
state->up_btn = go_gtk_builder_get_widget (gui, "up_button");
state->down_btn = go_gtk_builder_get_widget (gui, "down_button");
state->add_btn = go_gtk_builder_get_widget (gui, "add_button");
state->append_btn = go_gtk_builder_get_widget (gui, "append_button");
state->duplicate_btn = go_gtk_builder_get_widget (gui, "duplicate_button");
state->delete_btn = go_gtk_builder_get_widget (gui, "delete_button");
state->apply_names_btn = go_gtk_builder_get_widget (gui, "ok_button");
state->sort_asc_btn = go_gtk_builder_get_widget (gui, "sort-asc-button");
state->sort_desc_btn = go_gtk_builder_get_widget (gui, "sort-desc-button");
state->undo_btn = go_gtk_builder_get_widget (gui, "undo-button");
state->cancel_btn = go_gtk_builder_get_widget (gui, "cancel_button");
state->advanced_check = go_gtk_builder_get_widget (gui, "advanced-check");
state->initial_colors_set = FALSE;
state->image_padlock = go_gtk_widget_render_icon_pixbuf (widget, "gnumeric-protection-yes", GTK_ICON_SIZE_MENU);
state->image_padlock_no = go_gtk_widget_render_icon_pixbuf (widget, "gnumeric-protection-no", GTK_ICON_SIZE_MENU);
state->image_visible = go_gtk_widget_render_icon_pixbuf (widget, "gnumeric-visible", GTK_ICON_SIZE_MENU);
state->image_ltr = go_gtk_widget_render_icon_pixbuf (widget, "format-text-direction-ltr", GTK_ICON_SIZE_MENU);
state->image_rtl = go_gtk_widget_render_icon_pixbuf (widget, "format-text-direction-rtl", GTK_ICON_SIZE_MENU);
/* Listen for changes in the sheet order. */
state->sheet_order_changed_listener = g_signal_connect (G_OBJECT (wb),
"sheet_order_changed", G_CALLBACK (cb_sheet_order_changed),
state);
state->sheet_added_listener = g_signal_connect (G_OBJECT (wb),
"sheet_added", G_CALLBACK (cb_sheet_added),
state);
state->sheet_deleted_listener = g_signal_connect (G_OBJECT (wb),
"sheet_deleted", G_CALLBACK (cb_sheet_deleted),
state);
grid = GTK_GRID (go_gtk_builder_get_widget (gui,"main-grid"));
cg = go_color_group_fetch ("back_color_group",
wb_control_view (GNM_WBC (wbcg)));
icon = go_gtk_widget_render_icon_pixbuf (widget, "gnumeric-bucket", GTK_ICON_SIZE_LARGE_TOOLBAR);
state->ccombo_back = go_combo_color_new (icon, _("Default"), 0, cg);
g_object_unref (icon);
g_object_unref (cg);
go_combo_color_set_instant_apply (
GO_COMBO_COLOR (state->ccombo_back), TRUE);
gtk_grid_attach (grid, state->ccombo_back, 1, 4, 1, 1);
gtk_widget_set_sensitive (state->ccombo_back, FALSE);
cg = go_color_group_fetch ("fore_color_group",
wb_control_view (GNM_WBC (wbcg)));
icon = go_gtk_widget_render_icon_pixbuf (widget, "font", GTK_ICON_SIZE_LARGE_TOOLBAR);
state->ccombo_fore = go_combo_color_new (icon, _("Default"), 0, cg);
g_object_unref (icon);
g_object_unref (cg);
go_combo_color_set_instant_apply (
GO_COMBO_COLOR (state->ccombo_fore), TRUE);
gtk_grid_attach (grid, state->ccombo_fore, 2, 4, 1, 1);
gtk_widget_set_sensitive (state->ccombo_fore, FALSE);
create_sheet_list (state);
populate_sheet_list (state);
#define CONNECT(o,s,c) g_signal_connect(G_OBJECT(o),s,G_CALLBACK(c),state)
CONNECT (state->up_btn, "clicked", cb_up);
CONNECT (state->down_btn, "clicked", cb_down);
CONNECT (state->sort_asc_btn, "clicked", cb_asc);
CONNECT (state->sort_desc_btn, "clicked", cb_desc);
CONNECT (state->add_btn, "clicked", cb_add_clicked);
CONNECT (state->append_btn, "clicked", cb_append_clicked);
CONNECT (state->duplicate_btn, "clicked", cb_duplicate_clicked);
CONNECT (state->delete_btn, "clicked", cb_delete_clicked);
CONNECT (state->apply_names_btn, "clicked", cb_apply_names_clicked);
CONNECT (state->cancel_btn, "clicked", cb_cancel_clicked);
CONNECT (state->undo_btn, "clicked", cb_undo_clicked);
CONNECT (state->advanced_check, "toggled", cb_adv_check_toggled);
CONNECT (state->ccombo_back, "color_changed", cb_color_changed_back);
CONNECT (state->ccombo_fore, "color_changed", cb_color_changed_fore);
CONNECT (state->model, "rows-reordered", cb_dialog_order_changed);
state->model_row_insertion_listener =
CONNECT (state->model, "row-inserted", cb_dialog_order_changed_by_insertion);
#undef CONNECT
cb_adv_check_toggled (NULL, state);
gnm_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_SHEET_MANAGER);
gtk_widget_set_sensitive (state->undo_btn, wb->undo_commands != NULL);
gtk_widget_set_sensitive (state->apply_names_btn, FALSE);
/* a candidate for merging into attach guru */
wbc_gtk_attach_guru (state->wbcg, GTK_WIDGET (state->dialog));
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_sheet_order_destroy);
g_signal_connect (G_OBJECT (state->dialog), "destroy", G_CALLBACK (destroy_cb), NULL);
gnm_restore_window_geometry (GTK_WINDOW (state->dialog),
SHEET_ORDER_KEY);
go_gtk_nonmodal_dialog (wbcg_toplevel (state->wbcg),
GTK_WINDOW (state->dialog));
gtk_widget_show_all (GTK_WIDGET (state->dialog));
}
void
dialog_new_view (WBCGtk *wbcg)
{
ViewState *state;
GtkBuilder *gui;
if (gnm_dialog_raise_if_exists (wbcg, VIEW_DIALOG_KEY))
return;
gui = gnm_gtk_builder_load ("view.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (ViewState, 1);
state->wbcg = wbcg;
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (gui, "View");
state->location_elsewhere = GTK_RADIO_BUTTON (go_gtk_builder_get_widget (gui, "location_elsewhere"));
state->location_display_name = GTK_ENTRY (go_gtk_builder_get_widget (gui, "location_display_name"));
g_return_if_fail (state->dialog != NULL);
{
GdkScreen *this_screen = gtk_window_get_screen (wbcg_toplevel (wbcg));
GdkDisplay *this_display = gdk_screen_get_display (this_screen);
int n_screens = gdk_display_get_n_screens (this_display);
GtkBox *box = GTK_BOX (go_gtk_builder_get_widget (gui, "location_screens_vbox"));
int i;
for (i = 0; i < n_screens; i++) {
/* Get this for every screen -- it might change. */
GSList *group =
gtk_radio_button_get_group (state->location_elsewhere);
GdkScreen *screen = gdk_display_get_screen (this_display, i);
char *label =
screen == this_screen
? (n_screens == 1
? g_strdup (_("This screen"))
: g_strdup_printf (_("Screen %d [This screen]"), i))
: g_strdup_printf (_("Screen %d"), i);
GtkWidget *button =
gtk_radio_button_new_with_label (group, label);
g_free (label);
if (screen == this_screen)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_object_set_data (G_OBJECT (button),
"screen", screen);
gtk_box_pack_start (box, button, TRUE, TRUE, 0);
}
}
g_signal_connect (G_OBJECT (go_gtk_builder_get_widget (gui, "ok_button")),
"clicked",
G_CALLBACK (cb_view_ok_clicked), state);
g_signal_connect (G_OBJECT (go_gtk_builder_get_widget (gui, "cancel_button")),
"clicked",
G_CALLBACK (cb_view_cancel_clicked), state);
gnm_link_button_and_entry (GTK_WIDGET (state->location_elsewhere),
GTK_WIDGET (state->location_display_name));
gnm_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->location_display_name));
gnm_init_help_button (
go_gtk_builder_get_widget (gui, "help_button"),
GNUMERIC_HELP_LINK_VIEW);
gnm_keyed_dialog (wbcg, GTK_WINDOW (state->dialog),
VIEW_DIALOG_KEY);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_view_destroy);
gtk_widget_show_all (state->dialog);
}
void
dialog_merge (WBCGtk *wbcg)
{
MergeState *state;
GtkBuilder *gui;
GtkGrid *grid;
GtkWidget *scrolled;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GnmRange const *r;
g_return_if_fail (wbcg != NULL);
if (gnumeric_dialog_raise_if_exists (wbcg, MERGE_KEY))
return;
gui = gnm_gtk_builder_load ("merge.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new0 (MergeState, 1);
state->gui = gui;
state->wbcg = wbcg;
state->sheet = wb_control_cur_sheet (WORKBOOK_CONTROL (state->wbcg));
state->dialog = go_gtk_builder_get_widget (gui, "Merge");
state->warning_dialog = NULL;
state->add_btn = go_gtk_builder_get_widget (gui, "add_button");
state->delete_btn = go_gtk_builder_get_widget (gui, "remove_button");
state->merge_btn = go_gtk_builder_get_widget (gui, "merge_button");
state->change_btn = go_gtk_builder_get_widget (gui, "change_button");
state->cancel_btn = go_gtk_builder_get_widget (gui, "cancel_button");
gtk_widget_set_size_request (state->delete_btn, 100, -1);
gtk_button_set_alignment (GTK_BUTTON (state->add_btn), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->delete_btn), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->change_btn), 0., .5);
grid = GTK_GRID (go_gtk_builder_get_widget (gui, "main-grid"));
state->zone = gnm_expr_entry_new (wbcg, TRUE);
gnm_expr_entry_set_flags (state->zone, GNM_EE_SINGLE_RANGE, GNM_EE_MASK);
gnumeric_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->zone));
gtk_label_set_mnemonic_widget (GTK_LABEL (go_gtk_builder_get_widget (gui, "var1-label")),
GTK_WIDGET (state->zone));
gtk_widget_set_hexpand (GTK_WIDGET (state->zone), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->zone), 1, 0, 2, 1);
r = selection_first_range (
wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg)), NULL, NULL);
if (r != NULL)
gnm_expr_entry_load_from_range (state->zone,
state->sheet, r);
state->data = gnm_expr_entry_new (wbcg, TRUE);
gnm_expr_entry_set_flags (state->data, GNM_EE_SINGLE_RANGE, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->data), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->data), 0, 5, 1, 1);
state->field = gnm_expr_entry_new (wbcg, TRUE);
gnm_expr_entry_set_flags (state->field, GNM_EE_SINGLE_RANGE, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->field), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->field), 1, 5, 1, 1);
scrolled = go_gtk_builder_get_widget (state->gui, "scrolled");
state->model = gtk_list_store_new (NUM_COLMNS, G_TYPE_STRING, G_TYPE_STRING);
state->list = GTK_TREE_VIEW (gtk_tree_view_new_with_model
(GTK_TREE_MODEL (state->model)));
selection = gtk_tree_view_get_selection (state->list);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
column = gtk_tree_view_column_new_with_attributes (_("Input Data"),
gtk_cell_renderer_text_new (),
"text", DATA_RANGE,
NULL);
gtk_tree_view_column_set_sort_column_id (column, DATA_RANGE);
gtk_tree_view_column_set_min_width (column, 150);
gtk_tree_view_append_column (state->list, column);
column = gtk_tree_view_column_new_with_attributes (_("Merge Field"),
gtk_cell_renderer_text_new (),
"text", FIELD_LOCATION,
NULL);
gtk_tree_view_column_set_sort_column_id (column, FIELD_LOCATION);
gtk_tree_view_column_set_min_width (column, 100);
gtk_tree_view_append_column (state->list, column);
gtk_tree_view_set_headers_clickable (state->list, TRUE);
gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (state->list));
cb_merge_update_buttons (NULL, state);
g_signal_connect (selection,
"changed",
G_CALLBACK (cb_merge_selection_changed), state);
g_signal_connect_after (G_OBJECT (state->zone),
"changed",
G_CALLBACK (cb_merge_update_buttons), state);
g_signal_connect_after (G_OBJECT (state->data),
"changed",
G_CALLBACK (cb_merge_update_buttons), state);
g_signal_connect_after (G_OBJECT (state->field),
"changed",
G_CALLBACK (cb_merge_update_buttons), state);
g_signal_connect (G_OBJECT (state->add_btn),
"clicked",
G_CALLBACK (cb_merge_add_clicked), state);
g_signal_connect (G_OBJECT (state->change_btn),
"clicked",
G_CALLBACK (cb_merge_change_clicked), state);
g_signal_connect (G_OBJECT (state->delete_btn),
"clicked",
G_CALLBACK (cb_merge_delete_clicked), state);
g_signal_connect (G_OBJECT (state->merge_btn),
"clicked",
G_CALLBACK (cb_merge_merge_clicked), state);
g_signal_connect (G_OBJECT (state->cancel_btn),
"clicked",
G_CALLBACK (cb_merge_cancel_clicked), state);
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_DATA_MERGE);
gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
MERGE_KEY);
/* a candidate for merging into attach guru */
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_merge_destroy);
go_gtk_nonmodal_dialog (wbcg_toplevel (state->wbcg),
GTK_WINDOW (state->dialog));
wbc_gtk_attach_guru (state->wbcg, GTK_WIDGET (state->dialog));
gtk_widget_show_all (GTK_WIDGET (state->dialog));
}
void
dialog_autosave (WBCGtk *wbcg)
{
GtkBuilder *gui;
autosave_t *state;
int secs;
gboolean prompt;
g_return_if_fail (wbcg != NULL);
if (gnm_dialog_raise_if_exists (wbcg, AUTOSAVE_KEY))
return;
gui = gnm_gtk_builder_load ("autosave.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
g_object_get (wbcg,
"autosave-time", &secs,
"autosave-prompt", &prompt,
NULL);
state = g_new (autosave_t, 1);
state->wbcg = wbcg;
state->wb = wb_control_get_workbook (GNM_WBC (wbcg));
state->dialog = go_gtk_builder_get_widget (gui, "AutoSave");
state->minutes_entry = go_gtk_builder_get_widget (gui, "minutes");
state->prompt_cb = go_gtk_builder_get_widget (gui, "prompt_on_off");
state->autosave_on_off = go_gtk_builder_get_widget (gui, "autosave_on_off");
state->ok_button = go_gtk_builder_get_widget (gui, "button1");
state->cancel_button = go_gtk_builder_get_widget (gui, "button2");
if (!state->dialog || !state->minutes_entry || !state->prompt_cb ||
!state->autosave_on_off) {
go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR,
_("Could not create the autosave dialog."));
g_free (state);
return;
}
float_to_entry (GTK_ENTRY (state->minutes_entry),
secs / 60);
gnm_editable_enters (GTK_WINDOW (state->dialog),
state->minutes_entry);
g_signal_connect (G_OBJECT (state->autosave_on_off),
"toggled",
G_CALLBACK (autosave_set_sensitivity), state);
g_signal_connect (G_OBJECT (state->minutes_entry),
"changed",
G_CALLBACK (autosave_set_sensitivity), state);
g_signal_connect (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_autosave_ok), state);
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_autosave_cancel), state);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify)g_free);
gnm_init_help_button (
go_gtk_builder_get_widget (gui, "button3"),
GNUMERIC_HELP_LINK_AUTOSAVE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->autosave_on_off),
secs > 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->prompt_cb),
prompt);
autosave_set_sensitivity (NULL, state);
gnm_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
AUTOSAVE_KEY);
gtk_widget_show (state->dialog);
g_object_unref (gui);
}
/**
* dialog_init:
* @state:
*
* Create the dialog (guru).
*
**/
static gboolean
dialog_init (SolverState *state)
{
GtkGrid *grid;
GnmSolverParameters *param;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeViewColumn *column;
GSList *cl;
GnmCell *target_cell;
GnmValue const *input;
int i;
param = state->sheet->solver_parameters;
state->gui = gnm_gtk_builder_load ("solver.ui", NULL, GO_CMD_CONTEXT (state->wbcg));
if (state->gui == NULL)
return TRUE;
state->dialog = go_gtk_builder_get_widget (state->gui, "Solver");
if (state->dialog == NULL)
return TRUE;
state->notebook = go_gtk_builder_get_widget (state->gui, "solver_notebook");
/* buttons */
state->solve_button = go_gtk_builder_get_widget (state->gui, "solvebutton");
g_signal_connect (G_OBJECT (state->solve_button), "clicked",
G_CALLBACK (cb_dialog_solve_clicked), state);
state->close_button = go_gtk_builder_get_widget (state->gui, "closebutton");
g_signal_connect (G_OBJECT (state->close_button), "clicked",
G_CALLBACK (cb_dialog_close_clicked), state);
state->help_button = go_gtk_builder_get_widget (state->gui, "helpbutton");
gnm_init_help_button (state->help_button, GNUMERIC_HELP_LINK_SOLVER);
state->add_button = go_gtk_builder_get_widget (state->gui, "addbutton");
gtk_button_set_alignment (GTK_BUTTON (state->add_button), 0.5, .5);
g_signal_connect_swapped (G_OBJECT (state->add_button), "clicked",
G_CALLBACK (cb_dialog_add_clicked), state);
state->change_button = go_gtk_builder_get_widget (state->gui,
"changebutton");
g_signal_connect (G_OBJECT (state->change_button), "clicked",
G_CALLBACK (cb_dialog_change_clicked), state);
state->delete_button = go_gtk_builder_get_widget (state->gui,
"deletebutton");
gtk_button_set_alignment (GTK_BUTTON (state->delete_button), 0.5, .5);
g_signal_connect (G_OBJECT (state->delete_button), "clicked",
G_CALLBACK (cb_dialog_delete_clicked), state);
state->stop_button = go_gtk_builder_get_widget (state->gui, "stopbutton");
g_signal_connect_swapped (G_OBJECT (state->stop_button),
"clicked", G_CALLBACK (cb_stop_solver),
state);
/* target_entry */
grid = GTK_GRID (go_gtk_builder_get_widget (state->gui,
"parameter-grid"));
state->target_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->target_entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->target_entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->target_entry), 1, 0, 2, 1);
gnm_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->target_entry));
gtk_widget_show (GTK_WIDGET (state->target_entry));
g_signal_connect_after (G_OBJECT (state->target_entry), "changed",
G_CALLBACK (dialog_set_main_button_sensitivity),
state);
/* change_cell_entry */
state->change_cell_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->change_cell_entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->change_cell_entry), TRUE);
gtk_grid_attach (grid,
GTK_WIDGET (state->change_cell_entry), 1, 2, 2, 1);
gnm_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->change_cell_entry));
gtk_widget_show (GTK_WIDGET (state->change_cell_entry));
g_signal_connect_after (G_OBJECT (state->change_cell_entry), "changed",
G_CALLBACK (dialog_set_main_button_sensitivity), state);
/* Algorithm */
state->algorithm_combo = GTK_COMBO_BOX
(go_gtk_builder_get_widget (state->gui, "algorithm_combo"));
renderer = (GtkCellRenderer*) gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (state->algorithm_combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (state->algorithm_combo), renderer,
"text", 0,
NULL);
fill_algorithm_combo (state, param->options.model_type);
for (i = 0; model_type_group[i]; i++) {
const char *bname = model_type_group[i];
GtkWidget *w = go_gtk_builder_get_widget(state->gui, bname);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
param->options.model_type ==
(GnmSolverModelType)i);
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (cb_dialog_model_type_clicked), state);
}
/* Options */
state->max_iter_entry = go_gtk_builder_get_widget (state->gui,
"max_iter_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_iter_entry),
param->options.max_iter);
state->max_time_entry = go_gtk_builder_get_widget (state->gui,
"max_time_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_time_entry),
param->options.max_time_sec);
state->gradient_order_entry = go_gtk_builder_get_widget (state->gui,
"gradient_order_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->gradient_order_entry),
param->options.gradient_order);
/* lhs_entry */
grid = GTK_GRID (go_gtk_builder_get_widget (state->gui,
"constraints-grid"));
state->lhs.entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->lhs.entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->lhs.entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->lhs.entry), 0, 4, 1, 1);
state->lhs.label = go_gtk_builder_get_widget (state->gui, "lhs_label");
gtk_label_set_mnemonic_widget (GTK_LABEL (state->lhs.label),
GTK_WIDGET (state->lhs.entry));
gtk_widget_show (GTK_WIDGET (state->lhs.entry));
g_signal_connect_after (G_OBJECT (state->lhs.entry),
"changed",
G_CALLBACK (dialog_set_sec_button_sensitivity), state);
g_signal_connect_swapped (
gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->lhs.entry)),
"activate", G_CALLBACK (cb_dialog_add_clicked), state);
/* rhs_entry */
state->rhs.entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->rhs.entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL |
GNM_EE_CONSTANT_ALLOWED,
GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->rhs.entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->rhs.entry), 2, 4, 1, 1);
gtk_widget_show (GTK_WIDGET (state->rhs.entry));
state->rhs.label = go_gtk_builder_get_widget (state->gui, "rhs_label");
gtk_label_set_mnemonic_widget (
GTK_LABEL (state->rhs.label), GTK_WIDGET (state->rhs.entry));
g_signal_connect_after (G_OBJECT (state->rhs.entry),
"changed",
G_CALLBACK (dialog_set_sec_button_sensitivity), state);
g_signal_connect_swapped (
gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->rhs.entry)),
"activate", G_CALLBACK (cb_dialog_add_clicked), state);
/* type_menu */
state->type_combo = GTK_COMBO_BOX
(go_gtk_builder_get_widget (state->gui, "type_menu"));
gtk_combo_box_set_active (state->type_combo, 0);
g_signal_connect (state->type_combo, "changed",
G_CALLBACK (dialog_set_sec_button_sensitivity),
state);
/* constraint_list */
state->constraint_list = GTK_TREE_VIEW (go_gtk_builder_get_widget
(state->gui, "constraint_list"));
state->constr = NULL;
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (state->constraint_list)), "changed",
G_CALLBACK (constraint_select_click), state);
gtk_tree_view_set_reorderable (state->constraint_list, TRUE);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_view_set_model (state->constraint_list, GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (
_("Subject to the Constraints:"),
renderer, "text", 0, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (state->constraint_list, column);
{
GtkWidget *w = GTK_WIDGET (state->constraint_list);
int width, height, vsep;
PangoLayout *layout =
gtk_widget_create_pango_layout (w, "Mg19");
gtk_widget_style_get (w,
"vertical_separator", &vsep,
NULL);
pango_layout_get_pixel_size (layout, &width, &height);
gtk_widget_set_size_request (w,
-1,
(2 * height + vsep) * (4 + 1));
g_object_unref (layout);
}
/* Loading the old solver specs... from param */
for (cl = param->constraints; cl; cl = cl->next) {
GnmSolverConstraint const *c = cl->data;
GtkTreeIter iter;
char *str;
gtk_list_store_append (store, &iter);
str = gnm_solver_constraint_as_str (c, state->sheet);
gtk_list_store_set (store, &iter, 0, str, 1, c, -1);
g_free (str);
}
g_object_unref (store);
INIT_BOOL_ENTRY ("autoscale_button", options.automatic_scaling);
INIT_BOOL_ENTRY ("non_neg_button", options.assume_non_negative);
INIT_BOOL_ENTRY ("all_int_button", options.assume_discrete);
INIT_BOOL_ENTRY ("program", options.program_report);
INIT_BOOL_ENTRY ("sensitivity", options.sensitivity_report);
input = gnm_solver_param_get_input (param);
if (input != NULL)
gnm_expr_entry_load_from_text (state->change_cell_entry,
value_peek_string (input));
target_cell = gnm_solver_param_get_target_cell (param);
if (target_cell)
gnm_expr_entry_load_from_text (state->target_entry,
cell_name (target_cell));
else {
SheetView *sv = wb_control_cur_sheet_view
(GNM_WBC (state->wbcg));
if (sv) {
GnmRange first = {sv->edit_pos, sv->edit_pos};
gnm_expr_entry_load_from_range (state->target_entry,
state->sheet, &first);
}
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "max_button")),
param->problem_type == GNM_SOLVER_MAXIMIZE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "min_button")),
param->problem_type == GNM_SOLVER_MINIMIZE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "no_scenario")),
! param->options.add_scenario);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "optimal_scenario")),
param->options.add_scenario);
state->scenario_name_entry = go_gtk_builder_get_widget
(state->gui, "scenario_name_entry");
gtk_entry_set_text (GTK_ENTRY (state->scenario_name_entry),
param->options.scenario_name);
state->run.status_widget = go_gtk_builder_get_widget (state->gui, "solver_status_label");
state->run.problem_status_widget = go_gtk_builder_get_widget (state->gui, "problem_status_label");
state->run.objective_value_widget = go_gtk_builder_get_widget (state->gui, "objective_value_label");
state->run.timer_widget = go_gtk_builder_get_widget (state->gui, "elapsed_time_label");
state->run.spinner = go_gtk_builder_get_widget (state->gui, "run_spinner");
/* Done */
gnm_expr_entry_grab_focus (state->target_entry, FALSE);
wbcg_set_entry (state->wbcg, state->target_entry);
dialog_set_main_button_sensitivity (NULL, state);
dialog_set_sec_button_sensitivity (NULL, state);
/* dialog */
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_signal_connect_swapped (G_OBJECT (state->dialog),
"destroy",
G_CALLBACK (cb_dialog_solver_destroy),
state);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state,
(GDestroyNotify)unref_state);
return FALSE;
}
void
dialog_search (WBCGtk *wbcg)
{
GtkBuilder *gui;
GtkDialog *dialog;
DialogState *dd;
GtkGrid *grid;
g_return_if_fail (wbcg != NULL);
/* Only one guru per workbook. */
if (wbc_gtk_get_guru (wbcg))
return;
gui = gnm_gtk_builder_load ("search.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
dialog = GTK_DIALOG (gtk_builder_get_object (gui, "search_dialog"));
dd = g_new (DialogState, 1);
dd->wbcg = wbcg;
dd->gui = gui;
dd->dialog = dialog;
dd->matches = g_ptr_array_new ();
dd->prev_button = go_gtk_builder_get_widget (gui, "prev_button");
dd->next_button = go_gtk_builder_get_widget (gui, "next_button");
dd->notebook = GTK_NOTEBOOK (gtk_builder_get_object (gui, "notebook"));
dd->notebook_matches_page =
gtk_notebook_page_num (dd->notebook,
go_gtk_builder_get_widget (gui, "matches_tab"));
dd->rangetext = gnm_expr_entry_new (wbcg, TRUE);
gnm_expr_entry_set_flags (dd->rangetext, 0, GNM_EE_MASK);
grid = GTK_GRID (gtk_builder_get_object (gui, "normal-grid"));
gtk_widget_set_hexpand (GTK_WIDGET (dd->rangetext), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (dd->rangetext), 1, 6, 1, 1);
{
char *selection_text =
selection_to_string (
wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg)),
TRUE);
gnm_expr_entry_load_from_text (dd->rangetext, selection_text);
g_free (selection_text);
}
dd->gentry = GTK_ENTRY (gtk_entry_new ());
gtk_widget_set_hexpand (GTK_WIDGET (dd->gentry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (dd->gentry), 1, 0, 1, 1);
gtk_widget_grab_focus (GTK_WIDGET (dd->gentry));
gnumeric_editable_enters (GTK_WINDOW (dialog), GTK_WIDGET (dd->gentry));
dd->matches_table = make_matches_table (dd);
{
GtkWidget *scrolled_window =
gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window),
GTK_WIDGET (dd->matches_table));
gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (gui, "matches_vbox")),
scrolled_window,
TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_ALWAYS);
}
/* Set sensitivity of buttons. */
cursor_change (dd->matches_table, dd);
#define SETW(w,f) gtk_toggle_button_set_active \
(GTK_TOGGLE_BUTTON (gtk_builder_get_object (gui, w)), f())
SETW("search_expr", gnm_conf_get_searchreplace_change_cell_expressions);
SETW("search_other", gnm_conf_get_searchreplace_change_cell_other);
SETW("search_string", gnm_conf_get_searchreplace_change_cell_strings);
SETW("search_comments", gnm_conf_get_searchreplace_change_comments);
SETW("search_expr_results", gnm_conf_get_searchreplace_search_results);
SETW("ignore_case", gnm_conf_get_searchreplace_ignore_case);
SETW("match_words", gnm_conf_get_searchreplace_whole_words_only);
#undef SETW
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON
(gtk_builder_get_object
(gui,
search_type_group[gnm_conf_get_searchreplace_regex ()])), TRUE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON
(gtk_builder_get_object
(gui,
direction_group
[gnm_conf_get_searchreplace_columnmajor () ? 1 : 0])), TRUE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON
(gtk_builder_get_object
(gui,
scope_group[gnm_conf_get_searchreplace_scope ()])), TRUE);
g_signal_connect (G_OBJECT (dd->matches_table), "cursor_changed",
G_CALLBACK (cursor_change), dd);
g_signal_connect (G_OBJECT (dd->matches_table), "select_cursor_row",
G_CALLBACK (cb_next), dd);
go_gtk_builder_signal_connect (gui, "search_button", "clicked",
G_CALLBACK (search_clicked), dd);
g_signal_connect (G_OBJECT (dd->prev_button), "clicked",
G_CALLBACK (prev_clicked), dd);
g_signal_connect (G_OBJECT (dd->next_button), "clicked",
G_CALLBACK (next_clicked), dd);
go_gtk_builder_signal_connect_swapped (gui, "close_button", "clicked",
G_CALLBACK (gtk_widget_destroy), dd->dialog);
g_signal_connect (G_OBJECT (gnm_expr_entry_get_entry (dd->rangetext)), "focus-in-event",
G_CALLBACK (range_focused), dd);
go_gtk_builder_signal_connect (gui, "scope_range", "toggled",
G_CALLBACK (cb_focus_on_entry), dd->rangetext);
wbc_gtk_attach_guru_with_unfocused_rs (wbcg, GTK_WIDGET (dialog), dd->rangetext);
g_object_set_data_full (G_OBJECT (dialog),
"state", dd, (GDestroyNotify) free_state);
gnm_dialog_setup_destroy_handlers (dialog, wbcg,
GNM_DIALOG_DESTROY_SHEET_REMOVED);
gnumeric_init_help_button (
go_gtk_builder_get_widget (gui, "help_button"),
GNUMERIC_HELP_LINK_SEARCH);
gnumeric_restore_window_geometry (GTK_WINDOW (dialog), SEARCH_KEY);
go_gtk_nonmodal_dialog (wbcg_toplevel (wbcg), GTK_WINDOW (dialog));
gtk_widget_show_all (GTK_WIDGET (dialog));
}
void
dialog_so_size (WBCGtk *wbcg, GObject *so)
{
GtkBuilder *gui;
SOSizeState *state;
int width, height;
g_return_if_fail (wbcg != NULL);
if (gnumeric_dialog_raise_if_exists (wbcg, SO_SIZE_DIALOG_KEY))
return;
gui = gnm_gtk_builder_load ("sheetobject-size.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (SOSizeState, 1);
state->wbcg = wbcg;
state->sv = wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg));
state->sheet = sv_sheet (state->sv);
state->scg = wbcg_get_nth_scg (wbcg, state->sheet->index_in_wb);
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (state->gui, "object-size");
state->so = SHEET_OBJECT (so);
g_object_ref (so);
state->nameentry = GTK_ENTRY (go_gtk_builder_get_widget (state->gui, "name-entry"));
state->old_anchor = NULL;
state->old_name = NULL;
g_object_get (so, "name", &state->old_name, NULL);
if (state->old_name == NULL)
state->old_name = g_strdup ("");
gtk_entry_set_text (state->nameentry, state->old_name);
state->so_name_changed = FALSE;
g_signal_connect (G_OBJECT (state->nameentry),
"focus-out-event",
G_CALLBACK (cb_dialog_so_size_name_changed),
state);
state->so_print_check_changed = FALSE;
state->wpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "w-pts-label"));
state->wspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "w-spin"));
state->hpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "h-pts-label"));
state->hspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "h-spin"));
state->xpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "x-pts-label"));
state->xspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "x-spin"));
state->ypoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "y-pts-label"));
state->yspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "y-spin"));
state->print_check = GTK_WIDGET (go_gtk_builder_get_widget (state->gui,
"print-check"));
dialog_so_size_load (state);
state->active_anchor = sheet_object_anchor_dup (sheet_object_get_anchor
(state->so));
width = state->coords[2] - state->coords[0];
height = state->coords[3] - state->coords[1];
gtk_spin_button_set_value (state->wspin, (width < 0) ? - width : width);
gtk_spin_button_set_value (state->hspin, (height < 0) ? - height : height);
gtk_spin_button_set_value (state->xspin, 0.);
gtk_spin_button_set_value (state->yspin, 0.);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->print_check),
!(state->so->flags & SHEET_OBJECT_PRINT));
g_signal_connect (G_OBJECT (state->wspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->wpoints);
g_signal_connect (G_OBJECT (state->hspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->hpoints);
g_signal_connect (G_OBJECT (state->xspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->xpoints);
g_signal_connect (G_OBJECT (state->yspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->ypoints);
g_signal_connect (G_OBJECT (state->print_check),
"toggled",
G_CALLBACK (cb_dialog_so_size_print_check_toggled),
state);
cb_dialog_so_size_value_changed_update_points (state->wspin, GTK_LABEL (state->wpoints));
cb_dialog_so_size_value_changed_update_points (state->hspin, GTK_LABEL (state->hpoints));
cb_dialog_so_size_value_changed_update_points (state->xspin, GTK_LABEL (state->xpoints));
cb_dialog_so_size_value_changed_update_points (state->yspin, GTK_LABEL (state->ypoints));
g_signal_connect (G_OBJECT (state->wspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->hspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->xspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->yspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
state->ok_button = go_gtk_builder_get_widget (state->gui, "ok_button");
g_signal_connect (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_ok_clicked), state);
state->apply_button = go_gtk_builder_get_widget (state->gui, "apply_button");
g_signal_connect (G_OBJECT (state->apply_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_apply_clicked), state);
state->cancel_button = go_gtk_builder_get_widget (state->gui, "cancel_button");
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_cancel_clicked), state);
gnumeric_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_SO_SIZE);
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_so_size_destroy);
gnumeric_keyed_dialog (wbcg, GTK_WINDOW (state->dialog),
SO_SIZE_DIALOG_KEY);
dialog_so_size_button_sensitivity (state);
gtk_widget_show (state->dialog);
}
void
dialog_data_slicer (WBCGtk *wbcg, gboolean create)
{
static GtkTargetEntry row_targets[] = {
{ (char *)"GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP, 0 }
};
DialogDataSlicer *state;
GtkBuilder *gui;
GtkWidget *w;
g_return_if_fail (wbcg != NULL);
if (gnm_dialog_raise_if_exists (wbcg, DIALOG_KEY))
return;
gui = gnm_gtk_builder_load ("data-slicer.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (NULL == gui)
return;
state = g_new0 (DialogDataSlicer, 1);
state->wbcg = wbcg;
state->sv = wb_control_cur_sheet_view (GNM_WBC (wbcg));
state->dialog = go_gtk_builder_get_widget (gui, "dialog_data_slicer");
state->notebook = go_gtk_builder_get_widget (gui, "notebook");
state->slicer = create ? NULL : sv_editpos_in_slicer (state->sv);
state->cache = NULL;
state->source = NULL;
if (NULL == state->slicer) {
state->slicer = g_object_new (GNM_SHEET_SLICER_TYPE, NULL);
} else {
g_object_ref (state->slicer);
g_object_get (G_OBJECT (state->slicer), "cache", &state->cache, NULL);
if (NULL != state->cache &&
NULL != (state->source = go_data_cache_get_source (state->cache)))
g_object_ref (state->source);
}
state->source_expr = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->source_expr,
GNM_EE_SINGLE_RANGE, GNM_EE_MASK);
g_signal_connect_swapped (G_OBJECT (state->source_expr),
"changed", G_CALLBACK (cb_source_expr_changed), state);
w = go_gtk_builder_get_widget (gui, "source_vbox");
gtk_box_pack_start (GTK_BOX (w), GTK_WIDGET (state->source_expr), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (state->source_expr));
w = go_gtk_builder_get_widget (gui, "ok_button");
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (cb_dialog_data_slicer_ok), state);
w = go_gtk_builder_get_widget (gui, "cancel_button");
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (cb_dialog_data_slicer_cancel), state);
state->treeview = GTK_TREE_VIEW (go_gtk_builder_get_widget (gui, "field_tree"));
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (state->treeview), GDK_BUTTON1_MASK,
row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (state->treeview),
row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE);
state->selection = gtk_tree_view_get_selection (state->treeview);
gtk_tree_selection_set_mode (state->selection, GTK_SELECTION_SINGLE);
g_signal_connect (state->selection, "changed",
G_CALLBACK (cb_dialog_data_slicer_selection_changed), state);
gtk_tree_view_append_column (state->treeview,
gtk_tree_view_column_new_with_attributes ("",
gtk_cell_renderer_text_new (), "text", FIELD_NAME, NULL));
cb_dialog_data_slicer_create_model (state);
g_signal_connect (state->treeview, "realize", G_CALLBACK (gtk_tree_view_expand_all), NULL);
gtk_notebook_set_current_page (GTK_NOTEBOOK (state->notebook), create ? 0 : 1);
/* a candidate for merging into attach guru */
gnm_init_help_button (go_gtk_builder_get_widget (gui, "help_button"),
GNUMERIC_HELP_LINK_DATA_SLICER);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify)cb_dialog_data_slicer_destroy);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
gnm_keyed_dialog (wbcg, GTK_WINDOW (state->dialog), DIALOG_KEY);
gtk_widget_show (state->dialog);
g_object_unref (gui);
}
