/* GTK - The GIMP Toolkit

 * gtktextlayout.c - calculate the layout of the text

 *

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

 */

#define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API

#include "config.h"

#include "gtkmarshalers.h"

#include "gtktextlayout.h"

#include "gtktextbtree.h"

#include "gtktextiterprivate.h"

#include "gtktextutil.h"

#include "gtkintl.h"

#include "gtkalias.h"

#include <stdlib.h>

#include <string.h>

#define GTK_TEXT_LAYOUT_GET_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_TEXT_LAYOUT, GtkTextLayoutPrivate))

typedef struct _GtkTextLayoutPrivate GtkTextLayoutPrivate;

struct _GtkTextLayoutPrivate

{

  /* Cache the line that the cursor is positioned on, as the keyboard

     direction only influences the direction of the cursor line.

  */

  GtkTextLine *cursor_line;

};

static GtkTextLineData *gtk_text_layout_real_wrap (GtkTextLayout *layout,

                                                   GtkTextLine *line,

                                                   /* may be NULL */

                                                   GtkTextLineData *line_data);

static void gtk_text_layout_invalidated     (GtkTextLayout     *layout);

static void gtk_text_layout_real_invalidate        (GtkTextLayout     *layout,

						    const GtkTextIter *start,

						    const GtkTextIter *end);

static void gtk_text_layout_real_invalidate_cursors(GtkTextLayout     *layout,

						    const GtkTextIter *start,

						    const GtkTextIter *end);

static void gtk_text_layout_invalidate_cache       (GtkTextLayout     *layout,

						    GtkTextLine       *line,

						    gboolean           cursors_only);

static void gtk_text_layout_invalidate_cursor_line (GtkTextLayout     *layout,

						    gboolean           cursors_only);

static void gtk_text_layout_real_free_line_data    (GtkTextLayout     *layout,

						    GtkTextLine       *line,

						    GtkTextLineData   *line_data);

static void gtk_text_layout_emit_changed           (GtkTextLayout     *layout,

						    gint               y,

						    gint               old_height,

						    gint               new_height);

static void gtk_text_layout_invalidate_all (GtkTextLayout *layout);

static PangoAttribute *gtk_text_attr_appearance_new (const GtkTextAppearance *appearance);

static void gtk_text_layout_mark_set_handler    (GtkTextBuffer     *buffer,

						 const GtkTextIter *location,

						 GtkTextMark       *mark,

						 gpointer           data);

static void gtk_text_layout_buffer_insert_text  (GtkTextBuffer     *textbuffer,

						 GtkTextIter       *iter,

						 gchar             *str,

						 gint               len,

						 gpointer           data);

static void gtk_text_layout_buffer_delete_range (GtkTextBuffer     *textbuffer,

						 GtkTextIter       *start,

						 GtkTextIter       *end,

						 gpointer           data);

static void gtk_text_layout_update_cursor_line (GtkTextLayout *layout);

static void line_display_index_to_iter (GtkTextLayout      *layout,

	                                GtkTextLineDisplay *display,

			                GtkTextIter        *iter,

                                        gint                index,

                                        gint                trailing);

static gint line_display_iter_to_index (GtkTextLayout      *layout,

                                        GtkTextLineDisplay *display,

                                        const GtkTextIter  *iter);

enum {

  INVALIDATED,

  CHANGED,

  ALLOCATE_CHILD,

  LAST_SIGNAL

};

enum {

  ARG_0,

  LAST_ARG

};

#define PIXEL_BOUND(d) (((d) + PANGO_SCALE - 1) / PANGO_SCALE)

static void gtk_text_layout_finalize (GObject *object);

static guint signals[LAST_SIGNAL] = { 0 };

PangoAttrType gtk_text_attr_appearance_type = 0;

G_DEFINE_TYPE (GtkTextLayout, gtk_text_layout, G_TYPE_OBJECT)

static void

