void
dialog_data_table (WBCGtk *wbcg)
{
GnmDialogDataTable *state;
GnmRange const *r;
GnmRange input_range;
SheetView *sv;
Sheet *sheet;
g_return_if_fail (wbcg != NULL);
if (wbc_gtk_get_guru (wbcg) ||
gnm_dialog_raise_if_exists (wbcg, DIALOG_DATA_TABLE_KEY))
return;
sv = wb_control_cur_sheet_view (GNM_WBC (wbcg));
r = selection_first_range (sv, GO_CMD_CONTEXT (wbcg), _("Create Data Table"));
if (NULL == r)
return;
if (range_width (r) <= 1 || range_height (r) <= 1) {
GError *msg = g_error_new (go_error_invalid(), 0,
_("The selection must have more than 1 column and row to create a Data Table."));
go_cmd_context_error (GO_CMD_CONTEXT (wbcg), msg);
g_error_free (msg);
return;
}
input_range = *r;
input_range.start.col++;
input_range.start.row++;
sheet = sv_sheet (sv);
if (sheet_range_splits_region (sheet, &input_range, NULL,
GO_CMD_CONTEXT (wbcg), _("Data Table")))
return;
if (cmd_cell_range_is_locked_effective
(sheet, &input_range, GNM_WBC (wbcg),
_("Data Table")))
return;
state = g_new0 (GnmDialogDataTable, 1);
state->wbcg = wbcg;
state->sheet = sheet;
state->input_range = input_range;
if (data_table_init (state, wbcg)) {
go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR,
_("Could not create the Data Table definition dialog."));
g_free (state);
}
}
static void
wb_create_name (WorkbookControl *wbc, char const *text, GnmParsePos *pp)
{
GnmRange const *r;
GnmCellRef a, b;
GnmExpr const *target_range;
r = selection_first_range (wb_control_cur_sheet_view (wbc),
GO_CMD_CONTEXT (wbc), _("Define Name"));
if (r != NULL) {
a.sheet = b.sheet = wb_control_cur_sheet (wbc);
a.col = r->start.col;
a.row = r->start.row;
b.col = r->end.col;
b.row = r->end.row;
a.col_relative = a.row_relative = b.col_relative = b.row_relative = FALSE;
pp->sheet = NULL; /* make it a global name */
if (gnm_cellref_equal (&a, &b))
target_range = gnm_expr_new_cellref (&a);
else
target_range = gnm_expr_new_constant (
value_new_cellrange_unsafe (&a, &b));
cmd_define_name (wbc, text, pp, gnm_expr_top_new (target_range), NULL);
}
}
void
dialog_goto_cell (WBCGtk *wbcg)
{
GotoState* state;
GtkBuilder *gui;
g_return_if_fail (wbcg != NULL);
if (gnumeric_dialog_raise_if_exists (wbcg, GOTO_KEY))
return;
gui = gnm_gtk_builder_new ("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 (WORKBOOK_CONTROL (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;
}
gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
GOTO_KEY);
gtk_widget_show_all (state->dialog);
}
/*
* Select the given range and make the it visible.
*/
static gboolean
wb_control_jump (WorkbookControl *wbc, Sheet *sheet, const GnmRangeRef *r)
{
SheetView *sv;
GnmCellPos tmp;
if (r->a.sheet)
sheet = r->a.sheet;
if (!sheet_is_visible (sheet)) {
go_cmd_context_error_invalid
(GO_CMD_CONTEXT (wbc),
_("Cannot jump to an invisible sheet"),
sheet->name_unquoted);
return FALSE;
}
sv = sheet_get_view (sheet, wb_control_view (wbc));
tmp.col = r->a.col;
tmp.row = r->a.row;
sv_selection_set (sv, &tmp, r->a.col, r->a.row, r->b.col, r->b.row);
sv_make_cell_visible (sv, r->b.col, r->b.row, FALSE);
sv_make_cell_visible (sv, r->a.col, r->a.row, FALSE);
sv_update (sv);
if (wb_control_cur_sheet (wbc) != sheet)
wb_view_sheet_focus (wbc->wb_view, sheet);
return TRUE;
}
static void
gnm_stf_file_saver_save (G_GNUC_UNUSED GOFileSaver const *fs, GOIOContext *context,
GoView const *view, GsfOutput *output)
{
WorkbookView *wbv = GNM_WORKBOOK_VIEW (view);
Workbook *wb = wb_view_get_workbook (wbv);
GnmStfExport *stfe = gnm_stf_get_stfe (G_OBJECT (wb));
GsfOutput *dummy_sink;
/* TODO: move this GUI dependent code out of this
* filesaver into gui-file.c. After this, remove includes (see above). */
if (GNM_IS_WBC_GTK (context->impl)) {
gboolean cancelled =
stf_export_dialog (WBC_GTK (context->impl), stfe, wb);
if (cancelled) {
go_io_error_unknown (context);
return;
}
}
if (!stfe->sheet_list)
gnm_stf_export_options_sheet_list_add
(stfe, wb_view_cur_sheet (wbv));
g_object_set (G_OBJECT (stfe), "sink", output, NULL);
if (gnm_stf_export (stfe) == FALSE)
go_cmd_context_error_import (GO_CMD_CONTEXT (context),
_("Error while trying to export file as text"));
/* We're not allowed to set a NULL sink, so use a dummy. */
dummy_sink = gsf_output_memory_new ();
g_object_set (G_OBJECT (stfe), "sink", dummy_sink, NULL);
g_object_unref (dummy_sink);
}
static void
stf_write_csv (G_GNUC_UNUSED GOFileSaver const *fs, GOIOContext *context,
GoView const *view, GsfOutput *output)
{
Sheet *sheet;
GnmRangeRef const *range;
WorkbookView *wbv = GNM_WORKBOOK_VIEW (view);
GnmStfExport *config = g_object_new
(GNM_STF_EXPORT_TYPE,
"sink", output,
"quoting-triggers", ", \t\n\"",
NULL);
/* FIXME: this is crap in both branches of the "if". */
range = g_object_get_data (G_OBJECT (wb_view_get_workbook (wbv)), "ssconvert-range");
if (range && range->a.sheet)
sheet = range->a.sheet;
else
sheet = wb_view_cur_sheet (wbv);
gnm_stf_export_options_sheet_list_add (config, sheet);
if (gnm_stf_export (config) == FALSE)
go_cmd_context_error_import (GO_CMD_CONTEXT (context),
_("Error while trying to write CSV file"));
g_object_unref (config);
}
int
main (int argc, char const **argv)
{
GOErrorInfo *plugin_errs;
GOCmdContext *cc;
GOptionContext *ocontext;
GError *error = NULL;
const char *testname;
/* No code before here, we need to init threads */
argv = gnm_pre_parse_init (argc, argv);
ocontext = g_option_context_new (_("[testname]"));
g_option_context_add_main_entries (ocontext, sstest_options, GETTEXT_PACKAGE);
g_option_context_add_group (ocontext, gnm_get_option_group ());
g_option_context_parse (ocontext, &argc, (gchar ***)&argv, &error);
g_option_context_free (ocontext);
if (error) {
g_printerr (_("%s\nRun '%s --help' to see a full list of available command line options.\n"),
error->message, g_get_prgname ());
g_error_free (error);
return 1;
}
if (sstest_show_version) {
g_printerr (_("version '%s'\ndatadir := '%s'\nlibdir := '%s'\n"),
GNM_VERSION_FULL, gnm_sys_data_dir (), gnm_sys_lib_dir ());
return 0;
}
gnm_init ();
cc = cmd_context_stderr_new ();
gnm_plugins_init (GO_CMD_CONTEXT (cc));
go_plugin_db_activate_plugin_list (
go_plugins_get_available_plugins (), &plugin_errs);
if (plugin_errs) {
/* FIXME: What do we want to do here? */
go_error_info_free (plugin_errs);
}
testname = argv[1];
if (!testname) testname = "all";
/* ---------------------------------------- */
MAYBE_DO ("test_insdel_rowcol_names") test_insdel_rowcol_names ();
MAYBE_DO ("test_func_help") test_func_help ();
MAYBE_DO ("test_go_data_cache_build_cache") test_go_data_cache_build_cache();
MAYBE_DO ("test_go_data_slicer_tuple_compare_to") test_go_data_slicer_tuple_compare_to ();
/* ---------------------------------------- */
g_object_unref (cc);
gnm_shutdown ();
gnm_pre_parse_shutdown ();
return 0;
}
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
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;
}
static gboolean
gnumeric_init(GTypeModule *type_module, GList **registered_types, GError **error)
{
GOErrorInfo *plugin_errors = NULL;
const gchar *argv[1];
command_context_register_type(type_module, registered_types);
argv[0] = g_get_prgname();
gnm_pre_parse_init(1, argv);
gnm_init();
command_context = command_context_new();
gnm_plugins_init(GO_CMD_CONTEXT(command_context));
go_plugin_db_activate_plugin_list(go_plugins_get_available_plugins(),
&plugin_errors);
if (plugin_errors) {
g_set_error(error, CHUPA_DECOMPOSER_ERROR, CHUPA_DECOMPOSER_ERROR_INIT,
"[decomposer][excel][init][error]"
": failed to initialize GOffice plugins: %s",
go_error_info_peek_message(plugin_errors));
go_error_info_free(plugin_errors);
return FALSE;
} else {
return TRUE;
}
}
/**
* cmd_paste :
* @sheet: The destination sheet
* @range : The range to paste to within the destination sheet.
* @flags: Any paste special flags.
*
* Pastes the current cut buffer, copy buffer, or X selection to
* the destination sheet range.
*
* When pasting a cut the destination MUST be the same size as the src.
*
* When pasting a copy the destination can be a singleton, or an integer
* multiple of the size of the source. This is not tested here.
* Full undo support.
**/
void
cmd_paste (WorkbookControl *wbc, GnmPasteTarget const *pt)
{
GnmCellRegion *content;
GnmRange const *src_range;
g_return_if_fail (pt != NULL);
g_return_if_fail (IS_SHEET (pt->sheet));
src_range = gnm_app_clipboard_area_get ();
content = gnm_app_clipboard_contents_get ();
if (content == NULL && src_range != NULL) {
/* Pasting a Cut */
GnmExprRelocateInfo rinfo;
Sheet *src_sheet = gnm_app_clipboard_sheet_get ();
/* Validate the size & shape of the target here. */
int const cols = (src_range->end.col - src_range->start.col);
int const rows = (src_range->end.row - src_range->start.row);
GnmRange dst = pt->range;
if (range_is_singleton (&dst)) {
dst.end.col = dst.start.col + cols;
dst.end.row = dst.start.row + rows;
} else if ((dst.end.col - dst.start.col) != cols ||
(dst.end.row - dst.start.row) != rows) {
char *msg = g_strdup_printf (
_("destination has a different shape (%dRx%dC) than the original (%dRx%dC)\n\n"
"Try selecting a single cell or an area of the same shape and size."),
(dst.end.row - dst.start.row)+1,
(dst.end.col - dst.start.col)+1,
rows+1, cols+1);
go_cmd_context_error_invalid (GO_CMD_CONTEXT (wbc),
_("Unable to paste into selection"), msg);
g_free (msg);
return;
}
rinfo.reloc_type = GNM_EXPR_RELOCATE_MOVE_RANGE;
rinfo.origin = *src_range;
rinfo.col_offset = dst.start.col - rinfo.origin.start.col;
rinfo.row_offset = dst.start.row - rinfo.origin.start.row;
rinfo.origin_sheet = src_sheet;
rinfo.target_sheet = pt->sheet;
if (!cmd_paste_cut (wbc, &rinfo, TRUE, NULL))
gnm_app_clipboard_clear (TRUE);
/* If this application has marked a selection use it */
} else if (content != NULL)
cmd_paste_copy (wbc, pt, content);
/* See if the control has access to information to paste */
else
wb_control_paste_from_selection (wbc, pt);
}
/**
* dialog_goal_seek:
* @wbcg:
* @sheet:
*
* Create the dialog (guru).
*
**/
void
dialog_goal_seek (WBCGtk *wbcg, Sheet *sheet)
{
GoalSeekState *state;
GladeXML *gui;
g_return_if_fail (IS_SHEET (sheet));
/* Testing hook. */
if (wbcg == NULL) {
GnmRangeRef *range =
g_object_get_data (G_OBJECT (sheet), "ssconvert-goal-seek");
if (range) {
Sheet *start_sheet, *end_sheet;
GnmEvalPos ep;
GnmRange r;
gnm_rangeref_normalize (range,
eval_pos_init_sheet (&ep, sheet),
&start_sheet, &end_sheet,
&r);
g_return_if_fail (start_sheet == sheet);
dialog_goal_seek_test (sheet, &r);
return;
}
}
g_return_if_fail (wbcg != NULL);
/* Only pop up one copy per workbook */
if (gnumeric_dialog_raise_if_exists (wbcg, GOALSEEK_KEY))
return;
gui = gnm_glade_xml_new (GO_CMD_CONTEXT (wbcg),
"goalseek.glade", NULL, NULL);
if (gui == NULL)
return;
state = g_new (GoalSeekState, 1);
state->wbcg = wbcg;
state->wb = wb_control_get_workbook (WORKBOOK_CONTROL (wbcg));
state->sheet = sheet;
state->gui = gui;
state->warning_dialog = NULL;
state->cancelled = TRUE;
if (dialog_init (state)) {
go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR,
_("Could not create the Goal-Seek dialog."));
g_free (state);
return;
}
gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
GOALSEEK_KEY);
gtk_widget_show (state->dialog);
}
static gboolean
cmd_slicer_refresh_undo (GnmCommand *cmd, WorkbookControl *wbc)
{
CmdSlicerRefresh *me = CMD_SLICER_REFRESH (cmd);
GnmRange const *new_size = gnm_sheet_slicer_get_range (me->slicer);
GnmPasteTarget pt;
sheet_clear_region (me->cmd.sheet,
new_size->start.col, new_size->start.row,
new_size->end.col, new_size->end.row,
CLEAR_VALUES | CLEAR_FORMATS | CLEAR_MERGES | CLEAR_NOCHECKARRAY | CLEAR_RECALC_DEPS,
GO_CMD_CONTEXT (wbc));
clipboard_paste_region (me->orig_content,
paste_target_init (&pt, me->cmd.sheet, &me->orig_size, PASTE_DEFAULT),
GO_CMD_CONTEXT (wbc));
cellregion_unref (me->orig_content);
me->orig_content = NULL;
return FALSE;
}
void
go_io_progress_message (GOIOContext *ioc, const gchar *msg)
{
GOCmdContext *cc;
g_return_if_fail (GO_IS_IO_CONTEXT (ioc));
if (ioc->impl)
cc = ioc->impl;
else
cc = GO_CMD_CONTEXT (ioc);
go_cmd_context_progress_message_set (cc, msg);
}
static void
restore_old_values (ScenariosState *state)
{
GOCmdContext *cc;
if (state->undo == NULL)
return;
cc = GO_CMD_CONTEXT (state->base.wbcg);
go_undo_undo_with_data (state->undo, cc);
g_object_unref (state->undo);
state->undo = NULL;
state->current = NULL;
}
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);
}
static char *
stf_preparse (GOIOContext *context, GsfInput *input, size_t *data_len)
{
char *data;
data = stf_open_and_read (context, input, data_len);
if (!data) {
if (context)
go_cmd_context_error_import (GO_CMD_CONTEXT (context),
_("Error while trying to read file"));
return NULL;
}
return data;
}
void
go_io_error_display (GOIOContext *context)
{
GOCmdContext *cc;
g_return_if_fail (context != NULL);
if (context->info != NULL) {
if (context->impl)
cc = context->impl;
else
cc = GO_CMD_CONTEXT (context);
go_cmd_context_error_info_list
(cc, context->info);
}
}
/**
* cmd_paste_to_selection :
* @dest_sv: The sheet into which things should be pasted
* @flags: special paste flags (eg transpose)
*
* Using the current selection as a target
* Full undo support.
*/
void
cmd_paste_to_selection (WorkbookControl *wbc, SheetView *dest_sv, int paste_flags)
{
GnmRange const *r;
GnmPasteTarget pt;
if (!(r = selection_first_range (dest_sv, GO_CMD_CONTEXT (wbc), _("Paste"))))
return;
g_return_if_fail (r !=NULL);
pt.sheet = dest_sv->sheet;
pt.range = *r;
pt.paste_flags = paste_flags;
cmd_paste (wbc, &pt);
}
static void
soi_cb_save_as (SheetObject *so, SheetControl *sc)
{
WBCGtk *wbcg;
char *uri;
GsfOutput *output;
GSList *l = NULL;
GOImageFormat sel_fmt;
GOImageFormatInfo const *format_info;
GdkPixbuf *pixbuf = NULL;
GError *err = NULL;
SheetObjectImage *soi = SHEET_OBJECT_IMAGE (so);
g_return_if_fail (soi != NULL);
sel_fmt = go_image_get_format_from_name (soi->type);
if ((pixbuf = go_image_get_pixbuf (soi->image)) != NULL)
l = go_image_get_formats_with_pixbuf_saver ();
/* Move original format first in menu */
if (sel_fmt != GO_IMAGE_FORMAT_UNKNOWN) {
l = g_slist_remove (l, GUINT_TO_POINTER (sel_fmt));
l = g_slist_prepend (l, GUINT_TO_POINTER (sel_fmt));
}
wbcg = scg_wbcg (SHEET_CONTROL_GUI (sc));
uri = go_gui_get_image_save_info (wbcg_toplevel (wbcg), l, &sel_fmt, NULL);
if (!uri)
goto out;
output = go_file_create (uri, &err);
if (!output)
goto out;
format_info = go_image_get_format_info (sel_fmt);
sheet_object_write_image (so, (format_info? format_info->name: NULL), -1.0, output, &err);
gsf_output_close (output);
g_object_unref (output);
if (err != NULL)
go_cmd_context_error (GO_CMD_CONTEXT (wbcg), err);
out:
if (pixbuf)
g_object_unref (pixbuf);
g_free (uri);
g_slist_free (l);
}
void
glpk_file_save (GOFileSaver const *fs, GOIOContext *io_context,
WorkbookView const *wb_view, GsfOutput *output)
{
GError *err = NULL;
GString *prg;
GnmLocale *locale;
GnmSolver *sol = NULL;
GnmSubSolver *ssol = g_object_get_data (G_OBJECT (fs), "solver");
if (!ssol) {
// Create a temporary solver just functional enough to
// write the program
Sheet *sheet = wb_view_cur_sheet (wb_view);
sol = glpk_solver_create (sheet->solver_parameters);
ssol = GNM_SUB_SOLVER (sol);
}
go_io_progress_message (io_context,
_("Writing glpk file..."));
locale = gnm_push_C_locale ();
prg = glpk_create_program (ssol, io_context, &err);
gnm_pop_C_locale (locale);
gnm_app_recalc ();
if (!prg) {
go_cmd_context_error_import (GO_CMD_CONTEXT (io_context),
err ? err->message : "?");
goto fail;
}
gsf_output_write (output, prg->len, prg->str);
g_string_free (prg, TRUE);
fail:
go_io_progress_unset (io_context);
if (err)
g_error_free (err);
if (sol)
g_object_unref (sol);
}
/*
* This is called when something is entered in the location entry.
* We either go there (if the text refers to a cell by address or
* name), or we try to define a name for the selection.
*/
gboolean
wb_control_parse_and_jump (WorkbookControl *wbc, char const *text)
{
Sheet *sheet = wb_control_cur_sheet (wbc);
GnmParsePos pp;
GnmEvalPos ep;
GnmValue *target;
GnmRangeRef range;
SheetView *sv;
if (text == NULL || *text == '\0')
return FALSE;
sv = wb_control_cur_sheet_view (wbc);
parse_pos_init_editpos (&pp, sv);
target = value_new_cellrange_parsepos_str (&pp, text,
GNM_EXPR_PARSE_DEFAULT);
if (target == NULL) {
/* Not an address; is it a name? */
GnmParsePos pp;
GnmNamedExpr *nexpr = expr_name_lookup (
parse_pos_init_sheet (&pp, sheet), text);
/* If no name, or just a placeholder exists create a name */
if (nexpr == NULL || expr_name_is_placeholder (nexpr)) {
wb_create_name (wbc, text, &pp);
return FALSE;
} else {
target = gnm_expr_top_get_range (nexpr->texpr);
if (target == NULL) {
go_cmd_context_error_invalid (GO_CMD_CONTEXT (wbc),
_("Address"), text);
return FALSE;
}
}
}
eval_pos_init_editpos (&ep, sv);
gnm_cellref_make_abs (&range.a, &target->v_range.cell.a, &ep);
gnm_cellref_make_abs (&range.b, &target->v_range.cell.b, &ep);
value_release (target);
return wb_control_jump (wbc, sheet, &range);
}
static gboolean
cmd_slicer_refresh_redo (GnmCommand *cmd, WorkbookControl *wbc)
{
CmdSlicerRefresh *me = CMD_SLICER_REFRESH (cmd);
GnmRange const *new_size = gnm_sheet_slicer_get_range (me->slicer);
me->orig_size = *gnm_sheet_slicer_get_range (me->slicer);
me->orig_content = clipboard_copy_range (me->cmd.sheet, &me->orig_size);
sheet_clear_region (me->cmd.sheet,
new_size->start.col, new_size->start.row,
new_size->end.col, new_size->end.row,
CLEAR_VALUES | CLEAR_FORMATS | CLEAR_MERGES | CLEAR_NOCHECKARRAY | CLEAR_RECALC_DEPS,
GO_CMD_CONTEXT (wbc));
gnm_sheet_slicer_regenerate (me->slicer);
return FALSE;
}
ABI_FAR_CALL
int abi_plugin_register (XAP_ModuleInfo * mi)
{
mi->name = "AbiGOffice";
mi->desc = "The plugin enables Gnome Office Charts and components to be displayed in AbiWord";
mi->version = ABI_VERSION_STRING;
mi->author = "Jean Bréfort <*****@*****.**>";
mi->usage = "No Usage";
// Add to AbiWord's plugin importers
m_impSniffer = new IE_Imp_Object_Sniffer();
IE_Imp::registerImporter (m_impSniffer);
m_impCSniffer = new IE_Imp_Component_Sniffer();
IE_Imp::registerImporter (m_impCSniffer);
// Add to AbiWord's plugin listeners
XAP_App * pApp = XAP_App::getApp();
pGOChartManager = new GR_GOChartManager(NULL);
pGOChartManager->buildContextualMenu ();
pApp->registerEmbeddable(pGOChartManager);
/* Initialize libgoffice */
libgoffice_init ();
cc = GO_CMD_CONTEXT (g_object_new (ABI_CMD_CONTEXT_TYPE, NULL));
go_component_set_default_command_context (cc);
/* Initialize plugins manager */
go_plugins_init (cc, NULL, NULL, NULL, TRUE, GO_TYPE_PLUGIN_LOADER_MODULE);
/* Ensure some types are created */
GO_TYPE_DATA_SCALAR_STR;
GO_TYPE_DATA_VECTOR_STR;
GO_TYPE_DATA_SCALAR_VAL;
GO_TYPE_DATA_VECTOR_VAL;
GO_TYPE_DATA_MATRIX_VAL;
// Add to AbiWord's menus.
mime_types = go_components_get_mime_types ();
if (mime_types && mime_types->data)
{
pGOComponentManager = new GR_GOComponentManager(NULL);
pApp->registerEmbeddable(pGOComponentManager);
}
g_slist_foreach (mime_types, (GFunc) register_mime_cb, pApp);
AbiGOffice_addToMenus();
return 1;
}
void
go_io_progress_update (GOIOContext *ioc, gdouble f)
{
gboolean at_end;
g_return_if_fail (GO_IS_IO_CONTEXT (ioc));
if (ioc->progress_ranges != NULL) {
f = f * (ioc->progress_max - ioc->progress_min)
+ ioc->progress_min;
}
at_end = (f - ioc->last_progress > PROGRESS_UPDATE_STEP_END &&
f + PROGRESS_UPDATE_STEP > 1);
/* The use of fabs here means we can set progress back if we need to. */
if (at_end || fabs (f - ioc->last_progress) >= PROGRESS_UPDATE_STEP) {
GTimeVal tv;
double t;
(void) g_get_current_time (&tv);
t = tv.tv_sec + tv.tv_usec / 1000000.0;
if (at_end || t - ioc->last_time >= PROGRESS_UPDATE_PERIOD_SEC) {
GOCmdContext *cc;
if (ioc->impl)
cc = ioc->impl;
else
cc = GO_CMD_CONTEXT (ioc);
go_cmd_context_progress_set (cc, f);
ioc->last_time = t;
ioc->last_progress = f;
}
}
#ifdef GOFFICE_WITH_GTK
/* FIXME : abstract this into the workbook control */
if (ioc->exec_main_loop)
while (gtk_events_pending ())
gtk_main_iteration_do (FALSE);
#endif
}
/*
* Main entry point for the Cell Sort dialog box
*/
void
dialog_cell_sort (WBCGtk *wbcg)
{
SortFlowState *state;
GtkBuilder *gui;
g_return_if_fail (wbcg != NULL);
if (gnumeric_dialog_raise_if_exists (wbcg, CELL_SORT_KEY))
return;
gui = gnm_gtk_builder_new ("cell-sort.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (SortFlowState, 1);
state->wbcg = wbcg;
state->wb = wb_control_get_workbook (WORKBOOK_CONTROL (wbcg));
state->sv = wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg));
state->sheet = sv_sheet (state->sv);
state->warning_dialog = NULL;
state->sel = NULL;
state->sort_items = 0;
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (state->gui, "CellSort");
state->image_ascending =
gtk_widget_render_icon_pixbuf (state->dialog,
GTK_STOCK_SORT_ASCENDING,
GTK_ICON_SIZE_LARGE_TOOLBAR);
state->image_descending =
gtk_widget_render_icon_pixbuf (state->dialog,
GTK_STOCK_SORT_DESCENDING,
GTK_ICON_SIZE_LARGE_TOOLBAR);
dialog_init (state);
gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
CELL_SORT_KEY);
gtk_widget_show (state->dialog);
}
int gnumeric_init() {
gnumeric_init_ct++;
if (gnumeric_init_ct>1) return 0;
int res = 0;
int argc = 1;
char const *argv[] = { "gnumeric", NULL };
#ifdef OLD_GNUMERIC
gchar const **args = go_shell_argv_to_glib_encoding (argc, argv);
gnm_pre_parse_init (args[0]);
gnm_common_init (FALSE);
#else
gnm_pre_parse_init (argc, argv);
gnm_init ();
#endif
cc = cmd_context_stderr_new ();
gnm_plugins_init (GO_CMD_CONTEXT (cc));
go_plugin_db_activate_plugin_list (
go_plugins_get_available_plugins (), &plugin_errs);
atexit(gnumeric_atexit);
return 0;
}
static gboolean
data_table_init (GnmDialogDataTable *state, WBCGtk *wbcg)
{
GtkTable *table;
state->gui = gnm_glade_xml_new (GO_CMD_CONTEXT (wbcg),
"data-table.glade", NULL, NULL);
if (state->gui == NULL)
return TRUE;
state->dialog = glade_xml_get_widget (state->gui, "DataTable");
table = GTK_TABLE (glade_xml_get_widget (state->gui, "table"));
state->row_entry = init_entry (state, "row-entry");
state->col_entry = init_entry (state, "col-entry");
g_signal_connect (G_OBJECT (state->dialog), "response",
G_CALLBACK (cb_data_table_response), state);
gnumeric_init_help_button (
glade_xml_get_widget (state->gui, "help"),
GNUMERIC_HELP_LINK_DATA_TABLE);
/* a candidate for merging into attach guru */
gnumeric_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;
}
/**
* 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)
{
GladeXML *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_glade_xml_new (GO_CMD_CONTEXT (wbcg),
"dialog-stf.glade", NULL, NULL);
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 (glade_xml_get_widget (gui, "stf_dialog"));
pagedata.notebook = GTK_NOTEBOOK (glade_xml_get_widget (gui, "stf_notebook"));
pagedata.next_button = glade_xml_get_widget (gui, "forward_button");
pagedata.back_button = glade_xml_get_widget (gui, "back_button");
pagedata.cancel_button = glade_xml_get_widget (gui, "cancel_button");
pagedata.help_button = glade_xml_get_widget (gui, "help_button");
pagedata.finish_button = glade_xml_get_widget (gui, "finish_button");
pagedata.parseoptions = NULL;
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;
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;
}
