--- /dev/null
+/* Indentation functions.
+ Copyright (C) 1995 Board of Trustees, University of Illinois.
+ Copyright (C) 1985, 1986, 1987, 1988, 1992, 1993, 1994, 1995
+ Free Software Foundation, Inc.
+
+This file is part of XEmacs.
+
+XEmacs is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+XEmacs is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with XEmacs; see the file COPYING. If not, write to
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* This file has been Mule-ized. */
+
+/* Synched up with: 19.30. Diverges significantly from FSF. */
+
+
+#include <config.h>
+#include "lisp.h"
+
+#include "buffer.h"
+#include "device.h"
+#include "extents.h"
+#include "faces.h"
+#include "frame.h"
+#include "glyphs.h"
+#include "insdel.h"
+#ifdef REGION_CACHE_NEEDS_WORK
+#include "region-cache.h"
+#endif
+#include "window.h"
+
+Lisp_Object Qcoerce;
+
+/* Indentation can insert tabs if this is non-zero;
+ otherwise always uses spaces */
+int indent_tabs_mode;
+
+/* Avoid recalculation by remembering things in these variables. */
+
+/* Last value returned by current_column.
+
+ Some things set last_known_column_point to -1
+ to mark the memoized value as invalid */
+static int last_known_column;
+
+/* Last buffer searched by current_column */
+static struct buffer *last_known_column_buffer;
+
+/* Value of point when current_column was called */
+static Bufpos last_known_column_point;
+
+/* Value of MODIFF when current_column was called */
+static int last_known_column_modified;
+
+static Bufpos
+last_visible_position (Bufpos pos, struct buffer *buf)
+{
+ Lisp_Object buffer;
+ Lisp_Object value;
+
+ XSETBUFFER (buffer, buf);
+ value = Fprevious_single_property_change (make_int (pos), Qinvisible,
+ buffer, Qnil);
+ if (NILP (value))
+ return 0; /* no visible position found */
+ else
+ /* #### bug bug bug!!! This will return the position of the beginning
+ of an invisible extent; this extent is very likely to be start-closed,
+ and thus the spaces inserted in `indent-to' will go inside the
+ invisible extent.
+
+ Not sure what the correct solution is here. Rethink indent-to? */
+ return XINT (value);
+}
+
+#ifdef REGION_CACHE_NEEDS_WORK
+
+/* Allocate or free the width run cache, as requested by the current
+ state of current_buffer's cache_long_line_scans variable. */
+static void
+width_run_cache_on_off (struct buffer *buf)
+{
+ if (NILP (buf->cache_long_line_scans))
+ {
+ /* It should be off. */
+ if (buf->width_run_cache)
+ {
+ free_region_cache (buf->width_run_cache);
+ buf->width_run_cache = 0;
+ buf->width_table = Qnil;
+ }
+ }
+ else
+ {
+ /* It should be on. */
+ if (buf->width_run_cache == 0)
+ {
+ buf->width_run_cache = new_region_cache ();
+ recompute_width_table (buf, buffer_display_table ());
+ }
+ }
+}
+
+#endif /* REGION_CACHE_NEEDS_WORK */
+\f
+
+/* Cancel any recorded value of the horizontal position. */
+
+void
+invalidate_current_column (void)
+{
+ last_known_column_point = -1;
+}
+
+int
+column_at_point (struct buffer *buf, Bufpos init_pos, int cur_col)
+{
+ int col;
+ int tab_seen;
+ int tab_width = XINT (buf->tab_width);
+ int post_tab;
+ Bufpos pos = init_pos;
+ Emchar c;
+
+ if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
+ col = tab_seen = post_tab = 0;
+
+ while (1)
+ {
+ if (pos <= BUF_BEGV (buf))
+ break;
+
+ pos--;
+ c = BUF_FETCH_CHAR (buf, pos);
+ if (c == '\t')
+ {
+ if (tab_seen)
+ col = ((col + tab_width) / tab_width) * tab_width;
+
+ post_tab += col;
+ col = 0;
+ tab_seen = 1;
+ }
+ else if (c == '\n' ||
+ (EQ (buf->selective_display, Qt) && c == '\r'))
+ break;
+ else
+ {
+ /* #### This needs updating to handle the new redisplay. */
+ /* #### FSFmacs looks at ctl_arrow, display tables.
+ We need to do similar. */
+#if 0
+ displayed_glyphs = glyphs_from_bufpos (sel_frame, buf,
+ XWINDOW (selected_window),
+ pos, dp, 0, col, 0, 0, 0);
+ col += (displayed_glyphs->columns
+ - (displayed_glyphs->begin_columns
+ + displayed_glyphs->end_columns));
+#else /* XEmacs */
+#ifdef MULE
+ col += XCHARSET_COLUMNS (CHAR_CHARSET (c));
+#else
+ col ++;
+#endif /* MULE */
+#endif /* XEmacs */
+ }
+ }
+
+ if (tab_seen)
+ {
+ col = ((col + tab_width) / tab_width) * tab_width;
+ col += post_tab;
+ }
+
+ if (cur_col)
+ {
+ last_known_column_buffer = buf;
+ last_known_column = col;
+ last_known_column_point = init_pos;
+ last_known_column_modified = BUF_MODIFF (buf);
+ }
+
+ return col;
+}
+
+int
+string_column_at_point (Lisp_String* s, Bufpos init_pos, int tab_width)
+{
+ int col;
+ int tab_seen;
+ int post_tab;
+ Bufpos pos = init_pos;
+ Emchar c;
+
+ if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
+ col = tab_seen = post_tab = 0;
+
+ while (1)
+ {
+ if (pos <= 0)
+ break;
+
+ pos--;
+ c = string_char (s, pos);
+ if (c == '\t')
+ {
+ if (tab_seen)
+ col = ((col + tab_width) / tab_width) * tab_width;
+
+ post_tab += col;
+ col = 0;
+ tab_seen = 1;
+ }
+ else if (c == '\n')
+ break;
+ else
+#ifdef MULE
+ col += XCHARSET_COLUMNS (CHAR_CHARSET (c));
+#else
+ col ++;
+#endif /* MULE */
+ }
+
+ if (tab_seen)
+ {
+ col = ((col + tab_width) / tab_width) * tab_width;
+ col += post_tab;
+ }
+
+ return col;
+}
+
+int
+current_column (struct buffer *buf)
+{
+ if (buf == last_known_column_buffer
+ && BUF_PT (buf) == last_known_column_point
+ && BUF_MODIFF (buf) == last_known_column_modified)
+ return last_known_column;
+
+ return column_at_point (buf, BUF_PT (buf), 1);
+}
+
+DEFUN ("current-column", Fcurrent_column, 0, 1, 0, /*
+Return the horizontal position of point. Beginning of line is column 0.
+This is calculated by adding together the widths of all the displayed
+ representations of the character between the start of the previous line
+ and point. (e.g. control characters will have a width of 2 or 4, tabs
+ will have a variable width.)
+Ignores finite width of frame, which means that this function may return
+ values greater than (frame-width).
+Whether the line is visible (if `selective-display' is t) has no effect;
+ however, ^M is treated as end of line when `selective-display' is t.
+If BUFFER is nil, the current buffer is assumed.
+*/
+ (buffer))
+{
+ return make_int (current_column (decode_buffer (buffer, 0)));
+}
+
+\f
+DEFUN ("indent-to", Findent_to, 1, 3, "NIndent to column: ", /*
+Indent from point with tabs and spaces until COLUMN is reached.
+Optional second argument MINIMUM says always do at least MINIMUM spaces
+ even if that goes past COLUMN; by default, MINIMUM is zero.
+If BUFFER is nil, the current buffer is assumed.
+*/
+ (column, minimum, buffer))
+{
+ /* This function can GC */
+ int mincol;
+ int fromcol;
+ struct buffer *buf = decode_buffer (buffer, 0);
+ int tab_width = XINT (buf->tab_width);
+ Bufpos opoint = 0;
+
+ CHECK_INT (column);
+ if (NILP (minimum))
+ minimum = Qzero;
+ else
+ CHECK_INT (minimum);
+
+ XSETBUFFER (buffer, buf);
+
+ fromcol = current_column (buf);
+ mincol = fromcol + XINT (minimum);
+ if (mincol < XINT (column)) mincol = XINT (column);
+
+ if (fromcol == mincol)
+ return make_int (mincol);
+
+ if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
+
+ if (!NILP (Fextent_at (make_int (BUF_PT (buf)), buffer, Qinvisible,
+ Qnil, Qnil)))
+ {
+ Bufpos last_visible = last_visible_position (BUF_PT (buf), buf);
+
+ opoint = BUF_PT (buf);
+ if (last_visible >= BUF_BEGV (buf))
+ BUF_SET_PT (buf, last_visible);
+ else
+ error ("Visible portion of buffer not modifiable");
+ }
+
+ if (indent_tabs_mode)
+ {
+ int n = mincol / tab_width - fromcol / tab_width;
+ if (n != 0)
+ {
+ Finsert_char (make_char ('\t'), make_int (n), Qnil, buffer);
+
+ fromcol = (mincol / tab_width) * tab_width;
+ }
+ }
+
+ Finsert_char (make_char (' '), make_int (mincol - fromcol), Qnil, buffer);
+
+ last_known_column_buffer = buf;
+ last_known_column = mincol;
+ last_known_column_point = BUF_PT (buf);
+ last_known_column_modified = BUF_MODIFF (buf);
+
+ /* Not in FSF: */
+ if (opoint > 0)
+ BUF_SET_PT (buf, opoint);
+
+ return make_int (mincol);
+}
+
+int
+bi_spaces_at_point (struct buffer *b, Bytind bi_pos)
+{
+ Bytind bi_end = BI_BUF_ZV (b);
+ int col = 0;
+ Emchar c;
+ int tab_width = XINT (b->tab_width);
+
+ if (tab_width <= 0 || tab_width > 1000)
+ tab_width = 8;
+
+ while (bi_pos < bi_end &&
+ (c = BI_BUF_FETCH_CHAR (b, bi_pos),
+ (c == '\t'
+ ? (col += tab_width - col % tab_width)
+ : (c == ' ' ? ++col : 0))))
+ INC_BYTIND (b, bi_pos);
+
+ return col;
+}
+
+\f
+DEFUN ("current-indentation", Fcurrent_indentation, 0, 1, 0, /*
+Return the indentation of the current line.
+This is the horizontal position of the character
+following any initial whitespace.
+*/
+ (buffer))
+{
+ struct buffer *buf = decode_buffer (buffer, 0);
+ Bufpos pos = find_next_newline (buf, BUF_PT (buf), -1);
+
+ XSETBUFFER (buffer, buf);
+
+ if (!NILP (Fextent_at (make_int (pos), buffer, Qinvisible, Qnil, Qnil)))
+ return Qzero;
+
+ return make_int (bi_spaces_at_point (buf, bufpos_to_bytind (buf, pos)));
+}
+
+\f
+DEFUN ("move-to-column", Fmove_to_column, 1, 3, 0, /*
+Move point to column COLUMN in the current line.
+The column of a character is calculated by adding together the widths
+as displayed of the previous characters in the line.
+This function ignores line-continuation;
+there is no upper limit on the column number a character can have
+and horizontal scrolling has no effect.
+
+If specified column is within a character, point goes after that character.
+If it's past end of line, point goes to end of line.
+
+A value of 'coerce for the second (optional) argument FORCE means if
+COLUMN is in the middle of a tab character, change it to spaces.
+Any other non-nil value means the same, plus if the line is too short to
+reach column COLUMN, then add spaces/tabs to get there.
+
+Returns the actual column that it moved to.
+*/
+ (column, force, buffer))
+{
+ /* This function can GC */
+ Bufpos pos;
+ struct buffer *buf = decode_buffer (buffer, 0);
+ int col = current_column (buf);
+ int goal;
+ Bufpos end;
+ int tab_width = XINT (buf->tab_width);
+
+ int prev_col = 0;
+ Emchar c = 0;
+
+ XSETBUFFER (buffer, buf);
+ if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
+ CHECK_NATNUM (column);
+ goal = XINT (column);
+
+ retry:
+ pos = BUF_PT (buf);
+ end = BUF_ZV (buf);
+
+ /* If we're starting past the desired column,
+ back up to beginning of line and scan from there. */
+ if (col > goal)
+ {
+ pos = find_next_newline (buf, pos, -1);
+ col = 0;
+ }
+
+ while (col < goal && pos < end)
+ {
+ c = BUF_FETCH_CHAR (buf, pos);
+ if (c == '\n')
+ break;
+ if (c == '\r' && EQ (buf->selective_display, Qt))
+ break;
+ if (c == '\t')
+ {
+ prev_col = col;
+ col += tab_width;
+ col = col / tab_width * tab_width;
+ }
+ else
+ {
+ /* #### oh for the days of the complete new redisplay */
+ /* #### FSFmacs looks at ctl_arrow, display tables.
+ We need to do similar. */
+#if 0
+ displayed_glyphs = glyphs_from_bufpos (selected_frame (),
+ buf,
+ XWINDOW (Fselected_window (Qnil)),
+ pos, dp, 0, col, 0, 0, 0);
+ col += (displayed_glyphs->columns
+ - (displayed_glyphs->begin_columns
+ + displayed_glyphs->end_columns));
+#else /* XEmacs */
+#ifdef MULE
+ col += XCHARSET_COLUMNS (CHAR_CHARSET (c));
+#else
+ col ++;
+#endif /* MULE */
+#endif /* XEmacs */
+ }
+
+ pos++;
+ }
+
+ BUF_SET_PT (buf, pos);
+
+ /* If a tab char made us overshoot, change it to spaces
+ and scan through it again. */
+ if (!NILP (force) && col > goal && c == '\t' && prev_col < goal)
+ {
+ buffer_delete_range (buf, BUF_PT (buf) - 1, BUF_PT (buf), 0);
+ Findent_to (make_int (col - 1), Qzero, buffer);
+ buffer_insert_emacs_char (buf, ' ');
+ goto retry;
+ }
+
+ /* If line ends prematurely, add space to the end. */
+ if (col < goal && !NILP (force) && !EQ (force, Qcoerce))
+ {
+ col = goal;
+ Findent_to (make_int (col), Qzero, buffer);
+ }
+
+ last_known_column_buffer = buf;
+ last_known_column = col;
+ last_known_column_point = BUF_PT (buf);
+ last_known_column_modified = BUF_MODIFF (buf);
+
+ return make_int (col);
+}
+
+#if 0 /* #### OK boys, this function needs to be present, I think.
+ It was there before the 19.12 redisplay rewrite. */
+
+xxDEFUN ("compute-motion", Fcompute_motion, 7, 7, 0, /*
+ "Scan through the current buffer, calculating screen position.
+Scan the current buffer forward from offset FROM,
+assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
+to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
+and return the ending buffer position and screen location.
+
+There are three additional arguments:
+
+WIDTH is the number of columns available to display text;
+this affects handling of continuation lines.
+This is usually the value returned by `window-width', less one (to allow
+for the continuation glyph).
+
+OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
+HSCROLL is the number of columns not being displayed at the left
+margin; this is usually taken from a window's hscroll member.
+TAB-OFFSET is the number of columns of the first tab that aren't
+being displayed, perhaps because the line was continued within it.
+If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
+
+WINDOW is the window to operate on. Currently this is used only to
+find the display table. It does not matter what buffer WINDOW displays;
+`compute-motion' always operates on the current buffer.
+
+The value is a list of five elements:
+ (POS HPOS VPOS PREVHPOS CONTIN)
+POS is the buffer position where the scan stopped.
+VPOS is the vertical position where the scan stopped.
+HPOS is the horizontal position where the scan stopped.
+
+PREVHPOS is the horizontal position one character back from POS.
+CONTIN is t if a line was continued after (or within) the previous character.
+
+For example, to find the buffer position of column COL of line LINE
+of a certain window, pass the window's starting location as FROM
+and the window's upper-left coordinates as FROMPOS.
+Pass the buffer's (point-max) as TO, to limit the scan to the end of the
+visible section of the buffer, and pass LINE and COL as TOPOS.
+*/
+ (from, frompos, to, topos, width, offsets, window))
+{
+ Lisp_Object bufpos, hpos, vpos, prevhpos, contin;
+ struct position *pos;
+ int hscroll, tab_offset;
+ struct window *w = decode_window (window);
+
+ CHECK_INT_COERCE_MARKER (from);
+ CHECK_CONS (frompos);
+ CHECK_INT (XCAR (frompos));
+ CHECK_INT (XCDR (frompos));
+ CHECK_INT_COERCE_MARKER (to);
+ CHECK_CONS (topos);
+ CHECK_INT (XCAR (topos));
+ CHECK_INT (XCDR (topos));
+ CHECK_INT (width);
+ if (!NILP (offsets))
+ {
+ CHECK_CONS (offsets);
+ CHECK_INT (XCAR (offsets));
+ CHECK_INT (XCDR (offsets));
+ hscroll = XINT (XCAR (offsets));
+ tab_offset = XINT (XCDR (offsets));
+ }
+ else
+ hscroll = tab_offset = 0;
+
+ pos = compute_motion (XINT (from), XINT (XCDR (frompos)),
+ XINT (XCAR (frompos)),
+ XINT (to), XINT (XCDR (topos)),
+ XINT (XCAR (topos)),
+ XINT (width), hscroll, tab_offset, w);
+
+ XSETINT (bufpos, pos->bufpos);
+ XSETINT (hpos, pos->hpos);
+ XSETINT (vpos, pos->vpos);
+ XSETINT (prevhpos, pos->prevhpos);
+
+ return list5 (bufpos, hpos, vpos, prevhpos,
+ pos->contin ? Qt : Qnil);
+}
+
+#endif /* 0 */
+
+/* Helper for vmotion_1 - compute vertical pixel motion between
+ START and END in the line start cache CACHE. This just sums
+ the line heights, including both the starting and ending lines.
+*/
+static int
+vpix_motion (line_start_cache_dynarr *cache, int start, int end)
+{
+ int i, vpix;
+
+ assert (start <= end);
+ assert (start >= 0);
+ assert (end < Dynarr_length (cache));
+
+ vpix = 0;
+ for (i = start; i <= end; i++)
+ vpix += Dynarr_atp (cache, i)->height;
+
+ return vpix;
+}
+
+/*****************************************************************************
+ vmotion_1
+
+ Given a starting position ORIG, move point VTARGET lines in WINDOW.
+ Returns the new value for point. If the arg ret_vpos is not nil, it is
+ taken to be a pointer to an int and the number of lines actually moved is
+ returned in it. If the arg ret_vpix is not nil, it is taken to be a
+ pointer to an int and the vertical pixel height of the motion which
+ took place is returned in it.
+ ****************************************************************************/
+static Bufpos
+vmotion_1 (struct window *w, Bufpos orig, int vtarget,
+ int *ret_vpos, int *ret_vpix)
+{
+ struct buffer *b = XBUFFER (w->buffer);
+ int elt;
+
+ elt = point_in_line_start_cache (w, orig, (vtarget < 0
+ ? -vtarget
+ : vtarget));
+
+ /* #### This assertion must be true before the if statements are hit
+ but may possibly be wrong after the call to
+ point_in_line_start_cache if orig is outside of the visible
+ region of the buffer. Handle this. */
+ assert (elt >= 0);
+
+ /* Moving downward. */
+ if (vtarget > 0)
+ {
+ int cur_line = Dynarr_length (w->line_start_cache) - 1 - elt;
+ Bufpos ret_pt;
+
+ if (cur_line > vtarget)
+ cur_line = vtarget;
+
+ /* The traditional FSF behavior is to return the end of buffer
+ position if we couldn't move far enough because we hit it. */
+ if (cur_line < vtarget)
+ ret_pt = BUF_ZV (b);
+ else
+ ret_pt = Dynarr_atp (w->line_start_cache, cur_line + elt)->start;
+
+ while (ret_pt > BUF_ZV (b) && cur_line > 0)
+ {
+ cur_line--;
+ ret_pt = Dynarr_atp (w->line_start_cache, cur_line + elt)->start;
+ }
+
+ if (ret_vpos) *ret_vpos = cur_line;
+ if (ret_vpix)
+ *ret_vpix = vpix_motion (w->line_start_cache, elt, cur_line + elt);
+ return ret_pt;
+ }
+ else if (vtarget < 0)
+ {
+ if (elt < -vtarget)
+ {
+ if (ret_vpos) *ret_vpos = -elt;
+ if (ret_vpix)
+ *ret_vpix = vpix_motion (w->line_start_cache, 0, elt);
+ /* #### This should be BUF_BEGV (b), right? */
+ return Dynarr_atp (w->line_start_cache, 0)->start;
+ }
+ else
+ {
+ if (ret_vpos) *ret_vpos = vtarget;
+ if (ret_vpix)
+ *ret_vpix = vpix_motion (w->line_start_cache, elt + vtarget, elt);
+ return Dynarr_atp (w->line_start_cache, elt + vtarget)->start;
+ }
+ }
+ else
+ {
+ /* No vertical motion requested so we just return the position
+ of the beginning of the current line. */
+ if (ret_vpos) *ret_vpos = 0;
+ if (ret_vpix)
+ *ret_vpix = vpix_motion (w->line_start_cache, elt, elt);
+
+ return Dynarr_atp (w->line_start_cache, elt)->start;
+ }
+
+ RETURN_NOT_REACHED(0) /* shut up compiler */
+}
+
+/*****************************************************************************
+ vmotion
+
+ Given a starting position ORIG, move point VTARGET lines in WINDOW.
+ Returns the new value for point. If the arg ret_vpos is not nil, it is
+ taken to be a pointer to an int and the number of lines actually moved is
+ returned in it.
+ ****************************************************************************/
+Bufpos
+vmotion (struct window *w, Bufpos orig, int vtarget, int *ret_vpos)
+{
+ return vmotion_1 (w, orig, vtarget, ret_vpos, NULL);
+}
+
+/* Helper for Fvertical_motion.
+ */
+static
+Lisp_Object vertical_motion_1 (Lisp_Object lines, Lisp_Object window,
+ int pixels)
+{
+ Bufpos bufpos;
+ Bufpos orig;
+ int selected;
+ int *vpos, *vpix;
+ int value=0;
+ struct window *w;
+
+ if (NILP (window))
+ window = Fselected_window (Qnil);
+
+ CHECK_LIVE_WINDOW (window);
+ CHECK_INT (lines);
+
+ selected = (EQ (window, Fselected_window (Qnil)));
+
+ w = XWINDOW (window);
+
+ orig = selected ? BUF_PT (XBUFFER (w->buffer))
+ : marker_position (w->pointm[CURRENT_DISP]);
+
+ vpos = pixels ? NULL : &value;
+ vpix = pixels ? &value : NULL;
+
+ bufpos = vmotion_1 (w, orig, XINT (lines), vpos, vpix);
+
+ /* Note that the buffer's point is set, not the window's point. */
+ if (selected)
+ BUF_SET_PT (XBUFFER (w->buffer), bufpos);
+ else
+ set_marker_restricted (w->pointm[CURRENT_DISP],
+ make_int(bufpos),
+ w->buffer);
+
+ return make_int (value);
+}
+
+DEFUN ("vertical-motion", Fvertical_motion, 1, 3, 0, /*
+Move to start of frame line LINES lines down.
+If LINES is negative, this is moving up.
+Optional second argument is WINDOW to move in,
+the default is the selected window.
+
+Sets point to position found; this may be start of line
+or just the start of a continuation line.
+If optional third argument PIXELS is nil, returns number
+of lines moved; may be closer to zero than LINES if beginning
+or end of buffer was reached. If PIXELS is non-nil, the
+vertical pixel height of the motion which took place is
+returned instead of the actual number of lines moved. A
+motion of zero lines returns the height of the current line.
+
+Note that `vertical-motion' sets WINDOW's buffer's point, not
+WINDOW's point. (This differs from FSF Emacs, which buggily always
+sets current buffer's point, regardless of WINDOW.)
+*/
+ (lines, window, pixels))
+{
+ return vertical_motion_1 (lines, window, !NILP (pixels));
+}
+
+/*
+ * Like vmotion() but requested and returned movement is in pixels.
+ * HOW specifies the stopping condition. Positive means move at least
+ * PIXELS. Negative means at most. Zero means as close as possible.
+ */
+Bufpos
+vmotion_pixels (Lisp_Object window, Bufpos start, int pixels, int how,
+ int *motion)
+{
+ struct window *w;
+ Bufpos eobuf, bobuf;
+ int defheight;
+ int needed;
+ int line, next;
+ int remain, abspix, dirn;
+ int elt, nelt;
+ int i;
+ line_start_cache_dynarr *cache;
+ int previous = -1;
+ int lines;
+
+ if (NILP (window))
+ window = Fselected_window (Qnil);
+
+ CHECK_LIVE_WINDOW (window);
+ w = XWINDOW (window);
+
+ eobuf = BUF_ZV (XBUFFER (w->buffer));
+ bobuf = BUF_BEGV (XBUFFER (w->buffer));
+
+ default_face_height_and_width (window, &defheight, NULL);
+
+ /* guess num lines needed in line start cache + a few extra */
+ abspix = abs (pixels);
+ needed = (abspix + defheight-1)/defheight + 3;
+
+ dirn = (pixels >= 0) ? 1 : -1;
+
+ while (1)
+ {
+ elt = point_in_line_start_cache (w, start, needed);
+ assert (elt >= 0); /* in the cache */
+
+ cache = w->line_start_cache;
+ nelt = Dynarr_length (cache);
+
+ *motion = 0;
+
+ if (pixels == 0)
+ /* No vertical motion requested so we just return the position
+ of the beginning of the current display line. */
+ return Dynarr_atp (cache, elt)->start;
+
+ if ((dirn < 0 && elt == 0 &&
+ Dynarr_atp (cache, elt)->start <= bobuf) ||
+ (dirn > 0 && elt == nelt-1 &&
+ Dynarr_atp (cache, elt)->end >= eobuf))
+ return Dynarr_atp (cache, elt)->start;
+
+ remain = abspix;
+ for (i = elt; (dirn > 0) ? (i < nelt) : (i > 0); i += dirn)
+ {
+ /* cache line we're considering moving over */
+ int ii = (dirn > 0) ? i : i-1;
+
+ if (remain < 0)
+ return Dynarr_atp (cache, i)->start;
+
+ line = Dynarr_atp (cache, ii)->height;
+ next = remain - line;
+
+ /* is stopping condition satisfied? */
+ if ((how > 0 && remain <= 0) || /* at least */
+ (how < 0 && next < 0) || /* at most */
+ (how == 0 && remain <= abs (next))) /* closest */
+ return Dynarr_atp (cache, i)->start;
+
+ /* moving down and nowhere left to go? */
+ if (dirn > 0 && Dynarr_atp (cache, ii)->end >= eobuf)
+ return Dynarr_atp (cache, ii)->start;
+
+ /* take the step */
+ remain = next;
+ *motion += dirn * line;
+
+ /* moving up and nowhere left to go? */
+ if (dirn < 0 && Dynarr_atp (cache, ii)->start <= bobuf)
+ return Dynarr_atp (cache, ii)->start;
+ }
+
+ /* get here => need more cache lines. try again. */
+ assert (abs (*motion) > previous); /* progress? */
+ previous = abs (*motion);
+
+ lines = (pixels < 0) ? elt : (nelt - elt);
+ needed += (remain*lines + abspix-1)/abspix + 3;
+ }
+
+ RETURN_NOT_REACHED(0) /* shut up compiler */
+}
+
+DEFUN ("vertical-motion-pixels", Fvertical_motion_pixels, 1, 3, 0, /*
+Move to start of frame line PIXELS vertical pixels down.
+If PIXELS is negative, this is moving up.
+The actual vertical motion in pixels is returned.
+
+Optional second argument is WINDOW to move in,
+the default is the selected window.
+
+Optional third argument HOW specifies when to stop. A value
+less than zero indicates that the motion should be no more
+than PIXELS. A value greater than zero indicates that the
+motion should be at least PIXELS. Any other value indicates
+that the motion should be as close as possible to PIXELS.
+*/
+ (pixels, window, how))
+{
+ Bufpos bufpos;
+ Bufpos orig;
+ int selected;
+ int motion;
+ int howto;
+ struct window *w;
+
+ if (NILP (window))
+ window = Fselected_window (Qnil);
+
+ CHECK_LIVE_WINDOW (window);
+ CHECK_INT (pixels);
+
+ selected = (EQ (window, Fselected_window (Qnil)));
+
+ w = XWINDOW (window);
+
+ orig = selected ? BUF_PT (XBUFFER (w->buffer))
+ : marker_position (w->pointm[CURRENT_DISP]);
+
+ howto = INTP (how) ? XINT (how) : 0;
+
+ bufpos = vmotion_pixels (window, orig, XINT (pixels), howto, &motion);
+
+ if (selected)
+ BUF_SET_PT (XBUFFER (w->buffer), bufpos);
+ else
+ set_marker_restricted (w->pointm[CURRENT_DISP],
+ make_int(bufpos),
+ w->buffer);
+
+ return make_int (motion);
+}
+
+\f
+void
+syms_of_indent (void)
+{
+ DEFSUBR (Fcurrent_indentation);
+ DEFSUBR (Findent_to);
+ DEFSUBR (Fcurrent_column);
+ DEFSUBR (Fmove_to_column);
+#if 0 /* #### */
+ DEFSUBR (Fcompute_motion);
+#endif
+ DEFSUBR (Fvertical_motion);
+ DEFSUBR (Fvertical_motion_pixels);
+
+ defsymbol (&Qcoerce, "coerce");
+}
+
+void
+vars_of_indent (void)
+{
+ DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode /*
+*Indentation can insert tabs if this is non-nil.
+Setting this variable automatically makes it local to the current buffer.
+*/ );
+ indent_tabs_mode = 1;
+}
projects / chise / xemacs-chise.git- / blobdiff