xemacs-beta: src/window.c comparison

comparison src/window.c @ 438:84b14dcb0985 r21-2-27

Import from CVS: tag r21-2-27

author	cvs
date	Mon, 13 Aug 2007 11:32:25 +0200
parents	9d177e8d4150
children	8de8e3f6228a

comparison

equal deleted inserted replaced

-:e2a4e8b94b82
+:84b14dcb0985
 (con_dev_or_frame))
 {
 return FRAME_MINIBUF_WINDOW (decode_frame_or_selected (con_dev_or_frame));
 }
-DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, 1, 1, 0, /*
+DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, 0, 1, 0, /*
 Return non-nil if WINDOW is a minibuffer window.
 */
 (window))
 {
 return MINI_WINDOW_P (decode_window (window)) ? Qt : Qnil;
 (window))
 {
 return make_int (decode_window (window)->hscroll);
 }
-#ifdef MODELINE_IS_SCROLLABLE
 DEFUN ("modeline-hscroll", Fmodeline_hscroll, 0, 1, 0, /*
-Return the number of columns by which WINDOW's modeline is scrolled from
+Return the horizontal scrolling ammount of WINDOW's modeline.
-left margin. If the window has no modeline, return nil.
+If the window has no modeline, return nil.
 */
 (window))
 {
 struct window *w = decode_window (window);
-return (WINDOW_HAS_MODELINE_P (w)) ? make_int (w->modeline_hscroll) : Qnil;
+return (WINDOW_HAS_MODELINE_P (w)) ? make_int ((int) w->modeline_hscroll) :
+Qnil;
 }
 DEFUN ("set-modeline-hscroll", Fset_modeline_hscroll, 2, 2, 0, /*
-Set number of columns WINDOW's modeline is scrolled from left margin to NCOL.
+Set the horizontal scrolling ammount of WINDOW's modeline to NCOL.
-NCOL should be zero or positive. If NCOL is negative, it will be forced to 0.
+If NCOL is negative, it will silently be forced to 0.
-If the window has no modeline, do nothing and return nil.
+If the window has no modeline, return nil. Otherwise, return the actual
+value that was set.
 */
 (window, ncol))
 {
 struct window *w = decode_window (window);
 if (WINDOW_HAS_MODELINE_P (w))
 {
-int ncols;
+Charcount ncols;
 CHECK_INT (ncol);
-ncols = XINT (ncol);
+ncols = (XINT (ncol) <= 0) ? 0 : (Charcount) XINT (ncol);
-if (ncols < 0) ncols = 0;
+if (ncols != w->modeline_hscroll)
-if (w->modeline_hscroll != ncols)
+	{
-	MARK_MODELINE_CHANGED;
+	  MARK_MODELINE_CHANGED;
-w->modeline_hscroll = ncols;
+	  w->modeline_hscroll = ncols;
-return ncol;
+	}
-}
+return make_int ((int) ncols);
+}
 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.
 NCOL should be zero or positive.
 */
 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)
 {
 /* Go for partial display line scrolling. This just means bumping
 	 the clip by a reasonable amount and redisplaying, everything else
 	 remains unchanged. */
 	}
 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))))
 	    {
 	      maybe_signal_error (Qend_of_buffer, Qnil, Qwindow, errb);
 	      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
 	}
 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;
 	      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)))
 		{
 		  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),
 int pixel_left;
 int pixel_top;
 int pixel_width;
 int pixel_height;
 int hscroll;
