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 gnumeric_overlay_csv(GnumericWorkbookPtr workbook,
const char *start, const char *stop) {
WorkbookView *wbv = (WorkbookView *)workbook;
printf("For testing, try pasting some data into workbook\n");
//Workbook *wb = wb_view_get_workbook (wbv);
Sheet *sheet = wb_view_cur_sheet (wbv);
if (sheet==NULL) { printf("no sheet!\n"); return 1; }
StfParseOptions_t *options = stf_parse_options_guess(start);
stf_parse_sheet(options,start,stop,sheet,0,0);
stf_parse_options_free(options);
options = NULL;
return 0;
}
static void
gplp_func_file_open (GOFileOpener const *fo,
GOPluginService *service,
GOIOContext *io_context,
gpointer wb_view,
GsfInput *input)
{
ServiceLoaderDataFileOpener *loader_data;
Sheet *sheet, *old_sheet;
PyObject *open_result = NULL;
PyObject *input_wrapper;
printf("gplp_func_file_open(start)\n");
g_return_if_fail (GO_IS_PLUGIN_SERVICE_FILE_OPENER (service));
g_return_if_fail (input != NULL);
g_return_if_fail (_PyGObject_API != NULL);
old_sheet = wb_view_cur_sheet (wb_view);
loader_data = g_object_get_data (G_OBJECT (service), "loader_data");
SWITCH_TO_PLUGIN (go_plugin_service_get_plugin (service));
sheet = sheet_new (wb_view_get_workbook (wb_view), _("Some name"),
gnm_sheet_get_max_cols (old_sheet),
gnm_sheet_get_max_rows (old_sheet));
input_wrapper = pygobject_new (G_OBJECT (input));
if (input_wrapper != NULL) {
/* wrapping adds a reference */
g_object_unref (G_OBJECT (input));
open_result = PyObject_CallFunction
(loader_data->python_func_file_open,
(char *) "NO",
py_new_Sheet_object (sheet), input_wrapper);
Py_DECREF (input_wrapper);
}
if (open_result != NULL) {
Py_DECREF (open_result);
workbook_sheet_attach (wb_view_get_workbook (wb_view), sheet);
} else {
go_io_error_string (io_context, py_exc_to_string ());
gnm_python_clear_error_if_needed (SERVICE_GET_LOADER (service)->py_object);
g_object_unref (sheet);
}
printf("gplp_func_file_open(end)\n");
}
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);
}
void
sylk_file_save (GOFileSaver const *fs, GOIOContext *io_context,
gconstpointer wb_view, GsfOutput *output)
{
GnmLocale *locale;
SylkWriter state;
state.wb = wb_view_get_workbook (wb_view);
state.sheet = wb_view_cur_sheet (wb_view);
state.output = output;
state.convs = sylk_conventions_new ();
if (NULL == state.sheet) {
go_io_error_string (io_context, _("Cannot get default sheet."));
return;
}
locale = gnm_push_C_locale ();
gsf_output_puts (output, "ID;PGnumeric;N;E\r\n");
sylk_write_sheet (&state);
gsf_output_puts (output, "E\r\n");
gnm_pop_C_locale (locale);
gnm_conventions_unref (state.convs);
}
G_MODULE_EXPORT void
paradox_file_save (GOFileSaver const *fs, GOIOContext *io_context,
WorkbookView const *wb_view, GsfOutput *output)
{
Sheet *sheet;
GnmRange r;
gint row, col, i;
pxdoc_t *pxdoc = NULL;
pxfield_t *pxf;
char *data;
char *tmpfilename;
sheet = wb_view_cur_sheet (wb_view);
if (sheet == NULL) {
go_io_error_string (io_context, _("Cannot get default sheet."));
return;
}
r = sheet_get_extent (sheet, FALSE, TRUE);
#ifdef PX_MEMORY_DEBUGGING
pxdoc = PX_new2 (gn_errorhandler, PX_mp_malloc, PX_mp_realloc, PX_mp_free);
#else
pxdoc = PX_new2 (gn_errorhandler, gn_malloc, gn_realloc, gn_free);
#endif
/* Read the field specification and build the field array for
* PX_create_fp(). The memory is freed by PX_delete() including
* the memory for the field name. */
if ((pxf = (pxfield_t *) pxdoc->malloc (pxdoc, (r.end.col+1)*sizeof (pxfield_t), _("Allocate memory for field definitions."))) == NULL){
go_io_error_string (io_context, _("Cannot allocate memory for field definitions."));
PX_delete (pxdoc);
return;
}
for (col = r.start.col; col <= r.end.col; col++) {
GnmCell *cell = sheet_cell_get (sheet, col, 0);
if (gnm_cell_is_empty (cell)) {
go_io_error_string (io_context, _("First line of sheet must contain database specification."));
PX_delete (pxdoc);
return;
} else {
gchar *fieldstr, *tmp;
int len, needsize, needprecision;
i = col;
fieldstr = gnm_cell_get_rendered_text (cell);
needsize = 0;
needprecision = 0;
/* Search for the first comma which is the end of the field name. */
tmp = strchr (fieldstr, ',');
if (NULL == tmp) {
g_warning (_("Field specification must be a comma separated value (Name,Type,Size,Prec)."));
PX_delete (pxdoc);
return;
}
len = tmp-fieldstr;
if (NULL == (pxf[i].px_fname = pxdoc->malloc (pxdoc, len+1, _("Allocate memory for column name.")))) {
g_warning (_("Could not allocate memory for %d. field name."), i);
PX_delete (pxdoc);
return;
}
strncpy (pxf[i].px_fname, fieldstr, len);
pxf[i].px_fname[len] = '\0';
/* Get the field Type */
fieldstr = tmp+1;
if (*fieldstr == '\0') {
g_warning (_("%d. field specification ended unexpectedly."), i);
PX_delete (pxdoc);
return;
}
if (*fieldstr == ',') {
g_warning (_("%d. field specification misses type."), i);
PX_delete (pxdoc);
return;
}
switch ((int) *fieldstr) {
case 'S':
pxf[i].px_ftype = pxfShort;
pxf[i].px_flen = 2;
break;
case 'I':
pxf[i].px_ftype = pxfLong;
pxf[i].px_flen = 4;
break;
case 'A':
case 'C':
pxf[i].px_ftype = pxfAlpha;
needsize = 1;
break;
case 'N':
pxf[i].px_ftype = pxfNumber;
pxf[i].px_flen = 8;
break;
case '$':
pxf[i].px_ftype = pxfCurrency;
pxf[i].px_flen = 8;
break;
case 'L':
pxf[i].px_ftype = pxfLogical;
pxf[i].px_flen = 1;
break;
case 'D':
pxf[i].px_ftype = pxfDate;
pxf[i].px_flen = 4;
break;
case '+':
pxf[i].px_ftype = pxfAutoInc;
pxf[i].px_flen = 4;
break;
case '@':
pxf[i].px_ftype = pxfTimestamp;
pxf[i].px_flen = 8;
break;
case 'T':
pxf[i].px_ftype = pxfTime;
pxf[i].px_flen = 4;
break;
case '#':
pxf[i].px_ftype = pxfBCD;
pxf[i].px_flen = 17;
needprecision = 1;
break;
case 'M':
pxf[i].px_ftype = pxfMemoBLOb;
needsize = 1;
break;
case 'B':
pxf[i].px_ftype = pxfBLOb;
needsize = 1;
break;
case 'F':
pxf[i].px_ftype = pxfFmtMemoBLOb;
needsize = 1;
break;
case 'Y':
pxf[i].px_ftype = pxfBytes;
needsize = 1;
break;
default:
g_warning (_("%d. field type '%c' is unknown."), i, *fieldstr);
pxdoc->free (pxdoc, pxf);
PX_delete (pxdoc);
return;
}
if (needsize || needprecision) {
char *endptr;
/* find end of type definition */
tmp = strchr (fieldstr, ',');
if (NULL == tmp || *(tmp+1) == '\0') {
g_warning (_("Field specification misses the column size."));
PX_delete (pxdoc);
return;
}
fieldstr = tmp+1;
if (needsize)
pxf[i].px_flen = strtol (fieldstr, &endptr, 10);
else
pxf[i].px_fdc = strtol (fieldstr, &endptr, 10);
if ((endptr == NULL) || (fieldstr == endptr)) {
g_warning (_("Field specification misses the column size."));
PX_delete (pxdoc);
return;
}
if (*endptr != '\0') {
/* There is also precision which we do not care about. */
fieldstr = endptr+1;
g_warning (_("The remainder '%s' of the specification for field %d is being disregarded."), fieldstr, i+1);
}
}
}
}
/* Create the paradox file */
tmpfilename = tempnam ("/tmp", NULL);
if (0 > PX_create_file (pxdoc, pxf, r.end.col+1, tmpfilename, pxfFileTypNonIndexDB)) {
g_warning (_("Could not create output file."));
PX_delete (pxdoc);
return;
}
PX_set_inputencoding (pxdoc, "UTF-8");
PX_set_parameter (pxdoc, "targetencoding", "CP1252");
PX_set_tablename (pxdoc, sheet->name_unquoted);
if ((data = (char *) pxdoc->malloc (pxdoc, pxdoc->px_head->px_recordsize, _("Allocate memory for record data."))) == NULL) {
g_warning (_("Could not allocate memory for record data."));
PX_close (pxdoc);
PX_delete (pxdoc);
return;
}
/* Process all cells */
for (row = r.start.row+1; row <= r.end.row; row++) {
int i;
int offset;
offset = 0;
memset (data, 0, pxdoc->px_head->px_recordsize);
for (col = r.start.col, i = 0; col <= r.end.col; col++) {
GnmCell *cell = sheet_cell_get (sheet, col, row);
if (!gnm_cell_is_empty (cell)) {
char *fieldstr = gnm_cell_get_rendered_text (cell);
switch (pxf[i].px_ftype) {
case pxfShort: {
int value = value_get_as_int (cell->value);
PX_put_data_short (pxdoc, &data[offset], 2, (short int) value);
break;
}
case pxfLong:
case pxfAutoInc: {
int value = value_get_as_int (cell->value);
PX_put_data_long (pxdoc, &data[offset], 4, value);
break;
}
case pxfTimestamp: {
double value = value_get_as_float (cell->value);
/* 60 would be 29.2.1900 which didn't exist. */
if (value < 60)
value += 1.0;
value += 693594;
value *= 86400000.0;
PX_put_data_double (pxdoc, &data[offset], 8, value);
break;
}
case pxfCurrency:
case pxfNumber: {
double value = value_get_as_float (cell->value);
PX_put_data_double(pxdoc, &data[offset], 8, value);
break;
}
case pxfAlpha: {
char *value = fieldstr;
int nlen = strlen (value);
if (nlen > pxf[i].px_flen)
/* xgettext : last %d gives the number of characters.*/
/* This is input to ngettext. */
g_warning
(ngettext
("Field %d in line %d has possibly "
"been cut off. Data has %d character.",
"Field %d in line %d has possibly "
"been cut off. Data has %d characters.",
nlen),
i+1, row+1, nlen);
PX_put_data_alpha (pxdoc, &data[offset], pxf[i].px_flen, value);
break;
}
case pxfMemoBLOb:
case pxfFmtMemoBLOb: {
char *value = fieldstr;
if (0 > PX_put_data_blob (pxdoc, &data[offset], pxf[i].px_flen, value, strlen (value))) {
g_warning (_("Field %d in row %d could not be written."), i+1, row+1);
}
break;
}
case pxfDate: {
long value = value_get_as_int (cell->value);
/* 60 would be 29.2.1900 which didn't exist. */
if (value < 60)
value++;
value += 693594;
PX_put_data_long (pxdoc, &data[offset], 4, value);
break;
}
case pxfTime: {
double dtmp;
int value;
dtmp = value_get_as_float (cell->value);
dtmp -= ((int) dtmp);
value = (int) (dtmp * 86400000.0);
PX_put_data_long (pxdoc, &data[offset], 4, value);
break;
}
case pxfLogical: {
gboolean err; /* Ignored */
gboolean value = value_get_as_bool (cell->value, &err);
PX_put_data_byte (pxdoc, &data[offset], 1, value ? 1 : 0);
break;
}
case pxfBCD:
PX_put_data_bcd (pxdoc, &data[offset], pxf[i].px_fdc, fieldstr);
break;
}
}
offset += pxf[i].px_flen;
i++;
}
if ((i > 0) && (0 > PX_put_record (pxdoc, data))) {
g_warning (_("Could not write record number %d."), i+1);
pxdoc->free (pxdoc, data);
PX_close (pxdoc);
PX_delete (pxdoc);
return;
}
}
pxdoc->free (pxdoc, data);
PX_close (pxdoc);
PX_delete (pxdoc);
#ifdef PX_MEMORY_DEBUGGING
PX_mp_list_unfreed ();
#endif
{
FILE *fp;
size_t size;
fp = fopen (tmpfilename, "r");
if (fp) {
data = g_malloc (8192);
while (0 != (size = fread (data, 1, 8192, fp)))
gsf_output_write (output, size, data);
fclose (fp);
g_free (data);
} else
g_warning ("Cannot open %s\n", tmpfilename);
unlink (tmpfilename);
}
}
Sheet *
wb_control_cur_sheet (WorkbookControl const *wbc)
{
g_return_val_if_fail (IS_WORKBOOK_CONTROL (wbc), NULL);
return wb_view_cur_sheet (wbc->wb_view);
}
/*
* Write _current_ sheet of the workbook to a DIF format file
*/
void
dif_file_save (GOFileSaver const *fs, GOIOContext *io_context,
WorkbookView const *wbv, GsfOutput *out)
{
GnmLocale *locale;
Sheet *sheet;
GnmRange r;
gint row, col;
gboolean ok = TRUE;
sheet = wb_view_cur_sheet (wbv);
if (sheet == NULL) {
go_io_error_string (io_context, _("Cannot get default sheet."));
return;
}
r = sheet_get_extent (sheet, FALSE, TRUE);
/* Write out the standard headers */
gsf_output_puts (out, "TABLE\n" "0,1\n" "\"GNUMERIC\"\n");
gsf_output_printf (out, "VECTORS\n" "0,%d\n" "\"\"\n", r.end.col+1);
gsf_output_printf (out, "TUPLES\n" "0,%d\n" "\"\"\n", r.end.row+1);
gsf_output_puts (out, "DATA\n" "0,0\n" "\"\"\n");
locale = gnm_push_C_locale ();
/* Process all cells */
for (row = r.start.row; ok && row <= r.end.row; row++) {
gsf_output_puts (out, "-1,0\n" "BOT\n");
for (col = r.start.col; col <= r.end.col; col++) {
GnmCell *cell = sheet_cell_get (sheet, col, row);
if (gnm_cell_is_empty (cell)) {
gsf_output_puts(out, "1,0\n" "\"\"\n");
} else if (VALUE_IS_BOOLEAN (cell->value)) {
if (value_get_as_checked_bool (cell->value))
gsf_output_puts(out, "0,1\n" "TRUE\n");
else
gsf_output_puts(out, "0,0\n" "FALSE\n");
} else if (VALUE_IS_ERROR (cell->value)) {
if (value_error_classify (cell->value) == GNM_ERROR_NA)
gsf_output_puts(out, "0,0\n" "NA\n");
else
gsf_output_puts(out, "0,0\n" "ERROR\n");
} else if (VALUE_IS_FLOAT (cell->value))
gsf_output_printf (out, "0,%" GNM_FORMAT_g "\n" "V\n",
value_get_as_float (cell->value));
else {
gchar *str = gnm_cell_get_rendered_text (cell);
ok = gsf_output_printf (out,
"1,0\n" "\"%s\"\n",
str);
g_free (str);
}
}
}
gsf_output_puts (out, "-1,0\n" "EOD\n");
gnm_pop_C_locale (locale);
if (!ok)
go_io_error_string (io_context, _("Error while saving DIF file."));
}
int
main (int argc, char const **argv)
{
gboolean opened_workbook = FALSE;
gboolean with_gui;
GOIOContext *ioc;
WorkbookView *wbv;
GSList *wbcgs_to_kill = NULL;
GOCmdContext *cc;
#ifdef G_OS_WIN32
gboolean has_console;
#endif
/* No code before here, we need to init threads */
argv = gnm_pre_parse_init (argc, argv);
/*
* Attempt to disable Ubuntu's funky, non-working scroll
* bars. This needs to be done before gtk starts loading
* modules. Note: the following call will not replace
* an existing setting, so you can run with =1 if you like.
*/
g_setenv ("LIBOVERLAY_SCROLLBAR", "0", FALSE);
#ifdef G_OS_WIN32
has_console = FALSE;
{
typedef BOOL (CALLBACK* LPFNATTACHCONSOLE)(DWORD);
LPFNATTACHCONSOLE MyAttachConsole;
HMODULE hmod;
if ((hmod = GetModuleHandle("kernel32.dll"))) {
MyAttachConsole = (LPFNATTACHCONSOLE) GetProcAddress(hmod, "AttachConsole");
if (MyAttachConsole && MyAttachConsole(ATTACH_PARENT_PROCESS)) {
freopen("CONOUT$", "w", stdout);
freopen("CONOUT$", "w", stderr);
dup2(fileno(stdout), 1);
dup2(fileno(stderr), 2);
has_console = TRUE;
}
}
}
#endif
gnumeric_arg_parse (argc, (char **)argv);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
bind_textdomain_codeset (GETTEXT_PACKAGE "-functions", "UTF-8");
with_gui = !func_def_file && !func_state_file && !split_funcdocs;
if (with_gui) {
gnm_session_init (argv[0]);
}
gnm_init ();
/* These are useful for the build process only. */
if (func_state_file)
return gnm_dump_func_defs (func_state_file, 0);
if (func_def_file)
return gnm_dump_func_defs (func_def_file, 1);
if (split_funcdocs)
return gnm_dump_func_defs (NULL, 2);
if (ext_refs_file)
return gnm_dump_func_defs (ext_refs_file, 4);
if (with_gui) {
go_component_set_default_command_context (cc = cmd_context_stderr_new ());
g_object_unref (cc);
cc = g_object_new (GNM_TYPE_IO_CONTEXT_GTK,
"show-splash", !gnumeric_no_splash,
"show-warnings", !gnumeric_no_warnings,
NULL);
ioc = GO_IO_CONTEXT (g_object_ref (cc));
handle_paint_events ();
pathetic_qt_workaround ();
} else {
/* TODO: Make this inconsistency go away */
cc = cmd_context_stderr_new ();
ioc = go_io_context_new (cc);
go_component_set_default_command_context (cc);
}
/* Keep in sync with .desktop file */
g_set_application_name (_("Gnumeric Spreadsheet"));
gnm_plugins_init (GO_CMD_CONTEXT (ioc));
if (startup_files) {
int i;
for (i = 0; startup_files [i]; i++)
;
go_io_context_set_num_files (ioc, i);
for (i = 0;
startup_files [i] && !initial_workbook_open_complete;
i++) {
char *uri = go_shell_arg_to_uri (startup_files[i]);
if (uri == NULL) {
g_warning ("Ignoring invalid URI.");
continue;
}
go_io_context_processing_file (ioc, uri);
wbv = workbook_view_new_from_uri (uri, NULL, ioc, NULL);
g_free (uri);
if (go_io_error_occurred (ioc) ||
go_io_warning_occurred (ioc)) {
go_io_error_display (ioc);
go_io_error_clear (ioc);
}
if (wbv != NULL) {
WBCGtk *wbcg;
workbook_update_history (wb_view_get_workbook (wbv), GNM_FILE_SAVE_AS_STYLE_SAVE);
wbcg = wbc_gtk_new (wbv, NULL, NULL, geometry);
geometry = NULL;
sheet_update (wb_view_cur_sheet (wbv));
opened_workbook = TRUE;
gnm_io_context_gtk_set_transient_for (GNM_IO_CONTEXT_GTK (ioc),
wbcg_toplevel (wbcg));
if (immediate_exit_flag)
wbcgs_to_kill = g_slist_prepend (wbcgs_to_kill,
wbcg);
}
/* cheesy attempt to keep the ui from freezing during
load */
handle_paint_events ();
if (gnm_io_context_gtk_get_interrupted (GNM_IO_CONTEXT_GTK (ioc)))
break; /* Don't load any more workbooks */
}
}
g_object_unref (cc);
cc = NULL;
/* FIXME: Maybe we should quit here if we were asked to open
files and failed to do so. */
/* If we were intentionally short circuited exit now */
if (!initial_workbook_open_complete) {
initial_workbook_open_complete = TRUE;
if (!opened_workbook) {
gint n_of_sheets = gnm_conf_get_core_workbook_n_sheet ();
wbc_gtk_new (NULL,
workbook_new_with_sheets (n_of_sheets),
NULL, geometry);
}
if (immediate_exit_flag) {
GSList *l;
for (l = wbcgs_to_kill; l; l = l->next)
g_idle_add ((GSourceFunc)cb_kill_wbcg, l->data);
}
g_signal_connect (gnm_app_get_app (),
"workbook_removed",
G_CALLBACK (cb_workbook_removed),
NULL);
gnm_io_context_gtk_discharge_splash (GNM_IO_CONTEXT_GTK (ioc));
g_object_unref (ioc);
g_idle_add ((GSourceFunc)pathetic_qt_workaround, NULL);
gtk_main ();
} else {
g_object_unref (ioc);
g_slist_foreach (wbcgs_to_kill, (GFunc)cb_kill_wbcg, NULL);
}
g_slist_free (wbcgs_to_kill);
gnumeric_arg_shutdown ();
store_plugin_state ();
gnm_shutdown ();
#if defined(G_OS_WIN32)
if (has_console) {
close(1);
close(2);
FreeConsole();
}
#endif
gnm_pre_parse_shutdown ();
go_component_set_default_command_context (NULL);
/*
* This helps finding leaks. We might want it in developent
* only.
*/
if (with_gui && gnm_debug_flag ("close-displays")) {
GSList *displays;
gdk_flush();
while (g_main_context_iteration (NULL, FALSE))
;/* nothing */
displays = gdk_display_manager_list_displays
(gdk_display_manager_get ());
g_slist_foreach (displays, (GFunc)gdk_display_close, NULL);
g_slist_free (displays);
}
return 0;
}
