/* Interface code for dealing with text properties.
- Copyright (C) 1993, 1994, 1995, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1993, 1994, 1995, 1997, 1999 Free Software Foundation, Inc.
This file is part of GNU Emacs.
necessary for the system to remain consistent. This requirement
is enforced by the subrs installing properties onto the intervals. */
-/* The rest of the file is within this conditional */
-#ifdef USE_TEXT_PROPERTIES
\f
/* Types of hooks. */
Lisp_Object Qmouse_left;
/* Visual properties text (including strings) may have. */
Lisp_Object Qforeground, Qbackground, Qfont, Qunderline, Qstipple;
-Lisp_Object Qinvisible, Qread_only, Qintangible;
+Lisp_Object Qinvisible, Qread_only, Qintangible, Qmouse_face;
/* Sticky properties */
Lisp_Object Qfront_sticky, Qrear_nonsticky;
/* If o1 is a cons whose cdr is a cons, return non-zero and set o2 to
the o1's cdr. Otherwise, return zero. This is handy for
traversing plists. */
-#define PLIST_ELT_P(o1, o2) (CONSP (o1) && ((o2)=XCONS (o1)->cdr, CONSP (o2)))
+#define PLIST_ELT_P(o1, o2) (CONSP (o1) && ((o2)=XCDR (o1), CONSP (o2)))
Lisp_Object Vinhibit_point_motion_hooks;
Lisp_Object Vdefault_text_properties;
+Lisp_Object Vtext_property_default_nonsticky;
/* verify_interval_modification saves insertion hooks here
to be run later by report_interval_modification. */
#define soft 0
#define hard 1
-static INTERVAL
+INTERVAL
validate_interval_range (object, begin, end, force)
Lisp_Object object, *begin, *end;
int force;
Lisp_Object plist;
INTERVAL i;
{
- register Lisp_Object tail1, tail2, sym1, sym2;
+ register Lisp_Object tail1, tail2, sym1;
register int found;
/* Go through each element of PLIST. */
Lisp_Object value;
while (PLIST_ELT_P (plist, value))
- if (EQ (XCONS (plist)->car, prop))
- return XCONS (value)->car;
+ if (EQ (XCAR (plist), prop))
+ return XCAR (value);
else
- plist = XCONS (value)->cdr;
+ plist = XCDR (value);
return Qunbound;
}
or has a different value in PROPERTIES, make an undo record. */
for (sym = interval->plist;
PLIST_ELT_P (sym, value);
- sym = XCONS (value)->cdr)
- if (! EQ (property_value (properties, XCONS (sym)->car),
- XCONS (value)->car))
+ sym = XCDR (value))
+ if (! EQ (property_value (properties, XCAR (sym)),
+ XCAR (value)))
{
record_property_change (interval->position, LENGTH (interval),
- XCONS (sym)->car, XCONS (value)->car,
+ XCAR (sym), XCAR (value),
object);
}
make an undo record binding it to nil, so it will be removed. */
for (sym = properties;
PLIST_ELT_P (sym, value);
- sym = XCONS (value)->cdr)
- if (EQ (property_value (interval->plist, XCONS (sym)->car), Qunbound))
+ sym = XCDR (value))
+ if (EQ (property_value (interval->plist, XCAR (sym)), Qunbound))
{
record_property_change (interval->position, LENGTH (interval),
- XCONS (sym)->car, Qnil,
+ XCAR (sym), Qnil,
object);
}
}
}
return Fprevious_property_change (position, Qnil, temp);
}
+
+
+DEFUN ("next-single-char-property-change", Fnext_single_char_property_change,
+ Snext_single_char_property_change, 2, 4, 0,
+ "Return the position of next text property or overlay change for a specific property.\n\
+Scans characters forward from POSITION till it finds\n\
+a change in the PROP property, then returns the position of the change.\n\
+The optional third argument OBJECT is the string or buffer to scan.\n\
+The property values are compared with `eq'.\n\
+Return nil if the property is constant all the way to the end of OBJECT.\n\
+If the value is non-nil, it is a position greater than POSITION, never equal.\n\n\
+If the optional fourth argument LIMIT is non-nil, don't search\n\
+past position LIMIT; return LIMIT if nothing is found before LIMIT.")
+ (position, prop, object, limit)
+ Lisp_Object prop, position, object, limit;
+{
+ if (STRINGP (object))
+ {
+ position = Fnext_single_property_change (position, prop, object, limit);
+ if (NILP (position))
+ {
+ if (NILP (limit))
+ position = make_number (XSTRING (object)->size);
+ else
+ position = limit;
+ }
+ }
+ else
+ {
+ Lisp_Object initial_value, value;
+ int count = specpdl_ptr - specpdl;
+
+ if (! NILP (object))
+ CHECK_BUFFER (object, 0);
+
+ if (BUFFERP (object) && current_buffer != XBUFFER (object))
+ {
+ record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+ Fset_buffer (object);
+ }
+
+ initial_value = Fget_char_property (position, prop, object);
+
+ if (NILP (limit))
+ XSETFASTINT (limit, BUF_ZV (current_buffer));
+ else
+ CHECK_NUMBER_COERCE_MARKER (limit, 0);
+
+ for (;;)
+ {
+ position = Fnext_char_property_change (position, limit);
+ if (XFASTINT (position) >= XFASTINT (limit)) {
+ position = limit;
+ break;
+ }
+
+ value = Fget_char_property (position, prop, object);
+ if (!EQ (value, initial_value))
+ break;
+ }
+
+ unbind_to (count, Qnil);
+ }
+
+ return position;
+}
+
+DEFUN ("previous-single-char-property-change",
+ Fprevious_single_char_property_change,
+ Sprevious_single_char_property_change, 2, 4, 0,
+ "Return the position of previous text property or overlay change for a specific property.\n\
+Scans characters backward from POSITION till it finds\n\
+a change in the PROP property, then returns the position of the change.\n\
+The optional third argument OBJECT is the string or buffer to scan.\n\
+The property values are compared with `eq'.\n\
+Return nil if the property is constant all the way to the start of OBJECT.\n\
+If the value is non-nil, it is a position less than POSITION, never equal.\n\n\
+If the optional fourth argument LIMIT is non-nil, don't search\n\
+back past position LIMIT; return LIMIT if nothing is found before LIMIT.")
+ (position, prop, object, limit)
+ Lisp_Object prop, position, object, limit;
+{
+ if (STRINGP (object))
+ {
+ position = Fprevious_single_property_change (position, prop, object, limit);
+ if (NILP (position))
+ {
+ if (NILP (limit))
+ position = make_number (XSTRING (object)->size);
+ else
+ position = limit;
+ }
+ }
+ else
+ {
+ int count = specpdl_ptr - specpdl;
+
+ if (! NILP (object))
+ CHECK_BUFFER (object, 0);
+
+ if (BUFFERP (object) && current_buffer != XBUFFER (object))
+ {
+ record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+ Fset_buffer (object);
+ }
+
+ if (NILP (limit))
+ XSETFASTINT (limit, BUF_BEGV (current_buffer));
+ else
+ CHECK_NUMBER_COERCE_MARKER (limit, 0);
+
+ if (XFASTINT (position) <= XFASTINT (limit))
+ position = limit;
+ else
+ {
+ Lisp_Object initial_value =
+ Fget_char_property (make_number (XFASTINT (position) - 1),
+ prop, object);
+
+ for (;;)
+ {
+ position = Fprevious_char_property_change (position, limit);
+
+ if (XFASTINT (position) <= XFASTINT (limit))
+ {
+ position = limit;
+ break;
+ }
+ else
+ {
+ Lisp_Object value =
+ Fget_char_property (make_number (XFASTINT (position) - 1),
+ prop, object);
+
+ if (!EQ (value, initial_value))
+ break;
+ }
+ }
+ }
+
+ unbind_to (count, Qnil);
+ }
+
+ return position;
+}
\f
DEFUN ("next-property-change", Fnext_property_change,
Snext_property_change, 1, 3, 0,
is the string or buffer containing the text.")
(start, end, properties, object)
Lisp_Object start, end, properties, object;
+{
+ return set_text_properties (start, end, properties, object, Qt);
+}
+
+
+/* Replace properties of text from START to END with new list of
+ properties PROPERTIES. OBJECT is the buffer or string containing
+ the text. OBJECT nil means use the current buffer.
+ SIGNAL_AFTER_CHANGE_P nil means don't signal after changes. Value
+ is non-nil if properties were replaced; it is nil if there weren't
+ any properties to replace. */
+
+Lisp_Object
+set_text_properties (start, end, properties, object, signal_after_change_p)
+ Lisp_Object start, end, properties, object, signal_after_change_p;
{
register INTERVAL i, unchanged;
register INTERVAL prev_changed = NULL_INTERVAL;
register int s, len;
Lisp_Object ostart, oend;
- int have_modified = 0;
ostart = start;
oend = end;
copy_properties (unchanged, i);
i = split_interval_left (i, len);
set_properties (properties, i, object);
- if (BUFFERP (object))
+ if (BUFFERP (object) && !NILP (signal_after_change_p))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
if (LENGTH (i) == len)
{
- if (BUFFERP (object))
+ if (BUFFERP (object) && !NILP (signal_after_change_p))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
set_properties (properties, i, object);
if (!NULL_INTERVAL_P (prev_changed))
merge_interval_left (i);
- if (BUFFERP (object))
+ if (BUFFERP (object) && !NILP (signal_after_change_p))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
return Qt;
i = next_interval (i);
}
- if (BUFFERP (object))
+ if (BUFFERP (object) && !NILP (signal_after_change_p))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
return Qt;
return modified ? Qt : Qnil;
}
+
+
+/* Return a list representing the text properties of OBJECT between
+ START and END. if PROP is non-nil, report only on that property.
+ Each result list element has the form (S E PLIST), where S and E
+ are positions in OBJECT and PLIST is a property list containing the
+ text properties of OBJECT between S and E. Value is nil if OBJECT
+ doesn't contain text properties between START and END. */
+
+Lisp_Object
+text_property_list (object, start, end, prop)
+ Lisp_Object object, start, end, prop;
+{
+ struct interval *i;
+ Lisp_Object result;
+
+ result = Qnil;
+
+ i = validate_interval_range (object, &start, &end, soft);
+ if (!NULL_INTERVAL_P (i))
+ {
+ int s = XINT (start);
+ int e = XINT (end);
+
+ while (s < e)
+ {
+ int interval_end, len;
+ Lisp_Object plist;
+
+ interval_end = i->position + LENGTH (i);
+ if (interval_end > e)
+ interval_end = e;
+ len = interval_end - s;
+
+ plist = i->plist;
+
+ if (!NILP (prop))
+ for (; !NILP (plist); plist = Fcdr (Fcdr (plist)))
+ if (EQ (Fcar (plist), prop))
+ {
+ plist = Fcons (prop, Fcons (Fcar (Fcdr (plist)), Qnil));
+ break;
+ }
+
+ if (!NILP (plist))
+ result = Fcons (Fcons (make_number (s),
+ Fcons (make_number (s + len),
+ Fcons (plist, Qnil))),
+ result);
+
+ i = next_interval (i);
+ if (NULL_INTERVAL_P (i))
+ break;
+ s = i->position;
+ }
+ }
+
+ return result;
+}
+
+
+/* Add text properties to OBJECT from LIST. LIST is a list of triples
+ (START END PLIST), where START and END are positions and PLIST is a
+ property list containing the text properties to add. Adjust START
+ and END positions by DELTA before adding properties. Value is
+ non-zero if OBJECT was modified. */
+
+int
+add_text_properties_from_list (object, list, delta)
+ Lisp_Object object, list, delta;
+{
+ struct gcpro gcpro1, gcpro2;
+ int modified_p = 0;
+
+ GCPRO2 (list, object);
+
+ for (; CONSP (list); list = XCDR (list))
+ {
+ Lisp_Object item, start, end, plist, tem;
+
+ item = XCAR (list);
+ start = make_number (XINT (XCAR (item)) + XINT (delta));
+ end = make_number (XINT (XCAR (XCDR (item))) + XINT (delta));
+ plist = XCAR (XCDR (XCDR (item)));
+
+ tem = Fadd_text_properties (start, end, plist, object);
+ if (!NILP (tem))
+ modified_p = 1;
+ }
+
+ UNGCPRO;
+ return modified_p;
+}
+
+
+
+/* Modify end-points of ranges in LIST destructively. LIST is a list
+ as returned from text_property_list. Change end-points equal to
+ OLD_END to NEW_END. */
+
+void
+extend_property_ranges (list, old_end, new_end)
+ Lisp_Object list, old_end, new_end;
+{
+ for (; CONSP (list); list = XCDR (list))
+ {
+ Lisp_Object item, end;
+
+ item = XCAR (list);
+ end = XCAR (XCDR (item));
+
+ if (EQ (end, old_end))
+ XCAR (XCDR (item)) = new_end;
+ }
+}
+
+
\f
/* Call the modification hook functions in LIST, each with START and END. */
int start, end;
{
register INTERVAL intervals = BUF_INTERVALS (buf);
- register INTERVAL i, prev;
+ register INTERVAL i;
Lisp_Object hooks;
register Lisp_Object prev_mod_hooks;
Lisp_Object mod_hooks;
if (TMEM (Qread_only, tem)
|| (NILP (Fplist_get (i->plist, Qread_only))
&& TMEM (Qcategory, tem)))
- error ("Attempt to insert within read-only text");
+ Fsignal (Qtext_read_only, Qnil);
}
}
if (! TMEM (Qread_only, tem)
&& (! NILP (Fplist_get (prev->plist,Qread_only))
|| ! TMEM (Qcategory, tem)))
- error ("Attempt to insert within read-only text");
+ Fsignal (Qtext_read_only, Qnil);
}
}
}
if (TMEM (Qread_only, tem)
|| (NILP (Fplist_get (i->plist, Qread_only))
&& TMEM (Qcategory, tem)))
- error ("Attempt to insert within read-only text");
+ Fsignal (Qtext_read_only, Qnil);
tem = textget (prev->plist, Qrear_nonsticky);
if (! TMEM (Qread_only, tem)
&& (! NILP (Fplist_get (prev->plist, Qread_only))
|| ! TMEM (Qcategory, tem)))
- error ("Attempt to insert within read-only text");
+ Fsignal (Qtext_read_only, Qnil);
}
}
}
do
{
if (! INTERVAL_WRITABLE_P (i))
- error ("Attempt to modify read-only text");
+ Fsignal (Qtext_read_only, Qnil);
mod_hooks = textget (i->plist, Qmodification_hooks);
if (! NILP (mod_hooks) && ! EQ (mod_hooks, prev_mod_hooks))
This also inhibits the use of the `intangible' text property.");
Vinhibit_point_motion_hooks = Qnil;
+ DEFVAR_LISP ("text-property-default-nonsticky",
+ &Vtext_property_default_nonsticky,
+ "Alist of properties vs the corresponding non-stickinesses.\n\
+Each element has the form (PROPERTY . NONSTICKINESS).\n\
+\n\
+If a character in a buffer has PROPERTY, new text inserted adjacent to\n\
+the character doesn't inherit PROPERTY if NONSTICKINESS is non-nil,\n\
+inherits it if NONSTICKINESS is nil. The front-sticky and\n\
+rear-nonsticky properties of the character overrides NONSTICKINESS.");
+ Vtext_property_default_nonsticky = Qnil;
+
staticpro (&interval_insert_behind_hooks);
staticpro (&interval_insert_in_front_hooks);
interval_insert_behind_hooks = Qnil;
Qfront_sticky = intern ("front-sticky");
staticpro (&Qrear_nonsticky);
Qrear_nonsticky = intern ("rear-nonsticky");
+ staticpro (&Qmouse_face);
+ Qmouse_face = intern ("mouse-face");
/* Properties that text might use to specify certain actions */
defsubr (&Sget_char_property);
defsubr (&Snext_char_property_change);
defsubr (&Sprevious_char_property_change);
+ defsubr (&Snext_single_char_property_change);
+ defsubr (&Sprevious_single_char_property_change);
defsubr (&Snext_property_change);
defsubr (&Snext_single_property_change);
defsubr (&Sprevious_property_change);
/* defsubr (&Scopy_text_properties); */
}
-#else
-
-lose -- this shouldn't be compiled if USE_TEXT_PROPERTIES isn't defined
-
-#endif /* USE_TEXT_PROPERTIES */