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

   1 /* GTK - The GIMP Toolkit
   2  * gtktextview.c Copyright (C) 2000 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include <string.h>
  28
  29 #include "gtkbindings.h"
  30 #include "gtkdnd.h"
  31 #include "gtkintl.h"
  32 #include "gtkmain.h"
  33 #include "gtkmenu.h"
  34 #include "gtkmenuitem.h"
  35 #include "gtksignal.h"
  36 #include "gtktext.h"
  37 #include "gtktextdisplay.h"
  38 #include "gtktextview.h"
  39 #include "gtkimmulticontext.h"
  40 #include "gdk/gdkkeysyms.h"
  41 #include <string.h>
  42
  43 #define FOCUS_EDGE_WIDTH 1
  44 #define DRAG_THRESHOLD 8
  45
  46 #define SCREEN_WIDTH(widget) text_window_get_width (GTK_TEXT_VIEW (widget)->text_window)
  47 #define SCREEN_HEIGHT(widget) text_window_get_height (GTK_TEXT_VIEW (widget)->text_window)
  48
  49 enum
  50 {
  51   MOVE_CURSOR,
  52   SET_ANCHOR,
  53   INSERT_AT_CURSOR,
  54   DELETE_FROM_CURSOR,
  55   CUT_CLIPBOARD,
  56   COPY_CLIPBOARD,
  57   PASTE_CLIPBOARD,
  58   TOGGLE_OVERWRITE,
  59   SET_SCROLL_ADJUSTMENTS,
  60   LAST_SIGNAL
  61 };
  62
  63 enum
  64 {
  65   ARG_0,
  66   ARG_HEIGHT_LINES,
  67   ARG_WIDTH_COLUMNS,
  68   ARG_PIXELS_ABOVE_LINES,
  69   ARG_PIXELS_BELOW_LINES,
  70   ARG_PIXELS_INSIDE_WRAP,
  71   ARG_EDITABLE,
  72   ARG_WRAP_MODE,
  73   ARG_JUSTIFY,
  74   ARG_LEFT_MARGIN,
  75   ARG_RIGHT_MARGIN,
  76   ARG_INDENT,
  77   ARG_TABS,
  78   LAST_ARG
  79 };
  80
  81 static void gtk_text_view_init                 (GtkTextView      *text_view);
  82 static void gtk_text_view_class_init           (GtkTextViewClass *klass);
  83 static void gtk_text_view_destroy              (GtkObject        *object);
  84 static void gtk_text_view_finalize             (GObject          *object);
  85 static void gtk_text_view_set_arg              (GtkObject        *object,
  86                                                 GtkArg           *arg,
  87                                                 guint             arg_id);
  88 static void gtk_text_view_get_arg              (GtkObject        *object,
  89                                                 GtkArg           *arg,
  90                                                 guint             arg_id);
  91 static void gtk_text_view_size_request         (GtkWidget        *widget,
  92                                                 GtkRequisition   *requisition);
  93 static void gtk_text_view_size_allocate        (GtkWidget        *widget,
  94                                                 GtkAllocation    *allocation);
  95 static void gtk_text_view_realize              (GtkWidget        *widget);
  96 static void gtk_text_view_unrealize            (GtkWidget        *widget);
  97 static void gtk_text_view_style_set            (GtkWidget        *widget,
  98                                                 GtkStyle         *previous_style);
  99 static void gtk_text_view_direction_changed    (GtkWidget        *widget,
 100                                                 GtkTextDirection  previous_direction);
 101 static gint gtk_text_view_event                (GtkWidget        *widget,
 102                                                 GdkEvent         *event);
 103 static gint gtk_text_view_key_press_event      (GtkWidget        *widget,
 104                                                 GdkEventKey      *event);
 105 static gint gtk_text_view_key_release_event    (GtkWidget        *widget,
 106                                                 GdkEventKey      *event);
 107 static gint gtk_text_view_button_press_event   (GtkWidget        *widget,
 108                                                 GdkEventButton   *event);
 109 static gint gtk_text_view_button_release_event (GtkWidget        *widget,
 110                                                 GdkEventButton   *event);
 111 static gint gtk_text_view_focus_in_event       (GtkWidget        *widget,
 112                                                 GdkEventFocus    *event);
 113 static gint gtk_text_view_focus_out_event      (GtkWidget        *widget,
 114                                                 GdkEventFocus    *event);
 115 static gint gtk_text_view_motion_event         (GtkWidget        *widget,
 116                                                 GdkEventMotion   *event);
 117 static void gtk_text_view_draw                 (GtkWidget        *widget,
 118                                                 GdkRectangle     *area);
 119 static gint gtk_text_view_expose_event         (GtkWidget        *widget,
 120                                                 GdkEventExpose   *expose);
 121 static void gtk_text_view_draw_focus           (GtkWidget        *widget);
 122
 123 /* Source side drag signals */
 124 static void gtk_text_view_drag_begin       (GtkWidget        *widget,
 125                                             GdkDragContext   *context);
 126 static void gtk_text_view_drag_end         (GtkWidget        *widget,
 127                                             GdkDragContext   *context);
 128 static void gtk_text_view_drag_data_get    (GtkWidget        *widget,
 129                                             GdkDragContext   *context,
 130                                             GtkSelectionData *selection_data,
 131                                             guint             info,
 132                                             guint             time);
 133 static void gtk_text_view_drag_data_delete (GtkWidget        *widget,
 134                                             GdkDragContext   *context);
 135
 136 /* Target side drag signals */
 137 static void     gtk_text_view_drag_leave         (GtkWidget        *widget,
 138                                                   GdkDragContext   *context,
 139                                                   guint             time);
 140 static gboolean gtk_text_view_drag_motion        (GtkWidget        *widget,
 141                                                   GdkDragContext   *context,
 142                                                   gint              x,
 143                                                   gint              y,
 144                                                   guint             time);
 145 static gboolean gtk_text_view_drag_drop          (GtkWidget        *widget,
 146                                                   GdkDragContext   *context,
 147                                                   gint              x,
 148                                                   gint              y,
 149                                                   guint             time);
 150 static void     gtk_text_view_drag_data_received (GtkWidget        *widget,
 151                                                   GdkDragContext   *context,
 152                                                   gint              x,
 153                                                   gint              y,
 154                                                   GtkSelectionData *selection_data,
 155                                                   guint             info,
 156                                                   guint             time);
 157
 158 static void gtk_text_view_set_scroll_adjustments (GtkTextView   *text_view,
 159                                                   GtkAdjustment *hadj,
 160                                                   GtkAdjustment *vadj);
 161
 162 static void gtk_text_view_move_cursor      (GtkTextView           *text_view,
 163                                             GtkMovementStep        step,
 164                                             gint                   count,
 165                                             gboolean               extend_selection);
 166 static void gtk_text_view_set_anchor       (GtkTextView           *text_view);
 167 static void gtk_text_view_scroll_pages     (GtkTextView           *text_view,
 168                                             gint                   count);
 169 static void gtk_text_view_insert_at_cursor (GtkTextView           *text_view,
 170                                             const gchar           *str);
 171 static void gtk_text_view_delete_from_cursor (GtkTextView           *text_view,
 172                                               GtkDeleteType          type,
 173                                               gint                   count);
 174 static void gtk_text_view_cut_clipboard    (GtkTextView           *text_view);
 175 static void gtk_text_view_copy_clipboard   (GtkTextView           *text_view);
 176 static void gtk_text_view_paste_clipboard  (GtkTextView           *text_view);
 177 static void gtk_text_view_toggle_overwrite (GtkTextView           *text_view);
 178 static void gtk_text_view_unselect         (GtkTextView           *text_view);
 179
 180 static void     gtk_text_view_validate_onscreen     (GtkTextView        *text_view);
 181 static void     gtk_text_view_get_first_para_iter   (GtkTextView        *text_view,
 182                                                      GtkTextIter        *iter);
 183 static void     gtk_text_view_scroll_calc_now       (GtkTextView        *text_view);
 184 static void     gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
 185                                                          GtkTextAttributes *values,
 186                                                          GtkStyle           *style);
 187 static void     gtk_text_view_ensure_layout         (GtkTextView        *text_view);
 188 static void     gtk_text_view_destroy_layout        (GtkTextView        *text_view);
 189 static void     gtk_text_view_reset_im_context      (GtkTextView        *text_view);
 190 static void     gtk_text_view_start_selection_drag  (GtkTextView        *text_view,
 191                                                      const GtkTextIter  *iter,
 192                                                      GdkEventButton     *event);
 193 static gboolean gtk_text_view_end_selection_drag    (GtkTextView        *text_view,
 194                                                      GdkEventButton     *event);
 195 static void     gtk_text_view_start_selection_dnd   (GtkTextView        *text_view,
 196                                                      const GtkTextIter  *iter,
 197                                                      GdkEventMotion     *event);
 198 static void     gtk_text_view_start_cursor_blink    (GtkTextView        *text_view,
 199                                                      gboolean            with_delay);
 200 static void     gtk_text_view_stop_cursor_blink     (GtkTextView        *text_view);
 201
 202 static void gtk_text_view_value_changed           (GtkAdjustment *adj,
 203                                                    GtkTextView   *view);
 204 static void gtk_text_view_commit_handler          (GtkIMContext  *context,
 205                                                    const gchar   *str,
 206                                                    GtkTextView   *text_view);
 207 static void gtk_text_view_preedit_changed_handler (GtkIMContext  *context,
 208                                                    GtkTextView   *text_view);
 209
 210 static void gtk_text_view_mark_set_handler       (GtkTextBuffer     *buffer,
 211                                                   const GtkTextIter *location,
 212                                                   GtkTextMark       *mark,
 213                                                   gpointer           data);
 214 static void gtk_text_view_get_virtual_cursor_pos (GtkTextView       *text_view,
 215                                                   gint              *x,
 216                                                   gint              *y);
 217 static void gtk_text_view_set_virtual_cursor_pos (GtkTextView       *text_view,
 218                                                   gint               x,
 219                                                   gint               y);
 220
 221 static GtkAdjustment* get_hadjustment            (GtkTextView       *text_view);
 222 static GtkAdjustment* get_vadjustment            (GtkTextView       *text_view);
 223
 224 static void gtk_text_view_popup_menu             (GtkTextView       *text_view,
 225                                                   GdkEventButton    *event);
 226
 227 /* Container methods */
 228 static void gtk_text_view_add    (GtkContainer *container,
 229                                   GtkWidget    *child);
 230 static void gtk_text_view_remove (GtkContainer *container,
 231                                   GtkWidget    *child);
 232 static void gtk_text_view_forall (GtkContainer *container,
 233                                   gboolean      include_internals,
 234                                   GtkCallback   callback,
 235                                   gpointer      callback_data);
 236
 237 /* FIXME probably need the focus methods. */
 238
 239 typedef struct _GtkTextViewChild GtkTextViewChild;
 240
 241 struct _GtkTextViewChild
 242 {
 243   GtkWidget *widget;
 244
 245   GtkTextChildAnchor *anchor;
 246
 247   gint from_top_of_line;
 248   gint from_left_of_buffer;
 249
 250   /* These are ignored if anchor != NULL */
 251   GtkTextWindowType type;
 252   gint x;
 253   gint y;
 254 };
 255
 256 static GtkTextViewChild* text_view_child_new_anchored (GtkWidget          *child,
 257                                                        GtkTextChildAnchor *anchor,
 258                                                        GtkTextLayout      *layout);
 259 static GtkTextViewChild* text_view_child_new_window   (GtkWidget          *child,
 260                                                        GtkTextWindowType   type,
 261                                                        gint                x,
 262                                                        gint                y);
 263 static void              text_view_child_free         (GtkTextViewChild   *child);
 264
 265 static void              text_view_child_realize      (GtkTextView      *text_view,
 266                                                        GtkTextViewChild *child);
 267
 268 struct _GtkTextWindow
 269 {
 270   GtkTextWindowType type;
 271   GtkWidget *widget;
 272   GdkWindow *window;
 273   GdkWindow *bin_window;
 274   GtkRequisition requisition;
 275   GdkRectangle allocation;
 276 };
 277
 278 static GtkTextWindow *text_window_new             (GtkTextWindowType  type,
 279                                                    GtkWidget         *widget,
 280                                                    gint               width_request,
 281                                                    gint               height_request);
 282 static void           text_window_free            (GtkTextWindow     *win);
 283 static void           text_window_realize         (GtkTextWindow     *win,
 284                                                    GdkWindow         *parent);
 285 static void           text_window_unrealize       (GtkTextWindow     *win);
 286 static void           text_window_size_allocate   (GtkTextWindow     *win,
 287                                                    GdkRectangle      *rect);
 288 static void           text_window_scroll          (GtkTextWindow     *win,
 289                                                    gint               dx,
 290                                                    gint               dy);
 291 static void           text_window_invalidate_rect (GtkTextWindow     *win,
 292                                                    GdkRectangle      *rect);
 293
 294 static gint           text_window_get_width       (GtkTextWindow     *win);
 295 static gint           text_window_get_height      (GtkTextWindow     *win);
 296 static void           text_window_get_allocation  (GtkTextWindow     *win,
 297                                                    GdkRectangle      *rect);
 298
 299
 300 enum
 301 {
 302   TARGET_STRING,
 303   TARGET_TEXT,
 304   TARGET_COMPOUND_TEXT,
 305   TARGET_UTF8_STRING,
 306   TARGET_TEXT_BUFFER_CONTENTS
 307 };
 308
 309 static GtkTargetEntry target_table[] = {
 310   { "GTK_TEXT_BUFFER_CONTENTS", GTK_TARGET_SAME_APP,
 311     TARGET_TEXT_BUFFER_CONTENTS },
 312   { "UTF8_STRING", 0, TARGET_UTF8_STRING },
 313   { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
 314   { "TEXT", 0, TARGET_TEXT },
 315   { "text/plain", 0, TARGET_STRING },
 316   { "STRING",     0, TARGET_STRING }
 317 };
 318
 319 static GtkContainerClass *parent_class = NULL;
 320 static guint signals[LAST_SIGNAL] = { 0 };
 321
 322 GtkType
 323 gtk_text_view_get_type (void)
 324 {
 325   static GtkType our_type = 0;
 326
 327   if (our_type == 0)
 328     {
 329       static const GtkTypeInfo our_info =
 330       {
 331         "GtkTextView",
 332         sizeof (GtkTextView),
 333         sizeof (GtkTextViewClass),
 334         (GtkClassInitFunc) gtk_text_view_class_init,
 335         (GtkObjectInitFunc) gtk_text_view_init,
 336         /* reserved_1 */ NULL,
 337         /* reserved_2 */ NULL,
 338         (GtkClassInitFunc) NULL
 339       };
 340
 341       our_type = gtk_type_unique (GTK_TYPE_CONTAINER, &our_info);
 342     }
 343
 344   return our_type;
 345 }
 346
 347 static void
 348 add_move_binding (GtkBindingSet  *binding_set,
 349                   guint           keyval,
 350                   guint           modmask,
 351                   GtkMovementStep step,
 352                   gint            count)
 353 {
 354   g_return_if_fail ((modmask & GDK_SHIFT_MASK) == 0);
 355
 356   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
 357                                 "move_cursor", 3,
 358                                 GTK_TYPE_ENUM, step,
 359                                 GTK_TYPE_INT, count,
 360                                 GTK_TYPE_BOOL, FALSE);
 361
 362   /* Selection-extending version */
 363   gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,
 364                                 "move_cursor", 3,
 365                                 GTK_TYPE_ENUM, step,
 366                                 GTK_TYPE_INT, count,
 367                                 GTK_TYPE_BOOL, TRUE);
 368 }
 369
 370 static void
 371 gtk_text_view_class_init (GtkTextViewClass *klass)
 372 {
 373   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 374   GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
 375   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 376   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 377   GtkBindingSet *binding_set;
 378
 379   parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
 380
 381   /*
 382    * Arguments
 383    */
 384   gtk_object_add_arg_type ("GtkTextView::height_lines", GTK_TYPE_INT,
 385                            GTK_ARG_READWRITE, ARG_HEIGHT_LINES);
 386   gtk_object_add_arg_type ("GtkTextView::width_columns", GTK_TYPE_INT,
 387                            GTK_ARG_READWRITE, ARG_WIDTH_COLUMNS);
 388   gtk_object_add_arg_type ("GtkTextView::pixels_above_lines", GTK_TYPE_INT,
 389                            GTK_ARG_READWRITE, ARG_PIXELS_ABOVE_LINES);
 390   gtk_object_add_arg_type ("GtkTextView::pixels_below_lines", GTK_TYPE_INT,
 391                            GTK_ARG_READWRITE, ARG_PIXELS_BELOW_LINES);
 392   gtk_object_add_arg_type ("GtkTextView::pixels_inside_wrap", GTK_TYPE_INT,
 393                            GTK_ARG_READWRITE, ARG_PIXELS_INSIDE_WRAP);
 394   gtk_object_add_arg_type ("GtkTextView::editable", GTK_TYPE_BOOL,
 395                            GTK_ARG_READWRITE, ARG_EDITABLE);
 396   gtk_object_add_arg_type ("GtkTextView::wrap_mode", GTK_TYPE_ENUM,
 397                            GTK_ARG_READWRITE, ARG_WRAP_MODE);
 398   gtk_object_add_arg_type ("GtkTextView::justify", GTK_TYPE_ENUM,
 399                            GTK_ARG_READWRITE, ARG_JUSTIFY);
 400   gtk_object_add_arg_type ("GtkTextView::left_margin", GTK_TYPE_INT,
 401                            GTK_ARG_READWRITE, ARG_LEFT_MARGIN);
 402   gtk_object_add_arg_type ("GtkTextView::right_margin", GTK_TYPE_INT,
 403                            GTK_ARG_READWRITE, ARG_RIGHT_MARGIN);
 404   gtk_object_add_arg_type ("GtkTextView::indent", GTK_TYPE_INT,
 405                            GTK_ARG_READWRITE, ARG_INDENT);
 406   gtk_object_add_arg_type ("GtkTextView::tabs", GTK_TYPE_POINTER, /* FIXME */
 407                            GTK_ARG_READWRITE, ARG_TABS);
 408
 409   /*
 410    * Signals
 411    */
 412
 413   signals[MOVE_CURSOR] =
 414     gtk_signal_new ("move_cursor",
 415                     GTK_RUN_LAST | GTK_RUN_ACTION,
 416                     GTK_CLASS_TYPE (object_class),
 417                     GTK_SIGNAL_OFFSET (GtkTextViewClass, move_cursor),
 418                     gtk_marshal_VOID__ENUM_INT_BOOLEAN,
 419                     GTK_TYPE_NONE, 3, GTK_TYPE_MOVEMENT_STEP, GTK_TYPE_INT, GTK_TYPE_BOOL);
 420
 421   signals[SET_ANCHOR] =
 422     gtk_signal_new ("set_anchor",
 423                     GTK_RUN_LAST | GTK_RUN_ACTION,
 424                     GTK_CLASS_TYPE (object_class),
 425                     GTK_SIGNAL_OFFSET (GtkTextViewClass, set_anchor),
 426                     gtk_marshal_VOID__VOID,
 427                     GTK_TYPE_NONE, 0);
 428
 429   signals[INSERT_AT_CURSOR] =
 430     gtk_signal_new ("insert_at_cursor",
 431                     GTK_RUN_LAST | GTK_RUN_ACTION,
 432                     GTK_CLASS_TYPE (object_class),
 433                     GTK_SIGNAL_OFFSET (GtkTextViewClass, insert_at_cursor),
 434                     gtk_marshal_VOID__POINTER,
 435                     GTK_TYPE_NONE, 1, GTK_TYPE_STRING);
 436
 437   signals[DELETE_FROM_CURSOR] =
 438     gtk_signal_new ("delete_from_cursor",
 439                     GTK_RUN_LAST | GTK_RUN_ACTION,
 440                     GTK_CLASS_TYPE (object_class),
 441                     GTK_SIGNAL_OFFSET (GtkTextViewClass, delete_from_cursor),
 442                     gtk_marshal_VOID__ENUM_INT,
 443                     GTK_TYPE_NONE, 2, GTK_TYPE_DELETE_TYPE, GTK_TYPE_INT);
 444
 445   signals[CUT_CLIPBOARD] =
 446     gtk_signal_new ("cut_clipboard",
 447                     GTK_RUN_LAST | GTK_RUN_ACTION,
 448                     GTK_CLASS_TYPE (object_class),
 449                     GTK_SIGNAL_OFFSET (GtkTextViewClass, cut_clipboard),
 450                     gtk_marshal_VOID__VOID,
 451                     GTK_TYPE_NONE, 0);
 452
 453   signals[COPY_CLIPBOARD] =
 454     gtk_signal_new ("copy_clipboard",
 455                     GTK_RUN_LAST | GTK_RUN_ACTION,
 456                     GTK_CLASS_TYPE (object_class),
 457                     GTK_SIGNAL_OFFSET (GtkTextViewClass, copy_clipboard),
 458                     gtk_marshal_VOID__VOID,
 459                     GTK_TYPE_NONE, 0);
 460
 461   signals[PASTE_CLIPBOARD] =
 462     gtk_signal_new ("paste_clipboard",
 463                     GTK_RUN_LAST | GTK_RUN_ACTION,
 464                     GTK_CLASS_TYPE (object_class),
 465                     GTK_SIGNAL_OFFSET (GtkTextViewClass, paste_clipboard),
 466                     gtk_marshal_VOID__VOID,
 467                     GTK_TYPE_NONE, 0);
 468
 469   signals[TOGGLE_OVERWRITE] =
 470     gtk_signal_new ("toggle_overwrite",
 471                     GTK_RUN_LAST | GTK_RUN_ACTION,
 472                     GTK_CLASS_TYPE (object_class),
 473                     GTK_SIGNAL_OFFSET (GtkTextViewClass, toggle_overwrite),
 474                     gtk_marshal_VOID__VOID,
 475                     GTK_TYPE_NONE, 0);
 476
 477   signals[SET_SCROLL_ADJUSTMENTS] = widget_class->set_scroll_adjustments_signal =
 478     gtk_signal_new ("set_scroll_adjustments",
 479                     GTK_RUN_LAST,
 480                     GTK_CLASS_TYPE (object_class),
 481                     GTK_SIGNAL_OFFSET (GtkTextViewClass, set_scroll_adjustments),
 482                     gtk_marshal_VOID__POINTER_POINTER,
 483                     GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 484
 485   gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL);
 486
 487   /*
 488    * Key bindings
 489    */
 490
 491   binding_set = gtk_binding_set_by_class (klass);
 492
 493   /* Moving the insertion point */
 494   add_move_binding (binding_set, GDK_Right, 0,
 495                     GTK_MOVEMENT_POSITIONS, 1);
 496
 497   add_move_binding (binding_set, GDK_Left, 0,
 498                     GTK_MOVEMENT_POSITIONS, -1);
 499
 500   add_move_binding (binding_set, GDK_f, GDK_CONTROL_MASK,
 501                     GTK_MOVEMENT_CHARS, 1);
 502
 503   add_move_binding (binding_set, GDK_b, GDK_CONTROL_MASK,
 504                     GTK_MOVEMENT_CHARS, -1);
 505
 506   add_move_binding (binding_set, GDK_Right, GDK_CONTROL_MASK,
 507                     GTK_MOVEMENT_WORDS, 1);
 508
 509   add_move_binding (binding_set, GDK_Left, GDK_CONTROL_MASK,
 510                     GTK_MOVEMENT_WORDS, -1);
 511
 512   /* Eventually we want to move by display lines, not paragraphs */
 513   add_move_binding (binding_set, GDK_Up, 0,
 514                     GTK_MOVEMENT_DISPLAY_LINES, -1);
 515
 516   add_move_binding (binding_set, GDK_Down, 0,
 517                     GTK_MOVEMENT_DISPLAY_LINES, 1);
 518
 519   add_move_binding (binding_set, GDK_p, GDK_CONTROL_MASK,
 520                     GTK_MOVEMENT_DISPLAY_LINES, -1);
 521
 522   add_move_binding (binding_set, GDK_n, GDK_CONTROL_MASK,
 523                     GTK_MOVEMENT_DISPLAY_LINES, 1);
 524
 525   add_move_binding (binding_set, GDK_a, GDK_CONTROL_MASK,
 526                     GTK_MOVEMENT_PARAGRAPH_ENDS, -1);
 527
 528   add_move_binding (binding_set, GDK_e, GDK_CONTROL_MASK,
 529                     GTK_MOVEMENT_PARAGRAPH_ENDS, 1);
 530
 531   add_move_binding (binding_set, GDK_f, GDK_MOD1_MASK,
 532                     GTK_MOVEMENT_WORDS, 1);
 533
 534   add_move_binding (binding_set, GDK_b, GDK_MOD1_MASK,
 535                     GTK_MOVEMENT_WORDS, -1);
 536
 537   add_move_binding (binding_set, GDK_Home, 0,
 538                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
 539
 540   add_move_binding (binding_set, GDK_End, 0,
 541                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
 542
 543   add_move_binding (binding_set, GDK_Home, GDK_CONTROL_MASK,
 544                     GTK_MOVEMENT_BUFFER_ENDS, -1);
 545
 546   add_move_binding (binding_set, GDK_End, GDK_CONTROL_MASK,
 547                     GTK_MOVEMENT_BUFFER_ENDS, 1);
 548
 549   add_move_binding (binding_set, GDK_Page_Up, 0,
 550                     GTK_MOVEMENT_PAGES, -1);
 551
 552   add_move_binding (binding_set, GDK_Page_Down, 0,
 553                     GTK_MOVEMENT_PAGES, 1);
 554
 555
 556   /* Setting the cut/paste/copy anchor */
 557   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK,
 558                                 "set_anchor", 0);
 559
 560   /* Deleting text */
 561   gtk_binding_entry_add_signal (binding_set, GDK_Delete, 0,
 562                                 "delete_from_cursor", 2,
 563                                 GTK_TYPE_ENUM, GTK_DELETE_CHARS,
 564                                 GTK_TYPE_INT, 1);
 565
 566   gtk_binding_entry_add_signal (binding_set, GDK_d, GDK_CONTROL_MASK,
 567                                 "delete_from_cursor", 2,
 568                                 GTK_TYPE_ENUM, GTK_DELETE_CHARS,
 569                                 GTK_TYPE_INT, 1);
 570
 571   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0,
 572                                 "delete_from_cursor", 2,
 573                                 GTK_TYPE_ENUM, GTK_DELETE_CHARS,
 574                                 GTK_TYPE_INT, -1);
 575
 576   gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_CONTROL_MASK,
 577                                 "delete_from_cursor", 2,
 578                                 GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
 579                                 GTK_TYPE_INT, 1);
 580
 581   gtk_binding_entry_add_signal (binding_set, GDK_d, GDK_MOD1_MASK,
 582                                 "delete_from_cursor", 2,
 583                                 GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
 584                                 GTK_TYPE_INT, 1);
 585
 586   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_CONTROL_MASK,
 587                                 "delete_from_cursor", 2,
 588                                 GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
 589                                 GTK_TYPE_INT, -1);
 590
 591   gtk_binding_entry_add_signal (binding_set, GDK_k, GDK_CONTROL_MASK,
 592                                 "delete_from_cursor", 2,
 593                                 GTK_TYPE_ENUM, GTK_DELETE_PARAGRAPH_ENDS,
 594                                 GTK_TYPE_INT, 1);
 595
 596   gtk_binding_entry_add_signal (binding_set, GDK_u, GDK_CONTROL_MASK,
 597                                 "delete_from_cursor", 2,
 598                                 GTK_TYPE_ENUM, GTK_DELETE_PARAGRAPHS,
 599                                 GTK_TYPE_INT, 1);
 600
 601   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_MOD1_MASK,
 602                                 "delete_from_cursor", 2,
 603                                 GTK_TYPE_ENUM, GTK_DELETE_WHITESPACE,
 604                                 GTK_TYPE_INT, 1);
 605   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_MOD1_MASK,
 606                                 "insert_at_cursor", 1,
 607                                 GTK_TYPE_STRING, " ");
 608
 609   gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_MOD1_MASK,
 610                                 "delete_from_cursor", 2,
 611                                 GTK_TYPE_ENUM, GTK_DELETE_WHITESPACE,
 612                                 GTK_TYPE_INT, 1);
 613
 614   /* Cut/copy/paste */
 615
 616   gtk_binding_entry_add_signal (binding_set, GDK_x, GDK_CONTROL_MASK,
 617                                 "cut_clipboard", 0);
 618
 619   gtk_binding_entry_add_signal (binding_set, GDK_w, GDK_CONTROL_MASK,
 620                                 "cut_clipboard", 0);
 621
 622   gtk_binding_entry_add_signal (binding_set, GDK_c, GDK_CONTROL_MASK,
 623                                 "copy_clipboard", 0);
 624
 625   gtk_binding_entry_add_signal (binding_set, GDK_v, GDK_CONTROL_MASK,
 626                                 "paste_clipboard", 0);
 627
 628   gtk_binding_entry_add_signal (binding_set, GDK_y, GDK_CONTROL_MASK,
 629                                 "paste_clipboard", 0);
 630
 631   /* Overwrite */
 632   gtk_binding_entry_add_signal (binding_set, GDK_Insert, 0,
 633                                 "toggle_overwrite", 0);
 634
 635   /*
 636    * Default handlers and virtual methods
 637    */
 638   object_class->set_arg = gtk_text_view_set_arg;
 639   object_class->get_arg = gtk_text_view_get_arg;
 640
 641   object_class->destroy = gtk_text_view_destroy;
 642   gobject_class->finalize = gtk_text_view_finalize;
 643
 644   widget_class->realize = gtk_text_view_realize;
 645   widget_class->unrealize = gtk_text_view_unrealize;
 646   widget_class->style_set = gtk_text_view_style_set;
 647   widget_class->direction_changed = gtk_text_view_direction_changed;
 648   widget_class->size_request = gtk_text_view_size_request;
 649   widget_class->size_allocate = gtk_text_view_size_allocate;
 650   widget_class->event = gtk_text_view_event;
 651   widget_class->key_press_event = gtk_text_view_key_press_event;
 652   widget_class->key_release_event = gtk_text_view_key_release_event;
 653   widget_class->button_press_event = gtk_text_view_button_press_event;
 654   widget_class->button_release_event = gtk_text_view_button_release_event;
 655   widget_class->focus_in_event = gtk_text_view_focus_in_event;
 656   widget_class->focus_out_event = gtk_text_view_focus_out_event;
 657   widget_class->motion_notify_event = gtk_text_view_motion_event;
 658   widget_class->expose_event = gtk_text_view_expose_event;
 659   widget_class->draw = gtk_text_view_draw;
 660   widget_class->draw_focus = gtk_text_view_draw_focus;
 661
 662   widget_class->drag_begin = gtk_text_view_drag_begin;
 663   widget_class->drag_end = gtk_text_view_drag_end;
 664   widget_class->drag_data_get = gtk_text_view_drag_data_get;
 665   widget_class->drag_data_delete = gtk_text_view_drag_data_delete;
 666
 667   widget_class->drag_leave = gtk_text_view_drag_leave;
 668   widget_class->drag_motion = gtk_text_view_drag_motion;
 669   widget_class->drag_drop = gtk_text_view_drag_drop;
 670   widget_class->drag_data_received = gtk_text_view_drag_data_received;
 671
 672   container_class->add = gtk_text_view_add;
 673   container_class->remove = gtk_text_view_remove;
 674   container_class->forall = gtk_text_view_forall;
 675
 676   klass->move_cursor = gtk_text_view_move_cursor;
 677   klass->set_anchor = gtk_text_view_set_anchor;
 678   klass->insert_at_cursor = gtk_text_view_insert_at_cursor;
 679   klass->delete_from_cursor = gtk_text_view_delete_from_cursor;
 680   klass->cut_clipboard = gtk_text_view_cut_clipboard;
 681   klass->copy_clipboard = gtk_text_view_copy_clipboard;
 682   klass->paste_clipboard = gtk_text_view_paste_clipboard;
 683   klass->toggle_overwrite = gtk_text_view_toggle_overwrite;
 684   klass->set_scroll_adjustments = gtk_text_view_set_scroll_adjustments;
 685 }
 686
 687 void
 688 gtk_text_view_init (GtkTextView *text_view)
 689 {
 690   GtkWidget *widget;
 691
 692   widget = GTK_WIDGET (text_view);
 693
 694   GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
 695
 696   /* Set up default style */
 697   text_view->wrap_mode = GTK_WRAPMODE_NONE;
 698   text_view->pixels_above_lines = 0;
 699   text_view->pixels_below_lines = 0;
 700   text_view->pixels_inside_wrap = 0;
 701   text_view->justify = GTK_JUSTIFY_LEFT;
 702   text_view->left_margin = 0;
 703   text_view->right_margin = 0;
 704   text_view->indent = 0;
 705   text_view->tabs = NULL;
 706   text_view->editable = TRUE;
 707
 708   gtk_drag_dest_set (widget,
 709                      GTK_DEST_DEFAULT_DROP,
 710                      target_table, G_N_ELEMENTS (target_table),
 711                      GDK_ACTION_COPY | GDK_ACTION_MOVE);
 712
 713   text_view->virtual_cursor_x = -1;
 714   text_view->virtual_cursor_y = -1;
 715
 716   /* This object is completely private. No external entity can gain a reference
 717    * to it; so we create it here and destroy it in finalize ().
 718    */
 719   text_view->im_context = gtk_im_multicontext_new ();
 720
 721   gtk_signal_connect (GTK_OBJECT (text_view->im_context), "commit",
 722                       GTK_SIGNAL_FUNC (gtk_text_view_commit_handler), text_view);
 723
 724   gtk_signal_connect (GTK_OBJECT (text_view->im_context), "preedit_changed",
 725                       GTK_SIGNAL_FUNC (gtk_text_view_preedit_changed_handler), text_view);
 726
 727   text_view->cursor_visible = TRUE;
 728
 729   text_view->text_window = text_window_new (GTK_TEXT_WINDOW_TEXT,
 730                                             widget, 200, 200);
 731
 732   text_view->drag_start_x = -1;
 733   text_view->drag_start_y = -1;
 734 }
 735
 736 /**
 737  * gtk_text_view_new:
 738  *
 739  * Creates a new #GtkTextView. If you don't call gtk_text_view_set_buffer()
 740  * before using the text view, an empty default buffer will be created
 741  * for you. Get the buffer with gtk_text_view_get_buffer(). If you want
 742  * to specify your own buffer, consider gtk_text_view_new_with_buffer().
 743  *
 744  * Return value: a new #GtkTextView
 745  **/
 746 GtkWidget*
 747 gtk_text_view_new (void)
 748 {
 749   return GTK_WIDGET (gtk_type_new (gtk_text_view_get_type ()));
 750 }
 751
 752 /**
 753  * gtk_text_view_new_with_buffer:
 754  * @buffer: a #GtkTextBuffer
 755  *
 756  * Creates a new #GtkTextView widget displaying the buffer
 757  * @buffer. One buffer can be shared among many widgets.
 758  * @buffer may be NULL to create a default buffer, in which case
 759  * this function is equivalent to gtk_text_view_new(). The
 760  * text view adds its own reference count to the buffer; it does not
 761  * take over an existing reference.
 762  *
 763  * Return value: a new #GtkTextView.
 764  **/
 765 GtkWidget*
 766 gtk_text_view_new_with_buffer (GtkTextBuffer *buffer)
 767 {
 768   GtkTextView *text_view;
 769
 770   text_view = (GtkTextView*)gtk_text_view_new ();
 771
 772   gtk_text_view_set_buffer (text_view, buffer);
 773
 774   return GTK_WIDGET (text_view);
 775 }
 776
 777 /**
 778  * gtk_text_view_set_buffer:
 779  * @text_view: a #GtkTextView
 780  * @buffer: a #GtkTextBuffer
 781  *
 782  * Sets @buffer as the buffer being displayed by @text_view. The previous
 783  * buffer displayed by the text view is unreferenced, and a reference is
 784  * added to @buffer. If you owned a reference to @buffer before passing it
 785  * to this function, you must remove that reference yourself; #GtkTextView
 786  * will not "adopt" it.
 787  *
 788  **/
 789 void
 790 gtk_text_view_set_buffer (GtkTextView   *text_view,
 791                           GtkTextBuffer *buffer)
 792 {
 793   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
 794   g_return_if_fail (buffer == NULL || GTK_IS_TEXT_BUFFER (buffer));
 795
 796   if (text_view->buffer == buffer)
 797     return;
 798
 799   if (text_view->buffer != NULL)
 800     {
 801       /* Destroy all anchored children */
 802       GSList *tmp_list;
 803       GSList *copy;
 804
 805       copy = g_slist_copy (text_view->children);
 806       tmp_list = copy;
 807       while (tmp_list != NULL)
 808         {
 809           GtkTextViewChild *vc = tmp_list->data;
 810
 811           if (vc->anchor)
 812             {
 813               gtk_widget_destroy (vc->widget);
 814               /* vc may now be invalid! */
 815             }
 816
 817           tmp_list = g_slist_next (tmp_list);
 818         }
 819
 820       g_slist_free (copy);
 821
 822       gtk_signal_disconnect_by_func (GTK_OBJECT (text_view->buffer),
 823                                      gtk_text_view_mark_set_handler, text_view);
 824       gtk_object_unref (GTK_OBJECT (text_view->buffer));
 825       text_view->dnd_mark = NULL;
 826     }
 827
 828   text_view->buffer = buffer;
 829
 830   if (buffer != NULL)
 831     {
 832       GtkTextIter start;
 833
 834       gtk_object_ref (GTK_OBJECT (buffer));
 835       gtk_object_sink (GTK_OBJECT (buffer));
 836
 837       if (text_view->layout)
 838         gtk_text_layout_set_buffer (text_view->layout, buffer);
 839
 840       gtk_text_buffer_get_iter_at_offset (text_view->buffer, &start, 0);
 841
 842       text_view->dnd_mark = gtk_text_buffer_create_mark (text_view->buffer,
 843                                                          "gtk_drag_target",
 844                                                          &start, FALSE);
 845
 846       text_view->first_para_mark = gtk_text_buffer_create_mark (text_view->buffer,
 847                                                                 NULL,
 848                                                                 &start, TRUE);
 849
 850       text_view->first_para_pixels = 0;
 851
 852       gtk_signal_connect (GTK_OBJECT (text_view->buffer), "mark_set",
 853                           gtk_text_view_mark_set_handler, text_view);
 854     }
 855
 856   if (GTK_WIDGET_VISIBLE (text_view))
 857     gtk_widget_queue_draw (GTK_WIDGET (text_view));
 858 }
 859
 860 static GtkTextBuffer*
 861 get_buffer (GtkTextView *text_view)
 862 {
 863   if (text_view->buffer == NULL)
 864     {
 865       GtkTextBuffer *b;
 866       b = gtk_text_buffer_new (NULL);
 867       gtk_text_view_set_buffer (text_view, b);
 868       g_object_unref (G_OBJECT (b));
 869     }
 870
 871   return text_view->buffer;
 872 }
 873
 874 /**
 875  * gtk_text_view_get_buffer:
 876  * @text_view: a #GtkTextView
 877  *
 878  * Returns the #GtkTextBuffer being displayed by this text view.
 879  * The reference count on the buffer is not incremented; the caller
 880  * of this function won't own a new reference.
 881  *
 882  * Return value: a #GtkTextBuffer
 883  **/
 884 GtkTextBuffer*
 885 gtk_text_view_get_buffer (GtkTextView *text_view)
 886 {
 887   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
 888
 889   return get_buffer (text_view);
 890 }
 891
 892 /**
 893  * gtk_text_view_get_iter_at_location:
 894  * @text_view: a #GtkTextView
 895  * @iter: a #GtkTextIter
 896  * @x: x position, in buffer coordinates
 897  * @y: y position, in buffer coordinates
 898  *
 899  * Retrieves the iterator at buffer coordinates @x and @y. Buffer
 900  * coordinates are coordinates for the entire buffer, not just the
 901  * currently-displayed portion.  If you have coordinates from an
 902  * event, you have to convert those to buffer coordinates with
 903  * gtk_text_view_window_to_buffer_coords().
 904  *
 905  **/
 906 void
 907 gtk_text_view_get_iter_at_location (GtkTextView *text_view,
 908                                     GtkTextIter *iter,
 909                                     gint         x,
 910                                     gint         y)
 911 {
 912   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
 913   g_return_if_fail (iter != NULL);
 914   g_return_if_fail (text_view->layout != NULL);
 915
 916   gtk_text_layout_get_iter_at_pixel (text_view->layout,
 917                                      iter,
 918                                      x,
 919                                      y);
 920 }
 921
 922 /**
 923  * gtk_text_view_get_iter_location:
 924  * @text_view: a #GtkTextView
 925  * @iter: a #GtkTextIter
 926  * @location: bounds of the character at @iter
 927  *
 928  * Gets a rectangle which roughly contains the character at @iter.
 929  * The rectangle position is in buffer coordinates; use
 930  * gtk_text_view_buffer_to_window_coords() to convert these
 931  * coordinates to coordinates for one of the windows in the text view.
 932  *
 933  **/
 934 void
 935 gtk_text_view_get_iter_location (GtkTextView       *text_view,
 936                                  const GtkTextIter *iter,
 937                                  GdkRectangle      *location)
 938 {
 939   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
 940   g_return_if_fail (gtk_text_iter_get_buffer (iter) == get_buffer (text_view));
 941
 942   gtk_text_layout_get_iter_location (text_view->layout, iter, location);
 943 }
 944
 945 /**
 946  * gtk_text_view_get_line_yrange:
 947  * @text_view: a #GtkTextView
 948  * @iter: a #GtkTextIter
 949  * @y: return location for a y coordinate
 950  * @height: return location for a height
 951  *
 952  * Gets the y coordinate of the top of the line containing @iter,
 953  * and the height of the line. The coordinate is a buffer coordinate;
 954  * convert to window coordinates with gtk_text_view_buffer_to_window_coords().
 955  *
 956  **/
 957 void
 958 gtk_text_view_get_line_yrange (GtkTextView       *text_view,
 959                                const GtkTextIter *iter,
 960                                gint              *y,
 961                                gint              *height)
 962 {
 963   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
 964   g_return_if_fail (gtk_text_iter_get_buffer (iter) == get_buffer (text_view));
 965
 966   gtk_text_layout_get_line_yrange (text_view->layout,
 967                                    iter,
 968                                    y,
 969                                    height);
 970 }
 971
 972 /**
 973  * gtk_text_view_get_line_at_y:
 974  * @text_view: a #GtkTextView
 975  * @target_iter: a #GtkTextIter
 976  * @y: a y coordinate
 977  * @line_top: return location for top coordinate of the line
 978  *
 979  * Gets the #GtkTextIter at the start of the line containing
 980  * the coordinate @y. @y is in buffer coordinates, convert from
 981  * window coordinates with gtk_text_view_window_to_buffer_coords().
 982  * If non-%NULL, @line_top will be filled with the coordinate of the top
 983  * edge of the line.
 984  **/
 985 void
 986 gtk_text_view_get_line_at_y (GtkTextView *text_view,
 987                              GtkTextIter *target_iter,
 988                              gint         y,
 989                              gint        *line_top)
 990 {
 991   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
 992
 993   gtk_text_layout_get_line_at_y (text_view->layout,
 994                                  target_iter,
 995                                  y,
 996                                  line_top);
 997 }
 998
 999 static void
