src/dialogs/dialog-scenarios.c

   1 /* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /**
   3  * dialog-scenarios.c:  Create, edit, and view scenarios.
   4  *
   5  * Author:
   6  *        Jukka-Pekka Iivonen <jiivonen@hutcs.cs.hut.fi>
   7  *
   8  * (C) Copyright 2003 by Jukka-Pekka Iivonen <jiivonen@hutcs.cs.hut.fi>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  22  */
  23 #include <gnumeric-config.h>
  24 #include <glib/gi18n-lib.h>
  25 #include <gnumeric.h>
  26 #include "dialogs.h"
  27 #include "help.h"
  28
  29 #include <gui-util.h>
  30 #include <commands.h>
  31 #include <workbook-control.h>
  32 #include <workbook.h>
  33 #include <wbc-gtk.h>
  34 #include <sheet.h>
  35 #include <dao-gui-utils.h>
  36 #include <position.h>
  37 #include <ranges.h>
  38 #include <value.h>
  39 #include <cell.h>
  40 #include <dao.h>
  41 #include "scenarios.h"
  42
  43 #include <gtk/gtk.h>
  44 #include <goffice/goffice.h>
  45 #include <string.h>
  46
  47 #define DARK_GRAY  GO_COLOR_GREY(51)    /* "gray20" */
  48 #define LIGHT_GRAY GO_COLOR_GREY(199)   /* "gray78" */
  49
  50 typedef struct {
  51         GenericToolState base;
  52
  53         GtkWidget  *show_button;
  54         GtkWidget  *delete_button;
  55         GtkWidget  *summary_button;
  56         GtkWidget  *name_entry;
  57
  58         GtkWidget  *scenarios_treeview;
  59         GSList     *new_report_sheets;
  60
  61         GOUndo *undo;
  62         GnmScenario *current;
  63 } ScenariosState;
  64
  65 typedef GnmValue * (*ScenarioValueCB) (int col, int row, GnmValue *v, gpointer data);
  66
  67 static void
  68 scenario_for_each_value (GnmScenario *s, ScenarioValueCB fn, gpointer data)
  69 {
  70 }
  71
  72 /* Ok button pressed. */
  73 static void
  74 scenario_manager_ok (Sheet *sheet)
  75 {
  76         GList *l, *scenarios = g_list_copy (sheet->scenarios);
  77
  78         /* Update scenarios (free the deleted ones). */
  79         for (l = scenarios; l; l = l->next) {
  80                 GnmScenario *sc = l->data;
  81                 if (g_object_get_data (G_OBJECT (sc), "marked_deleted")) {
  82                         gnm_sheet_scenario_remove (sc->sheet, sc);
  83                 }
  84         }
  85         g_list_free (scenarios);
  86
  87         sheet_redraw_all (sheet, TRUE);
  88 }
  89
  90 /* Cancel button pressed. */
  91 static void
  92 scenario_recover_all (Sheet *sheet)
  93 {
  94         GList *l;
  95
  96         for (l = sheet->scenarios; l; l = l->next) {
  97                 GnmScenario *sc = l->data;
  98                 g_object_set_data (G_OBJECT (sc),
  99                                    "marked_deleted", GUINT_TO_POINTER (FALSE));
 100         }
 101 }
 102
 103 /* Scenario: Create summary report ***************************************/
 104
 105 static void
 106 rm_fun_cb (gpointer key, gpointer value, gpointer user_data)
 107 {
 108         g_free (value);
 109 }
 110
 111 typedef struct {
 112         data_analysis_output_t dao;
 113
 114         Sheet      *sheet;
 115         GHashTable *names;  /* A hash table for cell names->row. */
 116         int        col;
 117         int        row;
 118         GSList     *results;
 119 } summary_cb_t;
 120
 121 static GnmValue *
 122 summary_cb (int col, int row, GnmValue *v, summary_cb_t *p)
 123 {
 124         char  *tmp = dao_find_name (p->sheet, col, row);
 125         int   *index;
 126
 127         /* Check if some of the previous scenarios already included that
 128          * cell. If so, it's row will be put into *index. */
 129         index = g_hash_table_lookup (p->names, tmp);
 130         if (index != NULL) {
 131                 dao_set_cell_value (&p->dao, 2 + p->col, 3 + *index,
 132                                     value_dup (v));
 133
 134                 /* Set the colors. */
 135                 dao_set_colors (&p->dao, 2 + p->col, 3 + *index,
 136                                 2 + p->col, 3 + *index,
 137                                 gnm_color_new_go (GO_COLOR_BLACK),
 138                                 gnm_color_new_go (LIGHT_GRAY));
 139
 140         } else {
 141                 /* New cell. */
 142                 GnmCell *cell;
 143                 int  *r;
 144
 145                 /* Changing cell name. */
 146                 dao_set_cell (&p->dao, 0, 3 + p->row, tmp);
 147
 148                 /* GnmValue of the cell in this scenario. */
 149                 dao_set_cell_value (&p->dao, 2 + p->col, 3 + p->row,
 150                                     value_dup (v));
 151
 152                 /* Current value of the cell. */
 153                 cell = sheet_cell_fetch (p->sheet, col, row);
 154                 dao_set_cell_value (&p->dao, 1, 3 + p->row,
 155                                     value_dup (cell->value));
 156
 157                 /* Set the colors. */
 158                 dao_set_colors (&p->dao, 2 + p->col, 3 + p->row,
 159                                 2 + p->col, 3 + p->row,
 160                                 gnm_color_new_go (GO_COLOR_BLACK),
 161                                 gnm_color_new_go (LIGHT_GRAY));
 162
 163                 /* Insert row number into the hash table. */
 164                 r  = g_new (int, 1);
 165                 *r = p->row;
 166                 g_hash_table_insert (p->names, tmp, r);
 167
 168                 /* Increment the nbr of rows. */
 169                 p->row++;
 170         }
 171
 172         return v;
 173 }
 174
 175 static void
 176 scenario_summary_res_cells (WorkbookControl *wbc, GSList *results,
 177                             summary_cb_t *cb)
 178 {
 179 }
 180
 181 static void
 182 scenario_summary (WorkbookControl *wbc,
 183                   Sheet           *sheet,
 184                   GSList          *results,
 185                   Sheet           **new_sheet)
 186 {
 187         summary_cb_t cb;
 188         GList        *cur;
 189         GList        *scenarios = sheet->scenarios;
 190
 191         /* Initialize: Currently only new sheet output supported. */
 192         dao_init_new_sheet (&cb.dao);
 193         dao_prepare_output (wbc, &cb.dao, _("Scenario Summary"));
 194
 195         /* Titles. */
 196         dao_set_cell (&cb.dao, 1, 1, _("Current Values"));
 197         dao_set_cell (&cb.dao, 0, 2, _("Changing Cells:"));
 198
 199         /* Go through all scenarios. */
 200         cb.row     = 0;
 201         cb.names   = g_hash_table_new (g_str_hash, g_str_equal);
 202         cb.sheet   = sheet;
 203         cb.results = results;
 204         for (cb.col = 0, cur = scenarios; cur != NULL; cb.col++,
 205                      cur = cur->next) {
 206                 GnmScenario *s = cur->data;
 207
 208                 /* Scenario name. */
 209                 dao_set_cell (&cb.dao, 2 + cb.col, 1, s->name);
 210
 211                 scenario_for_each_value (s, (ScenarioValueCB) summary_cb, &cb);
 212         }
 213
 214         /* Set the alignment of names of the changing cells to be right. */
 215         dao_set_align (&cb.dao, 0, 3, 0, 2 + cb.row, GNM_HALIGN_RIGHT,
 216                        GNM_VALIGN_BOTTOM);
 217
 218         /* Result cells. */
 219         if (results != NULL)
 220                 scenario_summary_res_cells (wbc, results, &cb);
 221
 222         /* Destroy the hash table. */
 223         g_hash_table_foreach (cb.names, (GHFunc) rm_fun_cb, NULL);
 224         g_hash_table_destroy (cb.names);
 225
 226         /* Clean up the report output. */
 227         dao_set_bold (&cb.dao, 0, 0, 0, 2 + cb.row);
 228         dao_autofit_columns (&cb.dao);
 229         dao_set_cell (&cb.dao, 0, 0, _("Scenario Summary"));
 230
 231         dao_set_colors (&cb.dao, 0, 0, cb.col + 1, 1,
 232                         gnm_color_new_go (GO_COLOR_WHITE),
 233                         gnm_color_new_go (DARK_GRAY));
 234         dao_set_colors (&cb.dao, 0, 2, 0, 2 + cb.row,
 235                         gnm_color_new_go (GO_COLOR_BLACK),
 236                         gnm_color_new_go (LIGHT_GRAY));
 237
 238         dao_set_align (&cb.dao, 1, 1, cb.col + 1, 1, GNM_HALIGN_RIGHT,
 239                        GNM_VALIGN_BOTTOM);
 240
 241         *new_sheet = cb.dao.sheet;
 242 }
 243
 244 /********* Scenario Add UI **********************************************/
 245
 246 static gboolean
 247 scenario_name_used (const GList *scenarios, const gchar *name)
 248 {
 249         while (scenarios != NULL) {
 250                 const GnmScenario *s = scenarios->data;
 251
 252                 if (strcmp (s->name, name) == 0)
 253                         return TRUE;
 254                 scenarios = scenarios->next;
 255         }
 256         return FALSE;
 257 }
 258
 259 /*
 260  * A scenario name should have at least one printable character.
 261  */
 262 static gboolean
 263 check_name (const gchar *n)
 264 {
 265         while (*n && g_unichar_isspace (g_utf8_get_char (n)))
 266                 n = g_utf8_next_char (n);
 267
 268         if (*n)
 269                 return FALSE;
 270         else
 271                 return TRUE;
 272 }
 273
 274 /**
 275  * scenarios_ok_clicked_cb:
 276  * @button:
 277  * @state:
 278  *
 279  * Run the scenario manager tool.
 280  **/
 281 static void
 282 scenario_add_ok_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
 283                             ScenariosState *state)
 284 {
 285         data_analysis_output_t  dao;
 286         WorkbookControl         *wbc;
 287         gchar                   *name;
 288         gchar                   *comment;
 289         GnmValue                   *cell_range;
 290         GtkWidget               *entry, *comment_view;
 291         GtkTextBuffer           *buf;
 292         GtkTextIter             start, end;
 293         GnmScenario             *sc;
 294         GnmSheetRange           sr;
 295
 296         cell_range = gnm_expr_entry_parse_as_value
 297                 (GNM_EXPR_ENTRY (state->base.input_entry), state->base.sheet);
 298
 299         if (!cell_range || !gnm_sheet_range_from_value (&sr, cell_range)) {
 300                 go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
 301                                  GTK_MESSAGE_ERROR,
 302                                  _("Invalid changing cells"));
 303                 gnm_expr_entry_grab_focus (state->base.input_entry, TRUE);
 304                 return;
 305         }
 306
 307         if (sr.sheet && sr.sheet != state->base.sheet) {
 308                 go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
 309                                  GTK_MESSAGE_ERROR,
 310                                  _("Changing cells should be on the current "
 311                                    "sheet only."));
 312                 gnm_expr_entry_grab_focus (state->base.input_entry, TRUE);
 313                 goto out;
 314         }
 315         entry = go_gtk_builder_get_widget (state->base.gui, "name_entry");
 316
 317         name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
 318         if (scenario_name_used (state->base.sheet->scenarios, name)) {
 319                 g_free (name);
 320                 go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
 321                                  GTK_MESSAGE_ERROR,
 322                                  _("Scenario name already used"));
 323                 goto out;
 324         } else if (check_name (name)) {
 325                 g_free (name);
 326                 go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
 327                                  GTK_MESSAGE_ERROR,
 328                                  _("Invalid scenario name"));
 329                 goto out;
 330         }
 331
 332         comment_view = go_gtk_builder_get_widget (state->base.gui, "comment_view");
 333         buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (comment_view));
 334         gtk_text_buffer_get_start_iter (buf, &start);
 335         gtk_text_buffer_get_end_iter (buf, &end);
 336         comment = g_strdup (gtk_text_buffer_get_text (buf, &start, &end,
 337                                                       FALSE));
 338
 339         dao_init_new_sheet (&dao);
 340         dao.sheet = state->base.sheet;
 341
 342         wbc = GNM_WBC (state->base.wbcg);
 343
 344         sc = gnm_sheet_scenario_new (state->base.sheet, name);
 345         if (comment && comment[0])
 346                 gnm_scenario_set_comment (sc, comment);
 347         gnm_scenario_add_area (sc, &sr);
 348
 349         cmd_scenario_add (wbc, sc, state->base.sheet);
 350
 351         g_free (name);
 352         g_free (comment);
 353         gtk_widget_destroy (state->base.dialog);
 354  out:
 355         value_release (cell_range);
 356         return;
 357 }
 358
 359 /**
 360  * scenario_add_update_sensitivity_cb:
 361  * @dummy:
 362  * @state:
 363  *
 364  * Update the dialog widgets sensitivity
 365  **/
 366 static void
 367 scenario_add_update_sensitivity_cb (G_GNUC_UNUSED GtkWidget *dummy,
 368                                     ScenariosState *state)
 369 {
 370         gtk_widget_set_sensitive (state->base.ok_button, TRUE);
 371 }
 372
 373 void
 374 dialog_scenario_add (WBCGtk *wbcg)
 375 {
 376         ScenariosState *state;
 377         WorkbookControl  *wbc;
 378         GtkWidget        *comment_view;
 379         char const *error_str = _("Could not create the Scenario Add dialog.");
 380         GString          *buf;
 381
 382         if (wbcg == NULL)
 383                 return;
 384
 385         wbc = GNM_WBC (wbcg);
 386
 387         /* Only pop up one copy per workbook */
 388         if (gnm_dialog_raise_if_exists (wbcg, "ScenarioAdd"))
 389                 return;
 390
 391         state = g_new (ScenariosState, 1);
 392
 393         if (dialog_tool_init (&state->base, wbcg, wb_control_cur_sheet (wbc),
 394                               GNUMERIC_HELP_LINK_SCENARIOS_ADD,
 395                               "res:ui/scenario-add.ui", "ScenarioAdd",
 396                               error_str,
 397                               "ScenarioAdd",
 398                               G_CALLBACK (scenario_add_ok_clicked_cb), NULL,
 399                               G_CALLBACK (scenario_add_update_sensitivity_cb),
 400                               GNM_EE_SHEET_OPTIONAL))
 401         {
 402                 g_free (state);
 403                 return;
 404         }
 405
 406         state->name_entry = go_gtk_builder_get_widget (state->base.gui, "name_entry");
 407         if (state->name_entry == NULL)
 408                 return;
 409
 410         comment_view = go_gtk_builder_get_widget (state->base.gui, "comment_view");
 411         if (comment_view == NULL)
 412                 return;
 413         buf = g_string_new (NULL);
 414         g_string_append_printf (buf, _("Created on "));
 415         dao_append_date (buf);
 416         gtk_text_buffer_set_text (gtk_text_view_get_buffer
 417                                   (GTK_TEXT_VIEW (comment_view)), buf->str,
 418                                   strlen (buf->str));
 419         g_string_free (buf, FALSE);
 420
 421         state->base.gdao = NULL;
 422
 423         gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->base.dialog),
 424                                            wbcg,
 425                                            GNM_DIALOG_DESTROY_SHEET_REMOVED);
 426
 427         gnm_editable_enters (GTK_WINDOW (state->base.dialog),
 428                                   GTK_WIDGET (state->name_entry));
 429         scenario_add_update_sensitivity_cb (NULL, state);
 430         tool_load_selection ((GenericToolState *)state, TRUE);
 431 }
 432
 433
 434 /********* Scenario Manager UI ******************************************/
 435
 436 static void
 437 update_comment (ScenariosState *state, const gchar *cells,
 438                 const gchar *comment)
 439 {
 440         GtkWidget     *w;
 441         GtkTextBuffer *buf;
 442
 443         /* Update changing cells box */
 444         w = go_gtk_builder_get_widget (state->base.gui, "changing_cells_entry");
 445         gtk_entry_set_text (GTK_ENTRY (w), cells);
 446
 447         /* Update comment text view */
 448         w = go_gtk_builder_get_widget (state->base.gui, "comment_view");
 449         buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (w));
 450
 451         gtk_text_buffer_set_text (buf, comment, strlen (comment));
 452 }
 453
 454 static void
 455 set_selection_state (ScenariosState *state, gboolean f)
 456 {
 457         /* Set the sensitivies to FALSE since no selections have been made */
 458         gtk_widget_set_sensitive (state->show_button, f);
 459         gtk_widget_set_sensitive (state->delete_button, f);
 460
 461         if (f) {
 462                 GtkTreeSelection        *selection;
 463                 GtkTreeIter             iter;
 464                 GtkTreeModel            *model;
 465                 gchar                   *name;
 466                 gchar                   *cells_txt;
 467                 GnmScenario             *sc;
 468
 469                 selection = gtk_tree_view_get_selection
 470                         (GTK_TREE_VIEW
 471                          (state->scenarios_treeview));
 472                 if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
 473                         return;
 474                 model = gtk_tree_view_get_model
 475                         (GTK_TREE_VIEW
 476                          (state->scenarios_treeview));
 477
 478                 gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
 479                                     0, &name, -1);
 480
 481                 sc = gnm_sheet_scenario_find (state->base.sheet, name);
 482                 if (!sc)
 483                         return;
 484                 cells_txt = gnm_scenario_get_range_str (sc);
 485                 update_comment (state, cells_txt, sc->comment);
 486                 g_free (cells_txt);
 487         } else
 488                 update_comment (state, "", "");
 489 }
 490
 491 static void
 492 update_scenarios_treeview (GtkWidget *view, GList *scenarios)
 493 {
 494           GtkTreeIter  iter;
 495           GtkListStore *store;
 496           GtkTreePath  *path;
 497
 498           store = gtk_list_store_new (1, G_TYPE_STRING);
 499
 500           while (scenarios != NULL) {
 501                   GnmScenario *s = scenarios->data;
 502
 503                   gtk_list_store_append (store, &iter);
 504                   gtk_list_store_set (store, &iter, 0, s->name, -1);
 505                   scenarios = scenarios->next;
 506           }
 507           path = gtk_tree_path_new_from_string ("0");
 508           if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store),
 509                                        &iter, path)) {
 510                   ;             /* Do something */
 511           }  else {
 512                   /* No scenarios */
 513           }
 514           gtk_tree_path_free (path);
 515
 516           gtk_tree_view_set_model (GTK_TREE_VIEW (view),
 517                                    GTK_TREE_MODEL (store));
 518           g_object_unref (store);
 519           gtk_tree_view_append_column
 520                   (GTK_TREE_VIEW (view),
 521                    gtk_tree_view_column_new_with_attributes
 522                    (_("Name"),
 523                     gtk_cell_renderer_text_new (), "text", 0, NULL));
 524 }
 525
 526 /**
 527  * scenarios_update_sensitivity_cb:
 528  * @dummy:
 529  * @state:
 530  *
 531  * Update the dialog widgets sensitivity
 532  **/
 533 static void
 534 scenarios_update_sensitivity_cb (G_GNUC_UNUSED GtkWidget *dummy,
 535                                  ScenariosState *state)
 536 {
 537         gtk_widget_set_sensitive (state->base.ok_button, TRUE);
 538 }
 539
 540
 541 static void
 542 scenario_manager_free (ScenariosState *state)
 543 {
 544         g_slist_free (state->new_report_sheets);
 545         state->new_report_sheets = NULL;
 546
 547         if (state->undo) {
 548                 g_object_unref (state->undo);
 549                 state->undo = NULL;
 550         }
 551 }
 552
 553 /**
 554  * scenarios_ok_clicked_cb:
 555  * @button:
 556  * @state:
 557  *
 558  * Run the scenario manager tool.
 559  **/
 560 static void
 561 scenarios_ok_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
 562                          ScenariosState *state)
 563 {
 564         if (state->current) {
 565                 WorkbookControl *wbc = GNM_WBC (state->base.wbcg);
 566                 cmd_scenario_mngr (wbc, state->current, state->undo);
 567         }
 568
 569         scenario_manager_ok (state->base.sheet);
 570
 571         scenario_manager_free (state);
 572         gtk_widget_destroy (state->base.dialog);
 573
 574         return;
 575 }
 576
 577 static void
 578 restore_old_values (ScenariosState *state)
 579 {
 580         GOCmdContext *cc;
 581
 582         if (state->undo == NULL)
 583                 return;
 584
 585         cc = GO_CMD_CONTEXT (state->base.wbcg);
 586         go_undo_undo_with_data (state->undo, cc);
 587         g_object_unref (state->undo);
 588         state->undo = NULL;
 589         state->current = NULL;
 590 }
 591
 592 /**
 593  * scenarios_cancel_clicked_cb:
 594  * @button:
 595  * @state:
 596  *
 597  * Cancel clicked on the scenario manager tool.
 598  **/
 599 static void
 600 scenarios_cancel_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
 601                              ScenariosState *state)
 602 {
 603         GSList *cur;
 604         WorkbookControl *wbc;
 605
 606         restore_old_values (state);
 607
 608         wbc = GNM_WBC (state->base.wbcg);
 609
 610         /* Remove report sheets created on this dialog session. */
 611         for (cur = state->new_report_sheets; cur != NULL;
 612              cur = cur->next) {
 613                 Sheet *sheet = cur->data;
 614
 615                 /* Check that if the focus is on a deleted sheet. */
 616                 if (wb_control_cur_sheet (wbc) == sheet)
 617                         wb_control_sheet_focus (wbc, state->base.sheet);
 618
 619                 /* Delete a report sheet. */
 620                 workbook_sheet_delete (sheet);
 621         }
 622
 623         /* Recover the deleted scenarios. */
 624         scenario_recover_all (state->base.sheet);
 625
 626         scenario_manager_free (state);
 627         gtk_widget_destroy (state->base.dialog);
 628 }
 629
 630 static void
 631 scenarios_show_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
 632                            ScenariosState *state)
 633 {
 634         GtkTreeSelection        *selection;
 635         GtkTreeIter             iter;
 636         GtkTreeModel            *model;
 637         const gchar             *value;
 638
 639         selection = gtk_tree_view_get_selection
 640                 (GTK_TREE_VIEW (state->scenarios_treeview));
 641         if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
 642                 return;
 643         model = gtk_tree_view_get_model
 644                 (GTK_TREE_VIEW (state->scenarios_treeview));
 645
 646         gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,  0, &value, -1);
 647
 648         restore_old_values (state);
 649
 650         state->current = gnm_sheet_scenario_find (state->base.sheet, value);
 651         state->undo = gnm_scenario_apply (state->current);
 652 }
 653
 654 static void
 655 scenarios_delete_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
 656                              ScenariosState *state)
 657 {
 658         data_analysis_output_t  dao;
 659         GtkTreeSelection        *selection;
 660         GtkTreeIter             iter;
 661         GtkTreeModel            *model;
 662         gchar                   *value;
 663         gboolean                all_deleted;
 664         GnmScenario             *sc;
 665         GList                   *l;
 666
 667         restore_old_values (state);
 668
 669         selection = gtk_tree_view_get_selection
 670                 (GTK_TREE_VIEW (state->scenarios_treeview));
 671         dao_init_new_sheet (&dao);
 672         dao.sheet = state->base.sheet;
 673         if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
 674                 return;
 675         model = gtk_tree_view_get_model
 676                 (GTK_TREE_VIEW (state->scenarios_treeview));
 677
 678         gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, 0, &value, -1);
 679
 680         gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
 681
 682         sc = gnm_sheet_scenario_find (state->base.sheet, value);
 683         if (sc)
 684                 g_object_set_data (G_OBJECT (sc),
 685                                    "marked_deleted", GUINT_TO_POINTER (TRUE));
 686
 687         set_selection_state (state, FALSE);
 688
 689         all_deleted = TRUE;
 690         for (l = state->base.sheet->scenarios; l && all_deleted; l = l->next) {
 691                 GnmScenario *sc = l->data;
 692                 if (!g_object_get_data (G_OBJECT (sc), "marked_deleted"))
 693                         all_deleted = FALSE;
 694         }
 695
 696         gtk_widget_set_sensitive
 697                 (state->summary_button, !all_deleted);
 698 }
 699
 700 static void
 701 scenarios_summary_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
 702                               ScenariosState *state)
 703 {
 704         Sheet  *new_sheet;
 705         GSList *results;
 706
 707         restore_old_values (state);
 708
 709         results = gnm_expr_entry_parse_as_list (
 710                 GNM_EXPR_ENTRY (state->base.input_entry), state->base.sheet);
 711
 712         if (results == NULL) {
 713                 go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
 714                                  GTK_MESSAGE_ERROR,
 715                                  _("Results entry did not contain valid "
 716                                    "cell names."));
 717                 return;
 718         }
 719
 720         scenario_summary (GNM_WBC (state->base.wbcg), state->base.sheet,
 721                           results, &new_sheet);
 722
 723         state->new_report_sheets =
 724                 g_slist_prepend (state->new_report_sheets,
 725                                  new_sheet);
 726         if (results)
 727                 g_slist_free_full (results, (GDestroyNotify)value_release);
 728 }
 729
 730 static void
 731 cb_selection_changed (G_GNUC_UNUSED GtkTreeSelection *selection,
 732                       ScenariosState *state)
 733 {
 734         set_selection_state (state, TRUE);
 735 }
 736
 737 static gboolean
 738 init_scenario_buttons (ScenariosState *state)
 739 {
 740         /* Show button */
 741         state->show_button =
 742                 go_gtk_builder_get_widget (state->base.gui, "show_button");
 743         if (state->show_button == NULL)
 744                 return TRUE;
 745         g_signal_connect (G_OBJECT (state->show_button),
 746                           "clicked",
 747                           G_CALLBACK (scenarios_show_clicked_cb), state);
 748
 749         /* Delete button */
 750         state->delete_button =
 751                 go_gtk_builder_get_widget (state->base.gui, "delete_button");
 752         if (state->delete_button == NULL)
 753                 return TRUE;
 754         g_signal_connect (G_OBJECT (state->delete_button),
 755                           "clicked",
 756                           G_CALLBACK (scenarios_delete_clicked_cb), state);
 757
 758         /* Summary button */
 759         state->summary_button =
 760                 go_gtk_builder_get_widget (state->base.gui, "summary_button");
 761         if (state->summary_button == NULL)
 762                 return TRUE;
 763         g_signal_connect (G_OBJECT (state->summary_button),
 764                           "clicked",
 765                           G_CALLBACK (scenarios_summary_clicked_cb),
 766                           state);
 767
 768         set_selection_state (state, FALSE);
 769
 770         return FALSE;
 771 }
 772
 773 void
 774 dialog_scenarios (WBCGtk *wbcg)
 775 {
 776         ScenariosState   *state;
 777         WorkbookControl  *wbc;
 778         Sheet            *sheet;
 779         GtkWidget        *w;
 780         GtkTreeSelection *select;
 781         char const *error_str = _("Could not create the Scenarios dialog.");
 782
 783         g_return_if_fail (wbcg != NULL);
 784
 785         wbc   = GNM_WBC (wbcg);
 786         sheet = wb_control_cur_sheet (wbc);
 787
 788         state = g_new (ScenariosState, 1);
 789         state->new_report_sheets = NULL;
 790         state->current    = NULL;
 791         state->undo = NULL;
 792         state->base.wb = wb_control_get_workbook (wbc);
 793
 794         if (dialog_tool_init (&state->base, wbcg, sheet,
 795                               GNUMERIC_HELP_LINK_SCENARIOS_VIEW,
 796                               "res:ui/scenario-manager.ui", "Scenarios",
 797                               error_str, "Scenarios",
 798                               G_CALLBACK (scenarios_ok_clicked_cb),
 799                               G_CALLBACK (scenarios_cancel_clicked_cb),
 800                               G_CALLBACK (scenarios_update_sensitivity_cb),
 801                               0))
 802                 goto error_out;
 803
 804         if (init_scenario_buttons (state))
 805                 goto error_out;
 806
 807         state->scenarios_treeview = go_gtk_builder_get_widget
 808                 (state->base.gui, "scenarios_treeview");
 809         if (state->scenarios_treeview == NULL)
 810                 goto error_out;
 811
 812         w = go_gtk_builder_get_widget (state->base.gui, "changing_cells_entry");
 813         if (w == NULL)
 814                 goto error_out;
 815         gtk_widget_set_sensitive (w, FALSE);
 816         w = go_gtk_builder_get_widget (state->base.gui, "comment_view");
 817
 818         if (w == NULL)
 819                 goto error_out;
 820         gtk_widget_set_sensitive (w, FALSE);
 821
 822         if (state->base.sheet->scenarios == NULL)
 823                 gtk_widget_set_sensitive
 824                         (state->summary_button, FALSE);
 825
 826         update_scenarios_treeview (state->scenarios_treeview,
 827                                    sheet->scenarios);
 828         select = gtk_tree_view_get_selection
 829                 (GTK_TREE_VIEW (state->scenarios_treeview));
 830         g_signal_connect (select, "changed",
 831                           G_CALLBACK (cb_selection_changed), state);
 832
 833         scenarios_update_sensitivity_cb (NULL, state);
 834         gtk_widget_show (state->base.dialog);
 835
 836         return;
 837
 838  error_out:
 839         go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR,
 840                               "%s", error_str);
 841         g_free (state);
 842
 843         return;
 844 }