src/ui/gui/syntax-editor.c

   1 /*
   2     PSPPIRE --- A Graphical User Interface for PSPP
   3     Copyright (C) 2006  Free Software Foundation
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18     02110-1301, USA. */
  19
  20 #include <config.h>
  21 #include <stdlib.h>
  22 #include <gettext.h>
  23 #define _(msgid) gettext (msgid)
  24 #define N_(msgid) msgid
  25
  26 #include <glade/glade.h>
  27 #include <gtk/gtk.h>
  28 #include <libpspp/message.h>
  29 #include <libpspp/getl.h>
  30 #include "helper.h"
  31 #include "data-editor.h"
  32 #include "about.h"
  33
  34 #include "window-manager.h"
  35
  36 #include <language/command.h>
  37 #include <data/procedure.h>
  38 #include "syntax-editor.h"
  39 #include "syntax-editor-source.h"
  40
  41 extern struct source_stream *the_source_stream ;
  42 extern struct lexer *the_lexer;
  43 extern struct dataset *the_dataset;
  44
  45 static gboolean save_editor_to_file (struct syntax_editor *se,
  46                                      const gchar *filename,
  47                                      GError **err);
  48
  49 /* If the buffer's modified flag is set, then save it, and close the window.
  50    Otherwise just close the window.
  51 */
  52 static void
  53 save_if_modified (struct syntax_editor *se)
  54 {
  55   struct editor_window *e = (struct editor_window *) se;
  56   if ( TRUE == gtk_text_buffer_get_modified (se->buffer))
  57     {
  58       gint response;
  59       GtkWidget *dialog =
  60         gtk_message_dialog_new (GTK_WINDOW(e->window),
  61                                 GTK_DIALOG_MODAL,
  62                                 GTK_MESSAGE_QUESTION,
  63                                 GTK_BUTTONS_NONE,
  64                                 _("Save contents of syntax editor to %s?"),
  65                                 e->name ? e->name : _("Untitled")
  66                                 );
  67
  68       gtk_dialog_add_button  (GTK_DIALOG(dialog),
  69                               GTK_STOCK_YES,
  70                               GTK_RESPONSE_ACCEPT);
  71       gtk_dialog_add_button  (GTK_DIALOG(dialog),
  72                               GTK_STOCK_NO,
  73                               GTK_RESPONSE_REJECT);
  74       gtk_dialog_add_button  (GTK_DIALOG(dialog),
  75                               GTK_STOCK_CANCEL,
  76                               GTK_RESPONSE_CANCEL);
  77
  78
  79       response = gtk_dialog_run (GTK_DIALOG(dialog));
  80
  81       gtk_widget_destroy (dialog);
  82
  83       if ( response == GTK_RESPONSE_ACCEPT )
  84         {
  85           GError *err = NULL;
  86
  87           if ( ! save_editor_to_file (se, e->name ? e->name : _("Untitled"),
  88                                       &err) )
  89             {
  90               msg (ME, err->message);
  91               g_error_free (err);
  92             }
  93         }
  94
  95       if ( response == GTK_RESPONSE_CANCEL )
  96         return ;
  97     }
  98
  99   gtk_widget_destroy (e->window);
 100 }
 101
 102 /* Callback for the File->SaveAs menuitem */
 103 static void
 104 on_syntax_save_as   (GtkMenuItem     *menuitem,
 105                   gpointer         user_data)
 106 {
 107   GtkFileFilter *filter;
 108   gint response;
 109   struct syntax_editor *se = user_data;
 110   struct editor_window *e = user_data;
 111
 112   GtkWidget *dialog =
 113     gtk_file_chooser_dialog_new (_("Save Syntax"),
 114                                  GTK_WINDOW(e->window),
 115                                  GTK_FILE_CHOOSER_ACTION_SAVE,
 116                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 117                                  GTK_STOCK_SAVE,   GTK_RESPONSE_ACCEPT,
 118                                  NULL);
 119
 120   filter = gtk_file_filter_new ();
 121   gtk_file_filter_set_name (filter, _("Syntax Files (*.sps) "));
 122   gtk_file_filter_add_pattern (filter, "*.sps");
 123   gtk_file_filter_add_pattern (filter, "*.SPS");
 124   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
 125
 126   filter = gtk_file_filter_new ();
 127   gtk_file_filter_set_name (filter, _("All Files"));
 128   gtk_file_filter_add_pattern (filter, "*");
 129   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 130
 131   gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER(dialog),
 132                                                   TRUE);
 133   response = gtk_dialog_run (GTK_DIALOG (dialog));
 134
 135   if ( response == GTK_RESPONSE_ACCEPT )
 136     {
 137       GError *err = NULL;
 138       char *filename =
 139         gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog) );
 140
 141       if ( save_editor_to_file (se, filename, &err) )
 142         {
 143           g_free (e->name);
 144           e->name = g_strdup (filename);
 145         }
 146       else
 147         {
 148           msg ( ME, err->message );
 149           g_error_free (err);
 150         }
 151
 152       free (filename);
 153     }
 154
 155   gtk_widget_destroy ( dialog );
 156 }
 157
 158 /* Callback for the File->Save menuitem */
 159 void
 160 on_syntax_save   (GtkMenuItem     *menuitem,
 161                   gpointer         user_data)
 162 {
 163   struct syntax_editor *se = user_data;
 164   struct editor_window *e = user_data;
 165
 166   if ( e->name == NULL )
 167     on_syntax_save_as (menuitem, user_data);
 168   else
 169     {
 170       GError *err;
 171       save_editor_to_file (se, e->name, &err);
 172       msg (ME, err->message);
 173       g_error_free (err);
 174     }
 175 }
 176
 177
 178 /* Callback for the "delete" action (clicking the x on the top right
 179    hand corner of the window) */
 180 static gboolean
 181 on_delete (GtkWidget *w, GdkEvent *event, gpointer user_data)
 182 {
 183   struct syntax_editor *se = user_data;
 184   save_if_modified (se);
 185   return TRUE;
 186 }
 187
 188
 189 /* Callback for the File->Quit menuitem */
 190 static gboolean
 191 on_quit (GtkMenuItem *menuitem, gpointer    user_data)
 192 {
 193   struct syntax_editor *se = user_data;
 194   save_if_modified (se);
 195   return FALSE;
 196 }
 197
 198 static void
 199 on_run_all (GtkMenuItem *menuitem, gpointer user_data)
 200 {
 201   GtkTextIter begin, end;
 202   struct syntax_editor *se = user_data;
 203
 204   gtk_text_buffer_get_iter_at_line (se->buffer, &begin, 0);
 205   gtk_text_buffer_get_iter_at_line (se->buffer, &end, -1);
 206
 207   getl_append_source (the_source_stream,
 208                       create_syntax_editor_source (se, begin, end));
 209   for (;;)
 210     {
 211       int result = cmd_parse (the_lexer, the_dataset,
 212                               proc_has_source (the_dataset)
 213                               ? CMD_STATE_DATA : CMD_STATE_INITIAL);
 214
 215       if (result == CMD_EOF || result == CMD_FINISH)
 216         break;
 217     }
 218 }
 219
 220
 221
 222
 223 /*
 224   Create a new syntax editor with NAME.
 225   If NAME is NULL, a name will be automatically assigned
 226 */
 227 struct syntax_editor *
 228 new_syntax_editor (void)
 229 {
 230   GladeXML *xml =
 231     glade_xml_new (PKGDATADIR "/syntax-editor.glade", NULL, NULL);
 232
 233   GtkWidget *text_view;
 234   struct syntax_editor *se ;
 235   struct editor_window *e;
 236
 237   se = g_malloc (sizeof (*se));
 238
 239   e = (struct editor_window *)se;
 240
 241   e->window = get_widget_assert (xml, "syntax_editor");
 242   text_view = get_widget_assert (xml, "syntax_text_view");
 243   se->buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(text_view));
 244
 245   g_signal_connect (get_widget_assert (xml,"file_new_syntax"),
 246                     "activate",
 247                     G_CALLBACK(new_syntax_window),
 248                     e->window);
 249
 250   g_signal_connect (get_widget_assert (xml,"file_open_syntax"),
 251                     "activate",
 252                     G_CALLBACK(open_syntax_window),
 253                     e->window);
 254
 255   g_signal_connect (get_widget_assert (xml,"file_new_data"),
 256                     "activate",
 257                     G_CALLBACK(new_data_window),
 258                     e->window);
 259
 260   g_signal_connect (get_widget_assert (xml,"file_open_data"),
 261                     "activate",
 262                     G_CALLBACK(open_data_window),
 263                     e->window);
 264
 265
 266   g_signal_connect (get_widget_assert (xml,"help_about"),
 267                     "activate",
 268                     G_CALLBACK(about_new),
 269                     e->window);
 270
 271
 272 #if 0
 273
 274   g_signal_connect (get_widget_assert (xml,"file_quit"),
 275                     "activate",
 276                     G_CALLBACK(on_quit),
 277                     se);
 278
 279   g_signal_connect (get_widget_assert (xml,"file_save"),
 280                     "activate",
 281                     G_CALLBACK(on_syntax_save),
 282                     se);
 283
 284   g_signal_connect (get_widget_assert (xml,"file_save_as"),
 285                     "activate",
 286                     G_CALLBACK(on_syntax_save_as),
 287                     se);
 288
 289 #endif
 290
 291   g_signal_connect (get_widget_assert (xml,"run_all"),
 292                     "activate",
 293                     G_CALLBACK(on_run_all),
 294                     se);
 295
 296
 297
 298   g_object_unref (xml);
 299
 300   g_signal_connect (e->window, "delete-event",
 301                     G_CALLBACK(on_delete), se);
 302
 303   return se;
 304 }
 305
 306 /*
 307    Callback for the File->New->Syntax menuitem
 308 */
 309 void
 310 new_syntax_window (GtkMenuItem     *menuitem,
 311                    gpointer         user_data)
 312 {
 313   window_create (WINDOW_SYNTAX, NULL);
 314 }
 315
 316
 317 /*
 318   Save BUFFER to the file called FILENAME.
 319   If successful, clears the buffer's modified flag
 320 */
 321 static gboolean
 322 save_editor_to_file (struct syntax_editor *se,
 323                      const gchar *filename,
 324                      GError **err)
 325 {
 326   GtkTextBuffer *buffer = se->buffer;
 327   gboolean result ;
 328   GtkTextIter start, stop;
 329   gchar *text;
 330
 331   gchar *glibfilename;
 332   g_assert (filename);
 333
 334   glibfilename = g_filename_from_utf8 (filename, -1, 0, 0, err);
 335
 336   if ( ! glibfilename )
 337     return FALSE;
 338
 339   gtk_text_buffer_get_iter_at_line (buffer, &start, 0);
 340   gtk_text_buffer_get_iter_at_offset (buffer, &stop, -1);
 341
 342   text = gtk_text_buffer_get_text (buffer, &start, &stop, FALSE);
 343
 344   result =  g_file_set_contents (glibfilename, text, -1, err);
 345
 346   if ( result )
 347     {
 348       window_set_name_from_filename ((struct editor_window *) se, filename);
 349       gtk_text_buffer_set_modified (buffer, FALSE);
 350     }
 351
 352   return result;
 353 }
 354
 355
 356 /*
 357   Loads the buffer from the file called FILENAME
 358 */
 359 static gboolean
 360 load_editor_from_file (struct syntax_editor *se,
 361                        const gchar *filename,
 362                        GError **err)
 363 {
 364   GtkTextBuffer *buffer = se->buffer;
 365   gchar *text;
 366   GtkTextIter iter;
 367
 368   gchar *glibfilename = g_filename_from_utf8 (filename, -1, 0, 0, err);
 369
 370   if ( ! glibfilename )
 371     return FALSE;
 372
 373   /* FIXME: What if it's a very big file ? */
 374   if ( ! g_file_get_contents (glibfilename, &text, NULL, err) )
 375     {
 376       g_free (glibfilename);
 377       return FALSE;
 378     }
 379   g_free (glibfilename);
 380
 381   gtk_text_buffer_get_iter_at_line (buffer, &iter, 0);
 382
 383   gtk_text_buffer_insert (buffer, &iter, text, -1);
 384
 385   window_set_name_from_filename ((struct editor_window *)se, filename);
 386   gtk_text_buffer_set_modified (buffer, FALSE);
 387
 388   return TRUE;
 389 }
 390
 391
 392 /* Callback for the File->Open->Syntax menuitem */
 393 void
 394 open_syntax_window (GtkMenuItem *menuitem, gpointer parent)
 395 {
 396   GtkFileFilter *filter;
 397   gint response;
 398
 399   GtkWidget *dialog =
 400     gtk_file_chooser_dialog_new (_("Open Syntax"),
 401                                  GTK_WINDOW(parent),
 402                                  GTK_FILE_CHOOSER_ACTION_OPEN,
 403                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 404                                  GTK_STOCK_OPEN,   GTK_RESPONSE_ACCEPT,
 405                                  NULL);
 406
 407   filter = gtk_file_filter_new ();
 408   gtk_file_filter_set_name (filter, _("Syntax Files (*.sps) "));
 409   gtk_file_filter_add_pattern (filter, "*.sps");
 410   gtk_file_filter_add_pattern (filter, "*.SPS");
 411   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
 412
 413   filter = gtk_file_filter_new ();
 414   gtk_file_filter_set_name (filter, _("All Files"));
 415   gtk_file_filter_add_pattern (filter, "*");
 416   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 417
 418   response = gtk_dialog_run (GTK_DIALOG (dialog));
 419
 420   if (response == GTK_RESPONSE_ACCEPT)
 421     {
 422       const char *file_name = gtk_file_chooser_get_filename
 423         (GTK_FILE_CHOOSER (dialog));
 424
 425       struct syntax_editor *se = (struct syntax_editor *)
 426         window_create (WINDOW_SYNTAX, file_name);
 427
 428       load_editor_from_file (se, file_name, NULL);
 429     }
 430
 431   gtk_widget_destroy (dialog);
 432 }
 433
 434
 435
 436
 437
 438