1000 set_adjustment_clamped (GtkAdjustment *adj, gfloat val)
1001 {
1002   /* We don't really want to clamp to upper; we want to clamp to
1003      upper - page_size which is the highest value the scrollbar
1004      will let us reach. */
1005   if (val > (adj->upper - adj->page_size))
1006     val = adj->upper - adj->page_size;
1007
1008   if (val < adj->lower)
1009     val = adj->lower;
1010
1011   gtk_adjustment_set_value (adj, val);
1012 }
1013
1014 static gboolean
1015 gtk_text_view_scroll_to_mark_adjusted (GtkTextView *text_view,
1016                                        GtkTextMark *mark,
1017                                        gint margin,
1018                                        gfloat percentage)
1019 {
1020   GtkTextIter iter;
1021   GdkRectangle rect;
1022   GdkRectangle screen;
1023   gint screen_bottom;
1024   gint screen_right;
1025   GtkWidget *widget;
1026   gboolean retval = FALSE;
1027   gint scroll_inc;
1028
1029   gint current_x_scroll, current_y_scroll;
1030
1031   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
1032   g_return_val_if_fail (mark != NULL, FALSE);
1033
1034   widget = GTK_WIDGET (text_view);
1035
1036   if (!GTK_WIDGET_MAPPED (widget))
1037     {
1038       g_warning ("FIXME need to implement scroll_to_mark for unmapped GtkTextView?");
1039       return FALSE;
1040     }
1041
1042   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, mark);
1043
1044   gtk_text_layout_get_iter_location (text_view->layout,
1045                                      &iter,
1046                                      &rect);
1047
1048   /* Be sure the scroll region is up-to-date */
1049   gtk_text_view_scroll_calc_now (text_view);
1050
1051   current_x_scroll = text_view->xoffset;
1052   current_y_scroll = text_view->yoffset;
1053
1054   screen.x = current_x_scroll;
1055   screen.y = current_y_scroll;
1056   screen.width = SCREEN_WIDTH (widget);
1057   screen.height = SCREEN_HEIGHT (widget);
1058
1059   {
1060     /* Clamp margin so it's not too large. */
1061     gint small_dimension = MIN (screen.width, screen.height);
1062     gint max_rect_dim;
1063
1064     if (margin > (small_dimension/2 - 5)) /* 5 is arbitrary */
1065       margin = (small_dimension/2 - 5);
1066
1067     if (margin < 0)
1068       margin = 0;
1069
1070     /* make sure rectangle fits in the leftover space */
1071
1072     max_rect_dim = MAX (rect.width, rect.height);
1073
1074     if (max_rect_dim > (small_dimension - margin*2))
1075       margin -= max_rect_dim - (small_dimension - margin*2);
1076
1077     if (margin < 0)
1078       margin = 0;
1079   }
1080
1081   g_assert (margin >= 0);
1082
1083   screen.x += margin;
1084   screen.y += margin;
1085
1086   screen.width -= margin*2;
1087   screen.height -= margin*2;
1088
1089   screen_bottom = screen.y + screen.height;
1090   screen_right = screen.x + screen.width;
1091
1092   /* Vertical scroll (only vertical gets adjusted) */
1093
1094   scroll_inc = 0;
1095   if (rect.y < screen.y)
1096     {
1097       gint scroll_dest = rect.y;
1098       scroll_inc = (scroll_dest - screen.y) * percentage;
1099     }
1100   else if ((rect.y + rect.height) > screen_bottom)
1101     {
1102       gint scroll_dest = rect.y + rect.height;
1103       scroll_inc = (scroll_dest - screen_bottom) * percentage;
1104     }
1105
1106   if (scroll_inc != 0)
1107     {
1108       set_adjustment_clamped (get_vadjustment (text_view),
1109                               current_y_scroll + scroll_inc);
1110       retval = TRUE;
1111     }
1112
1113   /* Horizontal scroll */
1114
1115   scroll_inc = 0;
1116   if (rect.x < screen.x)
1117     {
1118       gint scroll_dest = rect.x;
1119       scroll_inc = scroll_dest - screen.x;
1120     }
1121   else if ((rect.x + rect.width) > screen_right)
1122     {
1123       gint scroll_dest = rect.x + rect.width;
1124       scroll_inc = scroll_dest - screen_right;
1125     }
1126
1127   if (scroll_inc != 0)
1128     {
1129       set_adjustment_clamped (get_hadjustment (text_view),
1130                               current_x_scroll + scroll_inc);
1131       retval = TRUE;
1132     }
1133
1134   return retval;
1135 }
1136
1137 /**
1138  * gtk_text_view_scroll_to_mark:
1139  * @text_view: a #GtkTextView
1140  * @mark: a #GtkTextMark
1141  * @mark_within_margin: a margin
1142  *
1143  * Scrolls @text_view so that @mark is on the screen. If
1144  * @mark_within_margin is nonzero, the mark will be moved onscreen by
1145  * that many pixels. For example, if @mark_within_margin is 5, the
1146  * mark will be at least 5 pixels away from the edge of the screen,
1147  * if possible.
1148  *
1149  * Return value: TRUE if scrolling occurred
1150  **/
1151 gboolean
1152 gtk_text_view_scroll_to_mark (GtkTextView *text_view,
1153                               GtkTextMark *mark,
1154                               gint mark_within_margin)
1155 {
1156   g_return_val_if_fail (mark_within_margin >= 0, FALSE);
1157
1158   return gtk_text_view_scroll_to_mark_adjusted (text_view, mark,
1159                                                 mark_within_margin, 1.0);
1160 }
1161
1162 static gboolean
1163 clamp_iter_onscreen (GtkTextView *text_view, GtkTextIter *iter)
1164 {
1165   GdkRectangle visible_rect;
1166   gtk_text_view_get_visible_rect (text_view, &visible_rect);
1167
1168   return gtk_text_layout_clamp_iter_to_vrange (text_view->layout, iter,
1169                                                visible_rect.y,
1170                                                visible_rect.y + visible_rect.height);
1171 }
1172
1173 /**
1174  * gtk_text_view_move_mark_onscreen:
1175  * @text_view: a #GtkTextView
1176  * @mark: a #GtkTextMark
1177  *
1178  * Moves a mark within the buffer so that it's
1179  * located within the currently-visible text area.
1180  *
1181  * Return value: %TRUE if scrolling occurred
1182  **/
1183 gboolean
1184 gtk_text_view_move_mark_onscreen (GtkTextView *text_view,
1185                                   GtkTextMark *mark)
1186 {
1187   GtkTextIter iter;
1188
1189   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
1190   g_return_val_if_fail (mark != NULL, FALSE);
1191
1192   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, mark);
1193
1194   if (clamp_iter_onscreen (text_view, &iter))
1195     {
1196       gtk_text_buffer_move_mark (get_buffer (text_view), mark, &iter);
1197       return TRUE;
1198     }
1199   else
1200     return FALSE;
1201 }
1202
1203 /**
1204  * gtk_text_view_get_visible_rect:
1205  * @text_view: a #GtkTextView
1206  * @visible_rect: rectangle to fill
1207  *
1208  * Fills @visible_rect with the currently-visible
1209  * region of the buffer, in buffer coordinates. Convert to window coordinates
1210  * with gtk_text_view_buffer_to_window_coords().
1211  **/
1212 void
1213 gtk_text_view_get_visible_rect (GtkTextView  *text_view,
1214                                 GdkRectangle *visible_rect)
1215 {
1216   GtkWidget *widget;
1217
1218   g_return_if_fail (text_view != NULL);
1219   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1220
1221   widget = GTK_WIDGET (text_view);
1222
1223   if (visible_rect)
1224     {
1225       visible_rect->x = text_view->xoffset;
1226       visible_rect->y = text_view->yoffset;
1227       visible_rect->width = SCREEN_WIDTH (widget);
1228       visible_rect->height = SCREEN_HEIGHT (widget);
1229     }
1230 }
1231
1232 /**
1233  * gtk_text_view_set_wrap_mode:
1234  * @text_view: a #GtkTextView
1235  * @wrap_mode: a #GtkWrapMode
1236  *
1237  * Sets the line wrapping for the view.
1238  **/
1239 void
1240 gtk_text_view_set_wrap_mode (GtkTextView *text_view,
1241                              GtkWrapMode  wrap_mode)
1242 {
1243   g_return_if_fail (text_view != NULL);
1244   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1245
1246   if (text_view->wrap_mode != wrap_mode)
1247     {
1248       text_view->wrap_mode = wrap_mode;
1249
1250       if (text_view->layout)
1251         {
1252           text_view->layout->default_style->wrap_mode = wrap_mode;
1253           gtk_text_layout_default_style_changed (text_view->layout);
1254         }
1255     }
1256 }
1257
1258 /**
1259  * gtk_text_view_get_wrap_mode:
1260  * @text_view: a #GtkTextView
1261  *
1262  * Gets the line wrapping for the view.
1263  *
1264  * Return value: the line wrap setting
1265  **/
1266 GtkWrapMode
1267 gtk_text_view_get_wrap_mode (GtkTextView *text_view)
1268 {
1269   g_return_val_if_fail (text_view != NULL, GTK_WRAPMODE_NONE);
1270   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), GTK_WRAPMODE_NONE);
1271
1272   return text_view->wrap_mode;
1273 }
1274
1275 /**
1276  * gtk_text_view_set_editable:
1277  * @text_view: a #GtkTextView
1278  * @setting: whether it's editable
1279  *
1280  * Sets the default editability of the #GtkTextView. You can override
1281  * this default setting with tags in the buffer, using the "editable"
1282  * attribute of tags.
1283  **/
1284 void
1285 gtk_text_view_set_editable (GtkTextView *text_view,
1286                             gboolean     setting)
1287 {
1288   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1289
1290   if (text_view->editable != setting)
1291     {
1292       text_view->editable = setting;
1293
1294       if (text_view->layout)
1295         {
1296           text_view->layout->default_style->editable = text_view->editable;
1297           gtk_text_layout_default_style_changed (text_view->layout);
1298         }
1299     }
1300 }
1301
1302 /**
1303  * gtk_text_view_get_editable:
1304  * @text_view: a #GtkTextView
1305  *
1306  * Returns the default editability of the #GtkTextView. Tags in the
1307  * buffer may override this setting for some ranges of text.
1308  *
1309  * Return value: whether text is editable by default
1310  **/
1311 gboolean
1312 gtk_text_view_get_editable (GtkTextView *text_view)
1313 {
1314   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
1315
1316   return text_view->editable;
1317 }
1318
1319 void
1320 gtk_text_view_set_pixels_above_lines (GtkTextView *text_view,
1321                                       gint         pixels_above_lines)
1322 {
1323   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1324
1325   if (text_view->pixels_above_lines != pixels_above_lines)
1326     {
1327       text_view->pixels_above_lines = pixels_above_lines;
1328
1329       if (text_view->layout)
1330         {
1331           text_view->layout->default_style->pixels_above_lines = pixels_above_lines;
1332           gtk_text_layout_default_style_changed (text_view->layout);
1333         }
1334     }
1335 }
1336
1337 gint
1338 gtk_text_view_get_pixels_above_lines (GtkTextView *text_view)
1339 {
1340   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
1341
1342   return text_view->pixels_above_lines;
1343 }
1344
1345 void
1346 gtk_text_view_set_pixels_below_lines (GtkTextView *text_view,
1347                                       gint         pixels_below_lines)
1348 {
1349   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1350
1351   if (text_view->pixels_below_lines != pixels_below_lines)
1352     {
1353       text_view->pixels_below_lines = pixels_below_lines;
1354
1355       if (text_view->layout)
1356         {
1357           text_view->layout->default_style->pixels_below_lines = pixels_below_lines;
1358           gtk_text_layout_default_style_changed (text_view->layout);
1359         }
1360     }
1361 }
1362
1363 gint
1364 gtk_text_view_get_pixels_below_lines (GtkTextView *text_view)
1365 {
1366   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
1367
1368   return text_view->pixels_below_lines;
1369 }
1370
1371 void
1372 gtk_text_view_set_pixels_inside_wrap (GtkTextView *text_view,
1373                                       gint         pixels_inside_wrap)
1374 {
1375   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1376
1377   if (text_view->pixels_inside_wrap != pixels_inside_wrap)
1378     {
1379       text_view->pixels_inside_wrap = pixels_inside_wrap;
1380
1381       if (text_view->layout)
1382         {
1383           text_view->layout->default_style->pixels_inside_wrap = pixels_inside_wrap;
1384           gtk_text_layout_default_style_changed (text_view->layout);
1385         }
1386     }
1387 }
1388
1389 gint
1390 gtk_text_view_get_pixels_inside_wrap (GtkTextView *text_view)
1391 {
1392   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
1393
1394   return text_view->pixels_inside_wrap;
1395 }
1396
1397 void
1398 gtk_text_view_set_justification (GtkTextView     *text_view,
1399                                  GtkJustification justify)
1400 {
1401   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1402
1403   if (text_view->justify != justify)
1404     {
1405       text_view->justify = justify;
1406
1407       if (text_view->layout)
1408         {
1409           text_view->layout->default_style->justify = justify;
1410           gtk_text_layout_default_style_changed (text_view->layout);
1411         }
1412     }
1413 }
1414
1415 GtkJustification
1416 gtk_text_view_get_justification (GtkTextView *text_view)
1417 {
1418   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), GTK_JUSTIFY_LEFT);
1419
1420   return text_view->justify;
1421 }
1422
1423 void
1424 gtk_text_view_set_left_margin (GtkTextView *text_view,
1425                                gint         left_margin)
1426 {
1427   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1428
1429   if (text_view->left_margin != left_margin)
1430     {
1431       text_view->left_margin = left_margin;
1432
1433       if (text_view->layout)
1434         {
1435           text_view->layout->default_style->left_margin = left_margin;
1436           gtk_text_layout_default_style_changed (text_view->layout);
1437         }
1438     }
1439 }
1440
1441 gint
1442 gtk_text_view_get_left_margin (GtkTextView *text_view)
1443 {
1444   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
1445
1446   return text_view->left_margin;
1447 }
1448
1449 void
1450 gtk_text_view_set_right_margin (GtkTextView *text_view,
1451                                 gint         right_margin)
1452 {
1453   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1454
1455   if (text_view->right_margin != right_margin)
1456     {
1457       text_view->right_margin = right_margin;
1458
1459       if (text_view->layout)
1460         {
1461           text_view->layout->default_style->right_margin = right_margin;
1462           gtk_text_layout_default_style_changed (text_view->layout);
1463         }
1464     }
1465 }
1466
1467 gint
1468 gtk_text_view_get_right_margin (GtkTextView *text_view)
1469 {
1470   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
1471
1472   return text_view->right_margin;
1473 }
1474
1475 void
1476 gtk_text_view_set_indent (GtkTextView *text_view,
1477                           gint         indent)
1478 {
1479   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1480
1481   if (text_view->indent != indent)
1482     {
1483       text_view->indent = indent;
1484
1485       if (text_view->layout)
1486         {
1487           text_view->layout->default_style->indent = indent;
1488           gtk_text_layout_default_style_changed (text_view->layout);
1489         }
1490     }
1491 }
1492
1493 gint
1494 gtk_text_view_get_indent (GtkTextView *text_view)
1495 {
1496   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
1497
1498   return text_view->indent;
1499 }
1500
1501 void
1502 gtk_text_view_set_tabs (GtkTextView   *text_view,
1503                         PangoTabArray *tabs)
1504 {
1505   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1506
1507   if (text_view->tabs)
1508     pango_tab_array_free (text_view->tabs);
1509
1510   text_view->tabs = tabs ? pango_tab_array_copy (tabs) : NULL;
1511
1512   if (text_view->layout)
1513     {
1514       /* some unkosher futzing in internal struct details... */
1515       if (text_view->layout->default_style->tabs)
1516         pango_tab_array_free (text_view->layout->default_style->tabs);
1517
1518       text_view->layout->default_style->tabs =
1519         text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
1520
1521       gtk_text_layout_default_style_changed (text_view->layout);
1522     }
1523 }
1524
1525 PangoTabArray*
1526 gtk_text_view_get_tabs (GtkTextView *text_view)
1527 {
1528   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
1529
1530   return text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
1531 }
1532
1533 /**
1534  * gtk_text_view_set_cursor_visible:
1535  * @text_view: a #GtkTextView
1536  * @setting: whether to show the insertion cursor
1537  *
1538  * Toggles whether the insertion point is displayed. A buffer with no editable
1539  * text probably shouldn't have a visible cursor, so you may want to turn
1540  * the cursor off.
1541  **/
1542 void
1543 gtk_text_view_set_cursor_visible    (GtkTextView   *text_view,
1544                                      gboolean       setting)
1545 {
1546   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
1547
1548   setting = (setting != FALSE);
1549
1550   if (text_view->cursor_visible != setting)
1551     {
1552       text_view->cursor_visible = setting;
1553
1554       if (GTK_WIDGET_HAS_FOCUS (text_view))
1555         {
1556           if (text_view->layout)
1557             {
1558               gtk_text_layout_set_cursor_visible (text_view->layout, setting);
1559
1560               if (setting)
1561                 gtk_text_view_start_cursor_blink (text_view, FALSE);
1562               else
1563                 gtk_text_view_stop_cursor_blink (text_view);
1564             }
1565         }
1566     }
1567 }
1568
1569 /**
1570  * gtk_text_view_get_cursor_visible:
1571  * @text_view: a #GtkTextView
1572  *
1573  * Find out whether the cursor is being displayed.
1574  *
1575  * Return value: whether the insertion mark is visible
1576  **/
1577 gboolean
1578 gtk_text_view_get_cursor_visible    (GtkTextView   *text_view)
1579 {
1580   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
1581
1582   return text_view->cursor_visible;
1583 }
1584
1585
1586 /**
1587  * gtk_text_view_place_cursor_onscreen:
1588  * @text_view: a #GtkTextView
1589  *
1590  * Moves the cursor to the currently visible region of the
1591  * buffer, it it isn't there already.
1592  *
1593  * Return value: TRUE if the cursor had to be moved.
1594  **/
1595 gboolean
1596 gtk_text_view_place_cursor_onscreen (GtkTextView *text_view)
1597 {
1598   GtkTextIter insert;
1599
1600   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
1601
1602   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
1603                                     gtk_text_buffer_get_mark (get_buffer (text_view),
1604                                                               "insert"));
1605
1606   if (clamp_iter_onscreen (text_view, &insert))
1607     {
1608       gtk_text_buffer_place_cursor (get_buffer (text_view), &insert);
1609       return TRUE;
1610     }
1611   else
1612     return FALSE;
1613 }
1614
1615 static void
1616 gtk_text_view_destroy (GtkObject *object)
1617 {
1618   GtkTextView *text_view;
1619   GtkTextLayout *layout;
1620
1621   text_view = GTK_TEXT_VIEW (object);
1622
1623   layout = text_view->layout;
1624
1625   gtk_text_view_destroy_layout (text_view);
1626   gtk_text_view_set_buffer (text_view, NULL);
1627
1628   (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
1629 }
1630
1631 static void
1632 gtk_text_view_finalize (GObject *object)
1633 {
1634   GtkTextView *text_view;
1635
1636   text_view = GTK_TEXT_VIEW (object);
1637
1638   g_return_if_fail (text_view->buffer == NULL);
1639
1640   if (text_view->hadjustment)
1641     gtk_object_unref (GTK_OBJECT (text_view->hadjustment));
1642   if (text_view->vadjustment)
1643     gtk_object_unref (GTK_OBJECT (text_view->vadjustment));
1644
1645   text_window_free (text_view->text_window);
1646
1647   if (text_view->left_window)
1648     text_window_free (text_view->left_window);
1649
1650   if (text_view->top_window)
1651     text_window_free (text_view->top_window);
1652
1653   if (text_view->right_window)
1654     text_window_free (text_view->right_window);
1655
1656   if (text_view->bottom_window)
1657     text_window_free (text_view->bottom_window);
1658
1659   gtk_object_unref (GTK_OBJECT (text_view->im_context));
1660
1661   (* G_OBJECT_CLASS (parent_class)->finalize) (object);
1662 }
1663
1664 static void
1665 gtk_text_view_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
1666 {
1667   GtkTextView *text_view;
1668
1669   text_view = GTK_TEXT_VIEW (object);
1670
1671   switch (arg_id)
1672     {
1673     case ARG_HEIGHT_LINES:
1674       g_warning ("FIXME");
1675       break;
1676
1677     case ARG_WIDTH_COLUMNS:
1678       g_warning ("FIXME");
1679       break;
1680
1681     case ARG_PIXELS_ABOVE_LINES:
1682       gtk_text_view_set_pixels_above_lines (text_view, GTK_VALUE_INT (*arg));
1683       break;
1684
1685     case ARG_PIXELS_BELOW_LINES:
1686       gtk_text_view_set_pixels_below_lines (text_view, GTK_VALUE_INT (*arg));
1687       break;
1688
1689     case ARG_PIXELS_INSIDE_WRAP:
1690       gtk_text_view_set_pixels_inside_wrap (text_view, GTK_VALUE_INT (*arg));
1691       break;
1692
1693     case ARG_EDITABLE:
1694       gtk_text_view_set_editable (text_view, GTK_VALUE_BOOL (*arg));
1695       break;
1696
1697     case ARG_WRAP_MODE:
1698       gtk_text_view_set_wrap_mode (text_view, GTK_VALUE_ENUM (*arg));
1699       break;
1700
1701     case ARG_JUSTIFY:
1702       gtk_text_view_set_justification (text_view, GTK_VALUE_ENUM (*arg));
1703       break;
1704
1705     case ARG_LEFT_MARGIN:
1706       gtk_text_view_set_left_margin (text_view, GTK_VALUE_INT (*arg));
1707       break;
1708
1709     case ARG_RIGHT_MARGIN:
1710       gtk_text_view_set_right_margin (text_view, GTK_VALUE_INT (*arg));
1711       break;
1712
1713     case ARG_INDENT:
1714       gtk_text_view_set_indent (text_view, GTK_VALUE_INT (*arg));
1715       break;
1716
1717     case ARG_TABS:
1718       gtk_text_view_set_tabs (text_view, GTK_VALUE_POINTER (*arg));
1719       break;
1720
1721     default:
1722       g_assert_not_reached ();
1723       break;
1724     }
1725 }
1726
1727 static void
1728 gtk_text_view_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
1729 {
1730   GtkTextView *text_view;
1731
1732   text_view = GTK_TEXT_VIEW (object);
1733
1734   switch (arg_id)
1735     {
1736     case ARG_HEIGHT_LINES:
1737       g_warning ("FIXME");
1738       break;
1739
1740     case ARG_WIDTH_COLUMNS:
1741       g_warning ("FIXME");
1742       break;
1743
1744     case ARG_PIXELS_ABOVE_LINES:
1745       GTK_VALUE_INT (*arg) = text_view->pixels_above_lines;
1746       break;
1747
1748     case ARG_PIXELS_BELOW_LINES:
1749       GTK_VALUE_INT (*arg) = text_view->pixels_below_lines;
1750       break;
1751
1752     case ARG_PIXELS_INSIDE_WRAP:
1753       GTK_VALUE_INT (*arg) = text_view->pixels_inside_wrap;
1754       break;
1755
1756     case ARG_EDITABLE:
1757       GTK_VALUE_BOOL (*arg) = text_view->editable;
1758       break;
1759
1760     case ARG_WRAP_MODE:
1761       GTK_VALUE_ENUM (*arg) = text_view->wrap_mode;
1762       break;
1763
1764     case ARG_JUSTIFY:
1765       GTK_VALUE_ENUM (*arg) = text_view->justify;
1766       break;
1767
1768     case ARG_LEFT_MARGIN:
1769       GTK_VALUE_INT (*arg) = text_view->left_margin;
1770       break;
1771
1772     case ARG_RIGHT_MARGIN:
1773       GTK_VALUE_INT (*arg) = text_view->right_margin;
1774       break;
1775
1776     case ARG_INDENT:
1777       GTK_VALUE_INT (*arg) = text_view->indent;
1778       break;
1779
1780     case ARG_TABS:
1781       GTK_VALUE_POINTER (*arg) = gtk_text_view_get_tabs (text_view);
1782       break;
1783
1784     default:
1785       arg->type = GTK_TYPE_INVALID;
1786       break;
1787     }
1788 }
1789
1790 static void
1791 gtk_text_view_size_request (GtkWidget      *widget,
1792                             GtkRequisition *requisition)
1793 {
1794   GtkTextView *text_view;
1795   GSList *tmp_list;
1796
1797   text_view = GTK_TEXT_VIEW (widget);
1798
1799   requisition->width = text_view->text_window->requisition.width + FOCUS_EDGE_WIDTH * 2;
1800   requisition->height = text_view->text_window->requisition.height + FOCUS_EDGE_WIDTH * 2;
1801
1802   if (text_view->left_window)
1803     requisition->width += text_view->left_window->requisition.width;
1804
1805   if (text_view->right_window)
1806     requisition->width += text_view->right_window->requisition.width;
1807
1808   if (text_view->top_window)
1809     requisition->height += text_view->top_window->requisition.height;
1810
1811   if (text_view->bottom_window)
1812     requisition->height += text_view->bottom_window->requisition.height;
1813
1814   tmp_list = text_view->children;
1815   while (tmp_list != NULL)
1816     {
1817       GtkTextViewChild *child = tmp_list->data;
1818
1819       if (child->anchor)
1820         {
1821           GtkRequisition child_req;
1822           GtkRequisition old_req;
1823
1824           old_req = child->widget->requisition;
1825
1826           gtk_widget_size_request (child->widget, &child_req);
1827
1828           if (text_view->layout &&
1829               (old_req.width != child_req.width ||
1830                old_req.height != child_req.height))
1831             gtk_text_child_anchor_queue_resize (child->anchor,
1832                                                 text_view->layout);
1833         }
1834       else
1835         {
1836
1837         }
1838
1839       tmp_list = g_slist_next (tmp_list);
1840     }
1841 }
1842
1843 static void
1844 gtk_text_view_update_child_allocation (GtkTextView      *text_view,
1845                                        GtkTextViewChild *vc)
1846 {
1847   gint buffer_y;
1848   GtkTextIter iter;
1849   GtkAllocation allocation;
1850
1851   gtk_text_buffer_get_iter_at_child_anchor (get_buffer (text_view),
1852                                             &iter,
1853                                             vc->anchor);
1854
1855   gtk_text_layout_get_line_yrange (text_view->layout, &iter,
1856                                    &buffer_y, NULL);
1857
1858   buffer_y += vc->from_top_of_line;
1859
1860   allocation.x = vc->from_left_of_buffer;
1861   allocation.y = buffer_y;
1862   allocation.width = vc->widget->requisition.width;
1863   allocation.height = vc->widget->requisition.height;
1864
1865   gtk_widget_size_allocate (vc->widget, &allocation);
1866 }
1867
1868 static void
1869 gtk_text_view_child_allocated (GtkTextLayout *layout,
1870                                GtkWidget     *child,
1871                                gint           x,
1872                                gint           y,
1873                                gpointer       data)
1874 {
1875   GtkTextViewChild *vc = NULL;
1876   GtkTextView *text_view = data;
1877
1878   /* x,y is the position of the child from the top of the line, and
1879    * from the left of the buffer. We have to translate that into text
1880    * window coordinates, then size_allocate the child.
1881    */
1882
1883   vc = gtk_object_get_data (GTK_OBJECT (child),
1884                             "gtk-text-view-child");
1885
1886   g_assert (vc != NULL);
1887
1888   g_print ("child allocated at %d,%d\n", x, y);
1889
1890   vc->from_left_of_buffer = x;
1891   vc->from_top_of_line = y;
1892
1893   gtk_text_view_update_child_allocation (text_view, vc);
1894 }
1895
1896 static void
1897 gtk_text_view_validate_children (GtkTextView *text_view)
1898 {
1899   GSList *tmp_list;
1900
1901   tmp_list = text_view->children;
1902   while (tmp_list != NULL)
1903     {
1904       GtkTextViewChild *child = tmp_list->data;
1905
1906       if (child->anchor)
1907         {
1908           /* We need to force-validate the regions containing
1909            * children.
1910            */
1911           GtkTextIter child_loc;
1912           gtk_text_buffer_get_iter_at_child_anchor (get_buffer (text_view),
1913                                                     &child_loc,
1914                                                     child->anchor);
1915
1916           gtk_text_layout_validate_yrange (text_view->layout,
1917                                            &child_loc,
1918                                            0, 1);
1919         }
1920       else
1921         {
1922
1923         }
1924
1925       tmp_list = g_slist_next (tmp_list);
1926     }
1927 }
1928
1929 static void
1930 gtk_text_view_size_allocate (GtkWidget *widget,
1931                              GtkAllocation *allocation)
1932 {
1933   GtkTextView *text_view;
1934   GtkTextIter first_para;
1935   gint y;
1936   GtkAdjustment *vadj;
1937   gboolean yoffset_changed = FALSE;
1938   gint width, height;
1939   GdkRectangle text_rect;
1940   GdkRectangle left_rect;
1941   GdkRectangle right_rect;
1942   GdkRectangle top_rect;
1943   GdkRectangle bottom_rect;
1944
1945   text_view = GTK_TEXT_VIEW (widget);
1946
1947   widget->allocation = *allocation;
1948
1949   if (GTK_WIDGET_REALIZED (widget))
1950     {
1951       gdk_window_move_resize (widget->window,
1952                               allocation->x, allocation->y,
1953                               allocation->width, allocation->height);
1954     }
1955
1956   /* distribute width/height among child windows. Ensure all
1957    * windows get at least a 1x1 allocation.
1958    */
1959
1960   width = allocation->width - FOCUS_EDGE_WIDTH * 2;
1961
1962   if (text_view->left_window)
1963     left_rect.width = text_view->left_window->requisition.width;
1964   else
1965     left_rect.width = 1;
1966
1967   width -= left_rect.width;
1968
1969   if (text_view->right_window)
1970     right_rect.width = text_view->right_window->requisition.width;
1971   else
1972     right_rect.width = 1;
1973
1974   width -= right_rect.width;
1975
1976   text_rect.width = MAX (1, width);
1977
1978   top_rect.width = text_rect.width;
1979   bottom_rect.width = text_rect.width;
1980
1981
1982   height = allocation->height - FOCUS_EDGE_WIDTH * 2;
1983
1984   if (text_view->top_window)
1985     top_rect.height = text_view->top_window->requisition.height;
1986   else
1987     top_rect.height = 1;
1988
1989   height -= top_rect.height;
1990
1991   if (text_view->bottom_window)
1992     bottom_rect.height = text_view->bottom_window->requisition.height;
1993   else
1994     bottom_rect.height = 1;
1995
1996   height -= bottom_rect.height;
1997
1998   text_rect.height = MAX (1, height);
1999
2000   left_rect.height = text_rect.height;
2001   right_rect.height = text_rect.height;
2002
2003   /* Origins */
2004   left_rect.x = FOCUS_EDGE_WIDTH;
2005   top_rect.y = FOCUS_EDGE_WIDTH;
2006
2007   text_rect.x = left_rect.x + left_rect.width;
2008   text_rect.y = top_rect.y + top_rect.height;
2009
2010   left_rect.y = text_rect.y;
2011   right_rect.y = text_rect.y;
2012
2013   top_rect.x = text_rect.x;
2014   bottom_rect.x = text_rect.x;
2015
2016   right_rect.x = text_rect.x + text_rect.width;
2017   bottom_rect.y = text_rect.y + text_rect.height;
2018
2019   text_window_size_allocate (text_view->text_window,
2020                              &text_rect);
2021
2022   if (text_view->left_window)
2023     text_window_size_allocate (text_view->left_window,
2024                                &left_rect);
2025
2026   if (text_view->right_window)
2027     text_window_size_allocate (text_view->right_window,
2028                                &right_rect);
2029
2030   if (text_view->top_window)
2031     text_window_size_allocate (text_view->top_window,
2032                                &top_rect);
2033
2034   if (text_view->bottom_window)
2035     text_window_size_allocate (text_view->bottom_window,
2036                                &bottom_rect);
2037
2038   gtk_text_view_ensure_layout (text_view);
2039   gtk_text_layout_set_screen_width (text_view->layout,
2040                                     SCREEN_WIDTH (text_view));
2041
2042   gtk_text_view_validate_children (text_view);
2043
2044   gtk_text_view_validate_onscreen (text_view);
2045   gtk_text_view_scroll_calc_now (text_view);
2046
2047   /* Now adjust the value of the adjustment to keep the cursor at the
2048    * same place in the buffer
2049    */
2050   gtk_text_view_get_first_para_iter (text_view, &first_para);
2051   gtk_text_layout_get_line_yrange (text_view->layout, &first_para, &y, NULL);
2052
2053   y += text_view->first_para_pixels;
2054
2055   /* Ensure h/v adj exist */
2056   get_hadjustment (text_view);
2057   get_vadjustment (text_view);
2058
2059   vadj = text_view->vadjustment;
2060   if (y > vadj->upper - vadj->page_size)
2061     y = MAX (0, vadj->upper - vadj->page_size);
2062
2063   if (y != text_view->yoffset)
2064     {
2065       vadj->value = text_view->yoffset = y;
2066       yoffset_changed = TRUE;
2067     }
2068
2069   text_view->hadjustment->page_size = SCREEN_WIDTH (text_view);
2070   text_view->hadjustment->page_increment = SCREEN_WIDTH (text_view) / 2;
2071   text_view->hadjustment->lower = 0;
2072   text_view->hadjustment->upper = MAX (SCREEN_WIDTH (text_view),
2073                                        text_view->width);
2074   gtk_signal_emit_by_name (GTK_OBJECT (text_view->hadjustment), "changed");
2075
2076   text_view->vadjustment->page_size = SCREEN_HEIGHT (text_view);
2077   text_view->vadjustment->page_increment = SCREEN_HEIGHT (text_view) / 2;
2078   text_view->vadjustment->lower = 0;
2079   text_view->vadjustment->upper = MAX (SCREEN_HEIGHT (text_view),
2080                                        text_view->height);
2081   gtk_signal_emit_by_name (GTK_OBJECT (text_view->vadjustment), "changed");
2082
2083   if (yoffset_changed)
2084     gtk_adjustment_value_changed (vadj);
2085 }
2086
2087 static void
2088 gtk_text_view_get_first_para_iter (GtkTextView *text_view,
2089                                    GtkTextIter *iter)
2090 {
2091   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), iter,
2092                                     text_view->first_para_mark);
2093 }
2094
2095 static void
2096 gtk_text_view_validate_onscreen (GtkTextView *text_view)
2097 {
2098   GtkWidget *widget = GTK_WIDGET (text_view);
2099
2100   if (SCREEN_HEIGHT (widget) > 0)
2101     {
2102       GtkTextIter first_para;
2103       gtk_text_view_get_first_para_iter (text_view, &first_para);
2104
2105       gtk_text_layout_validate_yrange (text_view->layout,
2106                                        &first_para,
2107                                        0,
2108                                        text_view->first_para_pixels +
2109                                        SCREEN_HEIGHT (widget));
2110     }
2111 }
2112
2113 static gboolean
2114 first_validate_callback (gpointer data)
2115 {
2116   GtkTextView *text_view = data;
2117
2118   gtk_text_view_validate_onscreen (text_view);
2119
2120   text_view->first_validate_idle = 0;
2121   return FALSE;
2122 }
2123
2124 static gboolean
2125 incremental_validate_callback (gpointer data)
2126 {
2127   GtkTextView *text_view = data;
2128
2129   gtk_text_layout_validate (text_view->layout, 2000);
2130   if (gtk_text_layout_is_valid (text_view->layout))
2131     {
2132       text_view->incremental_validate_idle = 0;
2133       return FALSE;
2134     }
2135   else
2136     return TRUE;
2137 }
2138
2139 static void
2140 invalidated_handler (GtkTextLayout *layout,
2141                      gpointer       data)
2142 {
2143   GtkTextView *text_view;
2144
2145   text_view = GTK_TEXT_VIEW (data);
2146
2147   if (!text_view->first_validate_idle)
2148     text_view->first_validate_idle = g_idle_add_full (GTK_PRIORITY_RESIZE - 1, first_validate_callback, text_view, NULL);
2149
2150   if (!text_view->incremental_validate_idle)
2151     text_view->incremental_validate_idle = g_idle_add_full (GDK_PRIORITY_REDRAW + 1, incremental_validate_callback, text_view, NULL);
2152 }
2153
2154 static void
2155 changed_handler (GtkTextLayout *layout,
2156                  gint           start_y,
2157                  gint           old_height,
2158                  gint           new_height,
2159                  gpointer       data)
2160 {
2161   GtkTextView *text_view;
2162   GtkWidget *widget;
2163   GdkRectangle visible_rect;
2164   GdkRectangle redraw_rect;
2165
2166   text_view = GTK_TEXT_VIEW (data);
2167   widget = GTK_WIDGET (data);
2168
2169   if (GTK_WIDGET_REALIZED (text_view))
2170     {
2171       gtk_text_view_get_visible_rect (text_view, &visible_rect);
2172
2173       redraw_rect.x = visible_rect.x;
2174       redraw_rect.width = visible_rect.width;
2175       redraw_rect.y = start_y;
2176
2177       if (old_height == new_height)
2178         redraw_rect.height = old_height;
2179       else
2180         redraw_rect.height = MAX (0, visible_rect.y + visible_rect.height - start_y);
2181
2182       if (gdk_rectangle_intersect (&redraw_rect, &visible_rect, &redraw_rect))
2183         {
2184           /* text_window_invalidate_rect() takes buffer coordinates */
2185           text_window_invalidate_rect (text_view->text_window,
2186                                        &redraw_rect);
2187
2188           if (text_view->left_window)
2189             text_window_invalidate_rect (text_view->left_window,
2190                                          &redraw_rect);
2191           if (text_view->right_window)
2192             text_window_invalidate_rect (text_view->right_window,
2193                                          &redraw_rect);
2194           if (text_view->top_window)
2195             text_window_invalidate_rect (text_view->top_window,
2196                                          &redraw_rect);
2197           if (text_view->bottom_window)
2198             text_window_invalidate_rect (text_view->bottom_window,
2199                                          &redraw_rect);
2200         }
2201     }
2202
2203   if (old_height != new_height)
2204     {
2205       gboolean yoffset_changed = FALSE;
2206       GSList *tmp_list;
2207
2208       if (start_y + old_height <= text_view->yoffset - text_view->first_para_pixels)
2209         {
2210           text_view->yoffset += new_height - old_height;
2211           get_vadjustment (text_view)->value = text_view->yoffset;
2212           yoffset_changed = TRUE;
2213         }
2214
2215       if (yoffset_changed)
2216         gtk_adjustment_value_changed (get_vadjustment (text_view));
2217
2218       /* FIXME be smarter about which anchored widgets we update */
2219
2220       tmp_list = text_view->children;
2221       while (tmp_list != NULL)
2222         {
2223           GtkTextViewChild *child = tmp_list->data;
2224
2225           if (child->anchor)
2226             gtk_text_view_update_child_allocation (text_view, child);
2227
2228           tmp_list = g_slist_next (tmp_list);
2229         }
2230     }
2231
2232   gtk_text_view_scroll_calc_now (text_view);
2233 }
2234
2235 static void
2236 gtk_text_view_realize (GtkWidget *widget)
2237 {
2238   GtkTextView *text_view;
2239   GdkWindowAttr attributes;
2240   gint attributes_mask;
2241   GSList *tmp_list;
2242
2243   text_view = GTK_TEXT_VIEW (widget);
2244   GTK_WIDGET_SET_FLAGS (text_view, GTK_REALIZED);
2245
2246   attributes.window_type = GDK_WINDOW_CHILD;
2247   attributes.x = widget->allocation.x;
2248   attributes.y = widget->allocation.y;
2249   attributes.width = widget->allocation.width;
2250   attributes.height = widget->allocation.height;
2251   attributes.wclass = GDK_INPUT_OUTPUT;
2252   attributes.visual = gtk_widget_get_visual (widget);
2253   attributes.colormap = gtk_widget_get_colormap (widget);
2254   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK;
2255
2256   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
2257
2258   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
2259                                    &attributes, attributes_mask);
2260   gdk_window_set_user_data (widget->window, widget);
2261
2262   /* must come before text_window_realize calls */
2263   widget->style = gtk_style_attach (widget->style, widget->window);
2264
2265   gdk_window_set_background (widget->window,
2266                              &widget->style->bg[GTK_WIDGET_STATE (widget)]);
2267
2268   text_window_realize (text_view->text_window, widget->window);
2269
2270   if (text_view->left_window)
2271     text_window_realize (text_view->left_window,
2272                          widget->window);
2273
2274   if (text_view->top_window)
2275     text_window_realize (text_view->top_window,
2276                          widget->window);
2277
2278   if (text_view->right_window)
2279     text_window_realize (text_view->right_window,
2280                          widget->window);
2281
2282   if (text_view->bottom_window)
2283     text_window_realize (text_view->bottom_window,
2284                          widget->window);
2285
2286   gtk_text_view_ensure_layout (text_view);
2287 }
2288
2289 static void
2290 gtk_text_view_unrealize (GtkWidget *widget)
2291 {
2292   GtkTextView *text_view;
2293   GSList *tmp_list;
2294
2295   text_view = GTK_TEXT_VIEW (widget);
2296
2297   if (text_view->first_validate_idle)
2298     {
2299       g_source_remove (text_view->first_validate_idle);
2300       text_view->first_validate_idle = 0;
2301     }
2302
2303   if (text_view->incremental_validate_idle)
2304     {
2305       g_source_remove (text_view->incremental_validate_idle);
2306       text_view->incremental_validate_idle = 0;
2307     }
2308
2309   if (text_view->popup_menu)
2310     {
2311       gtk_widget_destroy (text_view->popup_menu);
2312       text_view->popup_menu = NULL;
2313     }
2314
2315   text_window_unrealize (text_view->text_window);
2316
2317   if (text_view->left_window)
2318     text_window_unrealize (text_view->left_window);
2319
2320   if (text_view->top_window)
2321     text_window_unrealize (text_view->top_window);
2322
2323   if (text_view->right_window)
2324     text_window_unrealize (text_view->right_window);
2325
2326   if (text_view->bottom_window)
2327     text_window_unrealize (text_view->bottom_window);
2328
2329   gtk_text_view_destroy_layout (text_view);
2330
2331   (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
2332 }
2333
2334 static void
2335 gtk_text_view_style_set (GtkWidget *widget,
2336                          GtkStyle  *previous_style)
2337 {
2338   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
2339
2340   if (GTK_WIDGET_REALIZED (widget))
2341     {
2342       gdk_window_set_background (widget->window,
2343                                  &widget->style->bg[GTK_WIDGET_STATE (widget)]);
2344
2345       gdk_window_set_background (text_view->text_window->bin_window,
2346                                  &widget->style->base[GTK_WIDGET_STATE (widget)]);
2347
2348       if (text_view->left_window)
2349         gdk_window_set_background (text_view->left_window->bin_window,
2350                                    &widget->style->bg[GTK_WIDGET_STATE (widget)]);
2351       if (text_view->right_window)
2352         gdk_window_set_background (text_view->right_window->bin_window,
2353                                    &widget->style->bg[GTK_WIDGET_STATE (widget)]);
2354
2355       if (text_view->top_window)
2356         gdk_window_set_background (text_view->top_window->bin_window,
2357                                    &widget->style->bg[GTK_WIDGET_STATE (widget)]);
2358
2359       if (text_view->bottom_window)
2360         gdk_window_set_background (text_view->bottom_window->bin_window,
2361                                    &widget->style->bg[GTK_WIDGET_STATE (widget)]);
2362
2363       gtk_text_view_set_attributes_from_style (text_view,
2364                                                text_view->layout->default_style,
2365                                                widget->style);
2366       gtk_text_layout_default_style_changed (text_view->layout);
2367     }
2368 }
2369
2370 static void
2371 gtk_text_view_direction_changed (GtkWidget        *widget,
2372                                  GtkTextDirection  previous_direction)
2373 {
2374   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
2375
2376   if (text_view->layout)
2377     {
2378       text_view->layout->default_style->direction = gtk_widget_get_direction (widget);
2379       gtk_text_layout_default_style_changed (text_view->layout);
2380     }
2381 }
2382
2383 /*
2384  * Events
2385  */
2386
2387 static gboolean
2388 get_event_coordinates (GdkEvent *event, gint *x, gint *y)
2389 {
2390   if (event)
2391     switch (event->type)
2392       {
2393       case GDK_MOTION_NOTIFY:
2394         *x = event->motion.x;
2395         *y = event->motion.y;
2396         return TRUE;
2397         break;
2398
2399       case GDK_BUTTON_PRESS:
2400       case GDK_2BUTTON_PRESS:
2401       case GDK_3BUTTON_PRESS:
2402       case GDK_BUTTON_RELEASE:
2403         *x = event->button.x;
2404         *y = event->button.y;
2405         return TRUE;
2406         break;
2407
2408       case GDK_KEY_PRESS:
2409       case GDK_KEY_RELEASE:
2410       case GDK_ENTER_NOTIFY:
2411       case GDK_LEAVE_NOTIFY:
2412       case GDK_PROPERTY_NOTIFY:
2413       case GDK_SELECTION_CLEAR:
2414       case GDK_SELECTION_REQUEST:
2415       case GDK_SELECTION_NOTIFY:
2416       case GDK_PROXIMITY_IN:
2417       case GDK_PROXIMITY_OUT:
2418       case GDK_DRAG_ENTER:
2419       case GDK_DRAG_LEAVE:
2420       case GDK_DRAG_MOTION:
2421       case GDK_DRAG_STATUS:
2422       case GDK_DROP_START:
2423       case GDK_DROP_FINISHED:
2424       default:
2425         return FALSE;
2426         break;
2427       }
2428
2429   return FALSE;
2430 }
2431
2432 static gint
2433 emit_event_on_tags (GtkWidget   *widget,
2434                     GdkEvent    *event,
2435                     GtkTextIter *iter)
2436 {
2437   GSList *tags;
2438   GSList *tmp;
2439   gint retval = FALSE;
2440   GtkTextView *text_view;
2441
2442   text_view = GTK_TEXT_VIEW (widget);
2443
2444   tags = gtk_text_iter_get_tags (iter);
2445
2446   tmp = tags;
2447   while (tmp != NULL)
2448     {
2449       GtkTextTag *tag = tmp->data;
2450
2451       if (gtk_text_tag_event (tag, G_OBJECT (widget), event, iter))
2452         {
2453           retval = TRUE;
2454           break;
2455         }
2456
2457       tmp = g_slist_next (tmp);
2458     }
2459
2460   g_slist_free (tags);
2461
2462   return retval;
2463 }
2464
2465 static gint
2466 gtk_text_view_event (GtkWidget *widget, GdkEvent *event)
2467 {
2468   GtkTextView *text_view;
2469   gint x = 0, y = 0;
2470
2471   text_view = GTK_TEXT_VIEW (widget);
2472
2473   if (text_view->layout == NULL ||
2474       get_buffer (text_view) == NULL)
2475     return FALSE;
2476
2477   if (event->any.window != text_view->text_window->bin_window)
2478     return FALSE;
2479
2480   if (get_event_coordinates (event, &x, &y))
2481     {
2482       GtkTextIter iter;
2483
2484       x += text_view->xoffset;
2485       y += text_view->yoffset;
2486
2487       /* FIXME this is slow and we do it twice per event.
2488          My favorite solution is to have GtkTextLayout cache
2489          the last couple lookups. */
2490       gtk_text_layout_get_iter_at_pixel (text_view->layout,
2491                                          &iter,
2492                                          x, y);
2493
2494       return emit_event_on_tags (widget, event, &iter);
2495     }
2496   else if (event->type == GDK_KEY_PRESS ||
2497            event->type == GDK_KEY_RELEASE)
2498     {
2499       GtkTextMark *insert;
2500       GtkTextIter iter;
2501
2502       insert = gtk_text_buffer_get_mark (get_buffer (text_view),
2503                                          "insert");
2504
2505       gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, insert);
2506
2507       return emit_event_on_tags (widget, event, &iter);
2508     }
2509   else
2510     return FALSE;
2511 }
2512
2513 static gint
2514 gtk_text_view_key_press_event (GtkWidget *widget, GdkEventKey *event)
2515 {
2516   gint retval = FALSE;
2517   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
2518
2519   if (text_view->layout == NULL ||
2520       get_buffer (text_view) == NULL)
2521     return FALSE;
2522
2523   if (gtk_im_context_filter_keypress (text_view->im_context, event))
2524     {
2525       text_view->need_im_reset = TRUE;
2526       retval = TRUE;
2527     }
2528   else if (GTK_WIDGET_CLASS (parent_class)->key_press_event &&
2529            GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event))
2530     retval = TRUE;
2531   else if (event->keyval == GDK_Return)
2532     {
2533       gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), "\n", 1,
2534                                                     text_view->editable);
2535       gtk_text_view_scroll_to_mark (text_view,
2536                                     gtk_text_buffer_get_mark (get_buffer (text_view),
2537                                                               "insert"),
2538                                     0);
2539       retval = TRUE;
2540     }
2541   /* Pass through Tab as literal tab, unless Control is held down */
2542   else if (event->keyval == GDK_Tab && !(event->state & GDK_CONTROL_MASK))
2543     {
2544       gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), "\t", 1,
2545                                                     text_view->editable);
2546       gtk_text_view_scroll_to_mark (text_view,
2547                                     gtk_text_buffer_get_mark (get_buffer (text_view),
2548                                                               "insert"),
2549                                     0);
2550       retval = TRUE;
2551     }
2552   else
2553     retval = FALSE;
2554
2555   gtk_text_view_start_cursor_blink (text_view, TRUE);
2556
2557   return retval;
2558 }
2559
2560 static gint
2561 gtk_text_view_key_release_event (GtkWidget *widget, GdkEventKey *event)
2562 {
2563   return FALSE;
2564 }
2565
2566 static gint
2567 gtk_text_view_button_press_event (GtkWidget *widget, GdkEventButton *event)
2568 {
2569   GtkTextView *text_view;
2570
2571   text_view = GTK_TEXT_VIEW (widget);
2572
2573   gtk_widget_grab_focus (widget);
2574
2575   if (event->window != text_view->text_window->bin_window)
2576     {
2577       /* Remove selection if any. */
2578       gtk_text_view_unselect (text_view);
2579       return FALSE;
2580     }
2581
2582 #if 0
2583   /* debug hack */
2584   if (event->button == 3 && (event->state & GDK_CONTROL_MASK) != 0)
2585     _gtk_text_buffer_spew (GTK_TEXT_VIEW (widget)->buffer);
2586   else if (event->button == 3)
2587     gtk_text_layout_spew (GTK_TEXT_VIEW (widget)->layout);
2588 #endif
2589
2590   if (event->type == GDK_BUTTON_PRESS)
2591     {
2592       gtk_text_view_reset_im_context (text_view);
2593
2594       if (event->button == 1)
2595         {
2596           /* If we're in the selection, start a drag copy/move of the
2597            * selection; otherwise, start creating a new selection.
2598            */
2599           GtkTextIter iter;
2600           GtkTextIter start, end;
2601
2602           gtk_text_layout_get_iter_at_pixel (text_view->layout,
2603                                              &iter,
2604                                              event->x + text_view->xoffset,
2605                                              event->y + text_view->yoffset);
2606
2607           if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
2608                                                     &start, &end) &&
2609               gtk_text_iter_in_range (&iter, &start, &end))
2610             {
2611               text_view->drag_start_x = event->x;
2612               text_view->drag_start_y = event->y;
2613             }
2614           else
2615             {
2616               gtk_text_view_start_selection_drag (text_view, &iter, event);
2617             }
2618
2619           return TRUE;
2620         }
2621       else if (event->button == 2)
2622         {
2623           GtkTextIter iter;
2624
2625           gtk_text_layout_get_iter_at_pixel (text_view->layout,
2626                                              &iter,
2627                                              event->x + text_view->xoffset,
2628                                              event->y + text_view->yoffset);
2629
2630           gtk_text_buffer_paste_primary (get_buffer (text_view),
2631                                          &iter,
2632                                          text_view->editable);
2633           return TRUE;
2634         }
2635       else if (event->button == 3)
2636         {
2637           gtk_text_view_popup_menu (text_view, event);
2638         }
2639     }
2640
2641   return FALSE;
2642 }
2643
2644 static gint
2645 gtk_text_view_button_release_event (GtkWidget *widget, GdkEventButton *event)
2646 {
2647   GtkTextView *text_view;
2648
2649   text_view = GTK_TEXT_VIEW (widget);
2650
2651   if (event->window != text_view->text_window->bin_window)
2652     return FALSE;
2653
2654   if (event->button == 1)
2655     {
2656       if (text_view->drag_start_x >= 0)
2657         {
2658           text_view->drag_start_x = -1;
2659           text_view->drag_start_y = -1;
2660         }
2661
2662       if (gtk_text_view_end_selection_drag (GTK_TEXT_VIEW (widget), event))
2663         return TRUE;
2664       else
2665         {
2666           /* Unselect everything; probably we were dragging, or clicked
2667            * outside the text.
2668            */
2669           gtk_text_view_unselect (text_view);
2670           return FALSE;
2671         }
2672     }
2673
2674   return FALSE;
2675 }
2676
2677 static gint
2678 gtk_text_view_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
2679 {
2680   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
2681
2682   GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
2683   gtk_widget_draw_focus (widget);
2684
2685   if (text_view->cursor_visible && text_view->layout)
2686     {
2687       gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
2688       gtk_text_view_start_cursor_blink (text_view, FALSE);
2689     }
2690
2691   text_view->need_im_reset = TRUE;
2692   gtk_im_context_focus_in (GTK_TEXT_VIEW (widget)->im_context);
2693
2694   return FALSE;
2695 }
2696
2697 static gint
2698 gtk_text_view_focus_out_event (GtkWidget *widget, GdkEventFocus *event)
2699 {
2700   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
2701
2702   GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
2703   gtk_widget_draw_focus (widget);
2704
2705   if (text_view->cursor_visible && text_view->layout)
2706     {
2707       gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
2708       gtk_text_view_stop_cursor_blink (text_view);
2709     }
2710
2711   text_view->need_im_reset = TRUE;
2712   gtk_im_context_focus_out (GTK_TEXT_VIEW (widget)->im_context);
2713
2714   return FALSE;
2715 }
2716
2717 static gint
2718 gtk_text_view_motion_event (GtkWidget *widget, GdkEventMotion *event)
2719 {
2720   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
2721
2722   if (event->window == text_view->text_window->bin_window &&
2723       text_view->drag_start_x >= 0)
2724     {
2725       gint x, y;
2726       gint dx, dy;
2727
2728       gdk_window_get_pointer (text_view->text_window->bin_window,
2729                               &x, &y, NULL);
2730
2731       dx = text_view->drag_start_x - x;
2732       dy = text_view->drag_start_y - y;
2733
2734       if (ABS (dx) > DRAG_THRESHOLD ||
2735           ABS (dy) > DRAG_THRESHOLD)
2736         {
2737           GtkTextIter iter;
2738           gint buffer_x, buffer_y;
2739
2740           gtk_text_view_window_to_buffer_coords (text_view,
2741                                                  GTK_TEXT_WINDOW_TEXT,
2742                                                  text_view->drag_start_x,
2743                                                  text_view->drag_start_y,
2744                                                  &buffer_x,
2745                                                  &buffer_y);
2746
2747           gtk_text_layout_get_iter_at_pixel (text_view->layout,
2748                                              &iter,
2749                                              buffer_x, buffer_y);
2750
2751           gtk_text_view_start_selection_dnd (text_view, &iter, event);
2752           return TRUE;
2753         }
2754     }
2755
2756   return FALSE;
2757 }
2758
2759 static void
2760 gtk_text_view_paint (GtkWidget *widget, GdkRectangle *area)
2761 {
2762   GtkTextView *text_view;
2763
2764   text_view = GTK_TEXT_VIEW (widget);
2765
2766   g_return_if_fail (text_view->layout != NULL);
2767   g_return_if_fail (text_view->xoffset >= 0);
2768   g_return_if_fail (text_view->yoffset >= 0);
2769
2770   gtk_text_view_validate_onscreen (text_view);
2771
2772 #if 0
2773   printf ("painting %d,%d  %d x %d\n",
2774           area->x, area->y,
2775           area->width, area->height);
2776 #endif
2777
2778   gtk_text_layout_draw (text_view->layout,
2779                         widget,
2780                         text_view->text_window->bin_window,
2781                         text_view->xoffset,
2782                         text_view->yoffset,
2783                         area->x, area->y,
2784                         area->width, area->height);
2785 }
2786
2787 static void
2788 send_expose (GtkTextView   *text_view,
2789              GtkTextWindow *win,
2790              GdkRectangle  *area)
2791 {
2792   GdkEventExpose event;
2793
2794   event.type = GDK_EXPOSE;
2795   event.send_event = TRUE;
2796   event.window = win->bin_window;
2797   event.area = *area;
2798   event.count = 0;
2799
2800   /* Fix coordinates (convert widget coords to window coords) */
2801   gtk_text_view_window_to_buffer_coords (text_view,
2802                                          GTK_TEXT_WINDOW_WIDGET,
2803                                          event.area.x,
2804                                          event.area.y,
2805                                          &event.area.x,
2806                                          &event.area.y);
2807
2808   gtk_text_view_buffer_to_window_coords (text_view,
2809                                          win->type,
2810                                          event.area.x,
2811                                          event.area.y,
2812                                          &event.area.x,
2813                                          &event.area.y);
2814
2815
2816   gdk_window_ref (event.window);
2817   gtk_widget_event (GTK_WIDGET (text_view), (GdkEvent*) &event);
2818   gdk_window_unref (event.window);
2819 }
2820
2821 static void
2822 gtk_text_view_draw (GtkWidget *widget, GdkRectangle *area)
2823 {
2824   GdkRectangle intersection;
2825   GtkTextView *text_view;
2826
2827   text_view = GTK_TEXT_VIEW (widget);
2828
2829   gtk_text_view_paint (widget, area);
2830
2831   /* If the area overlaps the "edge" of the widget, draw the focus
2832    * rectangle
2833    */
2834   if (area->x < FOCUS_EDGE_WIDTH ||
2835       area->y < FOCUS_EDGE_WIDTH ||
2836       (area->x + area->width) > (widget->allocation.width - FOCUS_EDGE_WIDTH) ||
2837       (area->y + area->height) > (widget->allocation.height - FOCUS_EDGE_WIDTH))
2838     gtk_widget_draw_focus (widget);
2839
2840   /* Synthesize expose events for the user-drawn border windows,
2841    * just as we would for a drawing area.
2842    */
2843
2844   if (text_view->left_window &&
2845       gdk_rectangle_intersect (area, &text_view->left_window->allocation,
2846                                &intersection))
2847     send_expose (text_view, text_view->left_window, &intersection);
2848
2849   if (text_view->right_window &&
2850       gdk_rectangle_intersect (area, &text_view->right_window->allocation,
2851                                &intersection))
2852     send_expose (text_view, text_view->right_window, &intersection);
2853
2854   if (text_view->top_window &&
2855       gdk_rectangle_intersect (area, &text_view->top_window->allocation,
2856                                &intersection))
2857     send_expose (text_view, text_view->top_window, &intersection);
2858
2859   if (text_view->bottom_window &&
2860       gdk_rectangle_intersect (area, &text_view->bottom_window->allocation,
2861                                &intersection))
2862     send_expose (text_view, text_view->bottom_window, &intersection);
2863 }
2864
2865 static gint
2866 gtk_text_view_expose_event (GtkWidget *widget, GdkEventExpose *event)
2867 {
2868   if (event->window == gtk_text_view_get_window (GTK_TEXT_VIEW (widget),
2869                                                  GTK_TEXT_WINDOW_TEXT))
2870     gtk_text_view_paint (widget, &event->area);
2871
2872   if (event->window == widget->window)
2873     gtk_widget_draw_focus (widget);
2874
2875   return TRUE;
2876 }
2877
2878 static void
2879 gtk_text_view_draw_focus (GtkWidget *widget)
2880 {
2881   if (GTK_WIDGET_DRAWABLE (widget))
2882     {
2883       if (GTK_WIDGET_HAS_FOCUS (widget))
2884         {
2885           gtk_paint_focus (widget->style, widget->window,
2886                            NULL, widget, "textview",
2887                            0, 0,
2888                            widget->allocation.width - 1,
2889                            widget->allocation.height - 1);
2890         }
2891       else
2892         {
2893           gdk_window_clear (widget->window);
2894         }
2895     }
2896 }
2897
2898 /*
2899  * Container
2900  */
2901
2902 static void
2903 gtk_text_view_add (GtkContainer *container,
2904                    GtkWidget    *child)
2905 {
2906   g_return_if_fail (GTK_IS_TEXT_VIEW (container));
2907   g_return_if_fail (GTK_IS_WIDGET (child));
2908
2909   /* This is pretty random. */
2910   gtk_text_view_add_child_in_window (GTK_TEXT_VIEW (container),
2911                                      child,
2912                                      GTK_TEXT_WINDOW_WIDGET,
2913                                      0, 0);
2914 }
2915
2916 static void
2917 gtk_text_view_remove (GtkContainer *container,
2918                       GtkWidget    *child)
2919 {
2920   GSList *iter;
2921   GtkTextView *text_view;
2922   GtkTextViewChild *vc;
2923
2924   g_return_if_fail (GTK_IS_TEXT_VIEW (container));
2925   g_return_if_fail (GTK_IS_WIDGET (child));
2926   g_return_if_fail (child->parent == (GtkWidget*) container);
2927
2928   text_view = GTK_TEXT_VIEW (container);
2929
2930   vc = NULL;
2931   iter = text_view->children;
2932
2933   while (iter != NULL)
2934     {
2935       vc = iter->data;
2936
2937       if (vc->widget == child)
2938         break;
2939
2940       iter = g_slist_next (iter);
2941     }
2942
2943   g_assert (iter != NULL); /* be sure we had the child in the list */
2944
2945   text_view->children = g_slist_remove (text_view->children, vc);
2946
2947   gtk_widget_unparent (vc->widget);
2948
2949   text_view_child_free (vc);
2950 }
2951
2952 static void
2953 gtk_text_view_forall (GtkContainer *container,
2954                       gboolean      include_internals,
2955                       GtkCallback   callback,
2956                       gpointer      callback_data)
2957 {
2958   GSList *iter;
2959   GtkTextView *text_view;
2960
2961   g_return_if_fail (GTK_IS_TEXT_VIEW (container));
2962   g_return_if_fail (callback != NULL);
2963
2964   text_view = GTK_TEXT_VIEW (container);
2965
2966   iter = text_view->children;
2967
2968   while (iter != NULL)
2969     {
2970       GtkTextViewChild *vc = iter->data;
2971
2972       (* callback) (vc->widget, callback_data);
2973
2974       iter = g_slist_next (iter);
2975     }
2976 }
2977
2978 /* Note that CURSOR_ON_TIME is effectively added to PREBLINK_TIME
2979  * because blinking starts with the cursor turned on.
2980  */
2981 #define PREBLINK_TIME 300
2982 #define CURSOR_ON_TIME 800
2983 #define CURSOR_OFF_TIME 400
2984
2985 /*
2986  * preblink!
2987  */
2988
2989 static gint
2990 preblink_cb (gpointer data)
2991 {
2992   GtkTextView *text_view = GTK_TEXT_VIEW (data);
2993
2994   text_view->preblink_timeout = 0;
2995   gtk_text_view_start_cursor_blink (text_view, FALSE);
2996
2997   /* Remove ourselves */
2998   return FALSE;
2999 }
3000
3001 /*
3002  * Blink!
3003  */
3004
3005 static gint
3006 blink_cb (gpointer data)
3007 {
3008   GtkTextView *text_view = GTK_TEXT_VIEW (data);
3009   gboolean visible;
3010
3011   g_assert (text_view->layout);
3012   g_assert (GTK_WIDGET_HAS_FOCUS (text_view));
3013   g_assert (text_view->cursor_visible);
3014
3015   visible = gtk_text_layout_get_cursor_visible (text_view->layout);
3016
3017   if (visible)
3018     text_view->blink_timeout = gtk_timeout_add (CURSOR_OFF_TIME,
3019                                                 blink_cb,
3020                                                 text_view);
3021   else
3022     text_view->blink_timeout = gtk_timeout_add (CURSOR_ON_TIME,
3023                                                 blink_cb,
3024                                                 text_view);
3025
3026   gtk_text_layout_set_cursor_visible (text_view->layout,
3027                                       !visible);
3028
3029   /* Remove ourselves */
3030   return FALSE;
3031 }
3032
3033 static void
3034 gtk_text_view_start_cursor_blink(GtkTextView *text_view,
3035                                  gboolean     with_delay)
3036 {
3037   if (!text_view->cursor_visible)
3038     return;
3039
3040   if (text_view->preblink_timeout != 0)
3041     {
3042       gtk_timeout_remove (text_view->preblink_timeout);
3043       text_view->preblink_timeout = 0;
3044     }
3045
3046   if (with_delay)
3047     {
3048       if (text_view->blink_timeout != 0)
3049         {
3050           gtk_timeout_remove (text_view->blink_timeout);
3051           text_view->blink_timeout = 0;
3052         }
3053
3054       gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
3055
3056       text_view->preblink_timeout = gtk_timeout_add (PREBLINK_TIME,
3057                                                      preblink_cb,
3058                                                      text_view);
3059     }
3060   else
3061     {
3062       if (text_view->blink_timeout == 0)
3063         {
3064           gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
3065
3066           text_view->blink_timeout = gtk_timeout_add (CURSOR_ON_TIME,
3067                                                       blink_cb,
3068                                                       text_view);
3069         }
3070     }
3071 }
3072
3073 static void
3074 gtk_text_view_stop_cursor_blink (GtkTextView *text_view)
3075 {
3076   if (text_view->preblink_timeout)
3077     {
3078       gtk_timeout_remove (text_view->preblink_timeout);
3079       text_view->preblink_timeout = 0;
3080     }
3081
3082   if (text_view->blink_timeout)
3083     {
3084       gtk_timeout_remove (text_view->blink_timeout);
3085       text_view->blink_timeout = 0;
3086     }
3087 }
3088
3089 /*
3090  * Key binding handlers
3091  */
3092
3093 static void
3094 gtk_text_view_move_iter_by_lines (GtkTextView *text_view,
3095                                   GtkTextIter *newplace,
3096                                   gint         count)
3097 {
3098   while (count < 0)
3099     {
3100       gtk_text_layout_move_iter_to_previous_line (text_view->layout, newplace);
3101       count++;
3102     }
3103
3104   while (count > 0)
3105     {
3106       gtk_text_layout_move_iter_to_next_line (text_view->layout, newplace);
3107       count--;
3108     }
3109 }
3110
3111 static void
3112 gtk_text_view_move_cursor (GtkTextView     *text_view,
3113                            GtkMovementStep  step,
3114                            gint             count,
3115                            gboolean         extend_selection)
3116 {
3117   GtkTextIter insert;
3118   GtkTextIter newplace;
3119
3120   gint cursor_x_pos = 0;
3121
3122   gtk_text_view_reset_im_context (text_view);
3123
3124   if (step == GTK_MOVEMENT_PAGES)
3125     {
3126       gtk_text_view_scroll_pages (text_view, count);
3127       gtk_text_view_start_cursor_blink (text_view, TRUE);
3128       return;
3129     }
3130
3131   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
3132                                     gtk_text_buffer_get_mark (get_buffer (text_view),
3133                                                               "insert"));
3134   newplace = insert;
3135
3136   if (step == GTK_MOVEMENT_DISPLAY_LINES)
3137     gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, NULL);
3138
3139   switch (step)
3140     {
3141     case GTK_MOVEMENT_CHARS:
3142       gtk_text_iter_forward_chars (&newplace, count);
3143       break;
3144
3145     case GTK_MOVEMENT_POSITIONS:
3146       gtk_text_layout_move_iter_visually (text_view->layout,
3147                                           &newplace, count);
3148       break;
3149
3150     case GTK_MOVEMENT_WORDS:
3151       if (count < 0)
3152         gtk_text_iter_backward_word_starts (&newplace, -count);
3153       else if (count > 0)
3154         gtk_text_iter_forward_word_ends (&newplace, count);
3155       break;
3156
3157     case GTK_MOVEMENT_DISPLAY_LINES:
3158       gtk_text_view_move_iter_by_lines (text_view, &newplace, count);
3159       gtk_text_layout_move_iter_to_x (text_view->layout, &newplace, cursor_x_pos);
3160       break;
3161
3162     case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
3163       if (count > 1)
3164         gtk_text_view_move_iter_by_lines (text_view, &newplace, --count);
3165       else if (count < -1)
3166         gtk_text_view_move_iter_by_lines (text_view, &newplace, ++count);
3167
3168       if (count != 0)
3169         gtk_text_layout_move_iter_to_line_end (text_view->layout, &newplace, count);
3170       break;
3171
3172     case GTK_MOVEMENT_PARAGRAPHS:
3173       /* This should almost certainly instead be doing the parallel thing to WORD */
3174       /*       gtk_text_iter_down_lines (&newplace, count); */
3175       /* FIXME */
3176       break;
3177
3178     case GTK_MOVEMENT_PARAGRAPH_ENDS:
3179       if (count > 0)
3180         gtk_text_iter_forward_to_newline (&newplace);
3181       else if (count < 0)
3182         gtk_text_iter_set_line_offset (&newplace, 0);
3183       break;
3184
3185     case GTK_MOVEMENT_BUFFER_ENDS:
3186       if (count > 0)
3187         gtk_text_buffer_get_last_iter (get_buffer (text_view), &newplace);
3188       else if (count < 0)
3189         gtk_text_buffer_get_iter_at_offset (get_buffer (text_view), &newplace, 0);
3190       break;
3191
3192     default:
3193       break;
3194     }
3195
3196   if (!gtk_text_iter_equal (&insert, &newplace))
3197     {
3198       if (extend_selection)
3199         gtk_text_buffer_move_mark (get_buffer (text_view),
3200                                    gtk_text_buffer_get_mark (get_buffer (text_view),
3201                                                              "insert"),
3202                                    &newplace);
3203       else
3204         gtk_text_buffer_place_cursor (get_buffer (text_view), &newplace);
3205
3206       gtk_text_view_scroll_to_mark (text_view,
3207                                     gtk_text_buffer_get_mark (get_buffer (text_view),
3208                                                               "insert"), 0);
3209
3210       if (step == GTK_MOVEMENT_DISPLAY_LINES)
3211         {
3212           gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, -1);
3213         }
3214     }
3215
3216   gtk_text_view_start_cursor_blink (text_view, TRUE);
3217 }
3218
3219 static void
3220 gtk_text_view_set_anchor (GtkTextView *text_view)
3221 {
3222   GtkTextIter insert;
3223
3224   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
3225                                     gtk_text_buffer_get_mark (get_buffer (text_view),
3226                                                               "insert"));
3227
3228   gtk_text_buffer_create_mark (get_buffer (text_view), "anchor", &insert, TRUE);
3229 }
3230
3231 static void
3232 gtk_text_view_scroll_pages (GtkTextView *text_view,
3233                             gint         count)
3234 {
3235   gfloat newval;
3236   GtkAdjustment *adj;
3237   gint cursor_x_pos, cursor_y_pos;
3238   GtkTextIter new_insert;
3239   GtkTextIter anchor;
3240   gint y0, y1;
3241
3242   g_return_if_fail (text_view->vadjustment != NULL);
3243
3244   adj = text_view->vadjustment;
3245
3246   /* Validate the region that will be brought into view by the cursor motion
3247    */
3248   if (count < 0)
3249     {
3250       gtk_text_view_get_first_para_iter (text_view, &anchor);
3251       y0 = adj->page_size;
3252       y1 = adj->page_size + count * adj->page_increment;
3253     }
3254   else
3255     {
3256       gtk_text_view_get_first_para_iter (text_view, &anchor);
3257       y0 = count * adj->page_increment + adj->page_size;
3258       y1 = 0;
3259     }
3260
3261   gtk_text_layout_validate_yrange (text_view->layout, &anchor, y0, y1);
3262
3263   gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, &cursor_y_pos);
3264
3265   newval = adj->value;
3266
3267   newval += count * adj->page_increment;
3268
3269   cursor_y_pos += newval - adj->value;
3270   set_adjustment_clamped (adj, newval);
3271
3272   gtk_text_layout_get_iter_at_pixel (text_view->layout, &new_insert, cursor_x_pos, cursor_y_pos);
3273   clamp_iter_onscreen (text_view, &new_insert);
3274   gtk_text_buffer_place_cursor (get_buffer (text_view), &new_insert);
3275
3276   gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, cursor_y_pos);
3277
3278   /* Adjust to have the cursor _entirely_ onscreen, move_mark_onscreen
3279    * only guarantees 1 pixel onscreen.
3280    */
3281   gtk_text_view_scroll_to_mark (text_view,
3282                                 gtk_text_buffer_get_mark (get_buffer (text_view),
3283                                                           "insert"),
3284                                 0);
3285 }
3286
3287 static gboolean
3288 whitespace (gunichar ch, gpointer user_data)
3289 {
3290   return (ch == ' ' || ch == '\t');
3291 }
3292
3293 static gboolean
3294 not_whitespace (gunichar ch, gpointer user_data)
3295 {
3296   return !whitespace (ch, user_data);
3297 }
3298
3299 static gboolean
3300 find_whitepace_region (const GtkTextIter *center,
3301                        GtkTextIter *start, GtkTextIter *end)
3302 {
3303   *start = *center;
3304   *end = *center;
3305
3306   if (gtk_text_iter_backward_find_char (start, not_whitespace, NULL, NULL))
3307     gtk_text_iter_next_char (start); /* we want the first whitespace... */
3308   if (whitespace (gtk_text_iter_get_char (end), NULL))
3309     gtk_text_iter_forward_find_char (end, not_whitespace, NULL, NULL);
3310
3311   return !gtk_text_iter_equal (start, end);
3312 }
3313
3314 static void
3315 gtk_text_view_insert_at_cursor (GtkTextView *text_view,
3316                                 const gchar *str)
3317 {
3318   gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1,
3319                                                 text_view->editable);
3320 }
3321
3322 static void
3323 gtk_text_view_delete_from_cursor (GtkTextView   *text_view,
3324                                 GtkDeleteType  type,
3325                                 gint           count)
3326 {
3327   GtkTextIter insert;
3328   GtkTextIter start;
3329   GtkTextIter end;
3330   gboolean leave_one = FALSE;
3331
3332   gtk_text_view_reset_im_context (text_view);
3333
3334   if (type == GTK_DELETE_CHARS)
3335     {
3336       /* Char delete deletes the selection, if one exists */
3337       if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
3338                                             text_view->editable))
3339         return;
3340     }
3341
3342   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
3343                                     &insert,
3344                                     gtk_text_buffer_get_mark (get_buffer (text_view),
3345                                                               "insert"));
3346
3347   start = insert;
3348   end = insert;
3349
3350   switch (type)
3351     {
3352     case GTK_DELETE_CHARS:
3353       gtk_text_iter_forward_chars (&end, count);
3354       break;
3355
3356     case GTK_DELETE_WORD_ENDS:
3357       if (count > 0)
3358         gtk_text_iter_forward_word_ends (&end, count);
3359       else if (count < 0)
3360         gtk_text_iter_backward_word_starts (&start, 0 - count);
3361       break;
3362
3363     case GTK_DELETE_WORDS:
3364       break;
3365
3366     case GTK_DELETE_DISPLAY_LINE_ENDS:
3367       break;
3368
3369     case GTK_DELETE_DISPLAY_LINES:
3370       break;
3371
3372     case GTK_DELETE_PARAGRAPH_ENDS:
3373       /* If we're already at a newline, we need to
3374        * simply delete that newline, instead of
3375        * moving to the next one.
3376        */
3377       if (gtk_text_iter_get_char (&end) == '\n')
3378         {
3379           gtk_text_iter_next_char (&end);
3380           --count;
3381         }
3382
3383       while (count > 0)
3384         {
3385           if (!gtk_text_iter_forward_to_newline (&end))
3386             break;
3387
3388           --count;
3389         }
3390
3391       /* FIXME figure out what a negative count means
3392          and support that */
3393       break;
3394
3395     case GTK_DELETE_PARAGRAPHS:
3396       if (count > 0)
3397         {
3398           gtk_text_iter_set_line_offset (&start, 0);
3399           gtk_text_iter_forward_to_newline (&end);
3400
3401           /* Do the lines beyond the first. */
3402           while (count > 1)
3403             {
3404               gtk_text_iter_forward_to_newline (&end);
3405
3406               --count;
3407             }
3408         }
3409
3410       /* FIXME negative count? */
3411
3412       break;
3413
3414     case GTK_DELETE_WHITESPACE:
3415       {
3416         find_whitepace_region (&insert, &start, &end);
3417       }
3418       break;
3419
3420     default:
3421       break;
3422     }
3423
3424   if (!gtk_text_iter_equal (&start, &end))
3425     {
3426       if (gtk_text_buffer_delete_interactive (get_buffer (text_view), &start, &end,
3427                                               text_view->editable))
3428         {
3429           if (leave_one)
3430             gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view),
3431                                                           " ", 1,
3432                                                           text_view->editable);
3433         }
3434
3435       gtk_text_view_scroll_to_mark (text_view,
3436                                     gtk_text_buffer_get_mark (get_buffer (text_view), "insert"),
3437                                     0);
3438     }
3439 }
3440
3441 static void
3442 gtk_text_view_cut_clipboard (GtkTextView *text_view)
3443 {
3444   gtk_text_buffer_cut_clipboard (get_buffer (text_view), text_view->editable);
3445   gtk_text_view_scroll_to_mark (text_view,
3446                                 gtk_text_buffer_get_mark (get_buffer (text_view),
3447                                                           "insert"),
3448                                 0);
3449 }
3450
3451 static void
3452 gtk_text_view_copy_clipboard (GtkTextView *text_view)
3453 {
3454   gtk_text_buffer_copy_clipboard (get_buffer (text_view));
3455   gtk_text_view_scroll_to_mark (text_view,
3456                                 gtk_text_buffer_get_mark (get_buffer (text_view),
3457                                                           "insert"),
3458                                 0);
3459 }
3460
3461 static void
3462 gtk_text_view_paste_clipboard (GtkTextView *text_view)
3463 {
3464   gtk_text_buffer_paste_clipboard (get_buffer (text_view), text_view->editable);
3465   gtk_text_view_scroll_to_mark (text_view,
3466                                 gtk_text_buffer_get_mark (get_buffer (text_view),
3467                                                           "insert"),
3468                                 0);
3469 }
3470
3471 static void
3472 gtk_text_view_toggle_overwrite (GtkTextView *text_view)
3473 {
3474   text_view->overwrite_mode = !text_view->overwrite_mode;
3475 }
3476
3477 /*
3478  * Selections
3479  */
3480
3481 static void
3482 gtk_text_view_unselect (GtkTextView *text_view)
3483 {
3484   GtkTextIter insert;
3485
3486   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
3487                                     &insert,
3488                                     gtk_text_buffer_get_mark (get_buffer (text_view),
3489                                                               "insert"));
3490
3491   gtk_text_buffer_move_mark (get_buffer (text_view),
3492                              gtk_text_buffer_get_mark (get_buffer (text_view),
3493                                                        "selection_bound"),
3494                              &insert);
3495 }
3496
3497 static gboolean
3498 move_insert_to_pointer_and_scroll (GtkTextView *text_view, gboolean partial_scroll)
3499 {
3500   gint x, y;
3501   GdkModifierType state;
3502   GtkTextIter newplace;
3503   gint adjust = 0;
3504   gboolean in_threshold = FALSE;
3505
3506   gdk_window_get_pointer (text_view->text_window->bin_window,
3507                           &x, &y, &state);
3508
3509   /* Adjust movement by how long we've been selecting, to
3510      get an acceleration effect. The exact numbers are
3511      pretty arbitrary. We have a threshold before we
3512      start to accelerate. */
3513   /* uncommenting this printf helps visualize how it works. */
3514   /*   printf ("%d\n", text_view->scrolling_accel_factor); */
3515
3516   if (text_view->scrolling_accel_factor > 10)
3517     adjust = (text_view->scrolling_accel_factor - 10) * 75;
3518
3519   if (y < 0) /* scrolling upward */
3520     adjust = -adjust;
3521
3522   /* No adjust if the pointer has moved back inside the window for sure.
3523      Also I'm adding a small threshold where no adjust is added,
3524      in case you want to do a continuous slow scroll. */
3525 #define SLOW_SCROLL_TH 7
3526   if (x >= (0 - SLOW_SCROLL_TH) &&
3527       x < (SCREEN_WIDTH (text_view) + SLOW_SCROLL_TH) &&
3528       y >= (0 - SLOW_SCROLL_TH) &&
3529       y < (SCREEN_HEIGHT (text_view) + SLOW_SCROLL_TH))
3530     {
3531       adjust = 0;
3532       in_threshold = TRUE;
3533     }
3534
3535   gtk_text_layout_get_iter_at_pixel (text_view->layout,
3536                                      &newplace,
3537                                      x + text_view->xoffset,
3538                                      y + text_view->yoffset + adjust);
3539
3540   {
3541     gboolean scrolled = FALSE;
3542     GtkTextMark *insert_mark =
3543       gtk_text_buffer_get_mark (get_buffer (text_view), "insert");
3544
3545     gtk_text_buffer_move_mark (get_buffer (text_view),
3546                                insert_mark,
3547                                &newplace);
3548
3549     if (partial_scroll)
3550       scrolled = gtk_text_view_scroll_to_mark_adjusted (text_view, insert_mark, 0, 0.7);
3551     else
3552       scrolled = gtk_text_view_scroll_to_mark_adjusted (text_view, insert_mark, 0, 1.0);
3553
3554     if (scrolled)
3555       {
3556         /* We want to avoid rapid jump to super-accelerated when you
3557            leave the slow scroll threshold after scrolling for a
3558            while. So we slowly decrease accel when scrolling inside
3559            the threshold.
3560         */
3561         if (in_threshold)
3562           {
3563             if (text_view->scrolling_accel_factor > 1)
3564               text_view->scrolling_accel_factor -= 2;
3565           }
3566         else
3567           text_view->scrolling_accel_factor += 1;
3568       }
3569     else
3570       {
3571         /* If we don't scroll we're probably inside the window, but
3572            potentially just a bit outside. We decrease acceleration
3573            while the user is fooling around inside the window.
3574            Acceleration decreases faster than it increases. */
3575         if (text_view->scrolling_accel_factor > 4)
3576           text_view->scrolling_accel_factor -= 5;
3577       }
3578
3579     return scrolled;
3580   }
3581 }
3582
3583 static gint
3584 selection_scan_timeout (gpointer data)
3585 {
3586   GtkTextView *text_view;
3587
3588   text_view = GTK_TEXT_VIEW (data);
3589
3590   if (move_insert_to_pointer_and_scroll (text_view, TRUE))
3591     {
3592       return TRUE; /* remain installed. */
3593     }
3594   else
3595     {
3596       text_view->selection_drag_scan_timeout = 0;
3597       return FALSE; /* remove ourselves */
3598     }
3599 }
3600
3601 static gint
3602 selection_motion_event_handler (GtkTextView *text_view, GdkEventMotion *event, gpointer data)
3603 {
3604   if (move_insert_to_pointer_and_scroll (text_view, TRUE))
3605     {
3606       /* If we had to scroll offscreen, insert a timeout to do so
3607          again. Note that in the timeout, even if the mouse doesn't
3608          move, due to this scroll xoffset/yoffset will have changed
3609          and we'll need to scroll again. */
3610       if (text_view->selection_drag_scan_timeout != 0) /* reset on every motion event */
3611         gtk_timeout_remove (text_view->selection_drag_scan_timeout);
3612
3613       text_view->selection_drag_scan_timeout =
3614         gtk_timeout_add (50, selection_scan_timeout, text_view);
3615     }
3616
3617   return TRUE;
3618 }
3619
3620 static void
3621 gtk_text_view_start_selection_drag (GtkTextView       *text_view,
3622                                     const GtkTextIter *iter,
3623                                     GdkEventButton    *button)
3624 {
3625   GtkTextIter newplace;
3626
3627   g_return_if_fail (text_view->selection_drag_handler == 0);
3628
3629   gtk_grab_add (GTK_WIDGET (text_view));
3630
3631   text_view->scrolling_accel_factor = 0;
3632
3633   newplace = *iter;
3634
3635   gtk_text_buffer_place_cursor (get_buffer (text_view), &newplace);
3636
3637   text_view->selection_drag_handler = gtk_signal_connect (GTK_OBJECT (text_view),
3638                                                           "motion_notify_event",
3639                                                           GTK_SIGNAL_FUNC (selection_motion_event_handler),
3640                                                           NULL);
3641 }
3642
3643 /* returns whether we were really dragging */
3644 static gboolean
3645 gtk_text_view_end_selection_drag (GtkTextView *text_view, GdkEventButton *event)
3646 {
3647   if (text_view->selection_drag_handler == 0)
3648     return FALSE;
3649
3650   gtk_signal_disconnect (GTK_OBJECT (text_view), text_view->selection_drag_handler);
3651   text_view->selection_drag_handler = 0;
3652
3653   text_view->scrolling_accel_factor = 0;
3654
3655   if (text_view->selection_drag_scan_timeout != 0)
3656     {
3657       gtk_timeout_remove (text_view->selection_drag_scan_timeout);
3658       text_view->selection_drag_scan_timeout = 0;
3659     }
3660
3661   /* one last update to current position */
3662   move_insert_to_pointer_and_scroll (text_view, FALSE);
3663
3664   gtk_grab_remove (GTK_WIDGET (text_view));
3665
3666   return TRUE;
3667 }
3668
3669 /*
3670  * Layout utils
3671  */
3672
3673 static void
3674 gtk_text_view_set_adjustment_upper (GtkAdjustment *adj, gfloat upper)
3675 {
3676   if (upper != adj->upper)
3677     {
3678       gfloat min = MAX (0., upper - adj->page_size);
3679       gboolean value_changed = FALSE;
3680
3681       adj->upper = upper;
3682
3683       if (adj->value > min)
3684         {
3685           adj->value = min;
3686           value_changed = TRUE;
3687         }
3688
3689       gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
3690       if (value_changed)
3691         gtk_signal_emit_by_name (GTK_OBJECT (adj), "value_changed");
3692     }
3693 }
3694
3695 static void
3696 gtk_text_view_scroll_calc_now (GtkTextView *text_view)
3697 {
3698   gint width = 0, height = 0;
3699
3700   gtk_text_view_ensure_layout (text_view);
3701
3702
3703   gtk_text_layout_set_screen_width (text_view->layout,
3704                                     SCREEN_WIDTH (text_view));
3705
3706   gtk_text_layout_get_size (text_view->layout, &width, &height);
3707
3708   if (text_view->width != width || text_view->height != height)
3709     {
3710       text_view->width = width;
3711       text_view->height = height;
3712
3713       gtk_text_view_set_adjustment_upper (get_hadjustment (text_view),
3714                                           MAX (SCREEN_WIDTH (text_view), width));
3715       gtk_text_view_set_adjustment_upper (get_vadjustment (text_view),
3716                                           MAX (SCREEN_HEIGHT (text_view), height));
3717
3718       /* hadj/vadj exist since we called get_hadjustment/get_vadjustment above */
3719
3720       /* Set up the step sizes; we'll say that a page is
3721          our allocation minus one step, and a step is
3722          1/10 of our allocation. */
3723       text_view->hadjustment->step_increment =
3724         SCREEN_WIDTH (text_view) / 10.0;
3725       text_view->hadjustment->page_increment =
3726         SCREEN_WIDTH (text_view) * 0.9;
3727
3728       text_view->vadjustment->step_increment =
3729         SCREEN_HEIGHT (text_view) / 10.0;
3730       text_view->vadjustment->page_increment =
3731         SCREEN_HEIGHT (text_view) * 0.9;
3732     }
3733 }
3734
3735 static void
3736 gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
3737                                          GtkTextAttributes *values,
3738                                          GtkStyle           *style)
3739 {
3740   values->appearance.bg_color = style->base[GTK_STATE_NORMAL];
3741   values->appearance.fg_color = style->fg[GTK_STATE_NORMAL];
3742
3743   if (values->font.family_name)
3744     g_free (values->font.family_name);
3745
3746   values->font = *style->font_desc;
3747   values->font.family_name = g_strdup (style->font_desc->family_name);
3748 }
3749
3750 static void
3751 gtk_text_view_ensure_layout (GtkTextView *text_view)
3752 {
3753   GtkWidget *widget;
3754
3755   widget = GTK_WIDGET (text_view);
3756
3757   if (text_view->layout == NULL)
3758     {
3759       GtkTextAttributes *style;
3760       PangoContext *ltr_context, *rtl_context;
3761       GSList *tmp_list;
3762
3763       text_view->layout = gtk_text_layout_new ();
3764
3765       gtk_signal_connect (GTK_OBJECT (text_view->layout),
3766                           "invalidated",
3767                           GTK_SIGNAL_FUNC (invalidated_handler),
3768                           text_view);
3769
3770       gtk_signal_connect (GTK_OBJECT (text_view->layout),
3771                           "changed",
3772                           GTK_SIGNAL_FUNC (changed_handler),
3773                           text_view);
3774
3775       gtk_signal_connect (GTK_OBJECT (text_view->layout),
3776                           "allocate_child",
3777                           GTK_SIGNAL_FUNC (gtk_text_view_child_allocated),
3778                           text_view);
3779
3780       if (get_buffer (text_view))
3781         gtk_text_layout_set_buffer (text_view->layout, get_buffer (text_view));
3782
3783       if ((GTK_WIDGET_HAS_FOCUS (text_view) && text_view->cursor_visible))
3784         gtk_text_view_start_cursor_blink (text_view, FALSE);
3785       else
3786         gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
3787
3788       ltr_context = gtk_widget_create_pango_context (GTK_WIDGET (text_view));
3789       pango_context_set_base_dir (ltr_context, PANGO_DIRECTION_LTR);
3790       rtl_context = gtk_widget_create_pango_context (GTK_WIDGET (text_view));
3791       pango_context_set_base_dir (rtl_context, PANGO_DIRECTION_RTL);
3792
3793       gtk_text_layout_set_contexts (text_view->layout, ltr_context, rtl_context);
3794
3795       g_object_unref (G_OBJECT (ltr_context));
3796       g_object_unref (G_OBJECT (rtl_context));
3797
3798       style = gtk_text_attributes_new ();
3799
3800       gtk_widget_ensure_style (widget);
3801       gtk_text_view_set_attributes_from_style (text_view,
3802                                                style, widget->style);
3803
3804       style->pixels_above_lines = text_view->pixels_above_lines;
3805       style->pixels_below_lines = text_view->pixels_below_lines;
3806       style->pixels_inside_wrap = text_view->pixels_inside_wrap;
3807       style->left_margin = text_view->left_margin;
3808       style->right_margin = text_view->right_margin;
3809       style->indent = text_view->indent;
3810       style->tabs = text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
3811
3812       style->wrap_mode = text_view->wrap_mode;
3813       style->justify = text_view->justify;
3814       style->direction = gtk_widget_get_direction (GTK_WIDGET (text_view));
3815
3816       gtk_text_layout_set_default_style (text_view->layout, style);
3817
3818       gtk_text_attributes_unref (style);
3819
3820       /* Set layout for all anchored children */
3821
3822       tmp_list = text_view->children;
3823       while (tmp_list != NULL)
3824         {
3825           GtkTextViewChild *vc = tmp_list->data;
3826
3827           if (vc->anchor)
3828             {
3829               gtk_text_anchored_child_set_layout (vc->widget,
3830                                                   text_view->layout);
3831               /* vc may now be invalid! */
3832             }
3833
3834           tmp_list = g_slist_next (tmp_list);
3835         }
3836     }
3837 }
3838
3839 static void
3840 gtk_text_view_destroy_layout (GtkTextView *text_view)
3841 {
3842   if (text_view->layout)
3843     {
3844       /* Remove layout from all anchored children */
3845       GSList *tmp_list;
3846
3847       tmp_list = text_view->children;
3848       while (tmp_list != NULL)
3849         {
3850           GtkTextViewChild *vc = tmp_list->data;
3851
3852           if (vc->anchor)
3853             {
3854               gtk_text_anchored_child_set_layout (vc->widget, NULL);
3855               /* vc may now be invalid! */
3856             }
3857
3858           tmp_list = g_slist_next (tmp_list);
3859         }
3860
3861       gtk_text_view_stop_cursor_blink (text_view);
3862       gtk_text_view_end_selection_drag (text_view, NULL);
3863
3864       gtk_signal_disconnect_by_func (GTK_OBJECT (text_view->layout),
3865                                      invalidated_handler, text_view);
3866       gtk_signal_disconnect_by_func (GTK_OBJECT (text_view->layout),
3867                                      changed_handler, text_view);
3868       gtk_object_unref (GTK_OBJECT (text_view->layout));
3869       text_view->layout = NULL;
3870     }
3871 }
3872
3873 static void
3874 gtk_text_view_reset_im_context (GtkTextView *text_view)
3875 {
3876   if (text_view->need_im_reset)
3877     text_view->need_im_reset = 0;
3878
3879   gtk_im_context_reset (text_view->im_context);
3880 }
3881
3882 /*
3883  * DND feature
3884  */
3885
3886 static void
3887 gtk_text_view_start_selection_dnd (GtkTextView       *text_view,
3888                                    const GtkTextIter *iter,
3889                                    GdkEventMotion    *event)
3890 {
3891   GdkDragContext *context;
3892   GtkTargetList *target_list;
3893
3894   text_view->drag_start_x = -1;
3895   text_view->drag_start_y = -1;
3896
3897   target_list = gtk_target_list_new (target_table,
3898                                      G_N_ELEMENTS (target_table));
3899
3900   context = gtk_drag_begin (GTK_WIDGET (text_view), target_list,
3901                             GDK_ACTION_COPY | GDK_ACTION_MOVE,
3902                             1, (GdkEvent*)event);
3903
3904   gtk_target_list_unref (target_list);
3905
3906   gtk_drag_set_icon_default (context);
3907
3908   /* We're inside the selection, so start without being able
3909    * to accept the drag.
3910    */
3911   gdk_drag_status (context, 0, event->time);
3912   gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
3913 }
3914
3915 static void
3916 gtk_text_view_drag_begin (GtkWidget        *widget,
3917                           GdkDragContext   *context)
3918 {
3919
3920 }
3921
3922 static void
3923 gtk_text_view_drag_end (GtkWidget        *widget,
3924                         GdkDragContext   *context)
3925 {
3926   GtkTextView *text_view;
3927
3928   text_view = GTK_TEXT_VIEW (widget);
3929
3930   gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
3931 }
3932
3933 static void
3934 gtk_text_view_drag_data_get (GtkWidget        *widget,
3935                              GdkDragContext   *context,
3936                              GtkSelectionData *selection_data,
3937                              guint             info,
3938                              guint             time)
3939 {
3940   GtkTextView *text_view;
3941
3942   text_view = GTK_TEXT_VIEW (widget);
3943
3944   if (selection_data->target == gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE))
3945     {
3946       GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
3947
3948       gtk_selection_data_set (selection_data,
3949                               gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE),
3950                               8, /* bytes */
3951                               (void*)&buffer,
3952                               sizeof (buffer));
3953     }
3954   else
3955     {
3956       gchar *str;
3957       GtkTextIter start;
3958       GtkTextIter end;
3959
3960       str = NULL;
3961
3962       if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
3963                                                 &start, &end))
3964         {
3965           /* Extract the selected text */
3966           str = gtk_text_iter_get_visible_text (&start, &end);
3967         }
3968
3969       if (str)
3970         {
3971           gtk_selection_data_set_text (selection_data, str);
3972           g_free (str);
3973         }
3974     }
3975 }
3976
3977 static void
3978 gtk_text_view_drag_data_delete (GtkWidget        *widget,
3979                                 GdkDragContext   *context)
3980 {
3981   GtkTextView *text_view;
3982
3983   text_view = GTK_TEXT_VIEW (widget);
3984
3985   gtk_text_buffer_delete_selection (GTK_TEXT_VIEW (widget)->buffer,
3986                                     TRUE, GTK_TEXT_VIEW (widget)->editable);
3987 }
3988
3989 static void
3990 gtk_text_view_drag_leave (GtkWidget        *widget,
3991                           GdkDragContext   *context,
3992                           guint             time)
3993 {
3994
3995
3996 }
3997
3998 static gboolean
3999 gtk_text_view_drag_motion (GtkWidget        *widget,
4000                            GdkDragContext   *context,
4001                            gint              x,
4002                            gint              y,
4003                            guint             time)
4004 {
4005   GtkTextIter newplace;
4006   GtkTextView *text_view;
4007   GtkTextIter start;
4008   GtkTextIter end;
4009   GdkRectangle target_rect;
4010   gint bx, by;
4011
4012   text_view = GTK_TEXT_VIEW (widget);
4013
4014   target_rect = text_view->text_window->allocation;
4015
4016   if (x < target_rect.x ||
4017       y < target_rect.y ||
4018       x > (target_rect.x + target_rect.width) ||
4019       y > (target_rect.y + target_rect.height))
4020     return FALSE; /* outside the text window */
4021
4022   gtk_text_view_window_to_buffer_coords (text_view,
4023                                          GTK_TEXT_WINDOW_WIDGET,
4024                                          x, y,
4025                                          &bx, &by);
4026
4027   gtk_text_layout_get_iter_at_pixel (text_view->layout,
4028                                      &newplace,
4029                                      bx, by);
4030
4031   if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
4032                                             &start, &end) &&
4033       gtk_text_iter_in_range (&newplace, &start, &end))
4034     {
4035       /* We're inside the selection. */
4036       gdk_drag_status (context, 0, time);
4037       gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
4038     }
4039   else
4040     {
4041       if (gtk_text_iter_editable (&newplace, text_view->editable))
4042         {
4043           GtkWidget *source_widget;
4044           GdkDragAction suggested_action;
4045
4046           suggested_action = context->suggested_action;
4047
4048           source_widget = gtk_drag_get_source_widget (context);
4049
4050           if (source_widget == widget)
4051             {
4052               /* Default to MOVE, unless the user has
4053                * pressed ctrl or alt to affect available actions
4054                */
4055               if ((context->actions & GDK_ACTION_MOVE) != 0)
4056                 suggested_action = GDK_ACTION_MOVE;
4057             }
4058
4059           gtk_text_mark_set_visible (text_view->dnd_mark,
4060                                      text_view->cursor_visible);
4061
4062           gdk_drag_status (context, suggested_action, time);
4063         }
4064       else
4065         {
4066           /* Can't drop here. */
4067           gdk_drag_status (context, 0, time);
4068           gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
4069         }
4070     }
4071
4072   gtk_text_buffer_move_mark (get_buffer (text_view),
4073                              gtk_text_buffer_get_mark (get_buffer (text_view),
4074                                                        "gtk_drag_target"),
4075                              &newplace);
4076
4077   {
4078     /* The effect of this is that the text scrolls if you're near
4079        the edge. We have to scroll whether or not we're inside
4080        the selection. */
4081     gint margin;
4082
4083     margin = MIN (SCREEN_WIDTH (widget), SCREEN_HEIGHT (widget));
4084     margin /= 5;
4085
4086     gtk_text_view_scroll_to_mark_adjusted (text_view,
4087                                            gtk_text_buffer_get_mark (get_buffer (text_view),
4088                                                                      "gtk_drag_target"),
4089                                            margin, 1.0);
4090   }
4091
4092   return TRUE;
4093 }
4094
4095 static gboolean
4096 gtk_text_view_drag_drop (GtkWidget        *widget,
4097                          GdkDragContext   *context,
4098                          gint              x,
4099                          gint              y,
4100                          guint             time)
4101 {
4102 #if 0
4103   /* called automatically. */
4104   if (context->targets)
4105     {
4106       gtk_drag_get_data (widget, context,
4107                          GPOINTER_TO_INT (context->targets->data),
4108                          time);
4109       return TRUE;
4110     }
4111   else
4112     return FALSE;
4113 #endif
4114   return TRUE;
4115 }
4116
4117 static void
4118 insert_text_data (GtkTextView      *text_view,
4119                   GtkTextIter      *drop_point,
4120                   GtkSelectionData *selection_data)
4121 {
4122   gchar *str;
4123
4124   str = gtk_selection_data_get_text (selection_data);
4125
4126   if (str)
4127     {
4128       gtk_text_buffer_insert_interactive (get_buffer (text_view),
4129                                           drop_point, str, -1,
4130                                           text_view->editable);
4131       g_free (str);
4132     }
4133 }
4134
4135 static void
4136 gtk_text_view_drag_data_received (GtkWidget        *widget,
4137                                   GdkDragContext   *context,
4138                                   gint              x,
4139                                   gint              y,
4140                                   GtkSelectionData *selection_data,
4141                                   guint             info,
4142                                   guint             time)
4143 {
4144   GtkTextIter drop_point;
4145   GtkTextView *text_view;
4146   GtkTextMark *drag_target_mark;
4147
4148   text_view = GTK_TEXT_VIEW (widget);
4149
4150   drag_target_mark = gtk_text_buffer_get_mark (get_buffer (text_view),
4151                                                "gtk_drag_target");
4152
4153   if (drag_target_mark == NULL)
4154     return;
4155
4156   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
4157                                     &drop_point,
4158                                     drag_target_mark);
4159
4160   if (selection_data->target == gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE))
4161     {
4162       GtkTextBuffer *src_buffer = NULL;
4163       GtkTextIter start, end;
4164       gboolean copy_tags = TRUE;
4165
4166       if (selection_data->length != sizeof (src_buffer))
4167         return;
4168
4169       memcpy (&src_buffer, selection_data->data, sizeof (src_buffer));
4170
4171       if (src_buffer == NULL)
4172         return;
4173
4174       g_return_if_fail (GTK_IS_TEXT_BUFFER (src_buffer));
4175
4176       if (gtk_text_buffer_get_tag_table (src_buffer) !=
4177           gtk_text_buffer_get_tag_table (get_buffer (text_view)))
4178         copy_tags = FALSE;
4179
4180       if (gtk_text_buffer_get_selection_bounds (src_buffer,
4181                                                 &start,
4182                                                 &end))
4183         {
4184           if (copy_tags)
4185             gtk_text_buffer_insert_range_interactive (get_buffer (text_view),
4186                                                       &drop_point,
4187                                                       &start,
4188                                                       &end,
4189                                                       text_view->editable);
4190           else
4191             {
4192               gchar *str;
4193
4194               str = gtk_text_iter_get_visible_text (&start, &end);
4195               gtk_text_buffer_insert_interactive (get_buffer (text_view),
4196                                                   &drop_point, str, -1,
4197                                                   text_view->editable);
4198               g_free (str);
4199             }
4200         }
4201     }
4202   else
4203     insert_text_data (text_view, &drop_point, selection_data);
4204 }
4205
4206 static GtkAdjustment*
4207 get_hadjustment (GtkTextView *text_view)
4208 {
4209   if (text_view->hadjustment == NULL)
4210     gtk_text_view_set_scroll_adjustments (text_view,
4211                                           NULL, /* forces creation */
4212                                           text_view->vadjustment);
4213
4214   return text_view->hadjustment;
4215 }
4216
4217 static GtkAdjustment*
4218 get_vadjustment (GtkTextView *text_view)
4219 {
4220   if (text_view->vadjustment == NULL)
4221     gtk_text_view_set_scroll_adjustments (text_view,
4222                                           text_view->hadjustment,
4223                                           NULL); /* forces creation */
4224   return text_view->vadjustment;
4225 }
4226
4227
4228 static void
4229 gtk_text_view_set_scroll_adjustments (GtkTextView   *text_view,
4230                                       GtkAdjustment *hadj,
4231                                       GtkAdjustment *vadj)
4232 {
4233   gboolean need_adjust = FALSE;
4234
4235   g_return_if_fail (text_view != NULL);
4236   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
4237
4238   if (hadj)
4239     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
4240   else
4241     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
4242   if (vadj)
4243     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
4244   else
4245     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
4246
4247   if (text_view->hadjustment && (text_view->hadjustment != hadj))
4248     {
4249       gtk_signal_disconnect_by_data (GTK_OBJECT (text_view->hadjustment), text_view);
4250       gtk_object_unref (GTK_OBJECT (text_view->hadjustment));
4251     }
4252
4253   if (text_view->vadjustment && (text_view->vadjustment != vadj))
4254     {
4255       gtk_signal_disconnect_by_data (GTK_OBJECT (text_view->vadjustment), text_view);
4256       gtk_object_unref (GTK_OBJECT (text_view->vadjustment));
4257     }
4258
4259   if (text_view->hadjustment != hadj)
4260     {
4261       text_view->hadjustment = hadj;
4262       gtk_object_ref (GTK_OBJECT (text_view->hadjustment));
4263       gtk_object_sink (GTK_OBJECT (text_view->hadjustment));
4264
4265       gtk_signal_connect (GTK_OBJECT (text_view->hadjustment), "value_changed",
4266                           (GtkSignalFunc) gtk_text_view_value_changed,
4267                           text_view);
4268       need_adjust = TRUE;
4269     }
4270
4271   if (text_view->vadjustment != vadj)
4272     {
4273       text_view->vadjustment = vadj;
4274       gtk_object_ref (GTK_OBJECT (text_view->vadjustment));
4275       gtk_object_sink (GTK_OBJECT (text_view->vadjustment));
4276
4277       gtk_signal_connect (GTK_OBJECT (text_view->vadjustment), "value_changed",
4278                           (GtkSignalFunc) gtk_text_view_value_changed,
4279                           text_view);
4280       need_adjust = TRUE;
4281     }
4282
4283   if (need_adjust)
4284     gtk_text_view_value_changed (NULL, text_view);
4285 }
4286
4287 static void
4288 gtk_text_view_value_changed (GtkAdjustment *adj,
4289                              GtkTextView   *text_view)
4290 {
4291   GtkTextIter iter;
4292   gint line_top;
4293   gint dx = 0;
4294   gint dy = 0;
4295
4296   if (adj == text_view->hadjustment)
4297     {
4298       dx = text_view->xoffset - (gint)adj->value;
4299       text_view->xoffset = adj->value;
4300     }
4301   else if (adj == text_view->vadjustment)
4302     {
4303       dy = text_view->yoffset - (gint)adj->value;
4304       text_view->yoffset = adj->value;
4305
4306       if (text_view->layout)
4307         {
4308           gtk_text_layout_get_line_at_y (text_view->layout, &iter, adj->value, &line_top);
4309
4310           gtk_text_buffer_move_mark (get_buffer (text_view), text_view->first_para_mark, &iter);
4311
4312           text_view->first_para_pixels = adj->value - line_top;
4313         }
4314     }
4315
4316   if (GTK_WIDGET_REALIZED (text_view) && (dx != 0 || dy != 0))
4317     {
4318       if (dy != 0)
4319         {
4320           if (text_view->left_window)
4321             text_window_scroll (text_view->left_window, 0, dy);
4322           if (text_view->right_window)
4323             text_window_scroll (text_view->right_window, 0, dy);
4324         }
4325
4326       if (dx != 0)
4327         {
4328           if (text_view->top_window)
4329             text_window_scroll (text_view->top_window, dx, 0);
4330           if (text_view->bottom_window)
4331             text_window_scroll (text_view->bottom_window, dx, 0);
4332         }
4333
4334       /* It looks nicer to scroll the main area last, because
4335        * it takes a while, and making the side areas update
4336        * afterward emphasizes the slowness of scrolling the
4337        * main area.
4338        */
4339       text_window_scroll (text_view->text_window, dx, dy);
4340     }
4341 }
4342
4343 static void
4344 gtk_text_view_commit_handler (GtkIMContext  *context,
4345                               const gchar   *str,
4346                               GtkTextView   *text_view)
4347 {
4348   gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
4349                                     text_view->editable);
4350
4351   if (!strcmp (str, "\n"))
4352     {
4353       gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), "\n", 1,
4354                                                     text_view->editable);
4355     }
4356   else
4357     {
4358       if (text_view->overwrite_mode)
4359         gtk_text_view_delete_from_cursor (text_view, GTK_DELETE_CHARS, 1);
4360       gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1,
4361                                                     text_view->editable);
4362     }
4363
4364   gtk_text_view_scroll_to_mark (text_view,
4365                                 gtk_text_buffer_get_mark (get_buffer (text_view),
4366                                                           "insert"),
4367                                 0);
4368 }
4369
4370 static void
4371 gtk_text_view_preedit_changed_handler (GtkIMContext *context,
4372                                        GtkTextView  *text_view)
4373 {
4374   gchar *str;
4375   PangoAttrList *attrs;
4376   gint cursor_pos;
4377
4378   gtk_im_context_get_preedit_string (context, &str, &attrs, &cursor_pos);
4379   gtk_text_layout_set_preedit_string (text_view->layout, str, attrs, cursor_pos);
4380
4381   pango_attr_list_unref (attrs);
4382   g_free (str);
4383 }
4384
4385 static void
4386 gtk_text_view_mark_set_handler (GtkTextBuffer     *buffer,
4387                                 const GtkTextIter *location,
4388                                 GtkTextMark       *mark,
4389                                 gpointer           data)
4390 {
4391   GtkTextView *text_view = GTK_TEXT_VIEW (data);
4392   gboolean need_reset = FALSE;
4393
4394   if (mark == gtk_text_buffer_get_insert (buffer))
4395     {
4396       text_view->virtual_cursor_x = -1;
4397       text_view->virtual_cursor_y = -1;
4398       need_reset = TRUE;
4399     }
4400   else if (mark == gtk_text_buffer_get_selection_bound (buffer))
4401     {
4402       need_reset = TRUE;
4403     }
4404
4405   if (need_reset)
4406     gtk_text_view_reset_im_context (text_view);
4407 }
4408
4409 static void
4410 gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view,
4411                                       gint        *x,
4412                                       gint        *y)
4413 {
4414   GdkRectangle strong_pos;
4415   GtkTextIter insert;
4416
4417   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
4418                                     gtk_text_buffer_get_mark (get_buffer (text_view),
4419                                                               "insert"));
4420
4421   if ((x && text_view->virtual_cursor_x == -1) ||
4422       (y && text_view->virtual_cursor_y == -1))
4423     gtk_text_layout_get_cursor_locations (text_view->layout, &insert, &strong_pos, NULL);
4424
4425   if (x)
4426     {
4427       if (text_view->virtual_cursor_x != -1)
4428         *x = text_view->virtual_cursor_x;
4429       else
4430         *x = strong_pos.x;
4431     }
4432
4433   if (y)
4434     {
4435       if (text_view->virtual_cursor_x != -1)
4436         *y = text_view->virtual_cursor_y;
4437       else
4438         *y = strong_pos.y + strong_pos.height / 2;
4439     }
4440 }
4441
4442 static void
4443 gtk_text_view_set_virtual_cursor_pos (GtkTextView *text_view,
4444                                       gint         x,
4445                                       gint         y)
4446 {
4447   GdkRectangle strong_pos;
4448   GtkTextIter insert;
4449
4450   gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
4451                                     gtk_text_buffer_get_mark (get_buffer (text_view),
4452                                                               "insert"));
4453
4454   if (x == -1 || y == -1)
4455     gtk_text_layout_get_cursor_locations (text_view->layout, &insert, &strong_pos, NULL);
4456
4457   text_view->virtual_cursor_x = (x == -1) ? strong_pos.x : x;
4458   text_view->virtual_cursor_y = (y == -1) ? strong_pos.y + strong_pos.height / 2 : y;
4459 }
4460
4461 /* Quick hack of a popup menu
4462  */
4463 static void
4464 activate_cb (GtkWidget   *menuitem,
4465              GtkTextView *text_view)
4466 {
4467   const gchar *signal = gtk_object_get_data (GTK_OBJECT (menuitem), "gtk-signal");
4468   gtk_signal_emit_by_name (GTK_OBJECT (text_view), signal);
4469 }
4470
4471 static void
4472 append_action_signal (GtkTextView  *text_view,
4473                       GtkWidget    *menu,
4474                       const gchar  *label,
4475                       const gchar  *signal)
4476 {
4477   GtkWidget *menuitem = gtk_menu_item_new_with_label (label);
4478
4479   gtk_object_set_data (GTK_OBJECT (menuitem), "gtk-signal", (char *)signal);
4480   gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
4481                       activate_cb, text_view);
4482
4483   gtk_widget_show (menuitem);
4484   gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
4485 }
4486
4487 static void
4488 popup_menu_detach (GtkWidget *attach_widget,
4489                    GtkMenu   *menu)
4490 {
4491   GTK_TEXT_VIEW (attach_widget)->popup_menu = NULL;
4492 }
4493
4494 static void
4495 gtk_text_view_popup_menu (GtkTextView    *text_view,
4496                           GdkEventButton *event)
4497 {
4498   if (!text_view->popup_menu)
4499     {
4500       GtkWidget *menuitem;
4501
4502       text_view->popup_menu = gtk_menu_new ();
4503
4504       gtk_menu_attach_to_widget (GTK_MENU (text_view->popup_menu),
4505                                  GTK_WIDGET (text_view),
4506                                  popup_menu_detach);
4507
4508       append_action_signal (text_view, text_view->popup_menu, _("Cut"), "cut_clipboard");
4509       append_action_signal (text_view, text_view->popup_menu, _("Copy"), "copy_clipboard");
4510       append_action_signal (text_view, text_view->popup_menu, _("Paste"), "paste_clipboard");
4511
4512       menuitem = gtk_menu_item_new (); /* Separator */
4513       gtk_widget_show (menuitem);
4514       gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
4515
4516       gtk_im_multicontext_append_menuitems (GTK_IM_MULTICONTEXT (text_view->im_context),
4517                                             GTK_MENU_SHELL (text_view->popup_menu));
4518     }
4519
4520   gtk_menu_popup (GTK_MENU (text_view->popup_menu), NULL, NULL,
4521                   NULL, NULL,
4522                   event->button, event->time);
4523 }
4524
4525
4526
4527 /* Child GdkWindows */
4528
4529
4530 static GtkTextWindow*
4531 text_window_new (GtkTextWindowType  type,
4532                  GtkWidget         *widget,
4533                  gint               width_request,
4534                  gint               height_request)
4535 {
4536   GtkTextWindow *win;
4537
4538   win = g_new (GtkTextWindow, 1);
4539
4540   win->type = type;
4541   win->widget = widget;
4542   win->window = NULL;
4543   win->bin_window = NULL;
4544   win->requisition.width = width_request;
4545   win->requisition.height = height_request;
4546   win->allocation.width = width_request;
4547   win->allocation.height = height_request;
4548   win->allocation.x = 0;
4549   win->allocation.y = 0;
4550
4551   return win;
4552 }
4553
4554 static void
4555 text_window_free (GtkTextWindow *win)
4556 {
4557   if (win->window)
4558     text_window_unrealize (win);
4559
4560   g_free (win);
4561 }
4562
4563 static void
4564 text_window_realize (GtkTextWindow *win,
4565                      GdkWindow     *parent)
4566 {
4567   GdkWindowAttr attributes;
4568   gint attributes_mask;
4569   GdkCursor *cursor;
4570
4571   attributes.window_type = GDK_WINDOW_CHILD;
4572   attributes.x = win->allocation.x;
4573   attributes.y = win->allocation.y;
4574   attributes.width = win->allocation.width;
4575   attributes.height = win->allocation.height;
4576   attributes.wclass = GDK_INPUT_OUTPUT;
4577   attributes.visual = gtk_widget_get_visual (win->widget);
4578   attributes.colormap = gtk_widget_get_colormap (win->widget);
4579   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
4580
4581   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
4582
4583   win->window = gdk_window_new (parent,
4584                                 &attributes,
4585                                 attributes_mask);
4586
4587   gdk_window_show (win->window);
4588   gdk_window_set_user_data (win->window, win->widget);
4589
4590   attributes.x = 0;
4591   attributes.y = 0;
4592   attributes.width = win->allocation.width;
4593   attributes.height = win->allocation.height;
4594   attributes.event_mask = (GDK_EXPOSURE_MASK            |
4595                            GDK_SCROLL_MASK              |
4596                            GDK_KEY_PRESS_MASK           |
4597                            GDK_BUTTON_PRESS_MASK        |
4598                            GDK_BUTTON_RELEASE_MASK      |
4599                            GDK_POINTER_MOTION_MASK      |
4600                            GDK_POINTER_MOTION_HINT_MASK |
4601                            gtk_widget_get_events (win->widget));
4602
4603   win->bin_window = gdk_window_new (win->window,
4604                                     &attributes,
4605                                     attributes_mask);
4606
4607   gdk_window_show (win->bin_window);
4608   gdk_window_set_user_data (win->bin_window, win->widget);
4609
4610   if (win->type == GTK_TEXT_WINDOW_TEXT)
4611     {
4612       /* I-beam cursor */
4613       cursor = gdk_cursor_new (GDK_XTERM);
4614       gdk_window_set_cursor (win->bin_window, cursor);
4615       gdk_cursor_destroy (cursor);
4616
4617       gtk_im_context_set_client_window (GTK_TEXT_VIEW (win->widget)->im_context,
4618                                         win->window);
4619
4620
4621       gdk_window_set_background (win->bin_window,
4622                                  &win->widget->style->base[GTK_WIDGET_STATE (win->widget)]);
4623     }
4624   else
4625     {
4626       gdk_window_set_background (win->bin_window,
4627                                  &win->widget->style->bg[GTK_WIDGET_STATE (win->widget)]);
4628     }
4629
4630   g_object_set_qdata (G_OBJECT (win->window),
4631                       g_quark_from_static_string ("gtk-text-view-text-window"),
4632                       win);
4633
4634   g_object_set_qdata (G_OBJECT (win->bin_window),
4635                       g_quark_from_static_string ("gtk-text-view-text-window"),
4636                       win);
4637 }
4638
4639 static void
4640 text_window_unrealize (GtkTextWindow *win)
4641 {
4642   if (win->type == GTK_TEXT_WINDOW_TEXT)
4643     {
4644       gtk_im_context_set_client_window (GTK_TEXT_VIEW (win->widget)->im_context,
4645                                         NULL);
4646     }
4647
4648   gdk_window_set_user_data (win->window, NULL);
4649   gdk_window_set_user_data (win->bin_window, NULL);
4650   gdk_window_destroy (win->bin_window);
4651   gdk_window_destroy (win->window);
4652   win->window = NULL;
4653   win->bin_window = NULL;
4654 }
4655
4656 static void
4657 text_window_size_allocate (GtkTextWindow *win,
4658                            GdkRectangle  *rect)
4659 {
4660   win->allocation = *rect;
4661
4662   if (win->window)
4663     {
4664       gdk_window_move_resize (win->window,
4665                               rect->x, rect->y,
4666                               rect->width, rect->height);
4667
4668       gdk_window_resize (win->bin_window,
4669                          rect->width, rect->height);
4670     }
4671 }
4672
4673 static void
4674 text_window_scroll        (GtkTextWindow *win,
4675                            gint           dx,
4676                            gint           dy)
4677 {
4678   if (dx != 0 || dy != 0)
4679     {
4680       gdk_window_scroll (win->bin_window, dx, dy);
4681       gdk_window_process_updates (win->bin_window, TRUE);
4682     }
4683 }
4684
4685 static void
4686 text_window_invalidate_rect (GtkTextWindow *win,
4687                              GdkRectangle  *rect)
4688 {
4689   GdkRectangle window_rect;
4690
4691   gtk_text_view_buffer_to_window_coords (GTK_TEXT_VIEW (win->widget),
4692                                          win->type,
4693                                          rect->x,
4694                                          rect->y,
4695                                          &window_rect.x,
4696                                          &window_rect.y);
4697
4698   window_rect.width = rect->width;
4699   window_rect.height = rect->height;
4700
4701   /* Adjust the rect as appropriate */
4702
4703   switch (win->type)
4704     {
4705     case GTK_TEXT_WINDOW_TEXT:
4706       break;
4707
4708     case GTK_TEXT_WINDOW_LEFT:
4709     case GTK_TEXT_WINDOW_RIGHT:
4710       window_rect.x = 0;
4711       window_rect.width = win->allocation.width;
4712       break;
4713
4714     case GTK_TEXT_WINDOW_TOP:
4715     case GTK_TEXT_WINDOW_BOTTOM:
4716       window_rect.y = 0;
4717       window_rect.height = win->allocation.height;
4718       break;
4719
4720     default:
4721       g_warning ("%s: bug!", G_STRLOC);
4722       return;
4723       break;
4724     }
4725
4726   gdk_window_invalidate_rect (win->bin_window, &window_rect, FALSE);
4727 }
4728
4729 static gint
4730 text_window_get_width (GtkTextWindow *win)
4731 {
4732   return win->allocation.width;
4733 }
4734
4735 static gint
4736 text_window_get_height (GtkTextWindow *win)
4737 {
4738   return win->allocation.height;
4739 }
4740
4741 static void
4742 text_window_get_allocation (GtkTextWindow *win,
4743                             GdkRectangle  *rect)
4744 {
4745   *rect = win->allocation;
4746 }
4747
4748 /* Windows */
4749
4750
4751 /**
4752  * gtk_text_view_get_window:
4753  * @text_view: a #GtkTextView
4754  * @win: window to get
4755  *
4756  * Retrieves the #GdkWindow corresponding to an area of the text view;
4757  * possible windows include the overall widget window, child windows
4758  * on the left, right, top, bottom, and the window that displays the
4759  * text buffer. Windows are %NULL and nonexistent if their width or
4760  * height is 0, and are nonexistent before the widget has been
4761  * realized.
4762  *
4763  * Return value: a #GdkWindow, or %NULL
4764  **/
4765 GdkWindow*
4766 gtk_text_view_get_window (GtkTextView *text_view,
4767                           GtkTextWindowType win)
4768 {
4769   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
4770
4771   switch (win)
4772     {
4773     case GTK_TEXT_WINDOW_WIDGET:
4774       return GTK_WIDGET (text_view)->window;
4775       break;
4776
4777     case GTK_TEXT_WINDOW_TEXT:
4778       return text_view->text_window->bin_window;
4779       break;
4780
4781     case GTK_TEXT_WINDOW_LEFT:
4782       if (text_view->left_window)
4783         return text_view->left_window->bin_window;
4784       else
4785         return NULL;
4786       break;
4787
4788     case GTK_TEXT_WINDOW_RIGHT:
4789       if (text_view->right_window)
4790         return text_view->right_window->bin_window;
4791       else
4792         return NULL;
4793       break;
4794
4795     case GTK_TEXT_WINDOW_TOP:
4796       if (text_view->top_window)
4797         return text_view->top_window->bin_window;
4798       else
4799         return NULL;
4800       break;
4801
4802     case GTK_TEXT_WINDOW_BOTTOM:
4803       if (text_view->bottom_window)
4804         return text_view->bottom_window->bin_window;
4805       else
4806         return NULL;
4807       break;
4808
4809     default:
4810       g_warning ("%s: Unknown GtkTextWindowType", G_STRLOC);
4811       return NULL;
4812       break;
4813     }
4814 }
4815
4816 /**
4817  * gtk_text_view_get_window_type:
4818  * @text_view: a #GtkTextView
4819  * @window: a window type
4820  *
4821  * Usually used to find out which window an event corresponds to.
4822  * If you connect to an event signal on @text_view, this function
4823  * should be called on <literal>event-&gt;window</literal> to
4824  * see which window it was.
4825  *
4826  * Return value: the window type.
4827  **/
4828 GtkTextWindowType
4829 gtk_text_view_get_window_type (GtkTextView *text_view,
4830                                GdkWindow   *window)
4831 {
4832   GtkTextWindow *win;
4833
4834   g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
4835   g_return_val_if_fail (GDK_IS_WINDOW (text_view), 0);
4836
4837   if (window == GTK_WIDGET (text_view)->window)
4838     return GTK_TEXT_WINDOW_WIDGET;
4839
4840   win = g_object_get_qdata (G_OBJECT (window),
4841                             g_quark_try_string ("gtk-text-view-text-window"));
4842
4843   if (win)
4844     return win->type;
4845   else
4846     {
4847       return GTK_TEXT_WINDOW_PRIVATE;
4848     }
4849 }
4850
4851 static void
4852 buffer_to_widget (GtkTextView      *text_view,
4853                   gint              buffer_x,
4854                   gint              buffer_y,
4855                   gint             *window_x,
4856                   gint             *window_y)
4857 {
4858   if (window_x)
4859     {
4860       *window_x = buffer_x - text_view->xoffset + FOCUS_EDGE_WIDTH;
4861       if (text_view->left_window)
4862         *window_x += text_view->left_window->allocation.width;
4863     }
4864
4865   if (window_y)
4866     {
4867       *window_y = buffer_y - text_view->yoffset + FOCUS_EDGE_WIDTH;
4868       if (text_view->top_window)
4869         *window_y += text_view->top_window->allocation.height;
4870     }
4871 }
4872
4873 static void
4874 widget_to_text_window (GtkTextWindow *win,
4875                        gint           widget_x,
4876                        gint           widget_y,
4877                        gint          *window_x,
4878                        gint          *window_y)
4879 {
4880   if (window_x)
4881     *window_x = widget_x - win->allocation.x;
4882
4883   if (window_y)
4884     *window_y = widget_y - win->allocation.y;
4885 }
4886
4887 static void
4888 buffer_to_text_window (GtkTextView   *text_view,
4889                        GtkTextWindow *win,
4890                        gint           buffer_x,
4891                        gint           buffer_y,
4892                        gint          *window_x,
4893                        gint          *window_y)
4894 {
4895   if (win == NULL)
4896     {
4897       g_warning ("Attempt to convert text buffer coordinates to coordinates "
4898                  "for a nonexistent or private child window of GtkTextView");
4899       return;
4900     }
4901
4902   buffer_to_widget (text_view,
4903                     buffer_x, buffer_y,
4904                     window_x, window_y);
4905
4906   widget_to_text_window (win,
4907                          window_x ? *window_x : 0,
4908                          window_y ? *window_y : 0,
4909                          window_x,
4910                          window_y);
4911 }
4912
4913 /**
4914  * gtk_text_view_buffer_to_window_coords:
4915  * @text_view: a #GtkTextView
4916  * @win: a #GtkTextWindowType
4917  * @buffer_x: buffer x coordinate
4918  * @buffer_y: buffer y coordinate
4919  * @window_x: window x coordinate return location
4920  * @window_y: window y coordinate return location
4921  *
4922  * Converts coordinate (@buffer_x, @buffer_y) to coordinates for the window
4923  * @win, and stores the result in (@window_x, @window_y).
4924  **/
4925 void
4926 gtk_text_view_buffer_to_window_coords (GtkTextView      *text_view,
4927                                        GtkTextWindowType win,
4928                                        gint              buffer_x,
4929                                        gint              buffer_y,
4930                                        gint             *window_x,
4931                                        gint             *window_y)
4932 {
4933   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
4934
4935   switch (win)
4936     {
4937     case GTK_TEXT_WINDOW_WIDGET:
4938       buffer_to_widget (text_view,
4939                         buffer_x, buffer_y,
4940                         window_x, window_y);
4941       break;
4942
4943     case GTK_TEXT_WINDOW_TEXT:
4944       if (window_x)
4945         *window_x = buffer_x - text_view->xoffset;
4946       if (window_y)
4947         *window_y = buffer_y - text_view->yoffset;
4948       break;
4949
4950     case GTK_TEXT_WINDOW_LEFT:
4951       buffer_to_text_window (text_view,
4952                              text_view->left_window,
4953                              buffer_x, buffer_y,
4954                              window_x, window_y);
4955       break;
4956
4957     case GTK_TEXT_WINDOW_RIGHT:
4958       buffer_to_text_window (text_view,
4959                              text_view->right_window,
4960                              buffer_x, buffer_y,
4961                              window_x, window_y);
4962       break;
4963
4964     case GTK_TEXT_WINDOW_TOP:
4965       buffer_to_text_window (text_view,
4966                              text_view->top_window,
4967                              buffer_x, buffer_y,
4968                              window_x, window_y);
4969       break;
4970
4971     case GTK_TEXT_WINDOW_BOTTOM:
4972       buffer_to_text_window (text_view,
4973                              text_view->bottom_window,
4974                              buffer_x, buffer_y,
4975                              window_x, window_y);
4976       break;
4977
4978     case GTK_TEXT_WINDOW_PRIVATE:
4979       g_warning ("%s: can't get coords for private windows", G_STRLOC);
4980       break;
4981
4982     default:
4983       g_warning ("%s: Unknown GtkTextWindowType", G_STRLOC);
4984       break;
4985     }
4986 }
4987
4988 static void
4989 widget_to_buffer (GtkTextView *text_view,
4990                   gint         widget_x,
4991                   gint         widget_y,
4992                   gint        *buffer_x,
4993                   gint        *buffer_y)
4994 {
4995   if (buffer_x)
4996     {
4997       *buffer_x = widget_x - FOCUS_EDGE_WIDTH + text_view->xoffset;
4998       if (text_view->left_window)
4999         *buffer_x -= text_view->left_window->allocation.width;
5000     }
5001
5002   if (buffer_y)
5003     {
5004       *buffer_y = widget_y - FOCUS_EDGE_WIDTH + text_view->yoffset;
5005       if (text_view->top_window)
5006         *buffer_y -= text_view->top_window->allocation.height;
5007     }
5008 }
5009
5010 static void
5011 text_window_to_widget (GtkTextWindow *win,
5012                        gint           window_x,
5013                        gint           window_y,
5014                        gint          *widget_x,
5015                        gint          *widget_y)
5016 {
5017   if (widget_x)
5018     *widget_x = window_x + win->allocation.x;
5019
5020   if (widget_y)
5021     *widget_y = window_y + win->allocation.y;
5022 }
5023
5024 static void
5025 text_window_to_buffer (GtkTextView   *text_view,
5026                        GtkTextWindow *win,
5027                        gint           window_x,
5028                        gint           window_y,
5029                        gint          *buffer_x,
5030                        gint          *buffer_y)
5031 {
5032   if (win == NULL)
5033     {
5034       g_warning ("Attempt to convert GtkTextView buffer coordinates into "
5035                  "coordinates for a nonexistent child window.");
5036       return;
5037     }
5038
5039   text_window_to_widget (win,
5040                          window_x,
5041                          window_y,
5042                          buffer_x,
5043                          buffer_y);
5044
5045   widget_to_buffer (text_view,
5046                     buffer_x ? *buffer_x : 0,
5047                     buffer_y ? *buffer_y : 0,
5048                     buffer_x,
5049                     buffer_y);
5050 }
5051
5052 /**
5053  * gtk_text_view_window_to_buffer_coords:
5054  * @text_view: a #GtkTextView
5055  * @win: a #GtkTextWindowType
5056  * @window_x: window x coordinate
5057  * @window_y: window y coordinate
5058  * @buffer_x: buffer x coordinate return location
5059  * @buffer_y: buffer y coordinate return location
5060  *
5061  * Converts coordinates on the window identified by @win to buffer
5062  * coordinates, storing the result in (@buffer_x,@buffer_y).
5063  **/
5064 void
5065 gtk_text_view_window_to_buffer_coords (GtkTextView      *text_view,
5066                                        GtkTextWindowType win,
5067                                        gint              window_x,
5068                                        gint              window_y,
5069                                        gint             *buffer_x,
5070                                        gint             *buffer_y)
5071 {
5072   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5073
5074   switch (win)
5075     {
5076     case GTK_TEXT_WINDOW_WIDGET:
5077       widget_to_buffer (text_view,
5078                         window_x, window_y,
5079                         buffer_x, buffer_y);
5080       break;
5081
5082     case GTK_TEXT_WINDOW_TEXT:
5083       if (buffer_x)
5084         *buffer_x = window_x + text_view->xoffset;
5085       if (buffer_y)
5086         *buffer_y = window_y + text_view->yoffset;
5087       break;
5088
5089     case GTK_TEXT_WINDOW_LEFT:
5090       text_window_to_buffer (text_view,
5091                              text_view->left_window,
5092                              window_x, window_y,
5093                              buffer_x, buffer_y);
5094       break;
5095
5096     case GTK_TEXT_WINDOW_RIGHT:
5097       text_window_to_buffer (text_view,
5098                              text_view->right_window,
5099                              window_x, window_y,
5100                              buffer_x, buffer_y);
5101       break;
5102
5103     case GTK_TEXT_WINDOW_TOP:
5104       text_window_to_buffer (text_view,
5105                              text_view->top_window,
5106                              window_x, window_y,
5107                              buffer_x, buffer_y);
5108       break;
5109
5110     case GTK_TEXT_WINDOW_BOTTOM:
5111       text_window_to_buffer (text_view,
5112                              text_view->bottom_window,
5113                              window_x, window_y,
5114                              buffer_x, buffer_y);
5115       break;
5116
5117     case GTK_TEXT_WINDOW_PRIVATE:
5118       g_warning ("%s: can't get coords for private windows", G_STRLOC);
5119       break;
5120
5121     default:
5122       g_warning ("%s: Unknown GtkTextWindowType", G_STRLOC);
5123       break;
5124     }
5125 }
5126
5127 static void
5128 set_window_width (GtkTextView      *text_view,
5129                   gint              width,
5130                   GtkTextWindowType type,
5131                   GtkTextWindow   **winp)
5132 {
5133   if (width == 0)
5134     {
5135       if (*winp)
5136         {
5137           text_window_free (*winp);
5138           *winp = NULL;
5139           gtk_widget_queue_resize (GTK_WIDGET (text_view));
5140         }
5141     }
5142   else
5143     {
5144       if (*winp == NULL)
5145         {
5146           *winp = text_window_new (type,
5147                                    GTK_WIDGET (text_view),
5148                                    width, 0);
5149         }
5150       else
5151         {
5152           if ((*winp)->requisition.width == width)
5153             return;
5154         }
5155
5156       gtk_widget_queue_resize (GTK_WIDGET (text_view));
5157     }
5158 }
5159
5160
5161 static void
5162 set_window_height (GtkTextView      *text_view,
5163                    gint              height,
5164                    GtkTextWindowType type,
5165                    GtkTextWindow   **winp)
5166 {
5167   if (height == 0)
5168     {
5169       if (*winp)
5170         {
5171           text_window_free (*winp);
5172           *winp = NULL;
5173           gtk_widget_queue_resize (GTK_WIDGET (text_view));
5174         }
5175     }
5176   else
5177     {
5178       if (*winp == NULL)
5179         {
5180           *winp = text_window_new (type,
5181                                    GTK_WIDGET (text_view),
5182                                    0, height);
5183         }
5184       else
5185         {
5186           if ((*winp)->requisition.height == height)
5187             return;
5188         }
5189
5190       gtk_widget_queue_resize (GTK_WIDGET (text_view));
5191     }
5192 }
5193
5194 /**
5195  * gtk_text_view_set_border_window_size:
5196  * @text_view: a #GtkTextView
5197  * @type: window to affect
5198  * @size: width or height of the window
5199  *
5200  * Sets the width of %GTK_TEXT_WINDOW_LEFT or %GTK_TEXT_WINDOW_RIGHT,
5201  * or the height of %GTK_TEXT_WINDOW_TOP or %GTK_TEXT_WINDOW_BOTTOM.
5202  * Automatically destroys the corresponding window if the size is set to 0,
5203  * and creates the window if the size is set to non-zero.
5204  **/
5205 void
5206 gtk_text_view_set_border_window_size (GtkTextView      *text_view,
5207                                       GtkTextWindowType type,
5208                                       gint              size)
5209
5210 {
5211   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5212   g_return_if_fail (size >= 0);
5213   g_return_if_fail (type != GTK_TEXT_WINDOW_WIDGET);
5214   g_return_if_fail (type != GTK_TEXT_WINDOW_TEXT);
5215
5216   switch (type)
5217     {
5218     case GTK_TEXT_WINDOW_LEFT:
5219       set_window_width (text_view, size, GTK_TEXT_WINDOW_LEFT,
5220                         &text_view->left_window);
5221       break;
5222
5223     case GTK_TEXT_WINDOW_RIGHT:
5224       set_window_width (text_view, size, GTK_TEXT_WINDOW_RIGHT,
5225                         &text_view->right_window);
5226       break;
5227
5228     case GTK_TEXT_WINDOW_TOP:
5229       set_window_height (text_view, size, GTK_TEXT_WINDOW_TOP,
5230                          &text_view->top_window);
5231       break;
5232
5233     case GTK_TEXT_WINDOW_BOTTOM:
5234       set_window_height (text_view, size, GTK_TEXT_WINDOW_BOTTOM,
5235                          &text_view->bottom_window);
5236       break;
5237
5238     default:
5239       g_warning ("Can't set size of center or widget or private GtkTextWindowType in %s", G_STRLOC);
5240       break;
5241     }
5242 }
5243
5244 /**
5245  * gtk_text_view_set_text_window_size:
5246  * @text_view: a #GtkTextView
5247  * @width: a width in pixels
5248  * @height: a height in pixels
5249  *
5250  * Sets the size request for the main text window (%GTK_TEXT_WINDOW_TEXT).
5251  * If the widget gets more space than it requested, the main text window
5252  * will be larger than this.
5253  *
5254  **/
5255 void
5256 gtk_text_view_set_text_window_size (GtkTextView *text_view,
5257                                     gint         width,
5258                                     gint         height)
5259 {
5260   GtkTextWindow *win;
5261
5262   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5263   g_return_if_fail (width > 0);
5264   g_return_if_fail (height > 0);
5265
5266   win = text_view->text_window;
5267
5268   if (win->requisition.width == width &&
5269       win->requisition.height == height)
5270     return;
5271
5272   win->requisition.width = width;
5273   win->requisition.height = height;
5274
5275   gtk_widget_queue_resize (GTK_WIDGET (text_view));
5276 }
5277
5278 /*
5279  * Child widgets
5280  */
5281
5282 static GtkTextViewChild*
5283 text_view_child_new_anchored (GtkWidget          *child,
5284                               GtkTextChildAnchor *anchor,
5285                               GtkTextLayout      *layout)
5286 {
5287   GtkTextViewChild *vc;
5288
5289   vc = g_new (GtkTextViewChild, 1);
5290
5291   vc->widget = child;
5292   vc->anchor = anchor;
5293
5294   vc->from_top_of_line = 0;
5295   vc->from_left_of_buffer = 0;
5296
5297   g_object_ref (G_OBJECT (vc->widget));
5298   g_object_ref (G_OBJECT (vc->anchor));
5299
5300   gtk_object_set_data (GTK_OBJECT (child),
5301                        "gtk-text-view-child",
5302                        vc);
5303
5304   gtk_text_child_anchor_register_child (anchor, child, layout);
5305
5306   return vc;
5307 }
5308
5309 static GtkTextViewChild*
5310 text_view_child_new_window (GtkWidget          *child,
5311                             GtkTextWindowType   type,
5312                             gint                x,
5313                             gint                y)
5314 {
5315   GtkTextViewChild *vc;
5316
5317   vc = g_new (GtkTextViewChild, 1);
5318
5319   vc->widget = child;
5320   vc->anchor = NULL;
5321
5322   vc->from_top_of_line = 0;
5323   vc->from_left_of_buffer = 0;
5324
5325   g_object_ref (G_OBJECT (vc->widget));
5326
5327   vc->type = type;
5328   vc->x = x;
5329   vc->y = y;
5330
5331   return vc;
5332 }
5333
5334 static void
5335 text_view_child_free (GtkTextViewChild *child)
5336 {
5337
5338   gtk_object_remove_data (GTK_OBJECT (child->widget),
5339                           "gtk-text-view-child");
5340
5341   if (child->anchor)
5342     {
5343       gtk_text_child_anchor_unregister_child (child->anchor,
5344                                               child->widget);
5345       g_object_unref (G_OBJECT (child->anchor));
5346     }
5347
5348   g_object_unref (G_OBJECT (child->widget));
5349
5350   g_free (child);
5351 }
5352
5353 static void
5354 text_view_child_realize (GtkTextView      *text_view,
5355                          GtkTextViewChild *vc)
5356 {
5357   if (vc->anchor)
5358     gtk_widget_set_parent_window (vc->widget,
5359                                   text_view->text_window->bin_window);
5360   else
5361     {
5362       GdkWindow *window;
5363       window = gtk_text_view_get_window (text_view,
5364                                          vc->type);
5365       gtk_widget_set_parent_window (vc->widget, window);
5366     }
5367
5368   gtk_widget_realize (vc->widget);
5369 }
5370
5371 static void
5372 add_child (GtkTextView      *text_view,
5373            GtkTextViewChild *vc)
5374 {
5375   text_view->children = g_slist_prepend (text_view->children,
5376                                          vc);
5377
5378   gtk_widget_set_parent (vc->widget, GTK_WIDGET (text_view));
5379
5380   if (GTK_WIDGET_REALIZED (text_view))
5381     text_view_child_realize (text_view, vc);
5382
5383   if (GTK_WIDGET_VISIBLE (text_view) && GTK_WIDGET_VISIBLE (vc->widget))
5384     {
5385       if (GTK_WIDGET_MAPPED (text_view))
5386         gtk_widget_map (vc->widget);
5387
5388       gtk_widget_queue_resize (vc->widget);
5389     }
5390 }
5391
5392 void
5393 gtk_text_view_add_child_at_anchor (GtkTextView          *text_view,
5394                                    GtkWidget            *child,
5395                                    GtkTextChildAnchor   *anchor)
5396 {
5397   GtkTextViewChild *vc;
5398
5399   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5400   g_return_if_fail (GTK_IS_WIDGET (child));
5401   g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
5402   g_return_if_fail (child->parent == NULL);
5403
5404   gtk_text_view_ensure_layout (text_view);
5405
5406   vc = text_view_child_new_anchored (child, anchor,
5407                                      text_view->layout);
5408
5409   add_child (text_view, vc);
5410 }
5411
5412 void
5413 gtk_text_view_add_child_in_window (GtkTextView          *text_view,
5414                                    GtkWidget            *child,
5415                                    GtkTextWindowType     which_window,
5416                                    gint                  xpos,
5417                                    gint                  ypos)
5418 {
5419   GtkTextViewChild *vc;
5420
5421   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5422   g_return_if_fail (GTK_IS_WIDGET (child));
5423   g_return_if_fail (xpos >= 0);
5424   g_return_if_fail (ypos >= 0);
5425   g_return_if_fail (child->parent == NULL);
5426
5427   vc = text_view_child_new_window (child, which_window,
5428                                    xpos, ypos);
5429
5430   add_child (text_view, vc);
5431 }
5432
5433 void
5434 gtk_text_view_move_child          (GtkTextView          *text_view,
5435                                    GtkWidget            *child,
5436                                    gint                  xpos,
5437                                    gint                  ypos)
5438 {
5439   GtkTextViewChild *vc;
5440
5441   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
5442   g_return_if_fail (GTK_IS_WIDGET (child));
5443   g_return_if_fail (xpos >= 0);
5444   g_return_if_fail (ypos >= 0);
5445   g_return_if_fail (child->parent == (GtkWidget*) text_view);
5446
5447   vc = gtk_object_get_data (GTK_OBJECT (child),
5448                             "gtk-text-view-child");
5449
5450   g_assert (vc != NULL);
5451
5452   vc->x = xpos;
5453   vc->y = ypos;
5454
5455   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (text_view))
5456     gtk_widget_queue_resize (child);
5457 }
5458
5459