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               !(event->state & GDK_SHIFT_MASK))
4319             {
4320               text_view->drag_start_x = event->x;
4321               text_view->drag_start_y = event->y;
4322               text_view->pending_place_cursor_button = event->button;
4323             }
4324           else
4325             {
4326               gtk_text_view_start_selection_drag (text_view, &iter, event);
4327             }
4328
4329           return TRUE;
4330         }
4331       else if (event->button == 2)
4332         {
4333           GtkTextIter iter;
4334
4335           gtk_text_layout_get_iter_at_pixel (text_view->layout,
4336                                              &iter,
4337                                              event->x + text_view->xoffset,
4338                                              event->y + text_view->yoffset);
4339
4340           gtk_text_buffer_paste_clipboard (get_buffer (text_view),
4341                                            gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY),
4342                                            &iter,
4343                                            text_view->editable);
4344           return TRUE;
4345         }
4346       else if (event->button == 3)
4347         {
4348           gtk_text_view_do_popup (text_view, event);
4349           return TRUE;
4350         }
4351     }
4352   else if ((event->type == GDK_2BUTTON_PRESS ||
4353             event->type == GDK_3BUTTON_PRESS) &&
4354            event->button == 1)
4355     {
4356       GtkTextIter iter;
4357
4358       gtk_text_view_end_selection_drag (text_view);
4359
4360       gtk_text_layout_get_iter_at_pixel (text_view->layout,
4361                                          &iter,
4362                                          event->x + text_view->xoffset,
4363                                          event->y + text_view->yoffset);
4364
4365       gtk_text_view_start_selection_drag (text_view, &iter, event);
4366       return TRUE;
4367     }
4368
4369   return FALSE;
4370 }
4371
4372 static gint
4373 gtk_text_view_button_release_event (GtkWidget *widget, GdkEventButton *event)
4374 {
4375   GtkTextView *text_view;
4376
4377   text_view = GTK_TEXT_VIEW (widget);
4378
4379   if (event->window != text_view->text_window->bin_window)
4380     return FALSE;
4381
4382   if (event->button == 1)
4383     {
4384       if (text_view->drag_start_x >= 0)
4385         {
4386           text_view->drag_start_x = -1;
4387           text_view->drag_start_y = -1;
4388         }
4389
4390       if (gtk_text_view_end_selection_drag (GTK_TEXT_VIEW (widget)))
4391         return TRUE;
4392       else if (text_view->pending_place_cursor_button == event->button)
4393         {
4394           GtkTextIter iter;
4395
4396           /* Unselect everything; we clicked inside selection, but
4397            * didn't move by the drag threshold, so just clear selection
4398            * and place cursor.
4399            */
4400           gtk_text_layout_get_iter_at_pixel (text_view->layout,
4401                                              &iter,
4402                                              event->x + text_view->xoffset,
4403                                              event->y + text_view->yoffset);
4404
4405           gtk_text_buffer_place_cursor (get_buffer (text_view), &iter);
4406           gtk_text_view_check_cursor_blink (text_view);
4407
4408           text_view->pending_place_cursor_button = 0;
4409
4410           return FALSE;
4411         }
4412     }
4413
4414   return FALSE;
4415 }
4416
4417 static void
4418 keymap_direction_changed (GdkKeymap   *keymap,
4419                           GtkTextView *text_view)
4420 {
4421   gtk_text_view_check_keymap_direction (text_view);
4422 }
4423
4424 static gint
4425 gtk_text_view_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
4426 {
4427   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4428
4429   gtk_widget_queue_draw (widget);
4430
4431   DV(g_print (G_STRLOC": focus_in_event\n"));
4432
4433   gtk_text_view_reset_blink_time (text_view);
4434
4435   if (text_view->cursor_visible && text_view->layout)
4436     {
4437       gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
4438       gtk_text_view_check_cursor_blink (text_view);
4439     }
4440
4441   g_signal_connect (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
4442                     "direction-changed",
4443                     G_CALLBACK (keymap_direction_changed), text_view);
4444   gtk_text_view_check_keymap_direction (text_view);
4445
4446   if (text_view->editable)
4447     {
4448       text_view->need_im_reset = TRUE;
4449       gtk_im_context_focus_in (GTK_TEXT_VIEW (widget)->im_context);
4450     }
4451
4452   return FALSE;
4453 }
4454
4455 static gint
4456 gtk_text_view_focus_out_event (GtkWidget *widget, GdkEventFocus *event)
4457 {
4458   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4459
4460   gtk_text_view_end_selection_drag (text_view);
4461
4462   gtk_widget_queue_draw (widget);
4463
4464   DV(g_print (G_STRLOC": focus_out_event\n"));
4465
4466   if (text_view->cursor_visible && text_view->layout)
4467     {
4468       gtk_text_view_check_cursor_blink (text_view);
4469       gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
4470     }
4471
4472   g_signal_handlers_disconnect_by_func (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
4473                                         keymap_direction_changed,
4474                                         text_view);
4475
4476   if (text_view->editable)
4477     {
4478       text_view->need_im_reset = TRUE;
4479       gtk_im_context_focus_out (GTK_TEXT_VIEW (widget)->im_context);
4480     }
4481
4482   return FALSE;
4483 }
4484
4485 static gint
4486 gtk_text_view_motion_event (GtkWidget *widget, GdkEventMotion *event)
4487 {
4488   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4489
4490   gtk_text_view_unobscure_mouse_cursor (text_view);
4491
4492   if (event->window == text_view->text_window->bin_window &&
4493       text_view->drag_start_x >= 0)
4494     {
4495       gint x = event->x;
4496       gint y = event->y;
4497
4498       gdk_event_request_motions (event);
4499
4500       if (gtk_drag_check_threshold (widget,
4501                                     text_view->drag_start_x,
4502                                     text_view->drag_start_y,
4503                                     x, y))
4504         {
4505           GtkTextIter iter;
4506           gint buffer_x, buffer_y;
4507
4508           gtk_text_view_window_to_buffer_coords (text_view,
4509                                                  GTK_TEXT_WINDOW_TEXT,
4510                                                  text_view->drag_start_x,
4511                                                  text_view->drag_start_y,
4512                                                  &buffer_x,
4513                                                  &buffer_y);
4514
4515           gtk_text_layout_get_iter_at_pixel (text_view->layout,
4516                                              &iter,
4517                                              buffer_x, buffer_y);
4518
4519           gtk_text_view_start_selection_dnd (text_view, &iter, event);
4520           return TRUE;
4521         }
4522     }
4523
4524   return FALSE;
4525 }
4526
4527 static void
4528 gtk_text_view_paint (GtkWidget      *widget,
4529                      GdkRectangle   *area,
4530                      GdkEventExpose *event)
4531 {
4532   GtkTextView *text_view;
4533   GList *child_exposes;
4534   GList *tmp_list;
4535
4536   text_view = GTK_TEXT_VIEW (widget);
4537
4538   g_return_if_fail (text_view->layout != NULL);
4539   g_return_if_fail (text_view->xoffset >= 0);
4540   g_return_if_fail (text_view->yoffset >= 0);
4541
4542   while (text_view->first_validate_idle != 0)
4543     {
4544       DV (g_print (G_STRLOC": first_validate_idle: %d\n",
4545                    text_view->first_validate_idle));
4546       gtk_text_view_flush_first_validate (text_view);
4547     }
4548
4549   if (!text_view->onscreen_validated)
4550     {
4551       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.");
4552       g_assert_not_reached ();
4553     }
4554
4555 #if 0
4556   printf ("painting %d,%d  %d x %d\n",
4557           area->x, area->y,
4558           area->width, area->height);
4559 #endif
4560
4561   child_exposes = NULL;
4562   gtk_text_layout_draw (text_view->layout,
4563                         widget,
4564                         text_view->text_window->bin_window,
4565                         NULL,
4566                         text_view->xoffset,
4567                         text_view->yoffset,
4568                         area->x, area->y,
4569                         area->width, area->height,
4570                         &child_exposes);
4571
4572   tmp_list = child_exposes;
4573   while (tmp_list != NULL)
4574     {
4575       GtkWidget *child = tmp_list->data;
4576
4577       gtk_container_propagate_expose (GTK_CONTAINER (text_view),
4578                                       child,
4579                                       event);
4580
4581       g_object_unref (child);
4582
4583       tmp_list = tmp_list->next;
4584     }
4585
4586   g_list_free (child_exposes);
4587 }
4588
4589 static gint
4590 gtk_text_view_expose_event (GtkWidget *widget, GdkEventExpose *event)
4591 {
4592   GSList *tmp_list;
4593
4594   if (event->window == gtk_text_view_get_window (GTK_TEXT_VIEW (widget),
4595                                                  GTK_TEXT_WINDOW_TEXT))
4596     {
4597       DV(g_print (">Exposed ("G_STRLOC")\n"));
4598       gtk_text_view_paint (widget, &event->area, event);
4599     }
4600
4601   if (event->window == widget->window)
4602     gtk_text_view_draw_focus (widget);
4603
4604   /* Propagate exposes to all unanchored children.
4605    * Anchored children are handled in gtk_text_view_paint().
4606    */
4607   tmp_list = GTK_TEXT_VIEW (widget)->children;
4608   while (tmp_list != NULL)
4609     {
4610       GtkTextViewChild *vc = tmp_list->data;
4611
4612       /* propagate_expose checks that event->window matches
4613        * child->window
4614        */
4615       if (!vc->anchor)
4616         gtk_container_propagate_expose (GTK_CONTAINER (widget),
4617                                         vc->widget,
4618                                         event);
4619
4620       tmp_list = tmp_list->next;
4621     }
4622
4623   return FALSE;
4624 }
4625
4626 static void
4627 gtk_text_view_draw_focus (GtkWidget *widget)
4628 {
4629   gboolean interior_focus;
4630
4631   /* We clear the focus if we are in interior focus mode. */
4632   gtk_widget_style_get (widget,
4633                         "interior-focus", &interior_focus,
4634                         NULL);
4635
4636   if (GTK_WIDGET_DRAWABLE (widget))
4637     {
4638       if (GTK_WIDGET_HAS_FOCUS (widget) && !interior_focus)
4639         {
4640           gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
4641                            NULL, widget, "textview",
4642                            0, 0,
4643                            widget->allocation.width,
4644                            widget->allocation.height);
4645         }
4646       else
4647         {
4648           gdk_window_clear (widget->window);
4649         }
4650     }
4651 }
4652
4653 static gboolean
4654 gtk_text_view_focus (GtkWidget        *widget,
4655                      GtkDirectionType  direction)
4656 {
4657   GtkContainer *container;
4658   gboolean result;
4659
4660   container = GTK_CONTAINER (widget);
4661
4662   if (!gtk_widget_is_focus (widget) &&
4663       container->focus_child == NULL)
4664     {
4665       gtk_widget_grab_focus (widget);
4666       return TRUE;
4667     }
4668   else
4669     {
4670       /*
4671        * Unset CAN_FOCUS flag so that gtk_container_focus() allows
4672        * children to get the focus
4673        */
4674       GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
4675       result = GTK_WIDGET_CLASS (gtk_text_view_parent_class)->focus (widget, direction);
4676       GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
4677
4678       return result;
4679     }
4680 }
4681
4682 static void
4683 gtk_text_view_move_focus (GtkWidget        *widget,
4684                           GtkDirectionType  direction_type)
4685 {
4686   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
4687
4688   if (GTK_TEXT_VIEW_GET_CLASS (text_view)->move_focus)
4689     GTK_TEXT_VIEW_GET_CLASS (text_view)->move_focus (text_view,
4690                                                      direction_type);
4691 }
4692
4693 /*
4694  * Container
4695  */
4696
4697 static void
4698 gtk_text_view_add (GtkContainer *container,
4699                    GtkWidget    *child)
4700 {
4701   /* This is pretty random. */
4702   gtk_text_view_add_child_in_window (GTK_TEXT_VIEW (container),
4703                                      child,
4704                                      GTK_TEXT_WINDOW_WIDGET,
4705                                      0, 0);
4706 }
4707
4708 static void
4709 gtk_text_view_remove (GtkContainer *container,
4710                       GtkWidget    *child)
4711 {
4712   GSList *iter;
4713   GtkTextView *text_view;
4714   GtkTextViewChild *vc;
4715
4716   text_view = GTK_TEXT_VIEW (container);
4717
4718   vc = NULL;
4719   iter = text_view->children;
4720
4721   while (iter != NULL)
4722     {
4723       vc = iter->data;
4724
4725       if (vc->widget == child)
4726         break;
4727
4728       iter = g_slist_next (iter);
4729     }
4730
4731   g_assert (iter != NULL); /* be sure we had the child in the list */
4732
4733   text_view->children = g_slist_remove (text_view->children, vc);
4734
4735   gtk_widget_unparent (vc->widget);
4736
4737   text_view_child_free (vc);
4738 }
4739
4740 static void
4741 gtk_text_view_forall (GtkContainer *container,
4742                       gboolean      include_internals,
4743                       GtkCallback   callback,
4744                       gpointer      callback_data)
4745 {
4746   GSList *iter;
4747   GtkTextView *text_view;
4748   GSList *copy;
4749
4750   g_return_if_fail (GTK_IS_TEXT_VIEW (container));
4751   g_return_if_fail (callback != NULL);
4752
4753   text_view = GTK_TEXT_VIEW (container);
4754
4755   copy = g_slist_copy (text_view->children);
4756   iter = copy;
4757
4758   while (iter != NULL)
4759     {
4760       GtkTextViewChild *vc = iter->data;
4761
4762       (* callback) (vc->widget, callback_data);
4763
4764       iter = g_slist_next (iter);
4765     }
4766
4767   g_slist_free (copy);
4768 }
4769
4770 #define CURSOR_ON_MULTIPLIER 2
4771 #define CURSOR_OFF_MULTIPLIER 1
4772 #define CURSOR_PEND_MULTIPLIER 3
4773 #define CURSOR_DIVIDER 3
4774
4775 static gboolean
4776 cursor_blinks (GtkTextView *text_view)
4777 {
4778   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
4779   gboolean blink;
4780
4781 #ifdef DEBUG_VALIDATION_AND_SCROLLING
4782   return FALSE;
4783 #endif
4784   if (gtk_debug_flags & GTK_DEBUG_UPDATES)
4785     return FALSE;
4786
4787   g_object_get (settings, "gtk-cursor-blink", &blink, NULL);
4788
4789   if (!blink)
4790     return FALSE;
4791
4792   if (text_view->editable)
4793     {
4794       GtkTextMark *insert;
4795       GtkTextIter iter;
4796
4797       insert = gtk_text_buffer_get_insert (get_buffer (text_view));
4798       gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, insert);
4799
4800       if (gtk_text_iter_editable (&iter, text_view->editable))
4801         return blink;
4802     }
4803
4804   return FALSE;
4805 }
4806
4807 static gint
4808 get_cursor_time (GtkTextView *text_view)
4809 {
4810   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
4811   gint time;
4812
4813   g_object_get (settings, "gtk-cursor-blink-time", &time, NULL);
4814
4815   return time;
4816 }
4817
4818 static gint
4819 get_cursor_blink_timeout (GtkTextView *text_view)
4820 {
4821   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
4822   gint time;
4823
4824   g_object_get (settings, "gtk-cursor-blink-timeout", &time, NULL);
4825
4826   return time;
4827 }
4828
4829
4830 /*
4831  * Blink!
4832  */
4833
4834 static gint
4835 blink_cb (gpointer data)
4836 {
4837   GtkTextView *text_view;
4838   GtkTextViewPrivate *priv;
4839   gboolean visible;
4840   gint blink_timeout;
4841
4842   text_view = GTK_TEXT_VIEW (data);
4843   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
4844
4845   if (!GTK_WIDGET_HAS_FOCUS (text_view))
4846     {
4847       g_warning ("GtkTextView - did not receive focus-out-event. If you\n"
4848                  "connect a handler to this signal, it must return\n"
4849                  "FALSE so the text view gets the event as well");
4850
4851       gtk_text_view_check_cursor_blink (text_view);
4852
4853       return FALSE;
4854     }
4855
4856   g_assert (text_view->layout);
4857   g_assert (text_view->cursor_visible);
4858
4859   visible = gtk_text_layout_get_cursor_visible (text_view->layout);
4860
4861   blink_timeout = get_cursor_blink_timeout (text_view);
4862   if (priv->blink_time > 1000 * blink_timeout &&
4863       blink_timeout < G_MAXINT/1000)
4864     {
4865       /* we've blinked enough without the user doing anything, stop blinking */
4866       visible = 0;
4867       text_view->blink_timeout = 0;
4868     }
4869   else if (visible)
4870     text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER / CURSOR_DIVIDER,
4871                                               blink_cb,
4872                                               text_view);
4873   else
4874     {
4875       text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_ON_MULTIPLIER / CURSOR_DIVIDER,
4876                                                 blink_cb,
4877                                                 text_view);
4878       priv->blink_time += get_cursor_time (text_view);
4879     }
4880
4881   /* Block changed_handler while changing the layout's cursor visibility
4882    * because it would expose the whole paragraph. Instead, we expose
4883    * the cursor's area(s) manually below.
4884    */
4885   g_signal_handlers_block_by_func (text_view->layout,
4886                                    changed_handler,
4887                                    text_view);
4888   gtk_text_layout_set_cursor_visible (text_view->layout, !visible);
4889   g_signal_handlers_unblock_by_func (text_view->layout,
4890                                      changed_handler,
4891                                      text_view);
4892
4893   text_window_invalidate_cursors (text_view->text_window);
4894
4895   /* Remove ourselves */
4896   return FALSE;
4897 }
4898
4899
4900 static void
4901 gtk_text_view_stop_cursor_blink (GtkTextView *text_view)
4902 {
4903   if (text_view->blink_timeout)
4904     {
4905       g_source_remove (text_view->blink_timeout);
4906       text_view->blink_timeout = 0;
4907     }
4908 }
4909
4910 static void
4911 gtk_text_view_check_cursor_blink (GtkTextView *text_view)
4912 {
4913   if (text_view->layout != NULL &&
4914       text_view->cursor_visible &&
4915       GTK_WIDGET_HAS_FOCUS (text_view))
4916     {
4917       if (cursor_blinks (text_view))
4918         {
4919           if (text_view->blink_timeout == 0)
4920             {
4921               gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
4922
4923               text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER / CURSOR_DIVIDER,
4924                                                         blink_cb,
4925                                                         text_view);
4926             }
4927         }
4928       else
4929         {
4930           gtk_text_view_stop_cursor_blink (text_view);
4931           gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
4932         }
4933     }
4934   else
4935     {
4936       gtk_text_view_stop_cursor_blink (text_view);
4937       gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
4938     }
4939 }
4940
4941 static void
4942 gtk_text_view_pend_cursor_blink (GtkTextView *text_view)
4943 {
4944   if (text_view->layout != NULL &&
4945       text_view->cursor_visible &&
4946       GTK_WIDGET_HAS_FOCUS (text_view) &&
4947       cursor_blinks (text_view))
4948     {
4949       gtk_text_view_stop_cursor_blink (text_view);
4950       gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
4951
4952       text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_PEND_MULTIPLIER / CURSOR_DIVIDER,
4953                                                 blink_cb,
4954                                                 text_view);
4955     }
4956 }
4957
4958 static void
4959 gtk_text_view_reset_blink_time (GtkTextView *text_view)
4960 {
4961   GtkTextViewPrivate *priv;
4962
4963   priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
4964
4965   priv->blink_time = 0;
4966 }
4967
4968
4969 /*
4970  * Key binding handlers
4971  */
4972
4973 static gboolean
4974 gtk_text_view_move_iter_by_lines (GtkTextView *text_view,
4975                                   GtkTextIter *newplace,
4976                                   gint         count)
4977 {
4978   gboolean ret = TRUE;
4979
4980   while (count < 0)
4981     {
4982       ret = gtk_text_layout_move_iter_to_previous_line (text_view->layout, newplace);
4983       count++;
4984     }
4985
4986   while (count > 0)
4987     {
4988       ret = gtk_text_layout_move_iter_to_next_line (text_view->layout, newplace);
4989       count--;
4990     }
4991
4992   return ret;
4993 }
4994
4995 static void
4996 move_cursor (GtkTextView       *text_view,
4997              const GtkTextIter *new_location,
4998              gboolean           extend_selection)
4999 {
5000   if (extend_selection)
5001     gtk_text_buffer_move_mark_by_name (get_buffer (text_view),
5002                                        "insert",
5003                                        new_location);
5004   else
5005       gtk_text_buffer_place_cursor (get_buffer (text_view),
5006                                     new_location);
5007   gtk_text_view_check_cursor_blink (text_view);
5008 }
5009
5010 static void
5011 gtk_text_view_move_cursor_internal (GtkTextView     *text_view,
5012                                     GtkMovementStep  step,
5013                                     gint             count,
5014                                     gboolean         extend_selection)
5015 {
5016   GtkTextIter insert;
5017   GtkTextIter newplace;
5018   gint cursor_x_pos = 0;
5019   GtkDirectionType leave_direction = -1;
5020
5021   if (!text_view->cursor_visible)
5022     {
5023       GtkScrollStep scroll_step;
5024
5025       switch (step)
5026         {
5027         case GTK_MOVEMENT_VISUAL_POSITIONS:
5028           leave_direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
5029           /* fall through */
5030         case GTK_MOVEMENT_LOGICAL_POSITIONS:
5031         case GTK_MOVEMENT_WORDS:
5032           scroll_step = GTK_SCROLL_HORIZONTAL_STEPS;
5033           break;
5034         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
5035           scroll_step = GTK_SCROLL_HORIZONTAL_ENDS;
5036           break;
5037         case GTK_MOVEMENT_DISPLAY_LINES:
5038           leave_direction = count > 0 ? GTK_DIR_DOWN : GTK_DIR_UP;
5039           /* fall through */
5040         case GTK_MOVEMENT_PARAGRAPHS:
5041         case GTK_MOVEMENT_PARAGRAPH_ENDS:
5042           scroll_step = GTK_SCROLL_STEPS;
5043           break;
5044         case GTK_MOVEMENT_PAGES:
5045           scroll_step = GTK_SCROLL_PAGES;
5046           break;
5047         case GTK_MOVEMENT_HORIZONTAL_PAGES:
5048           scroll_step = GTK_SCROLL_HORIZONTAL_PAGES;
5049           break;
5050         case GTK_MOVEMENT_BUFFER_ENDS:
5051           scroll_step = GTK_SCROLL_ENDS;
5052           break;
5053         default:
5054           scroll_step = GTK_SCROLL_PAGES;
5055           break;
5056         }
5057
5058       if (!gtk_text_view_move_viewport (text_view, scroll_step, count))
5059         {
5060           if (leave_direction != -1 &&
5061               !gtk_widget_keynav_failed (GTK_WIDGET (text_view),
5062                                          leave_direction))
5063             {
5064               g_signal_emit_by_name (text_view, "move-focus", leave_direction);
5065             }
5066         }
5067
5068       return;
5069     }
5070
5071   gtk_text_view_reset_im_context (text_view);
5072
5073   if (step == GTK_MOVEMENT_PAGES)
5074     {
5075       if (!gtk_text_view_scroll_pages (text_view, count, extend_selection))
5076         gtk_widget_error_bell (GTK_WIDGET (text_view));
5077
5078       gtk_text_view_check_cursor_blink (text_view);
5079       gtk_text_view_pend_cursor_blink (text_view);
5080       return;
5081     }
5082   else if (step == GTK_MOVEMENT_HORIZONTAL_PAGES)
5083     {
5084       if (!gtk_text_view_scroll_hpages (text_view, count, extend_selection))
5085         gtk_widget_error_bell (GTK_WIDGET (text_view));
5086
5087       gtk_text_view_check_cursor_blink (text_view);
5088       gtk_text_view_pend_cursor_blink (text_view);
5089       return;
5090     }
5091
5092   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
5093                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5094   newplace = insert;
5095
5096   if (step == GTK_MOVEMENT_DISPLAY_LINES)
5097     gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, NULL);
5098
5099   switch (step)
5100     {
5101     case GTK_MOVEMENT_LOGICAL_POSITIONS:
5102       gtk_text_iter_forward_visible_cursor_positions (&newplace, count);
5103       break;
5104
5105     case GTK_MOVEMENT_VISUAL_POSITIONS:
5106       gtk_text_layout_move_iter_visually (text_view->layout,
5107                                           &newplace, count);
5108       break;
5109
5110     case GTK_MOVEMENT_WORDS:
5111       if (count < 0)
5112         gtk_text_iter_backward_visible_word_starts (&newplace, -count);
5113       else if (count > 0)
5114         {
5115           if (!gtk_text_iter_forward_visible_word_ends (&newplace, count))
5116             gtk_text_iter_forward_to_line_end (&newplace);
5117         }
5118       break;
5119
5120     case GTK_MOVEMENT_DISPLAY_LINES:
5121       if (count < 0)
5122         {
5123           leave_direction = GTK_DIR_UP;
5124
5125           if (gtk_text_view_move_iter_by_lines (text_view, &newplace, count))
5126             gtk_text_layout_move_iter_to_x (text_view->layout, &newplace, cursor_x_pos);
5127           else
5128             gtk_text_iter_set_line_offset (&newplace, 0);
5129         }
5130       if (count > 0)
5131         {
5132           leave_direction = GTK_DIR_DOWN;
5133
5134           if (gtk_text_view_move_iter_by_lines (text_view, &newplace, count))
5135             gtk_text_layout_move_iter_to_x (text_view->layout, &newplace, cursor_x_pos);
5136           else
5137             gtk_text_iter_forward_to_line_end (&newplace);
5138         }
5139       break;
5140
5141     case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
5142       if (count > 1)
5143         gtk_text_view_move_iter_by_lines (text_view, &newplace, --count);
5144       else if (count < -1)
5145         gtk_text_view_move_iter_by_lines (text_view, &newplace, ++count);
5146
5147       if (count != 0)
5148         gtk_text_layout_move_iter_to_line_end (text_view->layout, &newplace, count);
5149       break;
5150
5151     case GTK_MOVEMENT_PARAGRAPHS:
5152       if (count > 0)
5153         {
5154           if (!gtk_text_iter_ends_line (&newplace))
5155             {
5156               gtk_text_iter_forward_to_line_end (&newplace);
5157               --count;
5158             }
5159           gtk_text_iter_forward_visible_lines (&newplace, count);
5160           gtk_text_iter_forward_to_line_end (&newplace);
5161         }
5162       else if (count < 0)
5163         {
5164           if (gtk_text_iter_get_line_offset (&newplace) > 0)
5165             gtk_text_iter_set_line_offset (&newplace, 0);
5166           gtk_text_iter_forward_visible_lines (&newplace, count);
5167           gtk_text_iter_set_line_offset (&newplace, 0);
5168         }
5169       break;
5170
5171     case GTK_MOVEMENT_PARAGRAPH_ENDS:
5172       if (count > 0)
5173         {
5174           if (!gtk_text_iter_ends_line (&newplace))
5175             gtk_text_iter_forward_to_line_end (&newplace);
5176         }
5177       else if (count < 0)
5178         {
5179           gtk_text_iter_set_line_offset (&newplace, 0);
5180         }
5181       break;
5182
5183     case GTK_MOVEMENT_BUFFER_ENDS:
5184       if (count > 0)
5185         gtk_text_buffer_get_end_iter (get_buffer (text_view), &newplace);
5186       else if (count < 0)
5187         gtk_text_buffer_get_iter_at_offset (get_buffer (text_view), &newplace, 0);
5188      break;
5189
5190     default:
5191       break;
5192     }
5193
5194   /* call move_cursor() even if the cursor hasn't moved, since it
5195      cancels the selection
5196   */
5197   move_cursor (text_view, &newplace, extend_selection);
5198
5199   if (!gtk_text_iter_equal (&insert, &newplace))
5200     {
5201       DV(g_print (G_STRLOC": scrolling onscreen\n"));
5202       gtk_text_view_scroll_mark_onscreen (text_view,
5203                                           gtk_text_buffer_get_insert (get_buffer (text_view)));
5204
5205       if (step == GTK_MOVEMENT_DISPLAY_LINES)
5206         gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, -1);
5207     }
5208   else if (leave_direction != -1)
5209     {
5210       if (!gtk_widget_keynav_failed (GTK_WIDGET (text_view),
5211                                      leave_direction))
5212         {
5213           g_signal_emit_by_name (text_view, "move-focus", leave_direction);
5214         }
5215     }
5216   else
5217     {
5218       gtk_widget_error_bell (GTK_WIDGET (text_view));
5219     }
5220
5221   gtk_text_view_check_cursor_blink (text_view);
5222   gtk_text_view_pend_cursor_blink (text_view);
5223 }
5224
5225 static void
5226 gtk_text_view_move_cursor (GtkTextView     *text_view,
5227                            GtkMovementStep  step,
5228                            gint             count,
5229                            gboolean         extend_selection)
5230 {
5231   gtk_text_view_move_cursor_internal (text_view, step, count, extend_selection);
5232 }
5233
5234 static void
5235 gtk_text_view_page_horizontally (GtkTextView     *text_view,
5236                                  gint             count,
5237                                  gboolean         extend_selection)
5238 {
5239   gtk_text_view_move_cursor_internal (text_view, GTK_MOVEMENT_HORIZONTAL_PAGES,
5240                                       count, extend_selection);
5241 }
5242
5243
5244 static gboolean
5245 gtk_text_view_move_viewport (GtkTextView     *text_view,
5246                              GtkScrollStep    step,
5247                              gint             count)
5248 {
5249   GtkAdjustment *adjustment;
5250   gdouble increment;
5251
5252   switch (step)
5253     {
5254     case GTK_SCROLL_STEPS:
5255     case GTK_SCROLL_PAGES:
5256     case GTK_SCROLL_ENDS:
5257       adjustment = get_vadjustment (text_view);
5258       break;
5259     case GTK_SCROLL_HORIZONTAL_STEPS:
5260     case GTK_SCROLL_HORIZONTAL_PAGES:
5261     case GTK_SCROLL_HORIZONTAL_ENDS:
5262       adjustment = get_hadjustment (text_view);
5263       break;
5264     default:
5265       adjustment = get_vadjustment (text_view);
5266       break;
5267     }
5268
5269   switch (step)
5270     {
5271     case GTK_SCROLL_STEPS:
5272     case GTK_SCROLL_HORIZONTAL_STEPS:
5273       increment = adjustment->step_increment;
5274       break;
5275     case GTK_SCROLL_PAGES:
5276     case GTK_SCROLL_HORIZONTAL_PAGES:
5277       increment = adjustment->page_increment;
5278       break;
5279     case GTK_SCROLL_ENDS:
5280     case GTK_SCROLL_HORIZONTAL_ENDS:
5281       increment = adjustment->upper - adjustment->lower;
5282       break;
5283     default:
5284       increment = 0.0;
5285       break;
5286     }
5287
5288   return set_adjustment_clamped (adjustment, adjustment->value + count * increment);
5289 }
5290
5291 static void
5292 gtk_text_view_set_anchor (GtkTextView *text_view)
5293 {
5294   GtkTextIter insert;
5295
5296   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
5297                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5298
5299   gtk_text_buffer_create_mark (get_buffer (text_view), "anchor", &insert, TRUE);
5300 }
5301
5302 static gboolean
5303 gtk_text_view_scroll_pages (GtkTextView *text_view,
5304                             gint         count,
5305                             gboolean     extend_selection)
5306 {
5307   gdouble newval;
5308   gdouble oldval;
5309   GtkAdjustment *adj;
5310   gint cursor_x_pos, cursor_y_pos;
5311   GtkTextMark *insert_mark;
5312   GtkTextIter old_insert;
5313   GtkTextIter new_insert;
5314   GtkTextIter anchor;
5315   gint y0, y1;
5316
5317   g_return_val_if_fail (text_view->vadjustment != NULL, FALSE);
5318
5319   adj = text_view->vadjustment;
5320
5321   insert_mark = gtk_text_buffer_get_insert (get_buffer (text_view));
5322
5323   /* Make sure we start from the current cursor position, even
5324    * if it was offscreen, but don't queue more scrolls if we're
5325    * already behind.
5326    */
5327   if (text_view->pending_scroll)
5328     cancel_pending_scroll (text_view);
5329   else
5330     gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
5331
5332   /* Validate the region that will be brought into view by the cursor motion
5333    */
5334   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
5335                                     &old_insert, insert_mark);
5336
5337   if (count < 0)
5338     {
5339       gtk_text_view_get_first_para_iter (text_view, &anchor);
5340       y0 = adj->page_size;
5341       y1 = adj->page_size + count * adj->page_increment;
5342     }
5343   else
5344     {
5345       gtk_text_view_get_first_para_iter (text_view, &anchor);
5346       y0 = count * adj->page_increment + adj->page_size;
5347       y1 = 0;
5348     }
5349
5350   gtk_text_layout_validate_yrange (text_view->layout, &anchor, y0, y1);
5351   /* FIXME do we need to update the adjustment ranges here? */
5352
5353   new_insert = old_insert;
5354
5355   if (count < 0 && adj->value <= (adj->lower + 1e-12))
5356     {
5357       /* already at top, just be sure we are at offset 0 */
5358       gtk_text_buffer_get_start_iter (get_buffer (text_view), &new_insert);
5359       move_cursor (text_view, &new_insert, extend_selection);
5360     }
5361   else if (count > 0 && adj->value >= (adj->upper - adj->page_size - 1e-12))
5362     {
5363       /* already at bottom, just be sure we are at the end */
5364       gtk_text_buffer_get_end_iter (get_buffer (text_view), &new_insert);
5365       move_cursor (text_view, &new_insert, extend_selection);
5366     }
5367   else
5368     {
5369       gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, &cursor_y_pos);
5370
5371       oldval = adj->value;
5372       newval = adj->value;
5373
5374       newval += count * adj->page_increment;
5375
5376       set_adjustment_clamped (adj, newval);
5377       cursor_y_pos += adj->value - oldval;
5378
5379       gtk_text_layout_get_iter_at_pixel (text_view->layout, &new_insert, cursor_x_pos, cursor_y_pos);
5380       clamp_iter_onscreen (text_view, &new_insert);
5381       move_cursor (text_view, &new_insert, extend_selection);
5382
5383       gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, cursor_y_pos);
5384     }
5385
5386   /* Adjust to have the cursor _entirely_ onscreen, move_mark_onscreen
5387    * only guarantees 1 pixel onscreen.
5388    */
5389   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5390   gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
5391
5392   return !gtk_text_iter_equal (&old_insert, &new_insert);
5393 }
5394
5395 static gboolean
5396 gtk_text_view_scroll_hpages (GtkTextView *text_view,
5397                              gint         count,
5398                              gboolean     extend_selection)
5399 {
5400   gdouble newval;
5401   gdouble oldval;
5402   GtkAdjustment *adj;
5403   gint cursor_x_pos, cursor_y_pos;
5404   GtkTextMark *insert_mark;
5405   GtkTextIter old_insert;
5406   GtkTextIter new_insert;
5407   gint y, height;
5408
5409   g_return_val_if_fail (text_view->hadjustment != NULL, FALSE);
5410
5411   adj = text_view->hadjustment;
5412
5413   insert_mark = gtk_text_buffer_get_insert (get_buffer (text_view));
5414
5415   /* Make sure we start from the current cursor position, even
5416    * if it was offscreen, but don't queue more scrolls if we're
5417    * already behind.
5418    */
5419   if (text_view->pending_scroll)
5420     cancel_pending_scroll (text_view);
5421   else
5422     gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
5423
5424   /* Validate the line that we're moving within.
5425    */
5426   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
5427                                     &old_insert, insert_mark);
5428
5429   gtk_text_layout_get_line_yrange (text_view->layout, &old_insert, &y, &height);
5430   gtk_text_layout_validate_yrange (text_view->layout, &old_insert, y, y + height);
5431   /* FIXME do we need to update the adjustment ranges here? */
5432
5433   new_insert = old_insert;
5434
5435   if (count < 0 && adj->value <= (adj->lower + 1e-12))
5436     {
5437       /* already at far left, just be sure we are at offset 0 */
5438       gtk_text_iter_set_line_offset (&new_insert, 0);
5439       move_cursor (text_view, &new_insert, extend_selection);
5440     }
5441   else if (count > 0 && adj->value >= (adj->upper - adj->page_size - 1e-12))
5442     {
5443       /* already at far right, just be sure we are at the end */
5444       if (!gtk_text_iter_ends_line (&new_insert))
5445           gtk_text_iter_forward_to_line_end (&new_insert);
5446       move_cursor (text_view, &new_insert, extend_selection);
5447     }
5448   else
5449     {
5450       gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, &cursor_y_pos);
5451
5452       oldval = adj->value;
5453       newval = adj->value;
5454
5455       newval += count * adj->page_increment;
5456
5457       set_adjustment_clamped (adj, newval);
5458       cursor_x_pos += adj->value - oldval;
5459
5460       gtk_text_layout_get_iter_at_pixel (text_view->layout, &new_insert, cursor_x_pos, cursor_y_pos);
5461       clamp_iter_onscreen (text_view, &new_insert);
5462       move_cursor (text_view, &new_insert, extend_selection);
5463
5464       gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, cursor_y_pos);
5465     }
5466
5467   /*  FIXME for lines shorter than the overall widget width, this results in a
5468    *  "bounce" effect as we scroll to the right of the widget, then scroll
5469    *  back to get the end of the line onscreen.
5470    *      http://bugzilla.gnome.org/show_bug.cgi?id=68963
5471    */
5472
5473   /* Adjust to have the cursor _entirely_ onscreen, move_mark_onscreen
5474    * only guarantees 1 pixel onscreen.
5475    */
5476   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5477   gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
5478
5479   return !gtk_text_iter_equal (&old_insert, &new_insert);
5480 }
5481
5482 static gboolean
5483 whitespace (gunichar ch, gpointer user_data)
5484 {
5485   return (ch == ' ' || ch == '\t');
5486 }
5487
5488 static gboolean
5489 not_whitespace (gunichar ch, gpointer user_data)
5490 {
5491   return !whitespace (ch, user_data);
5492 }
5493
5494 static gboolean
5495 find_whitepace_region (const GtkTextIter *center,
5496                        GtkTextIter *start, GtkTextIter *end)
5497 {
5498   *start = *center;
5499   *end = *center;
5500
5501   if (gtk_text_iter_backward_find_char (start, not_whitespace, NULL, NULL))
5502     gtk_text_iter_forward_char (start); /* we want the first whitespace... */
5503   if (whitespace (gtk_text_iter_get_char (end), NULL))
5504     gtk_text_iter_forward_find_char (end, not_whitespace, NULL, NULL);
5505
5506   return !gtk_text_iter_equal (start, end);
5507 }
5508
5509 static void
5510 gtk_text_view_insert_at_cursor (GtkTextView *text_view,
5511                                 const gchar *str)
5512 {
5513   if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1,
5514                                                      text_view->editable))
5515     {
5516       gtk_widget_error_bell (GTK_WIDGET (text_view));
5517     }
5518 }
5519
5520 static void
5521 gtk_text_view_delete_from_cursor (GtkTextView   *text_view,
5522                                   GtkDeleteType  type,
5523                                   gint           count)
5524 {
5525   GtkTextIter insert;
5526   GtkTextIter start;
5527   GtkTextIter end;
5528   gboolean leave_one = FALSE;
5529
5530   gtk_text_view_reset_im_context (text_view);
5531
5532   if (type == GTK_DELETE_CHARS)
5533     {
5534       /* Char delete deletes the selection, if one exists */
5535       if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
5536                                             text_view->editable))
5537         return;
5538     }
5539
5540   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
5541                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5542
5543   start = insert;
5544   end = insert;
5545
5546   switch (type)
5547     {
5548     case GTK_DELETE_CHARS:
5549       gtk_text_iter_forward_cursor_positions (&end, count);
5550       break;
5551
5552     case GTK_DELETE_WORD_ENDS:
5553       if (count > 0)
5554         gtk_text_iter_forward_word_ends (&end, count);
5555       else if (count < 0)
5556         gtk_text_iter_backward_word_starts (&start, 0 - count);
5557       break;
5558
5559     case GTK_DELETE_WORDS:
5560       break;
5561
5562     case GTK_DELETE_DISPLAY_LINE_ENDS:
5563       break;
5564
5565     case GTK_DELETE_DISPLAY_LINES:
5566       break;
5567
5568     case GTK_DELETE_PARAGRAPH_ENDS:
5569       if (count > 0)
5570         {
5571           /* If we're already at a newline, we need to
5572            * simply delete that newline, instead of
5573            * moving to the next one.
5574            */
5575           if (gtk_text_iter_ends_line (&end))
5576             {
5577               gtk_text_iter_forward_line (&end);
5578               --count;
5579             }
5580
5581           while (count > 0)
5582             {
5583               if (!gtk_text_iter_forward_to_line_end (&end))
5584                 break;
5585
5586               --count;
5587             }
5588         }
5589       else if (count < 0)
5590         {
5591           if (gtk_text_iter_starts_line (&start))
5592             {
5593               gtk_text_iter_backward_line (&start);
5594               if (!gtk_text_iter_ends_line (&end))
5595                 gtk_text_iter_forward_to_line_end (&start);
5596             }
5597           else
5598             {
5599               gtk_text_iter_set_line_offset (&start, 0);
5600             }
5601           ++count;
5602
5603           gtk_text_iter_backward_lines (&start, -count);
5604         }
5605       break;
5606
5607     case GTK_DELETE_PARAGRAPHS:
5608       if (count > 0)
5609         {
5610           gtk_text_iter_set_line_offset (&start, 0);
5611           gtk_text_iter_forward_to_line_end (&end);
5612
5613           /* Do the lines beyond the first. */
5614           while (count > 1)
5615             {
5616               gtk_text_iter_forward_to_line_end (&end);
5617
5618               --count;
5619             }
5620         }
5621
5622       /* FIXME negative count? */
5623
5624       break;
5625
5626     case GTK_DELETE_WHITESPACE:
5627       {
5628         find_whitepace_region (&insert, &start, &end);
5629       }
5630       break;
5631
5632     default:
5633       break;
5634     }
5635
5636   if (!gtk_text_iter_equal (&start, &end))
5637     {
5638       gtk_text_buffer_begin_user_action (get_buffer (text_view));
5639
5640       if (gtk_text_buffer_delete_interactive (get_buffer (text_view), &start, &end,
5641                                               text_view->editable))
5642         {
5643           if (leave_one)
5644             gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view),
5645                                                           " ", 1,
5646                                                           text_view->editable);
5647         }
5648       else
5649         {
5650           gtk_widget_error_bell (GTK_WIDGET (text_view));
5651         }
5652
5653       gtk_text_buffer_end_user_action (get_buffer (text_view));
5654       gtk_text_view_set_virtual_cursor_pos (text_view, -1, -1);
5655
5656       DV(g_print (G_STRLOC": scrolling onscreen\n"));
5657       gtk_text_view_scroll_mark_onscreen (text_view,
5658                                           gtk_text_buffer_get_insert (get_buffer (text_view)));
5659     }
5660   else
5661     {
5662       gtk_widget_error_bell (GTK_WIDGET (text_view));
5663     }
5664 }
5665
5666 static void
5667 gtk_text_view_backspace (GtkTextView *text_view)
5668 {
5669   GtkTextIter insert;
5670
5671   gtk_text_view_reset_im_context (text_view);
5672
5673   /* Backspace deletes the selection, if one exists */
5674   if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
5675                                         text_view->editable))
5676     return;
5677
5678   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
5679                                     &insert,
5680                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5681
5682   if (gtk_text_buffer_backspace (get_buffer (text_view), &insert,
5683                                  TRUE, text_view->editable))
5684     {
5685       gtk_text_view_set_virtual_cursor_pos (text_view, -1, -1);
5686       DV(g_print (G_STRLOC": scrolling onscreen\n"));
5687       gtk_text_view_scroll_mark_onscreen (text_view,
5688                                           gtk_text_buffer_get_insert (get_buffer (text_view)));
5689     }
5690   else
5691     {
5692       gtk_widget_error_bell (GTK_WIDGET (text_view));
5693     }
5694 }
5695
5696 static void
5697 gtk_text_view_cut_clipboard (GtkTextView *text_view)
5698 {
5699   GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
5700                                                       GDK_SELECTION_CLIPBOARD);
5701
5702   gtk_text_buffer_cut_clipboard (get_buffer (text_view),
5703                                  clipboard,
5704                                  text_view->editable);
5705   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5706   gtk_text_view_scroll_mark_onscreen (text_view,
5707                                       gtk_text_buffer_get_insert (get_buffer (text_view)));
5708 }
5709
5710 static void
5711 gtk_text_view_copy_clipboard (GtkTextView *text_view)
5712 {
5713   GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
5714                                                       GDK_SELECTION_CLIPBOARD);
5715
5716   gtk_text_buffer_copy_clipboard (get_buffer (text_view),
5717                                   clipboard);
5718
5719   /* on copy do not scroll, we are already onscreen */
5720 }
5721
5722 static void
5723 gtk_text_view_paste_clipboard (GtkTextView *text_view)
5724 {
5725   GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
5726                                                       GDK_SELECTION_CLIPBOARD);
5727
5728   gtk_text_buffer_paste_clipboard (get_buffer (text_view),
5729                                    clipboard,
5730                                    NULL,
5731                                    text_view->editable);
5732 }
5733
5734 static void
5735 gtk_text_view_paste_done_handler (GtkTextBuffer *buffer,
5736                                   GtkClipboard  *clipboard,
5737                                   gpointer       data)
5738 {
5739   GtkTextView *text_view = data;
5740   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5741   gtk_text_view_scroll_mark_onscreen (text_view, gtk_text_buffer_get_insert (buffer));
5742 }
5743
5744 static void
5745 gtk_text_view_toggle_overwrite (GtkTextView *text_view)
5746 {
5747   if (text_view->text_window)
5748     text_window_invalidate_cursors (text_view->text_window);
5749
5750   text_view->overwrite_mode = !text_view->overwrite_mode;
5751
5752   if (text_view->layout)
5753     gtk_text_layout_set_overwrite_mode (text_view->layout,
5754                                         text_view->overwrite_mode && text_view->editable);
5755
5756   if (text_view->text_window)
5757     text_window_invalidate_cursors (text_view->text_window);
5758
5759   gtk_text_view_pend_cursor_blink (text_view);
5760
5761   g_object_notify (G_OBJECT (text_view), "overwrite");
5762 }
5763
5764 /**
5765  * gtk_text_view_get_overwrite:
5766  * @text_view: a #GtkTextView
5767  *
5768  * Returns whether the #GtkTextView is in overwrite mode or not.
5769  *
5770  * Return value: whether @text_view is in overwrite mode or not.
5771  *
5772  * Since: 2.4
5773  **/
5774 gboolean
5775 gtk_text_view_get_overwrite (GtkTextView *text_view)
5776 {
5777   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
5778
5779   return text_view->overwrite_mode;
5780 }
5781
5782 /**
5783  * gtk_text_view_set_overwrite:
5784  * @text_view: a #GtkTextView
5785  * @overwrite: %TRUE to turn on overwrite mode, %FALSE to turn it off
5786  *
5787  * Changes the #GtkTextView overwrite mode.
5788  *
5789  * Since: 2.4
5790  **/
5791 void
5792 gtk_text_view_set_overwrite (GtkTextView *text_view,
5793                              gboolean     overwrite)
5794 {
5795   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5796   overwrite = overwrite != FALSE;
5797
5798   if (text_view->overwrite_mode != overwrite)
5799     gtk_text_view_toggle_overwrite (text_view);
5800 }
5801
5802 /**
5803  * gtk_text_view_set_accepts_tab:
5804  * @text_view: A #GtkTextView
5805  * @accepts_tab: %TRUE if pressing the Tab key should insert a tab
5806  *    character, %FALSE, if pressing the Tab key should move the
5807  *    keyboard focus.
5808  *
5809  * Sets the behavior of the text widget when the Tab key is pressed.
5810  * If @accepts_tab is %TRUE, a tab character is inserted. If @accepts_tab
5811  * is %FALSE the keyboard focus is moved to the next widget in the focus
5812  * chain.
5813  *
5814  * Since: 2.4
5815  **/
5816 void
5817 gtk_text_view_set_accepts_tab (GtkTextView *text_view,
5818                                gboolean     accepts_tab)
5819 {
5820   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5821
5822   accepts_tab = accepts_tab != FALSE;
5823
5824   if (text_view->accepts_tab != accepts_tab)
5825     {
5826       text_view->accepts_tab = accepts_tab;
5827
5828       g_object_notify (G_OBJECT (text_view), "accepts-tab");
5829     }
5830 }
5831
5832 /**
5833  * gtk_text_view_get_accepts_tab:
5834  * @text_view: A #GtkTextView
5835  *
5836  * Returns whether pressing the Tab key inserts a tab characters.
5837  * gtk_text_view_set_accepts_tab().
5838  *
5839  * Return value: %TRUE if pressing the Tab key inserts a tab character,
5840  *   %FALSE if pressing the Tab key moves the keyboard focus.
5841  *
5842  * Since: 2.4
5843  **/
5844 gboolean
5845 gtk_text_view_get_accepts_tab (GtkTextView *text_view)
5846 {
5847   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
5848
5849   return text_view->accepts_tab;
5850 }
5851
5852 static void
5853 gtk_text_view_compat_move_focus (GtkTextView     *text_view,
5854                                  GtkDirectionType direction_type)
5855 {
5856   GSignalInvocationHint *hint = g_signal_get_invocation_hint (text_view);
5857
5858   /*  as of GTK+ 2.12, the "move-focus" signal has been moved to GtkWidget,
5859    *  the evil code below makes sure that both emitting the signal and
5860    *  calling the virtual function directly continue to work as expetcted
5861    */
5862
5863   if (hint->signal_id == g_signal_lookup ("move-focus", GTK_TYPE_WIDGET))
5864     {
5865       /*  if this is a signal emission, chain up  */
5866
5867       gboolean retval;
5868
5869       g_signal_chain_from_overridden_handler (text_view,
5870                                               direction_type, &retval);
5871     }
5872   else
5873     {
5874       /*  otherwise emit the signal, since somebody called the virtual
5875        *  function directly
5876        */
5877
5878       g_signal_emit_by_name (text_view, "move-focus", direction_type);
5879     }
5880 }
5881
5882 /*
5883  * Selections
5884  */
5885
5886 static void
5887 gtk_text_view_unselect (GtkTextView *text_view)
5888 {
5889   GtkTextIter insert;
5890
5891   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
5892                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
5893
5894   gtk_text_buffer_move_mark (get_buffer (text_view),
5895                              gtk_text_buffer_get_selection_bound (get_buffer (text_view)),
5896                              &insert);
5897 }
5898
5899 static void
5900 get_iter_at_pointer (GtkTextView *text_view,
5901                      GtkTextIter *iter,
5902                      gint        *x,
5903                      gint        *y)
5904 {
5905   gint xcoord, ycoord;
5906   GdkModifierType state;
5907
5908   gdk_window_get_pointer (text_view->text_window->bin_window,
5909                           &xcoord, &ycoord, &state);
5910
5911   gtk_text_layout_get_iter_at_pixel (text_view->layout,
5912                                      iter,
5913                                      xcoord + text_view->xoffset,
5914                                      ycoord + text_view->yoffset);
5915   if (x)
5916     *x = xcoord;
5917
5918   if (y)
5919     *y = ycoord;
5920 }
5921
5922 static void
5923 move_mark_to_pointer_and_scroll (GtkTextView *text_view,
5924                                  const gchar *mark_name)
5925 {
5926   GtkTextIter newplace;
5927   GtkTextMark *mark;
5928
5929   get_iter_at_pointer (text_view, &newplace, NULL, NULL);
5930
5931   mark = gtk_text_buffer_get_mark (get_buffer (text_view), mark_name);
5932
5933   /* This may invalidate the layout */
5934   DV(g_print (G_STRLOC": move mark\n"));
5935
5936   gtk_text_buffer_move_mark (get_buffer (text_view),
5937                              mark,
5938                              &newplace);
5939
5940   DV(g_print (G_STRLOC": scrolling onscreen\n"));
5941   gtk_text_view_scroll_mark_onscreen (text_view, mark);
5942
5943   DV (g_print ("first validate idle leaving %s is %d\n",
5944                G_STRLOC, text_view->first_validate_idle));
5945 }
5946
5947 static gboolean
5948 selection_scan_timeout (gpointer data)
5949 {
5950   GtkTextView *text_view;
5951
5952   text_view = GTK_TEXT_VIEW (data);
5953
5954   DV(g_print (G_STRLOC": calling move_mark_to_pointer_and_scroll\n"));
5955   gtk_text_view_scroll_mark_onscreen (text_view,
5956                                       gtk_text_buffer_get_insert (get_buffer (text_view)));
5957
5958   return TRUE; /* remain installed. */
5959 }
5960
5961 #define UPPER_OFFSET_ANCHOR 0.8
5962 #define LOWER_OFFSET_ANCHOR 0.2
5963
5964 static gboolean
5965 check_scroll (gdouble offset, GtkAdjustment *adj)
5966 {
5967   if ((offset > UPPER_OFFSET_ANCHOR &&
5968        adj->value + adj->page_size < adj->upper) ||
5969       (offset < LOWER_OFFSET_ANCHOR &&
5970        adj->value > adj->lower))
5971     return TRUE;
5972
5973   return FALSE;
5974 }
5975
5976 static gint
5977 drag_scan_timeout (gpointer data)
5978 {
5979   GtkTextView *text_view;
5980   GtkTextIter newplace;
5981   gint x, y, width, height;
5982   gdouble pointer_xoffset, pointer_yoffset;
5983
5984   text_view = GTK_TEXT_VIEW (data);
5985
5986   get_iter_at_pointer (text_view, &newplace, &x, &y);
5987   gdk_drawable_get_size (text_view->text_window->bin_window, &width, &height);
5988
5989   gtk_text_buffer_move_mark (get_buffer (text_view),
5990                              text_view->dnd_mark,
5991                              &newplace);
5992
5993   pointer_xoffset = (gdouble) x / width;
5994   pointer_yoffset = (gdouble) y / height;
5995
5996   if (check_scroll (pointer_xoffset, text_view->hadjustment) ||
5997       check_scroll (pointer_yoffset, text_view->vadjustment))
5998     {
5999       /* do not make offsets surpass lower nor upper anchors, this makes
6000        * scrolling speed relative to the distance of the pointer to the
6001        * anchors when it moves beyond them.
6002        */
6003       pointer_xoffset = CLAMP (pointer_xoffset, LOWER_OFFSET_ANCHOR, UPPER_OFFSET_ANCHOR);
6004       pointer_yoffset = CLAMP (pointer_yoffset, LOWER_OFFSET_ANCHOR, UPPER_OFFSET_ANCHOR);
6005
6006       gtk_text_view_scroll_to_mark (text_view,
6007                                     text_view->dnd_mark,
6008                                     0., TRUE, pointer_xoffset, pointer_yoffset);
6009     }
6010
6011   return TRUE;
6012 }
6013
6014 typedef enum
6015 {
6016   SELECT_CHARACTERS,
6017   SELECT_WORDS,
6018   SELECT_LINES
6019 } SelectionGranularity;
6020
6021 /*
6022  * Move @start and @end to the boundaries of the selection unit (indicated by
6023  * @granularity) which contained @start initially.
6024  * If the selction unit is SELECT_WORDS and @start is not contained in a word
6025  * the selection is extended to all the white spaces between the end of the
6026  * word preceding @start and the start of the one following.
6027  */
6028 static void
6029 extend_selection (GtkTextView *text_view,
6030                   SelectionGranularity granularity,
6031                   GtkTextIter *start,
6032                   GtkTextIter *end)
6033 {
6034   *end = *start;
6035
6036   if (granularity == SELECT_WORDS)
6037     {
6038       if (gtk_text_iter_inside_word (start))
6039         {
6040           if (!gtk_text_iter_starts_word (start))
6041             gtk_text_iter_backward_visible_word_start (start);
6042
6043           if (!gtk_text_iter_ends_word (end))
6044             {
6045               if (!gtk_text_iter_forward_visible_word_end (end))
6046                 gtk_text_iter_forward_to_end (end);
6047             }
6048         }
6049       else
6050         {
6051           GtkTextIter tmp;
6052
6053           tmp = *start;
6054           if (gtk_text_iter_backward_visible_word_start (&tmp))
6055             gtk_text_iter_forward_visible_word_end (&tmp);
6056
6057           if (gtk_text_iter_get_line (&tmp) == gtk_text_iter_get_line (start))
6058             *start = tmp;
6059           else
6060             gtk_text_iter_set_line_offset (start, 0);
6061
6062           tmp = *end;
6063           if (!gtk_text_iter_forward_visible_word_end (&tmp))
6064             gtk_text_iter_forward_to_end (&tmp);
6065
6066           if (gtk_text_iter_ends_word (&tmp))
6067             gtk_text_iter_backward_visible_word_start (&tmp);
6068
6069           if (gtk_text_iter_get_line (&tmp) == gtk_text_iter_get_line (end))
6070             *end = tmp;
6071           else
6072             gtk_text_iter_forward_to_line_end (end);
6073         }
6074     }
6075   else if (granularity == SELECT_LINES)
6076     {
6077       if (gtk_text_view_starts_display_line (text_view, start))
6078         {
6079           /* If on a display line boundary, we assume the user
6080            * clicked off the end of a line and we therefore select
6081            * the line before the boundary.
6082            */
6083           gtk_text_view_backward_display_line_start (text_view, start);
6084         }
6085       else
6086         {
6087           /* start isn't on the start of a line, so we move it to the
6088            * start, and move end to the end unless it's already there.
6089            */
6090           gtk_text_view_backward_display_line_start (text_view, start);
6091
6092           if (!gtk_text_view_starts_display_line (text_view, end))
6093             gtk_text_view_forward_display_line_end (text_view, end);
6094         }
6095     }
6096 }
6097
6098
6099 typedef struct
6100 {
6101   SelectionGranularity granularity;
6102   GtkTextMark *orig_start;
6103   GtkTextMark *orig_end;
6104 } SelectionData;
6105
6106 static void
6107 selection_data_free (SelectionData *data)
6108 {
6109   if (data->orig_start != NULL)
6110     gtk_text_buffer_delete_mark (gtk_text_mark_get_buffer (data->orig_start),
6111                                  data->orig_start);
6112   if (data->orig_end != NULL)
6113     gtk_text_buffer_delete_mark (gtk_text_mark_get_buffer (data->orig_end),
6114                                  data->orig_end);
6115   g_free (data);
6116 }
6117
6118 static gint
6119 selection_motion_event_handler (GtkTextView    *text_view,
6120                                 GdkEventMotion *event,
6121                                 SelectionData  *data)
6122 {
6123   gdk_event_request_motions (event);
6124
6125   if (data->granularity == SELECT_CHARACTERS)
6126     {
6127       move_mark_to_pointer_and_scroll (text_view, "insert");
6128     }
6129   else
6130     {
6131       GtkTextIter cursor, start, end;
6132       GtkTextIter orig_start, orig_end;
6133       GtkTextBuffer *buffer;
6134
6135       buffer = get_buffer (text_view);
6136
6137       gtk_text_buffer_get_iter_at_mark (buffer, &orig_start, data->orig_start);
6138       gtk_text_buffer_get_iter_at_mark (buffer, &orig_end, data->orig_end);
6139
6140       get_iter_at_pointer (text_view, &cursor, NULL, NULL);
6141
6142       start = cursor;
6143       extend_selection (text_view, data->granularity, &start, &end);
6144
6145       /* either the selection extends to the front, or end (or not) */
6146       if (gtk_text_iter_compare (&cursor, &orig_start) < 0)
6147         gtk_text_buffer_select_range (buffer, &start, &orig_end);
6148       else
6149         gtk_text_buffer_select_range (buffer, &end, &orig_start);
6150
6151       gtk_text_view_scroll_mark_onscreen (text_view,
6152                                           gtk_text_buffer_get_insert (buffer));
6153     }
6154
6155   /* If we had to scroll offscreen, insert a timeout to do so
6156    * again. Note that in the timeout, even if the mouse doesn't
6157    * move, due to this scroll xoffset/yoffset will have changed
6158    * and we'll need to scroll again.
6159    */
6160   if (text_view->scroll_timeout != 0) /* reset on every motion event */
6161     g_source_remove (text_view->scroll_timeout);
6162
6163   text_view->scroll_timeout =
6164     gdk_threads_add_timeout (50, selection_scan_timeout, text_view);
6165
6166   return TRUE;
6167 }
6168
6169 static void
6170 gtk_text_view_start_selection_drag (GtkTextView       *text_view,
6171                                     const GtkTextIter *iter,
6172                                     GdkEventButton    *button)
6173 {
6174   GtkTextIter cursor, ins, bound;
6175   GtkTextIter orig_start, orig_end;
6176   GtkTextBuffer *buffer;
6177   SelectionData *data;
6178
6179   if (text_view->selection_drag_handler != 0)
6180     return;
6181
6182   data = g_new0 (SelectionData, 1);
6183
6184   if (button->type == GDK_2BUTTON_PRESS)
6185     data->granularity = SELECT_WORDS;
6186   else if (button->type == GDK_3BUTTON_PRESS)
6187     data->granularity = SELECT_LINES;
6188   else
6189     data->granularity = SELECT_CHARACTERS;
6190
6191   gtk_grab_add (GTK_WIDGET (text_view));
6192
6193   buffer = get_buffer (text_view);
6194
6195   cursor = *iter;
6196   ins = cursor;
6197
6198   extend_selection (text_view, data->granularity, &ins, &bound);
6199   orig_start = ins;
6200   orig_end = bound;
6201
6202   if (button->state & GDK_SHIFT_MASK)
6203     {
6204       /* Extend selection */
6205       GtkTextIter old_ins, old_bound;
6206       GtkTextIter old_start, old_end;
6207
6208       gtk_text_buffer_get_iter_at_mark (buffer, &old_ins, gtk_text_buffer_get_insert (buffer));
6209       gtk_text_buffer_get_iter_at_mark (buffer, &old_bound, gtk_text_buffer_get_selection_bound (buffer));
6210       old_start = old_ins;
6211       old_end = old_bound;
6212       gtk_text_iter_order (&old_start, &old_end);
6213
6214       /* move the front cursor, if the mouse is in front of the selection. Should the
6215        * cursor however be inside the selection (this happens on tripple click) then we
6216        * move the side which was last moved (current insert mark) */
6217       if (gtk_text_iter_compare (&cursor, &old_start) <= 0 ||
6218           (gtk_text_iter_compare (&cursor, &old_end) < 0 &&
6219            gtk_text_iter_compare (&old_ins, &old_bound) <= 0))
6220         {
6221           bound = old_end;
6222           orig_start = old_end;
6223           orig_end = old_end;
6224         }
6225       else
6226         {
6227           ins = bound;
6228           bound = old_start;
6229           orig_end = bound;
6230           orig_start = bound;
6231         }
6232     }
6233
6234   gtk_text_buffer_select_range (buffer, &ins, &bound);
6235
6236   gtk_text_iter_order (&orig_start, &orig_end);
6237   data->orig_start = gtk_text_buffer_create_mark (buffer, NULL,
6238                                                   &orig_start, TRUE);
6239   data->orig_end = gtk_text_buffer_create_mark (buffer, NULL,
6240                                                 &orig_end, TRUE);
6241
6242   gtk_text_view_check_cursor_blink (text_view);
6243
6244   text_view->selection_drag_handler = g_signal_connect_data (text_view,
6245                                                              "motion-notify-event",
6246                                                              G_CALLBACK (selection_motion_event_handler),
6247                                                              data,
6248                                                              (GClosureNotify) selection_data_free, 0);
6249 }
6250
6251 /* returns whether we were really dragging */
6252 static gboolean
6253 gtk_text_view_end_selection_drag (GtkTextView    *text_view)
6254 {
6255   if (text_view->selection_drag_handler == 0)
6256     return FALSE;
6257
6258   g_signal_handler_disconnect (text_view, text_view->selection_drag_handler);
6259   text_view->selection_drag_handler = 0;
6260
6261   if (text_view->scroll_timeout != 0)
6262     {
6263       g_source_remove (text_view->scroll_timeout);
6264       text_view->scroll_timeout = 0;
6265     }
6266
6267   gtk_grab_remove (GTK_WIDGET (text_view));
6268
6269   return TRUE;
6270 }
6271
6272 /*
6273  * Layout utils
6274  */
6275
6276 static void
6277 gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
6278                                          GtkTextAttributes  *values,
6279                                          GtkStyle           *style)
6280 {
6281   values->appearance.bg_color = style->base[GTK_STATE_NORMAL];
6282   values->appearance.fg_color = style->text[GTK_STATE_NORMAL];
6283
6284   if (values->font)
6285     pango_font_description_free (values->font);
6286
6287   values->font = pango_font_description_copy (style->font_desc);
6288 }
6289
6290 static void
6291 gtk_text_view_check_keymap_direction (GtkTextView *text_view)
6292 {
6293   if (text_view->layout)
6294     {
6295       GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
6296       GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (text_view)));
6297       GtkTextDirection new_cursor_dir;
6298       GtkTextDirection new_keyboard_dir;
6299       gboolean split_cursor;
6300
6301       g_object_get (settings,
6302                     "gtk-split-cursor", &split_cursor,
6303                     NULL);
6304
6305       if (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_RTL)
6306         new_keyboard_dir = GTK_TEXT_DIR_RTL;
6307       else
6308         new_keyboard_dir  = GTK_TEXT_DIR_LTR;
6309
6310       if (split_cursor)
6311         new_cursor_dir = GTK_TEXT_DIR_NONE;
6312       else
6313         new_cursor_dir = new_keyboard_dir;
6314
6315       gtk_text_layout_set_cursor_direction (text_view->layout, new_cursor_dir);
6316       gtk_text_layout_set_keyboard_direction (text_view->layout, new_keyboard_dir);
6317     }
6318 }
6319
6320 static void
6321 gtk_text_view_ensure_layout (GtkTextView *text_view)
6322 {
6323   GtkWidget *widget;
6324
6325   widget = GTK_WIDGET (text_view);
6326
6327   if (text_view->layout == NULL)
6328     {
6329       GtkTextAttributes *style;
6330       PangoContext *ltr_context, *rtl_context;
6331       GSList *tmp_list;
6332
6333       DV(g_print(G_STRLOC"\n"));
6334
6335       text_view->layout = gtk_text_layout_new ();
6336
6337       g_signal_connect (text_view->layout,
6338                         "invalidated",
6339                         G_CALLBACK (invalidated_handler),
6340                         text_view);
6341
6342       g_signal_connect (text_view->layout,
6343                         "changed",
6344                         G_CALLBACK (changed_handler),
6345                         text_view);
6346
6347       g_signal_connect (text_view->layout,
6348                         "allocate-child",
6349                         G_CALLBACK (gtk_text_view_child_allocated),
6350                         text_view);
6351
6352       if (get_buffer (text_view))
6353         gtk_text_layout_set_buffer (text_view->layout, get_buffer (text_view));
6354
6355       if ((GTK_WIDGET_HAS_FOCUS (text_view) && text_view->cursor_visible))
6356         gtk_text_view_pend_cursor_blink (text_view);
6357       else
6358         gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
6359
6360       gtk_text_layout_set_overwrite_mode (text_view->layout,
6361                                           text_view->overwrite_mode && text_view->editable);
6362
6363       ltr_context = gtk_widget_create_pango_context (GTK_WIDGET (text_view));
6364       pango_context_set_base_dir (ltr_context, PANGO_DIRECTION_LTR);
6365       rtl_context = gtk_widget_create_pango_context (GTK_WIDGET (text_view));
6366       pango_context_set_base_dir (rtl_context, PANGO_DIRECTION_RTL);
6367
6368       gtk_text_layout_set_contexts (text_view->layout, ltr_context, rtl_context);
6369
6370       g_object_unref (ltr_context);
6371       g_object_unref (rtl_context);
6372
6373       gtk_text_view_check_keymap_direction (text_view);
6374
6375       style = gtk_text_attributes_new ();
6376
6377       gtk_widget_ensure_style (widget);
6378       gtk_text_view_set_attributes_from_style (text_view,
6379                                                style, widget->style);
6380
6381       style->pixels_above_lines = text_view->pixels_above_lines;
6382       style->pixels_below_lines = text_view->pixels_below_lines;
6383       style->pixels_inside_wrap = text_view->pixels_inside_wrap;
6384       style->left_margin = text_view->left_margin;
6385       style->right_margin = text_view->right_margin;
6386       style->indent = text_view->indent;
6387       style->tabs = text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
6388
6389       style->wrap_mode = text_view->wrap_mode;
6390       style->justification = text_view->justify;
6391       style->direction = gtk_widget_get_direction (GTK_WIDGET (text_view));
6392
6393       gtk_text_layout_set_default_style (text_view->layout, style);
6394
6395       gtk_text_attributes_unref (style);
6396
6397       /* Set layout for all anchored children */
6398
6399       tmp_list = text_view->children;
6400       while (tmp_list != NULL)
6401         {
6402           GtkTextViewChild *vc = tmp_list->data;
6403
6404           if (vc->anchor)
6405             {
6406               gtk_text_anchored_child_set_layout (vc->widget,
6407                                                   text_view->layout);
6408               /* vc may now be invalid! */
6409             }
6410
6411           tmp_list = g_slist_next (tmp_list);
6412         }
6413
6414       gtk_text_view_invalidate (text_view);
6415     }
6416 }
6417
6418 /**
6419  * gtk_text_view_get_default_attributes:
6420  * @text_view: a #GtkTextView
6421  *
6422  * Obtains a copy of the default text attributes. These are the
6423  * attributes used for text unless a tag overrides them.
6424  * You'd typically pass the default attributes in to
6425  * gtk_text_iter_get_attributes() in order to get the
6426  * attributes in effect at a given text position.
6427  *
6428  * The return value is a copy owned by the caller of this function,
6429  * and should be freed.
6430  *
6431  * Return value: a new #GtkTextAttributes
6432  **/
6433 GtkTextAttributes*
6434 gtk_text_view_get_default_attributes (GtkTextView *text_view)
6435 {
6436   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
6437
6438   gtk_text_view_ensure_layout (text_view);
6439
6440   return gtk_text_attributes_copy (text_view->layout->default_style);
6441 }
6442
6443 static void
6444 gtk_text_view_destroy_layout (GtkTextView *text_view)
6445 {
6446   if (text_view->layout)
6447     {
6448       GSList *tmp_list;
6449
6450       gtk_text_view_remove_validate_idles (text_view);
6451
6452       g_signal_handlers_disconnect_by_func (text_view->layout,
6453                                             invalidated_handler,
6454                                             text_view);
6455       g_signal_handlers_disconnect_by_func (text_view->layout,
6456                                             changed_handler,
6457                                             text_view);
6458
6459       /* Remove layout from all anchored children */
6460       tmp_list = text_view->children;
6461       while (tmp_list != NULL)
6462         {
6463           GtkTextViewChild *vc = tmp_list->data;
6464
6465           if (vc->anchor)
6466             {
6467               gtk_text_anchored_child_set_layout (vc->widget, NULL);
6468               /* vc may now be invalid! */
6469             }
6470
6471           tmp_list = g_slist_next (tmp_list);
6472         }
6473
6474       gtk_text_view_stop_cursor_blink (text_view);
6475       gtk_text_view_end_selection_drag (text_view);
6476
6477       g_object_unref (text_view->layout);
6478       text_view->layout = NULL;
6479     }
6480 }
6481
6482 static void
6483 gtk_text_view_reset_im_context (GtkTextView *text_view)
6484 {
6485   if (text_view->need_im_reset)
6486     {
6487       text_view->need_im_reset = FALSE;
6488       gtk_im_context_reset (text_view->im_context);
6489     }
6490 }
6491
6492 /*
6493  * DND feature
6494  */
6495
6496 static void
6497 drag_begin_cb (GtkWidget      *widget,
6498                GdkDragContext *context,
6499                gpointer        data)
6500 {
6501   GtkTextView   *text_view = GTK_TEXT_VIEW (widget);
6502   GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
6503   GtkTextIter    start;
6504   GtkTextIter    end;
6505   GdkPixmap     *pixmap = NULL;
6506
6507   g_signal_handlers_disconnect_by_func (widget, drag_begin_cb, NULL);
6508
6509   if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
6510     pixmap = _gtk_text_util_create_rich_drag_icon (widget, buffer, &start, &end);
6511
6512   if (pixmap)
6513     {
6514       gtk_drag_set_icon_pixmap (context,
6515                                 gdk_drawable_get_colormap (pixmap),
6516                                 pixmap,
6517                                 NULL,
6518                                 -2, -2);
6519       g_object_unref (pixmap);
6520     }
6521   else
6522     {
6523       gtk_drag_set_icon_default (context);
6524     }
6525 }
6526
6527 static void
6528 gtk_text_view_start_selection_dnd (GtkTextView       *text_view,
6529                                    const GtkTextIter *iter,
6530                                    GdkEventMotion    *event)
6531 {
6532   GtkTargetList *target_list;
6533
6534   text_view->drag_start_x = -1;
6535   text_view->drag_start_y = -1;
6536   text_view->pending_place_cursor_button = 0;
6537
6538   target_list = gtk_text_buffer_get_copy_target_list (get_buffer (text_view));
6539
6540   g_signal_connect (text_view, "drag-begin",
6541                     G_CALLBACK (drag_begin_cb), NULL);
6542   gtk_drag_begin (GTK_WIDGET (text_view), target_list,
6543                   GDK_ACTION_COPY | GDK_ACTION_MOVE,
6544                   1, (GdkEvent*)event);
6545 }
6546
6547 static void
6548 gtk_text_view_drag_begin (GtkWidget        *widget,
6549                           GdkDragContext   *context)
6550 {
6551   /* do nothing */
6552 }
6553
6554 static void
6555 gtk_text_view_drag_end (GtkWidget        *widget,
6556                         GdkDragContext   *context)
6557 {
6558 }
6559
6560 static void
6561 gtk_text_view_drag_data_get (GtkWidget        *widget,
6562                              GdkDragContext   *context,
6563                              GtkSelectionData *selection_data,
6564                              guint             info,
6565                              guint             time)
6566 {
6567   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
6568   GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
6569
6570   if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
6571     {
6572       gtk_selection_data_set (selection_data,
6573                               gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"),
6574                               8, /* bytes */
6575                               (void*)&buffer,
6576                               sizeof (buffer));
6577     }
6578   else if (info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
6579     {
6580       GtkTextIter start;
6581       GtkTextIter end;
6582       guint8 *str = NULL;
6583       gsize len;
6584
6585       if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
6586         {
6587           /* Extract the selected text */
6588           str = gtk_text_buffer_serialize (buffer, buffer,
6589                                            selection_data->target,
6590                                            &start, &end,
6591                                            &len);
6592         }
6593
6594       if (str)
6595         {
6596           gtk_selection_data_set (selection_data,
6597                                   selection_data->target,
6598                                   8, /* bytes */
6599                                   (guchar *) str, len);
6600           g_free (str);
6601         }
6602     }
6603   else
6604     {
6605       GtkTextIter start;
6606       GtkTextIter end;
6607       gchar *str = NULL;
6608
6609       if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
6610         {
6611           /* Extract the selected text */
6612           str = gtk_text_iter_get_visible_text (&start, &end);
6613         }
6614
6615       if (str)
6616         {
6617           gtk_selection_data_set_text (selection_data, str, -1);
6618           g_free (str);
6619         }
6620     }
6621 }
6622
6623 static void
6624 gtk_text_view_drag_data_delete (GtkWidget        *widget,
6625                                 GdkDragContext   *context)
6626 {
6627   gtk_text_buffer_delete_selection (GTK_TEXT_VIEW (widget)->buffer,
6628                                     TRUE, GTK_TEXT_VIEW (widget)->editable);
6629 }
6630
6631 static void
6632 gtk_text_view_drag_leave (GtkWidget        *widget,
6633                           GdkDragContext   *context,
6634                           guint             time)
6635 {
6636   GtkTextView *text_view;
6637
6638   text_view = GTK_TEXT_VIEW (widget);
6639
6640   gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
6641
6642   if (text_view->scroll_timeout != 0)
6643     g_source_remove (text_view->scroll_timeout);
6644
6645   text_view->scroll_timeout = 0;
6646 }
6647
6648 static gboolean
6649 gtk_text_view_drag_motion (GtkWidget        *widget,
6650                            GdkDragContext   *context,
6651                            gint              x,
6652                            gint              y,
6653                            guint             time)
6654 {
6655   GtkTextIter newplace;
6656   GtkTextView *text_view;
6657   GtkTextIter start;
6658   GtkTextIter end;
6659   GdkRectangle target_rect;
6660   gint bx, by;
6661   GdkAtom target;
6662   GdkDragAction suggested_action = 0;
6663
6664   text_view = GTK_TEXT_VIEW (widget);
6665
6666   target_rect = text_view->text_window->allocation;
6667
6668   if (x < target_rect.x ||
6669       y < target_rect.y ||
6670       x > (target_rect.x + target_rect.width) ||
6671       y > (target_rect.y + target_rect.height))
6672     return FALSE; /* outside the text window, allow parent widgets to handle event */
6673
6674   gtk_text_view_window_to_buffer_coords (text_view,
6675                                          GTK_TEXT_WINDOW_WIDGET,
6676                                          x, y,
6677                                          &bx, &by);
6678
6679   gtk_text_layout_get_iter_at_pixel (text_view->layout,
6680                                      &newplace,
6681                                      bx, by);
6682
6683   target = gtk_drag_dest_find_target (widget, context,
6684                                       gtk_drag_dest_get_target_list (widget));
6685
6686   if (target == GDK_NONE)
6687     {
6688       /* can't accept any of the offered targets */
6689     }
6690   else if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
6691                                                  &start, &end) &&
6692            gtk_text_iter_compare (&newplace, &start) >= 0 &&
6693            gtk_text_iter_compare (&newplace, &end) <= 0)
6694     {
6695       /* We're inside the selection. */
6696     }
6697   else
6698     {
6699       if (gtk_text_iter_can_insert (&newplace, text_view->editable))
6700         {
6701           GtkWidget *source_widget;
6702
6703           suggested_action = context->suggested_action;
6704
6705           source_widget = gtk_drag_get_source_widget (context);
6706
6707           if (source_widget == widget)
6708             {
6709               /* Default to MOVE, unless the user has
6710                * pressed ctrl or alt to affect available actions
6711                */
6712               if ((context->actions & GDK_ACTION_MOVE) != 0)
6713                 suggested_action = GDK_ACTION_MOVE;
6714             }
6715         }
6716       else
6717         {
6718           /* Can't drop here. */
6719         }
6720     }
6721
6722   if (suggested_action != 0)
6723     {
6724       gtk_text_mark_set_visible (text_view->dnd_mark,
6725                                  text_view->cursor_visible);
6726
6727       gdk_drag_status (context, suggested_action, time);
6728     }
6729   else
6730     {
6731       gdk_drag_status (context, 0, time);
6732       gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
6733     }
6734
6735   if (!text_view->scroll_timeout)
6736     text_view->scroll_timeout =
6737       gdk_threads_add_timeout (100, drag_scan_timeout, text_view);
6738
6739   /* TRUE return means don't propagate the drag motion to parent
6740    * widgets that may also be drop sites.
6741    */
6742   return TRUE;
6743 }
6744
6745 static gboolean
6746 gtk_text_view_drag_drop (GtkWidget        *widget,
6747                          GdkDragContext   *context,
6748                          gint              x,
6749                          gint              y,
6750                          guint             time)
6751 {
6752   GtkTextView *text_view;
6753   GtkTextIter drop_point;
6754   GdkAtom target = GDK_NONE;
6755
6756   text_view = GTK_TEXT_VIEW (widget);
6757
6758   if (text_view->scroll_timeout != 0)
6759     g_source_remove (text_view->scroll_timeout);
6760
6761   text_view->scroll_timeout = 0;
6762
6763   gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
6764
6765   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
6766                                     &drop_point,
6767                                     text_view->dnd_mark);
6768
6769   if (gtk_text_iter_can_insert (&drop_point, text_view->editable))
6770     target = gtk_drag_dest_find_target (widget, context, NULL);
6771
6772   if (target != GDK_NONE)
6773     gtk_drag_get_data (widget, context, target, time);
6774   else
6775     gtk_drag_finish (context, FALSE, FALSE, time);
6776
6777   return TRUE;
6778 }
6779
6780 static void
6781 insert_text_data (GtkTextView      *text_view,
6782                   GtkTextIter      *drop_point,
6783                   GtkSelectionData *selection_data)
6784 {
6785   guchar *str;
6786
6787   str = gtk_selection_data_get_text (selection_data);
6788
6789   if (str)
6790     {
6791       if (!gtk_text_buffer_insert_interactive (get_buffer (text_view),
6792                                                drop_point, (gchar *) str, -1,
6793                                                text_view->editable))
6794         {
6795           gtk_widget_error_bell (GTK_WIDGET (text_view));
6796         }
6797
6798       g_free (str);
6799     }
6800 }
6801
6802 static void
6803 gtk_text_view_drag_data_received (GtkWidget        *widget,
6804                                   GdkDragContext   *context,
6805                                   gint              x,
6806                                   gint              y,
6807                                   GtkSelectionData *selection_data,
6808                                   guint             info,
6809                                   guint             time)
6810 {
6811   GtkTextIter drop_point;
6812   GtkTextView *text_view;
6813   gboolean success = FALSE;
6814   GtkTextBuffer *buffer = NULL;
6815
6816   text_view = GTK_TEXT_VIEW (widget);
6817
6818   if (!text_view->dnd_mark)
6819     goto done;
6820
6821   buffer = get_buffer (text_view);
6822
6823   gtk_text_buffer_get_iter_at_mark (buffer,
6824                                     &drop_point,
6825                                     text_view->dnd_mark);
6826
6827   if (!gtk_text_iter_can_insert (&drop_point, text_view->editable))
6828     goto done;
6829
6830   success = TRUE;
6831
6832   gtk_text_buffer_begin_user_action (buffer);
6833
6834   if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
6835     {
6836       GtkTextBuffer *src_buffer = NULL;
6837       GtkTextIter start, end;
6838       gboolean copy_tags = TRUE;
6839
6840       if (selection_data->length != sizeof (src_buffer))
6841         return;
6842
6843       memcpy (&src_buffer, selection_data->data, sizeof (src_buffer));
6844
6845       if (src_buffer == NULL)
6846         return;
6847
6848       g_return_if_fail (GTK_IS_TEXT_BUFFER (src_buffer));
6849
6850       if (gtk_text_buffer_get_tag_table (src_buffer) !=
6851           gtk_text_buffer_get_tag_table (buffer))
6852         {
6853           /*  try to find a suitable rich text target instead  */
6854           GdkAtom *atoms;
6855           gint     n_atoms;
6856           GList   *list;
6857           GdkAtom  target = GDK_NONE;
6858
6859           copy_tags = FALSE;
6860
6861           atoms = gtk_text_buffer_get_deserialize_formats (buffer, &n_atoms);
6862
6863           for (list = context->targets; list; list = g_list_next (list))
6864             {
6865               gint i;
6866
6867               for (i = 0; i < n_atoms; i++)
6868                 if (GUINT_TO_POINTER (atoms[i]) == list->data)
6869                   {
6870                     target = atoms[i];
6871                     break;
6872                   }
6873             }
6874
6875           g_free (atoms);
6876
6877           if (target != GDK_NONE)
6878             {
6879               gtk_drag_get_data (widget, context, target, time);
6880               gtk_text_buffer_end_user_action (buffer);
6881               return;
6882             }
6883         }
6884
6885       if (gtk_text_buffer_get_selection_bounds (src_buffer,
6886                                                 &start,
6887                                                 &end))
6888         {
6889           if (copy_tags)
6890             gtk_text_buffer_insert_range_interactive (buffer,
6891                                                       &drop_point,
6892                                                       &start,
6893                                                       &end,
6894                                                       text_view->editable);
6895           else
6896             {
6897               gchar *str;
6898
6899               str = gtk_text_iter_get_visible_text (&start, &end);
6900               gtk_text_buffer_insert_interactive (buffer,
6901                                                   &drop_point, str, -1,
6902                                                   text_view->editable);
6903               g_free (str);
6904             }
6905         }
6906     }
6907   else if (selection_data->length > 0 &&
6908            info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
6909     {
6910       gboolean retval;
6911       GError *error = NULL;
6912
6913       retval = gtk_text_buffer_deserialize (buffer, buffer,
6914                                             selection_data->target,
6915                                             &drop_point,
6916                                             (guint8 *) selection_data->data,
6917                                             selection_data->length,
6918                                             &error);
6919
6920       if (!retval)
6921         {
6922           g_warning ("error pasting: %s\n", error->message);
6923           g_clear_error (&error);
6924         }
6925     }
6926   else
6927     insert_text_data (text_view, &drop_point, selection_data);
6928
6929  done:
6930   gtk_drag_finish (context, success,
6931                    success && context->action == GDK_ACTION_MOVE,
6932                    time);
6933
6934   if (success)
6935     {
6936       gtk_text_buffer_get_iter_at_mark (buffer,
6937                                         &drop_point,
6938                                         text_view->dnd_mark);
6939       gtk_text_buffer_place_cursor (buffer, &drop_point);
6940
6941       gtk_text_buffer_end_user_action (buffer);
6942     }
6943 }
6944
6945 static GtkAdjustment*
6946 get_hadjustment (GtkTextView *text_view)
6947 {
6948   if (text_view->hadjustment == NULL)
6949     gtk_text_view_set_scroll_adjustments (text_view,
6950                                           NULL, /* forces creation */
6951                                           text_view->vadjustment);
6952
6953   return text_view->hadjustment;
6954 }
6955
6956 static GtkAdjustment*
6957 get_vadjustment (GtkTextView *text_view)
6958 {
6959   if (text_view->vadjustment == NULL)
6960     gtk_text_view_set_scroll_adjustments (text_view,
6961                                           text_view->hadjustment,
6962                                           NULL); /* forces creation */
6963   return text_view->vadjustment;
6964 }
6965
6966
6967 static void
6968 gtk_text_view_set_scroll_adjustments (GtkTextView   *text_view,
6969                                       GtkAdjustment *hadj,
6970                                       GtkAdjustment *vadj)
6971 {
6972   gboolean need_adjust = FALSE;
6973
6974   if (hadj)
6975     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
6976   else
6977     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
6978   if (vadj)
6979     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
6980   else
6981     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
6982
6983   if (text_view->hadjustment && (text_view->hadjustment != hadj))
6984     {
6985       g_signal_handlers_disconnect_by_func (text_view->hadjustment,
6986                                             gtk_text_view_value_changed,
6987                                             text_view);
6988       g_object_unref (text_view->hadjustment);
6989     }
6990
6991   if (text_view->vadjustment && (text_view->vadjustment != vadj))
6992     {
6993       g_signal_handlers_disconnect_by_func (text_view->vadjustment,
6994                                             gtk_text_view_value_changed,
6995                                             text_view);
6996       g_object_unref (text_view->vadjustment);
6997     }
6998
6999   if (text_view->hadjustment != hadj)
7000     {
7001       text_view->hadjustment = hadj;
7002       g_object_ref_sink (text_view->hadjustment);
7003
7004       g_signal_connect (text_view->hadjustment, "value-changed",
7005                         G_CALLBACK (gtk_text_view_value_changed),
7006                         text_view);
7007       need_adjust = TRUE;
7008     }
7009
7010   if (text_view->vadjustment != vadj)
7011     {
7012       text_view->vadjustment = vadj;
7013       g_object_ref_sink (text_view->vadjustment);
7014
7015       g_signal_connect (text_view->vadjustment, "value-changed",
7016                         G_CALLBACK (gtk_text_view_value_changed),
7017                         text_view);
7018       need_adjust = TRUE;
7019     }
7020
7021   if (need_adjust)
7022     gtk_text_view_value_changed (NULL, text_view);
7023 }
7024
7025 /* FIXME this adjust_allocation is a big cut-and-paste from
7026  * GtkCList, needs to be some "official" way to do this
7027  * factored out.
7028  */
7029 typedef struct
7030 {
7031   GdkWindow *window;
7032   int dx;
7033   int dy;
7034 } ScrollData;
7035
7036 /* The window to which widget->window is relative */
7037 #define ALLOCATION_WINDOW(widget)               \
7038    (GTK_WIDGET_NO_WINDOW (widget) ?             \
7039     (widget)->window :                          \
7040      gdk_window_get_parent ((widget)->window))
7041
7042 static void
7043 adjust_allocation_recurse (GtkWidget *widget,
7044                            gpointer   data)
7045 {
7046   ScrollData *scroll_data = data;
7047
7048   /* Need to really size allocate instead of just poking
7049    * into widget->allocation if the widget is not realized.
7050    * FIXME someone figure out why this was.
7051    */
7052   if (!GTK_WIDGET_REALIZED (widget))
7053     {
7054       if (GTK_WIDGET_VISIBLE (widget))
7055         {
7056           GdkRectangle tmp_rectangle = widget->allocation;
7057           tmp_rectangle.x += scroll_data->dx;
7058           tmp_rectangle.y += scroll_data->dy;
7059
7060           gtk_widget_size_allocate (widget, &tmp_rectangle);
7061         }
7062     }
7063   else
7064     {
7065       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
7066         {
7067           widget->allocation.x += scroll_data->dx;
7068           widget->allocation.y += scroll_data->dy;
7069
7070           if (GTK_IS_CONTAINER (widget))
7071             gtk_container_forall (GTK_CONTAINER (widget),
7072                                   adjust_allocation_recurse,
7073                                   data);
7074         }
7075     }
7076 }
7077
7078 static void
7079 adjust_allocation (GtkWidget *widget,
7080                    int        dx,
7081                    int        dy)
7082 {
7083   ScrollData scroll_data;
7084
7085   if (GTK_WIDGET_REALIZED (widget))
7086     scroll_data.window = ALLOCATION_WINDOW (widget);
7087   else
7088     scroll_data.window = NULL;
7089
7090   scroll_data.dx = dx;
7091   scroll_data.dy = dy;
7092
7093   adjust_allocation_recurse (widget, &scroll_data);
7094 }
7095
7096 static void
7097 gtk_text_view_value_changed (GtkAdjustment *adj,
7098                              GtkTextView   *text_view)
7099 {
7100   GtkTextIter iter;
7101   gint line_top;
7102   gint dx = 0;
7103   gint dy = 0;
7104
7105   /* Note that we oddly call this function with adj == NULL
7106    * sometimes
7107    */
7108
7109   text_view->onscreen_validated = FALSE;
7110
7111   DV(g_print(">Scroll offset changed %s/%g, onscreen_validated = FALSE ("G_STRLOC")\n",
7112              adj == text_view->hadjustment ? "hadj" : adj == text_view->vadjustment ? "vadj" : "none",
7113              adj ? adj->value : 0.0));
7114
7115   if (adj == text_view->hadjustment)
7116     {
7117       dx = text_view->xoffset - (gint)adj->value;
7118       text_view->xoffset = adj->value;
7119
7120       /* If the change is due to a size change we need
7121        * to invalidate the entire text window because there might be
7122        * right-aligned or centered text
7123        */
7124       if (text_view->width_changed)
7125         {
7126           if (GTK_WIDGET_REALIZED (text_view))
7127             gdk_window_invalidate_rect (text_view->text_window->bin_window, NULL, FALSE);
7128
7129           text_view->width_changed = FALSE;
7130         }
7131     }
7132   else if (adj == text_view->vadjustment)
7133     {
7134       dy = text_view->yoffset - (gint)adj->value;
7135       text_view->yoffset = adj->value;
7136
7137       if (text_view->layout)
7138         {
7139           gtk_text_layout_get_line_at_y (text_view->layout, &iter, adj->value, &line_top);
7140
7141           gtk_text_buffer_move_mark (get_buffer (text_view), text_view->first_para_mark, &iter);
7142
7143           text_view->first_para_pixels = adj->value - line_top;
7144         }
7145     }
7146
7147   if (dx != 0 || dy != 0)
7148     {
7149       GSList *tmp_list;
7150
7151       if (GTK_WIDGET_REALIZED (text_view))
7152         {
7153           if (dy != 0)
7154             {
7155               if (text_view->left_window)
7156                 text_window_scroll (text_view->left_window, 0, dy);
7157               if (text_view->right_window)
7158                 text_window_scroll (text_view->right_window, 0, dy);
7159             }
7160
7161           if (dx != 0)
7162             {
7163               if (text_view->top_window)
7164                 text_window_scroll (text_view->top_window, dx, 0);
7165               if (text_view->bottom_window)
7166                 text_window_scroll (text_view->bottom_window, dx, 0);
7167             }
7168
7169           /* It looks nicer to scroll the main area last, because
7170            * it takes a while, and making the side areas update
7171            * afterward emphasizes the slowness of scrolling the
7172            * main area.
7173            */
7174           text_window_scroll (text_view->text_window, dx, dy);
7175         }
7176
7177       /* Children are now "moved" in the text window, poke
7178        * into widget->allocation for each child
7179        */
7180       tmp_list = text_view->children;
7181       while (tmp_list != NULL)
7182         {
7183           GtkTextViewChild *child = tmp_list->data;
7184
7185           if (child->anchor)
7186             adjust_allocation (child->widget, dx, dy);
7187
7188           tmp_list = g_slist_next (tmp_list);
7189         }
7190     }
7191
7192   /* This could result in invalidation, which would install the
7193    * first_validate_idle, which would validate onscreen;
7194    * but we're going to go ahead and validate here, so
7195    * first_validate_idle shouldn't have anything to do.
7196    */
7197   gtk_text_view_update_layout_width (text_view);
7198
7199   /* We also update the IM spot location here, since the IM context
7200    * might do something that leads to validation.
7201    */
7202   gtk_text_view_update_im_spot_location (text_view);
7203
7204   /* note that validation of onscreen could invoke this function
7205    * recursively, by scrolling to maintain first_para, or in response
7206    * to updating the layout width, however there is no problem with
7207    * that, or shouldn't be.
7208    */
7209   gtk_text_view_validate_onscreen (text_view);
7210
7211   /* process exposes */
7212   if (GTK_WIDGET_REALIZED (text_view))
7213     {
7214       DV (g_print ("Processing updates (%s)\n", G_STRLOC));
7215
7216       if (text_view->left_window)
7217         gdk_window_process_updates (text_view->left_window->bin_window, TRUE);
7218
7219       if (text_view->right_window)
7220         gdk_window_process_updates (text_view->right_window->bin_window, TRUE);
7221
7222       if (text_view->top_window)
7223         gdk_window_process_updates (text_view->top_window->bin_window, TRUE);
7224
7225       if (text_view->bottom_window)
7226         gdk_window_process_updates (text_view->bottom_window->bin_window, TRUE);
7227
7228       gdk_window_process_updates (text_view->text_window->bin_window, TRUE);
7229     }
7230
7231   /* If this got installed, get rid of it, it's just a waste of time. */
7232   if (text_view->first_validate_idle != 0)
7233     {
7234       g_source_remove (text_view->first_validate_idle);
7235       text_view->first_validate_idle = 0;
7236     }
7237
7238   /* Finally we update the IM cursor location again, to ensure any
7239    * changes made by the validation are pushed through.
7240    */
7241   gtk_text_view_update_im_spot_location (text_view);
7242
7243   DV(g_print(">End scroll offset changed handler ("G_STRLOC")\n"));
7244 }
7245
7246 static void
7247 gtk_text_view_commit_handler (GtkIMContext  *context,
7248                               const gchar   *str,
7249                               GtkTextView   *text_view)
7250 {
7251   gtk_text_view_commit_text (text_view, str);
7252 }
7253
7254 static void
7255 gtk_text_view_commit_text (GtkTextView   *text_view,
7256                            const gchar   *str)
7257 {
7258   gboolean had_selection;
7259
7260   gtk_text_buffer_begin_user_action (get_buffer (text_view));
7261
7262   had_selection = gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
7263                                                         NULL, NULL);
7264
7265   gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
7266                                     text_view->editable);
7267
7268   if (!strcmp (str, "\n"))
7269     {
7270       if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), "\n", 1,
7271                                                          text_view->editable))
7272         {
7273           gtk_widget_error_bell (GTK_WIDGET (text_view));
7274         }
7275     }
7276   else
7277     {
7278       if (!had_selection && text_view->overwrite_mode)
7279         {
7280           GtkTextIter insert;
7281
7282           gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
7283                                             &insert,
7284                                             gtk_text_buffer_get_insert (get_buffer (text_view)));
7285           if (!gtk_text_iter_ends_line (&insert))
7286             gtk_text_view_delete_from_cursor (text_view, GTK_DELETE_CHARS, 1);
7287         }
7288
7289       if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1,
7290                                                          text_view->editable))
7291         {
7292           gtk_widget_error_bell (GTK_WIDGET (text_view));
7293         }
7294     }
7295
7296   gtk_text_buffer_end_user_action (get_buffer (text_view));
7297
7298   gtk_text_view_set_virtual_cursor_pos (text_view, -1, -1);
7299   DV(g_print (G_STRLOC": scrolling onscreen\n"));
7300   gtk_text_view_scroll_mark_onscreen (text_view,
7301                                       gtk_text_buffer_get_insert (get_buffer (text_view)));
7302 }
7303
7304 static void
7305 gtk_text_view_preedit_changed_handler (GtkIMContext *context,
7306                                        GtkTextView  *text_view)
7307 {
7308   gchar *str;
7309   PangoAttrList *attrs;
7310   gint cursor_pos;
7311   GtkTextIter iter;
7312
7313   gtk_text_buffer_get_iter_at_mark (text_view->buffer, &iter,
7314                                     gtk_text_buffer_get_insert (text_view->buffer));
7315
7316   /* Keypress events are passed to input method even if cursor position is
7317    * not editable; so beep here if it's multi-key input sequence, input
7318    * method will be reset in key-press-event handler.
7319    */
7320   gtk_im_context_get_preedit_string (context, &str, &attrs, &cursor_pos);
7321
7322   if (str && str[0] && !gtk_text_iter_can_insert (&iter, text_view->editable))
7323     {
7324       gtk_widget_error_bell (GTK_WIDGET (text_view));
7325       goto out;
7326     }
7327
7328   if (text_view->layout)
7329     gtk_text_layout_set_preedit_string (text_view->layout, str, attrs, cursor_pos);
7330   if (GTK_WIDGET_HAS_FOCUS (text_view))
7331     gtk_text_view_scroll_mark_onscreen (text_view,
7332                                         gtk_text_buffer_get_insert (get_buffer (text_view)));
7333
7334 out:
7335   pango_attr_list_unref (attrs);
7336   g_free (str);
7337 }
7338
7339 static gboolean
7340 gtk_text_view_retrieve_surrounding_handler (GtkIMContext  *context,
7341                                             GtkTextView   *text_view)
7342 {
7343   GtkTextIter start;
7344   GtkTextIter end;
7345   gint pos;
7346   gchar *text;
7347
7348   gtk_text_buffer_get_iter_at_mark (text_view->buffer, &start,
7349                                     gtk_text_buffer_get_insert (text_view->buffer));
7350   end = start;
7351
7352   pos = gtk_text_iter_get_line_index (&start);
7353   gtk_text_iter_set_line_offset (&start, 0);
7354   gtk_text_iter_forward_to_line_end (&end);
7355
7356   text = gtk_text_iter_get_slice (&start, &end);
7357   gtk_im_context_set_surrounding (context, text, -1, pos);
7358   g_free (text);
7359
7360   return TRUE;
7361 }
7362
7363 static gboolean
7364 gtk_text_view_delete_surrounding_handler (GtkIMContext  *context,
7365                                           gint           offset,
7366                                           gint           n_chars,
7367                                           GtkTextView   *text_view)
7368 {
7369   GtkTextIter start;
7370   GtkTextIter end;
7371
7372   gtk_text_buffer_get_iter_at_mark (text_view->buffer, &start,
7373                                     gtk_text_buffer_get_insert (text_view->buffer));
7374   end = start;
7375
7376   gtk_text_iter_forward_chars (&start, offset);
7377   gtk_text_iter_forward_chars (&end, offset + n_chars);
7378
7379   gtk_text_buffer_delete_interactive (text_view->buffer, &start, &end,
7380                                       text_view->editable);
7381
7382   return TRUE;
7383 }
7384
7385 static void
7386 gtk_text_view_mark_set_handler (GtkTextBuffer     *buffer,
7387                                 const GtkTextIter *location,
7388                                 GtkTextMark       *mark,
7389                                 gpointer           data)
7390 {
7391   GtkTextView *text_view = GTK_TEXT_VIEW (data);
7392   gboolean need_reset = FALSE;
7393
7394   if (mark == gtk_text_buffer_get_insert (buffer))
7395     {
7396       text_view->virtual_cursor_x = -1;
7397       text_view->virtual_cursor_y = -1;
7398       gtk_text_view_update_im_spot_location (text_view);
7399       need_reset = TRUE;
7400     }
7401   else if (mark == gtk_text_buffer_get_selection_bound (buffer))
7402     {
7403       need_reset = TRUE;
7404     }
7405
7406   if (need_reset)
7407     gtk_text_view_reset_im_context (text_view);
7408 }
7409
7410 static void
7411 gtk_text_view_target_list_notify (GtkTextBuffer    *buffer,
7412                                   const GParamSpec *pspec,
7413                                   gpointer          data)
7414 {
7415   GtkWidget     *widget = GTK_WIDGET (data);
7416   GtkTargetList *view_list;
7417   GtkTargetList *buffer_list;
7418   GList         *list;
7419
7420   view_list = gtk_drag_dest_get_target_list (widget);
7421   buffer_list = gtk_text_buffer_get_paste_target_list (buffer);
7422
7423   if (view_list)
7424     gtk_target_list_ref (view_list);
7425   else
7426     view_list = gtk_target_list_new (NULL, 0);
7427
7428   list = view_list->list;
7429   while (list)
7430     {
7431       GtkTargetPair *pair = list->data;
7432
7433       list = g_list_next (list); /* get next element before removing */
7434
7435       if (pair->info >= GTK_TEXT_BUFFER_TARGET_INFO_TEXT &&
7436           pair->info <= GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
7437         {
7438           gtk_target_list_remove (view_list, pair->target);
7439         }
7440     }
7441
7442   for (list = buffer_list->list; list; list = g_list_next (list))
7443     {
7444       GtkTargetPair *pair = list->data;
7445
7446       gtk_target_list_add (view_list, pair->target, pair->flags, pair->info);
7447     }
7448
7449   gtk_drag_dest_set_target_list (widget, view_list);
7450   gtk_target_list_unref (view_list);
7451 }
7452
7453 static void
7454 gtk_text_view_get_cursor_location  (GtkTextView   *text_view,
7455                                     GdkRectangle  *pos)
7456 {
7457   GtkTextIter insert;
7458
7459   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
7460                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
7461
7462   gtk_text_layout_get_cursor_locations (text_view->layout, &insert, pos, NULL);
7463 }
7464
7465 static void
7466 gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view,
7467                                       gint        *x,
7468                                       gint        *y)
7469 {
7470   GdkRectangle pos;
7471
7472   if ((x && text_view->virtual_cursor_x == -1) ||
7473       (y && text_view->virtual_cursor_y == -1))
7474     gtk_text_view_get_cursor_location (text_view, &pos);
7475
7476   if (x)
7477     {
7478       if (text_view->virtual_cursor_x != -1)
7479         *x = text_view->virtual_cursor_x;
7480       else
7481         *x = pos.x;
7482     }
7483
7484   if (y)
7485     {
7486       if (text_view->virtual_cursor_x != -1)
7487         *y = text_view->virtual_cursor_y;
7488       else
7489         *y = pos.y + pos.height / 2;
7490     }
7491 }
7492
7493 static void
7494 gtk_text_view_set_virtual_cursor_pos (GtkTextView *text_view,
7495                                       gint         x,
7496                                       gint         y)
7497 {
7498   GdkRectangle pos;
7499
7500   if (!text_view->layout)
7501     return;
7502
7503   if (x == -1 || y == -1)
7504     gtk_text_view_get_cursor_location (text_view, &pos);
7505
7506   text_view->virtual_cursor_x = (x == -1) ? pos.x : x;
7507   text_view->virtual_cursor_y = (y == -1) ? pos.y + pos.height / 2 : y;
7508 }
7509
7510 /* Quick hack of a popup menu
7511  */
7512 static void
7513 activate_cb (GtkWidget   *menuitem,
7514              GtkTextView *text_view)
7515 {
7516   const gchar *signal = g_object_get_data (G_OBJECT (menuitem), "gtk-signal");
7517   g_signal_emit_by_name (text_view, signal);
7518 }
7519
7520 static void
7521 append_action_signal (GtkTextView  *text_view,
7522                       GtkWidget    *menu,
7523                       const gchar  *stock_id,
7524                       const gchar  *signal,
7525                       gboolean      sensitive)
7526 {
7527   GtkWidget *menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
7528
7529   g_object_set_data (G_OBJECT (menuitem), I_("gtk-signal"), (char *)signal);
7530   g_signal_connect (menuitem, "activate",
7531                     G_CALLBACK (activate_cb), text_view);
7532
7533   gtk_widget_set_sensitive (menuitem, sensitive);
7534
7535   gtk_widget_show (menuitem);
7536   gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
7537 }
7538
7539 static void
7540 gtk_text_view_select_all (GtkWidget *widget,
7541                           gboolean select)
7542 {
7543   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
7544   GtkTextBuffer *buffer;
7545   GtkTextIter start_iter, end_iter, insert;
7546
7547   buffer = text_view->buffer;
7548   if (select)
7549     {
7550       gtk_text_buffer_get_bounds (buffer, &start_iter, &end_iter);
7551       gtk_text_buffer_select_range (buffer, &start_iter, &end_iter);
7552     }
7553   else
7554     {
7555       gtk_text_buffer_get_iter_at_mark (buffer, &insert,
7556                                         gtk_text_buffer_get_insert (buffer));
7557       gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &insert);
7558     }
7559 }
7560
7561 static void
7562 select_all_cb (GtkWidget   *menuitem,
7563                GtkTextView *text_view)
7564 {
7565   gtk_text_view_select_all (GTK_WIDGET (text_view), TRUE);
7566 }
7567
7568 static void
7569 delete_cb (GtkTextView *text_view)
7570 {
7571   gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
7572                                     text_view->editable);
7573 }
7574
7575 static void
7576 popup_menu_detach (GtkWidget *attach_widget,
7577                    GtkMenu   *menu)
7578 {
7579   GTK_TEXT_VIEW (attach_widget)->popup_menu = NULL;
7580 }
7581
7582 static void
7583 popup_position_func (GtkMenu   *menu,
7584                      gint      *x,
7585                      gint      *y,
7586                      gboolean  *push_in,
7587                      gpointer   user_data)
7588 {
7589   GtkTextView *text_view;
7590   GtkWidget *widget;
7591   GdkRectangle cursor_rect;
7592   GdkRectangle onscreen_rect;
7593   gint root_x, root_y;
7594   GtkTextIter iter;
7595   GtkRequisition req;
7596   GdkScreen *screen;
7597   gint monitor_num;
7598   GdkRectangle monitor;
7599
7600   text_view = GTK_TEXT_VIEW (user_data);
7601   widget = GTK_WIDGET (text_view);
7602
7603   g_return_if_fail (GTK_WIDGET_REALIZED (text_view));
7604
7605   screen = gtk_widget_get_screen (widget);
7606
7607   gdk_window_get_origin (widget->window, &root_x, &root_y);
7608
7609   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
7610                                     &iter,
7611                                     gtk_text_buffer_get_insert (get_buffer (text_view)));
7612
7613   gtk_text_view_get_iter_location (text_view,
7614                                    &iter,
7615                                    &cursor_rect);
7616
7617   gtk_text_view_get_visible_rect (text_view, &onscreen_rect);
7618
7619   gtk_widget_size_request (text_view->popup_menu, &req);
7620
7621   /* can't use rectangle_intersect since cursor rect can have 0 width */
7622   if (cursor_rect.x >= onscreen_rect.x &&
7623       cursor_rect.x < onscreen_rect.x + onscreen_rect.width &&
7624       cursor_rect.y >= onscreen_rect.y &&
7625       cursor_rect.y < onscreen_rect.y + onscreen_rect.height)
7626     {
7627       gtk_text_view_buffer_to_window_coords (text_view,
7628                                              GTK_TEXT_WINDOW_WIDGET,
7629                                              cursor_rect.x, cursor_rect.y,
7630                                              &cursor_rect.x, &cursor_rect.y);
7631
7632       *x = root_x + cursor_rect.x + cursor_rect.width;
7633       *y = root_y + cursor_rect.y + cursor_rect.height;
7634     }
7635   else
7636     {
7637       /* Just center the menu, since cursor is offscreen. */
7638       *x = root_x + (widget->allocation.width / 2 - req.width / 2);
7639       *y = root_y + (widget->allocation.height / 2 - req.height / 2);
7640     }
7641
7642   /* Ensure sanity */
7643   *x = CLAMP (*x, root_x, (root_x + widget->allocation.width));
7644   *y = CLAMP (*y, root_y, (root_y + widget->allocation.height));
7645
7646   monitor_num = gdk_screen_get_monitor_at_point (screen, *x, *y);
7647   gtk_menu_set_monitor (menu, monitor_num);
7648   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
7649
7650   *x = CLAMP (*x, monitor.x, monitor.x + MAX (0, monitor.width - req.width));
7651   *y = CLAMP (*y, monitor.y, monitor.y + MAX (0, monitor.height - req.height));
7652
7653   *push_in = FALSE;
7654 }
7655
7656 typedef struct
7657 {
7658   GtkTextView *text_view;
7659   gint button;
7660   guint time;
7661 } PopupInfo;
7662
7663 static gboolean
7664 range_contains_editable_text (const GtkTextIter *start,
7665                               const GtkTextIter *end,
7666                               gboolean default_editability)
7667 {
7668   GtkTextIter iter = *start;
7669
7670   while (gtk_text_iter_compare (&iter, end) < 0)
7671     {
7672       if (gtk_text_iter_editable (&iter, default_editability))
7673         return TRUE;
7674
7675       gtk_text_iter_forward_to_tag_toggle (&iter, NULL);
7676     }
7677
7678   return FALSE;
7679 }
7680
7681 static void
7682 unichar_chosen_func (const char *text,
7683                      gpointer    data)
7684 {
7685   GtkTextView *text_view = GTK_TEXT_VIEW (data);
7686
7687   gtk_text_view_commit_text (text_view, text);
7688 }
7689
7690 static void
7691 popup_targets_received (GtkClipboard     *clipboard,
7692                         GtkSelectionData *data,
7693                         gpointer          user_data)
7694 {
7695   PopupInfo *info = user_data;
7696   GtkTextView *text_view = info->text_view;
7697
7698   if (GTK_WIDGET_REALIZED (text_view))
7699     {
7700       /* We implicitely rely here on the fact that if we are pasting ourself, we'll
7701        * have text targets as well as the private GTK_TEXT_BUFFER_CONTENTS target.
7702        */
7703       gboolean clipboard_contains_text;
7704       GtkWidget *menuitem;
7705       GtkWidget *submenu;
7706       gboolean have_selection;
7707       gboolean can_insert;
7708       GtkTextIter iter;
7709       GtkTextIter sel_start, sel_end;
7710       gboolean show_input_method_menu;
7711       gboolean show_unicode_menu;
7712
7713       clipboard_contains_text = gtk_selection_data_targets_include_text (data);
7714
7715       if (text_view->popup_menu)
7716         gtk_widget_destroy (text_view->popup_menu);
7717
7718       text_view->popup_menu = gtk_menu_new ();
7719
7720       gtk_menu_attach_to_widget (GTK_MENU (text_view->popup_menu),
7721                                  GTK_WIDGET (text_view),
7722                                  popup_menu_detach);
7723
7724       have_selection = gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
7725                                                              &sel_start, &sel_end);
7726
7727       gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
7728                                         &iter,
7729                                         gtk_text_buffer_get_insert (get_buffer (text_view)));
7730
7731       can_insert = gtk_text_iter_can_insert (&iter, text_view->editable);
7732
7733       append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_CUT, "cut-clipboard",
7734                             have_selection &&
7735                             range_contains_editable_text (&sel_start, &sel_end,
7736                                                           text_view->editable));
7737       append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_COPY, "copy-clipboard",
7738                             have_selection);
7739       append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_PASTE, "paste-clipboard",
7740                             can_insert && clipboard_contains_text);
7741
7742       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE, NULL);
7743       gtk_widget_set_sensitive (menuitem,
7744                                 have_selection &&
7745                                 range_contains_editable_text (&sel_start, &sel_end,
7746                                                               text_view->editable));
7747       g_signal_connect_swapped (menuitem, "activate",
7748                                 G_CALLBACK (delete_cb), text_view);
7749       gtk_widget_show (menuitem);
7750       gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7751
7752       menuitem = gtk_separator_menu_item_new ();
7753       gtk_widget_show (menuitem);
7754       gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7755
7756       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_SELECT_ALL, NULL);
7757       g_signal_connect (menuitem, "activate",
7758                         G_CALLBACK (select_all_cb), text_view);
7759       gtk_widget_show (menuitem);
7760       gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7761
7762       g_object_get (gtk_widget_get_settings (GTK_WIDGET (text_view)),
7763                     "gtk-show-input-method-menu", &show_input_method_menu,
7764                     "gtk-show-unicode-menu", &show_unicode_menu,
7765                     NULL);
7766
7767       if (show_input_method_menu || show_unicode_menu)
7768         {
7769           menuitem = gtk_separator_menu_item_new ();
7770           gtk_widget_show (menuitem);
7771           gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7772         }
7773
7774       if (show_input_method_menu)
7775         {
7776           menuitem = gtk_menu_item_new_with_mnemonic (_("Input _Methods"));
7777           gtk_widget_show (menuitem);
7778           gtk_widget_set_sensitive (menuitem, can_insert);
7779
7780           submenu = gtk_menu_new ();
7781           gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
7782           gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7783
7784           gtk_im_multicontext_append_menuitems (GTK_IM_MULTICONTEXT (text_view->im_context),
7785                                                 GTK_MENU_SHELL (submenu));
7786         }
7787
7788       if (show_unicode_menu)
7789         {
7790           menuitem = gtk_menu_item_new_with_mnemonic (_("_Insert Unicode Control Character"));
7791           gtk_widget_show (menuitem);
7792           gtk_widget_set_sensitive (menuitem, can_insert);
7793
7794           submenu = gtk_menu_new ();
7795           gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
7796           gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
7797
7798           _gtk_text_util_append_special_char_menuitems (GTK_MENU_SHELL (submenu),
7799                                                         unichar_chosen_func,
7800                                                         text_view);
7801         }
7802
7803       g_signal_emit (text_view,
7804                      signals[POPULATE_POPUP],
7805                      0,
7806                      text_view->popup_menu);
7807
7808       if (info->button)
7809         gtk_menu_popup (GTK_MENU (text_view->popup_menu), NULL, NULL,
7810                         NULL, NULL,
7811                         info->button, info->time);
7812       else
7813         {
7814           gtk_menu_popup (GTK_MENU (text_view->popup_menu), NULL, NULL,
7815                           popup_position_func, text_view,
7816                           0, gtk_get_current_event_time ());
7817           gtk_menu_shell_select_first (GTK_MENU_SHELL (text_view->popup_menu), FALSE);
7818         }
7819     }
7820
7821   g_object_unref (text_view);
7822   g_free (info);
7823 }
7824
7825 static void
7826 gtk_text_view_do_popup (GtkTextView    *text_view,
7827                         GdkEventButton *event)
7828 {
7829   PopupInfo *info = g_new (PopupInfo, 1);
7830
7831   /* In order to know what entries we should make sensitive, we
7832    * ask for the current targets of the clipboard, and when
7833    * we get them, then we actually pop up the menu.
7834    */
7835   info->text_view = g_object_ref (text_view);
7836
7837   if (event)
7838     {
7839       info->button = event->button;
7840       info->time = event->time;
7841     }
7842   else
7843     {
7844       info->button = 0;
7845       info->time = gtk_get_current_event_time ();
7846     }
7847
7848   gtk_clipboard_request_contents (gtk_widget_get_clipboard (GTK_WIDGET (text_view),
7849                                                             GDK_SELECTION_CLIPBOARD),
7850                                   gdk_atom_intern_static_string ("TARGETS"),
7851                                   popup_targets_received,
7852                                   info);
7853 }
7854
7855 static gboolean
7856 gtk_text_view_popup_menu (GtkWidget *widget)
7857 {
7858   gtk_text_view_do_popup (GTK_TEXT_VIEW (widget), NULL);
7859   return TRUE;
7860 }
7861
7862 /* Child GdkWindows */
7863
7864
7865 static GtkTextWindow*
7866 text_window_new (GtkTextWindowType  type,
7867                  GtkWidget         *widget,
7868                  gint               width_request,
7869                  gint               height_request)
7870 {
7871   GtkTextWindow *win;
7872
7873   win = g_new (GtkTextWindow, 1);
7874
7875   win->type = type;
7876   win->widget = widget;
7877   win->window = NULL;
7878   win->bin_window = NULL;
7879   win->requisition.width = width_request;
7880   win->requisition.height = height_request;
7881   win->allocation.width = width_request;
7882   win->allocation.height = height_request;
7883   win->allocation.x = 0;
7884   win->allocation.y = 0;
7885
7886   return win;
7887 }
7888
7889 static void
7890 text_window_free (GtkTextWindow *win)
7891 {
7892   if (win->window)
7893     text_window_unrealize (win);
7894
7895   g_free (win);
7896 }
7897
7898 static void
7899 text_window_realize (GtkTextWindow *win,
7900                      GtkWidget     *widget)
7901 {
7902   GdkWindowAttr attributes;
7903   gint attributes_mask;
7904   GdkCursor *cursor;
7905
7906   attributes.window_type = GDK_WINDOW_CHILD;
7907   attributes.x = win->allocation.x;
7908   attributes.y = win->allocation.y;
7909   attributes.width = win->allocation.width;
7910   attributes.height = win->allocation.height;
7911   attributes.wclass = GDK_INPUT_OUTPUT;
7912   attributes.visual = gtk_widget_get_visual (win->widget);
7913   attributes.colormap = gtk_widget_get_colormap (win->widget);
7914   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
7915
7916   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
7917
7918   win->window = gdk_window_new (widget->window,
7919                                 &attributes,
7920                                 attributes_mask);
7921
7922   gdk_window_set_back_pixmap (win->window, NULL, FALSE);
7923
7924   gdk_window_show (win->window);
7925   gdk_window_set_user_data (win->window, win->widget);
7926   gdk_window_lower (win->window);
7927
7928   attributes.x = 0;
7929   attributes.y = 0;
7930   attributes.width = win->allocation.width;
7931   attributes.height = win->allocation.height;
7932   attributes.event_mask = (GDK_EXPOSURE_MASK            |
7933                            GDK_SCROLL_MASK              |
7934                            GDK_KEY_PRESS_MASK           |
7935                            GDK_BUTTON_PRESS_MASK        |
7936                            GDK_BUTTON_RELEASE_MASK      |
7937                            GDK_POINTER_MOTION_MASK      |
7938                            GDK_POINTER_MOTION_HINT_MASK |
7939                            gtk_widget_get_events (win->widget));
7940
7941   win->bin_window = gdk_window_new (win->window,
7942                                     &attributes,
7943                                     attributes_mask);
7944
7945   gdk_window_show (win->bin_window);
7946   gdk_window_set_user_data (win->bin_window, win->widget);
7947
7948   if (win->type == GTK_TEXT_WINDOW_TEXT)
7949     {
7950       if (GTK_WIDGET_IS_SENSITIVE (widget))
7951         {
7952           /* I-beam cursor */
7953           cursor = gdk_cursor_new_for_display (gdk_drawable_get_display (widget->window),
7954                                                GDK_XTERM);
7955           gdk_window_set_cursor (win->bin_window, cursor);
7956           gdk_cursor_unref (cursor);
7957         }
7958
7959       gtk_im_context_set_client_window (GTK_TEXT_VIEW (widget)->im_context,
7960                                         win->window);
7961
7962
7963       gdk_window_set_background (win->bin_window,
7964                                  &widget->style->base[GTK_WIDGET_STATE (widget)]);
7965     }
7966   else
7967     {
7968       gdk_window_set_background (win->bin_window,
7969                                  &widget->style->bg[GTK_WIDGET_STATE (widget)]);
7970     }
7971
7972   g_object_set_qdata (G_OBJECT (win->window),
7973                       g_quark_from_static_string ("gtk-text-view-text-window"),
7974                       win);
7975
7976   g_object_set_qdata (G_OBJECT (win->bin_window),
7977                       g_quark_from_static_string ("gtk-text-view-text-window"),
7978                       win);
7979 }
7980
7981 static void
7982 text_window_unrealize (GtkTextWindow *win)
7983 {
7984   if (win->type == GTK_TEXT_WINDOW_TEXT)
7985     {
7986       gtk_im_context_set_client_window (GTK_TEXT_VIEW (win->widget)->im_context,
7987                                         NULL);
7988     }
7989
7990   gdk_window_set_user_data (win->window, NULL);
7991   gdk_window_set_user_data (win->bin_window, NULL);
7992   gdk_window_destroy (win->bin_window);
7993   gdk_window_destroy (win->window);
7994   win->window = NULL;
7995   win->bin_window = NULL;
7996 }
7997
7998 static void
7999 text_window_size_allocate (GtkTextWindow *win,
8000                            GdkRectangle  *rect)
8001 {
8002   win->allocation = *rect;
8003
8004   if (win->window)
8005     {
8006       gdk_window_move_resize (win->window,
8007                               rect->x, rect->y,
8008                               rect->width, rect->height);
8009
8010       gdk_window_resize (win->bin_window,
8011                          rect->width, rect->height);
8012     }
8013 }
8014
8015 static void
8016 text_window_scroll        (GtkTextWindow *win,
8017                            gint           dx,
8018                            gint           dy)
8019 {
8020   if (dx != 0 || dy != 0)
8021     {
8022       gdk_window_scroll (win->bin_window, dx, dy);
8023     }
8024 }
8025
8026 static void
8027 text_window_invalidate_rect (GtkTextWindow *win,
8028                              GdkRectangle  *rect)
8029 {
8030   GdkRectangle window_rect;
8031
8032   gtk_text_view_buffer_to_window_coords (GTK_TEXT_VIEW (win->widget),
8033                                          win->type,
8034                                          rect->x,
8035                                          rect->y,
8036                                          &window_rect.x,
8037                                          &window_rect.y);
8038
8039   window_rect.width = rect->width;
8040   window_rect.height = rect->height;
8041
8042   /* Adjust the rect as appropriate */
8043
8044   switch (win->type)
8045     {
8046     case GTK_TEXT_WINDOW_TEXT:
8047       break;
8048
8049     case GTK_TEXT_WINDOW_LEFT:
8050     case GTK_TEXT_WINDOW_RIGHT:
8051       window_rect.x = 0;
8052       window_rect.width = win->allocation.width;
8053       break;
8054
8055     case GTK_TEXT_WINDOW_TOP:
8056     case GTK_TEXT_WINDOW_BOTTOM:
8057       window_rect.y = 0;
8058       window_rect.height = win->allocation.height;
8059       break;
8060
8061     default:
8062       g_warning ("%s: bug!", G_STRFUNC);
8063       return;
8064       break;
8065     }
8066
8067   gdk_window_invalidate_rect (win->bin_window, &window_rect, FALSE);
8068
8069 #if 0
8070   {
8071     cairo_t *cr = gdk_cairo_create (win->bin_window);
8072     gdk_cairo_rectangle (cr, &window_rect);
8073     cairo_set_source_rgb  (cr, 1.0, 0.0, 0.0);  /* red */
8074     cairo_fill (cr);
8075     cairo_destroy (cr);
8076   }
8077 #endif
8078 }
8079
8080 static void
8081 text_window_invalidate_cursors (GtkTextWindow *win)
8082 {
8083   GtkTextView *text_view = GTK_TEXT_VIEW (win->widget);
8084   GtkTextIter  iter;
8085   GdkRectangle strong;
8086   GdkRectangle weak;
8087   gboolean     draw_arrow;
8088   gfloat       cursor_aspect_ratio;
8089   gint         stem_width;
8090   gint         arrow_width;
8091
8092   gtk_text_buffer_get_iter_at_mark (text_view->buffer, &iter,
8093                                     gtk_text_buffer_get_insert (text_view->buffer));
8094
8095   if (_gtk_text_layout_get_block_cursor (text_view->layout, &strong))
8096     {
8097       text_window_invalidate_rect (win, &strong);
8098       return;
8099     }
8100
8101   gtk_text_layout_get_cursor_locations (text_view->layout, &iter,
8102                                         &strong, &weak);
8103
8104   /* cursor width calculation as in gtkstyle.c:draw_insertion_cursor(),
8105    * ignoring the text direction be exposing both sides of the cursor
8106    */
8107
8108   draw_arrow = (strong.x != weak.x || strong.y != weak.y);
8109
8110   gtk_widget_style_get (win->widget,
8111                         "cursor-aspect-ratio", &cursor_aspect_ratio,
8112                         NULL);
8113
8114   stem_width = strong.height * cursor_aspect_ratio + 1;
8115   arrow_width = stem_width + 1;
8116
8117   strong.width = stem_width;
8118
8119   /* round up to the next even number */
8120   if (stem_width & 1)
8121     stem_width++;
8122
8123   strong.x     -= stem_width / 2;
8124   strong.width += stem_width;
8125
8126   if (draw_arrow)
8127     {
8128       strong.x     -= arrow_width;
8129       strong.width += arrow_width * 2;
8130     }
8131
8132   text_window_invalidate_rect (win, &strong);
8133
8134   if (draw_arrow) /* == have weak */
8135     {
8136       stem_width = weak.height * cursor_aspect_ratio + 1;
8137       arrow_width = stem_width + 1;
8138
8139       weak.width = stem_width;
8140
8141       /* round up to the next even number */
8142       if (stem_width & 1)
8143         stem_width++;
8144
8145       weak.x     -= stem_width / 2;
8146       weak.width += stem_width;
8147
8148       weak.x     -= arrow_width;
8149       weak.width += arrow_width * 2;
8150
8151       text_window_invalidate_rect (win, &weak);
8152     }
8153 }
8154
8155 static gint
8156 text_window_get_width (GtkTextWindow *win)
8157 {
8158   return win->allocation.width;
8159 }
8160
8161 static gint
8162 text_window_get_height (GtkTextWindow *win)
8163 {
8164   return win->allocation.height;
8165 }
8166
8167 /* Windows */
8168
8169
8170 /**
8171  * gtk_text_view_get_window:
8172  * @text_view: a #GtkTextView
8173  * @win: window to get
8174  *
8175  * Retrieves the #GdkWindow corresponding to an area of the text view;
8176  * possible windows include the overall widget window, child windows
8177  * on the left, right, top, bottom, and the window that displays the
8178  * text buffer. Windows are %NULL and nonexistent if their width or
8179  * height is 0, and are nonexistent before the widget has been
8180  * realized.
8181  *
8182  * Return value: a #GdkWindow, or %NULL
8183  **/
8184 GdkWindow*
8185 gtk_text_view_get_window (GtkTextView *text_view,
8186                           GtkTextWindowType win)
8187 {
8188   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
8189
8190   switch (win)
8191     {
8192     case GTK_TEXT_WINDOW_WIDGET:
8193       return GTK_WIDGET (text_view)->window;
8194       break;
8195
8196     case GTK_TEXT_WINDOW_TEXT:
8197       return text_view->text_window->bin_window;
8198       break;
8199
8200     case GTK_TEXT_WINDOW_LEFT:
8201       if (text_view->left_window)
8202         return text_view->left_window->bin_window;
8203       else
8204         return NULL;
8205       break;
8206
8207     case GTK_TEXT_WINDOW_RIGHT:
8208       if (text_view->right_window)
8209         return text_view->right_window->bin_window;
8210       else
8211         return NULL;
8212       break;
8213
8214     case GTK_TEXT_WINDOW_TOP:
8215       if (text_view->top_window)
8216         return text_view->top_window->bin_window;
8217       else
8218         return NULL;
8219       break;
8220
8221     case GTK_TEXT_WINDOW_BOTTOM:
8222       if (text_view->bottom_window)
8223         return text_view->bottom_window->bin_window;
8224       else
8225         return NULL;
8226       break;
8227
8228     case GTK_TEXT_WINDOW_PRIVATE:
8229       g_warning ("%s: You can't get GTK_TEXT_WINDOW_PRIVATE, it has \"PRIVATE\" in the name because it is private.", G_STRFUNC);
8230       return NULL;
8231       break;
8232     }
8233
8234   g_warning ("%s: Unknown GtkTextWindowType", G_STRFUNC);
8235   return NULL;
8236 }
8237
8238 /**
8239  * gtk_text_view_get_window_type:
8240  * @text_view: a #GtkTextView
8241  * @window: a window type
8242  *
8243  * Usually used to find out which window an event corresponds to.
8244  * If you connect to an event signal on @text_view, this function
8245  * should be called on <literal>event-&gt;window</literal> to
8246  * see which window it was.
8247  *
8248  * Return value: the window type.
8249  **/
8250 GtkTextWindowType
8251 gtk_text_view_get_window_type (GtkTextView *text_view,
8252                                GdkWindow   *window)
8253 {
8254   GtkTextWindow *win;
8255
8256   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
8257   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8258
8259   if (window == GTK_WIDGET (text_view)->window)
8260     return GTK_TEXT_WINDOW_WIDGET;
8261
8262   win = g_object_get_qdata (G_OBJECT (window),
8263                             g_quark_try_string ("gtk-text-view-text-window"));
8264
8265   if (win)
8266     return win->type;
8267   else
8268     {
8269       return GTK_TEXT_WINDOW_PRIVATE;
8270     }
8271 }
8272
8273 static void
8274 buffer_to_widget (GtkTextView      *text_view,
8275                   gint              buffer_x,
8276                   gint              buffer_y,
8277                   gint             *window_x,
8278                   gint             *window_y)
8279 {
8280   if (window_x)
8281     {
8282       *window_x = buffer_x - text_view->xoffset;
8283       *window_x += text_view->text_window->allocation.x;
8284     }
8285
8286   if (window_y)
8287     {
8288       *window_y = buffer_y - text_view->yoffset;
8289       *window_y += text_view->text_window->allocation.y;
8290     }
8291 }
8292
8293 static void
8294 widget_to_text_window (GtkTextWindow *win,
8295                        gint           widget_x,
8296                        gint           widget_y,
8297                        gint          *window_x,
8298                        gint          *window_y)
8299 {
8300   if (window_x)
8301     *window_x = widget_x - win->allocation.x;
8302
8303   if (window_y)
8304     *window_y = widget_y - win->allocation.y;
8305 }
8306
8307 static void
8308 buffer_to_text_window (GtkTextView   *text_view,
8309                        GtkTextWindow *win,
8310                        gint           buffer_x,
8311                        gint           buffer_y,
8312                        gint          *window_x,
8313                        gint          *window_y)
8314 {
8315   if (win == NULL)
8316     {
8317       g_warning ("Attempt to convert text buffer coordinates to coordinates "
8318                  "for a nonexistent or private child window of GtkTextView");
8319       return;
8320     }
8321
8322   buffer_to_widget (text_view,
8323                     buffer_x, buffer_y,
8324                     window_x, window_y);
8325
8326   widget_to_text_window (win,
8327                          window_x ? *window_x : 0,
8328                          window_y ? *window_y : 0,
8329                          window_x,
8330                          window_y);
8331 }
8332
8333 /**
8334  * gtk_text_view_buffer_to_window_coords:
8335  * @text_view: a #GtkTextView
8336  * @win: a #GtkTextWindowType except #GTK_TEXT_WINDOW_PRIVATE
8337  * @buffer_x: buffer x coordinate
8338  * @buffer_y: buffer y coordinate
8339  * @window_x: window x coordinate return location
8340  * @window_y: window y coordinate return location
8341  *
8342  * Converts coordinate (@buffer_x, @buffer_y) to coordinates for the window
8343  * @win, and stores the result in (@window_x, @window_y).
8344  *
8345  * Note that you can't convert coordinates for a nonexisting window (see
8346  * gtk_text_view_set_border_window_size()).
8347  **/
8348 void
8349 gtk_text_view_buffer_to_window_coords (GtkTextView      *text_view,
8350                                        GtkTextWindowType win,
8351                                        gint              buffer_x,
8352                                        gint              buffer_y,
8353                                        gint             *window_x,
8354                                        gint             *window_y)
8355 {
8356   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8357
8358   switch (win)
8359     {
8360     case GTK_TEXT_WINDOW_WIDGET:
8361       buffer_to_widget (text_view,
8362                         buffer_x, buffer_y,
8363                         window_x, window_y);
8364       break;
8365
8366     case GTK_TEXT_WINDOW_TEXT:
8367       if (window_x)
8368         *window_x = buffer_x - text_view->xoffset;
8369       if (window_y)
8370         *window_y = buffer_y - text_view->yoffset;
8371       break;
8372
8373     case GTK_TEXT_WINDOW_LEFT:
8374       buffer_to_text_window (text_view,
8375                              text_view->left_window,
8376                              buffer_x, buffer_y,
8377                              window_x, window_y);
8378       break;
8379
8380     case GTK_TEXT_WINDOW_RIGHT:
8381       buffer_to_text_window (text_view,
8382                              text_view->right_window,
8383                              buffer_x, buffer_y,
8384                              window_x, window_y);
8385       break;
8386
8387     case GTK_TEXT_WINDOW_TOP:
8388       buffer_to_text_window (text_view,
8389                              text_view->top_window,
8390                              buffer_x, buffer_y,
8391                              window_x, window_y);
8392       break;
8393
8394     case GTK_TEXT_WINDOW_BOTTOM:
8395       buffer_to_text_window (text_view,
8396                              text_view->bottom_window,
8397                              buffer_x, buffer_y,
8398                              window_x, window_y);
8399       break;
8400
8401     case GTK_TEXT_WINDOW_PRIVATE:
8402       g_warning ("%s: can't get coords for private windows", G_STRFUNC);
8403       break;
8404
8405     default:
8406       g_warning ("%s: Unknown GtkTextWindowType", G_STRFUNC);
8407       break;
8408     }
8409 }
8410
8411 static void
8412 widget_to_buffer (GtkTextView *text_view,
8413                   gint         widget_x,
8414                   gint         widget_y,
8415                   gint        *buffer_x,
8416                   gint        *buffer_y)
8417 {
8418   if (buffer_x)
8419     {
8420       *buffer_x = widget_x + text_view->xoffset;
8421       *buffer_x -= text_view->text_window->allocation.x;
8422     }
8423
8424   if (buffer_y)
8425     {
8426       *buffer_y = widget_y + text_view->yoffset;
8427       *buffer_y -= text_view->text_window->allocation.y;
8428     }
8429 }
8430
8431 static void
8432 text_window_to_widget (GtkTextWindow *win,
8433                        gint           window_x,
8434                        gint           window_y,
8435                        gint          *widget_x,
8436                        gint          *widget_y)
8437 {
8438   if (widget_x)
8439     *widget_x = window_x + win->allocation.x;
8440
8441   if (widget_y)
8442     *widget_y = window_y + win->allocation.y;
8443 }
8444
8445 static void
8446 text_window_to_buffer (GtkTextView   *text_view,
8447                        GtkTextWindow *win,
8448                        gint           window_x,
8449                        gint           window_y,
8450                        gint          *buffer_x,
8451                        gint          *buffer_y)
8452 {
8453   if (win == NULL)
8454     {
8455       g_warning ("Attempt to convert GtkTextView buffer coordinates into "
8456                  "coordinates for a nonexistent child window.");
8457       return;
8458     }
8459
8460   text_window_to_widget (win,
8461                          window_x,
8462                          window_y,
8463                          buffer_x,
8464                          buffer_y);
8465
8466   widget_to_buffer (text_view,
8467                     buffer_x ? *buffer_x : 0,
8468                     buffer_y ? *buffer_y : 0,
8469                     buffer_x,
8470                     buffer_y);
8471 }
8472
8473 /**
8474  * gtk_text_view_window_to_buffer_coords:
8475  * @text_view: a #GtkTextView
8476  * @win: a #GtkTextWindowType except #GTK_TEXT_WINDOW_PRIVATE
8477  * @window_x: window x coordinate
8478  * @window_y: window y coordinate
8479  * @buffer_x: buffer x coordinate return location
8480  * @buffer_y: buffer y coordinate return location
8481  *
8482  * Converts coordinates on the window identified by @win to buffer
8483  * coordinates, storing the result in (@buffer_x,@buffer_y).
8484  *
8485  * Note that you can't convert coordinates for a nonexisting window (see
8486  * gtk_text_view_set_border_window_size()).
8487  **/
8488 void
8489 gtk_text_view_window_to_buffer_coords (GtkTextView      *text_view,
8490                                        GtkTextWindowType win,
8491                                        gint              window_x,
8492                                        gint              window_y,
8493                                        gint             *buffer_x,
8494                                        gint             *buffer_y)
8495 {
8496   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8497
8498   switch (win)
8499     {
8500     case GTK_TEXT_WINDOW_WIDGET:
8501       widget_to_buffer (text_view,
8502                         window_x, window_y,
8503                         buffer_x, buffer_y);
8504       break;
8505
8506     case GTK_TEXT_WINDOW_TEXT:
8507       if (buffer_x)
8508         *buffer_x = window_x + text_view->xoffset;
8509       if (buffer_y)
8510         *buffer_y = window_y + text_view->yoffset;
8511       break;
8512
8513     case GTK_TEXT_WINDOW_LEFT:
8514       text_window_to_buffer (text_view,
8515                              text_view->left_window,
8516                              window_x, window_y,
8517                              buffer_x, buffer_y);
8518       break;
8519
8520     case GTK_TEXT_WINDOW_RIGHT:
8521       text_window_to_buffer (text_view,
8522                              text_view->right_window,
8523                              window_x, window_y,
8524                              buffer_x, buffer_y);
8525       break;
8526
8527     case GTK_TEXT_WINDOW_TOP:
8528       text_window_to_buffer (text_view,
8529                              text_view->top_window,
8530                              window_x, window_y,
8531                              buffer_x, buffer_y);
8532       break;
8533
8534     case GTK_TEXT_WINDOW_BOTTOM:
8535       text_window_to_buffer (text_view,
8536                              text_view->bottom_window,
8537                              window_x, window_y,
8538                              buffer_x, buffer_y);
8539       break;
8540
8541     case GTK_TEXT_WINDOW_PRIVATE:
8542       g_warning ("%s: can't get coords for private windows", G_STRFUNC);
8543       break;
8544
8545     default:
8546       g_warning ("%s: Unknown GtkTextWindowType", G_STRFUNC);
8547       break;
8548     }
8549 }
8550
8551 static void
8552 set_window_width (GtkTextView      *text_view,
8553                   gint              width,
8554                   GtkTextWindowType type,
8555                   GtkTextWindow   **winp)
8556 {
8557   if (width == 0)
8558     {
8559       if (*winp)
8560         {
8561           text_window_free (*winp);
8562           *winp = NULL;
8563           gtk_widget_queue_resize (GTK_WIDGET (text_view));
8564         }
8565     }
8566   else
8567     {
8568       if (*winp == NULL)
8569         {
8570           *winp = text_window_new (type,
8571                                    GTK_WIDGET (text_view),
8572                                    width, 0);
8573           /* if the widget is already realized we need to realize the child manually */
8574           if (GTK_WIDGET_REALIZED (text_view))
8575             text_window_realize (*winp, GTK_WIDGET (text_view));
8576         }
8577       else
8578         {
8579           if ((*winp)->requisition.width == width)
8580             return;
8581
8582           (*winp)->requisition.width = width;
8583         }
8584
8585       gtk_widget_queue_resize (GTK_WIDGET (text_view));
8586     }
8587 }
8588
8589
8590 static void
8591 set_window_height (GtkTextView      *text_view,
8592                    gint              height,
8593                    GtkTextWindowType type,
8594                    GtkTextWindow   **winp)
8595 {
8596   if (height == 0)
8597     {
8598       if (*winp)
8599         {
8600           text_window_free (*winp);
8601           *winp = NULL;
8602           gtk_widget_queue_resize (GTK_WIDGET (text_view));
8603         }
8604     }
8605   else
8606     {
8607       if (*winp == NULL)
8608         {
8609           *winp = text_window_new (type,
8610                                    GTK_WIDGET (text_view),
8611                                    0, height);
8612
8613           /* if the widget is already realized we need to realize the child manually */
8614           if (GTK_WIDGET_REALIZED (text_view))
8615             text_window_realize (*winp, GTK_WIDGET (text_view));
8616         }
8617       else
8618         {
8619           if ((*winp)->requisition.height == height)
8620             return;
8621
8622           (*winp)->requisition.height = height;
8623         }
8624
8625       gtk_widget_queue_resize (GTK_WIDGET (text_view));
8626     }
8627 }
8628
8629 /**
8630  * gtk_text_view_set_border_window_size:
8631  * @text_view: a #GtkTextView
8632  * @type: window to affect
8633  * @size: width or height of the window
8634  *
8635  * Sets the width of %GTK_TEXT_WINDOW_LEFT or %GTK_TEXT_WINDOW_RIGHT,
8636  * or the height of %GTK_TEXT_WINDOW_TOP or %GTK_TEXT_WINDOW_BOTTOM.
8637  * Automatically destroys the corresponding window if the size is set
8638  * to 0, and creates the window if the size is set to non-zero.  This
8639  * function can only be used for the "border windows," it doesn't work
8640  * with #GTK_TEXT_WINDOW_WIDGET, #GTK_TEXT_WINDOW_TEXT, or
8641  * #GTK_TEXT_WINDOW_PRIVATE.
8642  **/
8643 void
8644 gtk_text_view_set_border_window_size (GtkTextView      *text_view,
8645                                       GtkTextWindowType type,
8646                                       gint              size)
8647
8648 {
8649   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8650   g_return_if_fail (size >= 0);
8651
8652   switch (type)
8653     {
8654     case GTK_TEXT_WINDOW_LEFT:
8655       set_window_width (text_view, size, GTK_TEXT_WINDOW_LEFT,
8656                         &text_view->left_window);
8657       break;
8658
8659     case GTK_TEXT_WINDOW_RIGHT:
8660       set_window_width (text_view, size, GTK_TEXT_WINDOW_RIGHT,
8661                         &text_view->right_window);
8662       break;
8663
8664     case GTK_TEXT_WINDOW_TOP:
8665       set_window_height (text_view, size, GTK_TEXT_WINDOW_TOP,
8666                          &text_view->top_window);
8667       break;
8668
8669     case GTK_TEXT_WINDOW_BOTTOM:
8670       set_window_height (text_view, size, GTK_TEXT_WINDOW_BOTTOM,
8671                          &text_view->bottom_window);
8672       break;
8673
8674     default:
8675       g_warning ("Can only set size of left/right/top/bottom border windows with gtk_text_view_set_border_window_size()");
8676       break;
8677     }
8678 }
8679
8680 /**
8681  * gtk_text_view_get_border_window_size:
8682  * @text_view: a #GtkTextView
8683  * @type: window to return size from
8684  *
8685  * Gets the width of the specified border window. See
8686  * gtk_text_view_set_border_window_size().
8687  *
8688  * Return value: width of window
8689  **/
8690 gint
8691 gtk_text_view_get_border_window_size (GtkTextView       *text_view,
8692                                       GtkTextWindowType  type)
8693 {
8694   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
8695
8696   switch (type)
8697     {
8698     case GTK_TEXT_WINDOW_LEFT:
8699       if (text_view->left_window)
8700         return text_view->left_window->requisition.width;
8701       break;
8702
8703     case GTK_TEXT_WINDOW_RIGHT:
8704       if (text_view->right_window)
8705         return text_view->right_window->requisition.width;
8706       break;
8707
8708     case GTK_TEXT_WINDOW_TOP:
8709       if (text_view->top_window)
8710         return text_view->top_window->requisition.height;
8711       break;
8712
8713     case GTK_TEXT_WINDOW_BOTTOM:
8714       if (text_view->bottom_window)
8715         return text_view->bottom_window->requisition.height;
8716       break;
8717
8718     default:
8719       g_warning ("Can only get size of left/right/top/bottom border windows with gtk_text_view_get_border_window_size()");
8720       break;
8721     }
8722
8723   return 0;
8724 }
8725
8726 /*
8727  * Child widgets
8728  */
8729
8730 static GtkTextViewChild*
8731 text_view_child_new_anchored (GtkWidget          *child,
8732                               GtkTextChildAnchor *anchor,
8733                               GtkTextLayout      *layout)
8734 {
8735   GtkTextViewChild *vc;
8736
8737   vc = g_new (GtkTextViewChild, 1);
8738
8739   vc->type = GTK_TEXT_WINDOW_PRIVATE;
8740   vc->widget = child;
8741   vc->anchor = anchor;
8742
8743   vc->from_top_of_line = 0;
8744   vc->from_left_of_buffer = 0;
8745
8746   g_object_ref (vc->widget);
8747   g_object_ref (vc->anchor);
8748
8749   g_object_set_data (G_OBJECT (child),
8750                      I_("gtk-text-view-child"),
8751                      vc);
8752
8753   gtk_text_child_anchor_register_child (anchor, child, layout);
8754
8755   return vc;
8756 }
8757
8758 static GtkTextViewChild*
8759 text_view_child_new_window (GtkWidget          *child,
8760                             GtkTextWindowType   type,
8761                             gint                x,
8762                             gint                y)
8763 {
8764   GtkTextViewChild *vc;
8765
8766   vc = g_new (GtkTextViewChild, 1);
8767
8768   vc->widget = child;
8769   vc->anchor = NULL;
8770
8771   vc->from_top_of_line = 0;
8772   vc->from_left_of_buffer = 0;
8773
8774   g_object_ref (vc->widget);
8775
8776   vc->type = type;
8777   vc->x = x;
8778   vc->y = y;
8779
8780   g_object_set_data (G_OBJECT (child),
8781                      I_("gtk-text-view-child"),
8782                      vc);
8783
8784   return vc;
8785 }
8786
8787 static void
8788 text_view_child_free (GtkTextViewChild *child)
8789 {
8790   g_object_set_data (G_OBJECT (child->widget),
8791                      I_("gtk-text-view-child"), NULL);
8792
8793   if (child->anchor)
8794     {
8795       gtk_text_child_anchor_unregister_child (child->anchor,
8796                                               child->widget);
8797       g_object_unref (child->anchor);
8798     }
8799
8800   g_object_unref (child->widget);
8801
8802   g_free (child);
8803 }
8804
8805 static void
8806 text_view_child_set_parent_window (GtkTextView      *text_view,
8807                                    GtkTextViewChild *vc)
8808 {
8809   if (vc->anchor)
8810     gtk_widget_set_parent_window (vc->widget,
8811                                   text_view->text_window->bin_window);
8812   else
8813     {
8814       GdkWindow *window;
8815       window = gtk_text_view_get_window (text_view,
8816                                          vc->type);
8817       gtk_widget_set_parent_window (vc->widget, window);
8818     }
8819 }
8820
8821 static void
8822 add_child (GtkTextView      *text_view,
8823            GtkTextViewChild *vc)
8824 {
8825   text_view->children = g_slist_prepend (text_view->children,
8826                                          vc);
8827
8828   if (GTK_WIDGET_REALIZED (text_view))
8829     text_view_child_set_parent_window (text_view, vc);
8830
8831   gtk_widget_set_parent (vc->widget, GTK_WIDGET (text_view));
8832 }
8833
8834 /**
8835  * gtk_text_view_add_child_at_anchor:
8836  * @text_view: a #GtkTextView
8837  * @child: a #GtkWidget
8838  * @anchor: a #GtkTextChildAnchor in the #GtkTextBuffer for @text_view
8839  *
8840  * Adds a child widget in the text buffer, at the given @anchor.
8841  **/
8842 void
8843 gtk_text_view_add_child_at_anchor (GtkTextView          *text_view,
8844                                    GtkWidget            *child,
8845                                    GtkTextChildAnchor   *anchor)
8846 {
8847   GtkTextViewChild *vc;
8848
8849   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8850   g_return_if_fail (GTK_IS_WIDGET (child));
8851   g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
8852   g_return_if_fail (child->parent == NULL);
8853
8854   gtk_text_view_ensure_layout (text_view);
8855
8856   vc = text_view_child_new_anchored (child, anchor,
8857                                      text_view->layout);
8858
8859   add_child (text_view, vc);
8860
8861   g_assert (vc->widget == child);
8862   g_assert (gtk_widget_get_parent (child) == GTK_WIDGET (text_view));
8863 }
8864
8865 /**
8866  * gtk_text_view_add_child_in_window:
8867  * @text_view: a #GtkTextView
8868  * @child: a #GtkWidget
8869  * @which_window: which window the child should appear in
8870  * @xpos: X position of child in window coordinates
8871  * @ypos: Y position of child in window coordinates
8872  *
8873  * Adds a child at fixed coordinates in one of the text widget's
8874  * windows. The window must have nonzero size (see
8875  * gtk_text_view_set_border_window_size()). Note that the child
8876  * coordinates are given relative to the #GdkWindow in question, and
8877  * that these coordinates have no sane relationship to scrolling. When
8878  * placing a child in #GTK_TEXT_WINDOW_WIDGET, scrolling is
8879  * irrelevant, the child floats above all scrollable areas. But when
8880  * placing a child in one of the scrollable windows (border windows or
8881  * text window), you'll need to compute the child's correct position
8882  * in buffer coordinates any time scrolling occurs or buffer changes
8883  * occur, and then call gtk_text_view_move_child() to update the
8884  * child's position. Unfortunately there's no good way to detect that
8885  * scrolling has occurred, using the current API; a possible hack
8886  * would be to update all child positions when the scroll adjustments
8887  * change or the text buffer changes. See bug 64518 on
8888  * bugzilla.gnome.org for status of fixing this issue.
8889  **/
8890 void
8891 gtk_text_view_add_child_in_window (GtkTextView       *text_view,
8892                                    GtkWidget         *child,
8893                                    GtkTextWindowType  which_window,
8894                                    gint               xpos,
8895                                    gint               ypos)
8896 {
8897   GtkTextViewChild *vc;
8898
8899   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8900   g_return_if_fail (GTK_IS_WIDGET (child));
8901   g_return_if_fail (child->parent == NULL);
8902
8903   vc = text_view_child_new_window (child, which_window,
8904                                    xpos, ypos);
8905
8906   add_child (text_view, vc);
8907
8908   g_assert (vc->widget == child);
8909   g_assert (gtk_widget_get_parent (child) == GTK_WIDGET (text_view));
8910 }
8911
8912 /**
8913  * gtk_text_view_move_child:
8914  * @text_view: a #GtkTextView
8915  * @child: child widget already added to the text view
8916  * @xpos: new X position in window coordinates
8917  * @ypos: new Y position in window coordinates
8918  *
8919  * Updates the position of a child, as for gtk_text_view_add_child_in_window().
8920  **/
8921 void
8922 gtk_text_view_move_child (GtkTextView *text_view,
8923                           GtkWidget   *child,
8924                           gint         xpos,
8925                           gint         ypos)
8926 {
8927   GtkTextViewChild *vc;
8928
8929   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
8930   g_return_if_fail (GTK_IS_WIDGET (child));
8931   g_return_if_fail (child->parent == (GtkWidget*) text_view);
8932
8933   vc = g_object_get_data (G_OBJECT (child),
8934                           "gtk-text-view-child");
8935
8936   g_assert (vc != NULL);
8937
8938   if (vc->x == xpos &&
8939       vc->y == ypos)
8940     return;
8941
8942   vc->x = xpos;
8943   vc->y = ypos;
8944
8945   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (text_view))
8946     gtk_widget_queue_resize (child);
8947 }
8948
8949
8950 /* Iterator operations */
8951
8952 /**
8953  * gtk_text_view_forward_display_line:
8954  * @text_view: a #GtkTextView
8955  * @iter: a #GtkTextIter
8956  *
8957  * Moves the given @iter forward by one display (wrapped) line.
8958  * A display line is different from a paragraph. Paragraphs are
8959  * separated by newlines or other paragraph separator characters.
8960  * Display lines are created by line-wrapping a paragraph. If
8961  * wrapping is turned off, display lines and paragraphs will be the
8962  * same. Display lines are divided differently for each view, since
8963  * they depend on the view's width; paragraphs are the same in all
8964  * views, since they depend on the contents of the #GtkTextBuffer.
8965  *
8966  * Return value: %TRUE if @iter was moved and is not on the end iterator
8967  **/
8968 gboolean
8969 gtk_text_view_forward_display_line (GtkTextView *text_view,
8970                                     GtkTextIter *iter)
8971 {
8972   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
8973   g_return_val_if_fail (iter != NULL, FALSE);
8974
8975   gtk_text_view_ensure_layout (text_view);
8976
8977   return gtk_text_layout_move_iter_to_next_line (text_view->layout, iter);
8978 }
8979
8980 /**
8981  * gtk_text_view_backward_display_line:
8982  * @text_view: a #GtkTextView
8983  * @iter: a #GtkTextIter
8984  *
8985  * Moves the given @iter backward by one display (wrapped) line.
8986  * A display line is different from a paragraph. Paragraphs are
8987  * separated by newlines or other paragraph separator characters.
8988  * Display lines are created by line-wrapping a paragraph. If
8989  * wrapping is turned off, display lines and paragraphs will be the
8990  * same. Display lines are divided differently for each view, since
8991  * they depend on the view's width; paragraphs are the same in all
8992  * views, since they depend on the contents of the #GtkTextBuffer.
8993  *
8994  * Return value: %TRUE if @iter was moved and is not on the end iterator
8995  **/
8996 gboolean
8997 gtk_text_view_backward_display_line (GtkTextView *text_view,
8998                                      GtkTextIter *iter)
8999 {
9000   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
9001   g_return_val_if_fail (iter != NULL, FALSE);
9002
9003   gtk_text_view_ensure_layout (text_view);
9004
9005   return gtk_text_layout_move_iter_to_previous_line (text_view->layout, iter);
9006 }
9007
9008 /**
9009  * gtk_text_view_forward_display_line_end:
9010  * @text_view: a #GtkTextView
9011  * @iter: a #GtkTextIter
9012  *
9013  * Moves the given @iter forward to the next display line end.
9014  * A display line is different from a paragraph. Paragraphs are
9015  * separated by newlines or other paragraph separator characters.
9016  * Display lines are created by line-wrapping a paragraph. If
9017  * wrapping is turned off, display lines and paragraphs will be the
9018  * same. Display lines are divided differently for each view, since
9019  * they depend on the view's width; paragraphs are the same in all
9020  * views, since they depend on the contents of the #GtkTextBuffer.
9021  *
9022  * Return value: %TRUE if @iter was moved and is not on the end iterator
9023  **/
9024 gboolean
9025 gtk_text_view_forward_display_line_end (GtkTextView *text_view,
9026                                         GtkTextIter *iter)
9027 {
9028   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
9029   g_return_val_if_fail (iter != NULL, FALSE);
9030
9031   gtk_text_view_ensure_layout (text_view);
9032
9033   return gtk_text_layout_move_iter_to_line_end (text_view->layout, iter, 1);
9034 }
9035
9036 /**
9037  * gtk_text_view_backward_display_line_start:
9038  * @text_view: a #GtkTextView
9039  * @iter: a #GtkTextIter
9040  *
9041  * Moves the given @iter backward to the next display line start.
9042  * A display line is different from a paragraph. Paragraphs are
9043  * separated by newlines or other paragraph separator characters.
9044  * Display lines are created by line-wrapping a paragraph. If
9045  * wrapping is turned off, display lines and paragraphs will be the
9046  * same. Display lines are divided differently for each view, since
9047  * they depend on the view's width; paragraphs are the same in all
9048  * views, since they depend on the contents of the #GtkTextBuffer.
9049  *
9050  * Return value: %TRUE if @iter was moved and is not on the end iterator
9051  **/
9052 gboolean
9053 gtk_text_view_backward_display_line_start (GtkTextView *text_view,
9054                                            GtkTextIter *iter)
9055 {
9056   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
9057   g_return_val_if_fail (iter != NULL, FALSE);
9058
9059   gtk_text_view_ensure_layout (text_view);
9060
9061   return gtk_text_layout_move_iter_to_line_end (text_view->layout, iter, -1);
9062 }
9063
9064 /**
9065  * gtk_text_view_starts_display_line:
9066  * @text_view: a #GtkTextView
9067  * @iter: a #GtkTextIter
9068  *
9069  * Determines whether @iter is at the start of a display line.
9070  * See gtk_text_view_forward_display_line() for an explanation of
9071  * display lines vs. paragraphs.
9072  *
9073  * Return value: %TRUE if @iter begins a wrapped line
9074  **/
9075 gboolean
9076 gtk_text_view_starts_display_line (GtkTextView       *text_view,
9077                                    const GtkTextIter *iter)
9078 {
9079   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
9080   g_return_val_if_fail (iter != NULL, FALSE);
9081
9082   gtk_text_view_ensure_layout (text_view);
9083
9084   return gtk_text_layout_iter_starts_line (text_view->layout, iter);
9085 }
9086
9087 /**
9088  * gtk_text_view_move_visually:
9089  * @text_view: a #GtkTextView
9090  * @iter: a #GtkTextIter
9091  * @count: number of characters to move (negative moves left,
9092  *    positive moves right)
9093  *
9094  * Move the iterator a given number of characters visually, treating
9095  * it as the strong cursor position. If @count is positive, then the
9096  * new strong cursor position will be @count positions to the right of
9097  * the old cursor position. If @count is negative then the new strong
9098  * cursor position will be @count positions to the left of the old
9099  * cursor position.
9100  *
9101  * In the presence of bi-directional text, the correspondence
9102  * between logical and visual order will depend on the direction
9103  * of the current run, and there may be jumps when the cursor
9104  * is moved off of the end of a run.
9105  *
9106  * Return value: %TRUE if @iter moved and is not on the end iterator
9107  **/
9108 gboolean
9109 gtk_text_view_move_visually (GtkTextView *text_view,
9110                              GtkTextIter *iter,
9111                              gint         count)
9112 {
9113   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
9114   g_return_val_if_fail (iter != NULL, FALSE);
9115
9116   gtk_text_view_ensure_layout (text_view);
9117
9118   return gtk_text_layout_move_iter_visually (text_view->layout, iter, count);
9119 }
9120
9121 #define __GTK_TEXT_VIEW_C__
9122 #include "gtkaliasdef.c"