static bool
libxml2_loaded_p (void)
{
Lisp_Object found = Fassq (Qlibxml2, Vlibrary_cache);
return CONSP (found) && EQ (XCDR (found), Qt);
}
static Lisp_Object
x_get_local_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
int local_request, struct mac_display_info *dpyinfo)
{
Lisp_Object local_value;
Lisp_Object handler_fn, value, type, check;
if (!x_selection_owner_p (selection_symbol, dpyinfo))
return Qnil;
local_value = LOCAL_SELECTION (selection_symbol, dpyinfo);
/* TIMESTAMP is a special case. */
if (EQ (target_type, QTIMESTAMP))
{
handler_fn = Qnil;
value = XCAR (XCDR (XCDR (local_value)));
}
else
{
/* Don't allow a quit within the converter.
When the user types C-g, he would be surprised
if by luck it came during a converter. */
ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qinhibit_quit, Qt);
CHECK_SYMBOL (target_type);
handler_fn = Fcdr (Fassq (target_type, Vselection_converter_alist));
/* gcpro is not needed here since nothing but HANDLER_FN
is live, and that ought to be a symbol. */
if (!NILP (handler_fn))
value = call3 (handler_fn,
selection_symbol, (local_request ? Qnil : target_type),
XCAR (XCDR (local_value)));
else
value = Qnil;
unbind_to (count, Qnil);
}
if (local_request)
return value;
/* Make sure this value is of a type that we could transmit
to another application. */
type = target_type;
check = value;
if (CONSP (value)
&& SYMBOLP (XCAR (value)))
type = XCAR (value),
check = XCDR (value);
if (NILP (value) || mac_valid_selection_value_p (check, type))
return value;
signal_error ("Invalid data returned by selection-conversion function",
list2 (handler_fn, value));
}
static int
libxml2_loaded_p (void)
{
Lisp_Object found = Fassq (Qlibxml2_dll, Vlibrary_cache);
if (CONSP (found))
return EQ (XCDR (found), Qt) ? 1 : 0;
return 0;
}
static int
get_logical_cursor_bitmap (struct window *w, Lisp_Object cursor)
{
Lisp_Object cmap, bm = Qnil;
if ((cmap = BVAR (XBUFFER (w->buffer), fringe_cursor_alist)), !NILP (cmap))
{
bm = Fassq (cursor, cmap);
if (CONSP (bm))
{
if ((bm = XCDR (bm)), NILP (bm))
return NO_FRINGE_BITMAP;
return lookup_fringe_bitmap (bm);
}
}
if (EQ (cmap, BVAR (&buffer_defaults, fringe_cursor_alist)))
return NO_FRINGE_BITMAP;
bm = Fassq (cursor, BVAR (&buffer_defaults, fringe_cursor_alist));
if (!CONSP (bm) || ((bm = XCDR (bm)), NILP (bm)))
return NO_FRINGE_BITMAP;
return lookup_fringe_bitmap (bm);
}
static void
datum_print (repv stream, repv arg)
{
if (arg == Qnil)
{
DEFSTRING (eol, "()");
rep_stream_puts (stream, rep_PTR (rep_VAL (&eol)), 2, rep_TRUE);
}
else
{
repv printer = Fassq (DATUM_ID (arg), printer_alist);
if (printer && rep_CONSP (printer) && rep_CDR (printer) != Qnil)
rep_call_lisp2 (rep_CDR (printer), arg, stream);
else if (rep_SYMBOLP (DATUM_ID (arg)))
{
rep_stream_puts (stream, "#<datum ", -1, rep_FALSE);
rep_stream_puts (stream, rep_PTR (rep_SYM (DATUM_ID (arg))->name), -1, rep_TRUE);
rep_stream_putc (stream, '>');
}
else
rep_stream_puts (stream, "#<datum>", -1, rep_FALSE);
}
}
int
update_window_fringes (struct window *w, int keep_current_p)
{
struct glyph_row *row, *cur = 0;
int yb = window_text_bottom_y (w);
int rn, nrows = w->current_matrix->nrows;
int y;
int redraw_p = 0;
Lisp_Object boundary_top = Qnil, boundary_bot = Qnil;
Lisp_Object arrow_top = Qnil, arrow_bot = Qnil;
Lisp_Object empty_pos;
Lisp_Object ind = Qnil;
#define MAX_BITMAP_CACHE (8*4)
int bitmap_cache[MAX_BITMAP_CACHE];
int top_ind_rn, bot_ind_rn;
int top_ind_min_y, bot_ind_max_y;
/* top_ind_rn is set to a nonnegative value whenver
row->indicate_bob_p is set, so it's OK that top_row_ends_at_zv_p
is not initialized here. Similarly for bot_ind_rn,
row->indicate_eob_p and bot_row_ends_at_zv_p. */
int top_row_ends_at_zv_p IF_LINT (= 0), bot_row_ends_at_zv_p IF_LINT (= 0);
if (w->pseudo_window_p)
return 0;
if (!MINI_WINDOW_P (w)
&& (ind = BVAR (XBUFFER (w->buffer), indicate_buffer_boundaries), !NILP (ind)))
{
if (EQ (ind, Qleft) || EQ (ind, Qright))
boundary_top = boundary_bot = arrow_top = arrow_bot = ind;
else if (CONSP (ind) && CONSP (XCAR (ind)))
{
Lisp_Object pos;
if (pos = Fassq (Qt, ind), !NILP (pos))
boundary_top = boundary_bot = arrow_top = arrow_bot = XCDR (pos);
if (pos = Fassq (Qtop, ind), !NILP (pos))
boundary_top = XCDR (pos);
if (pos = Fassq (Qbottom, ind), !NILP (pos))
boundary_bot = XCDR (pos);
if (pos = Fassq (Qup, ind), !NILP (pos))
arrow_top = XCDR (pos);
if (pos = Fassq (Qdown, ind), !NILP (pos))
arrow_bot = XCDR (pos);
}
else
/* Anything else means boundary on left and no arrows. */
boundary_top = boundary_bot = Qleft;
}
top_ind_rn = bot_ind_rn = -1;
if (!NILP (ind))
{
for (y = w->vscroll, rn = 0;
y < yb && rn < nrows;
y += row->height, ++rn)
{
row = w->desired_matrix->rows + rn;
if (!row->enabled_p)
row = w->current_matrix->rows + rn;
row->indicate_bob_p = row->indicate_top_line_p = 0;
row->indicate_eob_p = row->indicate_bottom_line_p = 0;
if (!row->mode_line_p)
{
if (top_ind_rn < 0 && row->visible_height > 0)
{
if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->buffer))
&& !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w, row))
row->indicate_bob_p = !NILP (boundary_top);
else
row->indicate_top_line_p = !NILP (arrow_top);
top_ind_rn = rn;
}
if (bot_ind_rn < 0)
{
if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->buffer))
&& !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row))
row->indicate_eob_p = !NILP (boundary_bot), bot_ind_rn = rn;
else if (y + row->height >= yb)
row->indicate_bottom_line_p = !NILP (arrow_bot), bot_ind_rn = rn;
}
}
}
}
empty_pos = BVAR (XBUFFER (w->buffer), indicate_empty_lines);
if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
for (y = 0; y < MAX_BITMAP_CACHE; y++)
bitmap_cache[y] = -1;
#define LEFT_FRINGE(cache, which, partial_p) \
(bitmap_cache[cache*4+partial_p] >= 0 \
? bitmap_cache[cache*4+partial_p] \
: (bitmap_cache[cache*4+partial_p] = \
get_logical_fringe_bitmap (w, which, 0, partial_p)))
#define RIGHT_FRINGE(cache, which, partial_p) \
(bitmap_cache[cache*4+2+partial_p] >= 0 \
? bitmap_cache[cache*4+2+partial_p] \
: (bitmap_cache[cache*4+2+partial_p] = \
get_logical_fringe_bitmap (w, which, 1, partial_p)))
/* Extend top-aligned top indicator (or bottom-aligned bottom
indicator) to adjacent rows if it doesn't fit in one row. */
top_ind_min_y = bot_ind_max_y = -1;
if (top_ind_rn >= 0)
{
int bn = NO_FRINGE_BITMAP;
row = w->desired_matrix->rows + top_ind_rn;
if (!row->enabled_p)
row = w->current_matrix->rows + top_ind_rn;
top_row_ends_at_zv_p = row->ends_at_zv_p;
if (row->indicate_bob_p)
{
if (EQ (boundary_top, Qleft))
bn = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
? LEFT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
: LEFT_FRINGE (2, Qtop, 0));
else
bn = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
? RIGHT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
: RIGHT_FRINGE (2, Qtop, 0));
}
else if (row->indicate_top_line_p)
{
if (EQ (arrow_top, Qleft))
bn = LEFT_FRINGE (6, Qup, 0);
else
bn = RIGHT_FRINGE (6, Qup, 0);
}
if (bn != NO_FRINGE_BITMAP)
{
struct fringe_bitmap *fb = get_fringe_bitmap_data (bn);
if (fb->align == ALIGN_BITMAP_TOP && fb->period == 0)
{
struct glyph_row *row1;
int top_ind_max_y;
top_ind_min_y = WINDOW_HEADER_LINE_HEIGHT (w);
top_ind_max_y = top_ind_min_y + fb->height;
if (top_ind_max_y > yb)
top_ind_max_y = yb;
for (y = row->y + row->height, rn = top_ind_rn + 1;
y < top_ind_max_y && rn < nrows;
y += row1->height, rn++)
{
if (bot_ind_rn >= 0 && rn >= bot_ind_rn)
break;
row1 = w->desired_matrix->rows + rn;
if (!row1->enabled_p)
row1 = w->current_matrix->rows + rn;
row1->indicate_bob_p = row->indicate_bob_p;
row1->indicate_top_line_p = row->indicate_top_line_p;
}
}
}
}
if (bot_ind_rn >= 0)
{
int bn = NO_FRINGE_BITMAP;
row = w->desired_matrix->rows + bot_ind_rn;
if (!row->enabled_p)
row = w->current_matrix->rows + bot_ind_rn;
bot_row_ends_at_zv_p = row->ends_at_zv_p;
if (row->indicate_eob_p)
{
if (EQ (boundary_bot, Qleft))
bn = LEFT_FRINGE (3, Qbottom, row->ends_at_zv_p);
else
bn = RIGHT_FRINGE (3, Qbottom, row->ends_at_zv_p);
}
else if (row->indicate_bottom_line_p)
{
if (EQ (arrow_bot, Qleft))
bn = LEFT_FRINGE (7, Qdown, 0);
else
bn = RIGHT_FRINGE (7, Qdown, 0);
}
if (bn != NO_FRINGE_BITMAP)
{
struct fringe_bitmap *fb = get_fringe_bitmap_data (bn);
if (fb->align == ALIGN_BITMAP_BOTTOM && fb->period == 0)
{
struct glyph_row *row1;
int bot_ind_min_y;
bot_ind_max_y = row->y + row->visible_height;
bot_ind_min_y = bot_ind_max_y - fb->height;
if (bot_ind_min_y < WINDOW_HEADER_LINE_HEIGHT (w))
bot_ind_min_y = WINDOW_HEADER_LINE_HEIGHT (w);
for (y = row->y, rn = bot_ind_rn - 1;
y >= bot_ind_min_y && rn >= 0;
y -= row1->height, rn--)
{
if (top_ind_rn >= 0 && rn <= top_ind_rn)
break;
row1 = w->desired_matrix->rows + rn;
if (!row1->enabled_p)
row1 = w->current_matrix->rows + rn;
row1->indicate_eob_p = row->indicate_eob_p;
row1->indicate_bottom_line_p = row->indicate_bottom_line_p;
}
}
}
}
for (y = w->vscroll, rn = 0;
y < yb && rn < nrows;
y += row->height, rn++)
{
int left, right;
unsigned left_face_id, right_face_id;
int left_offset, right_offset;
int periodic_p;
row = w->desired_matrix->rows + rn;
cur = w->current_matrix->rows + rn;
if (!row->enabled_p)
row = cur;
left_face_id = right_face_id = DEFAULT_FACE_ID;
left_offset = right_offset = 0;
periodic_p = 0;
/* Decide which bitmap to draw in the left fringe. */
if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
left = NO_FRINGE_BITMAP;
else if (row->left_user_fringe_bitmap != NO_FRINGE_BITMAP)
{
left = row->left_user_fringe_bitmap;
left_face_id = row->left_user_fringe_face_id;
}
else if ((!row->reversed_p && row->truncated_on_left_p)
|| (row->reversed_p && row->truncated_on_right_p))
left = LEFT_FRINGE (0, Qtruncation, 0);
else if (row->indicate_bob_p && EQ (boundary_top, Qleft))
{
left = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
? LEFT_FRINGE (1, Qtop_bottom, top_row_ends_at_zv_p)
: LEFT_FRINGE (2, Qtop, 0));
if (top_ind_min_y >= 0)
left_offset = top_ind_min_y - row->y;
}
else if (row->indicate_eob_p && EQ (boundary_bot, Qleft))
{
left = LEFT_FRINGE (3, Qbottom, bot_row_ends_at_zv_p);
if (bot_ind_max_y >= 0)
left_offset = bot_ind_max_y - (row->y + row->visible_height);
}
else if ((!row->reversed_p && MATRIX_ROW_CONTINUATION_LINE_P (row))
|| (row->reversed_p && row->continued_p))
left = LEFT_FRINGE (4, Qcontinuation, 0);
else if (row->indicate_empty_line_p && EQ (empty_pos, Qleft))
left = LEFT_FRINGE (5, Qempty_line, 0);
else if (row->indicate_top_line_p && EQ (arrow_top, Qleft))
{
left = LEFT_FRINGE (6, Qup, 0);
if (top_ind_min_y >= 0)
left_offset = top_ind_min_y - row->y;
}
else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qleft))
{
left = LEFT_FRINGE (7, Qdown, 0);
if (bot_ind_max_y >= 0)
left_offset = bot_ind_max_y - (row->y + row->visible_height);
}
else
left = NO_FRINGE_BITMAP;
/* Decide which bitmap to draw in the right fringe. */
if (WINDOW_RIGHT_FRINGE_WIDTH (w) == 0)
right = NO_FRINGE_BITMAP;
else if (row->right_user_fringe_bitmap != NO_FRINGE_BITMAP)
{
right = row->right_user_fringe_bitmap;
right_face_id = row->right_user_fringe_face_id;
}
else if ((!row->reversed_p && row->truncated_on_right_p)
|| (row->reversed_p && row->truncated_on_left_p))
right = RIGHT_FRINGE (0, Qtruncation, 0);
else if (row->indicate_bob_p && EQ (boundary_top, Qright))
{
right = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
? RIGHT_FRINGE (1, Qtop_bottom, top_row_ends_at_zv_p)
: RIGHT_FRINGE (2, Qtop, 0));
if (top_ind_min_y >= 0)
right_offset = top_ind_min_y - row->y;
}
else if (row->indicate_eob_p && EQ (boundary_bot, Qright))
{
right = RIGHT_FRINGE (3, Qbottom, bot_row_ends_at_zv_p);
if (bot_ind_max_y >= 0)
right_offset = bot_ind_max_y - (row->y + row->visible_height);
}
else if ((!row->reversed_p && row->continued_p)
|| (row->reversed_p && MATRIX_ROW_CONTINUATION_LINE_P (row)))
right = RIGHT_FRINGE (4, Qcontinuation, 0);
else if (row->indicate_top_line_p && EQ (arrow_top, Qright))
{
right = RIGHT_FRINGE (6, Qup, 0);
if (top_ind_min_y >= 0)
right_offset = top_ind_min_y - row->y;
}
else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qright))
{
right = RIGHT_FRINGE (7, Qdown, 0);
if (bot_ind_max_y >= 0)
right_offset = bot_ind_max_y - (row->y + row->visible_height);
}
else if (row->indicate_empty_line_p && EQ (empty_pos, Qright))
right = RIGHT_FRINGE (5, Qempty_line, 0);
else
right = NO_FRINGE_BITMAP;
periodic_p = (get_fringe_bitmap_data (left)->period != 0
|| get_fringe_bitmap_data (right)->period != 0);
if (row->y != cur->y
|| row->visible_height != cur->visible_height
|| row->ends_at_zv_p != cur->ends_at_zv_p
|| left != cur->left_fringe_bitmap
|| right != cur->right_fringe_bitmap
|| left_face_id != cur->left_fringe_face_id
|| right_face_id != cur->right_fringe_face_id
|| left_offset != cur->left_fringe_offset
|| right_offset != cur->right_fringe_offset
|| periodic_p != cur->fringe_bitmap_periodic_p
|| cur->redraw_fringe_bitmaps_p)
{
redraw_p = row->redraw_fringe_bitmaps_p = 1;
if (!keep_current_p)
{
cur->redraw_fringe_bitmaps_p = 1;
cur->left_fringe_bitmap = left;
cur->right_fringe_bitmap = right;
cur->left_fringe_face_id = left_face_id;
cur->right_fringe_face_id = right_face_id;
cur->left_fringe_offset = left_offset;
cur->right_fringe_offset = right_offset;
cur->fringe_bitmap_periodic_p = periodic_p;
}
}
if (row->overlay_arrow_bitmap < 0)
row->overlay_arrow_bitmap = get_logical_fringe_bitmap (w, Qoverlay_arrow, 0, 0);
if (row->overlay_arrow_bitmap != cur->overlay_arrow_bitmap)
{
redraw_p = row->redraw_fringe_bitmaps_p = 1;
if (!keep_current_p)
{
cur->redraw_fringe_bitmaps_p = 1;
cur->overlay_arrow_bitmap = row->overlay_arrow_bitmap;
}
}
row->left_fringe_bitmap = left;
row->right_fringe_bitmap = right;
row->left_fringe_face_id = left_face_id;
row->right_fringe_face_id = right_face_id;
row->left_fringe_offset = left_offset;
row->right_fringe_offset = right_offset;
row->fringe_bitmap_periodic_p = periodic_p;
}
return redraw_p && !keep_current_p;
}
static int
get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, int partial_p)
{
Lisp_Object cmap, bm1 = Qnil, bm2 = Qnil, bm;
int ln1 = 0, ln2 = 0;
int ix1 = right_p;
int ix2 = ix1 + (partial_p ? 2 : 0);
/* Lookup in buffer-local fringe-indicator-alist before global alist.
Elements are:
BITMAP -- use for all
(L R) -- use for left right (whether partial or not)
(L R PL PR) -- use for left right partial-left partial-right
If any value in local binding is not present or t, use global value.
If partial, lookup partial bitmap in default value if not found here.
If not partial, or no partial spec is present, use non-partial bitmap. */
if ((cmap = BVAR (XBUFFER (w->buffer), fringe_indicator_alist)), !NILP (cmap))
{
bm1 = Fassq (bitmap, cmap);
if (CONSP (bm1))
{
if ((bm1 = XCDR (bm1)), NILP (bm1))
return NO_FRINGE_BITMAP;
if (CONSP (bm1))
{
ln1 = XINT (Flength (bm1));
if (partial_p)
{
if (ln1 > ix2)
{
bm = Fnth (make_number (ix2), bm1);
if (!EQ (bm, Qt))
goto found;
}
}
else
{
if (ln1 > ix1)
{
bm = Fnth (make_number (ix1), bm1);
if (!EQ (bm, Qt))
goto found;
}
}
}
else if ((bm = bm1, !EQ (bm, Qt)))
goto found;
}
}
if (!EQ (cmap, BVAR (&buffer_defaults, fringe_indicator_alist))
&& !NILP (BVAR (&buffer_defaults, fringe_indicator_alist)))
{
bm2 = Fassq (bitmap, BVAR (&buffer_defaults, fringe_indicator_alist));
if (CONSP (bm2))
{
if ((bm2 = XCDR (bm2)), !NILP (bm2))
{
if (CONSP (bm2))
{
ln2 = XINT (Flength (bm2));
if (partial_p)
{
if (ln2 > ix2)
{
bm = Fnth (make_number (ix2), bm2);
if (!EQ (bm, Qt))
goto found;
}
}
}
}
}
}
if (ln1 > ix1)
{
bm = Fnth (make_number (ix1), bm1);
if (!EQ (bm, Qt))
goto found;
}
if (ln2 > ix1)
{
bm = Fnth (make_number (ix1), bm2);
if (!EQ (bm, Qt))
goto found;
return NO_FRINGE_BITMAP;
}
else if ((bm = bm2, NILP (bm)))
return NO_FRINGE_BITMAP;
found:
return lookup_fringe_bitmap (bm);
}
void
compute_fringe_widths (struct frame *f, int redraw)
{
int o_left = FRAME_LEFT_FRINGE_WIDTH (f);
int o_right = FRAME_RIGHT_FRINGE_WIDTH (f);
int o_cols = FRAME_FRINGE_COLS (f);
Lisp_Object left_fringe = Fassq (Qleft_fringe, f->param_alist);
Lisp_Object right_fringe = Fassq (Qright_fringe, f->param_alist);
int left_fringe_width, right_fringe_width;
if (!NILP (left_fringe))
left_fringe = Fcdr (left_fringe);
if (!NILP (right_fringe))
right_fringe = Fcdr (right_fringe);
left_fringe_width = ((NILP (left_fringe) || !INTEGERP (left_fringe)) ? 8 :
XINT (left_fringe));
right_fringe_width = ((NILP (right_fringe) || !INTEGERP (right_fringe)) ? 8 :
XINT (right_fringe));
if (left_fringe_width || right_fringe_width)
{
int left_wid = left_fringe_width >= 0 ? left_fringe_width : -left_fringe_width;
int right_wid = right_fringe_width >= 0 ? right_fringe_width : -right_fringe_width;
int conf_wid = left_wid + right_wid;
int font_wid = FRAME_COLUMN_WIDTH (f);
int cols = (left_wid + right_wid + font_wid-1) / font_wid;
int real_wid = cols * font_wid;
if (left_wid && right_wid)
{
if (left_fringe_width < 0)
{
/* Left fringe width is fixed, adjust right fringe if necessary */
FRAME_LEFT_FRINGE_WIDTH (f) = left_wid;
FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid - left_wid;
}
else if (right_fringe_width < 0)
{
/* Right fringe width is fixed, adjust left fringe if necessary */
FRAME_LEFT_FRINGE_WIDTH (f) = real_wid - right_wid;
FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid;
}
else
{
/* Adjust both fringes with an equal amount.
Note that we are doing integer arithmetic here, so don't
lose a pixel if the total width is an odd number. */
int fill = real_wid - conf_wid;
FRAME_LEFT_FRINGE_WIDTH (f) = left_wid + fill/2;
FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid + fill - fill/2;
}
}
else if (left_fringe_width)
{
FRAME_LEFT_FRINGE_WIDTH (f) = real_wid;
FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
}
else
{
FRAME_LEFT_FRINGE_WIDTH (f) = 0;
FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid;
}
FRAME_FRINGE_COLS (f) = cols;
}
else
{
FRAME_LEFT_FRINGE_WIDTH (f) = 0;
FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
FRAME_FRINGE_COLS (f) = 0;
}
if (redraw && FRAME_VISIBLE_P (f))
if (o_left != FRAME_LEFT_FRINGE_WIDTH (f) ||
o_right != FRAME_RIGHT_FRINGE_WIDTH (f) ||
o_cols != FRAME_FRINGE_COLS (f))
redraw_frame (f);
}
ATTRS is an alist with any of the following pairs:
(font . FONT-NAME)
(position . (X . Y))
(dimensions . (COLS . ROWS))
(buffer . BUFFER)
::end:: */
{
Lisp_Window *w;
repv tem, tx, font;
int dims[4];
memcpy (dims, def_dims, sizeof (dims));
tem = Fassq (Qbuffer, attrs);
if (!tem)
return 0;
if (tem != Qnil)
tx = rep_CDR(tem);
else
tx = curr_vw ? rep_VAL(curr_vw->tx) : Qnil;
tem = Fassq (Qposition, attrs);
if (!tem)
return 0;
if (tem != Qnil && rep_CONSP(rep_CDR(tem)))
{
dims[0] = rep_INT(rep_CADR(tem));
dims[1] = rep_INT(rep_CDDR(tem));
}
/* Delete any uncompressed data already inserted on error. */
if (data->start)
del_range (data->start, PT);
/* Put point where it was, or if the buffer has shrunk because the
compressed data is bigger than the uncompressed, at
point-max. */
SET_PT (min (data->old_point, ZV));
}
DEFUN ("zlib-available-p", Fzlib_available_p, Szlib_available_p, 0, 0, 0,
doc: /* Return t if zlib decompression is available in this instance of Emacs. */)
(void)
{
#ifdef WINDOWSNT
Lisp_Object found = Fassq (Qzlib_dll, Vlibrary_cache);
if (CONSP (found))
return XCDR (found);
else
{
Lisp_Object status;
zlib_initialized = init_zlib_functions ();
status = zlib_initialized ? Qt : Qnil;
Vlibrary_cache = Fcons (Fcons (Qzlib_dll, status), Vlibrary_cache);
return status;
}
#else
return Qt;
#endif
}
repv gh_assq(repv x, repv alist)
{
return Fassq (x, alist);
}