xemacs-beta: src/gutter.c comparison

comparison src/gutter.c @ 5495:1f0b15040456

Merge.

author	Aidan Kehoe <kehoea@parhasard.net>
date	Sun, 01 May 2011 18:44:03 +0100
parents	308d34e9f07d
children	56144c8593a8

comparison

equal deleted inserted replaced

-:861f2601a38b
+:1f0b15040456
 /* Gutter implementation.
 Copyright (C) 1999, 2000 Andy Piper.
+Copyright (C) 2010 Ben Wing.
 This file is part of XEmacs.
-XEmacs is free software; you can redistribute it and/or modify it
+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
+Free Software Foundation, either version 3 of the License, or (at your
-later version.
+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
+along with XEmacs.  If not, see <http://www.gnu.org/licenses/>. */
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
 /* Synched up with: Not in FSF. */
 /* written by Andy Piper <andy@xemacs.org> with specifiers partially
 ripped-off from toolbar.c */
 #include "glyphs.h"
 #include "redisplay.h"
 #include "window.h"
 #include "gutter.h"
-Lisp_Object Vgutter[4];
+Lisp_Object Vgutter[NUM_EDGES];
-Lisp_Object Vgutter_size[4];
+Lisp_Object Vgutter_size[NUM_EDGES];
-Lisp_Object Vgutter_visible_p[4];
+Lisp_Object Vgutter_visible_p[NUM_EDGES];
-Lisp_Object Vgutter_border_width[4];
+Lisp_Object Vgutter_border_width[NUM_EDGES];
 Lisp_Object Vdefault_gutter, Vdefault_gutter_visible_p;
 Lisp_Object Vdefault_gutter_width, Vdefault_gutter_height;
 Lisp_Object Vdefault_gutter_border_width;
 Lisp_Object Qgutter_size;
 Lisp_Object Qgutter_visible;
 Lisp_Object Qdefault_gutter_position_changed_hook;
 static void
