mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2026-01-11 14:01:43 -08:00
Code Issues Projects Releases Wiki Activity

Make (many) trivial substitutions for renamed and

Browse source 
new macros in dispextern.h, frame.h and window.h.
(mode_line_string): No need to adjust width for mode lines, as it
is already adjusted by the caller.
(marginal_area_string): Handle fringes inside/outside margins.
This commit is contained in:
Kim F. Storm 2003-05-24 21:57:05 +00:00
parent 87388f9d42
commit 7df0201613
1 changed files with 119 additions and 121 deletions
Download patch file Download diff file Expand all files Collapse all files

240
src/dispnew.c
View file

@ -428,8 +428,8 @@ DEFUN ("dump-redisplay-history", Fdump_redisplay_history,
#else /* GLYPH_DEBUG == 0 */
#define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
#define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
#define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + WINDOW_TOP_EDGE_LINE (W))
#define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + WINDOW_LEFT_EDGE_COL (W))
#endif /* GLYPH_DEBUG == 0 */
@ -576,7 +576,7 @@ margin_glyphs_to_reserve (w, total_glyphs, margin)
if (NUMBERP (margin))
{
int width = XFASTINT (w->width);
int width = XFASTINT (w->total_cols);
double d = max (0, XFLOATINT (margin));
d = min (width / 2 - 1, d);
n = (int) ((double) total_glyphs / width * d);
@ -623,7 +623,7 @@ adjust_glyph_matrix (w, matrix, x, y, dim)
int header_line_changed_p = 0;
int header_line_p = 0;
int left = -1, right = -1;
int window_x, window_y, window_width = -1, window_height;
int window_width = -1, window_height;
/* See if W had a header line that has disappeared now, or vice versa. */
if (w)
@ -638,9 +638,9 @@ adjust_glyph_matrix (w, matrix, x, y, dim)
the matrix means preventing redisplay. */
if (matrix->pool == NULL)
{
window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
left = margin_glyphs_to_reserve (w, dim.width, w->left_margin_width);
right = margin_glyphs_to_reserve (w, dim.width, w->right_margin_width);
window_box (w, -1, 0, 0, &window_width, &window_height);
left = margin_glyphs_to_reserve (w, dim.width, w->left_margin_cols);
right = margin_glyphs_to_reserve (w, dim.width, w->right_margin_cols);
xassert (left >= 0 && right >= 0);
marginal_areas_changed_p = (left != matrix->left_margin_glyphs
|| right != matrix->right_margin_glyphs);
@ -648,8 +648,8 @@ adjust_glyph_matrix (w, matrix, x, y, dim)
if (!marginal_areas_changed_p
&& !fonts_changed_p
&& !header_line_changed_p
&& matrix->window_left_x == XFASTINT (w->left)
&& matrix->window_top_y == XFASTINT (w->top)
&& matrix->window_left_col == WINDOW_LEFT_EDGE_COL (w)
&& matrix->window_top_line == WINDOW_TOP_EDGE_LINE (w)
&& matrix->window_height == window_height
&& matrix->window_vscroll == w->vscroll
&& matrix->window_width == window_width)
@ -679,9 +679,9 @@ adjust_glyph_matrix (w, matrix, x, y, dim)
if (w)
{
left = margin_glyphs_to_reserve (w, dim.width,
w->left_margin_width);
w->left_margin_cols);
right = margin_glyphs_to_reserve (w, dim.width,
w->right_margin_width);
w->right_margin_cols);
}
else
left = right = 0;
@ -790,8 +790,8 @@ adjust_glyph_matrix (w, matrix, x, y, dim)
&& !header_line_changed_p
&& new_rows == 0
&& dim.width == matrix->matrix_w
&& matrix->window_left_x == XFASTINT (w->left)
&& matrix->window_top_y == XFASTINT (w->top)
&& matrix->window_left_col == WINDOW_LEFT_EDGE_COL (w)
&& matrix->window_top_line == WINDOW_TOP_EDGE_LINE (w)
&& matrix->window_width == window_width)
{
/* Find the last row in the window. */
@ -839,8 +839,8 @@ adjust_glyph_matrix (w, matrix, x, y, dim)
was last adjusted. This is used to optimize redisplay above. */
if (w)
{
matrix->window_left_x = XFASTINT (w->left);
matrix->window_top_y = XFASTINT (w->top);
matrix->window_left_col = WINDOW_LEFT_EDGE_COL (w);
matrix->window_top_line = WINDOW_TOP_EDGE_LINE (w);
matrix->window_height = window_height;
matrix->window_width = window_width;
matrix->window_vscroll = w->vscroll;
@ -983,8 +983,8 @@ shift_glyph_matrix (w, matrix, start, end, dy)
xassert (start >= 0 && start < matrix->nrows);
xassert (end >= 0 && end <= matrix->nrows);
min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
max_y = WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w);
min_y = WINDOW_HEADER_LINE_HEIGHT (w);
max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (w);
for (; start < end; ++start)
{
@ -1143,13 +1143,13 @@ blank_row (w, row, y)
{
int min_y, max_y;
min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
max_y = WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w);
min_y = WINDOW_HEADER_LINE_HEIGHT (w);
max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (w);
clear_glyph_row (row);
row->y = y;
row->ascent = row->phys_ascent = 0;
row->height = row->phys_height = CANON_Y_UNIT (XFRAME (w->frame));
row->height = row->phys_height = FRAME_LINE_HEIGHT (XFRAME (w->frame));
row->visible_height = row->height;
if (row->y < min_y)
@ -1905,10 +1905,10 @@ allocate_matrices_for_frame_redisplay (window, x, y, dim_only_p,
|| dim.width != w->desired_matrix->matrix_w
|| dim.height != w->desired_matrix->matrix_h
|| (margin_glyphs_to_reserve (w, dim.width,
w->right_margin_width)
w->right_margin_cols)
!= w->desired_matrix->left_margin_glyphs)
|| (margin_glyphs_to_reserve (w, dim.width,
w->left_margin_width)
w->left_margin_cols)
!= w->desired_matrix->right_margin_glyphs))
*window_change_flags |= CHANGED_LEAF_MATRIX;
@ -1985,7 +1985,7 @@ required_matrix_height (w)
}
#endif /* HAVE_WINDOW_SYSTEM */
return XINT (w->height);
return WINDOW_TOTAL_LINES (w);
}
@ -2000,7 +2000,7 @@ required_matrix_width (w)
if (FRAME_WINDOW_P (f))
{
int ch_width = FRAME_SMALLEST_CHAR_WIDTH (f);
int window_pixel_width = XFLOATINT (w->width) * CANON_X_UNIT (f);
int window_pixel_width = WINDOW_TOTAL_WIDTH (w);
/* Compute number of glyphs needed in a glyph row. */
return (((window_pixel_width + ch_width - 1)
@ -2013,7 +2013,7 @@ required_matrix_width (w)
}
#endif /* HAVE_WINDOW_SYSTEM */
return XINT (w->width);
return XINT (w->total_cols);
}
@ -2098,18 +2098,18 @@ adjust_frame_glyphs_initially ()
struct frame *sf = SELECTED_FRAME ();
struct window *root = XWINDOW (sf->root_window);
struct window *mini = XWINDOW (root->next);
int frame_height = FRAME_HEIGHT (sf);
int frame_width = FRAME_WIDTH (sf);
int frame_lines = FRAME_LINES (sf);
int frame_cols = FRAME_COLS (sf);
int top_margin = FRAME_TOP_MARGIN (sf);
/* Do it for the root window. */
XSETFASTINT (root->top, top_margin);
XSETFASTINT (root->width, frame_width);
set_window_height (sf->root_window, frame_height - 1 - top_margin, 0);
XSETFASTINT (root->top_line, top_margin);
XSETFASTINT (root->total_cols, frame_cols);
set_window_height (sf->root_window, frame_lines - 1 - top_margin, 0);
/* Do it for the mini-buffer window. */
XSETFASTINT (mini->top, frame_height - 1);
XSETFASTINT (mini->width, frame_width);
XSETFASTINT (mini->top_line, frame_lines - 1);
XSETFASTINT (mini->total_cols, frame_cols);
set_window_height (root->next, 1, 0);
adjust_frame_glyphs (sf);
@ -2161,13 +2161,13 @@ fake_current_matrices (window)
struct glyph_matrix *m = w->current_matrix;
struct glyph_matrix *fm = f->current_matrix;
xassert (m->matrix_h == XFASTINT (w->height));
xassert (m->matrix_w == XFASTINT (w->width));
xassert (m->matrix_h == WINDOW_TOTAL_LINES (w));
xassert (m->matrix_w == WINDOW_TOTAL_COLS (w));
for (i = 0; i < m->matrix_h; ++i)
{
struct glyph_row *r = m->rows + i;
struct glyph_row *fr = fm->rows + i + XFASTINT (w->top);
struct glyph_row *fr = fm->rows + i + WINDOW_TOP_EDGE_LINE (w);
xassert (r->glyphs[TEXT_AREA] >= fr->glyphs[TEXT_AREA]
&& r->glyphs[LAST_AREA] <= fr->glyphs[LAST_AREA]);
@ -2313,8 +2313,8 @@ adjust_frame_glyphs_for_frame_redisplay (f)
/* Size of frame matrices must equal size of frame. Note
that we are called for X frames with window widths NOT equal
to the frame width (from CHANGE_FRAME_SIZE_1). */
xassert (matrix_dim.width == FRAME_WIDTH (f)
&& matrix_dim.height == FRAME_HEIGHT (f));
xassert (matrix_dim.width == FRAME_COLS (f)
&& matrix_dim.height == FRAME_LINES (f));
/* Pointers to glyph memory in glyph rows are exchanged during
the update phase of redisplay, which means in general that a
@ -2386,10 +2386,10 @@ adjust_frame_glyphs_for_window_redisplay (f)
/* Set window dimensions to frame dimensions and allocate or
adjust glyph matrices of W. */
XSETFASTINT (w->top, 0);
XSETFASTINT (w->left, 0);
XSETFASTINT (w->height, FRAME_MENU_BAR_LINES (f));
XSETFASTINT (w->width, FRAME_WINDOW_WIDTH (f));
XSETFASTINT (w->top_line, 0);
XSETFASTINT (w->left_col, 0);
XSETFASTINT (w->total_lines, FRAME_MENU_BAR_LINES (f));
XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f));
allocate_matrices_for_window_redisplay (w);
}
#endif /* not USE_X_TOOLKIT */
@ -2407,10 +2407,10 @@ adjust_frame_glyphs_for_window_redisplay (f)
else
w = XWINDOW (f->tool_bar_window);
XSETFASTINT (w->top, FRAME_MENU_BAR_LINES (f));
XSETFASTINT (w->left, 0);
XSETFASTINT (w->height, FRAME_TOOL_BAR_LINES (f));
XSETFASTINT (w->width, FRAME_WINDOW_WIDTH (f));
XSETFASTINT (w->top_line, FRAME_MENU_BAR_LINES (f));
XSETFASTINT (w->left_col, 0);
XSETFASTINT (w->total_lines, FRAME_TOOL_BAR_LINES (f));
XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f));
allocate_matrices_for_window_redisplay (w);
#endif
}
@ -3022,14 +3022,14 @@ sync_window_with_frame_matrix_rows (w)
xassert (NILP (w->hchild) && NILP (w->vchild));
xassert (!FRAME_WINDOW_P (f));
left = margin_glyphs_to_reserve (w, 1, w->left_margin_width);
right = margin_glyphs_to_reserve (w, 1, w->right_margin_width);
left = margin_glyphs_to_reserve (w, 1, w->left_margin_cols);
right = margin_glyphs_to_reserve (w, 1, w->right_margin_cols);
x = w->current_matrix->matrix_x;
width = w->current_matrix->matrix_w;
window_row = w->current_matrix->rows;
window_row_end = window_row + w->current_matrix->nrows;
frame_row = f->current_matrix->rows + XFASTINT (w->top);
frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
for (; window_row < window_row_end; ++window_row, ++frame_row)
{
@ -3061,8 +3061,8 @@ frame_row_to_window (w, row)
found = frame_row_to_window (XWINDOW (w->hchild), row);
else if (!NILP (w->vchild))
found = frame_row_to_window (XWINDOW (w->vchild), row);
else if (row >= XFASTINT (w->top)
&& row < XFASTINT (w->top) + XFASTINT (w->height))
else if (row >= WINDOW_TOP_EDGE_LINE (w)
&& row < WINDOW_BOTTOM_EDGE_LINE (w))
found = w;
w = NILP (w->next) ? 0 : XWINDOW (w->next);
@ -3267,8 +3267,8 @@ window_to_frame_vpos (w, vpos)
xassert (!FRAME_WINDOW_P (f));
xassert (vpos >= 0 && vpos <= w->desired_matrix->nrows);
vpos += XFASTINT (w->top);
xassert (vpos >= 0 && vpos <= FRAME_HEIGHT (f));
vpos += WINDOW_TOP_EDGE_LINE (w);
xassert (vpos >= 0 && vpos <= FRAME_LINES (f));
return vpos;
}
@ -3284,7 +3284,7 @@ window_to_frame_hpos (w, hpos)
struct frame *f = XFRAME (w->frame);
xassert (!FRAME_WINDOW_P (f));
hpos += XFASTINT (w->left);
hpos += WINDOW_LEFT_EDGE_COL (w);
return hpos;
}
@ -3644,8 +3644,8 @@ direct_output_for_insert (g)
{
int x, y;
x = (WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos)
+ (INTEGERP (w->left_margin_width)
? XFASTINT (w->left_margin_width)
+ (INTEGERP (w->left_margin_cols)
? XFASTINT (w->left_margin_cols)
: 0));
y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
cursor_to (y, x);
@ -3739,8 +3739,8 @@ direct_output_forward_char (n)
{
int x, y;
x = (WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos)
+ (INTEGERP (w->left_margin_width)
? XFASTINT (w->left_margin_width)
+ (INTEGERP (w->left_margin_cols)
? XFASTINT (w->left_margin_cols)
: 0));
y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
cursor_to (y, x);
@ -4480,7 +4480,7 @@ update_window_line (w, vpos, mouse_face_overwritten_p)
/* Update display of the left margin area, if there is one. */
if (!desired_row->full_width_p
&& !NILP (w->left_margin_width))
&& !NILP (w->left_margin_cols))
{
changed_p = 1;
update_marginal_area (w, LEFT_MARGIN_AREA, vpos);
@ -4496,7 +4496,7 @@ update_window_line (w, vpos, mouse_face_overwritten_p)
/* Update display of the right margin area, if there is one. */
if (!desired_row->full_width_p
&& !NILP (w->right_margin_width))
&& !NILP (w->right_margin_cols))
{
changed_p = 1;
update_marginal_area (w, RIGHT_MARGIN_AREA, vpos);
@ -5126,7 +5126,7 @@ update_frame_1 (f, force_p, inhibit_id_p)
}
}
pause = (i < FRAME_HEIGHT (f) - 1) ? i : 0;
pause = (i < FRAME_LINES (f) - 1) ? i : 0;
/* Now just clean up termcap drivers and set cursor, etc. */
if (!pause)
@ -5143,7 +5143,7 @@ update_frame_1 (f, force_p, inhibit_id_p)
&& FRAME_HAS_MINIBUF_P (f)
&& EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
{
int top = XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top);
int top = WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f)));
int row, col;
if (cursor_in_echo_area < 0)
@ -5159,7 +5159,7 @@ update_frame_1 (f, force_p, inhibit_id_p)
cursor at the end of the prompt. If the mini-buffer
is several lines high, find the last line that has
any text on it. */
row = FRAME_HEIGHT (f);
row = FRAME_LINES (f);
do
{
--row;
@ -5187,9 +5187,9 @@ update_frame_1 (f, force_p, inhibit_id_p)
if (col >= FRAME_CURSOR_X_LIMIT (f))
{
/* If we have another row, advance cursor into it. */
if (row < FRAME_HEIGHT (f) - 1)
if (row < FRAME_LINES (f) - 1)
{
col = FRAME_LEFT_SCROLL_BAR_WIDTH (f);
col = FRAME_LEFT_SCROLL_BAR_COLS (f);
row++;
}
/* Otherwise move it back in range. */
@ -5211,15 +5211,15 @@ update_frame_1 (f, force_p, inhibit_id_p)
with the cursor in the lower half of it. The window
is split, and a message causes a redisplay before
a new cursor position has been computed. */
&& w->cursor.vpos < XFASTINT (w->height))
&& w->cursor.vpos < WINDOW_TOTAL_LINES (w))
{
int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos);
int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
if (INTEGERP (w->left_margin_width))
x += XFASTINT (w->left_margin_width);
if (INTEGERP (w->left_margin_cols))
x += XFASTINT (w->left_margin_cols);
/* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
/* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */
cursor_to (y, x);
}
}
@ -5241,12 +5241,12 @@ scrolling (frame)
int unchanged_at_top, unchanged_at_bottom;
int window_size;
int changed_lines;
int *old_hash = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
int *new_hash = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
int *draw_cost = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
int *old_draw_cost = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
int *old_hash = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
int *new_hash = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
int *draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
int *old_draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
register int i;
int free_at_end_vpos = FRAME_HEIGHT (frame);
int free_at_end_vpos = FRAME_LINES (frame);
struct glyph_matrix *current_matrix = frame->current_matrix;
struct glyph_matrix *desired_matrix = frame->desired_matrix;
@ -5258,8 +5258,8 @@ scrolling (frame)
number of unchanged lines at the end. */
changed_lines = 0;
unchanged_at_top = 0;
unchanged_at_bottom = FRAME_HEIGHT (frame);
for (i = 0; i < FRAME_HEIGHT (frame); i++)
unchanged_at_bottom = FRAME_LINES (frame);
for (i = 0; i < FRAME_LINES (frame); i++)
{
/* Give up on this scrolling if some old lines are not enabled. */
if (!MATRIX_ROW_ENABLED_P (current_matrix, i))
@ -5281,7 +5281,7 @@ scrolling (frame)
if (old_hash[i] != new_hash[i])
{
changed_lines++;
unchanged_at_bottom = FRAME_HEIGHT (frame) - i - 1;
unchanged_at_bottom = FRAME_LINES (frame) - i - 1;
}
else if (i == unchanged_at_top)
unchanged_at_top++;
@ -5290,10 +5290,10 @@ scrolling (frame)
/* If changed lines are few, don't allow preemption, don't scroll. */
if ((!scroll_region_ok && changed_lines < baud_rate / 2400)
|| unchanged_at_bottom == FRAME_HEIGHT (frame))
|| unchanged_at_bottom == FRAME_LINES (frame))
return 1;
window_size = (FRAME_HEIGHT (frame) - unchanged_at_top
window_size = (FRAME_LINES (frame) - unchanged_at_top
- unchanged_at_bottom);
if (scroll_region_ok)
@ -5306,7 +5306,7 @@ scrolling (frame)
if (!scroll_region_ok && window_size >= 18 && baud_rate > 2400
&& (window_size >=
10 * scrolling_max_lines_saved (unchanged_at_top,
FRAME_HEIGHT (frame) - unchanged_at_bottom,
FRAME_LINES (frame) - unchanged_at_bottom,
old_hash, new_hash, draw_cost)))
return 0;
@ -5365,7 +5365,7 @@ count_match (str1, end1, str2, end2)
/* Char insertion/deletion cost vector, from term.c */
extern int *char_ins_del_vector;
#define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
#define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_TOTAL_COLS((f))])
/* Perform a frame-based update on line VPOS in frame FRAME. */
@ -5441,10 +5441,10 @@ update_frame_line (f, vpos)
/* Don't call clear_end_of_line if we already wrote the whole
line. The cursor will not be at the right margin in that
case but in the line below. */
if (nlen < FRAME_WINDOW_WIDTH (f))
if (nlen < FRAME_TOTAL_COLS (f))
{
cursor_to (vpos, nlen);
clear_end_of_line (FRAME_WINDOW_WIDTH (f));
clear_end_of_line (FRAME_TOTAL_COLS (f));
}
else
/* Make sure we are in the right row, otherwise cursor movement
@ -5615,7 +5615,7 @@ update_frame_line (f, vpos)
no need to do clear-to-eol at the end of this function
(and it would not be safe, since cursor is not going to
be "at the margin" after the text is done). */
if (nlen == FRAME_WINDOW_WIDTH (f))
if (nlen == FRAME_TOTAL_COLS (f))
olen = 0;
/* Function write_glyphs is prepared to do nothing
@ -5705,7 +5705,7 @@ buffer_posn_from_coords (w, x, y, object, pos)
BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp)));
start_display (&it, w, startp);
left_area_width = WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w);
left_area_width = WINDOW_LEFT_MARGIN_WIDTH (w);
move_it_to (&it, -1, *x + it.first_visible_x - left_area_width, *y, -1,
MOVE_TO_X | MOVE_TO_Y);
@ -5743,13 +5743,6 @@ mode_line_string (w, x, y, part, charpos)
if (row->mode_line_p && row->enabled_p)
{
/* The mode lines are displayed over scroll bars and fringes,
and X is window-relative. Correct X by the scroll bar
and fringe width. */
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
x += FRAME_SCROLL_BAR_COLS (f) * CANON_X_UNIT (f);
x += FRAME_LEFT_FRINGE_WIDTH (f);
/* Find the glyph under X. If we find one with a string object,
it's the one we were looking for. */
glyph = row->glyphs[TEXT_AREA];
@ -5801,11 +5794,18 @@ marginal_area_string (w, x, y, part, charpos)
it's the one we were looking for. */
glyph = row->glyphs[area];
end = glyph + row->used[area];
if (area == RIGHT_MARGIN_AREA)
x0 = (window_box_width (w, TEXT_AREA)
+ window_box_width (w, LEFT_MARGIN_AREA));
x0 = ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
? WINDOW_LEFT_FRINGE_WIDTH (w)
: WINDOW_TOTAL_FRINGE_WIDTH (w))
+ window_box_width (w, LEFT_MARGIN_AREA)
+ window_box_width (w, TEXT_AREA));
else
x0 = 0;
x0 = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
? WINDOW_LEFT_FRINGE_WIDTH (w)
: 0);
for (; glyph < end; x0 += glyph->pixel_width, ++glyph)
if (x >= x0 && x < x0 + glyph->pixel_width)
{
@ -5885,11 +5885,9 @@ do_pending_window_change (safe)
{
struct frame *f = XFRAME (frame);
int height = FRAME_NEW_HEIGHT (f);
int width = FRAME_NEW_WIDTH (f);
if (height != 0 || width != 0)
change_frame_size (f, height, width, 0, 0, safe);
if (f->new_text_lines != 0 || f->new_text_cols != 0)
change_frame_size (f, f->new_text_lines, f->new_text_cols,
0, 0, safe);
}
}
}
@ -5931,38 +5929,38 @@ change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe)
register struct frame *f;
int newheight, newwidth, pretend, delay, safe;
{
int new_frame_window_width;
int new_frame_total_cols;
int count = SPECPDL_INDEX ();
/* If we can't deal with the change now, queue it for later. */
if (delay || (redisplaying_p && !safe))
{
FRAME_NEW_HEIGHT (f) = newheight;
FRAME_NEW_WIDTH (f) = newwidth;
f->new_text_lines = newheight;
f->new_text_cols = newwidth;
delayed_size_change = 1;
return;
}
/* This size-change overrides any pending one for this frame. */
FRAME_NEW_HEIGHT (f) = 0;
FRAME_NEW_WIDTH (f) = 0;
f->new_text_lines = 0;
f->new_text_cols = 0;
/* If an argument is zero, set it to the current value. */
if (newheight == 0)
newheight = FRAME_HEIGHT (f);
newheight = FRAME_LINES (f);
if (newwidth == 0)
newwidth = FRAME_WIDTH (f);
newwidth = FRAME_COLS (f);
/* Compute width of windows in F.
This is the width of the frame without vertical scroll bars. */
new_frame_window_width = FRAME_WINDOW_WIDTH_ARG (f, newwidth);
new_frame_total_cols = FRAME_TOTAL_COLS_ARG (f, newwidth);
/* Round up to the smallest acceptable size. */
check_frame_size (f, &newheight, &newwidth);
/* If we're not changing the frame size, quit now. */
if (newheight == FRAME_HEIGHT (f)
&& new_frame_window_width == FRAME_WINDOW_WIDTH (f))
if (newheight == FRAME_LINES (f)
&& new_frame_total_cols == FRAME_TOTAL_COLS (f))
return;
BLOCK_INPUT;
@ -5974,19 +5972,19 @@ change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe)
dos_set_window_size (&newheight, &newwidth);
#endif
if (newheight != FRAME_HEIGHT (f))
if (newheight != FRAME_LINES (f))
{
if (FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
{
/* Frame has both root and mini-buffer. */
XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f))->top,
XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f))->top_line,
FRAME_TOP_MARGIN (f));
set_window_height (FRAME_ROOT_WINDOW (f),
(newheight
- 1
- FRAME_TOP_MARGIN (f)),
0);
XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top,
XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top_line,
newheight - 1);
set_window_height (FRAME_MINIBUF_WINDOW (f), 1, 0);
}
@ -5999,21 +5997,21 @@ change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe)
FrameRows = newheight;
}
if (new_frame_window_width != FRAME_WINDOW_WIDTH (f))
if (new_frame_total_cols != FRAME_TOTAL_COLS (f))
{
set_window_width (FRAME_ROOT_WINDOW (f), new_frame_window_width, 0);
set_window_width (FRAME_ROOT_WINDOW (f), new_frame_total_cols, 0);
if (FRAME_HAS_MINIBUF_P (f))
set_window_width (FRAME_MINIBUF_WINDOW (f), new_frame_window_width, 0);
set_window_width (FRAME_MINIBUF_WINDOW (f), new_frame_total_cols, 0);
if (FRAME_TERMCAP_P (f) && !pretend)
FrameCols = newwidth;
if (WINDOWP (f->tool_bar_window))
XSETFASTINT (XWINDOW (f->tool_bar_window)->width, newwidth);
XSETFASTINT (XWINDOW (f->tool_bar_window)->total_cols, newwidth);
}
FRAME_HEIGHT (f) = newheight;
SET_FRAME_WIDTH (f, newwidth);
FRAME_LINES (f) = newheight;
SET_FRAME_COLS (f, newwidth);
{
struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
@ -6038,7 +6036,7 @@ change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe)
/* This isn't quite a no-op: it runs window-configuration-change-hook. */
Fset_window_buffer (FRAME_SELECTED_WINDOW (f),
XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer);
XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer, Qt);
unbind_to (count, Qnil);
}
@ -6537,8 +6535,8 @@ For types not defined in VMS, use define emacs_term \"TYPE\".\n\
{
struct frame *sf = SELECTED_FRAME ();
int width = FRAME_WINDOW_WIDTH (sf);
int height = FRAME_HEIGHT (sf);
int width = FRAME_TOTAL_COLS (sf);
int height = FRAME_LINES (sf);
unsigned int total_glyphs = height * (width + 2) * sizeof (struct glyph);