/* 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 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__ */