src/ui/gui/helper.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2007, 2009, 2010, 2011  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
  18 /* This file is a rubbish bin where stuff gets put when it doesn't seem to
  19    belong anywhere else.
  20 */
  21 #include <config.h>
  22
  23 #include        <glib-object.h>
  24
  25 #include <glib.h>
  26 #include "helper.h"
  27 #include <data/format.h>
  28 #include <data/data-in.h>
  29 #include <data/data-out.h>
  30 #include <data/dictionary.h>
  31 #include <data/casereader-provider.h>
  32 #include <libpspp/message.h>
  33 #include "psppire-syntax-window.h"
  34 #include <gtk/gtk.h>
  35 #include <libpspp/i18n.h>
  36
  37 #include <ctype.h>
  38 #include <string.h>
  39 #include <stdlib.h>
  40 #include <data/settings.h>
  41
  42 #include "psppire-data-store.h"
  43 #include "psppire.h"
  44
  45 #include "gl/configmake.h"
  46 #include "xalloc.h"
  47
  48 #include <gettext.h>
  49
  50 /* Formats a value according to VAR's print format and strips white space
  51    appropriately for VAR's type.  That is, if VAR is numeric, strips leading
  52    white space (because numbers are right-justified within their fields), and
  53    if VAR is string, strips trailing white space (because spaces pad out string
  54    values on the right).
  55
  56    Returns an allocated string.  The returned string must be freed when no
  57    longer required. */
  58 gchar *
  59 value_to_text (union value v, const struct variable *var)
  60 {
  61   gchar *s;
  62
  63   s = data_out (&v, var_get_encoding (var), var_get_print_format (var));
  64   if (var_is_numeric (var))
  65     g_strchug (s);
  66   else
  67     g_strchomp (s);
  68
  69   return s;
  70 }
  71
  72
  73 /* Converts TEXT to a value.
  74
  75    VAL will be initialised and filled by this function.
  76    It is the caller's responsibility to destroy VAL when no longer needed.
  77    VAR must be the variable with which VAL is associated.
  78
  79    On success, VAL is returned, NULL otherwise.
  80 */
  81 union value *
  82 text_to_value (const gchar *text,
  83                const struct variable *var,
  84                union value *val)
  85 {
  86   const struct fmt_spec *format = var_get_print_format (var);
  87   int width = var_get_width (var);
  88
  89   if ( format->type != FMT_A)
  90     {
  91       if ( ! text ) return NULL;
  92
  93       {
  94         const gchar *s = text;
  95         while (*s)
  96           {
  97             if ( !isspace (*s))
  98               break;
  99             s++;
 100           }
 101
 102         if ( !*s) return NULL;
 103       }
 104     }
 105
 106   value_init (val, width);
 107   free (data_in (ss_cstr (text), UTF8, format->type, val, width,
 108                  var_get_encoding (var)));
 109
 110   return val;
 111 }
 112
 113
 114 GtkBuilder *
 115 builder_new_real (const gchar *name)
 116 {
 117   GtkBuilder *builder = gtk_builder_new ();
 118
 119   GError *err = NULL;
 120   if ( ! gtk_builder_add_from_file (builder, name,  &err))
 121     {
 122       g_critical ("Couldnt open user interface  file %s: %s", name, err->message);
 123       g_clear_error (&err);
 124     }
 125
 126   return builder;
 127 }
 128
 129
 130 GObject *
 131 get_object_assert (GtkBuilder *builder, const gchar *name, GType type)
 132 {
 133   GObject *o = NULL;
 134   g_assert (name);
 135
 136   o = gtk_builder_get_object (builder, name);
 137
 138   if ( !o )
 139     g_critical ("Object `%s' could not be found\n", name);
 140   else if ( ! g_type_is_a (G_OBJECT_TYPE (o), type))
 141    {
 142      g_critical ("Object `%s' was expected to have type %s, but in fact has type %s",
 143         name, g_type_name (type), G_OBJECT_TYPE_NAME (o));
 144    }
 145
 146   return o;
 147 }
 148
 149
 150 GtkAction *
 151 get_action_assert (GtkBuilder *builder, const gchar *name)
 152 {
 153   return GTK_ACTION (get_object_assert (builder, name, GTK_TYPE_ACTION));
 154 }
 155
 156 GtkWidget *
 157 get_widget_assert (GtkBuilder *builder, const gchar *name)
 158 {
 159   return GTK_WIDGET (get_object_assert (builder, name, GTK_TYPE_WIDGET));
 160 }
 161
 162 /* This function must be used whenever a filename generated by glib,
 163    (eg, from gtk_file_chooser_get_filename) and passed to the C library,
 164    (eg through a pspp syntax string).
 165 */
 166 gchar *
 167 convert_glib_filename_to_system_filename (const gchar *fname, GError **err)
 168 {
 169   gchar *output_name;
 170
 171 #ifdef G_OS_WIN32
 172   const gchar *target_encoding;
 173   gchar *utf8_name = NULL;
 174
 175   g_get_charset (&target_encoding);
 176
 177   output_name = g_convert (fname, -1, target_encoding,
 178                         "UTF-8", NULL, NULL, err);
 179 #else
 180   output_name = xstrdup (fname);
 181 #endif
 182
 183   return output_name;
 184 }
 185
 186
 187
 188 #define _(msgid) gettext (msgid)
 189 #define N_(msgid) msgid
 190
 191
 192 static void
 193 give_help (void)
 194 {
 195   GtkWidget *dialog;
 196
 197   dialog = gtk_message_dialog_new (NULL,
 198                                    GTK_DIALOG_MODAL,
 199                                    GTK_MESSAGE_INFO,
 200                                    GTK_BUTTONS_CLOSE,
 201                                    _("Sorry. The help system hasn't yet "
 202                                      "been implemented."));
 203   gtk_dialog_run (GTK_DIALOG (dialog));
 204   gtk_widget_destroy (dialog);
 205 }
 206
 207 void
 208 connect_help (GtkBuilder *xml)
 209 {
 210   GSList *helps = gtk_builder_get_objects (xml);
 211
 212   GSList *i;
 213   for ( i = helps; i ; i = g_slist_next (i))
 214     {
 215       GObject *o = i->data;
 216       if ( GTK_IS_WIDGET (o) )
 217         {
 218           const gchar *name = gtk_buildable_get_name (GTK_BUILDABLE (o));
 219           gchar s[12] = {0};
 220
 221           if ( name)
 222             strncpy (s, name, 11);
 223           s[11] = '\0';
 224
 225
 226           if ( 0 == strcmp ("help_button", s))
 227             {
 228             g_signal_connect (o, "clicked", give_help, 0);
 229             }
 230         }
 231     }
 232
 233   g_slist_free (helps);
 234 }
 235
 236
 237 /* Create a deep copy of SRC */
 238 GtkListStore *
 239 clone_list_store (const GtkListStore *src)
 240 {
 241   GtkTreeIter src_iter;
 242   gboolean ok;
 243   gint i;
 244   const gint n_cols =  gtk_tree_model_get_n_columns (GTK_TREE_MODEL (src));
 245   GType *types = g_malloc (sizeof (*types) *  n_cols);
 246
 247   int row = 0;
 248   GtkListStore *dest;
 249
 250   for (i = 0 ; i < n_cols; ++i )
 251     types[i] = gtk_tree_model_get_column_type (GTK_TREE_MODEL (src), i);
 252
 253   dest = gtk_list_store_newv (n_cols, types);
 254
 255   for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (src),
 256                                            &src_iter);
 257        ok;
 258        ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (src), &src_iter))
 259     {
 260       GtkTreeIter dest_iter;
 261       gtk_list_store_append  (dest, &dest_iter);
 262
 263       for (i = 0 ; i < n_cols; ++i )
 264         {
 265           GValue val = {0};
 266
 267           gtk_tree_model_get_value (GTK_TREE_MODEL (src), &src_iter, i, &val);
 268           gtk_list_store_set_value (dest, &dest_iter, i, &val);
 269
 270           g_value_unset (&val);
 271         }
 272       row++;
 273     }
 274
 275   g_free (types);
 276
 277   return dest;
 278 }
 279
 280
 281
 282
 283 static gboolean
 284 on_delete (GtkWindow *window, GdkEvent *e, GtkWindow **addr)
 285 {
 286   *addr = NULL;
 287
 288   return FALSE;
 289 }
 290
 291 char *
 292 paste_syntax_to_window (gchar *syntax)
 293 {
 294   static GtkWidget *the_syntax_pasteboard = NULL;
 295
 296   GtkTextBuffer *buffer = NULL;
 297
 298   if ( NULL == the_syntax_pasteboard)
 299     {
 300       the_syntax_pasteboard = psppire_syntax_window_new (NULL);
 301       g_signal_connect (the_syntax_pasteboard, "delete-event", G_CALLBACK (on_delete),
 302                         &the_syntax_pasteboard);
 303     }
 304
 305   buffer = GTK_TEXT_BUFFER (PSPPIRE_SYNTAX_WINDOW (the_syntax_pasteboard)->buffer);
 306
 307   gtk_text_buffer_begin_user_action (buffer);
 308   gtk_text_buffer_insert_at_cursor (buffer, syntax, -1);
 309   gtk_text_buffer_insert_at_cursor (buffer, "\n", 1);
 310   gtk_text_buffer_end_user_action (buffer);
 311
 312   gtk_widget_show (the_syntax_pasteboard);
 313
 314   return syntax;
 315 }
 316
 317
 318 /* gtk_box_pack_start_defaults is deprecated.
 319    Therefore we roll our own until a better solution is found */
 320 void
 321 psppire_box_pack_start_defaults (GtkBox *box, GtkWidget *widget)
 322 {
 323   gtk_box_pack_start (box, widget, TRUE, TRUE, 0);
 324 }