gtk_text_layout_class_init (GtkTextLayoutClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->finalize = gtk_text_layout_finalize;

  klass->wrap = gtk_text_layout_real_wrap;

  klass->invalidate = gtk_text_layout_real_invalidate;

  klass->invalidate_cursors = gtk_text_layout_real_invalidate_cursors;

  klass->free_line_data = gtk_text_layout_real_free_line_data;

  signals[INVALIDATED] =

    g_signal_new (I_("invalidated"),

                  G_OBJECT_CLASS_TYPE (object_class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkTextLayoutClass, invalidated),

                  NULL, NULL,

                  _gtk_marshal_VOID__VOID,

                  G_TYPE_NONE,

                  0);

  signals[CHANGED] =

    g_signal_new (I_("changed"),

                  G_OBJECT_CLASS_TYPE (object_class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkTextLayoutClass, changed),

                  NULL, NULL,

                  _gtk_marshal_VOID__INT_INT_INT,

                  G_TYPE_NONE,

                  3,

                  G_TYPE_INT,

                  G_TYPE_INT,

                  G_TYPE_INT);

  signals[ALLOCATE_CHILD] =

    g_signal_new (I_("allocate-child"),

                  G_OBJECT_CLASS_TYPE (object_class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkTextLayoutClass, allocate_child),

                  NULL, NULL,

                  _gtk_marshal_VOID__OBJECT_INT_INT,

                  G_TYPE_NONE,

                  3,

                  GTK_TYPE_OBJECT,

                  G_TYPE_INT,

                  G_TYPE_INT);

  g_type_class_add_private (object_class, sizeof (GtkTextLayoutPrivate));

}

static void

gtk_text_layout_init (GtkTextLayout *text_layout)

{

  text_layout->cursor_visible = TRUE;

}

GtkTextLayout*

gtk_text_layout_new (void)

{

  return g_object_new (GTK_TYPE_TEXT_LAYOUT, NULL);

}

static void

free_style_cache (GtkTextLayout *text_layout)

{

  if (text_layout->one_style_cache)

    {

      gtk_text_attributes_unref (text_layout->one_style_cache);

      text_layout->one_style_cache = NULL;

    }

}

static void

gtk_text_layout_finalize (GObject *object)

{

  GtkTextLayout *layout;

  layout = GTK_TEXT_LAYOUT (object);

  gtk_text_layout_set_buffer (layout, NULL);

  if (layout->default_style)

    gtk_text_attributes_unref (layout->default_style);

  layout->default_style = NULL;

  if (layout->ltr_context)

    {

      g_object_unref (layout->ltr_context);

      layout->ltr_context = NULL;

    }

  if (layout->rtl_context)

    {

      g_object_unref (layout->rtl_context);

      layout->rtl_context = NULL;

    }

  if (layout->one_display_cache) 

    {

      GtkTextLineDisplay *tmp_display = layout->one_display_cache;

      layout->one_display_cache = NULL;

      gtk_text_layout_free_line_display (layout, tmp_display);

    }

  if (layout->preedit_string)

    {

      g_free (layout->preedit_string);

      layout->preedit_string = NULL;

    }

  if (layout->preedit_attrs)

    {

      pango_attr_list_unref (layout->preedit_attrs);

      layout->preedit_attrs = NULL;

    }

  G_OBJECT_CLASS (gtk_text_layout_parent_class)->finalize (object);

}

/**

 * gtk_text_layout_set_buffer:

 * @buffer: (allow-none):

 */

void

gtk_text_layout_set_buffer (GtkTextLayout *layout,

                            GtkTextBuffer *buffer)

