Pileus Git - ~andy/gtk/blob - gtk/gtktextview.c

   1 /* -*- Mode: C; c-file-style: "gnu"; tab-width: 8 -*- */
   2 /* GTK - The GIMP Toolkit
   3  * gtktextview.c Copyright (C) 2000 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  23  * file for a list of people on the GTK+ Team.  See the ChangeLog
  24  * files for a list of changes.  These files are distributed with
  25  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  26  */
  27
  28 #include "config.h"
  29 #include <string.h>
  30
  31 #define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
  32 #include "gtkbindings.h"
  33 #include "gtkdnd.h"
  34 #include "gtkimagemenuitem.h"
  35 #include "gtkintl.h"
  36 #include "gtkmain.h"
  37 #include "gtkmarshalers.h"
  38 #include "gtkmenu.h"
  39 #include "gtkmenuitem.h"
  40 #include "gtkseparatormenuitem.h"
  41 #include "gtksettings.h"
  42 #include "gtkstock.h"
  43 #include "gtktextbufferrichtext.h"
  44 #include "gtktextdisplay.h"
  45 #include "gtktextview.h"
  46 #include "gtkimmulticontext.h"
  47 #include "gdk/gdkkeysyms.h"
  48 #include "gtkprivate.h"
  49 #include "gtktextutil.h"
  50 #include "gtkwindow.h"
  51 #include "gtkalias.h"
  52
  53 /* How scrolling, validation, exposes, etc. work.
  54  *
  55  * The expose_event handler has the invariant that the onscreen lines
  56  * have been validated.
  57  *
  58  * There are two ways that onscreen lines can become invalid. The first
  59  * is to change which lines are onscreen. This happens when the value
  60  * of a scroll adjustment changes. So the code path begins in
  61  * gtk_text_view_value_changed() and goes like this:
  62  *   - gdk_window_scroll() to reflect the new adjustment value
  63  *   - validate the lines that were moved onscreen
  64  *   - gdk_window_process_updates() to handle the exposes immediately
  65  *
  66  * The second way is that you get the "invalidated" signal from the layout,
  67  * indicating that lines have become invalid. This code path begins in
  68  * invalidated_handler() and goes like this:
  69  *   - install high-priority idle which does the rest of the steps
  70  *   - if a scroll is pending from scroll_to_mark(), do the scroll,
  71  *     jumping to the gtk_text_view_value_changed() code path
  72  *   - otherwise, validate the onscreen lines
  73  *   - DO NOT process updates
  74  *
  75  * In both cases, validating the onscreen lines can trigger a scroll
  76  * due to maintaining the first_para on the top of the screen.
  77  * If validation triggers a scroll, we jump to the top of the code path
  78  * for value_changed, and bail out of the current code path.
  79  *
  80  * Also, in size_allocate, if we invalidate some lines from changing
  81  * the layout width, we need to go ahead and run the high-priority idle,
  82  * because GTK sends exposes right after doing the size allocates without
  83  * returning to the main loop. This is also why the high-priority idle
  84  * is at a higher priority than resizing.
  85  *
  86  */
  87
  88 #if 0
  89 #define DEBUG_VALIDATION_AND_SCROLLING
  90 #endif
  91
  92 #ifdef DEBUG_VALIDATION_AND_SCROLLING
  93 #define DV(x) (x)
  94 #else
  95 #define DV(x)
  96 #endif
  97
  98 #define SCREEN_WIDTH(widget) text_window_get_width (GTK_TEXT_VIEW (widget)->text_window)
  99 #define SCREEN_HEIGHT(widget) text_window_get_height (GTK_TEXT_VIEW (widget)->text_window)
 100
 101 #define SPACE_FOR_CURSOR 1
 102
 103 typedef struct _GtkTextViewPrivate GtkTextViewPrivate;
 104
 105 #define GTK_TEXT_VIEW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_TEXT_VIEW, GtkTextViewPrivate))
 106
 107 struct _GtkTextViewPrivate
 108 {
 109   guint blink_time;  /* time in msec the cursor has blinked since last user event */
 110   guint im_spot_idle;
 111   gchar *im_module;
 112 };
 113
 114
 115 struct _GtkTextPendingScroll
 116 {
 117   GtkTextMark   *mark;
 118   gdouble        within_margin;
 119   gboolean       use_align;
 120   gdouble        xalign;
 121   gdouble        yalign;
 122 };
 123
 124 enum
 125 {
 126   SET_SCROLL_ADJUSTMENTS,
 127   POPULATE_POPUP,
 128   MOVE_CURSOR,
 129   PAGE_HORIZONTALLY,
 130   SET_ANCHOR,
 131   INSERT_AT_CURSOR,
 132   DELETE_FROM_CURSOR,
 133   BACKSPACE,
 134   CUT_CLIPBOARD,
 135   COPY_CLIPBOARD,
 136   PASTE_CLIPBOARD,
 137   TOGGLE_OVERWRITE,
 138   MOVE_VIEWPORT,
 139   SELECT_ALL,
 140   TOGGLE_CURSOR_VISIBLE,
 141   LAST_SIGNAL
 142 };
 143
 144 enum
 145 {
 146   PROP_0,
 147   PROP_PIXELS_ABOVE_LINES,
 148   PROP_PIXELS_BELOW_LINES,
 149   PROP_PIXELS_INSIDE_WRAP,
 150   PROP_EDITABLE,
 151   PROP_WRAP_MODE,
 152   PROP_JUSTIFICATION,
 153   PROP_LEFT_MARGIN,
 154   PROP_RIGHT_MARGIN,
 155   PROP_INDENT,
 156   PROP_TABS,
 157   PROP_CURSOR_VISIBLE,
 158   PROP_BUFFER,
 159   PROP_OVERWRITE,
 160   PROP_ACCEPTS_TAB,
 161   PROP_IM_MODULE
 162 };
 163
 164 static void gtk_text_view_destroy              (GtkObject        *object);
 165 static void gtk_text_view_finalize             (GObject          *object);
 166 static void gtk_text_view_set_property         (GObject         *object,
 167                                                 guint            prop_id,
 168                                                 const GValue    *value,
 169                                                 GParamSpec      *pspec);
 170 static void gtk_text_view_get_property         (GObject         *object,
 171                                                 guint            prop_id,
 172                                                 GValue          *value,
 173                                                 GParamSpec      *pspec);
 174 static void gtk_text_view_size_request         (GtkWidget        *widget,
 175                                                 GtkRequisition   *requisition);
 176 static void gtk_text_view_size_allocate        (GtkWidget        *widget,
 177                                                 GtkAllocation    *allocation);
 178 static void gtk_text_view_realize              (GtkWidget        *widget);
 179 static void gtk_text_view_unrealize            (GtkWidget        *widget);
 180 static void gtk_text_view_style_set            (GtkWidget        *widget,
 181                                                 GtkStyle         *previous_style);
 182 static void gtk_text_view_direction_changed    (GtkWidget        *widget,
 183                                                 GtkTextDirection  previous_direction);
 184 static void gtk_text_view_grab_notify          (GtkWidget        *widget,
 185                                                 gboolean         was_grabbed);
 186 static void gtk_text_view_state_changed        (GtkWidget        *widget,
 187                                                 GtkStateType      previous_state);
 188
 189 static gint gtk_text_view_event                (GtkWidget        *widget,
 190                                                 GdkEvent         *event);
 191 static gint gtk_text_view_key_press_event      (GtkWidget        *widget,
 192                                                 GdkEventKey      *event);
 193 static gint gtk_text_view_key_release_event    (GtkWidget        *widget,
 194                                                 GdkEventKey      *event);
 195 static gint gtk_text_view_button_press_event   (GtkWidget        *widget,
 196                                                 GdkEventButton   *event);
 197 static gint gtk_text_view_button_release_event (GtkWidget        *widget,
 198                                                 GdkEventButton   *event);
 199 static gint gtk_text_view_focus_in_event       (GtkWidget        *widget,
 200                                                 GdkEventFocus    *event);
 201 static gint gtk_text_view_focus_out_event      (GtkWidget        *widget,
 202                                                 GdkEventFocus    *event);
 203 static gint gtk_text_view_motion_event         (GtkWidget        *widget,
 204                                                 GdkEventMotion   *event);
 205 static gint gtk_text_view_expose_event         (GtkWidget        *widget,
 206                                                 GdkEventExpose   *expose);
 207 static void gtk_text_view_draw_focus           (GtkWidget        *widget);
 208 static gboolean gtk_text_view_focus            (GtkWidget        *widget,
 209                                                 GtkDirectionType  direction);
 210 static void gtk_text_view_move_focus           (GtkWidget        *widget,
 211                                                 GtkDirectionType  direction_type);
 212 static void gtk_text_view_select_all           (GtkWidget        *widget,
 213                                                 gboolean          select);
 214
 215
 216 /* Source side drag signals */
 217 static void gtk_text_view_drag_begin       (GtkWidget        *widget,
 218                                             GdkDragContext   *context);
 219 static void gtk_text_view_drag_end         (GtkWidget        *widget,
 220                                             GdkDragContext   *context);
 221 static void gtk_text_view_drag_data_get    (GtkWidget        *widget,
 222                                             GdkDragContext   *context,
 223                                             GtkSelectionData *selection_data,
 224                                             guint             info,
 225                                             guint             time);
 226 static void gtk_text_view_drag_data_delete (GtkWidget        *widget,
 227                                             GdkDragContext   *context);
 228
 229 /* Target side drag signals */
 230 static void     gtk_text_view_drag_leave         (GtkWidget        *widget,
 231                                                   GdkDragContext   *context,
 232                                                   guint             time);
 233 static gboolean gtk_text_view_drag_motion        (GtkWidget        *widget,
 234                                                   GdkDragContext   *context,
 235                                                   gint              x,
 236                                                   gint              y,
 237                                                   guint             time);
 238 static gboolean gtk_text_view_drag_drop          (GtkWidget        *widget,
 239                                                   GdkDragContext   *context,
 240                                                   gint              x,
 241                                                   gint              y,
 242                                                   guint             time);
 243 static void     gtk_text_view_drag_data_received (GtkWidget        *widget,
 244                                                   GdkDragContext   *context,
 245                                                   gint              x,
 246                                                   gint              y,
 247                                                   GtkSelectionData *selection_data,
 248                                                   guint             info,
 249                                                   guint             time);
 250
 251 static void gtk_text_view_set_scroll_adjustments (GtkTextView   *text_view,
 252                                                   GtkAdjustment *hadj,
 253                                                   GtkAdjustment *vadj);
 254 static gboolean gtk_text_view_popup_menu         (GtkWidget     *widget);
 255
 256 static void gtk_text_view_move_cursor       (GtkTextView           *text_view,
 257                                              GtkMovementStep        step,
 258                                              gint                   count,
 259                                              gboolean               extend_selection);
 260 static void gtk_text_view_page_horizontally (GtkTextView          *text_view,
 261                                              gint                  count,
 262                                              gboolean              extend_selection);
 263 static gboolean gtk_text_view_move_viewport (GtkTextView           *text_view,
 264                                              GtkScrollStep          step,
 265                                              gint                   count);
 266 static void gtk_text_view_set_anchor       (GtkTextView           *text_view);
 267 static gboolean gtk_text_view_scroll_pages (GtkTextView           *text_view,
 268                                             gint                   count,
 269                                             gboolean               extend_selection);
 270 static gboolean gtk_text_view_scroll_hpages(GtkTextView           *text_view,
 271                                             gint                   count,
 272                                             gboolean               extend_selection);
 273 static void gtk_text_view_insert_at_cursor (GtkTextView           *text_view,
 274                                             const gchar           *str);
 275 static void gtk_text_view_delete_from_cursor (GtkTextView           *text_view,
 276                                               GtkDeleteType          type,
 277                                               gint                   count);
 278 static void gtk_text_view_backspace        (GtkTextView           *text_view);
 279 static void gtk_text_view_cut_clipboard    (GtkTextView           *text_view);
 280 static void gtk_text_view_copy_clipboard   (GtkTextView           *text_view);
 281 static void gtk_text_view_paste_clipboard  (GtkTextView           *text_view);
 282 static void gtk_text_view_toggle_overwrite (GtkTextView           *text_view);
 283 static void gtk_text_view_toggle_cursor_visible (GtkTextView      *text_view);
 284 static void gtk_text_view_compat_move_focus(GtkTextView           *text_view,
 285                                             GtkDirectionType       direction_type);
 286 static void gtk_text_view_unselect         (GtkTextView           *text_view);
 287
 288 static void     gtk_text_view_validate_onscreen     (GtkTextView        *text_view);
 289 static void     gtk_text_view_get_first_para_iter   (GtkTextView        *text_view,
 290                                                      GtkTextIter        *iter);
 291 static void     gtk_text_view_update_layout_width       (GtkTextView        *text_view);
 292 static void     gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
 293                                                          GtkTextAttributes *values,
 294                                                          GtkStyle           *style);
 295 static void     gtk_text_view_ensure_layout          (GtkTextView        *text_view);
 296 static void     gtk_text_view_destroy_layout         (GtkTextView        *text_view);
 297 static void     gtk_text_view_check_keymap_direction (GtkTextView        *text_view);
 298 static void     gtk_text_view_reset_im_context       (GtkTextView        *text_view);
 299 static void     gtk_text_view_start_selection_drag   (GtkTextView        *text_view,
 300                                                       const GtkTextIter  *iter,
 301                                                       GdkEventButton     *event);
 302 static gboolean gtk_text_view_end_selection_drag     (GtkTextView        *text_view);
 303 static void     gtk_text_view_start_selection_dnd    (GtkTextView        *text_view,
 304                                                       const GtkTextIter  *iter,
 305                                                       GdkEventMotion     *event);
 306 static void     gtk_text_view_check_cursor_blink     (GtkTextView        *text_view);
 307 static void     gtk_text_view_pend_cursor_blink      (GtkTextView        *text_view);
 308 static void     gtk_text_view_stop_cursor_blink      (GtkTextView        *text_view);
 309 static void     gtk_text_view_reset_blink_time       (GtkTextView        *text_view);
 310
 311 static void     gtk_text_view_value_changed                (GtkAdjustment *adj,
 312                                                             GtkTextView   *view);
 313 static void     gtk_text_view_commit_handler               (GtkIMContext  *context,
 314                                                             const gchar   *str,
 315                                                             GtkTextView   *text_view);
 316 static void     gtk_text_view_commit_text                  (GtkTextView   *text_view,
 317                                                             const gchar   *text);
 318 static void     gtk_text_view_preedit_changed_handler      (GtkIMContext  *context,
 319                                                             GtkTextView   *text_view);
 320 static gboolean gtk_text_view_retrieve_surrounding_handler (GtkIMContext  *context,
 321                                                             GtkTextView   *text_view);
 322 static gboolean gtk_text_view_delete_surrounding_handler   (GtkIMContext  *context,
 323                                                             gint           offset,
 324                                                             gint           n_chars,
 325                                                             GtkTextView   *text_view);
 326
 327 static void gtk_text_view_mark_set_handler       (GtkTextBuffer     *buffer,
 328                                                   const GtkTextIter *location,
 329                                                   GtkTextMark       *mark,
 330                                                   gpointer           data);
 331 static void gtk_text_view_target_list_notify     (GtkTextBuffer     *buffer,
 332                                                   const GParamSpec  *pspec,
 333                                                   gpointer           data);
 334 static void gtk_text_view_paste_done_handler     (GtkTextBuffer     *buffer,
 335                                                   GtkClipboard      *clipboard,
 336                                                   gpointer           data);
 337 static void gtk_text_view_get_cursor_location    (GtkTextView       *text_view,
 338                                                   GdkRectangle      *pos);
 339 static void gtk_text_view_get_virtual_cursor_pos (GtkTextView       *text_view,
 340                                                   gint              *x,
 341                                                   gint              *y);
 342 static void gtk_text_view_set_virtual_cursor_pos (GtkTextView       *text_view,
 343                                                   gint               x,
 344                                                   gint               y);
 345
 346 static GtkAdjustment* get_hadjustment            (GtkTextView       *text_view);
 347 static GtkAdjustment* get_vadjustment            (GtkTextView       *text_view);
 348
 349 static void gtk_text_view_do_popup               (GtkTextView       *text_view,
 350                                                   GdkEventButton    *event);
 351
 352 static void gtk_text_view_queue_scroll           (GtkTextView   *text_view,
 353                                                   GtkTextMark   *mark,
 354                                                   gdouble        within_margin,
 355                                                   gboolean       use_align,
 356                                                   gdouble        xalign,
 357                                                   gdouble        yalign);
 358
 359 static gboolean gtk_text_view_flush_scroll         (GtkTextView *text_view);
 360 static void     gtk_text_view_update_adjustments   (GtkTextView *text_view);
 361 static void     gtk_text_view_invalidate           (GtkTextView *text_view);
 362 static void     gtk_text_view_flush_first_validate (GtkTextView *text_view);
 363
 364 static void gtk_text_view_update_im_spot_location (GtkTextView *text_view);
 365
 366 /* Container methods */
 367 static void gtk_text_view_add    (GtkContainer *container,
 368                                   GtkWidget    *child);
 369 static void gtk_text_view_remove (GtkContainer *container,
 370                                   GtkWidget    *child);
 371 static void gtk_text_view_forall (GtkContainer *container,
 372                                   gboolean      include_internals,
 373                                   GtkCallback   callback,
 374                                   gpointer      callback_data);
 375
 376 /* FIXME probably need the focus methods. */
 377
 378 typedef struct _GtkTextViewChild GtkTextViewChild;
 379
 380 struct _GtkTextViewChild
 381 {
 382   GtkWidget *widget;
 383
 384   GtkTextChildAnchor *anchor;
 385
 386   gint from_top_of_line;
 387   gint from_left_of_buffer;
 388
 389   /* These are ignored if anchor != NULL */
 390   GtkTextWindowType type;
 391   gint x;
 392   gint y;
 393 };
 394
 395 static GtkTextViewChild* text_view_child_new_anchored      (GtkWidget          *child,
 396                                                             GtkTextChildAnchor *anchor,
 397                                                             GtkTextLayout      *layout);
 398 static GtkTextViewChild* text_view_child_new_window        (GtkWidget          *child,
 399                                                             GtkTextWindowType   type,
 400                                                             gint                x,
 401                                                             gint                y);
 402 static void              text_view_child_free              (GtkTextViewChild   *child);
 403 static void              text_view_child_set_parent_window (GtkTextView        *text_view,
 404                                                             GtkTextViewChild   *child);
 405
 406 struct _GtkTextWindow
 407 {
 408   GtkTextWindowType type;
 409   GtkWidget *widget;
 410   GdkWindow *window;
 411   GdkWindow *bin_window;
 412   GtkRequisition requisition;
 413   GdkRectangle allocation;
 414 };
 415
 416 static GtkTextWindow *text_window_new             (GtkTextWindowType  type,
 417                                                    GtkWidget         *widget,
 418                                                    gint               width_request,
 419                                                    gint               height_request);
 420 static void           text_window_free            (GtkTextWindow     *win);
 421 static void           text_window_realize         (GtkTextWindow     *win,
 422                                                    GtkWidget         *widget);
 423 static void           text_window_unrealize       (GtkTextWindow     *win);
 424 static void           text_window_size_allocate   (GtkTextWindow     *win,
 425                                                    GdkRectangle      *rect);
 426 static void           text_window_scroll          (GtkTextWindow     *win,
 427                                                    gint               dx,
 428                                                    gint               dy);
 429 static void           text_window_invalidate_rect (GtkTextWindow     *win,
 430                                                    GdkRectangle      *rect);
 431 static void           text_window_invalidate_cursors (GtkTextWindow  *win);
 432
 433 static gint           text_window_get_width       (GtkTextWindow     *win);
 434 static gint           text_window_get_height      (GtkTextWindow     *win);
 435
 436
 437 static guint signals[LAST_SIGNAL] = { 0 };
 438
 439 G_DEFINE_TYPE (GtkTextView, gtk_text_view, GTK_TYPE_CONTAINER)
 440
 441 static void
 442 add_move_binding (GtkBindingSet  *binding_set,
 443                   guint           keyval,
 444                   guint           modmask,
 445                   GtkMovementStep step,
 446                   gint            count)
 447 {
 448   g_assert ((modmask & GDK_SHIFT_MASK) == 0);
 449
 450   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
 451                                 "move-cursor", 3,
 452                                 G_TYPE_ENUM, step,
 453                                 G_TYPE_INT, count,
 454                                 G_TYPE_BOOLEAN, FALSE);
 455
 456   /* Selection-extending version */
 457   gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,
 458                                 "move-cursor", 3,
 459                                 G_TYPE_ENUM, step,
 460                                 G_TYPE_INT, count,
 461                                 G_TYPE_BOOLEAN, TRUE);
 462 }
 463
 464 static void
 465 gtk_text_view_class_init (GtkTextViewClass *klass)
 466 {
 467   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 468   GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
 469   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 470   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 471   GtkBindingSet *binding_set;
 472
 473   /* Default handlers and virtual methods
 474    */
 475   gobject_class->set_property = gtk_text_view_set_property;
 476   gobject_class->get_property = gtk_text_view_get_property;
 477
 478   object_class->destroy = gtk_text_view_destroy;
 479   gobject_class->finalize = gtk_text_view_finalize;
 480
 481   widget_class->realize = gtk_text_view_realize;
 482   widget_class->unrealize = gtk_text_view_unrealize;
 483   widget_class->style_set = gtk_text_view_style_set;
 484   widget_class->direction_changed = gtk_text_view_direction_changed;
 485   widget_class->grab_notify = gtk_text_view_grab_notify;
 486   widget_class->state_changed = gtk_text_view_state_changed;
 487   widget_class->size_request = gtk_text_view_size_request;
 488   widget_class->size_allocate = gtk_text_view_size_allocate;
 489   widget_class->event = gtk_text_view_event;
 490   widget_class->key_press_event = gtk_text_view_key_press_event;
 491   widget_class->key_release_event = gtk_text_view_key_release_event;
 492   widget_class->button_press_event = gtk_text_view_button_press_event;
 493   widget_class->button_release_event = gtk_text_view_button_release_event;
 494   widget_class->focus_in_event = gtk_text_view_focus_in_event;
 495   widget_class->focus_out_event = gtk_text_view_focus_out_event;
 496   widget_class->motion_notify_event = gtk_text_view_motion_event;
 497   widget_class->expose_event = gtk_text_view_expose_event;
 498   widget_class->focus = gtk_text_view_focus;
 499
 500   /* need to override the base class function via override_class_handler,
 501    * because the signal slot is not available in GtkWidgetCLass
 502    */
 503   g_signal_override_class_handler ("move-focus",
 504                                    GTK_TYPE_TEXT_VIEW,
 505                                    G_CALLBACK (gtk_text_view_move_focus));
 506
 507   widget_class->drag_begin = gtk_text_view_drag_begin;
 508   widget_class->drag_end = gtk_text_view_drag_end;
 509   widget_class->drag_data_get = gtk_text_view_drag_data_get;
 510   widget_class->drag_data_delete = gtk_text_view_drag_data_delete;
 511
 512   widget_class->drag_leave = gtk_text_view_drag_leave;
 513   widget_class->drag_motion = gtk_text_view_drag_motion;
 514   widget_class->drag_drop = gtk_text_view_drag_drop;
 515   widget_class->drag_data_received = gtk_text_view_drag_data_received;
 516
 517   widget_class->popup_menu = gtk_text_view_popup_menu;
 518
 519   container_class->add = gtk_text_view_add;
 520   container_class->remove = gtk_text_view_remove;
 521   container_class->forall = gtk_text_view_forall;
 522
 523   klass->move_cursor = gtk_text_view_move_cursor;
 524   klass->page_horizontally = gtk_text_view_page_horizontally;
 525   klass->set_anchor = gtk_text_view_set_anchor;
 526   klass->insert_at_cursor = gtk_text_view_insert_at_cursor;
 527   klass->delete_from_cursor = gtk_text_view_delete_from_cursor;
 528   klass->backspace = gtk_text_view_backspace;
 529   klass->cut_clipboard = gtk_text_view_cut_clipboard;
 530   klass->copy_clipboard = gtk_text_view_copy_clipboard;
 531   klass->paste_clipboard = gtk_text_view_paste_clipboard;
 532   klass->toggle_overwrite = gtk_text_view_toggle_overwrite;
 533   klass->move_focus = gtk_text_view_compat_move_focus;
 534   klass->set_scroll_adjustments = gtk_text_view_set_scroll_adjustments;
 535
 536   /*
 537    * Properties
 538    */
 539
 540   g_object_class_install_property (gobject_class,
 541                                    PROP_PIXELS_ABOVE_LINES,
 542                                    g_param_spec_int ("pixels-above-lines",
 543                                                      P_("Pixels Above Lines"),
 544                                                      P_("Pixels of blank space above paragraphs"),
 545                                                      0,
 546                                                      G_MAXINT,
 547                                                      0,
 548                                                      GTK_PARAM_READWRITE));
 549
 550   g_object_class_install_property (gobject_class,
 551                                    PROP_PIXELS_BELOW_LINES,
 552                                    g_param_spec_int ("pixels-below-lines",
 553                                                      P_("Pixels Below Lines"),
 554                                                      P_("Pixels of blank space below paragraphs"),
 555                                                      0,
 556                                                      G_MAXINT,
 557                                                      0,
 558                                                      GTK_PARAM_READWRITE));
 559
 560   g_object_class_install_property (gobject_class,
 561                                    PROP_PIXELS_INSIDE_WRAP,
 562                                    g_param_spec_int ("pixels-inside-wrap",
 563                                                      P_("Pixels Inside Wrap"),
 564                                                      P_("Pixels of blank space between wrapped lines in a paragraph"),
 565                                                      0,
 566                                                      G_MAXINT,
 567                                                      0,
 568                                                      GTK_PARAM_READWRITE));
 569
 570   g_object_class_install_property (gobject_class,
 571                                    PROP_EDITABLE,
 572                                    g_param_spec_boolean ("editable",
 573                                                          P_("Editable"),
 574                                                          P_("Whether the text can be modified by the user"),
 575                                                          TRUE,
 576                                                          GTK_PARAM_READWRITE));
 577
 578   g_object_class_install_property (gobject_class,
 579                                    PROP_WRAP_MODE,
 580                                    g_param_spec_enum ("wrap-mode",
 581                                                       P_("Wrap Mode"),
 582                                                       P_("Whether to wrap lines never, at word boundaries, or at character boundaries"),
 583                                                       GTK_TYPE_WRAP_MODE,
 584                                                       GTK_WRAP_NONE,
 585                                                       GTK_PARAM_READWRITE));
 586
 587   g_object_class_install_property (gobject_class,
 588                                    PROP_JUSTIFICATION,
 589                                    g_param_spec_enum ("justification",
 590                                                       P_("Justification"),
 591                                                       P_("Left, right, or center justification"),
 592                                                       GTK_TYPE_JUSTIFICATION,
 593                                                       GTK_JUSTIFY_LEFT,
 594                                                       GTK_PARAM_READWRITE));
 595
 596   g_object_class_install_property (gobject_class,
 597                                    PROP_LEFT_MARGIN,
 598                                    g_param_spec_int ("left-margin",
 599                                                      P_("Left Margin"),
 600                                                      P_("Width of the left margin in pixels"),
 601                                                      0,
 602                                                      G_MAXINT,
 603                                                      0,
 604                                                      GTK_PARAM_READWRITE));
 605
 606   g_object_class_install_property (gobject_class,
 607                                    PROP_RIGHT_MARGIN,
 608                                    g_param_spec_int ("right-margin",
 609                                                      P_("Right Margin"),
 610                                                      P_("Width of the right margin in pixels"),
 611                                                      0,
 612                                                      G_MAXINT,
 613                                                      0,
 614                                                      GTK_PARAM_READWRITE));
 615
 616   g_object_class_install_property (gobject_class,
 617                                    PROP_INDENT,
 618                                    g_param_spec_int ("indent",
 619                                                      P_("Indent"),
 620                                                      P_("Amount to indent the paragraph, in pixels"),
 621                                                      G_MININT,
 622                                                      G_MAXINT,
 623                                                      0,
 624                                                      GTK_PARAM_READWRITE));
 625
 626   g_object_class_install_property (gobject_class,
 627                                    PROP_TABS,
 628                                    g_param_spec_boxed ("tabs",
 629                                                        P_("Tabs"),
 630                                                        P_("Custom tabs for this text"),
 631                                                        PANGO_TYPE_TAB_ARRAY,
 632                                                        GTK_PARAM_READWRITE));
 633
 634   g_object_class_install_property (gobject_class,
 635                                    PROP_CURSOR_VISIBLE,
 636                                    g_param_spec_boolean ("cursor-visible",
 637                                                          P_("Cursor Visible"),
 638                                                          P_("If the insertion cursor is shown"),
 639                                                          TRUE,
 640                                                          GTK_PARAM_READWRITE));
 641
 642   g_object_class_install_property (gobject_class,
 643                                    PROP_BUFFER,
 644                                    g_param_spec_object ("buffer",
 645                                                         P_("Buffer"),
 646                                                         P_("The buffer which is displayed"),
 647                                                         GTK_TYPE_TEXT_BUFFER,
 648                                                         GTK_PARAM_READWRITE));
 649
 650   g_object_class_install_property (gobject_class,
 651                                    PROP_OVERWRITE,
 652                                    g_param_spec_boolean ("overwrite",
 653                                                          P_("Overwrite mode"),
 654                                                          P_("Whether entered text overwrites existing contents"),
 655                                                          FALSE,
 656                                                          GTK_PARAM_READWRITE));
 657
 658   g_object_class_install_property (gobject_class,
 659                                    PROP_ACCEPTS_TAB,
 660                                    g_param_spec_boolean ("accepts-tab",
 661                                                          P_("Accepts tab"),
 662                                                          P_("Whether Tab will result in a tab character being entered"),
 663                                                          TRUE,
 664                                                          GTK_PARAM_READWRITE));
 665
 666    /**
 667     * GtkTextView:im-module:
 668     *
 669     * Which IM (input method) module should be used for this entry.
 670     * See #GtkIMContext.
 671     *
 672     * Setting this to a non-%NULL value overrides the
 673     * system-wide IM module setting. See the GtkSettings
 674     * #GtkSettings:gtk-im-module property.
 675     *
 676     * Since: 2.16
 677     */
 678    g_object_class_install_property (gobject_class,
 679                                     PROP_IM_MODULE,
 680                                     g_param_spec_string ("im-module",
 681                                                          P_("IM module"),
 682                                                          P_("Which IM module should be used"),
 683                                                          NULL,
 684                                                          GTK_PARAM_READWRITE));
 685
 686   /*
 687    * Style properties
 688    */
 689   gtk_widget_class_install_style_property (widget_class,
 690                                            g_param_spec_boxed ("error-underline-color",
 691                                                                P_("Error underline color"),
 692                                                                P_("Color with which to draw error-indication underlines"),
 693                                                                GDK_TYPE_COLOR,
 694                                                                GTK_PARAM_READABLE));
 695
 696   /*
 697    * Signals
 698    */
 699
 700   /**
 701    * GtkTextView::move-cursor:
 702    * @text_view: the object which received the signal
 703    * @step: the granularity of the move, as a #GtkMovementStep
 704    * @count: the number of @step units to move
 705    * @extend_selection: %TRUE if the move should extend the selection
 706    *
 707    * The ::move-cursor signal is a
 708    * <link linkend="keybinding-signals">keybinding signal</link>
 709    * which gets emitted when the user initiates a cursor movement.
 710    * If the cursor is not visible in @text_view, this signal causes
 711    * the viewport to be moved instead.
 712    *
 713    * Applications should not connect to it, but may emit it with
 714    * g_signal_emit_by_name() if they need to control the cursor
 715    * programmatically.
 716    *
 717    * The default bindings for this signal come in two variants,
 718    * the variant with the Shift modifier extends the selection,
 719    * the variant without the Shift modifer does not.
 720    * There are too many key combinations to list them all here.
 721    * <itemizedlist>
 722    * <listitem>Arrow keys move by individual characters/lines</listitem>
 723    * <listitem>Ctrl-arrow key combinations move by words/paragraphs</listitem>
 724    * <listitem>Home/End keys move to the ends of the buffer</listitem>
 725    * <listitem>PageUp/PageDown keys move vertically by pages</listitem>
 726    * <listitem>Ctrl-PageUp/PageDown keys move horizontally by pages</listitem>
 727    * </itemizedlist>
 728    */
 729   signals[MOVE_CURSOR] =
 730     g_signal_new (I_("move-cursor"),
 731                   G_OBJECT_CLASS_TYPE (gobject_class),
 732                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 733                   G_STRUCT_OFFSET (GtkTextViewClass, move_cursor),
 734                   NULL, NULL,
 735                   _gtk_marshal_VOID__ENUM_INT_BOOLEAN,
 736                   G_TYPE_NONE, 3,
 737                   GTK_TYPE_MOVEMENT_STEP,
 738                   G_TYPE_INT,
 739                   G_TYPE_BOOLEAN);
 740
 741   /**
 742    * GtkTextView::page-horizontally:
 743    * @text_view: the object which received the signal
 744    * @count: the number of @step units to move
 745    * @extend_selection: %TRUE if the move should extend the selection
 746    *
 747    * The ::page-horizontally signal is a
 748    * <link linkend="keybinding-signals">keybinding signal</link>
 749    * which can be bound to key combinations to allow the user
 750    * to initiate horizontal cursor movement by pages.
 751    *
 752    * This signal should not be used anymore, instead use the
 753    * #GtkTextview::move-cursor signal with the #GTK_MOVEMENT_HORIZONTAL_PAGES
 754    * granularity.
 755    */
 756   signals[PAGE_HORIZONTALLY] =
 757     g_signal_new (I_("page-horizontally"),
 758                   G_OBJECT_CLASS_TYPE (gobject_class),
 759                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 760                   G_STRUCT_OFFSET (GtkTextViewClass, page_horizontally),
 761                   NULL, NULL,
 762                   _gtk_marshal_VOID__INT_BOOLEAN,
 763                   G_TYPE_NONE, 2,
 764                   G_TYPE_INT,
 765                   G_TYPE_BOOLEAN);
 766
 767   /**
 768    * GtkTextView::move-viewport:
 769    * @text_view: the object which received the signal
 770    * @step: the granularity of the move, as a #GtkMovementStep
 771    * @count: the number of @step units to move
 772    *
 773    * The ::move-viewport signal is a
 774    * <link linkend="keybinding-signals">keybinding signal</link>
 775    * which can be bound to key combinations to allow the user
 776    * to move the viewport, i.e. change what part of the text view
 777    * is visible in a containing scrolled window.
 778    *
 779    * There are no default bindings for this signal.
 780    */
 781   signals[MOVE_VIEWPORT] =
 782     g_signal_new_class_handler (I_("move-viewport"),
 783                                 G_OBJECT_CLASS_TYPE (gobject_class),
 784                                 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 785                                 G_CALLBACK (gtk_text_view_move_viewport),
 786                                 NULL, NULL,
 787                                 _gtk_marshal_VOID__ENUM_INT,
 788                                 G_TYPE_NONE, 2,
 789                                 GTK_TYPE_SCROLL_STEP,
 790                                 G_TYPE_INT);
 791
 792   /**
 793    * GtkTextView::set-anchor:
 794    * @text_view: the object which received the signal
 795    *
 796    * The ::set-anchor signal is a
 797    * <link linkend="keybinding-signals">keybinding signal</link>
 798    * which gets emitted when the user initiates setting the "anchor"
 799    * mark. The "anchor" mark gets placed at the same position as the
 800    * "insert" mark.
 801    *
 802    * This signal has no default bindings.
 803    */
 804   signals[SET_ANCHOR] =
 805     g_signal_new (I_("set-anchor"),
 806                   G_OBJECT_CLASS_TYPE (gobject_class),
 807                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 808                   G_STRUCT_OFFSET (GtkTextViewClass, set_anchor),
 809                   NULL, NULL,
 810                   _gtk_marshal_VOID__VOID,
 811                   G_TYPE_NONE, 0);
 812
 813   /**
 814    * GtkTextView::insert-at-cursor:
 815    * @text_view: the object which received the signal
 816    * @string: the string to insert
 817    *
 818    * The ::insert-at-cursor signal is a
 819    * <link linkend="keybinding-signals">keybinding signal</link>
 820    * which gets emitted when the user initiates the insertion of a
 821    * fixed string at the cursor.
 822    *
 823    * This signal has no default bindings.
 824    */
 825   signals[INSERT_AT_CURSOR] =
 826     g_signal_new (I_("insert-at-cursor"),
 827                   G_OBJECT_CLASS_TYPE (gobject_class),
 828                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 829                   G_STRUCT_OFFSET (GtkTextViewClass, insert_at_cursor),
 830                   NULL, NULL,
 831                   _gtk_marshal_VOID__STRING,
 832                   G_TYPE_NONE, 1,
 833                   G_TYPE_STRING);
 834
 835   /**
 836    * GtkTextView::delete-from-cursor:
 837    * @text_view: the object which received the signal
 838    * @type: the granularity of the deletion, as a #GtkDeleteType
 839    * @count: the number of @type units to delete
 840    *
 841    * The ::delete-from-cursor signal is a
 842    * <link linkend="keybinding-signals">keybinding signal</link>
 843    * which gets emitted when the user initiates a text deletion.
 844    *
 845    * If the @type is %GTK_DELETE_CHARS, GTK+ deletes the selection
 846    * if there is one, otherwise it deletes the requested number
 847    * of characters.
 848    *
 849    * The default bindings for this signal are
 850    * Delete for deleting a character, Ctrl-Delete for
 851    * deleting a word and Ctrl-Backspace for deleting a word
 852    * backwords.
 853    */
 854   signals[DELETE_FROM_CURSOR] =
 855     g_signal_new (I_("delete-from-cursor"),
 856                   G_OBJECT_CLASS_TYPE (gobject_class),
 857                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 858                   G_STRUCT_OFFSET (GtkTextViewClass, delete_from_cursor),
 859                   NULL, NULL,
 860                   _gtk_marshal_VOID__ENUM_INT,
 861                   G_TYPE_NONE, 2,
 862                   GTK_TYPE_DELETE_TYPE,
 863                   G_TYPE_INT);
 864
 865   /**
 866    * GtkTextView::backspace:
 867    * @text_view: the object which received the signal
 868    *
 869    * The ::backspace signal is a
 870    * <link linkend="keybinding-signals">keybinding signal</link>
 871    * which gets emitted when the user asks for it.
 872    *
 873    * The default bindings for this signal are
 874    * Backspace and Shift-Backspace.
 875    */
 876   signals[BACKSPACE] =
 877     g_signal_new (I_("backspace"),
 878                   G_OBJECT_CLASS_TYPE (gobject_class),
 879                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 880                   G_STRUCT_OFFSET (GtkTextViewClass, backspace),
 881                   NULL, NULL,
 882                   _gtk_marshal_VOID__VOID,
 883                   G_TYPE_NONE, 0);
 884
 885   /**
 886    * GtkTextView::cut-clipboard:
 887    * @text_view: the object which received the signal
 888    *
 889    * The ::cut-clipboard signal is a
 890    * <link linkend="keybinding-signals">keybinding signal</link>
 891    * which gets emitted to cut the selection to the clipboard.
 892    *
 893    * The default bindings for this signal are
 894    * Ctrl-x and Shift-Delete.
 895    */
 896   signals[CUT_CLIPBOARD] =
 897     g_signal_new (I_("cut-clipboard"),
 898                   G_OBJECT_CLASS_TYPE (gobject_class),
 899                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 900                   G_STRUCT_OFFSET (GtkTextViewClass, cut_clipboard),
 901                   NULL, NULL,
 902                   _gtk_marshal_VOID__VOID,
 903                   G_TYPE_NONE, 0);
 904
 905   /**
 906    * GtkTextView::copy-clipboard:
 907    * @text_view: the object which received the signal
 908    *
 909    * The ::copy-clipboard signal is a
 910    * <link linkend="keybinding-signals">keybinding signal</link>
 911    * which gets emitted to copy the selection to the clipboard.
 912    *
 913    * The default bindings for this signal are
 914    * Ctrl-c and Ctrl-Insert.
 915    */
 916   signals[COPY_CLIPBOARD] =
 917     g_signal_new (I_("copy-clipboard"),
 918                   G_OBJECT_CLASS_TYPE (gobject_class),
 919                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 920                   G_STRUCT_OFFSET (GtkTextViewClass, copy_clipboard),
 921                   NULL, NULL,
 922                   _gtk_marshal_VOID__VOID,
 923                   G_TYPE_NONE, 0);
 924
 925   /**
 926    * GtkTextView::paste-clipboard:
 927    * @text_view: the object which received the signal
 928    *
 929    * The ::paste-clipboard signal is a
 930    * <link linkend="keybinding-signals">keybinding signal</link>
 931    * which gets emitted to paste the contents of the clipboard
 932    * into the text view.
 933    *
 934    * The default bindings for this signal are
 935    * Ctrl-v and Shift-Insert.
 936    */
 937   signals[PASTE_CLIPBOARD] =
 938     g_signal_new (I_("paste-clipboard"),
 939                   G_OBJECT_CLASS_TYPE (gobject_class),
 940                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 941                   G_STRUCT_OFFSET (GtkTextViewClass, paste_clipboard),
 942                   NULL, NULL,
 943                   _gtk_marshal_VOID__VOID,
 944                   G_TYPE_NONE, 0);
 945
 946   /**
 947    * GtkTextView::toggle-overwrite:
 948    * @text_view: the object which received the signal
 949    *
 950    * The ::toggle-overwrite signal is a
 951    * <link linkend="keybinding-signals">keybinding signal</link>
 952    * which gets emitted to toggle the overwrite mode of the text view.
 953    *
 954    * The default bindings for this signal is Insert.
 955    */
 956   signals[TOGGLE_OVERWRITE] =
 957     g_signal_new (I_("toggle-overwrite"),
 958                   G_OBJECT_CLASS_TYPE (gobject_class),
 959                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 960                   G_STRUCT_OFFSET (GtkTextViewClass, toggle_overwrite),
 961                   NULL, NULL,
 962                   _gtk_marshal_VOID__VOID,
 963                   G_TYPE_NONE, 0);
 964
 965   /**
 966    * GtkTextView::set-scroll-adjustments
 967    * @horizontal: the horizontal #GtkAdjustment
 968    * @vertical: the vertical #GtkAdjustment
 969    *
 970    * Set the scroll adjustments for the text view. Usually scrolled containers
 971    * like #GtkScrolledWindow will emit this signal to connect two instances
 972    * of #GtkScrollbar to the scroll directions of the #GtkTextView.
 973    */
 974   signals[SET_SCROLL_ADJUSTMENTS] =
 975     g_signal_new (I_("set-scroll-adjustments"),
 976                   G_OBJECT_CLASS_TYPE (gobject_class),
 977                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 978                   G_STRUCT_OFFSET (GtkTextViewClass, set_scroll_adjustments),
 979                   NULL, NULL,
 980                   _gtk_marshal_VOID__OBJECT_OBJECT,
 981                   G_TYPE_NONE, 2,
 982                   GTK_TYPE_ADJUSTMENT,
 983                   GTK_TYPE_ADJUSTMENT);
 984   widget_class->set_scroll_adjustments_signal = signals[SET_SCROLL_ADJUSTMENTS];
 985
 986   /**
 987    * GtkTextView::populate-popup:
 988    * @entry: The text view on which the signal is emitted
 989    * @menu: the menu that is being populated
 990    *
 991    * The ::populate-popup signal gets emitted before showing the
 992    * context menu of the text view.
 993    *
 994    * If you need to add items to the context menu, connect
 995    * to this signal and append your menuitems to the @menu.
 996    */
 997   signals[POPULATE_POPUP] =
 998     g_signal_new (I_("populate-popup"),
 999                   G_OBJECT_CLASS_TYPE (gobject_class),
1000                   G_SIGNAL_RUN_LAST,
1001                   G_STRUCT_OFFSET (GtkTextViewClass, populate_popup),
1002                   NULL, NULL,
1003                   _gtk_marshal_VOID__OBJECT,
1004                   G_TYPE_NONE, 1,
1005                   GTK_TYPE_MENU);
1006
1007   /**
1008    * GtkTextView::select-all:
1009    * @text_view: the object which received the signal
1010    * @select: %TRUE to select, %FALSE to unselect
1011    *
1012    * The ::select-all signal is a
1013    * <link linkend="keybinding-signals">keybinding signal</link>
1014    * which gets emitted to select or unselect the complete
1015    * contents of the text view.
1016    *
1017    * The default bindings for this signal are Ctrl-a and Ctrl-/
1018    * for selecting and Shift-Ctrl-a and Ctrl-\ for unselecting.
1019    */
1020   signals[SELECT_ALL] =
1021     g_signal_new_class_handler (I_("select-all"),
1022                                 G_OBJECT_CLASS_TYPE (object_class),
1023                                 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1024                                 G_CALLBACK (gtk_text_view_select_all),
1025                                 NULL, NULL,
1026                                 _gtk_marshal_VOID__BOOLEAN,
1027                                 G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
1028
1029   /**
1030    * GtkTextView::toggle-cursor-visible:
1031    * @text_view: the object which received the signal
1032    *
1033    * The ::toggle-cursor-visible signal is a
1034    * <link linkend="keybinding-signals">keybinding signal</link>
1035    * which gets emitted to toggle the visibility of the cursor.
1036    *
1037    * The default binding for this signal is F7.
1038    */
1039   signals[TOGGLE_CURSOR_VISIBLE] =
1040     g_signal_new_class_handler (I_("toggle-cursor-visible"),
1041                                 G_OBJECT_CLASS_TYPE (object_class),
1042                                 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1043                                 G_CALLBACK (gtk_text_view_toggle_cursor_visible),
1044                                 NULL, NULL,
1045                                 _gtk_marshal_VOID__VOID,
1046                                 G_TYPE_NONE, 0);
1047
1048   /*
1049    * Key bindings
1050    */
1051
1052   binding_set = gtk_binding_set_by_class (klass);
1053
1054   /* Moving the insertion point */
1055   add_move_binding (binding_set, GDK_Right, 0,
1056                     GTK_MOVEMENT_VISUAL_POSITIONS, 1);
1057
1058   add_move_binding (binding_set, GDK_KP_Right, 0,
1059                     GTK_MOVEMENT_VISUAL_POSITIONS, 1);
1060
1061   add_move_binding (binding_set, GDK_Left, 0,
1062                     GTK_MOVEMENT_VISUAL_POSITIONS, -1);
1063
1064   add_move_binding (binding_set, GDK_KP_Left, 0,
1065                     GTK_MOVEMENT_VISUAL_POSITIONS, -1);
1066
1067   add_move_binding (binding_set, GDK_Right, GDK_CONTROL_MASK,
1068                     GTK_MOVEMENT_WORDS, 1);
1069
1070   add_move_binding (binding_set, GDK_KP_Right, GDK_CONTROL_MASK,
1071                     GTK_MOVEMENT_WORDS, 1);
1072
1073   add_move_binding (binding_set, GDK_Left, GDK_CONTROL_MASK,
1074                     GTK_MOVEMENT_WORDS, -1);
1075
1076   add_move_binding (binding_set, GDK_KP_Left, GDK_CONTROL_MASK,
1077                     GTK_MOVEMENT_WORDS, -1);
1078
1079   add_move_binding (binding_set, GDK_Up, 0,
1080                     GTK_MOVEMENT_DISPLAY_LINES, -1);
1081
1082   add_move_binding (binding_set, GDK_KP_Up, 0,
1083                     GTK_MOVEMENT_DISPLAY_LINES, -1);
1084
1085   add_move_binding (binding_set, GDK_Down, 0,
1086                     GTK_MOVEMENT_DISPLAY_LINES, 1);
1087
1088   add_move_binding (binding_set, GDK_KP_Down, 0,
1089                     GTK_MOVEMENT_DISPLAY_LINES, 1);
1090
1091   add_move_binding (binding_set, GDK_Up, GDK_CONTROL_MASK,
1092                     GTK_MOVEMENT_PARAGRAPHS, -1);
1093
1094   add_move_binding (binding_set, GDK_KP_Up, GDK_CONTROL_MASK,
1095                     GTK_MOVEMENT_PARAGRAPHS, -1);
1096
1097   add_move_binding (binding_set, GDK_Down, GDK_CONTROL_MASK,
1098                     GTK_MOVEMENT_PARAGRAPHS, 1);
1099
1100   add_move_binding (binding_set, GDK_KP_Down, GDK_CONTROL_MASK,
1101                     GTK_MOVEMENT_PARAGRAPHS, 1);
1102
1103   add_move_binding (binding_set, GDK_Home, 0,
1104                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
1105
1106   add_move_binding (binding_set, GDK_KP_Home, 0,
1107                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
1108
1109   add_move_binding (binding_set, GDK_End, 0,
1110                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
1111
1112   add_move_binding (binding_set, GDK_KP_End, 0,
1113                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
1114
1115   add_move_binding (binding_set, GDK_Home, GDK_CONTROL_MASK,
1116                     GTK_MOVEMENT_BUFFER_ENDS, -1);
1117
1118   add_move_binding (binding_set, GDK_KP_Home, GDK_CONTROL_MASK,
1119                     GTK_MOVEMENT_BUFFER_ENDS, -1);
1120
1121   add_move_binding (binding_set, GDK_End, GDK_CONTROL_MASK,
1122                     GTK_MOVEMENT_BUFFER_ENDS, 1);
1123
1124   add_move_binding (binding_set, GDK_KP_End, GDK_CONTROL_MASK,
1125                     GTK_MOVEMENT_BUFFER_ENDS, 1);
1126
1127   add_move_binding (binding_set, GDK_Page_Up, 0,
1128                     GTK_MOVEMENT_PAGES, -1);
1129
1130   add_move_binding (binding_set, GDK_KP_Page_Up, 0,
1131                     GTK_MOVEMENT_PAGES, -1);
1132
1133   add_move_binding (binding_set, GDK_Page_Down, 0,
1134                     GTK_MOVEMENT_PAGES, 1);
1135
1136   add_move_binding (binding_set, GDK_KP_Page_Down, 0,
1137                     GTK_MOVEMENT_PAGES, 1);
1138
1139   add_move_binding (binding_set, GDK_Page_Up, GDK_CONTROL_MASK,
1140                     GTK_MOVEMENT_HORIZONTAL_PAGES, -1);
1141
1142   add_move_binding (binding_set, GDK_KP_Page_Up, GDK_CONTROL_MASK,
1143                     GTK_MOVEMENT_HORIZONTAL_PAGES, -1);
1144
1145   add_move_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK,
1146                     GTK_MOVEMENT_HORIZONTAL_PAGES, 1);
1147
1148   add_move_binding (binding_set, GDK_KP_Page_Down, GDK_CONTROL_MASK,
1149                     GTK_MOVEMENT_HORIZONTAL_PAGES, 1);
1150
1151   /* Select all */
1152   gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK,
1153                                 "select-all", 1,
1154                                 G_TYPE_BOOLEAN, TRUE);
1155
1156   gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK,
1157                                 "select-all", 1,
1158                                 G_TYPE_BOOLEAN, TRUE);
1159
1160   /* Unselect all */
1161   gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_CONTROL_MASK,
1162                                  "select-all", 1,
1163                                  G_TYPE_BOOLEAN, FALSE);
1164
1165   gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
1166                                  "select-all", 1,
1167                                  G_TYPE_BOOLEAN, FALSE);
1168
1169   /* Deleting text */
1170   gtk_binding_entry_add_signal (binding_set, GDK_Delete, 0,
1171                                 "delete-from-cursor", 2,
1172                                 G_TYPE_ENUM, GTK_DELETE_CHARS,
1173                                 G_TYPE_INT, 1);
1174
1175   gtk_binding_entry_add_signal (binding_set, GDK_KP_Delete, 0,
1176                                 "delete-from-cursor", 2,
1177                                 G_TYPE_ENUM, GTK_DELETE_CHARS,
1178                                 G_TYPE_INT, 1);
1179
1180   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0,
1181                                 "backspace", 0);
1182
1183   /* Make this do the same as Backspace, to help with mis-typing */
1184   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_SHIFT_MASK,
1185                                 "backspace", 0);
1186
1187   gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_CONTROL_MASK,
1188                                 "delete-from-cursor", 2,
1189                                 G_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
1190                                 G_TYPE_INT, 1);
1191
1192   gtk_binding_entry_add_signal (binding_set, GDK_KP_Delete, GDK_CONTROL_MASK,
1193                                 "delete-from-cursor", 2,
1194                                 G_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
1195                                 G_TYPE_INT, 1);
1196
1197   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_CONTROL_MASK,
1198                                 "delete-from-cursor", 2,
1199                                 G_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
1200                                 G_TYPE_INT, -1);
1201
1202   gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
1203                                 "delete-from-cursor", 2,
1204                                 G_TYPE_ENUM, GTK_DELETE_PARAGRAPH_ENDS,
1205                                 G_TYPE_INT, 1);
1206
1207   gtk_binding_entry_add_signal (binding_set, GDK_KP_Delete, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
1208                                 "delete-from-cursor", 2,
1209                                 G_TYPE_ENUM, GTK_DELETE_PARAGRAPH_ENDS,
1210                                 G_TYPE_INT, 1);
1211
1212   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
1213                                 "delete-from-cursor", 2,
1214                                 G_TYPE_ENUM, GTK_DELETE_PARAGRAPH_ENDS,
1215                                 G_TYPE_INT, -1);
1216
1217   /* Cut/copy/paste */
1218
1219   gtk_binding_entry_add_signal (binding_set, GDK_x, GDK_CONTROL_MASK,
1220                                 "cut-clipboard", 0);
1221   gtk_binding_entry_add_signal (binding_set, GDK_c, GDK_CONTROL_MASK,
1222                                 "copy-clipboard", 0);
1223   gtk_binding_entry_add_signal (binding_set, GDK_v, GDK_CONTROL_MASK,
1224                                 "paste-clipboard", 0);
1225
1226   gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_SHIFT_MASK,
1227                                 "cut-clipboard", 0);
1228   gtk_binding_entry_add_signal (binding_set, GDK_Insert, GDK_CONTROL_MASK,
1229                                 "copy-clipboard", 0);
1230   gtk_binding_entry_add_signal (binding_set, GDK_Insert, GDK_SHIFT_MASK,
1231                                 "paste-clipboard", 0);
1232
1233   /* Overwrite */
1234   gtk_binding_entry_add_signal (binding_set, GDK_Insert, 0,
1235                                 "toggle-overwrite", 0);
1236   gtk_binding_entry_add_signal (binding_set, GDK_KP_Insert, 0,
1237                                 "toggle-overwrite", 0);
1238
1239   /* Caret mode */
1240   gtk_binding_entry_add_signal (binding_set, GDK_F7, 0,
1241                                 "toggle-cursor-visible", 0);
1242
1243   /* Control-tab focus motion */
1244   gtk_binding_entry_add_signal (binding_set, GDK_Tab, GDK_CONTROL_MASK,
1245                                 "move-focus", 1,
1246                                 GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_FORWARD);
1247   gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, GDK_CONTROL_MASK,
1248                                 "move-focus", 1,
1249                                 GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_FORWARD);
1250
1251   gtk_binding_entry_add_signal (binding_set, GDK_Tab, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
1252                                 "move-focus", 1,
1253                                 GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD);
1254   gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
1255                                 "move-focus", 1,
1256                                 GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD);
1257
1258   g_type_class_add_private (gobject_class, sizeof (GtkTextViewPrivate));
1259 }
1260
1261 static void
1262 gtk_text_view_init (GtkTextView *text_view)
1263 {
1264   GtkWidget *widget = GTK_WIDGET (text_view);
1265   GtkTargetList *target_list;
1266
1267   GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
1268
1269   /* Set up default style */
1270   text_view->wrap_mode = GTK_WRAP_NONE;
1271   text_view->pixels_above_lines = 0;
1272   text_view->pixels_below_lines = 0;
1273   text_view->pixels_inside_wrap = 0;
1274   text_view->justify = GTK_JUSTIFY_LEFT;
1275   text_view->left_margin = 0;
1276   text_view->right_margin = 0;
1277   text_view->indent = 0;
1278   text_view->tabs = NULL;
1279   text_view->editable = TRUE;
1280
1281   gtk_drag_dest_set (widget, 0, NULL, 0,
1282                      GDK_ACTION_COPY | GDK_ACTION_MOVE);
1283
1284   target_list = gtk_target_list_new (NULL, 0);
1285   gtk_drag_dest_set_target_list (widget, target_list);
1286   gtk_target_list_unref (target_list);
1287
1288   text_view->virtual_cursor_x = -1;
1289   text_view->virtual_cursor_y = -1;
1290
1291   /* This object is completely private. No external entity can gain a reference
1292    * to it; so we create it here and destroy it in finalize ().
1293    */
1294   text_view->im_context = gtk_im_multicontext_new ();
1295
1296   g_signal_connect (text_view->im_context, "commit",
1297                     G_CALLBACK (gtk_text_view_commit_handler), text_view);
1298   g_signal_connect (text_view->im_context, "preedit-changed",
1299                     G_CALLBACK (gtk_text_view_preedit_changed_handler), text_view);
1300   g_signal_connect (text_view->im_context, "retrieve-surrounding",
1301                     G_CALLBACK (gtk_text_view_retrieve_surrounding_handler), text_view);
1302   g_signal_connect (text_view->im_context, "delete-surrounding",
1303                     G_CALLBACK (gtk_text_view_delete_surrounding_handler), text_view);
1304
1305   text_view->cursor_visible = TRUE;
1306
1307   text_view->accepts_tab = TRUE;
1308
1309   text_view->text_window = text_window_new (GTK_TEXT_WINDOW_TEXT,
1310                                             widget, 200, 200);
1311
1312   text_view->drag_start_x = -1;
1313   text_view->drag_start_y = -1;
1314
1315   text_view->pending_place_cursor_button = 0;
1316
1317   /* We handle all our own redrawing */
1318   gtk_widget_set_redraw_on_allocate (widget, FALSE);
1319 }
1320
1321 /**
1322  * gtk_text_view_new:
1323  *
1324  * Creates a new #GtkTextView. If you don't call gtk_text_view_set_buffer()
1325  * before using the text view, an empty default buffer will be created
1326  * for you. Get the buffer with gtk_text_view_get_buffer(). If you want
1327  * to specify your own buffer, consider gtk_text_view_new_with_buffer().
1328  *
1329  * Return value: a new #GtkTextView
1330  **/
1331 GtkWidget*
1332 gtk_text_view_new (void)
1333 {
1334   return g_object_new (GTK_TYPE_TEXT_VIEW, NULL);
1335 }
1336
1337 /**
1338  * gtk_text_view_new_with_buffer:
1339  * @buffer: a #GtkTextBuffer
1340  *
1341  * Creates a new #GtkTextView widget displaying the buffer
1342  * @buffer. One buffer can be shared among many widgets.
1343  * @buffer may be %NULL to create a default buffer, in which case
1344  * this function is equivalent to gtk_text_view_new(). The
1345  * text view adds its own reference count to the buffer; it does not
1346  * take over an existing reference.
1347  *
1348  * Return value: a new #GtkTextView.
1349  **/
1350 GtkWidget*
1351 gtk_text_view_new_with_buffer (GtkTextBuffer *buffer)
1352 {
1353   GtkTextView *text_view;
1354
1355   text_view = (GtkTextView*)gtk_text_view_new ();
1356
1357   gtk_text_view_set_buffer (text_view, buffer);
1358
1359   return GTK_WIDGET (text_view);
1360 }
1361
1362 /**
1363  * gtk_text_view_set_buffer:
1364  * @text_view: a #GtkTextView
1365  * @buffer: a #GtkTextBuffer
1366  *
1367  * Sets @buffer as the buffer being displayed by @text_view. The previous
1368  * buffer displayed by the text view is unreferenced, and a reference is
1369  * added to @buffer. If you owned a reference to @buffer before passing it
1370  * to this function, you must remove that reference yourself; #GtkTextView
1371  * will not "adopt" it.
1372  **/
1373 void
1374 gtk_text_view_set_buffer (GtkTextView   *text_view,
1375                           GtkTextBuffer *buffer)
1376 {
1377   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1378   g_return_if_fail (buffer == NULL || GTK_IS_TEXT_BUFFER (buffer));
1379
1380   if (text_view->buffer == buffer)
1381     return;
1382
1383   if (text_view->buffer != NULL)
1384     {
1385       /* Destroy all anchored children */
1386       GSList *tmp_list;
1387       GSList *copy;
1388
1389       copy = g_slist_copy (text_view->children);
1390       tmp_list = copy;
1391       while (tmp_list != NULL)
1392         {
1393           GtkTextViewChild *vc = tmp_list->data;
1394
1395           if (vc->anchor)
1396             {
1397               gtk_widget_destroy (vc->widget);
1398               /* vc may now be invalid! */
1399             }
1400
1401           tmp_list = g_slist_next (tmp_list);
1402         }
1403
1404       g_slist_free (copy);
1405
1406       g_signal_handlers_disconnect_by_func (text_view->buffer,
1407                                             gtk_text_view_mark_set_handler,
1408                                             text_view);
1409       g_signal_handlers_disconnect_by_func (text_view->buffer,
1410                                             gtk_text_view_target_list_notify,
1411                                             text_view);
1412       g_signal_handlers_disconnect_by_func (text_view->buffer,
1413                                             gtk_text_view_paste_done_handler,
1414                                             text_view);
1415       g_object_unref (text_view->buffer);
1416       text_view->dnd_mark = NULL;
1417       text_view->first_para_mark = NULL;
1418
1419       if (GTK_WIDGET_REALIZED (text_view))
1420         {
1421           GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
1422                                                               GDK_SELECTION_PRIMARY);
1423           gtk_text_buffer_remove_selection_clipboard (text_view->buffer, clipboard);
1424         }
1425     }
1426
1427   text_view->buffer = buffer;
1428
1429   if (text_view->layout)
1430     gtk_text_layout_set_buffer (text_view->layout, buffer);
1431
1432   if (buffer != NULL)
1433     {
1434       GtkTextIter start;
1435
1436       g_object_ref (buffer);
1437
1438       gtk_text_buffer_get_iter_at_offset (text_view->buffer, &start, 0);
1439
1440       text_view->dnd_mark = gtk_text_buffer_create_mark (text_view->buffer,
1441                                                          "gtk_drag_target",
1442                                                          &start, FALSE);
1443
1444       text_view->first_para_mark = gtk_text_buffer_create_mark (text_view->buffer,
1445                                                                 NULL,
1446                                                                 &start, TRUE);
1447
1448       text_view->first_para_pixels = 0;
1449
1450       g_signal_connect (text_view->buffer, "mark-set",
1451                         G_CALLBACK (gtk_text_view_mark_set_handler),
1452                         text_view);
1453       g_signal_connect (text_view->buffer, "notify::paste-target-list",
1454                         G_CALLBACK (gtk_text_view_target_list_notify),
1455                         text_view);
1456       g_signal_connect (text_view->buffer, "paste-done",
1457                         G_CALLBACK (gtk_text_view_paste_done_handler),
1458                         text_view);
1459
1460       gtk_text_view_target_list_notify (text_view->buffer, NULL, text_view);
1461
1462       if (GTK_WIDGET_REALIZED (text_view))
1463         {
1464           GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
1465                                                               GDK_SELECTION_PRIMARY);
1466           gtk_text_buffer_add_selection_clipboard (text_view->buffer, clipboard);
1467         }
1468     }
1469
1470   g_object_notify (G_OBJECT (text_view), "buffer");
1471
1472   if (GTK_WIDGET_VISIBLE (text_view))
1473     gtk_widget_queue_draw (GTK_WIDGET (text_view));
1474
1475   DV(g_print ("Invalidating due to set_buffer\n"));
1476   gtk_text_view_invalidate (text_view);
1477 }
1478
1479 static GtkTextBuffer*
1480 get_buffer (GtkTextView *text_view)
1481 {
1482   if (text_view->buffer == NULL)
1483     {
1484       GtkTextBuffer *b;
1485       b = gtk_text_buffer_new (NULL);
1486       gtk_text_view_set_buffer (text_view, b);
1487       g_object_unref (b);
1488     }
1489
1490   return text_view->buffer;
1491 }
1492
1493 /**
1494  * gtk_text_view_get_buffer:
1495  * @text_view: a #GtkTextView
1496  *
1497  * Returns the #GtkTextBuffer being displayed by this text view.
1498  * The reference count on the buffer is not incremented; the caller
1499  * of this function won't own a new reference.
1500  *
1501  * Return value: a #GtkTextBuffer
1502  **/
1503 GtkTextBuffer*
1504 gtk_text_view_get_buffer (GtkTextView *text_view)
1505 {
1506   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
1507
1508   return get_buffer (text_view);
1509 }
1510
1511 /**
1512  * gtk_text_view_get_iter_at_location:
1513  * @text_view: a #GtkTextView
1514  * @iter: a #GtkTextIter
1515  * @x: x position, in buffer coordinates
1516  * @y: y position, in buffer coordinates
1517  *
1518  * Retrieves the iterator at buffer coordinates @x and @y. Buffer
1519  * coordinates are coordinates for the entire buffer, not just the
1520  * currently-displayed portion.  If you have coordinates from an
1521  * event, you have to convert those to buffer coordinates with
1522  * gtk_text_view_window_to_buffer_coords().
1523  **/
1524 void
1525 gtk_text_view_get_iter_at_location (GtkTextView *text_view,
1526                                     GtkTextIter *iter,
1527                                     gint         x,
1528                                     gint         y)
1529 {
1530   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1531   g_return_if_fail (iter != NULL);
1532
1533   gtk_text_view_ensure_layout (text_view);
1534
1535   gtk_text_layout_get_iter_at_pixel (text_view->layout,
1536                                      iter, x, y);
1537 }
1538
1539 /**
1540  * gtk_text_view_get_iter_at_position:
1541  * @text_view: a #GtkTextView
1542  * @iter: a #GtkTextIter
1543  * @trailing: if non-%NULL, location to store an integer indicating where
1544  *    in the grapheme the user clicked. It will either be
1545  *    zero, or the number of characters in the grapheme.
1546  *    0 represents the trailing edge of the grapheme.
1547  * @x: x position, in buffer coordinates
1548  * @y: y position, in buffer coordinates
1549  *
1550  * Retrieves the iterator pointing to the character at buffer
1551  * coordinates @x and @y. Buffer coordinates are coordinates for
1552  * the entire buffer, not just the currently-displayed portion.
1553  * If you have coordinates from an event, you have to convert
1554  * those to buffer coordinates with
1555  * gtk_text_view_window_to_buffer_coords().
1556  *
1557  * Note that this is different from gtk_text_view_get_iter_at_location(),
1558  * which returns cursor locations, i.e. positions <emphasis>between</emphasis>
1559  * characters.
1560  *
1561  * Since: 2.6
1562  **/
1563 void
1564 gtk_text_view_get_iter_at_position (GtkTextView *text_view,
1565                                     GtkTextIter *iter,
1566                                     gint        *trailing,
1567                                     gint         x,
1568                                     gint         y)
1569 {
1570   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1571   g_return_if_fail (iter != NULL);
1572
1573   gtk_text_view_ensure_layout (text_view);
1574
1575   gtk_text_layout_get_iter_at_position (text_view->layout,
1576                                         iter, trailing, x, y);
1577 }
1578
1579 /**
1580  * gtk_text_view_get_iter_location:
1581  * @text_view: a #GtkTextView
1582  * @iter: a #GtkTextIter
1583  * @location: bounds of the character at @iter
1584  *
1585  * Gets a rectangle which roughly contains the character at @iter.
1586  * The rectangle position is in buffer coordinates; use
1587  * gtk_text_view_buffer_to_window_coords() to convert these
1588  * coordinates to coordinates for one of the windows in the text view.
1589  **/
1590 void
1591 gtk_text_view_get_iter_location (GtkTextView       *text_view,
1592                                  const GtkTextIter *iter,
1593                                  GdkRectangle      *location)
1594 {
1595   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1596   g_return_if_fail (gtk_text_iter_get_buffer (iter) == get_buffer (text_view));
1597
1598   gtk_text_view_ensure_layout (text_view);
1599
1600   gtk_text_layout_get_iter_location (text_view->layout, iter, location);
1601 }
1602
1603 /**
1604  * gtk_text_view_get_line_yrange:
1605  * @text_view: a #GtkTextView
1606  * @iter: a #GtkTextIter
1607  * @y: return location for a y coordinate
1608  * @height: return location for a height
1609  *
1610  * Gets the y coordinate of the top of the line containing @iter,
1611  * and the height of the line. The coordinate is a buffer coordinate;
1612  * convert to window coordinates with gtk_text_view_buffer_to_window_coords().
1613  **/
1614 void
1615 gtk_text_view_get_line_yrange (GtkTextView       *text_view,
1616                                const GtkTextIter *iter,
1617                                gint              *y,
1618                                gint              *height)
1619 {
1620   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1621   g_return_if_fail (gtk_text_iter_get_buffer (iter) == get_buffer (text_view));
1622
1623   gtk_text_view_ensure_layout (text_view);
1624
1625   gtk_text_layout_get_line_yrange (text_view->layout,
1626                                    iter,
1627                                    y,
1628                                    height);
1629 }
1630
1631 /**
1632  * gtk_text_view_get_line_at_y:
1633  * @text_view: a #GtkTextView
1634  * @target_iter: a #GtkTextIter
1635  * @y: a y coordinate
1636  * @line_top: return location for top coordinate of the line
1637  *
1638  * Gets the #GtkTextIter at the start of the line containing
1639  * the coordinate @y. @y is in buffer coordinates, convert from
1640  * window coordinates with gtk_text_view_window_to_buffer_coords().
1641  * If non-%NULL, @line_top will be filled with the coordinate of the top
1642  * edge of the line.
1643  **/
1644 void
1645 gtk_text_view_get_line_at_y (GtkTextView *text_view,
1646                              GtkTextIter *target_iter,
1647                              gint         y,
1648                              gint        *line_top)
1649 {
1650   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1651
1652   gtk_text_view_ensure_layout (text_view);
1653
1654   gtk_text_layout_get_line_at_y (text_view->layout,
1655                                  target_iter,
1656                                  y,
1657                                  line_top);
1658 }
1659
1660 static gboolean
1661 set_adjustment_clamped (GtkAdjustment *adj, gdouble val)
1662 {
1663   DV (g_print ("  Setting adj to raw value %g\n", val));
1664
1665   /* We don't really want to clamp to upper; we want to clamp to
1666      upper - page_size which is the highest value the scrollbar
1667      will let us reach. */
1668   if (val > (adj->upper - adj->page_size))
1669     val = adj->upper - adj->page_size;
1670
1671   if (val < adj->lower)
1672     val = adj->lower;
1673
1674   if (val != adj->value)
1675     {
1676       DV (g_print ("  Setting adj to clamped value %g\n", val));
1677       gtk_adjustment_set_value (adj, val);
1678       return TRUE;
1679     }
1680   else
1681     return FALSE;
1682 }
1683
1684 /**
1685  * gtk_text_view_scroll_to_iter:
1686  * @text_view: a #GtkTextView
1687  * @iter: a #GtkTextIter
1688  * @within_margin: margin as a [0.0,0.5) fraction of screen size
1689  * @use_align: whether to use alignment arguments (if %FALSE,
1690  *    just get the mark onscreen)
1691  * @xalign: horizontal alignment of mark within visible area
1692  * @yalign: vertical alignment of mark within visible area
1693  *
1694  * Scrolls @text_view so that @iter is on the screen in the position
1695  * indicated by @xalign and @yalign. An alignment of 0.0 indicates
1696  * left or top, 1.0 indicates right or bottom, 0.5 means center.
1697  * If @use_align is %FALSE, the text scrolls the minimal distance to
1698  * get the mark onscreen, possibly not scrolling at all. The effective
1699  * screen for purposes of this function is reduced by a margin of size
1700  * @within_margin.
1701  *
1702  * Note that this function uses the currently-computed height of the
1703  * lines in the text buffer. Line heights are computed in an idle
1704  * handler; so this function may not have the desired effect if it's
1705  * called before the height computations. To avoid oddness, consider
1706  * using gtk_text_view_scroll_to_mark() which saves a point to be
1707  * scrolled to after line validation.
1708  *
1709  * Return value: %TRUE if scrolling occurred
1710  **/
1711 gboolean
1712 gtk_text_view_scroll_to_iter (GtkTextView   *text_view,
1713                               GtkTextIter   *iter,
1714                               gdouble        within_margin,
1715                               gboolean       use_align,
1716                               gdouble        xalign,
1717                               gdouble        yalign)
1718 {
1719   GdkRectangle rect;
1720   GdkRectangle screen;
1721   gint screen_bottom;
1722   gint screen_right;
1723   gint scroll_dest;
1724   GtkWidget *widget;
1725   gboolean retval = FALSE;
1726   gint scroll_inc;
1727   gint screen_xoffset, screen_yoffset;
1728   gint current_x_scroll, current_y_scroll;
1729
1730   /* FIXME why don't we do the validate-at-scroll-destination thing
1731    * from flush_scroll in this function? I think it wasn't done before
1732    * because changed_handler was screwed up, but I could be wrong.
1733    */
1734
1735   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
1736   g_return_val_if_fail (iter != NULL, FALSE);
1737   g_return_val_if_fail (within_margin >= 0.0 && within_margin < 0.5, FALSE);
1738   g_return_val_if_fail (xalign >= 0.0 && xalign <= 1.0, FALSE);
1739   g_return_val_if_fail (yalign >= 0.0 && yalign <= 1.0, FALSE);
1740
1741   widget = GTK_WIDGET (text_view);
1742
1743   DV(g_print(G_STRLOC"\n"));
1744
1745   gtk_text_layout_get_iter_location (text_view->layout,
1746                                      iter,
1747                                      &rect);
1748
1749   DV (g_print (" target rect %d,%d  %d x %d\n", rect.x, rect.y, rect.width, rect.height));
1750
1751   current_x_scroll = text_view->xoffset;
1752   current_y_scroll = text_view->yoffset;
1753
1754   screen.x = current_x_scroll;
1755   screen.y = current_y_scroll;
1756   screen.width = SCREEN_WIDTH (widget);
1757   screen.height = SCREEN_HEIGHT (widget);
1758
1759   screen_xoffset = screen.width * within_margin;
1760   screen_yoffset = screen.height * within_margin;
1761
1762   screen.x += screen_xoffset;
1763   screen.y += screen_yoffset;
1764   screen.width -= screen_xoffset * 2;
1765   screen.height -= screen_yoffset * 2;
1766
1767   /* paranoia check */
1768   if (screen.width < 1)
1769     screen.width = 1;
1770   if (screen.height < 1)
1771     screen.height = 1;
1772
1773   /* The -1 here ensures that we leave enough space to draw the cursor
1774    * when this function is used for horizontal scrolling.
1775    */
1776   screen_right = screen.x + screen.width - 1;
1777   screen_bottom = screen.y + screen.height;
1778
1779   /* The alignment affects the point in the target character that we
1780    * choose to align. If we're doing right/bottom alignment, we align
1781    * the right/bottom edge of the character the mark is at; if we're
1782    * doing left/top we align the left/top edge of the character; if
1783    * we're doing center alignment we align the center of the
1784    * character.
1785    */
1786
1787   /* Vertical scroll */
1788
1789   scroll_inc = 0;
1790   scroll_dest = current_y_scroll;
1791
1792   if (use_align)
1793     {
1794       scroll_dest = rect.y + (rect.height * yalign) - (screen.height * yalign);
1795
1796       /* if scroll_dest < screen.y, we move a negative increment (up),
1797        * else a positive increment (down)
1798        */
1799       scroll_inc = scroll_dest - screen.y + screen_yoffset;
1800     }
1801   else
1802     {
1803       /* move minimum to get onscreen */
1804       if (rect.y < screen.y)
1805         {
1806           scroll_dest = rect.y;
1807           scroll_inc = scroll_dest - screen.y - screen_yoffset;
1808         }
1809       else if ((rect.y + rect.height) > screen_bottom)
1810         {
1811           scroll_dest = rect.y + rect.height;
1812           scroll_inc = scroll_dest - screen_bottom + screen_yoffset;
1813         }
1814     }
1815
1816   if (scroll_inc != 0)
1817     {
1818       retval = set_adjustment_clamped (get_vadjustment (text_view),
1819                                        current_y_scroll + scroll_inc);
1820
1821       DV (g_print (" vert increment %d\n", scroll_inc));
1822     }
1823
1824   /* Horizontal scroll */
1825
1826   scroll_inc = 0;
1827   scroll_dest = current_x_scroll;
1828
1829   if (use_align)
1830     {
1831       scroll_dest = rect.x + (rect.width * xalign) - (screen.width * xalign);
1832
1833       /* if scroll_dest < screen.y, we move a negative increment (left),
1834        * else a positive increment (right)
1835        */
1836       scroll_inc = scroll_dest - screen.x + screen_xoffset;
1837     }
1838   else
1839     {
1840       /* move minimum to get onscreen */
1841       if (rect.x < screen.x)
1842         {
1843           scroll_dest = rect.x;
1844           scroll_inc = scroll_dest - screen.x - screen_xoffset;
1845         }
1846       else if ((rect.x + rect.width) > screen_right)
1847         {
1848           scroll_dest = rect.x + rect.width;
1849           scroll_inc = scroll_dest - screen_right + screen_xoffset;
1850         }
1851     }
1852
1853   if (scroll_inc != 0)
1854     {
1855       retval = set_adjustment_clamped (get_hadjustment (text_view),
1856                                        current_x_scroll + scroll_inc);
1857
1858       DV (g_print (" horiz increment %d\n", scroll_inc));
1859     }
1860
1861   if (retval)
1862     DV(g_print (">Actually scrolled ("G_STRLOC")\n"));
1863   else
1864     DV(g_print (">Didn't end up scrolling ("G_STRLOC")\n"));
1865
1866   return retval;
1867 }
1868
1869 static void
1870 free_pending_scroll (GtkTextPendingScroll *scroll)
1871 {
1872   if (!gtk_text_mark_get_deleted (scroll->mark))
1873     gtk_text_buffer_delete_mark (gtk_text_mark_get_buffer (scroll->mark),
1874                                  scroll->mark);
1875   g_object_unref (scroll->mark);
1876   g_free (scroll);
1877 }
1878
1879 static void
1880 cancel_pending_scroll (GtkTextView *text_view)
1881 {
1882   if (text_view->pending_scroll)
1883     {
1884       free_pending_scroll (text_view->pending_scroll);
1885       text_view->pending_scroll = NULL;
1886     }
1887 }
1888
1889 static void
1890 gtk_text_view_queue_scroll (GtkTextView   *text_view,
1891                             GtkTextMark   *mark,
1892                             gdouble        within_margin,
1893                             gboolean       use_align,
1894                             gdouble        xalign,
1895                             gdouble        yalign)
1896 {
1897   GtkTextIter iter;
1898   GtkTextPendingScroll *scroll;
1899
1900   DV(g_print(G_STRLOC"\n"));
1901
1902   scroll = g_new (GtkTextPendingScroll, 1);
1903
1904   scroll->within_margin = within_margin;
1905   scroll->use_align = use_align;
1906   scroll->xalign = xalign;
1907   scroll->yalign = yalign;
1908
1909   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, mark);
1910
1911   scroll->mark = gtk_text_buffer_create_mark (get_buffer (text_view),
1912                                               NULL,
1913                                               &iter,
1914                                               gtk_text_mark_get_left_gravity (mark));
1915
1916   g_object_ref (scroll->mark);
1917
1918   cancel_pending_scroll (text_view);
1919
1920   text_view->pending_scroll = scroll;
1921 }
1922
1923 static gboolean
1924 gtk_text_view_flush_scroll (GtkTextView *text_view)
1925 {
1926   GtkTextIter iter;
1927   GtkTextPendingScroll *scroll;
1928   gboolean retval;
1929   GtkWidget *widget;
1930
1931   widget = GTK_WIDGET (text_view);
1932
1933   DV(g_print(G_STRLOC"\n"));
1934
1935   if (text_view->pending_scroll == NULL)
1936     {
1937       DV (g_print ("in flush scroll, no pending scroll\n"));
1938       return FALSE;
1939     }
1940
1941   scroll = text_view->pending_scroll;
1942
1943   /* avoid recursion */
1944   text_view->pending_scroll = NULL;
1945
1946   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, scroll->mark);
1947
1948   /* Validate area around the scroll destination, so the adjustment
1949    * can meaningfully point into that area. We must validate
1950    * enough area to be sure that after we scroll, everything onscreen
1951    * is valid; otherwise, validation will maintain the first para
1952    * in one place, but may push the target iter off the bottom of
1953    * the screen.
1954    */
1955   DV(g_print (">Validating scroll destination ("G_STRLOC")\n"));
1956   gtk_text_layout_validate_yrange (text_view->layout, &iter,
1957                                    - (widget->allocation.height * 2),
1958                                    widget->allocation.height * 2);
1959
1960   DV(g_print (">Done validating scroll destination ("G_STRLOC")\n"));
1961
1962   /* Ensure we have updated width/height */
1963   gtk_text_view_update_adjustments (text_view);
1964
1965   retval = gtk_text_view_scroll_to_iter (text_view,
1966                                          &iter,
1967                                          scroll->within_margin,
1968                                          scroll->use_align,
1969                                          scroll->xalign,
1970                                          scroll->yalign);
1971
1972   free_pending_scroll (scroll);
1973
1974   return retval;
1975 }
1976
1977 static void
1978 gtk_text_view_set_adjustment_upper (GtkAdjustment *adj, gdouble upper)
1979 {
1980   if (upper != adj->upper)
1981     {
1982       gdouble min = MAX (0.0, upper - adj->page_size);
1983       gboolean value_changed = FALSE;
1984
1985       adj->upper = upper;
1986
1987       if (adj->value > min)
1988         {
1989           adj->value = min;
1990           value_changed = TRUE;
1991         }
1992
1993       gtk_adjustment_changed (adj);
1994       DV(g_print(">Changed adj upper to %g ("G_STRLOC")\n", upper));
1995
1996       if (value_changed)
1997         {
1998           DV(g_print(">Changed adj value because upper decreased ("G_STRLOC")\n"));
1999           gtk_adjustment_value_changed (adj);
2000         }
2001     }
2002 }
2003
2004 static void
2005 gtk_text_view_update_adjustments (GtkTextView *text_view)
2006 {
2007   gint width = 0, height = 0;
2008
2009   DV(g_print(">Updating adjustments ("G_STRLOC")\n"));
2010
2011   if (text_view->layout)
2012     gtk_text_layout_get_size (text_view->layout, &width, &height);
2013
2014   /* Make room for the cursor after the last character in the widest line */
2015   width += SPACE_FOR_CURSOR;
2016
2017   if (text_view->width != width || text_view->height != height)
2018     {
2019       if (text_view->width != width)
2020         text_view->width_changed = TRUE;
2021
2022       text_view->width = width;
2023       text_view->height = height;
2024
2025       gtk_text_view_set_adjustment_upper (get_hadjustment (text_view),
2026                                           MAX (SCREEN_WIDTH (text_view), width));
2027       gtk_text_view_set_adjustment_upper (get_vadjustment (text_view),
2028                                           MAX (SCREEN_HEIGHT (text_view), height));
2029
2030       /* hadj/vadj exist since we called get_hadjustment/get_vadjustment above */
2031
2032       /* Set up the step sizes; we'll say that a page is
2033          our allocation minus one step, and a step is
2034          1/10 of our allocation. */
2035       text_view->hadjustment->step_increment =
2036         SCREEN_WIDTH (text_view) / 10.0;
2037       text_view->hadjustment->page_increment =
2038         SCREEN_WIDTH (text_view) * 0.9;
2039
2040       text_view->vadjustment->step_increment =
2041         SCREEN_HEIGHT (text_view) / 10.0;
2042       text_view->vadjustment->page_increment =
2043         SCREEN_HEIGHT (text_view) * 0.9;
2044
2045       gtk_adjustment_changed (get_hadjustment (text_view));
2046       gtk_adjustment_changed (get_vadjustment (text_view));
2047     }
2048 }
2049
2050 static void
2051 gtk_text_view_update_layout_width (GtkTextView *text_view)
2052 {
2053   DV(g_print(">Updating layout width ("G_STRLOC")\n"));
2054
2055   gtk_text_view_ensure_layout (text_view);
2056
2057   gtk_text_layout_set_screen_width (text_view->layout,
2058                                     MAX (1, SCREEN_WIDTH (text_view) - SPACE_FOR_CURSOR));
2059 }
2060
2061 static void
2062 gtk_text_view_update_im_spot_location (GtkTextView *text_view)
2063 {
2064   GdkRectangle area;
2065
2066   if (text_view->layout == NULL)
2067     return;
2068
2069   gtk_text_view_get_cursor_location (text_view, &area);
2070
2071   area.x -= text_view->xoffset;
2072   area.y -= text_view->yoffset;
2073
2074   /* Width returned by Pango indicates direction of cursor,
2075    * by it's sign more than the size of cursor.
2076    */
2077   area.width = 0;
2078
2079   gtk_im_context_set_cursor_location (text_view->im_context, &area);
2080 }
2081
2082 static gboolean
2083 do_update_im_spot_location (gpointer text_view)
2084 {
2085   GtkTextViewPrivate *priv;
2086
2087   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
2088   priv->im_spot_idle = 0;
2089
2090   gtk_text_view_update_im_spot_location (text_view);
2091   return FALSE;
2092 }
2093
2094 static void
2095 queue_update_im_spot_location (GtkTextView *text_view)
2096 {
2097   GtkTextViewPrivate *priv;
2098
2099   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
2100
2101   /* Use priority a little higher than GTK_TEXT_VIEW_PRIORITY_VALIDATE,
2102    * so we don't wait until the entire buffer has been validated. */
2103   if (!priv->im_spot_idle)
2104     priv->im_spot_idle = gdk_threads_add_idle_full (GTK_TEXT_VIEW_PRIORITY_VALIDATE - 1,
2105                                                     do_update_im_spot_location,
2106                                                     text_view,
2107                                                     NULL);
2108 }
2109
2110 static void
2111 flush_update_im_spot_location (GtkTextView *text_view)
2112 {
2113   GtkTextViewPrivate *priv;
2114
2115   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
2116
2117   if (priv->im_spot_idle)
2118     {
2119       g_source_remove (priv->im_spot_idle);
2120       priv->im_spot_idle = 0;
2121       gtk_text_view_update_im_spot_location (text_view);
2122     }
2123 }
2124
2125 /**
2126  * gtk_text_view_scroll_to_mark:
2127  * @text_view: a #GtkTextView
2128  * @mark: a #GtkTextMark
2129  * @within_margin: margin as a [0.0,0.5) fraction of screen size
2130  * @use_align: whether to use alignment arguments (if %FALSE, just
2131  *    get the mark onscreen)
2132  * @xalign: horizontal alignment of mark within visible area
2133  * @yalign: vertical alignment of mark within visible area
2134  *
2135  * Scrolls @text_view so that @mark is on the screen in the position
2136  * indicated by @xalign and @yalign. An alignment of 0.0 indicates
2137  * left or top, 1.0 indicates right or bottom, 0.5 means center.
2138  * If @use_align is %FALSE, the text scrolls the minimal distance to
2139  * get the mark onscreen, possibly not scrolling at all. The effective
2140  * screen for purposes of this function is reduced by a margin of size
2141  * @within_margin.
2142  **/
2143 void
2144 gtk_text_view_scroll_to_mark (GtkTextView *text_view,
2145                               GtkTextMark *mark,
2146                               gdouble      within_margin,
2147                               gboolean     use_align,
2148                               gdouble      xalign,
2149                               gdouble      yalign)
2150 {
2151   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2152   g_return_if_fail (GTK_IS_TEXT_MARK (mark));
2153   g_return_if_fail (within_margin >= 0.0 && within_margin < 0.5);
2154   g_return_if_fail (xalign >= 0.0 && xalign <= 1.0);
2155   g_return_if_fail (yalign >= 0.0 && yalign <= 1.0);
2156
2157   gtk_text_view_queue_scroll (text_view, mark,
2158                               within_margin,
2159                               use_align,
2160                               xalign,
2161                               yalign);
2162
2163   /* If no validation is pending, we need to go ahead and force an
2164    * immediate scroll.
2165    */
2166   if (text_view->layout &&
2167       gtk_text_layout_is_valid (text_view->layout))
2168     gtk_text_view_flush_scroll (text_view);
2169 }
2170
2171 /**
2172  * gtk_text_view_scroll_mark_onscreen:
2173  * @text_view: a #GtkTextView
2174  * @mark: a mark in the buffer for @text_view
2175  *
2176  * Scrolls @text_view the minimum distance such that @mark is contained
2177  * within the visible area of the widget.
2178  **/
2179 void
2180 gtk_text_view_scroll_mark_onscreen (GtkTextView *text_view,
2181                                     GtkTextMark *mark)
2182 {
2183   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2184   g_return_if_fail (GTK_IS_TEXT_MARK (mark));
2185
2186   gtk_text_view_scroll_to_mark (text_view, mark, 0.0, FALSE, 0.0, 0.0);
2187 }
2188
2189 static gboolean
2190 clamp_iter_onscreen (GtkTextView *text_view, GtkTextIter *iter)
2191 {
2192   GdkRectangle visible_rect;
2193   gtk_text_view_get_visible_rect (text_view, &visible_rect);
2194
2195   return gtk_text_layout_clamp_iter_to_vrange (text_view->layout, iter,
2196                                                visible_rect.y,
2197                                                visible_rect.y + visible_rect.height);
2198 }
2199
2200 /**
2201  * gtk_text_view_move_mark_onscreen:
2202  * @text_view: a #GtkTextView
2203  * @mark: a #GtkTextMark
2204  *
2205  * Moves a mark within the buffer so that it's
2206  * located within the currently-visible text area.
2207  *
2208  * Return value: %TRUE if the mark moved (wasn't already onscreen)
2209  **/
2210 gboolean
2211 gtk_text_view_move_mark_onscreen (GtkTextView *text_view,
2212                                   GtkTextMark *mark)
2213 {
2214   GtkTextIter iter;
2215
2216   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
2217   g_return_val_if_fail (mark != NULL, FALSE);
2218
2219   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, mark);
2220
2221   if (clamp_iter_onscreen (text_view, &iter))
2222     {
2223       gtk_text_buffer_move_mark (get_buffer (text_view), mark, &iter);
2224       return TRUE;
2225     }
2226   else
2227     return FALSE;
2228 }
2229
2230 /**
2231  * gtk_text_view_get_visible_rect:
2232  * @text_view: a #GtkTextView
2233  * @visible_rect: rectangle to fill
2234  *
2235  * Fills @visible_rect with the currently-visible
2236  * region of the buffer, in buffer coordinates. Convert to window coordinates
2237  * with gtk_text_view_buffer_to_window_coords().
2238  **/
2239 void
2240 gtk_text_view_get_visible_rect (GtkTextView  *text_view,
2241                                 GdkRectangle *visible_rect)
2242 {
2243   GtkWidget *widget;
2244
2245   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2246
2247   widget = GTK_WIDGET (text_view);
2248
2249   if (visible_rect)
2250     {
2251       visible_rect->x = text_view->xoffset;
2252       visible_rect->y = text_view->yoffset;
2253       visible_rect->width = SCREEN_WIDTH (widget);
2254       visible_rect->height = SCREEN_HEIGHT (widget);
2255
2256       DV(g_print(" visible rect: %d,%d %d x %d\n",
2257                  visible_rect->x,
2258                  visible_rect->y,
2259                  visible_rect->width,
2260                  visible_rect->height));
2261     }
2262 }
2263
2264 /**
2265  * gtk_text_view_set_wrap_mode:
2266  * @text_view: a #GtkTextView
2267  * @wrap_mode: a #GtkWrapMode
2268  *
2269  * Sets the line wrapping for the view.
2270  **/
2271 void
2272 gtk_text_view_set_wrap_mode (GtkTextView *text_view,
2273                              GtkWrapMode  wrap_mode)
2274 {
2275   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2276
2277   if (text_view->wrap_mode != wrap_mode)
2278     {
2279       text_view->wrap_mode = wrap_mode;
2280
2281       if (text_view->layout)
2282         {
2283           text_view->layout->default_style->wrap_mode = wrap_mode;
2284           gtk_text_layout_default_style_changed (text_view->layout);
2285         }
2286     }
2287
2288   g_object_notify (G_OBJECT (text_view), "wrap-mode");
2289 }
2290
2291 /**
2292  * gtk_text_view_get_wrap_mode:
2293  * @text_view: a #GtkTextView
2294  *
2295  * Gets the line wrapping for the view.
2296  *
2297  * Return value: the line wrap setting
2298  **/
2299 GtkWrapMode
2300 gtk_text_view_get_wrap_mode (GtkTextView *text_view)
2301 {
2302   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), GTK_WRAP_NONE);
2303
2304   return text_view->wrap_mode;
2305 }
2306
2307 /**
2308  * gtk_text_view_set_editable:
2309  * @text_view: a #GtkTextView
2310  * @setting: whether it's editable
2311  *
2312  * Sets the default editability of the #GtkTextView. You can override
2313  * this default setting with tags in the buffer, using the "editable"
2314  * attribute of tags.
2315  **/
2316 void
2317 gtk_text_view_set_editable (GtkTextView *text_view,
2318                             gboolean     setting)
2319 {
2320   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2321   setting = setting != FALSE;
2322
2323   if (text_view->editable != setting)
2324     {
2325       if (!setting)
2326         {
2327           gtk_text_view_reset_im_context(text_view);
2328           if (GTK_WIDGET_HAS_FOCUS (text_view))
2329             gtk_im_context_focus_out (text_view->im_context);
2330         }
2331
2332       text_view->editable = setting;
2333
2334       if (setting && GTK_WIDGET_HAS_FOCUS (text_view))
2335         gtk_im_context_focus_in (text_view->im_context);
2336
2337       if (text_view->layout)
2338         {
2339           gtk_text_layout_set_overwrite_mode (text_view->layout,
2340                                               text_view->overwrite_mode && text_view->editable);
2341           text_view->layout->default_style->editable = text_view->editable;
2342           gtk_text_layout_default_style_changed (text_view->layout);
2343         }
2344
2345       g_object_notify (G_OBJECT (text_view), "editable");
2346     }
2347 }
2348
2349 /**
2350  * gtk_text_view_get_editable:
2351  * @text_view: a #GtkTextView
2352  *
2353  * Returns the default editability of the #GtkTextView. Tags in the
2354  * buffer may override this setting for some ranges of text.
2355  *
2356  * Return value: whether text is editable by default
2357  **/
2358 gboolean
2359 gtk_text_view_get_editable (GtkTextView *text_view)
2360 {
2361   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
2362
2363   return text_view->editable;
2364 }
2365
2366 /**
2367  * gtk_text_view_set_pixels_above_lines:
2368  * @text_view: a #GtkTextView
2369  * @pixels_above_lines: pixels above paragraphs
2370  *
2371  * Sets the default number of blank pixels above paragraphs in @text_view.
2372  * Tags in the buffer for @text_view may override the defaults.
2373  **/
2374 void
2375 gtk_text_view_set_pixels_above_lines (GtkTextView *text_view,
2376                                       gint         pixels_above_lines)
2377 {
2378   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2379
2380   if (text_view->pixels_above_lines != pixels_above_lines)
2381     {
2382       text_view->pixels_above_lines = pixels_above_lines;
2383
2384       if (text_view->layout)
2385         {
2386           text_view->layout->default_style->pixels_above_lines = pixels_above_lines;
2387           gtk_text_layout_default_style_changed (text_view->layout);
2388         }
2389
2390       g_object_notify (G_OBJECT (text_view), "pixels-above-lines");
2391     }
2392 }
2393
2394 /**
2395  * gtk_text_view_get_pixels_above_lines:
2396  * @text_view: a #GtkTextView
2397  *
2398  * Gets the default number of pixels to put above paragraphs.
2399  *
2400  * Return value: default number of pixels above paragraphs
2401  **/
2402 gint
2403 gtk_text_view_get_pixels_above_lines (GtkTextView *text_view)
2404 {
2405   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
2406
2407   return text_view->pixels_above_lines;
2408 }
2409
2410 /**
2411  * gtk_text_view_set_pixels_below_lines:
2412  * @text_view: a #GtkTextView
2413  * @pixels_below_lines: pixels below paragraphs
2414  *
2415  * Sets the default number of pixels of blank space
2416  * to put below paragraphs in @text_view. May be overridden
2417  * by tags applied to @text_view's buffer.
2418  **/
2419 void
2420 gtk_text_view_set_pixels_below_lines (GtkTextView *text_view,
2421                                       gint         pixels_below_lines)
2422 {
2423   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2424
2425   if (text_view->pixels_below_lines != pixels_below_lines)
2426     {
2427       text_view->pixels_below_lines = pixels_below_lines;
2428
2429       if (text_view->layout)
2430         {
2431           text_view->layout->default_style->pixels_below_lines = pixels_below_lines;
2432           gtk_text_layout_default_style_changed (text_view->layout);
2433         }
2434
2435       g_object_notify (G_OBJECT (text_view), "pixels-below-lines");
2436     }
2437 }
2438
2439 /**
2440  * gtk_text_view_get_pixels_below_lines:
2441  * @text_view: a #GtkTextView
2442  *
2443  * Gets the value set by gtk_text_view_set_pixels_below_lines().
2444  *
2445  * Return value: default number of blank pixels below paragraphs
2446  **/
2447 gint
2448 gtk_text_view_get_pixels_below_lines (GtkTextView *text_view)
2449 {
2450   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
2451
2452   return text_view->pixels_below_lines;
2453 }
2454
2455 /**
2456  * gtk_text_view_set_pixels_inside_wrap:
2457  * @text_view: a #GtkTextView
2458  * @pixels_inside_wrap: default number of pixels between wrapped lines
2459  *
2460  * Sets the default number of pixels of blank space to leave between
2461  * display/wrapped lines within a paragraph. May be overridden by
2462  * tags in @text_view's buffer.
2463  **/
2464 void
2465 gtk_text_view_set_pixels_inside_wrap (GtkTextView *text_view,
2466                                       gint         pixels_inside_wrap)
2467 {
2468   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2469
2470   if (text_view->pixels_inside_wrap != pixels_inside_wrap)
2471     {
2472       text_view->pixels_inside_wrap = pixels_inside_wrap;
2473
2474       if (text_view->layout)
2475         {
2476           text_view->layout->default_style->pixels_inside_wrap = pixels_inside_wrap;
2477           gtk_text_layout_default_style_changed (text_view->layout);
2478         }
2479
2480       g_object_notify (G_OBJECT (text_view), "pixels-inside-wrap");
2481     }
2482 }
2483
2484 /**
2485  * gtk_text_view_get_pixels_inside_wrap:
2486  * @text_view: a #GtkTextView
2487  *
2488  * Gets the value set by gtk_text_view_set_pixels_inside_wrap().
2489  *
2490  * Return value: default number of pixels of blank space between wrapped lines
2491  **/
2492 gint
2493 gtk_text_view_get_pixels_inside_wrap (GtkTextView *text_view)
2494 {
2495   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
2496
2497   return text_view->pixels_inside_wrap;
2498 }
2499
2500 /**
2501  * gtk_text_view_set_justification:
2502  * @text_view: a #GtkTextView
2503  * @justification: justification
2504  *
2505  * Sets the default justification of text in @text_view.
2506  * Tags in the view's buffer may override the default.
2507  *
2508  **/
2509 void
2510 gtk_text_view_set_justification (GtkTextView     *text_view,
2511                                  GtkJustification justification)
2512 {
2513   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2514
2515   if (text_view->justify != justification)
2516     {
2517       text_view->justify = justification;
2518
2519       if (text_view->layout)
2520         {
2521           text_view->layout->default_style->justification = justification;
2522           gtk_text_layout_default_style_changed (text_view->layout);
2523         }
2524
2525       g_object_notify (G_OBJECT (text_view), "justification");
2526     }
2527 }
2528
2529 /**
2530  * gtk_text_view_get_justification:
2531  * @text_view: a #GtkTextView
2532  *
2533  * Gets the default justification of paragraphs in @text_view.
2534  * Tags in the buffer may override the default.
2535  *
2536  * Return value: default justification
2537  **/
2538 GtkJustification
2539 gtk_text_view_get_justification (GtkTextView *text_view)
2540 {
2541   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), GTK_JUSTIFY_LEFT);
2542
2543   return text_view->justify;
2544 }
2545
2546 /**
2547  * gtk_text_view_set_left_margin:
2548  * @text_view: a #GtkTextView
2549  * @left_margin: left margin in pixels
2550  *
2551  * Sets the default left margin for text in @text_view.
2552  * Tags in the buffer may override the default.
2553  **/
2554 void
2555 gtk_text_view_set_left_margin (GtkTextView *text_view,
2556                                gint         left_margin)
2557 {
2558   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2559
2560   if (text_view->left_margin != left_margin)
2561     {
2562       text_view->left_margin = left_margin;
2563
2564       if (text_view->layout)
2565         {
2566           text_view->layout->default_style->left_margin = left_margin;
2567           gtk_text_layout_default_style_changed (text_view->layout);
2568         }
2569
2570       g_object_notify (G_OBJECT (text_view), "left-margin");
2571     }
2572 }
2573
2574 /**
2575  * gtk_text_view_get_left_margin:
2576  * @text_view: a #GtkTextView
2577  *
2578  * Gets the default left margin size of paragraphs in the @text_view.
2579  * Tags in the buffer may override the default.
2580  *
2581  * Return value: left margin in pixels
2582  **/
2583 gint
2584 gtk_text_view_get_left_margin (GtkTextView *text_view)
2585 {
2586   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
2587
2588   return text_view->left_margin;
2589 }
2590
2591 /**
2592  * gtk_text_view_set_right_margin:
2593  * @text_view: a #GtkTextView
2594  * @right_margin: right margin in pixels
2595  *
2596  * Sets the default right margin for text in the text view.
2597  * Tags in the buffer may override the default.
2598  **/
2599 void
2600 gtk_text_view_set_right_margin (GtkTextView *text_view,
2601                                 gint         right_margin)
2602 {
2603   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2604
2605   if (text_view->right_margin != right_margin)
2606     {
2607       text_view->right_margin = right_margin;
2608
2609       if (text_view->layout)
2610         {
2611           text_view->layout->default_style->right_margin = right_margin;
2612           gtk_text_layout_default_style_changed (text_view->layout);
2613         }
2614
2615       g_object_notify (G_OBJECT (text_view), "right-margin");
2616     }
2617 }
2618
2619 /**
2620  * gtk_text_view_get_right_margin:
2621  * @text_view: a #GtkTextView
2622  *
2623  * Gets the default right margin for text in @text_view. Tags
2624  * in the buffer may override the default.
2625  *
2626  * Return value: right margin in pixels
2627  **/
2628 gint
2629 gtk_text_view_get_right_margin (GtkTextView *text_view)
2630 {
2631   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
2632
2633   return text_view->right_margin;
2634 }
2635
2636 /**
2637  * gtk_text_view_set_indent:
2638  * @text_view: a #GtkTextView
2639  * @indent: indentation in pixels
2640  *
2641  * Sets the default indentation for paragraphs in @text_view.
2642  * Tags in the buffer may override the default.
2643  **/
2644 void
2645 gtk_text_view_set_indent (GtkTextView *text_view,
2646                           gint         indent)
2647 {
2648   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2649
2650   if (text_view->indent != indent)
2651     {
2652       text_view->indent = indent;
2653
2654       if (text_view->layout)
2655         {
2656           text_view->layout->default_style->indent = indent;
2657           gtk_text_layout_default_style_changed (text_view->layout);
2658         }
2659
2660       g_object_notify (G_OBJECT (text_view), "indent");
2661     }
2662 }
2663
2664 /**
2665  * gtk_text_view_get_indent:
2666  * @text_view: a #GtkTextView
2667  *
2668  * Gets the default indentation of paragraphs in @text_view.
2669  * Tags in the view's buffer may override the default.
2670  * The indentation may be negative.
2671  *
2672  * Return value: number of pixels of indentation
2673  **/
2674 gint
2675 gtk_text_view_get_indent (GtkTextView *text_view)
2676 {
2677   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
2678
2679   return text_view->indent;
2680 }
2681
2682 /**
2683  * gtk_text_view_set_tabs:
2684  * @text_view: a #GtkTextView
2685  * @tabs: tabs as a #PangoTabArray
2686  *
2687  * Sets the default tab stops for paragraphs in @text_view.
2688  * Tags in the buffer may override the default.
2689  **/
2690 void
2691 gtk_text_view_set_tabs (GtkTextView   *text_view,
2692                         PangoTabArray *tabs)
2693 {
2694   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2695
2696   if (text_view->tabs)
2697     pango_tab_array_free (text_view->tabs);
2698
2699   text_view->tabs = tabs ? pango_tab_array_copy (tabs) : NULL;
2700
2701   if (text_view->layout)
2702     {
2703       /* some unkosher futzing in internal struct details... */
2704       if (text_view->layout->default_style->tabs)
2705         pango_tab_array_free (text_view->layout->default_style->tabs);
2706
2707       text_view->layout->default_style->tabs =
2708         text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
2709
2710       gtk_text_layout_default_style_changed (text_view->layout);
2711     }
2712
2713   g_object_notify (G_OBJECT (text_view), "tabs");
2714 }
2715
2716 /**
2717  * gtk_text_view_get_tabs:
2718  * @text_view: a #GtkTextView
2719  *
2720  * Gets the default tabs for @text_view. Tags in the buffer may
2721  * override the defaults. The returned array will be %NULL if
2722  * "standard" (8-space) tabs are used. Free the return value
2723  * with pango_tab_array_free().
2724  *
2725  * Return value: copy of default tab array, or %NULL if "standard"
2726  *    tabs are used; must be freed with pango_tab_array_free().
2727  **/
2728 PangoTabArray*
2729 gtk_text_view_get_tabs (GtkTextView *text_view)
2730 {
2731   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
2732
2733   return text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
2734 }
2735
2736 static void
2737 gtk_text_view_toggle_cursor_visible (GtkTextView *text_view)
2738 {
2739   gtk_text_view_set_cursor_visible (text_view, !text_view->cursor_visible);
2740 }
2741
2742 /**
2743  * gtk_text_view_set_cursor_visible:
2744  * @text_view: a #GtkTextView
2745  * @setting: whether to show the insertion cursor
2746  *
2747  * Toggles whether the insertion point is displayed. A buffer with no editable
2748  * text probably shouldn't have a visible cursor, so you may want to turn
2749  * the cursor off.
2750  **/
2751 void
2752 gtk_text_view_set_cursor_visible (GtkTextView *text_view,
2753                                   gboolean     setting)
2754 {
2755   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
2756
2757   setting = (setting != FALSE);
2758
2759   if (text_view->cursor_visible != setting)
2760     {
2761       text_view->cursor_visible = setting;
2762
2763       if (GTK_WIDGET_HAS_FOCUS (text_view))
2764         {
2765           if (text_view->layout)
2766             {
2767               gtk_text_layout_set_cursor_visible (text_view->layout, setting);
2768               gtk_text_view_check_cursor_blink (text_view);
2769             }
2770         }
2771
2772       g_object_notify (G_OBJECT (text_view), "cursor-visible");
2773     }
2774 }
2775
2776 /**
2777  * gtk_text_view_get_cursor_visible:
2778  * @text_view: a #GtkTextView
2779  *
2780  * Find out whether the cursor is being displayed.
2781  *
2782  * Return value: whether the insertion mark is visible
2783  **/
2784 gboolean
2785 gtk_text_view_get_cursor_visible (GtkTextView *text_view)
2786 {
2787   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
2788
2789   return text_view->cursor_visible;
2790 }
2791
2792
2793 /**
2794  * gtk_text_view_place_cursor_onscreen:
2795  * @text_view: a #GtkTextView
2796  *
2797  * Moves the cursor to the currently visible region of the
2798  * buffer, it it isn't there already.
2799  *
2800  * Return value: %TRUE if the cursor had to be moved.
2801  **/
2802 gboolean
2803 gtk_text_view_place_cursor_onscreen (GtkTextView *text_view)
2804 {
2805   GtkTextIter insert;
2806
2807   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
2808
2809   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
2810                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
2811
2812   if (clamp_iter_onscreen (text_view, &insert))
2813     {
2814       gtk_text_buffer_place_cursor (get_buffer (text_view), &insert);
2815       return TRUE;
2816     }
2817   else
2818     return FALSE;
2819 }
2820
2821 static void
2822 gtk_text_view_remove_validate_idles (GtkTextView *text_view)
2823 {
2824   if (text_view->first_validate_idle != 0)
2825     {
2826       DV (g_print ("Removing first validate idle: %s\n", G_STRLOC));
2827       g_source_remove (text_view->first_validate_idle);
2828       text_view->first_validate_idle = 0;
2829     }
2830
2831   if (text_view->incremental_validate_idle != 0)
2832     {
2833       g_source_remove (text_view->incremental_validate_idle);
2834       text_view->incremental_validate_idle = 0;
2835     }
2836 }
2837
2838 static void
2839 gtk_text_view_destroy (GtkObject *object)
2840 {
2841   GtkTextView *text_view;
2842   GtkTextViewPrivate *priv;
2843
2844   text_view = GTK_TEXT_VIEW (object);
2845   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
2846
2847   gtk_text_view_remove_validate_idles (text_view);
2848   gtk_text_view_set_buffer (text_view, NULL);
2849   gtk_text_view_destroy_layout (text_view);
2850
2851   if (text_view->scroll_timeout)
2852     {
2853       g_source_remove (text_view->scroll_timeout);
2854       text_view->scroll_timeout = 0;
2855     }
2856
2857   if (priv->im_spot_idle)
2858     {
2859       g_source_remove (priv->im_spot_idle);
2860       priv->im_spot_idle = 0;
2861     }
2862
2863   GTK_OBJECT_CLASS (gtk_text_view_parent_class)->destroy (object);
2864 }
2865
2866 static void
2867 gtk_text_view_finalize (GObject *object)
2868 {
2869   GtkTextView *text_view;
2870   GtkTextViewPrivate *priv;
2871
2872   text_view = GTK_TEXT_VIEW (object);
2873   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
2874
2875   g_assert (text_view->buffer == NULL);
2876
2877   gtk_text_view_destroy_layout (text_view);
2878   gtk_text_view_set_buffer (text_view, NULL);
2879
2880   cancel_pending_scroll (text_view);
2881
2882   if (text_view->tabs)
2883     pango_tab_array_free (text_view->tabs);
2884
2885   if (text_view->hadjustment)
2886     g_object_unref (text_view->hadjustment);
2887   if (text_view->vadjustment)
2888     g_object_unref (text_view->vadjustment);
2889
2890   text_window_free (text_view->text_window);
2891
2892   if (text_view->left_window)
2893     text_window_free (text_view->left_window);
2894
2895   if (text_view->top_window)
2896     text_window_free (text_view->top_window);
2897
2898   if (text_view->right_window)
2899     text_window_free (text_view->right_window);
2900
2901   if (text_view->bottom_window)
2902     text_window_free (text_view->bottom_window);
2903
2904   g_object_unref (text_view->im_context);
2905
2906   g_free (priv->im_module);
2907
2908   G_OBJECT_CLASS (gtk_text_view_parent_class)->finalize (object);
2909 }
2910
2911 static void
2912 gtk_text_view_set_property (GObject         *object,
2913                             guint            prop_id,
2914                             const GValue    *value,
2915                             GParamSpec      *pspec)
2916 {
2917   GtkTextView *text_view;
2918   GtkTextViewPrivate *priv;
2919
2920   text_view = GTK_TEXT_VIEW (object);
2921   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
2922
2923   switch (prop_id)
2924     {
2925     case PROP_PIXELS_ABOVE_LINES:
2926       gtk_text_view_set_pixels_above_lines (text_view, g_value_get_int (value));
2927       break;
2928
2929     case PROP_PIXELS_BELOW_LINES:
2930       gtk_text_view_set_pixels_below_lines (text_view, g_value_get_int (value));
2931       break;
2932
2933     case PROP_PIXELS_INSIDE_WRAP:
2934       gtk_text_view_set_pixels_inside_wrap (text_view, g_value_get_int (value));
2935       break;
2936
2937     case PROP_EDITABLE:
2938       gtk_text_view_set_editable (text_view, g_value_get_boolean (value));
2939       break;
2940
2941     case PROP_WRAP_MODE:
2942       gtk_text_view_set_wrap_mode (text_view, g_value_get_enum (value));
2943       break;
2944
2945     case PROP_JUSTIFICATION:
2946       gtk_text_view_set_justification (text_view, g_value_get_enum (value));
2947       break;
2948
2949     case PROP_LEFT_MARGIN:
2950       gtk_text_view_set_left_margin (text_view, g_value_get_int (value));
2951       break;
2952
2953     case PROP_RIGHT_MARGIN:
2954       gtk_text_view_set_right_margin (text_view, g_value_get_int (value));
2955       break;
2956
2957     case PROP_INDENT:
2958       gtk_text_view_set_indent (text_view, g_value_get_int (value));
2959       break;
2960
2961     case PROP_TABS:
2962       gtk_text_view_set_tabs (text_view, g_value_get_boxed (value));
2963       break;
2964
2965     case PROP_CURSOR_VISIBLE:
2966       gtk_text_view_set_cursor_visible (text_view, g_value_get_boolean (value));
2967       break;
2968
2969     case PROP_OVERWRITE:
2970       gtk_text_view_set_overwrite (text_view, g_value_get_boolean (value));
2971       break;
2972
2973     case PROP_BUFFER:
2974       gtk_text_view_set_buffer (text_view, GTK_TEXT_BUFFER (g_value_get_object (value)));
2975       break;
2976
2977     case PROP_ACCEPTS_TAB:
2978       gtk_text_view_set_accepts_tab (text_view, g_value_get_boolean (value));
2979       break;
2980
2981     case PROP_IM_MODULE:
2982       g_free (priv->im_module);
2983       priv->im_module = g_strdup (g_value_get_string (value));
2984       if (GTK_IS_IM_MULTICONTEXT (text_view->im_context))
2985         gtk_im_multicontext_set_context_id (GTK_IM_MULTICONTEXT (text_view->im_context), priv->im_module);
2986       break;
2987
2988     default:
2989       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2990       break;
2991     }
2992 }
2993
2994 static void
2995 gtk_text_view_get_property (GObject         *object,
2996                             guint            prop_id,
2997                             GValue          *value,
2998                             GParamSpec      *pspec)
2999 {
3000   GtkTextView *text_view;
3001   GtkTextViewPrivate *priv;
3002
3003   text_view = GTK_TEXT_VIEW (object);
3004   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
3005
3006   switch (prop_id)
3007     {
3008     case PROP_PIXELS_ABOVE_LINES:
3009       g_value_set_int (value, text_view->pixels_above_lines);
3010       break;
3011
3012     case PROP_PIXELS_BELOW_LINES:
3013       g_value_set_int (value, text_view->pixels_below_lines);
3014       break;
3015
3016     case PROP_PIXELS_INSIDE_WRAP:
3017       g_value_set_int (value, text_view->pixels_inside_wrap);
3018       break;
3019
3020     case PROP_EDITABLE:
3021       g_value_set_boolean (value, text_view->editable);
3022       break;
3023
3024     case PROP_WRAP_MODE:
3025       g_value_set_enum (value, text_view->wrap_mode);
3026       break;
3027
3028     case PROP_JUSTIFICATION:
3029       g_value_set_enum (value, text_view->justify);
3030       break;
3031
3032     case PROP_LEFT_MARGIN:
3033       g_value_set_int (value, text_view->left_margin);
3034       break;
3035
3036     case PROP_RIGHT_MARGIN:
3037       g_value_set_int (value, text_view->right_margin);
3038       break;
3039
3040     case PROP_INDENT:
3041       g_value_set_int (value, text_view->indent);
3042       break;
3043
3044     case PROP_TABS:
3045       g_value_set_boxed (value, text_view->tabs);
3046       break;
3047
3048     case PROP_CURSOR_VISIBLE:
3049       g_value_set_boolean (value, text_view->cursor_visible);
3050       break;
3051
3052     case PROP_BUFFER:
3053       g_value_set_object (value, get_buffer (text_view));
3054       break;
3055
3056     case PROP_OVERWRITE:
3057       g_value_set_boolean (value, text_view->overwrite_mode);
3058       break;
3059
3060     case PROP_ACCEPTS_TAB:
3061       g_value_set_boolean (value, text_view->accepts_tab);
3062       break;
3063
3064     case PROP_IM_MODULE:
3065       g_value_set_string (value, priv->im_module);
3066       break;
3067
3068     default:
3069       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
3070       break;
3071     }
3072 }
3073
3074 static void
3075 gtk_text_view_size_request (GtkWidget      *widget,
3076                             GtkRequisition *requisition)
3077 {
3078   GtkTextView *text_view;
3079   GSList *tmp_list;
3080   gint focus_edge_width;
3081   gint focus_width;
3082   gboolean interior_focus;
3083
3084   text_view = GTK_TEXT_VIEW (widget);
3085
3086   gtk_widget_style_get (widget,
3087                         "interior-focus", &interior_focus,
3088                         "focus-line-width", &focus_width,
3089                         NULL);
3090
3091   if (interior_focus)
3092     focus_edge_width = 0;
3093   else
3094     focus_edge_width = focus_width;
3095
3096   if (text_view->layout)
3097     {
3098       text_view->text_window->requisition.width = text_view->layout->width;
3099       text_view->text_window->requisition.height = text_view->layout->height;
3100     }
3101   else
3102     {
3103       text_view->text_window->requisition.width = 0;
3104       text_view->text_window->requisition.height = 0;
3105     }
3106
3107   requisition->width = text_view->text_window->requisition.width + focus_edge_width * 2;
3108   requisition->height = text_view->text_window->requisition.height + focus_edge_width * 2;
3109
3110   if (text_view->left_window)
3111     requisition->width += text_view->left_window->requisition.width;
3112
3113   if (text_view->right_window)
3114     requisition->width += text_view->right_window->requisition.width;
3115
3116   if (text_view->top_window)
3117     requisition->height += text_view->top_window->requisition.height;
3118
3119   if (text_view->bottom_window)
3120     requisition->height += text_view->bottom_window->requisition.height;
3121
3122   requisition->width += GTK_CONTAINER (text_view)->border_width * 2;
3123   requisition->height += GTK_CONTAINER (text_view)->border_width * 2;
3124
3125   tmp_list = text_view->children;
3126   while (tmp_list != NULL)
3127     {
3128       GtkTextViewChild *child = tmp_list->data;
3129
3130       if (child->anchor)
3131         {
3132           GtkRequisition child_req;
3133           GtkRequisition old_req;
3134
3135           gtk_widget_get_child_requisition (child->widget, &old_req);
3136
3137           gtk_widget_size_request (child->widget, &child_req);
3138
3139           gtk_widget_get_child_requisition (child->widget, &child_req);
3140
3141           /* Invalidate layout lines if required */
3142           if (text_view->layout &&
3143               (old_req.width != child_req.width ||
3144                old_req.height != child_req.height))
3145             gtk_text_child_anchor_queue_resize (child->anchor,
3146                                                 text_view->layout);
3147         }
3148       else
3149         {
3150           GtkRequisition child_req;
3151
3152           gtk_widget_size_request (child->widget, &child_req);
3153         }
3154
3155       tmp_list = g_slist_next (tmp_list);
3156     }
3157 }
3158
3159 static void
3160 gtk_text_view_compute_child_allocation (GtkTextView      *text_view,
3161                                         GtkTextViewChild *vc,
3162                                         GtkAllocation    *allocation)
3163 {
3164   gint buffer_y;
3165   GtkTextIter iter;
3166   GtkRequisition req;
3167
3168   gtk_text_buffer_get_iter_at_child_anchor (get_buffer (text_view),
3169                                             &iter,
3170                                             vc->anchor);
3171
3172   gtk_text_layout_get_line_yrange (text_view->layout, &iter,
3173                                    &buffer_y, NULL);
3174
3175   buffer_y += vc->from_top_of_line;
3176
3177   allocation->x = vc->from_left_of_buffer - text_view->xoffset;
3178   allocation->y = buffer_y - text_view->yoffset;
3179
3180   gtk_widget_get_child_requisition (vc->widget, &req);
3181   allocation->width = req.width;
3182   allocation->height = req.height;
3183 }
3184
3185 static void
3186 gtk_text_view_update_child_allocation (GtkTextView      *text_view,
3187                                        GtkTextViewChild *vc)
3188 {
3189   GtkAllocation allocation;
3190
3191   gtk_text_view_compute_child_allocation (text_view, vc, &allocation);
3192
3193   gtk_widget_size_allocate (vc->widget, &allocation);
3194
3195 #if 0
3196   g_print ("allocation for %p allocated to %d,%d yoffset = %d\n",
3197            vc->widget,
3198            vc->widget->allocation.x,
3199            vc->widget->allocation.y,
3200            text_view->yoffset);
3201 #endif
3202 }
3203
3204 static void
3205 gtk_text_view_child_allocated (GtkTextLayout *layout,
3206                                GtkWidget     *child,
3207                                gint           x,
3208                                gint           y,
3209                                gpointer       data)
3210 {
3211   GtkTextViewChild *vc = NULL;
3212   GtkTextView *text_view = data;
3213
3214   /* x,y is the position of the child from the top of the line, and
3215    * from the left of the buffer. We have to translate that into text
3216    * window coordinates, then size_allocate the child.
3217    */
3218
3219   vc = g_object_get_data (G_OBJECT (child),
3220                           "gtk-text-view-child");
3221
3222   g_assert (vc != NULL);
3223
3224   DV (g_print ("child allocated at %d,%d\n", x, y));
3225
3226   vc->from_left_of_buffer = x;
3227   vc->from_top_of_line = y;
3228
3229   gtk_text_view_update_child_allocation (text_view, vc);
3230 }
3231
3232 static void
3233 gtk_text_view_allocate_children (GtkTextView *text_view)
3234 {
3235   GSList *tmp_list;
3236
3237   DV(g_print(G_STRLOC"\n"));
3238
3239   tmp_list = text_view->children;
3240   while (tmp_list != NULL)
3241     {
3242       GtkTextViewChild *child = tmp_list->data;
3243
3244       g_assert (child != NULL);
3245
3246       if (child->anchor)
3247         {
3248           /* We need to force-validate the regions containing
3249            * children.
3250            */
3251           GtkTextIter child_loc;
3252           gtk_text_buffer_get_iter_at_child_anchor (get_buffer (text_view),
3253                                                     &child_loc,
3254                                                     child->anchor);
3255
3256           /* Since anchored children are only ever allocated from
3257            * gtk_text_layout_get_line_display() we have to make sure
3258            * that the display line caching in the layout doesn't
3259            * get in the way. Invalidating the layout around the anchor
3260            * achieves this.
3261            */
3262           if (GTK_WIDGET_ALLOC_NEEDED (child->widget))
3263             {
3264               GtkTextIter end = child_loc;
3265               gtk_text_iter_forward_char (&end);
3266               gtk_text_layout_invalidate (text_view->layout, &child_loc, &end);
3267             }
3268
3269           gtk_text_layout_validate_yrange (text_view->layout,
3270                                            &child_loc,
3271                                            0, 1);
3272         }
3273       else
3274         {
3275           GtkAllocation allocation;
3276           GtkRequisition child_req;
3277
3278           allocation.x = child->x;
3279           allocation.y = child->y;
3280
3281           gtk_widget_get_child_requisition (child->widget, &child_req);
3282
3283           allocation.width = child_req.width;
3284           allocation.height = child_req.height;
3285
3286           gtk_widget_size_allocate (child->widget, &allocation);
3287         }
3288
3289       tmp_list = g_slist_next (tmp_list);
3290     }
3291 }
3292
3293 static void
3294 gtk_text_view_size_allocate (GtkWidget *widget,
3295                              GtkAllocation *allocation)
3296 {
3297   GtkTextView *text_view;
3298   GtkTextIter first_para;
3299   gint y;
3300   gint width, height;
3301   GdkRectangle text_rect;
3302   GdkRectangle left_rect;
3303   GdkRectangle right_rect;
3304   GdkRectangle top_rect;
3305   GdkRectangle bottom_rect;
3306   gint focus_edge_width;
3307   gint focus_width;
3308   gboolean interior_focus;
3309   gboolean size_changed;
3310
3311   text_view = GTK_TEXT_VIEW (widget);
3312
3313   DV(g_print(G_STRLOC"\n"));
3314
3315   size_changed =
3316     widget->allocation.width != allocation->width ||
3317     widget->allocation.height != allocation->height;
3318
3319   widget->allocation = *allocation;
3320
3321   if (GTK_WIDGET_REALIZED (widget))
3322     {
3323       gdk_window_move_resize (widget->window,
3324                               allocation->x, allocation->y,
3325                               allocation->width, allocation->height);
3326     }
3327
3328   /* distribute width/height among child windows. Ensure all
3329    * windows get at least a 1x1 allocation.
3330    */
3331
3332   gtk_widget_style_get (widget,
3333                         "interior-focus", &interior_focus,
3334                         "focus-line-width", &focus_width,
3335                         NULL);
3336
3337   if (interior_focus)
3338     focus_edge_width = 0;
3339   else
3340     focus_edge_width = focus_width;
3341
3342   width = allocation->width - focus_edge_width * 2 - GTK_CONTAINER (text_view)->border_width * 2;
3343
3344   if (text_view->left_window)
3345     left_rect.width = text_view->left_window->requisition.width;
3346   else
3347     left_rect.width = 0;
3348
3349   width -= left_rect.width;
3350
3351   if (text_view->right_window)
3352     right_rect.width = text_view->right_window->requisition.width;
3353   else
3354     right_rect.width = 0;
3355
3356   width -= right_rect.width;
3357
3358   text_rect.width = MAX (1, width);
3359
3360   top_rect.width = text_rect.width;
3361   bottom_rect.width = text_rect.width;
3362
3363
3364   height = allocation->height - focus_edge_width * 2 - GTK_CONTAINER (text_view)->border_width * 2;
3365
3366   if (text_view->top_window)
3367     top_rect.height = text_view->top_window->requisition.height;
3368   else
3369     top_rect.height = 0;
3370
3371   height -= top_rect.height;
3372
3373   if (text_view->bottom_window)
3374     bottom_rect.height = text_view->bottom_window->requisition.height;
3375   else
3376     bottom_rect.height = 0;
3377
3378   height -= bottom_rect.height;
3379
3380   text_rect.height = MAX (1, height);
3381
3382   left_rect.height = text_rect.height;
3383   right_rect.height = text_rect.height;
3384
3385   /* Origins */
3386   left_rect.x = focus_edge_width + GTK_CONTAINER (text_view)->border_width;
3387   top_rect.y = focus_edge_width + GTK_CONTAINER (text_view)->border_width;
3388
3389   text_rect.x = left_rect.x + left_rect.width;
3390   text_rect.y = top_rect.y + top_rect.height;
3391
3392   left_rect.y = text_rect.y;
3393   right_rect.y = text_rect.y;
3394
3395   top_rect.x = text_rect.x;
3396   bottom_rect.x = text_rect.x;
3397
3398   right_rect.x = text_rect.x + text_rect.width;
3399   bottom_rect.y = text_rect.y + text_rect.height;
3400
3401   text_window_size_allocate (text_view->text_window,
3402                              &text_rect);
3403
3404   if (text_view->left_window)
3405     text_window_size_allocate (text_view->left_window,
3406                                &left_rect);
3407
3408   if (text_view->right_window)
3409     text_window_size_allocate (text_view->right_window,
3410                                &right_rect);
3411
3412   if (text_view->top_window)
3413     text_window_size_allocate (text_view->top_window,
3414                                &top_rect);
3415
3416   if (text_view->bottom_window)
3417     text_window_size_allocate (text_view->bottom_window,
3418                                &bottom_rect);
3419
3420   gtk_text_view_update_layout_width (text_view);
3421
3422   /* Note that this will do some layout validation */
3423   gtk_text_view_allocate_children (text_view);
3424
3425   /* Ensure h/v adj exist */
3426   get_hadjustment (text_view);
3427   get_vadjustment (text_view);
3428
3429   text_view->hadjustment->page_size = SCREEN_WIDTH (text_view);
3430   text_view->hadjustment->page_increment = SCREEN_WIDTH (text_view) * 0.9;
3431   text_view->hadjustment->step_increment = SCREEN_WIDTH (text_view) * 0.1;
3432   text_view->hadjustment->lower = 0;
3433   text_view->hadjustment->upper = MAX (SCREEN_WIDTH (text_view),
3434                                        text_view->width);
3435
3436   if (text_view->hadjustment->value > text_view->hadjustment->upper - text_view->hadjustment->page_size)
3437     gtk_adjustment_set_value (text_view->hadjustment, MAX (0, text_view->hadjustment->upper - text_view->hadjustment->page_size));
3438
3439   gtk_adjustment_changed (text_view->hadjustment);
3440
3441   text_view->vadjustment->page_size = SCREEN_HEIGHT (text_view);
3442   text_view->vadjustment->page_increment = SCREEN_HEIGHT (text_view) * 0.9;
3443   text_view->vadjustment->step_increment = SCREEN_HEIGHT (text_view) * 0.1;
3444   text_view->vadjustment->lower = 0;
3445   text_view->vadjustment->upper = MAX (SCREEN_HEIGHT (text_view),
3446                                        text_view->height);
3447
3448   /* Now adjust the value of the adjustment to keep the cursor at the
3449    * same place in the buffer
3450    */
3451   gtk_text_view_get_first_para_iter (text_view, &first_para);
3452   gtk_text_layout_get_line_yrange (text_view->layout, &first_para, &y, NULL);
3453
3454   y += text_view->first_para_pixels;
3455
3456   if (y > text_view->vadjustment->upper - text_view->vadjustment->page_size)
3457     y = MAX (0, text_view->vadjustment->upper - text_view->vadjustment->page_size);
3458
3459   if (y != text_view->yoffset)
3460     gtk_adjustment_set_value (text_view->vadjustment, y);
3461
3462   gtk_adjustment_changed (text_view->vadjustment);
3463
3464   /* The GTK resize loop processes all the pending exposes right
3465    * after doing the resize stuff, so the idle sizer won't have a
3466    * chance to run. So we do the work here.
3467    */
3468   gtk_text_view_flush_first_validate (text_view);
3469
3470   /* widget->window doesn't get auto-redrawn as the layout is computed, so has to
3471    * be invalidated
3472    */
3473   if (size_changed && GTK_WIDGET_REALIZED (widget))
3474     gdk_window_invalidate_rect (widget->window, NULL, FALSE);
3475 }
3476
3477 static void
3478 gtk_text_view_get_first_para_iter (GtkTextView *text_view,
3479                                    GtkTextIter *iter)
3480 {
3481   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), iter,
3482                                     text_view->first_para_mark);
3483 }
3484
3485 static void
3486 gtk_text_view_validate_onscreen (GtkTextView *text_view)
3487 {
3488   GtkWidget *widget = GTK_WIDGET (text_view);
3489
3490   DV(g_print(">Validating onscreen ("G_STRLOC")\n"));
3491
3492   if (SCREEN_HEIGHT (widget) > 0)
3493     {
3494       GtkTextIter first_para;
3495
3496       /* Be sure we've validated the stuff onscreen; if we
3497        * scrolled, these calls won't have any effect, because
3498        * they were called in the recursive validate_onscreen
3499        */
3500       gtk_text_view_get_first_para_iter (text_view, &first_para);
3501
3502       gtk_text_layout_validate_yrange (text_view->layout,
3503                                        &first_para,
3504                                        0,
3505                                        text_view->first_para_pixels +
3506                                        SCREEN_HEIGHT (widget));
3507     }
3508
3509   text_view->onscreen_validated = TRUE;
3510
3511   DV(g_print(">Done validating onscreen, onscreen_validated = TRUE ("G_STRLOC")\n"));
3512
3513   /* This can have the odd side effect of triggering a scroll, which should
3514    * flip "onscreen_validated" back to FALSE, but should also get us
3515    * back into this function to turn it on again.
3516    */
3517   gtk_text_view_update_adjustments (text_view);
3518
3519   g_assert (text_view->onscreen_validated);
3520 }
3521
3522 static void
3523 gtk_text_view_flush_first_validate (GtkTextView *text_view)
3524 {
3525   if (text_view->first_validate_idle == 0)
3526     return;
3527
3528   /* Do this first, which means that if an "invalidate"
3529    * occurs during any of this process, a new first_validate_callback
3530    * will be installed, and we'll start again.
3531    */
3532   DV (g_print ("removing first validate in %s\n", G_STRLOC));
3533   g_source_remove (text_view->first_validate_idle);
3534   text_view->first_validate_idle = 0;
3535
3536   /* be sure we have up-to-date screen size set on the
3537    * layout.
3538    */
3539   gtk_text_view_update_layout_width (text_view);
3540
3541   /* Bail out if we invalidated stuff; scrolling right away will just
3542    * confuse the issue.
3543    */
3544   if (text_view->first_validate_idle != 0)
3545     {
3546       DV(g_print(">Width change forced requeue ("G_STRLOC")\n"));
3547     }
3548   else
3549     {
3550       /* scroll to any marks, if that's pending. This can jump us to
3551        * the validation codepath used for scrolling onscreen, if so we
3552        * bail out.  It won't jump if already in that codepath since
3553        * value_changed is not recursive, so also validate if
3554        * necessary.
3555        */
3556       if (!gtk_text_view_flush_scroll (text_view) ||
3557           !text_view->onscreen_validated)
3558         gtk_text_view_validate_onscreen (text_view);
3559
3560       DV(g_print(">Leaving first validate idle ("G_STRLOC")\n"));
3561
3562       g_assert (text_view->onscreen_validated);
3563     }
3564 }
3565
3566 static gboolean
3567 first_validate_callback (gpointer data)
3568 {
3569   GtkTextView *text_view = data;
3570
3571   /* Note that some of this code is duplicated at the end of size_allocate,
3572    * keep in sync with that.
3573    */
3574
3575   DV(g_print(G_STRLOC"\n"));
3576
3577   gtk_text_view_flush_first_validate (text_view);
3578
3579   return FALSE;
3580 }
3581
3582 static gboolean
3583 incremental_validate_callback (gpointer data)
3584 {
3585   GtkTextView *text_view = data;
3586   gboolean result = TRUE;
3587
3588   DV(g_print(G_STRLOC"\n"));
3589
3590   gtk_text_layout_validate (text_view->layout, 2000);
3591
3592   gtk_text_view_update_adjustments (text_view);
3593
3594   if (gtk_text_layout_is_valid (text_view->layout))
3595     {
3596       text_view->incremental_validate_idle = 0;
3597       result = FALSE;
3598     }
3599
3600   return result;
3601 }
3602
3603 static void
3604 gtk_text_view_invalidate (GtkTextView *text_view)
3605 {
3606   DV (g_print (">Invalidate, onscreen_validated = %d now FALSE ("G_STRLOC")\n",
3607                text_view->onscreen_validated));
3608
3609   text_view->onscreen_validated = FALSE;
3610
3611   /* We'll invalidate when the layout is created */
3612   if (text_view->layout == NULL)
3613     return;
3614
3615   if (!text_view->first_validate_idle)
3616     {
3617       text_view->first_validate_idle = gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, first_validate_callback, text_view, NULL);
3618       DV (g_print (G_STRLOC": adding first validate idle %d\n",
3619                    text_view->first_validate_idle));
3620     }
3621
3622   if (!text_view->incremental_validate_idle)
3623     {
3624       text_view->incremental_validate_idle = gdk_threads_add_idle_full (GTK_TEXT_VIEW_PRIORITY_VALIDATE, incremental_validate_callback, text_view, NULL);
3625       DV (g_print (G_STRLOC": adding incremental validate idle %d\n",
3626                    text_view->incremental_validate_idle));
3627     }
3628 }
3629
3630 static void
3631 invalidated_handler (GtkTextLayout *layout,
3632                      gpointer       data)
3633 {
3634   GtkTextView *text_view;
3635
3636   text_view = GTK_TEXT_VIEW (data);
3637
3638   DV (g_print ("Invalidating due to layout invalidate signal\n"));
3639   gtk_text_view_invalidate (text_view);
3640 }
3641
3642 static void
3643 changed_handler (GtkTextLayout     *layout,
3644                  gint               start_y,
3645                  gint               old_height,
3646                  gint               new_height,
3647                  gpointer           data)
3648 {
3649   GtkTextView *text_view;
3650   GtkWidget *widget;
3651   GdkRectangle visible_rect;
3652   GdkRectangle redraw_rect;
3653
3654   text_view = GTK_TEXT_VIEW (data);
3655   widget = GTK_WIDGET (data);
3656
3657   DV(g_print(">Lines Validated ("G_STRLOC")\n"));
3658
3659   if (GTK_WIDGET_REALIZED (text_view))
3660     {
3661       gtk_text_view_get_visible_rect (text_view, &visible_rect);
3662
3663       redraw_rect.x = visible_rect.x;
3664       redraw_rect.width = visible_rect.width;
3665       redraw_rect.y = start_y;
3666
3667       if (old_height == new_height)
3668         redraw_rect.height = old_height;
3669       else if (start_y + old_height > visible_rect.y)
3670         redraw_rect.height = MAX (0, visible_rect.y + visible_rect.height - start_y);
3671       else
3672         redraw_rect.height = 0;
3673
3674       if (gdk_rectangle_intersect (&redraw_rect, &visible_rect, &redraw_rect))
3675         {
3676           /* text_window_invalidate_rect() takes buffer coordinates */
3677           text_window_invalidate_rect (text_view->text_window,
3678                                        &redraw_rect);
3679
3680           DV(g_print(" invalidated rect: %d,%d %d x %d\n",
3681                      redraw_rect.x,
3682                      redraw_rect.y,
3683                      redraw_rect.width,
3684                      redraw_rect.height));
3685
3686           if (text_view->left_window)
3687             text_window_invalidate_rect (text_view->left_window,
3688                                          &redraw_rect);
3689           if (text_view->right_window)
3690             text_window_invalidate_rect (text_view->right_window,
3691                                          &redraw_rect);
3692           if (text_view->top_window)
3693             text_window_invalidate_rect (text_view->top_window,
3694                                          &redraw_rect);
3695           if (text_view->bottom_window)
3696             text_window_invalidate_rect (text_view->bottom_window,
3697                                          &redraw_rect);
3698
3699           queue_update_im_spot_location (text_view);
3700         }
3701     }
3702
3703   if (old_height != new_height)
3704     {
3705       gboolean yoffset_changed = FALSE;
3706       GSList *tmp_list;
3707       int new_first_para_top;
3708       int old_first_para_top;
3709       GtkTextIter first;
3710
3711       /* If the bottom of the old area was above the top of the
3712        * screen, we need to scroll to keep the current top of the
3713        * screen in place.  Remember that first_para_pixels is the
3714        * position of the top of the screen in coordinates relative to
3715        * the first paragraph onscreen.
3716        *
3717        * In short we are adding the height delta of the portion of the
3718        * changed region above first_para_mark to text_view->yoffset.
3719        */
3720       gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &first,
3721                                         text_view->first_para_mark);
3722
3723       gtk_text_layout_get_line_yrange (layout, &first, &new_first_para_top, NULL);
3724
3725       old_first_para_top = text_view->yoffset - text_view->first_para_pixels;
3726
3727       if (new_first_para_top != old_first_para_top)
3728         {
3729           text_view->yoffset += new_first_para_top - old_first_para_top;
3730
3731           get_vadjustment (text_view)->value = text_view->yoffset;
3732           yoffset_changed = TRUE;
3733         }
3734
3735       if (yoffset_changed)
3736         {
3737           DV(g_print ("Changing scroll position (%s)\n", G_STRLOC));
3738           gtk_adjustment_value_changed (get_vadjustment (text_view));
3739         }
3740
3741       /* FIXME be smarter about which anchored widgets we update */
3742
3743       tmp_list = text_view->children;
3744       while (tmp_list != NULL)
3745         {
3746           GtkTextViewChild *child = tmp_list->data;
3747
3748           if (child->anchor)
3749             gtk_text_view_update_child_allocation (text_view, child);
3750
3751           tmp_list = g_slist_next (tmp_list);
3752         }
3753     }
3754
3755   {
3756     GtkRequisition old_req;
3757     GtkRequisition new_req;
3758
3759     old_req = widget->requisition;
3760
3761     /* Use this instead of gtk_widget_size_request wrapper
3762      * to avoid the optimization which just returns widget->requisition
3763      * if a resize hasn't been queued.
3764      */
3765     GTK_WIDGET_GET_CLASS (widget)->size_request (widget, &new_req);
3766
3767     if (old_req.width != new_req.width ||
3768         old_req.height != new_req.height)
3769       {
3770         gtk_widget_queue_resize_no_redraw (widget);
3771       }
3772   }
3773 }
3774
3775 static void
3776 gtk_text_view_realize (GtkWidget *widget)
3777 {
3778   GtkTextView *text_view;
3779   GdkWindowAttr attributes;
3780   gint attributes_mask;
3781   GSList *tmp_list;
3782
3783   text_view = GTK_TEXT_VIEW (widget);
3784   GTK_WIDGET_SET_FLAGS (text_view, GTK_REALIZED);
3785
3786   attributes.window_type = GDK_WINDOW_CHILD;
3787   attributes.x = widget->allocation.x;
3788   attributes.y = widget->allocation.y;
3789   attributes.width = widget->allocation.width;
3790   attributes.height = widget->allocation.height;
3791   attributes.wclass = GDK_INPUT_OUTPUT;
3792   attributes.visual = gtk_widget_get_visual (widget);
3793   attributes.colormap = gtk_widget_get_colormap (widget);
3794   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK;
3795
3796   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
3797
3798   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
3799                                    &attributes, attributes_mask);
3800   gdk_window_set_user_data (widget->window, widget);
3801
3802   /* must come before text_window_realize calls */
3803   widget->style = gtk_style_attach (widget->style, widget->window);
3804
3805   gdk_window_set_background (widget->window,
3806                              &widget->style->bg[GTK_WIDGET_STATE (widget)]);
3807
3808   text_window_realize (text_view->text_window, widget);
3809
3810   if (text_view->left_window)
3811     text_window_realize (text_view->left_window, widget);
3812
3813   if (text_view->top_window)
3814     text_window_realize (text_view->top_window, widget);
3815
3816   if (text_view->right_window)
3817     text_window_realize (text_view->right_window, widget);
3818
3819   if (text_view->bottom_window)
3820     text_window_realize (text_view->bottom_window, widget);
3821
3822   gtk_text_view_ensure_layout (text_view);
3823
3824   if (text_view->buffer)
3825     {
3826       GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
3827                                                           GDK_SELECTION_PRIMARY);
3828       gtk_text_buffer_add_selection_clipboard (text_view->buffer, clipboard);
3829     }
3830
3831   tmp_list = text_view->children;
3832   while (tmp_list != NULL)
3833     {
3834       GtkTextViewChild *vc = tmp_list->data;
3835
3836       text_view_child_set_parent_window (text_view, vc);
3837
3838       tmp_list = tmp_list->next;
3839     }
3840
3841   /* Ensure updating the spot location. */
3842   gtk_text_view_update_im_spot_location (text_view);
3843 }
3844
3845 static void
3846 gtk_text_view_unrealize (GtkWidget *widget)
3847 {
3848   GtkTextView *text_view;
3849
3850   text_view = GTK_TEXT_VIEW (widget);
3851
3852   if (text_view->buffer)
3853     {
3854       GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
3855                                                           GDK_SELECTION_PRIMARY);
3856       gtk_text_buffer_remove_selection_clipboard (text_view->buffer, clipboard);
3857     }
3858
3859   gtk_text_view_remove_validate_idles (text_view);
3860
3861   if (text_view->popup_menu)
3862     {
3863       gtk_widget_destroy (text_view->popup_menu);
3864       text_view->popup_menu = NULL;
3865     }
3866
3867   text_window_unrealize (text_view->text_window);
3868
3869   if (text_view->left_window)
3870     text_window_unrealize (text_view->left_window);
3871
3872   if (text_view->top_window)
3873     text_window_unrealize (text_view->top_window);
3874
3875   if (text_view->right_window)
3876     text_window_unrealize (text_view->right_window);
3877
3878   if (text_view->bottom_window)
3879     text_window_unrealize (text_view->bottom_window);
3880
3881   gtk_text_view_destroy_layout (text_view);
3882
3883   GTK_WIDGET_CLASS (gtk_text_view_parent_class)->unrealize (widget);
3884 }
3885
3886 static void
3887 gtk_text_view_set_background (GtkTextView *text_view)
3888 {
3889   GtkWidget *widget = GTK_WIDGET (text_view);
3890
3891   gdk_window_set_background (widget->window,
3892                              &widget->style->bg[GTK_WIDGET_STATE (widget)]);
3893
3894   gdk_window_set_background (text_view->text_window->bin_window,
3895                              &widget->style->base[GTK_WIDGET_STATE (widget)]);
3896
3897   if (text_view->left_window)
3898     gdk_window_set_background (text_view->left_window->bin_window,
3899                                &widget->style->bg[GTK_WIDGET_STATE (widget)]);
3900   if (text_view->right_window)
3901     gdk_window_set_background (text_view->right_window->bin_window,
3902                                &widget->style->bg[GTK_WIDGET_STATE (widget)]);
3903
3904   if (text_view->top_window)
3905     gdk_window_set_background (text_view->top_window->bin_window,
3906                                &widget->style->bg[GTK_WIDGET_STATE (widget)]);
3907
3908   if (text_view->bottom_window)
3909     gdk_window_set_background (text_view->bottom_window->bin_window,
3910                                &widget->style->bg[GTK_WIDGET_STATE (widget)]);
3911 }
3912
3913 static void
3914 gtk_text_view_style_set (GtkWidget *widget,
3915                          GtkStyle  *previous_style)
3916 {
3917   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
3918   PangoContext *ltr_context, *rtl_context;
3919
3920   if (GTK_WIDGET_REALIZED (widget))
3921     {
3922       gtk_text_view_set_background (text_view);
3923     }
3924
3925   if (text_view->layout && previous_style)
3926     {
3927       gtk_text_view_set_attributes_from_style (text_view,
3928                                                text_view->layout->default_style,
3929                                                widget->style);
3930
3931
3932       ltr_context = gtk_widget_create_pango_context (widget);
3933       pango_context_set_base_dir (ltr_context, PANGO_DIRECTION_LTR);
3934       rtl_context = gtk_widget_create_pango_context (widget);
3935       pango_context_set_base_dir (rtl_context, PANGO_DIRECTION_RTL);
3936
3937       gtk_text_layout_set_contexts (text_view->layout, ltr_context, rtl_context);
3938
3939       g_object_unref (ltr_context);
3940       g_object_unref (rtl_context);
3941     }
3942 }
3943
3944 static void
3945 gtk_text_view_direction_changed (GtkWidget        *widget,
3946                                  GtkTextDirection  previous_direction)
3947 {
3948   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
3949
3950   if (text_view->layout)
3951     {
3952       text_view->layout->default_style->direction = gtk_widget_get_direction (widget);
3953
3954       gtk_text_layout_default_style_changed (text_view->layout);
3955     }
3956 }
3957
3958 static void
3959 gtk_text_view_state_changed (GtkWidget      *widget,
3960                              GtkStateType    previous_state)
3961 {
3962   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
3963   GdkCursor *cursor;
3964
3965   if (GTK_WIDGET_REALIZED (widget))
3966     {
3967       gtk_text_view_set_background (text_view);
3968
3969       if (GTK_WIDGET_IS_SENSITIVE (widget))
3970         cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), GDK_XTERM);
3971       else
3972         cursor = NULL;
3973
3974       gdk_window_set_cursor (text_view->text_window->bin_window, cursor);
3975
3976       if (cursor)
3977       gdk_cursor_unref (cursor);
3978
3979       text_view->mouse_cursor_obscured = FALSE;
3980     }
3981
3982   if (!GTK_WIDGET_IS_SENSITIVE (widget))
3983     {
3984       /* Clear any selection */
3985       gtk_text_view_unselect (text_view);
3986     }
3987
3988   gtk_widget_queue_draw (widget);
3989 }
3990
3991 static void
3992 set_invisible_cursor (GdkWindow *window)
3993 {
3994   GdkDisplay *display;
3995   GdkCursor *cursor;
3996
3997   display = gdk_drawable_get_display (window);
3998   cursor = gdk_cursor_new_for_display (display, GDK_BLANK_CURSOR);
3999
4000   gdk_window_set_cursor (window, cursor);
4001
4002   gdk_cursor_unref (cursor);
4003 }
4004
4005 static void
4006 gtk_text_view_obscure_mouse_cursor (GtkTextView *text_view)
4007 {
4008   if (text_view->mouse_cursor_obscured)
4009     return;
4010
4011   set_invisible_cursor (text_view->text_window->bin_window);
4012
4013   text_view->mouse_cursor_obscured = TRUE;
4014 }
4015
4016 static void
4017 gtk_text_view_unobscure_mouse_cursor (GtkTextView *text_view)
4018 {
4019   if (text_view->mouse_cursor_obscured)
4020     {
4021       GdkCursor *cursor;
4022
4023       cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (text_view)),
4024                                            GDK_XTERM);
4025       gdk_window_set_cursor (text_view->text_window->bin_window, cursor);
4026       gdk_cursor_unref (cursor);
4027       text_view->mouse_cursor_obscured = FALSE;
4028     }
4029 }
4030
4031 static void
4032 gtk_text_view_grab_notify (GtkWidget *widget,
4033                            gboolean   was_grabbed)
4034 {
4035   if (!was_grabbed)
4036     {
4037       gtk_text_view_end_selection_drag (GTK_TEXT_VIEW (widget));
4038       gtk_text_view_unobscure_mouse_cursor (GTK_TEXT_VIEW (widget));
4039     }
4040 }
4041
4042
4043 /*
4044  * Events
4045  */
4046
4047 static gboolean
4048 get_event_coordinates (GdkEvent *event, gint *x, gint *y)
4049 {
4050   if (event)
4051     switch (event->type)
4052       {
4053       case GDK_MOTION_NOTIFY:
4054         *x = event->motion.x;
4055         *y = event->motion.y;
4056         return TRUE;
4057         break;
4058
4059       case GDK_BUTTON_PRESS:
4060       case GDK_2BUTTON_PRESS:
4061       case GDK_3BUTTON_PRESS:
4062       case GDK_BUTTON_RELEASE:
4063         *x = event->button.x;
4064         *y = event->button.y;
4065         return TRUE;
4066         break;
4067
4068       case GDK_KEY_PRESS:
4069       case GDK_KEY_RELEASE:
4070       case GDK_ENTER_NOTIFY:
4071       case GDK_LEAVE_NOTIFY:
4072       case GDK_PROPERTY_NOTIFY:
4073       case GDK_SELECTION_CLEAR:
4074       case GDK_SELECTION_REQUEST:
4075       case GDK_SELECTION_NOTIFY:
4076       case GDK_PROXIMITY_IN:
4077       case GDK_PROXIMITY_OUT:
4078       case GDK_DRAG_ENTER:
4079       case GDK_DRAG_LEAVE:
4080       case GDK_DRAG_MOTION:
4081       case GDK_DRAG_STATUS:
4082       case GDK_DROP_START:
4083       case GDK_DROP_FINISHED:
4084       default:
4085         return FALSE;
4086         break;
4087       }
4088
4089   return FALSE;
4090 }
4091
4092 static gint
4093 emit_event_on_tags (GtkWidget   *widget,
4094                     GdkEvent    *event,
4095                     GtkTextIter *iter)
4096 {
4097   GSList *tags;
4098   GSList *tmp;
4099   gboolean retval = FALSE;
4100
4101   tags = gtk_text_iter_get_tags (iter);
4102
4103   tmp = tags;
4104   while (tmp != NULL)
4105     {
4106       GtkTextTag *tag = tmp->data;
4107
4108       if (gtk_text_tag_event (tag, G_OBJECT (widget), event, iter))
4109         {
4110           retval = TRUE;
4111           break;
4112         }
4113
4114       tmp = g_slist_next (tmp);
4115     }
4116
4117   g_slist_free (tags);
4118
4119   return retval;
4120 }
4121
4122 static gint
4123 gtk_text_view_event (GtkWidget *widget, GdkEvent *event)
4124 {
4125   GtkTextView *text_view;
4126   gint x = 0, y = 0;
4127
4128   text_view = GTK_TEXT_VIEW (widget);
4129
4130   if (text_view->layout == NULL ||
4131       get_buffer (text_view) == NULL)
4132     return FALSE;
4133
4134   if (event->any.window != text_view->text_window->bin_window)
4135     return FALSE;
4136
4137   if (get_event_coordinates (event, &x, &y))
4138     {
4139       GtkTextIter iter;
4140
4141       x += text_view->xoffset;
4142       y += text_view->yoffset;
4143
4144       /* FIXME this is slow and we do it twice per event.
4145        * My favorite solution is to have GtkTextLayout cache
4146        * the last couple lookups.
4147        */
4148       gtk_text_layout_get_iter_at_pixel (text_view->layout,
4149                                          &iter,
4150                                          x, y);
4151
4152       return emit_event_on_tags (widget, event, &iter);
4153     }
4154   else if (event->type == GDK_KEY_PRESS ||
4155            event->type == GDK_KEY_RELEASE)
4156     {
4157       GtkTextIter iter;
4158
4159       gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter,
4160                                         gtk_text_buffer_get_insert (get_buffer (text_view)));
4161
4162       return emit_event_on_tags (widget, event, &iter);
4163     }
4164   else
4165     return FALSE;
4166 }
4167
4168 static gint
4169 gtk_text_view_key_press_event (GtkWidget *widget, GdkEventKey *event)
4170 {
4171   gboolean retval = FALSE;
4172   gboolean obscure = FALSE;
4173   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4174   GtkTextMark *insert;
4175   GtkTextIter iter;
4176   gboolean can_insert;
4177
4178   if (text_view->layout == NULL ||
4179       get_buffer (text_view) == NULL)
4180     return FALSE;
4181
4182   /* Make sure input method knows where it is */
4183   flush_update_im_spot_location (text_view);
4184
4185   insert = gtk_text_buffer_get_insert (get_buffer (text_view));
4186   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, insert);
4187   can_insert = gtk_text_iter_can_insert (&iter, text_view->editable);
4188   if (gtk_im_context_filter_keypress (text_view->im_context, event))
4189     {
4190       text_view->need_im_reset = TRUE;
4191       if (!can_insert)
4192         gtk_text_view_reset_im_context (text_view);
4193       obscure = can_insert;
4194       retval = TRUE;
4195     }
4196   /* Binding set */
4197   else if (GTK_WIDGET_CLASS (gtk_text_view_parent_class)->key_press_event (widget, event))
4198     {
4199       retval = TRUE;
4200     }
4201   /* use overall editability not can_insert, more predictable for users */
4202   else if (text_view->editable &&
4203            (event->keyval == GDK_Return ||
4204             event->keyval == GDK_ISO_Enter ||
4205             event->keyval == GDK_KP_Enter))
4206     {
4207       /* this won't actually insert the newline if the cursor isn't
4208        * editable
4209        */
4210       gtk_text_view_reset_im_context (text_view);
4211       gtk_text_view_commit_text (text_view, "\n");
4212
4213       obscure = TRUE;
4214       retval = TRUE;
4215     }
4216   /* Pass through Tab as literal tab, unless Control is held down */
4217   else if ((event->keyval == GDK_Tab ||
4218             event->keyval == GDK_KP_Tab ||
4219             event->keyval == GDK_ISO_Left_Tab) &&
4220            !(event->state & GDK_CONTROL_MASK))
4221     {
4222       /* If the text widget isn't editable overall, or if the application
4223        * has turned off "accepts_tab", move the focus instead
4224        */
4225       if (text_view->accepts_tab && text_view->editable)
4226         {
4227           gtk_text_view_reset_im_context (text_view);
4228           gtk_text_view_commit_text (text_view, "\t");
4229           obscure = TRUE;
4230         }
4231       else
4232         g_signal_emit_by_name (text_view, "move-focus",
4233                                (event->state & GDK_SHIFT_MASK) ?
4234                                GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD);
4235
4236       retval = TRUE;
4237     }
4238   else
4239     retval = FALSE;
4240
4241   if (obscure)
4242     gtk_text_view_obscure_mouse_cursor (text_view);
4243
4244   gtk_text_view_reset_blink_time (text_view);
4245   gtk_text_view_pend_cursor_blink (text_view);
4246
4247   return retval;
4248 }
4249
4250 static gint
4251 gtk_text_view_key_release_event (GtkWidget *widget, GdkEventKey *event)
4252 {
4253   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4254   GtkTextMark *insert;
4255   GtkTextIter iter;
4256
4257   if (text_view->layout == NULL || get_buffer (text_view) == NULL)
4258     return FALSE;
4259
4260   insert = gtk_text_buffer_get_insert (get_buffer (text_view));
4261   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, insert);
4262   if (gtk_text_iter_can_insert (&iter, text_view->editable) &&
4263       gtk_im_context_filter_keypress (text_view->im_context, event))
4264     {
4265       text_view->need_im_reset = TRUE;
4266       return TRUE;
4267     }
4268   else
4269     return GTK_WIDGET_CLASS (gtk_text_view_parent_class)->key_release_event (widget, event);
4270 }
4271
4272 static gint
4273 gtk_text_view_button_press_event (GtkWidget *widget, GdkEventButton *event)
4274 {
4275   GtkTextView *text_view;
4276
4277   text_view = GTK_TEXT_VIEW (widget);
4278
4279   gtk_widget_grab_focus (widget);
4280
4281   if (event->window != text_view->text_window->bin_window)
4282     {
4283       /* Remove selection if any. */
4284       gtk_text_view_unselect (text_view);
4285       return FALSE;
4286     }
4287
4288   gtk_text_view_reset_blink_time (text_view);
4289
4290 #if 0
4291   /* debug hack */
4292   if (event->button == 3 && (event->state & GDK_CONTROL_MASK) != 0)
4293     _gtk_text_buffer_spew (GTK_TEXT_VIEW (widget)->buffer);
4294   else if (event->button == 3)
4295     gtk_text_layout_spew (GTK_TEXT_VIEW (widget)->layout);
4296 #endif
4297
4298   if (event->type == GDK_BUTTON_PRESS)
4299     {
4300       gtk_text_view_reset_im_context (text_view);
4301
4302       if (event->button == 1)
4303         {
4304           /* If we're in the selection, start a drag copy/move of the
4305            * selection; otherwise, start creating a new selection.
4306            */
4307           GtkTextIter iter;
4308           GtkTextIter start, end;
4309
4310           gtk_text_layout_get_iter_at_pixel (text_view->layout,
4311                                              &iter,
4312                                              event->x + text_view->xoffset,
4313                                              event->y + text_view->yoffset);
4314
4315           if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
4316                                                     &start, &end) &&
4317               gtk_text_iter_in_range (&iter, &start, &end))
4318             {
4319               text_view->drag_start_x = event->x;
4320               text_view->drag_start_y = event->y;
4321               text_view->pending_place_cursor_button = event->button;
4322             }
4323           else
4324             {
4325               gtk_text_view_start_selection_drag (text_view, &iter, event);
4326             }
4327
4328           return TRUE;
4329         }
4330       else if (event->button == 2)
4331         {
4332           GtkTextIter iter;
4333
4334           gtk_text_layout_get_iter_at_pixel (text_view->layout,
4335                                              &iter,
4336                                              event->x + text_view->xoffset,
4337                                              event->y + text_view->yoffset);
4338
4339           gtk_text_buffer_paste_clipboard (get_buffer (text_view),
4340                                            gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY),
4341                                            &iter,
4342                                            text_view->editable);
4343           return TRUE;
4344         }
4345       else if (event->button == 3)
4346         {
4347           gtk_text_view_do_popup (text_view, event);
4348           return TRUE;
4349         }
4350     }
4351   else if ((event->type == GDK_2BUTTON_PRESS ||
4352             event->type == GDK_3BUTTON_PRESS) &&
4353            event->button == 1)
4354     {
4355       GtkTextIter iter;
4356
4357       gtk_text_view_end_selection_drag (text_view);
4358
4359       gtk_text_layout_get_iter_at_pixel (text_view->layout,
4360                                          &iter,
4361                                          event->x + text_view->xoffset,
4362                                          event->y + text_view->yoffset);
4363
4364       gtk_text_view_start_selection_drag (text_view, &iter, event);
4365       return TRUE;
4366     }
4367
4368   return FALSE;
4369 }
4370
4371 static gint
4372 gtk_text_view_button_release_event (GtkWidget *widget, GdkEventButton *event)
4373 {
4374   GtkTextView *text_view;
4375
4376   text_view = GTK_TEXT_VIEW (widget);
4377
4378   if (event->window != text_view->text_window->bin_window)
4379     return FALSE;
4380
4381   if (event->button == 1)
4382     {
4383       if (text_view->drag_start_x >= 0)
4384         {
4385           text_view->drag_start_x = -1;
4386           text_view->drag_start_y = -1;
4387         }
4388
4389       if (gtk_text_view_end_selection_drag (GTK_TEXT_VIEW (widget)))
4390         return TRUE;
4391       else if (text_view->pending_place_cursor_button == event->button)
4392         {
4393           GtkTextIter iter;
4394
4395           /* Unselect everything; we clicked inside selection, but
4396            * didn't move by the drag threshold, so just clear selection
4397            * and place cursor.
4398            */
4399           gtk_text_layout_get_iter_at_pixel (text_view->layout,
4400                                              &iter,
4401                                              event->x + text_view->xoffset,
4402                                              event->y + text_view->yoffset);
4403
4404           gtk_text_buffer_place_cursor (get_buffer (text_view), &iter);
4405           gtk_text_view_check_cursor_blink (text_view);
4406
4407           text_view->pending_place_cursor_button = 0;
4408
4409           return FALSE;
4410         }
4411     }
4412
4413   return FALSE;
4414 }
4415
4416 static void
4417 keymap_direction_changed (GdkKeymap   *keymap,
4418                           GtkTextView *text_view)
4419 {
4420   gtk_text_view_check_keymap_direction (text_view);
4421 }
4422
4423 static gint
4424 gtk_text_view_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
4425 {
4426   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4427
4428   gtk_widget_queue_draw (widget);
4429
4430   DV(g_print (G_STRLOC": focus_in_event\n"));
4431
4432   gtk_text_view_reset_blink_time (text_view);
4433
4434   if (text_view->cursor_visible && text_view->layout)
4435     {
4436       gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
4437       gtk_text_view_check_cursor_blink (text_view);
4438     }
4439
4440   g_signal_connect (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
4441                     "direction-changed",
4442                     G_CALLBACK (keymap_direction_changed), text_view);
4443   gtk_text_view_check_keymap_direction (text_view);
4444
4445   if (text_view->editable)
4446     {
4447       text_view->need_im_reset = TRUE;
4448       gtk_im_context_focus_in (GTK_TEXT_VIEW (widget)->im_context);
4449     }
4450
4451   return FALSE;
4452 }
4453
4454 static gint
4455 gtk_text_view_focus_out_event (GtkWidget *widget, GdkEventFocus *event)
4456 {
4457   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4458
4459   gtk_text_view_end_selection_drag (text_view);
4460
4461   gtk_widget_queue_draw (widget);
4462
4463   DV(g_print (G_STRLOC": focus_out_event\n"));
4464
4465   if (text_view->cursor_visible && text_view->layout)
4466     {
4467       gtk_text_view_check_cursor_blink (text_view);
4468       gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
4469     }
4470
4471   g_signal_handlers_disconnect_by_func (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
4472                                         keymap_direction_changed,
4473                                         text_view);
4474
4475   if (text_view->editable)
4476     {
4477       text_view->need_im_reset = TRUE;
4478       gtk_im_context_focus_out (GTK_TEXT_VIEW (widget)->im_context);
4479     }
4480
4481   return FALSE;
4482 }
4483
4484 static gint
4485 gtk_text_view_motion_event (GtkWidget *widget, GdkEventMotion *event)
4486 {
4487   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4488
4489   gtk_text_view_unobscure_mouse_cursor (text_view);
4490
4491   if (event->window == text_view->text_window->bin_window &&
4492       text_view->drag_start_x >= 0)
4493     {
4494       gint x = event->x;
4495       gint y = event->y;
4496
4497       gdk_event_request_motions (event);
4498
4499       if (gtk_drag_check_threshold (widget,
4500                                     text_view->drag_start_x,
4501                                     text_view->drag_start_y,
4502                                     x, y))
4503         {
4504           GtkTextIter iter;
4505           gint buffer_x, buffer_y;
4506
4507           gtk_text_view_window_to_buffer_coords (text_view,
4508                                                  GTK_TEXT_WINDOW_TEXT,
4509                                                  text_view->drag_start_x,
4510                                                  text_view->drag_start_y,
4511                                                  &buffer_x,
4512                                                  &buffer_y);
4513
4514           gtk_text_layout_get_iter_at_pixel (text_view->layout,
4515                                              &iter,
4516                                              buffer_x, buffer_y);
4517
4518           gtk_text_view_start_selection_dnd (text_view, &iter, event);
4519           return TRUE;
4520         }
4521     }
4522
4523   return FALSE;
4524 }
4525
4526 static void
4527 gtk_text_view_paint (GtkWidget      *widget,
4528                      GdkRectangle   *area,
4529                      GdkEventExpose *event)
4530 {
4531   GtkTextView *text_view;
4532   GList *child_exposes;
4533   GList *tmp_list;
4534
4535   text_view = GTK_TEXT_VIEW (widget);
4536
4537   g_return_if_fail (text_view->layout != NULL);
4538   g_return_if_fail (text_view->xoffset >= 0);
4539   g_return_if_fail (text_view->yoffset >= 0);
4540
4541   while (text_view->first_validate_idle != 0)
4542     {
4543       DV (g_print (G_STRLOC": first_validate_idle: %d\n",
4544                    text_view->first_validate_idle));
4545       gtk_text_view_flush_first_validate (text_view);
4546     }
4547
4548   if (!text_view->onscreen_validated)
4549     {
4550       g_warning (G_STRLOC ": somehow some text lines were modified or scrolling occurred since the last validation of lines on the screen - may be a text widget bug.");
4551       g_assert_not_reached ();
4552     }
4553
4554 #if 0
4555   printf ("painting %d,%d  %d x %d\n",
4556           area->x, area->y,
4557           area->width, area->height);
4558 #endif
4559
4560   child_exposes = NULL;
4561   gtk_text_layout_draw (text_view->layout,
4562                         widget,
4563                         text_view->text_window->bin_window,
4564                         NULL,
4565                         text_view->xoffset,
4566                         text_view->yoffset,
4567                         area->x, area->y,
4568                         area->width, area->height,
4569                         &child_exposes);
4570
4571   tmp_list = child_exposes;
4572   while (tmp_list != NULL)
4573     {
4574       GtkWidget *child = tmp_list->data;
4575
4576       gtk_container_propagate_expose (GTK_CONTAINER (text_view),
4577                                       child,
4578                                       event);
4579
4580       g_object_unref (child);
4581
4582       tmp_list = tmp_list->next;
4583     }
4584
4585   g_list_free (child_exposes);
4586 }
4587
4588 static gint
4589 gtk_text_view_expose_event (GtkWidget *widget, GdkEventExpose *event)
4590 {
4591   GSList *tmp_list;
4592
4593   if (event->window == gtk_text_view_get_window (GTK_TEXT_VIEW (widget),
4594                                                  GTK_TEXT_WINDOW_TEXT))
4595     {
4596       DV(g_print (">Exposed ("G_STRLOC")\n"));
4597       gtk_text_view_paint (widget, &event->area, event);
4598     }
4599
4600   if (event->window == widget->window)
4601     gtk_text_view_draw_focus (widget);
4602
4603   /* Propagate exposes to all unanchored children.
4604    * Anchored children are handled in gtk_text_view_paint().
4605    */
4606   tmp_list = GTK_TEXT_VIEW (widget)->children;
4607   while (tmp_list != NULL)
4608     {
4609       GtkTextViewChild *vc = tmp_list->data;
4610
4611       /* propagate_expose checks that event->window matches
4612        * child->window
4613        */
4614       if (!vc->anchor)
4615         gtk_container_propagate_expose (GTK_CONTAINER (widget),
4616                                         vc->widget,
4617                                         event);
4618
4619       tmp_list = tmp_list->next;
4620     }
4621
4622   return FALSE;
4623 }
4624
4625 static void
4626 gtk_text_view_draw_focus (GtkWidget *widget)
4627 {
4628   gboolean interior_focus;
4629
4630   /* We clear the focus if we are in interior focus mode. */
4631   gtk_widget_style_get (widget,
4632                         "interior-focus", &interior_focus,
4633                         NULL);
4634
4635   if (GTK_WIDGET_DRAWABLE (widget))
4636     {
4637       if (GTK_WIDGET_HAS_FOCUS (widget) && !interior_focus)
4638         {
4639           gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
4640                            NULL, widget, "textview",
4641                            0, 0,
4642                            widget->allocation.width,
4643                            widget->allocation.height);
4644         }
4645       else
4646         {
4647           gdk_window_clear (widget->window);
4648         }
4649     }
4650 }
4651
4652 static gboolean
4653 gtk_text_view_focus (GtkWidget        *widget,
4654                      GtkDirectionType  direction)
4655 {
4656   GtkContainer *container;
4657   gboolean result;
4658
4659   container = GTK_CONTAINER (widget);
4660
4661   if (!gtk_widget_is_focus (widget) &&
4662       container->focus_child == NULL)
4663     {
4664       gtk_widget_grab_focus (widget);
4665       return TRUE;
4666     }
4667   else
4668     {
4669       /*
4670        * Unset CAN_FOCUS flag so that gtk_container_focus() allows
4671        * children to get the focus
4672        */
4673       GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
4674       result = GTK_WIDGET_CLASS (gtk_text_view_parent_class)->focus (widget, direction);
4675       GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
4676
4677       return result;
4678     }
4679 }
4680
4681 static void
4682 gtk_text_view_move_focus (GtkWidget        *widget,
4683                           GtkDirectionType  direction_type)
4684 {
4685   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4686
4687   if (GTK_TEXT_VIEW_GET_CLASS (text_view)->move_focus)
4688     GTK_TEXT_VIEW_GET_CLASS (text_view)->move_focus (text_view,
4689                                                      direction_type);
4690 }
4691
4692 /*
4693  * Container
4694  */
4695
4696 static void
4697 gtk_text_view_add (GtkContainer *container,
4698                    GtkWidget    *child)
4699 {
4700   /* This is pretty random. */
4701   gtk_text_view_add_child_in_window (GTK_TEXT_VIEW (container),
4702                                      child,
4703                                      GTK_TEXT_WINDOW_WIDGET,
4704                                      0, 0);
4705 }
4706
4707 static void
4708 gtk_text_view_remove (GtkContainer *container,
4709                       GtkWidget    *child)
4710 {
4711   GSList *iter;
4712   GtkTextView *text_view;
4713   GtkTextViewChild *vc;
4714
4715   text_view = GTK_TEXT_VIEW (container);
4716
4717   vc = NULL;
4718   iter = text_view->children;
4719
4720   while (iter != NULL)
4721     {
4722       vc = iter->data;
4723
4724       if (vc->widget == child)
4725         break;
4726
4727       iter = g_slist_next (iter);
4728     }
4729
4730   g_assert (iter != NULL); /* be sure we had the child in the list */
4731
4732   text_view->children = g_slist_remove (text_view->children, vc);
4733
4734   gtk_widget_unparent (vc->widget);
4735
4736   text_view_child_free (vc);
4737 }
4738
4739 static void
4740 gtk_text_view_forall (GtkContainer *container,
4741                       gboolean      include_internals,
4742                       GtkCallback   callback,
4743                       gpointer      callback_data)
4744 {
4745   GSList *iter;
4746   GtkTextView *text_view;
4747   GSList *copy;
4748
4749   g_return_if_fail (GTK_IS_TEXT_VIEW (container));
4750   g_return_if_fail (callback != NULL);
4751
4752   text_view = GTK_TEXT_VIEW (container);
4753
4754   copy = g_slist_copy (text_view->children);
4755   iter = copy;
4756
4757   while (iter != NULL)
4758     {
4759       GtkTextViewChild *vc = iter->data;
4760
4761       (* callback) (vc->widget, callback_data);
4762
4763       iter = g_slist_next (iter);
4764     }
4765
4766   g_slist_free (copy);
4767 }
4768
4769 #define CURSOR_ON_MULTIPLIER 2
4770 #define CURSOR_OFF_MULTIPLIER 1
4771 #define CURSOR_PEND_MULTIPLIER 3
4772 #define CURSOR_DIVIDER 3
4773
4774 static gboolean
4775 cursor_blinks (GtkTextView *text_view)
4776 {
4777   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
4778   gboolean blink;
4779
4780 #ifdef DEBUG_VALIDATION_AND_SCROLLING
4781   return FALSE;
4782 #endif
4783   if (gtk_debug_flags & GTK_DEBUG_UPDATES)
4784     return FALSE;
4785
4786   g_object_get (settings, "gtk-cursor-blink", &blink, NULL);
4787
4788   if (!blink)
4789     return FALSE;
4790
4791   if (text_view->editable)
4792     {
4793       GtkTextMark *insert;
4794       GtkTextIter iter;
4795
4796       insert = gtk_text_buffer_get_insert (get_buffer (text_view));
4797       gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, insert);
4798
4799       if (gtk_text_iter_editable (&iter, text_view->editable))
4800         return blink;
4801     }
4802
4803   return FALSE;
4804 }
4805
4806 static gint
4807 get_cursor_time (GtkTextView *text_view)
4808 {
4809   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
4810   gint time;
4811
4812   g_object_get (settings, "gtk-cursor-blink-time", &time, NULL);
4813
4814   return time;
4815 }
4816
4817 static gint
4818 get_cursor_blink_timeout (GtkTextView *text_view)
4819 {
4820   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
4821   gint time;
4822
4823   g_object_get (settings, "gtk-cursor-blink-timeout", &time, NULL);
4824
4825   return time;
4826 }
4827
4828
4829 /*
4830  * Blink!
4831  */
4832
4833 static gint
4834 blink_cb (gpointer data)
4835 {
4836   GtkTextView *text_view;
4837   GtkTextViewPrivate *priv;
4838   gboolean visible;
4839   gint blink_timeout;
4840
4841   text_view = GTK_TEXT_VIEW (data);
4842   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
4843
4844   if (!GTK_WIDGET_HAS_FOCUS (text_view))
4845     {
4846       g_warning ("GtkTextView - did not receive focus-out-event. If you\n"
4847                  "connect a handler to this signal, it must return\n"
4848                  "FALSE so the text view gets the event as well");
4849
4850       gtk_text_view_check_cursor_blink (text_view);
4851
4852       return FALSE;
4853     }
4854
4855   g_assert (text_view->layout);
4856   g_assert (text_view->cursor_visible);
4857
4858   visible = gtk_text_layout_get_cursor_visible (text_view->layout);
4859
4860   blink_timeout = get_cursor_blink_timeout (text_view);
4861   if (priv->blink_time > 1000 * blink_timeout &&
4862       blink_timeout < G_MAXINT/1000)
4863     {
4864       /* we've blinked enough without the user doing anything, stop blinking */
4865       visible = 0;
4866       text_view->blink_timeout = 0;
4867     }
4868   else if (visible)
4869     text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER / CURSOR_DIVIDER,
4870                                               blink_cb,
4871                                               text_view);
4872   else
4873     {
4874       text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_ON_MULTIPLIER / CURSOR_DIVIDER,
4875                                                 blink_cb,
4876                                                 text_view);
4877       priv->blink_time += get_cursor_time (text_view);
4878     }
4879
4880   /* Block changed_handler while changing the layout's cursor visibility
4881    * because it would expose the whole paragraph. Instead, we expose
4882    * the cursor's area(s) manually below.
4883    */
4884   g_signal_handlers_block_by_func (text_view->layout,
4885                                    changed_handler,
4886                                    text_view);
4887   gtk_text_layout_set_cursor_visible (text_view->layout, !visible);
4888   g_signal_handlers_unblock_by_func (text_view->layout,
4889                                      changed_handler,
4890                                      text_view);
4891
4892   text_window_invalidate_cursors (text_view->text_window);
4893
4894   /* Remove ourselves */
4895   return FALSE;
4896 }
4897
4898
4899 static void
4900 gtk_text_view_stop_cursor_blink (GtkTextView *text_view)
4901 {
4902   if (text_view->blink_timeout)
4903     {
4904       g_source_remove (text_view->blink_timeout);
4905       text_view->blink_timeout = 0;
4906     }
4907 }
4908
4909 static void
4910 gtk_text_view_check_cursor_blink (GtkTextView *text_view)
4911 {
4912   if (text_view->layout != NULL &&
4913       text_view->cursor_visible &&
4914       GTK_WIDGET_HAS_FOCUS (text_view))
4915     {
4916       if (cursor_blinks (text_view))
4917         {
4918           if (text_view->blink_timeout == 0)
4919             {
4920               gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
4921
4922               text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER / CURSOR_DIVIDER,
4923                                                         blink_cb,
4924                                                         text_view);
4925             }
4926         }
4927       else
4928         {
4929           gtk_text_view_stop_cursor_blink (text_view);
4930           gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
4931         }
4932     }
4933   else
4934     {
4935       gtk_text_view_stop_cursor_blink (text_view);
4936       gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
4937     }
4938 }
4939
4940 static void
4941 gtk_text_view_pend_cursor_blink (GtkTextView *text_view)
4942 {
4943   if (text_view->layout != NULL &&
4944       text_view->cursor_visible &&
4945       GTK_WIDGET_HAS_FOCUS (text_view) &&
4946       cursor_blinks (text_view))
4947     {
4948       gtk_text_view_stop_cursor_blink (text_view);
4949       gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
4950
4951       text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_PEND_MULTIPLIER / CURSOR_DIVIDER,
4952                                                 blink_cb,
4953                                                 text_view);
4954     }
4955 }
4956
4957 static void
4958 gtk_text_view_reset_blink_time (GtkTextView *text_view)
4959 {
4960   GtkTextViewPrivate *priv;
4961
4962   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
4963
4964   priv->blink_time = 0;
4965 }
4966
4967
4968 /*
4969  * Key binding handlers
4970  */
4971
4972 static gboolean
4973 gtk_text_view_move_iter_by_lines (GtkTextView *text_view,
4974                                   GtkTextIter *newplace,
4975                                   gint         count)
4976 {
4977   gboolean ret = TRUE;
4978
4979   while (count < 0)
4980     {
4981       ret = gtk_text_layout_move_iter_to_previous_line (text_view->layout, newplace);
4982       count++;
4983     }
4984
4985   while (count > 0)
4986     {
4987       ret = gtk_text_layout_move_iter_to_next_line (text_view->layout, newplace);
4988       count--;
4989     }
4990
4991   return ret;
4992 }
4993
4994 static void
4995 move_cursor (GtkTextView       *text_view,
4996              const GtkTextIter *new_location,
4997              gboolean           extend_selection)
4998 {
4999   if (extend_selection)
5000     gtk_text_buffer_move_mark_by_name (get_buffer (text_view),
5001                                        "insert",
5002                                        new_location);
5003   else
5004       gtk_text_buffer_place_cursor (get_buffer (text_view),
5005                                     new_location);
5006   gtk_text_view_check_cursor_blink (text_view);
5007 }
5008
5009 static void
5010 gtk_text_view_move_cursor_internal (GtkTextView     *text_view,
5011                                     GtkMovementStep  step,
5012                                     gint             count,
5013                                     gboolean         extend_selection)
5014 {
5015   GtkTextIter insert;
5016   GtkTextIter newplace;
5017   gint cursor_x_pos = 0;
5018   GtkDirectionType leave_direction = -1;
5019
5020   if (!text_view->cursor_visible)
5021     {
5022       GtkScrollStep scroll_step;
5023
5024       switch (step)
5025         {
5026         case GTK_MOVEMENT_VISUAL_POSITIONS:
5027           leave_direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
5028           /* fall through */
5029         case GTK_MOVEMENT_LOGICAL_POSITIONS:
5030         case GTK_MOVEMENT_WORDS:
5031           scroll_step = GTK_SCROLL_HORIZONTAL_STEPS;
5032           break;
5033         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
5034           scroll_step = GTK_SCROLL_HORIZONTAL_ENDS;
5035           break;
5036         case GTK_MOVEMENT_DISPLAY_LINES:
5037           leave_direction = count > 0 ? GTK_DIR_DOWN : GTK_DIR_UP;
5038           /* fall through */
5039         case GTK_MOVEMENT_PARAGRAPHS:
5040         case GTK_MOVEMENT_PARAGRAPH_ENDS:
5041           scroll_step = GTK_SCROLL_STEPS;
5042           break;
5043         case GTK_MOVEMENT_PAGES:
5044           scroll_step = GTK_SCROLL_PAGES;
5045           break;
5046         case GTK_MOVEMENT_HORIZONTAL_PAGES:
5047           scroll_step = GTK_SCROLL_HORIZONTAL_PAGES;
5048           break;
5049         case GTK_MOVEMENT_BUFFER_ENDS:
5050           scroll_step = GTK_SCROLL_ENDS;
5051           break;
5052         default:
5053           scroll_step = GTK_SCROLL_PAGES;
5054           break;
5055         }
5056
5057       if (!gtk_text_view_move_viewport (text_view, scroll_step, count))
5058         {
5059           if (leave_direction != -1 &&
5060               !gtk_widget_keynav_failed (GTK_WIDGET (text_view),
5061                                          leave_direction))
5062             {
5063               g_signal_emit_by_name (text_view, "move-focus", leave_direction);
5064             }
5065         }
5066
5067       return;
5068     }
5069
5070   gtk_text_view_reset_im_context (text_view);
5071
5072   if (step == GTK_MOVEMENT_PAGES)
5073     {
5074       if (!gtk_text_view_scroll_pages (text_view, count, extend_selection))
5075         gtk_widget_error_bell (GTK_WIDGET (text_view));
5076
5077       gtk_text_view_check_cursor_blink (text_view);
5078       gtk_text_view_pend_cursor_blink (text_view);
5079       return;
5080     }
5081   else if (step == GTK_MOVEMENT_HORIZONTAL_PAGES)
5082     {
5083       if (!gtk_text_view_scroll_hpages (text_view, count, extend_selection))
5084         gtk_widget_error_bell (GTK_WIDGET (text_view));
5085
5086       gtk_text_view_check_cursor_blink (text_view);
5087       gtk_text_view_pend_cursor_blink (text_view);
5088       return;
5089     }
5090
5091   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
5092                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5093   newplace = insert;
5094
5095   if (step == GTK_MOVEMENT_DISPLAY_LINES)
5096     gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, NULL);
5097
5098   switch (step)
5099     {
5100     case GTK_MOVEMENT_LOGICAL_POSITIONS:
5101       gtk_text_iter_forward_visible_cursor_positions (&newplace, count);
5102       break;
5103
5104     case GTK_MOVEMENT_VISUAL_POSITIONS:
5105       gtk_text_layout_move_iter_visually (text_view->layout,
5106                                           &newplace, count);
5107       break;
5108
5109     case GTK_MOVEMENT_WORDS:
5110       if (count < 0)
5111         gtk_text_iter_backward_visible_word_starts (&newplace, -count);
5112       else if (count > 0)
5113         {
5114           if (!gtk_text_iter_forward_visible_word_ends (&newplace, count))
5115             gtk_text_iter_forward_to_line_end (&newplace);
5116         }
5117       break;
5118
5119     case GTK_MOVEMENT_DISPLAY_LINES:
5120       if (count < 0)
5121         {
5122           leave_direction = GTK_DIR_UP;
5123
5124           if (gtk_text_view_move_iter_by_lines (text_view, &newplace, count))
5125             gtk_text_layout_move_iter_to_x (text_view->layout, &newplace, cursor_x_pos);
5126           else
5127             gtk_text_iter_set_line_offset (&newplace, 0);
5128         }
5129       if (count > 0)
5130         {
5131           leave_direction = GTK_DIR_DOWN;
5132
5133           if (gtk_text_view_move_iter_by_lines (text_view, &newplace, count))
5134             gtk_text_layout_move_iter_to_x (text_view->layout, &newplace, cursor_x_pos);
5135           else
5136             gtk_text_iter_forward_to_line_end (&newplace);
5137         }
5138       break;
5139
5140     case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
5141       if (count > 1)
5142         gtk_text_view_move_iter_by_lines (text_view, &newplace, --count);
5143       else if (count < -1)
5144         gtk_text_view_move_iter_by_lines (text_view, &newplace, ++count);
5145
5146       if (count != 0)
5147         gtk_text_layout_move_iter_to_line_end (text_view->layout, &newplace, count);
5148       break;
5149
5150     case GTK_MOVEMENT_PARAGRAPHS:
5151       if (count > 0)
5152         {
5153           if (!gtk_text_iter_ends_line (&newplace))
5154             {
5155               gtk_text_iter_forward_to_line_end (&newplace);
5156               --count;
5157             }
5158           gtk_text_iter_forward_visible_lines (&newplace, count);
5159           gtk_text_iter_forward_to_line_end (&newplace);
5160         }
5161       else if (count < 0)
5162         {
5163           if (gtk_text_iter_get_line_offset (&newplace) > 0)
5164             gtk_text_iter_set_line_offset (&newplace, 0);
5165           gtk_text_iter_forward_visible_lines (&newplace, count);
5166           gtk_text_iter_set_line_offset (&newplace, 0);
5167         }
5168       break;
5169
5170     case GTK_MOVEMENT_PARAGRAPH_ENDS:
5171       if (count > 0)
5172         {
5173           if (!gtk_text_iter_ends_line (&newplace))
5174             gtk_text_iter_forward_to_line_end (&newplace);
5175         }
5176       else if (count < 0)
5177         {
5178           gtk_text_iter_set_line_offset (&newplace, 0);
5179         }
5180       break;
5181
5182     case GTK_MOVEMENT_BUFFER_ENDS:
5183       if (count > 0)
5184         gtk_text_buffer_get_end_iter (get_buffer (text_view), &newplace);
5185       else if (count < 0)
5186         gtk_text_buffer_get_iter_at_offset (get_buffer (text_view), &newplace, 0);
5187      break;
5188
5189     default:
5190       break;
5191     }
5192
5193   /* call move_cursor() even if the cursor hasn't moved, since it
5194      cancels the selection
5195   */
5196   move_cursor (text_view, &newplace, extend_selection);
5197
5198   if (!gtk_text_iter_equal (&insert, &newplace))
5199     {
5200       DV(g_print (G_STRLOC": scrolling onscreen\n"));
5201       gtk_text_view_scroll_mark_onscreen (text_view,
5202                                           gtk_text_buffer_get_insert (get_buffer (text_view)));
5203
5204       if (step == GTK_MOVEMENT_DISPLAY_LINES)
5205         gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, -1);
5206     }
5207   else if (leave_direction != -1)
5208     {
5209       if (!gtk_widget_keynav_failed (GTK_WIDGET (text_view),
5210                                      leave_direction))
5211         {
5212           g_signal_emit_by_name (text_view, "move-focus", leave_direction);
5213         }
5214     }
5215   else
5216     {
5217       gtk_widget_error_bell (GTK_WIDGET (text_view));
5218     }
5219
5220   gtk_text_view_check_cursor_blink (text_view);
5221   gtk_text_view_pend_cursor_blink (text_view);
5222 }
5223
5224 static void
5225 gtk_text_view_move_cursor (GtkTextView     *text_view,
5226                            GtkMovementStep  step,
5227                            gint             count,
5228                            gboolean         extend_selection)
5229 {
5230   gtk_text_view_move_cursor_internal (text_view, step, count, extend_selection);
5231 }
5232
5233 static void
5234 gtk_text_view_page_horizontally (GtkTextView     *text_view,
5235                                  gint             count,
5236                                  gboolean         extend_selection)
5237 {
5238   gtk_text_view_move_cursor_internal (text_view, GTK_MOVEMENT_HORIZONTAL_PAGES,
5239                                       count, extend_selection);
5240 }
5241
5242
5243 static gboolean
5244 gtk_text_view_move_viewport (GtkTextView     *text_view,
5245                              GtkScrollStep    step,
5246                              gint             count)
5247 {
5248   GtkAdjustment *adjustment;
5249   gdouble increment;
5250
5251   switch (step)
5252     {
5253     case GTK_SCROLL_STEPS:
5254     case GTK_SCROLL_PAGES:
5255     case GTK_SCROLL_ENDS:
5256       adjustment = get_vadjustment (text_view);
5257       break;
5258     case GTK_SCROLL_HORIZONTAL_STEPS:
5259     case GTK_SCROLL_HORIZONTAL_PAGES:
5260     case GTK_SCROLL_HORIZONTAL_ENDS:
5261       adjustment = get_hadjustment (text_view);
5262       break;
5263     default:
5264       adjustment = get_vadjustment (text_view);
5265       break;
5266     }
5267
5268   switch (step)
5269     {
5270     case GTK_SCROLL_STEPS:
5271     case GTK_SCROLL_HORIZONTAL_STEPS:
5272       increment = adjustment->step_increment;
5273       break;
5274     case GTK_SCROLL_PAGES:
5275     case GTK_SCROLL_HORIZONTAL_PAGES:
5276       increment = adjustment->page_increment;
5277       break;
5278     case GTK_SCROLL_ENDS:
5279     case GTK_SCROLL_HORIZONTAL_ENDS:
5280       increment = adjustment->upper - adjustment->lower;
5281       break;
5282     default:
5283       increment = 0.0;
5284       break;
5285     }
5286
5287   return set_adjustment_clamped (adjustment, adjustment->value + count * increment);
5288 }
5289
5290 static void
5291 gtk_text_view_set_anchor (GtkTextView *text_view)
5292 {
5293   GtkTextIter insert;
5294
5295   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
5296                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5297
5298   gtk_text_buffer_create_mark (get_buffer (text_view), "anchor", &insert, TRUE);
5299 }
5300
5301 static gboolean
5302 gtk_text_view_scroll_pages (GtkTextView *text_view,
5303                             gint         count,
5304                             gboolean     extend_selection)
5305 {
5306   gdouble newval;
5307   gdouble oldval;
5308   GtkAdjustment *adj;
5309   gint cursor_x_pos, cursor_y_pos;
5310   GtkTextMark *insert_mark;
5311   GtkTextIter old_insert;
5312   GtkTextIter new_insert;
5313   GtkTextIter anchor;
5314   gint y0, y1;
5315
5316   g_return_val_if_fail (text_view->vadjustment != NULL, FALSE);
5317
5318   adj = text_view->vadjustment;
5319
5320   insert_mark = gtk_text_buffer_get_insert (get_buffer (text_view));
5321
5322   /* Make sure we start from the current cursor position, even
5323    * if it was offscreen, but don't queue more scrolls if we're
5324    * already behind.
5325    */
5326   if (text_view->pending_scroll)
5327     cancel_pending_scroll (text_view);
5328   else
5329     gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
5330
5331   /* Validate the region that will be brought into view by the cursor motion
5332    */
5333   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
5334                                     &old_insert, insert_mark);
5335
5336   if (count < 0)
5337     {
5338       gtk_text_view_get_first_para_iter (text_view, &anchor);
5339       y0 = adj->page_size;
5340       y1 = adj->page_size + count * adj->page_increment;
5341     }
5342   else
5343     {
5344       gtk_text_view_get_first_para_iter (text_view, &anchor);
5345       y0 = count * adj->page_increment + adj->page_size;
5346       y1 = 0;
5347     }
5348
5349   gtk_text_layout_validate_yrange (text_view->layout, &anchor, y0, y1);
5350   /* FIXME do we need to update the adjustment ranges here? */
5351
5352   new_insert = old_insert;
5353
5354   if (count < 0 && adj->value <= (adj->lower + 1e-12))
5355     {
5356       /* already at top, just be sure we are at offset 0 */
5357       gtk_text_buffer_get_start_iter (get_buffer (text_view), &new_insert);
5358       move_cursor (text_view, &new_insert, extend_selection);
5359     }
5360   else if (count > 0 && adj->value >= (adj->upper - adj->page_size - 1e-12))
5361     {
5362       /* already at bottom, just be sure we are at the end */
5363       gtk_text_buffer_get_end_iter (get_buffer (text_view), &new_insert);
5364       move_cursor (text_view, &new_insert, extend_selection);
5365     }
5366   else
5367     {
5368       gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, &cursor_y_pos);
5369
5370       oldval = adj->value;
5371       newval = adj->value;
5372
5373       newval += count * adj->page_increment;
5374
5375       set_adjustment_clamped (adj, newval);
5376       cursor_y_pos += adj->value - oldval;
5377
5378       gtk_text_layout_get_iter_at_pixel (text_view->layout, &new_insert, cursor_x_pos, cursor_y_pos);
5379       clamp_iter_onscreen (text_view, &new_insert);
5380       move_cursor (text_view, &new_insert, extend_selection);
5381
5382       gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, cursor_y_pos);
5383     }
5384
5385   /* Adjust to have the cursor _entirely_ onscreen, move_mark_onscreen
5386    * only guarantees 1 pixel onscreen.
5387    */
5388   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5389   gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
5390
5391   return !gtk_text_iter_equal (&old_insert, &new_insert);
5392 }
5393
5394 static gboolean
5395 gtk_text_view_scroll_hpages (GtkTextView *text_view,
5396                              gint         count,
5397                              gboolean     extend_selection)
5398 {
5399   gdouble newval;
5400   gdouble oldval;
5401   GtkAdjustment *adj;
5402   gint cursor_x_pos, cursor_y_pos;
5403   GtkTextMark *insert_mark;
5404   GtkTextIter old_insert;
5405   GtkTextIter new_insert;
5406   gint y, height;
5407
5408   g_return_val_if_fail (text_view->hadjustment != NULL, FALSE);
5409
5410   adj = text_view->hadjustment;
5411
5412   insert_mark = gtk_text_buffer_get_insert (get_buffer (text_view));
5413
5414   /* Make sure we start from the current cursor position, even
5415    * if it was offscreen, but don't queue more scrolls if we're
5416    * already behind.
5417    */
5418   if (text_view->pending_scroll)
5419     cancel_pending_scroll (text_view);
5420   else
5421     gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
5422
5423   /* Validate the line that we're moving within.
5424    */
5425   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
5426                                     &old_insert, insert_mark);
5427
5428   gtk_text_layout_get_line_yrange (text_view->layout, &old_insert, &y, &height);
5429   gtk_text_layout_validate_yrange (text_view->layout, &old_insert, y, y + height);
5430   /* FIXME do we need to update the adjustment ranges here? */
5431
5432   new_insert = old_insert;
5433
5434   if (count < 0 && adj->value <= (adj->lower + 1e-12))
5435     {
5436       /* already at far left, just be sure we are at offset 0 */
5437       gtk_text_iter_set_line_offset (&new_insert, 0);
5438       move_cursor (text_view, &new_insert, extend_selection);
5439     }
5440   else if (count > 0 && adj->value >= (adj->upper - adj->page_size - 1e-12))
5441     {
5442       /* already at far right, just be sure we are at the end */
5443       if (!gtk_text_iter_ends_line (&new_insert))
5444           gtk_text_iter_forward_to_line_end (&new_insert);
5445       move_cursor (text_view, &new_insert, extend_selection);
5446     }
5447   else
5448     {
5449       gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, &cursor_y_pos);
5450
5451       oldval = adj->value;
5452       newval = adj->value;
5453
5454       newval += count * adj->page_increment;
5455
5456       set_adjustment_clamped (adj, newval);
5457       cursor_x_pos += adj->value - oldval;
5458
5459       gtk_text_layout_get_iter_at_pixel (text_view->layout, &new_insert, cursor_x_pos, cursor_y_pos);
5460       clamp_iter_onscreen (text_view, &new_insert);
5461       move_cursor (text_view, &new_insert, extend_selection);
5462
5463       gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, cursor_y_pos);
5464     }
5465
5466   /*  FIXME for lines shorter than the overall widget width, this results in a
5467    *  "bounce" effect as we scroll to the right of the widget, then scroll
5468    *  back to get the end of the line onscreen.
5469    *      http://bugzilla.gnome.org/show_bug.cgi?id=68963
5470    */
5471
5472   /* Adjust to have the cursor _entirely_ onscreen, move_mark_onscreen
5473    * only guarantees 1 pixel onscreen.
5474    */
5475   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5476   gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
5477
5478   return !gtk_text_iter_equal (&old_insert, &new_insert);
5479 }
5480
5481 static gboolean
5482 whitespace (gunichar ch, gpointer user_data)
5483 {
5484   return (ch == ' ' || ch == '\t');
5485 }
5486
5487 static gboolean
5488 not_whitespace (gunichar ch, gpointer user_data)
5489 {
5490   return !whitespace (ch, user_data);
5491 }
5492
5493 static gboolean
5494 find_whitepace_region (const GtkTextIter *center,
5495                        GtkTextIter *start, GtkTextIter *end)
5496 {
5497   *start = *center;
5498   *end = *center;
5499
5500   if (gtk_text_iter_backward_find_char (start, not_whitespace, NULL, NULL))
5501     gtk_text_iter_forward_char (start); /* we want the first whitespace... */
5502   if (whitespace (gtk_text_iter_get_char (end), NULL))
5503     gtk_text_iter_forward_find_char (end, not_whitespace, NULL, NULL);
5504
5505   return !gtk_text_iter_equal (start, end);
5506 }
5507
5508 static void
5509 gtk_text_view_insert_at_cursor (GtkTextView *text_view,
5510                                 const gchar *str)
5511 {
5512   if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1,
5513                                                      text_view->editable))
5514     {
5515       gtk_widget_error_bell (GTK_WIDGET (text_view));
5516     }
5517 }
5518
5519 static void
5520 gtk_text_view_delete_from_cursor (GtkTextView   *text_view,
5521                                   GtkDeleteType  type,
5522                                   gint           count)
5523 {
5524   GtkTextIter insert;
5525   GtkTextIter start;
5526   GtkTextIter end;
5527   gboolean leave_one = FALSE;
5528
5529   gtk_text_view_reset_im_context (text_view);
5530
5531   if (type == GTK_DELETE_CHARS)
5532     {
5533       /* Char delete deletes the selection, if one exists */
5534       if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
5535                                             text_view->editable))
5536         return;
5537     }
5538
5539   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
5540                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5541
5542   start = insert;
5543   end = insert;
5544
5545   switch (type)
5546     {
5547     case GTK_DELETE_CHARS:
5548       gtk_text_iter_forward_cursor_positions (&end, count);
5549       break;
5550
5551     case GTK_DELETE_WORD_ENDS:
5552       if (count > 0)
5553         gtk_text_iter_forward_word_ends (&end, count);
5554       else if (count < 0)
5555         gtk_text_iter_backward_word_starts (&start, 0 - count);
5556       break;
5557
5558     case GTK_DELETE_WORDS:
5559       break;
5560
5561     case GTK_DELETE_DISPLAY_LINE_ENDS:
5562       break;
5563
5564     case GTK_DELETE_DISPLAY_LINES:
5565       break;
5566
5567     case GTK_DELETE_PARAGRAPH_ENDS:
5568       if (count > 0)
5569         {
5570           /* If we're already at a newline, we need to
5571            * simply delete that newline, instead of
5572            * moving to the next one.
5573            */
5574           if (gtk_text_iter_ends_line (&end))
5575             {
5576               gtk_text_iter_forward_line (&end);
5577               --count;
5578             }
5579
5580           while (count > 0)
5581             {
5582               if (!gtk_text_iter_forward_to_line_end (&end))
5583                 break;
5584
5585               --count;
5586             }
5587         }
5588       else if (count < 0)
5589         {
5590           if (gtk_text_iter_starts_line (&start))
5591             {
5592               gtk_text_iter_backward_line (&start);
5593               if (!gtk_text_iter_ends_line (&end))
5594                 gtk_text_iter_forward_to_line_end (&start);
5595             }
5596           else
5597             {
5598               gtk_text_iter_set_line_offset (&start, 0);
5599             }
5600           ++count;
5601
5602           gtk_text_iter_backward_lines (&start, -count);
5603         }
5604       break;
5605
5606     case GTK_DELETE_PARAGRAPHS:
5607       if (count > 0)
5608         {
5609           gtk_text_iter_set_line_offset (&start, 0);
5610           gtk_text_iter_forward_to_line_end (&end);
5611
5612           /* Do the lines beyond the first. */
5613           while (count > 1)
5614             {
5615               gtk_text_iter_forward_to_line_end (&end);
5616
5617               --count;
5618             }
5619         }
5620
5621       /* FIXME negative count? */
5622
5623       break;
5624
5625     case GTK_DELETE_WHITESPACE:
5626       {
5627         find_whitepace_region (&insert, &start, &end);
5628       }
5629       break;
5630
5631     default:
5632       break;
5633     }
5634
5635   if (!gtk_text_iter_equal (&start, &end))
5636     {
5637       gtk_text_buffer_begin_user_action (get_buffer (text_view));
5638
5639       if (gtk_text_buffer_delete_interactive (get_buffer (text_view), &start, &end,
5640                                               text_view->editable))
5641         {
5642           if (leave_one)
5643             gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view),
5644                                                           " ", 1,
5645                                                           text_view->editable);
5646         }
5647       else
5648         {
5649           gtk_widget_error_bell (GTK_WIDGET (text_view));
5650         }
5651
5652       gtk_text_buffer_end_user_action (get_buffer (text_view));
5653       gtk_text_view_set_virtual_cursor_pos (text_view, -1, -1);
5654
5655       DV(g_print (G_STRLOC": scrolling onscreen\n"));
5656       gtk_text_view_scroll_mark_onscreen (text_view,
5657                                           gtk_text_buffer_get_insert (get_buffer (text_view)));
5658     }
5659   else
5660     {
5661       gtk_widget_error_bell (GTK_WIDGET (text_view));
5662     }
5663 }
5664
5665 static void
5666 gtk_text_view_backspace (GtkTextView *text_view)
5667 {
5668   GtkTextIter insert;
5669
5670   gtk_text_view_reset_im_context (text_view);
5671
5672   /* Backspace deletes the selection, if one exists */
5673   if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
5674                                         text_view->editable))
5675     return;
5676
5677   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
5678                                     &insert,
5679                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5680
5681   if (gtk_text_buffer_backspace (get_buffer (text_view), &insert,
5682                                  TRUE, text_view->editable))
5683     {
5684       gtk_text_view_set_virtual_cursor_pos (text_view, -1, -1);
5685       DV(g_print (G_STRLOC": scrolling onscreen\n"));
5686       gtk_text_view_scroll_mark_onscreen (text_view,
5687                                           gtk_text_buffer_get_insert (get_buffer (text_view)));
5688     }
5689   else
5690     {
5691       gtk_widget_error_bell (GTK_WIDGET (text_view));
5692     }
5693 }
5694
5695 static void
5696 gtk_text_view_cut_clipboard (GtkTextView *text_view)
5697 {
5698   GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
5699                                                       GDK_SELECTION_CLIPBOARD);
5700
5701   gtk_text_buffer_cut_clipboard (get_buffer (text_view),
5702                                  clipboard,
5703                                  text_view->editable);
5704   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5705   gtk_text_view_scroll_mark_onscreen (text_view,
5706                                       gtk_text_buffer_get_insert (get_buffer (text_view)));
5707 }
5708
5709 static void
5710 gtk_text_view_copy_clipboard (GtkTextView *text_view)
5711 {
5712   GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
5713                                                       GDK_SELECTION_CLIPBOARD);
5714
5715   gtk_text_buffer_copy_clipboard (get_buffer (text_view),
5716                                   clipboard);
5717
5718   /* on copy do not scroll, we are already onscreen */
5719 }
5720
5721 static void
5722 gtk_text_view_paste_clipboard (GtkTextView *text_view)
5723 {
5724   GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
5725                                                       GDK_SELECTION_CLIPBOARD);
5726
5727   gtk_text_buffer_paste_clipboard (get_buffer (text_view),
5728                                    clipboard,
5729                                    NULL,
5730                                    text_view->editable);
5731 }
5732
5733 static void
5734 gtk_text_view_paste_done_handler (GtkTextBuffer *buffer,
5735                                   GtkClipboard  *clipboard,
5736                                   gpointer       data)
5737 {
5738   GtkTextView *text_view = data;
5739   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5740   gtk_text_view_scroll_mark_onscreen (text_view, gtk_text_buffer_get_insert (buffer));
5741 }
5742
5743 static void
5744 gtk_text_view_toggle_overwrite (GtkTextView *text_view)
5745 {
5746   if (text_view->text_window)
5747     text_window_invalidate_cursors (text_view->text_window);
5748
5749   text_view->overwrite_mode = !text_view->overwrite_mode;
5750
5751   if (text_view->layout)
5752     gtk_text_layout_set_overwrite_mode (text_view->layout,
5753                                         text_view->overwrite_mode && text_view->editable);
5754
5755   if (text_view->text_window)
5756     text_window_invalidate_cursors (text_view->text_window);
5757
5758   gtk_text_view_pend_cursor_blink (text_view);
5759
5760   g_object_notify (G_OBJECT (text_view), "overwrite");
5761 }
5762
5763 /**
5764  * gtk_text_view_get_overwrite:
5765  * @text_view: a #GtkTextView
5766  *
5767  * Returns whether the #GtkTextView is in overwrite mode or not.
5768  *
5769  * Return value: whether @text_view is in overwrite mode or not.
5770  *
5771  * Since: 2.4
5772  **/
5773 gboolean
5774 gtk_text_view_get_overwrite (GtkTextView *text_view)
5775 {
5776   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
5777
5778   return text_view->overwrite_mode;
5779 }
5780
5781 /**
5782  * gtk_text_view_set_overwrite:
5783  * @text_view: a #GtkTextView
5784  * @overwrite: %TRUE to turn on overwrite mode, %FALSE to turn it off
5785  *
5786  * Changes the #GtkTextView overwrite mode.
5787  *
5788  * Since: 2.4
5789  **/
5790 void
5791 gtk_text_view_set_overwrite (GtkTextView *text_view,
5792                              gboolean     overwrite)
5793 {
5794   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5795   overwrite = overwrite != FALSE;
5796
5797   if (text_view->overwrite_mode != overwrite)
5798     gtk_text_view_toggle_overwrite (text_view);
5799 }
5800
5801 /**
5802  * gtk_text_view_set_accepts_tab:
5803  * @text_view: A #GtkTextView
5804  * @accepts_tab: %TRUE if pressing the Tab key should insert a tab
5805  *    character, %FALSE, if pressing the Tab key should move the
5806  *    keyboard focus.
5807  *
5808  * Sets the behavior of the text widget when the Tab key is pressed.
5809  * If @accepts_tab is %TRUE, a tab character is inserted. If @accepts_tab
5810  * is %FALSE the keyboard focus is moved to the next widget in the focus
5811  * chain.
5812  *
5813  * Since: 2.4
5814  **/
5815 void
5816 gtk_text_view_set_accepts_tab (GtkTextView *text_view,
5817                                gboolean     accepts_tab)
5818 {
5819   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5820
5821   accepts_tab = accepts_tab != FALSE;
5822
5823   if (text_view->accepts_tab != accepts_tab)
5824     {
5825       text_view->accepts_tab = accepts_tab;
5826
5827       g_object_notify (G_OBJECT (text_view), "accepts-tab");
5828     }
5829 }
5830
5831 /**
5832  * gtk_text_view_get_accepts_tab:
5833  * @text_view: A #GtkTextView
5834  *
5835  * Returns whether pressing the Tab key inserts a tab characters.
5836  * gtk_text_view_set_accepts_tab().
5837  *
5838  * Return value: %TRUE if pressing the Tab key inserts a tab character,
5839  *   %FALSE if pressing the Tab key moves the keyboard focus.
5840  *
5841  * Since: 2.4
5842  **/
5843 gboolean
5844 gtk_text_view_get_accepts_tab (GtkTextView *text_view)
5845 {
5846   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
5847
5848   return text_view->accepts_tab;
5849 }
5850
5851 static void
5852 gtk_text_view_compat_move_focus (GtkTextView     *text_view,
5853                                  GtkDirectionType direction_type)
5854 {
5855   GSignalInvocationHint *hint = g_signal_get_invocation_hint (text_view);
5856
5857   /*  as of GTK+ 2.12, the "move-focus" signal has been moved to GtkWidget,
5858    *  the evil code below makes sure that both emitting the signal and
5859    *  calling the virtual function directly continue to work as expetcted
5860    */
5861
5862   if (hint->signal_id == g_signal_lookup ("move-focus", GTK_TYPE_WIDGET))
5863     {
5864       /*  if this is a signal emission, chain up  */
5865
5866       gboolean retval;
5867
5868       g_signal_chain_from_overridden_handler (text_view,
5869                                               direction_type, &retval);
5870     }
5871   else
5872     {
5873       /*  otherwise emit the signal, since somebody called the virtual
5874        *  function directly
5875        */
5876
5877       g_signal_emit_by_name (text_view, "move-focus", direction_type);
5878     }
5879 }
5880
5881 /*
5882  * Selections
5883  */
5884
5885 static void
5886 gtk_text_view_unselect (GtkTextView *text_view)
5887 {
5888   GtkTextIter insert;
5889
5890   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
5891                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5892
5893   gtk_text_buffer_move_mark (get_buffer (text_view),
5894                              gtk_text_buffer_get_selection_bound (get_buffer (text_view)),
5895                              &insert);
5896 }
5897
5898 static void
5899 get_iter_at_pointer (GtkTextView *text_view,
5900                      GtkTextIter *iter,
5901                      gint        *x,
5902                      gint        *y)
5903 {
5904   gint xcoord, ycoord;
5905   GdkModifierType state;
5906
5907   gdk_window_get_pointer (text_view->text_window->bin_window,
5908                           &xcoord, &ycoord, &state);
5909
5910   gtk_text_layout_get_iter_at_pixel (text_view->layout,
5911                                      iter,
5912                                      xcoord + text_view->xoffset,
5913                                      ycoord + text_view->yoffset);
5914   if (x)
5915     *x = xcoord;
5916
5917   if (y)
5918     *y = ycoord;
5919 }
5920
5921 static void
5922 move_mark_to_pointer_and_scroll (GtkTextView *text_view,
5923                                  const gchar *mark_name)
5924 {
5925   GtkTextIter newplace;
5926   GtkTextMark *mark;
5927
5928   get_iter_at_pointer (text_view, &newplace, NULL, NULL);
5929
5930   mark = gtk_text_buffer_get_mark (get_buffer (text_view), mark_name);
5931
5932   /* This may invalidate the layout */
5933   DV(g_print (G_STRLOC": move mark\n"));
5934
5935   gtk_text_buffer_move_mark (get_buffer (text_view),
5936                              mark,
5937                              &newplace);
5938
5939   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5940   gtk_text_view_scroll_mark_onscreen (text_view, mark);
5941
5942   DV (g_print ("first validate idle leaving %s is %d\n",
5943                G_STRLOC, text_view->first_validate_idle));
5944 }
5945
5946 static gboolean
5947 selection_scan_timeout (gpointer data)
5948 {
5949   GtkTextView *text_view;
5950
5951   text_view = GTK_TEXT_VIEW (data);
5952
5953   DV(g_print (G_STRLOC": calling move_mark_to_pointer_and_scroll\n"));
5954   gtk_text_view_scroll_mark_onscreen (text_view,
5955                                       gtk_text_buffer_get_insert (get_buffer (text_view)));
5956
5957   return TRUE; /* remain installed. */
5958 }
5959
5960 #define UPPER_OFFSET_ANCHOR 0.8
5961 #define LOWER_OFFSET_ANCHOR 0.2
5962
5963 static gboolean
5964 check_scroll (gdouble offset, GtkAdjustment *adj)
5965 {
5966   if ((offset > UPPER_OFFSET_ANCHOR &&
5967        adj->value + adj->page_size < adj->upper) ||
5968       (offset < LOWER_OFFSET_ANCHOR &&
5969        adj->value > adj->lower))
5970     return TRUE;
5971
5972   return FALSE;
5973 }
5974
5975 static gint
5976 drag_scan_timeout (gpointer data)
5977 {
5978   GtkTextView *text_view;
5979   GtkTextIter newplace;
5980   gint x, y, width, height;
5981   gdouble pointer_xoffset, pointer_yoffset;
5982
5983   text_view = GTK_TEXT_VIEW (data);
5984
5985   get_iter_at_pointer (text_view, &newplace, &x, &y);
5986   gdk_drawable_get_size (text_view->text_window->bin_window, &width, &height);
5987
5988   gtk_text_buffer_move_mark (get_buffer (text_view),
5989                              text_view->dnd_mark,
5990                              &newplace);
5991
5992   pointer_xoffset = (gdouble) x / width;
5993   pointer_yoffset = (gdouble) y / height;
5994
5995   if (check_scroll (pointer_xoffset, text_view->hadjustment) ||
5996       check_scroll (pointer_yoffset, text_view->vadjustment))
5997     {
5998       /* do not make offsets surpass lower nor upper anchors, this makes
5999        * scrolling speed relative to the distance of the pointer to the
6000        * anchors when it moves beyond them.
6001        */
6002       pointer_xoffset = CLAMP (pointer_xoffset, LOWER_OFFSET_ANCHOR, UPPER_OFFSET_ANCHOR);
6003       pointer_yoffset = CLAMP (pointer_yoffset, LOWER_OFFSET_ANCHOR, UPPER_OFFSET_ANCHOR);
6004
6005       gtk_text_view_scroll_to_mark (text_view,
6006                                     text_view->dnd_mark,
6007                                     0., TRUE, pointer_xoffset, pointer_yoffset);
6008     }
6009
6010   return TRUE;
6011 }
6012
6013 typedef enum
6014 {
6015   SELECT_CHARACTERS,
6016   SELECT_WORDS,
6017   SELECT_LINES
6018 } SelectionGranularity;
6019
6020 /*
6021  * Move @start and @end to the boundaries of the selection unit (indicated by
6022  * @granularity) which contained @start initially.
6023  * If the selction unit is SELECT_WORDS and @start is not contained in a word
6024  * the selection is extended to all the white spaces between the end of the
6025  * word preceding @start and the start of the one following.
6026  */
6027 static void
6028 extend_selection (GtkTextView *text_view,
6029                   SelectionGranularity granularity,
6030                   GtkTextIter *start,
6031                   GtkTextIter *end)
6032 {
6033   *end = *start;
6034
6035   if (granularity == SELECT_WORDS)
6036     {
6037       if (gtk_text_iter_inside_word (start))
6038         {
6039           if (!gtk_text_iter_starts_word (start))
6040             gtk_text_iter_backward_visible_word_start (start);
6041
6042           if (!gtk_text_iter_ends_word (end))
6043             {
6044               if (!gtk_text_iter_forward_visible_word_end (end))
6045                 gtk_text_iter_forward_to_end (end);
6046             }
6047         }
6048       else
6049         {
6050           GtkTextIter tmp;
6051
6052           tmp = *start;
6053           if (gtk_text_iter_backward_visible_word_start (&tmp))
6054             gtk_text_iter_forward_visible_word_end (&tmp);
6055
6056           if (gtk_text_iter_get_line (&tmp) == gtk_text_iter_get_line (start))
6057             *start = tmp;
6058           else
6059             gtk_text_iter_set_line_offset (start, 0);
6060
6061           tmp = *end;
6062           if (!gtk_text_iter_forward_visible_word_end (&tmp))
6063             gtk_text_iter_forward_to_end (&tmp);
6064
6065           if (gtk_text_iter_ends_word (&tmp))
6066             gtk_text_iter_backward_visible_word_start (&tmp);
6067
6068           if (gtk_text_iter_get_line (&tmp) == gtk_text_iter_get_line (end))
6069             *end = tmp;
6070           else
6071             gtk_text_iter_forward_to_line_end (end);
6072         }
6073     }
6074   else if (granularity == SELECT_LINES)
6075     {
6076       if (gtk_text_view_starts_display_line (text_view, start))
6077         {
6078           /* If on a display line boundary, we assume the user
6079            * clicked off the end of a line and we therefore select
6080            * the line before the boundary.
6081            */
6082           gtk_text_view_backward_display_line_start (text_view, start);
6083         }
6084       else
6085         {
6086           /* start isn't on the start of a line, so we move it to the
6087            * start, and move end to the end unless it's already there.
6088            */
6089           gtk_text_view_backward_display_line_start (text_view, start);
6090
6091           if (!gtk_text_view_starts_display_line (text_view, end))
6092             gtk_text_view_forward_display_line_end (text_view, end);
6093         }
6094     }
6095 }
6096
6097
6098 typedef struct
6099 {
6100   SelectionGranularity granularity;
6101   GtkTextMark *orig_start;
6102   GtkTextMark *orig_end;
6103 } SelectionData;
6104
6105 static void
6106 selection_data_free (SelectionData *data)
6107 {
6108   if (data->orig_start != NULL)
6109     gtk_text_buffer_delete_mark (gtk_text_mark_get_buffer (data->orig_start),
6110                                  data->orig_start);
6111   if (data->orig_end != NULL)
6112     gtk_text_buffer_delete_mark (gtk_text_mark_get_buffer (data->orig_end),
6113                                  data->orig_end);
6114   g_free (data);
6115 }
6116
6117 static gint
6118 selection_motion_event_handler (GtkTextView    *text_view,
6119                                 GdkEventMotion *event,
6120                                 SelectionData  *data)
6121 {
6122   gdk_event_request_motions (event);
6123
6124   if (data->granularity == SELECT_CHARACTERS)
6125     {
6126       move_mark_to_pointer_and_scroll (text_view, "insert");
6127     }
6128   else
6129     {
6130       GtkTextIter cursor, start, end;
6131       GtkTextIter orig_start, orig_end;
6132       GtkTextBuffer *buffer;
6133
6134       buffer = get_buffer (text_view);
6135
6136       gtk_text_buffer_get_iter_at_mark (buffer, &orig_start, data->orig_start);
6137       gtk_text_buffer_get_iter_at_mark (buffer, &orig_end, data->orig_end);
6138
6139       get_iter_at_pointer (text_view, &cursor, NULL, NULL);
6140
6141       start = cursor;
6142       extend_selection (text_view, data->granularity, &start, &end);
6143
6144       /* either the selection extends to the front, or end (or not) */
6145       if (gtk_text_iter_compare (&cursor, &orig_start) < 0)
6146         gtk_text_buffer_select_range (buffer, &start, &orig_end);
6147       else
6148         gtk_text_buffer_select_range (buffer, &end, &orig_start);
6149
6150       gtk_text_view_scroll_mark_onscreen (text_view,
6151                                           gtk_text_buffer_get_insert (buffer));
6152     }
6153
6154   /* If we had to scroll offscreen, insert a timeout to do so
6155    * again. Note that in the timeout, even if the mouse doesn't
6156    * move, due to this scroll xoffset/yoffset will have changed
6157    * and we'll need to scroll again.
6158    */
6159   if (text_view->scroll_timeout != 0) /* reset on every motion event */
6160     g_source_remove (text_view->scroll_timeout);
6161
6162   text_view->scroll_timeout =
6163     gdk_threads_add_timeout (50, selection_scan_timeout, text_view);
6164
6165   return TRUE;
6166 }
6167
6168 static void
6169 gtk_text_view_start_selection_drag (GtkTextView       *text_view,
6170                                     const GtkTextIter *iter,
6171                                     GdkEventButton    *button)
6172 {
6173   GtkTextIter cursor, ins, bound;
6174   GtkTextIter orig_start, orig_end;
6175   GtkTextBuffer *buffer;
6176   SelectionData *data;
6177
6178   if (text_view->selection_drag_handler != 0)
6179     return;
6180
6181   data = g_new0 (SelectionData, 1);
6182
6183   if (button->type == GDK_2BUTTON_PRESS)
6184     data->granularity = SELECT_WORDS;
6185   else if (button->type == GDK_3BUTTON_PRESS)
6186     data->granularity = SELECT_LINES;
6187   else
6188     data->granularity = SELECT_CHARACTERS;
6189
6190   gtk_grab_add (GTK_WIDGET (text_view));
6191
6192   buffer = get_buffer (text_view);
6193
6194   cursor = *iter;
6195   ins = cursor;
6196
6197   extend_selection (text_view, data->granularity, &ins, &bound);
6198   orig_start = ins;
6199   orig_end = bound;
6200
6201   if (button->state & GDK_SHIFT_MASK)
6202     {
6203       /* Extend selection */
6204       GtkTextIter old_ins, old_bound;
6205       GtkTextIter old_start, old_end;
6206
6207       gtk_text_buffer_get_iter_at_mark (buffer, &old_ins, gtk_text_buffer_get_insert (buffer));
6208       gtk_text_buffer_get_iter_at_mark (buffer, &old_bound, gtk_text_buffer_get_selection_bound (buffer));
6209       old_start = old_ins;
6210       old_end = old_bound;
6211       gtk_text_iter_order (&old_start, &old_end);
6212
6213       /* move the front cursor, if the mouse is in front of the selection. Should the
6214        * cursor however be inside the selection (this happens on tripple click) then we
6215        * move the side which was last moved (current insert mark) */
6216       if (gtk_text_iter_compare (&cursor, &old_start) <= 0 ||
6217           (gtk_text_iter_compare (&cursor, &old_end) < 0 &&
6218            gtk_text_iter_compare (&old_ins, &old_bound) <= 0))
6219         {
6220           bound = old_end;
6221           orig_start = old_end;
6222           orig_end = old_end;
6223         }
6224       else
6225         {
6226           ins = bound;
6227           bound = old_start;
6228           orig_end = bound;
6229           orig_start = bound;
6230         }
6231     }
6232
6233   gtk_text_buffer_select_range (buffer, &ins, &bound);
6234
6235   gtk_text_iter_order (&orig_start, &orig_end);
6236   data->orig_start = gtk_text_buffer_create_mark (buffer, NULL,
6237                                                   &orig_start, TRUE);
6238   data->orig_end = gtk_text_buffer_create_mark (buffer, NULL,
6239                                                 &orig_end, TRUE);
6240
6241   gtk_text_view_check_cursor_blink (text_view);
6242
6243   text_view->selection_drag_handler = g_signal_connect_data (text_view,
6244                                                              "motion-notify-event",
6245                                                              G_CALLBACK (selection_motion_event_handler),
6246                                                              data,
6247                                                              (GClosureNotify) selection_data_free, 0);
6248 }
6249
6250 /* returns whether we were really dragging */
6251 static gboolean
6252 gtk_text_view_end_selection_drag (GtkTextView    *text_view)
6253 {
6254   if (text_view->selection_drag_handler == 0)
6255     return FALSE;
6256
6257   g_signal_handler_disconnect (text_view, text_view->selection_drag_handler);
6258   text_view->selection_drag_handler = 0;
6259
6260   if (text_view->scroll_timeout != 0)
6261     {
6262       g_source_remove (text_view->scroll_timeout);
6263       text_view->scroll_timeout = 0;
6264     }
6265
6266   gtk_grab_remove (GTK_WIDGET (text_view));
6267
6268   return TRUE;
6269 }
6270
6271 /*
6272  * Layout utils
6273  */
6274
6275 static void
6276 gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
6277                                          GtkTextAttributes  *values,
6278                                          GtkStyle           *style)
6279 {
6280   values->appearance.bg_color = style->base[GTK_STATE_NORMAL];
6281   values->appearance.fg_color = style->text[GTK_STATE_NORMAL];
6282
6283   if (values->font)
6284     pango_font_description_free (values->font);
6285
6286   values->font = pango_font_description_copy (style->font_desc);
6287 }
6288
6289 static void
6290 gtk_text_view_check_keymap_direction (GtkTextView *text_view)
6291 {
6292   if (text_view->layout)
6293     {
6294       GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
6295       GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (text_view)));
6296       GtkTextDirection new_cursor_dir;
6297       GtkTextDirection new_keyboard_dir;
6298       gboolean split_cursor;
6299
6300       g_object_get (settings,
6301                     "gtk-split-cursor", &split_cursor,
6302                     NULL);
6303
6304       if (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_RTL)
6305         new_keyboard_dir = GTK_TEXT_DIR_RTL;
6306       else
6307         new_keyboard_dir  = GTK_TEXT_DIR_LTR;
6308
6309       if (split_cursor)
6310         new_cursor_dir = GTK_TEXT_DIR_NONE;
6311       else
6312         new_cursor_dir = new_keyboard_dir;
6313
6314       gtk_text_layout_set_cursor_direction (text_view->layout, new_cursor_dir);
6315       gtk_text_layout_set_keyboard_direction (text_view->layout, new_keyboard_dir);
6316     }
6317 }
6318
6319 static void
6320 gtk_text_view_ensure_layout (GtkTextView *text_view)
6321 {
6322   GtkWidget *widget;
6323
6324   widget = GTK_WIDGET (text_view);
6325
6326   if (text_view->layout == NULL)
6327     {
6328       GtkTextAttributes *style;
6329       PangoContext *ltr_context, *rtl_context;
6330       GSList *tmp_list;
6331
6332       DV(g_print(G_STRLOC"\n"));
6333
6334       text_view->layout = gtk_text_layout_new ();
6335
6336       g_signal_connect (text_view->layout,
6337                         "invalidated",
6338                         G_CALLBACK (invalidated_handler),
6339                         text_view);
6340
6341       g_signal_connect (text_view->layout,
6342                         "changed",
6343                         G_CALLBACK (changed_handler),
6344                         text_view);
6345
6346       g_signal_connect (text_view->layout,
6347                         "allocate-child",
6348                         G_CALLBACK (gtk_text_view_child_allocated),
6349                         text_view);
6350
6351       if (get_buffer (text_view))
6352         gtk_text_layout_set_buffer (text_view->layout, get_buffer (text_view));
6353
6354       if ((GTK_WIDGET_HAS_FOCUS (text_view) && text_view->cursor_visible))
6355         gtk_text_view_pend_cursor_blink (text_view);
6356       else
6357         gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
6358
6359       gtk_text_layout_set_overwrite_mode (text_view->layout,
6360                                           text_view->overwrite_mode && text_view->editable);
6361
6362       ltr_context = gtk_widget_create_pango_context (GTK_WIDGET (text_view));
6363       pango_context_set_base_dir (ltr_context, PANGO_DIRECTION_LTR);
6364       rtl_context = gtk_widget_create_pango_context (GTK_WIDGET (text_view));
6365       pango_context_set_base_dir (rtl_context, PANGO_DIRECTION_RTL);
6366
6367       gtk_text_layout_set_contexts (text_view->layout, ltr_context, rtl_context);
6368
6369       g_object_unref (ltr_context);
6370       g_object_unref (rtl_context);
6371
6372       gtk_text_view_check_keymap_direction (text_view);
6373
6374       style = gtk_text_attributes_new ();
6375
6376       gtk_widget_ensure_style (widget);
6377       gtk_text_view_set_attributes_from_style (text_view,
6378                                                style, widget->style);
6379
6380       style->pixels_above_lines = text_view->pixels_above_lines;
6381       style->pixels_below_lines = text_view->pixels_below_lines;
6382       style->pixels_inside_wrap = text_view->pixels_inside_wrap;
6383       style->left_margin = text_view->left_margin;
6384       style->right_margin = text_view->right_margin;
6385       style->indent = text_view->indent;
6386       style->tabs = text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
6387
6388       style->wrap_mode = text_view->wrap_mode;
6389       style->justification = text_view->justify;
6390       style->direction = gtk_widget_get_direction (GTK_WIDGET (text_view));
6391
6392       gtk_text_layout_set_default_style (text_view->layout, style);
6393
6394       gtk_text_attributes_unref (style);
6395
6396       /* Set layout for all anchored children */
6397
6398       tmp_list = text_view->children;
6399       while (tmp_list != NULL)
6400         {
6401           GtkTextViewChild *vc = tmp_list->data;
6402
6403           if (vc->anchor)
6404             {
6405               gtk_text_anchored_child_set_layout (vc->widget,
6406                                                   text_view->layout);
6407               /* vc may now be invalid! */
6408             }
6409
6410           tmp_list = g_slist_next (tmp_list);
6411         }
6412
6413       gtk_text_view_invalidate (text_view);
6414     }
6415 }
6416
6417 /**
6418  * gtk_text_view_get_default_attributes:
6419  * @text_view: a #GtkTextView
6420  *
6421  * Obtains a copy of the default text attributes. These are the
6422  * attributes used for text unless a tag overrides them.
6423  * You'd typically pass the default attributes in to
6424  * gtk_text_iter_get_attributes() in order to get the
6425  * attributes in effect at a given text position.
6426  *
6427  * The return value is a copy owned by the caller of this function,
6428  * and should be freed.
6429  *
6430  * Return value: a new #GtkTextAttributes
6431  **/
6432 GtkTextAttributes*
6433 gtk_text_view_get_default_attributes (GtkTextView *text_view)
6434 {
6435   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
6436
6437   gtk_text_view_ensure_layout (text_view);
6438
6439   return gtk_text_attributes_copy (text_view->layout->default_style);
6440 }
6441
6442 static void
6443 gtk_text_view_destroy_layout (GtkTextView *text_view)
6444 {
6445   if (text_view->layout)
6446     {
6447       GSList *tmp_list;
6448
6449       gtk_text_view_remove_validate_idles (text_view);
6450
6451       g_signal_handlers_disconnect_by_func (text_view->layout,
6452                                             invalidated_handler,
6453                                             text_view);
6454       g_signal_handlers_disconnect_by_func (text_view->layout,
6455                                             changed_handler,
6456                                             text_view);
6457
6458       /* Remove layout from all anchored children */
6459       tmp_list = text_view->children;
6460       while (tmp_list != NULL)
6461         {
6462           GtkTextViewChild *vc = tmp_list->data;
6463
6464           if (vc->anchor)
6465             {
6466               gtk_text_anchored_child_set_layout (vc->widget, NULL);
6467               /* vc may now be invalid! */
6468             }
6469
6470           tmp_list = g_slist_next (tmp_list);
6471         }
6472
6473       gtk_text_view_stop_cursor_blink (text_view);
6474       gtk_text_view_end_selection_drag (text_view);
6475
6476       g_object_unref (text_view->layout);
6477       text_view->layout = NULL;
6478     }
6479 }
6480
6481 static void
6482 gtk_text_view_reset_im_context (GtkTextView *text_view)
6483 {
6484   if (text_view->need_im_reset)
6485     {
6486       text_view->need_im_reset = FALSE;
6487       gtk_im_context_reset (text_view->im_context);
6488     }
6489 }
6490
6491 /*
6492  * DND feature
6493  */
6494
6495 static void
6496 drag_begin_cb (GtkWidget      *widget,
6497                GdkDragContext *context,
6498                gpointer        data)
6499 {
6500   GtkTextView   *text_view = GTK_TEXT_VIEW (widget);
6501   GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
6502   GtkTextIter    start;
6503   GtkTextIter    end;
6504   GdkPixmap     *pixmap = NULL;
6505
6506   g_signal_handlers_disconnect_by_func (widget, drag_begin_cb, NULL);
6507
6508   if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
6509     pixmap = _gtk_text_util_create_rich_drag_icon (widget, buffer, &start, &end);
6510
6511   if (pixmap)
6512     {
6513       gtk_drag_set_icon_pixmap (context,
6514                                 gdk_drawable_get_colormap (pixmap),
6515                                 pixmap,
6516                                 NULL,
6517                                 -2, -2);
6518       g_object_unref (pixmap);
6519     }
6520   else
6521     {
6522       gtk_drag_set_icon_default (context);
6523     }
6524 }
6525
6526 static void
6527 gtk_text_view_start_selection_dnd (GtkTextView       *text_view,
6528                                    const GtkTextIter *iter,
6529                                    GdkEventMotion    *event)
6530 {
6531   GtkTargetList *target_list;
6532
6533   text_view->drag_start_x = -1;
6534   text_view->drag_start_y = -1;
6535   text_view->pending_place_cursor_button = 0;
6536
6537   target_list = gtk_text_buffer_get_copy_target_list (get_buffer (text_view));
6538
6539   g_signal_connect (text_view, "drag-begin",
6540                     G_CALLBACK (drag_begin_cb), NULL);
6541   gtk_drag_begin (GTK_WIDGET (text_view), target_list,
6542                   GDK_ACTION_COPY | GDK_ACTION_MOVE,
6543                   1, (GdkEvent*)event);
6544 }
6545
6546 static void
6547 gtk_text_view_drag_begin (GtkWidget        *widget,
6548                           GdkDragContext   *context)
6549 {
6550   /* do nothing */
6551 }
6552
6553 static void
6554 gtk_text_view_drag_end (GtkWidget        *widget,
6555                         GdkDragContext   *context)
6556 {
6557 }
6558
6559 static void
6560 gtk_text_view_drag_data_get (GtkWidget        *widget,
6561                              GdkDragContext   *context,
6562                              GtkSelectionData *selection_data,
6563                              guint             info,
6564                              guint             time)
6565 {
6566   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
6567   GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
6568
6569   if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
6570     {
6571       gtk_selection_data_set (selection_data,
6572                               gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"),
6573                               8, /* bytes */
6574                               (void*)&buffer,
6575                               sizeof (buffer));
6576     }
6577   else if (info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
6578     {
6579       GtkTextIter start;
6580       GtkTextIter end;
6581       guint8 *str = NULL;
6582       gsize len;
6583
6584       if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
6585         {
6586           /* Extract the selected text */
6587           str = gtk_text_buffer_serialize (buffer, buffer,
6588                                            selection_data->target,
6589                                            &start, &end,
6590                                            &len);
6591         }
6592
6593       if (str)
6594         {
6595           gtk_selection_data_set (selection_data,
6596                                   selection_data->target,
6597                                   8, /* bytes */
6598                                   (guchar *) str, len);
6599           g_free (str);
6600         }
6601     }
6602   else
6603     {
6604       GtkTextIter start;
6605       GtkTextIter end;
6606       gchar *str = NULL;
6607
6608       if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
6609         {
6610           /* Extract the selected text */
6611           str = gtk_text_iter_get_visible_text (&start, &end);
6612         }
6613
6614       if (str)
6615         {
6616           gtk_selection_data_set_text (selection_data, str, -1);
6617           g_free (str);
6618         }
6619     }
6620 }
6621
6622 static void
6623 gtk_text_view_drag_data_delete (GtkWidget        *widget,
6624                                 GdkDragContext   *context)
6625 {
6626   gtk_text_buffer_delete_selection (GTK_TEXT_VIEW (widget)->buffer,
6627                                     TRUE, GTK_TEXT_VIEW (widget)->editable);
6628 }
6629
6630 static void
6631 gtk_text_view_drag_leave (GtkWidget        *widget,
6632                           GdkDragContext   *context,
6633                           guint             time)
6634 {
6635   GtkTextView *text_view;
6636
6637   text_view = GTK_TEXT_VIEW (widget);
6638
6639   gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
6640
6641   if (text_view->scroll_timeout != 0)
6642     g_source_remove (text_view->scroll_timeout);
6643
6644   text_view->scroll_timeout = 0;
6645 }
6646
6647 static gboolean
6648 gtk_text_view_drag_motion (GtkWidget        *widget,
6649                            GdkDragContext   *context,
6650                            gint              x,
6651                            gint              y,
6652                            guint             time)
6653 {
6654   GtkTextIter newplace;
6655   GtkTextView *text_view;
6656   GtkTextIter start;
6657   GtkTextIter end;
6658   GdkRectangle target_rect;
6659   gint bx, by;
6660   GdkAtom target;
6661   GdkDragAction suggested_action = 0;
6662
6663   text_view = GTK_TEXT_VIEW (widget);
6664
6665   target_rect = text_view->text_window->allocation;
6666
6667   if (x < target_rect.x ||
6668       y < target_rect.y ||
6669       x > (target_rect.x + target_rect.width) ||
6670       y > (target_rect.y + target_rect.height))
6671     return FALSE; /* outside the text window, allow parent widgets to handle event */
6672
6673   gtk_text_view_window_to_buffer_coords (text_view,
6674                                          GTK_TEXT_WINDOW_WIDGET,
6675                                          x, y,
6676                                          &bx, &by);
6677
6678   gtk_text_layout_get_iter_at_pixel (text_view->layout,
6679                                      &newplace,
6680                                      bx, by);
6681
6682   target = gtk_drag_dest_find_target (widget, context,
6683                                       gtk_drag_dest_get_target_list (widget));
6684
6685   if (target == GDK_NONE)
6686     {
6687       /* can't accept any of the offered targets */
6688     }
6689   else if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
6690                                                  &start, &end) &&
6691            gtk_text_iter_compare (&newplace, &start) >= 0 &&
6692            gtk_text_iter_compare (&newplace, &end) <= 0)
6693     {
6694       /* We're inside the selection. */
6695     }
6696   else
6697     {
6698       if (gtk_text_iter_can_insert (&newplace, text_view->editable))
6699         {
6700           GtkWidget *source_widget;
6701
6702           suggested_action = context->suggested_action;
6703
6704           source_widget = gtk_drag_get_source_widget (context);
6705
6706           if (source_widget == widget)
6707             {
6708               /* Default to MOVE, unless the user has
6709                * pressed ctrl or alt to affect available actions
6710                */
6711               if ((context->actions & GDK_ACTION_MOVE) != 0)
6712                 suggested_action = GDK_ACTION_MOVE;
6713             }
6714         }
6715       else
6716         {
6717           /* Can't drop here. */
6718         }
6719     }
6720
6721   if (suggested_action != 0)
6722     {
6723       gtk_text_mark_set_visible (text_view->dnd_mark,
6724                                  text_view->cursor_visible);
6725
6726       gdk_drag_status (context, suggested_action, time);
6727     }
6728   else
6729     {
6730       gdk_drag_status (context, 0, time);
6731       gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
6732     }
6733
6734   if (!text_view->scroll_timeout)
6735     text_view->scroll_timeout =
6736       gdk_threads_add_timeout (100, drag_scan_timeout, text_view);
6737
6738   /* TRUE return means don't propagate the drag motion to parent
6739    * widgets that may also be drop sites.
6740    */
6741   return TRUE;
6742 }
6743
6744 static gboolean
6745 gtk_text_view_drag_drop (GtkWidget        *widget,
6746                          GdkDragContext   *context,
6747                          gint              x,
6748                          gint              y,
6749                          guint             time)
6750 {
6751   GtkTextView *text_view;
6752   GtkTextIter drop_point;
6753   GdkAtom target = GDK_NONE;
6754
6755   text_view = GTK_TEXT_VIEW (widget);
6756
6757   if (text_view->scroll_timeout != 0)
6758     g_source_remove (text_view->scroll_timeout);
6759
6760   text_view->scroll_timeout = 0;
6761
6762   gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
6763
6764   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
6765                                     &drop_point,
6766                                     text_view->dnd_mark);
6767
6768   if (gtk_text_iter_can_insert (&drop_point, text_view->editable))
6769     target = gtk_drag_dest_find_target (widget, context, NULL);
6770
6771   if (target != GDK_NONE)
6772     gtk_drag_get_data (widget, context, target, time);
6773   else
6774     gtk_drag_finish (context, FALSE, FALSE, time);
6775
6776   return TRUE;
6777 }
6778
6779 static void
6780 insert_text_data (GtkTextView      *text_view,
6781                   GtkTextIter      *drop_point,
6782                   GtkSelectionData *selection_data)
6783 {
6784   guchar *str;
6785
6786   str = gtk_selection_data_get_text (selection_data);
6787
6788   if (str)
6789     {
6790       if (!gtk_text_buffer_insert_interactive (get_buffer (text_view),
6791                                                drop_point, (gchar *) str, -1,
6792                                                text_view->editable))
6793         {
6794           gtk_widget_error_bell (GTK_WIDGET (text_view));
6795         }
6796
6797       g_free (str);
6798     }
6799 }
6800
6801 static void
6802 gtk_text_view_drag_data_received (GtkWidget        *widget,
6803                                   GdkDragContext   *context,
6804                                   gint              x,
6805                                   gint              y,
6806                                   GtkSelectionData *selection_data,
6807                                   guint             info,
6808                                   guint             time)
6809 {
6810   GtkTextIter drop_point;
6811   GtkTextView *text_view;
6812   gboolean success = FALSE;
6813   GtkTextBuffer *buffer = NULL;
6814
6815   text_view = GTK_TEXT_VIEW (widget);
6816
6817   if (!text_view->dnd_mark)
6818     goto done;
6819
6820   buffer = get_buffer (text_view);
6821
6822   gtk_text_buffer_get_iter_at_mark (buffer,
6823                                     &drop_point,
6824                                     text_view->dnd_mark);
6825
6826   if (!gtk_text_iter_can_insert (&drop_point, text_view->editable))
6827     goto done;
6828
6829   success = TRUE;
6830
6831   gtk_text_buffer_begin_user_action (buffer);
6832
6833   if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
6834     {
6835       GtkTextBuffer *src_buffer = NULL;
6836       GtkTextIter start, end;
6837       gboolean copy_tags = TRUE;
6838
6839       if (selection_data->length != sizeof (src_buffer))
6840         return;
6841
6842       memcpy (&src_buffer, selection_data->data, sizeof (src_buffer));
6843
6844       if (src_buffer == NULL)
6845         return;
6846
6847       g_return_if_fail (GTK_IS_TEXT_BUFFER (src_buffer));
6848
6849       if (gtk_text_buffer_get_tag_table (src_buffer) !=
6850           gtk_text_buffer_get_tag_table (buffer))
6851         {
6852           /*  try to find a suitable rich text target instead  */
6853           GdkAtom *atoms;
6854           gint     n_atoms;
6855           GList   *list;
6856           GdkAtom  target = GDK_NONE;
6857
6858           copy_tags = FALSE;
6859
6860           atoms = gtk_text_buffer_get_deserialize_formats (buffer, &n_atoms);
6861
6862           for (list = context->targets; list; list = g_list_next (list))
6863             {
6864               gint i;
6865
6866               for (i = 0; i < n_atoms; i++)
6867                 if (GUINT_TO_POINTER (atoms[i]) == list->data)
6868                   {
6869                     target = atoms[i];
6870                     break;
6871                   }
6872             }
6873
6874           g_free (atoms);
6875
6876           if (target != GDK_NONE)
6877             {
6878               gtk_drag_get_data (widget, context, target, time);
6879               gtk_text_buffer_end_user_action (buffer);
6880               return;
6881             }
6882         }
6883
6884       if (gtk_text_buffer_get_selection_bounds (src_buffer,
6885                                                 &start,
6886                                                 &end))
6887         {
6888           if (copy_tags)
6889             gtk_text_buffer_insert_range_interactive (buffer,
6890                                                       &drop_point,
6891                                                       &start,
6892                                                       &end,
6893                                                       text_view->editable);
6894           else
6895             {
6896               gchar *str;
6897
6898               str = gtk_text_iter_get_visible_text (&start, &end);
6899               gtk_text_buffer_insert_interactive (buffer,
6900                                                   &drop_point, str, -1,
6901                                                   text_view->editable);
6902               g_free (str);
6903             }
6904         }
6905     }
6906   else if (selection_data->length > 0 &&
6907            info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
6908     {
6909       gboolean retval;
6910       GError *error = NULL;
6911
6912       retval = gtk_text_buffer_deserialize (buffer, buffer,
6913                                             selection_data->target,
6914                                             &drop_point,
6915                                             (guint8 *) selection_data->data,
6916                                             selection_data->length,
6917                                             &error);
6918
6919       if (!retval)
6920         {
6921           g_warning ("error pasting: %s\n", error->message);
6922           g_clear_error (&error);
6923         }
6924     }
6925   else
6926     insert_text_data (text_view, &drop_point, selection_data);
6927
6928  done:
6929   gtk_drag_finish (context, success,
6930                    success && context->action == GDK_ACTION_MOVE,
6931                    time);
6932
6933   if (success)
6934     {
6935       gtk_text_buffer_get_iter_at_mark (buffer,
6936                                         &drop_point,
6937                                         text_view->dnd_mark);
6938       gtk_text_buffer_place_cursor (buffer, &drop_point);
6939
6940       gtk_text_buffer_end_user_action (buffer);
6941     }
6942 }
6943
6944 static GtkAdjustment*
6945 get_hadjustment (GtkTextView *text_view)
6946 {
6947   if (text_view->hadjustment == NULL)
6948     gtk_text_view_set_scroll_adjustments (text_view,
6949                                           NULL, /* forces creation */
6950                                           text_view->vadjustment);
6951
6952   return text_view->hadjustment;
6953 }
6954
6955 static GtkAdjustment*
6956 get_vadjustment (GtkTextView *text_view)
6957 {
6958   if (text_view->vadjustment == NULL)
6959     gtk_text_view_set_scroll_adjustments (text_view,
6960                                           text_view->hadjustment,
6961                                           NULL); /* forces creation */
6962   return text_view->vadjustment;
6963 }
6964
6965
6966 static void
6967 gtk_text_view_set_scroll_adjustments (GtkTextView   *text_view,
6968                                       GtkAdjustment *hadj,
6969                                       GtkAdjustment *vadj)
6970 {
6971   gboolean need_adjust = FALSE;
6972
6973   if (hadj)
6974     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
6975   else
6976     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
6977   if (vadj)
6978     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
6979   else
6980     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
6981
6982   if (text_view->hadjustment && (text_view->hadjustment != hadj))
6983     {
6984       g_signal_handlers_disconnect_by_func (text_view->hadjustment,
6985                                             gtk_text_view_value_changed,
6986                                             text_view);
6987       g_object_unref (text_view->hadjustment);
6988     }
6989
6990   if (text_view->vadjustment && (text_view->vadjustment != vadj))
6991     {
6992       g_signal_handlers_disconnect_by_func (text_view->vadjustment,
6993                                             gtk_text_view_value_changed,
6994                                             text_view);
6995       g_object_unref (text_view->vadjustment);
6996     }
6997
6998   if (text_view->hadjustment != hadj)
6999     {
7000       text_view->hadjustment = hadj;
7001       g_object_ref_sink (text_view->hadjustment);
7002
7003       g_signal_connect (text_view->hadjustment, "value-changed",
7004                         G_CALLBACK (gtk_text_view_value_changed),
7005                         text_view);
7006       need_adjust = TRUE;
7007     }
7008
7009   if (text_view->vadjustment != vadj)
7010     {
7011       text_view->vadjustment = vadj;
7012       g_object_ref_sink (text_view->vadjustment);
7013
7014       g_signal_connect (text_view->vadjustment, "value-changed",
7015                         G_CALLBACK (gtk_text_view_value_changed),
7016                         text_view);
7017       need_adjust = TRUE;
7018     }
7019
7020   if (need_adjust)
7021     gtk_text_view_value_changed (NULL, text_view);
7022 }
7023
7024 /* FIXME this adjust_allocation is a big cut-and-paste from
7025  * GtkCList, needs to be some "official" way to do this
7026  * factored out.
7027  */
7028 typedef struct
7029 {
7030   GdkWindow *window;
7031   int dx;
7032   int dy;
7033 } ScrollData;
7034
7035 /* The window to which widget->window is relative */
7036 #define ALLOCATION_WINDOW(widget)               \
7037    (GTK_WIDGET_NO_WINDOW (widget) ?             \
7038     (widget)->window :                          \
7039      gdk_window_get_parent ((widget)->window))
7040
7041 static void
7042 adjust_allocation_recurse (GtkWidget *widget,
7043                            gpointer   data)
7044 {
7045   ScrollData *scroll_data = data;
7046
7047   /* Need to really size allocate instead of just poking
7048    * into widget->allocation if the widget is not realized.
7049    * FIXME someone figure out why this was.
7050    */
7051   if (!GTK_WIDGET_REALIZED (widget))
7052     {
7053       if (GTK_WIDGET_VISIBLE (widget))
7054         {
7055           GdkRectangle tmp_rectangle = widget->allocation;
7056           tmp_rectangle.x += scroll_data->dx;
7057           tmp_rectangle.y += scroll_data->dy;
7058
7059           gtk_widget_size_allocate (widget, &tmp_rectangle);
7060         }
7061     }
7062   else
7063     {
7064       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
7065         {
7066           widget->allocation.x += scroll_data->dx;
7067           widget->allocation.y += scroll_data->dy;
7068
7069           if (GTK_IS_CONTAINER (widget))
7070             gtk_container_forall (GTK_CONTAINER (widget),
7071                                   adjust_allocation_recurse,
7072                                   data);
7073         }
7074     }
7075 }
7076
7077 static void
7078 adjust_allocation (GtkWidget *widget,
7079                    int        dx,
7080                    int        dy)
7081 {
7082   ScrollData scroll_data;
7083
7084   if (GTK_WIDGET_REALIZED (widget))
7085     scroll_data.window = ALLOCATION_WINDOW (widget);
7086   else
7087     scroll_data.window = NULL;
7088
7089   scroll_data.dx = dx;
7090   scroll_data.dy = dy;
7091
7092   adjust_allocation_recurse (widget, &scroll_data);
7093 }
7094
7095 static void
7096 gtk_text_view_value_changed (GtkAdjustment *adj,
7097                              GtkTextView   *text_view)
7098 {
7099   GtkTextIter iter;
7100   gint line_top;
7101   gint dx = 0;
7102   gint dy = 0;
7103
7104   /* Note that we oddly call this function with adj == NULL
7105    * sometimes
7106    */
7107
7108   text_view->onscreen_validated = FALSE;
7109
7110   DV(g_print(">Scroll offset changed %s/%g, onscreen_validated = FALSE ("G_STRLOC")\n",
7111              adj == text_view->hadjustment ? "hadj" : adj == text_view->vadjustment ? "vadj" : "none",
7112              adj ? adj->value : 0.0));
7113
7114   if (adj == text_view->hadjustment)
7115     {
7116       dx = text_view->xoffset - (gint)adj->value;
7117       text_view->xoffset = adj->value;
7118
7119       /* If the change is due to a size change we need
7120        * to invalidate the entire text window because there might be
7121        * right-aligned or centered text
7122        */
7123       if (text_view->width_changed)
7124         {
7125           if (GTK_WIDGET_REALIZED (text_view))
7126             gdk_window_invalidate_rect (text_view->text_window->bin_window, NULL, FALSE);
7127
7128           text_view->width_changed = FALSE;
7129         }
7130     }
7131   else if (adj == text_view->vadjustment)
7132     {
7133       dy = text_view->yoffset - (gint)adj->value;
7134       text_view->yoffset = adj->value;
7135
7136       if (text_view->layout)
7137         {
7138           gtk_text_layout_get_line_at_y (text_view->layout, &iter, adj->value, &line_top);
7139
7140           gtk_text_buffer_move_mark (get_buffer (text_view), text_view->first_para_mark, &iter);
7141
7142           text_view->first_para_pixels = adj->value - line_top;
7143         }
7144     }
7145
7146   if (dx != 0 || dy != 0)
7147     {
7148       GSList *tmp_list;
7149
7150       if (GTK_WIDGET_REALIZED (text_view))
7151         {
7152           if (dy != 0)
7153             {
7154               if (text_view->left_window)
7155                 text_window_scroll (text_view->left_window, 0, dy);
7156               if (text_view->right_window)
7157                 text_window_scroll (text_view->right_window, 0, dy);
7158             }
7159
7160           if (dx != 0)
7161             {
7162               if (text_view->top_window)
7163                 text_window_scroll (text_view->top_window, dx, 0);
7164               if (text_view->bottom_window)
7165                 text_window_scroll (text_view->bottom_window, dx, 0);
7166             }
7167
7168           /* It looks nicer to scroll the main area last, because
7169            * it takes a while, and making the side areas update
7170            * afterward emphasizes the slowness of scrolling the
7171            * main area.
7172            */
7173           text_window_scroll (text_view->text_window, dx, dy);
7174         }
7175
7176       /* Children are now "moved" in the text window, poke
7177        * into widget->allocation for each child
7178        */
7179       tmp_list = text_view->children;
7180       while (tmp_list != NULL)
7181         {
7182           GtkTextViewChild *child = tmp_list->data;
7183
7184           if (child->anchor)
7185             adjust_allocation (child->widget, dx, dy);
7186
7187           tmp_list = g_slist_next (tmp_list);
7188         }
7189     }
7190
7191   /* This could result in invalidation, which would install the
7192    * first_validate_idle, which would validate onscreen;
7193    * but we're going to go ahead and validate here, so
7194    * first_validate_idle shouldn't have anything to do.
7195    */
7196   gtk_text_view_update_layout_width (text_view);
7197
7198   /* note that validation of onscreen could invoke this function
7199    * recursively, by scrolling to maintain first_para, or in response
7200    * to updating the layout width, however there is no problem with
7201    * that, or shouldn't be.
7202    */
7203   gtk_text_view_validate_onscreen (text_view);
7204
7205   /* process exposes */
7206   if (GTK_WIDGET_REALIZED (text_view))
7207     {
7208       DV (g_print ("Processing updates (%s)\n", G_STRLOC));
7209
7210       if (text_view->left_window)
7211         gdk_window_process_updates (text_view->left_window->bin_window, TRUE);
7212
7213       if (text_view->right_window)
7214         gdk_window_process_updates (text_view->right_window->bin_window, TRUE);
7215
7216       if (text_view->top_window)
7217         gdk_window_process_updates (text_view->top_window->bin_window, TRUE);
7218
7219       if (text_view->bottom_window)
7220         gdk_window_process_updates (text_view->bottom_window->bin_window, TRUE);
7221
7222       gdk_window_process_updates (text_view->text_window->bin_window, TRUE);
7223     }
7224
7225   /* If this got installed, get rid of it, it's just a waste of time. */
7226   if (text_view->first_validate_idle != 0)
7227     {
7228       g_source_remove (text_view->first_validate_idle);
7229       text_view->first_validate_idle = 0;
7230     }
7231
7232   gtk_text_view_update_im_spot_location (text_view);
7233
7234   DV(g_print(">End scroll offset changed handler ("G_STRLOC")\n"));
7235 }
7236
7237 static void
7238 gtk_text_view_commit_handler (GtkIMContext  *context,
7239                               const gchar   *str,
7240                               GtkTextView   *text_view)
7241 {
7242   gtk_text_view_commit_text (text_view, str);
7243 }
7244
7245 static void
7246 gtk_text_view_commit_text (GtkTextView   *text_view,
7247                            const gchar   *str)
7248 {
7249   gboolean had_selection;
7250
7251   gtk_text_buffer_begin_user_action (get_buffer (text_view));
7252
7253   had_selection = gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
7254                                                         NULL, NULL);
7255
7256   gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
7257                                     text_view->editable);
7258
7259   if (!strcmp (str, "\n"))
7260     {
7261       if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), "\n", 1,
7262                                                          text_view->editable))
7263         {
7264           gtk_widget_error_bell (GTK_WIDGET (text_view));
7265         }
7266     }
7267   else
7268     {
7269       if (!had_selection && text_view->overwrite_mode)
7270         {
7271           GtkTextIter insert;
7272
7273           gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
7274                                             &insert,
7275                                             gtk_text_buffer_get_insert (get_buffer (text_view)));
7276           if (!gtk_text_iter_ends_line (&insert))
7277             gtk_text_view_delete_from_cursor (text_view, GTK_DELETE_CHARS, 1);
7278         }
7279
7280       if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1,
7281                                                          text_view->editable))
7282         {
7283           gtk_widget_error_bell (GTK_WIDGET (text_view));
7284         }
7285     }
7286
7287   gtk_text_buffer_end_user_action (get_buffer (text_view));
7288
7289   gtk_text_view_set_virtual_cursor_pos (text_view, -1, -1);
7290   DV(g_print (G_STRLOC": scrolling onscreen\n"));
7291   gtk_text_view_scroll_mark_onscreen (text_view,
7292                                       gtk_text_buffer_get_insert (get_buffer (text_view)));
7293 }
7294
7295 static void
7296 gtk_text_view_preedit_changed_handler (GtkIMContext *context,
7297                                        GtkTextView  *text_view)
7298 {
7299   gchar *str;
7300   PangoAttrList *attrs;
7301   gint cursor_pos;
7302   GtkTextIter iter;
7303
7304   gtk_text_buffer_get_iter_at_mark (text_view->buffer, &iter,
7305                                     gtk_text_buffer_get_insert (text_view->buffer));
7306
7307   /* Keypress events are passed to input method even if cursor position is
7308    * not editable; so beep here if it's multi-key input sequence, input
7309    * method will be reset in key-press-event handler.
7310    */
7311   gtk_im_context_get_preedit_string (context, &str, &attrs, &cursor_pos);
7312
7313   if (str && str[0] && !gtk_text_iter_can_insert (&iter, text_view->editable))
7314     {
7315       gtk_widget_error_bell (GTK_WIDGET (text_view));
7316       goto out;
7317     }
7318
7319   if (text_view->layout)
7320     gtk_text_layout_set_preedit_string (text_view->layout, str, attrs, cursor_pos);
7321   if (GTK_WIDGET_HAS_FOCUS (text_view))
7322     gtk_text_view_scroll_mark_onscreen (text_view,
7323                                         gtk_text_buffer_get_insert (get_buffer (text_view)));
7324
7325 out:
7326   pango_attr_list_unref (attrs);
7327   g_free (str);
7328 }
7329
7330 static gboolean
7331 gtk_text_view_retrieve_surrounding_handler (GtkIMContext  *context,
7332                                             GtkTextView   *text_view)
7333 {
7334   GtkTextIter start;
7335   GtkTextIter end;
7336   gint pos;
7337   gchar *text;
7338
7339   gtk_text_buffer_get_iter_at_mark (text_view->buffer, &start,
7340                                     gtk_text_buffer_get_insert (text_view->buffer));
7341   end = start;
7342
7343   pos = gtk_text_iter_get_line_index (&start);
7344   gtk_text_iter_set_line_offset (&start, 0);
7345   gtk_text_iter_forward_to_line_end (&end);
7346
7347   text = gtk_text_iter_get_slice (&start, &end);
7348   gtk_im_context_set_surrounding (context, text, -1, pos);
7349   g_free (text);
7350
7351   return TRUE;
7352 }
7353
7354 static gboolean
7355 gtk_text_view_delete_surrounding_handler (GtkIMContext  *context,
7356                                           gint           offset,
7357                                           gint           n_chars,
7358                                           GtkTextView   *text_view)
7359 {
7360   GtkTextIter start;
7361   GtkTextIter end;
7362
7363   gtk_text_buffer_get_iter_at_mark (text_view->buffer, &start,
7364                                     gtk_text_buffer_get_insert (text_view->buffer));
7365   end = start;
7366
7367   gtk_text_iter_forward_chars (&start, offset);
7368   gtk_text_iter_forward_chars (&end, offset + n_chars);
7369
7370   gtk_text_buffer_delete_interactive (text_view->buffer, &start, &end,
7371                                       text_view->editable);
7372
7373   return TRUE;
7374 }
7375
7376 static void
7377 gtk_text_view_mark_set_handler (GtkTextBuffer     *buffer,
7378                                 const GtkTextIter *location,
7379                                 GtkTextMark       *mark,
7380                                 gpointer           data)
7381 {
7382   GtkTextView *text_view = GTK_TEXT_VIEW (data);
7383   gboolean need_reset = FALSE;
7384
7385   if (mark == gtk_text_buffer_get_insert (buffer))
7386     {
7387       text_view->virtual_cursor_x = -1;
7388       text_view->virtual_cursor_y = -1;
7389       gtk_text_view_update_im_spot_location (text_view);
7390       need_reset = TRUE;
7391     }
7392   else if (mark == gtk_text_buffer_get_selection_bound (buffer))
7393     {
7394       need_reset = TRUE;
7395     }
7396
7397   if (need_reset)
7398     gtk_text_view_reset_im_context (text_view);
7399 }
7400
7401 static void
7402 gtk_text_view_target_list_notify (GtkTextBuffer    *buffer,
7403                                   const GParamSpec *pspec,
7404                                   gpointer          data)
7405 {
7406   GtkWidget     *widget = GTK_WIDGET (data);
7407   GtkTargetList *view_list;
7408   GtkTargetList *buffer_list;
7409   GList         *list;
7410
7411   view_list = gtk_drag_dest_get_target_list (widget);
7412   buffer_list = gtk_text_buffer_get_paste_target_list (buffer);
7413
7414   if (view_list)
7415     gtk_target_list_ref (view_list);
7416   else
7417     view_list = gtk_target_list_new (NULL, 0);
7418
7419   list = view_list->list;
7420   while (list)
7421     {
7422       GtkTargetPair *pair = list->data;
7423
7424       list = g_list_next (list); /* get next element before removing */
7425
7426       if (pair->info >= GTK_TEXT_BUFFER_TARGET_INFO_TEXT &&
7427           pair->info <= GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
7428         {
7429           gtk_target_list_remove (view_list, pair->target);
7430         }
7431     }
7432
7433   for (list = buffer_list->list; list; list = g_list_next (list))
7434     {
7435       GtkTargetPair *pair = list->data;
7436
7437       gtk_target_list_add (view_list, pair->target, pair->flags, pair->info);
7438     }
7439
7440   gtk_drag_dest_set_target_list (widget, view_list);
7441   gtk_target_list_unref (view_list);
7442 }
7443
7444 static void
7445 gtk_text_view_get_cursor_location  (GtkTextView   *text_view,
7446                                     GdkRectangle  *pos)
7447 {
7448   GtkTextIter insert;
7449
7450   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
7451                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
7452
7453   gtk_text_layout_get_cursor_locations (text_view->layout, &insert, pos, NULL);
7454 }
7455
7456 static void
7457 gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view,
7458                                       gint        *x,
7459                                       gint        *y)
7460 {
7461   GdkRectangle pos;
7462
7463   if ((x && text_view->virtual_cursor_x == -1) ||
7464       (y && text_view->virtual_cursor_y == -1))
7465     gtk_text_view_get_cursor_location (text_view, &pos);
7466
7467   if (x)
7468     {
7469       if (text_view->virtual_cursor_x != -1)
7470         *x = text_view->virtual_cursor_x;
7471       else
7472         *x = pos.x;
7473     }
7474
7475   if (y)
7476     {
7477       if (text_view->virtual_cursor_x != -1)
7478         *y = text_view->virtual_cursor_y;
7479       else
7480         *y = pos.y + pos.height / 2;
7481     }
7482 }
7483
7484 static void
7485 gtk_text_view_set_virtual_cursor_pos (GtkTextView *text_view,
7486                                       gint         x,
7487                                       gint         y)
7488 {
7489   GdkRectangle pos;
7490
7491   if (!text_view->layout)
7492     return;
7493
7494   if (x == -1 || y == -1)
7495     gtk_text_view_get_cursor_location (text_view, &pos);
7496
7497   text_view->virtual_cursor_x = (x == -1) ? pos.x : x;
7498   text_view->virtual_cursor_y = (y == -1) ? pos.y + pos.height / 2 : y;
7499 }
7500
7501 /* Quick hack of a popup menu
7502  */
7503 static void
7504 activate_cb (GtkWidget   *menuitem,
7505              GtkTextView *text_view)
7506 {
7507   const gchar *signal = g_object_get_data (G_OBJECT (menuitem), "gtk-signal");
7508   g_signal_emit_by_name (text_view, signal);
7509 }
7510
7511 static void
7512 append_action_signal (GtkTextView  *text_view,
7513                       GtkWidget    *menu,
7514                       const gchar  *stock_id,
7515                       const gchar  *signal,
7516                       gboolean      sensitive)
7517 {
7518   GtkWidget *menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
7519
7520   g_object_set_data (G_OBJECT (menuitem), I_("gtk-signal"), (char *)signal);
7521   g_signal_connect (menuitem, "activate",
7522                     G_CALLBACK (activate_cb), text_view);
7523
7524   gtk_widget_set_sensitive (menuitem, sensitive);
7525
7526   gtk_widget_show (menuitem);
7527   gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
7528 }
7529
7530 static void
7531 gtk_text_view_select_all (GtkWidget *widget,
7532                           gboolean select)
7533 {
7534   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
7535   GtkTextBuffer *buffer;
7536   GtkTextIter start_iter, end_iter, insert;
7537
7538   buffer = text_view->buffer;
7539   if (select)
7540     {
7541       gtk_text_buffer_get_bounds (buffer, &start_iter, &end_iter);
7542       gtk_text_buffer_select_range (buffer, &start_iter, &end_iter);
7543     }
7544   else
7545     {
7546       gtk_text_buffer_get_iter_at_mark (buffer, &insert,
7547                                         gtk_text_buffer_get_insert (buffer));
7548       gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &insert);
7549     }
7550 }
7551
7552 static void
7553 select_all_cb (GtkWidget   *menuitem,
7554                GtkTextView *text_view)
7555 {
7556   gtk_text_view_select_all (GTK_WIDGET (text_view), TRUE);
7557 }
7558
7559 static void
7560 delete_cb (GtkTextView *text_view)
7561 {
7562   gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
7563                                     text_view->editable);
7564 }
7565
7566 static void
7567 popup_menu_detach (GtkWidget *attach_widget,
7568                    GtkMenu   *menu)
7569 {
7570   GTK_TEXT_VIEW (attach_widget)->popup_menu = NULL;
7571 }
7572
7573 static void
7574 popup_position_func (GtkMenu   *menu,
7575                      gint      *x,
7576                      gint      *y,
7577                      gboolean  *push_in,
7578                      gpointer   user_data)
7579 {
7580   GtkTextView *text_view;
7581   GtkWidget *widget;
7582   GdkRectangle cursor_rect;
7583   GdkRectangle onscreen_rect;
7584   gint root_x, root_y;
7585   GtkTextIter iter;
7586   GtkRequisition req;
7587   GdkScreen *screen;
7588   gint monitor_num;
7589   GdkRectangle monitor;
7590
7591   text_view = GTK_TEXT_VIEW (user_data);
7592   widget = GTK_WIDGET (text_view);
7593
7594   g_return_if_fail (GTK_WIDGET_REALIZED (text_view));
7595
7596   screen = gtk_widget_get_screen (widget);
7597
7598   gdk_window_get_origin (widget->window, &root_x, &root_y);
7599
7600   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
7601                                     &iter,
7602                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
7603
7604   gtk_text_view_get_iter_location (text_view,
7605                                    &iter,
7606                                    &cursor_rect);
7607
7608   gtk_text_view_get_visible_rect (text_view, &onscreen_rect);
7609
7610   gtk_widget_size_request (text_view->popup_menu, &req);
7611
7612   /* can't use rectangle_intersect since cursor rect can have 0 width */
7613   if (cursor_rect.x >= onscreen_rect.x &&
7614       cursor_rect.x < onscreen_rect.x + onscreen_rect.width &&
7615       cursor_rect.y >= onscreen_rect.y &&
7616       cursor_rect.y < onscreen_rect.y + onscreen_rect.height)
7617     {
7618       gtk_text_view_buffer_to_window_coords (text_view,
7619                                              GTK_TEXT_WINDOW_WIDGET,
7620                                              cursor_rect.x, cursor_rect.y,
7621                                              &cursor_rect.x, &cursor_rect.y);
7622
7623       *x = root_x + cursor_rect.x + cursor_rect.width;
7624       *y = root_y + cursor_rect.y + cursor_rect.height;
7625     }
7626   else
7627     {
7628       /* Just center the menu, since cursor is offscreen. */
7629       *x = root_x + (widget->allocation.width / 2 - req.width / 2);
7630       *y = root_y + (widget->allocation.height / 2 - req.height / 2);
7631     }
7632
7633   /* Ensure sanity */
7634   *x = CLAMP (*x, root_x, (root_x + widget->allocation.width));
7635   *y = CLAMP (*y, root_y, (root_y + widget->allocation.height));
7636
7637   monitor_num = gdk_screen_get_monitor_at_point (screen, *x, *y);
7638   gtk_menu_set_monitor (menu, monitor_num);
7639   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
7640
7641   *x = CLAMP (*x, monitor.x, monitor.x + MAX (0, monitor.width - req.width));
7642   *y = CLAMP (*y, monitor.y, monitor.y + MAX (0, monitor.height - req.height));
7643
7644   *push_in = FALSE;
7645 }
7646
7647 typedef struct
7648 {
7649   GtkTextView *text_view;
7650   gint button;
7651   guint time;
7652 } PopupInfo;
7653
7654 static gboolean
7655 range_contains_editable_text (const GtkTextIter *start,
7656                               const GtkTextIter *end,
7657                               gboolean default_editability)
7658 {
7659   GtkTextIter iter = *start;
7660
7661   while (gtk_text_iter_compare (&iter, end) < 0)
7662     {
7663       if (gtk_text_iter_editable (&iter, default_editability))
7664         return TRUE;
7665
7666       gtk_text_iter_forward_to_tag_toggle (&iter, NULL);
7667     }
7668
7669   return FALSE;
7670 }
7671
7672 static void
7673 unichar_chosen_func (const char *text,
7674                      gpointer    data)
7675 {
7676   GtkTextView *text_view = GTK_TEXT_VIEW (data);
7677
7678   gtk_text_view_commit_text (text_view, text);
7679 }
7680
7681 static void
7682 popup_targets_received (GtkClipboard     *clipboard,
7683                         GtkSelectionData *data,
7684                         gpointer          user_data)
7685 {
7686   PopupInfo *info = user_data;
7687   GtkTextView *text_view = info->text_view;
7688
7689   if (GTK_WIDGET_REALIZED (text_view))
7690     {
7691       /* We implicitely rely here on the fact that if we are pasting ourself, we'll
7692        * have text targets as well as the private GTK_TEXT_BUFFER_CONTENTS target.
7693        */
7694       gboolean clipboard_contains_text;
7695       GtkWidget *menuitem;
7696       GtkWidget *submenu;
7697       gboolean have_selection;
7698       gboolean can_insert;
7699       GtkTextIter iter;
7700       GtkTextIter sel_start, sel_end;
7701       gboolean show_input_method_menu;
7702       gboolean show_unicode_menu;
7703
7704       clipboard_contains_text = gtk_selection_data_targets_include_text (data);
7705
7706       if (text_view->popup_menu)
7707         gtk_widget_destroy (text_view->popup_menu);
7708
7709       text_view->popup_menu = gtk_menu_new ();
7710
7711       gtk_menu_attach_to_widget (GTK_MENU (text_view->popup_menu),
7712                                  GTK_WIDGET (text_view),
7713                                  popup_menu_detach);
7714
7715       have_selection = gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
7716                                                              &sel_start, &sel_end);
7717
7718       gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
7719                                         &iter,
7720                                         gtk_text_buffer_get_insert (get_buffer (text_view)));
7721
7722       can_insert = gtk_text_iter_can_insert (&iter, text_view->editable);
7723
7724       append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_CUT, "cut-clipboard",
7725                             have_selection &&
7726                             range_contains_editable_text (&sel_start, &sel_end,
7727                                                           text_view->editable));
7728       append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_COPY, "copy-clipboard",
7729                             have_selection);
7730       append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_PASTE, "paste-clipboard",
7731                             can_insert && clipboard_contains_text);
7732
7733       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE, NULL);
7734       gtk_widget_set_sensitive (menuitem,
7735                                 have_selection &&
7736                                 range_contains_editable_text (&sel_start, &sel_end,
7737                                                               text_view->editable));
7738       g_signal_connect_swapped (menuitem, "activate",
7739                                 G_CALLBACK (delete_cb), text_view);
7740       gtk_widget_show (menuitem);
7741       gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7742
7743       menuitem = gtk_separator_menu_item_new ();
7744       gtk_widget_show (menuitem);
7745       gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7746
7747       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_SELECT_ALL, NULL);
7748       g_signal_connect (menuitem, "activate",
7749                         G_CALLBACK (select_all_cb), text_view);
7750       gtk_widget_show (menuitem);
7751       gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7752
7753       g_object_get (gtk_widget_get_settings (GTK_WIDGET (text_view)),
7754                     "gtk-show-input-method-menu", &show_input_method_menu,
7755                     "gtk-show-unicode-menu", &show_unicode_menu,
7756                     NULL);
7757
7758       if (show_input_method_menu || show_unicode_menu)
7759         {
7760           menuitem = gtk_separator_menu_item_new ();
7761           gtk_widget_show (menuitem);
7762           gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7763         }
7764
7765       if (show_input_method_menu)
7766         {
7767           menuitem = gtk_menu_item_new_with_mnemonic (_("Input _Methods"));
7768           gtk_widget_show (menuitem);
7769           gtk_widget_set_sensitive (menuitem, can_insert);
7770
7771           submenu = gtk_menu_new ();
7772           gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
7773           gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7774
7775           gtk_im_multicontext_append_menuitems (GTK_IM_MULTICONTEXT (text_view->im_context),
7776                                                 GTK_MENU_SHELL (submenu));
7777         }
7778
7779       if (show_unicode_menu)
7780         {
7781           menuitem = gtk_menu_item_new_with_mnemonic (_("_Insert Unicode Control Character"));
7782           gtk_widget_show (menuitem);
7783           gtk_widget_set_sensitive (menuitem, can_insert);
7784
7785           submenu = gtk_menu_new ();
7786           gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
7787           gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7788
7789           _gtk_text_util_append_special_char_menuitems (GTK_MENU_SHELL (submenu),
7790                                                         unichar_chosen_func,
7791                                                         text_view);
7792         }
7793
7794       g_signal_emit (text_view,
7795                      signals[POPULATE_POPUP],
7796                      0,
7797                      text_view->popup_menu);
7798
7799       if (info->button)
7800         gtk_menu_popup (GTK_MENU (text_view->popup_menu), NULL, NULL,
7801                         NULL, NULL,
7802                         info->button, info->time);
7803       else
7804         {
7805           gtk_menu_popup (GTK_MENU (text_view->popup_menu), NULL, NULL,
7806                           popup_position_func, text_view,
7807                           0, gtk_get_current_event_time ());
7808           gtk_menu_shell_select_first (GTK_MENU_SHELL (text_view->popup_menu), FALSE);
7809         }
7810     }
7811
7812   g_object_unref (text_view);
7813   g_free (info);
7814 }
7815
7816 static void
7817 gtk_text_view_do_popup (GtkTextView    *text_view,
7818                         GdkEventButton *event)
7819 {
7820   PopupInfo *info = g_new (PopupInfo, 1);
7821
7822   /* In order to know what entries we should make sensitive, we
7823    * ask for the current targets of the clipboard, and when
7824    * we get them, then we actually pop up the menu.
7825    */
7826   info->text_view = g_object_ref (text_view);
7827
7828   if (event)
7829     {
7830       info->button = event->button;
7831       info->time = event->time;
7832     }
7833   else
7834     {
7835       info->button = 0;
7836       info->time = gtk_get_current_event_time ();
7837     }
7838
7839   gtk_clipboard_request_contents (gtk_widget_get_clipboard (GTK_WIDGET (text_view),
7840                                                             GDK_SELECTION_CLIPBOARD),
7841                                   gdk_atom_intern_static_string ("TARGETS"),
7842                                   popup_targets_received,
7843                                   info);
7844 }
7845
7846 static gboolean
7847 gtk_text_view_popup_menu (GtkWidget *widget)
7848 {
7849   gtk_text_view_do_popup (GTK_TEXT_VIEW (widget), NULL);
7850   return TRUE;
7851 }
7852
7853 /* Child GdkWindows */
7854
7855
7856 static GtkTextWindow*
7857 text_window_new (GtkTextWindowType  type,
7858                  GtkWidget         *widget,
7859                  gint               width_request,
7860                  gint               height_request)
7861 {
7862   GtkTextWindow *win;
7863
7864   win = g_new (GtkTextWindow, 1);
7865
7866   win->type = type;
7867   win->widget = widget;
7868   win->window = NULL;
7869   win->bin_window = NULL;
7870   win->requisition.width = width_request;
7871   win->requisition.height = height_request;
7872   win->allocation.width = width_request;
7873   win->allocation.height = height_request;
7874   win->allocation.x = 0;
7875   win->allocation.y = 0;
7876
7877   return win;
7878 }
7879
7880 static void
7881 text_window_free (GtkTextWindow *win)
7882 {
7883   if (win->window)
7884     text_window_unrealize (win);
7885
7886   g_free (win);
7887 }
7888
7889 static void
7890 text_window_realize (GtkTextWindow *win,
7891                      GtkWidget     *widget)
7892 {
7893   GdkWindowAttr attributes;
7894   gint attributes_mask;
7895   GdkCursor *cursor;
7896
7897   attributes.window_type = GDK_WINDOW_CHILD;
7898   attributes.x = win->allocation.x;
7899   attributes.y = win->allocation.y;
7900   attributes.width = win->allocation.width;
7901   attributes.height = win->allocation.height;
7902   attributes.wclass = GDK_INPUT_OUTPUT;
7903   attributes.visual = gtk_widget_get_visual (win->widget);
7904   attributes.colormap = gtk_widget_get_colormap (win->widget);
7905   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
7906
7907   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
7908
7909   win->window = gdk_window_new (widget->window,
7910                                 &attributes,
7911                                 attributes_mask);
7912
7913   gdk_window_set_back_pixmap (win->window, NULL, FALSE);
7914
7915   gdk_window_show (win->window);
7916   gdk_window_set_user_data (win->window, win->widget);
7917   gdk_window_lower (win->window);
7918
7919   attributes.x = 0;
7920   attributes.y = 0;
7921   attributes.width = win->allocation.width;
7922   attributes.height = win->allocation.height;
7923   attributes.event_mask = (GDK_EXPOSURE_MASK            |
7924                            GDK_SCROLL_MASK              |
7925                            GDK_KEY_PRESS_MASK           |
7926                            GDK_BUTTON_PRESS_MASK        |
7927                            GDK_BUTTON_RELEASE_MASK      |
7928                            GDK_POINTER_MOTION_MASK      |
7929                            GDK_POINTER_MOTION_HINT_MASK |
7930                            gtk_widget_get_events (win->widget));
7931
7932   win->bin_window = gdk_window_new (win->window,
7933                                     &attributes,
7934                                     attributes_mask);
7935
7936   gdk_window_show (win->bin_window);
7937   gdk_window_set_user_data (win->bin_window, win->widget);
7938
7939   if (win->type == GTK_TEXT_WINDOW_TEXT)
7940     {
7941       if (GTK_WIDGET_IS_SENSITIVE (widget))
7942         {
7943           /* I-beam cursor */
7944           cursor = gdk_cursor_new_for_display (gdk_drawable_get_display (widget->window),
7945                                                GDK_XTERM);
7946           gdk_window_set_cursor (win->bin_window, cursor);
7947           gdk_cursor_unref (cursor);
7948         }
7949
7950       gtk_im_context_set_client_window (GTK_TEXT_VIEW (widget)->im_context,
7951                                         win->window);
7952
7953
7954       gdk_window_set_background (win->bin_window,
7955                                  &widget->style->base[GTK_WIDGET_STATE (widget)]);
7956     }
7957   else
7958     {
7959       gdk_window_set_background (win->bin_window,
7960                                  &widget->style->bg[GTK_WIDGET_STATE (widget)]);
7961     }
7962
7963   g_object_set_qdata (G_OBJECT (win->window),
7964                       g_quark_from_static_string ("gtk-text-view-text-window"),
7965                       win);
7966
7967   g_object_set_qdata (G_OBJECT (win->bin_window),
7968                       g_quark_from_static_string ("gtk-text-view-text-window"),
7969                       win);
7970 }
7971
7972 static void
7973 text_window_unrealize (GtkTextWindow *win)
7974 {
7975   if (win->type == GTK_TEXT_WINDOW_TEXT)
7976     {
7977       gtk_im_context_set_client_window (GTK_TEXT_VIEW (win->widget)->im_context,
7978                                         NULL);
7979     }
7980
7981   gdk_window_set_user_data (win->window, NULL);
7982   gdk_window_set_user_data (win->bin_window, NULL);
7983   gdk_window_destroy (win->bin_window);
7984   gdk_window_destroy (win->window);
7985   win->window = NULL;
7986   win->bin_window = NULL;
7987 }
7988
7989 static void
7990 text_window_size_allocate (GtkTextWindow *win,
7991                            GdkRectangle  *rect)
7992 {
7993   win->allocation = *rect;
7994
7995   if (win->window)
7996     {
7997       gdk_window_move_resize (win->window,
7998                               rect->x, rect->y,
7999                               rect->width, rect->height);
8000
8001       gdk_window_resize (win->bin_window,
8002                          rect->width, rect->height);
8003     }
8004 }
8005
8006 static void
8007 text_window_scroll        (GtkTextWindow *win,
8008                            gint           dx,
8009                            gint           dy)
8010 {
8011   if (dx != 0 || dy != 0)
8012     {
8013       gdk_window_scroll (win->bin_window, dx, dy);
8014     }
8015 }
8016
8017 static void
8018 text_window_invalidate_rect (GtkTextWindow *win,
8019                              GdkRectangle  *rect)
8020 {
8021   GdkRectangle window_rect;
8022
8023   gtk_text_view_buffer_to_window_coords (GTK_TEXT_VIEW (win->widget),
8024                                          win->type,
8025                                          rect->x,
8026                                          rect->y,
8027                                          &window_rect.x,
8028                                          &window_rect.y);
8029
8030   window_rect.width = rect->width;
8031   window_rect.height = rect->height;
8032
8033   /* Adjust the rect as appropriate */
8034
8035   switch (win->type)
8036     {
8037     case GTK_TEXT_WINDOW_TEXT:
8038       break;
8039
8040     case GTK_TEXT_WINDOW_LEFT:
8041     case GTK_TEXT_WINDOW_RIGHT:
8042       window_rect.x = 0;
8043       window_rect.width = win->allocation.width;
8044       break;
8045
8046     case GTK_TEXT_WINDOW_TOP:
8047     case GTK_TEXT_WINDOW_BOTTOM:
8048       window_rect.y = 0;
8049       window_rect.height = win->allocation.height;
8050       break;
8051
8052     default:
8053       g_warning ("%s: bug!", G_STRFUNC);
8054       return;
8055       break;
8056     }
8057
8058   gdk_window_invalidate_rect (win->bin_window, &window_rect, FALSE);
8059
8060 #if 0
8061   {
8062     cairo_t *cr = gdk_cairo_create (win->bin_window);
8063     gdk_cairo_rectangle (cr, &window_rect);
8064     cairo_set_source_rgb  (cr, 1.0, 0.0, 0.0);  /* red */
8065     cairo_fill (cr);
8066     cairo_destroy (cr);
8067   }
8068 #endif
8069 }
8070
8071 static void
8072 text_window_invalidate_cursors (GtkTextWindow *win)
8073 {
8074   GtkTextView *text_view = GTK_TEXT_VIEW (win->widget);
8075   GtkTextIter  iter;
8076   GdkRectangle strong;
8077   GdkRectangle weak;
8078   gboolean     draw_arrow;
8079   gfloat       cursor_aspect_ratio;
8080   gint         stem_width;
8081   gint         arrow_width;
8082
8083   gtk_text_buffer_get_iter_at_mark (text_view->buffer, &iter,
8084                                     gtk_text_buffer_get_insert (text_view->buffer));
8085
8086   if (_gtk_text_layout_get_block_cursor (text_view->layout, &strong))
8087     {
8088       text_window_invalidate_rect (win, &strong);
8089       return;
8090     }
8091
8092   gtk_text_layout_get_cursor_locations (text_view->layout, &iter,
8093                                         &strong, &weak);
8094
8095   /* cursor width calculation as in gtkstyle.c:draw_insertion_cursor(),
8096    * ignoring the text direction be exposing both sides of the cursor
8097    */
8098
8099   draw_arrow = (strong.x != weak.x || strong.y != weak.y);
8100
8101   gtk_widget_style_get (win->widget,
8102                         "cursor-aspect-ratio", &cursor_aspect_ratio,
8103                         NULL);
8104
8105   stem_width = strong.height * cursor_aspect_ratio + 1;
8106   arrow_width = stem_width + 1;
8107
8108   strong.width = stem_width;
8109
8110   /* round up to the next even number */
8111   if (stem_width & 1)
8112     stem_width++;
8113
8114   strong.x     -= stem_width / 2;
8115   strong.width += stem_width;
8116
8117   if (draw_arrow)
8118     {
8119       strong.x     -= arrow_width;
8120       strong.width += arrow_width * 2;
8121     }
8122
8123   text_window_invalidate_rect (win, &strong);
8124
8125   if (draw_arrow) /* == have weak */
8126     {
8127       stem_width = weak.height * cursor_aspect_ratio + 1;
8128       arrow_width = stem_width + 1;
8129
8130       weak.width = stem_width;
8131
8132       /* round up to the next even number */
8133       if (stem_width & 1)
8134         stem_width++;
8135
8136       weak.x     -= stem_width / 2;
8137       weak.width += stem_width;
8138
8139       weak.x     -= arrow_width;
8140       weak.width += arrow_width * 2;
8141
8142       text_window_invalidate_rect (win, &weak);
8143     }
8144 }
8145
8146 static gint
8147 text_window_get_width (GtkTextWindow *win)
8148 {
8149   return win->allocation.width;
8150 }
8151
8152 static gint
8153 text_window_get_height (GtkTextWindow *win)
8154 {
8155   return win->allocation.height;
8156 }
8157
8158 /* Windows */
8159
8160
8161 /**
8162  * gtk_text_view_get_window:
8163  * @text_view: a #GtkTextView
8164  * @win: window to get
8165  *
8166  * Retrieves the #GdkWindow corresponding to an area of the text view;
8167  * possible windows include the overall widget window, child windows
8168  * on the left, right, top, bottom, and the window that displays the
8169  * text buffer. Windows are %NULL and nonexistent if their width or
8170  * height is 0, and are nonexistent before the widget has been
8171  * realized.
8172  *
8173  * Return value: a #GdkWindow, or %NULL
8174  **/
8175 GdkWindow*
8176 gtk_text_view_get_window (GtkTextView *text_view,
8177                           GtkTextWindowType win)
8178 {
8179   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
8180
8181   switch (win)
8182     {
8183     case GTK_TEXT_WINDOW_WIDGET:
8184       return GTK_WIDGET (text_view)->window;
8185       break;
8186
8187     case GTK_TEXT_WINDOW_TEXT:
8188       return text_view->text_window->bin_window;
8189       break;
8190
8191     case GTK_TEXT_WINDOW_LEFT:
8192       if (text_view->left_window)
8193         return text_view->left_window->bin_window;
8194       else
8195         return NULL;
8196       break;
8197
8198     case GTK_TEXT_WINDOW_RIGHT:
8199       if (text_view->right_window)
8200         return text_view->right_window->bin_window;
8201       else
8202         return NULL;
8203       break;
8204
8205     case GTK_TEXT_WINDOW_TOP:
8206       if (text_view->top_window)
8207         return text_view->top_window->bin_window;
8208       else
8209         return NULL;
8210       break;
8211
8212     case GTK_TEXT_WINDOW_BOTTOM:
8213       if (text_view->bottom_window)
8214         return text_view->bottom_window->bin_window;
8215       else
8216         return NULL;
8217       break;
8218
8219     case GTK_TEXT_WINDOW_PRIVATE:
8220       g_warning ("%s: You can't get GTK_TEXT_WINDOW_PRIVATE, it has \"PRIVATE\" in the name because it is private.", G_STRFUNC);
8221       return NULL;
8222       break;
8223     }
8224
8225   g_warning ("%s: Unknown GtkTextWindowType", G_STRFUNC);
8226   return NULL;
8227 }
8228
8229 /**
8230  * gtk_text_view_get_window_type:
8231  * @text_view: a #GtkTextView
8232  * @window: a window type
8233  *
8234  * Usually used to find out which window an event corresponds to.
8235  * If you connect to an event signal on @text_view, this function
8236  * should be called on <literal>event-&gt;window</literal> to
8237  * see which window it was.
8238  *
8239  * Return value: the window type.
8240  **/
8241 GtkTextWindowType
8242 gtk_text_view_get_window_type (GtkTextView *text_view,
8243                                GdkWindow   *window)
8244 {
8245   GtkTextWindow *win;
8246
8247   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
8248   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8249
8250   if (window == GTK_WIDGET (text_view)->window)
8251     return GTK_TEXT_WINDOW_WIDGET;
8252
8253   win = g_object_get_qdata (G_OBJECT (window),
8254                             g_quark_try_string ("gtk-text-view-text-window"));
8255
8256   if (win)
8257     return win->type;
8258   else
8259     {
8260       return GTK_TEXT_WINDOW_PRIVATE;
8261     }
8262 }
8263
8264 static void
8265 buffer_to_widget (GtkTextView      *text_view,
8266                   gint              buffer_x,
8267                   gint              buffer_y,
8268                   gint             *window_x,
8269                   gint             *window_y)
8270 {
8271   if (window_x)
8272     {
8273       *window_x = buffer_x - text_view->xoffset;
8274       *window_x += text_view->text_window->allocation.x;
8275     }
8276
8277   if (window_y)
8278     {
8279       *window_y = buffer_y - text_view->yoffset;
8280       *window_y += text_view->text_window->allocation.y;
8281     }
8282 }
8283
8284 static void
8285 widget_to_text_window (GtkTextWindow *win,
8286                        gint           widget_x,
8287                        gint           widget_y,
8288                        gint          *window_x,
8289                        gint          *window_y)
8290 {
8291   if (window_x)
8292     *window_x = widget_x - win->allocation.x;
8293
8294   if (window_y)
8295     *window_y = widget_y - win->allocation.y;
8296 }
8297
8298 static void
8299 buffer_to_text_window (GtkTextView   *text_view,
8300                        GtkTextWindow *win,
8301                        gint           buffer_x,
8302                        gint           buffer_y,
8303                        gint          *window_x,
8304                        gint          *window_y)
8305 {
8306   if (win == NULL)
8307     {
8308       g_warning ("Attempt to convert text buffer coordinates to coordinates "
8309                  "for a nonexistent or private child window of GtkTextView");
8310       return;
8311     }
8312
8313   buffer_to_widget (text_view,
8314                     buffer_x, buffer_y,
8315                     window_x, window_y);
8316
8317   widget_to_text_window (win,
8318                          window_x ? *window_x : 0,
8319                          window_y ? *window_y : 0,
8320                          window_x,
8321                          window_y);
8322 }
8323
8324 /**
8325  * gtk_text_view_buffer_to_window_coords:
8326  * @text_view: a #GtkTextView
8327  * @win: a #GtkTextWindowType except #GTK_TEXT_WINDOW_PRIVATE
8328  * @buffer_x: buffer x coordinate
8329  * @buffer_y: buffer y coordinate
8330  * @window_x: window x coordinate return location
8331  * @window_y: window y coordinate return location
8332  *
8333  * Converts coordinate (@buffer_x, @buffer_y) to coordinates for the window
8334  * @win, and stores the result in (@window_x, @window_y).
8335  *
8336  * Note that you can't convert coordinates for a nonexisting window (see
8337  * gtk_text_view_set_border_window_size()).
8338  **/
8339 void
8340 gtk_text_view_buffer_to_window_coords (GtkTextView      *text_view,
8341                                        GtkTextWindowType win,
8342                                        gint              buffer_x,
8343                                        gint              buffer_y,
8344                                        gint             *window_x,
8345                                        gint             *window_y)
8346 {
8347   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8348
8349   switch (win)
8350     {
8351     case GTK_TEXT_WINDOW_WIDGET:
8352       buffer_to_widget (text_view,
8353                         buffer_x, buffer_y,
8354                         window_x, window_y);
8355       break;
8356
8357     case GTK_TEXT_WINDOW_TEXT:
8358       if (window_x)
8359         *window_x = buffer_x - text_view->xoffset;
8360       if (window_y)
8361         *window_y = buffer_y - text_view->yoffset;
8362       break;
8363
8364     case GTK_TEXT_WINDOW_LEFT:
8365       buffer_to_text_window (text_view,
8366                              text_view->left_window,
8367                              buffer_x, buffer_y,
8368                              window_x, window_y);
8369       break;
8370
8371     case GTK_TEXT_WINDOW_RIGHT:
8372       buffer_to_text_window (text_view,
8373                              text_view->right_window,
8374                              buffer_x, buffer_y,
8375                              window_x, window_y);
8376       break;
8377
8378     case GTK_TEXT_WINDOW_TOP:
8379       buffer_to_text_window (text_view,
8380                              text_view->top_window,
8381                              buffer_x, buffer_y,
8382                              window_x, window_y);
8383       break;
8384
8385     case GTK_TEXT_WINDOW_BOTTOM:
8386       buffer_to_text_window (text_view,
8387                              text_view->bottom_window,
8388                              buffer_x, buffer_y,
8389                              window_x, window_y);
8390       break;
8391
8392     case GTK_TEXT_WINDOW_PRIVATE:
8393       g_warning ("%s: can't get coords for private windows", G_STRFUNC);
8394       break;
8395
8396     default:
8397       g_warning ("%s: Unknown GtkTextWindowType", G_STRFUNC);
8398       break;
8399     }
8400 }
8401
8402 static void
8403 widget_to_buffer (GtkTextView *text_view,
8404                   gint         widget_x,
8405                   gint         widget_y,
8406                   gint        *buffer_x,
8407                   gint        *buffer_y)
8408 {
8409   if (buffer_x)
8410     {
8411       *buffer_x = widget_x + text_view->xoffset;
8412       *buffer_x -= text_view->text_window->allocation.x;
8413     }
8414
8415   if (buffer_y)
8416     {
8417       *buffer_y = widget_y + text_view->yoffset;
8418       *buffer_y -= text_view->text_window->allocation.y;
8419     }
8420 }
8421
8422 static void
8423 text_window_to_widget (GtkTextWindow *win,
8424                        gint           window_x,
8425                        gint           window_y,
8426                        gint          *widget_x,
8427                        gint          *widget_y)
8428 {
8429   if (widget_x)
8430     *widget_x = window_x + win->allocation.x;
8431
8432   if (widget_y)
8433     *widget_y = window_y + win->allocation.y;
8434 }
8435
8436 static void
8437 text_window_to_buffer (GtkTextView   *text_view,
8438                        GtkTextWindow *win,
8439                        gint           window_x,
8440                        gint           window_y,
8441                        gint          *buffer_x,
8442                        gint          *buffer_y)
8443 {
8444   if (win == NULL)
8445     {
8446       g_warning ("Attempt to convert GtkTextView buffer coordinates into "
8447                  "coordinates for a nonexistent child window.");
8448       return;
8449     }
8450
8451   text_window_to_widget (win,
8452                          window_x,
8453                          window_y,
8454                          buffer_x,
8455                          buffer_y);
8456
8457   widget_to_buffer (text_view,
8458                     buffer_x ? *buffer_x : 0,
8459                     buffer_y ? *buffer_y : 0,
8460                     buffer_x,
8461                     buffer_y);
8462 }
8463
8464 /**
8465  * gtk_text_view_window_to_buffer_coords:
8466  * @text_view: a #GtkTextView
8467  * @win: a #GtkTextWindowType except #GTK_TEXT_WINDOW_PRIVATE
8468  * @window_x: window x coordinate
8469  * @window_y: window y coordinate
8470  * @buffer_x: buffer x coordinate return location
8471  * @buffer_y: buffer y coordinate return location
8472  *
8473  * Converts coordinates on the window identified by @win to buffer
8474  * coordinates, storing the result in (@buffer_x,@buffer_y).
8475  *
8476  * Note that you can't convert coordinates for a nonexisting window (see
8477  * gtk_text_view_set_border_window_size()).
8478  **/
8479 void
8480 gtk_text_view_window_to_buffer_coords (GtkTextView      *text_view,
8481                                        GtkTextWindowType win,
8482                                        gint              window_x,
8483                                        gint              window_y,
8484                                        gint             *buffer_x,
8485                                        gint             *buffer_y)
8486 {
8487   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8488
8489   switch (win)
8490     {
8491     case GTK_TEXT_WINDOW_WIDGET:
8492       widget_to_buffer (text_view,
8493                         window_x, window_y,
8494                         buffer_x, buffer_y);
8495       break;
8496
8497     case GTK_TEXT_WINDOW_TEXT:
8498       if (buffer_x)
8499         *buffer_x = window_x + text_view->xoffset;
8500       if (buffer_y)
8501         *buffer_y = window_y + text_view->yoffset;
8502       break;
8503
8504     case GTK_TEXT_WINDOW_LEFT:
8505       text_window_to_buffer (text_view,
8506                              text_view->left_window,
8507                              window_x, window_y,
8508                              buffer_x, buffer_y);
8509       break;
8510
8511     case GTK_TEXT_WINDOW_RIGHT:
8512       text_window_to_buffer (text_view,
8513                              text_view->right_window,
8514                              window_x, window_y,
8515                              buffer_x, buffer_y);
8516       break;
8517
8518     case GTK_TEXT_WINDOW_TOP:
8519       text_window_to_buffer (text_view,
8520                              text_view->top_window,
8521                              window_x, window_y,
8522                              buffer_x, buffer_y);
8523       break;
8524
8525     case GTK_TEXT_WINDOW_BOTTOM:
8526       text_window_to_buffer (text_view,
8527                              text_view->bottom_window,
8528                              window_x, window_y,
8529                              buffer_x, buffer_y);
8530       break;
8531
8532     case GTK_TEXT_WINDOW_PRIVATE:
8533       g_warning ("%s: can't get coords for private windows", G_STRFUNC);
8534       break;
8535
8536     default:
8537       g_warning ("%s: Unknown GtkTextWindowType", G_STRFUNC);
8538       break;
8539     }
8540 }
8541
8542 static void
8543 set_window_width (GtkTextView      *text_view,
8544                   gint              width,
8545                   GtkTextWindowType type,
8546                   GtkTextWindow   **winp)
8547 {
8548   if (width == 0)
8549     {
8550       if (*winp)
8551         {
8552           text_window_free (*winp);
8553           *winp = NULL;
8554           gtk_widget_queue_resize (GTK_WIDGET (text_view));
8555         }
8556     }
8557   else
8558     {
8559       if (*winp == NULL)
8560         {
8561           *winp = text_window_new (type,
8562                                    GTK_WIDGET (text_view),
8563                                    width, 0);
8564           /* if the widget is already realized we need to realize the child manually */
8565           if (GTK_WIDGET_REALIZED (text_view))
8566             text_window_realize (*winp, GTK_WIDGET (text_view));
8567         }
8568       else
8569         {
8570           if ((*winp)->requisition.width == width)
8571             return;
8572
8573           (*winp)->requisition.width = width;
8574         }
8575
8576       gtk_widget_queue_resize (GTK_WIDGET (text_view));
8577     }
8578 }
8579
8580
8581 static void
8582 set_window_height (GtkTextView      *text_view,
8583                    gint              height,
8584                    GtkTextWindowType type,
8585                    GtkTextWindow   **winp)
8586 {
8587   if (height == 0)
8588     {
8589       if (*winp)
8590         {
8591           text_window_free (*winp);
8592           *winp = NULL;
8593           gtk_widget_queue_resize (GTK_WIDGET (text_view));
8594         }
8595     }
8596   else
8597     {
8598       if (*winp == NULL)
8599         {
8600           *winp = text_window_new (type,
8601                                    GTK_WIDGET (text_view),
8602                                    0, height);
8603
8604           /* if the widget is already realized we need to realize the child manually */
8605           if (GTK_WIDGET_REALIZED (text_view))
8606             text_window_realize (*winp, GTK_WIDGET (text_view));
8607         }
8608       else
8609         {
8610           if ((*winp)->requisition.height == height)
8611             return;
8612
8613           (*winp)->requisition.height = height;
8614         }
8615
8616       gtk_widget_queue_resize (GTK_WIDGET (text_view));
8617     }
8618 }
8619
8620 /**
8621  * gtk_text_view_set_border_window_size:
8622  * @text_view: a #GtkTextView
8623  * @type: window to affect
8624  * @size: width or height of the window
8625  *
8626  * Sets the width of %GTK_TEXT_WINDOW_LEFT or %GTK_TEXT_WINDOW_RIGHT,
8627  * or the height of %GTK_TEXT_WINDOW_TOP or %GTK_TEXT_WINDOW_BOTTOM.
8628  * Automatically destroys the corresponding window if the size is set
8629  * to 0, and creates the window if the size is set to non-zero.  This
8630  * function can only be used for the "border windows," it doesn't work
8631  * with #GTK_TEXT_WINDOW_WIDGET, #GTK_TEXT_WINDOW_TEXT, or
8632  * #GTK_TEXT_WINDOW_PRIVATE.
8633  **/
8634 void
8635 gtk_text_view_set_border_window_size (GtkTextView      *text_view,
8636                                       GtkTextWindowType type,
8637                                       gint              size)
8638
8639 {
8640   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8641   g_return_if_fail (size >= 0);
8642
8643   switch (type)
8644     {
8645     case GTK_TEXT_WINDOW_LEFT:
8646       set_window_width (text_view, size, GTK_TEXT_WINDOW_LEFT,
8647                         &text_view->left_window);
8648       break;
8649
8650     case GTK_TEXT_WINDOW_RIGHT:
8651       set_window_width (text_view, size, GTK_TEXT_WINDOW_RIGHT,
8652                         &text_view->right_window);
8653       break;
8654
8655     case GTK_TEXT_WINDOW_TOP:
8656       set_window_height (text_view, size, GTK_TEXT_WINDOW_TOP,
8657                          &text_view->top_window);
8658       break;
8659
8660     case GTK_TEXT_WINDOW_BOTTOM:
8661       set_window_height (text_view, size, GTK_TEXT_WINDOW_BOTTOM,
8662                          &text_view->bottom_window);
8663       break;
8664
8665     default:
8666       g_warning ("Can only set size of left/right/top/bottom border windows with gtk_text_view_set_border_window_size()");
8667       break;
8668     }
8669 }
8670
8671 /**
8672  * gtk_text_view_get_border_window_size:
8673  * @text_view: a #GtkTextView
8674  * @type: window to return size from
8675  *
8676  * Gets the width of the specified border window. See
8677  * gtk_text_view_set_border_window_size().
8678  *
8679  * Return value: width of window
8680  **/
8681 gint
8682 gtk_text_view_get_border_window_size (GtkTextView       *text_view,
8683                                       GtkTextWindowType  type)
8684 {
8685   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
8686
8687   switch (type)
8688     {
8689     case GTK_TEXT_WINDOW_LEFT:
8690       if (text_view->left_window)
8691         return text_view->left_window->requisition.width;
8692       break;
8693
8694     case GTK_TEXT_WINDOW_RIGHT:
8695       if (text_view->right_window)
8696         return text_view->right_window->requisition.width;
8697       break;
8698
8699     case GTK_TEXT_WINDOW_TOP:
8700       if (text_view->top_window)
8701         return text_view->top_window->requisition.height;
8702       break;
8703
8704     case GTK_TEXT_WINDOW_BOTTOM:
8705       if (text_view->bottom_window)
8706         return text_view->bottom_window->requisition.height;
8707       break;
8708
8709     default:
8710       g_warning ("Can only get size of left/right/top/bottom border windows with gtk_text_view_get_border_window_size()");
8711       break;
8712     }
8713
8714   return 0;
8715 }
8716
8717 /*
8718  * Child widgets
8719  */
8720
8721 static GtkTextViewChild*
8722 text_view_child_new_anchored (GtkWidget          *child,
8723                               GtkTextChildAnchor *anchor,
8724                               GtkTextLayout      *layout)
8725 {
8726   GtkTextViewChild *vc;
8727
8728   vc = g_new (GtkTextViewChild, 1);
8729
8730   vc->type = GTK_TEXT_WINDOW_PRIVATE;
8731   vc->widget = child;
8732   vc->anchor = anchor;
8733
8734   vc->from_top_of_line = 0;
8735   vc->from_left_of_buffer = 0;
8736
8737   g_object_ref (vc->widget);
8738   g_object_ref (vc->anchor);
8739
8740   g_object_set_data (G_OBJECT (child),
8741                      I_("gtk-text-view-child"),
8742                      vc);
8743
8744   gtk_text_child_anchor_register_child (anchor, child, layout);
8745
8746   return vc;
8747 }
8748
8749 static GtkTextViewChild*
8750 text_view_child_new_window (GtkWidget          *child,
8751                             GtkTextWindowType   type,
8752                             gint                x,
8753                             gint                y)
8754 {
8755   GtkTextViewChild *vc;
8756
8757   vc = g_new (GtkTextViewChild, 1);
8758
8759   vc->widget = child;
8760   vc->anchor = NULL;
8761
8762   vc->from_top_of_line = 0;
8763   vc->from_left_of_buffer = 0;
8764
8765   g_object_ref (vc->widget);
8766
8767   vc->type = type;
8768   vc->x = x;
8769   vc->y = y;
8770
8771   g_object_set_data (G_OBJECT (child),
8772                      I_("gtk-text-view-child"),
8773                      vc);
8774
8775   return vc;
8776 }
8777
8778 static void
8779 text_view_child_free (GtkTextViewChild *child)
8780 {
8781   g_object_set_data (G_OBJECT (child->widget),
8782                      I_("gtk-text-view-child"), NULL);
8783
8784   if (child->anchor)
8785     {
8786       gtk_text_child_anchor_unregister_child (child->anchor,
8787                                               child->widget);
8788       g_object_unref (child->anchor);
8789     }
8790
8791   g_object_unref (child->widget);
8792
8793   g_free (child);
8794 }
8795
8796 static void
8797 text_view_child_set_parent_window (GtkTextView      *text_view,
8798                                    GtkTextViewChild *vc)
8799 {
8800   if (vc->anchor)
8801     gtk_widget_set_parent_window (vc->widget,
8802                                   text_view->text_window->bin_window);
8803   else
8804     {
8805       GdkWindow *window;
8806       window = gtk_text_view_get_window (text_view,
8807                                          vc->type);
8808       gtk_widget_set_parent_window (vc->widget, window);
8809     }
8810 }
8811
8812 static void
8813 add_child (GtkTextView      *text_view,
8814            GtkTextViewChild *vc)
8815 {
8816   text_view->children = g_slist_prepend (text_view->children,
8817                                          vc);
8818
8819   if (GTK_WIDGET_REALIZED (text_view))
8820     text_view_child_set_parent_window (text_view, vc);
8821
8822   gtk_widget_set_parent (vc->widget, GTK_WIDGET (text_view));
8823 }
8824
8825 /**
8826  * gtk_text_view_add_child_at_anchor:
8827  * @text_view: a #GtkTextView
8828  * @child: a #GtkWidget
8829  * @anchor: a #GtkTextChildAnchor in the #GtkTextBuffer for @text_view
8830  *
8831  * Adds a child widget in the text buffer, at the given @anchor.
8832  **/
8833 void
8834 gtk_text_view_add_child_at_anchor (GtkTextView          *text_view,
8835                                    GtkWidget            *child,
8836                                    GtkTextChildAnchor   *anchor)
8837 {
8838   GtkTextViewChild *vc;
8839
8840   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8841   g_return_if_fail (GTK_IS_WIDGET (child));
8842   g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
8843   g_return_if_fail (child->parent == NULL);
8844
8845   gtk_text_view_ensure_layout (text_view);
8846
8847   vc = text_view_child_new_anchored (child, anchor,
8848                                      text_view->layout);
8849
8850   add_child (text_view, vc);
8851
8852   g_assert (vc->widget == child);
8853   g_assert (gtk_widget_get_parent (child) == GTK_WIDGET (text_view));
8854 }
8855
8856 /**
8857  * gtk_text_view_add_child_in_window:
8858  * @text_view: a #GtkTextView
8859  * @child: a #GtkWidget
8860  * @which_window: which window the child should appear in
8861  * @xpos: X position of child in window coordinates
8862  * @ypos: Y position of child in window coordinates
8863  *
8864  * Adds a child at fixed coordinates in one of the text widget's
8865  * windows. The window must have nonzero size (see
8866  * gtk_text_view_set_border_window_size()). Note that the child
8867  * coordinates are given relative to the #GdkWindow in question, and
8868  * that these coordinates have no sane relationship to scrolling. When
8869  * placing a child in #GTK_TEXT_WINDOW_WIDGET, scrolling is
8870  * irrelevant, the child floats above all scrollable areas. But when
8871  * placing a child in one of the scrollable windows (border windows or
8872  * text window), you'll need to compute the child's correct position
8873  * in buffer coordinates any time scrolling occurs or buffer changes
8874  * occur, and then call gtk_text_view_move_child() to update the
8875  * child's position. Unfortunately there's no good way to detect that
8876  * scrolling has occurred, using the current API; a possible hack
8877  * would be to update all child positions when the scroll adjustments
8878  * change or the text buffer changes. See bug 64518 on
8879  * bugzilla.gnome.org for status of fixing this issue.
8880  **/
8881 void
8882 gtk_text_view_add_child_in_window (GtkTextView       *text_view,
8883                                    GtkWidget         *child,
8884                                    GtkTextWindowType  which_window,
8885                                    gint               xpos,
8886                                    gint               ypos)
8887 {
8888   GtkTextViewChild *vc;
8889
8890   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8891   g_return_if_fail (GTK_IS_WIDGET (child));
8892   g_return_if_fail (child->parent == NULL);
8893
8894   vc = text_view_child_new_window (child, which_window,
8895                                    xpos, ypos);
8896
8897   add_child (text_view, vc);
8898
8899   g_assert (vc->widget == child);
8900   g_assert (gtk_widget_get_parent (child) == GTK_WIDGET (text_view));
8901 }
8902
8903 /**
8904  * gtk_text_view_move_child:
8905  * @text_view: a #GtkTextView
8906  * @child: child widget already added to the text view
8907  * @xpos: new X position in window coordinates
8908  * @ypos: new Y position in window coordinates
8909  *
8910  * Updates the position of a child, as for gtk_text_view_add_child_in_window().
8911  **/
8912 void
8913 gtk_text_view_move_child (GtkTextView *text_view,
8914                           GtkWidget   *child,
8915                           gint         xpos,
8916                           gint         ypos)
8917 {
8918   GtkTextViewChild *vc;
8919
8920   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8921   g_return_if_fail (GTK_IS_WIDGET (child));
8922   g_return_if_fail (child->parent == (GtkWidget*) text_view);
8923
8924   vc = g_object_get_data (G_OBJECT (child),
8925                           "gtk-text-view-child");
8926
8927   g_assert (vc != NULL);
8928
8929   if (vc->x == xpos &&
8930       vc->y == ypos)
8931     return;
8932
8933   vc->x = xpos;
8934   vc->y = ypos;
8935
8936   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (text_view))
8937     gtk_widget_queue_resize (child);
8938 }
8939
8940
8941 /* Iterator operations */
8942
8943 /**
8944  * gtk_text_view_forward_display_line:
8945  * @text_view: a #GtkTextView
8946  * @iter: a #GtkTextIter
8947  *
8948  * Moves the given @iter forward by one display (wrapped) line.
8949  * A display line is different from a paragraph. Paragraphs are
8950  * separated by newlines or other paragraph separator characters.
8951  * Display lines are created by line-wrapping a paragraph. If
8952  * wrapping is turned off, display lines and paragraphs will be the
8953  * same. Display lines are divided differently for each view, since
8954  * they depend on the view's width; paragraphs are the same in all
8955  * views, since they depend on the contents of the #GtkTextBuffer.
8956  *
8957  * Return value: %TRUE if @iter was moved and is not on the end iterator
8958  **/
8959 gboolean
8960 gtk_text_view_forward_display_line (GtkTextView *text_view,
8961                                     GtkTextIter *iter)
8962 {
8963   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
8964   g_return_val_if_fail (iter != NULL, FALSE);
8965
8966   gtk_text_view_ensure_layout (text_view);
8967
8968   return gtk_text_layout_move_iter_to_next_line (text_view->layout, iter);
8969 }
8970
8971 /**
8972  * gtk_text_view_backward_display_line:
8973  * @text_view: a #GtkTextView
8974  * @iter: a #GtkTextIter
8975  *
8976  * Moves the given @iter backward by one display (wrapped) line.
8977  * A display line is different from a paragraph. Paragraphs are
8978  * separated by newlines or other paragraph separator characters.
8979  * Display lines are created by line-wrapping a paragraph. If
8980  * wrapping is turned off, display lines and paragraphs will be the
8981  * same. Display lines are divided differently for each view, since
8982  * they depend on the view's width; paragraphs are the same in all
8983  * views, since they depend on the contents of the #GtkTextBuffer.
8984  *
8985  * Return value: %TRUE if @iter was moved and is not on the end iterator
8986  **/
8987 gboolean
8988 gtk_text_view_backward_display_line (GtkTextView *text_view,
8989                                      GtkTextIter *iter)
8990 {
8991   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
8992   g_return_val_if_fail (iter != NULL, FALSE);
8993
8994   gtk_text_view_ensure_layout (text_view);
8995
8996   return gtk_text_layout_move_iter_to_previous_line (text_view->layout, iter);
8997 }
8998
8999 /**
9000  * gtk_text_view_forward_display_line_end:
9001  * @text_view: a #GtkTextView
9002  * @iter: a #GtkTextIter
9003  *
9004  * Moves the given @iter forward to the next display line end.
9005  * A display line is different from a paragraph. Paragraphs are
9006  * separated by newlines or other paragraph separator characters.
9007  * Display lines are created by line-wrapping a paragraph. If
9008  * wrapping is turned off, display lines and paragraphs will be the
9009  * same. Display lines are divided differently for each view, since
9010  * they depend on the view's width; paragraphs are the same in all
9011  * views, since they depend on the contents of the #GtkTextBuffer.
9012  *
9013  * Return value: %TRUE if @iter was moved and is not on the end iterator
9014  **/
9015 gboolean
9016 gtk_text_view_forward_display_line_end (GtkTextView *text_view,
9017                                         GtkTextIter *iter)
9018 {
9019   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
9020   g_return_val_if_fail (iter != NULL, FALSE);
9021
9022   gtk_text_view_ensure_layout (text_view);
9023
9024   return gtk_text_layout_move_iter_to_line_end (text_view->layout, iter, 1);
9025 }
9026
9027 /**
9028  * gtk_text_view_backward_display_line_start:
9029  * @text_view: a #GtkTextView
9030  * @iter: a #GtkTextIter
9031  *
9032  * Moves the given @iter backward to the next display line start.
9033  * A display line is different from a paragraph. Paragraphs are
9034  * separated by newlines or other paragraph separator characters.
9035  * Display lines are created by line-wrapping a paragraph. If
9036  * wrapping is turned off, display lines and paragraphs will be the
9037  * same. Display lines are divided differently for each view, since
9038  * they depend on the view's width; paragraphs are the same in all
9039  * views, since they depend on the contents of the #GtkTextBuffer.
9040  *
9041  * Return value: %TRUE if @iter was moved and is not on the end iterator
9042  **/
9043 gboolean
9044 gtk_text_view_backward_display_line_start (GtkTextView *text_view,
9045                                            GtkTextIter *iter)
9046 {
9047   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
9048   g_return_val_if_fail (iter != NULL, FALSE);
9049
9050   gtk_text_view_ensure_layout (text_view);
9051
9052   return gtk_text_layout_move_iter_to_line_end (text_view->layout, iter, -1);
9053 }
9054
9055 /**
9056  * gtk_text_view_starts_display_line:
9057  * @text_view: a #GtkTextView
9058  * @iter: a #GtkTextIter
9059  *
9060  * Determines whether @iter is at the start of a display line.
9061  * See gtk_text_view_forward_display_line() for an explanation of
9062  * display lines vs. paragraphs.
9063  *
9064  * Return value: %TRUE if @iter begins a wrapped line
9065  **/
9066 gboolean
9067 gtk_text_view_starts_display_line (GtkTextView       *text_view,
9068                                    const GtkTextIter *iter)
9069 {
9070   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
9071   g_return_val_if_fail (iter != NULL, FALSE);
9072
9073   gtk_text_view_ensure_layout (text_view);
9074
9075   return gtk_text_layout_iter_starts_line (text_view->layout, iter);
9076 }
9077
9078 /**
9079  * gtk_text_view_move_visually:
9080  * @text_view: a #GtkTextView
9081  * @iter: a #GtkTextIter
9082  * @count: number of characters to move (negative moves left,
9083  *    positive moves right)
9084  *
9085  * Move the iterator a given number of characters visually, treating
9086  * it as the strong cursor position. If @count is positive, then the
9087  * new strong cursor position will be @count positions to the right of
9088  * the old cursor position. If @count is negative then the new strong
9089  * cursor position will be @count positions to the left of the old
9090  * cursor position.
9091  *
9092  * In the presence of bi-directional text, the correspondence
9093  * between logical and visual order will depend on the direction
9094  * of the current run, and there may be jumps when the cursor
9095  * is moved off of the end of a run.
9096  *
9097  * Return value: %TRUE if @iter moved and is not on the end iterator
9098  **/
9099 gboolean
9100 gtk_text_view_move_visually (GtkTextView *text_view,
9101                              GtkTextIter *iter,
9102                              gint         count)
9103 {
9104   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
9105   g_return_val_if_fail (iter != NULL, FALSE);
9106
9107   gtk_text_view_ensure_layout (text_view);
9108
9109   return gtk_text_layout_move_iter_visually (text_view->layout, iter, count);
9110 }
9111
9112 #define __GTK_TEXT_VIEW_C__
9113 #include "gtkaliasdef.c"