pintos-os.org Git - pspp/blob - src/ui/gui/psppire-output-window.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2008, 2009, 2010, 2011, 2012, 2013  Free Software Foundation
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include <errno.h>
  20 #include <gtk/gtk.h>
  21 #include <stdlib.h>
  22 #include <sys/stat.h>
  23 #include <sys/types.h>
  24 #include <unistd.h>
  25
  26 #include "libpspp/cast.h"
  27 #include "libpspp/message.h"
  28 #include "libpspp/string-map.h"
  29 #include "output/cairo.h"
  30 #include "output/chart-item.h"
  31 #include "output/driver-provider.h"
  32 #include "output/message-item.h"
  33 #include "output/output-item.h"
  34 #include "output/tab.h"
  35 #include "output/table-item.h"
  36 #include "output/text-item.h"
  37 #include "ui/gui/help-menu.h"
  38 #include "ui/gui/builder-wrapper.h"
  39 #include "ui/gui/psppire-output-window.h"
  40
  41 #include "gl/tmpdir.h"
  42 #include "gl/xalloc.h"
  43 #include "gl/c-xvasprintf.h"
  44
  45 #include "helper.h"
  46
  47 #include <gettext.h>
  48 #define _(msgid) gettext (msgid)
  49 #define N_(msgid) msgid
  50
  51 enum
  52   {
  53     COL_TITLE,                  /* Table title. */
  54     COL_ADDR,                   /* Pointer to the table */
  55     COL_Y,                      /* Y position of top of title. */
  56     N_COLS
  57   };
  58
  59 static void psppire_output_window_class_init    (PsppireOutputWindowClass *class);
  60 static void psppire_output_window_init          (PsppireOutputWindow      *window);
  61
  62 static void psppire_output_window_style_set (GtkWidget *window, GtkStyle *prev);
  63
  64
  65 GType
  66 psppire_output_window_get_type (void)
  67 {
  68   static GType psppire_output_window_type = 0;
  69
  70   if (!psppire_output_window_type)
  71     {
  72       static const GTypeInfo psppire_output_window_info =
  73       {
  74         sizeof (PsppireOutputWindowClass),
  75         (GBaseInitFunc) NULL,
  76         (GBaseFinalizeFunc) NULL,
  77         (GClassInitFunc)psppire_output_window_class_init,
  78         (GClassFinalizeFunc) NULL,
  79         NULL,
  80         sizeof (PsppireOutputWindow),
  81         0,
  82         (GInstanceInitFunc) psppire_output_window_init,
  83       };
  84
  85       psppire_output_window_type =
  86         g_type_register_static (PSPPIRE_TYPE_WINDOW, "PsppireOutputWindow",
  87                                 &psppire_output_window_info, 0);
  88     }
  89
  90   return psppire_output_window_type;
  91 }
  92
  93 static GObjectClass *parent_class;
  94
  95 static void
  96 psppire_output_window_finalize (GObject *object)
  97 {
  98   string_map_destroy (&PSPPIRE_OUTPUT_WINDOW(object)->render_opts);
  99
 100
 101   if (G_OBJECT_CLASS (parent_class)->finalize)
 102     (*G_OBJECT_CLASS (parent_class)->finalize) (object);
 103 }
 104
 105
 106 static void
 107 psppire_output_window_dispose (GObject *obj)
 108 {
 109   PsppireOutputWindow *viewer = PSPPIRE_OUTPUT_WINDOW (obj);
 110   size_t i;
 111
 112   if (viewer->dispose_has_run)
 113     return;
 114
 115   viewer->dispose_has_run = TRUE;
 116   for (i = 0; i < viewer->n_items; i++)
 117     output_item_unref (viewer->items[i]);
 118   free (viewer->items);
 119   viewer->items = NULL;
 120   viewer->n_items = viewer->allocated_items = 0;
 121
 122   if (viewer->print_settings != NULL)
 123     g_object_unref (viewer->print_settings);
 124
 125   /* Chain up to the parent class */
 126   G_OBJECT_CLASS (parent_class)->dispose (obj);
 127 }
 128
 129 static void
 130 psppire_output_window_class_init (PsppireOutputWindowClass *class)
 131 {
 132   GObjectClass *object_class = G_OBJECT_CLASS (class);
 133
 134   parent_class = g_type_class_peek_parent (class);
 135   object_class->dispose = psppire_output_window_dispose;
 136
 137   GTK_WIDGET_CLASS (object_class)->style_set = psppire_output_window_style_set;
 138   object_class->finalize = psppire_output_window_finalize;
 139 }
 140
 141
 142 \f
 143 /* Output driver class. */
 144
 145 struct psppire_output_driver
 146   {
 147     struct output_driver driver;
 148     PsppireOutputWindow *viewer;
 149     struct xr_driver *xr;
 150     int font_height;
 151   };
 152
 153 static struct output_driver_class psppire_output_class;
 154
 155 static struct psppire_output_driver *
 156 psppire_output_cast (struct output_driver *driver)
 157 {
 158   assert (driver->class == &psppire_output_class);
 159   return UP_CAST (driver, struct psppire_output_driver, driver);
 160 }
 161
 162 static void on_dwgarea_realize (GtkWidget *widget, gpointer data);
 163
 164 static gboolean
 165 draw_callback (GtkWidget *widget, cairo_t *cr, gpointer data)
 166 {
 167   PsppireOutputWindow *viewer = PSPPIRE_OUTPUT_WINDOW (data);
 168   struct xr_rendering *r = g_object_get_data (G_OBJECT (widget), "rendering");
 169   const GtkStyle *style = gtk_widget_get_style (GTK_WIDGET (viewer));
 170
 171   PangoFontDescription *font_desc;
 172   char *font_name;
 173
 174   gchar *fgc =
 175     gdk_color_to_string (&style->text[gtk_widget_get_state (GTK_WIDGET (widget))]);
 176
 177   string_map_replace (&viewer->render_opts, "foreground-color", fgc);
 178
 179   free (fgc);
 180
 181   /* Use GTK+ default font as proportional font. */
 182   font_name = pango_font_description_to_string (style->font_desc);
 183   string_map_replace (&viewer->render_opts, "prop-font", font_name);
 184   g_free (font_name);
 185
 186   /* Derived emphasized font from proportional font. */
 187   font_desc = pango_font_description_copy (style->font_desc);
 188   pango_font_description_set_style (font_desc, PANGO_STYLE_ITALIC);
 189   font_name = pango_font_description_to_string (font_desc);
 190   string_map_replace (&viewer->render_opts, "emph-font", font_name);
 191   g_free (font_name);
 192   pango_font_description_free (font_desc);
 193
 194   xr_rendering_apply_options (r, &viewer->render_opts);
 195   xr_rendering_draw_all (r, cr);
 196
 197   return TRUE;
 198 }
 199
 200
 201 static void
 202 psppire_output_submit (struct output_driver *this,
 203                        const struct output_item *item)
 204 {
 205   struct psppire_output_driver *pod = psppire_output_cast (this);
 206   PsppireOutputWindow *viewer;
 207   GtkWidget *drawing_area;
 208   struct xr_rendering *r;
 209   struct string title;
 210   GtkTreeStore *store;
 211   GtkTreePath *path;
 212   GtkTreeIter iter;
 213   cairo_t *cr;
 214   int tw, th;
 215
 216   if (pod->viewer == NULL)
 217     {
 218       pod->viewer = PSPPIRE_OUTPUT_WINDOW (psppire_output_window_new ());
 219       gtk_widget_show_all (GTK_WIDGET (pod->viewer));
 220       pod->viewer->driver = pod;
 221     }
 222   viewer = pod->viewer;
 223
 224   if (viewer->n_items >= viewer->allocated_items)
 225     viewer->items = x2nrealloc (viewer->items, &viewer->allocated_items,
 226                                 sizeof *viewer->items);
 227   viewer->items[viewer->n_items++] = output_item_ref (item);
 228
 229   if (is_text_item (item))
 230     {
 231       const struct text_item *text_item = to_text_item (item);
 232       enum text_item_type type = text_item_get_type (text_item);
 233       const char *text = text_item_get_text (text_item);
 234
 235       if (type == TEXT_ITEM_COMMAND_CLOSE)
 236         {
 237           viewer->in_command = false;
 238           return;
 239         }
 240       else if (text[0] == '\0')
 241         return;
 242     }
 243
 244   cr = gdk_cairo_create (gtk_widget_get_window (GTK_WIDGET (pod->viewer)));
 245   if (pod->xr == NULL)
 246     {
 247       const GtkStyle *style = gtk_widget_get_style (GTK_WIDGET (viewer));
 248       struct text_item *text_item;
 249       PangoFontDescription *font_desc;
 250       char *font_name;
 251       int font_width;
 252
 253       /* Set the widget's text color as the foreground color for the output driver */
 254       gchar *fgc = gdk_color_to_string (&style->text[gtk_widget_get_state (GTK_WIDGET (viewer))]);
 255
 256       string_map_insert (&pod->viewer->render_opts, "foreground-color", fgc);
 257       g_free (fgc);
 258
 259       /* Use GTK+ default font as proportional font. */
 260       font_name = pango_font_description_to_string (style->font_desc);
 261       string_map_insert (&pod->viewer->render_opts, "prop-font", font_name);
 262       g_free (font_name);
 263
 264       /* Derived emphasized font from proportional font. */
 265       font_desc = pango_font_description_copy (style->font_desc);
 266       pango_font_description_set_style (font_desc, PANGO_STYLE_ITALIC);
 267       font_name = pango_font_description_to_string (font_desc);
 268       string_map_insert (&pod->viewer->render_opts, "emph-font", font_name);
 269       g_free (font_name);
 270       pango_font_description_free (font_desc);
 271
 272       /* Pretend that the "page" has a reasonable width and a very big length,
 273          so that most tables can be conveniently viewed on-screen with vertical
 274          scrolling only.  (The length should not be increased very much because
 275          it is already close enough to INT_MAX when expressed as thousands of a
 276          point.) */
 277       string_map_insert (&pod->viewer->render_opts, "paper-size", "300x200000mm");
 278       string_map_insert (&pod->viewer->render_opts, "left-margin", "0");
 279       string_map_insert (&pod->viewer->render_opts, "right-margin", "0");
 280       string_map_insert (&pod->viewer->render_opts, "top-margin", "0");
 281       string_map_insert (&pod->viewer->render_opts, "bottom-margin", "0");
 282
 283       pod->xr = xr_driver_create (cr, &pod->viewer->render_opts);
 284
 285
 286       text_item = text_item_create (TEXT_ITEM_PARAGRAPH, "X");
 287       r = xr_rendering_create (pod->xr, text_item_super (text_item), cr);
 288       xr_rendering_measure (r, &font_width, &pod->font_height);
 289       /* xr_rendering_destroy (r); */
 290       text_item_unref (text_item);
 291     }
 292   else
 293     pod->viewer->y += pod->font_height / 2;
 294
 295   r = xr_rendering_create (pod->xr, item, cr);
 296   if (r == NULL)
 297     goto done;
 298
 299   xr_rendering_measure (r, &tw, &th);
 300
 301   drawing_area = gtk_drawing_area_new ();
 302
 303   g_object_set_data (G_OBJECT (drawing_area), "rendering", r);
 304   g_signal_connect (drawing_area, "realize",
 305                      G_CALLBACK (on_dwgarea_realize), pod->viewer);
 306
 307   g_signal_connect (drawing_area, "draw",
 308                      G_CALLBACK (draw_callback), pod->viewer);
 309
 310   gtk_widget_set_size_request (drawing_area, tw, th);
 311   gtk_layout_put (pod->viewer->output, drawing_area, 0, pod->viewer->y);
 312
 313   gtk_widget_show (drawing_area);
 314
 315   if (!is_text_item (item)
 316       || text_item_get_type (to_text_item (item)) != TEXT_ITEM_SYNTAX
 317       || !viewer->in_command)
 318     {
 319       store = GTK_TREE_STORE (gtk_tree_view_get_model (viewer->overview));
 320
 321       ds_init_empty (&title);
 322       if (is_text_item (item)
 323           && text_item_get_type (to_text_item (item)) == TEXT_ITEM_COMMAND_OPEN)
 324         {
 325           gtk_tree_store_append (store, &iter, NULL);
 326           viewer->cur_command = iter; /* XXX shouldn't save a GtkTreeIter */
 327           viewer->in_command = true;
 328         }
 329       else
 330         {
 331           GtkTreeIter *p = viewer->in_command ? &viewer->cur_command : NULL;
 332           gtk_tree_store_append (store, &iter, p);
 333         }
 334
 335       ds_clear (&title);
 336       if (is_text_item (item))
 337         ds_put_cstr (&title, text_item_get_text (to_text_item (item)));
 338       else if (is_message_item (item))
 339         {
 340           const struct message_item *msg_item = to_message_item (item);
 341           const struct msg *msg = message_item_get_msg (msg_item);
 342           ds_put_format (&title, "%s: %s", _("Message"),
 343                          msg_severity_to_string (msg->severity));
 344         }
 345       else if (is_table_item (item))
 346         {
 347           const char *caption = table_item_get_caption (to_table_item (item));
 348           if (caption != NULL)
 349             ds_put_format (&title, "Table: %s", caption);
 350           else
 351             ds_put_cstr (&title, "Table");
 352         }
 353       else if (is_chart_item (item))
 354         {
 355           const char *s = chart_item_get_title (to_chart_item (item));
 356           if (s != NULL)
 357             ds_put_format (&title, "Chart: %s", s);
 358           else
 359             ds_put_cstr (&title, "Chart");
 360         }
 361       gtk_tree_store_set (store, &iter,
 362                           COL_TITLE, ds_cstr (&title),
 363                           COL_ADDR, item,
 364                           COL_Y, viewer->y,
 365                           -1);
 366       ds_destroy (&title);
 367
 368       path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
 369       gtk_tree_view_expand_row (viewer->overview, path, TRUE);
 370       gtk_tree_path_free (path);
 371     }
 372
 373   if (pod->viewer->max_width < tw)
 374     pod->viewer->max_width = tw;
 375   pod->viewer->y += th;
 376
 377   gtk_layout_set_size (pod->viewer->output,
 378                        pod->viewer->max_width, pod->viewer->y);
 379
 380   gtk_window_set_urgency_hint (GTK_WINDOW (pod->viewer), TRUE);
 381
 382 done:
 383   cairo_destroy (cr);
 384 }
 385
 386 static struct output_driver_class psppire_output_class =
 387   {
 388     "PSPPIRE",                  /* name */
 389     NULL,                       /* destroy */
 390     psppire_output_submit,      /* submit */
 391     NULL,                       /* flush */
 392   };
 393
 394 void
 395 psppire_output_window_setup (void)
 396 {
 397   struct psppire_output_driver *pod;
 398   struct output_driver *d;
 399
 400   pod = xzalloc (sizeof *pod);
 401   d = &pod->driver;
 402   output_driver_init (d, &psppire_output_class, "PSPPIRE",
 403                       SETTINGS_DEVICE_UNFILTERED);
 404   output_driver_register (d);
 405 }
 406
 407 \f
 408
 409 /* Callback for the "delete" action (clicking the x on the top right
 410    hand corner of the window) */
 411 static gboolean
 412 on_delete (GtkWidget *w, GdkEvent *event, gpointer user_data)
 413 {
 414   PsppireOutputWindow *ow = PSPPIRE_OUTPUT_WINDOW (user_data);
 415
 416   gtk_widget_destroy (GTK_WIDGET (ow));
 417
 418   ow->driver->viewer = NULL;
 419
 420   return FALSE;
 421 }
 422
 423
 424
 425 static void
 426 cancel_urgency (GtkWindow *window,  gpointer data)
 427 {
 428   gtk_window_set_urgency_hint (window, FALSE);
 429 }
 430
 431 static void
 432 on_row_activate (GtkTreeView *overview,
 433                  GtkTreePath *path,
 434                  GtkTreeViewColumn *column,
 435                  PsppireOutputWindow *window)
 436 {
 437   GtkTreeModel *model;
 438   GtkTreeIter iter;
 439   GtkAdjustment *vadj;
 440   GValue value = {0};
 441   double y, min, max;
 442
 443   model = gtk_tree_view_get_model (overview);
 444   if (!gtk_tree_model_get_iter (model, &iter, path))
 445     return;
 446
 447   gtk_tree_model_get_value (model, &iter, COL_Y, &value);
 448   y = g_value_get_long (&value);
 449   g_value_unset (&value);
 450
 451   vadj = gtk_layout_get_vadjustment (window->output);
 452   min = gtk_adjustment_get_lower (vadj);
 453   max = gtk_adjustment_get_upper (vadj) - gtk_adjustment_get_page_size (vadj);
 454   if (y < min)
 455     y = min;
 456   else if (y > max)
 457     y = max;
 458   gtk_adjustment_set_value (vadj, y);
 459 }
 460
 461 static void psppire_output_window_print (PsppireOutputWindow *window);
 462
 463
 464 static void
 465 export_output (PsppireOutputWindow *window, struct string_map *options,
 466                const char *format)
 467 {
 468   struct output_driver *driver;
 469   size_t i;
 470
 471   string_map_insert (options, "format", format);
 472   driver = output_driver_create (options);
 473   if (driver == NULL)
 474     return;
 475
 476   for (i = 0; i < window->n_items; i++)
 477     driver->class->submit (driver, window->items[i]);
 478   output_driver_destroy (driver);
 479 }
 480
 481
 482 struct file_types
 483 {
 484   const gchar *label;
 485   const gchar *ext;
 486 };
 487
 488 enum
 489   {
 490     FT_AUTO = 0,
 491     FT_PDF,
 492     FT_HTML,
 493     FT_ODT,
 494     FT_TXT,
 495     FT_PS,
 496     FT_CSV,
 497     n_FT
 498   };
 499
 500 #define N_EXTENSIONS (n_FT - 1)
 501
 502 struct file_types ft[n_FT] = {
 503   {N_("Infer file type from extension"),  NULL},
 504   {N_("PDF (*.pdf)"),                     ".pdf"},
 505   {N_("HTML (*.html)"),                   ".html"},
 506   {N_("OpenDocument (*.odt)"),            ".odt"},
 507   {N_("Text (*.txt)"),                    ".txt"},
 508   {N_("PostScript (*.ps)"),               ".ps"},
 509   {N_("Comma-Separated Values (*.csv)"),  ".csv"}
 510 };
 511
 512
 513 static void
 514 on_combo_change (GtkFileChooser *chooser)
 515 {
 516   gboolean sensitive = FALSE;
 517   GtkWidget *combo = gtk_file_chooser_get_extra_widget (chooser);
 518
 519   int x = 0;
 520   gchar *fn = gtk_file_chooser_get_filename (chooser);
 521
 522   if (combo &&  gtk_widget_get_realized (combo))
 523     x = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));
 524
 525   if (fn == NULL)
 526     {
 527       sensitive = FALSE;
 528     }
 529   else
 530     {
 531       gint i;
 532       if ( x != 0 )
 533         sensitive = TRUE;
 534
 535       for (i = 1 ; i < N_EXTENSIONS ; ++i)
 536         {
 537           if ( g_str_has_suffix (fn, ft[i].ext))
 538             {
 539               sensitive = TRUE;
 540               break;
 541             }
 542         }
 543     }
 544
 545   g_free (fn);
 546
 547   gtk_dialog_set_response_sensitive (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT, sensitive);
 548 }
 549
 550
 551 static void
 552 on_file_chooser_change (GObject *w, GParamSpec *pspec, gpointer data)
 553 {
 554
 555   GtkFileChooser *chooser = data;
 556   const gchar *name = g_param_spec_get_name (pspec);
 557
 558   if ( ! gtk_widget_get_realized (GTK_WIDGET (chooser)))
 559     return;
 560
 561   /* Ignore this one.  It causes recursion. */
 562   if ( 0 == strcmp ("tooltip-text", name))
 563     return;
 564
 565   on_combo_change (chooser);
 566 }
 567
 568
 569 /* Recursively descend all the children of W, connecting
 570    to their "notify" signal */
 571 static void
 572 iterate_widgets (GtkWidget *w, gpointer data)
 573 {
 574   if ( GTK_IS_CONTAINER (w))
 575     gtk_container_forall (GTK_CONTAINER (w), iterate_widgets, data);
 576   else
 577     g_signal_connect (w, "notify",  G_CALLBACK (on_file_chooser_change), data);
 578 }
 579
 580
 581
 582 static GtkListStore *
 583 create_file_type_list (void)
 584 {
 585   int i;
 586   GtkTreeIter iter;
 587   GtkListStore *list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
 588
 589   for (i = 0 ; i < n_FT ; ++i)
 590     {
 591       gtk_list_store_append (list, &iter);
 592       gtk_list_store_set (list, &iter,
 593                           0,  gettext (ft[i].label),
 594                           1,  ft[i].ext,
 595                           -1);
 596     }
 597
 598   return list;
 599 }
 600
 601 static void
 602 psppire_output_window_export (PsppireOutputWindow *window)
 603 {
 604   gint response;
 605   GtkWidget *combo;
 606   GtkListStore *list;
 607
 608   GtkFileChooser *chooser;
 609
 610   GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Export Output"),
 611                                         GTK_WINDOW (window),
 612                                         GTK_FILE_CHOOSER_ACTION_SAVE,
 613                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 614                                         GTK_STOCK_SAVE,   GTK_RESPONSE_ACCEPT,
 615                                         NULL);
 616
 617   g_object_set (dialog, "local-only", FALSE, NULL);
 618
 619   chooser = GTK_FILE_CHOOSER (dialog);
 620
 621   list = create_file_type_list ();
 622
 623   combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (list));
 624
 625
 626   {
 627     /* Create text cell renderer */
 628     GtkCellRenderer *cell = gtk_cell_renderer_text_new();
 629     gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, FALSE );
 630
 631     gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), cell,  "text", 0);
 632   }
 633
 634   g_signal_connect_swapped (combo, "changed", G_CALLBACK (on_combo_change), chooser);
 635
 636   gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
 637
 638   gtk_file_chooser_set_extra_widget (chooser, combo);
 639
 640   /* This kludge is necessary because there is no signal to tell us
 641      when the candidate filename of a GtkFileChooser has changed */
 642   gtk_container_forall (GTK_CONTAINER (dialog), iterate_widgets, dialog);
 643
 644
 645   gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
 646
 647   response = gtk_dialog_run (GTK_DIALOG (dialog));
 648
 649   if ( response == GTK_RESPONSE_ACCEPT )
 650     {
 651       gint file_type = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));
 652       gchar *filename = gtk_file_chooser_get_filename (chooser);
 653       struct string_map options;
 654
 655       g_return_if_fail (filename);
 656
 657       if (file_type == FT_AUTO)
 658         {
 659           /* If the "Infer file type from extension" option was chosen,
 660              search for the respective type in the list.
 661              (It's a O(n) search, but fortunately n is small). */
 662           gint i;
 663           for (i = 1 ; i < N_EXTENSIONS ; ++i)
 664             {
 665               if ( g_str_has_suffix (filename, ft[i].ext))
 666                 {
 667                   file_type = i;
 668                   break;
 669                 }
 670             }
 671         }
 672       else if (! g_str_has_suffix (filename, ft[file_type].ext))
 673         {
 674           /* If an explicit document format was chosen, and if the chosen
 675              filename does not already have that particular "extension",
 676              then append it.
 677            */
 678
 679           gchar *of = filename;
 680           filename = g_strconcat (filename, ft[file_type].ext, NULL);
 681           g_free (of);
 682         }
 683
 684       string_map_init (&options);
 685       string_map_insert (&options, "output-file", filename);
 686
 687       switch (file_type)
 688         {
 689         case FT_PDF:
 690           export_output (window, &options, "pdf");
 691           break;
 692         case FT_HTML:
 693           export_output (window, &options, "html");
 694           break;
 695         case FT_ODT:
 696           export_output (window, &options, "odt");
 697           break;
 698         case FT_PS:
 699           export_output (window, &options, "ps");
 700           break;
 701         case FT_CSV:
 702           export_output (window, &options, "csv");
 703           break;
 704
 705         case FT_TXT:
 706           string_map_insert (&options, "headers", "false");
 707           string_map_insert (&options, "paginate", "false");
 708           string_map_insert (&options, "squeeze", "true");
 709           string_map_insert (&options, "emphasis", "none");
 710           string_map_insert (&options, "charts", "none");
 711           string_map_insert (&options, "top-margin", "0");
 712           string_map_insert (&options, "bottom-margin", "0");
 713           export_output (window, &options, "txt");
 714           break;
 715         default:
 716           g_assert_not_reached ();
 717         }
 718
 719       string_map_destroy (&options);
 720
 721       free (filename);
 722     }
 723
 724   gtk_widget_destroy (dialog);
 725 }
 726
 727
 728 enum {
 729   SELECT_FMT_NULL,
 730   SELECT_FMT_TEXT,
 731   SELECT_FMT_UTF8,
 732   SELECT_FMT_HTML,
 733   SELECT_FMT_ODT
 734 };
 735
 736 /* GNU Hurd doesn't have PATH_MAX.  Use a fallback.
 737    Temporary directory names are usually not that long.  */
 738 #ifndef PATH_MAX
 739 # define PATH_MAX 1024
 740 #endif
 741
 742 static void
 743 clipboard_get_cb (GtkClipboard     *clipboard,
 744                   GtkSelectionData *selection_data,
 745                   guint             info,
 746                   gpointer          data)
 747 {
 748   PsppireOutputWindow *window = data;
 749
 750   gsize length;
 751   gchar *text = NULL;
 752   struct output_driver *driver = NULL;
 753   char dirname[PATH_MAX], *filename;
 754   struct string_map options;
 755
 756   GtkTreeSelection *sel = gtk_tree_view_get_selection (window->overview);
 757   GtkTreeModel *model = gtk_tree_view_get_model (window->overview);
 758
 759   GList *rows = gtk_tree_selection_get_selected_rows (sel, &model);
 760   GList *n = rows;
 761
 762   if ( n == NULL)
 763     return;
 764
 765   if (path_search (dirname, sizeof dirname, NULL, NULL, true)
 766       || mkdtemp (dirname) == NULL)
 767     {
 768       msg_error (errno, _("failed to create temporary directory during clipboard operation"));
 769       return;
 770     }
 771   filename = xasprintf ("%s/clip.tmp", dirname);
 772
 773   string_map_init (&options);
 774   string_map_insert (&options, "output-file", filename);
 775
 776   switch (info)
 777     {
 778     case SELECT_FMT_UTF8:
 779       string_map_insert (&options, "box", "unicode");
 780       /* fall-through */
 781
 782     case SELECT_FMT_TEXT:
 783       string_map_insert (&options, "format", "txt");
 784       break;
 785
 786     case SELECT_FMT_HTML:
 787       string_map_insert (&options, "format", "html");
 788       string_map_insert (&options, "borders", "false");
 789       string_map_insert (&options, "css", "false");
 790       break;
 791
 792     case SELECT_FMT_ODT:
 793       string_map_insert (&options, "format", "odt");
 794       break;
 795
 796     default:
 797       g_warning ("unsupported clip target\n");
 798       goto finish;
 799       break;
 800     }
 801
 802   driver = output_driver_create (&options);
 803   if (driver == NULL)
 804     goto finish;
 805
 806   while (n)
 807     {
 808       GtkTreePath *path = n->data ;
 809       GtkTreeIter iter;
 810       struct output_item *item ;
 811
 812       gtk_tree_model_get_iter (model, &iter, path);
 813       gtk_tree_model_get (model, &iter, COL_ADDR, &item, -1);
 814
 815       driver->class->submit (driver, item);
 816
 817       n = n->next;
 818     }
 819
 820   if ( driver->class->flush)
 821     driver->class->flush (driver);
 822
 823
 824   /* Some drivers (eg: the odt one) don't write anything until they
 825      are closed */
 826   output_driver_destroy (driver);
 827   driver = NULL;
 828
 829   if ( g_file_get_contents (filename, &text, &length, NULL) )
 830     {
 831       gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data),
 832                               8,
 833                               (const guchar *) text, length);
 834     }
 835
 836  finish:
 837
 838   if (driver != NULL)
 839     output_driver_destroy (driver);
 840
 841   g_free (text);
 842
 843   unlink (filename);
 844   free (filename);
 845   rmdir (dirname);
 846
 847   g_list_free (rows);
 848 }
 849
 850 static void
 851 clipboard_clear_cb (GtkClipboard *clipboard,
 852                     gpointer data)
 853 {
 854 }
 855
 856 static const GtkTargetEntry targets[] = {
 857
 858   { "STRING",        0, SELECT_FMT_TEXT },
 859   { "TEXT",          0, SELECT_FMT_TEXT },
 860   { "COMPOUND_TEXT", 0, SELECT_FMT_TEXT },
 861   { "text/plain",    0, SELECT_FMT_TEXT },
 862
 863   { "UTF8_STRING",   0, SELECT_FMT_UTF8 },
 864   { "text/plain;charset=utf-8", 0, SELECT_FMT_UTF8 },
 865
 866   { "text/html",     0, SELECT_FMT_HTML },
 867
 868   { "application/vnd.oasis.opendocument.text", 0, SELECT_FMT_ODT }
 869 };
 870
 871 static void
 872 on_copy (PsppireOutputWindow *window)
 873 {
 874   {
 875     GtkClipboard *clipboard =
 876       gtk_widget_get_clipboard (GTK_WIDGET (window),
 877                                 GDK_SELECTION_CLIPBOARD);
 878
 879     if (!gtk_clipboard_set_with_data (clipboard, targets,
 880                                        G_N_ELEMENTS (targets),
 881                                        clipboard_get_cb, clipboard_clear_cb,
 882                                       window))
 883
 884       clipboard_clear_cb (clipboard, window);
 885   }
 886 }
 887
 888 static void
 889 on_selection_change (GtkTreeSelection *sel, GtkAction *copy_action)
 890 {
 891   /* The Copy action is available only if there is something selected */
 892   gtk_action_set_sensitive (copy_action, gtk_tree_selection_count_selected_rows (sel) > 0);
 893 }
 894
 895 static void
 896 on_select_all (PsppireOutputWindow *window)
 897 {
 898   GtkTreeSelection *sel = gtk_tree_view_get_selection (window->overview);
 899   gtk_tree_view_expand_all (window->overview);
 900   gtk_tree_selection_select_all (sel);
 901 }
 902
 903
 904 static void
 905 copy_base_to_bg (GtkWidget *dest, GtkWidget *src)
 906 {
 907   int i;
 908   for (i = 0; i < 5; ++i)
 909     {
 910       GdkColor *col = &gtk_widget_get_style (src)->base[i];
 911       gtk_widget_modify_bg (dest, i, col);
 912
 913       col = &gtk_widget_get_style (src)->text[i];
 914       gtk_widget_modify_fg (dest, i, col);
 915     }
 916 }
 917
 918 static void
 919 on_dwgarea_realize (GtkWidget *dwg_area, gpointer data)
 920 {
 921   GtkWidget *viewer = GTK_WIDGET (data);
 922
 923   copy_base_to_bg (dwg_area, viewer);
 924 }
 925
 926
 927 static void
 928 psppire_output_window_style_set (GtkWidget *w, GtkStyle *prev)
 929 {
 930   GtkWidget *op = GTK_WIDGET (PSPPIRE_OUTPUT_WINDOW (w)->output);
 931
 932   /* Copy the base style from the parent widget to the container and
 933      all its children.
 934      We do this, because the container's primary purpose is to
 935      display text.  This way psppire appears to follow the chosen
 936      gnome theme.
 937    */
 938   copy_base_to_bg (op, w);
 939   gtk_container_foreach (GTK_CONTAINER (op), (GtkCallback) copy_base_to_bg,
 940                          PSPPIRE_OUTPUT_WINDOW (w)->output);
 941
 942     /* Chain up to the parent class */
 943   GTK_WIDGET_CLASS (parent_class)->style_set (w, prev);
 944 }
 945
 946 static void
 947 psppire_output_window_init (PsppireOutputWindow *window)
 948 {
 949   GtkTreeViewColumn *column;
 950   GtkCellRenderer *renderer;
 951   GtkBuilder *xml;
 952   GtkAction *copy_action;
 953   GtkAction *select_all_action;
 954   GtkTreeSelection *sel;
 955   GtkTreeModel *model;
 956
 957   string_map_init (&window->render_opts);
 958
 959   xml = builder_new ("output-viewer.ui");
 960
 961   copy_action = get_action_assert (xml, "edit_copy");
 962   select_all_action = get_action_assert (xml, "edit_select-all");
 963
 964   gtk_action_set_sensitive (copy_action, FALSE);
 965
 966   g_signal_connect_swapped (copy_action, "activate", G_CALLBACK (on_copy), window);
 967
 968   g_signal_connect_swapped (select_all_action, "activate", G_CALLBACK (on_select_all), window);
 969
 970   gtk_widget_reparent (get_widget_assert (xml, "vbox1"), GTK_WIDGET (window));
 971
 972   window->output = GTK_LAYOUT (get_widget_assert (xml, "output"));
 973   window->y = 0;
 974   window->print_settings = NULL;
 975   window->dispose_has_run = FALSE;
 976
 977   window->overview = GTK_TREE_VIEW (get_widget_assert (xml, "overview"));
 978
 979   sel = gtk_tree_view_get_selection (window->overview);
 980
 981   gtk_tree_selection_set_mode (sel, GTK_SELECTION_MULTIPLE);
 982
 983   g_signal_connect (sel, "changed", G_CALLBACK (on_selection_change), copy_action);
 984
 985   model = GTK_TREE_MODEL (gtk_tree_store_new (
 986                                              N_COLS,
 987                                              G_TYPE_STRING,  /* COL_TITLE */
 988                                              G_TYPE_POINTER, /* COL_ADDR */
 989                                              G_TYPE_LONG));  /* COL_Y */
 990   gtk_tree_view_set_model (window->overview, model);
 991   g_object_unref (model);
 992
 993   window->in_command = false;
 994
 995   window->items = NULL;
 996   window->n_items = window->allocated_items = 0;
 997
 998   column = gtk_tree_view_column_new ();
 999   gtk_tree_view_append_column (GTK_TREE_VIEW (window->overview), column);
1000   renderer = gtk_cell_renderer_text_new ();
1001   gtk_tree_view_column_pack_start (column, renderer, TRUE);
1002   gtk_tree_view_column_add_attribute (column, renderer, "text", COL_TITLE);
1003
1004   g_signal_connect (GTK_TREE_VIEW (window->overview),
1005                     "row-activated", G_CALLBACK (on_row_activate), window);
1006
1007   connect_help (xml);
1008
1009   g_signal_connect (window,
1010                     "focus-in-event",
1011                     G_CALLBACK (cancel_urgency),
1012                     NULL);
1013
1014   g_signal_connect (get_action_assert (xml,"windows_minimise-all"),
1015                     "activate",
1016                     G_CALLBACK (psppire_window_minimise_all),
1017                     NULL);
1018
1019   {
1020     GtkWidget *w;
1021     GtkUIManager *uim = GTK_UI_MANAGER (get_object_assert (xml, "uimanager1", GTK_TYPE_UI_MANAGER));
1022     merge_help_menu (uim);
1023
1024     w = gtk_ui_manager_get_widget (uim,"/ui/menubar/windows_menuitem/windows_minimise-all");
1025
1026     PSPPIRE_WINDOW (window)->menu =
1027       GTK_MENU_SHELL (gtk_widget_get_parent (w));
1028   }
1029
1030   g_signal_connect_swapped (get_action_assert (xml, "file_export"), "activate",
1031                             G_CALLBACK (psppire_output_window_export), window);
1032
1033
1034   g_signal_connect_swapped (get_action_assert (xml, "file_print"), "activate",
1035                             G_CALLBACK (psppire_output_window_print), window);
1036
1037   g_object_unref (xml);
1038
1039   g_signal_connect (window, "delete-event",
1040                     G_CALLBACK (on_delete), window);
1041 }
1042
1043
1044 GtkWidget*
1045 psppire_output_window_new (void)
1046 {
1047   return GTK_WIDGET (g_object_new (psppire_output_window_get_type (),
1048                                    /* TRANSLATORS: This will form a filename.  Please avoid whitespace. */
1049                                    "filename", _("Output"),
1050                                    "description", _("Output Viewer"),
1051                                    NULL));
1052 }
1053
1054 \f
1055
1056 static cairo_t *
1057 get_cairo_context_from_print_context (GtkPrintContext *context)
1058 {
1059   cairo_t *cr = gtk_print_context_get_cairo_context (context);
1060
1061   /*
1062     For all platforms except windows, gtk_print_context_get_dpi_[xy] returns 72.
1063     Windows returns 600.
1064   */
1065   double xres = gtk_print_context_get_dpi_x (context);
1066   double yres = gtk_print_context_get_dpi_y (context);
1067
1068   /* This means that the cairo context now has its dimensions in Points */
1069   cairo_scale (cr, xres / 72.0, yres / 72.0);
1070
1071   return cr;
1072 }
1073
1074
1075 static void
1076 create_xr_print_driver (GtkPrintContext *context, PsppireOutputWindow *window)
1077 {
1078   struct string_map options;
1079   GtkPageSetup *page_setup;
1080   double width, height;
1081   double left_margin;
1082   double right_margin;
1083   double top_margin;
1084   double bottom_margin;
1085
1086   page_setup = gtk_print_context_get_page_setup (context);
1087   width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM);
1088   height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM);
1089   left_margin = gtk_page_setup_get_left_margin (page_setup, GTK_UNIT_MM);
1090   right_margin = gtk_page_setup_get_right_margin (page_setup, GTK_UNIT_MM);
1091   top_margin = gtk_page_setup_get_top_margin (page_setup, GTK_UNIT_MM);
1092   bottom_margin = gtk_page_setup_get_bottom_margin (page_setup, GTK_UNIT_MM);
1093
1094   string_map_init (&options);
1095   string_map_insert_nocopy (&options, xstrdup ("paper-size"),
1096                             c_xasprintf("%.2fx%.2fmm", width, height));
1097   string_map_insert_nocopy (&options, xstrdup ("left-margin"),
1098                             c_xasprintf ("%.2fmm", left_margin));
1099   string_map_insert_nocopy (&options, xstrdup ("right-margin"),
1100                             c_xasprintf ("%.2fmm", right_margin));
1101   string_map_insert_nocopy (&options, xstrdup ("top-margin"),
1102                             c_xasprintf ("%.2fmm", top_margin));
1103   string_map_insert_nocopy (&options, xstrdup ("bottom-margin"),
1104                             c_xasprintf ("%.2fmm", bottom_margin));
1105
1106   window->print_xrd = xr_driver_create (get_cairo_context_from_print_context (context), &options);
1107
1108   string_map_destroy (&options);
1109 }
1110
1111 static gboolean
1112 paginate (GtkPrintOperation *operation,
1113           GtkPrintContext   *context,
1114           PsppireOutputWindow *window)
1115 {
1116   if (window->paginated)
1117     {
1118       /* Sometimes GTK+ emits this signal again even after pagination is
1119          complete.  Don't let that screw up printing. */
1120       return TRUE;
1121     }
1122   else if ( window->print_item < window->n_items )
1123     {
1124       xr_driver_output_item (window->print_xrd, window->items[window->print_item++]);
1125       while (xr_driver_need_new_page (window->print_xrd))
1126         {
1127           xr_driver_next_page (window->print_xrd, NULL);
1128           window->print_n_pages ++;
1129         }
1130       return FALSE;
1131     }
1132   else
1133     {
1134       gtk_print_operation_set_n_pages (operation, window->print_n_pages);
1135
1136       /* Re-create the driver to do the real printing. */
1137       xr_driver_destroy (window->print_xrd);
1138       create_xr_print_driver (context, window);
1139       window->print_item = 0;
1140       window->paginated = TRUE;
1141
1142       return TRUE;
1143     }
1144 }
1145
1146 static void
1147 begin_print (GtkPrintOperation *operation,
1148              GtkPrintContext   *context,
1149              PsppireOutputWindow *window)
1150 {
1151   create_xr_print_driver (context, window);
1152
1153   window->print_item = 0;
1154   window->print_n_pages = 1;
1155   window->paginated = FALSE;
1156 }
1157
1158 static void
1159 end_print (GtkPrintOperation *operation,
1160            GtkPrintContext   *context,
1161            PsppireOutputWindow *window)
1162 {
1163   xr_driver_destroy (window->print_xrd);
1164 }
1165
1166
1167 static void
1168 draw_page (GtkPrintOperation *operation,
1169            GtkPrintContext   *context,
1170            gint               page_number,
1171            PsppireOutputWindow *window)
1172 {
1173   xr_driver_next_page (window->print_xrd, get_cairo_context_from_print_context (context));
1174   while (!xr_driver_need_new_page (window->print_xrd)
1175          && window->print_item < window->n_items)
1176     xr_driver_output_item (window->print_xrd, window->items [window->print_item++]);
1177 }
1178
1179
1180 static void
1181 psppire_output_window_print (PsppireOutputWindow *window)
1182 {
1183   GtkPrintOperationResult res;
1184
1185   GtkPrintOperation *print = gtk_print_operation_new ();
1186
1187   if (window->print_settings != NULL)
1188     gtk_print_operation_set_print_settings (print, window->print_settings);
1189
1190   g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), window);
1191   g_signal_connect (print, "end_print",   G_CALLBACK (end_print),   window);
1192   g_signal_connect (print, "paginate",    G_CALLBACK (paginate),    window);
1193   g_signal_connect (print, "draw_page",   G_CALLBACK (draw_page),   window);
1194
1195   res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
1196                                  GTK_WINDOW (window), NULL);
1197
1198   if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
1199     {
1200       if (window->print_settings != NULL)
1201         g_object_unref (window->print_settings);
1202       window->print_settings = g_object_ref (gtk_print_operation_get_print_settings (print));
1203     }
1204
1205   g_object_unref (print);
1206 }