Re: Something like `without-redisplay'?

[Alexander Shukaev]

>> (defmacro devil-without-window-hscroll
>>     (&rest body)
>>   "\
>> Execute BODY without horizontal scrolling in the selected window."
>>   (declare (debug  t)
>>            (indent defun))
>>   `(let ((hscroll (window-hscroll)))
>>      (set-window-hscroll (selected-window) 0)
>>      (unwind-protect
>>          (progn ,@body)
>>        (set-window-hscroll (selected-window) hscroll))))
>>
>> In brief, these are macros which somehow alter viewport (how window
>> views a buffer) temporarily and then restore it.
>
> I don't understand the need for that: since redisplay doesn't happen
> as long as the code runs, why would you need to manipulate the
> viewport like that during the execution, just to have it back by the
> time redisplay is about to happen?
>
>> For instance, if `auto-hscroll-mode' is on, should I fear that
>> `set-window-hscroll' will move point?  I personally, have not
>> experienced this problem, but still I want to know exactly what to
>> expect.  For example, would you recommend to wrap
>> `set-window-hscroll' into `save-excursion' or that would be
>> redundant?  By the way, the same would apply to vertical changes in
>> viewport (due to vertical scrolling, for example) as Emacs
>> auto-scrolls (moves point to keep it in viewport) by default.  Yet,
>> again, I've never experienced any problem with this too.
>
> In general, hscroll only scrolls if point goes out of view.  Vertical
> scroll can happen even with point is in view, under some rare
> situations.
>
> But again, I don't understand what you want to accomplish with these
> macros, so I cannot answer your questions yet.

This macro is not about redisplay.  I just found one corner case when
`evil-previous-visual-line' and `evil-next-visual-line' which are
based on `evil-line-move',

;; The purpose of this function is the provide line motions which
;; preserve the column. This is how `previous-line' and `next-line'
;; work, but unfortunately the behaviour is hard-coded: if and only if
;; the last command was `previous-line' or `next-line', the column is
;; preserved. Furthermore, in contrast to Vim, when we cannot go
;; further, those motions move point to the beginning resp. the end of
;; the line (we never want point to leave its column). The code here
;; comes from simple.el, and I hope it will work in future.
(defun evil-line-move (count &optional noerror)
  "A wrapper for line motions which conserves the column.
Signals an error at buffer boundaries unless NOERROR is non-nil."
  (cond
   (noerror
    (condition-case nil
        (evil-line-move count)
      (error nil)))
   (t
    (evil-signal-without-movement
      (setq this-command (if (>= count 0)
                             #'next-line
                           #'previous-line))
      (let ((opoint (point)))
        (condition-case err
            (with-no-warnings
              (funcall this-command (abs count)))
          ((beginning-of-buffer end-of-buffer)
           (let ((col (or goal-column
                          (if (consp temporary-goal-column)
                              (car temporary-goal-column)
                            temporary-goal-column))))
             (if line-move-visual
                 (vertical-motion (cons col 0))
               (line-move-finish col opoint (< count 0)))
             ;; Maybe we should just `ding'?
             (signal (car err) (cdr err))))))))))

behave incorrectly when window has non-zero horizontal scroll.  The
problem might be deep in how Emacs implements `next-line' or
`previous-line' or whatever.  But I found a solution, when I use
`evil-previous-visual-line' and `evil-next-visual-line' in my own
functions, I simply wrap their calls into the
`devil-without-window-hscroll' macro, so that during their execution
there is no horizontal scrolling.  What is important to me, is that
the point does not unintentionally move as a side effect of
`devil-without-window-hscroll'.  That was the question basically: can
the point move due to application of such macros?