{

  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));

  g_return_if_fail (buffer == NULL || GTK_IS_TEXT_BUFFER (buffer));

  if (layout->buffer == buffer)

    return;

  free_style_cache (layout);

  if (layout->buffer)

    {

      _gtk_text_btree_remove_view (_gtk_text_buffer_get_btree (layout->buffer),

                                  layout);

      g_signal_handlers_disconnect_by_func (layout->buffer, 

                                            G_CALLBACK (gtk_text_layout_mark_set_handler), 

                                            layout);

      g_signal_handlers_disconnect_by_func (layout->buffer, 

                                            G_CALLBACK (gtk_text_layout_buffer_insert_text), 

                                            layout);

      g_signal_handlers_disconnect_by_func (layout->buffer, 

                                            G_CALLBACK (gtk_text_layout_buffer_delete_range), 

                                            layout);

      g_object_unref (layout->buffer);

      layout->buffer = NULL;

    }

  if (buffer)

    {

      layout->buffer = buffer;

      g_object_ref (buffer);

      _gtk_text_btree_add_view (_gtk_text_buffer_get_btree (buffer), layout);

      /* Bind to all signals that move the insert mark. */

      g_signal_connect_after (layout->buffer, "mark-set",

                              G_CALLBACK (gtk_text_layout_mark_set_handler), layout);

      g_signal_connect_after (layout->buffer, "insert-text",

                              G_CALLBACK (gtk_text_layout_buffer_insert_text), layout);

      g_signal_connect_after (layout->buffer, "delete-range",

                              G_CALLBACK (gtk_text_layout_buffer_delete_range), layout);

      gtk_text_layout_update_cursor_line (layout);

    }

}

void

gtk_text_layout_default_style_changed (GtkTextLayout *layout)

{

  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));

  DV (g_print ("invalidating all due to default style change (%s)\n", G_STRLOC));

  gtk_text_layout_invalidate_all (layout);

}

void

gtk_text_layout_set_default_style (GtkTextLayout *layout,

                                   GtkTextAttributes *values)

{

  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));

  g_return_if_fail (values != NULL);

  if (values == layout->default_style)

    return;

  gtk_text_attributes_ref (values);

  if (layout->default_style)

    gtk_text_attributes_unref (layout->default_style);

  layout->default_style = values;

  gtk_text_layout_default_style_changed (layout);

}

void

gtk_text_layout_set_contexts (GtkTextLayout *layout,

                              PangoContext  *ltr_context,

                              PangoContext  *rtl_context)

{

  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));

  if (layout->ltr_context != ltr_context)

    {

      if (layout->ltr_context)

	g_object_unref (layout->ltr_context);

      layout->ltr_context = ltr_context;

      g_object_ref (layout->ltr_context);

    }

  if (layout->rtl_context != rtl_context)

    {

      if (layout->rtl_context)

	g_object_unref (layout->rtl_context);

      layout->rtl_context = rtl_context;

      g_object_ref (layout->rtl_context);

    }

  DV (g_print ("invalidating all due to new pango contexts (%s)\n", G_STRLOC));

  gtk_text_layout_invalidate_all (layout);

}

/**

 * gtk_text_layout_set_overwrite_mode:

 * @layout: a #GtkTextLayout

 * @overwrite: overwrite mode

 *

 * Sets overwrite mode

 */

void

gtk_text_layout_set_overwrite_mode (GtkTextLayout *layout,

				    gboolean       overwrite)

{

  overwrite = overwrite != 0;

  if (overwrite != layout->overwrite_mode)

    {

      layout->overwrite_mode = overwrite;

      gtk_text_layout_invalidate_cursor_line (layout, TRUE);

    }

}

/**

 * gtk_text_layout_set_cursor_direction:

 * @direction: the new direction(s) for which to draw cursors.

 *             %GTK_TEXT_DIR_NONE means draw cursors for both

 *             left-to-right insertion and right-to-left insertion.

 *             (The two cursors will be visually distinguished.)

 * 

 * Sets which text directions (left-to-right and/or right-to-left) for

 * which cursors will be drawn for the insertion point. The visual

 * point at which new text is inserted depends on whether the new

 * text is right-to-left or left-to-right, so it may be desired to

 * make the drawn position of the cursor depend on the keyboard state.

 */

void

gtk_text_layout_set_cursor_direction (GtkTextLayout   *layout,

				      GtkTextDirection direction)

{

  if (direction != layout->cursor_direction)

    {

      layout->cursor_direction = direction;

      gtk_text_layout_invalidate_cursor_line (layout, TRUE);

    }

}

/**

 * gtk_text_layout_set_keyboard_direction:

 * @keyboard_dir: the current direction of the keyboard.

 *

 * Sets the keyboard direction; this is used as for the bidirectional

 * base direction for the line with the cursor if the line contains

 * only neutral characters.

 */

