/* testtext.c

 * Copyright (C) 2000 Red Hat, Inc

 * Author: Havoc Pennington

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <stdio.h>

#include <sys/stat.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#undef GDK_DISABLE_DEPRECATED

#undef GTK_DISABLE_DEPRECATED

#include <gtk/gtk.h>

#include <gdk/gdkkeysyms.h>

#include "prop-editor.h"

typedef struct _Buffer Buffer;

typedef struct _View View;

static gint untitled_serial = 1;

GSList *active_window_stack = NULL;

struct _Buffer

{

  gint refcount;

  GtkTextBuffer *buffer;

  char *filename;

  gint untitled_serial;

  GtkTextTag *invisible_tag;

  GtkTextTag *not_editable_tag;

  GtkTextTag *found_text_tag;

  GtkTextTag *rise_tag;

  GtkTextTag *large_tag;

  GtkTextTag *indent_tag;

  GtkTextTag *margin_tag;

  GtkTextTag *custom_tabs_tag;

  GSList *color_tags;

  guint color_cycle_timeout;

  gdouble start_hue;

};

struct _View

{

  GtkWidget *window;

  GtkWidget *text_view;

  GtkAccelGroup *accel_group;

  GtkItemFactory *item_factory;

  Buffer *buffer;

};

static void push_active_window (GtkWindow *window);

static void pop_active_window (void);

static GtkWindow *get_active_window (void);

static Buffer * create_buffer      (void);

static gboolean check_buffer_saved (Buffer *buffer);

static gboolean save_buffer        (Buffer *buffer);

static gboolean save_as_buffer     (Buffer *buffer);

static char *   buffer_pretty_name (Buffer *buffer);

static void     buffer_filename_set (Buffer *buffer);

static void     buffer_search_forward (Buffer *buffer,

                                       const char *str,

                                       View *view);

static void     buffer_search_backward (Buffer *buffer,

                                       const char *str,

                                       View *view);

static void     buffer_set_colors      (Buffer  *buffer,

                                        gboolean enabled);

static void     buffer_cycle_colors    (Buffer  *buffer);

static View *view_from_widget (GtkWidget *widget);

static View *create_view      (Buffer *buffer);

static void  check_close_view (View   *view);

static void  close_view       (View   *view);

static void  view_set_title   (View   *view);

static void  view_init_menus  (View   *view);

static void  view_add_example_widgets (View *view);

GSList *buffers = NULL;

GSList *views = NULL;

static void

push_active_window (GtkWindow *window)

{

  g_object_ref (window);

  active_window_stack = g_slist_prepend (active_window_stack, window);

}

static void

pop_active_window (void)

{

  g_object_unref (active_window_stack->data);

  active_window_stack = g_slist_delete_link (active_window_stack, active_window_stack);

}

static GtkWindow *

get_active_window (void)

{

  if (active_window_stack)

    return active_window_stack->data;

  else

    return NULL;

}

/*

 * Filesel utility function

 */

typedef gboolean (*FileselOKFunc) (const char *filename, gpointer data);

static void

filesel_ok_cb (GtkWidget *button, GtkWidget *filesel)

{

  FileselOKFunc ok_func = (FileselOKFunc)g_object_get_data (G_OBJECT (filesel), "ok-func");

  gpointer data = g_object_get_data (G_OBJECT (filesel), "ok-data");

  gint *result = g_object_get_data (G_OBJECT (filesel), "ok-result");

  gtk_widget_hide (filesel);

  if ((*ok_func) (gtk_file_selection_get_filename (GTK_FILE_SELECTION (filesel)), data))

    {

      gtk_widget_destroy (filesel);

      *result = TRUE;

    }

  else

    gtk_widget_show (filesel);

}

gboolean

filesel_run (GtkWindow    *parent, 

	     const char   *title,

	     const char   *start_file,

	     FileselOKFunc func,

	     gpointer      data)

