reorganized static libs

1 files changed, 440 insertions, 0 deletions

diff --git a/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gtk/gtktextlayout.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gtk/gtktextlayout.h
new file mode 100644
index 00000000..cb357864
--- /dev/null
+++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gtk/gtktextlayout.h
@@ -0,0 +1,440 @@
+/* GTK - The GIMP Toolkit
+ * gtktextlayout.h
+ *
+ * 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
+ * Pango support by Owen Taylor
+ *
+ * This file can be used under your choice of two licenses, the LGPL
+ * and the original Tk license.
+ *
+ * LGPL:
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Original Tk license:
+ *
+ * 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.
+ *
+ */
+/*
+ * 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_LAYOUT_H__
+#define __GTK_TEXT_LAYOUT_H__
+
+/* This is a "semi-private" header; it is intended for
+ * use by the text widget, and the text canvas item,
+ * but that's all. We may have to install it so the
+ * canvas item can use it, but users are not supposed
+ * to use it.
+ */
+#ifndef GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
+#error "You are not supposed to be including this file; the equivalent public API is in gtktextview.h"
+#endif
+
+#include <gtk/gtktextbuffer.h>
+#include <gtk/gtktextiter.h>
+
+G_BEGIN_DECLS
+
+/* forward declarations that have to be here to avoid including
+ * gtktextbtree.h
+ */
+typedef struct _GtkTextLine     GtkTextLine;
+typedef struct _GtkTextLineData GtkTextLineData;
+
+#define GTK_TYPE_TEXT_LAYOUT             (gtk_text_layout_get_type ())
+#define GTK_TEXT_LAYOUT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_LAYOUT, GtkTextLayout))
+#define GTK_TEXT_LAYOUT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_LAYOUT, GtkTextLayoutClass))
+#define GTK_IS_TEXT_LAYOUT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_LAYOUT))
+#define GTK_IS_TEXT_LAYOUT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_LAYOUT))
+#define GTK_TEXT_LAYOUT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_LAYOUT, GtkTextLayoutClass))
+
+typedef struct _GtkTextLayout         GtkTextLayout;
+typedef struct _GtkTextLayoutClass    GtkTextLayoutClass;
+typedef struct _GtkTextLineDisplay    GtkTextLineDisplay;
+typedef struct _GtkTextCursorDisplay  GtkTextCursorDisplay;
+typedef struct _GtkTextAttrAppearance GtkTextAttrAppearance;
+
+struct _GtkTextLayout
+{
+  GObject parent_instance;
+
+  /* width of the display area on-screen,
+   * i.e. pixels we should wrap to fit inside. */
+  gint screen_width;
+
+  /* width/height of the total logical area being layed out */
+  gint width;
+  gint height;
+
+  /* Pixel offsets from the left and from the top to be used when we
+   * draw; these allow us to create left/top margins. We don't need
+   * anything special for bottom/right margins, because those don't
+   * affect drawing.
+   */
+  /* gint left_edge; */
+  /* gint top_edge; */
+
+  GtkTextBuffer *buffer;
+
+  /* Default style used if no tags override it */
+  GtkTextAttributes *default_style;
+
+  /* Pango contexts used for creating layouts */
+  PangoContext *ltr_context;
+  PangoContext *rtl_context;
+
+  /* A cache of one style; this is used to ensure
+   * we don't constantly regenerate the style
+   * over long runs with the same style. */
+  GtkTextAttributes *one_style_cache;
+
+  /* A cache of one line display. Getting the same line
+   * many times in a row is the most common case.
+   */
+  GtkTextLineDisplay *one_display_cache;
+
+  /* Whether we are allowed to wrap right now */
+  gint wrap_loop_count;
+  
+  /* Whether to show the insertion cursor */
+  guint cursor_visible : 1;
+
+  /* For what GtkTextDirection to draw cursor GTK_TEXT_DIR_NONE -
+   * means draw both cursors.
+   */
+  guint cursor_direction : 2;
+
+  /* The keyboard direction is used to default the alignment when
+     there are no strong characters.
+  */
+  guint keyboard_direction : 2;
+
+  /* The preedit string and attributes, if any */
+
+  gchar *preedit_string;
+  PangoAttrList *preedit_attrs;
+  gint preedit_len;
+  gint preedit_cursor;
+
+  guint overwrite_mode : 1;
+};
+
+struct _GtkTextLayoutClass
+{
+  GObjectClass parent_class;
+
+  /* Some portion of the layout was invalidated
+   */
+  void  (*invalidated)  (GtkTextLayout *layout);
+
+  /* A range of the layout changed appearance and possibly height
+   */
+  void  (*changed)              (GtkTextLayout     *layout,
+                                 gint               y,
+                                 gint               old_height,
+                                 gint               new_height);
+  GtkTextLineData* (*wrap)      (GtkTextLayout     *layout,
+                                 GtkTextLine       *line,
+                                 GtkTextLineData   *line_data); /* may be NULL */
+  void  (*get_log_attrs)        (GtkTextLayout     *layout,
+                                 GtkTextLine       *line,
+                                 PangoLogAttr     **attrs,
+                                 gint              *n_attrs);
+  void  (*invalidate)           (GtkTextLayout     *layout,
+                                 const GtkTextIter *start,
+                                 const GtkTextIter *end);
+  void  (*free_line_data)       (GtkTextLayout     *layout,
+                                 GtkTextLine       *line,
+                                 GtkTextLineData   *line_data);
+
+  void (*allocate_child)        (GtkTextLayout     *layout,
+                                 GtkWidget         *child,
+                                 gint               x,
+                                 gint               y);
+
+  void (*invalidate_cursors)    (GtkTextLayout     *layout,
+                                 const GtkTextIter *start,
+                                 const GtkTextIter *end);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+};
+
+struct _GtkTextAttrAppearance
+{
+  PangoAttribute attr;
+  GtkTextAppearance appearance;
+};
+struct _GtkTextCursorDisplay
+{
+  gint x;
+  gint y;
+  gint height;
+  guint is_strong : 1;
+  guint is_weak : 1;
+};
+struct _GtkTextLineDisplay
+{
+  PangoLayout *layout;
+  GSList *cursors;
+  GSList *shaped_objects;	/* Only for backwards compatibility */
+  
+  GtkTextDirection direction;
+
+  gint width;                   /* Width of layout */
+  gint total_width;             /* width - margins, if no width set on layout, if width set on layout, -1 */
+  gint height;
+  /* Amount layout is shifted from left edge - this is the left margin
+   * plus any other factors, such as alignment or indentation.
+   */
+  gint x_offset;
+  gint left_margin;
+  gint right_margin;
+  gint top_margin;
+  gint bottom_margin;
+  gint insert_index;		/* Byte index of insert cursor within para or -1 */
+
+  gboolean size_only;
+  GtkTextLine *line;
+  
+  GdkColor *pg_bg_color;
+
+  GdkRectangle block_cursor;
+  guint cursors_invalid : 1;
+  guint has_block_cursor : 1;
+  guint cursor_at_line_end : 1;
+};
+
+extern PangoAttrType gtk_text_attr_appearance_type;
+
+GType         gtk_text_layout_get_type    (void) G_GNUC_CONST;
+
+GtkTextLayout*     gtk_text_layout_new                   (void);
+void               gtk_text_layout_set_buffer            (GtkTextLayout     *layout,
+							  GtkTextBuffer     *buffer);
+GtkTextBuffer     *gtk_text_layout_get_buffer            (GtkTextLayout     *layout);
+void               gtk_text_layout_set_default_style     (GtkTextLayout     *layout,
+							  GtkTextAttributes *values);
+void               gtk_text_layout_set_contexts          (GtkTextLayout     *layout,
+							  PangoContext      *ltr_context,
+							  PangoContext      *rtl_context);
+void               gtk_text_layout_set_cursor_direction  (GtkTextLayout     *layout,
+                                                          GtkTextDirection   direction);
+void		   gtk_text_layout_set_overwrite_mode	 (GtkTextLayout     *layout,
+							  gboolean           overwrite);
+void               gtk_text_layout_set_keyboard_direction (GtkTextLayout     *layout,
+							   GtkTextDirection keyboard_dir);
+void               gtk_text_layout_default_style_changed (GtkTextLayout     *layout);
+
+void gtk_text_layout_set_screen_width       (GtkTextLayout     *layout,
+                                             gint               width);
+void gtk_text_layout_set_preedit_string     (GtkTextLayout     *layout,
+ 					     const gchar       *preedit_string,
+ 					     PangoAttrList     *preedit_attrs,
+ 					     gint               cursor_pos);
+
+void     gtk_text_layout_set_cursor_visible (GtkTextLayout     *layout,
+                                             gboolean           cursor_visible);
+gboolean gtk_text_layout_get_cursor_visible (GtkTextLayout     *layout);
+
+/* Getting the size or the lines potentially results in a call to
+ * recompute, which is pretty massively expensive. Thus it should
+ * basically only be done in an idle handler.
+ *
+ * Long-term, we would really like to be able to do these without
+ * a full recompute so they may get cheaper over time.
+ */
+void    gtk_text_layout_get_size  (GtkTextLayout  *layout,
+                                   gint           *width,
+                                   gint           *height);
+GSList* gtk_text_layout_get_lines (GtkTextLayout  *layout,
+                                   /* [top_y, bottom_y) */
+                                   gint            top_y,
+                                   gint            bottom_y,
+                                   gint           *first_line_y);
+
+void gtk_text_layout_wrap_loop_start (GtkTextLayout *layout);
+void gtk_text_layout_wrap_loop_end   (GtkTextLayout *layout);
+
+GtkTextLineDisplay* gtk_text_layout_get_line_display  (GtkTextLayout      *layout,
+                                                       GtkTextLine        *line,
+                                                       gboolean            size_only);
+void                gtk_text_layout_free_line_display (GtkTextLayout      *layout,
+                                                       GtkTextLineDisplay *display);
+
+void gtk_text_layout_get_line_at_y     (GtkTextLayout     *layout,
+                                        GtkTextIter       *target_iter,
+                                        gint               y,
+                                        gint              *line_top);
+void gtk_text_layout_get_iter_at_pixel (GtkTextLayout     *layout,
+                                        GtkTextIter       *iter,
+                                        gint               x,
+                                        gint               y);
+void gtk_text_layout_get_iter_at_position (GtkTextLayout     *layout,
+					   GtkTextIter       *iter,
+					   gint              *trailing,
+					   gint               x,
+					   gint               y);
+void gtk_text_layout_invalidate        (GtkTextLayout     *layout,
+                                        const GtkTextIter *start,
+                                        const GtkTextIter *end);
+void gtk_text_layout_invalidate_cursors(GtkTextLayout     *layout,
+                                        const GtkTextIter *start,
+                                        const GtkTextIter *end);
+void gtk_text_layout_free_line_data    (GtkTextLayout     *layout,
+                                        GtkTextLine       *line,
+                                        GtkTextLineData   *line_data);
+
+gboolean gtk_text_layout_is_valid        (GtkTextLayout *layout);
+void     gtk_text_layout_validate_yrange (GtkTextLayout *layout,
+                                          GtkTextIter   *anchor_line,
+                                          gint           y0_,
+                                          gint           y1_);
+void     gtk_text_layout_validate        (GtkTextLayout *layout,
+                                          gint           max_pixels);
+
+/* This function should return the passed-in line data,
+ * OR remove the existing line data from the line, and
+ * return a NEW line data after adding it to the line.
+ * That is, invariant after calling the callback is that
+ * there should be exactly one line data for this view
+ * stored on the btree line.
+ */
+GtkTextLineData* gtk_text_layout_wrap  (GtkTextLayout   *layout,
+                                        GtkTextLine     *line,
+                                        GtkTextLineData *line_data); /* may be NULL */
+void     gtk_text_layout_changed              (GtkTextLayout     *layout,
+                                               gint               y,
+                                               gint               old_height,
+                                               gint               new_height);
+void     gtk_text_layout_cursors_changed      (GtkTextLayout     *layout,
+                                               gint               y,
+                                               gint               old_height,
+                                               gint               new_height);
+void     gtk_text_layout_get_iter_location    (GtkTextLayout     *layout,
+                                               const GtkTextIter *iter,
+                                               GdkRectangle      *rect);
+void     gtk_text_layout_get_line_yrange      (GtkTextLayout     *layout,
+                                               const GtkTextIter *iter,
+                                               gint              *y,
+                                               gint              *height);
+void     _gtk_text_layout_get_line_xrange     (GtkTextLayout     *layout,
+                                               const GtkTextIter *iter,
+                                               gint              *x,
+                                               gint              *width);
+void     gtk_text_layout_get_cursor_locations (GtkTextLayout     *layout,
+                                               GtkTextIter       *iter,
+                                               GdkRectangle      *strong_pos,
+                                               GdkRectangle      *weak_pos);
+gboolean _gtk_text_layout_get_block_cursor    (GtkTextLayout     *layout,
+					       GdkRectangle      *pos);
+gboolean gtk_text_layout_clamp_iter_to_vrange (GtkTextLayout     *layout,
+                                               GtkTextIter       *iter,
+                                               gint               top,
+                                               gint               bottom);
+
+gboolean gtk_text_layout_move_iter_to_line_end      (GtkTextLayout *layout,
+                                                     GtkTextIter   *iter,
+                                                     gint           direction);
+gboolean gtk_text_layout_move_iter_to_previous_line (GtkTextLayout *layout,
+                                                     GtkTextIter   *iter);
+gboolean gtk_text_layout_move_iter_to_next_line     (GtkTextLayout *layout,
+                                                     GtkTextIter   *iter);
+void     gtk_text_layout_move_iter_to_x             (GtkTextLayout *layout,
+                                                     GtkTextIter   *iter,
+                                                     gint           x);
+gboolean gtk_text_layout_move_iter_visually         (GtkTextLayout *layout,
+                                                     GtkTextIter   *iter,
+                                                     gint           count);
+
+gboolean gtk_text_layout_iter_starts_line           (GtkTextLayout       *layout,
+                                                     const GtkTextIter   *iter);
+
+void     gtk_text_layout_get_iter_at_line           (GtkTextLayout *layout,
+                                                     GtkTextIter    *iter,
+                                                     GtkTextLine    *line,
+                                                     gint            byte_offset);
+
+/* Don't use these. Use gtk_text_view_add_child_at_anchor().
+ * These functions are defined in gtktextchild.c, but here
+ * since they are semi-public and require GtkTextLayout to
+ * be declared.
+ */
+void gtk_text_child_anchor_register_child   (GtkTextChildAnchor *anchor,
+                                             GtkWidget          *child,
+                                             GtkTextLayout      *layout);
+void gtk_text_child_anchor_unregister_child (GtkTextChildAnchor *anchor,
+                                             GtkWidget          *child);
+
+void gtk_text_child_anchor_queue_resize     (GtkTextChildAnchor *anchor,
+                                             GtkTextLayout      *layout);
+
+void gtk_text_anchored_child_set_layout     (GtkWidget          *child,
+                                             GtkTextLayout      *layout);
+
+void gtk_text_layout_spew (GtkTextLayout *layout);
+
+G_END_DECLS
+
+#endif  /* __GTK_TEXT_LAYOUT_H__ */