void
select_palette (FRAME_PTR f, HDC hdc)
{
struct w32_display_info *display_info = FRAME_W32_DISPLAY_INFO (f);
if (!display_info->has_palette)
return;
if (display_info->palette == 0)
return;
if (!NILP (Vw32_enable_palette))
f->output_data.w32->old_palette =
SelectPalette (hdc, display_info->palette, FALSE);
else
f->output_data.w32->old_palette = NULL;
if (RealizePalette (hdc))
{
Lisp_Object frame, framelist;
FOR_EACH_FRAME (framelist, frame)
{
SET_FRAME_GARBAGED (XFRAME (frame));
}
}
/* Return non-zero if menus can handle radio and toggle buttons. */
static bool
have_boxes (void)
{
#if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NTGUI) || defined(HAVE_NS)
if (FRAME_WINDOW_P (XFRAME (Vmenu_updating_frame)))
return 1;
#endif
return 0;
}
/* Encode a menu string as appropriate for menu-updating-frame's type. */
static Lisp_Object
encode_menu_string (Lisp_Object str)
{
/* TTY menu strings are encoded by write_glyphs, when they are
delivered to the glass, so no need to encode them here. */
if (FRAME_TERMCAP_P (XFRAME (Vmenu_updating_frame)))
return str;
return ENCODE_MENU_STRING (str);
}
static struct frame *
frame_for_x_selection (Lisp_Object object)
{
Lisp_Object tail;
struct frame *f;
if (NILP (object))
{
f = XFRAME (selected_frame);
if (FRAME_MAC_P (f) && FRAME_LIVE_P (f))
return f;
for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
{
f = XFRAME (XCAR (tail));
if (FRAME_MAC_P (f) && FRAME_LIVE_P (f))
return f;
}
}
else if (TERMINALP (object))
{
struct terminal *t = get_terminal (object, 1);
if (t->type == output_mac)
{
for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
{
f = XFRAME (XCAR (tail));
if (FRAME_LIVE_P (f) && f->terminal == t)
return f;
}
}
}
else if (FRAMEP (object))
{
f = XFRAME (object);
if (FRAME_MAC_P (f) && FRAME_LIVE_P (f))
return f;
}
return NULL;
}
/* A device method. */
static void
x_update_scrollbar_instance_status (struct window *w, int active, int size,
struct scrollbar_instance *instance)
{
struct frame *f = XFRAME (w->frame);
Boolean managed = XtIsManaged (SCROLLBAR_X_WIDGET (instance));
if (active && size)
{
widget_value *wv = scrollbar_instance_to_widget_value (instance);
if (instance->scrollbar_instance_changed)
{
lw_modify_all_widgets (SCROLLBAR_X_ID (instance), wv, 0);
instance->scrollbar_instance_changed = 0;
}
if (!managed)
{
XtManageChild (SCROLLBAR_X_WIDGET (instance));
if (XtWindow (SCROLLBAR_X_WIDGET (instance)))
{
/* Raise this window so that it's visible on top of the
text window below it. */
XRaiseWindow (XtDisplay (SCROLLBAR_X_WIDGET (instance)),
XtWindow (SCROLLBAR_X_WIDGET (instance)));
update_one_widget_scrollbar_pointer
(w, SCROLLBAR_X_WIDGET (instance));
if (!SCROLLBAR_X_BACKING_STORE_INITIALIZED (instance))
{
update_one_scrollbar_bs (f, SCROLLBAR_X_WIDGET (instance));
SCROLLBAR_X_BACKING_STORE_INITIALIZED (instance) = 1;
}
}
}
if (!wv->scrollbar_data) ABORT ();
free_widget_value_tree (wv);
}
else if (managed)
{
#if defined (LWLIB_SCROLLBARS_MOTIF) || defined (LWLIB_SCROLLBARS_LUCID)
/* This isn't needed with Athena Scrollbars. It might not be needed */
/* with Motif scrollbars (it is apparently needed with Lesstif). */
XtUngrabKeyboard (SCROLLBAR_X_WIDGET (instance), CurrentTime);
#endif
XtUnmanageChild (SCROLLBAR_X_WIDGET (instance));
}
}
static Lisp_Object
uniscribe_list_family (Lisp_Object frame)
{
Lisp_Object list = Qnil;
LOGFONT font_match_pattern;
HDC dc;
FRAME_PTR f = XFRAME (frame);
memset (&font_match_pattern, 0, sizeof (font_match_pattern));
/* Limit enumerated fonts to outline fonts to save time. */
font_match_pattern.lfOutPrecision = OUT_OUTLINE_PRECIS;
dc = get_frame_dc (f);
EnumFontFamiliesEx (dc, &font_match_pattern,
(FONTENUMPROC) add_opentype_font_name_to_list,
(LPARAM) &list, 0);
release_frame_dc (f, dc);
return list;
}
static Lisp_Object
x_get_foreign_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
Lisp_Object time_stamp, Lisp_Object frame)
{
struct frame *f = XFRAME (frame);
OSStatus err;
Selection sel;
Lisp_Object result = Qnil;
if (!FRAME_LIVE_P (f))
return Qnil;
block_input ();
err = mac_get_selection_from_symbol (selection_symbol, 0, &sel);
if (err == noErr && sel)
{
if (EQ (target_type, QTARGETS))
{
Lisp_Object args[2];
args[0] = list1 (QTARGETS);
args[1] = mac_get_selection_target_list (sel);
result = Fvconcat (2, args);
}
else
{
result = mac_get_selection_value (sel, target_type);
if (STRINGP (result))
Fput_text_property (make_number (0), make_number (SBYTES (result)),
Qforeign_selection, target_type, result);
}
}
unblock_input ();
return result;
}
widget_value *
digest_single_submenu (int start, int end, bool top_level_items)
{
widget_value *wv, *prev_wv, *save_wv, *first_wv;
int i;
int submenu_depth = 0;
widget_value **submenu_stack;
bool panes_seen = 0;
struct frame *f = XFRAME (Vmenu_updating_frame);
USE_SAFE_ALLOCA;
SAFE_NALLOCA (submenu_stack, 1, menu_items_used);
wv = make_widget_value ("menu", NULL, true, Qnil);
wv->button_type = BUTTON_TYPE_NONE;
first_wv = wv;
save_wv = 0;
prev_wv = 0;
/* Loop over all panes and items made by the preceding call
to parse_single_submenu and construct a tree of widget_value objects.
Ignore the panes and items used by previous calls to
digest_single_submenu, even though those are also in menu_items. */
i = start;
while (i < end)
{
if (EQ (AREF (menu_items, i), Qnil))
{
submenu_stack[submenu_depth++] = save_wv;
save_wv = prev_wv;
prev_wv = 0;
i++;
}
else if (EQ (AREF (menu_items, i), Qlambda))
{
prev_wv = save_wv;
save_wv = submenu_stack[--submenu_depth];
i++;
}
else if (EQ (AREF (menu_items, i), Qt)
&& submenu_depth != 0)
i += MENU_ITEMS_PANE_LENGTH;
/* Ignore a nil in the item list.
It's meaningful only for dialog boxes. */
else if (EQ (AREF (menu_items, i), Qquote))
i += 1;
else if (EQ (AREF (menu_items, i), Qt))
{
/* Create a new pane. */
Lisp_Object pane_name;
const char *pane_string;
panes_seen = 1;
pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
/* TTY menus display menu items via tty_write_glyphs, which
will encode the strings as appropriate. */
if (!FRAME_TERMCAP_P (f))
{
#ifdef HAVE_NTGUI
if (STRINGP (pane_name))
{
if (unicode_append_menu)
/* Encode as UTF-8 for now. */
pane_name = ENCODE_UTF_8 (pane_name);
else if (STRING_MULTIBYTE (pane_name))
pane_name = ENCODE_SYSTEM (pane_name);
ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);
}
#elif defined (USE_LUCID) && defined (HAVE_XFT)
if (STRINGP (pane_name))
{
pane_name = ENCODE_UTF_8 (pane_name);
ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);
}
#elif !defined (HAVE_MULTILINGUAL_MENU)
if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))
{
pane_name = ENCODE_MENU_STRING (pane_name);
ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);
}
#endif
}
pane_string = (NILP (pane_name)
? "" : SSDATA (pane_name));
/* If there is just one top-level pane, put all its items directly
under the top-level menu. */
if (menu_items_n_panes == 1)
pane_string = "";
/* If the pane has a meaningful name,
make the pane a top-level menu item
with its items as a submenu beneath it. */
if (strcmp (pane_string, ""))
{
/* Set value to 1 so update_submenu_strings can handle '@'. */
wv = make_widget_value (NULL, (char *) 1, true, Qnil);
if (save_wv)
save_wv->next = wv;
else
first_wv->contents = wv;
wv->lname = pane_name;
wv->button_type = BUTTON_TYPE_NONE;
save_wv = wv;
}
else
save_wv = first_wv;
prev_wv = 0;
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
/* Create a new item within current pane. */
Lisp_Object item_name, enable, descrip, def, type, selected;
Lisp_Object help;
/* All items should be contained in panes. */
if (! panes_seen)
emacs_abort ();
item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);
descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);
def = AREF (menu_items, i + MENU_ITEMS_ITEM_DEFINITION);
type = AREF (menu_items, i + MENU_ITEMS_ITEM_TYPE);
selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);
help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
/* TTY menu items and their descriptions will be encoded by
tty_write_glyphs. */
if (!FRAME_TERMCAP_P (f))
{
#ifdef HAVE_NTGUI
if (STRINGP (item_name))
{
if (unicode_append_menu)
item_name = ENCODE_UTF_8 (item_name);
else if (STRING_MULTIBYTE (item_name))
item_name = ENCODE_SYSTEM (item_name);
ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);
}
if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
{
descrip = ENCODE_SYSTEM (descrip);
ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);
}
#elif USE_LUCID
if (STRINGP (item_name))
{
item_name = ENCODE_UTF_8 (item_name);
ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);
}
if (STRINGP (descrip))
{
descrip = ENCODE_UTF_8 (descrip);
ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);
}
#elif !defined (HAVE_MULTILINGUAL_MENU)
if (STRING_MULTIBYTE (item_name))
{
item_name = ENCODE_MENU_STRING (item_name);
ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);
}
if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
{
descrip = ENCODE_MENU_STRING (descrip);
ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);
}
#endif
}
wv = make_widget_value (NULL, NULL, !NILP (enable),
STRINGP (help) ? help : Qnil);
if (prev_wv)
prev_wv->next = wv;
else
save_wv->contents = wv;
wv->lname = item_name;
if (!NILP (descrip))
wv->lkey = descrip;
/* The intptr_t cast avoids a warning. There's no problem
as long as pointers have enough bits to hold small integers. */
wv->call_data = (!NILP (def) ? (void *) (intptr_t) i : 0);
if (NILP (type))
wv->button_type = BUTTON_TYPE_NONE;
else if (EQ (type, QCradio))
wv->button_type = BUTTON_TYPE_RADIO;
else if (EQ (type, QCtoggle))
wv->button_type = BUTTON_TYPE_TOGGLE;
else
emacs_abort ();
wv->selected = !NILP (selected);
prev_wv = wv;
i += MENU_ITEMS_ITEM_LENGTH;
}
}
/* If we have just one "menu item"
that was originally a button, return it by itself. */
if (top_level_items && first_wv->contents && first_wv->contents->next == 0)
{
wv = first_wv;
first_wv = first_wv->contents;
xfree (wv);
}
SAFE_FREE ();
return first_wv;
}
static void
single_menu_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy, void *skp_v)
{
Lisp_Object map, item_string, enabled;
struct gcpro gcpro1, gcpro2;
bool res;
struct skp *skp = skp_v;
/* Parse the menu item and leave the result in item_properties. */
GCPRO2 (key, item);
res = parse_menu_item (item, 0);
UNGCPRO;
if (!res)
return; /* Not a menu item. */
map = AREF (item_properties, ITEM_PROPERTY_MAP);
enabled = AREF (item_properties, ITEM_PROPERTY_ENABLE);
item_string = AREF (item_properties, ITEM_PROPERTY_NAME);
if (!NILP (map) && SREF (item_string, 0) == '@')
{
if (!NILP (enabled))
/* An enabled separate pane. Remember this to handle it later. */
skp->pending_maps = Fcons (Fcons (map, Fcons (item_string, key)),
skp->pending_maps);
return;
}
/* Simulate radio buttons and toggle boxes by putting a prefix in
front of them. */
if (!have_boxes ())
{
char const *prefix = 0;
Lisp_Object type = AREF (item_properties, ITEM_PROPERTY_TYPE);
if (!NILP (type))
{
Lisp_Object selected
= AREF (item_properties, ITEM_PROPERTY_SELECTED);
if (skp->notbuttons)
/* The first button. Line up previous items in this menu. */
{
int idx = skp->notbuttons; /* Index for first item this menu. */
int submenu = 0;
Lisp_Object tem;
while (idx < menu_items_used)
{
tem
= AREF (menu_items, idx + MENU_ITEMS_ITEM_NAME);
if (NILP (tem))
{
idx++;
submenu++; /* Skip sub menu. */
}
else if (EQ (tem, Qlambda))
{
idx++;
submenu--; /* End sub menu. */
}
else if (EQ (tem, Qt))
idx += 3; /* Skip new pane marker. */
else if (EQ (tem, Qquote))
idx++; /* Skip a left, right divider. */
else
{
if (!submenu && SREF (tem, 0) != '\0'
&& SREF (tem, 0) != '-')
ASET (menu_items, idx + MENU_ITEMS_ITEM_NAME,
concat2 (SCOPED_STRING (" "), tem));
idx += MENU_ITEMS_ITEM_LENGTH;
}
}
skp->notbuttons = 0;
}
/* Calculate prefix, if any, for this item. */
if (EQ (type, QCtoggle))
prefix = NILP (selected) ? "[ ] " : "[X] ";
else if (EQ (type, QCradio))
prefix = NILP (selected) ? "( ) " : "(*) ";
}
/* Not a button. If we have earlier buttons, then we need a prefix. */
else if (!skp->notbuttons && SREF (item_string, 0) != '\0'
&& SREF (item_string, 0) != '-')
prefix = " ";
if (prefix)
item_string = concat2 (SCOPED_STRING (prefix), item_string);
}
if ((FRAME_TERMCAP_P (XFRAME (Vmenu_updating_frame))
|| FRAME_MSDOS_P (XFRAME (Vmenu_updating_frame)))
&& !NILP (map))
/* Indicate visually that this is a submenu. */
item_string = concat2 (item_string, SCOPED_STRING (" >"));
push_menu_item (item_string, enabled, key,
AREF (item_properties, ITEM_PROPERTY_DEF),
AREF (item_properties, ITEM_PROPERTY_KEYEQ),
AREF (item_properties, ITEM_PROPERTY_TYPE),
AREF (item_properties, ITEM_PROPERTY_SELECTED),
AREF (item_properties, ITEM_PROPERTY_HELP));
#if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
/* Display a submenu using the toolkit. */
if (FRAME_WINDOW_P (XFRAME (Vmenu_updating_frame))
&& ! (NILP (map) || NILP (enabled)))
{
push_submenu_start ();
single_keymap_panes (map, Qnil, key, skp->maxdepth - 1);
push_submenu_end ();
}
#endif
}
static void
draw_fringe_bitmap_1 (struct window *w, struct glyph_row *row, int left_p, int overlay, int which)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct draw_fringe_bitmap_params p;
struct fringe_bitmap *fb;
int period;
int face_id = DEFAULT_FACE_ID;
int offset, header_line_height;
p.overlay_p = (overlay & 1) == 1;
p.cursor_p = (overlay & 2) == 2;
if (which != NO_FRINGE_BITMAP)
{
offset = 0;
}
else if (left_p)
{
which = row->left_fringe_bitmap;
face_id = row->left_fringe_face_id;
offset = row->left_fringe_offset;
}
else
{
which = row->right_fringe_bitmap;
face_id = row->right_fringe_face_id;
offset = row->right_fringe_offset;
}
if (face_id == DEFAULT_FACE_ID)
{
Lisp_Object face = fringe_faces[which];
face_id = NILP (face) ? lookup_named_face (f, Qfringe, 0)
: lookup_derived_face (f, face, FRINGE_FACE_ID, 0);
if (face_id < 0)
face_id = FRINGE_FACE_ID;
}
fb = get_fringe_bitmap_data (which);
period = fb->period;
/* Convert row to frame coordinates. */
p.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y) + offset;
p.which = which;
p.bits = fb->bits;
p.wd = fb->width;
p.h = fb->height;
p.dh = (period > 0 ? (p.y % period) : 0);
p.h -= p.dh;
/* Adjust y to the offset in the row to start drawing the bitmap. */
switch (fb->align)
{
case ALIGN_BITMAP_CENTER:
p.y += (row->height - p.h) / 2;
break;
case ALIGN_BITMAP_BOTTOM:
p.y += (row->visible_height - p.h);
break;
case ALIGN_BITMAP_TOP:
break;
}
p.face = FACE_FROM_ID (f, face_id);
if (p.face == NULL)
{
/* This could happen after clearing face cache.
But it shouldn't happen anymore. ++kfs */
return;
}
PREPARE_FACE_FOR_DISPLAY (f, p.face);
/* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
the fringe. */
p.bx = -1;
header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
p.by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, row->y));
p.ny = row->visible_height;
if (left_p)
{
int wd = WINDOW_LEFT_FRINGE_WIDTH (w);
int x = window_box_left (w, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
? LEFT_MARGIN_AREA
: TEXT_AREA));
if (p.wd > wd)
p.wd = wd;
p.x = x - p.wd - (wd - p.wd) / 2;
if (p.wd < wd || p.y > p.by || p.y + p.h < p.by + p.ny)
{
/* If W has a vertical border to its left, don't draw over it. */
wd -= ((!WINDOW_LEFTMOST_P (w)
&& !WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
? 1 : 0);
p.bx = x - wd;
p.nx = wd;
}
}
else
{
int x = window_box_right (w,
(WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
? RIGHT_MARGIN_AREA
: TEXT_AREA));
int wd = WINDOW_RIGHT_FRINGE_WIDTH (w);
if (p.wd > wd)
p.wd = wd;
p.x = x + (wd - p.wd) / 2;
/* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
the fringe. */
if (p.wd < wd || p.y > p.by || p.y + p.h < p.by + p.ny)
{
p.bx = x;
p.nx = wd;
}
}
FRAME_RIF (f)->draw_fringe_bitmap (w, row, &p);
}
static SIGTYPE
interrupt_signal (int sig)
{
/* This function can call lisp */
/* #### we should NOT be calling lisp from a signal handler, boys
and girls */
/* Must preserve main program's value of errno. */
int old_errno = errno;
EMACS_REESTABLISH_SIGNAL (sig, interrupt_signal);
/* with the macroized error-checking stuff, the garbage below
may mess things up because XCONSOLE() and such can use and
change global vars. */
#if ! (defined (ERROR_CHECK_TYPECHECK) && defined (MACROIZE_ERROR_CHECKING))
if (sigint_happened && CONSOLEP (Vcontrolling_terminal) &&
CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)) &&
!emacs_is_blocking)
{
char c;
fflush (stdout);
reset_initial_console ();
EMACS_UNBLOCK_SIGNAL (sig);
#ifdef SIGTSTP /* Support possible in later USG versions */
/*
* On systems which can suspend the current process and return to the original
* shell, this command causes the user to end up back at the shell.
* The "Auto-save" and "Abort" questions are not asked until
* the user elects to return to emacs, at which point he can save the current
* job and either dump core or continue.
*/
sys_suspend ();
#else
/* Perhaps should really fork an inferior shell?
But that would not provide any way to get back
to the original shell, ever. */
stdout_out ("No support for stopping a process on this operating system;\n");
stdout_out ("you can continue or abort.\n");
#endif /* not SIGTSTP */
stdout_out ("Auto-save? (y or n) ");
if (((c = getc (stdin)) & ~040) == 'Y')
Fdo_auto_save (Qnil, Qnil);
while (c != '\n')
c = getc (stdin);
stdout_out ("Abort (and dump core)? (y or n) ");
if (((c = getc (stdin)) & ~040) == 'Y')
ABORT ();
while (c != '\n')
c = getc (stdin);
stdout_out ("Continuing...\n");
reinit_initial_console ();
MARK_FRAME_CHANGED (XFRAME (DEVICE_SELECTED_FRAME
(XDEVICE (CONSOLE_SELECTED_DEVICE
(XCONSOLE
(Vcontrolling_terminal))))));
}
else
#endif /* ! (defined (ERROR_CHECKING) && defined (MACROIZE_ERROR_CHECKING)) */
{
/* Else request quit when it's safe */
Vquit_flag = Qt;
sigint_happened = 1;
#ifdef HAVE_UNIXOID_EVENT_LOOP
signal_fake_event ();
#endif
}
errno = old_errno;
SIGRETURN;
}
static void
draw_fringe_bitmap_1 (struct window *w, struct glyph_row *row, int left_p, int overlay, int which)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct draw_fringe_bitmap_params p;
struct fringe_bitmap *fb;
int period;
int face_id = DEFAULT_FACE_ID;
int offset, header_line_height;
p.overlay_p = (overlay & 1) == 1;
p.cursor_p = (overlay & 2) == 2;
if (which != NO_FRINGE_BITMAP)
{
offset = 0;
}
else if (left_p)
{
which = row->left_fringe_bitmap;
face_id = row->left_fringe_face_id;
offset = row->left_fringe_offset;
}
else
{
which = row->right_fringe_bitmap;
face_id = row->right_fringe_face_id;
offset = row->right_fringe_offset;
}
if (face_id == DEFAULT_FACE_ID)
{
Lisp_Object face = fringe_faces[which];
face_id = NILP (face) ? lookup_named_face (f, Qfringe, false)
: lookup_derived_face (f, face, FRINGE_FACE_ID, 0);
if (face_id < 0)
face_id = FRINGE_FACE_ID;
}
fb = get_fringe_bitmap_data (which);
period = fb->period;
/* Convert row to frame coordinates. */
p.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y) + offset;
p.which = which;
p.bits = fb->bits;
p.wd = fb->width;
p.h = fb->height;
p.dh = (period > 0 ? (p.y % period) : 0);
p.h -= p.dh;
/* Adjust y to the offset in the row to start drawing the bitmap. */
switch (fb->align)
{
case ALIGN_BITMAP_CENTER:
p.y += (row->height - p.h) / 2;
break;
case ALIGN_BITMAP_BOTTOM:
p.y += (row->visible_height - p.h);
break;
case ALIGN_BITMAP_TOP:
break;
}
p.face = FACE_FROM_ID_OR_NULL (f, face_id);
if (p.face == NULL)
{
/* This could happen after clearing face cache.
But it shouldn't happen anymore. ++kfs */
return;
}
prepare_face_for_display (f, p.face);
/* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
the fringe. */
p.bx = -1;
header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
p.by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, row->y));
p.ny = row->visible_height;
if (left_p)
{
int wd = WINDOW_LEFT_FRINGE_WIDTH (w);
int x = window_box_left (w, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
? LEFT_MARGIN_AREA
: TEXT_AREA));
if (p.wd > wd)
p.wd = wd;
p.x = x - p.wd - (wd - p.wd) / 2;
if (p.wd < wd || p.y > p.by || p.y + p.h < p.by + p.ny)
{
/* If W has a vertical border to its left, don't draw over it. */
wd -= ((!WINDOW_LEFTMOST_P (w)
/* This could be wrong when we allow window local
right dividers - but the window on the left is hard
to get. */
&& !FRAME_RIGHT_DIVIDER_WIDTH (f)
&& !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
/* But don't reduce the fringe width if the window
has a left margin, because that means we are not
in danger of drawing over the vertical border,
and OTOH leaving out that one pixel leaves behind
traces of the cursor, if it was in column zero
before drawing non-empty margin area. */
&& w->left_margin_cols == 0)
? 1 : 0);
p.bx = x - wd;
p.nx = wd;
}
}
else
{
int x = window_box_right (w,
(WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
? RIGHT_MARGIN_AREA
: TEXT_AREA));
int wd = WINDOW_RIGHT_FRINGE_WIDTH (w);
if (p.wd > wd)
p.wd = wd;
p.x = x + (wd - p.wd) / 2;
/* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
the fringe. */
if (p.wd < wd || p.y > p.by || p.y + p.h < p.by + p.ny)
{
p.bx = x;
p.nx = wd;
}
}
if (p.x >= WINDOW_BOX_LEFT_EDGE_X (w)
&& (p.x + p.wd) <= WINDOW_BOX_LEFT_EDGE_X (w) + WINDOW_PIXEL_WIDTH (w))
FRAME_RIF (f)->draw_fringe_bitmap (w, row, &p);
}
static void
x_own_selection (Lisp_Object selection_name, Lisp_Object selection_value,
Lisp_Object frame)
{
struct frame *f = XFRAME (frame);
struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
Time timestamp = last_event_timestamp;
OSStatus err;
Selection sel;
struct gcpro gcpro1, gcpro2;
Lisp_Object rest, handler_fn, value, target_type;
GCPRO2 (selection_name, selection_value);
block_input ();
err = mac_get_selection_from_symbol (selection_name, 1, &sel);
if (err == noErr && sel)
{
/* 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);
for (rest = Vselection_converter_alist; CONSP (rest); rest = XCDR (rest))
{
if (!(CONSP (XCAR (rest))
&& (target_type = XCAR (XCAR (rest)),
SYMBOLP (target_type))
&& mac_valid_selection_target_p (target_type)
&& (handler_fn = XCDR (XCAR (rest)),
SYMBOLP (handler_fn))))
continue;
if (!NILP (handler_fn))
value = call3 (handler_fn, selection_name,
target_type, selection_value);
else
value = Qnil;
if (NILP (value))
continue;
if (mac_valid_selection_value_p (value, target_type))
err = mac_put_selection_value (sel, target_type, value);
else if (CONSP (value)
&& EQ (XCAR (value), target_type)
&& mac_valid_selection_value_p (XCDR (value), target_type))
err = mac_put_selection_value (sel, target_type, XCDR (value));
}
unbind_to (count, Qnil);
}
unblock_input ();
UNGCPRO;
if (sel && err != noErr)
error ("Can't set selection");
/* Now update the local cache */
{
Lisp_Object selection_data;
Lisp_Object ownership_info;
Lisp_Object prev_value;
if (sel)
{
block_input ();
ownership_info = mac_get_selection_ownership_info (sel);
unblock_input ();
}
else
ownership_info = Qnil; /* dummy value for local-only selection */
selection_data = list5 (selection_name, selection_value,
INTEGER_TO_CONS (timestamp), frame, ownership_info);
prev_value = LOCAL_SELECTION (selection_name, dpyinfo);
tset_selection_alist
(dpyinfo->terminal,
Fcons (selection_data, dpyinfo->terminal->Vselection_alist));
/* If we already owned the selection, remove the old selection
data. Don't use Fdelq as that may QUIT. */
if (!NILP (prev_value))
{
/* We know it's not the CAR, so it's easy. */
Lisp_Object rest = dpyinfo->terminal->Vselection_alist;
for (; CONSP (rest); rest = XCDR (rest))
if (EQ (prev_value, Fcar (XCDR (rest))))
{
XSETCDR (rest, XCDR (XCDR (rest)));
break;
}
}
}
}
static void
apply_xft_settings (struct x_display_info *dpyinfo,
int send_event_p,
struct xsettings *settings)
{
#ifdef HAVE_XFT
FcPattern *pat;
struct xsettings oldsettings;
int changed = 0;
memset (&oldsettings, 0, sizeof (oldsettings));
pat = FcPatternCreate ();
XftDefaultSubstitute (dpyinfo->display,
XScreenNumberOfScreen (dpyinfo->screen),
pat);
FcPatternGetBool (pat, FC_ANTIALIAS, 0, &oldsettings.aa);
FcPatternGetBool (pat, FC_HINTING, 0, &oldsettings.hinting);
#ifdef FC_HINT_STYLE
FcPatternGetInteger (pat, FC_HINT_STYLE, 0, &oldsettings.hintstyle);
#endif
FcPatternGetInteger (pat, FC_LCD_FILTER, 0, &oldsettings.lcdfilter);
FcPatternGetInteger (pat, FC_RGBA, 0, &oldsettings.rgba);
FcPatternGetDouble (pat, FC_DPI, 0, &oldsettings.dpi);
if ((settings->seen & SEEN_AA) != 0 && oldsettings.aa != settings->aa)
{
FcPatternDel (pat, FC_ANTIALIAS);
FcPatternAddBool (pat, FC_ANTIALIAS, settings->aa);
++changed;
oldsettings.aa = settings->aa;
}
if ((settings->seen & SEEN_HINTING) != 0
&& oldsettings.hinting != settings->hinting)
{
FcPatternDel (pat, FC_HINTING);
FcPatternAddBool (pat, FC_HINTING, settings->hinting);
++changed;
oldsettings.hinting = settings->hinting;
}
if ((settings->seen & SEEN_RGBA) != 0 && oldsettings.rgba != settings->rgba)
{
FcPatternDel (pat, FC_RGBA);
FcPatternAddInteger (pat, FC_RGBA, settings->rgba);
oldsettings.rgba = settings->rgba;
++changed;
}
/* Older fontconfig versions don't have FC_LCD_FILTER. */
if ((settings->seen & SEEN_LCDFILTER) != 0
&& oldsettings.lcdfilter != settings->lcdfilter)
{
FcPatternDel (pat, FC_LCD_FILTER);
FcPatternAddInteger (pat, FC_LCD_FILTER, settings->lcdfilter);
++changed;
oldsettings.lcdfilter = settings->lcdfilter;
}
#ifdef FC_HINT_STYLE
if ((settings->seen & SEEN_HINTSTYLE) != 0
&& oldsettings.hintstyle != settings->hintstyle)
{
FcPatternDel (pat, FC_HINT_STYLE);
FcPatternAddInteger (pat, FC_HINT_STYLE, settings->hintstyle);
++changed;
oldsettings.hintstyle = settings->hintstyle;
}
#endif
if ((settings->seen & SEEN_DPI) != 0 && oldsettings.dpi != settings->dpi
&& settings->dpi > 0)
{
Lisp_Object frame, tail;
FcPatternDel (pat, FC_DPI);
FcPatternAddDouble (pat, FC_DPI, settings->dpi);
++changed;
oldsettings.dpi = settings->dpi;
/* Change the DPI on this display and all frames on the display. */
dpyinfo->resy = dpyinfo->resx = settings->dpi;
FOR_EACH_FRAME (tail, frame)
if (FRAME_X_P (XFRAME (frame))
&& FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
XFRAME (frame)->resy = XFRAME (frame)->resx = settings->dpi;
}
