src/ui/gui/psppire-output-window.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2008, 2009  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 <gtk/gtksignal.h>
  20 #include <gtk/gtkbox.h>
  21 #include "helper.h"
  22
  23 #include <libpspp/cast.h>
  24 #include <libpspp/message.h>
  25 #include <output/cairo.h>
  26 #include <output/driver-provider.h>
  27 #include <output/tab.h>
  28 #include <stdlib.h>
  29
  30 #include "about.h"
  31
  32 #include "psppire-output-window.h"
  33
  34
  35 #include "xalloc.h"
  36
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <unistd.h>
  40
  41 #include <gettext.h>
  42 #define _(msgid) gettext (msgid)
  43 #define N_(msgid) msgid
  44
  45 enum
  46   {
  47     COL_TITLE,                  /* Table title. */
  48     COL_Y,                      /* Y position of top of title. */
  49     N_COLS
  50   };
  51
  52 static void psppire_output_window_base_finalize (PsppireOutputWindowClass *, gpointer);
  53 static void psppire_output_window_base_init     (PsppireOutputWindowClass *class);
  54 static void psppire_output_window_class_init    (PsppireOutputWindowClass *class);
  55 static void psppire_output_window_init          (PsppireOutputWindow      *window);
  56
  57
  58 GType
  59 psppire_output_window_get_type (void)
  60 {
  61   static GType psppire_output_window_type = 0;
  62
  63   if (!psppire_output_window_type)
  64     {
  65       static const GTypeInfo psppire_output_window_info =
  66       {
  67         sizeof (PsppireOutputWindowClass),
  68         (GBaseInitFunc) psppire_output_window_base_init,
  69         (GBaseFinalizeFunc) psppire_output_window_base_finalize,
  70         (GClassInitFunc)psppire_output_window_class_init,
  71         (GClassFinalizeFunc) NULL,
  72         NULL,
  73         sizeof (PsppireOutputWindow),
  74         0,
  75         (GInstanceInitFunc) psppire_output_window_init,
  76       };
  77
  78       psppire_output_window_type =
  79         g_type_register_static (PSPPIRE_TYPE_WINDOW, "PsppireOutputWindow",
  80                                 &psppire_output_window_info, 0);
  81     }
  82
  83   return psppire_output_window_type;
  84 }
  85
  86 static GObjectClass *parent_class;
  87
  88 static void
  89 psppire_output_window_finalize (GObject *object)
  90 {
  91   if (G_OBJECT_CLASS (parent_class)->finalize)
  92     (*G_OBJECT_CLASS (parent_class)->finalize) (object);
  93 }
  94
  95
  96 static void
  97 psppire_output_window_class_init (PsppireOutputWindowClass *class)
  98 {
  99   parent_class = g_type_class_peek_parent (class);
 100 }
 101
 102
 103 static void
 104 psppire_output_window_base_init (PsppireOutputWindowClass *class)
 105 {
 106   GObjectClass *object_class = G_OBJECT_CLASS (class);
 107
 108   object_class->finalize = psppire_output_window_finalize;
 109 }
 110
 111
 112
 113 static void
 114 psppire_output_window_base_finalize (PsppireOutputWindowClass *class,
 115                                      gpointer class_data)
 116 {
 117 }
 118 \f
 119 /* Output driver class. */
 120
 121 struct psppire_output_driver
 122   {
 123     struct output_driver driver;
 124     PsppireOutputWindow *viewer;
 125     struct xr_driver *xr;
 126   };
 127
 128 static struct output_driver_class psppire_output_class;
 129
 130 static struct psppire_output_driver *
 131 psppire_output_cast (struct output_driver *driver)
 132 {
 133   assert (driver->class == &psppire_output_class);
 134   return UP_CAST (driver, struct psppire_output_driver, driver);
 135 }
 136
 137 static gboolean
 138 expose_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data)
 139 {
 140   struct xr_rendering *r = g_object_get_data (G_OBJECT (widget), "rendering");
 141   cairo_t *cr;
 142
 143   cr = gdk_cairo_create (widget->window);
 144   xr_rendering_draw (r, cr);
 145   cairo_destroy (cr);
 146
 147   return TRUE;
 148 }
 149
 150 static void
 151 psppire_output_submit (struct output_driver *this,
 152                        const struct output_item *item)
 153 {
 154   struct psppire_output_driver *pod = psppire_output_cast (this);
 155   GtkWidget *drawing_area;
 156   struct xr_rendering *r;
 157   cairo_t *cr;
 158   int tw, th;
 159
 160   if (pod->viewer == NULL)
 161     {
 162       pod->viewer = PSPPIRE_OUTPUT_WINDOW (psppire_output_window_new ());
 163       gtk_widget_show_all (GTK_WIDGET (pod->viewer));
 164       pod->viewer->driver = pod;
 165     }
 166
 167   cr = gdk_cairo_create (GTK_WIDGET (pod->viewer)->window);
 168   if (pod->xr == NULL)
 169     pod->xr = xr_create_driver (cr);
 170
 171   r = xr_rendering_create (pod->xr, item, cr);
 172   if (r == NULL)
 173     goto done;
 174
 175   xr_rendering_measure (r, &tw, &th);
 176
 177   drawing_area = gtk_drawing_area_new ();
 178   gtk_widget_modify_bg (
 179     GTK_WIDGET (drawing_area), GTK_STATE_NORMAL,
 180     &gtk_widget_get_style (drawing_area)->base[GTK_STATE_NORMAL]);
 181   g_object_set_data (G_OBJECT (drawing_area), "rendering", r);
 182   gtk_widget_set_size_request (drawing_area, tw, th);
 183   gtk_layout_put (pod->viewer->output, drawing_area, 0, pod->viewer->y);
 184   gtk_widget_show (drawing_area);
 185   g_signal_connect (G_OBJECT (drawing_area), "expose_event",
 186                      G_CALLBACK (expose_event_callback), NULL);
 187
 188   if (pod->viewer->max_width < tw)
 189     pod->viewer->max_width = tw;
 190   pod->viewer->y += th;
 191
 192   gtk_layout_set_size (pod->viewer->output,
 193                        pod->viewer->max_width, pod->viewer->y);
 194
 195   gtk_window_set_urgency_hint (GTK_WINDOW (pod->viewer), TRUE);
 196
 197 done:
 198   cairo_destroy (cr);
 199 }
 200
 201 static struct output_driver_class psppire_output_class =
 202   {
 203     "PSPPIRE",                  /* name */
 204     NULL,                       /* create */
 205     NULL,                       /* destroy */
 206     psppire_output_submit,      /* submit */
 207     NULL,                       /* flush */
 208   };
 209
 210 void
 211 psppire_output_window_setup (void)
 212 {
 213   struct psppire_output_driver *pod;
 214   struct output_driver *d;
 215
 216   pod = xzalloc (sizeof *pod);
 217   d = &pod->driver;
 218   output_driver_init (d, &psppire_output_class, "PSPPIRE", 0);
 219   output_driver_register (d);
 220 }
 221 \f
 222 int viewer_length = 16;
 223 int viewer_width = 59;
 224
 225 /* Callback for the "delete" action (clicking the x on the top right
 226    hand corner of the window) */
 227 static gboolean
 228 on_delete (GtkWidget *w, GdkEvent *event, gpointer user_data)
 229 {
 230   PsppireOutputWindow *ow = PSPPIRE_OUTPUT_WINDOW (user_data);
 231
 232   gtk_widget_destroy (GTK_WIDGET (ow));
 233
 234   ow->driver->viewer = NULL;
 235
 236   return FALSE;
 237 }
 238
 239
 240
 241 static void
 242 cancel_urgency (GtkWindow *window,  gpointer data)
 243 {
 244   gtk_window_set_urgency_hint (window, FALSE);
 245 }
 246
 247 static void
 248 on_row_activate (GtkTreeView *overview,
 249                  GtkTreePath *path,
 250                  GtkTreeViewColumn *column,
 251                  PsppireOutputWindow *window)
 252 {
 253   GtkTreeModel *model;
 254   GtkTreeIter iter;
 255   GtkAdjustment *vadj;
 256   GValue value = {0};
 257   double y, min, max;
 258
 259   model = gtk_tree_view_get_model (overview);
 260   if (!gtk_tree_model_get_iter (model, &iter, path))
 261     return;
 262
 263   gtk_tree_model_get_value (model, &iter, COL_Y, &value);
 264   y = g_value_get_long (&value);
 265   g_value_unset (&value);
 266
 267   vadj = gtk_layout_get_vadjustment (window->output);
 268   min = vadj->lower;
 269   max = vadj->upper - vadj->page_size;
 270   if (y < min)
 271     y = min;
 272   else if (y > max)
 273     y = max;
 274   gtk_adjustment_set_value (vadj, y);
 275 }
 276
 277 static void
 278 psppire_output_window_init (PsppireOutputWindow *window)
 279 {
 280   GtkTreeViewColumn *column;
 281   GtkCellRenderer *renderer;
 282   GtkBuilder *xml;
 283
 284   xml = builder_new ("output-viewer.ui");
 285
 286   gtk_widget_reparent (get_widget_assert (xml, "vbox1"), GTK_WIDGET (window));
 287
 288   window->output = GTK_LAYOUT (get_widget_assert (xml, "output"));
 289   window->y = 0;
 290
 291   window->overview = GTK_TREE_VIEW (get_widget_assert (xml, "overview"));
 292   gtk_tree_view_set_model (window->overview,
 293                            GTK_TREE_MODEL (gtk_tree_store_new (
 294                                              N_COLS,
 295                                              G_TYPE_STRING, /* COL_TITLE */
 296                                              G_TYPE_LONG))); /* COL_Y */
 297   window->last_table_num = -1;
 298
 299   column = gtk_tree_view_column_new ();
 300   gtk_tree_view_append_column (GTK_TREE_VIEW (window->overview), column);
 301   renderer = gtk_cell_renderer_text_new ();
 302   gtk_tree_view_column_pack_start (column, renderer, TRUE);
 303   gtk_tree_view_column_add_attribute (column, renderer, "text", COL_TITLE);
 304
 305   g_signal_connect (GTK_TREE_VIEW (window->overview),
 306                     "row-activated", G_CALLBACK (on_row_activate), window);
 307
 308   gtk_widget_modify_bg (GTK_WIDGET (window->output), GTK_STATE_NORMAL,
 309                         &gtk_widget_get_style (GTK_WIDGET (window->output))->base[GTK_STATE_NORMAL]);
 310
 311   connect_help (xml);
 312
 313   g_signal_connect (window,
 314                     "focus-in-event",
 315                     G_CALLBACK (cancel_urgency),
 316                     NULL);
 317
 318   g_signal_connect (get_action_assert (xml,"help_about"),
 319                     "activate",
 320                     G_CALLBACK (about_new),
 321                     window);
 322
 323   g_signal_connect (get_action_assert (xml,"help_reference"),
 324                     "activate",
 325                     G_CALLBACK (reference_manual),
 326                     NULL);
 327
 328   g_signal_connect (get_action_assert (xml,"windows_minimise-all"),
 329                     "activate",
 330                     G_CALLBACK (psppire_window_minimise_all),
 331                     NULL);
 332
 333   {
 334     GtkUIManager *uim = GTK_UI_MANAGER (get_object_assert (xml, "uimanager1", GTK_TYPE_UI_MANAGER));
 335
 336     PSPPIRE_WINDOW (window)->menu =
 337       GTK_MENU_SHELL (gtk_ui_manager_get_widget (uim,"/ui/menubar1/windows_menuitem/windows_minimise-all")->parent);
 338   }
 339
 340   g_object_unref (xml);
 341
 342   g_signal_connect (window, "delete-event",
 343                     G_CALLBACK (on_delete), window);
 344 }
 345
 346
 347 GtkWidget*
 348 psppire_output_window_new (void)
 349 {
 350   return GTK_WIDGET (g_object_new (psppire_output_window_get_type (),
 351                                    "filename", "Output",
 352                                    "description", _("Output Viewer"),
 353                                    NULL));
 354 }