gtk2 2.2.4-x64-mingw32

data/vendor/local/include/gtk-2.0/gtk/gtktexttag.h

@@ -0,0 +1,289 @@
+/* gtktexttag.c - text tag object
+ *
+ * Copyright (c) 1992-1994 The Regents of the University of California.
+ * Copyright (c) 1994-1997 Sun Microsystems, Inc.
+ * Copyright (c) 2000      Red Hat, Inc.
+ * Tk -> Gtk port by Havoc Pennington <hp@redhat.com>
+ *
+ * This software is copyrighted by the Regents of the University of
+ * California, Sun Microsystems, Inc., and other parties.  The
+ * following terms apply to all files associated with the software
+ * unless explicitly disclaimed in individual files.
+ *
+ * The authors hereby grant permission to use, copy, modify,
+ * distribute, and license this software and its documentation for any
+ * purpose, provided that existing copyright notices are retained in
+ * all copies and that this notice is included verbatim in any
+ * distributions. No written agreement, license, or royalty fee is
+ * required for any of the authorized uses.  Modifications to this
+ * software may be copyrighted by their authors and need not follow
+ * the licensing terms described here, provided that the new terms are
+ * clearly indicated on the first page of each file where they apply.
+ *
+ * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY
+ * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
+ * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION,
+ * OR ANY DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+ * NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS,
+ * AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE
+ * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ * GOVERNMENT USE: If you are acquiring this software on behalf of the
+ * U.S. government, the Government shall have only "Restricted Rights"
+ * in the software and related documentation as defined in the Federal
+ * Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
+ * are acquiring the software on behalf of the Department of Defense,
+ * the software shall be classified as "Commercial Computer Software"
+ * and the Government shall have only "Restricted Rights" as defined
+ * in Clause 252.227-7013 (c) (1) of DFARs.  Notwithstanding the
+ * foregoing, the authors grant the U.S. Government and others acting
+ * in its behalf permission to use and distribute the software in
+ * accordance with the terms specified in this license.
+ *
+ */
+
+#ifndef __GTK_TEXT_TAG_H__
+#define __GTK_TEXT_TAG_H__
+
+
+#if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gdk/gdk.h>
+#include <gtk/gtkenums.h>
+
+/* Not needed, retained for compatibility -Yosh */
+#include <gtk/gtkobject.h>
+
+
+G_BEGIN_DECLS
+
+typedef struct _GtkTextIter GtkTextIter;
+typedef struct _GtkTextTagTable GtkTextTagTable;
+
+typedef struct _GtkTextAttributes GtkTextAttributes;
+
+#define GTK_TYPE_TEXT_TAG            (gtk_text_tag_get_type ())
+#define GTK_TEXT_TAG(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_TAG, GtkTextTag))
+#define GTK_TEXT_TAG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_TAG, GtkTextTagClass))
+#define GTK_IS_TEXT_TAG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_TAG))
+#define GTK_IS_TEXT_TAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_TAG))
+#define GTK_TEXT_TAG_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_TAG, GtkTextTagClass))
+
+#define GTK_TYPE_TEXT_ATTRIBUTES     (gtk_text_attributes_get_type ())
+
+typedef struct _GtkTextTag GtkTextTag;
+typedef struct _GtkTextTagClass GtkTextTagClass;
+
+struct _GtkTextTag
+{
+  GObject parent_instance;
+
+  GtkTextTagTable *GSEAL (table);
+
+  char *GSEAL (name);           /* Name of this tag.  This field is actually
+                                 * a pointer to the key from the entry in
+                                 * tkxt->tagTable, so it needn't be freed
+                                 * explicitly. */
+  int GSEAL (priority);  /* Priority of this tag within widget.  0
+                         * means lowest priority.  Exactly one tag
+                         * has each integer value between 0 and
+                         * numTags-1. */
+  /*
+   * Information for displaying text with this tag.  The information
+   * belows acts as an override on information specified by lower-priority
+   * tags.  If no value is specified, then the next-lower-priority tag
+   * on the text determins the value.  The text widget itself provides
+   * defaults if no tag specifies an override.
+   */
+
+  GtkTextAttributes *GSEAL (values);
+  
+  /* Flags for whether a given value is set; if a value is unset, then
+   * this tag does not affect it.
+   */
+  guint GSEAL (bg_color_set) : 1;
+  guint GSEAL (bg_stipple_set) : 1;
+  guint GSEAL (fg_color_set) : 1;
+  guint GSEAL (scale_set) : 1;
+  guint GSEAL (fg_stipple_set) : 1;
+  guint GSEAL (justification_set) : 1;
+  guint GSEAL (left_margin_set) : 1;
+  guint GSEAL (indent_set) : 1;
+  guint GSEAL (rise_set) : 1;
+  guint GSEAL (strikethrough_set) : 1;
+  guint GSEAL (right_margin_set) : 1;
+  guint GSEAL (pixels_above_lines_set) : 1;
+  guint GSEAL (pixels_below_lines_set) : 1;
+  guint GSEAL (pixels_inside_wrap_set) : 1;
+  guint GSEAL (tabs_set) : 1;
+  guint GSEAL (underline_set) : 1;
+  guint GSEAL (wrap_mode_set) : 1;
+  guint GSEAL (bg_full_height_set) : 1;
+  guint GSEAL (invisible_set) : 1;
+  guint GSEAL (editable_set) : 1;
+  guint GSEAL (language_set) : 1;
+  guint GSEAL (pg_bg_color_set) : 1;
+
+  /* Whether these margins accumulate or override */
+  guint GSEAL (accumulative_margin) : 1;
+
+  guint GSEAL (pad1) : 1;
+};
+
+struct _GtkTextTagClass
+{
+  GObjectClass parent_class;
+
+  gboolean (* event) (GtkTextTag        *tag,
+                      GObject           *event_object, /* widget, canvas item, whatever */
+                      GdkEvent          *event,        /* the event itself */
+                      const GtkTextIter *iter);        /* location of event in buffer */
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+GType        gtk_text_tag_get_type     (void) G_GNUC_CONST;
+GtkTextTag  *gtk_text_tag_new          (const gchar       *name);
+gint         gtk_text_tag_get_priority (GtkTextTag        *tag);
+void         gtk_text_tag_set_priority (GtkTextTag        *tag,
+                                        gint               priority);
+gboolean     gtk_text_tag_event        (GtkTextTag        *tag,
+                                        GObject           *event_object,
+                                        GdkEvent          *event,
+                                        const GtkTextIter *iter);
+
+/*
+ * Style object created by folding a set of tags together
+ */
+
+typedef struct _GtkTextAppearance GtkTextAppearance;
+
+struct _GtkTextAppearance
+{
+  /*< public >*/
+  GdkColor bg_color;
+  GdkColor fg_color;
+  GdkBitmap *bg_stipple;
+  GdkBitmap *fg_stipple;
+
+  /* super/subscript rise, can be negative */
+  gint rise;
+
+  /*< private >*/
+  /* I'm not sure this can really be used without breaking some things
+   * an app might do :-/
+   */
+  gpointer padding1;
+
+  /*< public >*/
+  guint underline : 4;          /* PangoUnderline */
+  guint strikethrough : 1;
+
+  /* Whether to use background-related values; this is irrelevant for
+   * the values struct when in a tag, but is used for the composite
+   * values struct; it's true if any of the tags being composited
+   * had background stuff set.
+   */
+  guint draw_bg : 1;
+  
+  /* These are only used when we are actually laying out and rendering
+   * a paragraph; not when a GtkTextAppearance is part of a
+   * GtkTextAttributes.
+   */
+  guint inside_selection : 1;
+  guint is_text : 1;
+
+  /*< private >*/
+  guint pad1 : 1;
+  guint pad2 : 1;
+  guint pad3 : 1;
+  guint pad4 : 1;
+};
+
+struct _GtkTextAttributes
+{
+  /*< private >*/
+  guint refcount;
+
+  /*< public >*/
+  GtkTextAppearance appearance;
+
+  GtkJustification justification;
+  GtkTextDirection direction;
+
+  /* Individual chunks of this can be set/unset as a group */
+  PangoFontDescription *font;
+
+  gdouble font_scale;
+  
+  gint left_margin;
+
+  gint indent;  
+
+  gint right_margin;
+
+  gint pixels_above_lines;
+
+  gint pixels_below_lines;
+
+  gint pixels_inside_wrap;
+
+  PangoTabArray *tabs;
+
+  GtkWrapMode wrap_mode;        /* How to handle wrap-around for this tag.
+                                 * Must be GTK_WRAPMODE_CHAR,
+                                 * GTK_WRAPMODE_NONE, GTK_WRAPMODE_WORD
+                                 */
+
+  PangoLanguage *language;
+
+  /*< private >*/
+  GdkColor *pg_bg_color;
+
+  /*< public >*/
+  /* hide the text  */
+  guint invisible : 1;
+
+  /* Background is fit to full line height rather than
+   * baseline +/- ascent/descent (font height)
+   */
+  guint bg_full_height : 1;
+
+  /* can edit this text */
+  guint editable : 1;
+
+  /* colors are allocated etc. */
+  guint realized : 1;
+
+  /*< private >*/
+  guint pad1 : 1;
+  guint pad2 : 1;
+  guint pad3 : 1;
+  guint pad4 : 1;
+};
+
+GtkTextAttributes* gtk_text_attributes_new         (void);
+GtkTextAttributes* gtk_text_attributes_copy        (GtkTextAttributes *src);
+void               gtk_text_attributes_copy_values (GtkTextAttributes *src,
+                                                    GtkTextAttributes *dest);
+void               gtk_text_attributes_unref       (GtkTextAttributes *values);
+GtkTextAttributes *gtk_text_attributes_ref         (GtkTextAttributes *values);
+
+GType              gtk_text_attributes_get_type    (void) G_GNUC_CONST;
+
+
+G_END_DECLS
+
+#endif
+

data/vendor/local/include/gtk-2.0/gtk/gtktexttagtable.h

@@ -0,0 +1,101 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#ifndef __GTK_TEXT_TAG_TABLE_H__
+#define __GTK_TEXT_TAG_TABLE_H__
+
+#if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtktexttag.h>
+
+G_BEGIN_DECLS
+
+typedef void (* GtkTextTagTableForeach) (GtkTextTag *tag, gpointer data);
+
+#define GTK_TYPE_TEXT_TAG_TABLE            (gtk_text_tag_table_get_type ())
+#define GTK_TEXT_TAG_TABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_TAG_TABLE, GtkTextTagTable))
+#define GTK_TEXT_TAG_TABLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_TAG_TABLE, GtkTextTagTableClass))
+#define GTK_IS_TEXT_TAG_TABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_TAG_TABLE))
+#define GTK_IS_TEXT_TAG_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_TAG_TABLE))
+#define GTK_TEXT_TAG_TABLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_TAG_TABLE, GtkTextTagTableClass))
+
+typedef struct _GtkTextTagTableClass GtkTextTagTableClass;
+
+struct _GtkTextTagTable
+{
+  GObject parent_instance;
+
+  GHashTable *GSEAL (hash);
+  GSList *GSEAL (anonymous);
+  gint GSEAL (anon_count);
+
+  GSList *GSEAL (buffers);
+};
+
+struct _GtkTextTagTableClass
+{
+  GObjectClass parent_class;
+
+  void (* tag_changed) (GtkTextTagTable *table, GtkTextTag *tag, gboolean size_changed);
+  void (* tag_added) (GtkTextTagTable *table, GtkTextTag *tag);
+  void (* tag_removed) (GtkTextTagTable *table, GtkTextTag *tag);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+GType          gtk_text_tag_table_get_type (void) G_GNUC_CONST;
+
+GtkTextTagTable *gtk_text_tag_table_new      (void);
+void             gtk_text_tag_table_add      (GtkTextTagTable        *table,
+                                              GtkTextTag             *tag);
+void             gtk_text_tag_table_remove   (GtkTextTagTable        *table,
+                                              GtkTextTag             *tag);
+GtkTextTag      *gtk_text_tag_table_lookup   (GtkTextTagTable        *table,
+                                              const gchar            *name);
+void             gtk_text_tag_table_foreach  (GtkTextTagTable        *table,
+                                              GtkTextTagTableForeach  func,
+                                              gpointer                data);
+gint             gtk_text_tag_table_get_size (GtkTextTagTable        *table);
+
+
+/* INTERNAL private stuff - not even exported from the library on
+ * many platforms
+ */
+void _gtk_text_tag_table_add_buffer    (GtkTextTagTable *table,
+                                        gpointer         buffer);
+void _gtk_text_tag_table_remove_buffer (GtkTextTagTable *table,
+                                        gpointer         buffer);
+
+G_END_DECLS
+
+#endif
+

data/vendor/local/include/gtk-2.0/gtk/gtktextview.h

@@ -0,0 +1,376 @@
+/* GTK - The GIMP Toolkit
+ * gtktextview.h Copyright (C) 2000 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#ifndef __GTK_TEXT_VIEW_H__
+#define __GTK_TEXT_VIEW_H__
+
+#if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtkcontainer.h>
+#include <gtk/gtkimcontext.h>
+#include <gtk/gtktextbuffer.h>
+#include <gtk/gtkmenu.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_TEXT_VIEW             (gtk_text_view_get_type ())
+#define GTK_TEXT_VIEW(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_VIEW, GtkTextView))
+#define GTK_TEXT_VIEW_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_VIEW, GtkTextViewClass))
+#define GTK_IS_TEXT_VIEW(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_VIEW))
+#define GTK_IS_TEXT_VIEW_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_VIEW))
+#define GTK_TEXT_VIEW_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_VIEW, GtkTextViewClass))
+
+typedef enum
+{
+  GTK_TEXT_WINDOW_PRIVATE,
+  GTK_TEXT_WINDOW_WIDGET,
+  GTK_TEXT_WINDOW_TEXT,
+  GTK_TEXT_WINDOW_LEFT,
+  GTK_TEXT_WINDOW_RIGHT,
+  GTK_TEXT_WINDOW_TOP,
+  GTK_TEXT_WINDOW_BOTTOM
+} GtkTextWindowType;
+
+#define GTK_TEXT_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
+
+typedef struct _GtkTextView GtkTextView;
+typedef struct _GtkTextViewClass GtkTextViewClass;
+
+/* Internal private types. */
+typedef struct _GtkTextWindow GtkTextWindow;
+typedef struct _GtkTextPendingScroll GtkTextPendingScroll;
+
+struct _GtkTextView
+{
+  GtkContainer parent_instance;
+
+  struct _GtkTextLayout *GSEAL (layout);
+  GtkTextBuffer *GSEAL (buffer);
+
+  guint GSEAL (selection_drag_handler);
+  guint GSEAL (scroll_timeout);
+
+  /* Default style settings */
+  gint GSEAL (pixels_above_lines);
+  gint GSEAL (pixels_below_lines);
+  gint GSEAL (pixels_inside_wrap);
+  GtkWrapMode GSEAL (wrap_mode);
+  GtkJustification GSEAL (justify);
+  gint GSEAL (left_margin);
+  gint GSEAL (right_margin);
+  gint GSEAL (indent);
+  PangoTabArray *GSEAL (tabs);
+  guint GSEAL (editable) : 1;
+
+  guint GSEAL (overwrite_mode) : 1;
+  guint GSEAL (cursor_visible) : 1;
+
+  /* if we have reset the IM since the last character entered */  
+  guint GSEAL (need_im_reset) : 1;
+
+  guint GSEAL (accepts_tab) : 1;
+
+  guint GSEAL (width_changed) : 1;
+
+  /* debug flag - means that we've validated onscreen since the
+   * last "invalidate" signal from the layout
+   */
+  guint GSEAL (onscreen_validated) : 1;
+
+  guint GSEAL (mouse_cursor_obscured) : 1;
+
+  GtkTextWindow *GSEAL (text_window);
+  GtkTextWindow *GSEAL (left_window);
+  GtkTextWindow *GSEAL (right_window);
+  GtkTextWindow *GSEAL (top_window);
+  GtkTextWindow *GSEAL (bottom_window);
+
+  GtkAdjustment *GSEAL (hadjustment);
+  GtkAdjustment *GSEAL (vadjustment);
+
+  gint GSEAL (xoffset);         /* Offsets between widget coordinates and buffer coordinates */
+  gint GSEAL (yoffset);
+  gint GSEAL (width);           /* Width and height of the buffer */
+  gint GSEAL (height);
+
+  /* The virtual cursor position is normally the same as the
+   * actual (strong) cursor position, except in two circumstances:
+   *
+   * a) When the cursor is moved vertically with the keyboard
+   * b) When the text view is scrolled with the keyboard
+   *
+   * In case a), virtual_cursor_x is preserved, but not virtual_cursor_y
+   * In case b), both virtual_cursor_x and virtual_cursor_y are preserved.
+   */
+  gint GSEAL (virtual_cursor_x);   /* -1 means use actual cursor position */
+  gint GSEAL (virtual_cursor_y);   /* -1 means use actual cursor position */
+
+  GtkTextMark *GSEAL (first_para_mark); /* Mark at the beginning of the first onscreen paragraph */
+  gint GSEAL (first_para_pixels);       /* Offset of top of screen in the first onscreen paragraph */
+
+  GtkTextMark *GSEAL (dnd_mark);
+  guint GSEAL (blink_timeout);
+
+  guint GSEAL (first_validate_idle);        /* Idle to revalidate onscreen portion, runs before resize */
+  guint GSEAL (incremental_validate_idle);  /* Idle to revalidate offscreen portions, runs after redraw */
+
+  GtkIMContext *GSEAL (im_context);
+  GtkWidget *GSEAL (popup_menu);
+
+  gint GSEAL (drag_start_x);
+  gint GSEAL (drag_start_y);
+
+  GSList *GSEAL (children);
+
+  GtkTextPendingScroll *GSEAL (pending_scroll);
+
+  gint GSEAL (pending_place_cursor_button);
+};
+
+struct _GtkTextViewClass
+{
+  GtkContainerClass parent_class;
+
+  void (* set_scroll_adjustments)   (GtkTextView    *text_view,
+                                     GtkAdjustment  *hadjustment,
+                                     GtkAdjustment  *vadjustment);
+
+  void (* populate_popup)           (GtkTextView    *text_view,
+                                     GtkMenu        *menu);
+
+  /* These are all RUN_ACTION signals for keybindings */
+
+  /* move insertion point */
+  void (* move_cursor) (GtkTextView    *text_view,
+                        GtkMovementStep step,
+                        gint            count,
+                        gboolean        extend_selection);
+
+  /* FIXME should be deprecated in favor of adding GTK_MOVEMENT_HORIZONTAL_PAGES
+   * or something in GTK 2.2, was put in to avoid adding enum values during
+   * the freeze.
+   */
+  void (* page_horizontally) (GtkTextView *text_view,
+                              gint         count,
+                              gboolean     extend_selection);
+
+  /* move the "anchor" (what Emacs calls the mark) to the cursor position */
+  void (* set_anchor)  (GtkTextView    *text_view);
+
+  /* Edits */
+  void (* insert_at_cursor)      (GtkTextView *text_view,
+                                  const gchar *str);
+  void (* delete_from_cursor)    (GtkTextView  *text_view,
+                                  GtkDeleteType type,
+                                  gint          count);
+  void (* backspace)             (GtkTextView *text_view);
+
+  /* cut copy paste */
+  void (* cut_clipboard)   (GtkTextView *text_view);
+  void (* copy_clipboard)  (GtkTextView *text_view);
+  void (* paste_clipboard) (GtkTextView *text_view);
+  /* overwrite */
+  void (* toggle_overwrite) (GtkTextView *text_view);
+
+  /* as of GTK+ 2.12 the "move-focus" signal has been moved to GtkWidget,
+   * so this is merley a virtual function now. Overriding it in subclasses
+   * continues to work though.
+   */
+  void (* move_focus)       (GtkTextView     *text_view,
+                             GtkDirectionType direction);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+  void (*_gtk_reserved5) (void);
+  void (*_gtk_reserved6) (void);
+  void (*_gtk_reserved7) (void);
+};
+
+GType          gtk_text_view_get_type              (void) G_GNUC_CONST;
+GtkWidget *    gtk_text_view_new                   (void);
+GtkWidget *    gtk_text_view_new_with_buffer       (GtkTextBuffer *buffer);
+void           gtk_text_view_set_buffer            (GtkTextView   *text_view,
+                                                    GtkTextBuffer *buffer);
+GtkTextBuffer *gtk_text_view_get_buffer            (GtkTextView   *text_view);
+gboolean       gtk_text_view_scroll_to_iter        (GtkTextView   *text_view,
+                                                    GtkTextIter   *iter,
+                                                    gdouble        within_margin,
+                                                    gboolean       use_align,
+                                                    gdouble        xalign,
+                                                    gdouble        yalign);
+void           gtk_text_view_scroll_to_mark        (GtkTextView   *text_view,
+                                                    GtkTextMark   *mark,
+                                                    gdouble        within_margin,
+                                                    gboolean       use_align,
+                                                    gdouble        xalign,
+                                                    gdouble        yalign);
+void           gtk_text_view_scroll_mark_onscreen  (GtkTextView   *text_view,
+                                                    GtkTextMark   *mark);
+gboolean       gtk_text_view_move_mark_onscreen    (GtkTextView   *text_view,
+                                                    GtkTextMark   *mark);
+gboolean       gtk_text_view_place_cursor_onscreen (GtkTextView   *text_view);
+
+void           gtk_text_view_get_visible_rect      (GtkTextView   *text_view,
+                                                    GdkRectangle  *visible_rect);
+void           gtk_text_view_set_cursor_visible    (GtkTextView   *text_view,
+                                                    gboolean       setting);
+gboolean       gtk_text_view_get_cursor_visible    (GtkTextView   *text_view);
+
+void           gtk_text_view_get_iter_location     (GtkTextView   *text_view,
+                                                    const GtkTextIter *iter,
+                                                    GdkRectangle  *location);
+void           gtk_text_view_get_iter_at_location  (GtkTextView   *text_view,
+                                                    GtkTextIter   *iter,
+                                                    gint           x,
+                                                    gint           y);
+void           gtk_text_view_get_iter_at_position  (GtkTextView   *text_view,
+                                                    GtkTextIter   *iter,
+						    gint          *trailing,
+                                                    gint           x,
+                                                    gint           y);
+void           gtk_text_view_get_line_yrange       (GtkTextView       *text_view,
+                                                    const GtkTextIter *iter,
+                                                    gint              *y,
+                                                    gint              *height);
+
+void           gtk_text_view_get_line_at_y         (GtkTextView       *text_view,
+                                                    GtkTextIter       *target_iter,
+                                                    gint               y,
+                                                    gint              *line_top);
+
+void gtk_text_view_buffer_to_window_coords (GtkTextView       *text_view,
+                                            GtkTextWindowType  win,
+                                            gint               buffer_x,
+                                            gint               buffer_y,
+                                            gint              *window_x,
+                                            gint              *window_y);
+void gtk_text_view_window_to_buffer_coords (GtkTextView       *text_view,
+                                            GtkTextWindowType  win,
+                                            gint               window_x,
+                                            gint               window_y,
+                                            gint              *buffer_x,
+                                            gint              *buffer_y);
+
+GtkAdjustment* gtk_text_view_get_hadjustment (GtkTextView *text_view);
+GtkAdjustment* gtk_text_view_get_vadjustment (GtkTextView *text_view);
+
+GdkWindow*        gtk_text_view_get_window      (GtkTextView       *text_view,
+                                                 GtkTextWindowType  win);
+GtkTextWindowType gtk_text_view_get_window_type (GtkTextView       *text_view,
+                                                 GdkWindow         *window);
+
+void gtk_text_view_set_border_window_size (GtkTextView       *text_view,
+                                           GtkTextWindowType  type,
+                                           gint               size);
+gint gtk_text_view_get_border_window_size (GtkTextView       *text_view,
+					   GtkTextWindowType  type);
+
+gboolean gtk_text_view_forward_display_line           (GtkTextView       *text_view,
+                                                       GtkTextIter       *iter);
+gboolean gtk_text_view_backward_display_line          (GtkTextView       *text_view,
+                                                       GtkTextIter       *iter);
+gboolean gtk_text_view_forward_display_line_end       (GtkTextView       *text_view,
+                                                       GtkTextIter       *iter);
+gboolean gtk_text_view_backward_display_line_start    (GtkTextView       *text_view,
+                                                       GtkTextIter       *iter);
+gboolean gtk_text_view_starts_display_line            (GtkTextView       *text_view,
+                                                       const GtkTextIter *iter);
+gboolean gtk_text_view_move_visually                  (GtkTextView       *text_view,
+                                                       GtkTextIter       *iter,
+                                                       gint               count);
+
+gboolean        gtk_text_view_im_context_filter_keypress        (GtkTextView       *text_view,
+                                                                 GdkEventKey       *event);
+void            gtk_text_view_reset_im_context                  (GtkTextView       *text_view);
+
+/* Adding child widgets */
+void gtk_text_view_add_child_at_anchor (GtkTextView          *text_view,
+                                        GtkWidget            *child,
+                                        GtkTextChildAnchor   *anchor);
+
+void gtk_text_view_add_child_in_window (GtkTextView          *text_view,
+                                        GtkWidget            *child,
+                                        GtkTextWindowType     which_window,
+                                        /* window coordinates */
+                                        gint                  xpos,
+                                        gint                  ypos);
+
+void gtk_text_view_move_child          (GtkTextView          *text_view,
+                                        GtkWidget            *child,
+                                        /* window coordinates */
+                                        gint                  xpos,
+                                        gint                  ypos);
+
+/* Default style settings (fallbacks if no tag affects the property) */
+
+void             gtk_text_view_set_wrap_mode          (GtkTextView      *text_view,
+                                                       GtkWrapMode       wrap_mode);
+GtkWrapMode      gtk_text_view_get_wrap_mode          (GtkTextView      *text_view);
+void             gtk_text_view_set_editable           (GtkTextView      *text_view,
+                                                       gboolean          setting);
+gboolean         gtk_text_view_get_editable           (GtkTextView      *text_view);
+void             gtk_text_view_set_overwrite          (GtkTextView      *text_view,
+						       gboolean          overwrite);
+gboolean         gtk_text_view_get_overwrite          (GtkTextView      *text_view);
+void		 gtk_text_view_set_accepts_tab        (GtkTextView	*text_view,
+						       gboolean		 accepts_tab);
+gboolean	 gtk_text_view_get_accepts_tab        (GtkTextView	*text_view);
+void             gtk_text_view_set_pixels_above_lines (GtkTextView      *text_view,
+                                                       gint              pixels_above_lines);
+gint             gtk_text_view_get_pixels_above_lines (GtkTextView      *text_view);
+void             gtk_text_view_set_pixels_below_lines (GtkTextView      *text_view,
+                                                       gint              pixels_below_lines);
+gint             gtk_text_view_get_pixels_below_lines (GtkTextView      *text_view);
+void             gtk_text_view_set_pixels_inside_wrap (GtkTextView      *text_view,
+                                                       gint              pixels_inside_wrap);
+gint             gtk_text_view_get_pixels_inside_wrap (GtkTextView      *text_view);
+void             gtk_text_view_set_justification      (GtkTextView      *text_view,
+                                                       GtkJustification  justification);
+GtkJustification gtk_text_view_get_justification      (GtkTextView      *text_view);
+void             gtk_text_view_set_left_margin        (GtkTextView      *text_view,
+                                                       gint              left_margin);
+gint             gtk_text_view_get_left_margin        (GtkTextView      *text_view);
+void             gtk_text_view_set_right_margin       (GtkTextView      *text_view,
+                                                       gint              right_margin);
+gint             gtk_text_view_get_right_margin       (GtkTextView      *text_view);
+void             gtk_text_view_set_indent             (GtkTextView      *text_view,
+                                                       gint              indent);
+gint             gtk_text_view_get_indent             (GtkTextView      *text_view);
+void             gtk_text_view_set_tabs               (GtkTextView      *text_view,
+                                                       PangoTabArray    *tabs);
+PangoTabArray*   gtk_text_view_get_tabs               (GtkTextView      *text_view);
+
+/* note that the return value of this changes with the theme */
+GtkTextAttributes* gtk_text_view_get_default_attributes (GtkTextView    *text_view);
+
+G_END_DECLS
+
+#endif /* __GTK_TEXT_VIEW_H__ */