/* 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.
#include "window.h"
#include "buffer.h"
#include "dispextern.h"
-#include "xscrollbar.h"
#include "keyboard.h"
#ifdef HAVE_X_WINDOWS
extern void abort ();
-void x_set_frame_param ();
+#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_char;
/* 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;
#else /* X10 */
-/* Default size of an Emacs window without scroll bar. */
+/* Default size of an Emacs window. */
static char *default_window = "=80x24+0+0";
#define MAXICID 80
/* The last 23 bits of the timestamp of the last mouse button event. */
Time mouse_timestamp;
+/* Evaluate this expression to rebuild the section of syms_of_xfns
+ that initializes and staticpros the symbols declared below. Note
+ that Emacs 18 has a bug that keeps C-x C-e from being able to
+ evaluate this expression.
+
+(progn
+ ;; Accumulate a list of the symbols we want to initialize from the
+ ;; declarations at the top of the file.
+ (goto-char (point-min))
+ (search-forward "/\*&&& symbols declared here &&&*\/\n")
+ (let (symbol-list)
+ (while (looking-at "Lisp_Object \\(Q[a-z_]+\\)")
+ (setq symbol-list
+ (cons (buffer-substring (match-beginning 1) (match-end 1))
+ symbol-list))
+ (forward-line 1))
+ (setq symbol-list (nreverse symbol-list))
+ ;; Delete the section of syms_of_... where we initialize the symbols.
+ (search-forward "\n /\*&&& init symbols here &&&*\/\n")
+ (let ((start (point)))
+ (while (looking-at "^ Q")
+ (forward-line 2))
+ (kill-region start (point)))
+ ;; Write a new symbol initialization section.
+ (while symbol-list
+ (insert (format " %s = intern (\"" (car symbol-list)))
+ (let ((start (point)))
+ (insert (substring (car symbol-list) 1))
+ (subst-char-in-region start (point) ?_ ?-))
+ (insert (format "\");\n staticpro (&%s);\n" (car symbol-list)))
+ (setq symbol-list (cdr symbol-list)))))
+
+ */
+
+/*&&& symbols declared here &&&*/
+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 Qicon_left;
+Lisp_Object Qicon_top;
+Lisp_Object Qicon_type;
+Lisp_Object Qiconic_startup;
+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, Qonly, Qwidth;
+extern Lisp_Object Qunsplittable;
+
extern Lisp_Object Vwindow_system_version;
/* Mouse map for clicks in windows. */
if (XTYPE (frame) != Lisp_Frame)
continue;
f = XFRAME (frame);
- if (f->display.x->window_desc == wdesc
+ if (FRAME_X_WINDOW (f) == wdesc
|| f->display.x->icon_desc == wdesc)
return f;
}
return 0;
}
-/* Map an X window that implements a scroll bar to the Emacs frame it
- belongs to. Also store in *PART a symbol identifying which part of
- the scroll bar it is. */
-
-struct frame *
-x_window_to_scrollbar (wdesc, part_ptr, prefix_ptr)
- int wdesc;
- Lisp_Object *part_ptr;
- enum scroll_bar_prefix *prefix_ptr;
-{
- Lisp_Object tail, frame;
- struct frame *f;
-
- for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
- {
- frame = XCONS (tail)->car;
- if (XTYPE (frame) != Lisp_Frame)
- continue;
-
- f = XFRAME (frame);
- if (part_ptr == 0 && prefix_ptr == 0)
- return f;
-
- if (f->display.x->v_scrollbar == wdesc)
- {
- *part_ptr = Qvscrollbar_part;
- *prefix_ptr = VSCROLL_BAR_PREFIX;
- return f;
- }
- else if (f->display.x->v_slider == wdesc)
- {
- *part_ptr = Qvslider_part;
- *prefix_ptr = VSCROLL_SLIDER_PREFIX;
- return f;
- }
- else if (f->display.x->v_thumbup == wdesc)
- {
- *part_ptr = Qvthumbup_part;
- *prefix_ptr = VSCROLL_THUMBUP_PREFIX;
- return f;
- }
- else if (f->display.x->v_thumbdown == wdesc)
- {
- *part_ptr = Qvthumbdown_part;
- *prefix_ptr = VSCROLL_THUMBDOWN_PREFIX;
- return f;
- }
- else if (f->display.x->h_scrollbar == wdesc)
- {
- *part_ptr = Qhscrollbar_part;
- *prefix_ptr = HSCROLL_BAR_PREFIX;
- return f;
- }
- else if (f->display.x->h_slider == wdesc)
- {
- *part_ptr = Qhslider_part;
- *prefix_ptr = HSCROLL_SLIDER_PREFIX;
- return f;
- }
- else if (f->display.x->h_thumbleft == wdesc)
- {
- *part_ptr = Qhthumbleft_part;
- *prefix_ptr = HSCROLL_THUMBLEFT_PREFIX;
- return f;
- }
- else if (f->display.x->h_thumbright == wdesc)
- {
- *part_ptr = Qhthumbright_part;
- *prefix_ptr = HSCROLL_THUMBRIGHT_PREFIX;
- return f;
- }
- }
- return 0;
-}
\f
/* Connect the frame-parameter names for X frames
to the ways of passing the parameter values to the window system.
X_PARM_NAME,
X_PARM_AUTORAISE,
X_PARM_AUTOLOWER,
- X_PARM_VERT_SCROLLBAR,
- X_PARM_HORIZ_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_set_internal_border_width ();
-void x_set_name ();
+void x_explicitly_set_name ();
void x_set_autoraise ();
void x_set_autolower ();
-void x_set_vertical_scrollbar ();
-void x_set_horizontal_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_set_name,
- "autoraise", x_set_autoraise,
- "autolower", x_set_autolower,
- "vertical-scrollbar", x_set_vertical_scrollbar,
- "horizontal-scrollbar", x_set_horizontal_scrollbar,
+ "name", x_explicitly_set_name,
+ "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
{
int i;
- Qx_frame_parameter = intern ("x-frame-parameter");
-
for (i = 0; i < sizeof (x_frame_parms)/sizeof (x_frame_parms[0]); i++)
Fput (intern (x_frame_parms[i].name), Qx_frame_parameter,
make_number (i));
}
\f
+#if 1
+/* Change the parameters of FRAME as specified by ALIST.
+ If a parameter is not specially recognized, do nothing;
+ otherwise call the `x_set_...' function for that parameter. */
+void
+x_set_frame_parameters (f, alist)
+ FRAME_PTR f;
+ Lisp_Object alist;
+{
+ Lisp_Object tail;
+
+ /* If both of these parameters are present, it's more efficient to
+ set them both at once. So we wait until we've looked at the
+ entire list before we set them. */
+ Lisp_Object width, height;
+
+ /* Same here. */
+ Lisp_Object left, top;
+
+ XSET (width, Lisp_Int, FRAME_WIDTH (f));
+ XSET (height, Lisp_Int, FRAME_HEIGHT (f));
+
+ XSET (top, Lisp_Int, f->display.x->top_pos);
+ XSET (left, Lisp_Int, f->display.x->left_pos);
+
+ for (tail = alist; CONSP (tail); tail = Fcdr (tail))
+ {
+ Lisp_Object elt, prop, val;
+
+ elt = Fcar (tail);
+ prop = Fcar (elt);
+ val = Fcdr (elt);
+
+ if (EQ (prop, Qwidth))
+ width = val;
+ else if (EQ (prop, Qheight))
+ height = val;
+ else if (EQ (prop, Qtop))
+ top = val;
+ else if (EQ (prop, Qleft))
+ left = val;
+ else
+ {
+ register Lisp_Object tem;
+ tem = Fget (prop, Qx_frame_parameter);
+ if (XTYPE (tem) == Lisp_Int
+ && XINT (tem) >= 0
+ && XINT (tem) < sizeof (x_frame_parms)/sizeof (x_frame_parms[0]))
+ (*x_frame_parms[XINT (tem)].setter)(f, val,
+ get_frame_param (f, prop));
+ store_frame_param (f, prop, val);
+ }
+ }
+
+ /* Don't call these unless they've changed; the window may not actually
+ exist yet. */
+ {
+ Lisp_Object frame;
+
+ XSET (frame, Lisp_Frame, f);
+ if (XINT (width) != FRAME_WIDTH (f)
+ || XINT (height) != FRAME_HEIGHT (f))
+ Fset_frame_size (frame, width, height);
+ if (XINT (left) != f->display.x->left_pos
+ || XINT (top) != f->display.x->top_pos)
+ Fset_frame_position (frame, left, top);
+ }
+}
+#else
/* Report to X that a frame parameter of frame F is being set or changed.
PARAM is the symbol that says which parameter.
VAL is the new value.
&& XINT (tem) < sizeof (x_frame_parms)/sizeof (x_frame_parms[0]))
(*x_frame_parms[XINT (tem)].setter)(f, val, oldval);
}
-
+#endif
/* Insert a description of internally-recorded parameters of frame X
into the parameter alist *ALISTPTR that is to be given to the user.
Only parameters that are specific to the X window system
{
char buf[16];
- store_in_alist (alistptr, "left", make_number (f->display.x->left_pos));
- store_in_alist (alistptr, "top", make_number (f->display.x->top_pos));
- store_in_alist (alistptr, "border-width",
+ store_in_alist (alistptr, Qleft, make_number (f->display.x->left_pos));
+ store_in_alist (alistptr, Qtop, make_number (f->display.x->top_pos));
+ store_in_alist (alistptr, Qborder_width,
make_number (f->display.x->border_width));
- store_in_alist (alistptr, "internal-border-width",
+ store_in_alist (alistptr, Qinternal_border_width,
make_number (f->display.x->internal_border_width));
- sprintf (buf, "%d", f->display.x->window_desc);
- store_in_alist (alistptr, "window-id",
+ sprintf (buf, "%d", FRAME_X_WINDOW (f));
+ store_in_alist (alistptr, Qwindow_id,
build_string (buf));
}
\f
return WHITE_PIX_DEFAULT;
#ifdef HAVE_X11
- if (XFASTINT (x_screen_planes) == 1)
+ if (x_screen_planes == 1)
return def;
#else
if (DISPLAY_CELLS == 1)
/* Functions called only from `x_set_frame_param'
to set individual parameters.
- If f->display.x->window_desc is 0,
+ If FRAME_X_WINDOW (f) is 0,
the frame is being created and its X-window does not exist yet.
In that case, just record the parameter's new value
in the standard place; do not attempt to change the window. */
Lisp_Object arg, oldval;
{
f->display.x->foreground_pixel = x_decode_color (arg, BLACK_PIX_DEFAULT);
- if (f->display.x->window_desc != 0)
+ if (FRAME_X_WINDOW (f) != 0)
{
#ifdef HAVE_X11
BLOCK_INPUT;
f->display.x->foreground_pixel);
XSetBackground (x_current_display, f->display.x->reverse_gc,
f->display.x->foreground_pixel);
- if (f->display.x->v_scrollbar)
- {
- Pixmap up_arrow_pixmap, down_arrow_pixmap, slider_pixmap;
-
- XSetWindowBorder (x_current_display, f->display.x->v_scrollbar,
- f->display.x->foreground_pixel);
-
- slider_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- gray_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
- up_arrow_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- up_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
- down_arrow_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- down_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->v_thumbup,
- up_arrow_pixmap);
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->v_thumbdown,
- down_arrow_pixmap);
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->v_slider,
- slider_pixmap);
-
- XClearWindow (XDISPLAY f->display.x->v_thumbup);
- XClearWindow (XDISPLAY f->display.x->v_thumbdown);
- XClearWindow (XDISPLAY f->display.x->v_slider);
-
- XFreePixmap (x_current_display, down_arrow_pixmap);
- XFreePixmap (x_current_display, up_arrow_pixmap);
- XFreePixmap (x_current_display, slider_pixmap);
- }
- if (f->display.x->h_scrollbar)
- {
- Pixmap left_arrow_pixmap, right_arrow_pixmap, slider_pixmap;
-
- XSetWindowBorder (x_current_display, f->display.x->h_scrollbar,
- f->display.x->foreground_pixel);
-
- slider_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- gray_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- left_arrow_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- up_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
- right_arrow_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- down_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->h_slider,
- slider_pixmap);
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->h_thumbleft,
- left_arrow_pixmap);
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->h_thumbright,
- right_arrow_pixmap);
-
- XClearWindow (XDISPLAY f->display.x->h_thumbleft);
- XClearWindow (XDISPLAY f->display.x->h_thumbright);
- XClearWindow (XDISPLAY f->display.x->h_slider);
-
- XFreePixmap (x_current_display, slider_pixmap);
- XFreePixmap (x_current_display, left_arrow_pixmap);
- XFreePixmap (x_current_display, right_arrow_pixmap);
- }
UNBLOCK_INPUT;
#endif /* HAVE_X11 */
- if (f->visible)
+ if (FRAME_VISIBLE_P (f))
redraw_frame (f);
}
}
f->display.x->background_pixel = x_decode_color (arg, WHITE_PIX_DEFAULT);
- if (f->display.x->window_desc != 0)
+ if (FRAME_X_WINDOW (f) != 0)
{
BLOCK_INPUT;
#ifdef HAVE_X11
f->display.x->background_pixel);
XSetForeground (x_current_display, f->display.x->reverse_gc,
f->display.x->background_pixel);
- XSetWindowBackground (x_current_display, f->display.x->window_desc,
+ XSetWindowBackground (x_current_display, FRAME_X_WINDOW (f),
f->display.x->background_pixel);
- /* Scroll bars. */
- if (f->display.x->v_scrollbar)
- {
- Pixmap up_arrow_pixmap, down_arrow_pixmap, slider_pixmap;
-
- XSetWindowBackground (x_current_display, f->display.x->v_scrollbar,
- f->display.x->background_pixel);
-
- slider_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- gray_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
- up_arrow_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- up_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
- down_arrow_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- down_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->v_thumbup,
- up_arrow_pixmap);
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->v_thumbdown,
- down_arrow_pixmap);
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->v_slider,
- slider_pixmap);
-
- XClearWindow (XDISPLAY f->display.x->v_thumbup);
- XClearWindow (XDISPLAY f->display.x->v_thumbdown);
- XClearWindow (XDISPLAY f->display.x->v_slider);
-
- XFreePixmap (x_current_display, down_arrow_pixmap);
- XFreePixmap (x_current_display, up_arrow_pixmap);
- XFreePixmap (x_current_display, slider_pixmap);
- }
- if (f->display.x->h_scrollbar)
- {
- Pixmap left_arrow_pixmap, right_arrow_pixmap, slider_pixmap;
-
- XSetWindowBackground (x_current_display, f->display.x->h_scrollbar,
- f->display.x->background_pixel);
-
- slider_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- gray_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- left_arrow_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- up_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
- right_arrow_pixmap =
- XCreatePixmapFromBitmapData (XDISPLAY f->display.x->window_desc,
- down_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->h_slider,
- slider_pixmap);
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->h_thumbleft,
- left_arrow_pixmap);
- XSetWindowBackgroundPixmap (XDISPLAY f->display.x->h_thumbright,
- right_arrow_pixmap);
-
- XClearWindow (XDISPLAY f->display.x->h_thumbleft);
- XClearWindow (XDISPLAY f->display.x->h_thumbright);
- XClearWindow (XDISPLAY f->display.x->h_slider);
-
- XFreePixmap (x_current_display, slider_pixmap);
- XFreePixmap (x_current_display, left_arrow_pixmap);
- XFreePixmap (x_current_display, right_arrow_pixmap);
- }
#else
temp = XMakeTile (f->display.x->background_pixel);
- XChangeBackground (f->display.x->window_desc, temp);
+ XChangeBackground (FRAME_X_WINDOW (f), temp);
XFreePixmap (temp);
#endif /* not HAVE_X11 */
UNBLOCK_INPUT;
- if (f->visible)
+ if (FRAME_VISIBLE_P (f))
redraw_frame (f);
}
}
BLOCK_INPUT;
#ifdef HAVE_X11
+
+ /* It's not okay to crash if the user selects a screwey cursor. */
+ x_catch_errors ();
+
if (!EQ (Qnil, Vx_pointer_shape))
{
CHECK_NUMBER (Vx_pointer_shape, 0);
}
else
cursor = XCreateFontCursor (x_current_display, XC_xterm);
+ x_check_errors ("bad text pointer cursor: %s");
if (!EQ (Qnil, Vx_nontext_pointer_shape))
{
}
else
nontext_cursor = XCreateFontCursor (x_current_display, XC_left_ptr);
+ x_check_errors ("bad nontext pointer cursor: %s");
if (!EQ (Qnil, Vx_mode_pointer_shape))
{
else
mode_cursor = XCreateFontCursor (x_current_display, XC_xterm);
+ /* Check and report errors with the above calls. */
+ x_check_errors ("can't set cursor shape: %s");
+ x_uncatch_errors ();
+
{
XColor fore_color, back_color;
GXcopy);
#endif /* X10 */
- if (f->display.x->window_desc != 0)
+ if (FRAME_X_WINDOW (f) != 0)
{
- XDefineCursor (XDISPLAY f->display.x->window_desc, cursor);
+ XDefineCursor (XDISPLAY FRAME_X_WINDOW (f), cursor);
}
if (cursor != f->display.x->text_cursor && f->display.x->text_cursor != 0)
else
fore_pixel = f->display.x->background_pixel;
f->display.x->cursor_pixel = x_decode_color (arg, BLACK_PIX_DEFAULT);
- /* No invisible cursors */
+
+ /* Make sure that the cursor color differs from the background color. */
if (f->display.x->cursor_pixel == f->display.x->background_pixel)
{
f->display.x->cursor_pixel == f->display.x->mouse_pixel;
fore_pixel = f->display.x->background_pixel;
}
- if (f->display.x->window_desc != 0)
+ if (FRAME_X_WINDOW (f) != 0)
{
#ifdef HAVE_X11
BLOCK_INPUT;
UNBLOCK_INPUT;
#endif /* HAVE_X11 */
- if (f->visible)
+ if (FRAME_VISIBLE_P (f))
{
x_display_cursor (f, 0);
x_display_cursor (f, 1);
{
f->display.x->border_pixel = pix;
- if (f->display.x->window_desc != 0 && f->display.x->border_width > 0)
+ if (FRAME_X_WINDOW (f) != 0 && f->display.x->border_width > 0)
{
Pixmap temp;
int mask;
BLOCK_INPUT;
#ifdef HAVE_X11
- XSetWindowBorder (x_current_display, f->display.x->window_desc,
+ XSetWindowBorder (x_current_display, FRAME_X_WINDOW (f),
pix);
- if (f->display.x->h_scrollbar)
- XSetWindowBorder (x_current_display, f->display.x->h_slider,
- pix);
- if (f->display.x->v_scrollbar)
- XSetWindowBorder (x_current_display, f->display.x->v_slider,
- 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);
- XChangeBorder (f->display.x->window_desc, temp);
+ XChangeBorder (FRAME_X_WINDOW (f), temp);
XFreePixmap (XDISPLAY temp);
#endif /* not HAVE_X11 */
UNBLOCK_INPUT;
- if (f->visible)
+ if (FRAME_VISIBLE_P (f))
redraw_frame (f);
}
}
+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)
{
- error ("No icon window available.");
UNBLOCK_INPUT;
+ error ("No icon window available.");
}
/* If the window was unmapped (and its icon was mapped),
the new icon is not mapped, so map the window in its stead. */
- if (f->visible)
- XMapWindow (XDISPLAY f->display.x->window_desc);
+ if (FRAME_VISIBLE_P (f))
+ XMapWindow (XDISPLAY FRAME_X_WINDOW (f));
XFlushQueue ();
UNBLOCK_INPUT;
if (XINT (arg) == f->display.x->border_width)
return;
- if (f->display.x->window_desc != 0)
+ if (FRAME_X_WINDOW (f) != 0)
error ("Cannot change the border width of a window");
f->display.x->border_width = XINT (arg);
if (f->display.x->internal_border_width == old)
return;
- if (f->display.x->window_desc != 0)
+ if (FRAME_X_WINDOW (f) != 0)
{
BLOCK_INPUT;
x_set_window_size (f, f->width, f->height);
}
}
+/* Change the name of frame F to ARG. If ARG is nil, set F's name to
+ x_id_name.
+
+ If EXPLICIT is non-zero, that indicates that lisp code is setting the
+ name; if ARG is a string, set F's name to ARG and set
+ F->explicit_name; if ARG is Qnil, then clear F->explicit_name.
+
+ If EXPLICIT is zero, that indicates that Emacs redisplay code is
+ suggesting a new name, which lisp code should override; if
+ F->explicit_name is set, ignore the new name; otherwise, set it. */
+
void
-x_set_name (f, arg, oldval)
+x_set_name (f, name, explicit)
struct frame *f;
- Lisp_Object arg, oldval;
+ Lisp_Object name;
+ int explicit;
{
- /* If ARG is nil, set the name to the x_id_name. */
- if (NILP (arg))
- arg = build_string (x_id_name);
+ /* Make sure that requests from lisp code override requests from
+ Emacs redisplay code. */
+ if (explicit)
+ {
+ /* 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 = 1;
+
+ f->explicit_name = ! NILP (name);
+ }
+ else if (f->explicit_name)
+ return;
+
+ /* If NAME is nil, set the name to the x_id_name. */
+ if (NILP (name))
+ name = build_string (x_id_name);
else
- CHECK_STRING (arg, 0);
+ CHECK_STRING (name, 0);
- /* Don't change the name if it's already ARG. */
- if (! NILP (Fstring_equal (arg, f->name)))
+ /* Don't change the name if it's already NAME. */
+ if (! NILP (Fstring_equal (name, f->name)))
return;
- if (f->display.x->window_desc)
+ if (FRAME_X_WINDOW (f))
{
-#ifdef HAVE_X11
- XTextProperty prop;
- prop.value = XSTRING (arg)->data;
- prop.encoding = XA_STRING;
- prop.format = 8;
- prop.nitems = XSTRING (arg)->size;
BLOCK_INPUT;
- XSetWMName (XDISPLAY f->display.x->window_desc, &prop);
- XSetWMIconName (XDISPLAY f->display.x->window_desc, &prop);
- UNBLOCK_INPUT;
+
+#ifdef HAVE_X11R4
+ {
+ XTextProperty text;
+ text.value = XSTRING (name)->data;
+ text.encoding = XA_STRING;
+ text.format = 8;
+ text.nitems = XSTRING (name)->size;
+ XSetWMName (x_current_display, FRAME_X_WINDOW (f), &text);
+ XSetWMIconName (x_current_display, FRAME_X_WINDOW (f), &text);
+ }
#else
- BLOCK_INPUT;
- XStoreName (XDISPLAY f->display.x->window_desc,
- (char *) XSTRING (arg)->data);
- XSetIconName (XDISPLAY f->display.x->window_desc,
- (char *) XSTRING (arg)->data);
- UNBLOCK_INPUT;
+ XSetIconName (XDISPLAY FRAME_X_WINDOW (f),
+ XSTRING (name)->data);
+ XStoreName (XDISPLAY FRAME_X_WINDOW (f),
+ XSTRING (name)->data);
#endif
+
+ UNBLOCK_INPUT;
}
- f->name = arg;
+ f->name = name;
+}
+
+/* This function should be called when the user's lisp code has
+ specified a name for the frame; the name will override any set by the
+ redisplay code. */
+void
+x_explicitly_set_name (f, arg, oldval)
+ FRAME_PTR f;
+ Lisp_Object arg, oldval;
+{
+ x_set_name (f, arg, 1);
+}
+
+/* This function should be called by Emacs redisplay code to set the
+ name; names set this way will never override names set by the user's
+ lisp code. */
+void
+x_implicitly_set_name (f, arg, oldval)
+ FRAME_PTR f;
+ Lisp_Object arg, oldval;
+{
+ x_set_name (f, arg, 0);
}
void
{
f->auto_lower = !EQ (Qnil, arg);
}
+
+void
+x_set_vertical_scroll_bars (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+{
+ if (NILP (arg) != ! FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+ {
+ FRAME_HAS_VERTICAL_SCROLL_BARS (f) = ! NILP (arg);
+
+ /* 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
#ifdef HAVE_X11
int n_faces;
+#if 0
+/* I believe this function is obsolete with respect to the new face display
+ changes. */
x_set_face (scr, font, background, foreground, stipple)
struct frame *scr;
XFontStruct *font;
gc_mask |= GCStipple;
}
- temp_gc = XCreateGC (x_current_display, scr->display.x->window_desc,
+ temp_gc = XCreateGC (x_current_display, FRAME_X_WINDOW (scr),
gc_mask, &gc_values);
if (!temp_gc)
return 1;
x_face_table[++n_faces] = new_face;
return 1;
}
+#endif
x_set_glyph (scr, glyph)
{
XGCValues gc_values;
/* Need to do something about this. */
- Drawable drawable = selected_frame->display.x->window_desc;
+ Drawable drawable = FRAME_X_WINDOW (selected_frame);
CHECK_NUMBER (face_code, 1);
CHECK_STRING (font_name, 2);
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);
#else /* X10 */
DEFUN ("x-get-default", Fx_get_default, Sx_get_default, 1, 1, 0,
- "Get X default ATTRIBUTE from the system, or nil if no default.\n\
+ "Get X default ATTRIBUTE from the system, or nil if no default.\n\
Value is a string (when not nil) and ATTRIBUTE is also a string.\n\
The defaults are specified in the file `~/.Xdefaults'.")
(arg)
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 */
/* Types we might convert a resource string into. */
enum resource_types
{
- number, boolean, string,
+ number, boolean, string, symbol,
};
/* 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.
- If no default is specified, return nil. */
+ If no default is specified, return Qunbound. If you call
+ x_get_arg, make sure you deal with Qunbound in a reasonable way,
+ 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;
tem = Fassq (param, alist);
if (EQ (tem, Qnil))
tem = Fassq (param, Vdefault_frame_alist);
- if (EQ (tem, Qnil) && attribute)
+ if (EQ (tem, Qnil))
{
- tem = Fx_get_resource (build_string (attribute), Qnil, Qnil);
-
- if (NILP (tem))
- return Qnil;
- switch (type)
+ if (attribute)
{
- case number:
- return make_number (atoi (XSTRING (tem)->data));
-
- case boolean:
- tem = Fdowncase (tem);
- if (!strcmp (XSTRING (tem)->data, "on")
- || !strcmp (XSTRING (tem)->data, "true"))
- return Qt;
- else
- return Qnil;
-
- case string:
- return tem;
-
- default:
- abort ();
+ tem = Fx_get_resource (build_string (attribute),
+ build_string (class),
+ Qnil, Qnil);
+
+ if (NILP (tem))
+ return Qunbound;
+
+ switch (type)
+ {
+ case number:
+ return make_number (atoi (XSTRING (tem)->data));
+
+ case boolean:
+ tem = Fdowncase (tem);
+ if (!strcmp (XSTRING (tem)->data, "on")
+ || !strcmp (XSTRING (tem)->data, "true"))
+ return Qt;
+ else
+ return Qnil;
+
+ case string:
+ return tem;
+
+ case symbol:
+ return intern (tem);
+
+ default:
+ abort ();
+ }
}
+ else
+ return Qunbound;
}
return Fcdr (tem);
}
If that is not found either, use the value DEFLT. */
static Lisp_Object
-x_default_parameter (f, alist, propname, deflt, xprop, type)
+x_default_parameter (f, alist, prop, deflt, xprop, xclass, type)
struct frame *f;
Lisp_Object alist;
- char *propname;
+ Lisp_Object prop;
Lisp_Object deflt;
char *xprop;
+ char *xclass;
enum resource_types type;
{
- Lisp_Object propsym = intern (propname);
Lisp_Object tem;
- tem = x_get_arg (alist, propsym, xprop, type);
- if (EQ (tem, Qnil))
+ tem = x_get_arg (alist, prop, xprop, xclass, type);
+ if (EQ (tem, Qunbound))
tem = deflt;
- store_frame_param (f, propsym, tem);
- x_set_frame_param (f, propsym, tem, Qnil);
+ x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
return tem;
}
\f
"Parse an X-style geometry string STRING.\n\
Returns an alist of the form ((top . TOP), (left . LEFT) ... ).")
(string)
+ Lisp_Object string;
{
int geometry, x, y;
unsigned int width, height;
x = -1;
if (y == 0 && (geometry & YNegative))
y = -1;
- values[0] = Fcons (intern ("left"), make_number (x));
- values[1] = Fcons (intern ("top"), make_number (y));
+ values[0] = Fcons (Qleft, make_number (x));
+ values[1] = Fcons (Qtop, make_number (y));
return Flist (2, values);
break;
case (WidthValue | HeightValue):
- values[0] = Fcons (intern ("width"), make_number (width));
- values[1] = Fcons (intern ("height"), make_number (height));
+ values[0] = Fcons (Qwidth, make_number (width));
+ values[1] = Fcons (Qheight, make_number (height));
return Flist (2, values);
break;
x = -1;
if (y == 0 && (geometry & YNegative))
y = -1;
- values[0] = Fcons (intern ("width"), make_number (width));
- values[1] = Fcons (intern ("height"), make_number (height));
- values[2] = Fcons (intern ("left"), make_number (x));
- values[3] = Fcons (intern ("top"), make_number (y));
+ values[0] = Fcons (Qwidth, make_number (width));
+ values[1] = Fcons (Qheight, make_number (height));
+ values[2] = Fcons (Qleft, make_number (x));
+ values[3] = Fcons (Qtop, make_number (y));
return Flist (4, values);
break;
#define DEFAULT_ROWS 40
#define DEFAULT_COLS 80
-static
+static int
x_figure_window_size (f, parms)
struct frame *f;
Lisp_Object parms;
f->display.x->top_pos = 1;
f->display.x->left_pos = 1;
- tem0 = x_get_arg (parms, intern ("height"), 0, 0);
- tem1 = x_get_arg (parms, intern ("width"), 0, 0);
- if (! EQ (tem0, Qnil) && ! EQ (tem1, Qnil))
+ 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);
CHECK_NUMBER (tem1, 0);
f->width = XINT (tem1);
window_prompting |= USSize;
}
- else if (! EQ (tem0, Qnil) || ! EQ (tem1, Qnil))
+ else if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
error ("Must specify *both* height and width");
- f->display.x->pixel_width = (FONT_WIDTH (f->display.x->font) * f->width
- + 2 * f->display.x->internal_border_width);
- f->display.x->pixel_height = (FONT_HEIGHT (f->display.x->font) * f->height
- + 2 * f->display.x->internal_border_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, intern ("top"), 0, 0);
- tem1 = x_get_arg (parms, intern ("left"), 0, 0);
- if (! EQ (tem0, Qnil) && ! EQ (tem1, Qnil))
+ 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);
CHECK_NUMBER (tem1, 0);
x_calc_absolute_position (f);
window_prompting |= USPosition;
}
- else if (! EQ (tem0, Qnil) || ! EQ (tem1, Qnil))
+ else if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
error ("Must specify *both* top and left corners");
switch (window_prompting)
| CWEventMask);
BLOCK_INPUT;
- f->display.x->window_desc
+ FRAME_X_WINDOW (f)
= XCreateWindow (x_current_display, ROOT_WINDOW,
f->display.x->left_pos,
f->display.x->top_pos,
class_hints.res_name = (char *) XSTRING (f->name)->data;
class_hints.res_class = EMACS_CLASS;
- XSetClassHint (x_current_display, f->display.x->window_desc, &class_hints);
+ XSetClassHint (x_current_display, FRAME_X_WINDOW (f), &class_hints);
+
+ /* This indicates that we use the "Passive Input" input model.
+ Unless we do this, we don't get the Focus{In,Out} events that we
+ need to draw the cursor correctly. Accursed bureaucrats.
+ XWhipsAndChains (x_current_display, IronMaiden, &TheRack); */
+
+ f->display.x->wm_hints.input = True;
+ f->display.x->wm_hints.flags |= InputHint;
+ XSetWMHints (x_current_display, FRAME_X_WINDOW (f), &f->display.x->wm_hints);
/* x_set_name normally ignores requests to set the name if the
requested name is the same as the current name. This is the one
the X server hasn't been told. */
{
Lisp_Object name = f->name;
+ int explicit = f->explicit_name;
f->name = Qnil;
- x_set_name (f, name, Qnil);
+ f->explicit_name = 0;
+ x_set_name (f, name, explicit);
}
- XDefineCursor (XDISPLAY f->display.x->window_desc,
+ XDefineCursor (XDISPLAY FRAME_X_WINDOW (f),
f->display.x->text_cursor);
UNBLOCK_INPUT;
- if (f->display.x->window_desc == 0)
+ if (FRAME_X_WINDOW (f) == 0)
error ("Unable to create window.");
}
struct frame *f;
Lisp_Object parms;
{
- register Lisp_Object tem0,tem1;
- XWMHints hints;
+ Lisp_Object icon_x, icon_y;
/* Set the position of the icon. Note that twm groups all
icons in an icon window. */
- tem0 = x_get_arg (parms, intern ("icon-left"), 0, 0);
- tem1 = x_get_arg (parms, intern ("icon-top"), 0, 0);
- if (!EQ (tem0, Qnil) && !EQ (tem1, Qnil))
+ 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 (tem0, 0);
- CHECK_NUMBER (tem1, 0);
- hints.icon_x = XINT (tem0);
- hints.icon_x = XINT (tem0);
+ CHECK_NUMBER (icon_x, 0);
+ CHECK_NUMBER (icon_y, 0);
}
- else if (!EQ (tem0, Qnil) || !EQ (tem1, Qnil))
+ else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
error ("Both left and top icon corners of icon must be specified");
- else
- {
- hints.icon_x = f->display.x->left_pos;
- hints.icon_y = f->display.x->top_pos;
- }
+
+ BLOCK_INPUT;
+
+ if (! EQ (icon_x, Qunbound))
+ x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
/* Start up iconic or window? */
- tem0 = x_get_arg (parms, intern ("iconic-startup"), 0, 0);
- if (!EQ (tem0, Qnil))
- hints.initial_state = IconicState;
- else
- hints.initial_state = NormalState; /* the default, actually. */
- hints.input = False;
+ x_wm_set_window_state (f,
+ (EQ (x_get_arg (parms, Qiconic_startup,
+ 0, 0, boolean),
+ Qt)
+ ? IconicState
+ : NormalState));
- BLOCK_INPUT;
- hints.flags = StateHint | IconPositionHint | InputHint;
- XSetWMHints (x_current_display, f->display.x->window_desc, &hints);
UNBLOCK_INPUT;
}
background, border and mouse colors; also create the
mouse cursor and the gray border tile. */
+static char cursor_bits[] =
+ {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+
static void
x_make_gc (f)
struct frame *f;
XGCValues gc_values;
GC temp_gc;
XImage tileimage;
- static char cursor_bits[] =
- {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
- };
/* Create the GC's of this frame.
Note that many default values are used. */
gc_values.background = f->display.x->background_pixel;
gc_values.line_width = 0; /* Means 1 using fast algorithm. */
f->display.x->normal_gc = XCreateGC (x_current_display,
- f->display.x->window_desc,
+ FRAME_X_WINDOW (f),
GCLineWidth | GCFont
| GCForeground | GCBackground,
&gc_values);
gc_values.foreground = f->display.x->background_pixel;
gc_values.background = f->display.x->foreground_pixel;
f->display.x->reverse_gc = XCreateGC (x_current_display,
- f->display.x->window_desc,
+ FRAME_X_WINDOW (f),
GCFont | GCForeground | GCBackground
| GCLineWidth,
&gc_values);
= XCreateBitmapFromData (x_current_display, ROOT_WINDOW,
cursor_bits, 16, 16);
f->display.x->cursor_gc
- = XCreateGC (x_current_display, f->display.x->window_desc,
+ = XCreateGC (x_current_display, FRAME_X_WINDOW (f),
(GCFont | GCForeground | GCBackground
| GCFillStyle | GCStipple | GCLineWidth),
&gc_values);
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, intern ("name"), "Title", string);
- if (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, intern ("minibuffer"), 0, 0);
- if (EQ (tem, intern ("none")))
+ 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, intern ("only")))
+ else if (EQ (tem, Qonly))
{
f = make_minibuffer_frame ();
minibuffer_only = 1;
}
- else if (EQ (tem, Qnil) || EQ (tem, Qt))
- f = make_frame (1);
- else
+ else if (XTYPE (tem) == Lisp_Window)
f = make_frame_without_minibuffer (tem);
+ else
+ f = make_frame (1);
- /* Set the name; the functions to which we pass f expect the
- name to be set. */
- XSET (f->name, Lisp_String, name);
+ /* 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. */
+ 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, "font",
- build_string ("9x15"), "font", string);
- x_default_parameter (f, parms, "background-color",
- build_string ("white"), "background", string);
- x_default_parameter (f, parms, "border-width",
- make_number (2), "BorderWidth", number);
- /* This defaults to 2 in order to match XTerms. */
- x_default_parameter (f, parms, "internal-border-width",
- make_number (2), "InternalBorderWidth", number);
+ 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, "foreground-color",
- build_string ("black"), "foreground", string);
- x_default_parameter (f, parms, "mouse-color",
- build_string ("black"), "mouse", string);
- x_default_parameter (f, parms, "cursor-color",
- build_string ("black"), "cursor", string);
- x_default_parameter (f, parms, "border-color",
- build_string ("black"), "border", string);
-
- /* Need to do icon type, auto-raise, auto-lower. */
+ 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);
x_icon (f, parms);
x_make_gc (f);
+ /* 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", "IconType", symbol);
+
+ 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
f->height. */
width = f->width;
height = f->height;
f->height = f->width = 0;
- change_frame_size (f, height, width, 1);
+ change_frame_size (f, height, width, 1, 0);
BLOCK_INPUT;
x_wm_set_size_hint (f, window_prompting);
UNBLOCK_INPUT;
- tem = x_get_arg (parms, intern ("unsplittable"), 0, 0);
+ tem = x_get_arg (parms, Qunsplittable, 0, 0, boolean);
f->no_split = minibuffer_only || EQ (tem, Qt);
- /* Now handle the rest of the parameters. */
- x_default_parameter (f, parms, "horizontal-scroll-bar",
- Qnil, "?HScrollBar", string);
- x_default_parameter (f, parms, "vertical-scroll-bar",
- Qnil, "?VScrollBar", string);
-
/* Make the window appear on the frame and enable display. */
- if (!EQ (x_get_arg (parms, intern ("suppress-initial-map"), 0, 0), Qt))
+ if (!EQ (x_get_arg (parms, Qsuppress_initial_map, 0, 0, boolean), Qt))
x_make_frame_visible (f);
return frame;
if (x_current_display == 0)
error ("X windows are not in use or not initialized");
- name = Fassq (intern ("name"), parms);
+ name = Fassq (Qname, parms);
- tem = x_get_arg (parms, intern ("minibuffer"), 0, 0);
- if (EQ (tem, intern ("none")))
+ tem = x_get_arg (parms, Qminibuffer, 0, 0, symbol);
+ if (EQ (tem, Qnone))
f = make_frame_without_minibuffer (Qnil);
- else if (EQ (tem, intern ("only")))
+ else if (EQ (tem, Qonly))
{
f = make_minibuffer_frame ();
minibuffer_only = 1;
}
- else if (! EQ (tem, Qnil))
- f = make_frame_without_minibuffer (tem);
- else
+ else if (EQ (tem, Qnil) || EQ (tem, Qunbound))
f = make_frame (1);
+ else
+ f = make_frame_without_minibuffer (tem);
parent = ROOT_WINDOW;
/* Extract some window parameters from the supplied values.
These are the parameters that affect window geometry. */
- tem = x_get_arg (parms, intern ("font"), "BodyFont", string);
- if (EQ (tem, Qnil))
+ tem = x_get_arg (parms, Qfont, "BodyFont", 0, string);
+ if (EQ (tem, Qunbound))
tem = build_string ("9x15");
- x_set_font (f, tem);
- x_default_parameter (f, parms, "border-color",
- build_string ("black"), "Border", string);
- x_default_parameter (f, parms, "background-color",
- build_string ("white"), "Background", string);
- x_default_parameter (f, parms, "foreground-color",
- build_string ("black"), "Foreground", string);
- x_default_parameter (f, parms, "mouse-color",
- build_string ("black"), "Mouse", string);
- x_default_parameter (f, parms, "cursor-color",
- build_string ("black"), "Cursor", string);
- x_default_parameter (f, parms, "border-width",
- make_number (2), "BorderWidth", number);
- x_default_parameter (f, parms, "internal-border-width",
- make_number (4), "InternalBorderWidth", number);
- x_default_parameter (f, parms, "auto-raise",
- Qnil, "AutoRaise", boolean);
-
- hscroll = x_get_arg (parms, intern ("horizontal-scroll-bar"), 0, 0);
- vscroll = x_get_arg (parms, intern ("vertical-scroll-bar"), 0, 0);
+ x_set_font (f, tem, Qnil);
+ x_default_parameter (f, parms, Qborder_color,
+ build_string ("black"), "Border", 0, string);
+ x_default_parameter (f, parms, Qbackground_color,
+ build_string ("white"), "Background", 0, string);
+ x_default_parameter (f, parms, Qforeground_color,
+ build_string ("black"), "Foreground", 0, string);
+ x_default_parameter (f, parms, Qmouse_color,
+ build_string ("black"), "Mouse", 0, string);
+ x_default_parameter (f, parms, Qcursor_color,
+ build_string ("black"), "Cursor", 0, string);
+ x_default_parameter (f, parms, Qborder_width,
+ make_number (2), "BorderWidth", 0, number);
+ x_default_parameter (f, parms, Qinternal_border_width,
+ make_number (4), "InternalBorderWidth", 0, number);
+ x_default_parameter (f, parms, Qauto_raise,
+ Qnil, "AutoRaise", 0, boolean);
+
+ 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, intern ("window-id"), 0, 0);
- if (!EQ (tem, Qnil))
+ tem = x_get_arg (parms, Qwindow_id, 0, 0, number);
+ if (!EQ (tem, Qunbound))
{
WINDOWINFO_TYPE wininfo;
int nchildren;
Window *children, root;
- CHECK_STRING (tem, 0);
- f->display.x->window_desc = (Window) atoi (XSTRING (tem)->data);
+ CHECK_NUMBER (tem, 0);
+ FRAME_X_WINDOW (f) = (Window) XINT (tem);
BLOCK_INPUT;
- XGetWindowInfo (f->display.x->window_desc, &wininfo);
- XQueryTree (f->display.x->window_desc, &parent, &nchildren, &children);
+ XGetWindowInfo (FRAME_X_WINDOW (f), &wininfo);
+ XQueryTree (FRAME_X_WINDOW (f), &parent, &nchildren, &children);
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;
- f->visible = wininfo.mapped != 0;
+ FRAME_SET_VISIBILITY (f, wininfo.mapped != 0);
f->display.x->border_width = wininfo.bdrwidth;
f->display.x->parent_desc = parent;
}
else
{
- tem = x_get_arg (parms, intern ("parent-id"), 0, 0);
- if (!EQ (tem, Qnil))
+ tem = x_get_arg (parms, Qparent_id, 0, 0, number);
+ if (!EQ (tem, Qunbound))
{
- CHECK_STRING (tem, 0);
- parent = (Window) atoi (XSTRING (tem)->data);
+ CHECK_NUMBER (tem, 0);
+ parent = (Window) XINT (tem);
}
f->display.x->parent_desc = parent;
- tem = x_get_arg (parms, intern ("height"), 0, 0);
- if (EQ (tem, Qnil))
+ tem = x_get_arg (parms, Qheight, 0, 0, number);
+ if (EQ (tem, Qunbound))
{
- tem = x_get_arg (parms, intern ("width"), 0, 0);
- if (EQ (tem, Qnil))
+ tem = x_get_arg (parms, Qwidth, 0, 0, number);
+ if (EQ (tem, Qunbound))
{
- tem = x_get_arg (parms, intern ("top"), 0, 0);
- if (EQ (tem, Qnil))
- tem = x_get_arg (parms, intern ("left"), 0, 0);
+ tem = x_get_arg (parms, Qtop, 0, 0, number);
+ if (EQ (tem, Qunbound))
+ tem = x_get_arg (parms, Qleft, 0, 0, number);
}
}
- /* Now TEM is nil if no edge or size was specified.
+ /* Now TEM is Qunbound if no edge or size was specified.
In that case, we must do rubber-banding. */
- if (EQ (tem, Qnil))
+ if (EQ (tem, Qunbound))
{
- tem = x_get_arg (parms, intern ("geometry"), 0, 0);
+ 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, intern ("height"), 0, 0);
- if (EQ (tem, Qnil))
+ 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, intern ("width"), 0, 0);
- if (EQ (tem, Qnil))
+ 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, intern ("top"), 0, 0);
- if (EQ (tem, Qnil))
+ 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, intern ("left"), 0, 0);
- if (EQ (tem, Qnil))
+ 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;
- f->display.x->window_desc
+ FRAME_X_WINDOW (f)
= XCreateWindow (parent,
f->display.x->left_pos, /* Absolute horizontal offset */
f->display.x->top_pos, /* Absolute Vertical offset */
f->display.x->border_width,
BLACK_PIX_DEFAULT, WHITE_PIX_DEFAULT);
UNBLOCK_INPUT;
- if (f->display.x->window_desc == 0)
+ if (FRAME_X_WINDOW (f) == 0)
error ("Unable to create window.");
}
/* Install the now determined height and width
in the windows and in phys_lines and desired_lines. */
- /* ??? jla version had 1 here instead of 0. */
- change_frame_size (f, height, width, 1);
- XSelectInput (f->display.x->window_desc, KeyPressed | ExposeWindow
+ change_frame_size (f, height, width, 1, 0);
+ XSelectInput (FRAME_X_WINDOW (f), KeyPressed | ExposeWindow
| ButtonPressed | ButtonReleased | ExposeRegion | ExposeCopy
| EnterWindow | LeaveWindow | UnmapWindow );
x_set_resize_hint (f);
/* Tell the server the window's default name. */
-#ifdef HAVE_X11
- {
- XTextProperty prop;
- prop.value = XSTRING (f->name)->data;
- prop.encoding = XA_STRING;
- prop.format = 8;
- prop.nitems = XSTRING (f->name)->size;
- XSetWMName (XDISPLAY f->display.x->window_desc, &prop);
- }
-#else
- XStoreName (XDISPLAY f->display.x->window_desc, XSTRING (f->name)->data);
-#endif
+ XStoreName (XDISPLAY FRAME_X_WINDOW (f), XSTRING (f->name)->data);
/* Now override the defaults with all the rest of the specified
parms. */
- tem = x_get_arg (parms, intern ("unsplittable"), 0, 0);
+ 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, intern ("suppress-icon"), 0, 0), 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, "icon-type", Qnil,
- "BitmapIcon", boolean);
+ x_default_parameter (f, parms, Qicon_type, Qnil,
+ "BitmapIcon", 0, symbol);
}
/* Tell the X server the previously set values of the
background, border and mouse colors; also create the mouse cursor. */
BLOCK_INPUT;
temp = XMakeTile (f->display.x->background_pixel);
- XChangeBackground (f->display.x->window_desc, temp);
+ XChangeBackground (FRAME_X_WINDOW (f), temp);
XFreePixmap (temp);
UNBLOCK_INPUT;
x_set_border_pixel (f, f->display.x->border_pixel);
Fmodify_frame_parameters (frame, parms);
- if (!NILP (vscroll))
- install_vertical_scrollbar (f, pixelwidth, pixelheight);
- if (!NILP (hscroll))
- install_horizontal_scrollbar (f, pixelwidth, pixelheight);
-
/* Make the window appear on the frame and enable display. */
- if (!EQ (x_get_arg (parms, intern ("suppress-initial-map"), 0, 0), 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 */
{
CHECK_LIVE_FRAME (frame, 0);
- if (FRAME_IS_X (XFRAME (frame)))
+ if (FRAME_X_P (XFRAME (frame)))
{
BLOCK_INPUT;
x_focus_on_frame (XFRAME (frame));
}
#endif /* not HAVE_X11 */
\f
-/* Set whether frame F has a horizontal scroll bar.
- VAL is t or nil to specify it. */
-
-static void
-x_set_horizontal_scrollbar (f, val, oldval)
- struct frame *f;
- Lisp_Object val, oldval;
-{
- if (!NILP (val))
- {
- if (f->display.x->window_desc != 0)
- {
- BLOCK_INPUT;
- f->display.x->h_scrollbar_height = HSCROLL_HEIGHT;
- x_set_window_size (f, f->width, f->height);
- install_horizontal_scrollbar (f);
- SET_FRAME_GARBAGED (f);
- UNBLOCK_INPUT;
- }
- }
- else
- if (f->display.x->h_scrollbar)
- {
- BLOCK_INPUT;
- f->display.x->h_scrollbar_height = 0;
- XDestroyWindow (XDISPLAY f->display.x->h_scrollbar);
- f->display.x->h_scrollbar = 0;
- x_set_window_size (f, f->width, f->height);
- f->garbaged++;
- frame_garbaged++;
- BLOCK_INPUT;
- }
-}
-
-/* Set whether frame F has a vertical scroll bar.
- VAL is t or nil to specify it. */
-
-static void
-x_set_vertical_scrollbar (f, val, oldval)
- struct frame *f;
- Lisp_Object val, oldval;
-{
- if (!NILP (val))
- {
- if (f->display.x->window_desc != 0)
- {
- BLOCK_INPUT;
- f->display.x->v_scrollbar_width = VSCROLL_WIDTH;
- x_set_window_size (f, f->width, f->height);
- install_vertical_scrollbar (f);
- SET_FRAME_GARBAGED (f);
- UNBLOCK_INPUT;
- }
- }
- else
- if (f->display.x->v_scrollbar != 0)
- {
- BLOCK_INPUT;
- f->display.x->v_scrollbar_width = 0;
- XDestroyWindow (XDISPLAY f->display.x->v_scrollbar);
- f->display.x->v_scrollbar = 0;
- x_set_window_size (f, f->width, f->height);
- SET_FRAME_GARBAGED (f);
- UNBLOCK_INPUT;
- }
-}
-\f
-/* Create the X windows for a vertical scroll bar
- for a frame X that already has an X window but no scroll bar. */
-
-static void
-install_vertical_scrollbar (f)
- struct frame *f;
-{
- int ibw = f->display.x->internal_border_width;
- Window parent;
- XColor fore_color, back_color;
- Pixmap up_arrow_pixmap, down_arrow_pixmap, slider_pixmap;
- int pix_x, pix_y, width, height, border;
-
- height = f->display.x->pixel_height - ibw - 2;
- width = VSCROLL_WIDTH - 2;
- pix_x = f->display.x->pixel_width - ibw/2;
- pix_y = ibw / 2;
- border = 1;
-
-#ifdef HAVE_X11
- up_arrow_pixmap =
- XCreatePixmapFromBitmapData (x_current_display, f->display.x->window_desc,
- up_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- down_arrow_pixmap =
- XCreatePixmapFromBitmapData (x_current_display, f->display.x->window_desc,
- down_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- slider_pixmap =
- XCreatePixmapFromBitmapData (x_current_display, f->display.x->window_desc,
- gray_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- /* These cursor shapes will be installed when the mouse enters
- the appropriate window. */
-
- up_arrow_cursor = XCreateFontCursor (x_current_display, XC_sb_up_arrow);
- down_arrow_cursor = XCreateFontCursor (x_current_display, XC_sb_down_arrow);
- v_double_arrow_cursor = XCreateFontCursor (x_current_display, XC_sb_v_double_arrow);
-
- f->display.x->v_scrollbar =
- XCreateSimpleWindow (x_current_display, f->display.x->window_desc,
- pix_x, pix_y, width, height, border,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel);
- XFlush (x_current_display);
- XDefineCursor (x_current_display, f->display.x->v_scrollbar,
- v_double_arrow_cursor);
-
- /* Create slider window */
- f->display.x->v_slider =
- XCreateSimpleWindow (x_current_display, f->display.x->v_scrollbar,
- 0, VSCROLL_WIDTH - 2,
- VSCROLL_WIDTH - 4, VSCROLL_WIDTH - 4,
- 1, f->display.x->border_pixel,
- f->display.x->foreground_pixel);
- XFlush (x_current_display);
- XDefineCursor (x_current_display, f->display.x->v_slider,
- v_double_arrow_cursor);
- XSetWindowBackgroundPixmap (x_current_display, f->display.x->v_slider,
- slider_pixmap);
-
- f->display.x->v_thumbup =
- XCreateSimpleWindow (x_current_display, f->display.x->v_scrollbar,
- 0, 0,
- VSCROLL_WIDTH - 2, VSCROLL_WIDTH - 2,
- 0, f->display.x->foreground_pixel,
- f->display.x-> background_pixel);
- XFlush (x_current_display);
- XDefineCursor (x_current_display, f->display.x->v_thumbup,
- up_arrow_cursor);
- XSetWindowBackgroundPixmap (x_current_display, f->display.x->v_thumbup,
- up_arrow_pixmap);
-
- f->display.x->v_thumbdown =
- XCreateSimpleWindow (x_current_display, f->display.x->v_scrollbar,
- 0, height - VSCROLL_WIDTH + 2,
- VSCROLL_WIDTH - 2, VSCROLL_WIDTH - 2,
- 0, f->display.x->foreground_pixel,
- f->display.x->background_pixel);
- XFlush (x_current_display);
- XDefineCursor (x_current_display, f->display.x->v_thumbdown,
- down_arrow_cursor);
- XSetWindowBackgroundPixmap (x_current_display, f->display.x->v_thumbdown,
- down_arrow_pixmap);
-
- fore_color.pixel = f->display.x->mouse_pixel;
- back_color.pixel = f->display.x->background_pixel;
- XQueryColor (x_current_display,
- DefaultColormap (x_current_display,
- DefaultScreen (x_current_display)),
- &fore_color);
- XQueryColor (x_current_display,
- DefaultColormap (x_current_display,
- DefaultScreen (x_current_display)),
- &back_color);
- XRecolorCursor (x_current_display, up_arrow_cursor,
- &fore_color, &back_color);
- XRecolorCursor (x_current_display, down_arrow_cursor,
- &fore_color, &back_color);
- XRecolorCursor (x_current_display, v_double_arrow_cursor,
- &fore_color, &back_color);
-
- XFreePixmap (x_current_display, slider_pixmap);
- XFreePixmap (x_current_display, up_arrow_pixmap);
- XFreePixmap (x_current_display, down_arrow_pixmap);
- XFlush (x_current_display);
-
- XSelectInput (x_current_display, f->display.x->v_scrollbar,
- ButtonPressMask | ButtonReleaseMask
- | PointerMotionMask | PointerMotionHintMask
- | EnterWindowMask);
- XSelectInput (x_current_display, f->display.x->v_slider,
- ButtonPressMask | ButtonReleaseMask);
- XSelectInput (x_current_display, f->display.x->v_thumbdown,
- ButtonPressMask | ButtonReleaseMask);
- XSelectInput (x_current_display, f->display.x->v_thumbup,
- ButtonPressMask | ButtonReleaseMask);
- XFlush (x_current_display);
-
- /* This should be done at the same time as the main window. */
- XMapWindow (x_current_display, f->display.x->v_scrollbar);
- XMapSubwindows (x_current_display, f->display.x->v_scrollbar);
- XFlush (x_current_display);
-#else /* not HAVE_X11 */
- Bitmap b;
- Pixmap fore_tile, back_tile, bord_tile;
- static short up_arrow_bits[] = {
- 0x0000, 0x0180, 0x03c0, 0x07e0,
- 0x0ff0, 0x1ff8, 0x3ffc, 0x7ffe,
- 0x0180, 0x0180, 0x0180, 0x0180,
- 0x0180, 0x0180, 0x0180, 0xffff};
- static short down_arrow_bits[] = {
- 0xffff, 0x0180, 0x0180, 0x0180,
- 0x0180, 0x0180, 0x0180, 0x0180,
- 0x7ffe, 0x3ffc, 0x1ff8, 0x0ff0,
- 0x07e0, 0x03c0, 0x0180, 0x0000};
-
- fore_tile = XMakeTile (f->display.x->foreground_pixel);
- back_tile = XMakeTile (f->display.x->background_pixel);
- bord_tile = XMakeTile (f->display.x->border_pixel);
-
- b = XStoreBitmap (VSCROLL_WIDTH - 2, VSCROLL_WIDTH - 2, up_arrow_bits);
- up_arrow_pixmap = XMakePixmap (b,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel);
- XFreeBitmap (b);
-
- b = XStoreBitmap (VSCROLL_WIDTH - 2, VSCROLL_WIDTH - 2, down_arrow_bits);
- down_arrow_pixmap = XMakePixmap (b,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel);
- XFreeBitmap (b);
-
- ibw = f->display.x->internal_border_width;
-
- f->display.x->v_scrollbar = XCreateWindow (f->display.x->window_desc,
- width - VSCROLL_WIDTH - ibw/2,
- ibw/2,
- VSCROLL_WIDTH - 2,
- height - ibw - 2,
- 1, bord_tile, back_tile);
-
- f->display.x->v_scrollbar_width = VSCROLL_WIDTH;
-
- f->display.x->v_thumbup = XCreateWindow (f->display.x->v_scrollbar,
- 0, 0,
- VSCROLL_WIDTH - 2,
- VSCROLL_WIDTH - 2,
- 0, 0, up_arrow_pixmap);
- XTileAbsolute (f->display.x->v_thumbup);
-
- f->display.x->v_thumbdown = XCreateWindow (f->display.x->v_scrollbar,
- 0,
- height - ibw - VSCROLL_WIDTH,
- VSCROLL_WIDTH - 2,
- VSCROLL_WIDTH - 2,
- 0, 0, down_arrow_pixmap);
- XTileAbsolute (f->display.x->v_thumbdown);
-
- f->display.x->v_slider = XCreateWindow (f->display.x->v_scrollbar,
- 0, VSCROLL_WIDTH - 2,
- VSCROLL_WIDTH - 4,
- VSCROLL_WIDTH - 4,
- 1, back_tile, fore_tile);
-
- XSelectInput (f->display.x->v_scrollbar,
- (ButtonPressed | ButtonReleased | KeyPressed));
- XSelectInput (f->display.x->v_thumbup,
- (ButtonPressed | ButtonReleased | KeyPressed));
-
- XSelectInput (f->display.x->v_thumbdown,
- (ButtonPressed | ButtonReleased | KeyPressed));
-
- XMapWindow (f->display.x->v_thumbup);
- XMapWindow (f->display.x->v_thumbdown);
- XMapWindow (f->display.x->v_slider);
- XMapWindow (f->display.x->v_scrollbar);
-
- XFreePixmap (fore_tile);
- XFreePixmap (back_tile);
- XFreePixmap (up_arrow_pixmap);
- XFreePixmap (down_arrow_pixmap);
-#endif /* not HAVE_X11 */
-}
-
-static void
-install_horizontal_scrollbar (f)
- struct frame *f;
-{
- int ibw = f->display.x->internal_border_width;
- Window parent;
- Pixmap left_arrow_pixmap, right_arrow_pixmap, slider_pixmap;
- int pix_x, pix_y;
- int width;
-
- pix_x = ibw;
- pix_y = PIXEL_HEIGHT (f) - HSCROLL_HEIGHT - ibw ;
- width = PIXEL_WIDTH (f) - 2 * ibw;
- if (f->display.x->v_scrollbar_width)
- width -= (f->display.x->v_scrollbar_width + 1);
-
-#ifdef HAVE_X11
- left_arrow_pixmap =
- XCreatePixmapFromBitmapData (x_current_display, f->display.x->window_desc,
- left_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- right_arrow_pixmap =
- XCreatePixmapFromBitmapData (x_current_display, f->display.x->window_desc,
- right_arrow_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- slider_pixmap =
- XCreatePixmapFromBitmapData (x_current_display, f->display.x->window_desc,
- gray_bits, 16, 16,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel,
- DefaultDepth (x_current_display,
- XDefaultScreen (x_current_display)));
-
- left_arrow_cursor = XCreateFontCursor (x_current_display, XC_sb_left_arrow);
- right_arrow_cursor = XCreateFontCursor (x_current_display, XC_sb_right_arrow);
- h_double_arrow_cursor = XCreateFontCursor (x_current_display, XC_sb_h_double_arrow);
-
- f->display.x->h_scrollbar =
- XCreateSimpleWindow (x_current_display, f->display.x->window_desc,
- pix_x, pix_y,
- width - ibw - 2, HSCROLL_HEIGHT - 2, 1,
- f->display.x->foreground_pixel,
- f->display.x->background_pixel);
- XDefineCursor (x_current_display, f->display.x->h_scrollbar,
- h_double_arrow_cursor);
-
- f->display.x->h_slider =
- XCreateSimpleWindow (x_current_display, f->display.x->h_scrollbar,
- 0, 0,
- HSCROLL_HEIGHT - 4, HSCROLL_HEIGHT - 4,
- 1, f->display.x->foreground_pixel,
- f->display.x->background_pixel);
- XDefineCursor (x_current_display, f->display.x->h_slider,
- h_double_arrow_cursor);
- XSetWindowBackgroundPixmap (x_current_display, f->display.x->h_slider,
- slider_pixmap);
-
- f->display.x->h_thumbleft =
- XCreateSimpleWindow (x_current_display, f->display.x->h_scrollbar,
- 0, 0,
- HSCROLL_HEIGHT - 2, HSCROLL_HEIGHT - 2,
- 0, f->display.x->foreground_pixel,
- f->display.x->background_pixel);
- XDefineCursor (x_current_display, f->display.x->h_thumbleft,
- left_arrow_cursor);
- XSetWindowBackgroundPixmap (x_current_display, f->display.x->h_thumbleft,
- left_arrow_pixmap);
-
- f->display.x->h_thumbright =
- XCreateSimpleWindow (x_current_display, f->display.x->h_scrollbar,
- width - ibw - HSCROLL_HEIGHT, 0,
- HSCROLL_HEIGHT - 2, HSCROLL_HEIGHT -2,
- 0, f->display.x->foreground_pixel,
- f->display.x->background_pixel);
- XDefineCursor (x_current_display, f->display.x->h_thumbright,
- right_arrow_cursor);
- XSetWindowBackgroundPixmap (x_current_display, f->display.x->h_thumbright,
- right_arrow_pixmap);
-
- XFreePixmap (x_current_display, slider_pixmap);
- XFreePixmap (x_current_display, left_arrow_pixmap);
- XFreePixmap (x_current_display, right_arrow_pixmap);
-
- XSelectInput (x_current_display, f->display.x->h_scrollbar,
- ButtonPressMask | ButtonReleaseMask
- | PointerMotionMask | PointerMotionHintMask
- | EnterWindowMask);
- XSelectInput (x_current_display, f->display.x->h_slider,
- ButtonPressMask | ButtonReleaseMask);
- XSelectInput (x_current_display, f->display.x->h_thumbright,
- ButtonPressMask | ButtonReleaseMask);
- XSelectInput (x_current_display, f->display.x->h_thumbleft,
- ButtonPressMask | ButtonReleaseMask);
-
- XMapWindow (x_current_display, f->display.x->h_scrollbar);
- XMapSubwindows (x_current_display, f->display.x->h_scrollbar);
-#else /* not HAVE_X11 */
- Bitmap b;
- Pixmap fore_tile, back_tile, bord_tile;
-#endif
-}
-\f
-#ifndef HAVE_X11 /* X10 */
-#define XMoveResizeWindow XConfigureWindow
-#endif /* not HAVE_X11 */
-
-/* Adjust the displayed position in the scroll bar for window W. */
-
-void
-adjust_scrollbars (f)
- struct frame *f;
-{
- int pos;
- int first_char_in_window, char_beyond_window, chars_in_window;
- int chars_in_buffer, buffer_size;
- struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
-
- if (! FRAME_IS_X (f))
- return;
-
- if (f->display.x->v_scrollbar != 0)
- {
- int h, height;
- struct buffer *b = XBUFFER (w->buffer);
-
- buffer_size = Z - BEG;
- chars_in_buffer = ZV - BEGV;
- first_char_in_window = marker_position (w->start);
- char_beyond_window = buffer_size + 1 - XFASTINT (w->window_end_pos);
- chars_in_window = char_beyond_window - first_char_in_window;
-
- /* Calculate height of scrollbar area */
-
- height = f->height * FONT_HEIGHT (f->display.x->font)
- + f->display.x->internal_border_width
- - 2 * (f->display.x->v_scrollbar_width);
-
- /* Figure starting position for the scrollbar slider */
-
- if (chars_in_buffer <= 0)
- pos = 0;
- else
- pos = ((first_char_in_window - BEGV - BEG) * height
- / chars_in_buffer);
- pos = max (0, pos);
- pos = min (pos, height - 2);
-
- /* Figure length of the slider */
-
- if (chars_in_buffer <= 0)
- h = height;
- else
- h = (chars_in_window * height) / chars_in_buffer;
- h = min (h, height - pos);
- h = max (h, 1);
-
- /* Add thumbup offset to starting position of slider */
-
- pos += (f->display.x->v_scrollbar_width - 2);
-
- XMoveResizeWindow (XDISPLAY
- f->display.x->v_slider,
- 0, pos,
- f->display.x->v_scrollbar_width - 4, h);
- }
-
- if (f->display.x->h_scrollbar != 0)
- {
- int l, length; /* Length of the scrollbar area */
-
- length = f->width * FONT_WIDTH (f->display.x->font)
- + f->display.x->internal_border_width
- - 2 * (f->display.x->h_scrollbar_height);
-
- /* Starting position for horizontal slider */
- if (! w->hscroll)
- pos = 0;
- else
- pos = (w->hscroll * length) / (w->hscroll + f->width);
- pos = max (0, pos);
- pos = min (pos, length - 2);
-
- /* Length of slider */
- l = length - pos;
-
- /* Add thumbup offset */
- pos += (f->display.x->h_scrollbar_height - 2);
-
- XMoveResizeWindow (XDISPLAY
- f->display.x->h_slider,
- pos, 0,
- l, f->display.x->h_scrollbar_height - 4);
- }
-}
-\f
-/* Adjust the size of the scroll bars of frame F,
- when the frame size has changed. */
-
-void
-x_resize_scrollbars (f)
- struct frame *f;
-{
- int ibw = f->display.x->internal_border_width;
- int pixelwidth, pixelheight;
-
- if (f == 0
- || f->display.x == 0
- || (f->display.x->v_scrollbar == 0
- && f->display.x->h_scrollbar == 0))
- return;
-
- /* Get the size of the frame. */
- pixelwidth = (f->width * FONT_WIDTH (f->display.x->font)
- + 2 * ibw + f->display.x->v_scrollbar_width);
- pixelheight = (f->height * FONT_HEIGHT (f->display.x->font)
- + 2 * ibw + f->display.x->h_scrollbar_height);
-
- if (f->display.x->v_scrollbar_width && f->display.x->v_scrollbar)
- {
- BLOCK_INPUT;
- XMoveResizeWindow (XDISPLAY
- f->display.x->v_scrollbar,
- pixelwidth - f->display.x->v_scrollbar_width - ibw/2,
- ibw/2,
- f->display.x->v_scrollbar_width - 2,
- pixelheight - ibw - 2);
- XMoveWindow (XDISPLAY
- f->display.x->v_thumbdown, 0,
- pixelheight - ibw - f->display.x->v_scrollbar_width);
- UNBLOCK_INPUT;
- }
-
- if (f->display.x->h_scrollbar_height && f->display.x->h_scrollbar)
- {
- if (f->display.x->v_scrollbar_width)
- pixelwidth -= f->display.x->v_scrollbar_width + 1;
-
- BLOCK_INPUT;
- XMoveResizeWindow (XDISPLAY
- f->display.x->h_scrollbar,
- ibw / 2,
- pixelheight - f->display.x->h_scrollbar_height - ibw / 2,
- pixelwidth - ibw - 2,
- f->display.x->h_scrollbar_height - 2);
- XMoveWindow (XDISPLAY
- f->display.x->h_thumbright,
- pixelwidth - ibw - f->display.x->h_scrollbar_height, 0);
- UNBLOCK_INPUT;
- }
-}
-
-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)
"Return t if the X display used currently supports color.")
()
{
- if (XINT (x_screen_planes) <= 2)
+ if (x_screen_planes <= 2)
return Qnil;
switch (screen_visual->class)
}
}
-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. */
else
height = FONT_HEIGHT (f->display.x->font) * lines;
- XDrawRectangle (x_current_display, f->display.x->window_desc,
+ XDrawRectangle (x_current_display, FRAME_X_WINDOW (f),
gc, left, top, width, height);
}
this_point->x = pixel_points->x;
this_point->y = pixel_points->y;
- XDrawLines (x_current_display, f->display.x->window_desc,
+ XDrawLines (x_current_display, FRAME_X_WINDOW (f),
gc, pixel_points,
(this_point - pixel_points + 1), CoordModeOrigin);
}
while (1)
{
- obj = read_char (-1);
+ obj = read_char (-1, 0, 0, Qnil, 0);
if (XTYPE (obj) != Lisp_Cons)
break;
}
}
- unread_command_char = obj;
+ unread_command_event = obj;
if (mouse_below_point)
{
contour_begin_x = point_x;
gc_values.cap_style = CapRound;
gc_values.join_style = JoinRound;
- line_gc = XCreateGC (x_current_display, f->display.x->window_desc,
+ line_gc = XCreateGC (x_current_display, FRAME_X_WINDOW (f),
GCLineStyle | GCJoinStyle | GCCapStyle
| GCLineWidth | GCForeground | GCBackground,
&gc_values);
XSetDashes (x_current_display, line_gc, 0, dash_list, dashes);
gc_values.foreground = f->display.x->background_pixel;
gc_values.background = f->display.x->foreground_pixel;
- erase_gc = XCreateGC (x_current_display, f->display.x->window_desc,
+ erase_gc = XCreateGC (x_current_display, FRAME_X_WINDOW (f),
GCLineStyle | GCJoinStyle | GCCapStyle
| GCLineWidth | GCForeground | GCBackground,
&gc_values);
previous_y = x_mouse_y;
line = (x_mouse_y + 1) * FONT_HEIGHT (f->display.x->font)
+ f->display.x->internal_border_width;
- XDrawLine (x_current_display, f->display.x->window_desc,
+ XDrawLine (x_current_display, FRAME_X_WINDOW (f),
line_gc, left, line, right, line);
}
XFlushQueue ();
do
{
- obj = read_char (-1);
+ obj = read_char (-1, 0, 0, Qnil, 0);
if ((XTYPE (obj) != Lisp_Cons)
|| (! EQ (Fcar (Fcdr (Fcdr (obj))),
- intern ("vertical-scroll-bar")))
+ Qvertical_scroll_bar))
|| x_mouse_grabbed)
{
BLOCK_INPUT;
- XDrawLine (x_current_display, f->display.x->window_desc,
+ XDrawLine (x_current_display, FRAME_X_WINDOW (f),
erase_gc, left, line, right, line);
UNBLOCK_INPUT;
- unread_command_char = obj;
+ unread_command_event = obj;
#if 0
XFreeGC (x_current_display, line_gc);
XFreeGC (x_current_display, erase_gc);
while (x_mouse_y == previous_y);
BLOCK_INPUT;
- XDrawLine (x_current_display, f->display.x->window_desc,
+ XDrawLine (x_current_display, FRAME_X_WINDOW (f),
erase_gc, left, line, right, line);
UNBLOCK_INPUT;
}
current_pointer_shape = f->display.x->nontext_cursor;
XDefineCursor (x_current_display,
- f->display.x->window_desc,
+ FRAME_X_WINDOW (f),
current_pointer_shape);
buf = XBUFFER (XWINDOW (Vmouse_window)->buffer);
{
current_pointer_shape = f->display.x->modeline_cursor;
XDefineCursor (x_current_display,
- f->display.x->window_desc,
+ FRAME_X_WINDOW (f),
current_pointer_shape);
}
if (mouse_track_width) /* Over text; use text pointer shape. */
{
XDefineCursor (x_current_display,
- f->display.x->window_desc,
+ FRAME_X_WINDOW (f),
f->display.x->text_cursor);
x_rectangle (f, f->display.x->cursor_gc,
mouse_track_left, mouse_track_top,
}
else if (in_mode_line)
XDefineCursor (x_current_display,
- f->display.x->window_desc,
+ FRAME_X_WINDOW (f),
f->display.x->modeline_cursor);
else
XDefineCursor (x_current_display,
- f->display.x->window_desc,
+ FRAME_X_WINDOW (f),
f->display.x->nontext_cursor);
}
XFlush (x_current_display);
UNBLOCK_INPUT;
- obj = read_char (-1);
+ obj = read_char (-1, 0, 0, Qnil, 0);
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);
- unread_command_char = obj;
+ unread_command_event = obj;
if (mouse_track_width)
{
}
}
XDefineCursor (x_current_display,
- f->display.x->window_desc,
+ FRAME_X_WINDOW (f),
f->display.x->nontext_cursor);
XFlush (x_current_display);
UNBLOCK_INPUT;
Pixmap image;
image = XCreateBitmapFromData (x_current_display,
- f->display.x->window_desc, image_data,
+ FRAME_X_WINDOW (f), image_data,
width, height);
- XCopyPlane (x_current_display, image, f->display.x->window_desc,
+ XCopyPlane (x_current_display, image, FRAME_X_WINDOW (f),
f->display.x->normal_gc, 0, 0, width, height, x, y);
}
#endif
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;
}
int mask;
CHECK_STRING (string, 1);
- if (! FRAME_IS_X (selected_frame))
+ if (! FRAME_X_P (selected_frame))
error ("Selected frame does not understand X protocol.");
BLOCK_INPUT;
int n_visuals;
v = DefaultVisualOfScreen (screen);
+
+#ifdef HAVE_X11R4
vinfo_template.visualid = XVisualIDFromVisual (v);
+#else
+ vinfo_template.visualid = x->visualid;
+#endif
+
vinfo = XGetVisualInfo (x_current_display, VisualIDMask, &vinfo_template,
&n_visuals);
if (n_visuals != 1)
x_screen = DefaultScreenOfDisplay (x_current_display);
- x_screen_count = make_number (ScreenCount (x_current_display));
+ x_screen_count = ScreenCount (x_current_display);
Vx_vendor = build_string (ServerVendor (x_current_display));
- x_release = make_number (VendorRelease (x_current_display));
+ x_release = VendorRelease (x_current_display);
- x_screen_height = make_number (HeightOfScreen (x_screen));
- x_screen_height_mm = make_number (HeightMMOfScreen (x_screen));
- x_screen_width = make_number (WidthOfScreen (x_screen));
- x_screen_width_mm = make_number (WidthMMOfScreen (x_screen));
+ x_screen_height = HeightOfScreen (x_screen);
+ x_screen_height_mm = HeightMMOfScreen (x_screen);
+ x_screen_width = WidthOfScreen (x_screen);
+ x_screen_width_mm = WidthMMOfScreen (x_screen);
switch (DoesBackingStore (x_screen))
{
}
if (DoesSaveUnders (x_screen) == True)
- x_save_under = Qt;
+ x_save_under = 1;
else
- x_save_under = Qnil;
+ x_save_under = 0;
screen_visual = select_visual (x_screen, &n_planes);
- x_screen_planes = make_number (n_planes);
+ x_screen_planes = n_planes;
Vx_screen_visual = intern (x_visual_strings [screen_visual->class]);
/* X Atoms used by emacs. */
\f
syms_of_xfns ()
{
- init_x_parm_symbols ();
-
/* This is zero if not using X windows. */
x_current_display = 0;
+ /* The section below is built by the lisp expression at the top of the file,
+ just above where these variables are declared. */
+ /*&&& init symbols here &&&*/
+ Qauto_raise = intern ("auto-raise");
+ staticpro (&Qauto_raise);
+ Qauto_lower = intern ("auto-lower");
+ 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 (&Qforeground_color);
+ Qgeometry = intern ("geometry");
+ staticpro (&Qgeometry);
+ Qicon_left = intern ("icon-left");
+ staticpro (&Qicon_left);
+ Qicon_top = intern ("icon-top");
+ staticpro (&Qicon_top);
+ Qicon_type = intern ("icon-type");
+ staticpro (&Qicon_type);
+ Qiconic_startup = intern ("iconic-startup");
+ staticpro (&Qiconic_startup);
+ Qinternal_border_width = intern ("internal-border-width");
+ staticpro (&Qinternal_border_width);
+ Qleft = intern ("left");
+ 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 (&Qsuppress_icon);
+ Qsuppress_initial_map = intern ("suppress-initial-map");
+ staticpro (&Qsuppress_initial_map);
+ Qtop = intern ("top");
+ 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");
+ staticpro (&Qx_frame_parameter);
+ /* This is the end of symbol initialization. */
+
Fput (Qundefined_color, Qerror_conditions,
Fcons (Qundefined_color, Fcons (Qerror, Qnil)));
Fput (Qundefined_color, Qerror_message,
build_string ("Undefined color"));
- DEFVAR_INT ("mouse-x-position", &x_mouse_x,
- "The X coordinate of the mouse position, in characters.");
- x_mouse_x = Qnil;
-
- DEFVAR_INT ("mouse-y-position", &x_mouse_y,
- "The Y coordinate of the mouse position, in characters.");
- x_mouse_y = Qnil;
+ init_x_parm_symbols ();
DEFVAR_INT ("mouse-buffer-offset", &mouse_buffer_offset,
"The buffer offset of the character under the pointer.");
- mouse_buffer_offset = Qnil;
+ mouse_buffer_offset = 0;
DEFVAR_INT ("x-pointer-shape", &Vx_pointer_shape,
"The shape of the pointer when over text.");
"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);