{

  GtkWidget *filesel = gtk_file_selection_new (title);

  gboolean result = FALSE;

  if (!parent)

    parent = get_active_window ();

  if (parent)

    gtk_window_set_transient_for (GTK_WINDOW (filesel), parent);

  if (start_file)

    gtk_file_selection_set_filename (GTK_FILE_SELECTION (filesel), start_file);

  g_object_set_data (G_OBJECT (filesel), "ok-func", func);

  g_object_set_data (G_OBJECT (filesel), "ok-data", data);

  g_object_set_data (G_OBJECT (filesel), "ok-result", &result);

  g_signal_connect (GTK_FILE_SELECTION (filesel)->ok_button,

		    "clicked",

		    G_CALLBACK (filesel_ok_cb), filesel);

  g_signal_connect_swapped (GTK_FILE_SELECTION (filesel)->cancel_button,

			    "clicked",

			    G_CALLBACK (gtk_widget_destroy), filesel);

  g_signal_connect (filesel, "destroy",

		    G_CALLBACK (gtk_main_quit), NULL);

  gtk_window_set_modal (GTK_WINDOW (filesel), TRUE);

  gtk_widget_show (filesel);

  gtk_main ();

  return result;

}

/*

 * MsgBox utility functions

 */

static void

msgbox_yes_cb (GtkWidget *widget, gboolean *result)

{

  *result = 0;

  gtk_object_destroy (GTK_OBJECT (gtk_widget_get_toplevel (widget)));

}

static void

msgbox_no_cb (GtkWidget *widget, gboolean *result)

{

  *result = 1;

  gtk_object_destroy (GTK_OBJECT (gtk_widget_get_toplevel (widget)));

}

static gboolean

msgbox_key_press_cb (GtkWidget *widget, GdkEventKey *event, gpointer data)

{

  if (event->keyval == GDK_Escape)

    {

      g_signal_stop_emission_by_name (widget, "key_press_event");

      gtk_object_destroy (GTK_OBJECT (widget));

      return TRUE;

    }

  return FALSE;

}

/* Don't copy this example, it's all crack-smoking - you can just use

 * GtkMessageDialog now

 */

gint

msgbox_run (GtkWindow  *parent,

	    const char *message,

	    const char *yes_button,

	    const char *no_button,

	    const char *cancel_button,

	    gint default_index)

{

  gboolean result = -1;

  GtkWidget *dialog;

  GtkWidget *button;

  GtkWidget *label;

  GtkWidget *vbox;

  GtkWidget *button_box;

  GtkWidget *separator;

  g_return_val_if_fail (message != NULL, FALSE);

  g_return_val_if_fail (default_index >= 0 && default_index <= 1, FALSE);

  if (!parent)

    parent = get_active_window ();

  /* Create a dialog

   */

  dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);

  if (parent)

    gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);

  gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);

  /* Quit our recursive main loop when the dialog is destroyed.

   */

  g_signal_connect (dialog, "destroy",

		    G_CALLBACK (gtk_main_quit), NULL);

  /* Catch Escape key presses and have them destroy the dialog

   */

  g_signal_connect (dialog, "key_press_event",

		    G_CALLBACK (msgbox_key_press_cb), NULL);

  /* Fill in the contents of the widget

   */

  vbox = gtk_vbox_new (FALSE, 0);

  gtk_container_add (GTK_CONTAINER (dialog), vbox);

  label = gtk_label_new (message);

  gtk_misc_set_padding (GTK_MISC (label), 12, 12);

  gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

  gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);

  separator = gtk_hseparator_new ();

  gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);

  button_box = gtk_hbutton_box_new ();

  gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 0);

  gtk_container_set_border_width (GTK_CONTAINER (button_box), 8);

  /* When Yes is clicked, call the msgbox_yes_cb

   * This sets the result variable and destroys the dialog

   */

  if (yes_button)

    {

      button = gtk_button_new_with_label (yes_button);

      gtk_widget_set_can_default (button, TRUE);

      gtk_container_add (GTK_CONTAINER (button_box), button);

      if (default_index == 0)

	gtk_widget_grab_default (button);

      g_signal_connect (button, "clicked",

			G_CALLBACK (msgbox_yes_cb), &result);

    }

  /* When No is clicked, call the msgbox_no_cb

   * This sets the result variable and destroys the dialog

   */

  if (no_button)

    {

      button = gtk_button_new_with_label (no_button);

      gtk_widget_set_can_default (button, TRUE);

      gtk_container_add (GTK_CONTAINER (button_box), button);

      if (default_index == 0)

	gtk_widget_grab_default (button);

      g_signal_connect (button, "clicked",

			G_CALLBACK (msgbox_no_cb), &result);

    }

  /* When Cancel is clicked, destroy the dialog

   */

  if (cancel_button)

    {

      button = gtk_button_new_with_label (cancel_button);

      gtk_widget_set_can_default (button, TRUE);

      gtk_container_add (GTK_CONTAINER (button_box), button);

      if (default_index == 1)

	gtk_widget_grab_default (button);

      g_signal_connect_swapped (button, "clicked",

				G_CALLBACK (gtk_object_destroy), dialog);

    }

  gtk_widget_show_all (dialog);

  /* Run a recursive main loop until a button is clicked

   * or the user destroys the dialog through the window mananger */

  gtk_main ();

  return result;

}