-update_gutter_geometry (struct frame *f, enum gutter_pos pos);
+update_gutter_geometry (struct frame *f, enum edge_pos pos);
-#define SET_GUTTER_WAS_VISIBLE_FLAG(frame, pos, flag)	\
-do {							\
-switch (pos)					\
-{							\
-case TOP_GUTTER:					\
-	(frame)->top_gutter_was_visible = flag;		\
-	break;						\
-case BOTTOM_GUTTER:				\
-	(frame)->bottom_gutter_was_visible = flag;	\
-	break;						\
-case LEFT_GUTTER:					\
-	(frame)->left_gutter_was_visible = flag;	\
-	break;						\
-case RIGHT_GUTTER:				\
-	(frame)->right_gutter_was_visible = flag;	\
-	break;						\
-default:						\
-	ABORT ();					\
-}							\
-} while (0)
-static int gutter_was_visible (struct frame* frame, enum gutter_pos pos)
-{
-switch (pos)
-{
-case TOP_GUTTER:
-return frame->top_gutter_was_visible;
-case BOTTOM_GUTTER:
-return frame->bottom_gutter_was_visible;
-case LEFT_GUTTER:
-return frame->left_gutter_was_visible;
-case RIGHT_GUTTER:
-return frame->right_gutter_was_visible;
-default:
-ABORT ();
-	return 0;	/* To keep the compiler happy */
-}
-}
 #if 0
 static Lisp_Object
 frame_topmost_window (struct frame *f)
 {
 us the actual height, width and contents of the gutter, but if we
 use this for calculating the gutter positions we run into trouble
 if it is not the window nearest the gutter. Instead we predetermine
 the nearest window and then use that.*/
 static void
-get_gutter_coords (struct frame *f, enum gutter_pos pos, int *x, int *y,
+get_gutter_coords (struct frame *f, enum edge_pos pos, int *x, int *y,
 		   int *width, int *height)
 {
-struct window
+/* We use the bottommost window (not the minibuffer, but the bottommost
-* bot = XWINDOW (frame_bottommost_window (f));
+non-minibuffer window) rather than any FRAME_BOTTOM_GUTTER_START
+because the gutter goes *above* the minibuffer -- for this same reason,
+FRAME_BOTTOM_GUTTER_START isn't currently defined. */
+struct window *bot = XWINDOW (frame_bottommost_window (f));
 /* The top and bottom gutters take precedence over the left and
 right. */
 switch (pos)
 {
-case TOP_GUTTER:
+case TOP_EDGE:
-*x = FRAME_LEFT_BORDER_END (f);
+*x = FRAME_LEFT_GUTTER_START (f);
-*y = FRAME_TOP_BORDER_END (f);
+*y = FRAME_TOP_GUTTER_START (f);
-*width = FRAME_RIGHT_BORDER_START (f)
+*width = FRAME_RIGHT_GUTTER_END (f) - *x;
-	- FRAME_LEFT_BORDER_END (f);
 *height = FRAME_TOP_GUTTER_BOUNDS (f);
 break;
-case BOTTOM_GUTTER:
+case BOTTOM_EDGE:
-*x = FRAME_LEFT_BORDER_END (f);
+*x = FRAME_LEFT_GUTTER_START (f);
+#ifdef BOTTOM_GUTTER_IS_OUTSIDE_MINIBUFFER
+*y = FRAME_BOTTOM_GUTTER_START (f);
+#else
 *y = WINDOW_BOTTOM (bot);
-*width = FRAME_RIGHT_BORDER_START (f)
+#endif
-	- FRAME_LEFT_BORDER_END (f);
+*width = FRAME_RIGHT_GUTTER_END (f) - *x;
 *height = FRAME_BOTTOM_GUTTER_BOUNDS (f);
 break;
-case LEFT_GUTTER:
+case LEFT_EDGE:
-*x = FRAME_LEFT_BORDER_END (f);
+*x = FRAME_LEFT_GUTTER_START (f);
-*y = FRAME_TOP_BORDER_END (f) + FRAME_TOP_GUTTER_BOUNDS (f);
+*y = FRAME_TOP_GUTTER_END (f);
 *width = FRAME_LEFT_GUTTER_BOUNDS (f);
-*height = WINDOW_BOTTOM (bot)
+*height = WINDOW_BOTTOM (bot) - *y;
-	- (FRAME_TOP_BORDER_END (f) + FRAME_TOP_GUTTER_BOUNDS (f));
 break;
-case RIGHT_GUTTER:
+case RIGHT_EDGE:
-*x = FRAME_RIGHT_BORDER_START (f)
+*x = FRAME_RIGHT_GUTTER_START (f);
-	- FRAME_RIGHT_GUTTER_BOUNDS (f);
+*y = FRAME_TOP_GUTTER_END (f);
-*y = FRAME_TOP_BORDER_END (f) + FRAME_TOP_GUTTER_BOUNDS (f);
 *width = FRAME_RIGHT_GUTTER_BOUNDS (f);
-*height = WINDOW_BOTTOM (bot)
+*height = WINDOW_BOTTOM (bot) - *y;
-	- (FRAME_TOP_BORDER_END (f) + FRAME_TOP_GUTTER_BOUNDS (f));
 break;
 default:
 ABORT ();
 }
 window. 0 means the display_box is in the gutter but the
 display_glyph_area is not. */
 int display_boxes_in_gutter_p (struct frame *f, struct display_box* db,
 			       struct display_glyph_area* dga)
 {
-enum gutter_pos pos;
+enum edge_pos pos;
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 {
 if (FRAME_GUTTER_VISIBLE (f, pos))
 	{
 	  int x, y, width, height;
 	  get_gutter_coords (f, pos, &x, &y, &width, &height);
 }
 /* Convert the gutter specifier into something we can actually
 display. */
 static Lisp_Object construct_window_gutter_spec (struct window* w,
-						 enum gutter_pos pos)
+						 enum edge_pos pos)
 {
 Lisp_Object rest, *args;
 int nargs = 0;
 Lisp_Object gutter = RAW_WINDOW_GUTTER (w, pos);
 /* Sizing gutters is a pain so we try and help the user by determining
 what height will accommodate all lines. This is useless on left and
 right gutters as we always have a maximal number of lines. */
 static int
-calculate_gutter_size_from_display_lines (enum gutter_pos pos,
+calculate_gutter_size_from_display_lines (enum edge_pos pos,
 					  display_line_dynarr* ddla)
 {
 int size = 0;
 struct display_line *dl;
 /* For top and bottom the calculation is easy. */
-if (pos == TOP_GUTTER || pos == BOTTOM_GUTTER)
+if (pos == TOP_EDGE || pos == BOTTOM_EDGE)
 {
 /* grab coordinates of last line  */
 if (Dynarr_length (ddla))
 	{
 	  dl = Dynarr_atp (ddla, Dynarr_length (ddla) - 1);
 return size;
 }
 static Lisp_Object
-calculate_gutter_size (struct window *w, enum gutter_pos pos)
+calculate_gutter_size (struct window *w, enum edge_pos pos)
 {
 struct frame* f = XFRAME (WINDOW_FRAME (w));
 display_line_dynarr *ddla;
 Lisp_Object ret = Qnil;
 count = enter_redisplay_critical_section ();
 ddla = Dynarr_new (display_line);
 /* generate some display lines */
 generate_displayable_area (w, WINDOW_GUTTER (w, pos),
-				 FRAME_LEFT_BORDER_END (f),
+				 FRAME_LEFT_GUTTER_START (f),
-				 FRAME_TOP_BORDER_END (f),
+				 FRAME_TOP_GUTTER_START (f),
-				 FRAME_RIGHT_BORDER_START (f)
+				 FRAME_RIGHT_GUTTER_END (f)
-				 - FRAME_LEFT_BORDER_END (f),
+				 - FRAME_LEFT_GUTTER_START (f),
-				 FRAME_BOTTOM_BORDER_START (f)
+#ifdef BOTTOM_GUTTER_IS_OUTSIDE_MINIBUFFER
-				 - FRAME_TOP_BORDER_END (f),
+				 FRAME_BOTTOM_GUTTER_END (f)
+#else
+				 /* #### GEOM! This is how it used to read,
+				    and this includes both gutter and
+				    minibuffer below it.  Not clear whether
+				    it was intended that way. --ben */
+				 FRAME_BOTTOM_INTERNAL_BORDER_START (f)
+#endif
+				 - FRAME_TOP_GUTTER_START (f),
 				 ddla, 0, DEFAULT_INDEX);
 /* Let GC happen again. */
 exit_redisplay_critical_section (count);
 return ret;
 }
 static void
-output_gutter (struct frame *f, enum gutter_pos pos, int force)
+output_gutter (struct frame *f, enum edge_pos pos, int force)
 {
 Lisp_Object window = FRAME_LAST_NONMINIBUF_WINDOW (f);
 struct device *d = XDEVICE (f->device);
 struct window* w = XWINDOW (window);
 int x, y, width, height, ypos;
 cdla_len != Dynarr_length (ddla) ||
 (f->extents_changed && w->gutter_extent_modiff[pos]))
 {
 #ifdef DEBUG_GUTTERS
 stderr_out ("gutter redisplay [%s %dx%d@%d+%d] triggered by %s,\n",
-	      pos == TOP_GUTTER ? "TOP" :
+	      pos == TOP_EDGE ? "TOP" :
-	      pos == BOTTOM_GUTTER ? "BOTTOM" :
+	      pos == BOTTOM_EDGE ? "BOTTOM" :
-	      pos == LEFT_GUTTER ? "LEFT" : "RIGHT",
+	      pos == LEFT_EDGE ? "LEFT" : "RIGHT",
 	      width, height, x, y, force ? "force" :
 	      f->faces_changed ? "f->faces_changed" :
 	      f->frame_changed ? "f->frame_changed" :
 	      f->gutter_changed ? "f->gutter_changed" :
 	      f->glyphs_changed ? "f->glyphs_changed" :
 	}
 /* If the number of display lines has shrunk, adjust. */
 if (cdla_len > Dynarr_length (ddla))
 	{
-	  Dynarr_set_length (cdla, Dynarr_length (ddla));
+	  Dynarr_set_lengthr (cdla, Dynarr_length (ddla));
 	}
 /* grab coordinates of last line and blank after it. */
 if (Dynarr_length (ddla) > 0)
 	{
 w->gutter_extent_modiff [pos] = 0;
 }
 static void
-clear_gutter (struct frame *f, enum gutter_pos pos)
+clear_gutter (struct frame *f, enum edge_pos pos)
 {
 int x, y, width, height;
 Lisp_Object window = FRAME_LAST_NONMINIBUF_WINDOW (f);
 face_index findex = get_builtin_face_cache_index (XWINDOW (window),
 						    Vwidget_face);
 get_gutter_coords (f, pos, &x, &y, &width, &height);
-SET_GUTTER_WAS_VISIBLE_FLAG (f, pos, 0);
+f->gutter_was_visible[pos] = 0;
 redisplay_clear_region (window, findex, x, y, width, height);
 }
 /* [[#### I don't currently believe that redisplay needs to mark the
 /* See the comment in image_instantiate_cache_result as to why marking
 the glyph will also mark the image_instance. */
 void
 mark_gutters (struct frame *f)
 {
-enum gutter_pos pos;
+enum edge_pos pos;
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 {
 if (f->current_display_lines[pos])
 	mark_redisplay_structs (f->current_display_lines[pos]);
 /* [[#### Do we really need to mark the desired lines?]]
 	 ALWAYS mark everything. --ben */
 Lisp_Object frmcons, devcons, concons;
 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
 {
 struct frame *f = XFRAME (XCAR (frmcons));
-enum gutter_pos pos;
+enum edge_pos pos;
 Lisp_Object window = FRAME_LAST_NONMINIBUF_WINDOW (f);
 struct window* w = XWINDOW (window);
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 	{
 	  if (EQ (WINDOW_GUTTER (w, pos), obj))
 	    {
 	      w->gutter_extent_modiff[pos]++;
 	    }
 }
 /* We have to change the gutter geometry separately to the gutter
 update since it needs to occur outside of redisplay proper. */
 static void
-update_gutter_geometry (struct frame *f, enum gutter_pos pos)
+update_gutter_geometry (struct frame *f, enum edge_pos pos)
 {
 /* If the gutter geometry has changed then re-layout the
 frame. If we are in display there is almost no point in doing
 anything else since the frame size changes will be delayed
 until we are out of redisplay proper. */
 if (FRAME_GUTTER_BOUNDS (f, pos) != f->current_gutter_bounds[pos])
 {
 int width, height;
-pixel_to_char_size (f, FRAME_PIXWIDTH (f), FRAME_PIXHEIGHT (f),
+pixel_to_frame_unit_size (f, FRAME_PIXWIDTH (f), FRAME_PIXHEIGHT (f),
 			  &width, &height);
-change_frame_size (f, height, width, 0);
+change_frame_size (f, width, height, 0);
 MARK_FRAME_LAYOUT_CHANGED (f);
 }
 /* Mark sizes as up-to-date. */
 f->current_gutter_bounds[pos] = FRAME_GUTTER_BOUNDS (f, pos);
 {
 if (f->gutter_changed
 || f->frame_layout_changed
 || f->windows_structure_changed)
 {
-enum gutter_pos pos;
+enum edge_pos pos;
 /* If the gutter geometry has changed then re-layout the
 	 frame. If we are in display there is almost no point in doing
 	 anything else since the frame size changes will be delayed
 	 until we are out of redisplay proper. */
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 	{
 	  update_gutter_geometry (f, pos);
 	}
 }
 }
 f->gutter_changed || f->glyphs_changed ||
 f->size_changed || f->subwindows_changed ||
 f->windows_changed || f->windows_structure_changed ||
 f->extents_changed || f->frame_layout_changed)
 {
-enum gutter_pos pos;
+enum edge_pos pos;
 /* We don't actually care about these when outputting the gutter
 	 so locally disable them. */
 int local_clip_changed = f->clip_changed;
 int local_buffers_changed = f->buffers_changed;
 f->clip_changed = 0;
 f->buffers_changed = 0;
 /* and output */
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 	{
 	  if (FRAME_GUTTER_VISIBLE (f, pos))
 	      output_gutter (f, pos, 0);
-	  else if (gutter_was_visible (f, pos))
+	  else if (f->gutter_was_visible[pos])
 	      clear_gutter (f, pos);
 	}
 f->clip_changed = local_clip_changed;
 f->buffers_changed = local_buffers_changed;
 }
 void
 reset_gutter_display_lines (struct frame* f)
 {
-enum gutter_pos pos;
+enum edge_pos pos;
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 {
 if (f->current_display_lines[pos])
 	Dynarr_reset (f->current_display_lines[pos]);
 }
 }
 static void
-redraw_exposed_gutter (struct frame *f, enum gutter_pos pos, int x, int y,
+redraw_exposed_gutter (struct frame *f, enum edge_pos pos, int x, int y,
 		       int width, int height)
 {
 int g_x, g_y, g_width, g_height;
 get_gutter_coords (f, pos, &g_x, &g_y, &g_width, &g_height);
 void
 redraw_exposed_gutters (struct frame *f, int x, int y, int width,
 			int height)
 {
-enum gutter_pos pos;
+enum edge_pos pos;
 /* We are already inside the critical section -- our caller did that. */
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 {
 if (FRAME_GUTTER_VISIBLE (f, pos))
 	redraw_exposed_gutter (f, pos, x, y, width, height);
 }
 }
 void
 free_frame_gutters (struct frame *f)
 {
-enum gutter_pos pos;
+enum edge_pos pos;
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 {
 if (f->current_display_lines[pos])
 	{
 	  free_display_lines (f->current_display_lines[pos]);
 	  f->current_display_lines[pos] = 0;
 	  f->desired_display_lines[pos] = 0;
 	}
 }
 }
-static enum gutter_pos
+static enum edge_pos
 decode_gutter_position (Lisp_Object position)
 {
-if (EQ (position, Qtop))    return TOP_GUTTER;
+if (EQ (position, Qtop))    return TOP_EDGE;
-if (EQ (position, Qbottom)) return BOTTOM_GUTTER;
+if (EQ (position, Qbottom)) return BOTTOM_EDGE;
-if (EQ (position, Qleft))   return LEFT_GUTTER;
+if (EQ (position, Qleft))   return LEFT_EDGE;
-if (EQ (position, Qright))  return RIGHT_GUTTER;
+if (EQ (position, Qright))  return RIGHT_EDGE;
 invalid_constant ("Invalid gutter position", position);
-RETURN_NOT_REACHED (TOP_GUTTER);
+RETURN_NOT_REACHED (TOP_EDGE);
 }
 DEFUN ("set-default-gutter-position", Fset_default_gutter_position, 1, 1, 0, /*
 Set the position that the `default-gutter' will be displayed at.
 Valid positions are `top', `bottom', `left' and `right'.
 See `default-gutter-position'.
 */
 (position))
 {
-enum gutter_pos cur = decode_gutter_position (Vdefault_gutter_position);
+enum edge_pos cur = decode_gutter_position (Vdefault_gutter_position);
-enum gutter_pos new_ = decode_gutter_position (position);
+enum edge_pos new_ = decode_gutter_position (position);
 if (cur != new_)
 {
 /* The following calls will automatically cause the dirty
 	 flags to be set; we delay frame size changes to avoid
 set_specifier_fallback (Vgutter[cur], list1 (Fcons (Qnil, Qnil)));
 set_specifier_fallback (Vgutter[new_], Vdefault_gutter);
 set_specifier_fallback (Vgutter_size[cur], list1 (Fcons (Qnil, Qzero)));
 set_specifier_fallback (Vgutter_size[new_],
-			      new_ == TOP_GUTTER || new_ == BOTTOM_GUTTER
+			      new_ == TOP_EDGE || new_ == BOTTOM_EDGE
 			      ? Vdefault_gutter_height
 			      : Vdefault_gutter_width);
 set_specifier_fallback (Vgutter_border_width[cur],
 			      list1 (Fcons (Qnil, Qzero)));
 set_specifier_fallback (Vgutter_border_width[new_],
 the current window.
 */
 (pos, locale))
 {
 int x, y, width, height;
-enum gutter_pos p = TOP_GUTTER;
+enum edge_pos p = TOP_EDGE;
 struct frame *f = decode_frame (FW_FRAME (locale));
 if (NILP (pos))
 pos = Vdefault_gutter_position;
 p = decode_gutter_position (pos);
 the current window.
 */
 (pos, locale))
 {
 int x, y, width, height;
-enum gutter_pos p = TOP_GUTTER;
+enum edge_pos p = TOP_EDGE;
 struct frame *f = decode_frame (FW_FRAME (locale));
 if (NILP (pos))
 pos = Vdefault_gutter_position;
 p = decode_gutter_position (pos);
 /*
 Helper for invalidating the real specifier when default
 specifier caching changes
 */
 static void
-recompute_overlaying_specifier (Lisp_Object real_one[4])
+recompute_overlaying_specifier (Lisp_Object real_one[NUM_EDGES])
 {
-enum gutter_pos pos = decode_gutter_position (Vdefault_gutter_position);
+enum edge_pos pos = decode_gutter_position (Vdefault_gutter_position);
 Fset_specifier_dirty_flag (real_one[pos]);
 }
 static void gutter_specs_changed (Lisp_Object specifier, struct window *w,
-				  Lisp_Object oldval, enum gutter_pos pos);
+				  Lisp_Object oldval, enum edge_pos pos);
 static void
 gutter_specs_changed_1 (Lisp_Object arg)
 {
 gutter_specs_changed (X1ST (arg), XWINDOW (X2ND (arg)),
-			X3RD (arg), (enum gutter_pos) XINT (X4TH (arg)));
+			X3RD (arg), (enum edge_pos) XINT (X4TH (arg)));
 free_list (arg);
 }
 static void
 gutter_specs_changed (Lisp_Object specifier, struct window *w,
-		      Lisp_Object oldval, enum gutter_pos pos)
+		      Lisp_Object oldval, enum edge_pos pos)
 {
 if (in_display)
 register_post_redisplay_action (gutter_specs_changed_1,
 				    list4 (specifier, wrap_window (w),
 					   oldval, make_int (pos)));
 /* We define all of these so we can access which actual gutter changed. */
 static void
 top_gutter_specs_changed (Lisp_Object specifier, struct window *w,
 			  Lisp_Object oldval)
 {
-gutter_specs_changed (specifier, w, oldval, TOP_GUTTER);
+gutter_specs_changed (specifier, w, oldval, TOP_EDGE);
 }
 static void
 bottom_gutter_specs_changed (Lisp_Object specifier, struct window *w,
 			     Lisp_Object oldval)
 {
-gutter_specs_changed (specifier, w, oldval, BOTTOM_GUTTER);
+gutter_specs_changed (specifier, w, oldval, BOTTOM_EDGE);
 }
 static void
 left_gutter_specs_changed (Lisp_Object specifier, struct window *w,
 			   Lisp_Object oldval)
 {
-gutter_specs_changed (specifier, w, oldval, LEFT_GUTTER);
+gutter_specs_changed (specifier, w, oldval, LEFT_EDGE);
 }
 static void
 right_gutter_specs_changed (Lisp_Object specifier, struct window *w,
 			    Lisp_Object oldval)
 {
-gutter_specs_changed (specifier, w, oldval, RIGHT_GUTTER);
+gutter_specs_changed (specifier, w, oldval, RIGHT_EDGE);
 }
 static void
 default_gutter_specs_changed (Lisp_Object UNUSED (specifier),
 			      struct window *UNUSED (w),
 register_post_redisplay_action (gutter_geometry_changed_in_window_1,
 				    list3 (specifier, wrap_window (w),
 					   oldval));
 else
 {
-enum gutter_pos pos;
+enum edge_pos pos;
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 	{
 	  w->real_gutter_size[pos] = w->gutter_size[pos];
 	  if (EQ (w->real_gutter_size[pos], Qautodetect)
 	      && !NILP (w->gutter_visible_p[pos]))
 	    {
 }
 void
 init_frame_gutters (struct frame *f)
 {
-enum gutter_pos pos;
+enum edge_pos pos;
 struct window* w = XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f));
 /* We are here as far in frame creation so cached specifiers are
 already recomputed, and possibly modified by resource
 initialization. We need to recalculate autodetected gutters. */
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 {
 w->real_gutter[pos] = construct_window_gutter_spec (w, pos);
 w->real_gutter_size[pos] = w->gutter_size[pos];
 if (EQ (w->gutter_size[pos], Qautodetect)
 	  && !NILP (w->gutter_visible_p[pos]))
 	  MARK_WINDOWS_CHANGED (w);
 	}
 }
 /* Keep a record of the current sizes of things. */
-GUTTER_POS_LOOP (pos)
+EDGE_POS_LOOP (pos)
 {
 f->current_gutter_bounds[pos] = FRAME_GUTTER_BOUNDS (f, pos);
 }
 }
 			 offsetof (struct window, default_gutter),
 			 default_gutter_specs_changed,
 			 0, 0, 1);
 DEFVAR_SPECIFIER ("top-gutter",
-		    &Vgutter[TOP_GUTTER] /*
+		    &Vgutter[TOP_EDGE] /*
 Specifier for the gutter at the top of the frame.
 Use `set-specifier' to change this.
 See `default-gutter' for a description of a valid gutter instantiator.
 */ );
-Vgutter[TOP_GUTTER] = Fmake_specifier (Qgutter);
+Vgutter[TOP_EDGE] = Fmake_specifier (Qgutter);
-set_specifier_caching (Vgutter[TOP_GUTTER],
+set_specifier_caching (Vgutter[TOP_EDGE],
-			 offsetof (struct window, gutter[TOP_GUTTER]),
+			 offsetof (struct window, gutter[TOP_EDGE]),
 			 top_gutter_specs_changed,
 			 0, 0, 1);
 DEFVAR_SPECIFIER ("bottom-gutter",
-		    &Vgutter[BOTTOM_GUTTER] /*
+		    &Vgutter[BOTTOM_EDGE] /*
 Specifier for the gutter at the bottom of the frame.
 Use `set-specifier' to change this.
 See `default-gutter' for a description of a valid gutter instantiator.
 Note that, unless the `default-gutter-position' is `bottom', by
 default the height of the bottom gutter (controlled by
 `bottom-gutter-height') is 0; thus, a bottom gutter will not be
 displayed even if you provide a value for `bottom-gutter'.
 */ );
-Vgutter[BOTTOM_GUTTER] = Fmake_specifier (Qgutter);
+Vgutter[BOTTOM_EDGE] = Fmake_specifier (Qgutter);
-set_specifier_caching (Vgutter[BOTTOM_GUTTER],
+set_specifier_caching (Vgutter[BOTTOM_EDGE],
-			 offsetof (struct window, gutter[BOTTOM_GUTTER]),
+			 offsetof (struct window, gutter[BOTTOM_EDGE]),
 			 bottom_gutter_specs_changed,
 			 0, 0, 1);
 DEFVAR_SPECIFIER ("left-gutter",
-		    &Vgutter[LEFT_GUTTER] /*
+		    &Vgutter[LEFT_EDGE] /*
 Specifier for the gutter at the left edge of the frame.
 Use `set-specifier' to change this.
 See `default-gutter' for a description of a valid gutter instantiator.
 Note that, unless the `default-gutter-position' is `left', by
 default the height of the left gutter (controlled by
 `left-gutter-width') is 0; thus, a left gutter will not be
 displayed even if you provide a value for `left-gutter'.
 */ );
-Vgutter[LEFT_GUTTER] = Fmake_specifier (Qgutter);
+Vgutter[LEFT_EDGE] = Fmake_specifier (Qgutter);
-set_specifier_caching (Vgutter[LEFT_GUTTER],
+set_specifier_caching (Vgutter[LEFT_EDGE],
-			 offsetof (struct window, gutter[LEFT_GUTTER]),
+			 offsetof (struct window, gutter[LEFT_EDGE]),
 			 left_gutter_specs_changed,
 			 0, 0, 1);
 DEFVAR_SPECIFIER ("right-gutter",
-		    &Vgutter[RIGHT_GUTTER] /*
+		    &Vgutter[RIGHT_EDGE] /*
 Specifier for the gutter at the right edge of the frame.
 Use `set-specifier' to change this.
 See `default-gutter' for a description of a valid gutter instantiator.
 Note that, unless the `default-gutter-position' is `right', by
 default the height of the right gutter (controlled by
 `right-gutter-width') is 0; thus, a right gutter will not be
 displayed even if you provide a value for `right-gutter'.
 */ );
-Vgutter[RIGHT_GUTTER] = Fmake_specifier (Qgutter);
+Vgutter[RIGHT_EDGE] = Fmake_specifier (Qgutter);
-set_specifier_caching (Vgutter[RIGHT_GUTTER],
+set_specifier_caching (Vgutter[RIGHT_EDGE],
-			 offsetof (struct window, gutter[RIGHT_GUTTER]),
+			 offsetof (struct window, gutter[RIGHT_EDGE]),
 			 right_gutter_specs_changed,
 			 0, 0, 1);
 /* initially, top inherits from default; this can be
 changed with `set-default-gutter-position'. */
 fb = list1 (Fcons (Qnil, Qnil));
 set_specifier_fallback (Vdefault_gutter, fb);
-set_specifier_fallback (Vgutter[TOP_GUTTER], Vdefault_gutter);
+set_specifier_fallback (Vgutter[TOP_EDGE], Vdefault_gutter);
-set_specifier_fallback (Vgutter[BOTTOM_GUTTER], fb);
+set_specifier_fallback (Vgutter[BOTTOM_EDGE], fb);
-set_specifier_fallback (Vgutter[LEFT_GUTTER],   fb);
+set_specifier_fallback (Vgutter[LEFT_EDGE],   fb);
-set_specifier_fallback (Vgutter[RIGHT_GUTTER],  fb);
+set_specifier_fallback (Vgutter[RIGHT_EDGE],  fb);
 DEFVAR_SPECIFIER ("default-gutter-height", &Vdefault_gutter_height /*
 *Height of the default gutter, if it's oriented horizontally.
 This is a specifier; use `set-specifier' to change it.
 			 offsetof (struct window, default_gutter_width),
 			 default_gutter_size_changed_in_window,
 			 0, 0, 1);
 DEFVAR_SPECIFIER ("top-gutter-height",
-		    &Vgutter_size[TOP_GUTTER] /*
+		    &Vgutter_size[TOP_EDGE] /*
 *Height of the top gutter.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-height' for more information.
 */ );
-Vgutter_size[TOP_GUTTER] = Fmake_specifier (Qgutter_size);
+Vgutter_size[TOP_EDGE] = Fmake_specifier (Qgutter_size);
-set_specifier_caching (Vgutter_size[TOP_GUTTER],
+set_specifier_caching (Vgutter_size[TOP_EDGE],
-			 offsetof (struct window, gutter_size[TOP_GUTTER]),
+			 offsetof (struct window, gutter_size[TOP_EDGE]),
 			 gutter_geometry_changed_in_window, 0, 0, 1);
 DEFVAR_SPECIFIER ("bottom-gutter-height",
-		    &Vgutter_size[BOTTOM_GUTTER] /*
+		    &Vgutter_size[BOTTOM_EDGE] /*
 *Height of the bottom gutter.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-height' for more information.
 */ );
-Vgutter_size[BOTTOM_GUTTER] = Fmake_specifier (Qgutter_size);
+Vgutter_size[BOTTOM_EDGE] = Fmake_specifier (Qgutter_size);
-set_specifier_caching (Vgutter_size[BOTTOM_GUTTER],
+set_specifier_caching (Vgutter_size[BOTTOM_EDGE],
-			 offsetof (struct window, gutter_size[BOTTOM_GUTTER]),
+			 offsetof (struct window, gutter_size[BOTTOM_EDGE]),
 			 gutter_geometry_changed_in_window, 0, 0, 1);
 DEFVAR_SPECIFIER ("left-gutter-width",
-		    &Vgutter_size[LEFT_GUTTER] /*
+		    &Vgutter_size[LEFT_EDGE] /*
 *Width of left gutter.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-height' for more information.
 */ );
-Vgutter_size[LEFT_GUTTER] = Fmake_specifier (Qgutter_size);
+Vgutter_size[LEFT_EDGE] = Fmake_specifier (Qgutter_size);
-set_specifier_caching (Vgutter_size[LEFT_GUTTER],
+set_specifier_caching (Vgutter_size[LEFT_EDGE],
-			 offsetof (struct window, gutter_size[LEFT_GUTTER]),
+			 offsetof (struct window, gutter_size[LEFT_EDGE]),
 			 gutter_geometry_changed_in_window, 0, 0, 1);
 DEFVAR_SPECIFIER ("right-gutter-width",
-		    &Vgutter_size[RIGHT_GUTTER] /*
+		    &Vgutter_size[RIGHT_EDGE] /*
 *Width of right gutter.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-height' for more information.
 */ );
-Vgutter_size[RIGHT_GUTTER] = Fmake_specifier (Qgutter_size);
+Vgutter_size[RIGHT_EDGE] = Fmake_specifier (Qgutter_size);
-set_specifier_caching (Vgutter_size[RIGHT_GUTTER],
+set_specifier_caching (Vgutter_size[RIGHT_EDGE],
-			 offsetof (struct window, gutter_size[RIGHT_GUTTER]),
+			 offsetof (struct window, gutter_size[RIGHT_EDGE]),
 			 gutter_geometry_changed_in_window, 0, 0, 1);
 fb = Qnil;
 #ifdef HAVE_TTY
 fb = Fcons (Fcons (list1 (Qtty), Qautodetect), fb);
 fb = Fcons (Fcons (list1 (Qmswindows), Qautodetect), fb);
 #endif
 if (!NILP (fb))
 set_specifier_fallback (Vdefault_gutter_width, fb);
-set_specifier_fallback (Vgutter_size[TOP_GUTTER], Vdefault_gutter_height);
+set_specifier_fallback (Vgutter_size[TOP_EDGE], Vdefault_gutter_height);
 fb = list1 (Fcons (Qnil, Qzero));
-set_specifier_fallback (Vgutter_size[BOTTOM_GUTTER], fb);
+set_specifier_fallback (Vgutter_size[BOTTOM_EDGE], fb);
-set_specifier_fallback (Vgutter_size[LEFT_GUTTER],   fb);
+set_specifier_fallback (Vgutter_size[LEFT_EDGE],   fb);
-set_specifier_fallback (Vgutter_size[RIGHT_GUTTER],  fb);
+set_specifier_fallback (Vgutter_size[RIGHT_EDGE],  fb);
 DEFVAR_SPECIFIER ("default-gutter-border-width",
 		    &Vdefault_gutter_border_width /*
 *Width of the border around the default gutter.
 This is a specifier; use `set-specifier' to change it.
 			 offsetof (struct window, default_gutter_border_width),
 			 default_gutter_border_width_changed_in_window,
 			 0, 0, 0);
 DEFVAR_SPECIFIER ("top-gutter-border-width",
-		    &Vgutter_border_width[TOP_GUTTER] /*
+		    &Vgutter_border_width[TOP_EDGE] /*
 *Border width of the top gutter.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-height' for more information.
 */ );
-Vgutter_border_width[TOP_GUTTER] = Fmake_specifier (Qnatnum);
+Vgutter_border_width[TOP_EDGE] = Fmake_specifier (Qnatnum);
-set_specifier_caching (Vgutter_border_width[TOP_GUTTER],
+set_specifier_caching (Vgutter_border_width[TOP_EDGE],
 			 offsetof (struct window,
-				   gutter_border_width[TOP_GUTTER]),
+				   gutter_border_width[TOP_EDGE]),
 			 gutter_geometry_changed_in_window, 0, 0, 0);
 DEFVAR_SPECIFIER ("bottom-gutter-border-width",
-		    &Vgutter_border_width[BOTTOM_GUTTER] /*
+		    &Vgutter_border_width[BOTTOM_EDGE] /*
 *Border width of the bottom gutter.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-height' for more information.
 */ );
-Vgutter_border_width[BOTTOM_GUTTER] = Fmake_specifier (Qnatnum);
+Vgutter_border_width[BOTTOM_EDGE] = Fmake_specifier (Qnatnum);
-set_specifier_caching (Vgutter_border_width[BOTTOM_GUTTER],
+set_specifier_caching (Vgutter_border_width[BOTTOM_EDGE],
 			 offsetof (struct window,
-				   gutter_border_width[BOTTOM_GUTTER]),
+				   gutter_border_width[BOTTOM_EDGE]),
 			 gutter_geometry_changed_in_window, 0, 0, 0);
 DEFVAR_SPECIFIER ("left-gutter-border-width",
-		    &Vgutter_border_width[LEFT_GUTTER] /*
+		    &Vgutter_border_width[LEFT_EDGE] /*
 *Border width of left gutter.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-height' for more information.
 */ );
-Vgutter_border_width[LEFT_GUTTER] = Fmake_specifier (Qnatnum);
+Vgutter_border_width[LEFT_EDGE] = Fmake_specifier (Qnatnum);
-set_specifier_caching (Vgutter_border_width[LEFT_GUTTER],
+set_specifier_caching (Vgutter_border_width[LEFT_EDGE],
 			 offsetof (struct window,
-				   gutter_border_width[LEFT_GUTTER]),
+				   gutter_border_width[LEFT_EDGE]),
 			 gutter_geometry_changed_in_window, 0, 0, 0);
 DEFVAR_SPECIFIER ("right-gutter-border-width",
-		    &Vgutter_border_width[RIGHT_GUTTER] /*
+		    &Vgutter_border_width[RIGHT_EDGE] /*
 *Border width of right gutter.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-height' for more information.
 */ );
-Vgutter_border_width[RIGHT_GUTTER] = Fmake_specifier (Qnatnum);
+Vgutter_border_width[RIGHT_EDGE] = Fmake_specifier (Qnatnum);
-set_specifier_caching (Vgutter_border_width[RIGHT_GUTTER],
+set_specifier_caching (Vgutter_border_width[RIGHT_EDGE],
 			 offsetof (struct window,
-				   gutter_border_width[RIGHT_GUTTER]),
+				   gutter_border_width[RIGHT_EDGE]),
 			 gutter_geometry_changed_in_window, 0, 0, 0);
 fb = Qnil;
 #ifdef HAVE_TTY
 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
 fb = Fcons (Fcons (list1 (Qmswindows), make_int (DEFAULT_GUTTER_BORDER_WIDTH)), fb);
 #endif
 if (!NILP (fb))
 set_specifier_fallback (Vdefault_gutter_border_width, fb);
-set_specifier_fallback (Vgutter_border_width[TOP_GUTTER], Vdefault_gutter_border_width);
+set_specifier_fallback (Vgutter_border_width[TOP_EDGE], Vdefault_gutter_border_width);
 fb = list1 (Fcons (Qnil, Qzero));
-set_specifier_fallback (Vgutter_border_width[BOTTOM_GUTTER], fb);
+set_specifier_fallback (Vgutter_border_width[BOTTOM_EDGE], fb);
-set_specifier_fallback (Vgutter_border_width[LEFT_GUTTER],   fb);
+set_specifier_fallback (Vgutter_border_width[LEFT_EDGE],   fb);
-set_specifier_fallback (Vgutter_border_width[RIGHT_GUTTER],  fb);
+set_specifier_fallback (Vgutter_border_width[RIGHT_EDGE],  fb);
 DEFVAR_SPECIFIER ("default-gutter-visible-p", &Vdefault_gutter_visible_p /*
 *Whether the default gutter is visible.
 This is a specifier; use `set-specifier' to change it.
 				   default_gutter_visible_p),
 			 default_gutter_visible_p_changed_in_window,
 			 0, 0, 0);
 DEFVAR_SPECIFIER ("top-gutter-visible-p",
-		    &Vgutter_visible_p[TOP_GUTTER] /*
+		    &Vgutter_visible_p[TOP_EDGE] /*
 *Whether the top gutter is visible.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-visible-p' for more information.
 */ );
-Vgutter_visible_p[TOP_GUTTER] = Fmake_specifier (Qgutter_visible);
+Vgutter_visible_p[TOP_EDGE] = Fmake_specifier (Qgutter_visible);
-set_specifier_caching (Vgutter_visible_p[TOP_GUTTER],
+set_specifier_caching (Vgutter_visible_p[TOP_EDGE],
 			 offsetof (struct window,
-				   gutter_visible_p[TOP_GUTTER]),
+				   gutter_visible_p[TOP_EDGE]),
 			 top_gutter_specs_changed, 0, 0, 0);
 DEFVAR_SPECIFIER ("bottom-gutter-visible-p",
-		    &Vgutter_visible_p[BOTTOM_GUTTER] /*
+		    &Vgutter_visible_p[BOTTOM_EDGE] /*
 *Whether the bottom gutter is visible.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-visible-p' for more information.
 */ );
-Vgutter_visible_p[BOTTOM_GUTTER] = Fmake_specifier (Qgutter_visible);
+Vgutter_visible_p[BOTTOM_EDGE] = Fmake_specifier (Qgutter_visible);
-set_specifier_caching (Vgutter_visible_p[BOTTOM_GUTTER],
+set_specifier_caching (Vgutter_visible_p[BOTTOM_EDGE],
 			 offsetof (struct window,
-				   gutter_visible_p[BOTTOM_GUTTER]),
+				   gutter_visible_p[BOTTOM_EDGE]),
 			 bottom_gutter_specs_changed, 0, 0, 0);
 DEFVAR_SPECIFIER ("left-gutter-visible-p",
-		    &Vgutter_visible_p[LEFT_GUTTER] /*
+		    &Vgutter_visible_p[LEFT_EDGE] /*
 *Whether the left gutter is visible.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-visible-p' for more information.
 */ );
-Vgutter_visible_p[LEFT_GUTTER] = Fmake_specifier (Qgutter_visible);
+Vgutter_visible_p[LEFT_EDGE] = Fmake_specifier (Qgutter_visible);
-set_specifier_caching (Vgutter_visible_p[LEFT_GUTTER],
+set_specifier_caching (Vgutter_visible_p[LEFT_EDGE],
 			 offsetof (struct window,
-				   gutter_visible_p[LEFT_GUTTER]),
+				   gutter_visible_p[LEFT_EDGE]),
 			 left_gutter_specs_changed, 0, 0, 0);
 DEFVAR_SPECIFIER ("right-gutter-visible-p",
-		    &Vgutter_visible_p[RIGHT_GUTTER] /*
+		    &Vgutter_visible_p[RIGHT_EDGE] /*
 *Whether the right gutter is visible.
 This is a specifier; use `set-specifier' to change it.
 See `default-gutter-visible-p' for more information.
 */ );
-Vgutter_visible_p[RIGHT_GUTTER] = Fmake_specifier (Qgutter_visible);
+Vgutter_visible_p[RIGHT_EDGE] = Fmake_specifier (Qgutter_visible);
-set_specifier_caching (Vgutter_visible_p[RIGHT_GUTTER],
+set_specifier_caching (Vgutter_visible_p[RIGHT_EDGE],
 			 offsetof (struct window,
-				   gutter_visible_p[RIGHT_GUTTER]),
+				   gutter_visible_p[RIGHT_EDGE]),
 			 right_gutter_specs_changed, 0, 0, 0);
 /* initially, top inherits from default; this can be
 changed with `set-default-gutter-position'. */
 fb = list1 (Fcons (Qnil, Qt));
 set_specifier_fallback (Vdefault_gutter_visible_p, fb);
-set_specifier_fallback (Vgutter_visible_p[TOP_GUTTER],
+set_specifier_fallback (Vgutter_visible_p[TOP_EDGE],
 			  Vdefault_gutter_visible_p);
-set_specifier_fallback (Vgutter_visible_p[BOTTOM_GUTTER], fb);
+set_specifier_fallback (Vgutter_visible_p[BOTTOM_EDGE], fb);
-set_specifier_fallback (Vgutter_visible_p[LEFT_GUTTER],   fb);
+set_specifier_fallback (Vgutter_visible_p[LEFT_EDGE],   fb);
-set_specifier_fallback (Vgutter_visible_p[RIGHT_GUTTER],  fb);
+set_specifier_fallback (Vgutter_visible_p[RIGHT_EDGE],  fb);
 }

Mercurial > hg > xemacs-beta

comparison src/gutter.c @ 5495:1f0b15040456