Mercurial > hg > xemacs-beta
diff src/window.c @ 412:697ef44129c6 r21-2-14
Import from CVS: tag r21-2-14
| author | cvs |
|---|---|
| date | Mon, 13 Aug 2007 11:20:41 +0200 |
| parents | de805c49cfc1 |
| children | da8ed4261e83 |
line wrap: on
line diff
--- a/src/window.c Mon Aug 13 11:19:22 2007 +0200 +++ b/src/window.c Mon Aug 13 11:20:41 2007 +0200 @@ -38,10 +38,9 @@ #include "window.h" #include "elhash.h" #include "commands.h" -#include "gutter.h" Lisp_Object Qwindowp, Qwindow_live_p, Qwindow_configurationp; -Lisp_Object Qdisplay_buffer; +Lisp_Object Qscroll_up, Qscroll_down, Qdisplay_buffer; #ifdef MEMORY_USAGE_STATS Lisp_Object Qface_cache, Qglyph_cache, Qline_start_cache, Qother_redisplay; @@ -85,9 +84,6 @@ /* Spacing between outer egde of divider border and window edge */ Lisp_Object Vvertical_divider_spacing; -/* How much to scroll by per-line. */ -Lisp_Object Vwindow_pixel_scroll_increment; - /* Scroll if point lands on the bottom line and that line is partially clipped. */ int scroll_on_clipped_lines; @@ -121,7 +117,7 @@ int next_screen_context_lines; /* List of freed window configurations with 1 - 10 windows. */ -static Lisp_Object Vwindow_configuration_free_list[10]; +Lisp_Object Vwindow_configuration_free_list[10]; #define SET_LAST_MODIFIED(w, cache_too) \ do { \ @@ -141,38 +137,38 @@ #define MARK_DISP_VARIABLE(field) \ - mark_object (window->field[CURRENT_DISP]); \ - mark_object (window->field[DESIRED_DISP]); \ - mark_object (window->field[CMOTION_DISP]); + markobj (window->field[CURRENT_DISP]); \ + markobj (window->field[DESIRED_DISP]); \ + markobj (window->field[CMOTION_DISP]); static Lisp_Object -mark_window (Lisp_Object obj) +mark_window (Lisp_Object obj, void (*markobj) (Lisp_Object)) { struct window *window = XWINDOW (obj); - mark_object (window->frame); - mark_object (window->mini_p); - mark_object (window->next); - mark_object (window->prev); - mark_object (window->hchild); - mark_object (window->vchild); - mark_object (window->parent); - mark_object (window->buffer); + markobj (window->frame); + markobj (window->mini_p); + markobj (window->next); + markobj (window->prev); + markobj (window->hchild); + markobj (window->vchild); + markobj (window->parent); + markobj (window->buffer); MARK_DISP_VARIABLE (start); MARK_DISP_VARIABLE (pointm); - mark_object (window->sb_point); /* #### move to scrollbar.c? */ - mark_object (window->use_time); + markobj (window->sb_point); /* #### move to scrollbar.c? */ + markobj (window->use_time); MARK_DISP_VARIABLE (last_modified); MARK_DISP_VARIABLE (last_point); MARK_DISP_VARIABLE (last_start); MARK_DISP_VARIABLE (last_facechange); - mark_object (window->line_cache_last_updated); - mark_object (window->redisplay_end_trigger); - mark_object (window->subwindow_instance_cache); - - mark_face_cachels (window->face_cachels); - mark_glyph_cachels (window->glyph_cachels); - -#define WINDOW_SLOT(slot, compare) mark_object (window->slot) + markobj (window->line_cache_last_updated); + markobj (window->redisplay_end_trigger); + markobj (window->subwindow_instance_cache); + + mark_face_cachels (window->face_cachels, markobj); + mark_glyph_cachels (window->glyph_cachels, markobj); + +#define WINDOW_SLOT(slot, compare) ((void) (markobj (window->slot))) #include "winslots.h" return Qnil; @@ -235,7 +231,7 @@ DEFINE_LRECORD_IMPLEMENTATION ("window", window, mark_window, print_window, finalize_window, - 0, 0, 0, struct window); + 0, 0, struct window); #define INIT_DISP_VARIABLE(field, initialization) \ @@ -281,20 +277,15 @@ p->face_cachels = Dynarr_new (face_cachel); p->glyph_cachels = Dynarr_new (glyph_cachel); p->line_start_cache = Dynarr_new (line_start_cache); - p->subwindow_instance_cache = make_lisp_hash_table (30, - HASH_TABLE_KEY_VALUE_WEAK, - HASH_TABLE_EQUAL); + p->subwindow_instance_cache = make_lisp_hash_table (10, + HASH_TABLE_KEY_WEAK, + HASH_TABLE_EQ); p->line_cache_last_updated = Qzero; INIT_DISP_VARIABLE (last_point_x, 0); INIT_DISP_VARIABLE (last_point_y, 0); INIT_DISP_VARIABLE (window_end_pos, 0); p->redisplay_end_trigger = Qnil; - p->gutter_extent_modiff[0] = 0; - p->gutter_extent_modiff[1] = 0; - p->gutter_extent_modiff[2] = 0; - p->gutter_extent_modiff[3] = 0; - #define WINDOW_SLOT(slot, compare) p->slot = Qnil #include "winslots.h" @@ -650,7 +641,7 @@ return window_is_leftmost (w) && window_is_rightmost (w); } -int +static int window_is_highest (struct window *w) { Lisp_Object parent, current_ancestor, window; @@ -678,7 +669,7 @@ return 0; } -int +static int window_is_lowest (struct window *w) { Lisp_Object parent, current_ancestor, window; @@ -714,11 +705,6 @@ int window_truncation_on (struct window *w) { - /* Minibuffer windows are never truncated. - #### is this the right way ? */ - if (MINI_WINDOW_P (w)) - return 0; - /* Horizontally scrolled windows are truncated. */ if (w->hscroll) return 1; @@ -737,17 +723,6 @@ return 0; } -DEFUN ("window-truncated-p", Fwindow_truncated_p, 0, 1, 0, /* -Returns non-nil if text in the window is truncated. -*/ - (window)) -{ - struct window *w = decode_window (window); - - return window_truncation_on (w) ? Qt : Qnil; -} - - static int have_undivided_common_edge (struct window *w_right, void *closure) { @@ -997,6 +972,32 @@ return margin_width_internal (w, 0); } +static int +window_top_toolbar_height (struct window *w) +{ + /* #### implement this shit. */ + return 0; +} + +/* #### Currently used in scrollbar.c. Does it actually need to be? */ +int +window_bottom_toolbar_height (struct window *w) +{ + return 0; +} + +static int +window_left_toolbar_width (struct window *w) +{ + return 0; +} + +static int +window_right_toolbar_width (struct window *w) +{ + return 0; +} + /***************************************************************************** Window Gutters @@ -1015,74 +1016,62 @@ relative to the frame, not the window. ****************************************************************************/ -static int -window_top_window_gutter_height (struct window *w) -{ - if (!NILP (w->hchild) || !NILP (w->vchild)) - return 0; - -#ifdef HAVE_SCROLLBARS - if (!NILP (w->scrollbar_on_top_p)) - return window_scrollbar_height (w); - else -#endif - return 0; -} - int window_top_gutter_height (struct window *w) { - return window_top_window_gutter_height (w); -} - -static int -window_bottom_window_gutter_height (struct window *w) -{ - int gutter; + int toolbar_height = window_top_toolbar_height (w); if (!NILP (w->hchild) || !NILP (w->vchild)) return 0; - gutter = window_modeline_height (w); - #ifdef HAVE_SCROLLBARS - if (NILP (w->scrollbar_on_top_p)) - return window_scrollbar_height (w) + gutter; + if (!NILP (w->scrollbar_on_top_p)) + return window_scrollbar_height (w) + toolbar_height; else #endif - return gutter; + return toolbar_height; } int window_bottom_gutter_height (struct window *w) { - return window_bottom_window_gutter_height (w); -} - -static int -window_left_window_gutter_width (struct window *w, int modeline) -{ + int other_height; + if (!NILP (w->hchild) || !NILP (w->vchild)) return 0; + else + other_height = + window_modeline_height (w) + window_bottom_toolbar_height (w); #ifdef HAVE_SCROLLBARS - if (!modeline && !NILP (w->scrollbar_on_left_p)) - return window_scrollbar_width (w); + if (NILP (w->scrollbar_on_top_p)) + return window_scrollbar_height (w) + other_height; + else #endif - - return 0; + return other_height; } int window_left_gutter_width (struct window *w, int modeline) { - return window_left_window_gutter_width (w, modeline); + int gutter = window_left_toolbar_width (w); + + if (!NILP (w->hchild) || !NILP (w->vchild)) + return 0; + + +#ifdef HAVE_SCROLLBARS + if (!modeline && !NILP (w->scrollbar_on_left_p)) + gutter += window_scrollbar_width (w); +#endif + + return gutter; } -static int -window_right_window_gutter_width (struct window *w, int modeline) +int +window_right_gutter_width (struct window *w, int modeline) { - int gutter = 0; + int gutter = window_right_toolbar_width (w); if (!NILP (w->hchild) || !NILP (w->vchild)) return 0; @@ -1098,18 +1087,6 @@ return gutter; } -int -window_right_gutter_width (struct window *w, int modeline) -{ - return window_right_window_gutter_width (w, modeline); -} - -static int -window_pixel_height (struct window* w) -{ - return WINDOW_HEIGHT (w); -} - DEFUN ("windowp", Fwindowp, 1, 1, 0, /* Return t if OBJ is a window. @@ -1146,26 +1123,6 @@ } } -DEFUN ("last-nonminibuf-window", Flast_nonminibuf_window, 0, 1, 0, /* -Return the last selected window that is not a minibuffer window. -If the optional argument CON-DEV-OR-FRAME is specified and is a frame, -return the last non-minibuffer window used by that frame. If -CON-DEV-OR-FRAME is a device, then the selected frame on that device -will be used. If CON-DEV-OR-FRAME is a console, the selected frame on -that console's selected device will be used. Otherwise, the selected -frame is used. -*/ - (con_dev_or_frame)) -{ - if (NILP (con_dev_or_frame) && NILP (Fselected_device (Qnil))) - return Qnil; /* happens at startup */ - - { - struct frame *f = decode_frame_or_selected (con_dev_or_frame); - return FRAME_LAST_NONMINIBUF_WINDOW (f); - } -} - DEFUN ("minibuffer-window", Fminibuffer_window, 0, 1, 0, /* Return the window used now for minibuffers. If the optional argument CON-DEV-OR-FRAME is specified and is a frame, return @@ -1179,7 +1136,7 @@ return FRAME_MINIBUF_WINDOW (decode_frame_or_selected (con_dev_or_frame)); } -DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, 0, 1, 0, /* +DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, 1, 1, 0, /* Return non-nil if WINDOW is a minibuffer window. */ (window)) @@ -1325,22 +1282,6 @@ Use `window-height' to get consistent results in geometry calculations. Use `window-displayed-height' to get the actual number of lines currently displayed in a window. - -The names are somewhat confusing; here's a table to help out: - - width height -------------------------------------------------------------------------- -w/o gutters - (rows/columns) window-width window-text-area-height - (pixels) window-text-area-pixel-width window-text-area-pixel-height - -with gutters - (rows/columns) window-full-width window-height - (pixels) window-pixel-width window-pixel-height - -actually displayed - (rows/columns) ---- window-displayed-height - (pixels) ---- window-displayed-text-pixel-height */ (window)) { @@ -1367,20 +1308,7 @@ */ (window)) { - return make_int (window_pixel_height (decode_window (window))); -} - -DEFUN ("window-text-area-height", Fwindow_text_area_height, 0, 1, 0, /* -Return the number of default lines in the text area of WINDOW. -This actually works by dividing the window's text area pixel height (i.e. -excluding the modeline and horizontal scrollbar, if any) by the height of the -default font; therefore, the number of displayed lines will probably -be different. -See also `window-height' and `window-displayed-height'. -*/ - (window)) -{ - return make_int (window_char_height (decode_window (window), 0)); + return make_int (decode_window (window)->pixel_height); } DEFUN ("window-text-area-pixel-height", @@ -1417,7 +1345,7 @@ if (NILP (window)) window = Fselected_window (Qnil); - CHECK_LIVE_WINDOW (window); + CHECK_WINDOW (window); w = XWINDOW (window); start = marker_position (w->start[CURRENT_DISP]); @@ -1461,25 +1389,13 @@ DEFUN ("window-width", Fwindow_width, 0, 1, 0, /* Return the number of display columns in WINDOW. -This is the width that is usable columns available for text in WINDOW, -and does not include vertical scrollbars, dividers, or the like. See also -`window-full-width' and `window-height'. +This is the width that is usable columns available for text in WINDOW. */ (window)) { return make_int (window_char_width (decode_window (window), 0)); } -DEFUN ("window-full-width", Fwindow_full_width, 0, 1, 0, /* -Return the total number of columns in WINDOW. -This is like `window-width' but includes vertical scrollbars, dividers, -etc. -*/ - (window)) -{ - return make_int (window_char_width (decode_window (window), 1)); -} - DEFUN ("window-pixel-width", Fwindow_pixel_width, 0, 1, 0, /* Return the width of WINDOW in pixels. Defaults to current window. */ @@ -1509,23 +1425,22 @@ return make_int (decode_window (window)->hscroll); } +#ifdef MODELINE_IS_SCROLLABLE DEFUN ("modeline-hscroll", Fmodeline_hscroll, 0, 1, 0, /* -Return the horizontal scrolling ammount of WINDOW's modeline. -If the window has no modeline, return nil. +Return the number of columns by which WINDOW's modeline is scrolled from +left margin. If the window has no modeline, return nil. */ (window)) { struct window *w = decode_window (window); - return (WINDOW_HAS_MODELINE_P (w)) ? make_int ((int) w->modeline_hscroll) : - Qnil; + return (WINDOW_HAS_MODELINE_P (w)) ? make_int (w->modeline_hscroll) : Qnil; } DEFUN ("set-modeline-hscroll", Fset_modeline_hscroll, 2, 2, 0, /* -Set the horizontal scrolling ammount of WINDOW's modeline to NCOL. -If NCOL is negative, it will silently be forced to 0. -If the window has no modeline, return nil. Otherwise, return the actual -value that was set. +Set number of columns WINDOW's modeline is scrolled from left margin to NCOL. +NCOL should be zero or positive. If NCOL is negative, it will be forced to 0. +If the window has no modeline, do nothing and return nil. */ (window, ncol)) { @@ -1533,20 +1448,18 @@ if (WINDOW_HAS_MODELINE_P (w)) { - Charcount ncols; - + int ncols; CHECK_INT (ncol); - ncols = (XINT (ncol) <= 0) ? 0 : (Charcount) XINT (ncol); - if (ncols != w->modeline_hscroll) - { - MARK_MODELINE_CHANGED; - w->modeline_hscroll = ncols; - } - return make_int ((int) ncols); + ncols = XINT (ncol); + if (ncols < 0) ncols = 0; + if (w->modeline_hscroll != ncols) + MARK_MODELINE_CHANGED; + w->modeline_hscroll = ncols; + return ncol; } - return Qnil; } +#endif /* MODELINE_IS_SCROLLABLE */ DEFUN ("set-window-hscroll", Fset_window_hscroll, 2, 2, 0, /* Set number of columns WINDOW is scrolled from left margin to NCOL. @@ -1598,14 +1511,15 @@ DEFUN ("window-pixel-edges", Fwindow_pixel_edges, 0, 1, 0, /* Return a list of the pixel edge coordinates of WINDOW. \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame. -The frame toolbars, menubars and gutters are considered to be outside of this area. +The frame toolbars and menubars are considered to be outside of this area. */ (window)) { struct window *w = decode_window (window); - - int left = w->pixel_left; - int top = w->pixel_top; + struct frame *f = XFRAME (w->frame); + + int left = w->pixel_left - FRAME_LEFT_BORDER_END (f); + int top = w->pixel_top - FRAME_TOP_BORDER_END (f); return list4 (make_int (left), make_int (top), @@ -1694,28 +1608,6 @@ } } -DEFUN ("window-last-line-visible-height", Fwindow_last_line_visible_height, 0, 1, 0, /* -Return pixel height of visible part of last window line if it is clipped. -If the last line is not clipped, return nil. -*/ - (window)) -{ - struct window *w = decode_window (window); - display_line_dynarr *dla = window_display_lines (w, CURRENT_DISP); - int num_lines = Dynarr_length (dla); - struct display_line *dl; - - /* No lines - no clipped lines */ - if (num_lines == 0 || (num_lines == 1 && Dynarr_atp (dla, 0)->modeline)) - return Qnil; - - dl = Dynarr_atp (dla, num_lines - 1); - if (dl->clip == 0) - return Qnil; - - return make_int (dl->ascent + dl->descent - dl->clip); -} - DEFUN ("set-window-point", Fset_window_point, 2, 2, 0, /* Make point value in WINDOW be at position POS in WINDOW's buffer. */ @@ -1867,34 +1759,6 @@ /* #### Here, if replacement is a vertical combination and so is its new parent, we should make replacement's children be children of that parent instead. */ - - ERROR_CHECK_SUBWINDOW_CACHE (p); -} - -static int -window_unmap_subwindows_cache_mapper (Lisp_Object key, Lisp_Object value, - void *flag_closure) -{ - /* value can be nil; we cache failures as well as successes */ - if (!NILP (value)) - { - struct frame* f = XFRAME (XIMAGE_INSTANCE_FRAME (value)); - unmap_subwindow (value); - /* In case GC doesn't catch up fast enough, remove from the frame - cache also. Otherwise code that checks the sanity of the instance - will fail. */ - XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f)) - = delq_no_quit (value, XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f))); - } - return 0; -} - -static void -window_unmap_subwindows (struct window* w) -{ - assert (!NILP (w->subwindow_instance_cache)); - elisp_maphash (window_unmap_subwindows_cache_mapper, - w->subwindow_instance_cache, 0); } /* we're deleting W; set the structure of W to indicate this. */ @@ -1902,20 +1766,6 @@ static void mark_window_as_deleted (struct window *w) { - /* The window instance cache is going away now, so need to get the - cachels reset by redisplay. */ - MARK_FRAME_SUBWINDOWS_CHANGED (XFRAME (WINDOW_FRAME (w))); - - /* The cache is going away. If we leave unmapping to - reset_subwindow_cachels then we get in a situation where the - domain (the window) has been deleted but we still need access to - its attributes in order to unmap windows properly. Since the - subwindows are going to get GC'd anyway as a result of the domain - going away, it is safer to just unmap them all while we know the - domain is still valid. */ - ERROR_CHECK_SUBWINDOW_CACHE (w); - window_unmap_subwindows (w); - /* In the loop (while t (split-window) (delete-window)) we end up with a tree of deleted windows which are all connected @@ -1927,13 +1777,13 @@ Since the window-configuration code doesn't need any of the pointers to other windows (they are all recreated from the window-config data), we set them all to nil so that we - are able to collect more actual garbage. */ + are able to collect more actual garbage. + */ w->next = Qnil; w->prev = Qnil; w->hchild = Qnil; w->vchild = Qnil; w->parent = Qnil; - w->subwindow_instance_cache = Qnil; w->dead = 1; @@ -1970,7 +1820,6 @@ window = Fselected_window (Qnil); else CHECK_WINDOW (window); - w = XWINDOW (window); /* It's okay to delete an already-deleted window. */ @@ -2004,12 +1853,6 @@ par = XWINDOW (parent); MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f); - /* It's quite likely that deleting a window will result in - subwindows needing to be deleted also (since they are cached - per-window). So we mark them as changed, so that the cachels will - get reset by redisplay and thus deleted subwindows can get - GC'd. */ - MARK_FRAME_SUBWINDOWS_CHANGED (f); /* Are we trying to delete any frame's selected window? Note that we could be dealing with a non-leaf window @@ -2741,7 +2584,7 @@ new_buffer = Fother_buffer (obj, Qnil, Qnil); if (NILP (new_buffer)) new_buffer = Fget_buffer_create (QSscratch); - Fset_window_buffer (w, new_buffer, Qnil); + Fset_window_buffer (w, new_buffer); if (EQ (w, Fselected_window (Qnil))) Fset_buffer (p->buffer); } @@ -2813,7 +2656,7 @@ /* Otherwise show a different buffer in the window. */ p->dedicated = Qnil; - Fset_window_buffer (w, another_buffer, Qnil); + Fset_window_buffer (w, another_buffer); if (EQ (w, Fselected_window (Qnil))) Fset_buffer (p->buffer); } @@ -3114,41 +2957,17 @@ window_min_height = MIN_SAFE_WINDOW_HEIGHT; } -static int -frame_min_height (struct frame *frame) -{ - /* For height, we have to see whether the frame has a minibuffer, and - whether it wants a modeline. */ - return (FRAME_MINIBUF_ONLY_P (frame) ? MIN_SAFE_WINDOW_HEIGHT - 1 - : (! FRAME_HAS_MINIBUF_P (frame)) ? MIN_SAFE_WINDOW_HEIGHT - : 2 * MIN_SAFE_WINDOW_HEIGHT - 1); -} - -/* Return non-zero if both frame sizes are less than or equal to - minimal allowed values. ROWS and COLS are in characters */ -int -frame_size_valid_p (struct frame *frame, int rows, int cols) -{ - return (rows >= frame_min_height (frame) - && cols >= MIN_SAFE_WINDOW_WIDTH); -} - -/* Return non-zero if both frame sizes are less than or equal to - minimal allowed values. WIDTH and HEIGHT are in pixels */ -int -frame_pixsize_valid_p (struct frame *frame, int width, int height) -{ - int rows, cols; - pixel_to_real_char_size (frame, width, height, &cols, &rows); - return frame_size_valid_p (frame, rows, cols); -} - /* If *ROWS or *COLS are too small a size for FRAME, set them to the minimum allowable size. */ void check_frame_size (struct frame *frame, int *rows, int *cols) { - int min_height = frame_min_height (frame); + /* For height, we have to see whether the frame has a minibuffer, and + whether it wants a modeline. */ + int min_height = + (FRAME_MINIBUF_ONLY_P (frame) ? MIN_SAFE_WINDOW_HEIGHT - 1 + : (! FRAME_HAS_MINIBUF_P (frame)) ? MIN_SAFE_WINDOW_HEIGHT + : 2 * MIN_SAFE_WINDOW_HEIGHT - 1); if (*rows < min_height) *rows = min_height; @@ -3298,14 +3117,11 @@ static int window_select_count; -DEFUN ("set-window-buffer", Fset_window_buffer, 2, 3, 0, /* +DEFUN ("set-window-buffer", Fset_window_buffer, 2, 2, 0, /* Make WINDOW display BUFFER as its contents. BUFFER can be a buffer or buffer name. - -With non-nil optional argument `norecord', do not modify the -global or per-frame buffer ordering. */ - (window, buffer, norecord)) + (window, buffer)) { Lisp_Object tem; struct window *w = decode_window (window); @@ -3364,9 +3180,6 @@ recompute_all_cached_specifiers_in_window (w); if (EQ (window, Fselected_window (Qnil))) { - if (NILP (norecord)) - Frecord_buffer (buffer); - Fset_buffer (buffer); } return Qnil; @@ -3391,9 +3204,8 @@ /* we have already caught dead-window errors */ if (!NILP (w->hchild) || !NILP (w->vchild)) error ("Trying to select non-leaf window"); - + w->use_time = make_int (++window_select_count); - if (EQ (window, old_selected_window)) return window; @@ -3517,10 +3329,6 @@ p->line_start_cache = Dynarr_new (line_start_cache); p->face_cachels = Dynarr_new (face_cachel); p->glyph_cachels = Dynarr_new (glyph_cachel); - p->subwindow_instance_cache = - make_lisp_hash_table (30, - HASH_TABLE_KEY_VALUE_WEAK, - HASH_TABLE_EQUAL); /* Put new into window structure in place of window */ replace_window (window, new); @@ -3558,7 +3366,7 @@ if (NILP (window)) window = Fselected_window (Qnil); else - CHECK_LIVE_WINDOW (window); + CHECK_WINDOW (window); o = XWINDOW (window); f = XFRAME (WINDOW_FRAME (o)); @@ -3674,7 +3482,7 @@ /* do this last (after the window is completely initialized and the mirror-dirty flag is set) so that specifier recomputation caused as a result of this will work properly and not abort. */ - Fset_window_buffer (new, o->buffer, Qt); + Fset_window_buffer (new, o->buffer); return new; } @@ -3736,6 +3544,12 @@ } static int +window_pixel_height (Lisp_Object window) +{ + return WINDOW_HEIGHT (XWINDOW (window)); +} + +static int window_pixel_height_to_char_height (struct window *w, int pixel_height, int include_gutters_p) { @@ -3748,8 +3562,8 @@ avail_height = (pixel_height - (include_gutters_p ? 0 : - window_top_window_gutter_height (w) + - window_bottom_window_gutter_height (w))); + window_top_gutter_height (w) + + window_bottom_gutter_height (w))); default_face_height_and_width (window, &defheight, &defwidth); @@ -3780,8 +3594,8 @@ avail_height = char_height * defheight; pixel_height = (avail_height + (include_gutters_p ? 0 : - window_top_window_gutter_height (w) + - window_bottom_window_gutter_height (w))); + window_top_gutter_height (w) + + window_bottom_gutter_height (w))); /* It's the calling function's responsibility to check these values and make sure they're not out of range. @@ -3794,12 +3608,11 @@ /* Return number of default lines of text can fit in the window W. If INCLUDE_GUTTERS_P is 1, include "gutter" space (modeline plus horizontal scrollbar) in the space that is used for the calculation. - This doesn't include space used by the frame gutters. */ int window_char_height (struct window *w, int include_gutters_p) { - return window_pixel_height_to_char_height (w, window_pixel_height (w), + return window_pixel_height_to_char_height (w, WINDOW_HEIGHT (w), include_gutters_p); } @@ -3879,8 +3692,6 @@ return WINDOW_WIDTH (XWINDOW (window)); } -/* Calculate the pixel of a window, optionally including margin space - but no vertical gutters. */ static int window_pixel_width_to_char_width (struct window *w, int pixel_width, int include_margins_p) @@ -3925,8 +3736,8 @@ avail_width = char_width * defwidth; pixel_width = (avail_width + - window_left_window_gutter_width (w, 0) + - window_right_window_gutter_width (w, 0) + + window_left_gutter_width (w, 0) + + window_right_gutter_width (w, 0) + (include_margins_p ? 0 : window_left_margin_width (w)) + (include_margins_p ? 0 : window_right_margin_width (w))); @@ -3965,12 +3776,6 @@ (widthflag ? window_min_width : MINI_WINDOW_P (XWINDOW (window)) \ ? 1 : window_min_height) -static int -window_pixheight (Lisp_Object w) -{ - return window_pixel_height (XWINDOW (w)); -} - /* Unlike set_window_pixheight, this function also changes the heights of the siblings so as to keep everything consistent. */ @@ -3986,7 +3791,7 @@ int *sizep; int (*sizefun) (Lisp_Object) = (widthflag ? window_pixel_width - : window_pixheight); + : window_pixel_height); void (*setsizefun) (Lisp_Object, int, int) = (widthflag ? set_window_pixwidth : set_window_pixheight); @@ -4121,8 +3926,6 @@ SET_LAST_MODIFIED (w, 0); SET_LAST_FACECHANGE (w); MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f); - /* overkill maybe, but better to be correct */ - MARK_FRAME_GUTTERS_CHANGED (f); } #undef MINSIZE #undef CURBEG @@ -4132,8 +3935,7 @@ -/* Scroll contents of window WINDOW up N lines. If N < (top line height / - average line height) then we just adjust the top clip. */ +/* Scroll contents of window WINDOW up N lines. */ void window_scroll (Lisp_Object window, Lisp_Object n, int direction, Error_behavior errb) @@ -4143,9 +3945,6 @@ int selected = EQ (window, Fselected_window (Qnil)); int value = 0; Lisp_Object point, tem; - display_line_dynarr *dla; - int fheight, fwidth, modeline = 0; - struct display_line* dl; if (selected) point = make_int (BUF_PT (b)); @@ -4175,7 +3974,6 @@ window, Qnil); Fset_marker (w->start[CURRENT_DISP], point, w->buffer); w->start_at_line_beg = beginning_of_line_p (b, XINT (point)); - WINDOW_TEXT_TOP_CLIP (w) = 0; MARK_WINDOWS_CHANGED (w); } @@ -4219,164 +4017,82 @@ { return; } - - /* Determine parameters to test for partial line scrolling with. */ - dla = window_display_lines (w, CURRENT_DISP); - - if (INTP (Vwindow_pixel_scroll_increment)) - fheight = XINT (Vwindow_pixel_scroll_increment); - else if (!NILP (Vwindow_pixel_scroll_increment)) - default_face_height_and_width (window, &fheight, &fwidth); - - if (Dynarr_length (dla) >= 1) - modeline = Dynarr_atp (dla, 0)->modeline; - - dl = Dynarr_atp (dla, modeline); - - if (value > 0) + else if (value > 0) { - /* Go for partial display line scrolling. This just means bumping - the clip by a reasonable amount and redisplaying, everything else - remains unchanged. */ - if (!NILP (Vwindow_pixel_scroll_increment) - && - Dynarr_length (dla) >= (1 + modeline) - && - (dl->ascent - dl->top_clip) - fheight * value > 0) + int vtarget; + Bufpos startp, old_start; + + old_start = marker_position (w->start[CURRENT_DISP]); + startp = vmotion (w, old_start, value, &vtarget); + + if (vtarget < value && + (w->window_end_pos[CURRENT_DISP] == -1 + || (BUF_Z (b) - w->window_end_pos[CURRENT_DISP] > BUF_ZV (b)))) { - WINDOW_TEXT_TOP_CLIP (w) += value * fheight; - MARK_WINDOWS_CHANGED (w); + maybe_signal_error (Qend_of_buffer, Qnil, Qwindow, errb); + return; } else { - int vtarget; - Bufpos startp, old_start; - - if (WINDOW_TEXT_TOP_CLIP (w)) - { - WINDOW_TEXT_TOP_CLIP (w) = 0; - MARK_WINDOWS_CHANGED (w); - } - - old_start = marker_position (w->start[CURRENT_DISP]); - startp = vmotion (w, old_start, value, &vtarget); - - if (vtarget < value && - (w->window_end_pos[CURRENT_DISP] == -1 - || (BUF_Z (b) - w->window_end_pos[CURRENT_DISP] > BUF_ZV (b)))) + set_marker_restricted (w->start[CURRENT_DISP], make_int (startp), + w->buffer); + w->force_start = 1; + w->start_at_line_beg = beginning_of_line_p (b, startp); + MARK_WINDOWS_CHANGED (w); + + if (!point_would_be_visible (w, startp, XINT (point))) { - maybe_signal_error (Qend_of_buffer, Qnil, Qwindow, errb); - return; - } - else - { - set_marker_restricted (w->start[CURRENT_DISP], make_int (startp), - w->buffer); - w->force_start = 1; - w->start_at_line_beg = beginning_of_line_p (b, startp); - MARK_WINDOWS_CHANGED (w); - - if (!point_would_be_visible (w, startp, XINT (point))) - { - if (selected) - BUF_SET_PT (b, startp); - else - set_marker_restricted (w->pointm[CURRENT_DISP], - make_int (startp), - w->buffer); - } + if (selected) + BUF_SET_PT (b, startp); + else + set_marker_restricted (w->pointm[CURRENT_DISP], + make_int (startp), + w->buffer); } } } else if (value < 0) { - /* Go for partial display line scrolling. This just means bumping - the clip by a reasonable amount and redisplaying, everything else - remains unchanged. */ - if (!NILP (Vwindow_pixel_scroll_increment) - && - Dynarr_length (dla) >= (1 + modeline) - && - (dl->ascent - dl->top_clip) - fheight * value < - (dl->ascent + dl->descent - dl->clip) - && - WINDOW_TEXT_TOP_CLIP (w) + value * fheight > 0) + int vtarget; + Bufpos startp, old_start; + + old_start = marker_position (w->start[CURRENT_DISP]); + startp = vmotion (w, old_start, value, &vtarget); + + if (vtarget > value + && marker_position (w->start[CURRENT_DISP]) == BUF_BEGV (b)) { - WINDOW_TEXT_TOP_CLIP (w) += value * fheight; - MARK_WINDOWS_CHANGED (w); + maybe_signal_error (Qbeginning_of_buffer, Qnil, Qwindow, errb); + return; } else { - int vtarget; - Bufpos startp, old_start; - - if (WINDOW_TEXT_TOP_CLIP (w)) - { - WINDOW_TEXT_TOP_CLIP (w) = 0; - MARK_WINDOWS_CHANGED (w); - } - - old_start = marker_position (w->start[CURRENT_DISP]); - startp = vmotion (w, old_start, value, &vtarget); - - if (vtarget > value - && marker_position (w->start[CURRENT_DISP]) == BUF_BEGV (b)) - { - maybe_signal_error (Qbeginning_of_buffer, Qnil, Qwindow, errb); - return; - } - else + set_marker_restricted (w->start[CURRENT_DISP], make_int (startp), + w->buffer); + w->force_start = 1; + w->start_at_line_beg = beginning_of_line_p (b, startp); + MARK_WINDOWS_CHANGED (w); + + if (!point_would_be_visible (w, startp, XINT (point))) { - set_marker_restricted (w->start[CURRENT_DISP], make_int (startp), - w->buffer); - w->force_start = 1; - w->start_at_line_beg = beginning_of_line_p (b, startp); - MARK_WINDOWS_CHANGED (w); - - /* #### Scroll back by less than a line. This code was - originally for scrolling over large pixmaps and it - loses when a line being *exposed* at the top of the - window is bigger than the current one. However, for - pixel based scrolling in general we can guess that - the line we are going to display is probably the same - size as the one we are on. In that instance we can - have a reasonable stab at a suitable top clip. Fixing - this properly is hard (and probably slow) as we would - have to call redisplay to figure out the exposed line - size. */ - if (!NILP (Vwindow_pixel_scroll_increment) - && Dynarr_length (dla) >= (1 + modeline) - && dl->ascent + fheight * value > 0) - { - WINDOW_TEXT_TOP_CLIP (w) = (dl->ascent + fheight * value); - } - - if (!point_would_be_visible (w, startp, XINT (point))) - { - Bufpos new_point; - - if (MINI_WINDOW_P (w)) - new_point = startp; - else - new_point = start_of_last_line (w, startp); - - if (selected) - BUF_SET_PT (b, new_point); - else - set_marker_restricted (w->pointm[CURRENT_DISP], - make_int (new_point), - w->buffer); - } + Bufpos new_point; + + if (MINI_WINDOW_P (w)) + new_point = startp; + else + new_point = start_of_last_line (w, startp); + + if (selected) + BUF_SET_PT (b, new_point); + else + set_marker_restricted (w->pointm[CURRENT_DISP], + make_int (new_point), + w->buffer); } } } else /* value == 0 && direction == -1 */ { - if (WINDOW_TEXT_TOP_CLIP (w)) - { - WINDOW_TEXT_TOP_CLIP (w) = 0; - MARK_WINDOWS_CHANGED (w); - } if (marker_position (w->start[CURRENT_DISP]) == BUF_BEGV (b)) { maybe_signal_error (Qbeginning_of_buffer, Qnil, Qwindow, errb); @@ -4414,6 +4130,7 @@ } } } + } DEFUN ("scroll-up", Fscroll_up, 0, 1, "_P", /* @@ -4587,7 +4304,7 @@ if (NILP (window)) window = Fselected_window (Qnil); else - CHECK_LIVE_WINDOW (window); + CHECK_WINDOW (window); w = XWINDOW (window); b = XBUFFER (w->buffer); @@ -4889,7 +4606,7 @@ int pixel_width; int pixel_height; int hscroll; - Charcount modeline_hscroll; + int modeline_hscroll; int parent_index; /* index into saved_windows */ int prev_index; /* index into saved_windows */ char start_at_line_beg; /* boolean */ @@ -4926,35 +4643,36 @@ #define XWINDOW_CONFIGURATION(x) XRECORD (x, window_configuration, struct window_config) #define XSETWINDOW_CONFIGURATION(x, p) XSETRECORD (x, p, window_configuration) #define WINDOW_CONFIGURATIONP(x) RECORDP (x, window_configuration) +#define GC_WINDOW_CONFIGURATIONP(x) GC_RECORDP (x, window_configuration) #define CHECK_WINDOW_CONFIGURATION(x) CHECK_RECORD (x, window_configuration) static Lisp_Object -mark_window_config (Lisp_Object obj) +mark_window_config (Lisp_Object obj, void (*markobj) (Lisp_Object)) { struct window_config *config = XWINDOW_CONFIGURATION (obj); int i; - mark_object (config->current_window); - mark_object (config->current_buffer); - mark_object (config->minibuffer_scroll_window); - mark_object (config->root_window); + markobj (config->current_window); + markobj (config->current_buffer); + markobj (config->minibuffer_scroll_window); + markobj (config->root_window); for (i = 0; i < config->saved_windows_count; i++) { struct saved_window *s = SAVED_WINDOW_N (config, i); - mark_object (s->window); - mark_object (s->buffer); - mark_object (s->start); - mark_object (s->pointm); - mark_object (s->sb_point); - mark_object (s->mark); + markobj (s->window); + markobj (s->buffer); + markobj (s->start); + markobj (s->pointm); + markobj (s->sb_point); + markobj (s->mark); #if 0 /* #### This looked like this. I do not see why specifier cached values should not be marked, as such specifiers as toolbars might have GC-able instances. Freed configs are not marked, aren't they? -- kkm */ - mark_object (s->dedicated); + markobj (s->dedicated); #else -#define WINDOW_SLOT(slot, compare) mark_object (s->slot) +#define WINDOW_SLOT(slot, compare) ((void) (markobj (s->slot))) #include "winslots.h" #endif } @@ -4970,9 +4688,9 @@ } static size_t -sizeof_window_config (const void *h) +sizeof_window_config (CONST void *h) { - const struct window_config *c = (const struct window_config *) h; + CONST struct window_config *c = (CONST struct window_config *) h; return sizeof_window_config_for_n_windows (c->saved_windows_count); } @@ -4993,7 +4711,7 @@ window_configuration, mark_window_config, print_window_config, - 0, 0, 0, 0, sizeof_window_config, + 0, 0, 0, sizeof_window_config, struct window_config); @@ -5151,7 +4869,7 @@ int previous_pixel_width; int previous_minibuf_height, previous_minibuf_top,previous_minibuf_width; int real_font_height; - int converted_minibuf_height,target_minibuf_height; + int converted_minibuf_height,target_minibuf_height; int specpdl_count = specpdl_depth (); GCPRO1 (configuration); @@ -5216,20 +4934,15 @@ mark_windows_in_use (f, 1); - /* Force subwindows to be reinstantiated. They are all going - anyway and if we don't do this GC may not happen between now - and the next time we check their integrity. */ - reset_frame_subwindow_instance_cache (f); - #if 0 /* JV: This is bogus, First of all, the units are inconsistent. The frame sizes are measured - in characters but the window sizes are stored in pixels. So if a + in characters but the window sizes are stored in pixels. So if a font size change happened between saving and restoring, the frame "sizes" maybe equal but the windows still should be resized. This is tickled alot by the new "character size stays constant" policy in 21.0. It leads to very wierd - glitches (and possibly crashes when asserts are tickled). + glitches (and possibly craches when asserts are tickled). Just changing the units doens't help because changing the toolbar configuration can also change the pixel positions. @@ -5245,7 +4958,7 @@ || config->frame_width != FRAME_WIDTH (f)) change_frame_size (f, config->frame_height, config->frame_width, 0); #endif - + previous_pixel_top = XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_top; previous_pixel_height = XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_height; previous_pixel_left = XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_left; @@ -5255,7 +4968,7 @@ default_face_height_and_width (frame, &real_font_height, 0); assert(real_font_height > 0); - + if (FRAME_HAS_MINIBUF_P (f) && ! FRAME_MINIBUF_ONLY_P (f)) { previous_minibuf_height @@ -5268,14 +4981,13 @@ else { previous_minibuf_height = 0; - previous_minibuf_top = 0; previous_minibuf_width = 0; } converted_minibuf_height = (previous_minibuf_height % real_font_height) == 0 ? - (previous_minibuf_height / real_font_height ) : /* lines */ previous_minibuf_height; /* pixels */ - + /* Temporarily avoid any problems with windows that are smaller than they are supposed to be. */ window_min_height = 1; @@ -5302,10 +5014,6 @@ w->glyph_cachels = Dynarr_new (glyph_cachel); if (!w->line_start_cache) w->line_start_cache = Dynarr_new (line_start_cache); - w->gutter_extent_modiff[0] = 0; - w->gutter_extent_modiff[1] = 0; - w->gutter_extent_modiff[2] = 0; - w->gutter_extent_modiff[3] = 0; w->dead = 0; if (p->parent_index >= 0) @@ -5363,19 +5071,11 @@ w->hscroll = p->hscroll; w->modeline_hscroll = p->modeline_hscroll; w->line_cache_last_updated = Qzero; - /* The subwindow instance cache isn't preserved across - window configurations, and in fact doing so would be - wrong. We just reset to zero and then redisplay will fill - it up as needed. */ - w->subwindow_instance_cache = - make_lisp_hash_table (30, - HASH_TABLE_KEY_VALUE_WEAK, - HASH_TABLE_EQUAL); SET_LAST_MODIFIED (w, 1); SET_LAST_FACECHANGE (w); w->config_mark = 0; -#define WINDOW_SLOT(slot, compare) w->slot = p->slot +#define WINDOW_SLOT(slot, compare) w->slot = p->slot; #include "winslots.h" /* Reinstall the saved buffer and pointers into it. */ @@ -5469,7 +5169,7 @@ #### Now we get more cases correct then ever before, but are we treating all? For instance what if the frames minibuf window - is no longer the same one? + is no longer the same one? */ target_minibuf_height = previous_minibuf_height; if (converted_minibuf_height && @@ -5492,7 +5192,7 @@ set_window_pixwidth (FRAME_MINIBUF_WINDOW (f), previous_minibuf_width, 0); } - + /* This is a better way to deal with frame resizing, etc. What we _actually_ want is for the old (just restored) root window to fit @@ -5507,13 +5207,12 @@ /* Note that this function also updates the subwindow "pixel_left"s */ set_window_pixwidth (FRAME_ROOT_WINDOW (f), previous_pixel_width, 0); - + /* If restoring in the current frame make the window current, otherwise just update the frame selected_window slot to be the restored current_window. */ if (f == selected_frame ()) { -#if 0 /* When using `pop-window-configuration', often the minibuffer ends up as the selected window even though it's not active ... I really don't know the cause of this, but it should never @@ -5522,25 +5221,15 @@ #### Find out why this is really going wrong. */ if (!minibuf_level && MINI_WINDOW_P (XWINDOW (config->current_window))) - window_to_select = Fnext_window (config->current_window, - Qnil, Qnil, Qnil); + Fselect_window (Fnext_window (config->current_window, + Qnil, Qnil, Qnil), + Qnil); else - window_to_select = config->current_window; -#endif - /* Do this last so that buffer stacking is calculated - correctly. */ - Fselect_window (config->current_window, Qnil); - + Fselect_window (config->current_window, Qnil); if (!NILP (new_current_buffer)) - { - Fset_buffer (new_current_buffer); - Frecord_buffer (new_current_buffer); - } + Fset_buffer (new_current_buffer); else - { - Fset_buffer (XWINDOW (config->current_window)->buffer); - Frecord_buffer (XWINDOW (config->current_window)->buffer); - } + Fset_buffer (XWINDOW (Fselected_window (Qnil))->buffer); } else set_frame_selected_window (f, config->current_window); @@ -5660,7 +5349,7 @@ p->hscroll = w->hscroll; p->modeline_hscroll = w->modeline_hscroll; -#define WINDOW_SLOT(slot, compare) p->slot = w->slot +#define WINDOW_SLOT(slot, compare) p->slot = w->slot; #include "winslots.h" if (!NILP (w->buffer)) @@ -5749,14 +5438,7 @@ /* config->frame_width = FRAME_WIDTH (f); config->frame_height = FRAME_HEIGHT (f); */ - /* When using `push-window-configuration', often the minibuffer ends - up as the selected window because functions run as the result of - user interaction e.g. hyper-apropros. It seems to me the sensible - thing to do is not record the minibuffer here. */ - if (FRAME_MINIBUF_ONLY_P (f) || minibuf_level) - config->current_window = FRAME_SELECTED_WINDOW (f); - else - config->current_window = FRAME_LAST_NONMINIBUF_WINDOW (f); + config->current_window = FRAME_SELECTED_WINDOW (f); XSETBUFFER (config->current_buffer, current_buffer); config->minibuffer_scroll_window = Vminibuffer_scroll_window; config->root_window = FRAME_ROOT_WINDOW (f); @@ -5767,11 +5449,11 @@ /* save the minibuffer height using the heuristics from change_frame_size_1 */ - + XSETFRAME (frame, f); /* frame could have been nil ! */ default_face_height_and_width (frame, &real_font_height, 0); assert(real_font_height > 0); - + if (FRAME_HAS_MINIBUF_P (f) && ! FRAME_MINIBUF_ONLY_P (f)) minibuf_height = XWINDOW(FRAME_MINIBUF_WINDOW(f))->pixel_height; else @@ -5809,78 +5491,6 @@ return unbind_to (speccount, val); } -DEFUN ("current-pixel-column", Fcurrent_pixel_column, 0, 2, 0, /* -Return the horizontal pixel position of POS in window. -Beginning of line is column 0. This is calculated using the redisplay -display tables. If WINDOW is nil, the current window is assumed. -If POS is nil, point is assumed. Note that POS must be visible for -a non-nil result to be returned. -*/ - (window, pos)) -{ - struct window* w = decode_window (window); - display_line_dynarr *dla = window_display_lines (w, CURRENT_DISP); - - struct display_line *dl = 0; - struct display_block *db = 0; - struct rune* rb = 0; - int y = w->last_point_y[CURRENT_DISP]; - int x = w->last_point_x[CURRENT_DISP]; - - if (MINI_WINDOW_P (w)) - return Qnil; - - if (y<0 || x<0 || y >= Dynarr_length (dla) || !NILP (pos)) - { - int first_line, i; - Bufpos point; - - if (NILP (pos)) - pos = Fwindow_point (window); - - CHECK_INT (pos); - point = XINT (pos); - - if (Dynarr_length (dla) && Dynarr_atp (dla, 0)->modeline) - first_line = 1; - else - first_line = 0; - - for (i = first_line; i < Dynarr_length (dla); i++) - { - dl = Dynarr_atp (dla, i); - /* find the vertical location first */ - if (point >= dl->bufpos && point <= dl->end_bufpos) - { - db = get_display_block_from_line (dl, TEXT); - for (i = 0; i < Dynarr_length (db->runes); i++) - { - rb = Dynarr_atp (db->runes, i); - if (point <= rb->bufpos) - goto found_bufpos; - } - return Qnil; - } - } - return Qnil; - found_bufpos: - ; - } - else - { - /* optimised case */ - dl = Dynarr_atp (dla, y); - db = get_display_block_from_line (dl, TEXT); - - if (x >= Dynarr_length (db->runes)) - return Qnil; - - rb = Dynarr_atp (db->runes, x); - } - - return make_int (rb->xpos - WINDOW_LEFT (w)); -} - #ifdef DEBUG_XEMACS /* This is short and simple in elisp, but... it was written to debug @@ -5896,15 +5506,15 @@ child = Fwindow_first_hchild (window); for (i = level; i > 0; i--) - stderr_out ("\t"); - - stderr_out ("#<window"); + putc ('\t', stderr); + + fputs ("#<window", stderr); { Lisp_Object buffer = XWINDOW (window)->buffer; if (!NILP (buffer) && BUFFERP (buffer)) - stderr_out (" on %s", XSTRING_DATA (XBUFFER (buffer)->name)); + fprintf (stderr, " on %s", XSTRING_DATA (XBUFFER (buffer)->name)); } - stderr_out (" 0x%x>", XWINDOW (window)->header.uid); + fprintf (stderr, " 0x%x>", XWINDOW (window)->header.uid); while (!NILP (child)) { @@ -5930,12 +5540,11 @@ void syms_of_window (void) { - INIT_LRECORD_IMPLEMENTATION (window); - INIT_LRECORD_IMPLEMENTATION (window_configuration); - defsymbol (&Qwindowp, "windowp"); defsymbol (&Qwindow_live_p, "window-live-p"); defsymbol (&Qwindow_configurationp, "window-configuration-p"); + defsymbol (&Qscroll_up, "scroll-up"); + defsymbol (&Qscroll_down, "scroll-down"); defsymbol (&Qtemp_buffer_show_hook, "temp-buffer-show-hook"); defsymbol (&Qdisplay_buffer, "display-buffer"); @@ -5951,7 +5560,6 @@ #endif DEFSUBR (Fselected_window); - DEFSUBR (Flast_nonminibuf_window); DEFSUBR (Fminibuffer_window); DEFSUBR (Fwindow_minibuffer_p); DEFSUBR (Fwindowp); @@ -5962,7 +5570,6 @@ DEFSUBR (Fwindow_previous_child); DEFSUBR (Fwindow_parent); DEFSUBR (Fwindow_lowest_p); - DEFSUBR (Fwindow_truncated_p); DEFSUBR (Fwindow_highest_p); DEFSUBR (Fwindow_leftmost_p); DEFSUBR (Fwindow_rightmost_p); @@ -5972,27 +5579,26 @@ DEFSUBR (Fwindow_height); DEFSUBR (Fwindow_displayed_height); DEFSUBR (Fwindow_width); - DEFSUBR (Fwindow_full_width); DEFSUBR (Fwindow_pixel_height); DEFSUBR (Fwindow_pixel_width); - DEFSUBR (Fwindow_text_area_height); DEFSUBR (Fwindow_text_area_pixel_height); DEFSUBR (Fwindow_displayed_text_pixel_height); DEFSUBR (Fwindow_text_area_pixel_width); DEFSUBR (Fwindow_hscroll); - DEFSUBR (Fset_window_hscroll); +#ifdef MODELINE_IS_SCROLLABLE DEFSUBR (Fmodeline_hscroll); DEFSUBR (Fset_modeline_hscroll); +#endif /* MODELINE_IS_SCROLLABLE */ #if 0 /* bogus FSF crock */ DEFSUBR (Fwindow_redisplay_end_trigger); DEFSUBR (Fset_window_redisplay_end_trigger); #endif + DEFSUBR (Fset_window_hscroll); DEFSUBR (Fwindow_pixel_edges); DEFSUBR (Fwindow_text_area_pixel_edges); DEFSUBR (Fwindow_point); DEFSUBR (Fwindow_start); DEFSUBR (Fwindow_end); - DEFSUBR (Fwindow_last_line_visible_height); DEFSUBR (Fset_window_point); DEFSUBR (Fset_window_start); DEFSUBR (Fwindow_dedicated_p); @@ -6032,30 +5638,14 @@ DEFSUBR (Fset_window_configuration); DEFSUBR (Fcurrent_window_configuration); DEFSUBR (Fsave_window_excursion); - DEFSUBR (Fcurrent_pixel_column); -} - -void -reinit_vars_of_window (void) -{ - int i; - /* Make sure all windows get marked */ - minibuf_window = Qnil; - staticpro_nodump (&minibuf_window); - - for (i = 0; i < countof (Vwindow_configuration_free_list); i++) - { - Vwindow_configuration_free_list[i] = - make_lcrecord_list (sizeof_window_config_for_n_windows (i + 1), - &lrecord_window_configuration); - staticpro_nodump (&Vwindow_configuration_free_list[i]); - } } void vars_of_window (void) { - reinit_vars_of_window (); + /* Make sure all windows get marked */ + minibuf_window = Qnil; + staticpro (&minibuf_window); DEFVAR_BOOL ("scroll-on-clipped-lines", &scroll_on_clipped_lines /* *Non-nil means to scroll if point lands on a line which is clipped. @@ -6086,13 +5676,6 @@ */ ); Vother_window_scroll_buffer = Qnil; - DEFVAR_LISP ("window-pixel-scroll-increment", &Vwindow_pixel_scroll_increment /* -*Number of pixels to scroll by per requested line. -If nil then normal line scrolling occurs regardless of line height. -If t then scrolling is done in increments equal to the height of the default face. -*/ ); - Vwindow_pixel_scroll_increment = Qt; - DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines /* *Number of lines of continuity when scrolling by screenfuls. */ ); @@ -6107,6 +5690,18 @@ *Delete any window less than this wide. */ ); window_min_width = 10; + + { + int i; + + for (i = 0; i < countof (Vwindow_configuration_free_list); i++) + { + Vwindow_configuration_free_list[i] = + make_lcrecord_list (sizeof_window_config_for_n_windows (i + 1), + &lrecord_window_configuration); + staticpro (&Vwindow_configuration_free_list[i]); + } + } } void @@ -6127,7 +5722,8 @@ Fadd_spec_to_specifier (Vmodeline_shadow_thickness, make_int (2), Qnil, Qnil, Qnil); set_specifier_caching (Vmodeline_shadow_thickness, - offsetof (struct window, modeline_shadow_thickness), + slot_offset (struct window, + modeline_shadow_thickness), modeline_shadow_thickness_changed, 0, 0); @@ -6139,7 +5735,8 @@ set_specifier_fallback (Vhas_modeline_p, list1 (Fcons (Qnil, Qt))); set_specifier_caching (Vhas_modeline_p, - offsetof (struct window, has_modeline_p), + slot_offset (struct window, + has_modeline_p), /* #### It's strange that we need a special flag to indicate that the shadow-thickness has changed, but not one to indicate that @@ -6161,8 +5758,8 @@ set_specifier_fallback (Vvertical_divider_always_visible_p, list1 (Fcons (Qnil, Qt))); set_specifier_caching (Vvertical_divider_always_visible_p, - offsetof (struct window, - vertical_divider_always_visible_p), + slot_offset (struct window, + vertical_divider_always_visible_p), vertical_divider_changed_in_window, 0, 0); @@ -6176,8 +5773,8 @@ Fadd_spec_to_specifier (Vvertical_divider_shadow_thickness, make_int (2), Qnil, Qnil, Qnil); set_specifier_caching (Vvertical_divider_shadow_thickness, - offsetof (struct window, - vertical_divider_shadow_thickness), + slot_offset (struct window, + vertical_divider_shadow_thickness), vertical_divider_changed_in_window, 0, 0); DEFVAR_SPECIFIER ("vertical-divider-line-width", &Vvertical_divider_line_width /* @@ -6207,8 +5804,8 @@ set_specifier_fallback (Vvertical_divider_line_width, fb); } set_specifier_caching (Vvertical_divider_line_width, - offsetof (struct window, - vertical_divider_line_width), + slot_offset (struct window, + vertical_divider_line_width), vertical_divider_changed_in_window, 0, 0); @@ -6237,7 +5834,8 @@ set_specifier_fallback (Vvertical_divider_spacing, fb); } set_specifier_caching (Vvertical_divider_spacing, - offsetof (struct window, vertical_divider_spacing), + slot_offset (struct window, + vertical_divider_spacing), vertical_divider_changed_in_window, 0, 0); }