#ifdef DO_BLINK

/*

 * Example buffer filling code

 */

static gint

blink_timeout (gpointer data)

{

  GtkTextTag *tag;

  static gboolean flip = FALSE;

  tag = GTK_TEXT_TAG (data);

  g_object_set (tag,

                 "foreground", flip ? "blue" : "purple",

                 NULL);

  flip = !flip;

  return TRUE;

}

#endif

static gint

tag_event_handler (GtkTextTag *tag, GtkWidget *widget, GdkEvent *event,

                  const GtkTextIter *iter, gpointer user_data)

{

  gint char_index;

  char_index = gtk_text_iter_get_offset (iter);

  switch (event->type)

    {

    case GDK_MOTION_NOTIFY:

      printf ("Motion event at char %d tag `%s'\n",

             char_index, tag->name);

      break;

    case GDK_BUTTON_PRESS:

      printf ("Button press at char %d tag `%s'\n",

             char_index, tag->name);

      break;

    case GDK_2BUTTON_PRESS:

      printf ("Double click at char %d tag `%s'\n",

             char_index, tag->name);

      break;

    case GDK_3BUTTON_PRESS:

      printf ("Triple click at char %d tag `%s'\n",

             char_index, tag->name);

      break;

    case GDK_BUTTON_RELEASE:

      printf ("Button release at char %d tag `%s'\n",

             char_index, tag->name);

      break;

    case GDK_KEY_PRESS:

    case GDK_KEY_RELEASE:

      printf ("Key event at char %d tag `%s'\n",

              char_index, tag->name);

      break;

    case GDK_ENTER_NOTIFY:

    case GDK_LEAVE_NOTIFY:

    case GDK_PROPERTY_NOTIFY:

    case GDK_SELECTION_CLEAR:

    case GDK_SELECTION_REQUEST:

    case GDK_SELECTION_NOTIFY:

    case GDK_PROXIMITY_IN:

    case GDK_PROXIMITY_OUT:

    case GDK_DRAG_ENTER:

    case GDK_DRAG_LEAVE:

    case GDK_DRAG_MOTION:

    case GDK_DRAG_STATUS:

    case GDK_DROP_START:

    case GDK_DROP_FINISHED:

    default:

      break;

    }

  return FALSE;

}

static void

setup_tag (GtkTextTag *tag)

{

  g_signal_connect (tag,

		    "event",

		    G_CALLBACK (tag_event_handler),

		    NULL);

}