void

gtk_text_layout_set_keyboard_direction (GtkTextLayout   *layout,

					GtkTextDirection keyboard_dir)

{

  if (keyboard_dir != layout->keyboard_direction)

    {

      layout->keyboard_direction = keyboard_dir;

      gtk_text_layout_invalidate_cursor_line (layout, TRUE);

    }

}

/**

 * gtk_text_layout_get_buffer:

 * @layout: a #GtkTextLayout

 *

 * Gets the text buffer used by the layout. See

 * gtk_text_layout_set_buffer().

 *

 * Return value: the text buffer used by the layout.

 */

GtkTextBuffer *

gtk_text_layout_get_buffer (GtkTextLayout *layout)

{

  g_return_val_if_fail (GTK_IS_TEXT_LAYOUT (layout), NULL);

  return layout->buffer;

}

void

gtk_text_layout_set_screen_width (GtkTextLayout *layout, gint width)

{

  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));

  g_return_if_fail (width >= 0);

  g_return_if_fail (layout->wrap_loop_count == 0);

  if (layout->screen_width == width)

    return;

  layout->screen_width = width;

  DV (g_print ("invalidating all due to new screen width (%s)\n", G_STRLOC));

  gtk_text_layout_invalidate_all (layout);

}

/**

 * gtk_text_layout_set_cursor_visible:

 * @layout: a #GtkTextLayout

 * @cursor_visible: If %FALSE, then the insertion cursor will not

 *   be shown, even if the text is editable.

 *

 * Sets whether the insertion cursor should be shown. Generally,

 * widgets using #GtkTextLayout will hide the cursor when the

 * widget does not have the input focus.

 */

void

gtk_text_layout_set_cursor_visible (GtkTextLayout *layout,

                                    gboolean       cursor_visible)

{

  cursor_visible = (cursor_visible != FALSE);

  if (layout->cursor_visible != cursor_visible)

    {

      GtkTextIter iter;

      gint y, height;

      layout->cursor_visible = cursor_visible;

      /* Now queue a redraw on the paragraph containing the cursor

       */

      gtk_text_buffer_get_iter_at_mark (layout->buffer, &iter,

                                        gtk_text_buffer_get_insert (layout->buffer));

      gtk_text_layout_get_line_yrange (layout, &iter, &y, &height);

      gtk_text_layout_emit_changed (layout, y, height, height);

      gtk_text_layout_invalidate_cache (layout, _gtk_text_iter_get_text_line (&iter), TRUE);

    }

}

/**

 * gtk_text_layout_get_cursor_visible:

 * @layout: a #GtkTextLayout

 *

 * Returns whether the insertion cursor will be shown.

 *

 * Return value: if %FALSE, the insertion cursor will not be

 *     shown, even if the text is editable.

 */

gboolean

gtk_text_layout_get_cursor_visible (GtkTextLayout *layout)

{

  return layout->cursor_visible;

}

/**

 * gtk_text_layout_set_preedit_string:

 * @layout: a #PangoLayout

 * @preedit_string: a string to display at the insertion point

 * @preedit_attrs: a #PangoAttrList of attributes that apply to @preedit_string

 * @cursor_pos: position of cursor within preedit string in chars

 * 

 * Set the preedit string and attributes. The preedit string is a

 * string showing text that is currently being edited and not

 * yet committed into the buffer.

 */

void

gtk_text_layout_set_preedit_string (GtkTextLayout *layout,

				    const gchar   *preedit_string,

				    PangoAttrList *preedit_attrs,

				    gint           cursor_pos)

{

  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));

  g_return_if_fail (preedit_attrs != NULL || preedit_string == NULL);

  g_free (layout->preedit_string);

  if (layout->preedit_attrs)

    pango_attr_list_unref (layout->preedit_attrs);

  if (preedit_string)

    {

      layout->preedit_string = g_strdup (preedit_string);

      layout->preedit_len = strlen (layout->preedit_string);

      pango_attr_list_ref (preedit_attrs);

      layout->preedit_attrs = preedit_attrs;

      cursor_pos = CLAMP (cursor_pos, 0, g_utf8_strlen (layout->preedit_string, -1));

      layout->preedit_cursor = g_utf8_offset_to_pointer (layout->preedit_string, cursor_pos) - layout->preedit_string;

    }

  else

    {

      layout->preedit_string = NULL;

      layout->preedit_len = 0;

      layout->preedit_attrs = NULL;

      layout->preedit_cursor = 0;

    }

  gtk_text_layout_invalidate_cursor_line (layout, FALSE);

}

