/* Functions for the X window system.
- Copyright (C) 1989, 1992 Free Software Foundation.
+ Copyright (C) 1989, 1992, 1993 Free Software Foundation.
This file is part of GNU Emacs.
#ifdef HAVE_X_WINDOWS
extern void abort ();
+#include <X11/bitmaps/gray>
+
#define min(a,b) ((a) < (b) ? (a) : (b))
#define max(a,b) ((a) > (b) ? (a) : (b))
/* Color of chars displayed in cursor box. */
Lisp_Object Vx_cursor_fore_pixel;
-/* If non-nil, use vertical bar cursor. */
-Lisp_Object Vbar_cursor;
-
/* The X Visual we are using for X windows (the default) */
Visual *screen_visual;
Lisp_Object Vmouse_depressed;
extern unsigned int x_mouse_x, x_mouse_y, x_mouse_grabbed;
-extern Lisp_Object unread_command_event;
/* Atom for indicating window state to the window manager. */
Atom Xatom_wm_change_state;
/* When emacs became the selection owner. */
extern Time x_begin_selection_own;
-/* The value of the current emacs selection. */
-extern Lisp_Object Vx_selection_value;
-
/* Emacs' selection property identifier. */
extern Atom Xatom_emacs_selection;
Lisp_Object Qauto_raise;
Lisp_Object Qauto_lower;
Lisp_Object Qbackground_color;
+Lisp_Object Qbar;
Lisp_Object Qborder_color;
Lisp_Object Qborder_width;
+Lisp_Object Qbox;
Lisp_Object Qcursor_color;
+Lisp_Object Qcursor_type;
Lisp_Object Qfont;
Lisp_Object Qforeground_color;
Lisp_Object Qgeometry;
Lisp_Object Qinternal_border_width;
Lisp_Object Qleft;
Lisp_Object Qmouse_color;
+Lisp_Object Qnone;
Lisp_Object Qparent_id;
Lisp_Object Qsuppress_icon;
Lisp_Object Qsuppress_initial_map;
Lisp_Object Qtop;
Lisp_Object Qundefined_color;
+Lisp_Object Qvertical_scroll_bars;
Lisp_Object Qwindow_id;
Lisp_Object Qx_frame_parameter;
/* The below are defined in frame.c. */
-extern Lisp_Object Qheight, Qminibuffer, Qname, Qnone, Qonly, Qwidth;
+extern Lisp_Object Qheight, Qminibuffer, Qname, Qonly, Qwidth;
extern Lisp_Object Qunsplittable;
extern Lisp_Object Vwindow_system_version;
/* Points to table of defined typefaces. */
struct face *x_face_table[MAX_FACES_AND_GLYPHS];
-
-static char gray_bits[] =
- {
- 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa,
- 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa,
- 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa,
- 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa
- };
\f
/* Return the Emacs frame-object corresponding to an X window.
It could be the frame's main window or an icon window. */
X_PARM_NAME,
X_PARM_AUTORAISE,
X_PARM_AUTOLOWER,
- X_PARM_VERT_SCROLLBAR,
+ X_PARM_VERT_SCROLL_BAR,
};
void x_set_mouse_color ();
void x_set_cursor_color ();
void x_set_border_color ();
+void x_set_cursor_type ();
void x_set_icon_type ();
void x_set_font ();
void x_set_border_width ();
void x_explicitly_set_name ();
void x_set_autoraise ();
void x_set_autolower ();
-void x_set_vertical_scrollbar ();
+void x_set_vertical_scroll_bars ();
static struct x_frame_parm_table x_frame_parms[] =
{
"mouse-color", x_set_mouse_color,
"cursor-color", x_set_cursor_color,
"border-color", x_set_border_color,
+ "cursor-type", x_set_cursor_type,
"icon-type", x_set_icon_type,
"font", x_set_font,
"border-width", x_set_border_width,
"internal-border-width", x_set_internal_border_width,
"name", x_explicitly_set_name,
- "autoraise", x_set_autoraise,
- "autolower", x_set_autolower,
- "vertical-scrollbar", x_set_vertical_scrollbar,
+ "auto-raise", x_set_autoraise,
+ "auto-lower", x_set_autolower,
+ "vertical-scroll-bars", x_set_vertical_scroll_bars,
};
/* Attach the `x-frame-parameter' properties to
pix);
#else
if (pix < 0)
- temp = XMakePixmap ((Bitmap) XStoreBitmap (16, 16, gray_bits),
+ temp = XMakePixmap ((Bitmap) XStoreBitmap (gray_width, gray_height,
+ gray_bits),
BLACK_PIX_DEFAULT, WHITE_PIX_DEFAULT);
else
temp = XMakeTile (pix);
}
}
+void
+x_set_cursor_type (f, arg, oldval)
+ FRAME_PTR f;
+ Lisp_Object arg, oldval;
+{
+ if (EQ (arg, Qbar))
+ FRAME_DESIRED_CURSOR (f) = bar_cursor;
+ else if (EQ (arg, Qbox))
+ FRAME_DESIRED_CURSOR (f) = filled_box_cursor;
+ else
+ error
+ ("the `cursor-type' frame parameter should be either `bar' or `box'");
+
+ /* Make sure the cursor gets redrawn. This is overkill, but how
+ often do people change cursor types? */
+ update_mode_lines++;
+}
+
void
x_set_icon_type (f, arg, oldval)
struct frame *f;
if (NILP (arg))
result = x_text_icon (f, 0);
else
- result = x_bitmap_icon (f, 0);
+ result = x_bitmap_icon (f);
if (result)
{
}
}
-void x_user_set_name (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
-{
-}
-
/* Change the name of frame F to ARG. If ARG is nil, set F's name to
x_id_name.
/* If we're switching from explicit to implicit, we had better
update the mode lines and thereby update the title. */
if (f->explicit_name && NILP (name))
- update_mode_lines;
+ update_mode_lines = 1;
f->explicit_name = ! NILP (name);
}
}
void
-x_set_vertical_scrollbar (f, arg, oldval)
+x_set_vertical_scroll_bars (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
- if (NILP (arg) != ! FRAME_HAS_VERTICAL_SCROLLBARS (f))
+ if (NILP (arg) != ! FRAME_HAS_VERTICAL_SCROLL_BARS (f))
{
- FRAME_HAS_VERTICAL_SCROLLBARS (f) = ! NILP (arg);
+ FRAME_HAS_VERTICAL_SCROLL_BARS (f) = ! NILP (arg);
- x_set_window_size (f, FRAME_WIDTH (f), FRAME_HEIGHT (f));
+ /* We set this parameter before creating the X window for the
+ frame, so we can get the geometry right from the start.
+ However, if the window hasn't been created yet, we shouldn't
+ call x_set_window_size. */
+ if (FRAME_X_WINDOW (f))
+ x_set_window_size (f, FRAME_WIDTH (f), FRAME_HEIGHT (f));
}
}
\f
extern char *x_get_string_resource ();
extern XrmDatabase x_load_resources ();
-DEFUN ("x-get-resource", Fx_get_resource, Sx_get_resource, 1, 3, 0,
- "Retrieve the value of ATTRIBUTE from the X defaults database. This\n\
-searches using a key of the form \"INSTANCE.ATTRIBUTE\", with class\n\
-\"Emacs\", where INSTANCE is the name under which Emacs was invoked.\n\
+DEFUN ("x-get-resource", Fx_get_resource, Sx_get_resource, 2, 4, 0,
+ "Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.\n\
+This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the\n\
+class, where INSTANCE is the name under which Emacs was invoked.\n\
\n\
-Optional arguments COMPONENT and CLASS specify the component for which\n\
-we should look up ATTRIBUTE. When specified, Emacs searches using a\n\
-key of the form INSTANCE.COMPONENT.ATTRIBUTE, with class \"Emacs.CLASS\".")
- (attribute, name, class)
- Lisp_Object attribute, name, class;
+The optional arguments COMPONENT and SUBCLASS add to the key and the\n\
+class, respectively. You must specify both of them or neither.\n\
+If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'\n\
+and the class is `Emacs.CLASS.SUBCLASS'.")
+ (attribute, class, component, subclass)
+ Lisp_Object attribute, class, component, subclass;
{
register char *value;
char *name_key;
char *class_key;
CHECK_STRING (attribute, 0);
- if (!NILP (name))
- CHECK_STRING (name, 1);
- if (!NILP (class))
- CHECK_STRING (class, 2);
- if (NILP (name) != NILP (class))
- error ("x-get-resource: must specify both NAME and CLASS or neither");
-
- if (NILP (name))
- {
- name_key = (char *) alloca (XSTRING (invocation_name)->size + 1
- + XSTRING (attribute)->size + 1);
+ CHECK_STRING (class, 0);
+
+ if (!NILP (component))
+ CHECK_STRING (component, 1);
+ if (!NILP (subclass))
+ CHECK_STRING (subclass, 2);
+ if (NILP (component) != NILP (subclass))
+ error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
+
+ if (NILP (component))
+ {
+ /* Allocate space for the components, the dots which separate them,
+ and the final '\0'. */
+ name_key = (char *) alloca (XSTRING (invocation_name)->size
+ + XSTRING (attribute)->size
+ + 2);
+ class_key = (char *) alloca ((sizeof (EMACS_CLASS) - 1)
+ + XSTRING (class)->size
+ + 2);
sprintf (name_key, "%s.%s",
XSTRING (invocation_name)->data,
XSTRING (attribute)->data);
- class_key = EMACS_CLASS;
+ sprintf (class_key, "%s.%s",
+ EMACS_CLASS,
+ XSTRING (class)->data);
}
else
{
- name_key = (char *) alloca (XSTRING (invocation_name)->size + 1
- + XSTRING (name)->size + 1
- + XSTRING (attribute)->size + 1);
+ name_key = (char *) alloca (XSTRING (invocation_name)->size
+ + XSTRING (component)->size
+ + XSTRING (attribute)->size
+ + 3);
- class_key = (char *) alloca (sizeof (EMACS_CLASS)
- + XSTRING (class)->size + 1);
+ class_key = (char *) alloca ((sizeof (EMACS_CLASS) - 1)
+ + XSTRING (class)->size
+ + XSTRING (subclass)->size
+ + 3);
sprintf (name_key, "%s.%s.%s",
XSTRING (invocation_name)->data,
- XSTRING (name)->data,
+ XSTRING (component)->data,
XSTRING (attribute)->data);
sprintf (class_key, "%s.%s",
- XSTRING (invocation_name)->data,
- XSTRING (class)->data);
+ EMACS_CLASS,
+ XSTRING (class)->data,
+ XSTRING (subclass)->data);
}
value = x_get_string_resource (xrdb, name_key, class_key);
return (Qnil);
}
-#define Fx_get_resource(attribute, name, class) Fx_get_default(attribute)
+#define Fx_get_resource(attribute, class, component, subclass) \
+ Fx_get_default(attribute)
#endif /* X10 */
/* Return the value of parameter PARAM.
First search ALIST, then Vdefault_frame_alist, then the X defaults
- database, using ATTRIBUTE as the attribute name.
+ database, using ATTRIBUTE as the attribute name and CLASS as its class.
Convert the resource to the type specified by desired_type.
and don't let it get stored in any lisp-visible variables! */
static Lisp_Object
-x_get_arg (alist, param, attribute, type)
+x_get_arg (alist, param, attribute, class, type)
Lisp_Object alist, param;
char *attribute;
+ char *class;
enum resource_types type;
{
register Lisp_Object tem;
if (attribute)
{
- tem = Fx_get_resource (build_string (attribute), Qnil, Qnil);
+ tem = Fx_get_resource (build_string (attribute),
+ build_string (class),
+ Qnil, Qnil);
if (NILP (tem))
return Qunbound;
If that is not found either, use the value DEFLT. */
static Lisp_Object
-x_default_parameter (f, alist, prop, deflt, xprop, type)
+x_default_parameter (f, alist, prop, deflt, xprop, xclass, type)
struct frame *f;
Lisp_Object alist;
Lisp_Object prop;
Lisp_Object deflt;
char *xprop;
+ char *xclass;
enum resource_types type;
{
Lisp_Object tem;
- tem = x_get_arg (alist, prop, xprop, type);
+ tem = x_get_arg (alist, prop, xprop, xclass, type);
if (EQ (tem, Qunbound))
tem = deflt;
x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
f->display.x->top_pos = 1;
f->display.x->left_pos = 1;
- tem0 = x_get_arg (parms, Qheight, 0, number);
- tem1 = x_get_arg (parms, Qwidth, 0, number);
+ tem0 = x_get_arg (parms, Qheight, 0, 0, number);
+ tem1 = x_get_arg (parms, Qwidth, 0, 0, number);
if (! EQ (tem0, Qunbound) && ! EQ (tem1, Qunbound))
{
CHECK_NUMBER (tem0, 0);
else if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
error ("Must specify *both* height and width");
+ f->display.x->vertical_scroll_bar_extra =
+ (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
+ ? VERTICAL_SCROLL_BAR_PIXEL_WIDTH (f)
+ : 0);
f->display.x->pixel_width = CHAR_TO_PIXEL_WIDTH (f, f->width);
f->display.x->pixel_height = CHAR_TO_PIXEL_HEIGHT (f, f->height);
- tem0 = x_get_arg (parms, Qtop, 0, number);
- tem1 = x_get_arg (parms, Qleft, 0, number);
+ tem0 = x_get_arg (parms, Qtop, 0, 0, number);
+ tem1 = x_get_arg (parms, Qleft, 0, 0, number);
if (! EQ (tem0, Qunbound) && ! EQ (tem1, Qunbound))
{
CHECK_NUMBER (tem0, 0);
the X server hasn't been told. */
{
Lisp_Object name = f->name;
+ int explicit = f->explicit_name;
f->name = Qnil;
- x_implicitly_set_name (f, name, Qnil);
+ f->explicit_name = 0;
+ x_set_name (f, name, explicit);
}
XDefineCursor (XDISPLAY FRAME_X_WINDOW (f),
/* Set the position of the icon. Note that twm groups all
icons in an icon window. */
- icon_x = x_get_arg (parms, Qicon_left, 0, number);
- icon_y = x_get_arg (parms, Qicon_top, 0, number);
+ icon_x = x_get_arg (parms, Qicon_left, 0, 0, number);
+ icon_y = x_get_arg (parms, Qicon_top, 0, 0, number);
if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
{
CHECK_NUMBER (icon_x, 0);
/* Start up iconic or window? */
x_wm_set_window_state (f,
- (EQ (x_get_arg (parms, Qiconic_startup, 0, boolean),
+ (EQ (x_get_arg (parms, Qiconic_startup,
+ 0, 0, boolean),
Qt)
? IconicState
: NormalState));
the frame. Since this depends on the frame's pixel values,
this must be done on a per-frame basis. */
f->display.x->border_tile =
- XCreatePixmap (x_current_display, ROOT_WINDOW, 16, 16,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
- gc_values.foreground = f->display.x->foreground_pixel;
- gc_values.background = f->display.x->background_pixel;
- temp_gc = XCreateGC (x_current_display,
- (Drawable) f->display.x->border_tile,
- GCForeground | GCBackground, &gc_values);
-
- /* These are things that should be determined by the server, in
- Fx_open_connection */
- tileimage.height = 16;
- tileimage.width = 16;
- tileimage.xoffset = 0;
- tileimage.format = XYBitmap;
- tileimage.data = gray_bits;
- tileimage.byte_order = LSBFirst;
- tileimage.bitmap_unit = 8;
- tileimage.bitmap_bit_order = LSBFirst;
- tileimage.bitmap_pad = 8;
- tileimage.bytes_per_line = (16 + 7) >> 3;
- tileimage.depth = 1;
- XPutImage (x_current_display, f->display.x->border_tile, temp_gc,
- &tileimage, 0, 0, 0, 0, 16, 16);
- XFreeGC (x_current_display, temp_gc);
+ XCreatePixmapFromBitmapData
+ (x_current_display, ROOT_WINDOW,
+ gray_bits, gray_width, gray_height,
+ f->display.x->foreground_pixel,
+ f->display.x->background_pixel,
+ DefaultDepth (x_current_display, XDefaultScreen (x_current_display)));
}
#endif /* HAVE_X11 */
if (x_current_display == 0)
error ("X windows are not in use or not initialized");
- name = x_get_arg (parms, Qname, "Title", string);
- if (EQ (name, Qunbound) || NILP (name))
- name = build_string (x_id_name);
- if (XTYPE (name) != Lisp_String)
+ name = x_get_arg (parms, Qname, "title", "Title", string);
+ if (XTYPE (name) != Lisp_String
+ && ! EQ (name, Qunbound)
+ && ! NILP (name))
error ("x-create-frame: name parameter must be a string");
- tem = x_get_arg (parms, Qminibuffer, 0, symbol);
+ tem = x_get_arg (parms, Qminibuffer, 0, 0, symbol);
if (EQ (tem, Qnone) || NILP (tem))
f = make_frame_without_minibuffer (Qnil);
else if (EQ (tem, Qonly))
else
f = make_frame (1);
- /* Note that X Windows does support scrollbars. */
- FRAME_CAN_HAVE_SCROLLBARS (f) = 1;
+ /* Note that X Windows does support scroll bars. */
+ FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
- /* Set the name; the functions to which we pass f expect the
- name to be set. */
- f->name = name;
+ /* Set the name; the functions to which we pass f expect the name to
+ be set. */
+ if (EQ (name, Qunbound) || NILP (name))
+ {
+ f->name = build_string (x_id_name);
+ f->explicit_name = 0;
+ }
+ else
+ {
+ f->name = name;
+ f->explicit_name = 1;
+ }
XSET (frame, Lisp_Frame, f);
f->output_method = output_x_window;
/* Extract the window parameters from the supplied values
that are needed to determine window geometry. */
- x_default_parameter (f, parms, Qfont,
- build_string ("9x15"), "font", string);
- x_default_parameter (f, parms, Qbackground_color,
- build_string ("white"), "background", string);
- x_default_parameter (f, parms, Qborder_width,
- make_number (2), "BorderWidth", number);
- /* This defaults to 2 in order to match XTerms. */
- x_default_parameter (f, parms, Qinternal_border_width,
- make_number (2), "InternalBorderWidth", number);
- x_default_parameter (f, parms, Qvertical_scrollbar,
- Qt, "VerticalScrollbars", boolean);
+ x_default_parameter (f, parms, Qfont, build_string ("9x15"),
+ "font", "Font", string);
+ x_default_parameter (f, parms, Qborder_width, make_number (2),
+ "borderwidth", "BorderWidth", number);
+ /* This defaults to 2 in order to match xterm. */
+ x_default_parameter (f, parms, Qinternal_border_width, make_number (2),
+ "internalBorderWidth", "BorderWidth", number);
+ x_default_parameter (f, parms, Qvertical_scroll_bars, Qt,
+ "verticalScrollBars", "ScrollBars", boolean);
/* Also do the stuff which must be set before the window exists. */
- x_default_parameter (f, parms, Qforeground_color,
- build_string ("black"), "foreground", string);
- x_default_parameter (f, parms, Qmouse_color,
- build_string ("black"), "mouse", string);
- x_default_parameter (f, parms, Qcursor_color,
- build_string ("black"), "cursor", string);
- x_default_parameter (f, parms, Qborder_color,
- build_string ("black"), "border", string);
+ x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
+ "foreground", "Foreground", string);
+ x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
+ "background", "Background", string);
+ x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
+ "pointerColor", "Foreground", string);
+ x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
+ "cursorColor", "Foreground", string);
+ x_default_parameter (f, parms, Qborder_color, build_string ("black"),
+ "borderColor", "BorderColor", string);
f->display.x->parent_desc = ROOT_WINDOW;
window_prompting = x_figure_window_size (f, parms);
/* We need to do this after creating the X window, so that the
icon-creation functions can say whose icon they're describing. */
- x_default_parameter (f, parms, Qicon_type, Qnil, "IconType", symbol);
+ x_default_parameter (f, parms, Qicon_type, Qnil,
+ "iconType", "IconType", symbol);
- x_default_parameter (f, parms, Qauto_raise, Qnil, "AutoRaise", boolean);
- x_default_parameter (f, parms, Qauto_lower, Qnil, "AutoLower", boolean);
+ x_default_parameter (f, parms, Qauto_raise, Qnil,
+ "autoRaise", "AutoRaiseLower", boolean);
+ x_default_parameter (f, parms, Qauto_lower, Qnil,
+ "autoLower", "AutoRaiseLower", boolean);
+ x_default_parameter (f, parms, Qcursor_type, Qbox,
+ "cursorType", "CursorType", symbol);
/* Dimensions, especially f->height, must be done via change_frame_size.
Change will not be effected unless different from the current
x_wm_set_size_hint (f, window_prompting);
UNBLOCK_INPUT;
- tem = x_get_arg (parms, Qunsplittable, 0, boolean);
+ tem = x_get_arg (parms, Qunsplittable, 0, 0, boolean);
f->no_split = minibuffer_only || EQ (tem, Qt);
/* Make the window appear on the frame and enable display. */
- if (!EQ (x_get_arg (parms, Qsuppress_initial_map, 0, boolean), Qt))
+ if (!EQ (x_get_arg (parms, Qsuppress_initial_map, 0, 0, boolean), Qt))
x_make_frame_visible (f);
return frame;
name = Fassq (Qname, parms);
- tem = x_get_arg (parms, Qminibuffer, 0, symbol);
+ tem = x_get_arg (parms, Qminibuffer, 0, 0, symbol);
if (EQ (tem, Qnone))
f = make_frame_without_minibuffer (Qnil);
else if (EQ (tem, Qonly))
/* Extract some window parameters from the supplied values.
These are the parameters that affect window geometry. */
- tem = x_get_arg (parms, Qfont, "BodyFont", string);
+ tem = x_get_arg (parms, Qfont, "BodyFont", 0, string);
if (EQ (tem, Qunbound))
tem = build_string ("9x15");
x_set_font (f, tem, Qnil);
x_default_parameter (f, parms, Qborder_color,
- build_string ("black"), "Border", string);
+ build_string ("black"), "Border", 0, string);
x_default_parameter (f, parms, Qbackground_color,
- build_string ("white"), "Background", string);
+ build_string ("white"), "Background", 0, string);
x_default_parameter (f, parms, Qforeground_color,
- build_string ("black"), "Foreground", string);
+ build_string ("black"), "Foreground", 0, string);
x_default_parameter (f, parms, Qmouse_color,
- build_string ("black"), "Mouse", string);
+ build_string ("black"), "Mouse", 0, string);
x_default_parameter (f, parms, Qcursor_color,
- build_string ("black"), "Cursor", string);
+ build_string ("black"), "Cursor", 0, string);
x_default_parameter (f, parms, Qborder_width,
- make_number (2), "BorderWidth", number);
+ make_number (2), "BorderWidth", 0, number);
x_default_parameter (f, parms, Qinternal_border_width,
- make_number (4), "InternalBorderWidth", number);
+ make_number (4), "InternalBorderWidth", 0, number);
x_default_parameter (f, parms, Qauto_raise,
- Qnil, "AutoRaise", boolean);
+ Qnil, "AutoRaise", 0, boolean);
- hscroll = EQ (x_get_arg (parms, Qhorizontal_scroll_bar, 0, boolean), Qt);
- vscroll = EQ (x_get_arg (parms, Qvertical_scroll_bar, 0, boolean), Qt);
+ hscroll = EQ (x_get_arg (parms, Qhorizontal_scroll_bar, 0, 0, boolean), Qt);
+ vscroll = EQ (x_get_arg (parms, Qvertical_scroll_bar, 0, 0, boolean), Qt);
if (f->display.x->internal_border_width < 0)
f->display.x->internal_border_width = 0;
- tem = x_get_arg (parms, Qwindow_id, 0, number);
+ tem = x_get_arg (parms, Qwindow_id, 0, 0, number);
if (!EQ (tem, Qunbound))
{
WINDOWINFO_TYPE wininfo;
free (children);
UNBLOCK_INPUT;
- height = (wininfo.height - 2 * f->display.x->internal_border_width)
- / FONT_HEIGHT (f->display.x->font);
- width = (wininfo.width - 2 * f->display.x->internal_border_width)
- / FONT_WIDTH (f->display.x->font);
+ height = PIXEL_TO_CHAR_HEIGHT (f, wininfo.height);
+ width = PIXEL_TO_CHAR_WIDTH (f, wininfo.width);
f->display.x->left_pos = wininfo.x;
f->display.x->top_pos = wininfo.y;
FRAME_SET_VISIBILITY (f, wininfo.mapped != 0);
}
else
{
- tem = x_get_arg (parms, Qparent_id, 0, number);
+ tem = x_get_arg (parms, Qparent_id, 0, 0, number);
if (!EQ (tem, Qunbound))
{
CHECK_NUMBER (tem, 0);
parent = (Window) XINT (tem);
}
f->display.x->parent_desc = parent;
- tem = x_get_arg (parms, Qheight, 0, number);
+ tem = x_get_arg (parms, Qheight, 0, 0, number);
if (EQ (tem, Qunbound))
{
- tem = x_get_arg (parms, Qwidth, 0, number);
+ tem = x_get_arg (parms, Qwidth, 0, 0, number);
if (EQ (tem, Qunbound))
{
- tem = x_get_arg (parms, Qtop, 0, number);
+ tem = x_get_arg (parms, Qtop, 0, 0, number);
if (EQ (tem, Qunbound))
- tem = x_get_arg (parms, Qleft, 0, number);
+ tem = x_get_arg (parms, Qleft, 0, 0, number);
}
}
/* Now TEM is Qunbound if no edge or size was specified.
In that case, we must do rubber-banding. */
if (EQ (tem, Qunbound))
{
- tem = x_get_arg (parms, Qgeometry, 0, number);
+ tem = x_get_arg (parms, Qgeometry, 0, 0, number);
x_rubber_band (f,
&f->display.x->left_pos, &f->display.x->top_pos,
&width, &height,
{
/* Here if at least one edge or size was specified.
Demand that they all were specified, and use them. */
- tem = x_get_arg (parms, Qheight, 0, number);
+ tem = x_get_arg (parms, Qheight, 0, 0, number);
if (EQ (tem, Qunbound))
error ("Height not specified");
CHECK_NUMBER (tem, 0);
height = XINT (tem);
- tem = x_get_arg (parms, Qwidth, 0, number);
+ tem = x_get_arg (parms, Qwidth, 0, 0, number);
if (EQ (tem, Qunbound))
error ("Width not specified");
CHECK_NUMBER (tem, 0);
width = XINT (tem);
- tem = x_get_arg (parms, Qtop, 0, number);
+ tem = x_get_arg (parms, Qtop, 0, 0, number);
if (EQ (tem, Qunbound))
error ("Top position not specified");
CHECK_NUMBER (tem, 0);
f->display.x->left_pos = XINT (tem);
- tem = x_get_arg (parms, Qleft, 0, number);
+ tem = x_get_arg (parms, Qleft, 0, 0, number);
if (EQ (tem, Qunbound))
error ("Left position not specified");
CHECK_NUMBER (tem, 0);
f->display.x->top_pos = XINT (tem);
}
- pixelwidth = (width * FONT_WIDTH (f->display.x->font)
- + 2 * f->display.x->internal_border_width
- + (!NILP (vscroll) ? VSCROLL_WIDTH : 0));
- pixelheight = (height * FONT_HEIGHT (f->display.x->font)
- + 2 * f->display.x->internal_border_width
- + (!NILP (hscroll) ? HSCROLL_HEIGHT : 0));
+ pixelwidth = CHAR_TO_PIXEL_WIDTH (f, width);
+ pixelheight = CHAR_TO_PIXEL_HEIGHT (f, height);
BLOCK_INPUT;
FRAME_X_WINDOW (f)
/* Now override the defaults with all the rest of the specified
parms. */
- tem = x_get_arg (parms, Qunsplittable, 0, boolean);
+ tem = x_get_arg (parms, Qunsplittable, 0, 0, boolean);
f->no_split = minibuffer_only || EQ (tem, Qt);
/* Do not create an icon window if the caller says not to */
- if (!EQ (x_get_arg (parms, Qsuppress_icon, 0, boolean), Qt)
+ if (!EQ (x_get_arg (parms, Qsuppress_icon, 0, 0, boolean), Qt)
|| f->display.x->parent_desc != ROOT_WINDOW)
{
x_text_icon (f, iconidentity);
x_default_parameter (f, parms, Qicon_type, Qnil,
- "BitmapIcon", symbol);
+ "BitmapIcon", 0, symbol);
}
/* Tell the X server the previously set values of the
/* Make the window appear on the frame and enable display. */
- if (!EQ (x_get_arg (parms, Qsuppress_initial_map, 0, boolean), Qt))
+ if (!EQ (x_get_arg (parms, Qsuppress_initial_map, 0, 0, boolean), Qt))
x_make_window_visible (f);
- FRAME_GARBAGED (f);
+ SET_FRAME_GARBAGED (f);
return frame;
#endif /* X10 */
}
#endif /* not HAVE_X11 */
\f
-x_pixel_width (f)
- register struct frame *f;
-{
- return PIXEL_WIDTH (f);
-}
-
-x_pixel_height (f)
- register struct frame *f;
-{
- return PIXEL_HEIGHT (f);
-}
-\f
DEFUN ("x-defined-color", Fx_defined_color, Sx_defined_color, 1, 1, 0,
"Return t if the current X display supports the color named COLOR.")
(color)
}
}
-DEFUN ("x-pixel-width", Fx_pixel_width, Sx_pixel_width, 1, 1, 0,
- "Return the width in pixels of FRAME.")
- (frame)
- Lisp_Object frame;
+x_pixel_width (f)
+ register struct frame *f;
{
- CHECK_LIVE_FRAME (frame, 0);
- return make_number (XFRAME (frame)->display.x->pixel_width);
+ return PIXEL_WIDTH (f);
}
-DEFUN ("x-pixel-height", Fx_pixel_height, Sx_pixel_height, 1, 1, 0,
- "Return the height in pixels of FRAME.")
- (frame)
- Lisp_Object frame;
+x_pixel_height (f)
+ register struct frame *f;
{
- CHECK_LIVE_FRAME (frame, 0);
- return make_number (XFRAME (frame)->display.x->pixel_height);
+ return PIXEL_HEIGHT (f);
+}
+
+x_char_width (f)
+ register struct frame *f;
+{
+ return FONT_WIDTH (f->display.x->font);
+}
+
+x_char_height (f)
+ register struct frame *f;
+{
+ return FONT_HEIGHT (f->display.x->font);
}
\f
#if 0 /* These no longer seem like the right way to do things. */
BLOCK_INPUT;
}
while (XTYPE (obj) == Lisp_Cons /* Mouse event */
- && EQ (Fcar (Fcdr (Fcdr (obj))), Qnil) /* Not scrollbar */
+ && EQ (Fcar (Fcdr (Fcdr (obj))), Qnil) /* Not scroll bar */
&& EQ (Vmouse_depressed, Qnil) /* Only motion events */
&& EQ (Vmouse_window, selected_window) /* In this window */
&& x_mouse_frame);
Normally X-POS and Y-POS are the position of the click on the frame\n\
(measured in characters and lines), and WINDOW is the window clicked in.\n\
KEYSEQ is a string, the key sequence to be looked up in the mouse maps.\n\
-If FRAME-PART is non-nil, the event was on a scrollbar;\n\
-then Y-POS is really the total length of the scrollbar, while X-POS is\n\
-the relative position of the scrollbar's value within that total length,\n\
+If FRAME-PART is non-nil, the event was on a scroll bar;\n\
+then Y-POS is really the total length of the scroll bar, while X-POS is\n\
+the relative position of the scroll bar's value within that total length,\n\
and a third element OFFSET appears in that list: the height of the thumb-up\n\
area at the top of the scroll bar.\n\
FRAME-PART is one of the following symbols:\n\
- `vertical-scrollbar', `vertical-thumbup', `vertical-thumbdown',\n\
- `horizontal-scrollbar', `horizontal-thumbleft', `horizontal-thumbright'.\n\
+ `vertical-scroll-bar', `vertical-thumbup', `vertical-thumbdown',\n\
+ `horizontal-scroll-bar', `horizontal-thumbleft', `horizontal-thumbright'.\n\
TIMESTAMP is the lower 23 bits of the X-server's timestamp for\n\
the mouse event.")
(arg)
Fcons (timestamp, Qnil)))));
return Vmouse_event;
}
- else if ((f = x_window_to_scrollbar (xrep.MouseWindow, &part, &prefix)) != 0)
+ else if ((f = x_window_to_scroll_bar (xrep.MouseWindow, &part, &prefix)) != 0)
{
int pos, len;
Lisp_Object keyseq;
keyseq = concat2 (Fchar_to_string (make_number (prefix)),
Fchar_to_string (make_number (com_letter)));
- pos = xrep.MouseY - (f->display.x->v_scrollbar_width - 2);
+ pos = xrep.MouseY - (f->display.x->v_scroll_bar_width - 2);
XSET (tempx, Lisp_Int, pos);
len = ((FONT_HEIGHT (f->display.x->font) * f->height)
+ f->display.x->internal_border_width
- - (2 * (f->display.x->v_scrollbar_width - 2)));
+ - (2 * (f->display.x->v_scroll_bar_width - 2)));
XSET (tempy, Lisp_Int, len);
XSET (timestamp, Lisp_Int, (xrep.MouseTime & 0x7fffff));
Vmouse_window = f->selected_window;
Vmouse_event
= Fcons (Fcons (tempx, Fcons (tempy,
- Fcons (make_number (f->display.x->v_scrollbar_width - 2),
+ Fcons (make_number (f->display.x->v_scroll_bar_width - 2),
Qnil))),
Fcons (Vmouse_window,
Fcons (intern (part),
default:
if (f = x_window_to_frame (xrep.MouseWindow))
Vmouse_window = f->selected_window;
- else if (f = x_window_to_scrollbar (xrep.MouseWindow, &part, &prefix))
+ else if (f = x_window_to_scroll_bar (xrep.MouseWindow, &part, &prefix))
Vmouse_window = f->selected_window;
return Vmouse_event = Qnil;
}
staticpro (&Qauto_lower);
Qbackground_color = intern ("background-color");
staticpro (&Qbackground_color);
+ Qbar = intern ("bar");
+ staticpro (&Qbar);
Qborder_color = intern ("border-color");
staticpro (&Qborder_color);
Qborder_width = intern ("border-width");
staticpro (&Qborder_width);
+ Qbox = intern ("box");
+ staticpro (&Qbox);
Qcursor_color = intern ("cursor-color");
staticpro (&Qcursor_color);
+ Qcursor_type = intern ("cursor-type");
+ staticpro (&Qcursor_type);
Qfont = intern ("font");
staticpro (&Qfont);
Qforeground_color = intern ("foreground-color");
staticpro (&Qleft);
Qmouse_color = intern ("mouse-color");
staticpro (&Qmouse_color);
+ Qnone = intern ("none");
+ staticpro (&Qnone);
Qparent_id = intern ("parent-id");
staticpro (&Qparent_id);
Qsuppress_icon = intern ("suppress-icon");
staticpro (&Qtop);
Qundefined_color = intern ("undefined-color");
staticpro (&Qundefined_color);
+ Qvertical_scroll_bars = intern ("vertical-scroll-bars");
+ staticpro (&Qvertical_scroll_bars);
Qwindow_id = intern ("window-id");
staticpro (&Qwindow_id);
Qx_frame_parameter = intern ("x-frame-parameter");
"The shape of the pointer when over the mode line.");
Vx_mode_pointer_shape = Qnil;
- DEFVAR_LISP ("x-bar-cursor", &Vbar_cursor,
- "*If non-nil, use a vertical bar cursor. Otherwise, use the traditional box.");
- Vbar_cursor = Qnil;
-
DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel,
"A string indicating the foreground color of the cursor box.");
Vx_cursor_fore_pixel = Qnil;
#ifdef HAVE_X11
defsubr (&Sx_get_resource);
- defsubr (&Sx_pixel_width);
- defsubr (&Sx_pixel_height);
#if 0
defsubr (&Sx_draw_rectangle);
defsubr (&Sx_erase_rectangle);