static const char  *book_closed_xpm[] = {

"16 16 6 1",

"       c None s None",

".      c black",

"X      c red",

"o      c yellow",

"O      c #808080",

"#      c white",

"                ",

"       ..       ",

"     ..XX.      ",

"   ..XXXXX.     ",

" ..XXXXXXXX.    ",

".ooXXXXXXXXX.   ",

"..ooXXXXXXXXX.  ",

".X.ooXXXXXXXXX. ",

".XX.ooXXXXXX..  ",

" .XX.ooXXX..#O  ",

"  .XX.oo..##OO. ",

"   .XX..##OO..  ",

"    .X.#OO..    ",

"     ..O..      ",

"      ..        ",

"                "};

void

fill_example_buffer (GtkTextBuffer *buffer)

{

  GtkTextIter iter, iter2;

  GtkTextTag *tag;

  GtkTextChildAnchor *anchor;

  GdkColor color;

  GdkColor color2;

  GdkPixbuf *pixbuf;

  int i;

  char *str;

  /* FIXME this is broken if called twice on a buffer, since

   * we try to create tags a second time.

   */

  tag = gtk_text_buffer_create_tag (buffer, "fg_blue", NULL);

#ifdef DO_BLINK

  gtk_timeout_add (1000, blink_timeout, tag);

#endif     

  setup_tag (tag);

  color.red = color.green = 0;

  color.blue = 0xffff;

  color2.red = 0xfff;

  color2.blue = 0x0;

  color2.green = 0;

  g_object_set (tag,

                "foreground_gdk", &color,

                "background_gdk", &color2,

                "size_points", 24.0,

                NULL);

  tag = gtk_text_buffer_create_tag (buffer, "fg_red", NULL);

  setup_tag (tag);

  color.blue = color.green = 0;

  color.red = 0xffff;

  g_object_set (tag,

                "rise", -4 * PANGO_SCALE,

                "foreground_gdk", &color,

                NULL);

  tag = gtk_text_buffer_create_tag (buffer, "bg_green", NULL);

  setup_tag (tag);

  color.blue = color.red = 0;

  color.green = 0xffff;

  g_object_set (tag,

                "background_gdk", &color,

                "size_points", 10.0,

                NULL);

  tag = gtk_text_buffer_create_tag (buffer, "strikethrough", NULL);

  setup_tag (tag);

  g_object_set (tag,

                "strikethrough", TRUE,

                NULL);

  tag = gtk_text_buffer_create_tag (buffer, "underline", NULL);

  setup_tag (tag);

  g_object_set (tag,

                "underline", PANGO_UNDERLINE_SINGLE,

                NULL);

  tag = gtk_text_buffer_create_tag (buffer, "underline_error", NULL);

  setup_tag (tag);

  g_object_set (tag,

                "underline", PANGO_UNDERLINE_ERROR,

                NULL);

  tag = gtk_text_buffer_create_tag (buffer, "centered", NULL);

  g_object_set (tag,

                "justification", GTK_JUSTIFY_CENTER,

                NULL);

  tag = gtk_text_buffer_create_tag (buffer, "rtl_quote", NULL);

  g_object_set (tag,

                "wrap_mode", GTK_WRAP_WORD,

                "direction", GTK_TEXT_DIR_RTL,

                "indent", 30,

                "left_margin", 20,

                "right_margin", 20,

                NULL);

  tag = gtk_text_buffer_create_tag (buffer, "negative_indent", NULL);

  g_object_set (tag,

                "indent", -25,

                NULL);

  gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);

  anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);

  g_object_ref (anchor);

  g_object_set_data_full (G_OBJECT (buffer), "anchor", anchor,

                          (GDestroyNotify) g_object_unref);

  pixbuf = gdk_pixbuf_new_from_xpm_data (book_closed_xpm);

  i = 0;

  while (i < 100)

    {

      GtkTextMark * temp_mark;

      gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);

      gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);

      str = g_strdup_printf ("%d Hello World! blah blah blah blah blah blah blah blah blah blah blah blah\nwoo woo woo woo woo woo woo woo woo woo woo woo woo woo woo\n",

			    i);

      gtk_text_buffer_insert (buffer, &iter, str, -1);

      g_free (str);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 5);

      gtk_text_buffer_insert (buffer, &iter,

			     "(Hello World!)\nfoo foo Hello this is some text we are using to text word wrap. It has punctuation! gee; blah - hmm, great.\nnew line with a significant quantity of text on it. This line really does contain some text. More text! More text! More text!\n"

			     /* This is UTF8 stuff, Emacs doesn't

				really know how to display it */

			     "German (Deutsch S\303\274d) Gr\303\274\303\237 Gott Greek (\316\225\316\273\316\273\316\267\316\275\316\271\316\272\316\254) \316\223\316\265\316\271\316\254 \317\203\316\261\317\202 Hebrew(\327\251\327\234\327\225\327\235) Hebrew punctuation(\xd6\xbf\327\251\xd6\xbb\xd6\xbc\xd6\xbb\xd6\xbf\327\234\xd6\xbc\327\225\xd6\xbc\xd6\xbb\xd6\xbb\xd6\xbf\327\235\xd6\xbc\xd6\xbb\xd6\xbf) Japanese (\346\227\245\346\234\254\350\252\236) Thai (\340\270\252\340\270\247\340\270\261\340\270\252\340\270\224\340\270\265\340\270\204\340\270\243\340\270\261\340\270\232) Thai wrong spelling (\340\270\204\340\270\263\340\270\225\340\271\210\340\270\255\340\271\204\340\270\233\340\270\231\340\270\267\340\271\210\340\270\252\340\270\260\340\270\201\340\270\224\340\270\234\340\270\264\340\270\224 \340\270\236\340\270\261\340\270\261\340\271\211\340\270\261\340\270\261\340\271\210\340\270\207\340\271\202\340\270\201\340\270\260)\n", -1);

      temp_mark =

        gtk_text_buffer_create_mark (buffer, "tmp_mark", &iter, TRUE);