void

gtk_text_layout_get_size (GtkTextLayout *layout,

                          gint *width,

                          gint *height)

{

  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));

  if (width)

    *width = layout->width;

  if (height)

    *height = layout->height;

}

static void

gtk_text_layout_invalidated (GtkTextLayout *layout)

{

  g_signal_emit (layout, signals[INVALIDATED], 0);

}

static void

gtk_text_layout_emit_changed (GtkTextLayout *layout,

			      gint           y,

			      gint           old_height,

			      gint           new_height)

{

  g_signal_emit (layout, signals[CHANGED], 0, y, old_height, new_height);

}

static void

text_layout_changed (GtkTextLayout *layout,

                     gint           y,

                     gint           old_height,

                     gint           new_height,

                     gboolean       cursors_only)

{

  /* Check if the range intersects our cached line display,

   * and invalidate the cached line if so.

   */

  if (layout->one_display_cache)

    {

      GtkTextLine *line = layout->one_display_cache->line;

      gint cache_y = _gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),

						    line, layout);

      gint cache_height = layout->one_display_cache->height;

      if (cache_y + cache_height > y && cache_y < y + old_height)

	gtk_text_layout_invalidate_cache (layout, line, cursors_only);

    }

  gtk_text_layout_emit_changed (layout, y, old_height, new_height);

}

void

gtk_text_layout_changed (GtkTextLayout *layout,

                         gint           y,

                         gint           old_height,

                         gint           new_height)

{

  text_layout_changed (layout, y, old_height, new_height, FALSE);

}

void

gtk_text_layout_cursors_changed (GtkTextLayout *layout,

                                 gint           y,

				 gint           old_height,

				 gint           new_height)

{

  text_layout_changed (layout, y, old_height, new_height, TRUE);

}

void

gtk_text_layout_free_line_data (GtkTextLayout     *layout,

                                GtkTextLine       *line,

                                GtkTextLineData   *line_data)

{

  GTK_TEXT_LAYOUT_GET_CLASS (layout)->free_line_data (layout, line, line_data);

}

void

gtk_text_layout_invalidate (GtkTextLayout *layout,

                            const GtkTextIter *start_index,

                            const GtkTextIter *end_index)

{

  GTK_TEXT_LAYOUT_GET_CLASS (layout)->invalidate (layout, start_index, end_index);

}

void

gtk_text_layout_invalidate_cursors (GtkTextLayout *layout,

				    const GtkTextIter *start_index,

				    const GtkTextIter *end_index)

{

  GTK_TEXT_LAYOUT_GET_CLASS (layout)->invalidate_cursors (layout, start_index, end_index);

}

GtkTextLineData*

gtk_text_layout_wrap (GtkTextLayout *layout,

                      GtkTextLine  *line,

                      /* may be NULL */

                      GtkTextLineData *line_data)

{

  return GTK_TEXT_LAYOUT_GET_CLASS (layout)->wrap (layout, line, line_data);

}

/**

 * gtk_text_layout_get_lines:

 *

 * Return value: (element-type GtkTextLine) (transfer container):

 */

GSList*

gtk_text_layout_get_lines (GtkTextLayout *layout,

                           /* [top_y, bottom_y) */

                           gint top_y,

                           gint bottom_y,

                           gint *first_line_y)