-int modeline_hscroll;
+Charcount modeline_hscroll;
 int parent_index;           /* index into saved_windows */
 int prev_index;             /* index into saved_windows */
 char start_at_line_beg; /* boolean */
 #define WINDOW_SLOT_DECLARATION
 int previous_pixel_height;
 int previous_pixel_left;
 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 specpdl_count = specpdl_depth ();
 GCPRO1 (configuration);
 CHECK_WINDOW_CONFIGURATION (configuration);
 mark_windows_in_use (f, 1);
 #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
 	 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 craches when asserts are tickled).
 	 back.  We keep track of the prevailing height in these variables.  */
 if (config->frame_height != FRAME_HEIGHT (f)
 	  || 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;
 previous_pixel_width = XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_width;
 /* remember some properties of the minibuffer */
 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
 	    = XWINDOW(FRAME_MINIBUF_WINDOW(f))->pixel_height;
 	  previous_minibuf_top
 	    = XWINDOW(FRAME_MINIBUF_WINDOW(f))->pixel_width;
 	}
 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;
 window_min_width = 1;
 	 We take the old value if is in the same units but differs from the
 	 current value.
 #### 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?
 */
 target_minibuf_height = previous_minibuf_height;
 if (converted_minibuf_height &&
 	  (converted_minibuf_height * config->minibuf_height) > 0 &&
 	  (converted_minibuf_height !=  config->minibuf_height))
 	  set_window_pixheight (FRAME_MINIBUF_WINDOW (f),
 				target_minibuf_height, 0);
 	  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
 	 into the place of the new one. So we just do that. Simple! */
 XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_top = previous_pixel_top;
 		  (target_minibuf_height - previous_minibuf_height), 0);
 XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_left = previous_pixel_left;
 /* 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 ())
 	{
 config->saved_windows_count = n_windows;
 save_window_save (FRAME_ROOT_WINDOW (f), config, 0);
 /* 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
 minibuf_height = 0;
 config->minibuf_height = (minibuf_height % real_font_height) == 0 ?
 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;
 DEFSUBR (Fwindow_pixel_width);
 DEFSUBR (Fwindow_text_area_pixel_height);
 DEFSUBR (Fwindow_displayed_text_pixel_height);
 DEFSUBR (Fwindow_text_area_pixel_width);
 DEFSUBR (Fwindow_hscroll);
-#ifdef MODELINE_IS_SCROLLABLE
+DEFSUBR (Fset_window_hscroll);
 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);
 set_specifier_fallback (Vmodeline_shadow_thickness,
 			  list1 (Fcons (Qnil, Qzero)));
 Fadd_spec_to_specifier (Vmodeline_shadow_thickness, make_int (2),
 			  Qnil, Qnil, Qnil);
 set_specifier_caching (Vmodeline_shadow_thickness,
-			 slot_offset (struct window,
+			 offsetof (struct window, modeline_shadow_thickness),
-				      modeline_shadow_thickness),
 			 modeline_shadow_thickness_changed,
 			 0, 0);
 DEFVAR_SPECIFIER ("has-modeline-p", &Vhas_modeline_p /*
 *Whether the modeline should be displayed.
 */ );
 Vhas_modeline_p = Fmake_specifier (Qboolean);
 set_specifier_fallback (Vhas_modeline_p,
 			  list1 (Fcons (Qnil, Qt)));
 set_specifier_caching (Vhas_modeline_p,
-			 slot_offset (struct window,
+			 offsetof (struct window, has_modeline_p),
-				      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
 			    the modeline has been turned off or on. */
 			 some_window_value_changed,
 */ );
 Vvertical_divider_always_visible_p = Fmake_specifier (Qboolean);
 set_specifier_fallback (Vvertical_divider_always_visible_p,
 			  list1 (Fcons (Qnil, Qt)));
 set_specifier_caching (Vvertical_divider_always_visible_p,
-			 slot_offset (struct window,
+			 offsetof (struct window,
-				      vertical_divider_always_visible_p),
+				   vertical_divider_always_visible_p),
 			 vertical_divider_changed_in_window,
 			 0, 0);
 DEFVAR_SPECIFIER ("vertical-divider-shadow-thickness", &Vvertical_divider_shadow_thickness /*
 *How thick to draw 3D shadows around vertical dividers.
 set_specifier_fallback (Vvertical_divider_shadow_thickness,
 			  list1 (Fcons (Qnil, Qzero)));
 Fadd_spec_to_specifier (Vvertical_divider_shadow_thickness, make_int (2),
 			  Qnil, Qnil, Qnil);
 set_specifier_caching (Vvertical_divider_shadow_thickness,
-			 slot_offset (struct window,
+			 offsetof (struct window,
-				      vertical_divider_shadow_thickness),
+				   vertical_divider_shadow_thickness),
 			 vertical_divider_changed_in_window,
 			 0, 0);
 DEFVAR_SPECIFIER ("vertical-divider-line-width", &Vvertical_divider_line_width /*
 *The width of the vertical dividers, not including shadows.
 fb = Fcons (Fcons (list1 (Qmswindows), make_int (3)), fb);
 #endif
 set_specifier_fallback (Vvertical_divider_line_width, fb);
 }
 set_specifier_caching (Vvertical_divider_line_width,
-slot_offset (struct window,
+offsetof (struct window,
-				      vertical_divider_line_width),
+				   vertical_divider_line_width),
 			 vertical_divider_changed_in_window,
 0, 0);
 DEFVAR_SPECIFIER ("vertical-divider-spacing", &Vvertical_divider_spacing /*
 *How much space to leave around the vertical dividers.
 fb = Fcons (Fcons (list1 (Qmswindows), Qzero), fb);
 #endif
 set_specifier_fallback (Vvertical_divider_spacing, fb);
 }
 set_specifier_caching (Vvertical_divider_spacing,
-			 slot_offset (struct window,
+			 offsetof (struct window, vertical_divider_spacing),
-				      vertical_divider_spacing),
 			 vertical_divider_changed_in_window,
 			 0, 0);
 }

Mercurial > hg > xemacs-beta

comparison src/window.c @ 438:84b14dcb0985 r21-2-27