Re: Overalays and point-entered

[Nathaniel Flath <flat0103@gmail.com>]

[-- Attachment #1.1: Type: text/plain, Size: 1538 bytes --]

I wrote a patch to add point-left and point-entered to overlays.  I ended up
adding the implementation in command_loop_1.  The patch is attached - let me
know if anything needs to be fixed.

Thanks,
Nathaniel Flath

On Mon, Sep 14, 2009 at 3:22 PM, Stefan Monnier <monnier@iro.umontreal.ca>wrote:

> > By cursor motion, do you mean such as the cursor_to function in
> terminal.c?
>
> No, not exactly.  I mean more generally to trigger the code based on the
> motion that happen from command to command.  It could mean a hook in
> something like cursor_to, but it could also mean a hook in
> command_loop_1 (along the lines of what's done with
> adjust_point_for_property.
>
> > Adding these hook to that function seems to behave similarly to when I
> add
> > them to the point motion commands,
>
> The different between point-motion and cursor-motion can only be seen
> for operations that do a lot of internal movement.
> E.g. diff-context->unified.  Point-motion hooks will be triggered many
> times during a run of diff-context->unified (and may accidentally cause
> it to fail) whereas cursor motion hooks should only be triggered once
> after the command is done, so it can't cause it to fail.
>
> > in that modes or commands that do not appear to move the cursor( any
> > mode that traverses the buffer) will still trigger the hooks.
>
> If such a hook is run a bit more often than strictly needed, it's
> usually not considered a bug (tho it is recognized as a misfeature).
> So it might still be acceptable.
>
>
>        Stefan
>

[-- Attachment #1.2: Type: text/html, Size: 2047 bytes --]

[-- Attachment #2: overlay-properties.patch --]
[-- Type: text/x-patch, Size: 2673 bytes --]

--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1970,5 +1970,63 @@ command_loop_1 ()

     finalize:

+      /* Run point-entered and point-left hooks for overlays */
+      if (NILP (Vinhibit_point_motion_hooks))
+        {
+          int i, j;
+          int noverlays_cur, noverlays_prev;
+          Lisp_Object *overlay_cur_vec;
+          Lisp_Object *overlay_prev_vec;
+          extern Lisp_Object Qpoint_entered, Qpoint_left, Qwindow;
+          Lisp_Object point_left, point_entered;
+          Lisp_Object overlay_window;
+
+          GET_OVERLAYS_AT (current_buffer->pt,
+                           overlay_cur_vec,
+                           noverlays_cur,
+                           NULL,
+                           0);
+          GET_OVERLAYS_AT (last_point_position,
+                           overlay_prev_vec,
+                           noverlays_prev,
+                           NULL,
+                           0);
+
+          /* Go through each overlay that overlapped last_point_position and
+             run it's point_left hook only if the current location is not
+             overlapped by that overlay. */
+          for (i = 0; i < noverlays_prev; i++)
+            {
+              for (j = 0; j < noverlays_cur; j++)
+                {
+                  if (overlay_prev_vec[i] == overlay_cur_vec[j])
+                    goto next_overlay;
+                }
+              point_left = Foverlay_get (overlay_prev_vec[i], Qpoint_left);
+              overlay_window = Foverlay_get (overlay_prev_vec[i], Qwindow);
+              if (!NILP (point_left)
+                  && (NILP (overlay_window)
+                      || !NILP (Feq (overlay_window, Fselected_window()))))
+                call2 (point_left,
+                       make_number (last_point_position),
+                       make_number (current_buffer->pt));
+
+            next_overlay:
+              i = i;
+            }
+
+          /* Run point_entered functions for all overlays overlapping the
+             current point */
+          for (i = 0; i < noverlays_cur; i++)
+            {
+              point_entered = Foverlay_get (overlay_cur_vec[i], Qpoint_entered);
+              overlay_window = Foverlay_get (overlay_cur_vec[i], Qwindow);
+              if (!NILP (point_entered)
+                  && (NILP (overlay_window)
+                      || !NILP (Feq (overlay_window, Fselected_window()))))
+                call2 (point_entered, make_number (last_point_position), make_number (current_buffer->pt));
+            }
+        }
+
       if (current_buffer == prev_buffer
 	  && last_point_position != PT
 	  && NILP (Vdisable_point_adjustment)