#if 1

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 6);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 0, 13);

      gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 1, 10);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 1, 16);

      gtk_text_buffer_apply_tag_by_name (buffer, "underline", &iter, &iter2);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 1, 4);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 1, 7);

      gtk_text_buffer_apply_tag_by_name (buffer, "underline_error", &iter, &iter2);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 1, 14);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 1, 24);

      gtk_text_buffer_apply_tag_by_name (buffer, "strikethrough", &iter, &iter2);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 9);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 0, 16);

      gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 4, 2);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 4, 10);

      gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 4, 8);

      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 4, 15);

      gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);

#endif

      gtk_text_buffer_get_iter_at_mark (buffer, &iter, temp_mark);

      gtk_text_buffer_insert (buffer, &iter, "Centered text!\n", -1);

      gtk_text_buffer_get_iter_at_mark (buffer, &iter2, temp_mark);

      gtk_text_buffer_apply_tag_by_name (buffer, "centered", &iter2, &iter);

      gtk_text_buffer_move_mark (buffer, temp_mark, &iter);

      gtk_text_buffer_insert (buffer, &iter, "Word wrapped, Right-to-left Quote\n", -1);

      gtk_text_buffer_insert (buffer, &iter, "\331\210\331\202\330\257 \330\250\330\257\330\243 \330\253\331\204\330\247\330\253 \331\205\331\206 \330\243\331\203\330\253\330\261 \330\247\331\204\331\205\330\244\330\263\330\263\330\247\330\252 \330\252\331\202\330\257\331\205\330\247 \331\201\331\212 \330\264\330\250\331\203\330\251 \330\247\331\203\330\263\331\212\331\210\331\206 \330\250\330\261\330\247\331\205\330\254\331\207\330\247 \331\203\331\205\331\206\330\270\331\205\330\247\330\252 \331\204\330\247 \330\252\330\263\330\271\331\211 \331\204\331\204\330\261\330\250\330\255\330\214 \330\253\331\205 \330\252\330\255\331\210\331\204\330\252 \331\201\331\212 \330\247\331\204\330\263\331\206\331\210\330\247\330\252 \330\247\331\204\330\256\331\205\330\263 \330\247\331\204\331\205\330\247\330\266\331\212\330\251 \330\245\331\204\331\211 \331\205\330\244\330\263\330\263\330\247\330\252 \331\205\330\247\331\204\331\212\330\251 \331\205\331\206\330\270\331\205\330\251\330\214 \331\210\330\250\330\247\330\252\330\252 \330\254\330\262\330\241\330\247 \331\205\331\206 \330\247\331\204\331\206\330\270\330\247\331\205 \330\247\331\204\331\205\330\247\331\204\331\212 \331\201\331\212 \330\250\331\204\330\257\330\247\331\206\331\207\330\247\330\214 \331\210\331\204\331\203\331\206\331\207\330\247 \330\252\330\252\330\256\330\265\330\265 \331\201\331\212 \330\256\330\257\331\205\330\251 \331\202\330\267\330\247\330\271 \330\247\331\204\331\205\330\264\330\261\331\210\330\271\330\247\330\252 \330\247\331\204\330\265\330\272\331\212\330\261\330\251. \331\210\330\243\330\255\330\257 \330\243\331\203\330\253\330\261 \331\207\330\260\331\207 \330\247\331\204\331\205\330\244\330\263\330\263\330\247\330\252 \331\206\330\254\330\247\330\255\330\247 \331\207\331\210 \302\273\330\250\330\247\331\206\331\203\331\210\330\263\331\210\331\204\302\253 \331\201\331\212 \330\250\331\210\331\204\331\212\331\201\331\212\330\247.\n", -1);

      gtk_text_buffer_get_iter_at_mark (buffer, &iter2, temp_mark);

      gtk_text_buffer_apply_tag_by_name (buffer, "rtl_quote", &iter2, &iter);

      gtk_text_buffer_insert_with_tags (buffer, &iter,

                                        "Paragraph with negative indentation. blah blah blah blah blah. The quick brown fox jumped over the lazy dog.\n",

                                        -1,

                                        gtk_text_tag_table_lookup (gtk_text_buffer_get_tag_table (buffer),

                                                                   "negative_indent"),

                                        NULL);

      ++i;

    }

  g_object_unref (pixbuf);

  printf ("%d lines %d chars\n",

          gtk_text_buffer_get_line_count (buffer),

          gtk_text_buffer_get_char_count (buffer));

  /* Move cursor to start */

  gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);

  gtk_text_buffer_place_cursor (buffer, &iter);

  gtk_text_buffer_set_modified (buffer, FALSE);

}