{

  GtkTextLine *first_btree_line;

  GtkTextLine *last_btree_line;

  GtkTextLine *line;

  GSList *retval;

  g_return_val_if_fail (GTK_IS_TEXT_LAYOUT (layout), NULL);

  g_return_val_if_fail (bottom_y > top_y, NULL);

  retval = NULL;

  first_btree_line =

    _gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),

                                   layout, top_y, first_line_y);

  if (first_btree_line == NULL)

    {

      /* off the bottom */

      return NULL;

    }

  /* -1 since bottom_y is one past */

  last_btree_line =

    _gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),

                                    layout, bottom_y - 1, NULL);

  if (!last_btree_line)

    last_btree_line =

      _gtk_text_btree_get_end_iter_line (_gtk_text_buffer_get_btree (layout->buffer));

  g_assert (last_btree_line != NULL);

  line = first_btree_line;

  while (TRUE)

    {

      retval = g_slist_prepend (retval, line);

      if (line == last_btree_line)

        break;

      line = _gtk_text_line_next_excluding_last (line);

    }

  retval = g_slist_reverse (retval);

  return retval;

}

static void

invalidate_cached_style (GtkTextLayout *layout)

{

  free_style_cache (layout);

}

/* These should be called around a loop which wraps a CONTIGUOUS bunch

 * of display lines. If the lines aren't contiguous you can't call

 * these.

 */

void

gtk_text_layout_wrap_loop_start (GtkTextLayout *layout)

{

  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));

  g_return_if_fail (layout->one_style_cache == NULL);

  layout->wrap_loop_count += 1;

}

void

gtk_text_layout_wrap_loop_end (GtkTextLayout *layout)

{

  g_return_if_fail (layout->wrap_loop_count > 0);

  layout->wrap_loop_count -= 1;

  if (layout->wrap_loop_count == 0)

    {

      /* We cache a some stuff if we're iterating over some lines wrapping

       * them. This cleans it up.

       */

      /* Nuke our cached style */

      invalidate_cached_style (layout);

      g_assert (layout->one_style_cache == NULL);

    }

}

static void

gtk_text_layout_invalidate_all (GtkTextLayout *layout)

{

  GtkTextIter start;

  GtkTextIter end;

  if (layout->buffer == NULL)

    return;

  gtk_text_buffer_get_bounds (layout->buffer, &start, &end;;

  gtk_text_layout_invalidate (layout, &start, &end;;

}

static void

gtk_text_layout_invalidate_cache (GtkTextLayout *layout,

                                  GtkTextLine   *line,

				  gboolean       cursors_only)

{

  if (layout->one_display_cache && line == layout->one_display_cache->line)

    {

      GtkTextLineDisplay *display = layout->one_display_cache;

      if (cursors_only)

	{

	  g_slist_foreach (display->cursors, (GFunc)g_free, NULL);

	  g_slist_free (display->cursors);

	  display->cursors = NULL;

	  display->cursors_invalid = TRUE;

	  display->has_block_cursor = FALSE;

	}

      else

	{

	  layout->one_display_cache = NULL;

	  gtk_text_layout_free_line_display (layout, display);

	}

    }

}

/* Now invalidate the paragraph containing the cursor

 */

static void

gtk_text_layout_invalidate_cursor_line (GtkTextLayout *layout,

					gboolean cursors_only)

{

  GtkTextLayoutPrivate *priv = GTK_TEXT_LAYOUT_GET_PRIVATE (layout);

  GtkTextLineData *line_data;

  if (priv->cursor_line == NULL)

    return;

  line_data = _gtk_text_line_get_data (priv->cursor_line, layout);

  if (line_data)

    {

      if (cursors_only)

	  gtk_text_layout_invalidate_cache (layout, priv->cursor_line, TRUE);

      else

	{

	  gtk_text_layout_invalidate_cache (layout, priv->cursor_line, FALSE);

	  _gtk_text_line_invalidate_wrap (priv->cursor_line, line_data);

	}

      gtk_text_layout_invalidated (layout);

    }

}

static void

gtk_text_layout_update_cursor_line(GtkTextLayout *layout)

{

  GtkTextLayoutPrivate *priv = GTK_TEXT_LAYOUT_GET_PRIVATE (layout);

  GtkTextIter iter;

  gtk_text_buffer_get_iter_at_mark (layout->buffer, &iter,

                                    gtk_text_buffer_get_insert (layout->buffer));