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

   1 /* gtktextmark.c - mark segments
   2  *
   3  * Copyright (c) 1994 The Regents of the University of California.
   4  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
   5  * Copyright (c) 2000      Red Hat, Inc.
   6  * Tk -> Gtk port by Havoc Pennington <hp@redhat.com>
   7  *
   8  * This software is copyrighted by the Regents of the University of
   9  * California, Sun Microsystems, Inc., and other parties.  The
  10  * following terms apply to all files associated with the software
  11  * unless explicitly disclaimed in individual files.
  12  *
  13  * The authors hereby grant permission to use, copy, modify,
  14  * distribute, and license this software and its documentation for any
  15  * purpose, provided that existing copyright notices are retained in
  16  * all copies and that this notice is included verbatim in any
  17  * distributions. No written agreement, license, or royalty fee is
  18  * required for any of the authorized uses.  Modifications to this
  19  * software may be copyrighted by their authors and need not follow
  20  * the licensing terms described here, provided that the new terms are
  21  * clearly indicated on the first page of each file where they apply.
  22  *
  23  * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY
  24  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
  25  * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION,
  26  * OR ANY DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED
  27  * OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
  30  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  31  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
  32  * NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS,
  33  * AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE
  34  * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  35  *
  36  * GOVERNMENT USE: If you are acquiring this software on behalf of the
  37  * U.S. government, the Government shall have only "Restricted Rights"
  38  * in the software and related documentation as defined in the Federal
  39  * Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
  40  * are acquiring the software on behalf of the Department of Defense,
  41  * the software shall be classified as "Commercial Computer Software"
  42  * and the Government shall have only "Restricted Rights" as defined
  43  * in Clause 252.227-7013 (c) (1) of DFARs.  Notwithstanding the
  44  * foregoing, the authors grant the U.S. Government and others acting
  45  * in its behalf permission to use and distribute the software in
  46  * accordance with the terms specified in this license.
  47  *
  48  */
  49
  50 #define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
  51 #include "config.h"
  52 #include "gtktextbtree.h"
  53 #include "gtkprivate.h"
  54 #include "gtkintl.h"
  55
  56
  57 /**
  58  * SECTION:gtktextmark
  59  * @Short_description: A position in the buffer preserved across buffer modifications
  60  * @Title: GtkTextMark
  61  *
  62  * You may wish to begin by reading the <link linkend="TextWidget">text widget
  63  * conceptual overview</link> which gives an overview of all the objects and data
  64  * types related to the text widget and how they work together.
  65  *
  66  * A #GtkTextMark is like a bookmark in a text buffer; it preserves a position in
  67  * the text. You can convert the mark to an iterator using
  68  * gtk_text_buffer_get_iter_at_mark(). Unlike iterators, marks remain valid across
  69  * buffer mutations, because their behavior is defined when text is inserted or
  70  * deleted. When text containing a mark is deleted, the mark remains in the
  71  * position originally occupied by the deleted text. When text is inserted at a
  72  * mark, a mark with <firstterm>left gravity</firstterm> will be moved to the
  73  * beginning of the newly-inserted text, and a mark with <firstterm>right
  74  * gravity</firstterm> will be moved to the end.
  75  *
  76  * <footnote>
  77  * "left" and "right" here refer to logical direction (left is the toward the start
  78  * of the buffer); in some languages such as Hebrew the logically-leftmost text is
  79  * not actually on the left when displayed.
  80  * </footnote>
  81  *
  82  * Marks are reference counted, but the reference count only controls the validity
  83  * of the memory; marks can be deleted from the buffer at any time with
  84  * gtk_text_buffer_delete_mark(). Once deleted from the buffer, a mark is
  85  * essentially useless.
  86  *
  87  * Marks optionally have names; these can be convenient to avoid passing the
  88  * #GtkTextMark object around.
  89  *
  90  * Marks are typically created using the gtk_text_buffer_create_mark() function.
  91  */
  92
  93
  94 static void gtk_text_mark_set_property (GObject         *object,
  95                                         guint            prop_id,
  96                                         const GValue    *value,
  97                                         GParamSpec      *pspec);
  98 static void gtk_text_mark_get_property (GObject         *object,
  99                                         guint            prop_id,
 100                                         GValue          *value,
 101                                         GParamSpec      *pspec);
 102 static void gtk_text_mark_finalize     (GObject         *object);
 103
 104 static GtkTextLineSegment *gtk_mark_segment_new (GtkTextMark *mark_obj);
 105
 106 G_DEFINE_TYPE (GtkTextMark, gtk_text_mark, G_TYPE_OBJECT)
 107
 108 enum {
 109   PROP_0,
 110   PROP_NAME,
 111   PROP_LEFT_GRAVITY
 112 };
 113
 114 static void
 115 gtk_text_mark_class_init (GtkTextMarkClass *klass)
 116 {
 117   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 118
 119   object_class->finalize = gtk_text_mark_finalize;
 120   object_class->set_property = gtk_text_mark_set_property;
 121   object_class->get_property = gtk_text_mark_get_property;
 122
 123   g_object_class_install_property (object_class,
 124                                    PROP_NAME,
 125                                    g_param_spec_string ("name",
 126                                                         P_("Name"),
 127                                                         P_("Mark name"),
 128                                                         NULL,
 129                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 130
 131   g_object_class_install_property (object_class,
 132                                    PROP_LEFT_GRAVITY,
 133                                    g_param_spec_boolean ("left-gravity",
 134                                                          P_("Left gravity"),
 135                                                          P_("Whether the mark has left gravity"),
 136                                                          FALSE,
 137                                                          GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 138 }
 139
 140 static void
 141 gtk_text_mark_init (GtkTextMark *mark)
 142 {
 143   mark->segment = gtk_mark_segment_new (mark);
 144 }
 145
 146 static void
 147 gtk_text_mark_finalize (GObject *obj)
 148 {
 149   GtkTextMark *mark;
 150   GtkTextLineSegment *seg;
 151
 152   mark = GTK_TEXT_MARK (obj);
 153
 154   seg = mark->segment;
 155
 156   if (seg)
 157     {
 158       if (seg->body.mark.tree != NULL)
 159         g_warning ("GtkTextMark being finalized while still in the buffer; "
 160                    "someone removed a reference they didn't own! Crash "
 161                    "impending");
 162
 163       g_free (seg->body.mark.name);
 164       g_free (seg);
 165
 166       mark->segment = NULL;
 167     }
 168
 169   /* chain parent_class' handler */
 170   G_OBJECT_CLASS (gtk_text_mark_parent_class)->finalize (obj);
 171 }
 172
 173 static void
 174 gtk_text_mark_set_property (GObject      *object,
 175                             guint         prop_id,
 176                             const GValue *value,
 177                             GParamSpec   *pspec)
 178 {
 179   gchar *tmp;
 180   GtkTextMark *mark = GTK_TEXT_MARK (object);
 181   GtkTextLineSegment *seg = mark->segment;
 182
 183   switch (prop_id)
 184     {
 185     case PROP_NAME:
 186       tmp = seg->body.mark.name;
 187       seg->body.mark.name = g_value_dup_string (value);
 188       g_free (tmp);
 189       break;
 190
 191     case PROP_LEFT_GRAVITY:
 192       if (g_value_get_boolean (value))
 193         seg->type = &gtk_text_left_mark_type;
 194       else
 195         seg->type = &gtk_text_right_mark_type;
 196       break;
 197
 198     default:
 199       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 200     }
 201 }
 202
 203 static void
 204 gtk_text_mark_get_property (GObject    *object,
 205                             guint       prop_id,
 206                             GValue     *value,
 207                             GParamSpec *pspec)
 208 {
 209   GtkTextMark *mark = GTK_TEXT_MARK (object);
 210
 211   switch (prop_id)
 212     {
 213     case PROP_NAME:
 214       g_value_set_string (value, gtk_text_mark_get_name (mark));
 215       break;
 216
 217     case PROP_LEFT_GRAVITY:
 218       g_value_set_boolean (value, gtk_text_mark_get_left_gravity (mark));
 219       break;
 220
 221     default:
 222       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 223     }
 224 }
 225
 226 /**
 227  * gtk_text_mark_new:
 228  * @name: (allow-none): mark name or %NULL
 229  * @left_gravity: whether the mark should have left gravity
 230  *
 231  * Creates a text mark. Add it to a buffer using gtk_text_buffer_add_mark().
 232  * If @name is %NULL, the mark is anonymous; otherwise, the mark can be
 233  * retrieved by name using gtk_text_buffer_get_mark(). If a mark has left
 234  * gravity, and text is inserted at the mark's current location, the mark
 235  * will be moved to the left of the newly-inserted text. If the mark has
 236  * right gravity (@left_gravity = %FALSE), the mark will end up on the
 237  * right of newly-inserted text. The standard left-to-right cursor is a
 238  * mark with right gravity (when you type, the cursor stays on the right
 239  * side of the text you're typing).
 240  *
 241  * Return value: new #GtkTextMark
 242  *
 243  * Since: 2.12
 244  **/
 245 GtkTextMark *
 246 gtk_text_mark_new (const gchar *name,
 247                    gboolean     left_gravity)
 248 {
 249   return g_object_new (GTK_TYPE_TEXT_MARK,
 250                        "name", name,
 251                        "left-gravity", left_gravity,
 252                        NULL);
 253 }
 254
 255 /**
 256  * gtk_text_mark_get_visible:
 257  * @mark: a #GtkTextMark
 258  *
 259  * Returns %TRUE if the mark is visible (i.e. a cursor is displayed
 260  * for it).
 261  *
 262  * Return value: %TRUE if visible
 263  **/
 264 gboolean
 265 gtk_text_mark_get_visible (GtkTextMark *mark)
 266 {
 267   GtkTextLineSegment *seg;
 268
 269   seg = mark->segment;
 270
 271   return seg->body.mark.visible;
 272 }
 273
 274 /**
 275  * gtk_text_mark_get_name:
 276  * @mark: a #GtkTextMark
 277  *
 278  * Returns the mark name; returns NULL for anonymous marks.
 279  *
 280  * Return value: mark name
 281  **/
 282 const char *
 283 gtk_text_mark_get_name (GtkTextMark *mark)
 284 {
 285   GtkTextLineSegment *seg;
 286
 287   seg = mark->segment;
 288
 289   return seg->body.mark.name;
 290 }
 291
 292 /**
 293  * gtk_text_mark_get_deleted:
 294  * @mark: a #GtkTextMark
 295  *
 296  * Returns %TRUE if the mark has been removed from its buffer
 297  * with gtk_text_buffer_delete_mark(). See gtk_text_buffer_add_mark()
 298  * for a way to add it to a buffer again.
 299  *
 300  * Return value: whether the mark is deleted
 301  **/
 302 gboolean
 303 gtk_text_mark_get_deleted (GtkTextMark *mark)
 304 {
 305   GtkTextLineSegment *seg;
 306
 307   g_return_val_if_fail (GTK_IS_TEXT_MARK (mark), FALSE);
 308
 309   seg = mark->segment;
 310
 311   if (seg == NULL)
 312     return TRUE;
 313
 314   return seg->body.mark.tree == NULL;
 315 }
 316
 317 /**
 318  * gtk_text_mark_get_buffer:
 319  * @mark: a #GtkTextMark
 320  *
 321  * Gets the buffer this mark is located inside,
 322  * or %NULL if the mark is deleted.
 323  *
 324  * Return value: (transfer none): the mark's #GtkTextBuffer
 325  **/
 326 GtkTextBuffer*
 327 gtk_text_mark_get_buffer (GtkTextMark *mark)
 328 {
 329   GtkTextLineSegment *seg;
 330
 331   g_return_val_if_fail (GTK_IS_TEXT_MARK (mark), NULL);
 332
 333   seg = mark->segment;
 334
 335   if (seg->body.mark.tree == NULL)
 336     return NULL;
 337   else
 338     return _gtk_text_btree_get_buffer (seg->body.mark.tree);
 339 }
 340
 341 /**
 342  * gtk_text_mark_get_left_gravity:
 343  * @mark: a #GtkTextMark
 344  *
 345  * Determines whether the mark has left gravity.
 346  *
 347  * Return value: %TRUE if the mark has left gravity, %FALSE otherwise
 348  **/
 349 gboolean
 350 gtk_text_mark_get_left_gravity (GtkTextMark *mark)
 351 {
 352   GtkTextLineSegment *seg;
 353
 354   g_return_val_if_fail (GTK_IS_TEXT_MARK (mark), FALSE);
 355
 356   seg = mark->segment;
 357
 358   return seg->type == &gtk_text_left_mark_type;
 359 }
 360
 361 /*
 362  * Macro that determines the size of a mark segment:
 363  */
 364
 365 #define MSEG_SIZE ((unsigned) (G_STRUCT_OFFSET (GtkTextLineSegment, body) \
 366         + sizeof (GtkTextMarkBody)))
 367
 368
 369 static GtkTextLineSegment *
 370 gtk_mark_segment_new (GtkTextMark *mark_obj)
 371 {
 372   GtkTextLineSegment *mark;
 373
 374   mark = (GtkTextLineSegment *) g_malloc0 (MSEG_SIZE);
 375   mark->body.mark.name = NULL;
 376   mark->type = &gtk_text_right_mark_type;
 377
 378   mark->byte_count = 0;
 379   mark->char_count = 0;
 380
 381   mark->body.mark.obj = mark_obj;
 382   mark_obj->segment = mark;
 383
 384   mark->body.mark.tree = NULL;
 385   mark->body.mark.line = NULL;
 386   mark->next = NULL;
 387
 388   mark->body.mark.visible = FALSE;
 389   mark->body.mark.not_deleteable = FALSE;
 390
 391   return mark;
 392 }
 393
 394 void
 395 _gtk_mark_segment_set_tree (GtkTextLineSegment *mark,
 396                             GtkTextBTree       *tree)
 397 {
 398   g_assert (mark->body.mark.tree == NULL);
 399   g_assert (mark->body.mark.obj != NULL);
 400
 401   mark->byte_count = 0;
 402   mark->char_count = 0;
 403
 404   mark->body.mark.tree = tree;
 405   mark->body.mark.line = NULL;
 406   mark->next = NULL;
 407
 408   mark->body.mark.not_deleteable = FALSE;
 409 }
 410
 411 static int                 mark_segment_delete_func  (GtkTextLineSegment *segPtr,
 412                                                       GtkTextLine        *line,
 413                                                       int                 treeGone);
 414 static GtkTextLineSegment *mark_segment_cleanup_func (GtkTextLineSegment *segPtr,
 415                                                       GtkTextLine        *line);
 416 static void                mark_segment_check_func   (GtkTextLineSegment *segPtr,
 417                                                       GtkTextLine        *line);
 418
 419
 420 /*
 421  * The following structures declare the "mark" segment types.
 422  * There are actually two types for marks, one with left gravity
 423  * and one with right gravity.  They are identical except for
 424  * their gravity property.
 425  */
 426
 427 const GtkTextLineSegmentClass gtk_text_right_mark_type = {
 428   "mark",                                               /* name */
 429   FALSE,                                                /* leftGravity */
 430   NULL,                                         /* splitFunc */
 431   mark_segment_delete_func,                             /* deleteFunc */
 432   mark_segment_cleanup_func,                            /* cleanupFunc */
 433   NULL,                                         /* lineChangeFunc */
 434   mark_segment_check_func                               /* checkFunc */
 435 };
 436
 437 const GtkTextLineSegmentClass gtk_text_left_mark_type = {
 438   "mark",                                               /* name */
 439   TRUE,                                         /* leftGravity */
 440   NULL,                                         /* splitFunc */
 441   mark_segment_delete_func,                             /* deleteFunc */
 442   mark_segment_cleanup_func,                            /* cleanupFunc */
 443   NULL,                                         /* lineChangeFunc */
 444   mark_segment_check_func                               /* checkFunc */
 445 };
 446
 447 /*
 448  *--------------------------------------------------------------
 449  *
 450  * mark_segment_delete_func --
 451  *
 452  *      This procedure is invoked by the text B-tree code whenever
 453  *      a mark lies in a range of characters being deleted.
 454  *
 455  * Results:
 456  *      Returns 1 to indicate that deletion has been rejected,
 457  *      or 0 otherwise
 458  *
 459  * Side effects:
 460  *      Frees mark if tree is going away
 461  *
 462  *--------------------------------------------------------------
 463  */
 464
 465 static gboolean
 466 mark_segment_delete_func (GtkTextLineSegment *seg,
 467                           GtkTextLine        *line,
 468                           gboolean            tree_gone)
 469 {
 470   if (tree_gone)
 471     {
 472       _gtk_text_btree_release_mark_segment (seg->body.mark.tree, seg);
 473       return FALSE;
 474     }
 475   else
 476     return TRUE;
 477 }
 478
 479 /*
 480  *--------------------------------------------------------------
 481  *
 482  * mark_segment_cleanup_func --
 483  *
 484  *      This procedure is invoked by the B-tree code whenever a
 485  *      mark segment is moved from one line to another.
 486  *
 487  * Results:
 488  *      None.
 489  *
 490  * Side effects:
 491  *      The line field of the segment gets updated.
 492  *
 493  *--------------------------------------------------------------
 494  */
 495
 496 static GtkTextLineSegment *
 497 mark_segment_cleanup_func (GtkTextLineSegment *seg,
 498                            GtkTextLine        *line)
 499 {
 500   /* not sure why Tk did this here and not in LineChangeFunc */
 501   seg->body.mark.line = line;
 502   return seg;
 503 }
 504
 505 /*
 506  *--------------------------------------------------------------
 507  *
 508  * mark_segment_check_func --
 509  *
 510  *      This procedure is invoked by the B-tree code to perform
 511  *      consistency checks on mark segments.
 512  *
 513  * Results:
 514  *      None.
 515  *
 516  * Side effects:
 517  *      The procedure panics if it detects anything wrong with
 518  *      the mark.
 519  *
 520  *--------------------------------------------------------------
 521  */
 522
 523 static void
 524 mark_segment_check_func (GtkTextLineSegment *seg,
 525                          GtkTextLine        *line)
 526 {
 527   if (seg->body.mark.line != line)
 528     g_error ("mark_segment_check_func: seg->body.mark.line bogus");
 529 }