gboolean

fill_file_buffer (GtkTextBuffer *buffer, const char *filename)

{

  FILE* f;

  gchar buf[2048];

  gint remaining = 0;

  GtkTextIter iter, end;

  f = fopen (filename, "r");

  if (f == NULL)

    {

      gchar *err = g_strdup_printf ("Cannot open file '%s': %s",

				    filename, g_strerror (errno));

      msgbox_run (NULL, err, "OK", NULL, NULL, 0);

      g_free (err);

      return FALSE;

    }

  gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);

  while (!feof (f))

    {

      gint count;

      const char *leftover;

      int to_read = 2047  - remaining;

      count = fread (buf + remaining, 1, to_read, f);

      buf[count + remaining] = '\0';

      g_utf8_validate (buf, count + remaining, &leftover);

      g_assert (g_utf8_validate (buf, leftover - buf, NULL));

      gtk_text_buffer_insert (buffer, &iter, buf, leftover - buf);

      remaining = (buf + remaining + count) - leftover;

      g_memmove (buf, leftover, remaining);

      if (remaining > 6 || count < to_read)

	  break;

    }

  if (remaining)

    {

      gchar *err = g_strdup_printf ("Invalid UTF-8 data encountered reading file '%s'", filename);

      msgbox_run (NULL, err, "OK", NULL, NULL, 0);

      g_free (err);

    }

  /* We had a newline in the buffer to begin with. (The buffer always contains

   * a newline, so we delete to the end of the buffer to clean up.

   */

  gtk_text_buffer_get_end_iter (buffer, &end;;

  gtk_text_buffer_delete (buffer, &iter, &end;;

  gtk_text_buffer_set_modified (buffer, FALSE);

  return TRUE;

}

static gint

delete_event_cb (GtkWidget *window, GdkEventAny *event, gpointer data)

{

  View *view = view_from_widget (window);

  push_active_window (GTK_WINDOW (window));

  check_close_view (view);

  pop_active_window ();

  return TRUE;

}

/*

 * Menu callbacks

 */

static View *

get_empty_view (View *view)

{

  if (!view->buffer->filename &&

      !gtk_text_buffer_get_modified (view->buffer->buffer))

    return view;

  else

    return create_view (create_buffer ());

}

static View *

view_from_widget (GtkWidget *widget)

{

  if (GTK_IS_MENU_ITEM (widget))

    {

      GtkItemFactory *item_factory = gtk_item_factory_from_widget (widget);

      return g_object_get_data (G_OBJECT (item_factory), "view");      

    }

  else

    {

      GtkWidget *app = gtk_widget_get_toplevel (widget);

      return g_object_get_data (G_OBJECT (app), "view");

    }

}

static void

do_new (gpointer             callback_data,

	guint                callback_action,

	GtkWidget           *widget)

{

  create_view (create_buffer ());

}

static void

do_new_view (gpointer             callback_data,

	     guint                callback_action,

	     GtkWidget           *widget)

{

  View *view = view_from_widget (widget);

  create_view (view->buffer);

}

gboolean

open_ok_func (const char *filename, gpointer data)

{

  View *view = data;

  View *new_view = get_empty_view (view);

  if (!fill_file_buffer (new_view->buffer->buffer, filename))

    {

      if (new_view != view)

	close_view (new_view);

      return FALSE;

    }

  else

    {

      g_free (new_view->buffer->filename);

      new_view->buffer->filename = g_strdup (filename);

      buffer_filename_set (new_view->buffer);

      return TRUE;

    }

}

static void

do_open (gpointer             callback_data,

	 guint                callback_action,

	 GtkWidget           *widget)

{

  View *view = view_from_widget (widget);

  push_active_window (GTK_WINDOW (view->window));

  filesel_run (NULL, "Open File", NULL, open_ok_func, view);

  pop_active_window ();

}

static void

do_save_as (gpointer             callback_data,

	    guint                callback_action,

	    GtkWidget           *widget)

{

  View *view = view_from_widget (widget);  

  push_active_window (GTK_WINDOW (view->window));

  save_as_buffer (view->buffer);

  pop_active_window ();

}

static void

do_save (gpointer             callback_data,

	 guint                callback_action,

	 GtkWidget           *widget)

{

  View *view = view_from_widget (widget);

  push_active_window (GTK_WINDOW (view->window));

  if (!view->buffer->filename)

    do_save_as (callback_data, callback_action, widget);

  else

    save_buffer (view->buffer);

  pop_active_window ();

}

static void

do_close   (gpointer             callback_data,

	    guint                callback_action,

	    GtkWidget           *widget)

{

  View *view = view_from_widget (widget);

  push_active_window (GTK_WINDOW (view->window));

  check_close_view (view);

  pop_active_window ();

}

static void

do_exit    (gpointer             callback_data,

	    guint                callback_action,

	    GtkWidget           *widget)

{

  View *view = view_from_widget (widget);

  GSList *tmp_list = buffers;

  push_active_window (GTK_WINDOW (view->window));

  while (tmp_list)

    {

      if (!check_buffer_saved (tmp_list->data))

	return;

      tmp_list = tmp_list->next;

    }