view src/xterm.c @ 37914:055740f4bc36

(speeds): Put in #if 0.

+
鐃緒申��申鐃緒申/* X Communication module for terminals which understand the X protocol.
+
鐃緒申��申鐃緒申   Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000, 2001
+
鐃緒申��申鐃緒申   Free Software Foundation, Inc.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This file is part of GNU Emacs.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申GNU Emacs is free software; you can redistribute it and/or modify
+
鐃緒申��申鐃緒申it under the terms of the GNU General Public License as published by
+
鐃緒申��申鐃緒申the Free Software Foundation; either version 2, or (at your option)
+
鐃緒申��申鐃緒申any later version.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申GNU Emacs is distributed in the hope that it will be useful,
+
鐃緒申��申鐃緒申but WITHOUT ANY WARRANTY; without even the implied warranty of
+
鐃緒申��申鐃緒申MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+
鐃緒申��申鐃緒申GNU General Public License for more details.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申You should have received a copy of the GNU General Public License
+
鐃緒申��申鐃緒申along with GNU Emacs; see the file COPYING.  If not, write to
+
鐃緒申��申鐃緒申the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+
鐃緒申��申鐃緒申Boston, MA 02111-1307, USA.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* New display code by Gerd Moellmann <[e-mail]>.  */
+
鐃緒申��申鐃緒申/* Xt features made by Fred Pierresteguy.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#include <config.h>
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* On 4.3 these lose if they come after xterm.h.  */
+
鐃緒申��申鐃緒申/* Putting these at the beginning seems to be standard for other .c files.  */
+
鐃緒申��申鐃緒申#include <signal.h>
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#include <stdio.h>
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X_WINDOWS
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#include "lisp.h"
+
鐃緒申��申鐃緒申#include "blockinput.h"
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Need syssignal.h for various externs and definitions that may be required
+
鐃緒申��申鐃緒申   by some configurations for calls to signal later in this source file.  */
+
鐃緒申��申鐃緒申#include "syssignal.h"
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This may include sys/types.h, and that somehow loses
+
鐃緒申��申鐃緒申   if this is not done before the other system files.  */
+
鐃緒申��申鐃緒申#include "xterm.h"
+
鐃緒申��申鐃緒申#include <X11/cursorfont.h>
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Load sys/types.h if not already loaded.
+
鐃緒申��申鐃緒申   In some systems loading it twice is suicidal.  */
+
鐃緒申��申鐃緒申#ifndef makedev
+
鐃緒申��申鐃緒申#include <sys/types.h>
+
鐃緒申��申鐃緒申#endif /* makedev */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef BSD_SYSTEM
+
鐃緒申��申鐃緒申#include <sys/ioctl.h>
+
鐃緒申��申鐃緒申#endif /* ! defined (BSD_SYSTEM) */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#include "systty.h"
+
鐃緒申��申鐃緒申#include "systime.h"
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef INCLUDED_FCNTL
+
鐃緒申��申鐃緒申#include <fcntl.h>
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#include <ctype.h>
+
鐃緒申��申鐃緒申#include <errno.h>
+
鐃緒申��申鐃緒申#include <setjmp.h>
+
鐃緒申��申鐃緒申#include <sys/stat.h>
+
鐃緒申��申鐃緒申/* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed.  */
+
鐃緒申��申鐃緒申/* #include <sys/param.h>  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#include "charset.h"
+
鐃緒申��申鐃緒申#include "coding.h"
+
鐃緒申��申鐃緒申#include "ccl.h"
+
鐃緒申��申鐃緒申#include "frame.h"
+
鐃緒申��申鐃緒申#include "dispextern.h"
+
鐃緒申��申鐃緒申#include "fontset.h"
+
鐃緒申��申鐃緒申#include "termhooks.h"
+
鐃緒申��申鐃緒申#include "termopts.h"
+
鐃緒申��申鐃緒申#include "termchar.h"
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申#include "sink.h"
+
鐃緒申��申鐃緒申#include "sinkmask.h"
+
鐃緒申��申鐃緒申#endif /* ! 0 */
+
鐃緒申��申鐃緒申#include "gnu.h"
+
鐃緒申��申鐃緒申#include "disptab.h"
+
鐃緒申��申鐃緒申#include "buffer.h"
+
鐃緒申��申鐃緒申#include "window.h"
+
鐃緒申��申鐃緒申#include "keyboard.h"
+
鐃緒申��申鐃緒申#include "intervals.h"
+
鐃緒申��申鐃緒申#include "process.h"
+
鐃緒申��申鐃緒申#include "atimer.h"
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申#include <X11/Shell.h>
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_SYS_TIME_H
+
鐃緒申��申鐃緒申#include <sys/time.h>
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef HAVE_UNISTD_H
+
鐃緒申��申鐃緒申#include <unistd.h>
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern void free_frame_menubar P_ ((struct frame *));
+
鐃緒申��申鐃緒申extern struct frame *x_menubar_window_to_frame P_ ((struct x_display_info *,
+
鐃緒申��申鐃緒申						    int));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
+
鐃緒申��申鐃緒申#define HACK_EDITRES
+
鐃緒申��申鐃緒申extern void _XEditResCheckMessages ();
+
鐃緒申��申鐃緒申#endif /* not NO_EDITRES */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Include toolkit specific headers for the scroll bar widget.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申#if defined USE_MOTIF
+
鐃緒申��申鐃緒申#include <Xm/Xm.h>		/* for LESSTIF_VERSION */
+
鐃緒申��申鐃緒申#include <Xm/ScrollBar.h>
+
鐃緒申��申鐃緒申#else /* !USE_MOTIF i.e. use Xaw */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_XAW3D
+
鐃緒申��申鐃緒申#include <X11/Xaw3d/Simple.h>
+
鐃緒申��申鐃緒申#include <X11/Xaw3d/Scrollbar.h>
+
鐃緒申��申鐃緒申#define ARROW_SCROLLBAR
+
鐃緒申��申鐃緒申#include <X11/Xaw3d/ScrollbarP.h>
+
鐃緒申��申鐃緒申#else /* !HAVE_XAW3D */
+
鐃緒申��申鐃緒申#include <X11/Xaw/Simple.h>
+
鐃緒申��申鐃緒申#include <X11/Xaw/Scrollbar.h>
+
鐃緒申��申鐃緒申#endif /* !HAVE_XAW3D */
+
鐃緒申��申鐃緒申#ifndef XtNpickTop
+
鐃緒申��申鐃緒申#define XtNpickTop "pickTop"
+
鐃緒申��申鐃緒申#endif /* !XtNpickTop */
+
鐃緒申��申鐃緒申#endif /* !USE_MOTIF */
+
鐃緒申��申鐃緒申#endif /* USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申#define x_any_window_to_frame x_window_to_frame
+
鐃緒申��申鐃緒申#define x_top_window_to_frame x_window_to_frame
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申#include "widget.h"
+
鐃緒申��申鐃緒申#ifndef XtNinitialState
+
鐃緒申��申鐃緒申#define XtNinitialState "initialState"
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef min
+
鐃緒申��申鐃緒申#define min(a,b) ((a) < (b) ? (a) : (b))
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifndef max
+
鐃緒申��申鐃緒申#define max(a,b) ((a) > (b) ? (a) : (b))
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define abs(x)	((x) < 0 ? -(x) : (x))
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define BETWEEN(X, LOWER, UPPER)  ((X) >= (LOWER) && (X) < (UPPER))
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Bitmaps for truncated lines.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申enum bitmap_type
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  NO_BITMAP,
+
鐃緒申��申鐃緒申  LEFT_TRUNCATION_BITMAP,
+
鐃緒申��申鐃緒申  RIGHT_TRUNCATION_BITMAP,
+
鐃緒申��申鐃緒申  OVERLAY_ARROW_BITMAP,
+
鐃緒申��申鐃緒申  CONTINUED_LINE_BITMAP,
+
鐃緒申��申鐃緒申  CONTINUATION_LINE_BITMAP,
+
鐃緒申��申鐃緒申  ZV_LINE_BITMAP
+
鐃緒申��申鐃緒申};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Bitmap drawn to indicate lines not displaying text if
+
鐃緒申��申鐃緒申   `indicate-empty-lines' is non-nil.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define zv_width 8
+
鐃緒申��申鐃緒申#define zv_height 8
+
鐃緒申��申鐃緒申static unsigned char zv_bits[] = {
+
鐃緒申��申鐃緒申   0x00, 0x00, 0x1e, 0x1e, 0x1e, 0x1e, 0x00, 0x00};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* An arrow like this: `<-'.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define left_width 8
+
鐃緒申��申鐃緒申#define left_height 8
+
鐃緒申��申鐃緒申static unsigned char left_bits[] = {
+
鐃緒申��申鐃緒申   0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Right truncation arrow bitmap `->'.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define right_width 8
+
鐃緒申��申鐃緒申#define right_height 8
+
鐃緒申��申鐃緒申static unsigned char right_bits[] = {
+
鐃緒申��申鐃緒申   0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Marker for continued lines.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define continued_width 8
+
鐃緒申��申鐃緒申#define continued_height 8
+
鐃緒申��申鐃緒申static unsigned char continued_bits[] = {
+
鐃緒申��申鐃緒申   0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Marker for continuation lines.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define continuation_width 8
+
鐃緒申��申鐃緒申#define continuation_height 8
+
鐃緒申��申鐃緒申static unsigned char continuation_bits[] = {
+
鐃緒申��申鐃緒申   0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Overlay arrow bitmap.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申/* A bomb.  */
+
鐃緒申��申鐃緒申#define ov_width 8
+
鐃緒申��申鐃緒申#define ov_height 8
+
鐃緒申��申鐃緒申static unsigned char ov_bits[] = {
+
鐃緒申��申鐃緒申   0x30, 0x08, 0x3c, 0x7e, 0x7a, 0x7a, 0x62, 0x3c};
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申/* A triangular arrow.  */
+
鐃緒申��申鐃緒申#define ov_width 8
+
鐃緒申��申鐃緒申#define ov_height 8
+
鐃緒申��申鐃緒申static unsigned char ov_bits[] = {
+
鐃緒申��申鐃緒申   0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern Lisp_Object Qhelp_echo;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Non-nil means Emacs uses toolkit scroll bars.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Lisp_Object Vx_toolkit_scroll_bars;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* If a string, XTread_socket generates an event to display that string.
+
鐃緒申��申鐃緒申   (The display is done in read_char.)  */
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申static Lisp_Object help_echo;
+
鐃緒申��申鐃緒申static Lisp_Object help_echo_window;
+
鐃緒申��申鐃緒申static Lisp_Object help_echo_object;
+
鐃緒申��申鐃緒申static int help_echo_pos;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Temporary variable for XTread_socket.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object previous_help_echo;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Non-zero means that a HELP_EVENT has been generated since Emacs
+
鐃緒申��申鐃緒申   start.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int any_help_event_p;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Non-zero means draw block and hollow cursor as wide as the glyph
+
鐃緒申��申鐃緒申   under it.  For example, if a block cursor is over a tab, it will be
+
鐃緒申��申鐃緒申   drawn as wide as that tab on the display.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int x_stretch_cursor_p;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Non-zero means make use of UNDERLINE_POSITION font properties.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int x_use_underline_position_properties;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is a chain of structures for all the X displays currently in
+
鐃緒申��申鐃緒申   use.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct x_display_info *x_display_list;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is a list of cons cells, each of the form (NAME
+
鐃緒申��申鐃緒申   . FONT-LIST-CACHE), one for each element of x_display_list and in
+
鐃緒申��申鐃緒申   the same order.  NAME is the name of the frame.  FONT-LIST-CACHE
+
鐃緒申��申鐃緒申   records previous values returned by x-list-fonts.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Lisp_Object x_display_name_list;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Frame being updated by update_frame.  This is declared in term.c.
+
鐃緒申��申鐃緒申   This is set by update_begin and looked at by all the XT functions.
+
鐃緒申��申鐃緒申   It is zero while not inside an update.  In that case, the XT
+
鐃緒申��申鐃緒申   functions assume that `selected_frame' is the frame to apply to.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern struct frame *updating_frame;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern int waiting_for_input;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is a frame waiting to be auto-raised, within XTread_socket.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct frame *pending_autoraise_frame;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申/* The application context for Xt use.  */
+
鐃緒申��申鐃緒申XtAppContext Xt_app_con;
+
鐃緒申��申鐃緒申static String Xt_default_resources[] = {0};
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Nominal cursor position -- where to draw output.  
+
鐃緒申��申鐃緒申   HPOS and VPOS are window relative glyph matrix coordinates.
+
鐃緒申��申鐃緒申   X and Y are window relative pixel coordinates.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct cursor_pos output_cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Non-zero means user is interacting with a toolkit scroll bar.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int toolkit_scroll_bar_interaction;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Mouse movement.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Formerly, we used PointerMotionHintMask (in standard_event_mask)
+
鐃緒申��申鐃緒申   so that we would have to call XQueryPointer after each MotionNotify
+
鐃緒申��申鐃緒申   event to ask for another such event.  However, this made mouse tracking
+
鐃緒申��申鐃緒申   slow, and there was a bug that made it eventually stop.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Simply asking for MotionNotify all the time seems to work better.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   In order to avoid asking for motion events and then throwing most
+
鐃緒申��申鐃緒申   of them away or busy-polling the server for mouse positions, we ask
+
鐃緒申��申鐃緒申   the server for pointer motion hints.  This means that we get only
+
鐃緒申��申鐃緒申   one event per group of mouse movements.  "Groups" are delimited by
+
鐃緒申��申鐃緒申   other kinds of events (focus changes and button clicks, for
+
鐃緒申��申鐃緒申   example), or by XQueryPointer calls; when one of these happens, we
+
鐃緒申��申鐃緒申   get another MotionNotify event the next time the mouse moves.  This
+
鐃緒申��申鐃緒申   is at least as efficient as getting motion events when mouse
+
鐃緒申��申鐃緒申   tracking is on, and I suspect only negligibly worse when tracking
+
鐃緒申��申鐃緒申   is off.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Where the mouse was last time we reported a mouse event.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申FRAME_PTR last_mouse_frame;
+
鐃緒申��申鐃緒申static XRectangle last_mouse_glyph;
+
鐃緒申��申鐃緒申static Lisp_Object last_mouse_press_frame;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The scroll bar in which the last X motion event occurred.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If the last X motion event occurred in a scroll bar, we set this so
+
鐃緒申��申鐃緒申   XTmouse_position can know whether to report a scroll bar motion or
+
鐃緒申��申鐃緒申   an ordinary motion.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If the last X motion event didn't occur in a scroll bar, we set
+
鐃緒申��申鐃緒申   this to Qnil, to tell XTmouse_position to return an ordinary motion
+
鐃緒申��申鐃緒申   event.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object last_mouse_scroll_bar;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is a hack.  We would really prefer that XTmouse_position would
+
鐃緒申��申鐃緒申   return the time associated with the position it returns, but there
+
鐃緒申��申鐃緒申   doesn't seem to be any way to wrest the time-stamp from the server
+
鐃緒申��申鐃緒申   along with the position query.  So, we just keep track of the time
+
鐃緒申��申鐃緒申   of the last movement we received, and return that in hopes that
+
鐃緒申��申鐃緒申   it's somewhat accurate.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Time last_mouse_movement_time;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Incremented by XTread_socket whenever it really tries to read
+
鐃緒申��申鐃緒申   events.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef __STDC__
+
鐃緒申��申鐃緒申static int volatile input_signal_count;
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申static int input_signal_count;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Used locally within XTread_socket.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int x_noop_count;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Initial values of argv and argc.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern char **initial_argv;
+
鐃緒申��申鐃緒申extern int initial_argc;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern Lisp_Object Vcommand_line_args, Vsystem_name;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Tells if a window manager is present or not.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern Lisp_Object Vx_no_window_manager;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern Lisp_Object Qface, Qmouse_face;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern int errno;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* A mask of extra modifier bits to put into every keyboard char.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern int extra_keyboard_modifiers;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object Qvendor_specific_keysyms;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申extern XrmDatabase x_load_resources P_ ((Display *, char *, char *, char *));
+
鐃緒申��申鐃緒申extern Lisp_Object x_icon_type P_ ((struct frame *));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Enumeration for overriding/changing the face to use for drawing
+
鐃緒申��申鐃緒申   glyphs in x_draw_glyphs.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申enum draw_glyphs_face
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  DRAW_NORMAL_TEXT,
+
鐃緒申��申鐃緒申  DRAW_INVERSE_VIDEO,
+
鐃緒申��申鐃緒申  DRAW_CURSOR,
+
鐃緒申��申鐃緒申  DRAW_MOUSE_FACE,
+
鐃緒申��申鐃緒申  DRAW_IMAGE_RAISED,
+
鐃緒申��申鐃緒申  DRAW_IMAGE_SUNKEN
+
鐃緒申��申鐃緒申};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int clear_mouse_face P_ ((struct x_display_info *));
+
鐃緒申��申鐃緒申static int x_alloc_nearest_color_1 P_ ((Display *, Colormap, XColor *));
+
鐃緒申��申鐃緒申static void x_set_window_size_1 P_ ((struct frame *, int, int, int));
+
鐃緒申��申鐃緒申static const XColor *x_color_cells P_ ((Display *, int *));
+
鐃緒申��申鐃緒申static void x_update_window_end P_ ((struct window *, int, int));
+
鐃緒申��申鐃緒申static void frame_to_window_pixel_xy P_ ((struct window *, int *, int *));
+
鐃緒申��申鐃緒申void x_delete_display P_ ((struct x_display_info *));
+
鐃緒申��申鐃緒申static unsigned int x_x_to_emacs_modifiers P_ ((struct x_display_info *,
+
鐃緒申��申鐃緒申						unsigned));
+
鐃緒申��申鐃緒申static int fast_find_position P_ ((struct window *, int, int *, int *,
+
鐃緒申��申鐃緒申				   int *, int *));
+
鐃緒申��申鐃緒申static int fast_find_string_pos P_ ((struct window *, int, Lisp_Object,
+
鐃緒申��申鐃緒申				     int *, int *, int *, int *, int));
+
鐃緒申��申鐃緒申static void set_output_cursor P_ ((struct cursor_pos *));
+
鐃緒申��申鐃緒申static struct glyph *x_y_to_hpos_vpos P_ ((struct window *, int, int,
+
鐃緒申��申鐃緒申					   int *, int *, int *, int));
+
鐃緒申��申鐃緒申static void note_mode_line_highlight P_ ((struct window *, int, int));
+
鐃緒申��申鐃緒申static void note_mouse_highlight P_ ((struct frame *, int, int));
+
鐃緒申��申鐃緒申static void note_tool_bar_highlight P_ ((struct frame *f, int, int));
+
鐃緒申��申鐃緒申static void x_handle_tool_bar_click P_ ((struct frame *, XButtonEvent *));
+
鐃緒申��申鐃緒申static void show_mouse_face P_ ((struct x_display_info *,
+
鐃緒申��申鐃緒申				 enum draw_glyphs_face));
+
鐃緒申��申鐃緒申static int x_io_error_quitter P_ ((Display *));
+
鐃緒申��申鐃緒申int x_catch_errors P_ ((Display *));
+
鐃緒申��申鐃緒申void x_uncatch_errors P_ ((Display *, int));
+
鐃緒申��申鐃緒申void x_lower_frame P_ ((struct frame *));
+
鐃緒申��申鐃緒申void x_scroll_bar_clear P_ ((struct frame *));
+
鐃緒申��申鐃緒申int x_had_errors_p P_ ((Display *));
+
鐃緒申��申鐃緒申void x_wm_set_size_hint P_ ((struct frame *, long, int));
+
鐃緒申��申鐃緒申void x_raise_frame P_ ((struct frame *));
+
鐃緒申��申鐃緒申void x_set_window_size P_ ((struct frame *, int, int, int));
+
鐃緒申��申鐃緒申void x_wm_set_window_state P_ ((struct frame *, int));
+
鐃緒申��申鐃緒申void x_wm_set_icon_pixmap P_ ((struct frame *, int));
+
鐃緒申��申鐃緒申void x_initialize P_ ((void));
+
鐃緒申��申鐃緒申static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
+
鐃緒申��申鐃緒申static int x_compute_min_glyph_bounds P_ ((struct frame *));
+
鐃緒申��申鐃緒申static void x_draw_phys_cursor_glyph P_ ((struct window *,
+
鐃緒申��申鐃緒申					  struct glyph_row *,
+
鐃緒申��申鐃緒申					  enum draw_glyphs_face));
+
鐃緒申��申鐃緒申static void x_update_end P_ ((struct frame *));
+
鐃緒申��申鐃緒申static void XTframe_up_to_date P_ ((struct frame *));
+
鐃緒申��申鐃緒申static void XTreassert_line_highlight P_ ((int, int));
+
鐃緒申��申鐃緒申static void x_change_line_highlight P_ ((int, int, int, int));
+
鐃緒申��申鐃緒申static void XTset_terminal_modes P_ ((void));
+
鐃緒申��申鐃緒申static void XTreset_terminal_modes P_ ((void));
+
鐃緒申��申鐃緒申static void XTcursor_to P_ ((int, int, int, int));
+
鐃緒申��申鐃緒申static void x_write_glyphs P_ ((struct glyph *, int));
+
鐃緒申��申鐃緒申static void x_clear_end_of_line P_ ((int));
+
鐃緒申��申鐃緒申static void x_clear_frame P_ ((void));
+
鐃緒申��申鐃緒申static void x_clear_cursor P_ ((struct window *));
+
鐃緒申��申鐃緒申static void frame_highlight P_ ((struct frame *));
+
鐃緒申��申鐃緒申static void frame_unhighlight P_ ((struct frame *));
+
鐃緒申��申鐃緒申static void x_new_focus_frame P_ ((struct x_display_info *, struct frame *));
+
鐃緒申��申鐃緒申static void XTframe_rehighlight P_ ((struct frame *));
+
鐃緒申��申鐃緒申static void x_frame_rehighlight P_ ((struct x_display_info *));
+
鐃緒申��申鐃緒申static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
+
鐃緒申��申鐃緒申static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int));
+
鐃緒申��申鐃緒申static int x_intersect_rectangles P_ ((XRectangle *, XRectangle *,
+
鐃緒申��申鐃緒申				       XRectangle *));
+
鐃緒申��申鐃緒申static void expose_frame P_ ((struct frame *, int, int, int, int));
+
鐃緒申��申鐃緒申static void expose_window_tree P_ ((struct window *, XRectangle *));
+
鐃緒申��申鐃緒申static int expose_window P_ ((struct window *, XRectangle *));
+
鐃緒申��申鐃緒申static void expose_area P_ ((struct window *, struct glyph_row *,
+
鐃緒申��申鐃緒申			     XRectangle *, enum glyph_row_area));
+
鐃緒申��申鐃緒申static void expose_line P_ ((struct window *, struct glyph_row *,
+
鐃緒申��申鐃緒申			     XRectangle *));
+
鐃緒申��申鐃緒申static void x_update_cursor_in_window_tree P_ ((struct window *, int));
+
鐃緒申��申鐃緒申static void x_update_window_cursor P_ ((struct window *, int));
+
鐃緒申��申鐃緒申static void x_erase_phys_cursor P_ ((struct window *));
+
鐃緒申��申鐃緒申void x_display_and_set_cursor P_ ((struct window *, int, int, int, int, int));
+
鐃緒申��申鐃緒申static void x_draw_bitmap P_ ((struct window *, struct glyph_row *, 
+
鐃緒申��申鐃緒申			       enum bitmap_type));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void x_clip_to_row P_ ((struct window *, struct glyph_row *,
+
鐃緒申��申鐃緒申			       GC, int));
+
鐃緒申��申鐃緒申static int x_phys_cursor_in_rect_p P_ ((struct window *, XRectangle *));
+
鐃緒申��申鐃緒申static void x_draw_row_bitmaps P_ ((struct window *, struct glyph_row *));
+
鐃緒申��申鐃緒申static void note_overwritten_text_cursor P_ ((struct window *, int, int));
+
鐃緒申��申鐃緒申static void x_flush P_ ((struct frame *f));
+
鐃緒申��申鐃緒申static void x_update_begin P_ ((struct frame *));
+
鐃緒申��申鐃緒申static void x_update_window_begin P_ ((struct window *));
+
鐃緒申��申鐃緒申static void x_draw_vertical_border P_ ((struct window *));
+
鐃緒申��申鐃緒申static void x_after_update_window_line P_ ((struct glyph_row *));
+
鐃緒申��申鐃緒申static INLINE void take_vertical_position_into_account P_ ((struct it *));
+
鐃緒申��申鐃緒申static void x_produce_stretch_glyph P_ ((struct it *));
+
鐃緒申��申鐃緒申static struct scroll_bar *x_window_to_scroll_bar P_ ((Window));
+
鐃緒申��申鐃緒申static void x_scroll_bar_report_motion P_ ((struct frame **, Lisp_Object *,
+
鐃緒申��申鐃緒申					    enum scroll_bar_part *,
+
鐃緒申��申鐃緒申					    Lisp_Object *, Lisp_Object *,
+
鐃緒申��申鐃緒申					    unsigned long *));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Flush display of frame F, or of all frames if F is null.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_flush (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  if (f == NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object rest, frame;
+
鐃緒申��申鐃緒申      FOR_EACH_FRAME (rest, frame)
+
鐃緒申��申鐃緒申	x_flush (XFRAME (frame));
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (FRAME_X_P (f))
+
鐃緒申��申鐃緒申    XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Remove calls to XFlush by defining XFlush to an empty replacement.
+
鐃緒申��申鐃緒申   Calls to XFlush should be unnecessary because the X output buffer
+
鐃緒申��申鐃緒申   is flushed automatically as needed by calls to XPending,
+
鐃緒申��申鐃緒申   XNextEvent, or XWindowEvent according to the XFlush man page.
+
鐃緒申��申鐃緒申   XTread_socket calls XPending.  Removing XFlush improves
+
鐃緒申��申鐃緒申   performance.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define XFlush(DISPLAY)	(void) 0 
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			      Debugging
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is a function useful for recording debugging information about
+
鐃緒申��申鐃緒申   the sequence of occurrences in this file.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct record 
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  char *locus;
+
鐃緒申��申鐃緒申  int type;
+
鐃緒申��申鐃緒申};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct record event_record[100];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int event_record_index;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申record_event (locus, type)
+
鐃緒申��申鐃緒申     char *locus;
+
鐃緒申��申鐃緒申     int type;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (event_record_index == sizeof (event_record) / sizeof (struct record))
+
鐃緒申��申鐃緒申    event_record_index = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  event_record[event_record_index].locus = locus;
+
鐃緒申��申鐃緒申  event_record[event_record_index].type = type;
+
鐃緒申��申鐃緒申  event_record_index++;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* 0 */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return the struct x_display_info corresponding to DPY.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct x_display_info *
+
鐃緒申��申鐃緒申x_display_info_for_display (dpy)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
+
鐃緒申��申鐃緒申    if (dpyinfo->display == dpy)
+
鐃緒申��申鐃緒申      return dpyinfo;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申		    Starting and ending an update
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申									
+
鐃緒申��申鐃緒申/* Start an update of frame F.  This function is installed as a hook
+
鐃緒申��申鐃緒申   for update_begin, i.e. it is called when update_begin is called.
+
鐃緒申��申鐃緒申   This function is called prior to calls to x_update_window_begin for
+
鐃緒申��申鐃緒申   each window being updated.  Currently, there is nothing to do here
+
鐃緒申��申鐃緒申   because all interesting stuff is done on a window basis.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_update_begin (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Nothing to do.  */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Start update of window W.  Set the global variable updated_window
+
鐃緒申��申鐃緒申   to the window being updated and set output_cursor to the cursor
+
鐃緒申��申鐃緒申   position of W.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_update_window_begin (w)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (WINDOW_FRAME (w));
+
鐃緒申��申鐃緒申  struct x_display_info *display_info = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  updated_window = w;
+
鐃緒申��申鐃緒申  set_output_cursor (&w->cursor);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (f == display_info->mouse_face_mouse_frame)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Don't do highlighting for mouse motion during the update.  */
+
鐃緒申��申鐃緒申      display_info->mouse_face_defer = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* If F needs to be redrawn, simply forget about any prior mouse
+
鐃緒申��申鐃緒申	 highlighting.  */
+
鐃緒申��申鐃緒申      if (FRAME_GARBAGED_P (f))
+
鐃緒申��申鐃緒申	display_info->mouse_face_window = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if 0 /* Rows in a current matrix containing glyphs in mouse-face have
+
鐃緒申��申鐃緒申	 their mouse_face_p flag set, which means that they are always
+
鐃緒申��申鐃緒申	 unequal to rows in a desired matrix which never have that
+
鐃緒申��申鐃緒申	 flag set.  So, rows containing mouse-face glyphs are never
+
鐃緒申��申鐃緒申	 scrolled, and we don't have to switch the mouse highlight off
+
鐃緒申��申鐃緒申	 here to prevent it from being scrolled.  */
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Can we tell that this update does not affect the window
+
鐃緒申��申鐃緒申	 where the mouse highlight is?  If so, no need to turn off.
+
鐃緒申��申鐃緒申	 Likewise, don't do anything if the frame is garbaged;
+
鐃緒申��申鐃緒申	 in that case, the frame's current matrix that we would use
+
鐃緒申��申鐃緒申	 is all wrong, and we will redisplay that line anyway.  */
+
鐃緒申��申鐃緒申      if (!NILP (display_info->mouse_face_window)
+
鐃緒申��申鐃緒申	  && w == XWINDOW (display_info->mouse_face_window))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  for (i = 0; i < w->desired_matrix->nrows; ++i)
+
鐃緒申��申鐃緒申	    if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (i < w->desired_matrix->nrows)
+
鐃緒申��申鐃緒申	    clear_mouse_face (display_info);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申#endif /* 0 */
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw a vertical window border to the right of window W if W doesn't
+
鐃緒申��申鐃緒申   have vertical scroll bars.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_vertical_border (w)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (WINDOW_FRAME (w));
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Redraw borders between horizontally adjacent windows.  Don't
+
鐃緒申��申鐃緒申     do it for frames with vertical scroll bars because either the
+
鐃緒申��申鐃緒申     right scroll bar of a window, or the left scroll bar of its
+
鐃緒申��申鐃緒申     neighbor will suffice as a border.  */
+
鐃緒申��申鐃緒申  if (!WINDOW_RIGHTMOST_P (w)
+
鐃緒申��申鐃緒申      && !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int x0, x1, y0, y1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      window_box_edges (w, -1, &x0, &y0, &x1, &y1);
+
鐃緒申��申鐃緒申      x1 += FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f);
+
鐃緒申��申鐃緒申      y1 -= 1;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 
+
鐃緒申��申鐃緒申		 f->output_data.x->normal_gc, x1, y0, x1, y1);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申/* End update of window W (which is equal to updated_window).
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Draw vertical borders between horizontally adjacent windows, and
+
鐃緒申��申鐃緒申   display W's cursor if CURSOR_ON_P is non-zero.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
+
鐃緒申��申鐃緒申   glyphs in mouse-face were overwritten.  In that case we have to
+
鐃緒申��申鐃緒申   make sure that the mouse-highlight is properly redrawn.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   W may be a menu bar pseudo-window in case we don't have X toolkit
+
鐃緒申��申鐃緒申   support.  Such windows don't have a cursor, so don't display it
+
鐃緒申��申鐃緒申   here.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int cursor_on_p, mouse_face_overwritten_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申  if (!w->pseudo_window_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (cursor_on_p)
+
鐃緒申��申鐃緒申	x_display_and_set_cursor (w, 1, output_cursor.hpos,
+
鐃緒申��申鐃緒申				  output_cursor.vpos,
+
鐃緒申��申鐃緒申				  output_cursor.x, output_cursor.y);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      x_draw_vertical_border (w);
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* If a row with mouse-face was overwritten, arrange for
+
鐃緒申��申鐃緒申     XTframe_up_to_date to redisplay the mouse highlight.  */
+
鐃緒申��申鐃緒申  if (mouse_face_overwritten_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_window = Qnil;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申  updated_window = NULL;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* End update of frame F.  This function is installed as a hook in
+
鐃緒申��申鐃緒申   update_end.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_update_end (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Mouse highlight may be displayed again.  */
+
鐃緒申��申鐃緒申  FRAME_X_DISPLAY_INFO (f)->mouse_face_defer = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This function is called from various places in xdisp.c whenever a
+
鐃緒申��申鐃緒申   complete update has been performed.  The global variable
+
鐃緒申��申鐃緒申   updated_window is not available here.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTframe_up_to_date (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (FRAME_X_P (f))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (dpyinfo->mouse_face_deferred_gc
+
鐃緒申��申鐃緒申	  || f == dpyinfo->mouse_face_mouse_frame)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  BLOCK_INPUT;
+
鐃緒申��申鐃緒申	  if (dpyinfo->mouse_face_mouse_frame)
+
鐃緒申��申鐃緒申	    note_mouse_highlight (dpyinfo->mouse_face_mouse_frame,
+
鐃緒申��申鐃緒申				  dpyinfo->mouse_face_mouse_x,
+
鐃緒申��申鐃緒申				  dpyinfo->mouse_face_mouse_y);
+
鐃緒申��申鐃緒申	  dpyinfo->mouse_face_deferred_gc = 0;
+
鐃緒申��申鐃緒申	  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
+
鐃緒申��申鐃緒申   arrow bitmaps, or clear the areas where they would be displayed
+
鐃緒申��申鐃緒申   before DESIRED_ROW is made current.  The window being updated is
+
鐃緒申��申鐃緒申   found in updated_window.  This function It is called from
+
鐃緒申��申鐃緒申   update_window_line only if it is known that there are differences
+
鐃緒申��申鐃緒申   between bitmaps to be drawn between current row and DESIRED_ROW.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_after_update_window_line (desired_row)
+
鐃緒申��申鐃緒申     struct glyph_row *desired_row;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct window *w = updated_window;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  xassert (w);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (!desired_row->mode_line_p && !w->pseudo_window_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct frame *f;
+
鐃緒申��申鐃緒申      int width;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申      x_draw_row_bitmaps (w, desired_row);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* When a window has disappeared, make sure that no rest of
+
鐃緒申��申鐃緒申	 full-width rows stays visible in the internal border.  */
+
鐃緒申��申鐃緒申      if (windows_or_buffers_changed
+
鐃緒申��申鐃緒申	  && (f = XFRAME (w->frame),
+
鐃緒申��申鐃緒申	      width = FRAME_INTERNAL_BORDER_WIDTH (f),
+
鐃緒申��申鐃緒申	      width != 0))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int height = desired_row->visible_height;
+
鐃緒申��申鐃緒申	  int x = (window_box_right (w, -1)
+
鐃緒申��申鐃緒申		   + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f));
+
鐃緒申��申鐃緒申	  int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申			x, y, width, height, False);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw the bitmap WHICH in one of the areas to the left or right of
+
鐃緒申��申鐃緒申   window W.  ROW is the glyph row for which to display the bitmap; it
+
鐃緒申��申鐃緒申   determines the vertical position at which the bitmap has to be
+
鐃緒申��申鐃緒申   drawn.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_bitmap (w, row, which)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     enum bitmap_type which;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (WINDOW_FRAME (w));
+
鐃緒申��申鐃緒申  Display *display = FRAME_X_DISPLAY (f);
+
鐃緒申��申鐃緒申  Window window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申  int x, y, wd, h, dy;
+
鐃緒申��申鐃緒申  unsigned char *bits;
+
鐃緒申��申鐃緒申  Pixmap pixmap;
+
鐃緒申��申鐃緒申  GC gc = f->output_data.x->normal_gc;
+
鐃緒申��申鐃緒申  struct face *face;
+
鐃緒申��申鐃緒申  int depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Must clip because of partially visible lines.  */
+
鐃緒申��申鐃緒申  x_clip_to_row (w, row, gc, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  switch (which)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申    case LEFT_TRUNCATION_BITMAP:
+
鐃緒申��申鐃緒申      wd = left_width;
+
鐃緒申��申鐃緒申      h = left_height;
+
鐃緒申��申鐃緒申      bits = left_bits;
+
鐃緒申��申鐃緒申      x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
+
鐃緒申��申鐃緒申	   - wd
+
鐃緒申��申鐃緒申	   - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申    case OVERLAY_ARROW_BITMAP:
+
鐃緒申��申鐃緒申      wd = left_width;
+
鐃緒申��申鐃緒申      h = left_height;
+
鐃緒申��申鐃緒申      bits = ov_bits;
+
鐃緒申��申鐃緒申      x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
+
鐃緒申��申鐃緒申	   - wd
+
鐃緒申��申鐃緒申	   - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申    case RIGHT_TRUNCATION_BITMAP:
+
鐃緒申��申鐃緒申      wd = right_width;
+
鐃緒申��申鐃緒申      h = right_height;
+
鐃緒申��申鐃緒申      bits = right_bits;
+
鐃緒申��申鐃緒申      x = window_box_right (w, -1);
+
鐃緒申��申鐃緒申      x += (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f) - wd) / 2;
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case CONTINUED_LINE_BITMAP:
+
鐃緒申��申鐃緒申      wd = right_width;
+
鐃緒申��申鐃緒申      h = right_height;
+
鐃緒申��申鐃緒申      bits = continued_bits;
+
鐃緒申��申鐃緒申      x = window_box_right (w, -1);
+
鐃緒申��申鐃緒申      x += (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f) - wd) / 2;
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申    case CONTINUATION_LINE_BITMAP:
+
鐃緒申��申鐃緒申      wd = continuation_width;
+
鐃緒申��申鐃緒申      h = continuation_height;
+
鐃緒申��申鐃緒申      bits = continuation_bits;
+
鐃緒申��申鐃緒申      x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
+
鐃緒申��申鐃緒申	   - wd
+
鐃緒申��申鐃緒申	   - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case ZV_LINE_BITMAP:
+
鐃緒申��申鐃緒申      wd = zv_width;
+
鐃緒申��申鐃緒申      h = zv_height;
+
鐃緒申��申鐃緒申      bits = zv_bits;
+
鐃緒申��申鐃緒申      x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
+
鐃緒申��申鐃緒申	   - wd
+
鐃緒申��申鐃緒申	   - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    default:
+
鐃緒申��申鐃緒申      abort ();
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Convert to frame coordinates.  Set dy to the offset in the row to
+
鐃緒申��申鐃緒申     start drawing the bitmap.  */
+
鐃緒申��申鐃緒申  y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
+
鐃緒申��申鐃緒申  dy = (row->height - h) / 2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Draw the bitmap.  I believe these small pixmaps can be cached
+
鐃緒申��申鐃緒申     by the server.  */
+
鐃緒申��申鐃緒申  face = FACE_FROM_ID (f, BITMAP_AREA_FACE_ID);
+
鐃緒申��申鐃緒申  pixmap = XCreatePixmapFromBitmapData (display, window, bits, wd, h,
+
鐃緒申��申鐃緒申					face->foreground,
+
鐃緒申��申鐃緒申					face->background, depth);
+
鐃緒申��申鐃緒申  XCopyArea (display, pixmap, window, gc, 0, 0, wd, h, x, y + dy);
+
鐃緒申��申鐃緒申  XFreePixmap (display, pixmap);
+
鐃緒申��申鐃緒申  XSetClipMask (display, gc, None);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw flags bitmaps for glyph row ROW on window W.  Call this
+
鐃緒申��申鐃緒申   function with input blocked.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_row_bitmaps (w, row)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  enum bitmap_type bitmap;
+
鐃緒申��申鐃緒申  struct face *face;
+
鐃緒申��申鐃緒申  int header_line_height = -1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (interrupt_input_blocked);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If row is completely invisible, because of vscrolling, we
+
鐃緒申��申鐃緒申     don't have to draw anything.  */
+
鐃緒申��申鐃緒申  if (row->visible_height <= 0)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  face = FACE_FROM_ID (f, BITMAP_AREA_FACE_ID);
+
鐃緒申��申鐃緒申  PREPARE_FACE_FOR_DISPLAY (f, face);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Decide which bitmap to draw at the left side.  */
+
鐃緒申��申鐃緒申  if (row->overlay_arrow_p)
+
鐃緒申��申鐃緒申    bitmap = OVERLAY_ARROW_BITMAP;
+
鐃緒申��申鐃緒申  else if (row->truncated_on_left_p)
+
鐃緒申��申鐃緒申    bitmap = LEFT_TRUNCATION_BITMAP;
+
鐃緒申��申鐃緒申  else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
+
鐃緒申��申鐃緒申    bitmap = CONTINUATION_LINE_BITMAP;
+
鐃緒申��申鐃緒申  else if (row->indicate_empty_line_p)
+
鐃緒申��申鐃緒申    bitmap = ZV_LINE_BITMAP;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    bitmap = NO_BITMAP;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Clear flags area if no bitmap to draw or if bitmap doesn't fill
+
鐃緒申��申鐃緒申     the flags area.  */
+
鐃緒申��申鐃緒申  if (bitmap == NO_BITMAP
+
鐃緒申��申鐃緒申      || FRAME_FLAGS_BITMAP_WIDTH (f) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f)
+
鐃緒申��申鐃緒申      || row->height > FRAME_FLAGS_BITMAP_HEIGHT (f))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* If W has a vertical border to its left, don't draw over it.  */
+
鐃緒申��申鐃緒申      int border = ((XFASTINT (w->left) > 0
+
鐃緒申��申鐃緒申		     && !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+
鐃緒申��申鐃緒申		    ? 1 : 0);
+
鐃緒申��申鐃緒申      int left = window_box_left (w, -1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (header_line_height < 0)
+
鐃緒申��申鐃緒申	header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* In case the same realized face is used for bitmap areas and
+
鐃緒申��申鐃緒申	 for something displayed in the text (e.g. face `region' on
+
鐃緒申��申鐃緒申	 mono-displays, the fill style may have been changed to
+
鐃緒申��申鐃緒申	 FillSolid in x_draw_glyph_string_background.  */
+
鐃緒申��申鐃緒申      if (face->stipple)
+
鐃緒申��申鐃緒申	XSetFillStyle (FRAME_X_DISPLAY (f), face->gc, FillOpaqueStippled);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->background);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		      face->gc,
+
鐃緒申��申鐃緒申		      (left
+
鐃緒申��申鐃緒申		       - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f)
+
鐃緒申��申鐃緒申		       + border),
+
鐃緒申��申鐃緒申		      WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
+
鐃緒申��申鐃緒申						       row->y)),
+
鐃緒申��申鐃緒申		      FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - border,
+
鐃緒申��申鐃緒申		      row->visible_height);
+
鐃緒申��申鐃緒申      if (!face->stipple)
+
鐃緒申��申鐃緒申	XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Draw the left bitmap.  */
+
鐃緒申��申鐃緒申  if (bitmap != NO_BITMAP)
+
鐃緒申��申鐃緒申    x_draw_bitmap (w, row, bitmap);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Decide which bitmap to draw at the right side.  */
+
鐃緒申��申鐃緒申  if (row->truncated_on_right_p)
+
鐃緒申��申鐃緒申    bitmap = RIGHT_TRUNCATION_BITMAP;
+
鐃緒申��申鐃緒申  else if (row->continued_p)
+
鐃緒申��申鐃緒申    bitmap = CONTINUED_LINE_BITMAP;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    bitmap = NO_BITMAP;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Clear flags area if no bitmap to draw of if bitmap doesn't fill
+
鐃緒申��申鐃緒申     the flags area.  */
+
鐃緒申��申鐃緒申  if (bitmap == NO_BITMAP
+
鐃緒申��申鐃緒申      || FRAME_FLAGS_BITMAP_WIDTH (f) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f)
+
鐃緒申��申鐃緒申      || row->height > FRAME_FLAGS_BITMAP_HEIGHT (f))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int right = window_box_right (w, -1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (header_line_height < 0)
+
鐃緒申��申鐃緒申	header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* In case the same realized face is used for bitmap areas and
+
鐃緒申��申鐃緒申	 for something displayed in the text (e.g. face `region' on
+
鐃緒申��申鐃緒申	 mono-displays, the fill style may have been changed to
+
鐃緒申��申鐃緒申	 FillSolid in x_draw_glyph_string_background.  */
+
鐃緒申��申鐃緒申      if (face->stipple)
+
鐃緒申��申鐃緒申	XSetFillStyle (FRAME_X_DISPLAY (f), face->gc, FillOpaqueStippled);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->background);
+
鐃緒申��申鐃緒申      XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		      face->gc,
+
鐃緒申��申鐃緒申		      right,
+
鐃緒申��申鐃緒申		      WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
+
鐃緒申��申鐃緒申						       row->y)),
+
鐃緒申��申鐃緒申		      FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f),
+
鐃緒申��申鐃緒申		      row->visible_height);
+
鐃緒申��申鐃緒申      if (!face->stipple)
+
鐃緒申��申鐃緒申	XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Draw the right bitmap.  */
+
鐃緒申��申鐃緒申  if (bitmap != NO_BITMAP)
+
鐃緒申��申鐃緒申    x_draw_bitmap (w, row, bitmap);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			  Line Highlighting
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* External interface to control of standout mode.  Not used for X
+
鐃緒申��申鐃緒申   frames.  Aborts when called.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTreassert_line_highlight (new, vpos)
+
鐃緒申��申鐃緒申     int new, vpos;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  abort ();
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Call this when about to modify line at position VPOS and change
+
鐃緒申��申鐃緒申   whether it is highlighted.  Not used for X frames.  Aborts when
+
鐃緒申��申鐃緒申   called.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_change_line_highlight (new_highlight, vpos, y, first_unused_hpos)
+
鐃緒申��申鐃緒申     int new_highlight, vpos, y, first_unused_hpos;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  abort ();
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is called when starting Emacs and when restarting after
+
鐃緒申��申鐃緒申   suspend.  When starting Emacs, no X window is mapped.  And nothing
+
鐃緒申��申鐃緒申   must be done to Emacs's own window if it is suspended (though that
+
鐃緒申��申鐃緒申   rarely happens).  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTset_terminal_modes ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is called when exiting or suspending Emacs.  Exiting will make
+
鐃緒申��申鐃緒申   the X-windows go away, and suspending requires no action.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTreset_terminal_modes ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			    Output Cursor
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set the global variable output_cursor to CURSOR.  All cursor
+
鐃緒申��申鐃緒申   positions are relative to updated_window.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申set_output_cursor (cursor)
+
鐃緒申��申鐃緒申    struct cursor_pos *cursor;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  output_cursor.hpos = cursor->hpos;
+
鐃緒申��申鐃緒申  output_cursor.vpos = cursor->vpos;
+
鐃緒申��申鐃緒申  output_cursor.x = cursor->x;
+
鐃緒申��申鐃緒申  output_cursor.y = cursor->y;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set a nominal cursor position.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   HPOS and VPOS are column/row positions in a window glyph matrix.  X
+
鐃緒申��申鐃緒申   and Y are window text area relative pixel positions.
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申   If this is done during an update, updated_window will contain the
+
鐃緒申��申鐃緒申   window that is being updated and the position is the future output
+
鐃緒申��申鐃緒申   cursor position for that window.  If updated_window is null, use
+
鐃緒申��申鐃緒申   selected_window and display the cursor at the given position.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTcursor_to (vpos, hpos, y, x)
+
鐃緒申��申鐃緒申     int vpos, hpos, y, x;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct window *w;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If updated_window is not set, work on selected_window.  */
+
鐃緒申��申鐃緒申  if (updated_window)
+
鐃緒申��申鐃緒申    w = updated_window;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    w = XWINDOW (selected_window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Set the output cursor.  */
+
鐃緒申��申鐃緒申  output_cursor.hpos = hpos;
+
鐃緒申��申鐃緒申  output_cursor.vpos = vpos;
+
鐃緒申��申鐃緒申  output_cursor.x = x;
+
鐃緒申��申鐃緒申  output_cursor.y = y;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If not called as part of an update, really display the cursor.
+
鐃緒申��申鐃緒申     This will also set the cursor position of W.  */
+
鐃緒申��申鐃緒申  if (updated_window == NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申      x_display_cursor (w, 1, hpos, vpos, x, y);
+
鐃緒申��申鐃緒申      XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			   Display Iterator
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Function prototypes of this page.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct face *x_get_glyph_face_and_encoding P_ ((struct frame *,
+
鐃緒申��申鐃緒申						       struct glyph *,
+
鐃緒申��申鐃緒申						       XChar2b *,
+
鐃緒申��申鐃緒申						       int *));
+
鐃緒申��申鐃緒申static struct face *x_get_char_face_and_encoding P_ ((struct frame *, int,
+
鐃緒申��申鐃緒申						      int, XChar2b *, int));
+
鐃緒申��申鐃緒申static XCharStruct *x_per_char_metric P_ ((XFontStruct *, XChar2b *));
+
鐃緒申��申鐃緒申static void x_encode_char P_ ((int, XChar2b *, struct font_info *));
+
鐃緒申��申鐃緒申static void x_append_glyph P_ ((struct it *));
+
鐃緒申��申鐃緒申static void x_append_composite_glyph P_ ((struct it *));
+
鐃緒申��申鐃緒申static void x_append_stretch_glyph P_ ((struct it *it, Lisp_Object,
+
鐃緒申��申鐃緒申					int, int, double));
+
鐃緒申��申鐃緒申static void x_produce_glyphs P_ ((struct it *));
+
鐃緒申��申鐃緒申static void x_produce_image_glyph P_ ((struct it *it));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Get metrics of character CHAR2B in FONT.  Value is null if CHAR2B
+
鐃緒申��申鐃緒申   is not contained in the font.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE XCharStruct *
+
鐃緒申��申鐃緒申x_per_char_metric (font, char2b)
+
鐃緒申��申鐃緒申     XFontStruct *font;
+
鐃緒申��申鐃緒申     XChar2b *char2b;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* The result metric information.  */
+
鐃緒申��申鐃緒申  XCharStruct *pcm = NULL;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (font && char2b);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (font->per_char != NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (font->min_byte1 == 0 && font->max_byte1 == 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* min_char_or_byte2 specifies the linear character index
+
鐃緒申��申鐃緒申	     corresponding to the first element of the per_char array,
+
鐃緒申��申鐃緒申	     max_char_or_byte2 is the index of the last character.  A
+
鐃緒申��申鐃緒申	     character with non-zero CHAR2B->byte1 is not in the font.
+
鐃緒申��申鐃緒申	     A character with byte2 less than min_char_or_byte2 or
+
鐃緒申��申鐃緒申	     greater max_char_or_byte2 is not in the font.  */
+
鐃緒申��申鐃緒申	  if (char2b->byte1 == 0
+
鐃緒申��申鐃緒申	      && char2b->byte2 >= font->min_char_or_byte2
+
鐃緒申��申鐃緒申	      && char2b->byte2 <= font->max_char_or_byte2)
+
鐃緒申��申鐃緒申	    pcm = font->per_char + char2b->byte2 - font->min_char_or_byte2;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* If either min_byte1 or max_byte1 are nonzero, both
+
鐃緒申��申鐃緒申	     min_char_or_byte2 and max_char_or_byte2 are less than
+
鐃緒申��申鐃緒申	     256, and the 2-byte character index values corresponding
+
鐃緒申��申鐃緒申	     to the per_char array element N (counting from 0) are:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	     byte1 = N/D + min_byte1
+
鐃緒申��申鐃緒申	     byte2 = N\D + min_char_or_byte2
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	     where:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	     D = max_char_or_byte2 - min_char_or_byte2 + 1
+
鐃緒申��申鐃緒申	     / = integer division
+
鐃緒申��申鐃緒申	     \ = integer modulus  */
+
鐃緒申��申鐃緒申	  if (char2b->byte1 >= font->min_byte1
+
鐃緒申��申鐃緒申	      && char2b->byte1 <= font->max_byte1
+
鐃緒申��申鐃緒申	      && char2b->byte2 >= font->min_char_or_byte2
+
鐃緒申��申鐃緒申	      && char2b->byte2 <= font->max_char_or_byte2)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      pcm = (font->per_char
+
鐃緒申��申鐃緒申		     + ((font->max_char_or_byte2 - font->min_char_or_byte2 + 1)
+
鐃緒申��申鐃緒申			* (char2b->byte1 - font->min_byte1))
+
鐃緒申��申鐃緒申		     + (char2b->byte2 - font->min_char_or_byte2));
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* If the per_char pointer is null, all glyphs between the first
+
鐃緒申��申鐃緒申	 and last character indexes inclusive have the same
+
鐃緒申��申鐃緒申	 information, as given by both min_bounds and max_bounds.  */
+
鐃緒申��申鐃緒申      if (char2b->byte2 >= font->min_char_or_byte2
+
鐃緒申��申鐃緒申	  && char2b->byte2 <= font->max_char_or_byte2)
+
鐃緒申��申鐃緒申	pcm = &font->max_bounds;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return ((pcm == NULL
+
鐃緒申��申鐃緒申	   || (pcm->width == 0 && (pcm->rbearing - pcm->lbearing) == 0))
+
鐃緒申��申鐃緒申	  ? NULL : pcm);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Encode CHAR2B using encoding information from FONT_INFO.  CHAR2B is
+
鐃緒申��申鐃緒申   the two-byte form of C.  Encoding is returned in *CHAR2B.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_encode_char (c, char2b, font_info)
+
鐃緒申��申鐃緒申     int c;
+
鐃緒申��申鐃緒申     XChar2b *char2b;
+
鐃緒申��申鐃緒申     struct font_info *font_info;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int charset = CHAR_CHARSET (c);
+
鐃緒申��申鐃緒申  XFontStruct *font = font_info->font;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
+
鐃緒申��申鐃緒申     This may be either a program in a special encoder language or a
+
鐃緒申��申鐃緒申     fixed encoding.  */
+
鐃緒申��申鐃緒申  if (font_info->font_encoder)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* It's a program.  */
+
鐃緒申��申鐃緒申      struct ccl_program *ccl = font_info->font_encoder;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (CHARSET_DIMENSION (charset) == 1)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  ccl->reg[0] = charset;
+
鐃緒申��申鐃緒申	  ccl->reg[1] = char2b->byte2;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  ccl->reg[0] = charset;
+
鐃緒申��申鐃緒申	  ccl->reg[1] = char2b->byte1;
+
鐃緒申��申鐃緒申	  ccl->reg[2] = char2b->byte2;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      ccl_driver (ccl, NULL, NULL, 0, 0, NULL);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* We assume that MSBs are appropriately set/reset by CCL
+
鐃緒申��申鐃緒申	 program.  */
+
鐃緒申��申鐃緒申      if (font->max_byte1 == 0)	/* 1-byte font */
+
鐃緒申��申鐃緒申	char2b->byte1 = 0, char2b->byte2 = ccl->reg[1];
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	char2b->byte1 = ccl->reg[1], char2b->byte2 = ccl->reg[2];
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (font_info->encoding[charset])
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Fixed encoding scheme.  See fontset.h for the meaning of the
+
鐃緒申��申鐃緒申	 encoding numbers.  */
+
鐃緒申��申鐃緒申      int enc = font_info->encoding[charset];
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if ((enc == 1 || enc == 2)
+
鐃緒申��申鐃緒申	  && CHARSET_DIMENSION (charset) == 2)
+
鐃緒申��申鐃緒申	char2b->byte1 |= 0x80;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if (enc == 1 || enc == 3)
+
鐃緒申��申鐃緒申	char2b->byte2 |= 0x80;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Get face and two-byte form of character C in face FACE_ID on frame
+
鐃緒申��申鐃緒申   F.  The encoding of C is returned in *CHAR2B.  MULTIBYTE_P non-zero
+
鐃緒申��申鐃緒申   means we want to display multibyte text.  Value is a pointer to a
+
鐃緒申��申鐃緒申   realized face that is ready for display.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE struct face *
+
鐃緒申��申鐃緒申x_get_char_face_and_encoding (f, c, face_id, char2b, multibyte_p)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int c, face_id;
+
鐃緒申��申鐃緒申     XChar2b *char2b;
+
鐃緒申��申鐃緒申     int multibyte_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct face *face = FACE_FROM_ID (f, face_id);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!multibyte_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Unibyte case.  We don't have to encode, but we have to make
+
鐃緒申��申鐃緒申	 sure to use a face suitable for unibyte.  */
+
鐃緒申��申鐃緒申      char2b->byte1 = 0;
+
鐃緒申��申鐃緒申      char2b->byte2 = c;
+
鐃緒申��申鐃緒申      face_id = FACE_FOR_CHAR (f, face, c);
+
鐃緒申��申鐃緒申      face = FACE_FROM_ID (f, face_id);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (c < 128 && face_id < BASIC_FACE_ID_SENTINEL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Case of ASCII in a face known to fit ASCII.  */
+
鐃緒申��申鐃緒申      char2b->byte1 = 0;
+
鐃緒申��申鐃緒申      char2b->byte2 = c;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int c1, c2, charset;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Split characters into bytes.  If c2 is -1 afterwards, C is
+
鐃緒申��申鐃緒申	 really a one-byte character so that byte1 is zero.  */
+
鐃緒申��申鐃緒申      SPLIT_CHAR (c, charset, c1, c2);
+
鐃緒申��申鐃緒申      if (c2 > 0)
+
鐃緒申��申鐃緒申	char2b->byte1 = c1, char2b->byte2 = c2;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	char2b->byte1 = 0, char2b->byte2 = c1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Maybe encode the character in *CHAR2B.  */
+
鐃緒申��申鐃緒申      if (face->font != NULL)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  struct font_info *font_info
+
鐃緒申��申鐃緒申	    = FONT_INFO_FROM_ID (f, face->font_info_id);
+
鐃緒申��申鐃緒申	  if (font_info)
+
鐃緒申��申鐃緒申	    x_encode_char (c, char2b, font_info);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Make sure X resources of the face are allocated.  */
+
鐃緒申��申鐃緒申  xassert (face != NULL);
+
鐃緒申��申鐃緒申  PREPARE_FACE_FOR_DISPLAY (f, face);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  return face;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Get face and two-byte form of character glyph GLYPH on frame F.
+
鐃緒申��申鐃緒申   The encoding of GLYPH->u.ch is returned in *CHAR2B.  Value is
+
鐃緒申��申鐃緒申   a pointer to a realized face that is ready for display.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE struct face *
+
鐃緒申��申鐃緒申x_get_glyph_face_and_encoding (f, glyph, char2b, two_byte_p)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     struct glyph *glyph;
+
鐃緒申��申鐃緒申     XChar2b *char2b;
+
鐃緒申��申鐃緒申     int *two_byte_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct face *face;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (glyph->type == CHAR_GLYPH);
+
鐃緒申��申鐃緒申  face = FACE_FROM_ID (f, glyph->face_id);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (two_byte_p)
+
鐃緒申��申鐃緒申    *two_byte_p = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!glyph->multibyte_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Unibyte case.  We don't have to encode, but we have to make
+
鐃緒申��申鐃緒申	 sure to use a face suitable for unibyte.  */
+
鐃緒申��申鐃緒申      char2b->byte1 = 0;
+
鐃緒申��申鐃緒申      char2b->byte2 = glyph->u.ch;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (glyph->u.ch < 128
+
鐃緒申��申鐃緒申	   && glyph->face_id < BASIC_FACE_ID_SENTINEL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Case of ASCII in a face known to fit ASCII.  */
+
鐃緒申��申鐃緒申      char2b->byte1 = 0;
+
鐃緒申��申鐃緒申      char2b->byte2 = glyph->u.ch;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int c1, c2, charset;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Split characters into bytes.  If c2 is -1 afterwards, C is
+
鐃緒申��申鐃緒申	 really a one-byte character so that byte1 is zero.  */
+
鐃緒申��申鐃緒申      SPLIT_CHAR (glyph->u.ch, charset, c1, c2);
+
鐃緒申��申鐃緒申      if (c2 > 0)
+
鐃緒申��申鐃緒申	char2b->byte1 = c1, char2b->byte2 = c2;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	char2b->byte1 = 0, char2b->byte2 = c1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Maybe encode the character in *CHAR2B.  */
+
鐃緒申��申鐃緒申      if (charset != CHARSET_ASCII)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  struct font_info *font_info
+
鐃緒申��申鐃緒申	    = FONT_INFO_FROM_ID (f, face->font_info_id);
+
鐃緒申��申鐃緒申	  if (font_info)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      x_encode_char (glyph->u.ch, char2b, font_info);
+
鐃緒申��申鐃緒申	      if (two_byte_p)
+
鐃緒申��申鐃緒申		*two_byte_p
+
鐃緒申��申鐃緒申		  = ((XFontStruct *) (font_info->font))->max_byte1 > 0;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Make sure X resources of the face are allocated.  */
+
鐃緒申��申鐃緒申  xassert (face != NULL);
+
鐃緒申��申鐃緒申  PREPARE_FACE_FOR_DISPLAY (f, face);
+
鐃緒申��申鐃緒申  return face;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Store one glyph for IT->char_to_display in IT->glyph_row.  
+
鐃緒申��申鐃緒申   Called from x_produce_glyphs when IT->glyph_row is non-null.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_append_glyph (it)
+
鐃緒申��申鐃緒申     struct it *it;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct glyph *glyph;
+
鐃緒申��申鐃緒申  enum glyph_row_area area = it->area;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  xassert (it->glyph_row);
+
鐃緒申��申鐃緒申  xassert (it->char_to_display != '\n' && it->char_to_display != '\t');
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
+
鐃緒申��申鐃緒申  if (glyph < it->glyph_row->glyphs[area + 1])
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      glyph->charpos = CHARPOS (it->position);
+
鐃緒申��申鐃緒申      glyph->object = it->object;
+
鐃緒申��申鐃緒申      glyph->pixel_width = it->pixel_width;
+
鐃緒申��申鐃緒申      glyph->voffset = it->voffset;
+
鐃緒申��申鐃緒申      glyph->type = CHAR_GLYPH;
+
鐃緒申��申鐃緒申      glyph->multibyte_p = it->multibyte_p;
+
鐃緒申��申鐃緒申      glyph->left_box_line_p = it->start_of_box_run_p;
+
鐃緒申��申鐃緒申      glyph->right_box_line_p = it->end_of_box_run_p;
+
鐃緒申��申鐃緒申      glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
+
鐃緒申��申鐃緒申				      || it->phys_descent > it->descent);
+
鐃緒申��申鐃緒申      glyph->padding_p = 0;
+
鐃緒申��申鐃緒申      glyph->glyph_not_available_p = it->glyph_not_available_p;
+
鐃緒申��申鐃緒申      glyph->face_id = it->face_id;
+
鐃緒申��申鐃緒申      glyph->u.ch = it->char_to_display;
+
鐃緒申��申鐃緒申      ++it->glyph_row->used[area];
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Store one glyph for the composition IT->cmp_id in IT->glyph_row.  
+
鐃緒申��申鐃緒申   Called from x_produce_glyphs when IT->glyph_row is non-null.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_append_composite_glyph (it)
+
鐃緒申��申鐃緒申     struct it *it;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct glyph *glyph;
+
鐃緒申��申鐃緒申  enum glyph_row_area area = it->area;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  xassert (it->glyph_row);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
+
鐃緒申��申鐃緒申  if (glyph < it->glyph_row->glyphs[area + 1])
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      glyph->charpos = CHARPOS (it->position);
+
鐃緒申��申鐃緒申      glyph->object = it->object;
+
鐃緒申��申鐃緒申      glyph->pixel_width = it->pixel_width;
+
鐃緒申��申鐃緒申      glyph->voffset = it->voffset;
+
鐃緒申��申鐃緒申      glyph->type = COMPOSITE_GLYPH;
+
鐃緒申��申鐃緒申      glyph->multibyte_p = it->multibyte_p;
+
鐃緒申��申鐃緒申      glyph->left_box_line_p = it->start_of_box_run_p;
+
鐃緒申��申鐃緒申      glyph->right_box_line_p = it->end_of_box_run_p;
+
鐃緒申��申鐃緒申      glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
+
鐃緒申��申鐃緒申				      || it->phys_descent > it->descent);
+
鐃緒申��申鐃緒申      glyph->padding_p = 0;
+
鐃緒申��申鐃緒申      glyph->glyph_not_available_p = 0;
+
鐃緒申��申鐃緒申      glyph->face_id = it->face_id;
+
鐃緒申��申鐃緒申      glyph->u.cmp_id = it->cmp_id;
+
鐃緒申��申鐃緒申      ++it->glyph_row->used[area];
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Change IT->ascent and IT->height according to the setting of
+
鐃緒申��申鐃緒申   IT->voffset.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申take_vertical_position_into_account (it)
+
鐃緒申��申鐃緒申     struct it *it;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (it->voffset)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (it->voffset < 0)
+
鐃緒申��申鐃緒申	/* Increase the ascent so that we can display the text higher
+
鐃緒申��申鐃緒申	   in the line.  */
+
鐃緒申��申鐃緒申	it->ascent += abs (it->voffset);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	/* Increase the descent so that we can display the text lower
+
鐃緒申��申鐃緒申	   in the line.  */
+
鐃緒申��申鐃緒申	it->descent += it->voffset;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Produce glyphs/get display metrics for the image IT is loaded with.
+
鐃緒申��申鐃緒申   See the description of struct display_iterator in dispextern.h for
+
鐃緒申��申鐃緒申   an overview of struct display_iterator.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_produce_image_glyph (it)
+
鐃緒申��申鐃緒申     struct it *it;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct image *img;
+
鐃緒申��申鐃緒申  struct face *face;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (it->what == IT_IMAGE);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  face = FACE_FROM_ID (it->f, it->face_id);
+
鐃緒申��申鐃緒申  img = IMAGE_FROM_ID (it->f, it->image_id);
+
鐃緒申��申鐃緒申  xassert (img);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Make sure X resources of the face and image are loaded.  */
+
鐃緒申��申鐃緒申  PREPARE_FACE_FOR_DISPLAY (it->f, face);
+
鐃緒申��申鐃緒申  prepare_image_for_display (it->f, img);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  it->ascent = it->phys_ascent = image_ascent (img, face);
+
鐃緒申��申鐃緒申  it->descent = it->phys_descent = img->height + 2 * img->vmargin - it->ascent;
+
鐃緒申��申鐃緒申  it->pixel_width = img->width + 2 * img->hmargin;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  it->nglyphs = 1;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (face->box != FACE_NO_BOX)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (face->box_line_width > 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  it->ascent += face->box_line_width;
+
鐃緒申��申鐃緒申	  it->descent += face->box_line_width;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if (it->start_of_box_run_p)
+
鐃緒申��申鐃緒申	it->pixel_width += abs (face->box_line_width);
+
鐃緒申��申鐃緒申      if (it->end_of_box_run_p)
+
鐃緒申��申鐃緒申	it->pixel_width += abs (face->box_line_width);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  take_vertical_position_into_account (it);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (it->glyph_row)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct glyph *glyph;
+
鐃緒申��申鐃緒申      enum glyph_row_area area = it->area;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
+
鐃緒申��申鐃緒申      if (glyph < it->glyph_row->glyphs[area + 1])
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  glyph->charpos = CHARPOS (it->position);
+
鐃緒申��申鐃緒申	  glyph->object = it->object;
+
鐃緒申��申鐃緒申	  glyph->pixel_width = it->pixel_width;
+
鐃緒申��申鐃緒申	  glyph->voffset = it->voffset;
+
鐃緒申��申鐃緒申	  glyph->type = IMAGE_GLYPH;
+
鐃緒申��申鐃緒申	  glyph->multibyte_p = it->multibyte_p;
+
鐃緒申��申鐃緒申	  glyph->left_box_line_p = it->start_of_box_run_p;
+
鐃緒申��申鐃緒申	  glyph->right_box_line_p = it->end_of_box_run_p;
+
鐃緒申��申鐃緒申	  glyph->overlaps_vertically_p = 0;
+
鐃緒申��申鐃緒申          glyph->padding_p = 0;
+
鐃緒申��申鐃緒申	  glyph->glyph_not_available_p = 0;
+
鐃緒申��申鐃緒申	  glyph->face_id = it->face_id;
+
鐃緒申��申鐃緒申	  glyph->u.img_id = img->id;
+
鐃緒申��申鐃緒申	  ++it->glyph_row->used[area];
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Append a stretch glyph to IT->glyph_row.  OBJECT is the source
+
鐃緒申��申鐃緒申   of the glyph, WIDTH and HEIGHT are the width and height of the 
+
鐃緒申��申鐃緒申   stretch.  ASCENT is the percentage/100 of HEIGHT to use for the 
+
鐃緒申��申鐃緒申   ascent of the glyph (0 <= ASCENT <= 1).  */
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_append_stretch_glyph (it, object, width, height, ascent)
+
鐃緒申��申鐃緒申     struct it *it;
+
鐃緒申��申鐃緒申     Lisp_Object object;
+
鐃緒申��申鐃緒申     int width, height;
+
鐃緒申��申鐃緒申     double ascent;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct glyph *glyph;
+
鐃緒申��申鐃緒申  enum glyph_row_area area = it->area;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (ascent >= 0 && ascent <= 1);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
+
鐃緒申��申鐃緒申  if (glyph < it->glyph_row->glyphs[area + 1])
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      glyph->charpos = CHARPOS (it->position);
+
鐃緒申��申鐃緒申      glyph->object = object;
+
鐃緒申��申鐃緒申      glyph->pixel_width = width;
+
鐃緒申��申鐃緒申      glyph->voffset = it->voffset;
+
鐃緒申��申鐃緒申      glyph->type = STRETCH_GLYPH;
+
鐃緒申��申鐃緒申      glyph->multibyte_p = it->multibyte_p;
+
鐃緒申��申鐃緒申      glyph->left_box_line_p = it->start_of_box_run_p;
+
鐃緒申��申鐃緒申      glyph->right_box_line_p = it->end_of_box_run_p;
+
鐃緒申��申鐃緒申      glyph->overlaps_vertically_p = 0;
+
鐃緒申��申鐃緒申      glyph->padding_p = 0;
+
鐃緒申��申鐃緒申      glyph->glyph_not_available_p = 0;
+
鐃緒申��申鐃緒申      glyph->face_id = it->face_id;
+
鐃緒申��申鐃緒申      glyph->u.stretch.ascent = height * ascent;
+
鐃緒申��申鐃緒申      glyph->u.stretch.height = height;
+
鐃緒申��申鐃緒申      ++it->glyph_row->used[area];
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Produce a stretch glyph for iterator IT.  IT->object is the value
+
鐃緒申��申鐃緒申   of the glyph property displayed.  The value must be a list
+
鐃緒申��申鐃緒申   `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
+
鐃緒申��申鐃緒申   being recognized:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   1. `:width WIDTH' specifies that the space should be WIDTH *
+
鐃緒申��申鐃緒申   canonical char width wide.  WIDTH may be an integer or floating 
+
鐃緒申��申鐃緒申   point number.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   2. `:relative-width FACTOR' specifies that the width of the stretch
+
鐃緒申��申鐃緒申   should be computed from the width of the first character having the
+
鐃緒申��申鐃緒申   `glyph' property, and should be FACTOR times that width.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   3. `:align-to HPOS' specifies that the space should be wide enough
+
鐃緒申��申鐃緒申   to reach HPOS, a value in canonical character units.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Exactly one of the above pairs must be present.  
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   4. `:height HEIGHT' specifies that the height of the stretch produced
+
鐃緒申��申鐃緒申   should be HEIGHT, measured in canonical character units.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   5. `:relative-height FACTOR' specifies that the height of the the
+
鐃緒申��申鐃緒申   stretch should be FACTOR times the height of the characters having
+
鐃緒申��申鐃緒申   the glyph property.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Either none or exactly one of 4 or 5 must be present.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   6. `:ascent ASCENT'  specifies that ASCENT percent of the height
+
鐃緒申��申鐃緒申   of the stretch should be used for the ascent of the stretch.
+
鐃緒申��申鐃緒申   ASCENT must be in the range 0 <= ASCENT <= 100.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define NUMVAL(X)				\
+
鐃緒申��申鐃緒申     ((INTEGERP (X) || FLOATP (X))		\
+
鐃緒申��申鐃緒申      ? XFLOATINT (X)				\
+
鐃緒申��申鐃緒申      : - 1)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_produce_stretch_glyph (it)
+
鐃緒申��申鐃緒申     struct it *it;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* (space :width WIDTH :height HEIGHT.  */
+
鐃緒申��申鐃緒申#if GLYPH_DEBUG
+
鐃緒申��申鐃緒申  extern Lisp_Object Qspace;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  extern Lisp_Object QCwidth, QCheight, QCascent;
+
鐃緒申��申鐃緒申  extern Lisp_Object QCrelative_width, QCrelative_height;
+
鐃緒申��申鐃緒申  extern Lisp_Object QCalign_to;
+
鐃緒申��申鐃緒申  Lisp_Object prop, plist;
+
鐃緒申��申鐃緒申  double width = 0, height = 0, ascent = 0;
+
鐃緒申��申鐃緒申  struct face *face = FACE_FROM_ID (it->f, it->face_id);
+
鐃緒申��申鐃緒申  XFontStruct *font = face->font ? face->font : FRAME_FONT (it->f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  PREPARE_FACE_FOR_DISPLAY (it->f, face);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* List should start with `space'.  */
+
鐃緒申��申鐃緒申  xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
+
鐃緒申��申鐃緒申  plist = XCDR (it->object);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Compute the width of the stretch.  */
+
鐃緒申��申鐃緒申  if (prop = Fplist_get (plist, QCwidth),
+
鐃緒申��申鐃緒申      NUMVAL (prop) > 0)
+
鐃緒申��申鐃緒申    /* Absolute width `:width WIDTH' specified and valid.  */
+
鐃緒申��申鐃緒申    width = NUMVAL (prop) * CANON_X_UNIT (it->f);
+
鐃緒申��申鐃緒申  else if (prop = Fplist_get (plist, QCrelative_width),
+
鐃緒申��申鐃緒申	   NUMVAL (prop) > 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Relative width `:relative-width FACTOR' specified and valid.
+
鐃緒申��申鐃緒申	 Compute the width of the characters having the `glyph'
+
鐃緒申��申鐃緒申	 property.  */
+
鐃緒申��申鐃緒申      struct it it2;
+
鐃緒申��申鐃緒申      unsigned char *p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      it2 = *it;
+
鐃緒申��申鐃緒申      if (it->multibyte_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
+
鐃緒申��申鐃緒申			- IT_BYTEPOS (*it));
+
鐃緒申��申鐃緒申	  it2.c = STRING_CHAR_AND_LENGTH (p, maxlen, it2.len);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	it2.c = *p, it2.len = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      it2.glyph_row = NULL;
+
鐃緒申��申鐃緒申      it2.what = IT_CHARACTER;
+
鐃緒申��申鐃緒申      x_produce_glyphs (&it2);
+
鐃緒申��申鐃緒申      width = NUMVAL (prop) * it2.pixel_width;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (prop = Fplist_get (plist, QCalign_to),
+
鐃緒申��申鐃緒申	   NUMVAL (prop) > 0)
+
鐃緒申��申鐃緒申    width = NUMVAL (prop) * CANON_X_UNIT (it->f) - it->current_x;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    /* Nothing specified -> width defaults to canonical char width.  */
+
鐃緒申��申鐃緒申    width = CANON_X_UNIT (it->f);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Compute height.  */
+
鐃緒申��申鐃緒申  if (prop = Fplist_get (plist, QCheight),
+
鐃緒申��申鐃緒申      NUMVAL (prop) > 0)
+
鐃緒申��申鐃緒申    height = NUMVAL (prop) * CANON_Y_UNIT (it->f);
+
鐃緒申��申鐃緒申  else if (prop = Fplist_get (plist, QCrelative_height),
+
鐃緒申��申鐃緒申	   NUMVAL (prop) > 0)
+
鐃緒申��申鐃緒申    height = FONT_HEIGHT (font) * NUMVAL (prop);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    height = FONT_HEIGHT (font);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Compute percentage of height used for ascent.  If 
+
鐃緒申��申鐃緒申     `:ascent ASCENT' is present and valid, use that.  Otherwise,
+
鐃緒申��申鐃緒申     derive the ascent from the font in use.  */
+
鐃緒申��申鐃緒申  if (prop = Fplist_get (plist, QCascent),
+
鐃緒申��申鐃緒申      NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
+
鐃緒申��申鐃緒申    ascent = NUMVAL (prop) / 100.0;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    ascent = (double) font->ascent / FONT_HEIGHT (font);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (width <= 0)
+
鐃緒申��申鐃緒申    width = 1;
+
鐃緒申��申鐃緒申  if (height <= 0)
+
鐃緒申��申鐃緒申    height = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (it->glyph_row)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object object = it->stack[it->sp - 1].string;
+
鐃緒申��申鐃緒申      if (!STRINGP (object))
+
鐃緒申��申鐃緒申	object = it->w->buffer;
+
鐃緒申��申鐃緒申      x_append_stretch_glyph (it, object, width, height, ascent);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  it->pixel_width = width;
+
鐃緒申��申鐃緒申  it->ascent = it->phys_ascent = height * ascent;
+
鐃緒申��申鐃緒申  it->descent = it->phys_descent = height - it->ascent;
+
鐃緒申��申鐃緒申  it->nglyphs = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (face->box != FACE_NO_BOX)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (face->box_line_width > 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  it->ascent += face->box_line_width;
+
鐃緒申��申鐃緒申	  it->descent += face->box_line_width;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if (it->start_of_box_run_p)
+
鐃緒申��申鐃緒申	it->pixel_width += abs (face->box_line_width);
+
鐃緒申��申鐃緒申      if (it->end_of_box_run_p)
+
鐃緒申��申鐃緒申	it->pixel_width += abs (face->box_line_width);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  take_vertical_position_into_account (it);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return proper value to be used as baseline offset of font that has
+
鐃緒申��申鐃緒申   ASCENT and DESCENT to draw characters by the font at the vertical
+
鐃緒申��申鐃緒申   center of the line of frame F.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Here, out task is to find the value of BOFF in the following figure;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	-------------------------+-----------+-
+
鐃緒申��申鐃緒申	 -+-+---------+-+        |           |
+
鐃緒申��申鐃緒申	  | |         | |        |           |
+
鐃緒申��申鐃緒申	  | |         | |        F_ASCENT    F_HEIGHT
+
鐃緒申��申鐃緒申	  | |         | ASCENT   |           |
+
鐃緒申��申鐃緒申     HEIGHT |         | |        |           |
+
鐃緒申��申鐃緒申	  | |         |-|-+------+-----------|------- baseline
+
鐃緒申��申鐃緒申	  | |         | | BOFF   |           |
+
鐃緒申��申鐃緒申	  | |---------|-+-+      |           |
+
鐃緒申��申鐃緒申	  | |         | DESCENT  |           |
+
鐃緒申��申鐃緒申	 -+-+---------+-+        F_DESCENT   |
+
鐃緒申��申鐃緒申	-------------------------+-----------+-
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	-BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
+
鐃緒申��申鐃緒申	BOFF = DESCENT +  (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
+
鐃緒申��申鐃緒申	DESCENT = FONT->descent
+
鐃緒申��申鐃緒申	HEIGHT = FONT_HEIGHT (FONT)
+
鐃緒申��申鐃緒申	F_DESCENT = (F->output_data.x->font->descent
+
鐃緒申��申鐃緒申		     - F->output_data.x->baseline_offset)
+
鐃緒申��申鐃緒申	F_HEIGHT = FRAME_LINE_HEIGHT (F)
+
鐃緒申��申鐃緒申*/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define VCENTER_BASELINE_OFFSET(FONT, F)			\
+
鐃緒申��申鐃緒申  ((FONT)->descent						\
+
鐃緒申��申鐃緒申   + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT))		\
+
鐃緒申��申鐃緒申      + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2	\
+
鐃緒申��申鐃緒申   - ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Produce glyphs/get display metrics for the display element IT is
+
鐃緒申��申鐃緒申   loaded with.  See the description of struct display_iterator in
+
鐃緒申��申鐃緒申   dispextern.h for an overview of struct display_iterator.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_produce_glyphs (it)
+
鐃緒申��申鐃緒申     struct it *it;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  it->glyph_not_available_p = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (it->what == IT_CHARACTER)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XChar2b char2b;
+
鐃緒申��申鐃緒申      XFontStruct *font;
+
鐃緒申��申鐃緒申      struct face *face = FACE_FROM_ID (it->f, it->face_id);
+
鐃緒申��申鐃緒申      XCharStruct *pcm;
+
鐃緒申��申鐃緒申      int font_not_found_p;
+
鐃緒申��申鐃緒申      struct font_info *font_info;
+
鐃緒申��申鐃緒申      int boff;			/* baseline offset */
+
鐃緒申��申鐃緒申      /* We may change it->multibyte_p upon unibyte<->multibyte
+
鐃緒申��申鐃緒申	 conversion.  So, save the current value now and restore it
+
鐃緒申��申鐃緒申	 later.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	 Note: It seems that we don't have to record multibyte_p in
+
鐃緒申��申鐃緒申	 struct glyph because the character code itself tells if or
+
鐃緒申��申鐃緒申	 not the character is multibyte.  Thus, in the future, we must
+
鐃緒申��申鐃緒申	 consider eliminating the field `multibyte_p' in the struct
+
鐃緒申��申鐃緒申	 glyph.
+
鐃緒申��申鐃緒申      */
+
鐃緒申��申鐃緒申      int saved_multibyte_p = it->multibyte_p;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Maybe translate single-byte characters to multibyte, or the
+
鐃緒申��申鐃緒申	 other way.  */
+
鐃緒申��申鐃緒申      it->char_to_display = it->c;
+
鐃緒申��申鐃緒申      if (!ASCII_BYTE_P (it->c))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (unibyte_display_via_language_environment
+
鐃緒申��申鐃緒申	      && SINGLE_BYTE_CHAR_P (it->c)
+
鐃緒申��申鐃緒申	      && (it->c >= 0240
+
鐃緒申��申鐃緒申		  || !NILP (Vnonascii_translation_table)))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      it->char_to_display = unibyte_char_to_multibyte (it->c);
+
鐃緒申��申鐃緒申	      it->multibyte_p = 1;
+
鐃緒申��申鐃緒申	      it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
+
鐃緒申��申鐃緒申	      face = FACE_FROM_ID (it->f, it->face_id);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else if (!SINGLE_BYTE_CHAR_P (it->c)
+
鐃緒申��申鐃緒申		   && !it->multibyte_p)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      it->char_to_display = multibyte_char_to_unibyte (it->c, Qnil);
+
鐃緒申��申鐃緒申	      it->multibyte_p = 0;
+
鐃緒申��申鐃緒申	      it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
+
鐃緒申��申鐃緒申	      face = FACE_FROM_ID (it->f, it->face_id);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Get font to use.  Encode IT->char_to_display.  */
+
鐃緒申��申鐃緒申      x_get_char_face_and_encoding (it->f, it->char_to_display,
+
鐃緒申��申鐃緒申				    it->face_id, &char2b,
+
鐃緒申��申鐃緒申				    it->multibyte_p);
+
鐃緒申��申鐃緒申      font = face->font;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* When no suitable font found, use the default font.  */
+
鐃緒申��申鐃緒申      font_not_found_p = font == NULL;
+
鐃緒申��申鐃緒申      if (font_not_found_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  font = FRAME_FONT (it->f);
+
鐃緒申��申鐃緒申	  boff = it->f->output_data.x->baseline_offset;
+
鐃緒申��申鐃緒申	  font_info = NULL;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  font_info = FONT_INFO_FROM_ID (it->f, face->font_info_id);
+
鐃緒申��申鐃緒申	  boff = font_info->baseline_offset;
+
鐃緒申��申鐃緒申	  if (font_info->vertical_centering)
+
鐃緒申��申鐃緒申	    boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (it->char_to_display >= ' '
+
鐃緒申��申鐃緒申	  && (!it->multibyte_p || it->char_to_display < 128))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* Either unibyte or ASCII.  */
+
鐃緒申��申鐃緒申	  int stretched_p;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  it->nglyphs = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  pcm = x_per_char_metric (font, &char2b);
+
鐃緒申��申鐃緒申	  it->ascent = font->ascent + boff;
+
鐃緒申��申鐃緒申	  it->descent = font->descent - boff;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (pcm)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      it->phys_ascent = pcm->ascent + boff;
+
鐃緒申��申鐃緒申	      it->phys_descent = pcm->descent - boff;
+
鐃緒申��申鐃緒申	      it->pixel_width = pcm->width;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      it->glyph_not_available_p = 1;
+
鐃緒申��申鐃緒申	      it->phys_ascent = font->ascent + boff;
+
鐃緒申��申鐃緒申	      it->phys_descent = font->descent - boff;
+
鐃緒申��申鐃緒申	      it->pixel_width = FONT_WIDTH (font);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* If this is a space inside a region of text with
+
鐃緒申��申鐃緒申	     `space-width' property, change its width.  */
+
鐃緒申��申鐃緒申	  stretched_p = it->char_to_display == ' ' && !NILP (it->space_width);
+
鐃緒申��申鐃緒申	  if (stretched_p)
+
鐃緒申��申鐃緒申	    it->pixel_width *= XFLOATINT (it->space_width);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* If face has a box, add the box thickness to the character
+
鐃緒申��申鐃緒申	     height.  If character has a box line to the left and/or
+
鐃緒申��申鐃緒申	     right, add the box line width to the character's width.  */
+
鐃緒申��申鐃緒申	  if (face->box != FACE_NO_BOX)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      int thick = face->box_line_width;
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申	      if (thick > 0)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  it->ascent += thick;
+
鐃緒申��申鐃緒申		  it->descent += thick;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		thick = -thick;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      if (it->start_of_box_run_p)
+
鐃緒申��申鐃緒申		it->pixel_width += thick;
+
鐃緒申��申鐃緒申	      if (it->end_of_box_run_p)
+
鐃緒申��申鐃緒申		it->pixel_width += thick;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* If face has an overline, add the height of the overline
+
鐃緒申��申鐃緒申	     (1 pixel) and a 1 pixel margin to the character height.  */
+
鐃緒申��申鐃緒申	  if (face->overline_p)
+
鐃緒申��申鐃緒申	    it->ascent += 2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  take_vertical_position_into_account (it);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申	  /* If we have to actually produce glyphs, do it.  */
+
鐃緒申��申鐃緒申	  if (it->glyph_row)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      if (stretched_p)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  /* Translate a space with a `space-width' property
+
鐃緒申��申鐃緒申		     into a stretch glyph.  */
+
鐃緒申��申鐃緒申		  double ascent = (double) font->ascent / FONT_HEIGHT (font);
+
鐃緒申��申鐃緒申		  x_append_stretch_glyph (it, it->object, it->pixel_width, 
+
鐃緒申��申鐃緒申					  it->ascent + it->descent, ascent);
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		x_append_glyph (it);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      /* If characters with lbearing or rbearing are displayed
+
鐃緒申��申鐃緒申		 in this line, record that fact in a flag of the
+
鐃緒申��申鐃緒申		 glyph row.  This is used to optimize X output code.  */
+
鐃緒申��申鐃緒申	      if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
+
鐃緒申��申鐃緒申		it->glyph_row->contains_overlapping_glyphs_p = 1;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else if (it->char_to_display == '\n')
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* A newline has no width but we need the height of the line.  */
+
鐃緒申��申鐃緒申	  it->pixel_width = 0;
+
鐃緒申��申鐃緒申	  it->nglyphs = 0;
+
鐃緒申��申鐃緒申	  it->ascent = it->phys_ascent = font->ascent + boff;
+
鐃緒申��申鐃緒申	  it->descent = it->phys_descent = font->descent - boff;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申	  if (face->box != FACE_NO_BOX
+
鐃緒申��申鐃緒申	      && face->box_line_width > 0)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      it->ascent += face->box_line_width;
+
鐃緒申��申鐃緒申	      it->descent += face->box_line_width;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else if (it->char_to_display == '\t')
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int tab_width = it->tab_width * CANON_X_UNIT (it->f);
+
鐃緒申��申鐃緒申	  int x = it->current_x + it->continuation_lines_width;
+
鐃緒申��申鐃緒申	  int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* If the distance from the current position to the next tab
+
鐃緒申��申鐃緒申	     stop is less than a canonical character width, use the
+
鐃緒申��申鐃緒申	     tab stop after that.  */
+
鐃緒申��申鐃緒申	  if (next_tab_x - x < CANON_X_UNIT (it->f))
+
鐃緒申��申鐃緒申	    next_tab_x += tab_width;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申	  it->pixel_width = next_tab_x - x;
+
鐃緒申��申鐃緒申	  it->nglyphs = 1;
+
鐃緒申��申鐃緒申	  it->ascent = it->phys_ascent = font->ascent + boff;
+
鐃緒申��申鐃緒申	  it->descent = it->phys_descent = font->descent - boff;
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  if (it->glyph_row)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      double ascent = (double) it->ascent / (it->ascent + it->descent);
+
鐃緒申��申鐃緒申	      x_append_stretch_glyph (it, it->object, it->pixel_width, 
+
鐃緒申��申鐃緒申				      it->ascent + it->descent, ascent);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else 
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* A multi-byte character.  Assume that the display width of the
+
鐃緒申��申鐃緒申	     character is the width of the character multiplied by the
+
鐃緒申��申鐃緒申	     width of the font.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* If we found a font, this font should give us the right
+
鐃緒申��申鐃緒申	     metrics.  If we didn't find a font, use the frame's
+
鐃緒申��申鐃緒申	     default font and calculate the width of the character
+
鐃緒申��申鐃緒申	     from the charset width; this is what old redisplay code
+
鐃緒申��申鐃緒申	     did.  */
+
鐃緒申��申鐃緒申	  pcm = x_per_char_metric (font, &char2b);
+
鐃緒申��申鐃緒申	  if (font_not_found_p || !pcm)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      int charset = CHAR_CHARSET (it->char_to_display);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      it->glyph_not_available_p = 1;
+
鐃緒申��申鐃緒申	      it->pixel_width = (FONT_WIDTH (FRAME_FONT (it->f))
+
鐃緒申��申鐃緒申				 * CHARSET_WIDTH (charset));
+
鐃緒申��申鐃緒申	      it->phys_ascent = font->ascent + boff;
+
鐃緒申��申鐃緒申	      it->phys_descent = font->descent - boff;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      it->pixel_width = pcm->width;
+
鐃緒申��申鐃緒申	      it->phys_ascent = pcm->ascent + boff;
+
鐃緒申��申鐃緒申	      it->phys_descent = pcm->descent - boff;
+
鐃緒申��申鐃緒申	      if (it->glyph_row
+
鐃緒申��申鐃緒申		  && (pcm->lbearing < 0
+
鐃緒申��申鐃緒申		      || pcm->rbearing > pcm->width))
+
鐃緒申��申鐃緒申		it->glyph_row->contains_overlapping_glyphs_p = 1;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  it->nglyphs = 1;
+
鐃緒申��申鐃緒申	  it->ascent = font->ascent + boff;
+
鐃緒申��申鐃緒申	  it->descent = font->descent - boff;
+
鐃緒申��申鐃緒申	  if (face->box != FACE_NO_BOX)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      int thick = face->box_line_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      if (thick > 0)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  it->ascent += thick;
+
鐃緒申��申鐃緒申		  it->descent += thick;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		thick = - thick;
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	      if (it->start_of_box_run_p)
+
鐃緒申��申鐃緒申		it->pixel_width += thick;
+
鐃緒申��申鐃緒申	      if (it->end_of_box_run_p)
+
鐃緒申��申鐃緒申		it->pixel_width += thick;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申	  /* If face has an overline, add the height of the overline
+
鐃緒申��申鐃緒申	     (1 pixel) and a 1 pixel margin to the character height.  */
+
鐃緒申��申鐃緒申	  if (face->overline_p)
+
鐃緒申��申鐃緒申	    it->ascent += 2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  take_vertical_position_into_account (it);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申	  if (it->glyph_row)
+
鐃緒申��申鐃緒申	    x_append_glyph (it);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      it->multibyte_p = saved_multibyte_p;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (it->what == IT_COMPOSITION)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Note: A composition is represented as one glyph in the
+
鐃緒申��申鐃緒申	 glyph matrix.  There are no padding glyphs.  */
+
鐃緒申��申鐃緒申      XChar2b char2b;
+
鐃緒申��申鐃緒申      XFontStruct *font;
+
鐃緒申��申鐃緒申      struct face *face = FACE_FROM_ID (it->f, it->face_id);
+
鐃緒申��申鐃緒申      XCharStruct *pcm;
+
鐃緒申��申鐃緒申      int font_not_found_p;
+
鐃緒申��申鐃緒申      struct font_info *font_info;
+
鐃緒申��申鐃緒申      int boff;			/* baseline offset */
+
鐃緒申��申鐃緒申      struct composition *cmp = composition_table[it->cmp_id];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Maybe translate single-byte characters to multibyte.  */
+
鐃緒申��申鐃緒申      it->char_to_display = it->c;
+
鐃緒申��申鐃緒申      if (unibyte_display_via_language_environment
+
鐃緒申��申鐃緒申	  && SINGLE_BYTE_CHAR_P (it->c)
+
鐃緒申��申鐃緒申	  && (it->c >= 0240
+
鐃緒申��申鐃緒申	      || (it->c >= 0200
+
鐃緒申��申鐃緒申		  && !NILP (Vnonascii_translation_table))))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  it->char_to_display = unibyte_char_to_multibyte (it->c);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Get face and font to use.  Encode IT->char_to_display.  */
+
鐃緒申��申鐃緒申      it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
+
鐃緒申��申鐃緒申      face = FACE_FROM_ID (it->f, it->face_id);
+
鐃緒申��申鐃緒申      x_get_char_face_and_encoding (it->f, it->char_to_display,
+
鐃緒申��申鐃緒申				    it->face_id, &char2b, it->multibyte_p);
+
鐃緒申��申鐃緒申      font = face->font;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* When no suitable font found, use the default font.  */
+
鐃緒申��申鐃緒申      font_not_found_p = font == NULL;
+
鐃緒申��申鐃緒申      if (font_not_found_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  font = FRAME_FONT (it->f);
+
鐃緒申��申鐃緒申	  boff = it->f->output_data.x->baseline_offset;
+
鐃緒申��申鐃緒申	  font_info = NULL;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  font_info = FONT_INFO_FROM_ID (it->f, face->font_info_id);
+
鐃緒申��申鐃緒申	  boff = font_info->baseline_offset;
+
鐃緒申��申鐃緒申	  if (font_info->vertical_centering)
+
鐃緒申��申鐃緒申	    boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* There are no padding glyphs, so there is only one glyph to
+
鐃緒申��申鐃緒申	 produce for the composition.  Important is that pixel_width,
+
鐃緒申��申鐃緒申	 ascent and descent are the values of what is drawn by
+
鐃緒申��申鐃緒申	 draw_glyphs (i.e. the values of the overall glyphs composed).  */
+
鐃緒申��申鐃緒申      it->nglyphs = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* If we have not yet calculated pixel size data of glyphs of
+
鐃緒申��申鐃緒申	 the composition for the current face font, calculate them
+
鐃緒申��申鐃緒申	 now.  Theoretically, we have to check all fonts for the
+
鐃緒申��申鐃緒申	 glyphs, but that requires much time and memory space.  So,
+
鐃緒申��申鐃緒申	 here we check only the font of the first glyph.  This leads
+
鐃緒申��申鐃緒申	 to incorrect display very rarely, and C-l (recenter) can
+
鐃緒申��申鐃緒申	 correct the display anyway.  */
+
鐃緒申��申鐃緒申      if (cmp->font != (void *) font)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* Ascent and descent of the font of the first character of
+
鐃緒申��申鐃緒申	     this composition (adjusted by baseline offset).  Ascent
+
鐃緒申��申鐃緒申	     and descent of overall glyphs should not be less than
+
鐃緒申��申鐃緒申	     them respectively.  */
+
鐃緒申��申鐃緒申	  int font_ascent = font->ascent + boff;
+
鐃緒申��申鐃緒申	  int font_descent = font->descent - boff;
+
鐃緒申��申鐃緒申	  /* Bounding box of the overall glyphs.  */
+
鐃緒申��申鐃緒申	  int leftmost, rightmost, lowest, highest;
+
鐃緒申��申鐃緒申	  int i, width, ascent, descent;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  cmp->font = (void *) font;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Initialize the bounding box.  */
+
鐃緒申��申鐃緒申	  if (font_info
+
鐃緒申��申鐃緒申	      && (pcm = x_per_char_metric (font, &char2b)))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      width = pcm->width;
+
鐃緒申��申鐃緒申	      ascent = pcm->ascent;
+
鐃緒申��申鐃緒申	      descent = pcm->descent;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      width = FONT_WIDTH (font);
+
鐃緒申��申鐃緒申	      ascent = font->ascent;
+
鐃緒申��申鐃緒申	      descent = font->descent;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  rightmost = width;
+
鐃緒申��申鐃緒申	  lowest = - descent + boff;
+
鐃緒申��申鐃緒申	  highest = ascent + boff;
+
鐃緒申��申鐃緒申	  leftmost = 0;
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  if (font_info
+
鐃緒申��申鐃緒申	      && font_info->default_ascent
+
鐃緒申��申鐃緒申	      && CHAR_TABLE_P (Vuse_default_ascent)
+
鐃緒申��申鐃緒申	      && !NILP (Faref (Vuse_default_ascent,
+
鐃緒申��申鐃緒申			       make_number (it->char_to_display))))
+
鐃緒申��申鐃緒申	    highest = font_info->default_ascent + boff;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Draw the first glyph at the normal position.  It may be
+
鐃緒申��申鐃緒申	     shifted to right later if some other glyphs are drawn at
+
鐃緒申��申鐃緒申	     the left.  */
+
鐃緒申��申鐃緒申	  cmp->offsets[0] = 0;
+
鐃緒申��申鐃緒申	  cmp->offsets[1] = boff;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Set cmp->offsets for the remaining glyphs.  */
+
鐃緒申��申鐃緒申	  for (i = 1; i < cmp->glyph_len; i++)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      int left, right, btm, top;
+
鐃緒申��申鐃緒申	      int ch = COMPOSITION_GLYPH (cmp, i);
+
鐃緒申��申鐃緒申	      int face_id = FACE_FOR_CHAR (it->f, face, ch);
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申	      face = FACE_FROM_ID (it->f, face_id);
+
鐃緒申��申鐃緒申	      x_get_char_face_and_encoding (it->f, ch, face->id, &char2b,
+
鐃緒申��申鐃緒申					    it->multibyte_p);
+
鐃緒申��申鐃緒申	      font = face->font;
+
鐃緒申��申鐃緒申	      if (font == NULL)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  font = FRAME_FONT (it->f);
+
鐃緒申��申鐃緒申		  boff = it->f->output_data.x->baseline_offset;
+
鐃緒申��申鐃緒申		  font_info = NULL;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  font_info
+
鐃緒申��申鐃緒申		    = FONT_INFO_FROM_ID (it->f, face->font_info_id);
+
鐃緒申��申鐃緒申		  boff = font_info->baseline_offset;
+
鐃緒申��申鐃緒申		  if (font_info->vertical_centering)
+
鐃緒申��申鐃緒申		    boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      if (font_info
+
鐃緒申��申鐃緒申		  && (pcm = x_per_char_metric (font, &char2b)))
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  width = pcm->width;
+
鐃緒申��申鐃緒申		  ascent = pcm->ascent;
+
鐃緒申��申鐃緒申		  descent = pcm->descent;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  width = FONT_WIDTH (font);
+
鐃緒申��申鐃緒申		  ascent = 1;
+
鐃緒申��申鐃緒申		  descent = 0;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  /* Relative composition with or without
+
鐃緒申��申鐃緒申		     alternate chars.  */
+
鐃緒申��申鐃緒申		  left = (leftmost + rightmost - width) / 2;
+
鐃緒申��申鐃緒申		  btm = - descent + boff;
+
鐃緒申��申鐃緒申		  if (font_info && font_info->relative_compose
+
鐃緒申��申鐃緒申		      && (! CHAR_TABLE_P (Vignore_relative_composition)
+
鐃緒申��申鐃緒申			  || NILP (Faref (Vignore_relative_composition,
+
鐃緒申��申鐃緒申					  make_number (ch)))))
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		      if (- descent >= font_info->relative_compose)
+
鐃緒申��申鐃緒申			/* One extra pixel between two glyphs.  */
+
鐃緒申��申鐃緒申			btm = highest + 1;
+
鐃緒申��申鐃緒申		      else if (ascent <= 0)
+
鐃緒申��申鐃緒申			/* One extra pixel between two glyphs.  */
+
鐃緒申��申鐃緒申			btm = lowest - 1 - ascent - descent;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  /* A composition rule is specified by an integer
+
鐃緒申��申鐃緒申		     value that encodes global and new reference
+
鐃緒申��申鐃緒申		     points (GREF and NREF).  GREF and NREF are
+
鐃緒申��申鐃緒申		     specified by numbers as below:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			0---1---2 -- ascent
+
鐃緒申��申鐃緒申			|       |
+
鐃緒申��申鐃緒申			|       |
+
鐃緒申��申鐃緒申			|       |
+
鐃緒申��申鐃緒申			9--10--11 -- center
+
鐃緒申��申鐃緒申			|       |
+
鐃緒申��申鐃緒申		     ---3---4---5--- baseline
+
鐃緒申��申鐃緒申			|       |
+
鐃緒申��申鐃緒申			6---7---8 -- descent
+
鐃緒申��申鐃緒申		  */
+
鐃緒申��申鐃緒申		  int rule = COMPOSITION_RULE (cmp, i);
+
鐃緒申��申鐃緒申		  int gref, nref, grefx, grefy, nrefx, nrefy;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  COMPOSITION_DECODE_RULE (rule, gref, nref);
+
鐃緒申��申鐃緒申		  grefx = gref % 3, nrefx = nref % 3;
+
鐃緒申��申鐃緒申		  grefy = gref / 3, nrefy = nref / 3;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  left = (leftmost
+
鐃緒申��申鐃緒申			  + grefx * (rightmost - leftmost) / 2
+
鐃緒申��申鐃緒申			  - nrefx * width / 2);
+
鐃緒申��申鐃緒申		  btm = ((grefy == 0 ? highest
+
鐃緒申��申鐃緒申			  : grefy == 1 ? 0
+
鐃緒申��申鐃緒申			  : grefy == 2 ? lowest
+
鐃緒申��申鐃緒申			  : (highest + lowest) / 2)
+
鐃緒申��申鐃緒申			 - (nrefy == 0 ? ascent + descent
+
鐃緒申��申鐃緒申			    : nrefy == 1 ? descent - boff
+
鐃緒申��申鐃緒申			    : nrefy == 2 ? 0
+
鐃緒申��申鐃緒申			    : (ascent + descent) / 2));
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      cmp->offsets[i * 2] = left;
+
鐃緒申��申鐃緒申	      cmp->offsets[i * 2 + 1] = btm + descent;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      /* Update the bounding box of the overall glyphs. */
+
鐃緒申��申鐃緒申	      right = left + width;
+
鐃緒申��申鐃緒申	      top = btm + descent + ascent;
+
鐃緒申��申鐃緒申	      if (left < leftmost)
+
鐃緒申��申鐃緒申		leftmost = left;
+
鐃緒申��申鐃緒申	      if (right > rightmost)
+
鐃緒申��申鐃緒申		rightmost = right;
+
鐃緒申��申鐃緒申	      if (top > highest)
+
鐃緒申��申鐃緒申		highest = top;
+
鐃緒申��申鐃緒申	      if (btm < lowest)
+
鐃緒申��申鐃緒申		lowest = btm;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* If there are glyphs whose x-offsets are negative,
+
鐃緒申��申鐃緒申	     shift all glyphs to the right and make all x-offsets
+
鐃緒申��申鐃緒申	     non-negative.  */
+
鐃緒申��申鐃緒申	  if (leftmost < 0)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      for (i = 0; i < cmp->glyph_len; i++)
+
鐃緒申��申鐃緒申		cmp->offsets[i * 2] -= leftmost;
+
鐃緒申��申鐃緒申	      rightmost -= leftmost;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  cmp->pixel_width = rightmost;
+
鐃緒申��申鐃緒申	  cmp->ascent = highest;
+
鐃緒申��申鐃緒申	  cmp->descent = - lowest;
+
鐃緒申��申鐃緒申	  if (cmp->ascent < font_ascent)
+
鐃緒申��申鐃緒申	    cmp->ascent = font_ascent;
+
鐃緒申��申鐃緒申	  if (cmp->descent < font_descent)
+
鐃緒申��申鐃緒申	    cmp->descent = font_descent;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      it->pixel_width = cmp->pixel_width;
+
鐃緒申��申鐃緒申      it->ascent = it->phys_ascent = cmp->ascent;
+
鐃緒申��申鐃緒申      it->descent = it->phys_descent = cmp->descent;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (face->box != FACE_NO_BOX)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int thick = face->box_line_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (thick > 0)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      it->ascent += thick;
+
鐃緒申��申鐃緒申	      it->descent += thick;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    thick = - thick;
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  if (it->start_of_box_run_p)
+
鐃緒申��申鐃緒申	    it->pixel_width += thick;
+
鐃緒申��申鐃緒申	  if (it->end_of_box_run_p)
+
鐃緒申��申鐃緒申	    it->pixel_width += thick;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申      /* If face has an overline, add the height of the overline
+
鐃緒申��申鐃緒申	 (1 pixel) and a 1 pixel margin to the character height.  */
+
鐃緒申��申鐃緒申      if (face->overline_p)
+
鐃緒申��申鐃緒申	it->ascent += 2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      take_vertical_position_into_account (it);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申      if (it->glyph_row)
+
鐃緒申��申鐃緒申	x_append_composite_glyph (it);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (it->what == IT_IMAGE)
+
鐃緒申��申鐃緒申    x_produce_image_glyph (it);
+
鐃緒申��申鐃緒申  else if (it->what == IT_STRETCH)
+
鐃緒申��申鐃緒申    x_produce_stretch_glyph (it);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Accumulate dimensions.  Note: can't assume that it->descent > 0
+
鐃緒申��申鐃緒申     because this isn't true for images with `:ascent 100'.  */
+
鐃緒申��申鐃緒申  xassert (it->ascent >= 0 && it->descent >= 0);
+
鐃緒申��申鐃緒申  if (it->area == TEXT_AREA)
+
鐃緒申��申鐃緒申    it->current_x += it->pixel_width;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  it->descent += it->extra_line_spacing;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  it->max_ascent = max (it->max_ascent, it->ascent);
+
鐃緒申��申鐃緒申  it->max_descent = max (it->max_descent, it->descent);
+
鐃緒申��申鐃緒申  it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
+
鐃緒申��申鐃緒申  it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Estimate the pixel height of the mode or top line on frame F.
+
鐃緒申��申鐃緒申   FACE_ID specifies what line's height to estimate.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申x_estimate_mode_line_height (f, face_id)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     enum face_id face_id;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int height = FONT_HEIGHT (FRAME_FONT (f));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* This function is called so early when Emacs starts that the face
+
鐃緒申��申鐃緒申     cache and mode line face are not yet initialized.  */
+
鐃緒申��申鐃緒申  if (FRAME_FACE_CACHE (f))
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	struct face *face = FACE_FROM_ID (f, face_id);
+
鐃緒申��申鐃緒申	if (face)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    if (face->font)
+
鐃緒申��申鐃緒申	      height = FONT_HEIGHT (face->font);
+
鐃緒申��申鐃緒申	    if (face->box_line_width > 0)
+
鐃緒申��申鐃緒申	      height += 2 * face->box_line_width;
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  return height;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			    Glyph display
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* A sequence of glyphs to be drawn in the same face.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   This data structure is not really completely X specific, so it
+
鐃緒申��申鐃緒申   could possibly, at least partially, be useful for other systems.  It
+
鐃緒申��申鐃緒申   is currently not part of the external redisplay interface because
+
鐃緒申��申鐃緒申   it's not clear what other systems will need.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct glyph_string
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* X-origin of the string.  */
+
鐃緒申��申鐃緒申  int x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Y-origin and y-position of the base line of this string.  */
+
鐃緒申��申鐃緒申  int y, ybase;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* The width of the string, not including a face extension.  */
+
鐃緒申��申鐃緒申  int width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* The width of the string, including a face extension.  */
+
鐃緒申��申鐃緒申  int background_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* The height of this string.  This is the height of the line this
+
鐃緒申��申鐃緒申     string is drawn in, and can be different from the height of the
+
鐃緒申��申鐃緒申     font the string is drawn in.  */
+
鐃緒申��申鐃緒申  int height;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Number of pixels this string overwrites in front of its x-origin.
+
鐃緒申��申鐃緒申     This number is zero if the string has an lbearing >= 0; it is
+
鐃緒申��申鐃緒申     -lbearing, if the string has an lbearing < 0.  */
+
鐃緒申��申鐃緒申  int left_overhang;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Number of pixels this string overwrites past its right-most
+
鐃緒申��申鐃緒申     nominal x-position, i.e. x + width.  Zero if the string's
+
鐃緒申��申鐃緒申     rbearing is <= its nominal width, rbearing - width otherwise.  */
+
鐃緒申��申鐃緒申  int right_overhang;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* The frame on which the glyph string is drawn.  */
+
鐃緒申��申鐃緒申  struct frame *f;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* The window on which the glyph string is drawn.  */
+
鐃緒申��申鐃緒申  struct window *w;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* X display and window for convenience.  */
+
鐃緒申��申鐃緒申  Display *display;
+
鐃緒申��申鐃緒申  Window window;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* The glyph row for which this string was built.  It determines the
+
鐃緒申��申鐃緒申     y-origin and height of the string.  */
+
鐃緒申��申鐃緒申  struct glyph_row *row;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* The area within row.  */
+
鐃緒申��申鐃緒申  enum glyph_row_area area;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Characters to be drawn, and number of characters.  */
+
鐃緒申��申鐃緒申  XChar2b *char2b;
+
鐃緒申��申鐃緒申  int nchars;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* A face-override for drawing cursors, mouse face and similar.  */
+
鐃緒申��申鐃緒申  enum draw_glyphs_face hl;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Face in which this string is to be drawn.  */
+
鐃緒申��申鐃緒申  struct face *face;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Font in which this string is to be drawn.  */
+
鐃緒申��申鐃緒申  XFontStruct *font;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Font info for this string.  */
+
鐃緒申��申鐃緒申  struct font_info *font_info;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Non-null means this string describes (part of) a composition.
+
鐃緒申��申鐃緒申     All characters from char2b are drawn composed.  */
+
鐃緒申��申鐃緒申  struct composition *cmp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Index of this glyph string's first character in the glyph
+
鐃緒申��申鐃緒申     definition of CMP.  If this is zero, this glyph string describes
+
鐃緒申��申鐃緒申     the first character of a composition.  */
+
鐃緒申��申鐃緒申  int gidx;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* 1 means this glyph strings face has to be drawn to the right end
+
鐃緒申��申鐃緒申     of the window's drawing area.  */
+
鐃緒申��申鐃緒申  unsigned extends_to_end_of_line_p : 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* 1 means the background of this string has been drawn.  */
+
鐃緒申��申鐃緒申  unsigned background_filled_p : 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* 1 means glyph string must be drawn with 16-bit functions.  */
+
鐃緒申��申鐃緒申  unsigned two_byte_p : 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* 1 means that the original font determined for drawing this glyph
+
鐃緒申��申鐃緒申     string could not be loaded.  The member `font' has been set to
+
鐃緒申��申鐃緒申     the frame's default font in this case.  */
+
鐃緒申��申鐃緒申  unsigned font_not_found_p : 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* 1 means that the face in which this glyph string is drawn has a
+
鐃緒申��申鐃緒申     stipple pattern.  */
+
鐃緒申��申鐃緒申  unsigned stippled_p : 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* 1 means only the foreground of this glyph string must be drawn,
+
鐃緒申��申鐃緒申     and we should use the physical height of the line this glyph
+
鐃緒申��申鐃緒申     string appears in as clip rect.  */
+
鐃緒申��申鐃緒申  unsigned for_overlaps_p : 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* The GC to use for drawing this glyph string.  */
+
鐃緒申��申鐃緒申  GC gc;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* A pointer to the first glyph in the string.  This glyph
+
鐃緒申��申鐃緒申     corresponds to char2b[0].  Needed to draw rectangles if
+
鐃緒申��申鐃緒申     font_not_found_p is 1.  */
+
鐃緒申��申鐃緒申  struct glyph *first_glyph;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Image, if any.  */
+
鐃緒申��申鐃緒申  struct image *img;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  struct glyph_string *next, *prev;
+
鐃緒申��申鐃緒申};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if 1
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_dump_glyph_string (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  fprintf (stderr, "glyph string\n");
+
鐃緒申��申鐃緒申  fprintf (stderr, "  x, y, w, h = %d, %d, %d, %d\n",
+
鐃緒申��申鐃緒申	   s->x, s->y, s->width, s->height);
+
鐃緒申��申鐃緒申  fprintf (stderr, "  ybase = %d\n", s->ybase);
+
鐃緒申��申鐃緒申  fprintf (stderr, "  hl = %d\n", s->hl);
+
鐃緒申��申鐃緒申  fprintf (stderr, "  left overhang = %d, right = %d\n",
+
鐃緒申��申鐃緒申	   s->left_overhang, s->right_overhang);
+
鐃緒申��申鐃緒申  fprintf (stderr, "  nchars = %d\n", s->nchars);
+
鐃緒申��申鐃緒申  fprintf (stderr, "  extends to end of line = %d\n",
+
鐃緒申��申鐃緒申	   s->extends_to_end_of_line_p);
+
鐃緒申��申鐃緒申  fprintf (stderr, "  font height = %d\n", FONT_HEIGHT (s->font));
+
鐃緒申��申鐃緒申  fprintf (stderr, "  bg width = %d\n", s->background_width);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* GLYPH_DEBUG */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void x_append_glyph_string_lists P_ ((struct glyph_string **,
+
鐃緒申��申鐃緒申					     struct glyph_string **,
+
鐃緒申��申鐃緒申					     struct glyph_string *,
+
鐃緒申��申鐃緒申					     struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_prepend_glyph_string_lists P_ ((struct glyph_string **,
+
鐃緒申��申鐃緒申					      struct glyph_string **,
+
鐃緒申��申鐃緒申					      struct glyph_string *,
+
鐃緒申��申鐃緒申					      struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_append_glyph_string P_ ((struct glyph_string **,
+
鐃緒申��申鐃緒申				       struct glyph_string **,
+
鐃緒申��申鐃緒申				       struct glyph_string *));
+
鐃緒申��申鐃緒申static int x_left_overwritten P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static int x_left_overwriting P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static int x_right_overwritten P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static int x_right_overwriting P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static int x_fill_glyph_string P_ ((struct glyph_string *, int, int, int,
+
鐃緒申��申鐃緒申				    int));
+
鐃緒申��申鐃緒申static void x_init_glyph_string P_ ((struct glyph_string *,
+
鐃緒申��申鐃緒申					XChar2b *, struct window *,
+
鐃緒申��申鐃緒申					struct glyph_row *,
+
鐃緒申��申鐃緒申					enum glyph_row_area, int, 
+
鐃緒申��申鐃緒申					enum draw_glyphs_face));
+
鐃緒申��申鐃緒申static int x_draw_glyphs P_ ((struct window *, int , struct glyph_row *,
+
鐃緒申��申鐃緒申			      enum glyph_row_area, int, int,
+
鐃緒申��申鐃緒申			      enum draw_glyphs_face, int *, int *, int));
+
鐃緒申��申鐃緒申static void x_set_glyph_string_clipping P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_set_glyph_string_gc P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_draw_glyph_string_background P_ ((struct glyph_string *,
+
鐃緒申��申鐃緒申						int));
+
鐃緒申��申鐃緒申static void x_draw_glyph_string_foreground P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_draw_composite_glyph_string_foreground P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_draw_glyph_string_box P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_draw_glyph_string  P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_compute_glyph_string_overhangs P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_set_cursor_gc P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_set_mode_line_face_gc P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_set_mouse_face_gc P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_get_glyph_overhangs P_ ((struct glyph *, struct frame *,
+
鐃緒申��申鐃緒申				       int *, int *));
+
鐃緒申��申鐃緒申static void x_compute_overhangs_and_x P_ ((struct glyph_string *, int, int));
+
鐃緒申��申鐃緒申static int x_alloc_lighter_color P_ ((struct frame *, Display *, Colormap,
+
鐃緒申��申鐃緒申				      unsigned long *, double, int));
+
鐃緒申��申鐃緒申static void x_setup_relief_color P_ ((struct frame *, struct relief *,
+
鐃緒申��申鐃緒申				      double, int, unsigned long));
+
鐃緒申��申鐃緒申static void x_setup_relief_colors P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_draw_image_glyph_string P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_draw_image_relief P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_draw_image_foreground P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_draw_image_foreground_1 P_ ((struct glyph_string *, Pixmap));
+
鐃緒申��申鐃緒申static void x_fill_image_glyph_string P_ ((struct glyph_string *));
+
鐃緒申��申鐃緒申static void x_clear_glyph_string_rect P_ ((struct glyph_string *, int,
+
鐃緒申��申鐃緒申					   int, int, int));
+
鐃緒申��申鐃緒申static void x_draw_relief_rect P_ ((struct frame *, int, int, int, int,
+
鐃緒申��申鐃緒申				    int, int, int, int, XRectangle *));
+
鐃緒申��申鐃緒申static void x_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
+
鐃緒申��申鐃緒申				 int, int, int, XRectangle *));
+
鐃緒申��申鐃緒申static void x_fix_overlapping_area P_ ((struct window *, struct glyph_row *,
+
鐃緒申��申鐃緒申					enum glyph_row_area));
+
鐃緒申��申鐃緒申static int x_fill_stretch_glyph_string P_ ((struct glyph_string *,
+
鐃緒申��申鐃緒申					    struct glyph_row *,
+
鐃緒申��申鐃緒申					    enum glyph_row_area, int, int));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if GLYPH_DEBUG
+
鐃緒申��申鐃緒申static void x_check_font P_ ((struct frame *, XFontStruct *));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Append the list of glyph strings with head H and tail T to the list
+
鐃緒申��申鐃緒申   with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the result.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_append_glyph_string_lists (head, tail, h, t)
+
鐃緒申��申鐃緒申     struct glyph_string **head, **tail;
+
鐃緒申��申鐃緒申     struct glyph_string *h, *t;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (h)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (*head)
+
鐃緒申��申鐃緒申	(*tail)->next = h;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	*head = h;
+
鐃緒申��申鐃緒申      h->prev = *tail;
+
鐃緒申��申鐃緒申      *tail = t;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Prepend the list of glyph strings with head H and tail T to the
+
鐃緒申��申鐃緒申   list with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the
+
鐃緒申��申鐃緒申   result.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_prepend_glyph_string_lists (head, tail, h, t)
+
鐃緒申��申鐃緒申     struct glyph_string **head, **tail;
+
鐃緒申��申鐃緒申     struct glyph_string *h, *t;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (h)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (*head)
+
鐃緒申��申鐃緒申	(*head)->prev = t;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	*tail = t;
+
鐃緒申��申鐃緒申      t->next = *head;
+
鐃緒申��申鐃緒申      *head = h;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Append glyph string S to the list with head *HEAD and tail *TAIL.
+
鐃緒申��申鐃緒申   Set *HEAD and *TAIL to the resulting list.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_append_glyph_string (head, tail, s)
+
鐃緒申��申鐃緒申     struct glyph_string **head, **tail;
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  s->next = s->prev = NULL;
+
鐃緒申��申鐃緒申  x_append_glyph_string_lists (head, tail, s, s);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set S->gc to a suitable GC for drawing glyph string S in cursor
+
鐃緒申��申鐃緒申   face.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_set_cursor_gc (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (s->font == FRAME_FONT (s->f)
+
鐃緒申��申鐃緒申      && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
+
鐃緒申��申鐃緒申      && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
+
鐃緒申��申鐃緒申      && !s->cmp)
+
鐃緒申��申鐃緒申    s->gc = s->f->output_data.x->cursor_gc;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Cursor on non-default face: must merge.  */
+
鐃緒申��申鐃緒申      XGCValues xgcv;
+
鐃緒申��申鐃緒申      unsigned long mask;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      xgcv.background = s->f->output_data.x->cursor_pixel;
+
鐃緒申��申鐃緒申      xgcv.foreground = s->face->background;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* If the glyph would be invisible, try a different foreground.  */
+
鐃緒申��申鐃緒申      if (xgcv.foreground == xgcv.background)
+
鐃緒申��申鐃緒申	xgcv.foreground = s->face->foreground;
+
鐃緒申��申鐃緒申      if (xgcv.foreground == xgcv.background)
+
鐃緒申��申鐃緒申	xgcv.foreground = s->f->output_data.x->cursor_foreground_pixel;
+
鐃緒申��申鐃緒申      if (xgcv.foreground == xgcv.background)
+
鐃緒申��申鐃緒申	xgcv.foreground = s->face->foreground;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Make sure the cursor is distinct from text in this face.  */
+
鐃緒申��申鐃緒申      if (xgcv.background == s->face->background
+
鐃緒申��申鐃緒申	  && xgcv.foreground == s->face->foreground)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  xgcv.background = s->face->foreground;
+
鐃緒申��申鐃緒申	  xgcv.foreground = s->face->background;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      IF_DEBUG (x_check_font (s->f, s->font));
+
鐃緒申��申鐃緒申      xgcv.font = s->font->fid;
+
鐃緒申��申鐃緒申      xgcv.graphics_exposures = False;
+
鐃緒申��申鐃緒申      mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
+
鐃緒申��申鐃緒申	XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
+
鐃緒申��申鐃緒申		   mask, &xgcv);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc
+
鐃緒申��申鐃緒申	  = XCreateGC (s->display, s->window, mask, &xgcv);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set up S->gc of glyph string S for drawing text in mouse face.  */
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_set_mouse_face_gc (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{     
+
鐃緒申��申鐃緒申  int face_id;
+
鐃緒申��申鐃緒申  struct face *face;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* What face has to be used last for the mouse face?  */
+
鐃緒申��申鐃緒申  face_id = FRAME_X_DISPLAY_INFO (s->f)->mouse_face_face_id;
+
鐃緒申��申鐃緒申  face = FACE_FROM_ID (s->f, face_id);
+
鐃緒申��申鐃緒申  if (face == NULL)
+
鐃緒申��申鐃緒申    face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (s->first_glyph->type == CHAR_GLYPH)
+
鐃緒申��申鐃緒申    face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    face_id = FACE_FOR_CHAR (s->f, face, 0);
+
鐃緒申��申鐃緒申  s->face = FACE_FROM_ID (s->f, face_id);
+
鐃緒申��申鐃緒申  PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If font in this face is same as S->font, use it.  */
+
鐃緒申��申鐃緒申  if (s->font == s->face->font)
+
鐃緒申��申鐃緒申    s->gc = s->face->gc;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Otherwise construct scratch_cursor_gc with values from FACE
+
鐃緒申��申鐃緒申	 but font FONT.  */
+
鐃緒申��申鐃緒申      XGCValues xgcv;
+
鐃緒申��申鐃緒申      unsigned long mask;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      xgcv.background = s->face->background;
+
鐃緒申��申鐃緒申      xgcv.foreground = s->face->foreground;
+
鐃緒申��申鐃緒申      IF_DEBUG (x_check_font (s->f, s->font));
+
鐃緒申��申鐃緒申      xgcv.font = s->font->fid;
+
鐃緒申��申鐃緒申      xgcv.graphics_exposures = False;
+
鐃緒申��申鐃緒申      mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
+
鐃緒申��申鐃緒申	XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
+
鐃緒申��申鐃緒申		   mask, &xgcv);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc
+
鐃緒申��申鐃緒申	  = XCreateGC (s->display, s->window, mask, &xgcv);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (s->gc != 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
+
鐃緒申��申鐃緒申   Faces to use in the mode line have already been computed when the
+
鐃緒申��申鐃緒申   matrix was built, so there isn't much to do, here.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_set_mode_line_face_gc (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{     
+
鐃緒申��申鐃緒申  s->gc = s->face->gc;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set S->gc of glyph string S for drawing that glyph string.  Set
+
鐃緒申��申鐃緒申   S->stippled_p to a non-zero value if the face of S has a stipple
+
鐃緒申��申鐃緒申   pattern.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_set_glyph_string_gc (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (s->hl == DRAW_NORMAL_TEXT)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      s->gc = s->face->gc;
+
鐃緒申��申鐃緒申      s->stippled_p = s->face->stipple != 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (s->hl == DRAW_INVERSE_VIDEO)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_set_mode_line_face_gc (s);
+
鐃緒申��申鐃緒申      s->stippled_p = s->face->stipple != 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (s->hl == DRAW_CURSOR)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_set_cursor_gc (s);
+
鐃緒申��申鐃緒申      s->stippled_p = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (s->hl == DRAW_MOUSE_FACE)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_set_mouse_face_gc (s);
+
鐃緒申��申鐃緒申      s->stippled_p = s->face->stipple != 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (s->hl == DRAW_IMAGE_RAISED
+
鐃緒申��申鐃緒申	   || s->hl == DRAW_IMAGE_SUNKEN)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      s->gc = s->face->gc;
+
鐃緒申��申鐃緒申      s->stippled_p = s->face->stipple != 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      s->gc = s->face->gc;
+
鐃緒申��申鐃緒申      s->stippled_p = s->face->stipple != 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* GC must have been set.  */
+
鐃緒申��申鐃緒申  xassert (s->gc != 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return in *R the clipping rectangle for glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_get_glyph_string_clip_rect (s, r)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     XRectangle *r;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (s->row->full_width_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Draw full-width.  X coordinates are relative to S->w->left.  */
+
鐃緒申��申鐃緒申      int canon_x = CANON_X_UNIT (s->f);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      r->x = WINDOW_LEFT_MARGIN (s->w) * canon_x;
+
鐃緒申��申鐃緒申      r->width = XFASTINT (s->w->width) * canon_x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (FRAME_HAS_VERTICAL_SCROLL_BARS (s->f))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int width = FRAME_SCROLL_BAR_WIDTH (s->f) * canon_x;
+
鐃緒申��申鐃緒申	  if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s->f))
+
鐃緒申��申鐃緒申	    r->x -= width;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      r->x += FRAME_INTERNAL_BORDER_WIDTH (s->f);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Unless displaying a mode or menu bar line, which are always
+
鐃緒申��申鐃緒申	 fully visible, clip to the visible part of the row.  */
+
鐃緒申��申鐃緒申      if (s->w->pseudo_window_p)
+
鐃緒申��申鐃緒申	r->height = s->row->visible_height;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	r->height = s->height;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* This is a text line that may be partially visible.  */
+
鐃緒申��申鐃緒申      r->x = WINDOW_AREA_TO_FRAME_PIXEL_X (s->w, s->area, 0);
+
鐃緒申��申鐃緒申      r->width = window_box_width (s->w, s->area);
+
鐃緒申��申鐃緒申      r->height = s->row->visible_height;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Don't use S->y for clipping because it doesn't take partially
+
鐃緒申��申鐃緒申     visible lines into account.  For example, it can be negative for
+
鐃緒申��申鐃緒申     partially visible lines at the top of a window.  */
+
鐃緒申��申鐃緒申  if (!s->row->full_width_p
+
鐃緒申��申鐃緒申      && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
+
鐃緒申��申鐃緒申    r->y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    r->y = max (0, s->row->y);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If drawing a tool-bar window, draw it over the internal border
+
鐃緒申��申鐃緒申     at the top of the window.  */
+
鐃緒申��申鐃緒申  if (s->w == XWINDOW (s->f->tool_bar_window))
+
鐃緒申��申鐃緒申    r->y -= s->f->output_data.x->internal_border_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If S draws overlapping rows, it's sufficient to use the top and
+
鐃緒申��申鐃緒申     bottom of the window for clipping because this glyph string
+
鐃緒申��申鐃緒申     intentionally draws over other lines.  */
+
鐃緒申��申鐃緒申  if (s->for_overlaps_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      r->y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
+
鐃緒申��申鐃緒申      r->height = window_text_bottom_y (s->w) - r->y;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申  r->y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r->y);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set clipping for output of glyph string S.  S may be part of a mode
+
鐃緒申��申鐃緒申   line or menu if we don't have X toolkit support.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_set_glyph_string_clipping (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XRectangle r;
+
鐃緒申��申鐃緒申  x_get_glyph_string_clip_rect (s, &r);
+
鐃緒申��申鐃緒申  XSetClipRectangles (s->display, s->gc, 0, 0, &r, 1, Unsorted);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Compute left and right overhang of glyph string S.  If S is a glyph
+
鐃緒申��申鐃緒申   string for a composition, assume overhangs don't exist.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_compute_glyph_string_overhangs (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (s->cmp == NULL
+
鐃緒申��申鐃緒申      && s->first_glyph->type == CHAR_GLYPH)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XCharStruct cs;
+
鐃緒申��申鐃緒申      int direction, font_ascent, font_descent;
+
鐃緒申��申鐃緒申      XTextExtents16 (s->font, s->char2b, s->nchars, &direction,
+
鐃緒申��申鐃緒申		      &font_ascent, &font_descent, &cs);
+
鐃緒申��申鐃緒申      s->right_overhang = cs.rbearing > cs.width ? cs.rbearing - cs.width : 0;
+
鐃緒申��申鐃緒申      s->left_overhang = cs.lbearing < 0 ? -cs.lbearing : 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Compute overhangs and x-positions for glyph string S and its
+
鐃緒申��申鐃緒申   predecessors, or successors.  X is the starting x-position for S.
+
鐃緒申��申鐃緒申   BACKWARD_P non-zero means process predecessors.  */
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_compute_overhangs_and_x (s, x, backward_p)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     int x;
+
鐃緒申��申鐃緒申     int backward_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (backward_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      while (s)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x_compute_glyph_string_overhangs (s);
+
鐃緒申��申鐃緒申	  x -= s->width;
+
鐃緒申��申鐃緒申	  s->x = x;
+
鐃緒申��申鐃緒申	  s = s->prev;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      while (s)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x_compute_glyph_string_overhangs (s);
+
鐃緒申��申鐃緒申	  s->x = x;
+
鐃緒申��申鐃緒申	  x += s->width;
+
鐃緒申��申鐃緒申	  s = s->next;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
+
鐃緒申��申鐃緒申   frame F.  Overhangs of glyphs other than type CHAR_GLYPH are
+
鐃緒申��申鐃緒申   assumed to be zero.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_get_glyph_overhangs (glyph, f, left, right)
+
鐃緒申��申鐃緒申     struct glyph *glyph;
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int *left, *right;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  *left = *right = 0;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (glyph->type == CHAR_GLYPH)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XFontStruct *font;
+
鐃緒申��申鐃緒申      struct face *face;
+
鐃緒申��申鐃緒申      struct font_info *font_info;
+
鐃緒申��申鐃緒申      XChar2b char2b;
+
鐃緒申��申鐃緒申      XCharStruct *pcm;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      face = x_get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
+
鐃緒申��申鐃緒申      font = face->font;
+
鐃緒申��申鐃緒申      font_info = FONT_INFO_FROM_ID (f, face->font_info_id);
+
鐃緒申��申鐃緒申      if (font
+
鐃緒申��申鐃緒申	  && (pcm = x_per_char_metric (font, &char2b)))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (pcm->rbearing > pcm->width)
+
鐃緒申��申鐃緒申	    *right = pcm->rbearing - pcm->width;
+
鐃緒申��申鐃緒申	  if (pcm->lbearing < 0)
+
鐃緒申��申鐃緒申	    *left = -pcm->lbearing;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return the index of the first glyph preceding glyph string S that
+
鐃緒申��申鐃緒申   is overwritten by S because of S's left overhang.  Value is -1
+
鐃緒申��申鐃緒申   if no glyphs are overwritten.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_left_overwritten (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int k;
+
鐃緒申��申鐃緒申    
+
鐃緒申��申鐃緒申  if (s->left_overhang)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int x = 0, i;
+
鐃緒申��申鐃緒申      struct glyph *glyphs = s->row->glyphs[s->area];
+
鐃緒申��申鐃緒申      int first = s->first_glyph - glyphs;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
+
鐃緒申��申鐃緒申	x -= glyphs[i].pixel_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      k = i + 1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    k = -1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return k;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return the index of the first glyph preceding glyph string S that
+
鐃緒申��申鐃緒申   is overwriting S because of its right overhang.  Value is -1 if no
+
鐃緒申��申鐃緒申   glyph in front of S overwrites S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_left_overwriting (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i, k, x;
+
鐃緒申��申鐃緒申  struct glyph *glyphs = s->row->glyphs[s->area];
+
鐃緒申��申鐃緒申  int first = s->first_glyph - glyphs;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  k = -1;
+
鐃緒申��申鐃緒申  x = 0;
+
鐃緒申��申鐃緒申  for (i = first - 1; i >= 0; --i)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int left, right;
+
鐃緒申��申鐃緒申      x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
+
鐃緒申��申鐃緒申      if (x + right > 0)
+
鐃緒申��申鐃緒申	k = i;
+
鐃緒申��申鐃緒申      x -= glyphs[i].pixel_width;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return k;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return the index of the last glyph following glyph string S that is
+
鐃緒申��申鐃緒申   not overwritten by S because of S's right overhang.  Value is -1 if
+
鐃緒申��申鐃緒申   no such glyph is found.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_right_overwritten (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int k = -1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (s->right_overhang)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int x = 0, i;
+
鐃緒申��申鐃緒申      struct glyph *glyphs = s->row->glyphs[s->area];
+
鐃緒申��申鐃緒申      int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
+
鐃緒申��申鐃緒申      int end = s->row->used[s->area];
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      for (i = first; i < end && s->right_overhang > x; ++i)
+
鐃緒申��申鐃緒申	x += glyphs[i].pixel_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      k = i;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return k;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return the index of the last glyph following glyph string S that
+
鐃緒申��申鐃緒申   overwrites S because of its left overhang.  Value is negative
+
鐃緒申��申鐃緒申   if no such glyph is found.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_right_overwriting (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i, k, x;
+
鐃緒申��申鐃緒申  int end = s->row->used[s->area];
+
鐃緒申��申鐃緒申  struct glyph *glyphs = s->row->glyphs[s->area];
+
鐃緒申��申鐃緒申  int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  k = -1;
+
鐃緒申��申鐃緒申  x = 0;
+
鐃緒申��申鐃緒申  for (i = first; i < end; ++i)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int left, right;
+
鐃緒申��申鐃緒申      x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
+
鐃緒申��申鐃緒申      if (x - left < 0)
+
鐃緒申��申鐃緒申	k = i;
+
鐃緒申��申鐃緒申      x += glyphs[i].pixel_width;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return k;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Fill rectangle X, Y, W, H with background color of glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_clear_glyph_string_rect (s, x, y, w, h)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     int x, y, w, h;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XGCValues xgcv;
+
鐃緒申��申鐃緒申  XGetGCValues (s->display, s->gc, GCForeground | GCBackground, &xgcv);
+
鐃緒申��申鐃緒申  XSetForeground (s->display, s->gc, xgcv.background);
+
鐃緒申��申鐃緒申  XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
+
鐃緒申��申鐃緒申  XSetForeground (s->display, s->gc, xgcv.foreground);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw the background of glyph_string S.  If S->background_filled_p
+
鐃緒申��申鐃緒申   is non-zero don't draw it.  FORCE_P non-zero means draw the
+
鐃緒申��申鐃緒申   background even if it wouldn't be drawn normally.  This is used
+
鐃緒申��申鐃緒申   when a string preceding S draws into the background of S, or S
+
鐃緒申��申鐃緒申   contains the first component of a composition.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_glyph_string_background (s, force_p)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     int force_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Nothing to do if background has already been drawn or if it
+
鐃緒申��申鐃緒申     shouldn't be drawn in the first place.  */
+
鐃緒申��申鐃緒申  if (!s->background_filled_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int box_line_width = max (s->face->box_line_width, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (s->stippled_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* Fill background with a stipple pattern.  */
+
鐃緒申��申鐃緒申	  XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
+
鐃緒申��申鐃緒申	  XFillRectangle (s->display, s->window, s->gc, s->x,
+
鐃緒申��申鐃緒申			  s->y + box_line_width,
+
鐃緒申��申鐃緒申			  s->background_width,
+
鐃緒申��申鐃緒申			  s->height - 2 * box_line_width);
+
鐃緒申��申鐃緒申	  XSetFillStyle (s->display, s->gc, FillSolid);
+
鐃緒申��申鐃緒申	  s->background_filled_p = 1;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
+
鐃緒申��申鐃緒申	       || s->font_not_found_p
+
鐃緒申��申鐃緒申	       || s->extends_to_end_of_line_p
+
鐃緒申��申鐃緒申	       || force_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
+
鐃緒申��申鐃緒申				     s->background_width,
+
鐃緒申��申鐃緒申				     s->height - 2 * box_line_width);
+
鐃緒申��申鐃緒申	  s->background_filled_p = 1;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw the foreground of glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_glyph_string_foreground (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i, x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If first glyph of S has a left box line, start drawing the text
+
鐃緒申��申鐃緒申     of S to the right of that box line.  */
+
鐃緒申��申鐃緒申  if (s->face->box != FACE_NO_BOX
+
鐃緒申��申鐃緒申      && s->first_glyph->left_box_line_p)
+
鐃緒申��申鐃緒申    x = s->x + abs (s->face->box_line_width);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x = s->x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Draw characters of S as rectangles if S's font could not be
+
鐃緒申��申鐃緒申     loaded.  */
+
鐃緒申��申鐃緒申  if (s->font_not_found_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      for (i = 0; i < s->nchars; ++i)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  struct glyph *g = s->first_glyph + i;
+
鐃緒申��申鐃緒申	  XDrawRectangle (s->display, s->window,
+
鐃緒申��申鐃緒申			  s->gc, x, s->y, g->pixel_width - 1,
+
鐃緒申��申鐃緒申			  s->height - 1);
+
鐃緒申��申鐃緒申	  x += g->pixel_width;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      char *char1b = (char *) s->char2b;
+
鐃緒申��申鐃緒申      int boff = s->font_info->baseline_offset;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (s->font_info->vertical_centering)
+
鐃緒申��申鐃緒申	boff = VCENTER_BASELINE_OFFSET (s->font, s->f) - boff;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* If we can use 8-bit functions, condense S->char2b.  */
+
鐃緒申��申鐃緒申      if (!s->two_byte_p)
+
鐃緒申��申鐃緒申	for (i = 0; i < s->nchars; ++i)
+
鐃緒申��申鐃緒申	  char1b[i] = s->char2b[i].byte2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Draw text with XDrawString if background has already been
+
鐃緒申��申鐃緒申	 filled.  Otherwise, use XDrawImageString.  (Note that
+
鐃緒申��申鐃緒申	 XDrawImageString is usually faster than XDrawString.)  Always
+
鐃緒申��申鐃緒申	 use XDrawImageString when drawing the cursor so that there is
+
鐃緒申��申鐃緒申	 no chance that characters under a box cursor are invisible.  */
+
鐃緒申��申鐃緒申      if (s->for_overlaps_p
+
鐃緒申��申鐃緒申	  || (s->background_filled_p && s->hl != DRAW_CURSOR))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* Draw characters with 16-bit or 8-bit functions.  */
+
鐃緒申��申鐃緒申	  if (s->two_byte_p)
+
鐃緒申��申鐃緒申	    XDrawString16 (s->display, s->window, s->gc, x,
+
鐃緒申��申鐃緒申			   s->ybase - boff, s->char2b, s->nchars);
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    XDrawString (s->display, s->window, s->gc, x,
+
鐃緒申��申鐃緒申			 s->ybase - boff, char1b, s->nchars);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (s->two_byte_p)
+
鐃緒申��申鐃緒申	    XDrawImageString16 (s->display, s->window, s->gc, x,
+
鐃緒申��申鐃緒申				s->ybase - boff, s->char2b, s->nchars);
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    XDrawImageString (s->display, s->window, s->gc, x,
+
鐃緒申��申鐃緒申			      s->ybase - boff, char1b, s->nchars);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw the foreground of composite glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_composite_glyph_string_foreground (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i, x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If first glyph of S has a left box line, start drawing the text
+
鐃緒申��申鐃緒申     of S to the right of that box line.  */
+
鐃緒申��申鐃緒申  if (s->face->box != FACE_NO_BOX
+
鐃緒申��申鐃緒申      && s->first_glyph->left_box_line_p)
+
鐃緒申��申鐃緒申    x = s->x + abs (s->face->box_line_width);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x = s->x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* S is a glyph string for a composition.  S->gidx is the index of
+
鐃緒申��申鐃緒申     the first character drawn for glyphs of this composition.
+
鐃緒申��申鐃緒申     S->gidx == 0 means we are drawing the very first character of
+
鐃緒申��申鐃緒申     this composition.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Draw a rectangle for the composition if the font for the very
+
鐃緒申��申鐃緒申     first character of the composition could not be loaded.  */
+
鐃緒申��申鐃緒申  if (s->font_not_found_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (s->gidx == 0)
+
鐃緒申��申鐃緒申	XDrawRectangle (s->display, s->window, s->gc, x, s->y,
+
鐃緒申��申鐃緒申			s->width - 1, s->height - 1);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      for (i = 0; i < s->nchars; i++, ++s->gidx)
+
鐃緒申��申鐃緒申	XDrawString16 (s->display, s->window, s->gc,
+
鐃緒申��申鐃緒申		       x + s->cmp->offsets[s->gidx * 2],
+
鐃緒申��申鐃緒申		       s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
+
鐃緒申��申鐃緒申		       s->char2b + i, 1);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct frame *x_frame_of_widget P_ ((Widget));
+
鐃緒申��申鐃緒申static Boolean cvt_string_to_pixel P_ ((Display *, XrmValue *, Cardinal *,
+
鐃緒申��申鐃緒申					XrmValue *, XrmValue *, XtPointer *));
+
鐃緒申��申鐃緒申static void cvt_pixel_dtor P_ ((XtAppContext, XrmValue *, XtPointer,
+
鐃緒申��申鐃緒申				XrmValue *, Cardinal *));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return the frame on which widget WIDGET is used.. Abort if frame
+
鐃緒申��申鐃緒申   cannot be determined.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct frame *
+
鐃緒申��申鐃緒申x_frame_of_widget (widget)
+
鐃緒申��申鐃緒申     Widget widget;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申  Lisp_Object tail;
+
鐃緒申��申鐃緒申  struct frame *f;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  dpyinfo = x_display_info_for_display (XtDisplay (widget));
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Find the top-level shell of the widget.  Note that this function
+
鐃緒申��申鐃緒申     can be called when the widget is not yet realized, so XtWindow
+
鐃緒申��申鐃緒申     (widget) == 0.  That's the reason we can't simply use
+
鐃緒申��申鐃緒申     x_any_window_to_frame.  */
+
鐃緒申��申鐃緒申  while (!XtIsTopLevelShell (widget))
+
鐃緒申��申鐃緒申    widget = XtParent (widget);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Look for a frame with that top-level widget.  Allocate the color
+
鐃緒申��申鐃緒申     on that frame to get the right gamma correction value.  */
+
鐃緒申��申鐃緒申  for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
+
鐃緒申��申鐃緒申    if (GC_FRAMEP (XCAR (tail))
+
鐃緒申��申鐃緒申	&& (f = XFRAME (XCAR (tail)),
+
鐃緒申��申鐃緒申	    (f->output_data.nothing != 1
+
鐃緒申��申鐃緒申	     && FRAME_X_DISPLAY_INFO (f) == dpyinfo))
+
鐃緒申��申鐃緒申	&& f->output_data.x->widget == widget)
+
鐃緒申��申鐃緒申      return f;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  abort ();
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Allocate the color COLOR->pixel on the screen and display of
+
鐃緒申��申鐃緒申   widget WIDGET in colormap CMAP.  If an exact match cannot be
+
鐃緒申��申鐃緒申   allocated, try the nearest color available.  Value is non-zero
+
鐃緒申��申鐃緒申   if successful.  This is called from lwlib.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申x_alloc_nearest_color_for_widget (widget, cmap, color)
+
鐃緒申��申鐃緒申     Widget widget;
+
鐃緒申��申鐃緒申     Colormap cmap;
+
鐃緒申��申鐃緒申     XColor *color;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = x_frame_of_widget (widget);
+
鐃緒申��申鐃緒申  return x_alloc_nearest_color (f, cmap, color);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Allocate a color which is lighter or darker than *PIXEL by FACTOR
+
鐃緒申��申鐃緒申   or DELTA.  Try a color with RGB values multiplied by FACTOR first.
+
鐃緒申��申鐃緒申   If this produces the same color as PIXEL, try a color where all RGB
+
鐃緒申��申鐃緒申   values have DELTA added.  Return the allocated color in *PIXEL.
+
鐃緒申��申鐃緒申   DISPLAY is the X display, CMAP is the colormap to operate on.
+
鐃緒申��申鐃緒申   Value is non-zero if successful.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申x_alloc_lighter_color_for_widget (widget, display, cmap, pixel, factor, delta)
+
鐃緒申��申鐃緒申     Widget widget;
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申     Colormap cmap;
+
鐃緒申��申鐃緒申     unsigned long *pixel;
+
鐃緒申��申鐃緒申     double factor;
+
鐃緒申��申鐃緒申     int delta;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = x_frame_of_widget (widget);
+
鐃緒申��申鐃緒申  return x_alloc_lighter_color (f, display, cmap, pixel, factor, delta);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Structure specifying which arguments should be passed by Xt to
+
鐃緒申��申鐃緒申   cvt_string_to_pixel.  We want the widget's screen and colormap.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static XtConvertArgRec cvt_string_to_pixel_args[] =
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    {XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.screen),
+
鐃緒申��申鐃緒申     sizeof (Screen *)},
+
鐃緒申��申鐃緒申    {XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.colormap),
+
鐃緒申��申鐃緒申     sizeof (Colormap)}
+
鐃緒申��申鐃緒申  };
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The address of this variable is returned by
+
鐃緒申��申鐃緒申   cvt_string_to_pixel.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Pixel cvt_string_to_pixel_value;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Convert a color name to a pixel color.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   DPY is the display we are working on.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   ARGS is an array of *NARGS XrmValue structures holding additional
+
鐃緒申��申鐃緒申   information about the widget for which the conversion takes place.
+
鐃緒申��申鐃緒申   The contents of this array are determined by the specification
+
鐃緒申��申鐃緒申   in cvt_string_to_pixel_args.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   FROM is a pointer to an XrmValue which points to the color name to
+
鐃緒申��申鐃緒申   convert.  TO is an XrmValue in which to return the pixel color.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   CLOSURE_RET is a pointer to user-data, in which we record if
+
鐃緒申��申鐃緒申   we allocated the color or not.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Value is True if successful, False otherwise.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Boolean
+
鐃緒申��申鐃緒申cvt_string_to_pixel (dpy, args, nargs, from, to, closure_ret)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申     XrmValue *args;
+
鐃緒申��申鐃緒申     Cardinal *nargs;
+
鐃緒申��申鐃緒申     XrmValue *from, *to;
+
鐃緒申��申鐃緒申     XtPointer *closure_ret;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Screen *screen;
+
鐃緒申��申鐃緒申  Colormap cmap;
+
鐃緒申��申鐃緒申  Pixel pixel;
+
鐃緒申��申鐃緒申  String color_name;
+
鐃緒申��申鐃緒申  XColor color;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (*nargs != 2)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
+
鐃緒申��申鐃緒申		       "wrongParameters", "cvt_string_to_pixel",
+
鐃緒申��申鐃緒申		       "XtToolkitError",
+
鐃緒申��申鐃緒申		       "Screen and colormap args required", NULL, NULL);
+
鐃緒申��申鐃緒申      return False;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  screen = *(Screen **) args[0].addr;
+
鐃緒申��申鐃緒申  cmap = *(Colormap *) args[1].addr;
+
鐃緒申��申鐃緒申  color_name = (String) from->addr;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (strcmp (color_name, XtDefaultBackground) == 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      *closure_ret = (XtPointer) False;
+
鐃緒申��申鐃緒申      pixel = WhitePixelOfScreen (screen);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (strcmp (color_name, XtDefaultForeground) == 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      *closure_ret = (XtPointer) False;
+
鐃緒申��申鐃緒申      pixel = BlackPixelOfScreen (screen);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (XParseColor (dpy, cmap, color_name, &color)
+
鐃緒申��申鐃緒申	   && x_alloc_nearest_color_1 (dpy, cmap, &color))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      pixel = color.pixel;
+
鐃緒申��申鐃緒申      *closure_ret = (XtPointer) True;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      String params[1];
+
鐃緒申��申鐃緒申      Cardinal nparams = 1;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      params[0] = color_name;
+
鐃緒申��申鐃緒申      XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
+
鐃緒申��申鐃緒申		       "badValue", "cvt_string_to_pixel",
+
鐃緒申��申鐃緒申		       "XtToolkitError", "Invalid color `%s'",
+
鐃緒申��申鐃緒申		       params, &nparams);
+
鐃緒申��申鐃緒申      return False;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (to->addr != NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (to->size < sizeof (Pixel))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  to->size = sizeof (Pixel);
+
鐃緒申��申鐃緒申	  return False;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      *(Pixel *) to->addr = pixel;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      cvt_string_to_pixel_value = pixel;
+
鐃緒申��申鐃緒申      to->addr = (XtPointer) &cvt_string_to_pixel_value;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  to->size = sizeof (Pixel);
+
鐃緒申��申鐃緒申  return True;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Free a pixel color which was previously allocated via
+
鐃緒申��申鐃緒申   cvt_string_to_pixel.  This is registered as the destructor
+
鐃緒申��申鐃緒申   for this type of resource via XtSetTypeConverter.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   APP is the application context in which we work.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   TO is a pointer to an XrmValue holding the color to free.
+
鐃緒申��申鐃緒申   CLOSURE is the value we stored in CLOSURE_RET for this color
+
鐃緒申��申鐃緒申   in cvt_string_to_pixel.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   ARGS and NARGS are like for cvt_string_to_pixel.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申cvt_pixel_dtor (app, to, closure, args, nargs)
+
鐃緒申��申鐃緒申    XtAppContext app;
+
鐃緒申��申鐃緒申    XrmValuePtr to;
+
鐃緒申��申鐃緒申    XtPointer closure;
+
鐃緒申��申鐃緒申    XrmValuePtr args;
+
鐃緒申��申鐃緒申    Cardinal *nargs;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (*nargs != 2)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XtAppWarningMsg (app, "wrongParameters", "cvt_pixel_dtor",
+
鐃緒申��申鐃緒申		       "XtToolkitError",
+
鐃緒申��申鐃緒申		       "Screen and colormap arguments required",
+
鐃緒申��申鐃緒申		       NULL, NULL);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (closure != NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* We did allocate the pixel, so free it.  */
+
鐃緒申��申鐃緒申      Screen *screen = *(Screen **) args[0].addr;
+
鐃緒申��申鐃緒申      Colormap cmap = *(Colormap *) args[1].addr;
+
鐃緒申��申鐃緒申      x_free_dpy_colors (DisplayOfScreen (screen), screen, cmap,
+
鐃緒申��申鐃緒申			 (Pixel *) to->addr, 1, 0);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Value is an array of XColor structures for the contents of the
+
鐃緒申��申鐃緒申   color map of display DPY.  Set *NCELLS to the size of the array.
+
鐃緒申��申鐃緒申   Note that this probably shouldn't be called for large color maps,
+
鐃緒申��申鐃緒申   say a 24-bit TrueColor map.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static const XColor *
+
鐃緒申��申鐃緒申x_color_cells (dpy, ncells)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申     int *ncells;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (dpyinfo->color_cells == NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Screen *screen = dpyinfo->screen;
+
鐃緒申��申鐃緒申      int i;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      dpyinfo->ncolor_cells
+
鐃緒申��申鐃緒申	= XDisplayCells (dpy, XScreenNumberOfScreen (screen));
+
鐃緒申��申鐃緒申      dpyinfo->color_cells
+
鐃緒申��申鐃緒申	= (XColor *) xmalloc (dpyinfo->ncolor_cells
+
鐃緒申��申鐃緒申			      * sizeof *dpyinfo->color_cells);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      for (i = 0; i < dpyinfo->ncolor_cells; ++i)
+
鐃緒申��申鐃緒申	dpyinfo->color_cells[i].pixel = i;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      XQueryColors (dpy, dpyinfo->cmap,
+
鐃緒申��申鐃緒申		    dpyinfo->color_cells, dpyinfo->ncolor_cells);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  *ncells = dpyinfo->ncolor_cells;
+
鐃緒申��申鐃緒申  return dpyinfo->color_cells;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* On frame F, translate pixel colors to RGB values for the NCOLORS
+
鐃緒申��申鐃緒申   colors in COLORS.  Use cached information, if available.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_query_colors (f, colors, ncolors)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     XColor *colors;
+
鐃緒申��申鐃緒申     int ncolors;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (dpyinfo->color_cells)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int i;
+
鐃緒申��申鐃緒申      for (i = 0; i < ncolors; ++i)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  unsigned long pixel = colors[i].pixel;
+
鐃緒申��申鐃緒申	  xassert (pixel < dpyinfo->ncolor_cells);
+
鐃緒申��申鐃緒申	  xassert (dpyinfo->color_cells[pixel].pixel == pixel);
+
鐃緒申��申鐃緒申	  colors[i] = dpyinfo->color_cells[pixel];
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors, ncolors);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* On frame F, translate pixel color to RGB values for the color in
+
鐃緒申��申鐃緒申   COLOR.  Use cached information, if available.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_query_color (f, color)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     XColor *color;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  x_query_colors (f, color, 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申     
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP.  If an
+
鐃緒申��申鐃緒申   exact match can't be allocated, try the nearest color available.
+
鐃緒申��申鐃緒申   Value is non-zero if successful.  Set *COLOR to the color
+
鐃緒申��申鐃緒申   allocated.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_alloc_nearest_color_1 (dpy, cmap, color)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申     Colormap cmap;
+
鐃緒申��申鐃緒申     XColor *color;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int rc;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  rc = XAllocColor (dpy, cmap, color);
+
鐃緒申��申鐃緒申  if (rc == 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* If we got to this point, the colormap is full, so we're going
+
鐃緒申��申鐃緒申	 to try to get the next closest color.  The algorithm used is
+
鐃緒申��申鐃緒申	 a least-squares matching, which is what X uses for closest
+
鐃緒申��申鐃緒申	 color matching with StaticColor visuals.  */
+
鐃緒申��申鐃緒申      int nearest, i;
+
鐃緒申��申鐃緒申      unsigned long nearest_delta = ~0;
+
鐃緒申��申鐃緒申      int ncells;
+
鐃緒申��申鐃緒申      const XColor *cells = x_color_cells (dpy, &ncells);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      for (nearest = i = 0; i < ncells; ++i)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  long dred   = (color->red   >> 8) - (cells[i].red   >> 8);
+
鐃緒申��申鐃緒申	  long dgreen = (color->green >> 8) - (cells[i].green >> 8);
+
鐃緒申��申鐃緒申	  long dblue  = (color->blue  >> 8) - (cells[i].blue  >> 8);
+
鐃緒申��申鐃緒申	  unsigned long delta = dred * dred + dgreen * dgreen + dblue * dblue;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (delta < nearest_delta)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      nearest = i;
+
鐃緒申��申鐃緒申	      nearest_delta = delta;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      color->red   = cells[nearest].red;
+
鐃緒申��申鐃緒申      color->green = cells[nearest].green;
+
鐃緒申��申鐃緒申      color->blue  = cells[nearest].blue;
+
鐃緒申��申鐃緒申      rc = XAllocColor (dpy, cmap, color);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* If allocation succeeded, and the allocated pixel color is not
+
鐃緒申��申鐃緒申         equal to a cached pixel color recorded earlier, there was a
+
鐃緒申��申鐃緒申         change in the colormap, so clear the color cache.  */
+
鐃緒申��申鐃緒申      struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
+
鐃緒申��申鐃緒申      XColor *cached_color;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if (dpyinfo->color_cells
+
鐃緒申��申鐃緒申	  && (cached_color = &dpyinfo->color_cells[color->pixel],
+
鐃緒申��申鐃緒申	      (cached_color->red != color->red
+
鐃緒申��申鐃緒申	       || cached_color->blue != color->blue
+
鐃緒申��申鐃緒申	       || cached_color->green != color->green)))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  xfree (dpyinfo->color_cells);
+
鐃緒申��申鐃緒申	  dpyinfo->color_cells = NULL;
+
鐃緒申��申鐃緒申	  dpyinfo->ncolor_cells = 0;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef DEBUG_X_COLORS
+
鐃緒申��申鐃緒申  if (rc)
+
鐃緒申��申鐃緒申    register_color (color->pixel);
+
鐃緒申��申鐃緒申#endif /* DEBUG_X_COLORS */
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  return rc;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Allocate the color COLOR->pixel on frame F, colormap CMAP.  If an
+
鐃緒申��申鐃緒申   exact match can't be allocated, try the nearest color available.
+
鐃緒申��申鐃緒申   Value is non-zero if successful.  Set *COLOR to the color
+
鐃緒申��申鐃緒申   allocated.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申x_alloc_nearest_color (f, cmap, color)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     Colormap cmap;
+
鐃緒申��申鐃緒申     XColor *color;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  gamma_correct (f, color);
+
鐃緒申��申鐃緒申  return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f), cmap, color);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Allocate color PIXEL on frame F.  PIXEL must already be allocated.
+
鐃緒申��申鐃緒申   It's necessary to do this instead of just using PIXEL directly to
+
鐃緒申��申鐃緒申   get color reference counts right.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申unsigned long
+
鐃緒申��申鐃緒申x_copy_color (f, pixel)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     unsigned long pixel;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XColor color;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  color.pixel = pixel;
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  x_query_color (f, &color);
+
鐃緒申��申鐃緒申  XAllocColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &color);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申#ifdef DEBUG_X_COLORS
+
鐃緒申��申鐃緒申  register_color (pixel);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  return color.pixel;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Allocate color PIXEL on display DPY.  PIXEL must already be allocated.
+
鐃緒申��申鐃緒申   It's necessary to do this instead of just using PIXEL directly to
+
鐃緒申��申鐃緒申   get color reference counts right.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申unsigned long
+
鐃緒申��申鐃緒申x_copy_dpy_color (dpy, cmap, pixel)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申     Colormap cmap;
+
鐃緒申��申鐃緒申     unsigned long pixel;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XColor color;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  color.pixel = pixel;
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  XQueryColor (dpy, cmap, &color);
+
鐃緒申��申鐃緒申  XAllocColor (dpy, cmap, &color);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申#ifdef DEBUG_X_COLORS
+
鐃緒申��申鐃緒申  register_color (pixel);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  return color.pixel;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Brightness beyond which a color won't have its highlight brightness
+
鐃緒申��申鐃緒申   boosted.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Nominally, highlight colors for `3d' faces are calculated by
+
鐃緒申��申鐃緒申   brightening an object's color by a constant scale factor, but this
+
鐃緒申��申鐃緒申   doesn't yield good results for dark colors, so for colors who's
+
鐃緒申��申鐃緒申   brightness is less than this value (on a scale of 0-65535) have an
+
鐃緒申��申鐃緒申   use an additional additive factor.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   The value here is set so that the default menu-bar/mode-line color
+
鐃緒申��申鐃緒申   (grey75) will not have its highlights changed at all.  */
+
鐃緒申��申鐃緒申#define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Allocate a color which is lighter or darker than *PIXEL by FACTOR
+
鐃緒申��申鐃緒申   or DELTA.  Try a color with RGB values multiplied by FACTOR first.
+
鐃緒申��申鐃緒申   If this produces the same color as PIXEL, try a color where all RGB
+
鐃緒申��申鐃緒申   values have DELTA added.  Return the allocated color in *PIXEL.
+
鐃緒申��申鐃緒申   DISPLAY is the X display, CMAP is the colormap to operate on.
+
鐃緒申��申鐃緒申   Value is non-zero if successful.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_alloc_lighter_color (f, display, cmap, pixel, factor, delta)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申     Colormap cmap;
+
鐃緒申��申鐃緒申     unsigned long *pixel;
+
鐃緒申��申鐃緒申     double factor;
+
鐃緒申��申鐃緒申     int delta;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XColor color, new;
+
鐃緒申��申鐃緒申  long bright;
+
鐃緒申��申鐃緒申  int success_p;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get RGB color values.  */
+
鐃緒申��申鐃緒申  color.pixel = *pixel;
+
鐃緒申��申鐃緒申  x_query_color (f, &color);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Change RGB values by specified FACTOR.  Avoid overflow!  */
+
鐃緒申��申鐃緒申  xassert (factor >= 0);
+
鐃緒申��申鐃緒申  new.red = min (0xffff, factor * color.red);
+
鐃緒申��申鐃緒申  new.green = min (0xffff, factor * color.green);
+
鐃緒申��申鐃緒申  new.blue = min (0xffff, factor * color.blue);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Calculate brightness of COLOR.  */
+
鐃緒申��申鐃緒申  bright = (2 * color.red + 3 * color.green + color.blue) / 6;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We only boost colors that are darker than
+
鐃緒申��申鐃緒申     HIGHLIGHT_COLOR_DARK_BOOST_LIMIT.  */
+
鐃緒申��申鐃緒申  if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
+
鐃緒申��申鐃緒申    /* Make an additive adjustment to NEW, because it's dark enough so
+
鐃緒申��申鐃緒申       that scaling by FACTOR alone isn't enough.  */
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* How far below the limit this color is (0 - 1, 1 being darker).  */
+
鐃緒申��申鐃緒申      double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
+
鐃緒申��申鐃緒申      /* The additive adjustment.  */
+
鐃緒申��申鐃緒申      int min_delta = delta * dimness * factor / 2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (factor < 1)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  new.red =   max (0, new.red -   min_delta);
+
鐃緒申��申鐃緒申	  new.green = max (0, new.green - min_delta);
+
鐃緒申��申鐃緒申	  new.blue =  max (0, new.blue -  min_delta);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  new.red =   min (0xffff, min_delta + new.red);
+
鐃緒申��申鐃緒申	  new.green = min (0xffff, min_delta + new.green);
+
鐃緒申��申鐃緒申	  new.blue =  min (0xffff, min_delta + new.blue);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Try to allocate the color.  */
+
鐃緒申��申鐃緒申  success_p = x_alloc_nearest_color (f, cmap, &new);
+
鐃緒申��申鐃緒申  if (success_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (new.pixel == *pixel)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* If we end up with the same color as before, try adding
+
鐃緒申��申鐃緒申	     delta to the RGB values.  */
+
鐃緒申��申鐃緒申	  x_free_colors (f, &new.pixel, 1);
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  new.red = min (0xffff, delta + color.red);
+
鐃緒申��申鐃緒申	  new.green = min (0xffff, delta + color.green);
+
鐃緒申��申鐃緒申	  new.blue = min (0xffff, delta + color.blue);
+
鐃緒申��申鐃緒申	  success_p = x_alloc_nearest_color (f, cmap, &new);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	success_p = 1;
+
鐃緒申��申鐃緒申      *pixel = new.pixel;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  return success_p;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set up the foreground color for drawing relief lines of glyph
+
鐃緒申��申鐃緒申   string S.  RELIEF is a pointer to a struct relief containing the GC
+
鐃緒申��申鐃緒申   with which lines will be drawn.  Use a color that is FACTOR or
+
鐃緒申��申鐃緒申   DELTA lighter or darker than the relief's background which is found
+
鐃緒申��申鐃緒申   in S->f->output_data.x->relief_background.  If such a color cannot
+
鐃緒申��申鐃緒申   be allocated, use DEFAULT_PIXEL, instead.  */
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_setup_relief_color (f, relief, factor, delta, default_pixel)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     struct relief *relief;
+
鐃緒申��申鐃緒申     double factor;
+
鐃緒申��申鐃緒申     int delta;
+
鐃緒申��申鐃緒申     unsigned long default_pixel;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XGCValues xgcv;
+
鐃緒申��申鐃緒申  struct x_output *di = f->output_data.x;
+
鐃緒申��申鐃緒申  unsigned long mask = GCForeground | GCLineWidth | GCGraphicsExposures;
+
鐃緒申��申鐃緒申  unsigned long pixel;
+
鐃緒申��申鐃緒申  unsigned long background = di->relief_background;
+
鐃緒申��申鐃緒申  Colormap cmap = FRAME_X_COLORMAP (f);
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  Display *dpy = FRAME_X_DISPLAY (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xgcv.graphics_exposures = False;
+
鐃緒申��申鐃緒申  xgcv.line_width = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Free previously allocated color.  The color cell will be reused
+
鐃緒申��申鐃緒申     when it has been freed as many times as it was allocated, so this
+
鐃緒申��申鐃緒申     doesn't affect faces using the same colors.  */
+
鐃緒申��申鐃緒申  if (relief->gc
+
鐃緒申��申鐃緒申      && relief->allocated_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_free_colors (f, &relief->pixel, 1);
+
鐃緒申��申鐃緒申      relief->allocated_p = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Allocate new color.  */
+
鐃緒申��申鐃緒申  xgcv.foreground = default_pixel;
+
鐃緒申��申鐃緒申  pixel = background;
+
鐃緒申��申鐃緒申  if (dpyinfo->n_planes != 1
+
鐃緒申��申鐃緒申      && x_alloc_lighter_color (f, dpy, cmap, &pixel, factor, delta))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      relief->allocated_p = 1;
+
鐃緒申��申鐃緒申      xgcv.foreground = relief->pixel = pixel;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (relief->gc == 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      xgcv.stipple = dpyinfo->gray;
+
鐃緒申��申鐃緒申      mask |= GCStipple;
+
鐃緒申��申鐃緒申      relief->gc = XCreateGC (dpy, FRAME_X_WINDOW (f), mask, &xgcv);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    XChangeGC (dpy, relief->gc, mask, &xgcv);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set up colors for the relief lines around glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_setup_relief_colors (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_output *di = s->f->output_data.x;
+
鐃緒申��申鐃緒申  unsigned long color;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (s->face->use_box_color_for_shadows_p)
+
鐃緒申��申鐃緒申    color = s->face->box_color;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XGCValues xgcv;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Get the background color of the face.  */
+
鐃緒申��申鐃緒申      XGetGCValues (s->display, s->gc, GCBackground, &xgcv);
+
鐃緒申��申鐃緒申      color = xgcv.background;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (di->white_relief.gc == 0
+
鐃緒申��申鐃緒申      || color != di->relief_background)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      di->relief_background = color;
+
鐃緒申��申鐃緒申      x_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
+
鐃緒申��申鐃緒申			    WHITE_PIX_DEFAULT (s->f));
+
鐃緒申��申鐃緒申      x_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
+
鐃緒申��申鐃緒申			    BLACK_PIX_DEFAULT (s->f));
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw a relief on frame F inside the rectangle given by LEFT_X,
+
鐃緒申��申鐃緒申   TOP_Y, RIGHT_X, and BOTTOM_Y.  WIDTH is the thickness of the relief
+
鐃緒申��申鐃緒申   to draw, it must be >= 0.  RAISED_P non-zero means draw a raised
+
鐃緒申��申鐃緒申   relief.  LEFT_P non-zero means draw a relief on the left side of
+
鐃緒申��申鐃緒申   the rectangle.  RIGHT_P non-zero means draw a relief on the right
+
鐃緒申��申鐃緒申   side of the rectangle.  CLIP_RECT is the clipping rectangle to use
+
鐃緒申��申鐃緒申   when drawing.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_relief_rect (f, left_x, top_y, right_x, bottom_y, width,
+
鐃緒申��申鐃緒申		    raised_p, left_p, right_p, clip_rect)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int left_x, top_y, right_x, bottom_y, left_p, right_p, raised_p;
+
鐃緒申��申鐃緒申     XRectangle *clip_rect;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i;
+
鐃緒申��申鐃緒申  GC gc;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (raised_p)
+
鐃緒申��申鐃緒申    gc = f->output_data.x->white_relief.gc;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    gc = f->output_data.x->black_relief.gc;
+
鐃緒申��申鐃緒申  XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, clip_rect, 1, Unsorted);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Top.  */
+
鐃緒申��申鐃緒申  for (i = 0; i < width; ++i)
+
鐃緒申��申鐃緒申    XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申	       left_x + i * left_p, top_y + i,
+
鐃緒申��申鐃緒申	       right_x + 1 - i * right_p, top_y + i);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Left.  */
+
鐃緒申��申鐃緒申  if (left_p)
+
鐃緒申��申鐃緒申    for (i = 0; i < width; ++i)
+
鐃緒申��申鐃緒申      XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申		 left_x + i, top_y + i, left_x + i, bottom_y - i + 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSetClipMask (FRAME_X_DISPLAY (f), gc, None);
+
鐃緒申��申鐃緒申  if (raised_p)
+
鐃緒申��申鐃緒申    gc = f->output_data.x->black_relief.gc;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    gc = f->output_data.x->white_relief.gc;
+
鐃緒申��申鐃緒申  XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, clip_rect, 1, Unsorted);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Bottom.  */
+
鐃緒申��申鐃緒申  for (i = 0; i < width; ++i)
+
鐃緒申��申鐃緒申    XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申	       left_x + i * left_p + 1, bottom_y - i,
+
鐃緒申��申鐃緒申	       right_x + 1 - i * right_p, bottom_y - i);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Right.  */
+
鐃緒申��申鐃緒申  if (right_p)
+
鐃緒申��申鐃緒申    for (i = 0; i < width; ++i)
+
鐃緒申��申鐃緒申      XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申		 right_x - i, top_y + i + 1, right_x - i, bottom_y - i);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSetClipMask (FRAME_X_DISPLAY (f), gc, None);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
+
鐃緒申��申鐃緒申   RIGHT_X, and BOTTOM_Y.  WIDTH is the thickness of the lines to
+
鐃緒申��申鐃緒申   draw, it must be >= 0.  LEFT_P non-zero means draw a line on the
+
鐃緒申��申鐃緒申   left side of the rectangle.  RIGHT_P non-zero means draw a line
+
鐃緒申��申鐃緒申   on the right side of the rectangle.  CLIP_RECT is the clipping
+
鐃緒申��申鐃緒申   rectangle to use when drawing.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
+
鐃緒申��申鐃緒申		 left_p, right_p, clip_rect)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     int left_x, top_y, right_x, bottom_y, left_p, right_p;
+
鐃緒申��申鐃緒申     XRectangle *clip_rect;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XGCValues xgcv;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
+
鐃緒申��申鐃緒申  XSetForeground (s->display, s->gc, s->face->box_color);
+
鐃緒申��申鐃緒申  XSetClipRectangles (s->display, s->gc, 0, 0, clip_rect, 1, Unsorted);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Top.  */
+
鐃緒申��申鐃緒申  XFillRectangle (s->display, s->window, s->gc,
+
鐃緒申��申鐃緒申		  left_x, top_y, right_x - left_x + 1, width);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Left.  */
+
鐃緒申��申鐃緒申  if (left_p)
+
鐃緒申��申鐃緒申    XFillRectangle (s->display, s->window, s->gc,
+
鐃緒申��申鐃緒申		    left_x, top_y, width, bottom_y - top_y + 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Bottom.  */
+
鐃緒申��申鐃緒申  XFillRectangle (s->display, s->window, s->gc,
+
鐃緒申��申鐃緒申		  left_x, bottom_y - width + 1, right_x - left_x + 1, width);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Right.  */
+
鐃緒申��申鐃緒申  if (right_p)
+
鐃緒申��申鐃緒申    XFillRectangle (s->display, s->window, s->gc,
+
鐃緒申��申鐃緒申		    right_x - width + 1, top_y, width, bottom_y - top_y + 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSetForeground (s->display, s->gc, xgcv.foreground);
+
鐃緒申��申鐃緒申  XSetClipMask (s->display, s->gc, None);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw a box around glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_glyph_string_box (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
+
鐃緒申��申鐃緒申  int left_p, right_p;
+
鐃緒申��申鐃緒申  struct glyph *last_glyph;
+
鐃緒申��申鐃緒申  XRectangle clip_rect;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  last_x = window_box_right (s->w, s->area);
+
鐃緒申��申鐃緒申  if (s->row->full_width_p
+
鐃緒申��申鐃緒申      && !s->w->pseudo_window_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      last_x += FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s->f);
+
鐃緒申��申鐃緒申      if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s->f))
+
鐃緒申��申鐃緒申	last_x += FRAME_SCROLL_BAR_WIDTH (s->f) * CANON_X_UNIT (s->f);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* The glyph that may have a right box line.  */
+
鐃緒申��申鐃緒申  last_glyph = (s->cmp || s->img
+
鐃緒申��申鐃緒申		? s->first_glyph
+
鐃緒申��申鐃緒申		: s->first_glyph + s->nchars - 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  width = abs (s->face->box_line_width);
+
鐃緒申��申鐃緒申  raised_p = s->face->box == FACE_RAISED_BOX;
+
鐃緒申��申鐃緒申  left_x = s->x;
+
鐃緒申��申鐃緒申  right_x = (s->row->full_width_p && s->extends_to_end_of_line_p
+
鐃緒申��申鐃緒申	     ? last_x - 1
+
鐃緒申��申鐃緒申	     : min (last_x, s->x + s->background_width) - 1);
+
鐃緒申��申鐃緒申  top_y = s->y;
+
鐃緒申��申鐃緒申  bottom_y = top_y + s->height - 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  left_p = (s->first_glyph->left_box_line_p
+
鐃緒申��申鐃緒申	    || (s->hl == DRAW_MOUSE_FACE
+
鐃緒申��申鐃緒申		&& (s->prev == NULL
+
鐃緒申��申鐃緒申		    || s->prev->hl != s->hl)));
+
鐃緒申��申鐃緒申  right_p = (last_glyph->right_box_line_p
+
鐃緒申��申鐃緒申	     || (s->hl == DRAW_MOUSE_FACE
+
鐃緒申��申鐃緒申		 && (s->next == NULL
+
鐃緒申��申鐃緒申		     || s->next->hl != s->hl)));
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  x_get_glyph_string_clip_rect (s, &clip_rect);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (s->face->box == FACE_SIMPLE_BOX)
+
鐃緒申��申鐃緒申    x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
+
鐃緒申��申鐃緒申		     left_p, right_p, &clip_rect);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_setup_relief_colors (s);
+
鐃緒申��申鐃緒申      x_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
+
鐃緒申��申鐃緒申			  width, raised_p, left_p, right_p, &clip_rect);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw foreground of image glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_image_foreground (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int x;
+
鐃緒申��申鐃緒申  int y = s->ybase - image_ascent (s->img, s->face);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If first glyph of S has a left box line, start drawing it to the
+
鐃緒申��申鐃緒申     right of that line.  */
+
鐃緒申��申鐃緒申  if (s->face->box != FACE_NO_BOX
+
鐃緒申��申鐃緒申      && s->first_glyph->left_box_line_p)
+
鐃緒申��申鐃緒申    x = s->x + abs (s->face->box_line_width);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x = s->x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If there is a margin around the image, adjust x- and y-position
+
鐃緒申��申鐃緒申     by that margin.  */
+
鐃緒申��申鐃緒申  x += s->img->hmargin;
+
鐃緒申��申鐃緒申  y += s->img->vmargin;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (s->img->pixmap)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (s->img->mask)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* We can't set both a clip mask and use XSetClipRectangles
+
鐃緒申��申鐃緒申	     because the latter also sets a clip mask.  We also can't
+
鐃緒申��申鐃緒申	     trust on the shape extension to be available
+
鐃緒申��申鐃緒申	     (XShapeCombineRegion).  So, compute the rectangle to draw
+
鐃緒申��申鐃緒申	     manually.  */
+
鐃緒申��申鐃緒申	  unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
+
鐃緒申��申鐃緒申				| GCFunction);
+
鐃緒申��申鐃緒申	  XGCValues xgcv;
+
鐃緒申��申鐃緒申	  XRectangle clip_rect, image_rect, r;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  xgcv.clip_mask = s->img->mask;
+
鐃緒申��申鐃緒申	  xgcv.clip_x_origin = x;
+
鐃緒申��申鐃緒申	  xgcv.clip_y_origin = y;
+
鐃緒申��申鐃緒申	  xgcv.function = GXcopy;
+
鐃緒申��申鐃緒申	  XChangeGC (s->display, s->gc, mask, &xgcv);
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  x_get_glyph_string_clip_rect (s, &clip_rect);
+
鐃緒申��申鐃緒申	  image_rect.x = x;
+
鐃緒申��申鐃緒申	  image_rect.y = y;
+
鐃緒申��申鐃緒申	  image_rect.width = s->img->width;
+
鐃緒申��申鐃緒申	  image_rect.height = s->img->height;
+
鐃緒申��申鐃緒申	  if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
+
鐃緒申��申鐃緒申	    XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
+
鐃緒申��申鐃緒申		       r.x - x, r.y - y, r.width, r.height, r.x, r.y);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  unsigned long mask = GCClipXOrigin | GCClipYOrigin | GCFunction;
+
鐃緒申��申鐃緒申	  XGCValues xgcv;
+
鐃緒申��申鐃緒申	  XRectangle clip_rect, image_rect, r;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  x_get_glyph_string_clip_rect (s, &clip_rect);
+
鐃緒申��申鐃緒申	  image_rect.x = x;
+
鐃緒申��申鐃緒申	  image_rect.y = y;
+
鐃緒申��申鐃緒申	  image_rect.width = s->img->width;
+
鐃緒申��申鐃緒申	  image_rect.height = s->img->height;
+
鐃緒申��申鐃緒申	  if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
+
鐃緒申��申鐃緒申	    XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
+
鐃緒申��申鐃緒申		       r.x - x, r.y - y, r.width, r.height, r.x, r.y);
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  /* When the image has a mask, we can expect that at
+
鐃緒申��申鐃緒申	     least part of a mouse highlight or a block cursor will
+
鐃緒申��申鐃緒申	     be visible.  If the image doesn't have a mask, make
+
鐃緒申��申鐃緒申	     a block cursor visible by drawing a rectangle around
+
鐃緒申��申鐃緒申	     the image.  I believe it's looking better if we do
+
鐃緒申��申鐃緒申	     nothing here for mouse-face.  */
+
鐃緒申��申鐃緒申	  if (s->hl == DRAW_CURSOR)
+
鐃緒申��申鐃緒申	    XDrawRectangle (s->display, s->window, s->gc, x, y,
+
鐃緒申��申鐃緒申			    s->img->width - 1, s->img->height - 1);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    /* Draw a rectangle if image could not be loaded.  */
+
鐃緒申��申鐃緒申    XDrawRectangle (s->display, s->window, s->gc, x, y,
+
鐃緒申��申鐃緒申		    s->img->width - 1, s->img->height - 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw a relief around the image glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_image_relief (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int x0, y0, x1, y1, thick, raised_p;
+
鐃緒申��申鐃緒申  XRectangle r;
+
鐃緒申��申鐃緒申  int x;
+
鐃緒申��申鐃緒申  int y = s->ybase - image_ascent (s->img, s->face);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* If first glyph of S has a left box line, start drawing it to the
+
鐃緒申��申鐃緒申     right of that line.  */
+
鐃緒申��申鐃緒申  if (s->face->box != FACE_NO_BOX
+
鐃緒申��申鐃緒申      && s->first_glyph->left_box_line_p)
+
鐃緒申��申鐃緒申    x = s->x + abs (s->face->box_line_width);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x = s->x;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* If there is a margin around the image, adjust x- and y-position
+
鐃緒申��申鐃緒申     by that margin.  */
+
鐃緒申��申鐃緒申  x += s->img->hmargin;
+
鐃緒申��申鐃緒申  y += s->img->vmargin;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (s->hl == DRAW_IMAGE_SUNKEN
+
鐃緒申��申鐃緒申      || s->hl == DRAW_IMAGE_RAISED)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      thick = tool_bar_button_relief > 0 ? tool_bar_button_relief : 3;
+
鐃緒申��申鐃緒申      raised_p = s->hl == DRAW_IMAGE_RAISED;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      thick = abs (s->img->relief);
+
鐃緒申��申鐃緒申      raised_p = s->img->relief > 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  x0 = x - thick;
+
鐃緒申��申鐃緒申  y0 = y - thick;
+
鐃緒申��申鐃緒申  x1 = x + s->img->width + thick - 1;
+
鐃緒申��申鐃緒申  y1 = y + s->img->height + thick - 1;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  x_setup_relief_colors (s);
+
鐃緒申��申鐃緒申  x_get_glyph_string_clip_rect (s, &r);
+
鐃緒申��申鐃緒申  x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p, 1, 1, &r);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw the foreground of image glyph string S to PIXMAP.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_image_foreground_1 (s, pixmap)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     Pixmap pixmap;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int x;
+
鐃緒申��申鐃緒申  int y = s->ybase - s->y - image_ascent (s->img, s->face);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If first glyph of S has a left box line, start drawing it to the
+
鐃緒申��申鐃緒申     right of that line.  */
+
鐃緒申��申鐃緒申  if (s->face->box != FACE_NO_BOX
+
鐃緒申��申鐃緒申      && s->first_glyph->left_box_line_p)
+
鐃緒申��申鐃緒申    x = abs (s->face->box_line_width);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If there is a margin around the image, adjust x- and y-position
+
鐃緒申��申鐃緒申     by that margin.  */
+
鐃緒申��申鐃緒申  x += s->img->hmargin;
+
鐃緒申��申鐃緒申  y += s->img->vmargin;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (s->img->pixmap)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (s->img->mask)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* We can't set both a clip mask and use XSetClipRectangles
+
鐃緒申��申鐃緒申	     because the latter also sets a clip mask.  We also can't
+
鐃緒申��申鐃緒申	     trust on the shape extension to be available
+
鐃緒申��申鐃緒申	     (XShapeCombineRegion).  So, compute the rectangle to draw
+
鐃緒申��申鐃緒申	     manually.  */
+
鐃緒申��申鐃緒申	  unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
+
鐃緒申��申鐃緒申				| GCFunction);
+
鐃緒申��申鐃緒申	  XGCValues xgcv;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  xgcv.clip_mask = s->img->mask;
+
鐃緒申��申鐃緒申	  xgcv.clip_x_origin = x;
+
鐃緒申��申鐃緒申	  xgcv.clip_y_origin = y;
+
鐃緒申��申鐃緒申	  xgcv.function = GXcopy;
+
鐃緒申��申鐃緒申	  XChangeGC (s->display, s->gc, mask, &xgcv);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
+
鐃緒申��申鐃緒申		     0, 0, s->img->width, s->img->height, x, y);
+
鐃緒申��申鐃緒申	  XSetClipMask (s->display, s->gc, None);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
+
鐃緒申��申鐃緒申		     0, 0, s->img->width, s->img->height, x, y);
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  /* When the image has a mask, we can expect that at
+
鐃緒申��申鐃緒申	     least part of a mouse highlight or a block cursor will
+
鐃緒申��申鐃緒申	     be visible.  If the image doesn't have a mask, make
+
鐃緒申��申鐃緒申	     a block cursor visible by drawing a rectangle around
+
鐃緒申��申鐃緒申	     the image.  I believe it's looking better if we do
+
鐃緒申��申鐃緒申	     nothing here for mouse-face.  */
+
鐃緒申��申鐃緒申	  if (s->hl == DRAW_CURSOR)
+
鐃緒申��申鐃緒申	    XDrawRectangle (s->display, pixmap, s->gc, x, y,
+
鐃緒申��申鐃緒申			    s->img->width - 1, s->img->height - 1);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    /* Draw a rectangle if image could not be loaded.  */
+
鐃緒申��申鐃緒申    XDrawRectangle (s->display, pixmap, s->gc, x, y,
+
鐃緒申��申鐃緒申		    s->img->width - 1, s->img->height - 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw part of the background of glyph string S.  X, Y, W, and H
+
鐃緒申��申鐃緒申   give the rectangle to draw.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_glyph_string_bg_rect (s, x, y, w, h)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     int x, y, w, h;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (s->stippled_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Fill background with a stipple pattern.  */
+
鐃緒申��申鐃緒申      XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
+
鐃緒申��申鐃緒申      XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
+
鐃緒申��申鐃緒申      XSetFillStyle (s->display, s->gc, FillSolid);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x_clear_glyph_string_rect (s, x, y, w, h);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw image glyph string S.  
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申            s->y
+
鐃緒申��申鐃緒申   s->x      +-------------------------
+
鐃緒申��申鐃緒申	     |   s->face->box
+
鐃緒申��申鐃緒申	     |
+
鐃緒申��申鐃緒申	     |     +-------------------------
+
鐃緒申��申鐃緒申	     |     |  s->img->margin
+
鐃緒申��申鐃緒申	     |     |
+
鐃緒申��申鐃緒申	     |     |       +-------------------
+
鐃緒申��申鐃緒申	     |     |       |  the image
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申 */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_image_glyph_string (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int x, y;
+
鐃緒申��申鐃緒申  int box_line_hwidth = abs (s->face->box_line_width);
+
鐃緒申��申鐃緒申  int box_line_vwidth = max (s->face->box_line_width, 0);
+
鐃緒申��申鐃緒申  int height;
+
鐃緒申��申鐃緒申  Pixmap pixmap = None;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  height = s->height - 2 * box_line_vwidth;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Fill background with face under the image.  Do it only if row is
+
鐃緒申��申鐃緒申     taller than image or if image has a clip mask to reduce
+
鐃緒申��申鐃緒申     flickering.  */
+
鐃緒申��申鐃緒申  s->stippled_p = s->face->stipple != 0;
+
鐃緒申��申鐃緒申  if (height > s->img->height
+
鐃緒申��申鐃緒申      || s->img->hmargin
+
鐃緒申��申鐃緒申      || s->img->vmargin
+
鐃緒申��申鐃緒申      || s->img->mask
+
鐃緒申��申鐃緒申      || s->img->pixmap == 0
+
鐃緒申��申鐃緒申      || s->width != s->background_width)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (box_line_hwidth && s->first_glyph->left_box_line_p)
+
鐃緒申��申鐃緒申	x = s->x + box_line_hwidth;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	x = s->x;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      y = s->y + box_line_vwidth;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if (s->img->mask)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* Create a pixmap as large as the glyph string.  Fill it
+
鐃緒申��申鐃緒申	     with the background color.  Copy the image to it, using
+
鐃緒申��申鐃緒申	     its mask.  Copy the temporary pixmap to the display.  */
+
鐃緒申��申鐃緒申	  Screen *screen = FRAME_X_SCREEN (s->f);
+
鐃緒申��申鐃緒申	  int depth = DefaultDepthOfScreen (screen);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Create a pixmap as large as the glyph string.  */
+
鐃緒申��申鐃緒申 	  pixmap = XCreatePixmap (s->display, s->window,
+
鐃緒申��申鐃緒申				  s->background_width,
+
鐃緒申��申鐃緒申				  s->height, depth);
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  /* Don't clip in the following because we're working on the
+
鐃緒申��申鐃緒申	     pixmap.  */
+
鐃緒申��申鐃緒申	  XSetClipMask (s->display, s->gc, None);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Fill the pixmap with the background color/stipple.  */
+
鐃緒申��申鐃緒申	  if (s->stippled_p)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      /* Fill background with a stipple pattern.  */
+
鐃緒申��申鐃緒申	      XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
+
鐃緒申��申鐃緒申	      XFillRectangle (s->display, pixmap, s->gc,
+
鐃緒申��申鐃緒申			      0, 0, s->background_width, s->height);
+
鐃緒申��申鐃緒申	      XSetFillStyle (s->display, s->gc, FillSolid);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      XGCValues xgcv;
+
鐃緒申��申鐃緒申	      XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
+
鐃緒申��申鐃緒申			    &xgcv);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, s->gc, xgcv.background);
+
鐃緒申��申鐃緒申	      XFillRectangle (s->display, pixmap, s->gc,
+
鐃緒申��申鐃緒申			      0, 0, s->background_width, s->height);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, s->gc, xgcv.foreground);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      s->background_filled_p = 1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Draw the foreground.  */
+
鐃緒申��申鐃緒申  if (pixmap != None)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_draw_image_foreground_1 (s, pixmap);
+
鐃緒申��申鐃緒申      x_set_glyph_string_clipping (s);
+
鐃緒申��申鐃緒申      XCopyArea (s->display, pixmap, s->window, s->gc,
+
鐃緒申��申鐃緒申		 0, 0, s->background_width, s->height, s->x, s->y);
+
鐃緒申��申鐃緒申      XFreePixmap (s->display, pixmap);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x_draw_image_foreground (s);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If we must draw a relief around the image, do it.  */
+
鐃緒申��申鐃緒申  if (s->img->relief
+
鐃緒申��申鐃緒申      || s->hl == DRAW_IMAGE_RAISED
+
鐃緒申��申鐃緒申      || s->hl == DRAW_IMAGE_SUNKEN)
+
鐃緒申��申鐃緒申    x_draw_image_relief (s);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw stretch glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_stretch_glyph_string (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  xassert (s->first_glyph->type == STRETCH_GLYPH);
+
鐃緒申��申鐃緒申  s->stippled_p = s->face->stipple != 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (s->hl == DRAW_CURSOR
+
鐃緒申��申鐃緒申      && !x_stretch_cursor_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
+
鐃緒申��申鐃緒申	 as wide as the stretch glyph.  */
+
鐃緒申��申鐃緒申      int width = min (CANON_X_UNIT (s->f), s->background_width);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Draw cursor.  */
+
鐃緒申��申鐃緒申      x_draw_glyph_string_bg_rect (s, s->x, s->y, width, s->height);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Clear rest using the GC of the original non-cursor face.  */
+
鐃緒申��申鐃緒申      if (width < s->background_width)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  GC gc = s->face->gc;
+
鐃緒申��申鐃緒申	  int x = s->x + width, y = s->y;
+
鐃緒申��申鐃緒申	  int w = s->background_width - width, h = s->height;
+
鐃緒申��申鐃緒申	  XRectangle r;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  x_get_glyph_string_clip_rect (s, &r);
+
鐃緒申��申鐃緒申	  XSetClipRectangles (s->display, gc, 0, 0, &r, 1, Unsorted);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (s->face->stipple)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      /* Fill background with a stipple pattern.  */
+
鐃緒申��申鐃緒申	      XSetFillStyle (s->display, gc, FillOpaqueStippled);
+
鐃緒申��申鐃緒申	      XFillRectangle (s->display, s->window, gc, x, y, w, h);
+
鐃緒申��申鐃緒申	      XSetFillStyle (s->display, gc, FillSolid);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      XGCValues xgcv;
+
鐃緒申��申鐃緒申	      XGetGCValues (s->display, gc, GCForeground | GCBackground, &xgcv);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, gc, xgcv.background);
+
鐃緒申��申鐃緒申	      XFillRectangle (s->display, s->window, gc, x, y, w, h);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, gc, xgcv.foreground);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (!s->background_filled_p)
+
鐃緒申��申鐃緒申    x_draw_glyph_string_bg_rect (s, s->x, s->y, s->background_width,
+
鐃緒申��申鐃緒申				 s->height);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  s->background_filled_p = 1;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw glyph string S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_glyph_string (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int relief_drawn_p = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If S draws into the background of its successor, draw the
+
鐃緒申��申鐃緒申     background of the successor first so that S can draw into it.
+
鐃緒申��申鐃緒申     This makes S->next use XDrawString instead of XDrawImageString.  */
+
鐃緒申��申鐃緒申  if (s->next && s->right_overhang && !s->for_overlaps_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      xassert (s->next->img == NULL);
+
鐃緒申��申鐃緒申      x_set_glyph_string_gc (s->next);
+
鐃緒申��申鐃緒申      x_set_glyph_string_clipping (s->next);
+
鐃緒申��申鐃緒申      x_draw_glyph_string_background (s->next, 1);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Set up S->gc, set clipping and draw S.  */
+
鐃緒申��申鐃緒申  x_set_glyph_string_gc (s);
+
鐃緒申��申鐃緒申  x_set_glyph_string_clipping (s);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Draw relief (if any) in advance for char/composition so that the
+
鐃緒申��申鐃緒申     glyph string can be drawn over it.  */
+
鐃緒申��申鐃緒申  if (!s->for_overlaps_p
+
鐃緒申��申鐃緒申      && s->face->box != FACE_NO_BOX
+
鐃緒申��申鐃緒申      && (s->first_glyph->type == CHAR_GLYPH
+
鐃緒申��申鐃緒申	  || s->first_glyph->type == COMPOSITE_GLYPH))
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_draw_glyph_string_background (s, 1);
+
鐃緒申��申鐃緒申      x_draw_glyph_string_box (s);
+
鐃緒申��申鐃緒申      relief_drawn_p = 1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  switch (s->first_glyph->type)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申    case IMAGE_GLYPH:
+
鐃緒申��申鐃緒申      x_draw_image_glyph_string (s);
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case STRETCH_GLYPH:
+
鐃緒申��申鐃緒申      x_draw_stretch_glyph_string (s);
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case CHAR_GLYPH:
+
鐃緒申��申鐃緒申      if (s->for_overlaps_p)
+
鐃緒申��申鐃緒申	s->background_filled_p = 1;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	x_draw_glyph_string_background (s, 0);
+
鐃緒申��申鐃緒申      x_draw_glyph_string_foreground (s);
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case COMPOSITE_GLYPH:
+
鐃緒申��申鐃緒申      if (s->for_overlaps_p || s->gidx > 0)
+
鐃緒申��申鐃緒申	s->background_filled_p = 1;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	x_draw_glyph_string_background (s, 1);
+
鐃緒申��申鐃緒申      x_draw_composite_glyph_string_foreground (s);
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    default:
+
鐃緒申��申鐃緒申      abort ();
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!s->for_overlaps_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Draw underline.  */
+
鐃緒申��申鐃緒申      if (s->face->underline_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  unsigned long tem, h;
+
鐃緒申��申鐃緒申	  int y;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Get the underline thickness.  Default is 1 pixel.  */
+
鐃緒申��申鐃緒申	  if (!XGetFontProperty (s->font, XA_UNDERLINE_THICKNESS, &h))
+
鐃緒申��申鐃緒申	    h = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Get the underline position.  This is the recommended
+
鐃緒申��申鐃緒申	     vertical offset in pixels from the baseline to the top of
+
鐃緒申��申鐃緒申	     the underline.  This is a signed value according to the
+
鐃緒申��申鐃緒申	     specs, and its default is
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	     ROUND ((maximum descent) / 2), with
+
鐃緒申��申鐃緒申	     ROUND(x) = floor (x + 0.5)  */
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  if (x_use_underline_position_properties
+
鐃緒申��申鐃緒申	      && XGetFontProperty (s->font, XA_UNDERLINE_POSITION, &tem))
+
鐃緒申��申鐃緒申	    y = s->ybase + (long) tem;
+
鐃緒申��申鐃緒申	  else if (s->face->font)
+
鐃緒申��申鐃緒申	    y = s->ybase + (s->face->font->max_bounds.descent + 1) / 2;
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    y = s->y + s->height - h;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申	  if (s->face->underline_defaulted_p)
+
鐃緒申��申鐃緒申	    XFillRectangle (s->display, s->window, s->gc,
+
鐃緒申��申鐃緒申			    s->x, y, s->width, h);
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      XGCValues xgcv;
+
鐃緒申��申鐃緒申	      XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, s->gc, s->face->underline_color);
+
鐃緒申��申鐃緒申	      XFillRectangle (s->display, s->window, s->gc,
+
鐃緒申��申鐃緒申			      s->x, y, s->width, h);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, s->gc, xgcv.foreground);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Draw overline.  */
+
鐃緒申��申鐃緒申      if (s->face->overline_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  unsigned long dy = 0, h = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (s->face->overline_color_defaulted_p)
+
鐃緒申��申鐃緒申	    XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
+
鐃緒申��申鐃緒申			    s->width, h);
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      XGCValues xgcv;
+
鐃緒申��申鐃緒申	      XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, s->gc, s->face->overline_color);
+
鐃緒申��申鐃緒申	      XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
+
鐃緒申��申鐃緒申			      s->width, h);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, s->gc, xgcv.foreground);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申      /* Draw strike-through.  */
+
鐃緒申��申鐃緒申      if (s->face->strike_through_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  unsigned long h = 1;
+
鐃緒申��申鐃緒申	  unsigned long dy = (s->height - h) / 2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (s->face->strike_through_color_defaulted_p)
+
鐃緒申��申鐃緒申	    XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
+
鐃緒申��申鐃緒申			    s->width, h);
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      XGCValues xgcv;
+
鐃緒申��申鐃緒申	      XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, s->gc, s->face->strike_through_color);
+
鐃緒申��申鐃緒申	      XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
+
鐃緒申��申鐃緒申			      s->width, h);
+
鐃緒申��申鐃緒申	      XSetForeground (s->display, s->gc, xgcv.foreground);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申      /* Draw relief if not yet drawn.  */
+
鐃緒申��申鐃緒申      if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
+
鐃緒申��申鐃緒申	x_draw_glyph_string_box (s);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Reset clipping.  */
+
鐃緒申��申鐃緒申  XSetClipMask (s->display, s->gc, None);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int x_fill_composite_glyph_string P_ ((struct glyph_string *,
+
鐃緒申��申鐃緒申					      struct face **, int));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Fill glyph string S with composition components specified by S->cmp.
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申   FACES is an array of faces for all components of this composition.
+
鐃緒申��申鐃緒申   S->gidx is the index of the first component for S.
+
鐃緒申��申鐃緒申   OVERLAPS_P non-zero means S should draw the foreground only, and
+
鐃緒申��申鐃緒申   use its physical height for clipping.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Value is the index of a component not in S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_fill_composite_glyph_string (s, faces, overlaps_p)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     struct face **faces;
+
鐃緒申��申鐃緒申     int overlaps_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (s);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  s->for_overlaps_p = overlaps_p;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  s->face = faces[s->gidx];
+
鐃緒申��申鐃緒申  s->font = s->face->font;
+
鐃緒申��申鐃緒申  s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* For all glyphs of this composition, starting at the offset
+
鐃緒申��申鐃緒申     S->gidx, until we reach the end of the definition or encounter a
+
鐃緒申��申鐃緒申     glyph that requires the different face, add it to S.  */
+
鐃緒申��申鐃緒申  ++s->nchars;
+
鐃緒申��申鐃緒申  for (i = s->gidx + 1; i < s->cmp->glyph_len && faces[i] == s->face; ++i)
+
鐃緒申��申鐃緒申    ++s->nchars;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* All glyph strings for the same composition has the same width,
+
鐃緒申��申鐃緒申     i.e. the width set for the first component of the composition.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  s->width = s->first_glyph->pixel_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If the specified font could not be loaded, use the frame's
+
鐃緒申��申鐃緒申     default font, but record the fact that we couldn't load it in
+
鐃緒申��申鐃緒申     the glyph string so that we can draw rectangles for the
+
鐃緒申��申鐃緒申     characters of the glyph string.  */
+
鐃緒申��申鐃緒申  if (s->font == NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      s->font_not_found_p = 1;
+
鐃緒申��申鐃緒申      s->font = FRAME_FONT (s->f);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Adjust base line for subscript/superscript text.  */
+
鐃緒申��申鐃緒申  s->ybase += s->first_glyph->voffset;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  xassert (s->face && s->face->gc);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* This glyph string must always be drawn with 16-bit functions.  */
+
鐃緒申��申鐃緒申  s->two_byte_p = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return s->gidx + s->nchars;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Fill glyph string S from a sequence of character glyphs.
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申   FACE_ID is the face id of the string.  START is the index of the
+
鐃緒申��申鐃緒申   first glyph to consider, END is the index of the last + 1.
+
鐃緒申��申鐃緒申   OVERLAPS_P non-zero means S should draw the foreground only, and
+
鐃緒申��申鐃緒申   use its physical height for clipping.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Value is the index of the first glyph not in S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_fill_glyph_string (s, face_id, start, end, overlaps_p)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     int face_id;
+
鐃緒申��申鐃緒申     int start, end, overlaps_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct glyph *glyph, *last;
+
鐃緒申��申鐃緒申  int voffset;
+
鐃緒申��申鐃緒申  int glyph_not_available_p;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  xassert (s->f == XFRAME (s->w->frame));
+
鐃緒申��申鐃緒申  xassert (s->nchars == 0);
+
鐃緒申��申鐃緒申  xassert (start >= 0 && end > start);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  s->for_overlaps_p = overlaps_p,
+
鐃緒申��申鐃緒申  glyph = s->row->glyphs[s->area] + start;
+
鐃緒申��申鐃緒申  last = s->row->glyphs[s->area] + end;
+
鐃緒申��申鐃緒申  voffset = glyph->voffset;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  glyph_not_available_p = glyph->glyph_not_available_p;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  while (glyph < last
+
鐃緒申��申鐃緒申	 && glyph->type == CHAR_GLYPH
+
鐃緒申��申鐃緒申	 && glyph->voffset == voffset
+
鐃緒申��申鐃緒申	 /* Same face id implies same font, nowadays.  */
+
鐃緒申��申鐃緒申	 && glyph->face_id == face_id
+
鐃緒申��申鐃緒申	 && glyph->glyph_not_available_p == glyph_not_available_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int two_byte_p;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      s->face = x_get_glyph_face_and_encoding (s->f, glyph,
+
鐃緒申��申鐃緒申					       s->char2b + s->nchars,
+
鐃緒申��申鐃緒申					       &two_byte_p);
+
鐃緒申��申鐃緒申      s->two_byte_p = two_byte_p;
+
鐃緒申��申鐃緒申      ++s->nchars;
+
鐃緒申��申鐃緒申      xassert (s->nchars <= end - start);
+
鐃緒申��申鐃緒申      s->width += glyph->pixel_width;
+
鐃緒申��申鐃緒申      ++glyph;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  s->font = s->face->font;
+
鐃緒申��申鐃緒申  s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* If the specified font could not be loaded, use the frame's font,
+
鐃緒申��申鐃緒申     but record the fact that we couldn't load it in
+
鐃緒申��申鐃緒申     S->font_not_found_p so that we can draw rectangles for the
+
鐃緒申��申鐃緒申     characters of the glyph string.  */
+
鐃緒申��申鐃緒申  if (s->font == NULL || glyph_not_available_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      s->font_not_found_p = 1;
+
鐃緒申��申鐃緒申      s->font = FRAME_FONT (s->f);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Adjust base line for subscript/superscript text.  */
+
鐃緒申��申鐃緒申  s->ybase += voffset;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (s->face && s->face->gc);
+
鐃緒申��申鐃緒申  return glyph - s->row->glyphs[s->area];
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Fill glyph string S from image glyph S->first_glyph.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_fill_image_glyph_string (s)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  xassert (s->first_glyph->type == IMAGE_GLYPH);
+
鐃緒申��申鐃緒申  s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
+
鐃緒申��申鐃緒申  xassert (s->img);
+
鐃緒申��申鐃緒申  s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
+
鐃緒申��申鐃緒申  s->font = s->face->font;
+
鐃緒申��申鐃緒申  s->width = s->first_glyph->pixel_width;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Adjust base line for subscript/superscript text.  */
+
鐃緒申��申鐃緒申  s->ybase += s->first_glyph->voffset;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Fill glyph string S from a sequence of stretch glyphs.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   ROW is the glyph row in which the glyphs are found, AREA is the
+
鐃緒申��申鐃緒申   area within the row.  START is the index of the first glyph to
+
鐃緒申��申鐃緒申   consider, END is the index of the last + 1.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Value is the index of the first glyph not in S.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_fill_stretch_glyph_string (s, row, area, start, end)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     enum glyph_row_area area;
+
鐃緒申��申鐃緒申     int start, end;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct glyph *glyph, *last;
+
鐃緒申��申鐃緒申  int voffset, face_id;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  xassert (s->first_glyph->type == STRETCH_GLYPH);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  glyph = s->row->glyphs[s->area] + start;
+
鐃緒申��申鐃緒申  last = s->row->glyphs[s->area] + end;
+
鐃緒申��申鐃緒申  face_id = glyph->face_id;
+
鐃緒申��申鐃緒申  s->face = FACE_FROM_ID (s->f, face_id);
+
鐃緒申��申鐃緒申  s->font = s->face->font;
+
鐃緒申��申鐃緒申  s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
+
鐃緒申��申鐃緒申  s->width = glyph->pixel_width;
+
鐃緒申��申鐃緒申  voffset = glyph->voffset;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (++glyph;
+
鐃緒申��申鐃緒申       (glyph < last
+
鐃緒申��申鐃緒申	&& glyph->type == STRETCH_GLYPH
+
鐃緒申��申鐃緒申	&& glyph->voffset == voffset
+
鐃緒申��申鐃緒申	&& glyph->face_id == face_id);
+
鐃緒申��申鐃緒申       ++glyph)
+
鐃緒申��申鐃緒申    s->width += glyph->pixel_width;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Adjust base line for subscript/superscript text.  */
+
鐃緒申��申鐃緒申  s->ybase += voffset;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (s->face && s->face->gc);
+
鐃緒申��申鐃緒申  return glyph - s->row->glyphs[s->area];
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Initialize glyph string S.  CHAR2B is a suitably allocated vector
+
鐃緒申��申鐃緒申   of XChar2b structures for S; it can't be allocated in
+
鐃緒申��申鐃緒申   x_init_glyph_string because it must be allocated via `alloca'.  W
+
鐃緒申��申鐃緒申   is the window on which S is drawn.  ROW and AREA are the glyph row
+
鐃緒申��申鐃緒申   and area within the row from which S is constructed.  START is the
+
鐃緒申��申鐃緒申   index of the first glyph structure covered by S.  HL is a
+
鐃緒申��申鐃緒申   face-override for drawing S.  */
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_init_glyph_string (s, char2b, w, row, area, start, hl)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     XChar2b *char2b;
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     enum glyph_row_area area;
+
鐃緒申��申鐃緒申     int start;
+
鐃緒申��申鐃緒申     enum draw_glyphs_face hl;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  bzero (s, sizeof *s);
+
鐃緒申��申鐃緒申  s->w = w;
+
鐃緒申��申鐃緒申  s->f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  s->display = FRAME_X_DISPLAY (s->f);
+
鐃緒申��申鐃緒申  s->window = FRAME_X_WINDOW (s->f);
+
鐃緒申��申鐃緒申  s->char2b = char2b;
+
鐃緒申��申鐃緒申  s->hl = hl;
+
鐃緒申��申鐃緒申  s->row = row;
+
鐃緒申��申鐃緒申  s->area = area;
+
鐃緒申��申鐃緒申  s->first_glyph = row->glyphs[area] + start;
+
鐃緒申��申鐃緒申  s->height = row->height;
+
鐃緒申��申鐃緒申  s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Display the internal border below the tool-bar window.  */
+
鐃緒申��申鐃緒申  if (s->w == XWINDOW (s->f->tool_bar_window))
+
鐃緒申��申鐃緒申    s->y -= s->f->output_data.x->internal_border_width;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  s->ybase = s->y + row->ascent;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set background width of glyph string S.  START is the index of the
+
鐃緒申��申鐃緒申   first glyph following S.  LAST_X is the right-most x-position + 1
+
鐃緒申��申鐃緒申   in the drawing area.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_set_glyph_string_background_width (s, start, last_x)
+
鐃緒申��申鐃緒申     struct glyph_string *s;
+
鐃緒申��申鐃緒申     int start;
+
鐃緒申��申鐃緒申     int last_x;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* If the face of this glyph string has to be drawn to the end of
+
鐃緒申��申鐃緒申     the drawing area, set S->extends_to_end_of_line_p.  */
+
鐃緒申��申鐃緒申  struct face *default_face = FACE_FROM_ID (s->f, DEFAULT_FACE_ID);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (start == s->row->used[s->area]
+
鐃緒申��申鐃緒申      && s->hl == DRAW_NORMAL_TEXT
+
鐃緒申��申鐃緒申      && s->area == TEXT_AREA
+
鐃緒申��申鐃緒申      && (s->row->fill_line_p
+
鐃緒申��申鐃緒申	  || s->face->background != default_face->background
+
鐃緒申��申鐃緒申	  || s->face->stipple != default_face->stipple))
+
鐃緒申��申鐃緒申    s->extends_to_end_of_line_p = 1;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* If S extends its face to the end of the line, set its
+
鐃緒申��申鐃緒申     background_width to the distance to the right edge of the drawing
+
鐃緒申��申鐃緒申     area.  */
+
鐃緒申��申鐃緒申  if (s->extends_to_end_of_line_p)
+
鐃緒申��申鐃緒申    s->background_width = last_x - s->x + 1;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    s->background_width = s->width;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Add a glyph string for a stretch glyph to the list of strings
+
鐃緒申��申鐃緒申   between HEAD and TAIL.  START is the index of the stretch glyph in
+
鐃緒申��申鐃緒申   row area AREA of glyph row ROW.  END is the index of the last glyph
+
鐃緒申��申鐃緒申   in that glyph row area.  X is the current output position assigned
+
鐃緒申��申鐃緒申   to the new glyph string constructed.  HL overrides that face of the
+
鐃緒申��申鐃緒申   glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
+
鐃緒申��申鐃緒申   is the right-most x-position of the drawing area.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* SunOS 4 bundled cc, barfed on continuations in the arg lists here
+
鐃緒申��申鐃緒申   and below -- keep them on one line.  */
+
鐃緒申��申鐃緒申#define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
+
鐃緒申��申鐃緒申     do									    \
+
鐃緒申��申鐃緒申       {								    \
+
鐃緒申��申鐃緒申	 s = (struct glyph_string *) alloca (sizeof *s);		    \
+
鐃緒申��申鐃緒申	 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL);	    \
+
鐃緒申��申鐃緒申	 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END);    \
+
鐃緒申��申鐃緒申	 x_append_glyph_string (&HEAD, &TAIL, s);			    \
+
鐃緒申��申鐃緒申         s->x = (X);							    \
+
鐃緒申��申鐃緒申       }								    \
+
鐃緒申��申鐃緒申     while (0)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Add a glyph string for an image glyph to the list of strings
+
鐃緒申��申鐃緒申   between HEAD and TAIL.  START is the index of the image glyph in
+
鐃緒申��申鐃緒申   row area AREA of glyph row ROW.  END is the index of the last glyph
+
鐃緒申��申鐃緒申   in that glyph row area.  X is the current output position assigned
+
鐃緒申��申鐃緒申   to the new glyph string constructed.  HL overrides that face of the
+
鐃緒申��申鐃緒申   glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
+
鐃緒申��申鐃緒申   is the right-most x-position of the drawing area.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
+
鐃緒申��申鐃緒申     do									\
+
鐃緒申��申鐃緒申       {								\
+
鐃緒申��申鐃緒申	 s = (struct glyph_string *) alloca (sizeof *s);		\
+
鐃緒申��申鐃緒申	 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL);        \
+
鐃緒申��申鐃緒申	 x_fill_image_glyph_string (s);					\
+
鐃緒申��申鐃緒申	 x_append_glyph_string (&HEAD, &TAIL, s);			\
+
鐃緒申��申鐃緒申	 ++START;							\
+
鐃緒申��申鐃緒申         s->x = (X);							\
+
鐃緒申��申鐃緒申       }								\
+
鐃緒申��申鐃緒申     while (0)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Add a glyph string for a sequence of character glyphs to the list
+
鐃緒申��申鐃緒申   of strings between HEAD and TAIL.  START is the index of the first
+
鐃緒申��申鐃緒申   glyph in row area AREA of glyph row ROW that is part of the new
+
鐃緒申��申鐃緒申   glyph string.  END is the index of the last glyph in that glyph row
+
鐃緒申��申鐃緒申   area.  X is the current output position assigned to the new glyph
+
鐃緒申��申鐃緒申   string constructed.  HL overrides that face of the glyph; e.g. it
+
鐃緒申��申鐃緒申   is DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the
+
鐃緒申��申鐃緒申   right-most x-position of the drawing area.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
+
鐃緒申��申鐃緒申     do									   \
+
鐃緒申��申鐃緒申       {								   \
+
鐃緒申��申鐃緒申	 int c, face_id;						   \
+
鐃緒申��申鐃緒申	 XChar2b *char2b;						   \
+
鐃緒申��申鐃緒申									   \
+
鐃緒申��申鐃緒申	 c = (ROW)->glyphs[AREA][START].u.ch;				   \
+
鐃緒申��申鐃緒申	 face_id = (ROW)->glyphs[AREA][START].face_id;			   \
+
鐃緒申��申鐃緒申									   \
+
鐃緒申��申鐃緒申	 s = (struct glyph_string *) alloca (sizeof *s);		   \
+
鐃緒申��申鐃緒申	 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b);	   \
+
鐃緒申��申鐃緒申	 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL);	   \
+
鐃緒申��申鐃緒申	 x_append_glyph_string (&HEAD, &TAIL, s);			   \
+
鐃緒申��申鐃緒申	 s->x = (X);							   \
+
鐃緒申��申鐃緒申	 START = x_fill_glyph_string (s, face_id, START, END,		   \
+
鐃緒申��申鐃緒申                                          OVERLAPS_P);			   \
+
鐃緒申��申鐃緒申       }								   \
+
鐃緒申��申鐃緒申     while (0)
+
鐃緒申��申鐃緒申     
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Add a glyph string for a composite sequence to the list of strings
+
鐃緒申��申鐃緒申   between HEAD and TAIL.  START is the index of the first glyph in
+
鐃緒申��申鐃緒申   row area AREA of glyph row ROW that is part of the new glyph
+
鐃緒申��申鐃緒申   string.  END is the index of the last glyph in that glyph row area.
+
鐃緒申��申鐃緒申   X is the current output position assigned to the new glyph string
+
鐃緒申��申鐃緒申   constructed.  HL overrides that face of the glyph; e.g. it is
+
鐃緒申��申鐃緒申   DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the right-most
+
鐃緒申��申鐃緒申   x-position of the drawing area.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P)	  \
+
鐃緒申��申鐃緒申  do {									  \
+
鐃緒申��申鐃緒申    int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id;			  \
+
鐃緒申��申鐃緒申    int face_id = (ROW)->glyphs[AREA][START].face_id;			  \
+
鐃緒申��申鐃緒申    struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id);	  \
+
鐃緒申��申鐃緒申    struct composition *cmp = composition_table[cmp_id];		  \
+
鐃緒申��申鐃緒申    int glyph_len = cmp->glyph_len;					  \
+
鐃緒申��申鐃緒申    XChar2b *char2b;							  \
+
鐃緒申��申鐃緒申    struct face **faces;						  \
+
鐃緒申��申鐃緒申    struct glyph_string *first_s = NULL;				  \
+
鐃緒申��申鐃緒申    int n;								  \
+
鐃緒申��申鐃緒申    									  \
+
鐃緒申��申鐃緒申    base_face = base_face->ascii_face;					  \
+
鐃緒申��申鐃緒申    char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len);		  \
+
鐃緒申��申鐃緒申    faces = (struct face **) alloca ((sizeof *faces) * glyph_len);	  \
+
鐃緒申��申鐃緒申    /* At first, fill in `char2b' and `faces'.  */			  \
+
鐃緒申��申鐃緒申    for (n = 0; n < glyph_len; n++)					  \
+
鐃緒申��申鐃緒申      {									  \
+
鐃緒申��申鐃緒申	int c = COMPOSITION_GLYPH (cmp, n);				  \
+
鐃緒申��申鐃緒申	int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
+
鐃緒申��申鐃緒申	faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id);	  \
+
鐃緒申��申鐃緒申	x_get_char_face_and_encoding (XFRAME (w->frame), c,		  \
+
鐃緒申��申鐃緒申				      this_face_id, char2b + n, 1);	  \
+
鐃緒申��申鐃緒申      }									  \
+
鐃緒申��申鐃緒申    									  \
+
鐃緒申��申鐃緒申    /* Make glyph_strings for each glyph sequence that is drawable by	  \
+
鐃緒申��申鐃緒申       the same face, and append them to HEAD/TAIL.  */			  \
+
鐃緒申��申鐃緒申    for (n = 0; n < cmp->glyph_len;)					  \
+
鐃緒申��申鐃緒申      {									  \
+
鐃緒申��申鐃緒申	s = (struct glyph_string *) alloca (sizeof *s);			  \
+
鐃緒申��申鐃緒申	x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL);	  \
+
鐃緒申��申鐃緒申	x_append_glyph_string (&(HEAD), &(TAIL), s);			  \
+
鐃緒申��申鐃緒申	s->cmp = cmp;							  \
+
鐃緒申��申鐃緒申	s->gidx = n;							  \
+
鐃緒申��申鐃緒申	s->x = (X);							  \
+
鐃緒申��申鐃緒申									  \
+
鐃緒申��申鐃緒申	if (n == 0)							  \
+
鐃緒申��申鐃緒申	  first_s = s;							  \
+
鐃緒申��申鐃緒申									  \
+
鐃緒申��申鐃緒申	n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P);	  \
+
鐃緒申��申鐃緒申      }									  \
+
鐃緒申��申鐃緒申    									  \
+
鐃緒申��申鐃緒申    ++START;								  \
+
鐃緒申��申鐃緒申    s = first_s;							  \
+
鐃緒申��申鐃緒申  } while (0)
+
鐃緒申��申鐃緒申    
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Build a list of glyph strings between HEAD and TAIL for the glyphs
+
鐃緒申��申鐃緒申   of AREA of glyph row ROW on window W between indices START and END.
+
鐃緒申��申鐃緒申   HL overrides the face for drawing glyph strings, e.g. it is
+
鐃緒申��申鐃緒申   DRAW_CURSOR to draw a cursor.  X and LAST_X are start and end
+
鐃緒申��申鐃緒申   x-positions of the drawing area.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   This is an ugly monster macro construct because we must use alloca
+
鐃緒申��申鐃緒申   to allocate glyph strings (because x_draw_glyphs can be called
+
鐃緒申��申鐃緒申   asynchronously).  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
+
鐃緒申��申鐃緒申     do									   \
+
鐃緒申��申鐃緒申       {								   \
+
鐃緒申��申鐃緒申	 HEAD = TAIL = NULL;						   \
+
鐃緒申��申鐃緒申	 while (START < END)						   \
+
鐃緒申��申鐃緒申	   {								   \
+
鐃緒申��申鐃緒申             struct glyph *first_glyph = (ROW)->glyphs[AREA] + START;	   \
+
鐃緒申��申鐃緒申             switch (first_glyph->type)					   \
+
鐃緒申��申鐃緒申	       {							   \
+
鐃緒申��申鐃緒申	       case CHAR_GLYPH:						   \
+
鐃緒申��申鐃緒申                 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
+
鐃緒申��申鐃緒申		                           TAIL, HL, X, LAST_X,		   \
+
鐃緒申��申鐃緒申                                           OVERLAPS_P);	                   \
+
鐃緒申��申鐃緒申		 break;							   \
+
鐃緒申��申鐃緒申									   \
+
鐃緒申��申鐃緒申	       case COMPOSITE_GLYPH:					   \
+
鐃緒申��申鐃緒申                 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END,   \
+
鐃緒申��申鐃緒申						 HEAD, TAIL, HL, X, LAST_X,\
+
鐃緒申��申鐃緒申						 OVERLAPS_P);		   \
+
鐃緒申��申鐃緒申		 break;							   \
+
鐃緒申��申鐃緒申									   \
+
鐃緒申��申鐃緒申	       case STRETCH_GLYPH:					   \
+
鐃緒申��申鐃緒申		 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END,	   \
+
鐃緒申��申鐃緒申					     HEAD, TAIL, HL, X, LAST_X);   \
+
鐃緒申��申鐃緒申		 break;							   \
+
鐃緒申��申鐃緒申									   \
+
鐃緒申��申鐃緒申	       case IMAGE_GLYPH:					   \
+
鐃緒申��申鐃緒申		 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
+
鐃緒申��申鐃緒申					   TAIL, HL, X, LAST_X);	   \
+
鐃緒申��申鐃緒申		 break;							   \
+
鐃緒申��申鐃緒申									   \
+
鐃緒申��申鐃緒申	       default:							   \
+
鐃緒申��申鐃緒申		 abort ();						   \
+
鐃緒申��申鐃緒申	       }							   \
+
鐃緒申��申鐃緒申									   \
+
鐃緒申��申鐃緒申             x_set_glyph_string_background_width (s, START, LAST_X);	   \
+
鐃緒申��申鐃緒申	     (X) += s->width;						   \
+
鐃緒申��申鐃緒申            }								   \
+
鐃緒申��申鐃緒申       }								   \
+
鐃緒申��申鐃緒申     while (0)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw glyphs between START and END in AREA of ROW on window W,
+
鐃緒申��申鐃緒申   starting at x-position X.  X is relative to AREA in W.  HL is a
+
鐃緒申��申鐃緒申   face-override with the following meaning:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   DRAW_NORMAL_TEXT	draw normally
+
鐃緒申��申鐃緒申   DRAW_CURSOR		draw in cursor face
+
鐃緒申��申鐃緒申   DRAW_MOUSE_FACE	draw in mouse face.
+
鐃緒申��申鐃緒申   DRAW_INVERSE_VIDEO	draw in mode line face
+
鐃緒申��申鐃緒申   DRAW_IMAGE_SUNKEN	draw an image with a sunken relief around it
+
鐃緒申��申鐃緒申   DRAW_IMAGE_RAISED	draw an image with a raised relief around it
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If REAL_START is non-null, return in *REAL_START the real starting
+
鐃緒申��申鐃緒申   position for display.  This can be different from START in case
+
鐃緒申��申鐃緒申   overlapping glyphs must be displayed.  If REAL_END is non-null,
+
鐃緒申��申鐃緒申   return in *REAL_END the real end position for display.  This can be
+
鐃緒申��申鐃緒申   different from END in case overlapping glyphs must be displayed.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If OVERLAPS_P is non-zero, draw only the foreground of characters
+
鐃緒申��申鐃緒申   and clip to the physical height of ROW.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Value is the x-position reached, relative to AREA of W.  */
+
鐃緒申��申鐃緒申     
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_draw_glyphs (w, x, row, area, start, end, hl, real_start, real_end,
+
鐃緒申��申鐃緒申	       overlaps_p)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int x;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     enum glyph_row_area area;
+
鐃緒申��申鐃緒申     int start, end;
+
鐃緒申��申鐃緒申     enum draw_glyphs_face hl;
+
鐃緒申��申鐃緒申     int *real_start, *real_end;
+
鐃緒申��申鐃緒申     int overlaps_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct glyph_string *head, *tail;
+
鐃緒申��申鐃緒申  struct glyph_string *s;
+
鐃緒申��申鐃緒申  int last_x, area_width;
+
鐃緒申��申鐃緒申  int x_reached;
+
鐃緒申��申鐃緒申  int i, j;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Let's rather be paranoid than getting a SEGV.  */
+
鐃緒申��申鐃緒申  end = min (end, row->used[area]);
+
鐃緒申��申鐃緒申  start = max (0, start);
+
鐃緒申��申鐃緒申  start = min (end, start);
+
鐃緒申��申鐃緒申  if (real_start)
+
鐃緒申��申鐃緒申    *real_start = start;
+
鐃緒申��申鐃緒申  if (real_end)
+
鐃緒申��申鐃緒申    *real_end = end;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Translate X to frame coordinates.  Set last_x to the right
+
鐃緒申��申鐃緒申     end of the drawing area.  */
+
鐃緒申��申鐃緒申  if (row->full_width_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* X is relative to the left edge of W, without scroll bars
+
鐃緒申��申鐃緒申	 or flag areas.  */
+
鐃緒申��申鐃緒申      struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申      /* int width = FRAME_FLAGS_AREA_WIDTH (f);  */
+
鐃緒申��申鐃緒申      int window_left_x = WINDOW_LEFT_MARGIN (w) * CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      x += window_left_x;
+
鐃緒申��申鐃緒申      area_width = XFASTINT (w->width) * CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申      last_x = window_left_x + area_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int width = FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申	  if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
+
鐃緒申��申鐃緒申	    last_x += width;
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    x -= width;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      x += FRAME_INTERNAL_BORDER_WIDTH (f);
+
鐃緒申��申鐃緒申      last_x += FRAME_INTERNAL_BORDER_WIDTH (f);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, x);
+
鐃緒申��申鐃緒申      area_width = window_box_width (w, area);
+
鐃緒申��申鐃緒申      last_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, area_width);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Build a doubly-linked list of glyph_string structures between
+
鐃緒申��申鐃緒申     head and tail from what we have to draw.  Note that the macro
+
鐃緒申��申鐃緒申     BUILD_GLYPH_STRINGS will modify its start parameter.  That's
+
鐃緒申��申鐃緒申     the reason we use a separate variable `i'.  */
+
鐃緒申��申鐃緒申  i = start;
+
鐃緒申��申鐃緒申  BUILD_GLYPH_STRINGS (w, row, area, i, end, head, tail, hl, x, last_x,
+
鐃緒申��申鐃緒申		       overlaps_p);
+
鐃緒申��申鐃緒申  if (tail)
+
鐃緒申��申鐃緒申    x_reached = tail->x + tail->background_width;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x_reached = x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If there are any glyphs with lbearing < 0 or rbearing > width in
+
鐃緒申��申鐃緒申     the row, redraw some glyphs in front or following the glyph
+
鐃緒申��申鐃緒申     strings built above.  */
+
鐃緒申��申鐃緒申  if (head && !overlaps_p && row->contains_overlapping_glyphs_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int dummy_x = 0;
+
鐃緒申��申鐃緒申      struct glyph_string *h, *t;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Compute overhangs for all glyph strings.  */
+
鐃緒申��申鐃緒申      for (s = head; s; s = s->next)
+
鐃緒申��申鐃緒申	x_compute_glyph_string_overhangs (s);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Prepend glyph strings for glyphs in front of the first glyph
+
鐃緒申��申鐃緒申	 string that are overwritten because of the first glyph
+
鐃緒申��申鐃緒申	 string's left overhang.  The background of all strings
+
鐃緒申��申鐃緒申	 prepended must be drawn because the first glyph string 
+
鐃緒申��申鐃緒申	 draws over it.  */
+
鐃緒申��申鐃緒申      i = x_left_overwritten (head);
+
鐃緒申��申鐃緒申      if (i >= 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  j = i;
+
鐃緒申��申鐃緒申	  BUILD_GLYPH_STRINGS (w, row, area, j, start, h, t,
+
鐃緒申��申鐃緒申			       DRAW_NORMAL_TEXT, dummy_x, last_x,
+
鐃緒申��申鐃緒申			       overlaps_p);
+
鐃緒申��申鐃緒申	  start = i;
+
鐃緒申��申鐃緒申	  if (real_start)
+
鐃緒申��申鐃緒申	    *real_start = start;
+
鐃緒申��申鐃緒申	  x_compute_overhangs_and_x (t, head->x, 1);
+
鐃緒申��申鐃緒申	  x_prepend_glyph_string_lists (&head, &tail, h, t);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Prepend glyph strings for glyphs in front of the first glyph
+
鐃緒申��申鐃緒申	 string that overwrite that glyph string because of their
+
鐃緒申��申鐃緒申	 right overhang.  For these strings, only the foreground must
+
鐃緒申��申鐃緒申	 be drawn, because it draws over the glyph string at `head'.
+
鐃緒申��申鐃緒申	 The background must not be drawn because this would overwrite
+
鐃緒申��申鐃緒申	 right overhangs of preceding glyphs for which no glyph
+
鐃緒申��申鐃緒申	 strings exist.  */
+
鐃緒申��申鐃緒申      i = x_left_overwriting (head);
+
鐃緒申��申鐃緒申      if (i >= 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  BUILD_GLYPH_STRINGS (w, row, area, i, start, h, t,
+
鐃緒申��申鐃緒申			       DRAW_NORMAL_TEXT, dummy_x, last_x,
+
鐃緒申��申鐃緒申			       overlaps_p);
+
鐃緒申��申鐃緒申	  for (s = h; s; s = s->next)
+
鐃緒申��申鐃緒申	    s->background_filled_p = 1;
+
鐃緒申��申鐃緒申	  if (real_start)
+
鐃緒申��申鐃緒申	    *real_start = i;
+
鐃緒申��申鐃緒申	  x_compute_overhangs_and_x (t, head->x, 1);
+
鐃緒申��申鐃緒申	  x_prepend_glyph_string_lists (&head, &tail, h, t);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Append glyphs strings for glyphs following the last glyph
+
鐃緒申��申鐃緒申	 string tail that are overwritten by tail.  The background of
+
鐃緒申��申鐃緒申	 these strings has to be drawn because tail's foreground draws
+
鐃緒申��申鐃緒申	 over it.  */
+
鐃緒申��申鐃緒申      i = x_right_overwritten (tail);
+
鐃緒申��申鐃緒申      if (i >= 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  BUILD_GLYPH_STRINGS (w, row, area, end, i, h, t,
+
鐃緒申��申鐃緒申			       DRAW_NORMAL_TEXT, x, last_x,
+
鐃緒申��申鐃緒申			       overlaps_p);
+
鐃緒申��申鐃緒申	  x_compute_overhangs_and_x (h, tail->x + tail->width, 0);
+
鐃緒申��申鐃緒申	  x_append_glyph_string_lists (&head, &tail, h, t);
+
鐃緒申��申鐃緒申	  if (real_end)
+
鐃緒申��申鐃緒申	    *real_end = i;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Append glyph strings for glyphs following the last glyph
+
鐃緒申��申鐃緒申	 string tail that overwrite tail.  The foreground of such
+
鐃緒申��申鐃緒申	 glyphs has to be drawn because it writes into the background
+
鐃緒申��申鐃緒申	 of tail.  The background must not be drawn because it could
+
鐃緒申��申鐃緒申	 paint over the foreground of following glyphs.  */
+
鐃緒申��申鐃緒申      i = x_right_overwriting (tail);
+
鐃緒申��申鐃緒申      if (i >= 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  BUILD_GLYPH_STRINGS (w, row, area, end, i, h, t,
+
鐃緒申��申鐃緒申			       DRAW_NORMAL_TEXT, x, last_x,
+
鐃緒申��申鐃緒申			       overlaps_p);
+
鐃緒申��申鐃緒申	  for (s = h; s; s = s->next)
+
鐃緒申��申鐃緒申	    s->background_filled_p = 1;
+
鐃緒申��申鐃緒申	  x_compute_overhangs_and_x (h, tail->x + tail->width, 0);
+
鐃緒申��申鐃緒申	  x_append_glyph_string_lists (&head, &tail, h, t);
+
鐃緒申��申鐃緒申	  if (real_end)
+
鐃緒申��申鐃緒申	    *real_end = i;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Draw all strings.  */
+
鐃緒申��申鐃緒申  for (s = head; s; s = s->next)
+
鐃緒申��申鐃緒申    x_draw_glyph_string (s);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Value is the x-position up to which drawn, relative to AREA of W.
+
鐃緒申��申鐃緒申     This doesn't include parts drawn because of overhangs.  */
+
鐃緒申��申鐃緒申  x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
+
鐃緒申��申鐃緒申  if (!row->full_width_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (area > LEFT_MARGIN_AREA)
+
鐃緒申��申鐃緒申	x_reached -= window_box_width (w, LEFT_MARGIN_AREA);
+
鐃緒申��申鐃緒申      if (area > TEXT_AREA)
+
鐃緒申��申鐃緒申	x_reached -= window_box_width (w, TEXT_AREA);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  return x_reached;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Fix the display of area AREA of overlapping row ROW in window W.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_fix_overlapping_area (w, row, area)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     enum glyph_row_area area;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i, x;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (area == LEFT_MARGIN_AREA)
+
鐃緒申��申鐃緒申    x = 0;
+
鐃緒申��申鐃緒申  else if (area == TEXT_AREA)
+
鐃緒申��申鐃緒申    x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x = (window_box_width (w, LEFT_MARGIN_AREA)
+
鐃緒申��申鐃緒申	 + window_box_width (w, TEXT_AREA));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (i = 0; i < row->used[area];)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (row->glyphs[area][i].overlaps_vertically_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int start = i, start_x = x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  do
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      x += row->glyphs[area][i].pixel_width;
+
鐃緒申��申鐃緒申	      ++i;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  while (i < row->used[area]
+
鐃緒申��申鐃緒申		 && row->glyphs[area][i].overlaps_vertically_p);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  x_draw_glyphs (w, start_x, row, area, start, i,
+
鐃緒申��申鐃緒申			 (row->inverse_p
+
鐃緒申��申鐃緒申			  ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT),
+
鐃緒申��申鐃緒申			 NULL, NULL, 1);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x += row->glyphs[area][i].pixel_width;
+
鐃緒申��申鐃緒申	  ++i;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Output LEN glyphs starting at START at the nominal cursor position.
+
鐃緒申��申鐃緒申   Advance the nominal cursor over the text.  The global variable
+
鐃緒申��申鐃緒申   updated_window contains the window being updated, updated_row is
+
鐃緒申��申鐃緒申   the glyph row being updated, and updated_area is the area of that
+
鐃緒申��申鐃緒申   row being updated.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_write_glyphs (start, len)
+
鐃緒申��申鐃緒申     struct glyph *start;
+
鐃緒申��申鐃緒申     int len;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int x, hpos, real_start, real_end;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (updated_window && updated_row);
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Write glyphs.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  hpos = start - updated_row->glyphs[updated_area];
+
鐃緒申��申鐃緒申  x = x_draw_glyphs (updated_window, output_cursor.x,
+
鐃緒申��申鐃緒申		     updated_row, updated_area,
+
鐃緒申��申鐃緒申		     hpos, hpos + len,
+
鐃緒申��申鐃緒申		     (updated_row->inverse_p
+
鐃緒申��申鐃緒申		      ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT),
+
鐃緒申��申鐃緒申		     &real_start, &real_end, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If we drew over the cursor, note that it is not visible any more.  */
+
鐃緒申��申鐃緒申  note_overwritten_text_cursor (updated_window, real_start,
+
鐃緒申��申鐃緒申				real_end - real_start);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Advance the output cursor.  */
+
鐃緒申��申鐃緒申  output_cursor.hpos += len;
+
鐃緒申��申鐃緒申  output_cursor.x = x;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Insert LEN glyphs from START at the nominal cursor position.   */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_insert_glyphs (start, len)
+
鐃緒申��申鐃緒申     struct glyph *start;
+
鐃緒申��申鐃緒申     register int len;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f;
+
鐃緒申��申鐃緒申  struct window *w;
+
鐃緒申��申鐃緒申  int line_height, shift_by_width, shifted_region_width;
+
鐃緒申��申鐃緒申  struct glyph_row *row;
+
鐃緒申��申鐃緒申  struct glyph *glyph;
+
鐃緒申��申鐃緒申  int frame_x, frame_y, hpos, real_start, real_end;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (updated_window && updated_row);
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  w = updated_window;
+
鐃緒申��申鐃緒申  f = XFRAME (WINDOW_FRAME (w));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the height of the line we are in.  */
+
鐃緒申��申鐃緒申  row = updated_row;
+
鐃緒申��申鐃緒申  line_height = row->height;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the width of the glyphs to insert.  */
+
鐃緒申��申鐃緒申  shift_by_width = 0;
+
鐃緒申��申鐃緒申  for (glyph = start; glyph < start + len; ++glyph)
+
鐃緒申��申鐃緒申    shift_by_width += glyph->pixel_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the width of the region to shift right.  */
+
鐃緒申��申鐃緒申  shifted_region_width = (window_box_width (w, updated_area)
+
鐃緒申��申鐃緒申			  - output_cursor.x
+
鐃緒申��申鐃緒申			  - shift_by_width);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Shift right.  */
+
鐃緒申��申鐃緒申  frame_x = window_box_left (w, updated_area) + output_cursor.x;
+
鐃緒申��申鐃緒申  frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);
+
鐃緒申��申鐃緒申  XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申	     f->output_data.x->normal_gc,
+
鐃緒申��申鐃緒申	     frame_x, frame_y,
+
鐃緒申��申鐃緒申	     shifted_region_width, line_height,
+
鐃緒申��申鐃緒申	     frame_x + shift_by_width, frame_y);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Write the glyphs.  */
+
鐃緒申��申鐃緒申  hpos = start - row->glyphs[updated_area];
+
鐃緒申��申鐃緒申  x_draw_glyphs (w, output_cursor.x, row, updated_area, hpos, hpos + len,
+
鐃緒申��申鐃緒申		 DRAW_NORMAL_TEXT, &real_start, &real_end, 0);
+
鐃緒申��申鐃緒申  note_overwritten_text_cursor (w, real_start, real_end - real_start);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Advance the output cursor.  */
+
鐃緒申��申鐃緒申  output_cursor.hpos += len;
+
鐃緒申��申鐃緒申  output_cursor.x += shift_by_width;
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Delete N glyphs at the nominal cursor position.  Not implemented
+
鐃緒申��申鐃緒申   for X frames.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_delete_glyphs (n)
+
鐃緒申��申鐃緒申     register int n;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  abort ();
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
+
鐃緒申��申鐃緒申   If they are <= 0, this is probably an error.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_clear_area (dpy, window, x, y, width, height, exposures)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申     Window window;
+
鐃緒申��申鐃緒申     int x, y;
+
鐃緒申��申鐃緒申     int width, height;
+
鐃緒申��申鐃緒申     int exposures;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  xassert (width > 0 && height > 0);
+
鐃緒申��申鐃緒申  XClearArea (dpy, window, x, y, width, height, exposures);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Erase the current text line from the nominal cursor position
+
鐃緒申��申鐃緒申   (inclusive) to pixel column TO_X (exclusive).  The idea is that
+
鐃緒申��申鐃緒申   everything from TO_X onward is already erased.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   TO_X is a pixel position relative to updated_area of
+
鐃緒申��申鐃緒申   updated_window.  TO_X == -1 means clear to the end of this area.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_clear_end_of_line (to_x)
+
鐃緒申��申鐃緒申     int to_x;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f;
+
鐃緒申��申鐃緒申  struct window *w = updated_window;
+
鐃緒申��申鐃緒申  int max_x, min_y, max_y;
+
鐃緒申��申鐃緒申  int from_x, from_y, to_y;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  xassert (updated_window && updated_row);
+
鐃緒申��申鐃緒申  f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (updated_row->full_width_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      max_x = XFASTINT (w->width) * CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申      if (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
+
鐃緒申��申鐃緒申	  && !w->pseudo_window_p)
+
鐃緒申��申鐃緒申	max_x += FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    max_x = window_box_width (w, updated_area);
+
鐃緒申��申鐃緒申  max_y = window_text_bottom_y (w);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* TO_X == 0 means don't do anything.  TO_X < 0 means clear to end
+
鐃緒申��申鐃緒申     of window.  For TO_X > 0, truncate to end of drawing area.  */
+
鐃緒申��申鐃緒申  if (to_x == 0)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申  else if (to_x < 0)
+
鐃緒申��申鐃緒申    to_x = max_x;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    to_x = min (to_x, max_x);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  to_y = min (max_y, output_cursor.y + updated_row->height);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Notice if the cursor will be cleared by this operation.  */
+
鐃緒申��申鐃緒申  if (!updated_row->full_width_p)
+
鐃緒申��申鐃緒申    note_overwritten_text_cursor (w, output_cursor.hpos, -1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  from_x = output_cursor.x;
+
鐃緒申��申鐃緒申     
+
鐃緒申��申鐃緒申  /* Translate to frame coordinates.  */
+
鐃緒申��申鐃緒申  if (updated_row->full_width_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
+
鐃緒申��申鐃緒申      to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      from_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, from_x);
+
鐃緒申��申鐃緒申      to_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, to_x);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+
鐃緒申��申鐃緒申  from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
+
鐃緒申��申鐃緒申  to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Prevent inadvertently clearing to end of the X window.  */
+
鐃緒申��申鐃緒申  if (to_x > from_x && to_y > from_y)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申      x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		    from_x, from_y, to_x - from_x, to_y - from_y,
+
鐃緒申��申鐃緒申		    False);
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Clear entire frame.  If updating_frame is non-null, clear that
+
鐃緒申��申鐃緒申   frame.  Otherwise clear the selected frame.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_clear_frame ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (updating_frame)
+
鐃緒申��申鐃緒申    f = updating_frame;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    f = SELECTED_FRAME ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Clearing the frame will erase any cursor, so mark them all as no
+
鐃緒申��申鐃緒申     longer visible.  */
+
鐃緒申��申鐃緒申  mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
+
鐃緒申��申鐃緒申  output_cursor.hpos = output_cursor.vpos = 0;
+
鐃緒申��申鐃緒申  output_cursor.x = -1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We don't set the output cursor here because there will always
+
鐃緒申��申鐃緒申     follow an explicit cursor_to.  */
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We have to clear the scroll bars, too.  If we have changed
+
鐃緒申��申鐃緒申     colors or something like that, then they should be notified.  */
+
鐃緒申��申鐃緒申  x_scroll_bar_clear (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Invert the middle quarter of the frame for .15 sec.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* We use the select system call to do the waiting, so we have to make
+
鐃緒申��申鐃緒申   sure it's available.  If it isn't, we just won't do visual bells.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Subtract the `struct timeval' values X and Y, storing the result in
+
鐃緒申��申鐃緒申   *RESULT.  Return 1 if the difference is negative, otherwise 0.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申timeval_subtract (result, x, y)
+
鐃緒申��申鐃緒申     struct timeval *result, x, y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Perform the carry for the later subtraction by updating y.  This
+
鐃緒申��申鐃緒申     is safer because on some systems the tv_sec member is unsigned.  */
+
鐃緒申��申鐃緒申  if (x.tv_usec < y.tv_usec)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1;
+
鐃緒申��申鐃緒申      y.tv_usec -= 1000000 * nsec;
+
鐃緒申��申鐃緒申      y.tv_sec += nsec;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (x.tv_usec - y.tv_usec > 1000000)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int nsec = (y.tv_usec - x.tv_usec) / 1000000;
+
鐃緒申��申鐃緒申      y.tv_usec += 1000000 * nsec;
+
鐃緒申��申鐃緒申      y.tv_sec -= nsec;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Compute the time remaining to wait.  tv_usec is certainly
+
鐃緒申��申鐃緒申     positive.  */
+
鐃緒申��申鐃緒申  result->tv_sec = x.tv_sec - y.tv_sec;
+
鐃緒申��申鐃緒申  result->tv_usec = x.tv_usec - y.tv_usec;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Return indication of whether the result should be considered
+
鐃緒申��申鐃緒申     negative.  */
+
鐃緒申��申鐃緒申  return x.tv_sec < y.tv_sec;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申XTflash (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    GC gc;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Create a GC that will use the GXxor function to flip foreground
+
鐃緒申��申鐃緒申       pixels into background pixels.  */
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XGCValues values;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      values.function = GXxor;
+
鐃緒申��申鐃緒申      values.foreground = (f->output_data.x->foreground_pixel
+
鐃緒申��申鐃緒申			   ^ f->output_data.x->background_pixel);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      gc = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		      GCFunction | GCForeground, &values);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Get the height not including a menu bar widget.  */
+
鐃緒申��申鐃緒申      int height = CHAR_TO_PIXEL_HEIGHT (f, FRAME_HEIGHT (f));
+
鐃緒申��申鐃緒申      /* Height of each line to flash.  */
+
鐃緒申��申鐃緒申      int flash_height = FRAME_LINE_HEIGHT (f);
+
鐃緒申��申鐃緒申      /* These will be the left and right margins of the rectangles.  */
+
鐃緒申��申鐃緒申      int flash_left = FRAME_INTERNAL_BORDER_WIDTH (f);
+
鐃緒申��申鐃緒申      int flash_right = PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      int width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Don't flash the area between a scroll bar and the frame
+
鐃緒申��申鐃緒申	 edge it is next to.  */
+
鐃緒申��申鐃緒申      switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	case vertical_scroll_bar_left:
+
鐃緒申��申鐃緒申	  flash_left += VERTICAL_SCROLL_BAR_WIDTH_TRIM;
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	case vertical_scroll_bar_right:
+
鐃緒申��申鐃緒申	  flash_right -= VERTICAL_SCROLL_BAR_WIDTH_TRIM;
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	default:
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      width = flash_right - flash_left;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* If window is tall, flash top and bottom line.  */
+
鐃緒申��申鐃緒申      if (height > 3 * FRAME_LINE_HEIGHT (f))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申			  flash_left,
+
鐃緒申��申鐃緒申			  (FRAME_INTERNAL_BORDER_WIDTH (f)
+
鐃緒申��申鐃緒申			   + FRAME_TOOL_BAR_LINES (f) * CANON_Y_UNIT (f)),
+
鐃緒申��申鐃緒申			  width, flash_height);
+
鐃緒申��申鐃緒申	  XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申			  flash_left,
+
鐃緒申��申鐃緒申			  (height - flash_height
+
鐃緒申��申鐃緒申			   - FRAME_INTERNAL_BORDER_WIDTH (f)),
+
鐃緒申��申鐃緒申			  width, flash_height);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	/* If it is short, flash it all.  */ 
+
鐃緒申��申鐃緒申	XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申			flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
+
鐃緒申��申鐃緒申			width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      x_flush (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	struct timeval wakeup;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	EMACS_GET_TIME (wakeup);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* Compute time to wait until, propagating carry from usecs.  */
+
鐃緒申��申鐃緒申	wakeup.tv_usec += 150000;
+
鐃緒申��申鐃緒申	wakeup.tv_sec += (wakeup.tv_usec / 1000000);
+
鐃緒申��申鐃緒申	wakeup.tv_usec %= 1000000;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* Keep waiting until past the time wakeup or any input gets
+
鐃緒申��申鐃緒申	   available.  */
+
鐃緒申��申鐃緒申	while (! detect_input_pending ())
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    struct timeval current;
+
鐃緒申��申鐃緒申	    struct timeval timeout;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    EMACS_GET_TIME (current);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    /* Break if result would be negative.  */
+
鐃緒申��申鐃緒申	    if (timeval_subtract (&current, wakeup, current))
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    /* How long `select' should wait.  */
+
鐃緒申��申鐃緒申	    timeout.tv_sec = 0;
+
鐃緒申��申鐃緒申	    timeout.tv_usec = 10000;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    /* Try to wait that long--but we might wake up sooner.  */
+
鐃緒申��申鐃緒申	    select (0, NULL, NULL, NULL, &timeout);
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* If window is tall, flash top and bottom line.  */
+
鐃緒申��申鐃緒申      if (height > 3 * FRAME_LINE_HEIGHT (f))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申			  flash_left,
+
鐃緒申��申鐃緒申			  (FRAME_INTERNAL_BORDER_WIDTH (f)
+
鐃緒申��申鐃緒申			   + FRAME_TOOL_BAR_LINES (f) * CANON_Y_UNIT (f)),
+
鐃緒申��申鐃緒申			  width, flash_height);
+
鐃緒申��申鐃緒申	  XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申			  flash_left,
+
鐃緒申��申鐃緒申			  (height - flash_height
+
鐃緒申��申鐃緒申			   - FRAME_INTERNAL_BORDER_WIDTH (f)),
+
鐃緒申��申鐃緒申			  width, flash_height);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	/* If it is short, flash it all.  */ 
+
鐃緒申��申鐃緒申	XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
+
鐃緒申��申鐃緒申			flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
+
鐃緒申��申鐃緒申			width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      XFreeGC (FRAME_X_DISPLAY (f), gc);
+
鐃緒申��申鐃緒申      x_flush (f);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Make audible bell.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申XTring_bell ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = SELECTED_FRAME ();
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (FRAME_X_DISPLAY (f))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
+
鐃緒申��申鐃緒申      if (visible_bell)
+
鐃緒申��申鐃緒申	XTflash (f);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  BLOCK_INPUT;
+
鐃緒申��申鐃緒申	  XBell (FRAME_X_DISPLAY (f), 0);
+
鐃緒申��申鐃緒申	  XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申	  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Specify how many text lines, from the top of the window,
+
鐃緒申��申鐃緒申   should be affected by insert-lines and delete-lines operations.
+
鐃緒申��申鐃緒申   This, and those operations, are used only within an update
+
鐃緒申��申鐃緒申   that is bounded by calls to x_update_begin and x_update_end.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTset_terminal_window (n)
+
鐃緒申��申鐃緒申     register int n;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* This function intentionally left blank.  */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			      Line Dance
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Perform an insert-lines or delete-lines operation, inserting N
+
鐃緒申��申鐃緒申   lines or deleting -N lines at vertical position VPOS.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_ins_del_lines (vpos, n)
+
鐃緒申��申鐃緒申     int vpos, n;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  abort ();
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Scroll part of the display as described by RUN.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_scroll_run (w, run)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct run *run;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  int x, y, width, height, from_y, to_y, bottom_y;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get frame-relative bounding box of the text display area of W,
+
鐃緒申��申鐃緒申     without mode lines.  Include in this box the flags areas to the
+
鐃緒申��申鐃緒申     left and right of W.  */
+
鐃緒申��申鐃緒申  window_box (w, -1, &x, &y, &width, &height);
+
鐃緒申��申鐃緒申  width += FRAME_X_FLAGS_AREA_WIDTH (f);
+
鐃緒申��申鐃緒申  x -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
+
鐃緒申��申鐃緒申  to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
+
鐃緒申��申鐃緒申  bottom_y = y + height;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (to_y < from_y)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Scrolling up.  Make sure we don't copy part of the mode
+
鐃緒申��申鐃緒申	 line at the bottom.  */
+
鐃緒申��申鐃緒申      if (from_y + run->height > bottom_y)
+
鐃緒申��申鐃緒申	height = bottom_y - from_y;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	height = run->height;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Scolling down.  Make sure we don't copy over the mode line.
+
鐃緒申��申鐃緒申	 at the bottom.  */
+
鐃緒申��申鐃緒申      if (to_y + run->height > bottom_y)
+
鐃緒申��申鐃緒申	height = bottom_y - to_y;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	height = run->height;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Cursor off.  Will be switched on again in x_update_window_end.  */
+
鐃緒申��申鐃緒申  updated_window = w;
+
鐃緒申��申鐃緒申  x_clear_cursor (w);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XCopyArea (FRAME_X_DISPLAY (f),
+
鐃緒申��申鐃緒申	     FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申	     f->output_data.x->normal_gc,
+
鐃緒申��申鐃緒申	     x, from_y,
+
鐃緒申��申鐃緒申	     width, height,
+
鐃緒申��申鐃緒申	     x, to_y);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			   Exposure Events
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申									
+
鐃緒申��申鐃緒申/* Redisplay an exposed area of frame F.  X and Y are the upper-left
+
鐃緒申��申鐃緒申   corner of the exposed rectangle.  W and H are width and height of
+
鐃緒申��申鐃緒申   the exposed area.  All are pixel values.  W or H zero means redraw
+
鐃緒申��申鐃緒申   the entire frame.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申expose_frame (f, x, y, w, h)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int x, y, w, h;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XRectangle r;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  TRACE ((stderr, "expose_frame "));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* No need to redraw if frame will be redrawn soon.  */
+
鐃緒申��申鐃緒申  if (FRAME_GARBAGED_P (f))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      TRACE ((stderr, " garbaged\n"));
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If basic faces haven't been realized yet, there is no point in
+
鐃緒申��申鐃緒申     trying to redraw anything.  This can happen when we get an expose
+
鐃緒申��申鐃緒申     event while Emacs is starting, e.g. by moving another window.  */
+
鐃緒申��申鐃緒申  if (FRAME_FACE_CACHE (f) == NULL
+
鐃緒申��申鐃緒申      || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      TRACE ((stderr, " no faces\n"));
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (w == 0 || h == 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      r.x = r.y = 0;
+
鐃緒申��申鐃緒申      r.width = CANON_X_UNIT (f) * f->width;
+
鐃緒申��申鐃緒申      r.height = CANON_Y_UNIT (f) * f->height;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      r.x = x;
+
鐃緒申��申鐃緒申      r.y = y;
+
鐃緒申��申鐃緒申      r.width = w;
+
鐃緒申��申鐃緒申      r.height = h;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  TRACE ((stderr, "(%d, %d, %d, %d)\n", r.x, r.y, r.width, r.height));
+
鐃緒申��申鐃緒申  expose_window_tree (XWINDOW (f->root_window), &r);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (WINDOWP (f->tool_bar_window))
+
鐃緒申��申鐃緒申    expose_window (XWINDOW (f->tool_bar_window), &r);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  if (WINDOWP (f->menu_bar_window))
+
鐃緒申��申鐃緒申    expose_window (XWINDOW (f->menu_bar_window), &r);
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Redraw (parts) of all windows in the window tree rooted at W that
+
鐃緒申��申鐃緒申   intersect R.  R contains frame pixel coordinates.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申expose_window_tree (w, r)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     XRectangle *r;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  while (w)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (!NILP (w->hchild))
+
鐃緒申��申鐃緒申	expose_window_tree (XWINDOW (w->hchild), r);
+
鐃緒申��申鐃緒申      else if (!NILP (w->vchild))
+
鐃緒申��申鐃緒申	expose_window_tree (XWINDOW (w->vchild), r);
+
鐃緒申��申鐃緒申      else if (expose_window (w, r) == 0)
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申      w = NILP (w->next) ? NULL : XWINDOW (w->next);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Redraw the part of glyph row area AREA of glyph row ROW on window W
+
鐃緒申��申鐃緒申   which intersects rectangle R.  R is in window-relative coordinates.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申expose_area (w, row, r, area)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     XRectangle *r;
+
鐃緒申��申鐃緒申     enum glyph_row_area area;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct glyph *first = row->glyphs[area];
+
鐃緒申��申鐃緒申  struct glyph *end = row->glyphs[area] + row->used[area];
+
鐃緒申��申鐃緒申  struct glyph *last;
+
鐃緒申��申鐃緒申  int first_x, start_x, x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (area == TEXT_AREA && row->fill_line_p)
+
鐃緒申��申鐃緒申    /* If row extends face to end of line write the whole line.  */
+
鐃緒申��申鐃緒申    x_draw_glyphs (w, 0, row, area,
+
鐃緒申��申鐃緒申		   0, row->used[area],
+
鐃緒申��申鐃緒申		   row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
+
鐃緒申��申鐃緒申		   NULL, NULL, 0);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Set START_X to the window-relative start position for drawing glyphs of
+
鐃緒申��申鐃緒申	 AREA.  The first glyph of the text area can be partially visible.
+
鐃緒申��申鐃緒申	 The first glyphs of other areas cannot.  */
+
鐃緒申��申鐃緒申      if (area == LEFT_MARGIN_AREA)
+
鐃緒申��申鐃緒申	start_x = 0;
+
鐃緒申��申鐃緒申      else if (area == TEXT_AREA)
+
鐃緒申��申鐃緒申	start_x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	start_x = (window_box_width (w, LEFT_MARGIN_AREA)
+
鐃緒申��申鐃緒申		   + window_box_width (w, TEXT_AREA));
+
鐃緒申��申鐃緒申      x = start_x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Find the first glyph that must be redrawn.  */
+
鐃緒申��申鐃緒申      while (first < end
+
鐃緒申��申鐃緒申	     && x + first->pixel_width < r->x)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x += first->pixel_width;
+
鐃緒申��申鐃緒申	  ++first;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Find the last one.  */
+
鐃緒申��申鐃緒申      last = first;
+
鐃緒申��申鐃緒申      first_x = x;
+
鐃緒申��申鐃緒申      while (last < end
+
鐃緒申��申鐃緒申	     && x < r->x + r->width)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x += last->pixel_width;
+
鐃緒申��申鐃緒申	  ++last;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Repaint.  */
+
鐃緒申��申鐃緒申      if (last > first)
+
鐃緒申��申鐃緒申	x_draw_glyphs (w, first_x - start_x, row, area,
+
鐃緒申��申鐃緒申		       first - row->glyphs[area],
+
鐃緒申��申鐃緒申		       last - row->glyphs[area],
+
鐃緒申��申鐃緒申		       row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
+
鐃緒申��申鐃緒申		       NULL, NULL, 0);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Redraw the parts of the glyph row ROW on window W intersecting
+
鐃緒申��申鐃緒申   rectangle R.  R is in window-relative coordinates.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申expose_line (w, row, r)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     XRectangle *r;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  xassert (row->enabled_p);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (row->mode_line_p || w->pseudo_window_p)
+
鐃緒申��申鐃緒申    x_draw_glyphs (w, 0, row, TEXT_AREA, 0, row->used[TEXT_AREA],
+
鐃緒申��申鐃緒申		   row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
+
鐃緒申��申鐃緒申		   NULL, NULL, 0);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (row->used[LEFT_MARGIN_AREA])
+
鐃緒申��申鐃緒申	expose_area (w, row, r, LEFT_MARGIN_AREA);
+
鐃緒申��申鐃緒申      if (row->used[TEXT_AREA])
+
鐃緒申��申鐃緒申	expose_area (w, row, r, TEXT_AREA);
+
鐃緒申��申鐃緒申      if (row->used[RIGHT_MARGIN_AREA])
+
鐃緒申��申鐃緒申	expose_area (w, row, r, RIGHT_MARGIN_AREA);
+
鐃緒申��申鐃緒申      x_draw_row_bitmaps (w, row);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return non-zero if W's cursor intersects rectangle R.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_phys_cursor_in_rect_p (w, r)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     XRectangle *r;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XRectangle cr, result;
+
鐃緒申��申鐃緒申  struct glyph *cursor_glyph;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  cursor_glyph = get_phys_cursor_glyph (w);
+
鐃緒申��申鐃緒申  if (cursor_glyph)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      cr.x = w->phys_cursor.x;
+
鐃緒申��申鐃緒申      cr.y = w->phys_cursor.y;
+
鐃緒申��申鐃緒申      cr.width = cursor_glyph->pixel_width;
+
鐃緒申��申鐃緒申      cr.height = w->phys_cursor_height;
+
鐃緒申��申鐃緒申      return x_intersect_rectangles (&cr, r, &result);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    return 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Redraw the part of window W intersection rectangle FR.  Pixel
+
鐃緒申��申鐃緒申   coordinates in FR are frame-relative.  Call this function with
+
鐃緒申��申鐃緒申   input blocked.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申expose_window (w, fr)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     XRectangle *fr;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  XRectangle wr, r;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If window is not yet fully initialized, do nothing.  This can
+
鐃緒申��申鐃緒申     happen when toolkit scroll bars are used and a window is split.
+
鐃緒申��申鐃緒申     Reconfiguring the scroll bar will generate an expose for a newly
+
鐃緒申��申鐃緒申     created window.  */
+
鐃緒申��申鐃緒申  if (w->current_matrix == NULL)
+
鐃緒申��申鐃緒申    return 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* When we're currently updating the window, display and current
+
鐃緒申��申鐃緒申     matrix usually don't agree.  Arrange for a thorough display
+
鐃緒申��申鐃緒申     later.  */
+
鐃緒申��申鐃緒申  if (w == updated_window)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      SET_FRAME_GARBAGED (f);
+
鐃緒申��申鐃緒申      return 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Frame-relative pixel rectangle of W.  */
+
鐃緒申��申鐃緒申  wr.x = XFASTINT (w->left) * CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申  wr.y = XFASTINT (w->top) * CANON_Y_UNIT (f);
+
鐃緒申��申鐃緒申  wr.width = XFASTINT (w->width) * CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申  wr.height = XFASTINT (w->height) * CANON_Y_UNIT (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (x_intersect_rectangles (fr, &wr, &r))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int yb = window_text_bottom_y (w);
+
鐃緒申��申鐃緒申      struct glyph_row *row;
+
鐃緒申��申鐃緒申      int cursor_cleared_p;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申      TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
+
鐃緒申��申鐃緒申	      r.x, r.y, r.width, r.height));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Convert to window coordinates.  */
+
鐃緒申��申鐃緒申      r.x = FRAME_TO_WINDOW_PIXEL_X (w, r.x);
+
鐃緒申��申鐃緒申      r.y = FRAME_TO_WINDOW_PIXEL_Y (w, r.y);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Turn off the cursor.  */
+
鐃緒申��申鐃緒申      if (!w->pseudo_window_p
+
鐃緒申��申鐃緒申	  && x_phys_cursor_in_rect_p (w, &r))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x_clear_cursor (w);
+
鐃緒申��申鐃緒申	  cursor_cleared_p = 1;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	cursor_cleared_p = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Find the first row intersecting the rectangle R.  */
+
鐃緒申��申鐃緒申      for (row = w->current_matrix->rows;
+
鐃緒申��申鐃緒申	   row->enabled_p;
+
鐃緒申��申鐃緒申	   ++row)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int y0 = row->y;
+
鐃緒申��申鐃緒申	  int y1 = MATRIX_ROW_BOTTOM_Y (row);
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  if ((y0 >= r.y && y0 < r.y + r.height)
+
鐃緒申��申鐃緒申	      || (y1 > r.y && y1 < r.y + r.height)
+
鐃緒申��申鐃緒申	      || (r.y >= y0 && r.y < y1)
+
鐃緒申��申鐃緒申	      || (r.y + r.height > y0 && r.y + r.height < y1))
+
鐃緒申��申鐃緒申	    expose_line (w, row, &r);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (y1 >= yb)
+
鐃緒申��申鐃緒申	    break;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Display the mode line if there is one.  */
+
鐃緒申��申鐃緒申      if (WINDOW_WANTS_MODELINE_P (w)
+
鐃緒申��申鐃緒申	  && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
+
鐃緒申��申鐃緒申	      row->enabled_p)
+
鐃緒申��申鐃緒申	  && row->y < r.y + r.height)
+
鐃緒申��申鐃緒申	expose_line (w, row, &r);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (!w->pseudo_window_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* Draw border between windows.  */
+
鐃緒申��申鐃緒申	  x_draw_vertical_border (w);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申	  /* Turn the cursor on again.  */
+
鐃緒申��申鐃緒申	  if (cursor_cleared_p)
+
鐃緒申��申鐃緒申	    x_update_window_cursor (w, 1);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  return 1;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Determine the intersection of two rectangles R1 and R2.  Return
+
鐃緒申��申鐃緒申   the intersection in *RESULT.  Value is non-zero if RESULT is not
+
鐃緒申��申鐃緒申   empty.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_intersect_rectangles (r1, r2, result)
+
鐃緒申��申鐃緒申     XRectangle *r1, *r2, *result;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XRectangle *left, *right;
+
鐃緒申��申鐃緒申  XRectangle *upper, *lower;
+
鐃緒申��申鐃緒申  int intersection_p = 0;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Rearrange so that R1 is the left-most rectangle.  */
+
鐃緒申��申鐃緒申  if (r1->x < r2->x)
+
鐃緒申��申鐃緒申    left = r1, right = r2;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    left = r2, right = r1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* X0 of the intersection is right.x0, if this is inside R1,
+
鐃緒申��申鐃緒申     otherwise there is no intersection.  */
+
鐃緒申��申鐃緒申  if (right->x <= left->x + left->width)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      result->x = right->x;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* The right end of the intersection is the minimum of the
+
鐃緒申��申鐃緒申	 the right ends of left and right.  */
+
鐃緒申��申鐃緒申      result->width = (min (left->x + left->width, right->x + right->width)
+
鐃緒申��申鐃緒申		       - result->x);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Same game for Y.  */
+
鐃緒申��申鐃緒申      if (r1->y < r2->y)
+
鐃緒申��申鐃緒申	upper = r1, lower = r2;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	upper = r2, lower = r1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* The upper end of the intersection is lower.y0, if this is inside
+
鐃緒申��申鐃緒申	 of upper.  Otherwise, there is no intersection.  */
+
鐃緒申��申鐃緒申      if (lower->y <= upper->y + upper->height)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  result->y = lower->y;
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  /* The lower end of the intersection is the minimum of the lower
+
鐃緒申��申鐃緒申	     ends of upper and lower.  */
+
鐃緒申��申鐃緒申	  result->height = (min (lower->y + lower->height, 
+
鐃緒申��申鐃緒申				 upper->y + upper->height)
+
鐃緒申��申鐃緒申			    - result->y);
+
鐃緒申��申鐃緒申	  intersection_p = 1;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return intersection_p;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申frame_highlight (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* We used to only do this if Vx_no_window_manager was non-nil, but
+
鐃緒申��申鐃緒申     the ICCCM (section 4.1.6) says that the window's border pixmap
+
鐃緒申��申鐃緒申     and border pixel are window attributes which are "private to the
+
鐃緒申��申鐃緒申     client", so we can always change it to whatever we want.  */
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		    f->output_data.x->border_pixel);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申  x_update_cursor (f, 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申frame_unhighlight (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* We used to only do this if Vx_no_window_manager was non-nil, but
+
鐃緒申��申鐃緒申     the ICCCM (section 4.1.6) says that the window's border pixmap
+
鐃緒申��申鐃緒申     and border pixel are window attributes which are "private to the
+
鐃緒申��申鐃緒申     client", so we can always change it to whatever we want.  */
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  XSetWindowBorderPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申			  f->output_data.x->border_tile);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申  x_update_cursor (f, 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The focus has changed.  Update the frames as necessary to reflect
+
鐃緒申��申鐃緒申   the new situation.  Note that we can't change the selected frame
+
鐃緒申��申鐃緒申   here, because the Lisp code we are interrupting might become confused.
+
鐃緒申��申鐃緒申   Each event gets marked with the frame in which it occurred, so the
+
鐃緒申��申鐃緒申   Lisp code can tell when the switch took place by examining the events.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_new_focus_frame (dpyinfo, frame)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申     struct frame *frame;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *old_focus = dpyinfo->x_focus_frame;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (frame != dpyinfo->x_focus_frame)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Set this before calling other routines, so that they see
+
鐃緒申��申鐃緒申	 the correct value of x_focus_frame.  */
+
鐃緒申��申鐃緒申      dpyinfo->x_focus_frame = frame;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (old_focus && old_focus->auto_lower)
+
鐃緒申��申鐃緒申	x_lower_frame (old_focus);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申      selected_frame = frame;
+
鐃緒申��申鐃緒申      XSETFRAME (XWINDOW (selected_frame->selected_window)->frame,
+
鐃緒申��申鐃緒申		 selected_frame);
+
鐃緒申��申鐃緒申      Fselect_window (selected_frame->selected_window);
+
鐃緒申��申鐃緒申      choose_minibuf_frame ();
+
鐃緒申��申鐃緒申#endif /* ! 0 */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (dpyinfo->x_focus_frame && dpyinfo->x_focus_frame->auto_raise)
+
鐃緒申��申鐃緒申	pending_autoraise_frame = dpyinfo->x_focus_frame;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	pending_autoraise_frame = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  x_frame_rehighlight (dpyinfo);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Handle an event saying the mouse has moved out of an Emacs frame.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_mouse_leave (dpyinfo)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  x_new_focus_frame (dpyinfo, dpyinfo->x_focus_event_frame);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The focus has changed, or we have redirected a frame's focus to
+
鐃緒申��申鐃緒申   another frame (this happens when a frame uses a surrogate
+
鐃緒申��申鐃緒申   mini-buffer frame).  Shift the highlight as appropriate.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   The FRAME argument doesn't necessarily have anything to do with which
+
鐃緒申��申鐃緒申   frame is being highlighted or un-highlighted; we only use it to find
+
鐃緒申��申鐃緒申   the appropriate X display info.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTframe_rehighlight (frame)
+
鐃緒申��申鐃緒申     struct frame *frame;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame));
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_frame_rehighlight (dpyinfo)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *old_highlight = dpyinfo->x_highlight_frame;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (dpyinfo->x_focus_frame)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      dpyinfo->x_highlight_frame
+
鐃緒申��申鐃緒申	= ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame)))
+
鐃緒申��申鐃緒申	   ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
+
鐃緒申��申鐃緒申	   : dpyinfo->x_focus_frame);
+
鐃緒申��申鐃緒申      if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame) = Qnil;
+
鐃緒申��申鐃緒申	  dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    dpyinfo->x_highlight_frame = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (dpyinfo->x_highlight_frame != old_highlight)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (old_highlight)
+
鐃緒申��申鐃緒申	frame_unhighlight (old_highlight);
+
鐃緒申��申鐃緒申      if (dpyinfo->x_highlight_frame)
+
鐃緒申��申鐃緒申	frame_highlight (dpyinfo->x_highlight_frame);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Keyboard processing - modifier keys, vendor-specific keysyms, etc.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Initialize mode_switch_bit and modifier_meaning.  */
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_find_modifier_meanings (dpyinfo)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int min_code, max_code;
+
鐃緒申��申鐃緒申  KeySym *syms;
+
鐃緒申��申鐃緒申  int syms_per_code;
+
鐃緒申��申鐃緒申  XModifierKeymap *mods;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo->meta_mod_mask = 0;
+
鐃緒申��申鐃緒申  dpyinfo->shift_lock_mask = 0;
+
鐃緒申��申鐃緒申  dpyinfo->alt_mod_mask = 0;
+
鐃緒申��申鐃緒申  dpyinfo->super_mod_mask = 0;
+
鐃緒申��申鐃緒申  dpyinfo->hyper_mod_mask = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R4
+
鐃緒申��申鐃緒申  XDisplayKeycodes (dpyinfo->display, &min_code, &max_code);
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申  min_code = dpyinfo->display->min_keycode;
+
鐃緒申��申鐃緒申  max_code = dpyinfo->display->max_keycode;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  syms = XGetKeyboardMapping (dpyinfo->display,
+
鐃緒申��申鐃緒申			      min_code, max_code - min_code + 1,
+
鐃緒申��申鐃緒申			      &syms_per_code);
+
鐃緒申��申鐃緒申  mods = XGetModifierMapping (dpyinfo->display);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Scan the modifier table to see which modifier bits the Meta and
+
鐃緒申��申鐃緒申     Alt keysyms are on.  */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    int row, col;	/* The row and column in the modifier table.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    for (row = 3; row < 8; row++)
+
鐃緒申��申鐃緒申      for (col = 0; col < mods->max_keypermod; col++)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  KeyCode code
+
鐃緒申��申鐃緒申	    = mods->modifiermap[(row * mods->max_keypermod) + col];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Zeroes are used for filler.  Skip them.  */
+
鐃緒申��申鐃緒申	  if (code == 0)
+
鐃緒申��申鐃緒申	    continue;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Are any of this keycode's keysyms a meta key?  */
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    int code_col;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    for (code_col = 0; code_col < syms_per_code; code_col++)
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		int sym = syms[((code - min_code) * syms_per_code) + code_col];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		switch (sym)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		  case XK_Meta_L:
+
鐃緒申��申鐃緒申		  case XK_Meta_R:
+
鐃緒申��申鐃緒申		    dpyinfo->meta_mod_mask |= (1 << row);
+
鐃緒申��申鐃緒申		    break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  case XK_Alt_L:
+
鐃緒申��申鐃緒申		  case XK_Alt_R:
+
鐃緒申��申鐃緒申		    dpyinfo->alt_mod_mask |= (1 << row);
+
鐃緒申��申鐃緒申		    break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  case XK_Hyper_L:
+
鐃緒申��申鐃緒申		  case XK_Hyper_R:
+
鐃緒申��申鐃緒申		    dpyinfo->hyper_mod_mask |= (1 << row);
+
鐃緒申��申鐃緒申		    break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  case XK_Super_L:
+
鐃緒申��申鐃緒申		  case XK_Super_R:
+
鐃緒申��申鐃緒申		    dpyinfo->super_mod_mask |= (1 << row);
+
鐃緒申��申鐃緒申		    break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  case XK_Shift_Lock:
+
鐃緒申��申鐃緒申		    /* Ignore this if it's not on the lock modifier.  */
+
鐃緒申��申鐃緒申		    if ((1 << row) == LockMask)
+
鐃緒申��申鐃緒申		      dpyinfo->shift_lock_mask = LockMask;
+
鐃緒申��申鐃緒申		    break;
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If we couldn't find any meta keys, accept any alt keys as meta keys.  */
+
鐃緒申��申鐃緒申  if (! dpyinfo->meta_mod_mask)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      dpyinfo->meta_mod_mask = dpyinfo->alt_mod_mask;
+
鐃緒申��申鐃緒申      dpyinfo->alt_mod_mask = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If some keys are both alt and meta,
+
鐃緒申��申鐃緒申     make them just meta, not alt.  */
+
鐃緒申��申鐃緒申  if (dpyinfo->alt_mod_mask & dpyinfo->meta_mod_mask)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      dpyinfo->alt_mod_mask &= ~dpyinfo->meta_mod_mask;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XFree ((char *) syms);
+
鐃緒申��申鐃緒申  XFreeModifiermap (mods);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Convert between the modifier bits X uses and the modifier bits
+
鐃緒申��申鐃緒申   Emacs uses.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static unsigned int
+
鐃緒申��申鐃緒申x_x_to_emacs_modifiers (dpyinfo, state)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申     unsigned int state;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return (  ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
+
鐃緒申��申鐃緒申	  | ((state & ControlMask)	       ? ctrl_modifier  : 0)
+
鐃緒申��申鐃緒申	  | ((state & dpyinfo->meta_mod_mask)  ? meta_modifier  : 0)
+
鐃緒申��申鐃緒申	  | ((state & dpyinfo->alt_mod_mask)   ? alt_modifier  : 0)
+
鐃緒申��申鐃緒申	  | ((state & dpyinfo->super_mod_mask) ? super_modifier  : 0)
+
鐃緒申��申鐃緒申	  | ((state & dpyinfo->hyper_mod_mask) ? hyper_modifier  : 0));
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static unsigned int
+
鐃緒申��申鐃緒申x_emacs_to_x_modifiers (dpyinfo, state)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申     unsigned int state;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return (  ((state & alt_modifier)	? dpyinfo->alt_mod_mask   : 0)
+
鐃緒申��申鐃緒申	  | ((state & super_modifier)	? dpyinfo->super_mod_mask : 0)
+
鐃緒申��申鐃緒申	  | ((state & hyper_modifier)	? dpyinfo->hyper_mod_mask : 0)
+
鐃緒申��申鐃緒申	  | ((state & shift_modifier)	? ShiftMask        : 0)
+
鐃緒申��申鐃緒申	  | ((state & ctrl_modifier)	? ControlMask      : 0)
+
鐃緒申��申鐃緒申	  | ((state & meta_modifier)	? dpyinfo->meta_mod_mask  : 0));
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Convert a keysym to its name.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申char *
+
鐃緒申��申鐃緒申x_get_keysym_name (keysym)
+
鐃緒申��申鐃緒申     KeySym keysym;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  char *value;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  value = XKeysymToString (keysym);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return value;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Mouse clicks and mouse movement.  Rah.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
+
鐃緒申��申鐃緒申   co-ordinates in (*X, *Y).  Set *BOUNDS to the rectangle that the
+
鐃緒申��申鐃緒申   glyph at X, Y occupies, if BOUNDS != 0.  If NOCLIP is non-zero, do
+
鐃緒申��申鐃緒申   not force the value into range.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
+
鐃緒申��申鐃緒申     FRAME_PTR f;
+
鐃緒申��申鐃緒申     register int pix_x, pix_y;
+
鐃緒申��申鐃緒申     register int *x, *y;
+
鐃緒申��申鐃緒申     XRectangle *bounds;
+
鐃緒申��申鐃緒申     int noclip;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Arrange for the division in PIXEL_TO_CHAR_COL etc.  to round down
+
鐃緒申��申鐃緒申     even for negative values.  */
+
鐃緒申��申鐃緒申  if (pix_x < 0)
+
鐃緒申��申鐃緒申    pix_x -= FONT_WIDTH ((f)->output_data.x->font) - 1;
+
鐃緒申��申鐃緒申  if (pix_y < 0)
+
鐃緒申��申鐃緒申    pix_y -= (f)->output_data.x->line_height - 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  pix_x = PIXEL_TO_CHAR_COL (f, pix_x);
+
鐃緒申��申鐃緒申  pix_y = PIXEL_TO_CHAR_ROW (f, pix_y);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (bounds)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      bounds->width  = FONT_WIDTH  (f->output_data.x->font);
+
鐃緒申��申鐃緒申      bounds->height = f->output_data.x->line_height;
+
鐃緒申��申鐃緒申      bounds->x = CHAR_TO_PIXEL_COL (f, pix_x);
+
鐃緒申��申鐃緒申      bounds->y = CHAR_TO_PIXEL_ROW (f, pix_y);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!noclip)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (pix_x < 0)
+
鐃緒申��申鐃緒申	pix_x = 0;
+
鐃緒申��申鐃緒申      else if (pix_x > FRAME_WINDOW_WIDTH (f))
+
鐃緒申��申鐃緒申	pix_x = FRAME_WINDOW_WIDTH (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (pix_y < 0)
+
鐃緒申��申鐃緒申	pix_y = 0;
+
鐃緒申��申鐃緒申      else if (pix_y > f->height)
+
鐃緒申��申鐃緒申	pix_y = f->height;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  *x = pix_x;
+
鐃緒申��申鐃緒申  *y = pix_y;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Given HPOS/VPOS in the current matrix of W, return corresponding
+
鐃緒申��申鐃緒申   frame-relative pixel positions in *FRAME_X and *FRAME_Y.  If we
+
鐃緒申��申鐃緒申   can't tell the positions because W's display is not up to date,
+
鐃緒申��申鐃緒申   return 0.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申glyph_to_pixel_coords (w, hpos, vpos, frame_x, frame_y)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int hpos, vpos;
+
鐃緒申��申鐃緒申     int *frame_x, *frame_y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int success_p;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (hpos >= 0 && hpos < w->current_matrix->matrix_w);
+
鐃緒申��申鐃緒申  xassert (vpos >= 0 && vpos < w->current_matrix->matrix_h);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (display_completed)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
+
鐃緒申��申鐃緒申      struct glyph *glyph = row->glyphs[TEXT_AREA];
+
鐃緒申��申鐃緒申      struct glyph *end = glyph + min (hpos, row->used[TEXT_AREA]);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      *frame_y = row->y;
+
鐃緒申��申鐃緒申      *frame_x = row->x;
+
鐃緒申��申鐃緒申      while (glyph < end)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  *frame_x += glyph->pixel_width;
+
鐃緒申��申鐃緒申	  ++glyph;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      success_p = 1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      *frame_y = *frame_x = 0;
+
鐃緒申��申鐃緒申      success_p = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  *frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, *frame_y);
+
鐃緒申��申鐃緒申  *frame_x = WINDOW_TO_FRAME_PIXEL_X (w, *frame_x);
+
鐃緒申��申鐃緒申  return success_p;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Prepare a mouse-event in *RESULT for placement in the input queue.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If the event is a button press, then note that we have grabbed
+
鐃緒申��申鐃緒申   the mouse.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object
+
鐃緒申��申鐃緒申construct_mouse_click (result, event, f)
+
鐃緒申��申鐃緒申     struct input_event *result;
+
鐃緒申��申鐃緒申     XButtonEvent *event;
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Make the event type no_event; we'll change that when we decide
+
鐃緒申��申鐃緒申     otherwise.  */
+
鐃緒申��申鐃緒申  result->kind = mouse_click;
+
鐃緒申��申鐃緒申  result->code = event->button - Button1;
+
鐃緒申��申鐃緒申  result->timestamp = event->time;
+
鐃緒申��申鐃緒申  result->modifiers = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
+
鐃緒申��申鐃緒申					       event->state)
+
鐃緒申��申鐃緒申		       | (event->type == ButtonRelease
+
鐃緒申��申鐃緒申			  ? up_modifier
+
鐃緒申��申鐃緒申			  : down_modifier));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSETINT (result->x, event->x);
+
鐃緒申��申鐃緒申  XSETINT (result->y, event->y);
+
鐃緒申��申鐃緒申  XSETFRAME (result->frame_or_window, f);
+
鐃緒申��申鐃緒申  result->arg = Qnil;
+
鐃緒申��申鐃緒申  return Qnil;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Function to report a mouse movement to the mainstream Emacs code.
+
鐃緒申��申鐃緒申   The input handler calls this.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   We have received a mouse movement event, which is given in *event.
+
鐃緒申��申鐃緒申   If the mouse is over a different glyph than it was last time, tell
+
鐃緒申��申鐃緒申   the mainstream emacs code by setting mouse_moved.  If not, ask for
+
鐃緒申��申鐃緒申   another motion event, so we can check again the next time it moves.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static XMotionEvent last_mouse_motion_event;
+
鐃緒申��申鐃緒申static Lisp_Object last_mouse_motion_frame;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申note_mouse_movement (frame, event)
+
鐃緒申��申鐃緒申     FRAME_PTR frame;
+
鐃緒申��申鐃緒申     XMotionEvent *event;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  last_mouse_movement_time = event->time;
+
鐃緒申��申鐃緒申  last_mouse_motion_event = *event;
+
鐃緒申��申鐃緒申  XSETFRAME (last_mouse_motion_frame, frame);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (event->window != FRAME_X_WINDOW (frame))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      frame->mouse_moved = 1;
+
鐃緒申��申鐃緒申      last_mouse_scroll_bar = Qnil;
+
鐃緒申��申鐃緒申      note_mouse_highlight (frame, -1, -1);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Has the mouse moved off the glyph it was on at the last sighting?  */
+
鐃緒申��申鐃緒申  else if (event->x < last_mouse_glyph.x
+
鐃緒申��申鐃緒申	   || event->x >= last_mouse_glyph.x + last_mouse_glyph.width
+
鐃緒申��申鐃緒申	   || event->y < last_mouse_glyph.y
+
鐃緒申��申鐃緒申	   || event->y >= last_mouse_glyph.y + last_mouse_glyph.height)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      frame->mouse_moved = 1;
+
鐃緒申��申鐃緒申      last_mouse_scroll_bar = Qnil;
+
鐃緒申��申鐃緒申      note_mouse_highlight (frame, event->x, event->y);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is used for debugging, to turn off note_mouse_highlight.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申 int disable_mouse_highlight;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/************************************************************************
+
鐃緒申��申鐃緒申			      Mouse Face
+
鐃緒申��申鐃緒申 ************************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Find the glyph under window-relative coordinates X/Y in window W.
+
鐃緒申��申鐃緒申   Consider only glyphs from buffer text, i.e. no glyphs from overlay
+
鐃緒申��申鐃緒申   strings.  Return in *HPOS and *VPOS the row and column number of
+
鐃緒申��申鐃緒申   the glyph found.  Return in *AREA the glyph area containing X.
+
鐃緒申��申鐃緒申   Value is a pointer to the glyph found or null if X/Y is not on
+
鐃緒申��申鐃緒申   text, or we can't tell because W's current matrix is not up to
+
鐃緒申��申鐃緒申   date.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct glyph *
+
鐃緒申��申鐃緒申x_y_to_hpos_vpos (w, x, y, hpos, vpos, area, buffer_only_p)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int x, y;
+
鐃緒申��申鐃緒申     int *hpos, *vpos, *area;
+
鐃緒申��申鐃緒申     int buffer_only_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct glyph *glyph, *end;
+
鐃緒申��申鐃緒申  struct glyph_row *row = NULL;
+
鐃緒申��申鐃緒申  int x0, i, left_area_width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Find row containing Y.  Give up if some row is not enabled.  */
+
鐃緒申��申鐃緒申  for (i = 0; i < w->current_matrix->nrows; ++i)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      row = MATRIX_ROW (w->current_matrix, i);
+
鐃緒申��申鐃緒申      if (!row->enabled_p)
+
鐃緒申��申鐃緒申	return NULL;
+
鐃緒申��申鐃緒申      if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  *vpos = i;
+
鐃緒申��申鐃緒申  *hpos = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Give up if Y is not in the window.  */
+
鐃緒申��申鐃緒申  if (i == w->current_matrix->nrows)
+
鐃緒申��申鐃緒申    return NULL;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the glyph area containing X.  */
+
鐃緒申��申鐃緒申  if (w->pseudo_window_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      *area = TEXT_AREA;
+
鐃緒申��申鐃緒申      x0 = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      left_area_width = window_box_width (w, LEFT_MARGIN_AREA);
+
鐃緒申��申鐃緒申      if (x < left_area_width)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  *area = LEFT_MARGIN_AREA;
+
鐃緒申��申鐃緒申	  x0 = 0;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else if (x < left_area_width + window_box_width (w, TEXT_AREA))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  *area = TEXT_AREA;
+
鐃緒申��申鐃緒申	  x0 = row->x + left_area_width;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  *area = RIGHT_MARGIN_AREA;
+
鐃緒申��申鐃緒申	  x0 = left_area_width + window_box_width (w, TEXT_AREA);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Find glyph containing X.  */
+
鐃緒申��申鐃緒申  glyph = row->glyphs[*area];
+
鐃緒申��申鐃緒申  end = glyph + row->used[*area];
+
鐃緒申��申鐃緒申  while (glyph < end)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (x < x0 + glyph->pixel_width)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (w->pseudo_window_p)
+
鐃緒申��申鐃緒申	    break;
+
鐃緒申��申鐃緒申	  else if (!buffer_only_p || BUFFERP (glyph->object))
+
鐃緒申��申鐃緒申	    break;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      x0 += glyph->pixel_width;
+
鐃緒申��申鐃緒申      ++glyph;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (glyph == end)
+
鐃緒申��申鐃緒申    return NULL;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  *hpos = glyph - row->glyphs[*area];
+
鐃緒申��申鐃緒申  return glyph;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Convert frame-relative x/y to coordinates relative to window W.
+
鐃緒申��申鐃緒申   Takes pseudo-windows into account.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申frame_to_window_pixel_xy (w, x, y)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int *x, *y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (w->pseudo_window_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* A pseudo-window is always full-width, and starts at the
+
鐃緒申��申鐃緒申	 left edge of the frame, plus a frame border.  */
+
鐃緒申��申鐃緒申      struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申      *x -= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f);
+
鐃緒申��申鐃緒申      *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      *x = FRAME_TO_WINDOW_PIXEL_X (w, *x);
+
鐃緒申��申鐃緒申      *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Take proper action when mouse has moved to the mode or header line of
+
鐃緒申��申鐃緒申   window W, x-position X.  MODE_LINE_P non-zero means mouse is on the
+
鐃緒申��申鐃緒申   mode line.  X is relative to the start of the text display area of
+
鐃緒申��申鐃緒申   W, so the width of bitmap areas and scroll bars must be subtracted
+
鐃緒申��申鐃緒申   to get a position relative to the start of the mode line.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申note_mode_line_highlight (w, x, mode_line_p)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int x, mode_line_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  Cursor cursor = dpyinfo->vertical_scroll_bar_cursor;
+
鐃緒申��申鐃緒申  struct glyph_row *row;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (mode_line_p)
+
鐃緒申��申鐃緒申    row = MATRIX_MODE_LINE_ROW (w->current_matrix);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (row->enabled_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct glyph *glyph, *end;
+
鐃緒申��申鐃緒申      Lisp_Object help, map;
+
鐃緒申��申鐃緒申      int x0;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Find the glyph under X.  */
+
鐃緒申��申鐃緒申      glyph = row->glyphs[TEXT_AREA];
+
鐃緒申��申鐃緒申      end = glyph + row->used[TEXT_AREA];
+
鐃緒申��申鐃緒申      x0 = - (FRAME_LEFT_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f)
+
鐃緒申��申鐃緒申	      + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f));
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      while (glyph < end
+
鐃緒申��申鐃緒申	     && x >= x0 + glyph->pixel_width)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x0 += glyph->pixel_width;
+
鐃緒申��申鐃緒申	  ++glyph;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (glyph < end
+
鐃緒申��申鐃緒申	  && STRINGP (glyph->object)
+
鐃緒申��申鐃緒申	  && XSTRING (glyph->object)->intervals
+
鐃緒申��申鐃緒申	  && glyph->charpos >= 0
+
鐃緒申��申鐃緒申	  && glyph->charpos < XSTRING (glyph->object)->size)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* If we're on a string with `help-echo' text property,
+
鐃緒申��申鐃緒申	     arrange for the help to be displayed.  This is done by
+
鐃緒申��申鐃緒申	     setting the global variable help_echo to the help string.  */
+
鐃緒申��申鐃緒申	  help = Fget_text_property (make_number (glyph->charpos),
+
鐃緒申��申鐃緒申				     Qhelp_echo, glyph->object);
+
鐃緒申��申鐃緒申	  if (!NILP (help))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      help_echo = help;
+
鐃緒申��申鐃緒申	      XSETWINDOW (help_echo_window, w);
+
鐃緒申��申鐃緒申	      help_echo_object = glyph->object;
+
鐃緒申��申鐃緒申	      help_echo_pos = glyph->charpos;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Change the mouse pointer according to what is under X/Y.  */
+
鐃緒申��申鐃緒申	  map = Fget_text_property (make_number (glyph->charpos),
+
鐃緒申��申鐃緒申				    Qlocal_map, glyph->object);
+
鐃緒申��申鐃緒申	  if (KEYMAPP (map))
+
鐃緒申��申鐃緒申	    cursor = f->output_data.x->nontext_cursor;
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      map = Fget_text_property (make_number (glyph->charpos),
+
鐃緒申��申鐃緒申					Qkeymap, glyph->object);
+
鐃緒申��申鐃緒申	      if (KEYMAPP (map))
+
鐃緒申��申鐃緒申		cursor = f->output_data.x->nontext_cursor;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Take proper action when the mouse has moved to position X, Y on
+
鐃緒申��申鐃緒申   frame F as regards highlighting characters that have mouse-face
+
鐃緒申��申鐃緒申   properties.  Also de-highlighting chars where the mouse was before.
+
鐃緒申��申鐃緒申   X and Y can be negative or out of range.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申note_mouse_highlight (f, x, y)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int x, y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  int portion;
+
鐃緒申��申鐃緒申  Lisp_Object window;
+
鐃緒申��申鐃緒申  struct window *w;
+
鐃緒申��申鐃緒申  Cursor cursor = None;
+
鐃緒申��申鐃緒申  struct buffer *b;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* When a menu is active, don't highlight because this looks odd.  */
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  if (popup_activated ())
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (disable_mouse_highlight
+
鐃緒申��申鐃緒申      || !f->glyphs_initialized_p)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_mouse_x = x;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_mouse_y = y;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_mouse_frame = f;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (dpyinfo->mouse_face_defer)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (gc_in_progress)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_deferred_gc = 1;
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Which window is that in?  */
+
鐃緒申��申鐃緒申  window = window_from_coordinates (f, x, y, &portion, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If we were displaying active text in another window, clear that.  */
+
鐃緒申��申鐃緒申  if (! EQ (window, dpyinfo->mouse_face_window))
+
鐃緒申��申鐃緒申    clear_mouse_face (dpyinfo);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Not on a window -> return.  */
+
鐃緒申��申鐃緒申  if (!WINDOWP (window))
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Convert to window-relative pixel coordinates.  */
+
鐃緒申��申鐃緒申  w = XWINDOW (window);
+
鐃緒申��申鐃緒申  frame_to_window_pixel_xy (w, &x, &y);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Handle tool-bar window differently since it doesn't display a
+
鐃緒申��申鐃緒申     buffer.  */
+
鐃緒申��申鐃緒申  if (EQ (window, f->tool_bar_window))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      note_tool_bar_highlight (f, x, y);
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Mouse is on the mode or header line?  */
+
鐃緒申��申鐃緒申  if (portion == 1 || portion == 3)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      note_mode_line_highlight (w, x, portion == 1);
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (portion == 2)
+
鐃緒申��申鐃緒申    cursor = f->output_data.x->horizontal_drag_cursor;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    cursor = f->output_data.x->text_cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Are we in a window whose display is up to date?
+
鐃緒申��申鐃緒申     And verify the buffer's text has not changed.  */
+
鐃緒申��申鐃緒申  b = XBUFFER (w->buffer);
+
鐃緒申��申鐃緒申  if (/* Within text portion of the window.  */
+
鐃緒申��申鐃緒申      portion == 0
+
鐃緒申��申鐃緒申      && EQ (w->window_end_valid, w->buffer)
+
鐃緒申��申鐃緒申      && XFASTINT (w->last_modified) == BUF_MODIFF (b)
+
鐃緒申��申鐃緒申      && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int hpos, vpos, pos, i, area;
+
鐃緒申��申鐃緒申      struct glyph *glyph;
+
鐃緒申��申鐃緒申      Lisp_Object object;
+
鐃緒申��申鐃緒申      Lisp_Object mouse_face = Qnil, overlay = Qnil, position;
+
鐃緒申��申鐃緒申      Lisp_Object *overlay_vec = NULL;
+
鐃緒申��申鐃緒申      int len, noverlays;
+
鐃緒申��申鐃緒申      struct buffer *obuf;
+
鐃緒申��申鐃緒申      int obegv, ozv, same_region;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Find the glyph under X/Y.  */
+
鐃緒申��申鐃緒申      glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &area, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Clear mouse face if X/Y not over text.  */
+
鐃緒申��申鐃緒申      if (glyph == NULL
+
鐃緒申��申鐃緒申	  || area != TEXT_AREA
+
鐃緒申��申鐃緒申	  || !MATRIX_ROW (w->current_matrix, vpos)->displays_text_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (clear_mouse_face (dpyinfo))
+
鐃緒申��申鐃緒申	    cursor = None;
+
鐃緒申��申鐃緒申	  goto set_cursor;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      pos = glyph->charpos;
+
鐃緒申��申鐃緒申      object = glyph->object;
+
鐃緒申��申鐃緒申      if (!STRINGP (object) && !BUFFERP (object))
+
鐃緒申��申鐃緒申	goto set_cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* If we get an out-of-range value, return now; avoid an error.  */
+
鐃緒申��申鐃緒申      if (BUFFERP (object) && pos > BUF_Z (b))
+
鐃緒申��申鐃緒申	goto set_cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Make the window's buffer temporarily current for
+
鐃緒申��申鐃緒申	 overlays_at and compute_char_face.  */
+
鐃緒申��申鐃緒申      obuf = current_buffer;
+
鐃緒申��申鐃緒申      current_buffer = b;
+
鐃緒申��申鐃緒申      obegv = BEGV;
+
鐃緒申��申鐃緒申      ozv = ZV;
+
鐃緒申��申鐃緒申      BEGV = BEG;
+
鐃緒申��申鐃緒申      ZV = Z;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Is this char mouse-active or does it have help-echo?  */
+
鐃緒申��申鐃緒申      position = make_number (pos);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (BUFFERP (object))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* Put all the overlays we want in a vector in overlay_vec.
+
鐃緒申��申鐃緒申	     Store the length in len.  If there are more than 10, make
+
鐃緒申��申鐃緒申	     enough space for all, and try again.  */
+
鐃緒申��申鐃緒申	  len = 10;
+
鐃緒申��申鐃緒申	  overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
+
鐃緒申��申鐃緒申	  noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL, 0);
+
鐃緒申��申鐃緒申	  if (noverlays > len)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      len = noverlays;
+
鐃緒申��申鐃緒申	      overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
+
鐃緒申��申鐃緒申	      noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL,0);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Sort overlays into increasing priority order.  */
+
鐃緒申��申鐃緒申	  noverlays = sort_overlays (overlay_vec, noverlays, w);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	noverlays = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      same_region = (EQ (window, dpyinfo->mouse_face_window)
+
鐃緒申��申鐃緒申		     && vpos >= dpyinfo->mouse_face_beg_row
+
鐃緒申��申鐃緒申		     && vpos <= dpyinfo->mouse_face_end_row
+
鐃緒申��申鐃緒申		     && (vpos > dpyinfo->mouse_face_beg_row
+
鐃緒申��申鐃緒申			 || hpos >= dpyinfo->mouse_face_beg_col)
+
鐃緒申��申鐃緒申		     && (vpos < dpyinfo->mouse_face_end_row
+
鐃緒申��申鐃緒申			 || hpos < dpyinfo->mouse_face_end_col
+
鐃緒申��申鐃緒申			 || dpyinfo->mouse_face_past_end));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (same_region)
+
鐃緒申��申鐃緒申	cursor = None;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Check mouse-face highlighting.  */
+
鐃緒申��申鐃緒申      if (! same_region
+
鐃緒申��申鐃緒申	  /* If there exists an overlay with mouse-face overlapping
+
鐃緒申��申鐃緒申	     the one we are currently highlighting, we have to
+
鐃緒申��申鐃緒申	     check if we enter the overlapping overlay, and then
+
鐃緒申��申鐃緒申	     highlight only that.  */
+
鐃緒申��申鐃緒申	  || (OVERLAYP (dpyinfo->mouse_face_overlay)
+
鐃緒申��申鐃緒申	      && mouse_face_overlay_overlaps (dpyinfo->mouse_face_overlay)))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* Clear the display of the old active region, if any.  */
+
鐃緒申��申鐃緒申	  if (clear_mouse_face (dpyinfo))
+
鐃緒申��申鐃緒申	    cursor = None;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Find the highest priority overlay that has a mouse-face
+
鐃緒申��申鐃緒申	     property.  */
+
鐃緒申��申鐃緒申	  overlay = Qnil;
+
鐃緒申��申鐃緒申	  for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
+
鐃緒申��申鐃緒申	      if (!NILP (mouse_face))
+
鐃緒申��申鐃緒申		overlay = overlay_vec[i];
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  dpyinfo->mouse_face_overlay = overlay;
+
鐃緒申��申鐃緒申	    
+
鐃緒申��申鐃緒申	  /* If no overlay applies, get a text property.  */
+
鐃緒申��申鐃緒申	  if (NILP (overlay))
+
鐃緒申��申鐃緒申	    mouse_face = Fget_text_property (position, Qmouse_face, object);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Handle the overlay case.  */
+
鐃緒申��申鐃緒申	  if (!NILP (overlay))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      /* Find the range of text around this char that
+
鐃緒申��申鐃緒申		 should be active.  */
+
鐃緒申��申鐃緒申	      Lisp_Object before, after;
+
鐃緒申��申鐃緒申	      int ignore;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      before = Foverlay_start (overlay);
+
鐃緒申��申鐃緒申	      after = Foverlay_end (overlay);
+
鐃緒申��申鐃緒申	      /* Record this as the current active region.  */
+
鐃緒申��申鐃緒申	      fast_find_position (w, XFASTINT (before),
+
鐃緒申��申鐃緒申				  &dpyinfo->mouse_face_beg_col,
+
鐃緒申��申鐃緒申				  &dpyinfo->mouse_face_beg_row,
+
鐃緒申��申鐃緒申				  &dpyinfo->mouse_face_beg_x,
+
鐃緒申��申鐃緒申				  &dpyinfo->mouse_face_beg_y);
+
鐃緒申��申鐃緒申	      dpyinfo->mouse_face_past_end
+
鐃緒申��申鐃緒申		= !fast_find_position (w, XFASTINT (after),
+
鐃緒申��申鐃緒申				       &dpyinfo->mouse_face_end_col,
+
鐃緒申��申鐃緒申				       &dpyinfo->mouse_face_end_row,
+
鐃緒申��申鐃緒申				       &dpyinfo->mouse_face_end_x,
+
鐃緒申��申鐃緒申				       &dpyinfo->mouse_face_end_y);
+
鐃緒申��申鐃緒申	      dpyinfo->mouse_face_window = window;
+
鐃緒申��申鐃緒申	      dpyinfo->mouse_face_face_id
+
鐃緒申��申鐃緒申		= face_at_buffer_position (w, pos, 0, 0,
+
鐃緒申��申鐃緒申					   &ignore, pos + 1, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      /* Display it as active.  */
+
鐃緒申��申鐃緒申	      show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
+
鐃緒申��申鐃緒申	      cursor = None;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  /* Handle the text property case.  */
+
鐃緒申��申鐃緒申	  else if (!NILP (mouse_face) && BUFFERP (object))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      /* Find the range of text around this char that
+
鐃緒申��申鐃緒申		 should be active.  */
+
鐃緒申��申鐃緒申	      Lisp_Object before, after, beginning, end;
+
鐃緒申��申鐃緒申	      int ignore;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      beginning = Fmarker_position (w->start);
+
鐃緒申��申鐃緒申	      end = make_number (BUF_Z (XBUFFER (object))
+
鐃緒申��申鐃緒申				 - XFASTINT (w->window_end_pos));
+
鐃緒申��申鐃緒申	      before
+
鐃緒申��申鐃緒申		= Fprevious_single_property_change (make_number (pos + 1),
+
鐃緒申��申鐃緒申						    Qmouse_face,
+
鐃緒申��申鐃緒申						    object, beginning);
+
鐃緒申��申鐃緒申	      after
+
鐃緒申��申鐃緒申		= Fnext_single_property_change (position, Qmouse_face,
+
鐃緒申��申鐃緒申						object, end);
+
鐃緒申��申鐃緒申		
+
鐃緒申��申鐃緒申	      /* Record this as the current active region.  */
+
鐃緒申��申鐃緒申	      fast_find_position (w, XFASTINT (before),
+
鐃緒申��申鐃緒申				  &dpyinfo->mouse_face_beg_col,
+
鐃緒申��申鐃緒申				  &dpyinfo->mouse_face_beg_row,
+
鐃緒申��申鐃緒申				  &dpyinfo->mouse_face_beg_x,
+
鐃緒申��申鐃緒申				  &dpyinfo->mouse_face_beg_y);
+
鐃緒申��申鐃緒申	      dpyinfo->mouse_face_past_end
+
鐃緒申��申鐃緒申		= !fast_find_position (w, XFASTINT (after),
+
鐃緒申��申鐃緒申				       &dpyinfo->mouse_face_end_col,
+
鐃緒申��申鐃緒申				       &dpyinfo->mouse_face_end_row,
+
鐃緒申��申鐃緒申				       &dpyinfo->mouse_face_end_x,
+
鐃緒申��申鐃緒申				       &dpyinfo->mouse_face_end_y);
+
鐃緒申��申鐃緒申	      dpyinfo->mouse_face_window = window;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      if (BUFFERP (object))
+
鐃緒申��申鐃緒申		dpyinfo->mouse_face_face_id
+
鐃緒申��申鐃緒申		  = face_at_buffer_position (w, pos, 0, 0,
+
鐃緒申��申鐃緒申					     &ignore, pos + 1, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      /* Display it as active.  */
+
鐃緒申��申鐃緒申	      show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
+
鐃緒申��申鐃緒申	      cursor = None;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else if (!NILP (mouse_face) && STRINGP (object))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      Lisp_Object b, e;
+
鐃緒申��申鐃緒申	      int ignore;
+
鐃緒申��申鐃緒申		
+
鐃緒申��申鐃緒申	      b = Fprevious_single_property_change (make_number (pos + 1),
+
鐃緒申��申鐃緒申						    Qmouse_face,
+
鐃緒申��申鐃緒申						    object, Qnil);
+
鐃緒申��申鐃緒申	      e = Fnext_single_property_change (position, Qmouse_face,
+
鐃緒申��申鐃緒申						object, Qnil);
+
鐃緒申��申鐃緒申	      if (NILP (b))
+
鐃緒申��申鐃緒申		b = make_number (0);
+
鐃緒申��申鐃緒申	      if (NILP (e))
+
鐃緒申��申鐃緒申		e = make_number (XSTRING (object)->size - 1);
+
鐃緒申��申鐃緒申	      fast_find_string_pos (w, XINT (b), object,
+
鐃緒申��申鐃緒申				    &dpyinfo->mouse_face_beg_col,
+
鐃緒申��申鐃緒申				    &dpyinfo->mouse_face_beg_row,
+
鐃緒申��申鐃緒申				    &dpyinfo->mouse_face_beg_x,
+
鐃緒申��申鐃緒申				    &dpyinfo->mouse_face_beg_y, 0);
+
鐃緒申��申鐃緒申	      fast_find_string_pos (w, XINT (e), object,
+
鐃緒申��申鐃緒申				    &dpyinfo->mouse_face_end_col,
+
鐃緒申��申鐃緒申				    &dpyinfo->mouse_face_end_row,
+
鐃緒申��申鐃緒申				    &dpyinfo->mouse_face_end_x,
+
鐃緒申��申鐃緒申				    &dpyinfo->mouse_face_end_y, 1);
+
鐃緒申��申鐃緒申	      dpyinfo->mouse_face_past_end = 0;
+
鐃緒申��申鐃緒申	      dpyinfo->mouse_face_window = window;
+
鐃緒申��申鐃緒申	      dpyinfo->mouse_face_face_id
+
鐃緒申��申鐃緒申		= face_at_string_position (w, object, pos, 0, 0, 0, &ignore,
+
鐃緒申��申鐃緒申					   glyph->face_id, 1);
+
鐃緒申��申鐃緒申	      show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
+
鐃緒申��申鐃緒申	      cursor = None;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Look for a `help-echo' property.  */
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	Lisp_Object help, overlay;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* Check overlays first.  */
+
鐃緒申��申鐃緒申	help = overlay = Qnil;
+
鐃緒申��申鐃緒申	for (i = noverlays - 1; i >= 0 && NILP (help); --i)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    overlay = overlay_vec[i];
+
鐃緒申��申鐃緒申	    help = Foverlay_get (overlay, Qhelp_echo);
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	if (!NILP (help))
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    help_echo = help;
+
鐃緒申��申鐃緒申	    help_echo_window = window;
+
鐃緒申��申鐃緒申	    help_echo_object = overlay;
+
鐃緒申��申鐃緒申	    help_echo_pos = pos;
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申	else
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    Lisp_Object object = glyph->object;
+
鐃緒申��申鐃緒申	    int charpos = glyph->charpos;
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申	    /* Try text properties.  */
+
鐃緒申��申鐃緒申	    if (STRINGP (object)
+
鐃緒申��申鐃緒申		&& charpos >= 0
+
鐃緒申��申鐃緒申		&& charpos < XSTRING (object)->size)
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		help = Fget_text_property (make_number (charpos),
+
鐃緒申��申鐃緒申					   Qhelp_echo, object);
+
鐃緒申��申鐃緒申		if (NILP (help))
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    /* If the string itself doesn't specify a help-echo,
+
鐃緒申��申鐃緒申		       see if the buffer text ``under'' it does.  */
+
鐃緒申��申鐃緒申		    struct glyph_row *r
+
鐃緒申��申鐃緒申		      = MATRIX_ROW (w->current_matrix, vpos);
+
鐃緒申��申鐃緒申		    int start = MATRIX_ROW_START_CHARPOS (r);
+
鐃緒申��申鐃緒申		    int pos = string_buffer_position (w, object, start);
+
鐃緒申��申鐃緒申		    if (pos > 0)
+
鐃緒申��申鐃緒申		      {
+
鐃緒申��申鐃緒申			help = Fget_text_property (make_number (pos),
+
鐃緒申��申鐃緒申						   Qhelp_echo, w->buffer);
+
鐃緒申��申鐃緒申			if (!NILP (help))
+
鐃緒申��申鐃緒申			  {
+
鐃緒申��申鐃緒申			    charpos = pos;
+
鐃緒申��申鐃緒申			    object = w->buffer;
+
鐃緒申��申鐃緒申			  }
+
鐃緒申��申鐃緒申		      }
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	    else if (BUFFERP (object)
+
鐃緒申��申鐃緒申		     && charpos >= BEGV
+
鐃緒申��申鐃緒申		     && charpos < ZV)
+
鐃緒申��申鐃緒申	      help = Fget_text_property (make_number (charpos), Qhelp_echo,
+
鐃緒申��申鐃緒申					 object);
+
鐃緒申��申鐃緒申	    
+
鐃緒申��申鐃緒申	    if (!NILP (help))
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		help_echo = help;
+
鐃緒申��申鐃緒申		help_echo_window = window;
+
鐃緒申��申鐃緒申		help_echo_object = object;
+
鐃緒申��申鐃緒申		help_echo_pos = charpos;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申      BEGV = obegv;
+
鐃緒申��申鐃緒申      ZV = ozv;
+
鐃緒申��申鐃緒申      current_buffer = obuf;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申 set_cursor:
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (cursor != None)
+
鐃緒申��申鐃緒申    XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申redo_mouse_highlight ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (!NILP (last_mouse_motion_frame)
+
鐃緒申��申鐃緒申      && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
+
鐃緒申��申鐃緒申    note_mouse_highlight (XFRAME (last_mouse_motion_frame),
+
鐃緒申��申鐃緒申			  last_mouse_motion_event.x,
+
鐃緒申��申鐃緒申			  last_mouse_motion_event.y);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			       Tool-bars
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int x_tool_bar_item P_ ((struct frame *, int, int,
+
鐃緒申��申鐃緒申				struct glyph **, int *, int *, int *));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Tool-bar item index of the item on which a mouse button was pressed
+
鐃緒申��申鐃緒申   or -1.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int last_tool_bar_item;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Get information about the tool-bar item at position X/Y on frame F.
+
鐃緒申��申鐃緒申   Return in *GLYPH a pointer to the glyph of the tool-bar item in
+
鐃緒申��申鐃緒申   the current matrix of the tool-bar window of F, or NULL if not
+
鐃緒申��申鐃緒申   on a tool-bar item.  Return in *PROP_IDX the index of the tool-bar
+
鐃緒申��申鐃緒申   item in F->tool_bar_items.  Value is
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   -1	if X/Y is not on a tool-bar item
+
鐃緒申��申鐃緒申   0	if X/Y is on the same item that was highlighted before.
+
鐃緒申��申鐃緒申   1	otherwise.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_tool_bar_item (f, x, y, glyph, hpos, vpos, prop_idx)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int x, y;
+
鐃緒申��申鐃緒申     struct glyph **glyph;
+
鐃緒申��申鐃緒申     int *hpos, *vpos, *prop_idx;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  struct window *w = XWINDOW (f->tool_bar_window);
+
鐃緒申��申鐃緒申  int area;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Find the glyph under X/Y.  */
+
鐃緒申��申鐃緒申  *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, &area, 0);
+
鐃緒申��申鐃緒申  if (*glyph == NULL)
+
鐃緒申��申鐃緒申    return -1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the start of this tool-bar item's properties in
+
鐃緒申��申鐃緒申     f->tool_bar_items.  */
+
鐃緒申��申鐃緒申  if (!tool_bar_item_info (f, *glyph, prop_idx))
+
鐃緒申��申鐃緒申    return -1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Is mouse on the highlighted item?  */
+
鐃緒申��申鐃緒申  if (EQ (f->tool_bar_window, dpyinfo->mouse_face_window)
+
鐃緒申��申鐃緒申      && *vpos >= dpyinfo->mouse_face_beg_row
+
鐃緒申��申鐃緒申      && *vpos <= dpyinfo->mouse_face_end_row
+
鐃緒申��申鐃緒申      && (*vpos > dpyinfo->mouse_face_beg_row
+
鐃緒申��申鐃緒申	  || *hpos >= dpyinfo->mouse_face_beg_col)
+
鐃緒申��申鐃緒申      && (*vpos < dpyinfo->mouse_face_end_row
+
鐃緒申��申鐃緒申	  || *hpos < dpyinfo->mouse_face_end_col
+
鐃緒申��申鐃緒申	  || dpyinfo->mouse_face_past_end))
+
鐃緒申��申鐃緒申    return 0;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  return 1;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Handle mouse button event on the tool-bar of frame F, at
+
鐃緒申��申鐃緒申   frame-relative coordinates X/Y.  EVENT_TYPE is either ButtionPress
+
鐃緒申��申鐃緒申   or ButtonRelase.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_handle_tool_bar_click (f, button_event)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     XButtonEvent *button_event;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  struct window *w = XWINDOW (f->tool_bar_window);
+
鐃緒申��申鐃緒申  int hpos, vpos, prop_idx;
+
鐃緒申��申鐃緒申  struct glyph *glyph;
+
鐃緒申��申鐃緒申  Lisp_Object enabled_p;
+
鐃緒申��申鐃緒申  int x = button_event->x;
+
鐃緒申��申鐃緒申  int y = button_event->y;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* If not on the highlighted tool-bar item, return.  */
+
鐃緒申��申鐃緒申  frame_to_window_pixel_xy (w, &x, &y);
+
鐃緒申��申鐃緒申  if (x_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx) != 0)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If item is disabled, do nothing.  */
+
鐃緒申��申鐃緒申  enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
+
鐃緒申��申鐃緒申  if (NILP (enabled_p))
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (button_event->type == ButtonPress)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Show item in pressed state.  */
+
鐃緒申��申鐃緒申      show_mouse_face (dpyinfo, DRAW_IMAGE_SUNKEN);
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_image_state = DRAW_IMAGE_SUNKEN;
+
鐃緒申��申鐃緒申      last_tool_bar_item = prop_idx;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object key, frame;
+
鐃緒申��申鐃緒申      struct input_event event;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Show item in released state.  */
+
鐃緒申��申鐃緒申      show_mouse_face (dpyinfo, DRAW_IMAGE_RAISED);
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_image_state = DRAW_IMAGE_RAISED;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      XSETFRAME (frame, f);
+
鐃緒申��申鐃緒申      event.kind = TOOL_BAR_EVENT;
+
鐃緒申��申鐃緒申      event.frame_or_window = frame;
+
鐃緒申��申鐃緒申      event.arg = frame;
+
鐃緒申��申鐃緒申      kbd_buffer_store_event (&event);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      event.kind = TOOL_BAR_EVENT;
+
鐃緒申��申鐃緒申      event.frame_or_window = frame;
+
鐃緒申��申鐃緒申      event.arg = key;
+
鐃緒申��申鐃緒申      event.modifiers = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
+
鐃緒申��申鐃緒申						button_event->state);
+
鐃緒申��申鐃緒申      kbd_buffer_store_event (&event);
+
鐃緒申��申鐃緒申      last_tool_bar_item = -1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Possibly highlight a tool-bar item on frame F when mouse moves to
+
鐃緒申��申鐃緒申   tool-bar window-relative coordinates X/Y.  Called from
+
鐃緒申��申鐃緒申   note_mouse_highlight.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申note_tool_bar_highlight (f, x, y)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int x, y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object window = f->tool_bar_window;
+
鐃緒申��申鐃緒申  struct window *w = XWINDOW (window);
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  int hpos, vpos;
+
鐃緒申��申鐃緒申  struct glyph *glyph;
+
鐃緒申��申鐃緒申  struct glyph_row *row;
+
鐃緒申��申鐃緒申  int i;
+
鐃緒申��申鐃緒申  Lisp_Object enabled_p;
+
鐃緒申��申鐃緒申  int prop_idx;
+
鐃緒申��申鐃緒申  enum draw_glyphs_face draw;
+
鐃緒申��申鐃緒申  int mouse_down_p, rc;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Function note_mouse_highlight is called with negative x(y
+
鐃緒申��申鐃緒申     values when mouse moves outside of the frame.  */
+
鐃緒申��申鐃緒申  if (x <= 0 || y <= 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      clear_mouse_face (dpyinfo);
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  rc = x_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
+
鐃緒申��申鐃緒申  if (rc < 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Not on tool-bar item.  */
+
鐃緒申��申鐃緒申      clear_mouse_face (dpyinfo);
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else if (rc == 0)
+
鐃緒申��申鐃緒申    goto set_help_echo;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  clear_mouse_face (dpyinfo);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Mouse is down, but on different tool-bar item?  */
+
鐃緒申��申鐃緒申  mouse_down_p = (dpyinfo->grabbed
+
鐃緒申��申鐃緒申		  && f == last_mouse_frame
+
鐃緒申��申鐃緒申		  && FRAME_LIVE_P (f));
+
鐃緒申��申鐃緒申  if (mouse_down_p
+
鐃緒申��申鐃緒申      && last_tool_bar_item != prop_idx)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_image_state = DRAW_NORMAL_TEXT;
+
鐃緒申��申鐃緒申  draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* If tool-bar item is not enabled, don't highlight it.  */
+
鐃緒申��申鐃緒申  enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
+
鐃緒申��申鐃緒申  if (!NILP (enabled_p))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Compute the x-position of the glyph.  In front and past the
+
鐃緒申��申鐃緒申	 image is a space.  We include this is the highlighted area.  */
+
鐃緒申��申鐃緒申      row = MATRIX_ROW (w->current_matrix, vpos);
+
鐃緒申��申鐃緒申      for (i = x = 0; i < hpos; ++i)
+
鐃緒申��申鐃緒申	x += row->glyphs[TEXT_AREA][i].pixel_width;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Record this as the current active region.  */
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_beg_col = hpos;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_beg_row = vpos;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_beg_x = x;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_beg_y = row->y;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_past_end = 0;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_end_col = hpos + 1;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_end_row = vpos;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_end_x = x + glyph->pixel_width;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_end_y = row->y;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_window = window;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Display it as active.  */
+
鐃緒申��申鐃緒申      show_mouse_face (dpyinfo, draw);
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_image_state = draw;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申 set_help_echo:
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Set help_echo to a help string.to display for this tool-bar item.
+
鐃緒申��申鐃緒申     XTread_socket does the rest.  */
+
鐃緒申��申鐃緒申  help_echo_object = help_echo_window = Qnil;
+
鐃緒申��申鐃緒申  help_echo_pos = -1;
+
鐃緒申��申鐃緒申  help_echo = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
+
鐃緒申��申鐃緒申  if (NILP (help_echo))
+
鐃緒申��申鐃緒申    help_echo = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Find the glyph matrix position of buffer position POS in window W.
+
鐃緒申��申鐃緒申   *HPOS, *VPOS, *X, and *Y are set to the positions found.  W's
+
鐃緒申��申鐃緒申   current glyphs must be up to date.  If POS is above window start
+
鐃緒申��申鐃緒申   return (0, 0, 0, 0).  If POS is after end of W, return end of
+
鐃緒申��申鐃緒申   last line in W.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申fast_find_position (w, pos, hpos, vpos, x, y)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int pos;
+
鐃緒申��申鐃緒申     int *hpos, *vpos, *x, *y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i;
+
鐃緒申��申鐃緒申  int lastcol;
+
鐃緒申��申鐃緒申  int maybe_next_line_p = 0;
+
鐃緒申��申鐃緒申  int line_start_position;
+
鐃緒申��申鐃緒申  int yb = window_text_bottom_y (w);
+
鐃緒申��申鐃緒申  struct glyph_row *row, *best_row;
+
鐃緒申��申鐃緒申  int row_vpos, best_row_vpos;
+
鐃緒申��申鐃緒申  int current_x;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  row = best_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
+
鐃緒申��申鐃緒申  row_vpos = best_row_vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  while (row->y < yb)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (row->used[TEXT_AREA])
+
鐃緒申��申鐃緒申	line_start_position = row->glyphs[TEXT_AREA]->charpos;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	line_start_position = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (line_start_position > pos)
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申      /* If the position sought is the end of the buffer,
+
鐃緒申��申鐃緒申	 don't include the blank lines at the bottom of the window.  */
+
鐃緒申��申鐃緒申      else if (line_start_position == pos
+
鐃緒申��申鐃緒申	       && pos == BUF_ZV (XBUFFER (w->buffer)))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  maybe_next_line_p = 1;
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else if (line_start_position > 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  best_row = row;
+
鐃緒申��申鐃緒申	  best_row_vpos = row_vpos;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (row->y + row->height >= yb)
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      ++row;
+
鐃緒申��申鐃緒申      ++row_vpos;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Find the right column within BEST_ROW.  */
+
鐃緒申��申鐃緒申  lastcol = 0;
+
鐃緒申��申鐃緒申  current_x = best_row->x;
+
鐃緒申��申鐃緒申  for (i = 0; i < best_row->used[TEXT_AREA]; i++)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct glyph *glyph = best_row->glyphs[TEXT_AREA] + i;
+
鐃緒申��申鐃緒申      int charpos;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      charpos = glyph->charpos;
+
鐃緒申��申鐃緒申      if (charpos == pos)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  *hpos = i;
+
鐃緒申��申鐃緒申	  *vpos = best_row_vpos;
+
鐃緒申��申鐃緒申	  *x = current_x;
+
鐃緒申��申鐃緒申	  *y = best_row->y;
+
鐃緒申��申鐃緒申	  return 1;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else if (charpos > pos)
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申      else if (charpos > 0)
+
鐃緒申��申鐃緒申	lastcol = i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      current_x += glyph->pixel_width;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If we're looking for the end of the buffer,
+
鐃緒申��申鐃緒申     and we didn't find it in the line we scanned,
+
鐃緒申��申鐃緒申     use the start of the following line.  */
+
鐃緒申��申鐃緒申  if (maybe_next_line_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      ++best_row;
+
鐃緒申��申鐃緒申      ++best_row_vpos;
+
鐃緒申��申鐃緒申      lastcol = 0;
+
鐃緒申��申鐃緒申      current_x = best_row->x;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  *vpos = best_row_vpos;
+
鐃緒申��申鐃緒申  *hpos = lastcol + 1;
+
鐃緒申��申鐃緒申  *x = current_x;
+
鐃緒申��申鐃緒申  *y = best_row->y;
+
鐃緒申��申鐃緒申  return 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Find the position of the the glyph for position POS in OBJECT in
+
鐃緒申��申鐃緒申   window W's current matrix, and return in *X/*Y the pixel
+
鐃緒申��申鐃緒申   coordinates, and return in *HPOS/*VPOS the column/row of the glyph.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   RIGHT_P non-zero means return the position of the right edge of the
+
鐃緒申��申鐃緒申   glyph, RIGHT_P zero means return the left edge position.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If no glyph for POS exists in the matrix, return the position of
+
鐃緒申��申鐃緒申   the glyph with the next smaller position that is in the matrix, if
+
鐃緒申��申鐃緒申   RIGHT_P is zero.  If RIGHT_P is non-zero, and no glyph for POS
+
鐃緒申��申鐃緒申   exists in the matrix, return the position of the glyph with the
+
鐃緒申��申鐃緒申   next larger position in OBJECT.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Value is non-zero if a glyph was found.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申fast_find_string_pos (w, pos, object, hpos, vpos, x, y, right_p)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int pos;
+
鐃緒申��申鐃緒申     Lisp_Object object;
+
鐃緒申��申鐃緒申     int *hpos, *vpos, *x, *y;
+
鐃緒申��申鐃緒申     int right_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int yb = window_text_bottom_y (w);
+
鐃緒申��申鐃緒申  struct glyph_row *r;
+
鐃緒申��申鐃緒申  struct glyph *best_glyph = NULL;
+
鐃緒申��申鐃緒申  struct glyph_row *best_row = NULL;
+
鐃緒申��申鐃緒申  int best_x = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
+
鐃緒申��申鐃緒申       r->enabled_p && r->y < yb;
+
鐃緒申��申鐃緒申       ++r)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct glyph *g = r->glyphs[TEXT_AREA];
+
鐃緒申��申鐃緒申      struct glyph *e = g + r->used[TEXT_AREA];
+
鐃緒申��申鐃緒申      int gx;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      for (gx = r->x; g < e; gx += g->pixel_width, ++g)
+
鐃緒申��申鐃緒申	if (EQ (g->object, object))
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    if (g->charpos == pos)
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		best_glyph = g;
+
鐃緒申��申鐃緒申		best_x = gx;
+
鐃緒申��申鐃緒申		best_row = r;
+
鐃緒申��申鐃緒申		goto found;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	    else if (best_glyph == NULL
+
鐃緒申��申鐃緒申		     || ((abs (g->charpos - pos)
+
鐃緒申��申鐃緒申			 < abs (best_glyph->charpos - pos))
+
鐃緒申��申鐃緒申			 && (right_p
+
鐃緒申��申鐃緒申			     ? g->charpos < pos
+
鐃緒申��申鐃緒申			     : g->charpos > pos)))
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		best_glyph = g;
+
鐃緒申��申鐃緒申		best_x = gx;
+
鐃緒申��申鐃緒申		best_row = r;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申 found:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (best_glyph)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      *x = best_x;
+
鐃緒申��申鐃緒申      *hpos = best_glyph - best_row->glyphs[TEXT_AREA];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (right_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  *x += best_glyph->pixel_width;
+
鐃緒申��申鐃緒申	  ++*hpos;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      *y = best_row->y;
+
鐃緒申��申鐃緒申      *vpos = best_row - w->current_matrix->rows;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return best_glyph != NULL;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Display the active region described by mouse_face_*
+
鐃緒申��申鐃緒申   in its mouse-face if HL > 0, in its normal face if HL = 0.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申show_mouse_face (dpyinfo, draw)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申     enum draw_glyphs_face draw;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct window *w = XWINDOW (dpyinfo->mouse_face_window);
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (WINDOW_FRAME (w));
+
鐃緒申��申鐃緒申  int i;
+
鐃緒申��申鐃緒申  int cursor_off_p = 0;
+
鐃緒申��申鐃緒申  struct cursor_pos saved_cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  saved_cursor = output_cursor;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* If window is in the process of being destroyed, don't bother
+
鐃緒申��申鐃緒申     to do anything.  */
+
鐃緒申��申鐃緒申  if (w->current_matrix == NULL)
+
鐃緒申��申鐃緒申    goto set_x_cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Recognize when we are called to operate on rows that don't exist
+
鐃緒申��申鐃緒申     anymore.  This can happen when a window is split.  */
+
鐃緒申��申鐃緒申  if (dpyinfo->mouse_face_end_row >= w->current_matrix->nrows)
+
鐃緒申��申鐃緒申    goto set_x_cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  set_output_cursor (&w->phys_cursor);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Note that mouse_face_beg_row etc. are window relative.  */
+
鐃緒申��申鐃緒申  for (i = dpyinfo->mouse_face_beg_row;
+
鐃緒申��申鐃緒申       i <= dpyinfo->mouse_face_end_row;
+
鐃緒申��申鐃緒申       i++)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int start_hpos, end_hpos, start_x;
+
鐃緒申��申鐃緒申      struct glyph_row *row = MATRIX_ROW (w->current_matrix, i);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Don't do anything if row doesn't have valid contents.  */
+
鐃緒申��申鐃緒申      if (!row->enabled_p)
+
鐃緒申��申鐃緒申	continue;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* For all but the first row, the highlight starts at column 0.  */
+
鐃緒申��申鐃緒申      if (i == dpyinfo->mouse_face_beg_row)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  start_hpos = dpyinfo->mouse_face_beg_col;
+
鐃緒申��申鐃緒申	  start_x = dpyinfo->mouse_face_beg_x;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  start_hpos = 0;
+
鐃緒申��申鐃緒申	  start_x = 0;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (i == dpyinfo->mouse_face_end_row)
+
鐃緒申��申鐃緒申	end_hpos = dpyinfo->mouse_face_end_col;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	end_hpos = row->used[TEXT_AREA];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* If the cursor's in the text we are about to rewrite, turn the
+
鐃緒申��申鐃緒申	 cursor off.  */
+
鐃緒申��申鐃緒申      if (!w->pseudo_window_p
+
鐃緒申��申鐃緒申	  && i == output_cursor.vpos
+
鐃緒申��申鐃緒申	  && output_cursor.hpos >= start_hpos - 1
+
鐃緒申��申鐃緒申	  && output_cursor.hpos <= end_hpos)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x_update_window_cursor (w, 0);
+
鐃緒申��申鐃緒申	  cursor_off_p = 1;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (end_hpos > start_hpos)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  row->mouse_face_p = draw == DRAW_MOUSE_FACE || DRAW_IMAGE_RAISED;
+
鐃緒申��申鐃緒申	  x_draw_glyphs (w, start_x, row, TEXT_AREA, 
+
鐃緒申��申鐃緒申			 start_hpos, end_hpos, draw, NULL, NULL, 0);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If we turned the cursor off, turn it back on.  */
+
鐃緒申��申鐃緒申  if (cursor_off_p)
+
鐃緒申��申鐃緒申    x_display_cursor (w, 1,
+
鐃緒申��申鐃緒申		      output_cursor.hpos, output_cursor.vpos,
+
鐃緒申��申鐃緒申		      output_cursor.x, output_cursor.y);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  output_cursor = saved_cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申 set_x_cursor:
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Change the mouse cursor.  */
+
鐃緒申��申鐃緒申  if (draw == DRAW_NORMAL_TEXT)
+
鐃緒申��申鐃緒申    XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		   f->output_data.x->text_cursor);
+
鐃緒申��申鐃緒申  else if (draw == DRAW_MOUSE_FACE)
+
鐃緒申��申鐃緒申    XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		   f->output_data.x->cross_cursor);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		   f->output_data.x->nontext_cursor);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Clear out the mouse-highlighted active region.
+
鐃緒申��申鐃緒申   Redraw it un-highlighted first.  Value is non-zero if mouse
+
鐃緒申��申鐃緒申   face was actually drawn unhighlighted.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申clear_mouse_face (dpyinfo)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int cleared = 0;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (!NILP (dpyinfo->mouse_face_window))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      show_mouse_face (dpyinfo, DRAW_NORMAL_TEXT);
+
鐃緒申��申鐃緒申      cleared = 1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_window = Qnil;
+
鐃緒申��申鐃緒申  return cleared;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Clear any mouse-face on window W.  This function is part of the
+
鐃緒申��申鐃緒申   redisplay interface, and is called from try_window_id and similar
+
鐃緒申��申鐃緒申   functions to ensure the mouse-highlight is off.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_clear_mouse_face (w)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
+
鐃緒申��申鐃緒申  Lisp_Object window;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  XSETWINDOW (window, w);
+
鐃緒申��申鐃緒申  if (EQ (window, dpyinfo->mouse_face_window))
+
鐃緒申��申鐃緒申    clear_mouse_face (dpyinfo);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Just discard the mouse face information for frame F, if any.
+
鐃緒申��申鐃緒申   This is used when the size of F is changed.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申cancel_mouse_face (f)
+
鐃緒申��申鐃緒申     FRAME_PTR f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object window;
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  window = dpyinfo->mouse_face_window;
+
鐃緒申��申鐃緒申  if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_window = Qnil;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int glyph_rect P_ ((struct frame *f, int, int, XRectangle *));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Try to determine frame pixel position and size of the glyph under
+
鐃緒申��申鐃緒申   frame pixel coordinates X/Y on frame F .  Return the position and
+
鐃緒申��申鐃緒申   size in *RECT.  Value is non-zero if we could compute these
+
鐃緒申��申鐃緒申   values.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申glyph_rect (f, x, y, rect)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int x, y;
+
鐃緒申��申鐃緒申     XRectangle *rect;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object window;
+
鐃緒申��申鐃緒申  int part, found = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  window = window_from_coordinates (f, x, y, &part, 0);
+
鐃緒申��申鐃緒申  if (!NILP (window))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct window *w = XWINDOW (window);
+
鐃緒申��申鐃緒申      struct glyph_row *r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
+
鐃緒申��申鐃緒申      struct glyph_row *end = r + w->current_matrix->nrows - 1;
+
鐃緒申��申鐃緒申      int area;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      frame_to_window_pixel_xy (w, &x, &y);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      for (; !found && r < end && r->enabled_p; ++r)
+
鐃緒申��申鐃緒申	if (r->y >= y)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    struct glyph *g = r->glyphs[TEXT_AREA];
+
鐃緒申��申鐃緒申	    struct glyph *end = g + r->used[TEXT_AREA];
+
鐃緒申��申鐃緒申	    int gx;
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申	    for (gx = r->x; !found && g < end; gx += g->pixel_width, ++g)
+
鐃緒申��申鐃緒申	      if (gx >= x)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  rect->width = g->pixel_width;
+
鐃緒申��申鐃緒申		  rect->height = r->height;
+
鐃緒申��申鐃緒申		  rect->x = WINDOW_TO_FRAME_PIXEL_X (w, gx);
+
鐃緒申��申鐃緒申		  rect->y = WINDOW_TO_FRAME_PIXEL_Y (w, r->y);
+
鐃緒申��申鐃緒申		  found = 1;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return found;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return the current position of the mouse.
+
鐃緒申��申鐃緒申   *FP should be a frame which indicates which display to ask about.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
+
鐃緒申��申鐃緒申   and *PART to the frame, window, and scroll bar part that the mouse
+
鐃緒申��申鐃緒申   is over.  Set *X and *Y to the portion and whole of the mouse's
+
鐃緒申��申鐃緒申   position on the scroll bar.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If the mouse movement started elsewhere, set *FP to the frame the
+
鐃緒申��申鐃緒申   mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
+
鐃緒申��申鐃緒申   the mouse is over.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Set *TIME to the server time-stamp for the time at which the mouse
+
鐃緒申��申鐃緒申   was at this position.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Don't store anything if we don't have a valid set of values to report.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   This clears the mouse_moved flag, so we can wait for the next mouse
+
鐃緒申��申鐃緒申   movement.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTmouse_position (fp, insist, bar_window, part, x, y, time)
+
鐃緒申��申鐃緒申     FRAME_PTR *fp;
+
鐃緒申��申鐃緒申     int insist;
+
鐃緒申��申鐃緒申     Lisp_Object *bar_window;
+
鐃緒申��申鐃緒申     enum scroll_bar_part *part;
+
鐃緒申��申鐃緒申     Lisp_Object *x, *y;
+
鐃緒申��申鐃緒申     unsigned long *time;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  FRAME_PTR f1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (! NILP (last_mouse_scroll_bar) && insist == 0)
+
鐃緒申��申鐃緒申    x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Window root;
+
鐃緒申��申鐃緒申      int root_x, root_y;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      Window dummy_window;
+
鐃緒申��申鐃緒申      int dummy;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      Lisp_Object frame, tail;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Clear the mouse-moved flag for every frame on this display.  */
+
鐃緒申��申鐃緒申      FOR_EACH_FRAME (tail, frame)
+
鐃緒申��申鐃緒申	if (FRAME_X_DISPLAY (XFRAME (frame)) == FRAME_X_DISPLAY (*fp))
+
鐃緒申��申鐃緒申	  XFRAME (frame)->mouse_moved = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      last_mouse_scroll_bar = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Figure out which root window we're on.  */
+
鐃緒申��申鐃緒申      XQueryPointer (FRAME_X_DISPLAY (*fp),
+
鐃緒申��申鐃緒申		     DefaultRootWindow (FRAME_X_DISPLAY (*fp)),
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		     /* The root window which contains the pointer.  */
+
鐃緒申��申鐃緒申		     &root,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		     /* Trash which we can't trust if the pointer is on
+
鐃緒申��申鐃緒申			a different screen.  */
+
鐃緒申��申鐃緒申		     &dummy_window,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		     /* The position on that root window.  */
+
鐃緒申��申鐃緒申		     &root_x, &root_y,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		     /* More trash we can't trust.  */
+
鐃緒申��申鐃緒申		     &dummy, &dummy,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		     /* Modifier keys and pointer buttons, about which
+
鐃緒申��申鐃緒申			we don't care.  */
+
鐃緒申��申鐃緒申		     (unsigned int *) &dummy);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Now we have a position on the root; find the innermost window
+
鐃緒申��申鐃緒申	 containing the pointer.  */
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	Window win, child;
+
鐃緒申��申鐃緒申	int win_x, win_y;
+
鐃緒申��申鐃緒申	int parent_x = 0, parent_y = 0;
+
鐃緒申��申鐃緒申	int count;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	win = root;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* XTranslateCoordinates can get errors if the window
+
鐃緒申��申鐃緒申	   structure is changing at the same time this function
+
鐃緒申��申鐃緒申	   is running.  So at least we must not crash from them.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	count = x_catch_errors (FRAME_X_DISPLAY (*fp));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	if (FRAME_X_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
+
鐃緒申��申鐃緒申	    && FRAME_LIVE_P (last_mouse_frame))
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    /* If mouse was grabbed on a frame, give coords for that frame
+
鐃緒申��申鐃緒申	       even if the mouse is now outside it.  */
+
鐃緒申��申鐃緒申	    XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申				   /* From-window, to-window.  */
+
鐃緒申��申鐃緒申				   root, FRAME_X_WINDOW (last_mouse_frame),
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申				   /* From-position, to-position.  */
+
鐃緒申��申鐃緒申				   root_x, root_y, &win_x, &win_y,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申				   /* Child of win.  */
+
鐃緒申��申鐃緒申				   &child);
+
鐃緒申��申鐃緒申	    f1 = last_mouse_frame;
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申	else
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    while (1)
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申				       /* From-window, to-window.  */
+
鐃緒申��申鐃緒申				       root, win,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申				       /* From-position, to-position.  */
+
鐃緒申��申鐃緒申				       root_x, root_y, &win_x, &win_y,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申				       /* Child of win.  */
+
鐃緒申��申鐃緒申				       &child);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		if (child == None || child == win)
+
鐃緒申��申鐃緒申		  break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		win = child;
+
鐃緒申��申鐃緒申		parent_x = win_x;
+
鐃緒申��申鐃緒申		parent_y = win_y;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    /* Now we know that:
+
鐃緒申��申鐃緒申	       win is the innermost window containing the pointer
+
鐃緒申��申鐃緒申	       (XTC says it has no child containing the pointer),
+
鐃緒申��申鐃緒申	       win_x and win_y are the pointer's position in it
+
鐃緒申��申鐃緒申	       (XTC did this the last time through), and
+
鐃緒申��申鐃緒申	       parent_x and parent_y are the pointer's position in win's parent.
+
鐃緒申��申鐃緒申	       (They are what win_x and win_y were when win was child.
+
鐃緒申��申鐃緒申	       If win is the root window, it has no parent, and
+
鐃緒申��申鐃緒申	       parent_{x,y} are invalid, but that's okay, because we'll
+
鐃緒申��申鐃緒申	       never use them in that case.)  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    /* Is win one of our frames?  */
+
鐃緒申��申鐃緒申	    f1 = x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp), win);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申	    /* If we end up with the menu bar window, say it's not
+
鐃緒申��申鐃緒申	       on the frame.  */
+
鐃緒申��申鐃緒申	    if (f1 != NULL
+
鐃緒申��申鐃緒申		&& f1->output_data.x->menubar_widget
+
鐃緒申��申鐃緒申		&& win == XtWindow (f1->output_data.x->menubar_widget))
+
鐃緒申��申鐃緒申	      f1 = NULL;
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	if (x_had_errors_p (FRAME_X_DISPLAY (*fp)))
+
鐃緒申��申鐃緒申	  f1 = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	x_uncatch_errors (FRAME_X_DISPLAY (*fp), count);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* If not, is it one of our scroll bars?  */
+
鐃緒申��申鐃緒申	if (! f1)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    struct scroll_bar *bar = x_window_to_scroll_bar (win);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    if (bar)
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+
鐃緒申��申鐃緒申		win_x = parent_x;
+
鐃緒申��申鐃緒申		win_y = parent_y;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	if (f1 == 0 && insist > 0)
+
鐃緒申��申鐃緒申	  f1 = SELECTED_FRAME ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	if (f1)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    /* Ok, we found a frame.  Store all the values.
+
鐃緒申��申鐃緒申	       last_mouse_glyph is a rectangle used to reduce the
+
鐃緒申��申鐃緒申	       generation of mouse events.  To not miss any motion
+
鐃緒申��申鐃緒申	       events, we must divide the frame into rectangles of the
+
鐃緒申��申鐃緒申	       size of the smallest character that could be displayed
+
鐃緒申��申鐃緒申	       on it, i.e. into the same rectangles that matrices on
+
鐃緒申��申鐃緒申	       the frame are divided into.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    int width, height, gx, gy;
+
鐃緒申��申鐃緒申	    XRectangle rect;
+
鐃緒申��申鐃緒申	    
+
鐃緒申��申鐃緒申	    if (glyph_rect (f1, win_x, win_y, &rect))
+
鐃緒申��申鐃緒申	      last_mouse_glyph = rect;
+
鐃緒申��申鐃緒申	    else
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		width = FRAME_SMALLEST_CHAR_WIDTH (f1);
+
鐃緒申��申鐃緒申		height = FRAME_SMALLEST_FONT_HEIGHT (f1);
+
鐃緒申��申鐃緒申		gx = win_x;
+
鐃緒申��申鐃緒申		gy = win_y;
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申		/* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
+
鐃緒申��申鐃緒申		   round down even for negative values.  */
+
鐃緒申��申鐃緒申		if (gx < 0)
+
鐃緒申��申鐃緒申		  gx -= width - 1;
+
鐃緒申��申鐃緒申		if (gy < 0)
+
鐃緒申��申鐃緒申		  gy -= height - 1;
+
鐃緒申��申鐃緒申		gx = (gx + width - 1) / width * width;
+
鐃緒申��申鐃緒申		gy = (gy + height - 1) / height * height;
+
鐃緒申��申鐃緒申	    
+
鐃緒申��申鐃緒申		last_mouse_glyph.width  = width;
+
鐃緒申��申鐃緒申		last_mouse_glyph.height = height;
+
鐃緒申��申鐃緒申		last_mouse_glyph.x = gx;
+
鐃緒申��申鐃緒申		last_mouse_glyph.y = gy;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    *bar_window = Qnil;
+
鐃緒申��申鐃緒申	    *part = 0;
+
鐃緒申��申鐃緒申	    *fp = f1;
+
鐃緒申��申鐃緒申	    XSETINT (*x, win_x);
+
鐃緒申��申鐃緒申	    XSETINT (*y, win_y);
+
鐃緒申��申鐃緒申	    *time = last_mouse_movement_time;
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Atimer callback function for TIMER.  Called every 0.1s to process
+
鐃緒申��申鐃緒申   Xt timeouts, if needed.  We must avoid calling XtAppPending as
+
鐃緒申��申鐃緒申   much as possible because that function does an implicit XFlush
+
鐃緒申��申鐃緒申   that slows us down.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_process_timeouts (timer)
+
鐃緒申��申鐃緒申     struct atimer *timer;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (toolkit_scroll_bar_interaction || popup_activated_flag)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申      while (XtAppPending (Xt_app_con) & XtIMTimer)
+
鐃緒申��申鐃緒申	XtAppProcessEvent (Xt_app_con, XtIMTimer);
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Scroll bar support.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Given an X window ID, find the struct scroll_bar which manages it.
+
鐃緒申��申鐃緒申   This can be called in GC, so we have to make sure to strip off mark
+
鐃緒申��申鐃緒申   bits.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct scroll_bar *
+
鐃緒申��申鐃緒申x_window_to_scroll_bar (window_id)
+
鐃緒申��申鐃緒申     Window window_id;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object tail;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (tail = Vframe_list;
+
鐃緒申��申鐃緒申       XGCTYPE (tail) == Lisp_Cons;
+
鐃緒申��申鐃緒申       tail = XCDR (tail))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object frame, bar, condemned;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      frame = XCAR (tail);
+
鐃緒申��申鐃緒申      /* All elements of Vframe_list should be frames.  */
+
鐃緒申��申鐃緒申      if (! GC_FRAMEP (frame))
+
鐃緒申��申鐃緒申	abort ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Scan this frame's scroll bar list for a scroll bar with the
+
鐃緒申��申鐃緒申         right window ID.  */
+
鐃緒申��申鐃緒申      condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
+
鐃緒申��申鐃緒申      for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
+
鐃緒申��申鐃緒申	   /* This trick allows us to search both the ordinary and
+
鐃緒申��申鐃緒申              condemned scroll bar lists with one loop.  */
+
鐃緒申��申鐃緒申	   ! GC_NILP (bar) || (bar = condemned,
+
鐃緒申��申鐃緒申			       condemned = Qnil,
+
鐃緒申��申鐃緒申			       ! GC_NILP (bar));
+
鐃緒申��申鐃緒申	   bar = XSCROLL_BAR (bar)->next)
+
鐃緒申��申鐃緒申	if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)) == window_id)
+
鐃緒申��申鐃緒申	  return XSCROLL_BAR (bar);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if defined USE_X_TOOLKIT && defined USE_LUCID
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return the Lucid menu bar WINDOW is part of.  Return null
+
鐃緒申��申鐃緒申   if WINDOW is not part of a menu bar.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Widget
+
鐃緒申��申鐃緒申x_window_to_menu_bar (window)
+
鐃緒申��申鐃緒申     Window window;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object tail;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  for (tail = Vframe_list;
+
鐃緒申��申鐃緒申       XGCTYPE (tail) == Lisp_Cons;
+
鐃緒申��申鐃緒申       tail = XCDR (tail))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object frame = XCAR (tail);
+
鐃緒申��申鐃緒申      Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if (menu_bar && xlwmenu_window_p (menu_bar, window))
+
鐃緒申��申鐃緒申	return menu_bar;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return NULL;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT && USE_LUCID */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/************************************************************************
+
鐃緒申��申鐃緒申			 Toolkit scroll bars
+
鐃緒申��申鐃緒申 ************************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void x_scroll_bar_to_input_event P_ ((XEvent *, struct input_event *));
+
鐃緒申��申鐃緒申static void x_send_scroll_bar_event P_ ((Lisp_Object, int, int, int));
+
鐃緒申��申鐃緒申static void x_create_toolkit_scroll_bar P_ ((struct frame *,
+
鐃緒申��申鐃緒申					     struct scroll_bar *));
+
鐃緒申��申鐃緒申static void x_set_toolkit_scroll_bar_thumb P_ ((struct scroll_bar *,
+
鐃緒申��申鐃緒申						int, int, int));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Id of action hook installed for scroll bars.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static XtActionHookId action_hook_id;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Lisp window being scrolled.  Set when starting to interact with
+
鐃緒申��申鐃緒申   a toolkit scroll bar, reset to nil when ending the interaction.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object window_being_scrolled;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Last scroll bar part sent in xm_scroll_callback.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int last_scroll_bar_part;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Whether this is an Xaw with arrow-scrollbars.  This should imply
+
鐃緒申��申鐃緒申   that movements of 1/20 of the screen size are mapped to up/down.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Boolean xaw3d_arrow_scroll;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Whether the drag scrolling maintains the mouse at the top of the
+
鐃緒申��申鐃緒申   thumb.  If not, resizing the thumb needs to be done more carefully
+
鐃緒申��申鐃緒申   to avoid jerkyness.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Boolean xaw3d_pick_top;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Action hook installed via XtAppAddActionHook when toolkit scroll
+
鐃緒申��申鐃緒申   bars are used..  The hook is responsible for detecting when
+
鐃緒申��申鐃緒申   the user ends an interaction with the scroll bar, and generates
+
鐃緒申��申鐃緒申   a `end-scroll' scroll_bar_click' event if so.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申xt_action_hook (widget, client_data, action_name, event, params,
+
鐃緒申��申鐃緒申		num_params)
+
鐃緒申��申鐃緒申     Widget widget;
+
鐃緒申��申鐃緒申     XtPointer client_data;
+
鐃緒申��申鐃緒申     String action_name;
+
鐃緒申��申鐃緒申     XEvent *event;
+
鐃緒申��申鐃緒申     String *params;
+
鐃緒申��申鐃緒申     Cardinal *num_params;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int scroll_bar_p;
+
鐃緒申��申鐃緒申  char *end_action;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#ifdef USE_MOTIF
+
鐃緒申��申鐃緒申  scroll_bar_p = XmIsScrollBar (widget);
+
鐃緒申��申鐃緒申  end_action = "Release";
+
鐃緒申��申鐃緒申#else /* !USE_MOTIF i.e. use Xaw */
+
鐃緒申��申鐃緒申  scroll_bar_p = XtIsSubclass (widget, scrollbarWidgetClass);
+
鐃緒申��申鐃緒申  end_action = "EndScroll";
+
鐃緒申��申鐃緒申#endif /* USE_MOTIF */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (scroll_bar_p
+
鐃緒申��申鐃緒申      && strcmp (action_name, end_action) == 0
+
鐃緒申��申鐃緒申      && WINDOWP (window_being_scrolled))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct window *w;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      x_send_scroll_bar_event (window_being_scrolled,
+
鐃緒申��申鐃緒申			       scroll_bar_end_scroll, 0, 0);
+
鐃緒申��申鐃緒申      w = XWINDOW (window_being_scrolled);
+
鐃緒申��申鐃緒申      XSCROLL_BAR (w->vertical_scroll_bar)->dragging = Qnil;
+
鐃緒申��申鐃緒申      window_being_scrolled = Qnil;
+
鐃緒申��申鐃緒申      last_scroll_bar_part = -1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Xt timeouts no longer needed.  */
+
鐃緒申��申鐃緒申      toolkit_scroll_bar_interaction = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* A vector of windows used for communication between
+
鐃緒申��申鐃緒申   x_send_scroll_bar_event and x_scroll_bar_to_input_event.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct window **scroll_bar_windows;
+
鐃緒申��申鐃緒申static int scroll_bar_windows_size;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Send a client message with message type Xatom_Scrollbar for a
+
鐃緒申��申鐃緒申   scroll action to the frame of WINDOW.  PART is a value identifying
+
鐃緒申��申鐃緒申   the part of the scroll bar that was clicked on.  PORTION is the
+
鐃緒申��申鐃緒申   amount to scroll of a whole of WHOLE.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_send_scroll_bar_event (window, part, portion, whole)
+
鐃緒申��申鐃緒申     Lisp_Object window;
+
鐃緒申��申鐃緒申     int part, portion, whole;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XEvent event;
+
鐃緒申��申鐃緒申  XClientMessageEvent *ev = (XClientMessageEvent *) &event;
+
鐃緒申��申鐃緒申  struct window *w = XWINDOW (window);
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  int i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Construct a ClientMessage event to send to the frame.  */
+
鐃緒申��申鐃緒申  ev->type = ClientMessage;
+
鐃緒申��申鐃緒申  ev->message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_Scrollbar;
+
鐃緒申��申鐃緒申  ev->display = FRAME_X_DISPLAY (f);
+
鐃緒申��申鐃緒申  ev->window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申  ev->format = 32;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We can only transfer 32 bits in the XClientMessageEvent, which is
+
鐃緒申��申鐃緒申     not enough to store a pointer or Lisp_Object on a 64 bit system.
+
鐃緒申��申鐃緒申     So, store the window in scroll_bar_windows and pass the index
+
鐃緒申��申鐃緒申     into that array in the event.  */
+
鐃緒申��申鐃緒申  for (i = 0; i < scroll_bar_windows_size; ++i)
+
鐃緒申��申鐃緒申    if (scroll_bar_windows[i] == NULL)
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (i == scroll_bar_windows_size)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int new_size = max (10, 2 * scroll_bar_windows_size);
+
鐃緒申��申鐃緒申      size_t nbytes = new_size * sizeof *scroll_bar_windows;
+
鐃緒申��申鐃緒申      size_t old_nbytes = scroll_bar_windows_size * sizeof *scroll_bar_windows;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      scroll_bar_windows = (struct window **) xrealloc (scroll_bar_windows,
+
鐃緒申��申鐃緒申							nbytes);
+
鐃緒申��申鐃緒申      bzero (&scroll_bar_windows[i], nbytes - old_nbytes);
+
鐃緒申��申鐃緒申      scroll_bar_windows_size = new_size;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  scroll_bar_windows[i] = w;
+
鐃緒申��申鐃緒申  ev->data.l[0] = (long) i;
+
鐃緒申��申鐃緒申  ev->data.l[1] = (long) part;
+
鐃緒申��申鐃緒申  ev->data.l[2] = (long) 0;
+
鐃緒申��申鐃緒申  ev->data.l[3] = (long) portion;
+
鐃緒申��申鐃緒申  ev->data.l[4] = (long) whole;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Make Xt timeouts work while the scroll bar is active.  */
+
鐃緒申��申鐃緒申  toolkit_scroll_bar_interaction = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Setting the event mask to zero means that the message will
+
鐃緒申��申鐃緒申     be sent to the client that created the window, and if that
+
鐃緒申��申鐃緒申     window no longer exists, no event will be sent.  */
+
鐃緒申��申鐃緒申  XSendEvent (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), False, 0, &event);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Transform a scroll bar ClientMessage EVENT to an Emacs input event
+
鐃緒申��申鐃緒申   in *IEVENT.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_scroll_bar_to_input_event (event, ievent)
+
鐃緒申��申鐃緒申     XEvent *event;
+
鐃緒申��申鐃緒申     struct input_event *ievent;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XClientMessageEvent *ev = (XClientMessageEvent *) event;
+
鐃緒申��申鐃緒申  Lisp_Object window;
+
鐃緒申��申鐃緒申  struct frame *f;
+
鐃緒申��申鐃緒申  struct window *w;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  w = scroll_bar_windows[ev->data.l[0]];
+
鐃緒申��申鐃緒申  scroll_bar_windows[ev->data.l[0]] = NULL;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSETWINDOW (window, w);
+
鐃緒申��申鐃緒申  f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  ievent->kind = scroll_bar_click;
+
鐃緒申��申鐃緒申  ievent->frame_or_window = window;
+
鐃緒申��申鐃緒申  ievent->arg = Qnil;
+
鐃緒申��申鐃緒申  ievent->timestamp = XtLastTimestampProcessed (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申  ievent->part = ev->data.l[1];
+
鐃緒申��申鐃緒申  ievent->code = ev->data.l[2];
+
鐃緒申��申鐃緒申  ievent->x = make_number ((int) ev->data.l[3]);
+
鐃緒申��申鐃緒申  ievent->y = make_number ((int) ev->data.l[4]);
+
鐃緒申��申鐃緒申  ievent->modifiers = 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_MOTIF
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Minimum and maximum values used for Motif scroll bars.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define XM_SB_MIN 1
+
鐃緒申��申鐃緒申#define XM_SB_MAX 10000000
+
鐃緒申��申鐃緒申#define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Scroll bar callback for Motif scroll bars.  WIDGET is the scroll
+
鐃緒申��申鐃緒申   bar widget.  CLIENT_DATA is a pointer to the scroll_bar structure.
+
鐃緒申��申鐃緒申   CALL_DATA is a pointer a a XmScrollBarCallbackStruct.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申xm_scroll_callback (widget, client_data, call_data)
+
鐃緒申��申鐃緒申     Widget widget;
+
鐃緒申��申鐃緒申     XtPointer client_data, call_data;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct scroll_bar *bar = (struct scroll_bar *) client_data;
+
鐃緒申��申鐃緒申  XmScrollBarCallbackStruct *cs = (XmScrollBarCallbackStruct *) call_data;
+
鐃緒申��申鐃緒申  double percent;
+
鐃緒申��申鐃緒申  int part = -1, whole = 0, portion = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  switch (cs->reason)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申    case XmCR_DECREMENT:
+
鐃緒申��申鐃緒申      bar->dragging = Qnil;
+
鐃緒申��申鐃緒申      part = scroll_bar_up_arrow;
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case XmCR_INCREMENT:
+
鐃緒申��申鐃緒申      bar->dragging = Qnil;
+
鐃緒申��申鐃緒申      part = scroll_bar_down_arrow;
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case XmCR_PAGE_DECREMENT:
+
鐃緒申��申鐃緒申      bar->dragging = Qnil;
+
鐃緒申��申鐃緒申      part = scroll_bar_above_handle;
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case XmCR_PAGE_INCREMENT:
+
鐃緒申��申鐃緒申      bar->dragging = Qnil;
+
鐃緒申��申鐃緒申      part = scroll_bar_below_handle;
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case XmCR_TO_TOP:
+
鐃緒申��申鐃緒申      bar->dragging = Qnil;
+
鐃緒申��申鐃緒申      part = scroll_bar_to_top;
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申    case XmCR_TO_BOTTOM:
+
鐃緒申��申鐃緒申      bar->dragging = Qnil;
+
鐃緒申��申鐃緒申      part = scroll_bar_to_bottom;
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    case XmCR_DRAG:
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	int slider_size;
+
鐃緒申��申鐃緒申	int dragging_down_p = (INTEGERP (bar->dragging)
+
鐃緒申��申鐃緒申			       && XINT (bar->dragging) <= cs->value);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* Get the slider size.  */
+
鐃緒申��申鐃緒申	BLOCK_INPUT;
+
鐃緒申��申鐃緒申	XtVaGetValues (widget, XmNsliderSize, &slider_size, NULL);
+
鐃緒申��申鐃緒申	UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* At the max position of the scroll bar, do a line-wise
+
鐃緒申��申鐃緒申	   movement.  Without doing anything, we would be called with
+
鐃緒申��申鐃緒申	   the same cs->value again and again.  If we want to make
+
鐃緒申��申鐃緒申	   sure that we can reach the end of the buffer, we have to do
+
鐃緒申��申鐃緒申	   something.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	   Implementation note: setting bar->dragging always to
+
鐃緒申��申鐃緒申	   cs->value gives a smoother movement at the max position.
+
鐃緒申��申鐃緒申	   Setting it to nil when doing line-wise movement gives
+
鐃緒申��申鐃緒申	   a better slider behavior. */
+
鐃緒申��申鐃緒申	
+
鐃緒申��申鐃緒申	if (cs->value + slider_size == XM_SB_MAX
+
鐃緒申��申鐃緒申	    || (dragging_down_p
+
鐃緒申��申鐃緒申		&& last_scroll_bar_part == scroll_bar_down_arrow))
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    part = scroll_bar_down_arrow;
+
鐃緒申��申鐃緒申	    bar->dragging = Qnil;
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申	else
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    whole = XM_SB_RANGE;
+
鐃緒申��申鐃緒申	    portion = min (cs->value - XM_SB_MIN, XM_SB_MAX - slider_size);
+
鐃緒申��申鐃緒申	    part = scroll_bar_handle;
+
鐃緒申��申鐃緒申	    bar->dragging = make_number (cs->value);
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申    case XmCR_VALUE_CHANGED:
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申    };
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (part >= 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      window_being_scrolled = bar->window;
+
鐃緒申��申鐃緒申      last_scroll_bar_part = part;
+
鐃緒申��申鐃緒申      x_send_scroll_bar_event (bar->window, part, portion, whole);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#else /* !USE_MOTIF, i.e. Xaw.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Xaw scroll bar callback.  Invoked when the thumb is dragged.
+
鐃緒申��申鐃緒申   WIDGET is the scroll bar widget.  CLIENT_DATA is a pointer to the
+
鐃緒申��申鐃緒申   scroll bar struct.  CALL_DATA is a pointer to a float saying where
+
鐃緒申��申鐃緒申   the thumb is.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申xaw_jump_callback (widget, client_data, call_data)
+
鐃緒申��申鐃緒申     Widget widget;
+
鐃緒申��申鐃緒申     XtPointer client_data, call_data;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct scroll_bar *bar = (struct scroll_bar *) client_data;
+
鐃緒申��申鐃緒申  float top = *(float *) call_data;
+
鐃緒申��申鐃緒申  float shown;
+
鐃緒申��申鐃緒申  int whole, portion, height;
+
鐃緒申��申鐃緒申  int part;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the size of the thumb, a value between 0 and 1.  */
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  XtVaGetValues (widget, XtNshown, &shown, XtNheight, &height, NULL);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  whole = 10000000;
+
鐃緒申��申鐃緒申  portion = shown < 1 ? top * whole : 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (shown < 1 && (abs (top + shown - 1) < 1.0/height))
+
鐃緒申��申鐃緒申    /* Some derivatives of Xaw refuse to shrink the thumb when you reach
+
鐃緒申��申鐃緒申       the bottom, so we force the scrolling whenever we see that we're
+
鐃緒申��申鐃緒申       too close to the bottom (in x_set_toolkit_scroll_bar_thumb
+
鐃緒申��申鐃緒申       we try to ensure that we always stay two pixels away from the
+
鐃緒申��申鐃緒申       bottom).  */
+
鐃緒申��申鐃緒申    part = scroll_bar_down_arrow;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    part = scroll_bar_handle;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  window_being_scrolled = bar->window;
+
鐃緒申��申鐃緒申  bar->dragging = make_number (portion);
+
鐃緒申��申鐃緒申  last_scroll_bar_part = part;
+
鐃緒申��申鐃緒申  x_send_scroll_bar_event (bar->window, part, portion, whole);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Xaw scroll bar callback.  Invoked for incremental scrolling.,
+
鐃緒申��申鐃緒申   i.e. line or page up or down.  WIDGET is the Xaw scroll bar
+
鐃緒申��申鐃緒申   widget.  CLIENT_DATA is a pointer to the scroll_bar structure for
+
鐃緒申��申鐃緒申   the scroll bar.  CALL_DATA is an integer specifying the action that
+
鐃緒申��申鐃緒申   has taken place.  It's magnitude is in the range 0..height of the
+
鐃緒申��申鐃緒申   scroll bar.  Negative values mean scroll towards buffer start.
+
鐃緒申��申鐃緒申   Values < height of scroll bar mean line-wise movement.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申xaw_scroll_callback (widget, client_data, call_data)
+
鐃緒申��申鐃緒申     Widget widget;
+
鐃緒申��申鐃緒申     XtPointer client_data, call_data;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct scroll_bar *bar = (struct scroll_bar *) client_data;
+
鐃緒申��申鐃緒申  int position = (int) call_data;
+
鐃緒申��申鐃緒申  Dimension height;
+
鐃緒申��申鐃緒申  int part;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the height of the scroll bar.  */
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  XtVaGetValues (widget, XtNheight, &height, NULL);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (abs (position) >= height)
+
鐃緒申��申鐃緒申    part = (position < 0) ? scroll_bar_above_handle : scroll_bar_below_handle;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If Xaw3d was compiled with ARROW_SCROLLBAR,
+
鐃緒申��申鐃緒申     it maps line-movement to call_data = max(5, height/20).  */
+
鐃緒申��申鐃緒申  else if (xaw3d_arrow_scroll && abs (position) <= max (5, height / 20))
+
鐃緒申��申鐃緒申    part = (position < 0) ? scroll_bar_up_arrow : scroll_bar_down_arrow;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    part = scroll_bar_move_ratio;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  window_being_scrolled = bar->window;
+
鐃緒申��申鐃緒申  bar->dragging = Qnil;
+
鐃緒申��申鐃緒申  last_scroll_bar_part = part;
+
鐃緒申��申鐃緒申  x_send_scroll_bar_event (bar->window, part, position, height);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* not USE_MOTIF */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Create the widget for scroll bar BAR on frame F.  Record the widget
+
鐃緒申��申鐃緒申   and X window of the scroll bar in BAR.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_create_toolkit_scroll_bar (f, bar)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     struct scroll_bar *bar;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Window xwindow;
+
鐃緒申��申鐃緒申  Widget widget;
+
鐃緒申��申鐃緒申  Arg av[20];
+
鐃緒申��申鐃緒申  int ac = 0;
+
鐃緒申��申鐃緒申  char *scroll_bar_name = "verticalScrollBar";
+
鐃緒申��申鐃緒申  unsigned long pixel;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_MOTIF
+
鐃緒申��申鐃緒申  /* Set resources.  Create the widget.  */
+
鐃緒申��申鐃緒申  XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
+
鐃緒申��申鐃緒申  XtSetArg (av[ac], XmNminimum, XM_SB_MIN); ++ac;
+
鐃緒申��申鐃緒申  XtSetArg (av[ac], XmNmaximum, XM_SB_MAX); ++ac;
+
鐃緒申��申鐃緒申  XtSetArg (av[ac], XmNorientation, XmVERTICAL); ++ac;
+
鐃緒申��申鐃緒申  XtSetArg (av[ac], XmNprocessingDirection, XmMAX_ON_BOTTOM), ++ac;
+
鐃緒申��申鐃緒申  XtSetArg (av[ac], XmNincrement, 1); ++ac;
+
鐃緒申��申鐃緒申  XtSetArg (av[ac], XmNpageIncrement, 1); ++ac;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  pixel = f->output_data.x->scroll_bar_foreground_pixel;
+
鐃緒申��申鐃緒申  if (pixel != -1)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XtSetArg (av[ac], XmNforeground, pixel);
+
鐃緒申��申鐃緒申      ++ac;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  pixel = f->output_data.x->scroll_bar_background_pixel;
+
鐃緒申��申鐃緒申  if (pixel != -1)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XtSetArg (av[ac], XmNbackground, pixel);
+
鐃緒申��申鐃緒申      ++ac;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  widget = XmCreateScrollBar (f->output_data.x->edit_widget,
+
鐃緒申��申鐃緒申			      scroll_bar_name, av, ac);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Add one callback for everything that can happen.  */
+
鐃緒申��申鐃緒申  XtAddCallback (widget, XmNdecrementCallback, xm_scroll_callback,
+
鐃緒申��申鐃緒申		 (XtPointer) bar);
+
鐃緒申��申鐃緒申  XtAddCallback (widget, XmNdragCallback, xm_scroll_callback,
+
鐃緒申��申鐃緒申		 (XtPointer) bar);
+
鐃緒申��申鐃緒申  XtAddCallback (widget, XmNincrementCallback, xm_scroll_callback,
+
鐃緒申��申鐃緒申		 (XtPointer) bar);
+
鐃緒申��申鐃緒申  XtAddCallback (widget, XmNpageDecrementCallback, xm_scroll_callback,
+
鐃緒申��申鐃緒申		 (XtPointer) bar);
+
鐃緒申��申鐃緒申  XtAddCallback (widget, XmNpageIncrementCallback, xm_scroll_callback,
+
鐃緒申��申鐃緒申		 (XtPointer) bar);
+
鐃緒申��申鐃緒申  XtAddCallback (widget, XmNtoBottomCallback, xm_scroll_callback,
+
鐃緒申��申鐃緒申		 (XtPointer) bar);
+
鐃緒申��申鐃緒申  XtAddCallback (widget, XmNtoTopCallback, xm_scroll_callback,
+
鐃緒申��申鐃緒申		 (XtPointer) bar);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Realize the widget.  Only after that is the X window created.  */
+
鐃緒申��申鐃緒申  XtRealizeWidget (widget);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Set the cursor to an arrow.  I didn't find a resource to do that.
+
鐃緒申��申鐃緒申     And I'm wondering why it hasn't an arrow cursor by default.  */
+
鐃緒申��申鐃緒申  XDefineCursor (XtDisplay (widget), XtWindow (widget),
+
鐃緒申��申鐃緒申		 f->output_data.x->nontext_cursor);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#else /* !USE_MOTIF i.e. use Xaw */
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Set resources.  Create the widget.  The background of the
+
鐃緒申��申鐃緒申     Xaw3d scroll bar widget is a little bit light for my taste.
+
鐃緒申��申鐃緒申     We don't alter it here to let users change it according
+
鐃緒申��申鐃緒申     to their taste with `emacs*verticalScrollBar.background: xxx'.  */
+
鐃緒申��申鐃緒申  XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
+
鐃緒申��申鐃緒申  XtSetArg (av[ac], XtNorientation, XtorientVertical); ++ac;
+
鐃緒申��申鐃緒申  /* For smoother scrolling with Xaw3d   -sm */
+
鐃緒申��申鐃緒申  /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
+
鐃緒申��申鐃緒申  /* XtSetArg (av[ac], XtNbeNiceToColormap, True); ++ac; */
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  pixel = f->output_data.x->scroll_bar_foreground_pixel;
+
鐃緒申��申鐃緒申  if (pixel != -1)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XtSetArg (av[ac], XtNforeground, pixel);
+
鐃緒申��申鐃緒申      ++ac;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  pixel = f->output_data.x->scroll_bar_background_pixel;
+
鐃緒申��申鐃緒申  if (pixel != -1)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XtSetArg (av[ac], XtNbackground, pixel);
+
鐃緒申��申鐃緒申      ++ac;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  widget = XtCreateWidget (scroll_bar_name, scrollbarWidgetClass,
+
鐃緒申��申鐃緒申			   f->output_data.x->edit_widget, av, ac);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    char *initial = "";
+
鐃緒申��申鐃緒申    char *val = initial;
+
鐃緒申��申鐃緒申    XtVaGetValues (widget, XtNscrollVCursor, (XtPointer) &val,
+
鐃緒申��申鐃緒申		   XtNpickTop, (XtPointer) &xaw3d_pick_top, NULL);
+
鐃緒申��申鐃緒申    if (val == initial)
+
鐃緒申��申鐃緒申      {	/* ARROW_SCROLL */
+
鐃緒申��申鐃緒申	xaw3d_arrow_scroll = True;
+
鐃緒申��申鐃緒申	/* Isn't that just a personal preference ?   -sm */
+
鐃緒申��申鐃緒申	XtVaSetValues (widget, XtNcursorName, "top_left_arrow", NULL);
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Define callbacks.  */
+
鐃緒申��申鐃緒申  XtAddCallback (widget, XtNjumpProc, xaw_jump_callback, (XtPointer) bar);
+
鐃緒申��申鐃緒申  XtAddCallback (widget, XtNscrollProc, xaw_scroll_callback,
+
鐃緒申��申鐃緒申		 (XtPointer) bar);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Realize the widget.  Only after that is the X window created.  */
+
鐃緒申��申鐃緒申  XtRealizeWidget (widget);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#endif /* !USE_MOTIF */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Install an action hook that let's us detect when the user
+
鐃緒申��申鐃緒申     finishes interacting with a scroll bar.  */
+
鐃緒申��申鐃緒申  if (action_hook_id == 0)
+
鐃緒申��申鐃緒申    action_hook_id = XtAppAddActionHook (Xt_app_con, xt_action_hook, 0);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Remember X window and widget in the scroll bar vector.  */
+
鐃緒申��申鐃緒申  SET_SCROLL_BAR_X_WIDGET (bar, widget);
+
鐃緒申��申鐃緒申  xwindow = XtWindow (widget);
+
鐃緒申��申鐃緒申  SET_SCROLL_BAR_X_WINDOW (bar, xwindow);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set the thumb size and position of scroll bar BAR.  We are currently
+
鐃緒申��申鐃緒申   displaying PORTION out of a whole WHOLE, and our position POSITION.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
+
鐃緒申��申鐃緒申     struct scroll_bar *bar;
+
鐃緒申��申鐃緒申     int portion, position, whole;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+
鐃緒申��申鐃緒申  Widget widget = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
+
鐃緒申��申鐃緒申  float top, shown;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (whole == 0)
+
鐃緒申��申鐃緒申    top = 0, shown = 1;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      top = (float) position / whole;
+
鐃緒申��申鐃緒申      shown = (float) portion / whole;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_MOTIF
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    int size, value;
+
鐃緒申��申鐃緒申    XmScrollBarWidget sb;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Slider size.  Must be in the range [1 .. MAX - MIN] where MAX
+
鐃緒申��申鐃緒申       is the scroll bar's maximum and MIN is the scroll bar's minimum
+
鐃緒申��申鐃緒申       value.  */
+
鐃緒申��申鐃緒申    size = shown * XM_SB_RANGE;
+
鐃緒申��申鐃緒申    size = min (size, XM_SB_RANGE);
+
鐃緒申��申鐃緒申    size = max (size, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Position.  Must be in the range [MIN .. MAX - SLIDER_SIZE].  */
+
鐃緒申��申鐃緒申    value = top * XM_SB_RANGE;
+
鐃緒申��申鐃緒申    value = min (value, XM_SB_MAX - size);
+
鐃緒申��申鐃緒申    value = max (value, XM_SB_MIN);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    if (NILP (bar->dragging))
+
鐃緒申��申鐃緒申      XmScrollBarSetValues (widget, value, size, 0, 0, False);
+
鐃緒申��申鐃緒申    else if (last_scroll_bar_part == scroll_bar_down_arrow)
+
鐃緒申��申鐃緒申      /* This has the negative side effect that the slider value is
+
鐃緒申��申鐃緒申	 not what it would be if we scrolled here using line-wise or
+
鐃緒申��申鐃緒申	 page-wise movement.  */
+
鐃緒申��申鐃緒申      XmScrollBarSetValues (widget, value, XM_SB_RANGE - value, 0, 0, False);
+
鐃緒申��申鐃緒申    else
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	/* If currently dragging, only update the slider size.
+
鐃緒申��申鐃緒申	   This reduces flicker effects.  */
+
鐃緒申��申鐃緒申	int old_value, old_size, increment, page_increment;
+
鐃緒申��申鐃緒申	
+
鐃緒申��申鐃緒申	XmScrollBarGetValues (widget, &old_value, &old_size,
+
鐃緒申��申鐃緒申			      &increment, &page_increment);
+
鐃緒申��申鐃緒申	XmScrollBarSetValues (widget, old_value,
+
鐃緒申��申鐃緒申			      min (size, XM_SB_RANGE - old_value),
+
鐃緒申��申鐃緒申			      0, 0, False);
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申#else /* !USE_MOTIF i.e. use Xaw */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    float old_top, old_shown;
+
鐃緒申��申鐃緒申    Dimension height;
+
鐃緒申��申鐃緒申    XtVaGetValues (widget,
+
鐃緒申��申鐃緒申		   XtNtopOfThumb, &old_top,
+
鐃緒申��申鐃緒申		   XtNshown, &old_shown,
+
鐃緒申��申鐃緒申		   XtNheight, &height,
+
鐃緒申��申鐃緒申		   NULL);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Massage the top+shown values.  */
+
鐃緒申��申鐃緒申    if (NILP (bar->dragging) || last_scroll_bar_part == scroll_bar_down_arrow)
+
鐃緒申��申鐃緒申      top = max (0, min (1, top));
+
鐃緒申��申鐃緒申    else
+
鐃緒申��申鐃緒申      top = old_top;
+
鐃緒申��申鐃緒申    /* Keep two pixels available for moving the thumb down.  */
+
鐃緒申��申鐃緒申    shown = max (0, min (1 - top - (2.0 / height), shown));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* If the call to XawScrollbarSetThumb below doesn't seem to work,
+
鐃緒申��申鐃緒申       check that your system's configuration file contains a define
+
鐃緒申��申鐃緒申       for `NARROWPROTO'.  See s/freebsd.h for an example.  */
+
鐃緒申��申鐃緒申    if (top != old_top || shown != old_shown)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	if (NILP (bar->dragging))
+
鐃緒申��申鐃緒申	  XawScrollbarSetThumb (widget, top, shown);
+
鐃緒申��申鐃緒申	else
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申#ifdef HAVE_XAW3D
+
鐃緒申��申鐃緒申	    ScrollbarWidget sb = (ScrollbarWidget) widget;
+
鐃緒申��申鐃緒申	    int scroll_mode = 0;
+
鐃緒申��申鐃緒申	    
+
鐃緒申��申鐃緒申	    /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR.  */
+
鐃緒申��申鐃緒申	    if (xaw3d_arrow_scroll)
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		/* Xaw3d stupidly ignores resize requests while dragging
+
鐃緒申��申鐃緒申		   so we have to make it believe it's not in dragging mode.  */
+
鐃緒申��申鐃緒申		scroll_mode = sb->scrollbar.scroll_mode;
+
鐃緒申��申鐃緒申		if (scroll_mode == 2)
+
鐃緒申��申鐃緒申		  sb->scrollbar.scroll_mode = 0;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申	    /* Try to make the scrolling a tad smoother.  */
+
鐃緒申��申鐃緒申	    if (!xaw3d_pick_top)
+
鐃緒申��申鐃緒申	      shown = min (shown, old_shown);
+
鐃緒申��申鐃緒申	    
+
鐃緒申��申鐃緒申	    XawScrollbarSetThumb (widget, top, shown);
+
鐃緒申��申鐃緒申	    
+
鐃緒申��申鐃緒申#ifdef HAVE_XAW3D
+
鐃緒申��申鐃緒申	    if (xaw3d_arrow_scroll && scroll_mode == 2)
+
鐃緒申��申鐃緒申	      sb->scrollbar.scroll_mode = scroll_mode;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申#endif /* !USE_MOTIF */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/************************************************************************
+
鐃緒申��申鐃緒申			 Scroll bars, general
+
鐃緒申��申鐃緒申 ************************************************************************/
+
鐃緒申��申鐃緒申									 
+
鐃緒申��申鐃緒申/* Create a scroll bar and return the scroll bar vector for it.  W is
+
鐃緒申��申鐃緒申   the Emacs window on which to create the scroll bar. TOP, LEFT,
+
鐃緒申��申鐃緒申   WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
+
鐃緒申��申鐃緒申   scroll bar. */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct scroll_bar *
+
鐃緒申��申鐃緒申x_scroll_bar_create (w, top, left, width, height)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int top, left, width, height;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  struct scroll_bar *bar
+
鐃緒申��申鐃緒申    = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申  x_create_toolkit_scroll_bar (f, bar);
+
鐃緒申��申鐃緒申#else /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    XSetWindowAttributes a;
+
鐃緒申��申鐃緒申    unsigned long mask;
+
鐃緒申��申鐃緒申    Window window;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    a.background_pixel = f->output_data.x->scroll_bar_background_pixel;
+
鐃緒申��申鐃緒申    if (a.background_pixel == -1)
+
鐃緒申��申鐃緒申      a.background_pixel = f->output_data.x->background_pixel;
+
鐃緒申��申鐃緒申    
+
鐃緒申��申鐃緒申    a.event_mask = (ButtonPressMask | ButtonReleaseMask
+
鐃緒申��申鐃緒申		    | ButtonMotionMask | PointerMotionHintMask
+
鐃緒申��申鐃緒申		    | ExposureMask);
+
鐃緒申��申鐃緒申    a.cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    mask = (CWBackPixel | CWEventMask | CWCursor);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Clear the area of W that will serve as a scroll bar.  This is
+
鐃緒申��申鐃緒申       for the case that a window has been split horizontally.  In
+
鐃緒申��申鐃緒申       this case, no clear_frame is generated to reduce flickering.  */
+
鐃緒申��申鐃緒申    x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		  left, top, width,
+
鐃緒申��申鐃緒申		  window_box_height (w), False);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    window = XCreateWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申			    /* Position and size of scroll bar.  */
+
鐃緒申��申鐃緒申			    left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
+
鐃緒申��申鐃緒申			    top,
+
鐃緒申��申鐃緒申			    width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
+
鐃緒申��申鐃緒申			    height,
+
鐃緒申��申鐃緒申			    /* Border width, depth, class, and visual.  */
+
鐃緒申��申鐃緒申			     0,
+
鐃緒申��申鐃緒申			    CopyFromParent,
+
鐃緒申��申鐃緒申			    CopyFromParent,
+
鐃緒申��申鐃緒申			    CopyFromParent,
+
鐃緒申��申鐃緒申			     /* Attributes.  */
+
鐃緒申��申鐃緒申			    mask, &a);
+
鐃緒申��申鐃緒申    SET_SCROLL_BAR_X_WINDOW (bar, window);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申#endif /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSETWINDOW (bar->window, w);
+
鐃緒申��申鐃緒申  XSETINT (bar->top, top);
+
鐃緒申��申鐃緒申  XSETINT (bar->left, left);
+
鐃緒申��申鐃緒申  XSETINT (bar->width, width);
+
鐃緒申��申鐃緒申  XSETINT (bar->height, height);
+
鐃緒申��申鐃緒申  XSETINT (bar->start, 0);
+
鐃緒申��申鐃緒申  XSETINT (bar->end, 0);
+
鐃緒申��申鐃緒申  bar->dragging = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Add bar to its frame's list of scroll bars.  */
+
鐃緒申��申鐃緒申  bar->next = FRAME_SCROLL_BARS (f);
+
鐃緒申��申鐃緒申  bar->prev = Qnil;
+
鐃緒申��申鐃緒申  XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
+
鐃緒申��申鐃緒申  if (!NILP (bar->next))
+
鐃緒申��申鐃緒申    XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Map the window/widget.  */
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    Widget scroll_bar = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
+
鐃緒申��申鐃緒申    XtConfigureWidget (scroll_bar,
+
鐃緒申��申鐃緒申		       left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
+
鐃緒申��申鐃緒申		       top,
+
鐃緒申��申鐃緒申		       width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
+
鐃緒申��申鐃緒申		       max (height, 1), 0);
+
鐃緒申��申鐃緒申    XtMapWidget (scroll_bar);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申#else /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申  XMapRaised (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
+
鐃緒申��申鐃緒申#endif /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申  return bar;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw BAR's handle in the proper position.
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申   If the handle is already drawn from START to END, don't bother
+
鐃緒申��申鐃緒申   redrawing it, unless REBUILD is non-zero; in that case, always
+
鐃緒申��申鐃緒申   redraw it.  (REBUILD is handy for drawing the handle after expose
+
鐃緒申��申鐃緒申   events.)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Normally, we want to constrain the start and end of the handle to
+
鐃緒申��申鐃緒申   fit inside its rectangle, but if the user is dragging the scroll
+
鐃緒申��申鐃緒申   bar handle, we want to let them drag it down all the way, so that
+
鐃緒申��申鐃緒申   the bar's top is as far down as it goes; otherwise, there's no way
+
鐃緒申��申鐃緒申   to move to the very end of the buffer.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_scroll_bar_set_handle (bar, start, end, rebuild)
+
鐃緒申��申鐃緒申     struct scroll_bar *bar;
+
鐃緒申��申鐃緒申     int start, end;
+
鐃緒申��申鐃緒申     int rebuild;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int dragging = ! NILP (bar->dragging);
+
鐃緒申��申鐃緒申  Window w = SCROLL_BAR_X_WINDOW (bar);
+
鐃緒申��申鐃緒申  FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+
鐃緒申��申鐃緒申  GC gc = f->output_data.x->normal_gc;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If the display is already accurate, do nothing.  */
+
鐃緒申��申鐃緒申  if (! rebuild
+
鐃緒申��申鐃緒申      && start == XINT (bar->start)
+
鐃緒申��申鐃緒申      && end == XINT (bar->end))
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    int inside_width = VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f, XINT (bar->width));
+
鐃緒申��申鐃緒申    int inside_height = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
+
鐃緒申��申鐃緒申    int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Make sure the values are reasonable, and try to preserve
+
鐃緒申��申鐃緒申       the distance between start and end.  */
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int length = end - start;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (start < 0)
+
鐃緒申��申鐃緒申	start = 0;
+
鐃緒申��申鐃緒申      else if (start > top_range)
+
鐃緒申��申鐃緒申	start = top_range;
+
鐃緒申��申鐃緒申      end = start + length;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (end < start)
+
鐃緒申��申鐃緒申	end = start;
+
鐃緒申��申鐃緒申      else if (end > top_range && ! dragging)
+
鐃緒申��申鐃緒申	end = top_range;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Store the adjusted setting in the scroll bar.  */
+
鐃緒申��申鐃緒申    XSETINT (bar->start, start);
+
鐃緒申��申鐃緒申    XSETINT (bar->end, end);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Clip the end position, just for display.  */
+
鐃緒申��申鐃緒申    if (end > top_range)
+
鐃緒申��申鐃緒申      end = top_range;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
+
鐃緒申��申鐃緒申       below top positions, to make sure the handle is always at least
+
鐃緒申��申鐃緒申       that many pixels tall.  */
+
鐃緒申��申鐃緒申    end += VERTICAL_SCROLL_BAR_MIN_HANDLE;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Draw the empty space above the handle.  Note that we can't clear
+
鐃緒申��申鐃緒申       zero-height areas; that means "clear to end of window."  */
+
鐃緒申��申鐃緒申    if (0 < start)
+
鐃緒申��申鐃緒申      x_clear_area (FRAME_X_DISPLAY (f), w,
+
鐃緒申��申鐃緒申		    /* x, y, width, height, and exposures.  */
+
鐃緒申��申鐃緒申		    VERTICAL_SCROLL_BAR_LEFT_BORDER,
+
鐃緒申��申鐃緒申		    VERTICAL_SCROLL_BAR_TOP_BORDER,
+
鐃緒申��申鐃緒申		    inside_width, start,
+
鐃緒申��申鐃緒申		    False);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Change to proper foreground color if one is specified.  */
+
鐃緒申��申鐃緒申    if (f->output_data.x->scroll_bar_foreground_pixel != -1)
+
鐃緒申��申鐃緒申      XSetForeground (FRAME_X_DISPLAY (f), gc,
+
鐃緒申��申鐃緒申		      f->output_data.x->scroll_bar_foreground_pixel);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Draw the handle itself.  */
+
鐃緒申��申鐃緒申    XFillRectangle (FRAME_X_DISPLAY (f), w, gc,
+
鐃緒申��申鐃緒申		    /* x, y, width, height */
+
鐃緒申��申鐃緒申		    VERTICAL_SCROLL_BAR_LEFT_BORDER,
+
鐃緒申��申鐃緒申		    VERTICAL_SCROLL_BAR_TOP_BORDER + start,
+
鐃緒申��申鐃緒申		    inside_width, end - start);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Restore the foreground color of the GC if we changed it above.  */
+
鐃緒申��申鐃緒申    if (f->output_data.x->scroll_bar_foreground_pixel != -1)
+
鐃緒申��申鐃緒申      XSetForeground (FRAME_X_DISPLAY (f), gc,
+
鐃緒申��申鐃緒申		      f->output_data.x->foreground_pixel);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Draw the empty space below the handle.  Note that we can't
+
鐃緒申��申鐃緒申       clear zero-height areas; that means "clear to end of window." */
+
鐃緒申��申鐃緒申    if (end < inside_height)
+
鐃緒申��申鐃緒申      x_clear_area (FRAME_X_DISPLAY (f), w,
+
鐃緒申��申鐃緒申		    /* x, y, width, height, and exposures.  */
+
鐃緒申��申鐃緒申		    VERTICAL_SCROLL_BAR_LEFT_BORDER,
+
鐃緒申��申鐃緒申		    VERTICAL_SCROLL_BAR_TOP_BORDER + end,
+
鐃緒申��申鐃緒申		    inside_width, inside_height - end,
+
鐃緒申��申鐃緒申		    False);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* !USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
+
鐃緒申��申鐃緒申   nil.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_scroll_bar_remove (bar)
+
鐃緒申��申鐃緒申     struct scroll_bar *bar;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申  XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar));
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申  XDestroyWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Disassociate this scroll bar from its window.  */
+
鐃緒申��申鐃緒申  XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set the handle of the vertical scroll bar for WINDOW to indicate
+
鐃緒申��申鐃緒申   that we are displaying PORTION characters out of a total of WHOLE
+
鐃緒申��申鐃緒申   characters, starting at POSITION.  If WINDOW has no scroll bar,
+
鐃緒申��申鐃緒申   create one.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTset_vertical_scroll_bar (w, portion, whole, position)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int portion, whole, position;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  struct scroll_bar *bar;
+
鐃緒申��申鐃緒申  int top, height, left, sb_left, width, sb_width;
+
鐃緒申��申鐃緒申  int window_x, window_y, window_width, window_height;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get window dimensions.  */
+
鐃緒申��申鐃緒申  window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
+
鐃緒申��申鐃緒申  top = window_y;
+
鐃緒申��申鐃緒申  width = FRAME_SCROLL_BAR_COLS (f) * CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申  height = window_height;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Compute the left edge of the scroll bar area.  */
+
鐃緒申��申鐃緒申  if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
+
鐃緒申��申鐃緒申    left = XINT (w->left) + XINT (w->width) - FRAME_SCROLL_BAR_COLS (f);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    left = XFASTINT (w->left);
+
鐃緒申��申鐃緒申  left *= CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申  left += FRAME_INTERNAL_BORDER_WIDTH (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Compute the width of the scroll bar which might be less than
+
鐃緒申��申鐃緒申     the width of the area reserved for the scroll bar.  */
+
鐃緒申��申鐃緒申  if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f) > 0)
+
鐃緒申��申鐃緒申    sb_width = FRAME_SCROLL_BAR_PIXEL_WIDTH (f);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    sb_width = width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Compute the left edge of the scroll bar.  */
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申  if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
+
鐃緒申��申鐃緒申    sb_left = left + width - sb_width - (width - sb_width) / 2; 
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    sb_left = left + (width - sb_width) / 2;
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申  if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
+
鐃緒申��申鐃緒申    sb_left = left + width - sb_width; 
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    sb_left = left;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Does the scroll bar exist yet?  */
+
鐃緒申��申鐃緒申  if (NILP (w->vertical_scroll_bar))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申      if (width && height)
+
鐃緒申��申鐃緒申	x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		      left, top, width, height, False);
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申      bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* It may just need to be moved and resized.  */
+
鐃緒申��申鐃緒申      unsigned int mask = 0;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      bar = XSCROLL_BAR (w->vertical_scroll_bar);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (sb_left != XINT (bar->left))
+
鐃緒申��申鐃緒申	mask |= CWX;
+
鐃緒申��申鐃緒申      if (top != XINT (bar->top))
+
鐃緒申��申鐃緒申	mask |= CWY;
+
鐃緒申��申鐃緒申      if (sb_width != XINT (bar->width))
+
鐃緒申��申鐃緒申	mask |= CWWidth;
+
鐃緒申��申鐃緒申      if (height != XINT (bar->height))	
+
鐃緒申��申鐃緒申	mask |= CWHeight;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Since toolkit scroll bars are smaller than the space reserved
+
鐃緒申��申鐃緒申	 for them on the frame, we have to clear "under" them.  */
+
鐃緒申��申鐃緒申      if (width && height)
+
鐃緒申��申鐃緒申	x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		      left, top, width, height, False);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Move/size the scroll bar widget.  */
+
鐃緒申��申鐃緒申      if (mask)
+
鐃緒申��申鐃緒申	XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar),
+
鐃緒申��申鐃緒申			   sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
+
鐃緒申��申鐃緒申			   top,
+
鐃緒申��申鐃緒申			   sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
+
鐃緒申��申鐃緒申			   max (height, 1), 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#else /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申      /* Clear areas not covered by the scroll bar because of
+
鐃緒申��申鐃緒申	 VERTICAL_SCROLL_BAR_WIDTH_TRIM.  */
+
鐃緒申��申鐃緒申      if (VERTICAL_SCROLL_BAR_WIDTH_TRIM)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申			left, top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
+
鐃緒申��申鐃緒申			height, False);
+
鐃緒申��申鐃緒申	  x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申			left + width - VERTICAL_SCROLL_BAR_WIDTH_TRIM,
+
鐃緒申��申鐃緒申			top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
+
鐃緒申��申鐃緒申			height, False);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Clear areas not covered by the scroll bar because it's not as
+
鐃緒申��申鐃緒申	 wide as the area reserved for it .  This makes sure a
+
鐃緒申��申鐃緒申	 previous mode line display is cleared after C-x 2 C-x 1, for
+
鐃緒申��申鐃緒申	 example.  */
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	int area_width = FRAME_SCROLL_BAR_COLS (f) * CANON_X_UNIT (f);
+
鐃緒申��申鐃緒申	int rest = area_width - sb_width;
+
鐃緒申��申鐃緒申	if (rest > 0)
+
鐃緒申��申鐃緒申	  x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申			left + area_width -  rest, 0,
+
鐃緒申��申鐃緒申			rest, max (height, 1), False);
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Move/size the scroll bar window.  */
+
鐃緒申��申鐃緒申      if (mask)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  XWindowChanges wc;
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  wc.x = sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM;
+
鐃緒申��申鐃緒申	  wc.y = top;
+
鐃緒申��申鐃緒申	  wc.width = sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2;
+
鐃緒申��申鐃緒申	  wc.height = height;
+
鐃緒申��申鐃緒申	  XConfigureWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar),
+
鐃緒申��申鐃緒申			    mask, &wc);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#endif /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Remember new settings.  */
+
鐃緒申��申鐃緒申      XSETINT (bar->left, sb_left);
+
鐃緒申��申鐃緒申      XSETINT (bar->top, top);
+
鐃緒申��申鐃緒申      XSETINT (bar->width, sb_width);
+
鐃緒申��申鐃緒申      XSETINT (bar->height, height);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申  x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole);
+
鐃緒申��申鐃緒申#else /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申  /* Set the scroll bar's current state, unless we're currently being
+
鐃緒申��申鐃緒申     dragged.  */
+
鐃緒申��申鐃緒申  if (NILP (bar->dragging))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (whole == 0)
+
鐃緒申��申鐃緒申	x_scroll_bar_set_handle (bar, 0, top_range, 0);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int start = ((double) position * top_range) / whole;
+
鐃緒申��申鐃緒申	  int end = ((double) (position + portion) * top_range) / whole;
+
鐃緒申��申鐃緒申	  x_scroll_bar_set_handle (bar, start, end, 0);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申#endif /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSETVECTOR (w->vertical_scroll_bar, bar);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The following three hooks are used when we're doing a thorough
+
鐃緒申��申鐃緒申   redisplay of the frame.  We don't explicitly know which scroll bars
+
鐃緒申��申鐃緒申   are going to be deleted, because keeping track of when windows go
+
鐃緒申��申鐃緒申   away is a real pain - "Can you say set-window-configuration, boys
+
鐃緒申��申鐃緒申   and girls?"  Instead, we just assert at the beginning of redisplay
+
鐃緒申��申鐃緒申   that *all* scroll bars are to be removed, and then save a scroll bar
+
鐃緒申��申鐃緒申   from the fiery pit when we actually redisplay its window.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Arrange for all scroll bars on FRAME to be removed at the next call
+
鐃緒申��申鐃緒申   to `*judge_scroll_bars_hook'.  A scroll bar may be spared if
+
鐃緒申��申鐃緒申   `*redeem_scroll_bar_hook' is applied to its window before the judgment.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTcondemn_scroll_bars (frame)
+
鐃緒申��申鐃緒申     FRAME_PTR frame;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS.  */
+
鐃緒申��申鐃緒申  while (! NILP (FRAME_SCROLL_BARS (frame)))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object bar;
+
鐃緒申��申鐃緒申      bar = FRAME_SCROLL_BARS (frame);
+
鐃緒申��申鐃緒申      FRAME_SCROLL_BARS (frame) = XSCROLL_BAR (bar)->next;
+
鐃緒申��申鐃緒申      XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
+
鐃緒申��申鐃緒申      XSCROLL_BAR (bar)->prev = Qnil;
+
鐃緒申��申鐃緒申      if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
+
鐃緒申��申鐃緒申	XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
+
鐃緒申��申鐃緒申      FRAME_CONDEMNED_SCROLL_BARS (frame) = bar;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
+
鐃緒申��申鐃緒申   Note that WINDOW isn't necessarily condemned at all.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTredeem_scroll_bar (window)
+
鐃緒申��申鐃緒申     struct window *window;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct scroll_bar *bar;
+
鐃緒申��申鐃緒申  struct frame *f;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We can't redeem this window's scroll bar if it doesn't have one.  */
+
鐃緒申��申鐃緒申  if (NILP (window->vertical_scroll_bar))
+
鐃緒申��申鐃緒申    abort ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  bar = XSCROLL_BAR (window->vertical_scroll_bar);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Unlink it from the condemned list.  */
+
鐃緒申��申鐃緒申  f = XFRAME (WINDOW_FRAME (window));
+
鐃緒申��申鐃緒申  if (NILP (bar->prev))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* If the prev pointer is nil, it must be the first in one of
+
鐃緒申��申鐃緒申	 the lists.  */
+
鐃緒申��申鐃緒申      if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
+
鐃緒申��申鐃緒申	/* It's not condemned.  Everything's fine.  */
+
鐃緒申��申鐃緒申	return;
+
鐃緒申��申鐃緒申      else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
+
鐃緒申��申鐃緒申		   window->vertical_scroll_bar))
+
鐃緒申��申鐃緒申	FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	/* If its prev pointer is nil, it must be at the front of
+
鐃緒申��申鐃緒申	   one or the other!  */
+
鐃緒申��申鐃緒申	abort ();
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    XSCROLL_BAR (bar->prev)->next = bar->next;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (! NILP (bar->next))
+
鐃緒申��申鐃緒申    XSCROLL_BAR (bar->next)->prev = bar->prev;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  bar->next = FRAME_SCROLL_BARS (f);
+
鐃緒申��申鐃緒申  bar->prev = Qnil;
+
鐃緒申��申鐃緒申  XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
+
鐃緒申��申鐃緒申  if (! NILP (bar->next))
+
鐃緒申��申鐃緒申    XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Remove all scroll bars on FRAME that haven't been saved since the
+
鐃緒申��申鐃緒申   last call to `*condemn_scroll_bars_hook'.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTjudge_scroll_bars (f)
+
鐃緒申��申鐃緒申     FRAME_PTR f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object bar, next;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  bar = FRAME_CONDEMNED_SCROLL_BARS (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Clear out the condemned list now so we won't try to process any
+
鐃緒申��申鐃緒申     more events on the hapless scroll bars.  */
+
鐃緒申��申鐃緒申  FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (; ! NILP (bar); bar = next)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct scroll_bar *b = XSCROLL_BAR (bar);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      x_scroll_bar_remove (b);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      next = b->next;
+
鐃緒申��申鐃緒申      b->next = b->prev = Qnil;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Now there should be no references to the condemned scroll bars,
+
鐃緒申��申鐃緒申     and they should get garbage-collected.  */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Handle an Expose or GraphicsExpose event on a scroll bar.  This
+
鐃緒申��申鐃緒申   is a no-op when using toolkit scroll bars.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   This may be called from a signal handler, so we have to ignore GC
+
鐃緒申��申鐃緒申   mark bits.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_scroll_bar_expose (bar, event)
+
鐃緒申��申鐃緒申     struct scroll_bar *bar;
+
鐃緒申��申鐃緒申     XEvent *event;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#ifndef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Window w = SCROLL_BAR_X_WINDOW (bar);
+
鐃緒申��申鐃緒申  FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+
鐃緒申��申鐃緒申  GC gc = f->output_data.x->normal_gc;
+
鐃緒申��申鐃緒申  int width_trim = VERTICAL_SCROLL_BAR_WIDTH_TRIM;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  x_scroll_bar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Draw a one-pixel border just inside the edges of the scroll bar.  */
+
鐃緒申��申鐃緒申  XDrawRectangle (FRAME_X_DISPLAY (f), w, gc,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  /* x, y, width, height */
+
鐃緒申��申鐃緒申		  0, 0,
+
鐃緒申��申鐃緒申		  XINT (bar->width) - 1 - width_trim - width_trim,
+
鐃緒申��申鐃緒申		  XINT (bar->height) - 1);
+
鐃緒申��申鐃緒申    
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Handle a mouse click on the scroll bar BAR.  If *EMACS_EVENT's kind
+
鐃緒申��申鐃緒申   is set to something other than no_event, it is enqueued.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   This may be called from a signal handler, so we have to ignore GC
+
鐃緒申��申鐃緒申   mark bits.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_scroll_bar_handle_click (bar, event, emacs_event)
+
鐃緒申��申鐃緒申     struct scroll_bar *bar;
+
鐃緒申��申鐃緒申     XEvent *event;
+
鐃緒申��申鐃緒申     struct input_event *emacs_event;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (! GC_WINDOWP (bar->window))
+
鐃緒申��申鐃緒申    abort ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  emacs_event->kind = scroll_bar_click;
+
鐃緒申��申鐃緒申  emacs_event->code = event->xbutton.button - Button1;
+
鐃緒申��申鐃緒申  emacs_event->modifiers
+
鐃緒申��申鐃緒申    = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO 
+
鐃緒申��申鐃緒申			       (XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))),
+
鐃緒申��申鐃緒申			       event->xbutton.state)
+
鐃緒申��申鐃緒申       | (event->type == ButtonRelease
+
鐃緒申��申鐃緒申	  ? up_modifier
+
鐃緒申��申鐃緒申	  : down_modifier));
+
鐃緒申��申鐃緒申  emacs_event->frame_or_window = bar->window;
+
鐃緒申��申鐃緒申  emacs_event->arg = Qnil;
+
鐃緒申��申鐃緒申  emacs_event->timestamp = event->xbutton.time;
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申    FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+
鐃緒申��申鐃緒申    int internal_height
+
鐃緒申��申鐃緒申      = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申    int top_range
+
鐃緒申��申鐃緒申      = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
+
鐃緒申��申鐃緒申    int y = event->xbutton.y - VERTICAL_SCROLL_BAR_TOP_BORDER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    if (y < 0) y = 0;
+
鐃緒申��申鐃緒申    if (y > top_range) y = top_range;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    if (y < XINT (bar->start))
+
鐃緒申��申鐃緒申      emacs_event->part = scroll_bar_above_handle;
+
鐃緒申��申鐃緒申    else if (y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
+
鐃緒申��申鐃緒申      emacs_event->part = scroll_bar_handle;
+
鐃緒申��申鐃緒申    else
+
鐃緒申��申鐃緒申      emacs_event->part = scroll_bar_below_handle;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Just because the user has clicked on the handle doesn't mean
+
鐃緒申��申鐃緒申       they want to drag it.  Lisp code needs to be able to decide
+
鐃緒申��申鐃緒申       whether or not we're dragging.  */
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申    /* If the user has just clicked on the handle, record where they're
+
鐃緒申��申鐃緒申       holding it.  */
+
鐃緒申��申鐃緒申    if (event->type == ButtonPress
+
鐃緒申��申鐃緒申	&& emacs_event->part == scroll_bar_handle)
+
鐃緒申��申鐃緒申      XSETINT (bar->dragging, y - XINT (bar->start));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* If the user has released the handle, set it to its final position.  */
+
鐃緒申��申鐃緒申    if (event->type == ButtonRelease
+
鐃緒申��申鐃緒申	&& ! NILP (bar->dragging))
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	int new_start = y - XINT (bar->dragging);
+
鐃緒申��申鐃緒申	int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	x_scroll_bar_set_handle (bar, new_start, new_end, 0);
+
鐃緒申��申鐃緒申	bar->dragging = Qnil;
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Same deal here as the other #if 0.  */
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申    /* Clicks on the handle are always reported as occurring at the top of
+
鐃緒申��申鐃緒申       the handle.  */
+
鐃緒申��申鐃緒申    if (emacs_event->part == scroll_bar_handle)
+
鐃緒申��申鐃緒申      emacs_event->x = bar->start;
+
鐃緒申��申鐃緒申    else
+
鐃緒申��申鐃緒申      XSETINT (emacs_event->x, y);
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申    XSETINT (emacs_event->x, y);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    XSETINT (emacs_event->y, top_range);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Handle some mouse motion while someone is dragging the scroll bar.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   This may be called from a signal handler, so we have to ignore GC
+
鐃緒申��申鐃緒申   mark bits.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_scroll_bar_note_movement (bar, event)
+
鐃緒申��申鐃緒申     struct scroll_bar *bar;
+
鐃緒申��申鐃緒申     XEvent *event;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  FRAME_PTR f = XFRAME (XWINDOW (bar->window)->frame);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  last_mouse_movement_time = event->xmotion.time;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  f->mouse_moved = 1;
+
鐃緒申��申鐃緒申  XSETVECTOR (last_mouse_scroll_bar, bar);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If we're dragging the bar, display it.  */
+
鐃緒申��申鐃緒申  if (! GC_NILP (bar->dragging))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Where should the handle be now?  */
+
鐃緒申��申鐃緒申      int new_start = event->xmotion.y - XINT (bar->dragging);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (new_start != XINT (bar->start))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  x_scroll_bar_set_handle (bar, new_start, new_end, 0);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* !USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return information to the user about the current position of the mouse
+
鐃緒申��申鐃緒申   on the scroll bar.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
+
鐃緒申��申鐃緒申     FRAME_PTR *fp;
+
鐃緒申��申鐃緒申     Lisp_Object *bar_window;
+
鐃緒申��申鐃緒申     enum scroll_bar_part *part;
+
鐃緒申��申鐃緒申     Lisp_Object *x, *y;
+
鐃緒申��申鐃緒申     unsigned long *time;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
+
鐃緒申��申鐃緒申  Window w = SCROLL_BAR_X_WINDOW (bar);
+
鐃緒申��申鐃緒申  FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+
鐃緒申��申鐃緒申  int win_x, win_y;
+
鐃緒申��申鐃緒申  Window dummy_window;
+
鐃緒申��申鐃緒申  int dummy_coord;
+
鐃緒申��申鐃緒申  unsigned int dummy_mask;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the mouse's position relative to the scroll bar window, and
+
鐃緒申��申鐃緒申     report that.  */
+
鐃緒申��申鐃緒申  if (! XQueryPointer (FRAME_X_DISPLAY (f), w,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		       /* Root, child, root x and root y.  */
+
鐃緒申��申鐃緒申		       &dummy_window, &dummy_window,
+
鐃緒申��申鐃緒申		       &dummy_coord, &dummy_coord,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		       /* Position relative to scroll bar.  */
+
鐃緒申��申鐃緒申		       &win_x, &win_y,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		       /* Mouse buttons and modifier keys.  */
+
鐃緒申��申鐃緒申		       &dummy_mask))
+
鐃緒申��申鐃緒申    ;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申      int inside_height
+
鐃緒申��申鐃緒申	= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申      int top_range
+
鐃緒申��申鐃緒申	= VERTICAL_SCROLL_BAR_TOP_RANGE     (f, XINT (bar->height));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (! NILP (bar->dragging))
+
鐃緒申��申鐃緒申	win_y -= XINT (bar->dragging);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (win_y < 0)
+
鐃緒申��申鐃緒申	win_y = 0;
+
鐃緒申��申鐃緒申      if (win_y > top_range)
+
鐃緒申��申鐃緒申	win_y = top_range;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      *fp = f;
+
鐃緒申��申鐃緒申      *bar_window = bar->window;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (! NILP (bar->dragging))
+
鐃緒申��申鐃緒申	*part = scroll_bar_handle;
+
鐃緒申��申鐃緒申      else if (win_y < XINT (bar->start))
+
鐃緒申��申鐃緒申	*part = scroll_bar_above_handle;
+
鐃緒申��申鐃緒申      else if (win_y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
+
鐃緒申��申鐃緒申	*part = scroll_bar_handle;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	*part = scroll_bar_below_handle;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      XSETINT (*x, win_y);
+
鐃緒申��申鐃緒申      XSETINT (*y, top_range);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      f->mouse_moved = 0;
+
鐃緒申��申鐃緒申      last_mouse_scroll_bar = Qnil;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  *time = last_mouse_movement_time;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The screen has been cleared so we may have changed foreground or
+
鐃緒申��申鐃緒申   background colors, and the scroll bars may need to be redrawn.
+
鐃緒申��申鐃緒申   Clear out the scroll bars, and ask for expose events, so we can
+
鐃緒申��申鐃緒申   redraw them.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_scroll_bar_clear (f)
+
鐃緒申��申鐃緒申     FRAME_PTR f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#ifndef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申  Lisp_Object bar;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We can have scroll bars even if this is 0,
+
鐃緒申��申鐃緒申     if we just turned off scroll bar mode.
+
鐃緒申��申鐃緒申     But in that case we should not clear them.  */
+
鐃緒申��申鐃緒申  if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+
鐃緒申��申鐃緒申    for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
+
鐃緒申��申鐃緒申	 bar = XSCROLL_BAR (bar)->next)
+
鐃緒申��申鐃緒申      XClearArea (FRAME_X_DISPLAY (f),
+
鐃緒申��申鐃緒申		  SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)),
+
鐃緒申��申鐃緒申		  0, 0, 0, 0, True);
+
鐃緒申��申鐃緒申#endif /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This processes Expose events from the menu-bar specific X event
+
鐃緒申��申鐃緒申   loop in xmenu.c.  This allows to redisplay the frame if necessary
+
鐃緒申��申鐃緒申   when handling menu-bar or pop-up items.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申process_expose_from_menu (event)
+
鐃緒申��申鐃緒申     XEvent event;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  FRAME_PTR f;
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申  int frame_exposed_p = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo = x_display_info_for_display (event.xexpose.display);
+
鐃緒申��申鐃緒申  f = x_window_to_frame (dpyinfo, event.xexpose.window);
+
鐃緒申��申鐃緒申  if (f)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (f->async_visible == 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  f->async_visible = 1;
+
鐃緒申��申鐃緒申	  f->async_iconified = 0;
+
鐃緒申��申鐃緒申	  f->output_data.x->has_been_visible = 1;
+
鐃緒申��申鐃緒申	  SET_FRAME_GARBAGED (f);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  expose_frame (x_window_to_frame (dpyinfo, event.xexpose.window),
+
鐃緒申��申鐃緒申			event.xexpose.x, event.xexpose.y,
+
鐃緒申��申鐃緒申			event.xexpose.width, event.xexpose.height);
+
鐃緒申��申鐃緒申	  frame_exposed_p = 1;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct scroll_bar *bar
+
鐃緒申��申鐃緒申	= x_window_to_scroll_bar (event.xexpose.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (bar)
+
鐃緒申��申鐃緒申	x_scroll_bar_expose (bar, &event);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申  return frame_exposed_p;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Define a queue to save up SelectionRequest events for later handling.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct selection_event_queue
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    XEvent event;
+
鐃緒申��申鐃緒申    struct selection_event_queue *next;
+
鐃緒申��申鐃緒申  };
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct selection_event_queue *queue;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Nonzero means queue up certain events--don't process them yet.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int x_queue_selection_requests;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Queue up an X event *EVENT, to be processed later.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_queue_event (f, event)
+
鐃緒申��申鐃緒申     FRAME_PTR f;
+
鐃緒申��申鐃緒申     XEvent *event;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct selection_event_queue *queue_tmp
+
鐃緒申��申鐃緒申    = (struct selection_event_queue *) xmalloc (sizeof (struct selection_event_queue));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (queue_tmp != NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      queue_tmp->event = *event;
+
鐃緒申��申鐃緒申      queue_tmp->next = queue;
+
鐃緒申��申鐃緒申      queue = queue_tmp;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Take all the queued events and put them back
+
鐃緒申��申鐃緒申   so that they get processed afresh.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_unqueue_events (display)
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  while (queue != NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct selection_event_queue *queue_tmp = queue;
+
鐃緒申��申鐃緒申      XPutBackEvent (display, &queue_tmp->event);
+
鐃緒申��申鐃緒申      queue = queue_tmp->next;
+
鐃緒申��申鐃緒申      xfree ((char *)queue_tmp);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Start queuing SelectionRequest events.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_start_queuing_selection_requests (display)
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  x_queue_selection_requests++;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Stop queuing SelectionRequest events.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_stop_queuing_selection_requests (display)
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  x_queue_selection_requests--;
+
鐃緒申��申鐃緒申  x_unqueue_events (display);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The main X event-reading loop - XTread_socket.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Time stamp of enter window event.  This is only used by XTread_socket,
+
鐃緒申��申鐃緒申   but we have to put it out here, since static variables within functions
+
鐃緒申��申鐃緒申   sometimes don't work.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Time enter_timestamp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This holds the state XLookupString needs to implement dead keys
+
鐃緒申��申鐃緒申   and other tricks known as "compose processing".  _X Window System_
+
鐃緒申��申鐃緒申   says that a portable program can't use this, but Stephen Gildea assures
+
鐃緒申��申鐃緒申   me that letting the compiler initialize it to zeros will work okay.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   This must be defined outside of XTread_socket, for the same reasons
+
鐃緒申��申鐃緒申   given for enter_time stamp, above.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static XComposeStatus compose_status;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Record the last 100 characters stored
+
鐃緒申��申鐃緒申   to help debug the loss-of-chars-during-GC problem.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int temp_index;
+
鐃緒申��申鐃緒申static short temp_buffer[100];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set this to nonzero to fake an "X I/O error"
+
鐃緒申��申鐃緒申   on a particular display.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct x_display_info *XTread_socket_fake_io_error;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* When we find no input here, we occasionally do a no-op command
+
鐃緒申��申鐃緒申   to verify that the X server is still running and we can still talk with it.
+
鐃緒申��申鐃緒申   We try all the open displays, one by one.
+
鐃緒申��申鐃緒申   This variable is used for cycling thru the displays.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct x_display_info *next_noop_dpyinfo;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define SET_SAVED_MENU_EVENT(size)					\
+
鐃緒申��申鐃緒申     do									\
+
鐃緒申��申鐃緒申       {								\
+
鐃緒申��申鐃緒申	 if (f->output_data.x->saved_menu_event == 0)			\
+
鐃緒申��申鐃緒申           f->output_data.x->saved_menu_event				\
+
鐃緒申��申鐃緒申	     = (XEvent *) xmalloc (sizeof (XEvent));			\
+
鐃緒申��申鐃緒申         bcopy (&event, f->output_data.x->saved_menu_event, size);	\
+
鐃緒申��申鐃緒申         if (numchars >= 1)						\
+
鐃緒申��申鐃緒申           {								\
+
鐃緒申��申鐃緒申             bufp->kind = menu_bar_activate_event;			\
+
鐃緒申��申鐃緒申             XSETFRAME (bufp->frame_or_window, f);			\
+
鐃緒申��申鐃緒申             bufp->arg = Qnil;						\
+
鐃緒申��申鐃緒申             bufp++;							\
+
鐃緒申��申鐃緒申             count++;							\
+
鐃緒申��申鐃緒申             numchars--;						\
+
鐃緒申��申鐃緒申           }								\
+
鐃緒申��申鐃緒申       }								\
+
鐃緒申��申鐃緒申     while (0)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
+
鐃緒申��申鐃緒申#define SET_SAVED_KEY_EVENT    SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Read events coming from the X server.
+
鐃緒申��申鐃緒申   This routine is called by the SIGIO handler.
+
鐃緒申��申鐃緒申   We return as soon as there are no more events to be read.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Events representing keys are stored in buffer BUFP,
+
鐃緒申��申鐃緒申   which can hold up to NUMCHARS characters.
+
鐃緒申��申鐃緒申   We return the number of characters stored into the buffer,
+
鐃緒申��申鐃緒申   thus pretending to be `read'.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   EXPECTED is nonzero if the caller knows input is available.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申XTread_socket (sd, bufp, numchars, expected)
+
鐃緒申��申鐃緒申     register int sd;
+
鐃緒申��申鐃緒申     /* register */ struct input_event *bufp;
+
鐃緒申��申鐃緒申     /* register */ int numchars;
+
鐃緒申��申鐃緒申     int expected;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int count = 0;
+
鐃緒申��申鐃緒申  int nbytes = 0;
+
鐃緒申��申鐃緒申  XEvent event;
+
鐃緒申��申鐃緒申  struct frame *f;
+
鐃緒申��申鐃緒申  int event_found = 0;
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申  struct coding_system coding;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (interrupt_input_blocked)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      interrupt_input_pending = 1;
+
鐃緒申��申鐃緒申      return -1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  interrupt_input_pending = 0;
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* So people can tell when we have read the available input.  */
+
鐃緒申��申鐃緒申  input_signal_count++;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (numchars <= 0)
+
鐃緒申��申鐃緒申    abort ();			/* Don't think this happens.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  ++handling_signal;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* The input should be decoded if it is from XIM.  Currently the
+
鐃緒申��申鐃緒申     locale of XIM is the same as that of the system.  So, we can use
+
鐃緒申��申鐃緒申     Vlocale_coding_system which is initialized properly at Emacs
+
鐃緒申��申鐃緒申     startup time.  */
+
鐃緒申��申鐃緒申  setup_coding_system (Vlocale_coding_system, &coding);
+
鐃緒申��申鐃緒申  coding.src_multibyte = 0;
+
鐃緒申��申鐃緒申  coding.dst_multibyte = 1;
+
鐃緒申��申鐃緒申  /* The input is converted to events, thus we can't handle
+
鐃緒申��申鐃緒申     composition.  Anyway, there's no XIM that gives us composition
+
鐃緒申��申鐃緒申     information.  */
+
鐃緒申��申鐃緒申  coding.composing = COMPOSITION_DISABLED;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Find the display we are supposed to read input for.
+
鐃緒申��申鐃緒申     It's the one communicating on descriptor SD.  */
+
鐃緒申��申鐃緒申  for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申#if 0 /* This ought to be unnecessary; let's verify it.  */
+
鐃緒申��申鐃緒申#ifdef FIOSNBIO
+
鐃緒申��申鐃緒申      /* If available, Xlib uses FIOSNBIO to make the socket
+
鐃緒申��申鐃緒申	 non-blocking, and then looks for EWOULDBLOCK.  If O_NDELAY is set,
+
鐃緒申��申鐃緒申	 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
+
鐃緒申��申鐃緒申	 a read returns 0, which Xlib interprets as equivalent to EPIPE.  */
+
鐃緒申��申鐃緒申      fcntl (dpyinfo->connection, F_SETFL, 0);
+
鐃緒申��申鐃緒申#endif /* ! defined (FIOSNBIO) */
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if 0 /* This code can't be made to work, with multiple displays,
+
鐃緒申��申鐃緒申	 and appears not to be used on any system any more.
+
鐃緒申��申鐃緒申	 Also keyboard.c doesn't turn O_NDELAY on and off
+
鐃緒申��申鐃緒申	 for X connections.  */
+
鐃緒申��申鐃緒申#ifndef SIGIO
+
鐃緒申��申鐃緒申#ifndef HAVE_SELECT
+
鐃緒申��申鐃緒申      if (! (fcntl (dpyinfo->connection, F_GETFL, 0) & O_NDELAY))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  extern int read_alarm_should_throw;
+
鐃緒申��申鐃緒申	  read_alarm_should_throw = 1;
+
鐃緒申��申鐃緒申	  XPeekEvent (dpyinfo->display, &event);
+
鐃緒申��申鐃緒申	  read_alarm_should_throw = 0;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申#endif /* HAVE_SELECT */
+
鐃緒申��申鐃緒申#endif /* SIGIO */
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* For debugging, this gives a way to fake an I/O error.  */
+
鐃緒申��申鐃緒申      if (dpyinfo == XTread_socket_fake_io_error)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  XTread_socket_fake_io_error = 0;
+
鐃緒申��申鐃緒申	  x_io_error_quitter (dpyinfo->display);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      while (XPending (dpyinfo->display))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  XNextEvent (dpyinfo->display, &event);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    /* Filter events for the current X input method.
+
鐃緒申��申鐃緒申	       XFilterEvent returns non-zero if the input method has
+
鐃緒申��申鐃緒申	       consumed the event.  We pass the frame's X window to
+
鐃緒申��申鐃緒申	       XFilterEvent because that's the one for which the IC
+
鐃緒申��申鐃緒申	       was created.  */
+
鐃緒申��申鐃緒申	    struct frame *f1 = x_any_window_to_frame (dpyinfo,
+
鐃緒申��申鐃緒申						      event.xclient.window);
+
鐃緒申��申鐃緒申	    if (XFilterEvent (&event, f1 ? FRAME_X_WINDOW (f1) : None))
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申	  event_found = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  switch (event.type)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	    case ClientMessage:
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		if (event.xclient.message_type
+
鐃緒申��申鐃緒申		    == dpyinfo->Xatom_wm_protocols
+
鐃緒申��申鐃緒申		    && event.xclient.format == 32)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    if (event.xclient.data.l[0]
+
鐃緒申��申鐃緒申			== dpyinfo->Xatom_wm_take_focus)
+
鐃緒申��申鐃緒申		      {
+
鐃緒申��申鐃緒申			/* Use x_any_window_to_frame because this
+
鐃緒申��申鐃緒申			   could be the shell widget window
+
鐃緒申��申鐃緒申			   if the frame has no title bar.  */
+
鐃緒申��申鐃緒申			f = x_any_window_to_frame (dpyinfo, event.xclient.window);
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申			/* Not quite sure this is needed -pd */
+
鐃緒申��申鐃緒申			if (f && FRAME_XIC (f))
+
鐃緒申��申鐃緒申			  XSetICFocus (FRAME_XIC (f));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#if 0 /* Emacs sets WM hints whose `input' field is `true'.  This
+
鐃緒申��申鐃緒申	 instructs the WM to set the input focus automatically for
+
鐃緒申��申鐃緒申	 Emacs with a call to XSetInputFocus.  Setting WM_TAKE_FOCUS
+
鐃緒申��申鐃緒申	 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
+
鐃緒申��申鐃緒申	 it has set the focus.  So, XSetInputFocus below is not
+
鐃緒申��申鐃緒申	 needed.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	 The call to XSetInputFocus below has also caused trouble.  In
+
鐃緒申��申鐃緒申	 cases where the XSetInputFocus done by the WM and the one
+
鐃緒申��申鐃緒申	 below are temporally close (on a fast machine), the call
+
鐃緒申��申鐃緒申	 below can generate additional FocusIn events which confuse
+
鐃緒申��申鐃緒申	 Emacs.  */
+
鐃緒申��申鐃緒申			
+
鐃緒申��申鐃緒申			/* Since we set WM_TAKE_FOCUS, we must call
+
鐃緒申��申鐃緒申			   XSetInputFocus explicitly.  But not if f is null,
+
鐃緒申��申鐃緒申			   since that might be an event for a deleted frame.  */
+
鐃緒申��申鐃緒申			if (f)
+
鐃緒申��申鐃緒申			  {
+
鐃緒申��申鐃緒申			    Display *d = event.xclient.display;
+
鐃緒申��申鐃緒申			    /* Catch and ignore errors, in case window has been
+
鐃緒申��申鐃緒申			       iconified by a window manager such as GWM.  */
+
鐃緒申��申鐃緒申			    int count = x_catch_errors (d);
+
鐃緒申��申鐃緒申			    XSetInputFocus (d, event.xclient.window,
+
鐃緒申��申鐃緒申					    /* The ICCCM says this is
+
鐃緒申��申鐃緒申					       the only valid choice.  */
+
鐃緒申��申鐃緒申					    RevertToParent,
+
鐃緒申��申鐃緒申					    event.xclient.data.l[1]);
+
鐃緒申��申鐃緒申			    /* This is needed to detect the error
+
鐃緒申��申鐃緒申			       if there is an error.  */
+
鐃緒申��申鐃緒申			    XSync (d, False);
+
鐃緒申��申鐃緒申			    x_uncatch_errors (d, count);
+
鐃緒申��申鐃緒申			  }  
+
鐃緒申��申鐃緒申			/* Not certain about handling scroll bars here */
+
鐃緒申��申鐃緒申#endif /* 0 */
+
鐃緒申��申鐃緒申		      }
+
鐃緒申��申鐃緒申		    else if (event.xclient.data.l[0]
+
鐃緒申��申鐃緒申			     == dpyinfo->Xatom_wm_save_yourself)
+
鐃緒申��申鐃緒申		      {
+
鐃緒申��申鐃緒申			/* Save state modify the WM_COMMAND property to
+
鐃緒申��申鐃緒申			   something which can reinstate us.  This notifies
+
鐃緒申��申鐃緒申			   the session manager, who's looking for such a
+
鐃緒申��申鐃緒申			   PropertyNotify.  Can restart processing when
+
鐃緒申��申鐃緒申			   a keyboard or mouse event arrives.  */
+
鐃緒申��申鐃緒申			if (numchars > 0)
+
鐃緒申��申鐃緒申			  {
+
鐃緒申��申鐃緒申			    f = x_top_window_to_frame (dpyinfo,
+
鐃緒申��申鐃緒申						       event.xclient.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			    /* This is just so we only give real data once
+
鐃緒申��申鐃緒申			       for a single Emacs process.  */
+
鐃緒申��申鐃緒申			    if (f == SELECTED_FRAME ())
+
鐃緒申��申鐃緒申			      XSetCommand (FRAME_X_DISPLAY (f),
+
鐃緒申��申鐃緒申					   event.xclient.window,
+
鐃緒申��申鐃緒申					   initial_argv, initial_argc);
+
鐃緒申��申鐃緒申			    else if (f)
+
鐃緒申��申鐃緒申			      XSetCommand (FRAME_X_DISPLAY (f),
+
鐃緒申��申鐃緒申					   event.xclient.window,
+
鐃緒申��申鐃緒申					   0, 0);
+
鐃緒申��申鐃緒申			  }
+
鐃緒申��申鐃緒申		      }
+
鐃緒申��申鐃緒申		    else if (event.xclient.data.l[0]
+
鐃緒申��申鐃緒申			     == dpyinfo->Xatom_wm_delete_window)
+
鐃緒申��申鐃緒申		      {
+
鐃緒申��申鐃緒申			struct frame *f
+
鐃緒申��申鐃緒申			  = x_any_window_to_frame (dpyinfo,
+
鐃緒申��申鐃緒申						   event.xclient.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			if (f)
+
鐃緒申��申鐃緒申			  {
+
鐃緒申��申鐃緒申			    if (numchars == 0)
+
鐃緒申��申鐃緒申			      abort ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			    bufp->kind = delete_window_event;
+
鐃緒申��申鐃緒申			    XSETFRAME (bufp->frame_or_window, f);
+
鐃緒申��申鐃緒申			    bufp->arg = Qnil;
+
鐃緒申��申鐃緒申			    bufp++;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			    count += 1;
+
鐃緒申��申鐃緒申			    numchars -= 1;
+
鐃緒申��申鐃緒申			  }
+
鐃緒申��申鐃緒申		      }
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申		else if (event.xclient.message_type
+
鐃緒申��申鐃緒申			 == dpyinfo->Xatom_wm_configure_denied)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申		else if (event.xclient.message_type
+
鐃緒申��申鐃緒申			 == dpyinfo->Xatom_wm_window_moved)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    int new_x, new_y;
+
鐃緒申��申鐃緒申		    struct frame *f
+
鐃緒申��申鐃緒申		      = x_window_to_frame (dpyinfo, event.xclient.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		    new_x = event.xclient.data.s[0];
+
鐃緒申��申鐃緒申		    new_y = event.xclient.data.s[1];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		    if (f)
+
鐃緒申��申鐃緒申		      {
+
鐃緒申��申鐃緒申			f->output_data.x->left_pos = new_x;
+
鐃緒申��申鐃緒申			f->output_data.x->top_pos = new_y;
+
鐃緒申��申鐃緒申		      }
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申#ifdef HACK_EDITRES
+
鐃緒申��申鐃緒申		else if (event.xclient.message_type
+
鐃緒申��申鐃緒申			 == dpyinfo->Xatom_editres)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    struct frame *f
+
鐃緒申��申鐃緒申		      = x_any_window_to_frame (dpyinfo, event.xclient.window);
+
鐃緒申��申鐃緒申		    _XEditResCheckMessages (f->output_data.x->widget, NULL,
+
鐃緒申��申鐃緒申					    &event, NULL);
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申#endif /* HACK_EDITRES */
+
鐃緒申��申鐃緒申		else if ((event.xclient.message_type
+
鐃緒申��申鐃緒申			  == dpyinfo->Xatom_DONE)
+
鐃緒申��申鐃緒申			 || (event.xclient.message_type
+
鐃緒申��申鐃緒申			     == dpyinfo->Xatom_PAGE))
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    /* Ghostview job completed.  Kill it.  We could
+
鐃緒申��申鐃緒申		       reply with "Next" if we received "Page", but we
+
鐃緒申��申鐃緒申		       currently never do because we are interested in
+
鐃緒申��申鐃緒申		       images, only, which should have 1 page.  */
+
鐃緒申��申鐃緒申		    Pixmap pixmap = (Pixmap) event.xclient.data.l[1];
+
鐃緒申��申鐃緒申		    struct frame *f
+
鐃緒申��申鐃緒申		      = x_window_to_frame (dpyinfo, event.xclient.window);
+
鐃緒申��申鐃緒申		    x_kill_gs_process (pixmap, f);
+
鐃緒申��申鐃緒申		    expose_frame (f, 0, 0, 0, 0);
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申		/* Scroll bar callbacks send a ClientMessage from which
+
鐃緒申��申鐃緒申		   we construct an input_event.  */
+
鐃緒申��申鐃緒申		else if (event.xclient.message_type
+
鐃緒申��申鐃緒申			 == dpyinfo->Xatom_Scrollbar)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    x_scroll_bar_to_input_event (&event, bufp);
+
鐃緒申��申鐃緒申		    ++bufp, ++count, --numchars;
+
鐃緒申��申鐃緒申		    goto out;
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申#endif /* USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申		else
+
鐃緒申��申鐃緒申		  goto OTHER;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case SelectionNotify:
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申	      if (! x_window_to_frame (dpyinfo, event.xselection.requestor))
+
鐃緒申��申鐃緒申		goto OTHER;
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申	      x_handle_selection_notify (&event.xselection);
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case SelectionClear:	/* Someone has grabbed ownership.  */
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申	      if (! x_window_to_frame (dpyinfo, event.xselectionclear.window))
+
鐃緒申��申鐃緒申		goto OTHER;
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		XSelectionClearEvent *eventp = (XSelectionClearEvent *) &event;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		if (numchars == 0)
+
鐃緒申��申鐃緒申		  abort ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		bufp->kind = selection_clear_event;
+
鐃緒申��申鐃緒申		SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
+
鐃緒申��申鐃緒申		SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
+
鐃緒申��申鐃緒申		SELECTION_EVENT_TIME (bufp) = eventp->time;
+
鐃緒申��申鐃緒申		bufp->frame_or_window = Qnil;
+
鐃緒申��申鐃緒申		bufp->arg = Qnil;
+
鐃緒申��申鐃緒申		bufp++;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		count += 1;
+
鐃緒申��申鐃緒申		numchars -= 1;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case SelectionRequest:	/* Someone wants our selection.  */
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申	      if (!x_window_to_frame (dpyinfo, event.xselectionrequest.owner))
+
鐃緒申��申鐃緒申		goto OTHER;
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申	      if (x_queue_selection_requests)
+
鐃緒申��申鐃緒申		x_queue_event (x_window_to_frame (dpyinfo, event.xselectionrequest.owner),
+
鐃緒申��申鐃緒申			       &event);
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  XSelectionRequestEvent *eventp = (XSelectionRequestEvent *) &event;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  if (numchars == 0)
+
鐃緒申��申鐃緒申		    abort ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  bufp->kind = selection_request_event;
+
鐃緒申��申鐃緒申		  SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
+
鐃緒申��申鐃緒申		  SELECTION_EVENT_REQUESTOR (bufp) = eventp->requestor;
+
鐃緒申��申鐃緒申		  SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
+
鐃緒申��申鐃緒申		  SELECTION_EVENT_TARGET (bufp) = eventp->target;
+
鐃緒申��申鐃緒申		  SELECTION_EVENT_PROPERTY (bufp) = eventp->property;
+
鐃緒申��申鐃緒申		  SELECTION_EVENT_TIME (bufp) = eventp->time;
+
鐃緒申��申鐃緒申		  bufp->frame_or_window = Qnil;
+
鐃緒申��申鐃緒申		  bufp->arg = Qnil;
+
鐃緒申��申鐃緒申		  bufp++;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  count += 1;
+
鐃緒申��申鐃緒申		  numchars -= 1;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case PropertyNotify:
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申	      if (!x_any_window_to_frame (dpyinfo, event.xproperty.window))
+
鐃緒申��申鐃緒申		goto OTHER;
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申	      x_handle_property_notify (&event.xproperty);
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case ReparentNotify:
+
鐃緒申��申鐃緒申	      f = x_top_window_to_frame (dpyinfo, event.xreparent.window);
+
鐃緒申��申鐃緒申	      if (f)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  int x, y;
+
鐃緒申��申鐃緒申		  f->output_data.x->parent_desc = event.xreparent.parent;
+
鐃緒申��申鐃緒申		  x_real_positions (f, &x, &y);
+
鐃緒申��申鐃緒申		  f->output_data.x->left_pos = x;
+
鐃緒申��申鐃緒申		  f->output_data.x->top_pos = y;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case Expose:
+
鐃緒申��申鐃緒申	      f = x_window_to_frame (dpyinfo, event.xexpose.window);
+
鐃緒申��申鐃緒申	      if (f)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  if (f->async_visible == 0)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      f->async_visible = 1;
+
鐃緒申��申鐃緒申		      f->async_iconified = 0;
+
鐃緒申��申鐃緒申		      f->output_data.x->has_been_visible = 1;
+
鐃緒申��申鐃緒申		      SET_FRAME_GARBAGED (f);
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  else
+
鐃緒申��申鐃緒申		    expose_frame (x_window_to_frame (dpyinfo,
+
鐃緒申��申鐃緒申						     event.xexpose.window),
+
鐃緒申��申鐃緒申				  event.xexpose.x, event.xexpose.y,
+
鐃緒申��申鐃緒申				  event.xexpose.width, event.xexpose.height);
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申#ifndef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申		  struct scroll_bar *bar;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#if defined USE_X_TOOLKIT && defined USE_LUCID
+
鐃緒申��申鐃緒申		  /* Submenus of the Lucid menu bar aren't widgets
+
鐃緒申��申鐃緒申		     themselves, so there's no way to dispatch events
+
鐃緒申��申鐃緒申		     to them.  Recognize this case separately.  */
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    Widget widget
+
鐃緒申��申鐃緒申		      = x_window_to_menu_bar (event.xexpose.window);
+
鐃緒申��申鐃緒申		    if (widget)
+
鐃緒申��申鐃緒申		      xlwmenu_redisplay (widget);
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT && USE_LUCID */
+
鐃緒申��申鐃緒申		  
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申		  /* Dispatch event to the widget.  */
+
鐃緒申��申鐃緒申		  goto OTHER;
+
鐃緒申��申鐃緒申#else /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申		  bar = x_window_to_scroll_bar (event.xexpose.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  if (bar)
+
鐃緒申��申鐃緒申		    x_scroll_bar_expose (bar, &event);
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申		  else
+
鐃緒申��申鐃緒申		    goto OTHER;
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申#endif /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case GraphicsExpose:	/* This occurs when an XCopyArea's
+
鐃緒申��申鐃緒申				      source area was obscured or not
+
鐃緒申��申鐃緒申				      available.*/
+
鐃緒申��申鐃緒申	      f = x_window_to_frame (dpyinfo, event.xgraphicsexpose.drawable);
+
鐃緒申��申鐃緒申	      if (f)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  expose_frame (f,
+
鐃緒申��申鐃緒申				event.xgraphicsexpose.x, event.xgraphicsexpose.y,
+
鐃緒申��申鐃緒申				event.xgraphicsexpose.width,
+
鐃緒申��申鐃緒申				event.xgraphicsexpose.height);
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		goto OTHER;
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case NoExpose:		/* This occurs when an XCopyArea's
+
鐃緒申��申鐃緒申					   source area was completely
+
鐃緒申��申鐃緒申					   available */
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case UnmapNotify:
+
鐃緒申��申鐃緒申	      /* Redo the mouse-highlight after the tooltip has gone.  */
+
鐃緒申��申鐃緒申	      if (event.xmap.window == tip_window)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  tip_window = 0;
+
鐃緒申��申鐃緒申		  redo_mouse_highlight ();
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申	      f = x_top_window_to_frame (dpyinfo, event.xunmap.window);
+
鐃緒申��申鐃緒申	      if (f)		/* F may no longer exist if
+
鐃緒申��申鐃緒申				       the frame was deleted.  */
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  /* While a frame is unmapped, display generation is
+
鐃緒申��申鐃緒申		     disabled; you don't want to spend time updating a
+
鐃緒申��申鐃緒申		     display that won't ever be seen.  */
+
鐃緒申��申鐃緒申		  f->async_visible = 0;
+
鐃緒申��申鐃緒申		  /* We can't distinguish, from the event, whether the window
+
鐃緒申��申鐃緒申		     has become iconified or invisible.  So assume, if it
+
鐃緒申��申鐃緒申		     was previously visible, than now it is iconified.
+
鐃緒申��申鐃緒申		     But x_make_frame_invisible clears both
+
鐃緒申��申鐃緒申		     the visible flag and the iconified flag;
+
鐃緒申��申鐃緒申		     and that way, we know the window is not iconified now.  */
+
鐃緒申��申鐃緒申		  if (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f))
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      f->async_iconified = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		      bufp->kind = iconify_event;
+
鐃緒申��申鐃緒申		      XSETFRAME (bufp->frame_or_window, f);
+
鐃緒申��申鐃緒申		      bufp->arg = Qnil;
+
鐃緒申��申鐃緒申		      bufp++;
+
鐃緒申��申鐃緒申		      count++;
+
鐃緒申��申鐃緒申		      numchars--;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case MapNotify:
+
鐃緒申��申鐃緒申	      if (event.xmap.window == tip_window)
+
鐃緒申��申鐃緒申		/* The tooltip has been drawn already.  Avoid
+
鐃緒申��申鐃緒申		   the SET_FRAME_GARBAGED below.  */
+
鐃緒申��申鐃緒申		goto OTHER;
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申	      /* We use x_top_window_to_frame because map events can
+
鐃緒申��申鐃緒申		 come for sub-windows and they don't mean that the
+
鐃緒申��申鐃緒申		 frame is visible.  */
+
鐃緒申��申鐃緒申	      f = x_top_window_to_frame (dpyinfo, event.xmap.window);
+
鐃緒申��申鐃緒申	      if (f)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  f->async_visible = 1;
+
鐃緒申��申鐃緒申		  f->async_iconified = 0;
+
鐃緒申��申鐃緒申		  f->output_data.x->has_been_visible = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  /* wait_reading_process_input will notice this and update
+
鐃緒申��申鐃緒申		     the frame's display structures.  */
+
鐃緒申��申鐃緒申		  SET_FRAME_GARBAGED (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  if (f->iconified)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      bufp->kind = deiconify_event;
+
鐃緒申��申鐃緒申		      XSETFRAME (bufp->frame_or_window, f);
+
鐃緒申��申鐃緒申		      bufp->arg = Qnil;
+
鐃緒申��申鐃緒申		      bufp++;
+
鐃緒申��申鐃緒申		      count++;
+
鐃緒申��申鐃緒申		      numchars--;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  else if (! NILP (Vframe_list)
+
鐃緒申��申鐃緒申			   && ! NILP (XCDR (Vframe_list)))
+
鐃緒申��申鐃緒申		    /* Force a redisplay sooner or later
+
鐃緒申��申鐃緒申		       to update the frame titles
+
鐃緒申��申鐃緒申		       in case this is the second frame.  */
+
鐃緒申��申鐃緒申		    record_asynch_buffer_change ();
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case KeyPress:
+
鐃緒申��申鐃緒申	      f = x_any_window_to_frame (dpyinfo, event.xkey.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申	      if (f == 0)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  /* Scroll bars consume key events, but we want
+
鐃緒申��申鐃緒申		     the keys to go to the scroll bar's frame.  */
+
鐃緒申��申鐃緒申		  Widget widget = XtWindowToWidget (dpyinfo->display,
+
鐃緒申��申鐃緒申						    event.xkey.window);
+
鐃緒申��申鐃緒申		  if (widget && XmIsScrollBar (widget))
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      widget = XtParent (widget);
+
鐃緒申��申鐃緒申		      f = x_any_window_to_frame (dpyinfo, XtWindow (widget));
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申#endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      if (f != 0)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  KeySym keysym, orig_keysym;
+
鐃緒申��申鐃緒申		  /* [e-mail] says that making this 81
+
鐃緒申��申鐃緒申		     instead of 80 fixed a bug whereby meta chars made
+
鐃緒申��申鐃緒申		     his Emacs hang.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		     It seems that some version of XmbLookupString has
+
鐃緒申��申鐃緒申		     a bug of not returning XBufferOverflow in
+
鐃緒申��申鐃緒申		     status_return even if the input is too long to
+
鐃緒申��申鐃緒申		     fit in 81 bytes.  So, we must prepare sufficient
+
鐃緒申��申鐃緒申		     bytes for copy_buffer.  513 bytes (256 chars for
+
鐃緒申��申鐃緒申		     two-byte character set) seems to be a faily good
+
鐃緒申��申鐃緒申		     approximation.  -- 2000.8.10 [e-mail]  */
+
鐃緒申��申鐃緒申		  unsigned char copy_buffer[513];
+
鐃緒申��申鐃緒申		  unsigned char *copy_bufptr = copy_buffer;
+
鐃緒申��申鐃緒申		  int copy_bufsiz = sizeof (copy_buffer);
+
鐃緒申��申鐃緒申		  int modifiers;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  event.xkey.state
+
鐃緒申��申鐃緒申		    |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f),
+
鐃緒申��申鐃緒申					       extra_keyboard_modifiers);
+
鐃緒申��申鐃緒申		  modifiers = event.xkey.state;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  /* This will have to go some day...  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  /* make_lispy_event turns chars into control chars.
+
鐃緒申��申鐃緒申		     Don't do it here because XLookupString is too eager.  */
+
鐃緒申��申鐃緒申		  event.xkey.state &= ~ControlMask;
+
鐃緒申��申鐃緒申		  event.xkey.state &= ~(dpyinfo->meta_mod_mask
+
鐃緒申��申鐃緒申					| dpyinfo->super_mod_mask
+
鐃緒申��申鐃緒申					| dpyinfo->hyper_mod_mask
+
鐃緒申��申鐃緒申					| dpyinfo->alt_mod_mask);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  /* In case Meta is ComposeCharacter,
+
鐃緒申��申鐃緒申		     clear its status.  According to Markus Ehrnsperger
+
鐃緒申��申鐃緒申		     [e-mail]
+
鐃緒申��申鐃緒申		     this enables ComposeCharacter to work whether or
+
鐃緒申��申鐃緒申		     not it is combined with Meta.  */
+
鐃緒申��申鐃緒申		  if (modifiers & dpyinfo->meta_mod_mask)
+
鐃緒申��申鐃緒申		    bzero (&compose_status, sizeof (compose_status));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申		  if (FRAME_XIC (f))
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      Status status_return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		      nbytes = XmbLookupString (FRAME_XIC (f),
+
鐃緒申��申鐃緒申						&event.xkey, copy_bufptr,
+
鐃緒申��申鐃緒申						copy_bufsiz, &keysym,
+
鐃緒申��申鐃緒申						&status_return);
+
鐃緒申��申鐃緒申		      if (status_return == XBufferOverflow)
+
鐃緒申��申鐃緒申			{
+
鐃緒申��申鐃緒申			  copy_bufsiz = nbytes + 1;
+
鐃緒申��申鐃緒申			  copy_bufptr = (char *) alloca (copy_bufsiz);
+
鐃緒申��申鐃緒申			  nbytes = XmbLookupString (FRAME_XIC (f),
+
鐃緒申��申鐃緒申						    &event.xkey, copy_bufptr,
+
鐃緒申��申鐃緒申						    copy_bufsiz, &keysym,
+
鐃緒申��申鐃緒申						    &status_return);
+
鐃緒申��申鐃緒申			}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		      if (status_return == XLookupNone)
+
鐃緒申��申鐃緒申			break;
+
鐃緒申��申鐃緒申		      else if (status_return == XLookupChars)
+
鐃緒申��申鐃緒申			{
+
鐃緒申��申鐃緒申			  keysym = NoSymbol;
+
鐃緒申��申鐃緒申			  modifiers = 0;
+
鐃緒申��申鐃緒申			}
+
鐃緒申��申鐃緒申		      else if (status_return != XLookupKeySym
+
鐃緒申��申鐃緒申			       && status_return != XLookupBoth)
+
鐃緒申��申鐃緒申			abort ();
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  else
+
鐃緒申��申鐃緒申		    nbytes = XLookupString (&event.xkey, copy_bufptr,
+
鐃緒申��申鐃緒申					    copy_bufsiz, &keysym,
+
鐃緒申��申鐃緒申					    &compose_status);
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申		  nbytes = XLookupString (&event.xkey, copy_bufptr,
+
鐃緒申��申鐃緒申					  copy_bufsiz, &keysym,
+
鐃緒申��申鐃緒申					  &compose_status);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  orig_keysym = keysym;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  if (numchars > 1)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
+
鐃緒申��申鐃緒申			   || keysym == XK_Delete
+
鐃緒申��申鐃緒申#ifdef XK_ISO_Left_Tab
+
鐃緒申��申鐃緒申			   || (keysym >= XK_ISO_Left_Tab && keysym <= XK_ISO_Enter)
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申			   || (keysym >= XK_Kanji && keysym <= XK_Eisu_toggle)
+
鐃緒申��申鐃緒申			   || IsCursorKey (keysym) /* 0xff50 <= x < 0xff60 */
+
鐃緒申��申鐃緒申			   || IsMiscFunctionKey (keysym) /* 0xff60 <= x < VARIES */
+
鐃緒申��申鐃緒申#ifdef HPUX
+
鐃緒申��申鐃緒申			   /* This recognizes the "extended function keys".
+
鐃緒申��申鐃緒申			      It seems there's no cleaner way.
+
鐃緒申��申鐃緒申			      Test IsModifierKey to avoid handling mode_switch
+
鐃緒申��申鐃緒申			      incorrectly.  */
+
鐃緒申��申鐃緒申			   || ((unsigned) (keysym) >= XK_Select
+
鐃緒申��申鐃緒申			       && (unsigned)(keysym) < XK_KP_Space)
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_circumflex
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_circumflex
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_grave
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_grave
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_tilde
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_tilde
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_diaeresis
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_diaeresis
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_macron
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_macron
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_degree
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_degree
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_acute
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_acute
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_cedilla
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_cedilla
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_breve
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_breve
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_ogonek
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_ogonek
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_caron
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_caron
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_doubleacute
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_doubleacute
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_dead_abovedot
+
鐃緒申��申鐃緒申			   || orig_keysym == XK_dead_abovedot
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申			   || IsKeypadKey (keysym) /* 0xff80 <= x < 0xffbe */
+
鐃緒申��申鐃緒申			   || IsFunctionKey (keysym) /* 0xffbe <= x < 0xffe1 */
+
鐃緒申��申鐃緒申			   /* Any "vendor-specific" key is ok.  */
+
鐃緒申��申鐃緒申			   || (orig_keysym & (1 << 28)))
+
鐃緒申��申鐃緒申			  && ! (IsModifierKey (orig_keysym)
+
鐃緒申��申鐃緒申#ifndef HAVE_X11R5
+
鐃緒申��申鐃緒申#ifdef XK_Mode_switch
+
鐃緒申��申鐃緒申				|| ((unsigned)(orig_keysym) == XK_Mode_switch)
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef XK_Num_Lock
+
鐃緒申��申鐃緒申				|| ((unsigned)(orig_keysym) == XK_Num_Lock)
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#endif /* not HAVE_X11R5 */
+
鐃緒申��申鐃緒申				))
+
鐃緒申��申鐃緒申			{
+
鐃緒申��申鐃緒申			  if (temp_index == sizeof temp_buffer / sizeof (short))
+
鐃緒申��申鐃緒申			    temp_index = 0;
+
鐃緒申��申鐃緒申			  temp_buffer[temp_index++] = keysym;
+
鐃緒申��申鐃緒申			  bufp->kind = non_ascii_keystroke;
+
鐃緒申��申鐃緒申			  bufp->code = keysym;
+
鐃緒申��申鐃緒申			  XSETFRAME (bufp->frame_or_window, f);
+
鐃緒申��申鐃緒申			  bufp->arg = Qnil;
+
鐃緒申��申鐃緒申			  bufp->modifiers
+
鐃緒申��申鐃緒申			    = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
+
鐃緒申��申鐃緒申						      modifiers);
+
鐃緒申��申鐃緒申			  bufp->timestamp = event.xkey.time;
+
鐃緒申��申鐃緒申			  bufp++;
+
鐃緒申��申鐃緒申			  count++;
+
鐃緒申��申鐃緒申			  numchars--;
+
鐃緒申��申鐃緒申			}
+
鐃緒申��申鐃緒申		      else if (numchars > nbytes)
+
鐃緒申��申鐃緒申			{
+
鐃緒申��申鐃緒申			  register int i;
+
鐃緒申��申鐃緒申			  register int c;
+
鐃緒申��申鐃緒申			  int nchars, len;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			  for (i = 0; i < nbytes; i++)
+
鐃緒申��申鐃緒申			    {
+
鐃緒申��申鐃緒申			      if (temp_index == (sizeof temp_buffer
+
鐃緒申��申鐃緒申						 / sizeof (short)))
+
鐃緒申��申鐃緒申				temp_index = 0;
+
鐃緒申��申鐃緒申			      temp_buffer[temp_index++] = copy_bufptr[i];
+
鐃緒申��申鐃緒申			    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			  if (/* If the event is not from XIM, */
+
鐃緒申��申鐃緒申			      event.xkey.keycode != 0
+
鐃緒申��申鐃緒申			      /* or the current locale doesn't request
+
鐃緒申��申鐃緒申				 decoding of the intup data, ... */
+
鐃緒申��申鐃緒申			      || coding.type == coding_type_raw_text
+
鐃緒申��申鐃緒申			      || coding.type == coding_type_no_conversion)
+
鐃緒申��申鐃緒申			    {
+
鐃緒申��申鐃緒申			      /* ... we can use the input data as is.  */
+
鐃緒申��申鐃緒申			      nchars = nbytes;
+
鐃緒申��申鐃緒申			    }
+
鐃緒申��申鐃緒申			  else
+
鐃緒申��申鐃緒申			    { 
+
鐃緒申��申鐃緒申			      /* We have to decode the input data.  */
+
鐃緒申��申鐃緒申			      int require;
+
鐃緒申��申鐃緒申			      unsigned char *p;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			      require = decoding_buffer_size (&coding, nbytes);
+
鐃緒申��申鐃緒申			      p = (unsigned char *) alloca (require);
+
鐃緒申��申鐃緒申			      coding.mode |= CODING_MODE_LAST_BLOCK;
+
鐃緒申��申鐃緒申			      decode_coding (&coding, copy_bufptr, p,
+
鐃緒申��申鐃緒申					     nbytes, require);
+
鐃緒申��申鐃緒申			      nbytes = coding.produced;
+
鐃緒申��申鐃緒申			      nchars = coding.produced_char;
+
鐃緒申��申鐃緒申			      copy_bufptr = p;
+
鐃緒申��申鐃緒申			    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			  /* Convert the input data to a sequence of
+
鐃緒申��申鐃緒申			     character events.  */
+
鐃緒申��申鐃緒申			  for (i = 0; i < nbytes; i += len)
+
鐃緒申��申鐃緒申			    {
+
鐃緒申��申鐃緒申			      c = STRING_CHAR_AND_LENGTH (copy_bufptr + i,
+
鐃緒申��申鐃緒申							  nbytes - i, len);
+
鐃緒申��申鐃緒申			      bufp->kind = (SINGLE_BYTE_CHAR_P (c)
+
鐃緒申��申鐃緒申					    ? ascii_keystroke
+
鐃緒申��申鐃緒申					    : multibyte_char_keystroke);
+
鐃緒申��申鐃緒申			      bufp->code = c;
+
鐃緒申��申鐃緒申			      XSETFRAME (bufp->frame_or_window, f);
+
鐃緒申��申鐃緒申			      bufp->arg = Qnil;
+
鐃緒申��申鐃緒申			      bufp->modifiers
+
鐃緒申��申鐃緒申				= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
+
鐃緒申��申鐃緒申							  modifiers);
+
鐃緒申��申鐃緒申			      bufp->timestamp = event.xkey.time;
+
鐃緒申��申鐃緒申			      bufp++;
+
鐃緒申��申鐃緒申			    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			  count += nchars;
+
鐃緒申��申鐃緒申			  numchars -= nchars;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			  if (keysym == NoSymbol)
+
鐃緒申��申鐃緒申			    break;
+
鐃緒申��申鐃緒申			}
+
鐃緒申��申鐃緒申		      else
+
鐃緒申��申鐃緒申			abort ();
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  else
+
鐃緒申��申鐃緒申		    abort ();
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申	      /* Don't dispatch this event since XtDispatchEvent calls
+
鐃緒申��申鐃緒申		 XFilterEvent, and two calls in a row may freeze the
+
鐃緒申��申鐃緒申		 client.  */
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case KeyRelease:
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申	      /* Don't dispatch this event since XtDispatchEvent calls
+
鐃緒申��申鐃緒申		 XFilterEvent, and two calls in a row may freeze the
+
鐃緒申��申鐃緒申		 client.  */
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      /* Here's a possible interpretation of the whole
+
鐃緒申��申鐃緒申		 FocusIn-EnterNotify FocusOut-LeaveNotify mess.  If
+
鐃緒申��申鐃緒申		 you get a FocusIn event, you have to get a FocusOut
+
鐃緒申��申鐃緒申		 event before you relinquish the focus.  If you
+
鐃緒申��申鐃緒申		 haven't received a FocusIn event, then a mere
+
鐃緒申��申鐃緒申		 LeaveNotify is enough to free you.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case EnterNotify:
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		f = x_any_window_to_frame (dpyinfo, event.xcrossing.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		if (event.xcrossing.focus)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    /* Avoid nasty pop/raise loops.  */
+
鐃緒申��申鐃緒申		    if (f && (!(f->auto_raise)
+
鐃緒申��申鐃緒申			      || !(f->auto_lower)
+
鐃緒申��申鐃緒申			      || (event.xcrossing.time - enter_timestamp) > 500))
+
鐃緒申��申鐃緒申		      {
+
鐃緒申��申鐃緒申			x_new_focus_frame (dpyinfo, f);
+
鐃緒申��申鐃緒申			enter_timestamp = event.xcrossing.time;
+
鐃緒申��申鐃緒申		      }
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申		else if (f == dpyinfo->x_focus_frame)
+
鐃緒申��申鐃緒申		  x_new_focus_frame (dpyinfo, 0);
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申		/* EnterNotify counts as mouse movement,
+
鐃緒申��申鐃緒申		   so update things that depend on mouse position.  */
+
鐃緒申��申鐃緒申		if (f && !f->output_data.x->hourglass_p)
+
鐃緒申��申鐃緒申		  note_mouse_movement (f, &event.xmotion);
+
鐃緒申��申鐃緒申		goto OTHER;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case FocusIn:
+
鐃緒申��申鐃緒申	      f = x_any_window_to_frame (dpyinfo, event.xfocus.window);
+
鐃緒申��申鐃緒申	      if (event.xfocus.detail != NotifyPointer)
+
鐃緒申��申鐃緒申		dpyinfo->x_focus_event_frame = f;
+
鐃緒申��申鐃緒申	      if (f)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  x_new_focus_frame (dpyinfo, f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  /* Don't stop displaying the initial startup message
+
鐃緒申��申鐃緒申		     for a switch-frame event we don't need.  */
+
鐃緒申��申鐃緒申		  if (GC_NILP (Vterminal_frame)
+
鐃緒申��申鐃緒申		      && GC_CONSP (Vframe_list)
+
鐃緒申��申鐃緒申		      && !GC_NILP (XCDR (Vframe_list)))
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      bufp->kind = FOCUS_IN_EVENT;
+
鐃緒申��申鐃緒申		      XSETFRAME (bufp->frame_or_window, f);
+
鐃緒申��申鐃緒申		      bufp->arg = Qnil;
+
鐃緒申��申鐃緒申		      ++bufp, ++count, --numchars;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申	      if (f && FRAME_XIC (f))
+
鐃緒申��申鐃緒申		XSetICFocus (FRAME_XIC (f));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case LeaveNotify:
+
鐃緒申��申鐃緒申	      f = x_top_window_to_frame (dpyinfo, event.xcrossing.window);
+
鐃緒申��申鐃緒申	      if (f)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  if (f == dpyinfo->mouse_face_mouse_frame)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      /* If we move outside the frame, then we're
+
鐃緒申��申鐃緒申			 certainly no longer on any text in the frame.  */
+
鐃緒申��申鐃緒申		      clear_mouse_face (dpyinfo);
+
鐃緒申��申鐃緒申		      dpyinfo->mouse_face_mouse_frame = 0;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  /* Generate a nil HELP_EVENT to cancel a help-echo.
+
鐃緒申��申鐃緒申		     Do it only if there's something to cancel.
+
鐃緒申��申鐃緒申		     Otherwise, the startup message is cleared when
+
鐃緒申��申鐃緒申		     the mouse leaves the frame.  */
+
鐃緒申��申鐃緒申		  if (any_help_event_p)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      Lisp_Object frame;
+
鐃緒申��申鐃緒申		      int n;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		      XSETFRAME (frame, f);
+
鐃緒申��申鐃緒申		      help_echo = Qnil;
+
鐃緒申��申鐃緒申		      n = gen_help_event (bufp, numchars,
+
鐃緒申��申鐃緒申					  Qnil, frame, Qnil, Qnil, 0);
+
鐃緒申��申鐃緒申		      bufp += n, count += n, numchars -= n;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  if (event.xcrossing.focus)
+
鐃緒申��申鐃緒申		    x_mouse_leave (dpyinfo);
+
鐃緒申��申鐃緒申		  else
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      if (f == dpyinfo->x_focus_event_frame)
+
鐃緒申��申鐃緒申			dpyinfo->x_focus_event_frame = 0;
+
鐃緒申��申鐃緒申		      if (f == dpyinfo->x_focus_frame)
+
鐃緒申��申鐃緒申			x_new_focus_frame (dpyinfo, 0);
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case FocusOut:
+
鐃緒申��申鐃緒申	      f = x_any_window_to_frame (dpyinfo, event.xfocus.window);
+
鐃緒申��申鐃緒申	      if (event.xfocus.detail != NotifyPointer
+
鐃緒申��申鐃緒申		  && f == dpyinfo->x_focus_event_frame)
+
鐃緒申��申鐃緒申		dpyinfo->x_focus_event_frame = 0;
+
鐃緒申��申鐃緒申	      if (f && f == dpyinfo->x_focus_frame)
+
鐃緒申��申鐃緒申		x_new_focus_frame (dpyinfo, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申	      if (f && FRAME_XIC (f))
+
鐃緒申��申鐃緒申		XUnsetICFocus (FRAME_XIC (f));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case MotionNotify:
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		previous_help_echo = help_echo;
+
鐃緒申��申鐃緒申		help_echo = help_echo_object = help_echo_window = Qnil;
+
鐃緒申��申鐃緒申		help_echo_pos = -1;
+
鐃緒申��申鐃緒申		
+
鐃緒申��申鐃緒申		if (dpyinfo->grabbed && last_mouse_frame
+
鐃緒申��申鐃緒申		    && FRAME_LIVE_P (last_mouse_frame))
+
鐃緒申��申鐃緒申		  f = last_mouse_frame;
+
鐃緒申��申鐃緒申		else
+
鐃緒申��申鐃緒申		  f = x_window_to_frame (dpyinfo, event.xmotion.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		if (f)
+
鐃緒申��申鐃緒申		  note_mouse_movement (f, &event.xmotion);
+
鐃緒申��申鐃緒申		else
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申#ifndef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申		    struct scroll_bar *bar
+
鐃緒申��申鐃緒申		      = x_window_to_scroll_bar (event.xmotion.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		    if (bar)
+
鐃緒申��申鐃緒申		      x_scroll_bar_note_movement (bar, &event);
+
鐃緒申��申鐃緒申#endif /* USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		    /* If we move outside the frame, then we're
+
鐃緒申��申鐃緒申		       certainly no longer on any text in the frame.  */
+
鐃緒申��申鐃緒申		    clear_mouse_face (dpyinfo);
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		/* If the contents of the global variable help_echo
+
鐃緒申��申鐃緒申		   has changed, generate a HELP_EVENT.  */
+
鐃緒申��申鐃緒申		if (!NILP (help_echo)
+
鐃緒申��申鐃緒申		    || !NILP (previous_help_echo))
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    Lisp_Object frame;
+
鐃緒申��申鐃緒申		    int n;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		    if (f)
+
鐃緒申��申鐃緒申		      XSETFRAME (frame, f);
+
鐃緒申��申鐃緒申		    else
+
鐃緒申��申鐃緒申		      frame = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		    any_help_event_p = 1;
+
鐃緒申��申鐃緒申		    n = gen_help_event (bufp, numchars, help_echo, frame,
+
鐃緒申��申鐃緒申					help_echo_window, help_echo_object,
+
鐃緒申��申鐃緒申					help_echo_pos);
+
鐃緒申��申鐃緒申		    bufp += n, count += n, numchars -= n;
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申		
+
鐃緒申��申鐃緒申		goto OTHER;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case ConfigureNotify:
+
鐃緒申��申鐃緒申	      f = x_top_window_to_frame (dpyinfo, event.xconfigure.window);
+
鐃緒申��申鐃緒申	      if (f)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申#ifndef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申		  int rows = PIXEL_TO_CHAR_HEIGHT (f, event.xconfigure.height);
+
鐃緒申��申鐃緒申		  int columns = PIXEL_TO_CHAR_WIDTH (f, event.xconfigure.width);
+
鐃緒申��申鐃緒申		  
+
鐃緒申��申鐃緒申		  /* In the toolkit version, change_frame_size
+
鐃緒申��申鐃緒申		     is called by the code that handles resizing
+
鐃緒申��申鐃緒申		     of the EmacsFrame widget.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  /* Even if the number of character rows and columns has
+
鐃緒申��申鐃緒申		     not changed, the font size may have changed, so we need
+
鐃緒申��申鐃緒申		     to check the pixel dimensions as well.  */
+
鐃緒申��申鐃緒申		  if (columns != f->width
+
鐃緒申��申鐃緒申		      || rows != f->height
+
鐃緒申��申鐃緒申		      || event.xconfigure.width != f->output_data.x->pixel_width
+
鐃緒申��申鐃緒申		      || event.xconfigure.height != f->output_data.x->pixel_height)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      change_frame_size (f, rows, columns, 0, 1, 0);
+
鐃緒申��申鐃緒申		      SET_FRAME_GARBAGED (f);
+
鐃緒申��申鐃緒申		      cancel_mouse_face (f);
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  f->output_data.x->pixel_width = event.xconfigure.width;
+
鐃緒申��申鐃緒申		  f->output_data.x->pixel_height = event.xconfigure.height;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  /* What we have now is the position of Emacs's own window.
+
鐃緒申��申鐃緒申		     Convert that to the position of the window manager window.  */
+
鐃緒申��申鐃緒申		  x_real_positions (f, &f->output_data.x->left_pos,
+
鐃緒申��申鐃緒申				    &f->output_data.x->top_pos);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申		  if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMStatusArea))
+
鐃緒申��申鐃緒申		    xic_set_statusarea (f);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		  if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      /* Since the WM decorations come below top_pos now,
+
鐃緒申��申鐃緒申			 we must put them below top_pos in the future.  */
+
鐃緒申��申鐃緒申		      f->output_data.x->win_gravity = NorthWestGravity;
+
鐃緒申��申鐃緒申		      x_wm_set_size_hint (f, (long) 0, 0);
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申#ifdef USE_MOTIF
+
鐃緒申��申鐃緒申		  /* Some window managers pass (0,0) as the location of
+
鐃緒申��申鐃緒申		     the window, and the Motif event handler stores it
+
鐃緒申��申鐃緒申		     in the emacs widget, which messes up Motif menus.  */
+
鐃緒申��申鐃緒申		  if (event.xconfigure.x == 0 && event.xconfigure.y == 0)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      event.xconfigure.x = f->output_data.x->widget->core.x;
+
鐃緒申��申鐃緒申		      event.xconfigure.y = f->output_data.x->widget->core.y;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申#endif /* USE_MOTIF */
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case ButtonPress:
+
鐃緒申��申鐃緒申	    case ButtonRelease:
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		/* If we decide we want to generate an event to be seen
+
鐃緒申��申鐃緒申		   by the rest of Emacs, we put it here.  */
+
鐃緒申��申鐃緒申		struct input_event emacs_event;
+
鐃緒申��申鐃緒申		int tool_bar_p = 0;
+
鐃緒申��申鐃緒申		
+
鐃緒申��申鐃緒申		emacs_event.kind = no_event;
+
鐃緒申��申鐃緒申		bzero (&compose_status, sizeof (compose_status));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		if (dpyinfo->grabbed
+
鐃緒申��申鐃緒申		    && last_mouse_frame
+
鐃緒申��申鐃緒申		    && FRAME_LIVE_P (last_mouse_frame))
+
鐃緒申��申鐃緒申		  f = last_mouse_frame;
+
鐃緒申��申鐃緒申		else
+
鐃緒申��申鐃緒申		  f = x_window_to_frame (dpyinfo, event.xbutton.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		if (f)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    /* Is this in the tool-bar?  */
+
鐃緒申��申鐃緒申		    if (WINDOWP (f->tool_bar_window)
+
鐃緒申��申鐃緒申			&& XFASTINT (XWINDOW (f->tool_bar_window)->height))
+
鐃緒申��申鐃緒申		      {
+
鐃緒申��申鐃緒申			Lisp_Object window;
+
鐃緒申��申鐃緒申			int p, x, y;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			x = event.xbutton.x;
+
鐃緒申��申鐃緒申			y = event.xbutton.y;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申			/* Set x and y.  */
+
鐃緒申��申鐃緒申			window = window_from_coordinates (f, x, y, &p, 1);
+
鐃緒申��申鐃緒申			if (EQ (window, f->tool_bar_window))
+
鐃緒申��申鐃緒申			  {
+
鐃緒申��申鐃緒申			    x_handle_tool_bar_click (f, &event.xbutton);
+
鐃緒申��申鐃緒申			    tool_bar_p = 1;
+
鐃緒申��申鐃緒申			  }
+
鐃緒申��申鐃緒申		      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		    if (!tool_bar_p)
+
鐃緒申��申鐃緒申		      if (!dpyinfo->x_focus_frame
+
鐃緒申��申鐃緒申			  || f == dpyinfo->x_focus_frame)
+
鐃緒申��申鐃緒申			construct_mouse_click (&emacs_event, &event, f);
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申		else
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申#ifndef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申		    struct scroll_bar *bar
+
鐃緒申��申鐃緒申		      = x_window_to_scroll_bar (event.xbutton.window);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		    if (bar)
+
鐃緒申��申鐃緒申		      x_scroll_bar_handle_click (bar, &event, &emacs_event);
+
鐃緒申��申鐃緒申#endif /* not USE_TOOLKIT_SCROLL_BARS */
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		if (event.type == ButtonPress)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    dpyinfo->grabbed |= (1 << event.xbutton.button);
+
鐃緒申��申鐃緒申		    last_mouse_frame = f;
+
鐃緒申��申鐃緒申		    /* Ignore any mouse motion that happened
+
鐃緒申��申鐃緒申		       before this event; any subsequent mouse-movement
+
鐃緒申��申鐃緒申		       Emacs events should reflect only motion after
+
鐃緒申��申鐃緒申		       the ButtonPress.  */
+
鐃緒申��申鐃緒申		    if (f != 0)
+
鐃緒申��申鐃緒申		      f->mouse_moved = 0;
+
鐃緒申��申鐃緒申		    
+
鐃緒申��申鐃緒申		    if (!tool_bar_p)
+
鐃緒申��申鐃緒申		      last_tool_bar_item = -1;
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申		else
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    dpyinfo->grabbed &= ~(1 << event.xbutton.button);
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		if (numchars >= 1 && emacs_event.kind != no_event)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    bcopy (&emacs_event, bufp, sizeof (struct input_event));
+
鐃緒申��申鐃緒申		    bufp++;
+
鐃緒申��申鐃緒申		    count++;
+
鐃緒申��申鐃緒申		    numchars--;
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申		f = x_menubar_window_to_frame (dpyinfo, event.xbutton.window);
+
鐃緒申��申鐃緒申		/* For a down-event in the menu bar,
+
鐃緒申��申鐃緒申		   don't pass it to Xt right now.
+
鐃緒申��申鐃緒申		   Instead, save it away
+
鐃緒申��申鐃緒申		   and we will pass it to Xt from kbd_buffer_get_event.
+
鐃緒申��申鐃緒申		   That way, we can run some Lisp code first.  */
+
鐃緒申��申鐃緒申		if (f && event.type == ButtonPress
+
鐃緒申��申鐃緒申		    /* Verify the event is really within the menu bar
+
鐃緒申��申鐃緒申		       and not just sent to it due to grabbing.  */
+
鐃緒申��申鐃緒申		    && event.xbutton.x >= 0
+
鐃緒申��申鐃緒申		    && event.xbutton.x < f->output_data.x->pixel_width
+
鐃緒申��申鐃緒申		    && event.xbutton.y >= 0
+
鐃緒申��申鐃緒申		    && event.xbutton.y < f->output_data.x->menubar_height
+
鐃緒申��申鐃緒申		    && event.xbutton.same_screen)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    SET_SAVED_BUTTON_EVENT;
+
鐃緒申��申鐃緒申		    XSETFRAME (last_mouse_press_frame, f);
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申		else if (event.type == ButtonPress)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    last_mouse_press_frame = Qnil;
+
鐃緒申��申鐃緒申		    goto OTHER;
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_MOTIF /* This should do not harm for Lucid,
+
鐃緒申��申鐃緒申		    but I am trying to be cautious.  */
+
鐃緒申��申鐃緒申		else if (event.type == ButtonRelease)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    if (!NILP (last_mouse_press_frame))
+
鐃緒申��申鐃緒申		      {
+
鐃緒申��申鐃緒申			f = XFRAME (last_mouse_press_frame);
+
鐃緒申��申鐃緒申			if (f->output_data.x)
+
鐃緒申��申鐃緒申			  SET_SAVED_BUTTON_EVENT;
+
鐃緒申��申鐃緒申		      }
+
鐃緒申��申鐃緒申		    else
+
鐃緒申��申鐃緒申		      goto OTHER;
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申#endif /* USE_MOTIF */
+
鐃緒申��申鐃緒申		else
+
鐃緒申��申鐃緒申		  goto OTHER;
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case CirculateNotify:
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申	    case CirculateRequest:
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case VisibilityNotify:
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    case MappingNotify:
+
鐃緒申��申鐃緒申	      /* Someone has changed the keyboard mapping - update the
+
鐃緒申��申鐃緒申		 local cache.  */
+
鐃緒申��申鐃緒申	      switch (event.xmapping.request)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		case MappingModifier:
+
鐃緒申��申鐃緒申		  x_find_modifier_meanings (dpyinfo);
+
鐃緒申��申鐃緒申		  /* This is meant to fall through.  */
+
鐃緒申��申鐃緒申		case MappingKeyboard:
+
鐃緒申��申鐃緒申		  XRefreshKeyboardMapping (&event.xmapping);
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      goto OTHER;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	    default:
+
鐃緒申��申鐃緒申	    OTHER:
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申	      BLOCK_INPUT;
+
鐃緒申��申鐃緒申	      XtDispatchEvent (&event);
+
鐃緒申��申鐃緒申	      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申 out:;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* On some systems, an X bug causes Emacs to get no more events
+
鐃緒申��申鐃緒申     when the window is destroyed.  Detect that.  (1994.)  */
+
鐃緒申��申鐃緒申  if (! event_found)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
+
鐃緒申��申鐃緒申	 One XNOOP in 100 loops will make Emacs terminate.
+
鐃緒申��申鐃緒申	 B. Bretthauer, 1994 */
+
鐃緒申��申鐃緒申      x_noop_count++;
+
鐃緒申��申鐃緒申      if (x_noop_count >= 100)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x_noop_count=0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (next_noop_dpyinfo == 0)
+
鐃緒申��申鐃緒申	    next_noop_dpyinfo = x_display_list;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  XNoOp (next_noop_dpyinfo->display);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Each time we get here, cycle through the displays now open.  */
+
鐃緒申��申鐃緒申	  next_noop_dpyinfo = next_noop_dpyinfo->next;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If the focus was just given to an auto-raising frame,
+
鐃緒申��申鐃緒申     raise it now.  */
+
鐃緒申��申鐃緒申  /* ??? This ought to be able to handle more than one such frame.  */
+
鐃緒申��申鐃緒申  if (pending_autoraise_frame)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_raise_frame (pending_autoraise_frame);
+
鐃緒申��申鐃緒申      pending_autoraise_frame = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申  --handling_signal;
+
鐃緒申��申鐃緒申  return count;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			     Text Cursor
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Note if the text cursor of window W has been overwritten by a
+
鐃緒申��申鐃緒申   drawing operation that outputs N glyphs starting at HPOS in the
+
鐃緒申��申鐃緒申   line given by output_cursor.vpos.  N < 0 means all the rest of the
+
鐃緒申��申鐃緒申   line after HPOS has been written.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申note_overwritten_text_cursor (w, hpos, n)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int hpos, n;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (updated_area == TEXT_AREA
+
鐃緒申��申鐃緒申      && output_cursor.vpos == w->phys_cursor.vpos
+
鐃緒申��申鐃緒申      && hpos <= w->phys_cursor.hpos
+
鐃緒申��申鐃緒申      && (n < 0
+
鐃緒申��申鐃緒申	  || hpos + n > w->phys_cursor.hpos))
+
鐃緒申��申鐃緒申    w->phys_cursor_on_p = 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set clipping for output in glyph row ROW.  W is the window in which
+
鐃緒申��申鐃緒申   we operate.  GC is the graphics context to set clipping in.
+
鐃緒申��申鐃緒申   WHOLE_LINE_P non-zero means include the areas used for truncation
+
鐃緒申��申鐃緒申   mark display and alike in the clipping rectangle.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   ROW may be a text row or, e.g., a mode line.  Text rows must be
+
鐃緒申��申鐃緒申   clipped to the interior of the window dedicated to text display,
+
鐃緒申��申鐃緒申   mode lines must be clipped to the whole window.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_clip_to_row (w, row, gc, whole_line_p)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     GC gc;
+
鐃緒申��申鐃緒申     int whole_line_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (WINDOW_FRAME (w));
+
鐃緒申��申鐃緒申  XRectangle clip_rect;
+
鐃緒申��申鐃緒申  int window_x, window_y, window_width, window_height;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  clip_rect.x = WINDOW_TO_FRAME_PIXEL_X (w, 0);
+
鐃緒申��申鐃緒申  clip_rect.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
+
鐃緒申��申鐃緒申  clip_rect.y = max (clip_rect.y, window_y);
+
鐃緒申��申鐃緒申  clip_rect.width = window_width;
+
鐃緒申��申鐃緒申  clip_rect.height = row->visible_height;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If clipping to the whole line, including trunc marks, extend
+
鐃緒申��申鐃緒申     the rectangle to the left and increase its width.  */
+
鐃緒申��申鐃緒申  if (whole_line_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      clip_rect.x -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
+
鐃緒申��申鐃緒申      clip_rect.width += FRAME_X_FLAGS_AREA_WIDTH (f);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, &clip_rect, 1, Unsorted);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw a hollow box cursor on window W in glyph row ROW.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_hollow_cursor (w, row)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (WINDOW_FRAME (w));
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  Display *dpy = FRAME_X_DISPLAY (f);
+
鐃緒申��申鐃緒申  int x, y, wd, h;
+
鐃緒申��申鐃緒申  XGCValues xgcv;
+
鐃緒申��申鐃緒申  struct glyph *cursor_glyph;
+
鐃緒申��申鐃緒申  GC gc;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Compute frame-relative coordinates from window-relative
+
鐃緒申��申鐃緒申     coordinates.  */
+
鐃緒申��申鐃緒申  x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
+
鐃緒申��申鐃緒申  y = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
+
鐃緒申��申鐃緒申       + row->ascent - w->phys_cursor_ascent);
+
鐃緒申��申鐃緒申  h = row->height - 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the glyph the cursor is on.  If we can't tell because
+
鐃緒申��申鐃緒申     the current matrix is invalid or such, give up.  */
+
鐃緒申��申鐃緒申  cursor_glyph = get_phys_cursor_glyph (w);
+
鐃緒申��申鐃緒申  if (cursor_glyph == NULL)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Compute the width of the rectangle to draw.  If on a stretch
+
鐃緒申��申鐃緒申     glyph, and `x-stretch-block-cursor' is nil, don't draw a
+
鐃緒申��申鐃緒申     rectangle as wide as the glyph, but use a canonical character
+
鐃緒申��申鐃緒申     width instead.  */
+
鐃緒申��申鐃緒申  wd = cursor_glyph->pixel_width - 1;
+
鐃緒申��申鐃緒申  if (cursor_glyph->type == STRETCH_GLYPH
+
鐃緒申��申鐃緒申      && !x_stretch_cursor_p)
+
鐃緒申��申鐃緒申    wd = min (CANON_X_UNIT (f), wd);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* The foreground of cursor_gc is typically the same as the normal
+
鐃緒申��申鐃緒申     background color, which can cause the cursor box to be invisible.  */
+
鐃緒申��申鐃緒申  xgcv.foreground = f->output_data.x->cursor_pixel;
+
鐃緒申��申鐃緒申  if (dpyinfo->scratch_cursor_gc)
+
鐃緒申��申鐃緒申    XChangeGC (dpy, dpyinfo->scratch_cursor_gc, GCForeground, &xgcv);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    dpyinfo->scratch_cursor_gc = XCreateGC (dpy, FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申					    GCForeground, &xgcv);
+
鐃緒申��申鐃緒申  gc = dpyinfo->scratch_cursor_gc;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Set clipping, draw the rectangle, and reset clipping again.  */
+
鐃緒申��申鐃緒申  x_clip_to_row (w, row, gc, 0);
+
鐃緒申��申鐃緒申  XDrawRectangle (dpy, FRAME_X_WINDOW (f), gc, x, y, wd, h);
+
鐃緒申��申鐃緒申  XSetClipMask (dpy, gc, None);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw a bar cursor on window W in glyph row ROW.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Implementation note: One would like to draw a bar cursor with an
+
鐃緒申��申鐃緒申   angle equal to the one given by the font property XA_ITALIC_ANGLE.
+
鐃緒申��申鐃緒申   Unfortunately, I didn't find a font yet that has this property set.
+
鐃緒申��申鐃緒申   --gerd.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_bar_cursor (w, row, width)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     int width;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  struct glyph *cursor_glyph;
+
鐃緒申��申鐃緒申  GC gc;
+
鐃緒申��申鐃緒申  int x;
+
鐃緒申��申鐃緒申  unsigned long mask;
+
鐃緒申��申鐃緒申  XGCValues xgcv;
+
鐃緒申��申鐃緒申  Display *dpy;
+
鐃緒申��申鐃緒申  Window window;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申  /* If cursor is out of bounds, don't draw garbage.  This can happen
+
鐃緒申��申鐃緒申     in mini-buffer windows when switching between echo area glyphs
+
鐃緒申��申鐃緒申     and mini-buffer.  */
+
鐃緒申��申鐃緒申  cursor_glyph = get_phys_cursor_glyph (w);
+
鐃緒申��申鐃緒申  if (cursor_glyph == NULL)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If on an image, draw like a normal cursor.  That's usually better
+
鐃緒申��申鐃緒申     visible than drawing a bar, esp. if the image is large so that
+
鐃緒申��申鐃緒申     the bar might not be in the window.  */
+
鐃緒申��申鐃緒申  if (cursor_glyph->type == IMAGE_GLYPH)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct glyph_row *row;
+
鐃緒申��申鐃緒申      row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
+
鐃緒申��申鐃緒申      x_draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      xgcv.background = f->output_data.x->cursor_pixel;
+
鐃緒申��申鐃緒申      xgcv.foreground = f->output_data.x->cursor_pixel;
+
鐃緒申��申鐃緒申      xgcv.graphics_exposures = 0;
+
鐃緒申��申鐃緒申      mask = GCForeground | GCBackground | GCGraphicsExposures;
+
鐃緒申��申鐃緒申      dpy = FRAME_X_DISPLAY (f);
+
鐃緒申��申鐃緒申      window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申      gc = FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申      if (gc)
+
鐃緒申��申鐃緒申	XChangeGC (dpy, gc, mask, &xgcv);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  gc = XCreateGC (dpy, window, mask, &xgcv);
+
鐃緒申��申鐃緒申	  FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc = gc;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申      if (width < 0)
+
鐃緒申��申鐃緒申	width = f->output_data.x->cursor_width;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申      x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
+
鐃緒申��申鐃緒申      x_clip_to_row (w, row, gc, 0);
+
鐃緒申��申鐃緒申      XFillRectangle (dpy, window, gc,
+
鐃緒申��申鐃緒申		      x,
+
鐃緒申��申鐃緒申		      WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
+
鐃緒申��申鐃緒申		      min (cursor_glyph->pixel_width, width),
+
鐃緒申��申鐃緒申		      row->height);
+
鐃緒申��申鐃緒申      XSetClipMask (dpy, gc, None);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Clear the cursor of window W to background color, and mark the
+
鐃緒申��申鐃緒申   cursor as not shown.  This is used when the text where the cursor
+
鐃緒申��申鐃緒申   is is about to be rewritten.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_clear_cursor (w)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (FRAME_VISIBLE_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
+
鐃緒申��申鐃緒申    x_update_window_cursor (w, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Draw the cursor glyph of window W in glyph row ROW.  See the
+
鐃緒申��申鐃緒申   comment of x_draw_glyphs for the meaning of HL.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_draw_phys_cursor_glyph (w, row, hl)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     struct glyph_row *row;
+
鐃緒申��申鐃緒申     enum draw_glyphs_face hl;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* If cursor hpos is out of bounds, don't draw garbage.  This can
+
鐃緒申��申鐃緒申     happen in mini-buffer windows when switching between echo area
+
鐃緒申��申鐃緒申     glyphs and mini-buffer.  */
+
鐃緒申��申鐃緒申  if (w->phys_cursor.hpos < row->used[TEXT_AREA])
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
+
鐃緒申��申鐃緒申		     w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
+
鐃緒申��申鐃緒申		     hl, 0, 0, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* When we erase the cursor, and ROW is overlapped by other
+
鐃緒申��申鐃緒申	 rows, make sure that these overlapping parts of other rows
+
鐃緒申��申鐃緒申	 are redrawn.  */
+
鐃緒申��申鐃緒申      if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (row > w->current_matrix->rows
+
鐃緒申��申鐃緒申	      && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
+
鐃緒申��申鐃緒申	    x_fix_overlapping_area (w, row - 1, TEXT_AREA);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
+
鐃緒申��申鐃緒申	      && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
+
鐃緒申��申鐃緒申	    x_fix_overlapping_area (w, row + 1, TEXT_AREA);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Erase the image of a cursor of window W from the screen.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_erase_phys_cursor (w)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  int hpos = w->phys_cursor.hpos;
+
鐃緒申��申鐃緒申  int vpos = w->phys_cursor.vpos;
+
鐃緒申��申鐃緒申  int mouse_face_here_p = 0;
+
鐃緒申��申鐃緒申  struct glyph_matrix *active_glyphs = w->current_matrix;
+
鐃緒申��申鐃緒申  struct glyph_row *cursor_row;
+
鐃緒申��申鐃緒申  struct glyph *cursor_glyph;
+
鐃緒申��申鐃緒申  enum draw_glyphs_face hl;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* No cursor displayed or row invalidated => nothing to do on the
+
鐃緒申��申鐃緒申     screen.  */
+
鐃緒申��申鐃緒申  if (w->phys_cursor_type == NO_CURSOR)
+
鐃緒申��申鐃緒申    goto mark_cursor_off;
+
鐃緒申��申鐃緒申	   
+
鐃緒申��申鐃緒申  /* VPOS >= active_glyphs->nrows means that window has been resized.
+
鐃緒申��申鐃緒申     Don't bother to erase the cursor.  */
+
鐃緒申��申鐃緒申  if (vpos >= active_glyphs->nrows)
+
鐃緒申��申鐃緒申    goto mark_cursor_off;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If row containing cursor is marked invalid, there is nothing we
+
鐃緒申��申鐃緒申     can do.  */
+
鐃緒申��申鐃緒申  cursor_row = MATRIX_ROW (active_glyphs, vpos);
+
鐃緒申��申鐃緒申  if (!cursor_row->enabled_p)
+
鐃緒申��申鐃緒申    goto mark_cursor_off;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* This can happen when the new row is shorter than the old one.
+
鐃緒申��申鐃緒申     In this case, either x_draw_glyphs or clear_end_of_line
+
鐃緒申��申鐃緒申     should have cleared the cursor.  Note that we wouldn't be
+
鐃緒申��申鐃緒申     able to erase the cursor in this case because we don't have a
+
鐃緒申��申鐃緒申     cursor glyph at hand.  */
+
鐃緒申��申鐃緒申  if (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])
+
鐃緒申��申鐃緒申    goto mark_cursor_off;
+
鐃緒申��申鐃緒申	 
+
鐃緒申��申鐃緒申  /* If the cursor is in the mouse face area, redisplay that when
+
鐃緒申��申鐃緒申     we clear the cursor.  */
+
鐃緒申��申鐃緒申  if (! NILP (dpyinfo->mouse_face_window)
+
鐃緒申��申鐃緒申      && w == XWINDOW (dpyinfo->mouse_face_window)
+
鐃緒申��申鐃緒申      && (vpos > dpyinfo->mouse_face_beg_row
+
鐃緒申��申鐃緒申	  || (vpos == dpyinfo->mouse_face_beg_row
+
鐃緒申��申鐃緒申	      && hpos >= dpyinfo->mouse_face_beg_col))
+
鐃緒申��申鐃緒申      && (vpos < dpyinfo->mouse_face_end_row
+
鐃緒申��申鐃緒申	  || (vpos == dpyinfo->mouse_face_end_row
+
鐃緒申��申鐃緒申	      && hpos < dpyinfo->mouse_face_end_col))
+
鐃緒申��申鐃緒申      /* Don't redraw the cursor's spot in mouse face if it is at the
+
鐃緒申��申鐃緒申	 end of a line (on a newline).  The cursor appears there, but
+
鐃緒申��申鐃緒申	 mouse highlighting does not.  */
+
鐃緒申��申鐃緒申      && cursor_row->used[TEXT_AREA] > hpos)
+
鐃緒申��申鐃緒申    mouse_face_here_p = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Maybe clear the display under the cursor.  */
+
鐃緒申��申鐃緒申  if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int x;
+
鐃緒申��申鐃緒申      int header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      cursor_glyph = get_phys_cursor_glyph (w);
+
鐃緒申��申鐃緒申      if (cursor_glyph == NULL)
+
鐃緒申��申鐃緒申	goto mark_cursor_off;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		    x,
+
鐃緒申��申鐃緒申		    WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
+
鐃緒申��申鐃緒申						     cursor_row->y)),
+
鐃緒申��申鐃緒申		    cursor_glyph->pixel_width,
+
鐃緒申��申鐃緒申		    cursor_row->visible_height,
+
鐃緒申��申鐃緒申		    False);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Erase the cursor by redrawing the character underneath it.  */
+
鐃緒申��申鐃緒申  if (mouse_face_here_p)
+
鐃緒申��申鐃緒申    hl = DRAW_MOUSE_FACE;
+
鐃緒申��申鐃緒申  else if (cursor_row->inverse_p)
+
鐃緒申��申鐃緒申    hl = DRAW_INVERSE_VIDEO;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    hl = DRAW_NORMAL_TEXT;
+
鐃緒申��申鐃緒申  x_draw_phys_cursor_glyph (w, cursor_row, hl);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申 mark_cursor_off:
+
鐃緒申��申鐃緒申  w->phys_cursor_on_p = 0;
+
鐃緒申��申鐃緒申  w->phys_cursor_type = NO_CURSOR;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Display or clear cursor of window W.  If ON is zero, clear the
+
鐃緒申��申鐃緒申   cursor.  If it is non-zero, display the cursor.  If ON is nonzero,
+
鐃緒申��申鐃緒申   where to put the cursor is specified by HPOS, VPOS, X and Y.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_display_and_set_cursor (w, on, hpos, vpos, x, y)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int on, hpos, vpos, x, y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct frame *f = XFRAME (w->frame);
+
鐃緒申��申鐃緒申  int new_cursor_type;
+
鐃緒申��申鐃緒申  int new_cursor_width;
+
鐃緒申��申鐃緒申  struct glyph_matrix *current_glyphs;
+
鐃緒申��申鐃緒申  struct glyph_row *glyph_row;
+
鐃緒申��申鐃緒申  struct glyph *glyph;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* This is pointless on invisible frames, and dangerous on garbaged
+
鐃緒申��申鐃緒申     windows and frames; in the latter case, the frame or window may
+
鐃緒申��申鐃緒申     be in the midst of changing its size, and x and y may be off the
+
鐃緒申��申鐃緒申     window.  */
+
鐃緒申��申鐃緒申  if (! FRAME_VISIBLE_P (f)
+
鐃緒申��申鐃緒申      || FRAME_GARBAGED_P (f)
+
鐃緒申��申鐃緒申      || vpos >= w->current_matrix->nrows
+
鐃緒申��申鐃緒申      || hpos >= w->current_matrix->matrix_w)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If cursor is off and we want it off, return quickly.  */
+
鐃緒申��申鐃緒申  if (!on && !w->phys_cursor_on_p)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  current_glyphs = w->current_matrix;
+
鐃緒申��申鐃緒申  glyph_row = MATRIX_ROW (current_glyphs, vpos);
+
鐃緒申��申鐃緒申  glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* If cursor row is not enabled, we don't really know where to 
+
鐃緒申��申鐃緒申     display the cursor.  */
+
鐃緒申��申鐃緒申  if (!glyph_row->enabled_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      w->phys_cursor_on_p = 0;
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (interrupt_input_blocked);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Set new_cursor_type to the cursor we want to be displayed.  In a
+
鐃緒申��申鐃緒申     mini-buffer window, we want the cursor only to appear if we are
+
鐃緒申��申鐃緒申     reading input from this window.  For the selected window, we want
+
鐃緒申��申鐃緒申     the cursor type given by the frame parameter.  If explicitly
+
鐃緒申��申鐃緒申     marked off, draw no cursor.  In all other cases, we want a hollow
+
鐃緒申��申鐃緒申     box cursor.  */
+
鐃緒申��申鐃緒申  new_cursor_width = -1;
+
鐃緒申��申鐃緒申  if (cursor_in_echo_area
+
鐃緒申��申鐃緒申      && FRAME_HAS_MINIBUF_P (f)
+
鐃緒申��申鐃緒申      && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (w == XWINDOW (echo_area_window))
+
鐃緒申��申鐃緒申	new_cursor_type = FRAME_DESIRED_CURSOR (f);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	new_cursor_type = HOLLOW_BOX_CURSOR;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (f != FRAME_X_DISPLAY_INFO (f)->x_highlight_frame
+
鐃緒申��申鐃緒申	  || w != XWINDOW (f->selected_window))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  extern int cursor_in_non_selected_windows;
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  if (MINI_WINDOW_P (w)
+
鐃緒申��申鐃緒申	      || !cursor_in_non_selected_windows
+
鐃緒申��申鐃緒申	      || NILP (XBUFFER (w->buffer)->cursor_type))
+
鐃緒申��申鐃緒申	    new_cursor_type = NO_CURSOR;
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    new_cursor_type = HOLLOW_BOX_CURSOR;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else if (w->cursor_off_p)
+
鐃緒申��申鐃緒申	new_cursor_type = NO_CURSOR;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  struct buffer *b = XBUFFER (w->buffer);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (EQ (b->cursor_type, Qt))
+
鐃緒申��申鐃緒申	    new_cursor_type = FRAME_DESIRED_CURSOR (f);
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    new_cursor_type = x_specified_cursor_type (b->cursor_type, 
+
鐃緒申��申鐃緒申						       &new_cursor_width);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If cursor is currently being shown and we don't want it to be or
+
鐃緒申��申鐃緒申     it is in the wrong place, or the cursor type is not what we want,
+
鐃緒申��申鐃緒申     erase it.  */
+
鐃緒申��申鐃緒申  if (w->phys_cursor_on_p
+
鐃緒申��申鐃緒申      && (!on
+
鐃緒申��申鐃緒申	  || w->phys_cursor.x != x
+
鐃緒申��申鐃緒申	  || w->phys_cursor.y != y
+
鐃緒申��申鐃緒申	  || new_cursor_type != w->phys_cursor_type))
+
鐃緒申��申鐃緒申    x_erase_phys_cursor (w);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If the cursor is now invisible and we want it to be visible,
+
鐃緒申��申鐃緒申     display it.  */
+
鐃緒申��申鐃緒申  if (on && !w->phys_cursor_on_p)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      w->phys_cursor_ascent = glyph_row->ascent;
+
鐃緒申��申鐃緒申      w->phys_cursor_height = glyph_row->height;
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Set phys_cursor_.* before x_draw_.* is called because some
+
鐃緒申��申鐃緒申	 of them may need the information.  */
+
鐃緒申��申鐃緒申      w->phys_cursor.x = x;
+
鐃緒申��申鐃緒申      w->phys_cursor.y = glyph_row->y;
+
鐃緒申��申鐃緒申      w->phys_cursor.hpos = hpos;
+
鐃緒申��申鐃緒申      w->phys_cursor.vpos = vpos;
+
鐃緒申��申鐃緒申      w->phys_cursor_type = new_cursor_type;
+
鐃緒申��申鐃緒申      w->phys_cursor_on_p = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      switch (new_cursor_type)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	case HOLLOW_BOX_CURSOR:
+
鐃緒申��申鐃緒申	  x_draw_hollow_cursor (w, glyph_row);
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	case FILLED_BOX_CURSOR:
+
鐃緒申��申鐃緒申	  x_draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	case BAR_CURSOR:
+
鐃緒申��申鐃緒申	  x_draw_bar_cursor (w, glyph_row, new_cursor_width);
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	case NO_CURSOR:
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	default:
+
鐃緒申��申鐃緒申	  abort ();
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申      if (w == XWINDOW (f->selected_window))
+
鐃緒申��申鐃緒申	if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMPreeditPosition))
+
鐃緒申��申鐃緒申	  xic_set_preeditarea (w, x, y);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef XFlush
+
鐃緒申��申鐃緒申  if (updating_frame != f)
+
鐃緒申��申鐃緒申    XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Display the cursor on window W, or clear it.  X and Y are window
+
鐃緒申��申鐃緒申   relative pixel coordinates.  HPOS and VPOS are glyph matrix
+
鐃緒申��申鐃緒申   positions.  If W is not the selected window, display a hollow
+
鐃緒申��申鐃緒申   cursor.  ON non-zero means display the cursor at X, Y which
+
鐃緒申��申鐃緒申   correspond to HPOS, VPOS, otherwise it is cleared.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_display_cursor (w, on, hpos, vpos, x, y)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int on, hpos, vpos, x, y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  x_display_and_set_cursor (w, on, hpos, vpos, x, y);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Display the cursor on window W, or clear it, according to ON_P.
+
鐃緒申��申鐃緒申   Don't change the cursor's position.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_update_cursor (f, on_p)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  x_update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Call x_update_window_cursor with parameter ON_P on all leaf windows
+
鐃緒申��申鐃緒申   in the window tree rooted at W.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_update_cursor_in_window_tree (w, on_p)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int on_p;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  while (w)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (!NILP (w->hchild))
+
鐃緒申��申鐃緒申	x_update_cursor_in_window_tree (XWINDOW (w->hchild), on_p);
+
鐃緒申��申鐃緒申      else if (!NILP (w->vchild))
+
鐃緒申��申鐃緒申	x_update_cursor_in_window_tree (XWINDOW (w->vchild), on_p);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	x_update_window_cursor (w, on_p);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      w = NILP (w->next) ? 0 : XWINDOW (w->next);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Switch the display of W's cursor on or off, according to the value
+
鐃緒申��申鐃緒申   of ON.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_update_window_cursor (w, on)
+
鐃緒申��申鐃緒申     struct window *w;
+
鐃緒申��申鐃緒申     int on;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Don't update cursor in windows whose frame is in the process
+
鐃緒申��申鐃緒申     of being deleted.  */
+
鐃緒申��申鐃緒申  if (w->current_matrix)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申      x_display_and_set_cursor (w, on, w->phys_cursor.hpos, w->phys_cursor.vpos,
+
鐃緒申��申鐃緒申				w->phys_cursor.x, w->phys_cursor.y);
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Icons.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Refresh bitmap kitchen sink icon for frame F
+
鐃緒申��申鐃緒申   when we get an expose event for it.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申refreshicon (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Normally, the window manager handles this function.  */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Make the x-window of frame F use the gnu icon bitmap.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申x_bitmap_icon (f, file)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     Lisp_Object file;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int bitmap_id;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (FRAME_X_WINDOW (f) == 0)
+
鐃緒申��申鐃緒申    return 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Free up our existing icon bitmap if any.  */
+
鐃緒申��申鐃緒申  if (f->output_data.x->icon_bitmap > 0)
+
鐃緒申��申鐃緒申    x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
+
鐃緒申��申鐃緒申  f->output_data.x->icon_bitmap = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (STRINGP (file))
+
鐃緒申��申鐃緒申    bitmap_id = x_create_bitmap_from_file (f, file);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Create the GNU bitmap if necessary.  */
+
鐃緒申��申鐃緒申      if (FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id < 0)
+
鐃緒申��申鐃緒申	FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id
+
鐃緒申��申鐃緒申	  = x_create_bitmap_from_data (f, gnu_bits,
+
鐃緒申��申鐃緒申				       gnu_width, gnu_height);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* The first time we create the GNU bitmap,
+
鐃緒申��申鐃緒申	 this increments the ref-count one extra time.
+
鐃緒申��申鐃緒申	 As a result, the GNU bitmap is never freed.
+
鐃緒申��申鐃緒申	 That way, we don't have to worry about allocating it again.  */
+
鐃緒申��申鐃緒申      x_reference_bitmap (f, FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      bitmap_id = FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  x_wm_set_icon_pixmap (f, bitmap_id);
+
鐃緒申��申鐃緒申  f->output_data.x->icon_bitmap = bitmap_id;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Make the x-window of frame F use a rectangle with text.
+
鐃緒申��申鐃緒申   Use ICON_NAME as the text.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申x_text_icon (f, icon_name)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     char *icon_name;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (FRAME_X_WINDOW (f) == 0)
+
鐃緒申��申鐃緒申    return 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R4
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    XTextProperty text;
+
鐃緒申��申鐃緒申    text.value = (unsigned char *) icon_name;
+
鐃緒申��申鐃緒申    text.encoding = XA_STRING;
+
鐃緒申��申鐃緒申    text.format = 8;
+
鐃緒申��申鐃緒申    text.nitems = strlen (icon_name);
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申    XSetWMIconName (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget),
+
鐃緒申��申鐃緒申		    &text);
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申    XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &text);
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申#else /* not HAVE_X11R4 */
+
鐃緒申��申鐃緒申  XSetIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), icon_name);
+
鐃緒申��申鐃緒申#endif /* not HAVE_X11R4 */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (f->output_data.x->icon_bitmap > 0)
+
鐃緒申��申鐃緒申    x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
+
鐃緒申��申鐃緒申  f->output_data.x->icon_bitmap = 0;
+
鐃緒申��申鐃緒申  x_wm_set_icon_pixmap (f, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define X_ERROR_MESSAGE_SIZE 200
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* If non-nil, this should be a string.
+
鐃緒申��申鐃緒申   It means catch X errors  and store the error message in this string.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object x_error_message_string;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* An X error handler which stores the error message in
+
鐃緒申��申鐃緒申   x_error_message_string.  This is called from x_error_handler if
+
鐃緒申��申鐃緒申   x_catch_errors is in effect.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_error_catcher (display, error)
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申     XErrorEvent *error;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XGetErrorText (display, error->error_code,
+
鐃緒申��申鐃緒申		 XSTRING (x_error_message_string)->data,
+
鐃緒申��申鐃緒申		 X_ERROR_MESSAGE_SIZE);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Begin trapping X errors for display DPY.  Actually we trap X errors
+
鐃緒申��申鐃緒申   for all displays, but DPY should be the display you are actually
+
鐃緒申��申鐃緒申   operating on.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   After calling this function, X protocol errors no longer cause
+
鐃緒申��申鐃緒申   Emacs to exit; instead, they are recorded in the string
+
鐃緒申��申鐃緒申   stored in x_error_message_string.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Calling x_check_errors signals an Emacs error if an X error has
+
鐃緒申��申鐃緒申   occurred since the last call to x_catch_errors or x_check_errors.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Calling x_uncatch_errors resumes the normal error handling.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void x_check_errors ();
+
鐃緒申��申鐃緒申static Lisp_Object x_catch_errors_unwind ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申x_catch_errors (dpy)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int count = specpdl_ptr - specpdl;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Make sure any errors from previous requests have been dealt with.  */
+
鐃緒申��申鐃緒申  XSync (dpy, False);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  record_unwind_protect (x_catch_errors_unwind, x_error_message_string);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  x_error_message_string = make_uninit_string (X_ERROR_MESSAGE_SIZE);
+
鐃緒申��申鐃緒申  XSTRING (x_error_message_string)->data[0] = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return count;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Unbind the binding that we made to check for X errors.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object
+
鐃緒申��申鐃緒申x_catch_errors_unwind (old_val)
+
鐃緒申��申鐃緒申     Lisp_Object old_val;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  x_error_message_string = old_val;
+
鐃緒申��申鐃緒申  return Qnil;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* If any X protocol errors have arrived since the last call to
+
鐃緒申��申鐃緒申   x_catch_errors or x_check_errors, signal an Emacs error using
+
鐃緒申��申鐃緒申   sprintf (a buffer, FORMAT, the x error message text) as the text.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_check_errors (dpy, format)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申     char *format;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Make sure to catch any errors incurred so far.  */
+
鐃緒申��申鐃緒申  XSync (dpy, False);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (XSTRING (x_error_message_string)->data[0])
+
鐃緒申��申鐃緒申    error (format, XSTRING (x_error_message_string)->data);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Nonzero if we had any X protocol errors
+
鐃緒申��申鐃緒申   since we did x_catch_errors on DPY.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申x_had_errors_p (dpy)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Make sure to catch any errors incurred so far.  */
+
鐃緒申��申鐃緒申  XSync (dpy, False);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return XSTRING (x_error_message_string)->data[0] != 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Forget about any errors we have had, since we did x_catch_errors on DPY.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_clear_errors (dpy)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XSTRING (x_error_message_string)->data[0] = 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Stop catching X protocol errors and let them make Emacs die.
+
鐃緒申��申鐃緒申   DPY should be the display that was passed to x_catch_errors.
+
鐃緒申��申鐃緒申   COUNT should be the value that was returned by
+
鐃緒申��申鐃緒申   the corresponding call to x_catch_errors.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_uncatch_errors (dpy, count)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申     int count;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  unbind_to (count, Qnil);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申static unsigned int x_wire_count;
+
鐃緒申��申鐃緒申x_trace_wire ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  fprintf (stderr, "Lib call: %d\n", ++x_wire_count);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申#endif /* ! 0 */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Handle SIGPIPE, which can happen when the connection to a server
+
鐃緒申��申鐃緒申   simply goes away.  SIGPIPE is handled by x_connection_signal.
+
鐃緒申��申鐃緒申   Don't need to do anything, because the write which caused the 
+
鐃緒申��申鐃緒申   SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
+
鐃緒申��申鐃緒申   which will do the appropriate cleanup for us.  */
+
鐃緒申��申鐃緒申   
+
鐃緒申��申鐃緒申static SIGTYPE
+
鐃緒申��申鐃緒申x_connection_signal (signalnum)	/* If we don't have an argument, */
+
鐃緒申��申鐃緒申     int signalnum;		/* some compilers complain in signal calls.  */
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#ifdef USG
+
鐃緒申��申鐃緒申  /* USG systems forget handlers when they are used;
+
鐃緒申��申鐃緒申     must reestablish each time */
+
鐃緒申��申鐃緒申  signal (signalnum, x_connection_signal);
+
鐃緒申��申鐃緒申#endif /* USG */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/************************************************************************
+
鐃緒申��申鐃緒申			  Handling X errors
+
鐃緒申��申鐃緒申 ************************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Handle the loss of connection to display DPY.  ERROR_MESSAGE is
+
鐃緒申��申鐃緒申   the text of an error message that lead to the connection loss.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static SIGTYPE
+
鐃緒申��申鐃緒申x_connection_closed (dpy, error_message)
+
鐃緒申��申鐃緒申     Display *dpy;
+
鐃緒申��申鐃緒申     char *error_message;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
+
鐃緒申��申鐃緒申  Lisp_Object frame, tail;
+
鐃緒申��申鐃緒申  int count;
+
鐃緒申��申鐃緒申  char *msg;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  msg = (char *) alloca (strlen (error_message) + 1);
+
鐃緒申��申鐃緒申  strcpy (msg, error_message);
+
鐃緒申��申鐃緒申  handling_signal = 0;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Prevent being called recursively because of an error condition
+
鐃緒申��申鐃緒申     below.  Otherwise, we might end up with printing ``can't find per
+
鐃緒申��申鐃緒申     display information'' in the recursive call instead of printing
+
鐃緒申��申鐃緒申     the original message here.  */
+
鐃緒申��申鐃緒申  count = x_catch_errors (dpy);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* We have to close the display to inform Xt that it doesn't
+
鐃緒申��申鐃緒申     exist anymore.  If we don't, Xt will continue to wait for
+
鐃緒申��申鐃緒申     events from the display.  As a consequence, a sequence of
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申     M-x make-frame-on-display RET :1 RET
+
鐃緒申��申鐃緒申     ...kill the new frame, so that we get an IO error...
+
鐃緒申��申鐃緒申     M-x make-frame-on-display RET :1 RET
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申     will indefinitely wait in Xt for events for display `:1', opened
+
鐃緒申��申鐃緒申     in the first class to make-frame-on-display.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申     Closing the display is reported to lead to a bus error on
+
鐃緒申��申鐃緒申     OpenWindows in certain situations.  I suspect that is a bug
+
鐃緒申��申鐃緒申     in OpenWindows.  I don't know how to cicumvent it here.  */
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  /* If DPYINFO is null, this means we didn't open the display
+
鐃緒申��申鐃緒申     in the first place, so don't try to close it.  */
+
鐃緒申��申鐃緒申  if (dpyinfo)
+
鐃緒申��申鐃緒申    XtCloseDisplay (dpy);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Indicate that this display is dead.  */
+
鐃緒申��申鐃緒申  if (dpyinfo)
+
鐃緒申��申鐃緒申    dpyinfo->display = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* First delete frames whose mini-buffers are on frames
+
鐃緒申��申鐃緒申     that are on the dead display.  */
+
鐃緒申��申鐃緒申  FOR_EACH_FRAME (tail, frame)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object minibuf_frame;
+
鐃緒申��申鐃緒申      minibuf_frame
+
鐃緒申��申鐃緒申	= WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame))));
+
鐃緒申��申鐃緒申      if (FRAME_X_P (XFRAME (frame))
+
鐃緒申��申鐃緒申	  && FRAME_X_P (XFRAME (minibuf_frame))
+
鐃緒申��申鐃緒申	  && ! EQ (frame, minibuf_frame)
+
鐃緒申��申鐃緒申	  && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame)) == dpyinfo)
+
鐃緒申��申鐃緒申	Fdelete_frame (frame, Qt);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Now delete all remaining frames on the dead display.
+
鐃緒申��申鐃緒申     We are now sure none of these is used as the mini-buffer
+
鐃緒申��申鐃緒申     for another frame that we need to delete.  */
+
鐃緒申��申鐃緒申  FOR_EACH_FRAME (tail, frame)
+
鐃緒申��申鐃緒申    if (FRAME_X_P (XFRAME (frame))
+
鐃緒申��申鐃緒申	&& FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	/* Set this to t so that Fdelete_frame won't get confused
+
鐃緒申��申鐃緒申	   trying to find a replacement.  */
+
鐃緒申��申鐃緒申	FRAME_KBOARD (XFRAME (frame))->Vdefault_minibuffer_frame = Qt;
+
鐃緒申��申鐃緒申	Fdelete_frame (frame, Qt);
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (dpyinfo)
+
鐃緒申��申鐃緒申    x_delete_display (dpyinfo);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  x_uncatch_errors (dpy, count);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (x_display_list == 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      fprintf (stderr, "%s\n", msg);
+
鐃緒申��申鐃緒申      shut_down_emacs (0, 0, Qnil);
+
鐃緒申��申鐃緒申      exit (70);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Ordinary stack unwind doesn't deal with these.  */
+
鐃緒申��申鐃緒申#ifdef SIGIO
+
鐃緒申��申鐃緒申  sigunblock (sigmask (SIGIO));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  sigunblock (sigmask (SIGALRM));
+
鐃緒申��申鐃緒申  TOTALLY_UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  clear_waiting_for_input ();
+
鐃緒申��申鐃緒申  error ("%s", msg);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is the usual handler for X protocol errors.
+
鐃緒申��申鐃緒申   It kills all frames on the display that we got the error for.
+
鐃緒申��申鐃緒申   If that was the only one, it prints an error message and kills Emacs.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_error_quitter (display, error)
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申     XErrorEvent *error;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  char buf[256], buf1[356];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Note that there is no real way portable across R3/R4 to get the
+
鐃緒申��申鐃緒申     original error handler.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XGetErrorText (display, error->error_code, buf, sizeof (buf));
+
鐃緒申��申鐃緒申  sprintf (buf1, "X protocol error: %s on protocol request %d",
+
鐃緒申��申鐃緒申	   buf, error->request_code);
+
鐃緒申��申鐃緒申  x_connection_closed (display, buf1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is the first-level handler for X protocol errors.
+
鐃緒申��申鐃緒申   It calls x_error_quitter or x_error_catcher.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_error_handler (display, error)
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申     XErrorEvent *error;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (! NILP (x_error_message_string))
+
鐃緒申��申鐃緒申    x_error_catcher (display, error);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x_error_quitter (display, error);
+
鐃緒申��申鐃緒申  return 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This is the handler for X IO errors, always.
+
鐃緒申��申鐃緒申   It kills all frames on the display that we lost touch with.
+
鐃緒申��申鐃緒申   If that was the only one, it prints an error message and kills Emacs.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_io_error_quitter (display)
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  char buf[256];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  sprintf (buf, "Connection lost to X server `%s'", DisplayString (display));
+
鐃緒申��申鐃緒申  x_connection_closed (display, buf);
+
鐃緒申��申鐃緒申  return 0;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Changing the font of the frame.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Give frame F the font named FONTNAME as its default font, and
+
鐃緒申��申鐃緒申   return the full name of that font.  FONTNAME may be a wildcard
+
鐃緒申��申鐃緒申   pattern; in that case, we choose some font that fits the pattern.
+
鐃緒申��申鐃緒申   The return value shows which font we chose.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Lisp_Object
+
鐃緒申��申鐃緒申x_new_font (f, fontname)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     register char *fontname;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct font_info *fontp
+
鐃緒申��申鐃緒申    = FS_LOAD_FONT (f, 0, fontname, -1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!fontp)
+
鐃緒申��申鐃緒申    return Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  f->output_data.x->font = (XFontStruct *) (fontp->font);
+
鐃緒申��申鐃緒申  f->output_data.x->baseline_offset = fontp->baseline_offset;
+
鐃緒申��申鐃緒申  f->output_data.x->fontset = -1;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Compute the scroll bar width in character columns.  */
+
鐃緒申��申鐃緒申  if (f->scroll_bar_pixel_width > 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int wid = FONT_WIDTH (f->output_data.x->font);
+
鐃緒申��申鐃緒申      f->scroll_bar_cols = (f->scroll_bar_pixel_width + wid-1) / wid;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int wid = FONT_WIDTH (f->output_data.x->font);
+
鐃緒申��申鐃緒申      f->scroll_bar_cols = (14 + wid - 1) / wid;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Now make the frame display the given font.  */
+
鐃緒申��申鐃緒申  if (FRAME_X_WINDOW (f) != 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
+
鐃緒申��申鐃緒申		f->output_data.x->font->fid);
+
鐃緒申��申鐃緒申      XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->reverse_gc,
+
鐃緒申��申鐃緒申		f->output_data.x->font->fid);
+
鐃緒申��申鐃緒申      XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->cursor_gc,
+
鐃緒申��申鐃緒申		f->output_data.x->font->fid);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      frame_update_line_height (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Don't change the size of a tip frame; there's no point in
+
鐃緒申��申鐃緒申	 doing it because it's done in Fx_show_tip, and it leads to
+
鐃緒申��申鐃緒申	 problems because the tip frame has no widget.  */
+
鐃緒申��申鐃緒申      if (NILP (tip_frame) || XFRAME (tip_frame) != f)
+
鐃緒申��申鐃緒申	x_set_window_size (f, 0, f->width, f->height);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    /* If we are setting a new frame's font for the first time,
+
鐃緒申��申鐃緒申       there are no faces yet, so this font's height is the line height.  */
+
鐃緒申��申鐃緒申    f->output_data.x->line_height = FONT_HEIGHT (f->output_data.x->font);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return build_string (fontp->full_name);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Give frame F the fontset named FONTSETNAME as its default font, and
+
鐃緒申��申鐃緒申   return the full name of that fontset.  FONTSETNAME may be a wildcard
+
鐃緒申��申鐃緒申   pattern; in that case, we choose some fontset that fits the pattern.
+
鐃緒申��申鐃緒申   The return value shows which fontset we chose.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Lisp_Object
+
鐃緒申��申鐃緒申x_new_fontset (f, fontsetname)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     char *fontsetname;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int fontset = fs_query_fontset (build_string (fontsetname), 0);
+
鐃緒申��申鐃緒申  Lisp_Object result;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (fontset < 0)
+
鐃緒申��申鐃緒申    return Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (f->output_data.x->fontset == fontset)
+
鐃緒申��申鐃緒申    /* This fontset is already set in frame F.  There's nothing more
+
鐃緒申��申鐃緒申       to do.  */
+
鐃緒申��申鐃緒申    return fontset_name (fontset);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  result = x_new_font (f, (XSTRING (fontset_ascii (fontset))->data));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!STRINGP (result))
+
鐃緒申��申鐃緒申    /* Can't load ASCII font.  */
+
鐃緒申��申鐃緒申    return Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Since x_new_font doesn't update any fontset information, do it now.  */
+
鐃緒申��申鐃緒申  f->output_data.x->fontset = fontset;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申  if (FRAME_XIC (f)
+
鐃緒申��申鐃緒申      && (FRAME_XIC_STYLE (f) & (XIMPreeditPosition | XIMStatusArea)))
+
鐃緒申��申鐃緒申    xic_set_xfontset (f, XSTRING (fontset_ascii (fontset))->data);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  return build_string (fontsetname);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			   X Input Methods
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R6
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* XIM destroy callback function, which is called whenever the
+
鐃緒申��申鐃緒申   connection to input method XIM dies.  CLIENT_DATA contains a
+
鐃緒申��申鐃緒申   pointer to the x_display_info structure corresponding to XIM.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申xim_destroy_callback (xim, client_data, call_data)
+
鐃緒申��申鐃緒申     XIM xim;
+
鐃緒申��申鐃緒申     XPointer client_data;
+
鐃緒申��申鐃緒申     XPointer call_data;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = (struct x_display_info *) client_data;
+
鐃緒申��申鐃緒申  Lisp_Object frame, tail;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* No need to call XDestroyIC.. */
+
鐃緒申��申鐃緒申  FOR_EACH_FRAME (tail, frame)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct frame *f = XFRAME (frame);
+
鐃緒申��申鐃緒申      if (FRAME_X_DISPLAY_INFO (f) == dpyinfo)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  FRAME_XIC (f) = NULL;
+
鐃緒申��申鐃緒申	  if (FRAME_XIC_FONTSET (f))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
+
鐃緒申��申鐃緒申	      FRAME_XIC_FONTSET (f) = NULL;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* No need to call XCloseIM.  */
+
鐃緒申��申鐃緒申  dpyinfo->xim = NULL;
+
鐃緒申��申鐃緒申  XFree (dpyinfo->xim_styles);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* HAVE_X11R6 */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Open the connection to the XIM server on display DPYINFO.
+
鐃緒申��申鐃緒申   RESOURCE_NAME is the resource name Emacs uses.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申xim_open_dpy (dpyinfo, resource_name)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申     char *resource_name;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#ifdef USE_XIM
+
鐃緒申��申鐃緒申  XIM xim;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xim = XOpenIM (dpyinfo->display, dpyinfo->xrdb, resource_name, EMACS_CLASS);
+
鐃緒申��申鐃緒申  dpyinfo->xim = xim;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (xim)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R6
+
鐃緒申��申鐃緒申      XIMCallback destroy;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      /* Get supported styles and XIM values.  */
+
鐃緒申��申鐃緒申      XGetIMValues (xim, XNQueryInputStyle, &dpyinfo->xim_styles, NULL);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R6
+
鐃緒申��申鐃緒申      destroy.callback = xim_destroy_callback;
+
鐃緒申��申鐃緒申      destroy.client_data = (XPointer)dpyinfo;
+
鐃緒申��申鐃緒申      /* This isn't prptotyped in OSF 5.0.  */
+
鐃緒申��申鐃緒申      XSetIMValues (xim, XNDestroyCallback, &destroy, NULL);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#else /* not USE_XIM */
+
鐃緒申��申鐃緒申  dpyinfo->xim = NULL;
+
鐃緒申��申鐃緒申#endif /* not USE_XIM */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R6_XIM
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct xim_inst_t
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申  char *resource_name;
+
鐃緒申��申鐃緒申};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* XIM instantiate callback function, which is called whenever an XIM
+
鐃緒申��申鐃緒申   server is available.  DISPLAY is teh display of the XIM.
+
鐃緒申��申鐃緒申   CLIENT_DATA contains a pointer to an xim_inst_t structure created
+
鐃緒申��申鐃緒申   when the callback was registered.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申xim_instantiate_callback (display, client_data, call_data)
+
鐃緒申��申鐃緒申     Display *display;
+
鐃緒申��申鐃緒申     XPointer client_data;
+
鐃緒申��申鐃緒申     XPointer call_data;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct xim_inst_t *xim_inst = (struct xim_inst_t *) client_data;
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = xim_inst->dpyinfo;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We don't support multiple XIM connections. */
+
鐃緒申��申鐃緒申  if (dpyinfo->xim)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  xim_open_dpy (dpyinfo, xim_inst->resource_name);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Create XIC for the existing frames on the same display, as long
+
鐃緒申��申鐃緒申     as they have no XIC.  */
+
鐃緒申��申鐃緒申  if (dpyinfo->xim && dpyinfo->reference_count > 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object tail, frame;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申      FOR_EACH_FRAME (tail, frame)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  struct frame *f = XFRAME (frame);
+
鐃緒申��申鐃緒申	  
+
鐃緒申��申鐃緒申	  if (FRAME_X_DISPLAY_INFO (f) == xim_inst->dpyinfo)
+
鐃緒申��申鐃緒申	    if (FRAME_XIC (f) == NULL)
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		create_frame_xic (f);
+
鐃緒申��申鐃緒申		if (FRAME_XIC_STYLE (f) & XIMStatusArea)
+
鐃緒申��申鐃緒申		  xic_set_statusarea (f);
+
鐃緒申��申鐃緒申		if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    struct window *w = XWINDOW (f->selected_window);
+
鐃緒申��申鐃緒申		    xic_set_preeditarea (w, w->cursor.x, w->cursor.y);
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* HAVE_X11R6_XIM */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Open a connection to the XIM server on display DPYINFO.
+
鐃緒申��申鐃緒申   RESOURCE_NAME is the resource name for Emacs.  On X11R5, open the
+
鐃緒申��申鐃緒申   connection only at the first time.  On X11R6, open the connection
+
鐃緒申��申鐃緒申   in the XIM instantiate callback function.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申xim_initialize (dpyinfo, resource_name)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申     char *resource_name;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#ifdef USE_XIM
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R6_XIM
+
鐃緒申��申鐃緒申  struct xim_inst_t *xim_inst;
+
鐃緒申��申鐃緒申  int len;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  dpyinfo->xim = NULL;
+
鐃緒申��申鐃緒申  xim_inst = (struct xim_inst_t *) xmalloc (sizeof (struct xim_inst_t));
+
鐃緒申��申鐃緒申  xim_inst->dpyinfo = dpyinfo;
+
鐃緒申��申鐃緒申  len = strlen (resource_name);
+
鐃緒申��申鐃緒申  xim_inst->resource_name = (char *) xmalloc (len + 1);
+
鐃緒申��申鐃緒申  bcopy (resource_name, xim_inst->resource_name, len + 1);
+
鐃緒申��申鐃緒申  XRegisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
+
鐃緒申��申鐃緒申				  resource_name, EMACS_CLASS,
+
鐃緒申��申鐃緒申				  xim_instantiate_callback,
+
鐃緒申��申鐃緒申				  /* Fixme: This is XPointer in
+
鐃緒申��申鐃緒申				     XFree86 but (XPointer *) on
+
鐃緒申��申鐃緒申				     Tru64, at least.  */
+
鐃緒申��申鐃緒申				  (XPointer) xim_inst);
+
鐃緒申��申鐃緒申#else /* not HAVE_X11R6_XIM */
+
鐃緒申��申鐃緒申  dpyinfo->xim = NULL;
+
鐃緒申��申鐃緒申  xim_open_dpy (dpyinfo, resource_name);
+
鐃緒申��申鐃緒申#endif /* not HAVE_X11R6_XIM */
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#else /* not USE_XIM */
+
鐃緒申��申鐃緒申  dpyinfo->xim = NULL;
+
鐃緒申��申鐃緒申#endif /* not USE_XIM */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Close the connection to the XIM server on display DPYINFO. */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申xim_close_dpy (dpyinfo)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#ifdef USE_XIM
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R6_XIM
+
鐃緒申��申鐃緒申  if (dpyinfo->display)
+
鐃緒申��申鐃緒申    XUnregisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
+
鐃緒申��申鐃緒申				      NULL, EMACS_CLASS,
+
鐃緒申��申鐃緒申				      xim_instantiate_callback, NULL);
+
鐃緒申��申鐃緒申#endif /* not HAVE_X11R6_XIM */
+
鐃緒申��申鐃緒申  if (dpyinfo->display)
+
鐃緒申��申鐃緒申    XCloseIM (dpyinfo->xim);
+
鐃緒申��申鐃緒申  dpyinfo->xim = NULL;
+
鐃緒申��申鐃緒申  XFree (dpyinfo->xim_styles);
+
鐃緒申��申鐃緒申#endif /* USE_XIM */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* not HAVE_X11R6_XIM */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Calculate the absolute position in frame F
+
鐃緒申��申鐃緒申   from its current recorded position values and gravity.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_calc_absolute_position (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Window child;
+
鐃緒申��申鐃緒申  int win_x = 0, win_y = 0;
+
鐃緒申��申鐃緒申  int flags = f->output_data.x->size_hint_flags;
+
鐃緒申��申鐃緒申  int this_window;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We have nothing to do if the current position
+
鐃緒申��申鐃緒申     is already for the top-left corner.  */
+
鐃緒申��申鐃緒申  if (! ((flags & XNegative) || (flags & YNegative)))
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  this_window = XtWindow (f->output_data.x->widget);
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申  this_window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Find the position of the outside upper-left corner of
+
鐃緒申��申鐃緒申     the inner window, with respect to the outer window.
+
鐃緒申��申鐃緒申     But do this only if we will need the results.  */
+
鐃緒申��申鐃緒申  if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int count;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申      count = x_catch_errors (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申      while (1)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  x_clear_errors (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申	  XTranslateCoordinates (FRAME_X_DISPLAY (f),
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申				 /* From-window, to-window.  */
+
鐃緒申��申鐃緒申				 this_window,
+
鐃緒申��申鐃緒申				 f->output_data.x->parent_desc,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申				 /* From-position, to-position.  */
+
鐃緒申��申鐃緒申				 0, 0, &win_x, &win_y,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申				 /* Child of win.  */
+
鐃緒申��申鐃緒申				 &child);
+
鐃緒申��申鐃緒申	  if (x_had_errors_p (FRAME_X_DISPLAY (f)))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      Window newroot, newparent = 0xdeadbeef;
+
鐃緒申��申鐃緒申	      Window *newchildren;
+
鐃緒申��申鐃緒申	      unsigned int nchildren;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      if (! XQueryTree (FRAME_X_DISPLAY (f), this_window, &newroot,
+
鐃緒申��申鐃緒申				&newparent, &newchildren, &nchildren))
+
鐃緒申��申鐃緒申		break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      XFree ((char *) newchildren);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      f->output_data.x->parent_desc = newparent;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    break;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      x_uncatch_errors (FRAME_X_DISPLAY (f), count);
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Treat negative positions as relative to the leftmost bottommost
+
鐃緒申��申鐃緒申     position that fits on the screen.  */
+
鐃緒申��申鐃緒申  if (flags & XNegative)
+
鐃緒申��申鐃緒申    f->output_data.x->left_pos = (FRAME_X_DISPLAY_INFO (f)->width
+
鐃緒申��申鐃緒申				  - 2 * f->output_data.x->border_width - win_x
+
鐃緒申��申鐃緒申				  - PIXEL_WIDTH (f)
+
鐃緒申��申鐃緒申				  + f->output_data.x->left_pos);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    int height = PIXEL_HEIGHT (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if defined USE_X_TOOLKIT && defined USE_MOTIF
+
鐃緒申��申鐃緒申    /* Something is fishy here.  When using Motif, starting Emacs with
+
鐃緒申��申鐃緒申       `-g -0-0', the frame appears too low by a few pixels.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申       This seems to be so because initially, while Emacs is starting,
+
鐃緒申��申鐃緒申       the column widget's height and the frame's pixel height are
+
鐃緒申��申鐃緒申       different.  The column widget's height is the right one.  In
+
鐃緒申��申鐃緒申       later invocations, when Emacs is up, the frame's pixel height
+
鐃緒申��申鐃緒申       is right, though.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申       It's not obvious where the initial small difference comes from.
+
鐃緒申��申鐃緒申       2000-12-01, gerd.  */
+
鐃緒申��申鐃緒申    
+
鐃緒申��申鐃緒申    XtVaGetValues (f->output_data.x->column_widget, XtNheight, &height, NULL);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (flags & YNegative)
+
鐃緒申��申鐃緒申    f->output_data.x->top_pos = (FRAME_X_DISPLAY_INFO (f)->height
+
鐃緒申��申鐃緒申				 - 2 * f->output_data.x->border_width
+
鐃緒申��申鐃緒申				 - win_y
+
鐃緒申��申鐃緒申				 - height
+
鐃緒申��申鐃緒申				 + f->output_data.x->top_pos);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* The left_pos and top_pos
+
鐃緒申��申鐃緒申     are now relative to the top and left screen edges,
+
鐃緒申��申鐃緒申     so the flags should correspond.  */
+
鐃緒申��申鐃緒申  f->output_data.x->size_hint_flags &= ~ (XNegative | YNegative);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
+
鐃緒申��申鐃緒申   to really change the position, and 0 when calling from
+
鐃緒申��申鐃緒申   x_make_frame_visible (in that case, XOFF and YOFF are the current
+
鐃緒申��申鐃緒申   position values).  It is -1 when calling from x_set_frame_parameters,
+
鐃緒申��申鐃緒申   which means, do adjust for borders but don't change the gravity.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_set_offset (f, xoff, yoff, change_gravity)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     register int xoff, yoff;
+
鐃緒申��申鐃緒申     int change_gravity;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int modified_top, modified_left;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (change_gravity > 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      f->output_data.x->top_pos = yoff;
+
鐃緒申��申鐃緒申      f->output_data.x->left_pos = xoff;
+
鐃緒申��申鐃緒申      f->output_data.x->size_hint_flags &= ~ (XNegative | YNegative);
+
鐃緒申��申鐃緒申      if (xoff < 0)
+
鐃緒申��申鐃緒申	f->output_data.x->size_hint_flags |= XNegative;
+
鐃緒申��申鐃緒申      if (yoff < 0)
+
鐃緒申��申鐃緒申	f->output_data.x->size_hint_flags |= YNegative;
+
鐃緒申��申鐃緒申      f->output_data.x->win_gravity = NorthWestGravity;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  x_calc_absolute_position (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  x_wm_set_size_hint (f, (long) 0, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  modified_left = f->output_data.x->left_pos;
+
鐃緒申��申鐃緒申  modified_top = f->output_data.x->top_pos;
+
鐃緒申��申鐃緒申#if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
+
鐃緒申��申鐃緒申	 this seems to be unnecessary and incorrect.  rms, 4/17/97.  */
+
鐃緒申��申鐃緒申  /* It is a mystery why we need to add the border_width here
+
鐃緒申��申鐃緒申     when the frame is already visible, but experiment says we do.  */
+
鐃緒申��申鐃緒申  if (change_gravity != 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      modified_left += f->output_data.x->border_width;
+
鐃緒申��申鐃緒申      modified_top += f->output_data.x->border_width;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  XMoveWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget),
+
鐃緒申��申鐃緒申	       modified_left, modified_top);
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申  XMoveWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申	       modified_left, modified_top);
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Change the size of frame F's X window to COLS/ROWS in the case F
+
鐃緒申��申鐃緒申   doesn't have a widget.  If CHANGE_GRAVITY is 1, we change to
+
鐃緒申��申鐃緒申   top-left-corner window gravity for this size change and subsequent
+
鐃緒申��申鐃緒申   size changes.  Otherwise we leave the window gravity unchanged.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_set_window_size_1 (f, change_gravity, cols, rows)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int change_gravity;
+
鐃緒申��申鐃緒申     int cols, rows;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int pixelwidth, pixelheight;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  check_frame_size (f, &rows, &cols);
+
鐃緒申��申鐃緒申  f->output_data.x->vertical_scroll_bar_extra
+
鐃緒申��申鐃緒申    = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f)
+
鐃緒申��申鐃緒申       ? 0
+
鐃緒申��申鐃緒申       : FRAME_SCROLL_BAR_PIXEL_WIDTH (f) > 0
+
鐃緒申��申鐃緒申       ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f)
+
鐃緒申��申鐃緒申       : (FRAME_SCROLL_BAR_COLS (f) * FONT_WIDTH (f->output_data.x->font)));
+
鐃緒申��申鐃緒申  f->output_data.x->flags_areas_extra
+
鐃緒申��申鐃緒申    = FRAME_FLAGS_AREA_WIDTH (f);
+
鐃緒申��申鐃緒申  pixelwidth = CHAR_TO_PIXEL_WIDTH (f, cols);
+
鐃緒申��申鐃緒申  pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  f->output_data.x->win_gravity = NorthWestGravity;
+
鐃緒申��申鐃緒申  x_wm_set_size_hint (f, (long) 0, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSync (FRAME_X_DISPLAY (f), False);
+
鐃緒申��申鐃緒申  XResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		 pixelwidth, pixelheight);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Now, strictly speaking, we can't be sure that this is accurate,
+
鐃緒申��申鐃緒申     but the window manager will get around to dealing with the size
+
鐃緒申��申鐃緒申     change request eventually, and we'll hear how it went when the
+
鐃緒申��申鐃緒申     ConfigureNotify event gets here.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申     We could just not bother storing any of this information here,
+
鐃緒申��申鐃緒申     and let the ConfigureNotify event set everything up, but that
+
鐃緒申��申鐃緒申     might be kind of confusing to the Lisp code, since size changes
+
鐃緒申��申鐃緒申     wouldn't be reported in the frame parameters until some random
+
鐃緒申��申鐃緒申     point in the future when the ConfigureNotify event arrives.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申     We pass 1 for DELAY since we can't run Lisp code inside of
+
鐃緒申��申鐃緒申     a BLOCK_INPUT.  */
+
鐃緒申��申鐃緒申  change_frame_size (f, rows, cols, 0, 1, 0);
+
鐃緒申��申鐃緒申  PIXEL_WIDTH (f) = pixelwidth;
+
鐃緒申��申鐃緒申  PIXEL_HEIGHT (f) = pixelheight;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
+
鐃緒申��申鐃緒申     receive in the ConfigureNotify event; if we get what we asked
+
鐃緒申��申鐃緒申     for, then the event won't cause the screen to become garbaged, so
+
鐃緒申��申鐃緒申     we have to make sure to do it here.  */
+
鐃緒申��申鐃緒申  SET_FRAME_GARBAGED (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Call this to change the size of frame F's x-window.
+
鐃緒申��申鐃緒申   If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
+
鐃緒申��申鐃緒申   for this size change and subsequent size changes.
+
鐃緒申��申鐃緒申   Otherwise we leave the window gravity unchanged.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_set_window_size (f, change_gravity, cols, rows)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int change_gravity;
+
鐃緒申��申鐃緒申     int cols, rows;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (f->output_data.x->widget != NULL)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* The x and y position of the widget is clobbered by the
+
鐃緒申��申鐃緒申	 call to XtSetValues within EmacsFrameSetCharSize.
+
鐃緒申��申鐃緒申	 This is a real kludge, but I don't understand Xt so I can't
+
鐃緒申��申鐃緒申	 figure out a correct fix.  Can anyone else tell me? -- rms.  */
+
鐃緒申��申鐃緒申      int xpos = f->output_data.x->widget->core.x;
+
鐃緒申��申鐃緒申      int ypos = f->output_data.x->widget->core.y;
+
鐃緒申��申鐃緒申      EmacsFrameSetCharSize (f->output_data.x->edit_widget, cols, rows);
+
鐃緒申��申鐃緒申      f->output_data.x->widget->core.x = xpos;
+
鐃緒申��申鐃緒申      f->output_data.x->widget->core.y = ypos;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x_set_window_size_1 (f, change_gravity, cols, rows);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  x_set_window_size_1 (f, change_gravity, cols, rows);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If cursor was outside the new size, mark it as off.  */
+
鐃緒申��申鐃緒申  mark_window_cursors_off (XWINDOW (f->root_window));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Clear out any recollection of where the mouse highlighting was,
+
鐃緒申��申鐃緒申     since it might be in a place that's outside the new frame size. 
+
鐃緒申��申鐃緒申     Actually checking whether it is outside is a pain in the neck,
+
鐃緒申��申鐃緒申     so don't try--just let the highlighting be done afresh with new size.  */
+
鐃緒申��申鐃緒申  cancel_mouse_face (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Mouse warping.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_set_mouse_position (f, x, y)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int x, y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int pix_x, pix_y;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  pix_x = CHAR_TO_PIXEL_COL (f, x) + FONT_WIDTH  (f->output_data.x->font) / 2;
+
鐃緒申��申鐃緒申  pix_y = CHAR_TO_PIXEL_ROW (f, y) + f->output_data.x->line_height / 2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (pix_x < 0) pix_x = 0;
+
鐃緒申��申鐃緒申  if (pix_x > PIXEL_WIDTH (f)) pix_x = PIXEL_WIDTH (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (pix_y < 0) pix_y = 0;
+
鐃緒申��申鐃緒申  if (pix_y > PIXEL_HEIGHT (f)) pix_y = PIXEL_HEIGHT (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		0, 0, 0, 0, pix_x, pix_y);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_set_mouse_pixel_position (f, pix_x, pix_y)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int pix_x, pix_y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		0, 0, 0, 0, pix_x, pix_y);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* focus shifting, raising and lowering.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_focus_on_frame (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#if 0  /* This proves to be unpleasant.  */
+
鐃緒申��申鐃緒申  x_raise_frame (f);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申  /* I don't think that the ICCCM allows programs to do things like this
+
鐃緒申��申鐃緒申     without the interaction of the window manager.  Whatever you end up
+
鐃緒申��申鐃緒申     doing with this code, do it to x_unfocus_frame too.  */
+
鐃緒申��申鐃緒申  XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
鐃緒申��申鐃緒申		  RevertToPointerRoot, CurrentTime);
+
鐃緒申��申鐃緒申#endif /* ! 0 */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_unfocus_frame (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申  /* Look at the remarks in x_focus_on_frame.  */
+
鐃緒申��申鐃緒申  if (FRAME_X_DISPLAY_INFO (f)->x_focus_frame == f)
+
鐃緒申��申鐃緒申    XSetInputFocus (FRAME_X_DISPLAY (f), PointerRoot,
+
鐃緒申��申鐃緒申		    RevertToPointerRoot, CurrentTime);
+
鐃緒申��申鐃緒申#endif /* ! 0 */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Raise frame F.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_raise_frame (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (f->async_visible)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申      XRaiseWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget));
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申      XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申      XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Lower frame F.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_lower_frame (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (f->async_visible)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申      XLowerWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget));
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申      XLowerWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申      XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申XTframe_raise_lower (f, raise_flag)
+
鐃緒申��申鐃緒申     FRAME_PTR f;
+
鐃緒申��申鐃緒申     int raise_flag;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (raise_flag)
+
鐃緒申��申鐃緒申    x_raise_frame (f);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    x_lower_frame (f);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Change of visibility.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* This tries to wait until the frame is really visible.
+
鐃緒申��申鐃緒申   However, if the window manager asks the user where to position
+
鐃緒申��申鐃緒申   the frame, this will return before the user finishes doing that.
+
鐃緒申��申鐃緒申   The frame will not actually be visible at that time,
+
鐃緒申��申鐃緒申   but it will become visible later when the window manager
+
鐃緒申��申鐃緒申   finishes with it.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_make_frame_visible (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object type;
+
鐃緒申��申鐃緒申  int original_top, original_left;
+
鐃緒申��申鐃緒申  int retry_count = 2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申 retry:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  type = x_icon_type (f);
+
鐃緒申��申鐃緒申  if (!NILP (type))
+
鐃緒申��申鐃緒申    x_bitmap_icon (f, type);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (! FRAME_VISIBLE_P (f))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* We test FRAME_GARBAGED_P here to make sure we don't
+
鐃緒申��申鐃緒申	 call x_set_offset a second time
+
鐃緒申��申鐃緒申	 if we get to x_make_frame_visible a second time
+
鐃緒申��申鐃緒申	 before the window gets really visible.  */
+
鐃緒申��申鐃緒申      if (! FRAME_ICONIFIED_P (f)
+
鐃緒申��申鐃緒申	  && ! f->output_data.x->asked_for_visible)
+
鐃緒申��申鐃緒申	x_set_offset (f, f->output_data.x->left_pos, f->output_data.x->top_pos, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      f->output_data.x->asked_for_visible = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (! EQ (Vx_no_window_manager, Qt))
+
鐃緒申��申鐃緒申	x_wm_set_window_state (f, NormalState);
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申      /* This was XtPopup, but that did nothing for an iconified frame.  */
+
鐃緒申��申鐃緒申      XtMapWidget (f->output_data.x->widget);
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申      XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申#if 0 /* This seems to bring back scroll bars in the wrong places
+
鐃緒申��申鐃緒申	 if the window configuration has changed.  They seem
+
鐃緒申��申鐃緒申	 to come back ok without this.  */
+
鐃緒申��申鐃緒申      if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+
鐃緒申��申鐃緒申	XMapSubwindows (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Synchronize to ensure Emacs knows the frame is visible
+
鐃緒申��申鐃緒申     before we do anything else.  We do this loop with input not blocked
+
鐃緒申��申鐃緒申     so that incoming events are handled.  */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    Lisp_Object frame;
+
鐃緒申��申鐃緒申    int count;
+
鐃緒申��申鐃緒申    /* This must be before UNBLOCK_INPUT
+
鐃緒申��申鐃緒申       since events that arrive in response to the actions above
+
鐃緒申��申鐃緒申       will set it when they are handled.  */
+
鐃緒申��申鐃緒申    int previously_visible = f->output_data.x->has_been_visible;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    original_left = f->output_data.x->left_pos;
+
鐃緒申��申鐃緒申    original_top = f->output_data.x->top_pos;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* This must come after we set COUNT.  */
+
鐃緒申��申鐃緒申    UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* We unblock here so that arriving X events are processed.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Now move the window back to where it was "supposed to be".
+
鐃緒申��申鐃緒申       But don't do it if the gravity is negative.
+
鐃緒申��申鐃緒申       When the gravity is negative, this uses a position
+
鐃緒申��申鐃緒申       that is 3 pixels too low.  Perhaps that's really the border width.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申       Don't do this if the window has never been visible before,
+
鐃緒申��申鐃緒申       because the window manager may choose the position
+
鐃緒申��申鐃緒申       and we don't want to override it.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    if (! FRAME_VISIBLE_P (f) && ! FRAME_ICONIFIED_P (f)
+
鐃緒申��申鐃緒申	&& f->output_data.x->win_gravity == NorthWestGravity
+
鐃緒申��申鐃緒申	&& previously_visible)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	Drawable rootw;
+
鐃緒申��申鐃緒申	int x, y;
+
鐃緒申��申鐃緒申	unsigned int width, height, border, depth;
+
鐃緒申��申鐃緒申	
+
鐃緒申��申鐃緒申	BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* On some window managers (such as FVWM) moving an existing
+
鐃緒申��申鐃緒申	   window, even to the same place, causes the window manager
+
鐃緒申��申鐃緒申	   to introduce an offset.  This can cause the window to move
+
鐃緒申��申鐃緒申	   to an unexpected location.  Check the geometry (a little
+
鐃緒申��申鐃緒申	   slow here) and then verify that the window is in the right
+
鐃緒申��申鐃緒申	   place.  If the window is not in the right place, move it
+
鐃緒申��申鐃緒申	   there, and take the potential window manager hit.  */
+
鐃緒申��申鐃緒申	XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+
鐃緒申��申鐃緒申		      &rootw, &x, &y, &width, &height, &border, &depth);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	if (original_left != x || original_top != y)
+
鐃緒申��申鐃緒申	  XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+
鐃緒申��申鐃緒申		       original_left, original_top);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    XSETFRAME (frame, f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Wait until the frame is visible.  Process X events until a
+
鐃緒申��申鐃緒申       MapNotify event has been seen, or until we think we won't get a
+
鐃緒申��申鐃緒申       MapNotify at all..  */
+
鐃緒申��申鐃緒申    for (count = input_signal_count + 10;
+
鐃緒申��申鐃緒申	 input_signal_count < count && !FRAME_VISIBLE_P (f);)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	/* Force processing of queued events.  */
+
鐃緒申��申鐃緒申	x_sync (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* Machines that do polling rather than SIGIO have been
+
鐃緒申��申鐃緒申	   observed to go into a busy-wait here.  So we'll fake an
+
鐃緒申��申鐃緒申	   alarm signal to let the handler know that there's something
+
鐃緒申��申鐃緒申	   to be read.  We used to raise a real alarm, but it seems
+
鐃緒申��申鐃緒申	   that the handler isn't always enabled here.  This is
+
鐃緒申��申鐃緒申	   probably a bug.  */
+
鐃緒申��申鐃緒申	if (input_polling_used ())
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    /* It could be confusing if a real alarm arrives while
+
鐃緒申��申鐃緒申	       processing the fake one.  Turn it off and let the
+
鐃緒申��申鐃緒申	       handler reset it.  */
+
鐃緒申��申鐃緒申	    extern void poll_for_input_1 P_ ((void));
+
鐃緒申��申鐃緒申	    int old_poll_suppress_count = poll_suppress_count;
+
鐃緒申��申鐃緒申	    poll_suppress_count = 1;
+
鐃緒申��申鐃緒申	    poll_for_input_1 ();
+
鐃緒申��申鐃緒申	    poll_suppress_count = old_poll_suppress_count;
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* See if a MapNotify event has been processed.  */
+
鐃緒申��申鐃緒申	FRAME_SAMPLE_VISIBILITY (f);
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* 2000-09-28: In
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申       (let ((f (selected-frame)))
+
鐃緒申��申鐃緒申          (iconify-frame f)
+
鐃緒申��申鐃緒申	  (raise-frame f))
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申       the frame is not raised with various window managers on
+
鐃緒申��申鐃緒申       FreeBSD, Linux and Solaris.  It turns out that, for some
+
鐃緒申��申鐃緒申       unknown reason, the call to XtMapWidget is completely ignored.
+
鐃緒申��申鐃緒申       Mapping the widget a second time works.  */
+
鐃緒申��申鐃緒申    
+
鐃緒申��申鐃緒申    if (!FRAME_VISIBLE_P (f) && --retry_count > 0)
+
鐃緒申��申鐃緒申      goto retry;
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Change from mapped state to withdrawn state.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Make the frame visible (mapped and not iconified).  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_make_frame_invisible (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Window window;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  /* Use the frame's outermost window, not the one we normally draw on.  */
+
鐃緒申��申鐃緒申  window = XtWindow (f->output_data.x->widget);
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申  window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Don't keep the highlight on an invisible frame.  */
+
鐃緒申��申鐃緒申  if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
+
鐃緒申��申鐃緒申    FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if 0/* This might add unreliability; I don't trust it -- rms.  */
+
鐃緒申��申鐃緒申  if (! f->async_visible && ! f->async_iconified)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
+
鐃緒申��申鐃緒申     that the current position of the window is user-specified, rather than
+
鐃緒申��申鐃緒申     program-specified, so that when the window is mapped again, it will be
+
鐃緒申��申鐃緒申     placed at the same location, without forcing the user to position it
+
鐃緒申��申鐃緒申     by hand again (they have already done that once for this window.)  */
+
鐃緒申��申鐃緒申  x_wm_set_size_hint (f, (long) 0, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R4
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (! XWithdrawWindow (FRAME_X_DISPLAY (f), window,
+
鐃緒申��申鐃緒申			 DefaultScreen (FRAME_X_DISPLAY (f))))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT_RESIGNAL;
+
鐃緒申��申鐃緒申      error ("Can't notify window manager of window withdrawal");
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申#else /* ! defined (HAVE_X11R4) */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /*  Tell the window manager what we're going to do.  */
+
鐃緒申��申鐃緒申  if (! EQ (Vx_no_window_manager, Qt))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      XEvent unmap;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      unmap.xunmap.type = UnmapNotify;
+
鐃緒申��申鐃緒申      unmap.xunmap.window = window;
+
鐃緒申��申鐃緒申      unmap.xunmap.event = DefaultRootWindow (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申      unmap.xunmap.from_configure = False;
+
鐃緒申��申鐃緒申      if (! XSendEvent (FRAME_X_DISPLAY (f),
+
鐃緒申��申鐃緒申			DefaultRootWindow (FRAME_X_DISPLAY (f)),
+
鐃緒申��申鐃緒申			False,
+
鐃緒申��申鐃緒申			SubstructureRedirectMaskSubstructureNotifyMask,
+
鐃緒申��申鐃緒申			&unmap))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  UNBLOCK_INPUT_RESIGNAL;
+
鐃緒申��申鐃緒申	  error ("Can't notify window manager of withdrawal");
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Unmap the window ourselves.  Cheeky!  */
+
鐃緒申��申鐃緒申  XUnmapWindow (FRAME_X_DISPLAY (f), window);
+
鐃緒申��申鐃緒申#endif /* ! defined (HAVE_X11R4) */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We can't distinguish this from iconification
+
鐃緒申��申鐃緒申     just by the event that we get from the server.
+
鐃緒申��申鐃緒申     So we can't win using the usual strategy of letting
+
鐃緒申��申鐃緒申     FRAME_SAMPLE_VISIBILITY set this.  So do it by hand,
+
鐃緒申��申鐃緒申     and synchronize with the server to make sure we agree.  */
+
鐃緒申��申鐃緒申  f->visible = 0;
+
鐃緒申��申鐃緒申  FRAME_ICONIFIED_P (f) = 0;
+
鐃緒申��申鐃緒申  f->async_visible = 0;
+
鐃緒申��申鐃緒申  f->async_iconified = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  x_sync (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Change window state from mapped to iconified.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_iconify_frame (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int result;
+
鐃緒申��申鐃緒申  Lisp_Object type;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Don't keep the highlight on an invisible frame.  */
+
鐃緒申��申鐃緒申  if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
+
鐃緒申��申鐃緒申    FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (f->async_iconified)
+
鐃緒申��申鐃緒申    return;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  FRAME_SAMPLE_VISIBILITY (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  type = x_icon_type (f);
+
鐃緒申��申鐃緒申  if (!NILP (type))
+
鐃緒申��申鐃緒申    x_bitmap_icon (f, type);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (! FRAME_VISIBLE_P (f))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (! EQ (Vx_no_window_manager, Qt))
+
鐃緒申��申鐃緒申	x_wm_set_window_state (f, IconicState);
+
鐃緒申��申鐃緒申      /* This was XtPopup, but that did nothing for an iconified frame.  */
+
鐃緒申��申鐃緒申      XtMapWidget (f->output_data.x->widget);
+
鐃緒申��申鐃緒申      /* The server won't give us any event to indicate
+
鐃緒申��申鐃緒申	 that an invisible frame was changed to an icon,
+
鐃緒申��申鐃緒申	 so we have to record it here.  */
+
鐃緒申��申鐃緒申      f->iconified = 1;
+
鐃緒申��申鐃緒申      f->visible = 1;
+
鐃緒申��申鐃緒申      f->async_iconified = 1;
+
鐃緒申��申鐃緒申      f->async_visible = 0;
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  result = XIconifyWindow (FRAME_X_DISPLAY (f),
+
鐃緒申��申鐃緒申			   XtWindow (f->output_data.x->widget),
+
鐃緒申��申鐃緒申			   DefaultScreen (FRAME_X_DISPLAY (f)));
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!result)
+
鐃緒申��申鐃緒申    error ("Can't notify window manager of iconification");
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  f->async_iconified = 1;
+
鐃緒申��申鐃緒申  f->async_visible = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Make sure the X server knows where the window should be positioned,
+
鐃緒申��申鐃緒申     in case the user deiconifies with the window manager.  */
+
鐃緒申��申鐃緒申  if (! FRAME_VISIBLE_P (f) && !FRAME_ICONIFIED_P (f))
+
鐃緒申��申鐃緒申    x_set_offset (f, f->output_data.x->left_pos, f->output_data.x->top_pos, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Since we don't know which revision of X we're running, we'll use both
+
鐃緒申��申鐃緒申     the X11R3 and X11R4 techniques.  I don't know if this is a good idea.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* X11R4: send a ClientMessage to the window manager using the
+
鐃緒申��申鐃緒申     WM_CHANGE_STATE type.  */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    XEvent message;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    message.xclient.window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申    message.xclient.type = ClientMessage;
+
鐃緒申��申鐃緒申    message.xclient.message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_change_state;
+
鐃緒申��申鐃緒申    message.xclient.format = 32;
+
鐃緒申��申鐃緒申    message.xclient.data.l[0] = IconicState;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    if (! XSendEvent (FRAME_X_DISPLAY (f),
+
鐃緒申��申鐃緒申		      DefaultRootWindow (FRAME_X_DISPLAY (f)),
+
鐃緒申��申鐃緒申		      False,
+
鐃緒申��申鐃緒申		      SubstructureRedirectMask | SubstructureNotifyMask,
+
鐃緒申��申鐃緒申		      &message))
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	UNBLOCK_INPUT_RESIGNAL;
+
鐃緒申��申鐃緒申	error ("Can't notify window manager of iconification");
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* X11R3: set the initial_state field of the window manager hints to
+
鐃緒申��申鐃緒申     IconicState.  */
+
鐃緒申��申鐃緒申  x_wm_set_window_state (f, IconicState);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!FRAME_VISIBLE_P (f))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* If the frame was withdrawn, before, we must map it.  */
+
鐃緒申��申鐃緒申      XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  f->async_iconified = 1;
+
鐃緒申��申鐃緒申  f->async_visible = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Free X resources of frame F.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_free_frame_resources (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If a display connection is dead, don't try sending more
+
鐃緒申��申鐃緒申     commands to the X server.  */
+
鐃緒申��申鐃緒申  if (dpyinfo->display)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (f->output_data.x->icon_desc)
+
鐃緒申��申鐃緒申	XDestroyWindow (FRAME_X_DISPLAY (f), f->output_data.x->icon_desc);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申      if (FRAME_XIC (f))
+
鐃緒申��申鐃緒申	free_frame_xic (f);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if (FRAME_X_WINDOW (f))
+
鐃緒申��申鐃緒申	XDestroyWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申      if (f->output_data.x->widget)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  XtDestroyWidget (f->output_data.x->widget);
+
鐃緒申��申鐃緒申	  f->output_data.x->widget = NULL;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      free_frame_menubar (f);
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      unload_color (f, f->output_data.x->foreground_pixel);
+
鐃緒申��申鐃緒申      unload_color (f, f->output_data.x->background_pixel);
+
鐃緒申��申鐃緒申      unload_color (f, f->output_data.x->cursor_pixel);
+
鐃緒申��申鐃緒申      unload_color (f, f->output_data.x->cursor_foreground_pixel);
+
鐃緒申��申鐃緒申      unload_color (f, f->output_data.x->border_pixel);
+
鐃緒申��申鐃緒申      unload_color (f, f->output_data.x->mouse_pixel);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      if (f->output_data.x->scroll_bar_background_pixel != -1)
+
鐃緒申��申鐃緒申	unload_color (f, f->output_data.x->scroll_bar_background_pixel);
+
鐃緒申��申鐃緒申      if (f->output_data.x->scroll_bar_foreground_pixel != -1)
+
鐃緒申��申鐃緒申	unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
+
鐃緒申��申鐃緒申      if (f->output_data.x->white_relief.allocated_p)
+
鐃緒申��申鐃緒申	unload_color (f, f->output_data.x->white_relief.pixel);
+
鐃緒申��申鐃緒申      if (f->output_data.x->black_relief.allocated_p)
+
鐃緒申��申鐃緒申	unload_color (f, f->output_data.x->black_relief.pixel);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (FRAME_FACE_CACHE (f))
+
鐃緒申��申鐃緒申	free_frame_faces (f);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申      x_free_gcs (f);
+
鐃緒申��申鐃緒申      XFlush (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (f->output_data.x->saved_menu_event)
+
鐃緒申��申鐃緒申    xfree (f->output_data.x->saved_menu_event);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xfree (f->output_data.x);
+
鐃緒申��申鐃緒申  f->output_data.x = NULL;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (f == dpyinfo->x_focus_frame)
+
鐃緒申��申鐃緒申    dpyinfo->x_focus_frame = 0;
+
鐃緒申��申鐃緒申  if (f == dpyinfo->x_focus_event_frame)
+
鐃緒申��申鐃緒申    dpyinfo->x_focus_event_frame = 0;
+
鐃緒申��申鐃緒申  if (f == dpyinfo->x_highlight_frame)
+
鐃緒申��申鐃緒申    dpyinfo->x_highlight_frame = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (f == dpyinfo->mouse_face_mouse_frame)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_beg_row
+
鐃緒申��申鐃緒申	= dpyinfo->mouse_face_beg_col = -1;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_end_row
+
鐃緒申��申鐃緒申	= dpyinfo->mouse_face_end_col = -1;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_window = Qnil;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_deferred_gc = 0;
+
鐃緒申��申鐃緒申      dpyinfo->mouse_face_mouse_frame = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Destroy the X window of frame F.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_destroy_window (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If a display connection is dead, don't try sending more
+
鐃緒申��申鐃緒申     commands to the X server.  */
+
鐃緒申��申鐃緒申  if (dpyinfo->display != 0)
+
鐃緒申��申鐃緒申    x_free_frame_resources (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo->reference_count--;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Setting window manager hints.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set the normal size hints for the window manager, for frame F.
+
鐃緒申��申鐃緒申   FLAGS is the flags word to use--or 0 meaning preserve the flags
+
鐃緒申��申鐃緒申   that the window now has.
+
鐃緒申��申鐃緒申   If USER_POSITION is nonzero, we set the USPosition
+
鐃緒申��申鐃緒申   flag (this is useful when FLAGS is 0).  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_wm_set_size_hint (f, flags, user_position)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     long flags;
+
鐃緒申��申鐃緒申     int user_position;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  XSizeHints size_hints;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  Arg al[2];
+
鐃緒申��申鐃緒申  int ac = 0;
+
鐃緒申��申鐃緒申  Dimension widget_width, widget_height;
+
鐃緒申��申鐃緒申  Window window = XtWindow (f->output_data.x->widget);
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申  Window window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Setting PMaxSize caused various problems.  */
+
鐃緒申��申鐃緒申  size_hints.flags = PResizeInc | PMinSize /* | PMaxSize */;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  size_hints.x = f->output_data.x->left_pos;
+
鐃緒申��申鐃緒申  size_hints.y = f->output_data.x->top_pos;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  XtSetArg (al[ac], XtNwidth, &widget_width); ac++;
+
鐃緒申��申鐃緒申  XtSetArg (al[ac], XtNheight, &widget_height); ac++;
+
鐃緒申��申鐃緒申  XtGetValues (f->output_data.x->widget, al, ac);
+
鐃緒申��申鐃緒申  size_hints.height = widget_height;
+
鐃緒申��申鐃緒申  size_hints.width = widget_width;
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申  size_hints.height = PIXEL_HEIGHT (f);
+
鐃緒申��申鐃緒申  size_hints.width = PIXEL_WIDTH (f);
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  size_hints.width_inc = FONT_WIDTH (f->output_data.x->font);
+
鐃緒申��申鐃緒申  size_hints.height_inc = f->output_data.x->line_height;
+
鐃緒申��申鐃緒申  size_hints.max_width
+
鐃緒申��申鐃緒申    = FRAME_X_DISPLAY_INFO (f)->width - CHAR_TO_PIXEL_WIDTH (f, 0);
+
鐃緒申��申鐃緒申  size_hints.max_height
+
鐃緒申��申鐃緒申    = FRAME_X_DISPLAY_INFO (f)->height - CHAR_TO_PIXEL_HEIGHT (f, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Calculate the base and minimum sizes.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申     (When we use the X toolkit, we don't do it here.
+
鐃緒申��申鐃緒申     Instead we copy the values that the widgets are using, below.)  */
+
鐃緒申��申鐃緒申#ifndef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    int base_width, base_height;
+
鐃緒申��申鐃緒申    int min_rows = 0, min_cols = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    base_width = CHAR_TO_PIXEL_WIDTH (f, 0);
+
鐃緒申��申鐃緒申    base_height = CHAR_TO_PIXEL_HEIGHT (f, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    check_frame_size (f, &min_rows, &min_cols);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* The window manager uses the base width hints to calculate the
+
鐃緒申��申鐃緒申       current number of rows and columns in the frame while
+
鐃緒申��申鐃緒申       resizing; min_width and min_height aren't useful for this
+
鐃緒申��申鐃緒申       purpose, since they might not give the dimensions for a
+
鐃緒申��申鐃緒申       zero-row, zero-column frame.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申       We use the base_width and base_height members if we have
+
鐃緒申��申鐃緒申       them; otherwise, we set the min_width and min_height members
+
鐃緒申��申鐃緒申       to the size for a zero x zero frame.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R4
+
鐃緒申��申鐃緒申    size_hints.flags |= PBaseSize;
+
鐃緒申��申鐃緒申    size_hints.base_width = base_width;
+
鐃緒申��申鐃緒申    size_hints.base_height = base_height;
+
鐃緒申��申鐃緒申    size_hints.min_width  = base_width + min_cols * size_hints.width_inc;
+
鐃緒申��申鐃緒申    size_hints.min_height = base_height + min_rows * size_hints.height_inc;
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申    size_hints.min_width = base_width;
+
鐃緒申��申鐃緒申    size_hints.min_height = base_height;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If we don't need the old flags, we don't need the old hint at all.  */
+
鐃緒申��申鐃緒申  if (flags)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      size_hints.flags |= flags;
+
鐃緒申��申鐃緒申      goto no_read;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    XSizeHints hints;		/* Sometimes I hate X Windows... */
+
鐃緒申��申鐃緒申    long supplied_return;
+
鐃緒申��申鐃緒申    int value;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R4
+
鐃緒申��申鐃緒申    value = XGetWMNormalHints (FRAME_X_DISPLAY (f), window, &hints,
+
鐃緒申��申鐃緒申			       &supplied_return);
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申    value = XGetNormalHints (FRAME_X_DISPLAY (f), window, &hints);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申    size_hints.base_height = hints.base_height;
+
鐃緒申��申鐃緒申    size_hints.base_width = hints.base_width;
+
鐃緒申��申鐃緒申    size_hints.min_height = hints.min_height;
+
鐃緒申��申鐃緒申    size_hints.min_width = hints.min_width;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    if (flags)
+
鐃緒申��申鐃緒申      size_hints.flags |= flags;
+
鐃緒申��申鐃緒申    else
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	if (value == 0)
+
鐃緒申��申鐃緒申	  hints.flags = 0;
+
鐃緒申��申鐃緒申	if (hints.flags & PSize)
+
鐃緒申��申鐃緒申	  size_hints.flags |= PSize;
+
鐃緒申��申鐃緒申	if (hints.flags & PPosition)
+
鐃緒申��申鐃緒申	  size_hints.flags |= PPosition;
+
鐃緒申��申鐃緒申	if (hints.flags & USPosition)
+
鐃緒申��申鐃緒申	  size_hints.flags |= USPosition;
+
鐃緒申��申鐃緒申	if (hints.flags & USSize)
+
鐃緒申��申鐃緒申	  size_hints.flags |= USSize;
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申 no_read:
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef PWinGravity
+
鐃緒申��申鐃緒申  size_hints.win_gravity = f->output_data.x->win_gravity;
+
鐃緒申��申鐃緒申  size_hints.flags |= PWinGravity;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (user_position)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      size_hints.flags &= ~ PPosition;
+
鐃緒申��申鐃緒申      size_hints.flags |= USPosition;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申#endif /* PWinGravity */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R4
+
鐃緒申��申鐃緒申  XSetWMNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申  XSetNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Used for IconicState or NormalState */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_wm_set_window_state (f, state)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int state;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  Arg al[1];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XtSetArg (al[0], XtNinitialState, state);
+
鐃緒申��申鐃緒申  XtSetValues (f->output_data.x->widget, al, 1);
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申  Window window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  f->output_data.x->wm_hints.flags |= StateHint;
+
鐃緒申��申鐃緒申  f->output_data.x->wm_hints.initial_state = state;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_wm_set_icon_pixmap (f, pixmap_id)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int pixmap_id;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Pixmap icon_pixmap;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  Window window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (pixmap_id > 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      icon_pixmap = x_bitmap_pixmap (f, pixmap_id);
+
鐃緒申��申鐃緒申      f->output_data.x->wm_hints.icon_pixmap = icon_pixmap;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* It seems there is no way to turn off use of an icon pixmap.
+
鐃緒申��申鐃緒申	 The following line does it, only if no icon has yet been created,
+
鐃緒申��申鐃緒申	 for some window managers.  But with mwm it crashes.
+
鐃緒申��申鐃緒申	 Some people say it should clear the IconPixmapHint bit in this case,
+
鐃緒申��申鐃緒申	 but that doesn't work, and the X consortium said it isn't the
+
鐃緒申��申鐃緒申	 right thing at all.  Since there is no way to win,
+
鐃緒申��申鐃緒申	 best to explicitly give up.  */
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申      f->output_data.x->wm_hints.icon_pixmap = None;
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申      return;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    Arg al[1];
+
鐃緒申��申鐃緒申    XtSetArg (al[0], XtNiconPixmap, icon_pixmap);
+
鐃緒申��申鐃緒申    XtSetValues (f->output_data.x->widget, al, 1);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  f->output_data.x->wm_hints.flags |= IconPixmapHint;
+
鐃緒申��申鐃緒申  XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_wm_set_icon_position (f, icon_x, icon_y)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     int icon_x, icon_y;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  Window window = XtWindow (f->output_data.x->widget);
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申  Window window = FRAME_X_WINDOW (f);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  f->output_data.x->wm_hints.flags |= IconPositionHint;
+
鐃緒申��申鐃緒申  f->output_data.x->wm_hints.icon_x = icon_x;
+
鐃緒申��申鐃緒申  f->output_data.x->wm_hints.icon_y = icon_y;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申				Fonts
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return a pointer to struct font_info of font FONT_IDX of frame F.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct font_info *
+
鐃緒申��申鐃緒申x_get_font_info (f, font_idx)
+
鐃緒申��申鐃緒申     FRAME_PTR f;
+
鐃緒申��申鐃緒申     int font_idx;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return (FRAME_X_FONT_TABLE (f) + font_idx);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return a list of names of available fonts matching PATTERN on frame F.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If SIZE is > 0, it is the size (maximum bounds width) of fonts
+
鐃緒申��申鐃緒申   to be listed.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   SIZE < 0 means include scalable fonts.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Frame F null means we have not yet created any frame on X, and
+
鐃緒申��申鐃緒申   consult the first display in x_display_list.  MAXNAMES sets a limit
+
鐃緒申��申鐃緒申   on how many fonts to match.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Lisp_Object
+
鐃緒申��申鐃緒申x_list_fonts (f, pattern, size, maxnames)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     Lisp_Object pattern;
+
鐃緒申��申鐃緒申     int size;
+
鐃緒申��申鐃緒申     int maxnames;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object list = Qnil, patterns, newlist = Qnil, key = Qnil;
+
鐃緒申��申鐃緒申  Lisp_Object tem, second_best;
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo
+
鐃緒申��申鐃緒申    = f ? FRAME_X_DISPLAY_INFO (f) : x_display_list;
+
鐃緒申��申鐃緒申  Display *dpy = dpyinfo->display;
+
鐃緒申��申鐃緒申  int try_XLoadQueryFont = 0;
+
鐃緒申��申鐃緒申  int count;
+
鐃緒申��申鐃緒申  int allow_scalable_fonts_p = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (size < 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      allow_scalable_fonts_p = 1;
+
鐃緒申��申鐃緒申      size = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  patterns = Fassoc (pattern, Valternate_fontname_alist);
+
鐃緒申��申鐃緒申  if (NILP (patterns))
+
鐃緒申��申鐃緒申    patterns = Fcons (pattern, Qnil);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (maxnames == 1 && !size)
+
鐃緒申��申鐃緒申    /* We can return any single font matching PATTERN.  */
+
鐃緒申��申鐃緒申    try_XLoadQueryFont = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (; CONSP (patterns); patterns = XCDR (patterns))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int num_fonts;
+
鐃緒申��申鐃緒申      char **names = NULL;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      pattern = XCAR (patterns);
+
鐃緒申��申鐃緒申      /* See if we cached the result for this particular query.
+
鐃緒申��申鐃緒申         The cache is an alist of the form:
+
鐃緒申��申鐃緒申	 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...)  */
+
鐃緒申��申鐃緒申      tem = XCDR (dpyinfo->name_list_element);
+
鐃緒申��申鐃緒申      key = Fcons (Fcons (pattern, make_number (maxnames)),
+
鐃緒申��申鐃緒申		   allow_scalable_fonts_p ? Qt : Qnil);
+
鐃緒申��申鐃緒申      list = Fassoc (key, tem);
+
鐃緒申��申鐃緒申      if (!NILP (list))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  list = Fcdr_safe (list);
+
鐃緒申��申鐃緒申	  /* We have a cashed list.  Don't have to get the list again.  */
+
鐃緒申��申鐃緒申	  goto label_cached;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* At first, put PATTERN in the cache.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      BLOCK_INPUT;
+
鐃緒申��申鐃緒申      count = x_catch_errors (dpy);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (try_XLoadQueryFont)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  XFontStruct *font;
+
鐃緒申��申鐃緒申	  unsigned long value;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  font = XLoadQueryFont (dpy, XSTRING (pattern)->data);
+
鐃緒申��申鐃緒申	  if (x_had_errors_p (dpy))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      /* This error is perhaps due to insufficient memory on X
+
鐃緒申��申鐃緒申                 server.  Let's just ignore it.  */
+
鐃緒申��申鐃緒申	      font = NULL;
+
鐃緒申��申鐃緒申	      x_clear_errors (dpy);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (font
+
鐃緒申��申鐃緒申	      && XGetFontProperty (font, XA_FONT, &value))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      char *name = (char *) XGetAtomName (dpy, (Atom) value);
+
鐃緒申��申鐃緒申	      int len = strlen (name);
+
鐃緒申��申鐃緒申	      char *tmp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      /* If DXPC (a Differential X Protocol Compressor)
+
鐃緒申��申鐃緒申                 Ver.3.7 is running, XGetAtomName will return null
+
鐃緒申��申鐃緒申                 string.  We must avoid such a name.  */
+
鐃緒申��申鐃緒申	      if (len == 0)
+
鐃緒申��申鐃緒申		try_XLoadQueryFont = 0;
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  num_fonts = 1;
+
鐃緒申��申鐃緒申		  names = (char **) alloca (sizeof (char *));
+
鐃緒申��申鐃緒申		  /* Some systems only allow alloca assigned to a
+
鐃緒申��申鐃緒申                     simple var.  */
+
鐃緒申��申鐃緒申		  tmp = (char *) alloca (len + 1);  names[0] = tmp;
+
鐃緒申��申鐃緒申		  bcopy (name, names[0], len + 1);
+
鐃緒申��申鐃緒申		  XFree (name);
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    try_XLoadQueryFont = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (font)
+
鐃緒申��申鐃緒申	    XFreeFont (dpy, font);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (!try_XLoadQueryFont)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* We try at least 10 fonts because XListFonts will return
+
鐃緒申��申鐃緒申	     auto-scaled fonts at the head.  */
+
鐃緒申��申鐃緒申	  names = XListFonts (dpy, XSTRING (pattern)->data, max (maxnames, 10),
+
鐃緒申��申鐃緒申			      &num_fonts);
+
鐃緒申��申鐃緒申	  if (x_had_errors_p (dpy))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      /* This error is perhaps due to insufficient memory on X
+
鐃緒申��申鐃緒申                 server.  Let's just ignore it.  */
+
鐃緒申��申鐃緒申	      names = NULL;
+
鐃緒申��申鐃緒申	      x_clear_errors (dpy);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      x_uncatch_errors (dpy, count);
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (names)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  /* Make a list of all the fonts we got back.
+
鐃緒申��申鐃緒申	     Store that in the font cache for the display.  */
+
鐃緒申��申鐃緒申	  for (i = 0; i < num_fonts; i++)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      int width = 0;
+
鐃緒申��申鐃緒申	      char *p = names[i];
+
鐃緒申��申鐃緒申	      int average_width = -1, dashes = 0;
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申	      /* Count the number of dashes in NAMES[I].  If there are
+
鐃緒申��申鐃緒申		 14 dashes, and the field value following 12th dash
+
鐃緒申��申鐃緒申		 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
+
鐃緒申��申鐃緒申		 is usually too ugly to be used for editing.  Let's
+
鐃緒申��申鐃緒申		 ignore it.  */
+
鐃緒申��申鐃緒申	      while (*p)
+
鐃緒申��申鐃緒申		if (*p++ == '-')
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    dashes++;
+
鐃緒申��申鐃緒申		    if (dashes == 7) /* PIXEL_SIZE field */
+
鐃緒申��申鐃緒申		      width = atoi (p);
+
鐃緒申��申鐃緒申		    else if (dashes == 12) /* AVERAGE_WIDTH field */
+
鐃緒申��申鐃緒申		      average_width = atoi (p);
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申	      
+
鐃緒申��申鐃緒申	      if (allow_scalable_fonts_p
+
鐃緒申��申鐃緒申		  || dashes < 14 || average_width != 0)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  tem = build_string (names[i]);
+
鐃緒申��申鐃緒申		  if (NILP (Fassoc (tem, list)))
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      if (STRINGP (Vx_pixel_size_width_font_regexp)
+
鐃緒申��申鐃緒申			  && ((fast_c_string_match_ignore_case
+
鐃緒申��申鐃緒申			       (Vx_pixel_size_width_font_regexp, names[i]))
+
鐃緒申��申鐃緒申			      >= 0))
+
鐃緒申��申鐃緒申			/* We can set the value of PIXEL_SIZE to the
+
鐃緒申��申鐃緒申			  width of this font.  */
+
鐃緒申��申鐃緒申			list = Fcons (Fcons (tem, make_number (width)), list);
+
鐃緒申��申鐃緒申		      else
+
鐃緒申��申鐃緒申			/* For the moment, width is not known.  */
+
鐃緒申��申鐃緒申			list = Fcons (Fcons (tem, Qnil), list);
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  if (!try_XLoadQueryFont)
+
鐃緒申��申鐃緒申	    XFreeFontNames (names);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Now store the result in the cache.  */
+
鐃緒申��申鐃緒申      XCDR (dpyinfo->name_list_element)
+
鐃緒申��申鐃緒申        = Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    label_cached:
+
鐃緒申��申鐃緒申      if (NILP (list)) continue; /* Try the remaining alternatives.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      newlist = second_best = Qnil;
+
鐃緒申��申鐃緒申      /* Make a list of the fonts that have the right width.  */
+
鐃緒申��申鐃緒申      for (; CONSP (list); list = XCDR (list))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int found_size;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  tem = XCAR (list);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (!CONSP (tem) || NILP (XCAR (tem)))
+
鐃緒申��申鐃緒申	    continue;
+
鐃緒申��申鐃緒申	  if (!size)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      newlist = Fcons (XCAR (tem), newlist);
+
鐃緒申��申鐃緒申	      continue;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (!INTEGERP (XCDR (tem)))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      /* Since we have not yet known the size of this font, we
+
鐃緒申��申鐃緒申		 must try slow function call XLoadQueryFont.  */
+
鐃緒申��申鐃緒申	      XFontStruct *thisinfo;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      BLOCK_INPUT;
+
鐃緒申��申鐃緒申	      count = x_catch_errors (dpy);
+
鐃緒申��申鐃緒申	      thisinfo = XLoadQueryFont (dpy,
+
鐃緒申��申鐃緒申					 XSTRING (XCAR (tem))->data);
+
鐃緒申��申鐃緒申	      if (x_had_errors_p (dpy))
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  /* This error is perhaps due to insufficient memory on X
+
鐃緒申��申鐃緒申		     server.  Let's just ignore it.  */
+
鐃緒申��申鐃緒申		  thisinfo = NULL;
+
鐃緒申��申鐃緒申		  x_clear_errors (dpy);
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      x_uncatch_errors (dpy, count);
+
鐃緒申��申鐃緒申	      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      if (thisinfo)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  XCDR (tem)
+
鐃緒申��申鐃緒申		    = (thisinfo->min_bounds.width == 0
+
鐃緒申��申鐃緒申		       ? make_number (0)
+
鐃緒申��申鐃緒申		       : make_number (thisinfo->max_bounds.width));
+
鐃緒申��申鐃緒申		  XFreeFont (dpy, thisinfo);
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		/* For unknown reason, the previous call of XListFont had
+
鐃緒申��申鐃緒申		  returned a font which can't be opened.  Record the size
+
鐃緒申��申鐃緒申		  as 0 not to try to open it again.  */
+
鐃緒申��申鐃緒申		XCDR (tem) = make_number (0);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  found_size = XINT (XCDR (tem));
+
鐃緒申��申鐃緒申	  if (found_size == size)
+
鐃緒申��申鐃緒申	    newlist = Fcons (XCAR (tem), newlist);
+
鐃緒申��申鐃緒申	  else if (found_size > 0)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      if (NILP (second_best))
+
鐃緒申��申鐃緒申		second_best = tem;
+
鐃緒申��申鐃緒申	      else if (found_size < size)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  if (XINT (XCDR (second_best)) > size
+
鐃緒申��申鐃緒申		      || XINT (XCDR (second_best)) < found_size)
+
鐃緒申��申鐃緒申		    second_best = tem;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  if (XINT (XCDR (second_best)) > size
+
鐃緒申��申鐃緒申		      && XINT (XCDR (second_best)) > found_size)
+
鐃緒申��申鐃緒申		    second_best = tem;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      if (!NILP (newlist))
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申      else if (!NILP (second_best))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  newlist = Fcons (XCAR (second_best), Qnil);
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return newlist;
+
鐃緒申��申鐃緒申}  
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if GLYPH_DEBUG
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Check that FONT is valid on frame F.  It is if it can be found in F's
+
鐃緒申��申鐃緒申   font table.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申x_check_font (f, font)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     XFontStruct *font;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i;
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (font != NULL);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (i = 0; i < dpyinfo->n_fonts; i++)
+
鐃緒申��申鐃緒申    if (dpyinfo->font_table[i].name 
+
鐃緒申��申鐃緒申	&& font == dpyinfo->font_table[i].font)
+
鐃緒申��申鐃緒申      break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (i < dpyinfo->n_fonts);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* GLYPH_DEBUG != 0 */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set *W to the minimum width, *H to the minimum font height of FONT.
+
鐃緒申��申鐃緒申   Note: There are (broken) X fonts out there with invalid XFontStruct
+
鐃緒申��申鐃緒申   min_bounds contents.  For example, [e-mail] reports that
+
鐃緒申��申鐃緒申   "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
+
鐃緒申��申鐃緒申   have font->min_bounds.width == 0.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static INLINE void
+
鐃緒申��申鐃緒申x_font_min_bounds (font, w, h)
+
鐃緒申��申鐃緒申     XFontStruct *font;
+
鐃緒申��申鐃緒申     int *w, *h;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  *h = FONT_HEIGHT (font);
+
鐃緒申��申鐃緒申  *w = font->min_bounds.width;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Try to handle the case where FONT->min_bounds has invalid
+
鐃緒申��申鐃緒申     contents.  Since the only font known to have invalid min_bounds
+
鐃緒申��申鐃緒申     is fixed-width, use max_bounds if min_bounds seems to be invalid.  */
+
鐃緒申��申鐃緒申  if (*w <= 0)
+
鐃緒申��申鐃緒申    *w = font->max_bounds.width;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Compute the smallest character width and smallest font height over
+
鐃緒申��申鐃緒申   all fonts available on frame F.  Set the members smallest_char_width
+
鐃緒申��申鐃緒申   and smallest_font_height in F's x_display_info structure to
+
鐃緒申��申鐃緒申   the values computed.  Value is non-zero if smallest_font_height or
+
鐃緒申��申鐃緒申   smallest_char_width become smaller than they were before.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申x_compute_min_glyph_bounds (f)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int i;
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  XFontStruct *font;
+
鐃緒申��申鐃緒申  int old_width = dpyinfo->smallest_char_width;
+
鐃緒申��申鐃緒申  int old_height = dpyinfo->smallest_font_height;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  dpyinfo->smallest_font_height = 100000;
+
鐃緒申��申鐃緒申  dpyinfo->smallest_char_width = 100000;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  for (i = 0; i < dpyinfo->n_fonts; ++i)
+
鐃緒申��申鐃緒申    if (dpyinfo->font_table[i].name)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	struct font_info *fontp = dpyinfo->font_table + i;
+
鐃緒申��申鐃緒申	int w, h;
+
鐃緒申��申鐃緒申	
+
鐃緒申��申鐃緒申	font = (XFontStruct *) fontp->font;
+
鐃緒申��申鐃緒申	xassert (font != (XFontStruct *) ~0);
+
鐃緒申��申鐃緒申	x_font_min_bounds (font, &w, &h);
+
鐃緒申��申鐃緒申	
+
鐃緒申��申鐃緒申	dpyinfo->smallest_font_height = min (dpyinfo->smallest_font_height, h);
+
鐃緒申��申鐃緒申	dpyinfo->smallest_char_width = min (dpyinfo->smallest_char_width, w);
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xassert (dpyinfo->smallest_char_width > 0
+
鐃緒申��申鐃緒申	   && dpyinfo->smallest_font_height > 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return (dpyinfo->n_fonts == 1
+
鐃緒申��申鐃緒申	  || dpyinfo->smallest_char_width < old_width
+
鐃緒申��申鐃緒申	  || dpyinfo->smallest_font_height < old_height);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Load font named FONTNAME of the size SIZE for frame F, and return a
+
鐃緒申��申鐃緒申   pointer to the structure font_info while allocating it dynamically.
+
鐃緒申��申鐃緒申   If SIZE is 0, load any size of font.
+
鐃緒申��申鐃緒申   If loading is failed, return NULL.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct font_info *
+
鐃緒申��申鐃緒申x_load_font (f, fontname, size)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     register char *fontname;
+
鐃緒申��申鐃緒申     int size;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  Lisp_Object font_names;
+
鐃緒申��申鐃緒申  int count;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get a list of all the fonts that match this name.  Once we
+
鐃緒申��申鐃緒申     have a list of matching fonts, we compare them against the fonts
+
鐃緒申��申鐃緒申     we already have by comparing names.  */
+
鐃緒申��申鐃緒申  font_names = x_list_fonts (f, build_string (fontname), size, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!NILP (font_names))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object tail;
+
鐃緒申��申鐃緒申      int i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      for (i = 0; i < dpyinfo->n_fonts; i++)
+
鐃緒申��申鐃緒申	for (tail = font_names; CONSP (tail); tail = XCDR (tail))
+
鐃緒申��申鐃緒申	  if (dpyinfo->font_table[i].name
+
鐃緒申��申鐃緒申	      && (!strcmp (dpyinfo->font_table[i].name,
+
鐃緒申��申鐃緒申			   XSTRING (XCAR (tail))->data)
+
鐃緒申��申鐃緒申		  || !strcmp (dpyinfo->font_table[i].full_name,
+
鐃緒申��申鐃緒申			      XSTRING (XCAR (tail))->data)))
+
鐃緒申��申鐃緒申	    return (dpyinfo->font_table + i);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Load the font and add it to the table.  */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    char *full_name;
+
鐃緒申��申鐃緒申    XFontStruct *font;
+
鐃緒申��申鐃緒申    struct font_info *fontp;
+
鐃緒申��申鐃緒申    unsigned long value;
+
鐃緒申��申鐃緒申    int i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* If we have found fonts by x_list_font, load one of them.  If
+
鐃緒申��申鐃緒申       not, we still try to load a font by the name given as FONTNAME
+
鐃緒申��申鐃緒申       because XListFonts (called in x_list_font) of some X server has
+
鐃緒申��申鐃緒申       a bug of not finding a font even if the font surely exists and
+
鐃緒申��申鐃緒申       is loadable by XLoadQueryFont.  */
+
鐃緒申��申鐃緒申    if (size > 0 && !NILP (font_names))
+
鐃緒申��申鐃緒申      fontname = (char *) XSTRING (XCAR (font_names))->data;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    BLOCK_INPUT;
+
鐃緒申��申鐃緒申    count = x_catch_errors (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申    font = (XFontStruct *) XLoadQueryFont (FRAME_X_DISPLAY (f), fontname);
+
鐃緒申��申鐃緒申    if (x_had_errors_p (FRAME_X_DISPLAY (f)))
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	/* This error is perhaps due to insufficient memory on X
+
鐃緒申��申鐃緒申	   server.  Let's just ignore it.  */
+
鐃緒申��申鐃緒申	font = NULL;
+
鐃緒申��申鐃緒申	x_clear_errors (FRAME_X_DISPLAY (f));
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申    x_uncatch_errors (FRAME_X_DISPLAY (f), count);
+
鐃緒申��申鐃緒申    UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    if (!font)
+
鐃緒申��申鐃緒申      return NULL;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Find a free slot in the font table.  */
+
鐃緒申��申鐃緒申    for (i = 0; i < dpyinfo->n_fonts; ++i)
+
鐃緒申��申鐃緒申      if (dpyinfo->font_table[i].name == NULL)
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* If no free slot found, maybe enlarge the font table.  */
+
鐃緒申��申鐃緒申    if (i == dpyinfo->n_fonts
+
鐃緒申��申鐃緒申	&& dpyinfo->n_fonts == dpyinfo->font_table_size)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	int sz;
+
鐃緒申��申鐃緒申	dpyinfo->font_table_size = max (16, 2 * dpyinfo->font_table_size);
+
鐃緒申��申鐃緒申	sz = dpyinfo->font_table_size * sizeof *dpyinfo->font_table;
+
鐃緒申��申鐃緒申	dpyinfo->font_table
+
鐃緒申��申鐃緒申	  = (struct font_info *) xrealloc (dpyinfo->font_table, sz);
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    fontp = dpyinfo->font_table + i;
+
鐃緒申��申鐃緒申    if (i == dpyinfo->n_fonts)
+
鐃緒申��申鐃緒申      ++dpyinfo->n_fonts;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Now fill in the slots of *FONTP.  */
+
鐃緒申��申鐃緒申    BLOCK_INPUT;
+
鐃緒申��申鐃緒申    fontp->font = font;
+
鐃緒申��申鐃緒申    fontp->font_idx = i;
+
鐃緒申��申鐃緒申    fontp->name = (char *) xmalloc (strlen (fontname) + 1);
+
鐃緒申��申鐃緒申    bcopy (fontname, fontp->name, strlen (fontname) + 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Try to get the full name of FONT.  Put it in FULL_NAME.  */
+
鐃緒申��申鐃緒申    full_name = 0;
+
鐃緒申��申鐃緒申    if (XGetFontProperty (font, XA_FONT, &value))
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	char *name = (char *) XGetAtomName (FRAME_X_DISPLAY (f), (Atom) value);
+
鐃緒申��申鐃緒申	char *p = name;
+
鐃緒申��申鐃緒申	int dashes = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	/* Count the number of dashes in the "full name".
+
鐃緒申��申鐃緒申	   If it is too few, this isn't really the font's full name,
+
鐃緒申��申鐃緒申	   so don't use it.
+
鐃緒申��申鐃緒申	   In X11R4, the fonts did not come with their canonical names
+
鐃緒申��申鐃緒申	   stored in them.  */
+
鐃緒申��申鐃緒申	while (*p)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    if (*p == '-')
+
鐃緒申��申鐃緒申	      dashes++;
+
鐃緒申��申鐃緒申	    p++;
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	if (dashes >= 13)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    full_name = (char *) xmalloc (p - name + 1);
+
鐃緒申��申鐃緒申	    bcopy (name, full_name, p - name + 1);
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	XFree (name);
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申    
+
鐃緒申��申鐃緒申    if (full_name != 0)
+
鐃緒申��申鐃緒申      fontp->full_name = full_name;
+
鐃緒申��申鐃緒申    else
+
鐃緒申��申鐃緒申      fontp->full_name = fontp->name;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    fontp->size = font->max_bounds.width;
+
鐃緒申��申鐃緒申    fontp->height = FONT_HEIGHT (font);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    if (NILP (font_names))
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	/* We come here because of a bug of XListFonts mentioned at
+
鐃緒申��申鐃緒申	   the head of this block.  Let's store this information in
+
鐃緒申��申鐃緒申	   the cache for x_list_fonts.  */
+
鐃緒申��申鐃緒申	Lisp_Object lispy_name = build_string (fontname);
+
鐃緒申��申鐃緒申	Lisp_Object lispy_full_name = build_string (fontp->full_name);
+
鐃緒申��申鐃緒申	Lisp_Object key = Fcons (Fcons (lispy_name, make_number (256)),
+
鐃緒申��申鐃緒申				 Qnil);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	XCDR (dpyinfo->name_list_element)
+
鐃緒申��申鐃緒申	  = Fcons (Fcons (key,
+
鐃緒申��申鐃緒申			  Fcons (Fcons (lispy_full_name,
+
鐃緒申��申鐃緒申					make_number (fontp->size)),
+
鐃緒申��申鐃緒申				 Qnil)),
+
鐃緒申��申鐃緒申		   XCDR (dpyinfo->name_list_element));
+
鐃緒申��申鐃緒申	if (full_name)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    key = Fcons (Fcons (lispy_full_name, make_number (256)),
+
鐃緒申��申鐃緒申			 Qnil);
+
鐃緒申��申鐃緒申	    XCDR (dpyinfo->name_list_element)
+
鐃緒申��申鐃緒申	      = Fcons (Fcons (key,
+
鐃緒申��申鐃緒申			      Fcons (Fcons (lispy_full_name,
+
鐃緒申��申鐃緒申					    make_number (fontp->size)),
+
鐃緒申��申鐃緒申				     Qnil)),
+
鐃緒申��申鐃緒申		       XCDR (dpyinfo->name_list_element));
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* The slot `encoding' specifies how to map a character
+
鐃緒申��申鐃緒申       code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
+
鐃緒申��申鐃緒申       the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
+
鐃緒申��申鐃緒申       (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
+
鐃緒申��申鐃緒申       2:0xA020..0xFF7F).  For the moment, we don't know which charset
+
鐃緒申��申鐃緒申       uses this font.  So, we set information in fontp->encoding[1]
+
鐃緒申��申鐃緒申       which is never used by any charset.  If mapping can't be
+
鐃緒申��申鐃緒申       decided, set FONT_ENCODING_NOT_DECIDED.  */
+
鐃緒申��申鐃緒申    fontp->encoding[1]
+
鐃緒申��申鐃緒申      = (font->max_byte1 == 0
+
鐃緒申��申鐃緒申	 /* 1-byte font */
+
鐃緒申��申鐃緒申	 ? (font->min_char_or_byte2 < 0x80
+
鐃緒申��申鐃緒申	    ? (font->max_char_or_byte2 < 0x80
+
鐃緒申��申鐃緒申	       ? 0		/* 0x20..0x7F */
+
鐃緒申��申鐃緒申	       : FONT_ENCODING_NOT_DECIDED) /* 0x20..0xFF */
+
鐃緒申��申鐃緒申	    : 1)		/* 0xA0..0xFF */
+
鐃緒申��申鐃緒申	 /* 2-byte font */
+
鐃緒申��申鐃緒申	 : (font->min_byte1 < 0x80
+
鐃緒申��申鐃緒申	    ? (font->max_byte1 < 0x80
+
鐃緒申��申鐃緒申	       ? (font->min_char_or_byte2 < 0x80
+
鐃緒申��申鐃緒申		  ? (font->max_char_or_byte2 < 0x80
+
鐃緒申��申鐃緒申		     ? 0		/* 0x2020..0x7F7F */
+
鐃緒申��申鐃緒申		     : FONT_ENCODING_NOT_DECIDED) /* 0x2020..0x7FFF */
+
鐃緒申��申鐃緒申		  : 3)		/* 0x20A0..0x7FFF */
+
鐃緒申��申鐃緒申	       : FONT_ENCODING_NOT_DECIDED) /* 0x20??..0xA0?? */
+
鐃緒申��申鐃緒申	    : (font->min_char_or_byte2 < 0x80
+
鐃緒申��申鐃緒申	       ? (font->max_char_or_byte2 < 0x80
+
鐃緒申��申鐃緒申		  ? 2		/* 0xA020..0xFF7F */
+
鐃緒申��申鐃緒申		  : FONT_ENCODING_NOT_DECIDED) /* 0xA020..0xFFFF */
+
鐃緒申��申鐃緒申	       : 1)));		/* 0xA0A0..0xFFFF */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    fontp->baseline_offset
+
鐃緒申��申鐃緒申      = (XGetFontProperty (font, dpyinfo->Xatom_MULE_BASELINE_OFFSET, &value)
+
鐃緒申��申鐃緒申	 ? (long) value : 0);
+
鐃緒申��申鐃緒申    fontp->relative_compose
+
鐃緒申��申鐃緒申      = (XGetFontProperty (font, dpyinfo->Xatom_MULE_RELATIVE_COMPOSE, &value)
+
鐃緒申��申鐃緒申	 ? (long) value : 0);
+
鐃緒申��申鐃緒申    fontp->default_ascent
+
鐃緒申��申鐃緒申      = (XGetFontProperty (font, dpyinfo->Xatom_MULE_DEFAULT_ASCENT, &value)
+
鐃緒申��申鐃緒申	 ? (long) value : 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    /* Set global flag fonts_changed_p to non-zero if the font loaded
+
鐃緒申��申鐃緒申       has a character with a smaller width than any other character
+
鐃緒申��申鐃緒申       before, or if the font loaded has a smalle>r height than any
+
鐃緒申��申鐃緒申       other font loaded before.  If this happens, it will make a
+
鐃緒申��申鐃緒申       glyph matrix reallocation necessary.  */
+
鐃緒申��申鐃緒申    fonts_changed_p = x_compute_min_glyph_bounds (f);
+
鐃緒申��申鐃緒申    UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申    return fontp;
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Return a pointer to struct font_info of a font named FONTNAME for
+
鐃緒申��申鐃緒申   frame F.  If no such font is loaded, return NULL.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct font_info *
+
鐃緒申��申鐃緒申x_query_font (f, fontname)
+
鐃緒申��申鐃緒申     struct frame *f;
+
鐃緒申��申鐃緒申     register char *fontname;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
鐃緒申��申鐃緒申  int i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (i = 0; i < dpyinfo->n_fonts; i++)
+
鐃緒申��申鐃緒申    if (dpyinfo->font_table[i].name
+
鐃緒申��申鐃緒申	&& (!strcmp (dpyinfo->font_table[i].name, fontname)
+
鐃緒申��申鐃緒申	    || !strcmp (dpyinfo->font_table[i].full_name, fontname)))
+
鐃緒申��申鐃緒申      return (dpyinfo->font_table + i);
+
鐃緒申��申鐃緒申  return NULL;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Find a CCL program for a font specified by FONTP, and set the member
+
鐃緒申��申鐃緒申 `encoder' of the structure.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_find_ccl_program (fontp)
+
鐃緒申��申鐃緒申     struct font_info *fontp;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object list, elt;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  elt = Qnil;
+
鐃緒申��申鐃緒申  for (list = Vfont_ccl_encoder_alist; CONSP (list); list = XCDR (list))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      elt = XCAR (list);
+
鐃緒申��申鐃緒申      if (CONSP (elt)
+
鐃緒申��申鐃緒申	  && STRINGP (XCAR (elt))
+
鐃緒申��申鐃緒申	  && ((fast_c_string_match_ignore_case (XCAR (elt), fontp->name)
+
鐃緒申��申鐃緒申	       >= 0)
+
鐃緒申��申鐃緒申	      || (fast_c_string_match_ignore_case (XCAR (elt), fontp->full_name)
+
鐃緒申��申鐃緒申		  >= 0)))
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  if (! NILP (list))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct ccl_program *ccl
+
鐃緒申��申鐃緒申	= (struct ccl_program *) xmalloc (sizeof (struct ccl_program));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (setup_ccl_program (ccl, XCDR (elt)) < 0)
+
鐃緒申��申鐃緒申	xfree (ccl);
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	fontp->font_encoder = ccl;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/***********************************************************************
+
鐃緒申��申鐃緒申			    Initialization
+
鐃緒申��申鐃緒申 ***********************************************************************/
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申static XrmOptionDescRec emacs_options[] = {
+
鐃緒申��申鐃緒申  {"-geometry",	".geometry", XrmoptionSepArg, NULL},
+
鐃緒申��申鐃緒申  {"-iconic",	".iconic", XrmoptionNoArg, (XtPointer) "yes"},
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
+
鐃緒申��申鐃緒申     XrmoptionSepArg, NULL},
+
鐃緒申��申鐃緒申  {"-ib",	"*EmacsScreen.internalBorderWidth", XrmoptionSepArg, NULL},
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {"-T",	"*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
+
鐃緒申��申鐃緒申  {"-wn",	"*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
+
鐃緒申��申鐃緒申  {"-title",	"*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
+
鐃緒申��申鐃緒申  {"-iconname",	"*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
+
鐃緒申��申鐃緒申  {"-in",	"*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
+
鐃緒申��申鐃緒申  {"-mc",	"*pointerColor", XrmoptionSepArg, (XtPointer) NULL},
+
鐃緒申��申鐃緒申  {"-cr",	"*cursorColor", XrmoptionSepArg, (XtPointer) NULL}
+
鐃緒申��申鐃緒申};
+
鐃緒申��申鐃緒申#endif /* USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int x_initialized;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef MULTI_KBOARD
+
鐃緒申��申鐃緒申/* Test whether two display-name strings agree up to the dot that separates
+
鐃緒申��申鐃緒申   the screen number from the server number.  */
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申same_x_server (name1, name2)
+
鐃緒申��申鐃緒申     char *name1, *name2;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int seen_colon = 0;
+
鐃緒申��申鐃緒申  unsigned char *system_name = XSTRING (Vsystem_name)->data;
+
鐃緒申��申鐃緒申  int system_name_length = strlen (system_name);
+
鐃緒申��申鐃緒申  int length_until_period = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  while (system_name[length_until_period] != 0
+
鐃緒申��申鐃緒申	 && system_name[length_until_period] != '.')
+
鐃緒申��申鐃緒申    length_until_period++;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Treat `unix' like an empty host name.  */
+
鐃緒申��申鐃緒申  if (! strncmp (name1, "unix:", 5))
+
鐃緒申��申鐃緒申    name1 += 4;
+
鐃緒申��申鐃緒申  if (! strncmp (name2, "unix:", 5))
+
鐃緒申��申鐃緒申    name2 += 4;
+
鐃緒申��申鐃緒申  /* Treat this host's name like an empty host name.  */
+
鐃緒申��申鐃緒申  if (! strncmp (name1, system_name, system_name_length)
+
鐃緒申��申鐃緒申      && name1[system_name_length] == ':')
+
鐃緒申��申鐃緒申    name1 += system_name_length;
+
鐃緒申��申鐃緒申  if (! strncmp (name2, system_name, system_name_length)
+
鐃緒申��申鐃緒申      && name2[system_name_length] == ':')
+
鐃緒申��申鐃緒申    name2 += system_name_length;
+
鐃緒申��申鐃緒申  /* Treat this host's domainless name like an empty host name.  */
+
鐃緒申��申鐃緒申  if (! strncmp (name1, system_name, length_until_period)
+
鐃緒申��申鐃緒申      && name1[length_until_period] == ':')
+
鐃緒申��申鐃緒申    name1 += length_until_period;
+
鐃緒申��申鐃緒申  if (! strncmp (name2, system_name, length_until_period)
+
鐃緒申��申鐃緒申      && name2[length_until_period] == ':')
+
鐃緒申��申鐃緒申    name2 += length_until_period;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (; *name1 != '\0' && *name1 == *name2; name1++, name2++)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (*name1 == ':')
+
鐃緒申��申鐃緒申	seen_colon++;
+
鐃緒申��申鐃緒申      if (seen_colon && *name1 == '.')
+
鐃緒申��申鐃緒申	return 1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  return (seen_colon
+
鐃緒申��申鐃緒申	  && (*name1 == '.' || *name1 == '\0')
+
鐃緒申��申鐃緒申	  && (*name2 == '.' || *name2 == '\0'));
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct x_display_info *
+
鐃緒申��申鐃緒申x_term_init (display_name, xrm_option, resource_name)
+
鐃緒申��申鐃緒申     Lisp_Object display_name;
+
鐃緒申��申鐃緒申     char *xrm_option;
+
鐃緒申��申鐃緒申     char *resource_name;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int connection;
+
鐃緒申��申鐃緒申  Display *dpy;
+
鐃緒申��申鐃緒申  struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申  XrmDatabase xrdb;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!x_initialized)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      x_initialize ();
+
鐃緒申��申鐃緒申      x_initialized = 1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  /* [e-mail] reports that this causes
+
鐃緒申��申鐃緒申     errors with X11R5:
+
鐃緒申��申鐃緒申	   X protocol error: BadAtom (invalid Atom parameter)
+
鐃緒申��申鐃緒申	   on protocol request 18skiloaf.
+
鐃緒申��申鐃緒申     So let's not use it until R6.  */
+
鐃緒申��申鐃緒申#ifdef HAVE_X11XTR6
+
鐃緒申��申鐃緒申  XtSetLanguageProc (NULL, NULL, NULL);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    int argc = 0;
+
鐃緒申��申鐃緒申    char *argv[3];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    argv[0] = "";
+
鐃緒申��申鐃緒申    argc = 1;
+
鐃緒申��申鐃緒申    if (xrm_option)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	argv[argc++] = "-xrm";
+
鐃緒申��申鐃緒申	argv[argc++] = xrm_option;
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申    dpy = XtOpenDisplay (Xt_app_con, XSTRING (display_name)->data,
+
鐃緒申��申鐃緒申			 resource_name, EMACS_CLASS,
+
鐃緒申��申鐃緒申			 emacs_options, XtNumber (emacs_options),
+
鐃緒申��申鐃緒申			 &argc, argv);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X11XTR6
+
鐃緒申��申鐃緒申    /* I think this is to compensate for XtSetLanguageProc.  */
+
鐃緒申��申鐃緒申    fixup_locale ();
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#else /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R5
+
鐃緒申��申鐃緒申  XSetLocaleModifiers ("");
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  dpy = XOpenDisplay (XSTRING (display_name)->data);
+
鐃緒申��申鐃緒申#endif /* not USE_X_TOOLKIT */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Detect failure.  */
+
鐃緒申��申鐃緒申  if (dpy == 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申      return 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* We have definitely succeeded.  Record the new connection.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo = (struct x_display_info *) xmalloc (sizeof (struct x_display_info));
+
鐃緒申��申鐃緒申  bzero (dpyinfo, sizeof *dpyinfo);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef MULTI_KBOARD
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    struct x_display_info *share;
+
鐃緒申��申鐃緒申    Lisp_Object tail;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    for (share = x_display_list, tail = x_display_name_list; share;
+
鐃緒申��申鐃緒申	 share = share->next, tail = XCDR (tail))
+
鐃緒申��申鐃緒申      if (same_x_server (XSTRING (XCAR (XCAR (tail)))->data,
+
鐃緒申��申鐃緒申			 XSTRING (display_name)->data))
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申    if (share)
+
鐃緒申��申鐃緒申      dpyinfo->kboard = share->kboard;
+
鐃緒申��申鐃緒申    else
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	dpyinfo->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
+
鐃緒申��申鐃緒申	init_kboard (dpyinfo->kboard);
+
鐃緒申��申鐃緒申	if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound))
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    char *vendor = ServerVendor (dpy);
+
鐃緒申��申鐃緒申	    UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申	    dpyinfo->kboard->Vsystem_key_alist
+
鐃緒申��申鐃緒申	      = call1 (Qvendor_specific_keysyms,
+
鐃緒申��申鐃緒申		       build_string (vendor ? vendor : ""));
+
鐃緒申��申鐃緒申	    BLOCK_INPUT;
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	dpyinfo->kboard->next_kboard = all_kboards;
+
鐃緒申��申鐃緒申	all_kboards = dpyinfo->kboard;
+
鐃緒申��申鐃緒申	/* Don't let the initial kboard remain current longer than necessary.
+
鐃緒申��申鐃緒申	   That would cause problems if a file loaded on startup tries to
+
鐃緒申��申鐃緒申	   prompt in the mini-buffer.  */
+
鐃緒申��申鐃緒申	if (current_kboard == initial_kboard)
+
鐃緒申��申鐃緒申	  current_kboard = dpyinfo->kboard;
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申    dpyinfo->kboard->reference_count++;
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Put this display on the chain.  */
+
鐃緒申��申鐃緒申  dpyinfo->next = x_display_list;
+
鐃緒申��申鐃緒申  x_display_list = dpyinfo;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Put it on x_display_name_list as well, to keep them parallel.  */ 
+
鐃緒申��申鐃緒申  x_display_name_list = Fcons (Fcons (display_name, Qnil),
+
鐃緒申��申鐃緒申			       x_display_name_list);
+
鐃緒申��申鐃緒申  dpyinfo->name_list_element = XCAR (x_display_name_list);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo->display = dpy;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#if 0
+
鐃緒申��申鐃緒申  XSetAfterFunction (x_current_display, x_trace_wire);
+
鐃緒申��申鐃緒申#endif /* ! 0 */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo->x_id_name
+
鐃緒申��申鐃緒申    = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name))
+
鐃緒申��申鐃緒申			+ STRING_BYTES (XSTRING (Vsystem_name))
+
鐃緒申��申鐃緒申			+ 2);
+
鐃緒申��申鐃緒申  sprintf (dpyinfo->x_id_name, "%s@%s",
+
鐃緒申��申鐃緒申	   XSTRING (Vinvocation_name)->data, XSTRING (Vsystem_name)->data);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Figure out which modifier bits mean what.  */
+
鐃緒申��申鐃緒申  x_find_modifier_meanings (dpyinfo);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get the scroll bar cursor.  */
+
鐃緒申��申鐃緒申  dpyinfo->vertical_scroll_bar_cursor
+
鐃緒申��申鐃緒申    = XCreateFontCursor (dpyinfo->display, XC_sb_v_double_arrow);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  xrdb = x_load_resources (dpyinfo->display, xrm_option,
+
鐃緒申��申鐃緒申			   resource_name, EMACS_CLASS);
+
鐃緒申��申鐃緒申#ifdef HAVE_XRMSETDATABASE
+
鐃緒申��申鐃緒申  XrmSetDatabase (dpyinfo->display, xrdb);
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申  dpyinfo->display->db = xrdb;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  /* Put the rdb where we can find it in a way that works on
+
鐃緒申��申鐃緒申     all versions.  */
+
鐃緒申��申鐃緒申  dpyinfo->xrdb = xrdb;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo->screen = ScreenOfDisplay (dpyinfo->display,
+
鐃緒申��申鐃緒申				     DefaultScreen (dpyinfo->display));
+
鐃緒申��申鐃緒申  select_visual (dpyinfo);
+
鐃緒申��申鐃緒申  dpyinfo->cmap = DefaultColormapOfScreen (dpyinfo->screen);
+
鐃緒申��申鐃緒申  dpyinfo->height = HeightOfScreen (dpyinfo->screen);
+
鐃緒申��申鐃緒申  dpyinfo->width = WidthOfScreen (dpyinfo->screen);
+
鐃緒申��申鐃緒申  dpyinfo->root_window = RootWindowOfScreen (dpyinfo->screen);
+
鐃緒申��申鐃緒申  dpyinfo->grabbed = 0;
+
鐃緒申��申鐃緒申  dpyinfo->reference_count = 0;
+
鐃緒申��申鐃緒申  dpyinfo->icon_bitmap_id = -1;
+
鐃緒申��申鐃緒申  dpyinfo->font_table = NULL;
+
鐃緒申��申鐃緒申  dpyinfo->n_fonts = 0;
+
鐃緒申��申鐃緒申  dpyinfo->font_table_size = 0;
+
鐃緒申��申鐃緒申  dpyinfo->bitmaps = 0;
+
鐃緒申��申鐃緒申  dpyinfo->bitmaps_size = 0;
+
鐃緒申��申鐃緒申  dpyinfo->bitmaps_last = 0;
+
鐃緒申��申鐃緒申  dpyinfo->scratch_cursor_gc = 0;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_mouse_frame = 0;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_deferred_gc = 0;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_window = Qnil;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_overlay = Qnil;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_mouse_x = dpyinfo->mouse_face_mouse_y = 0;
+
鐃緒申��申鐃緒申  dpyinfo->mouse_face_defer = 0;
+
鐃緒申��申鐃緒申  dpyinfo->x_focus_frame = 0;
+
鐃緒申��申鐃緒申  dpyinfo->x_focus_event_frame = 0;
+
鐃緒申��申鐃緒申  dpyinfo->x_highlight_frame = 0;
+
鐃緒申��申鐃緒申  dpyinfo->image_cache = make_image_cache ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* See if a private colormap is requested.  */
+
鐃緒申��申鐃緒申  if (dpyinfo->visual == DefaultVisualOfScreen (dpyinfo->screen))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (dpyinfo->visual->class == PseudoColor)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  Lisp_Object value;
+
鐃緒申��申鐃緒申	  value = display_x_get_resource (dpyinfo,
+
鐃緒申��申鐃緒申					  build_string ("privateColormap"),
+
鐃緒申��申鐃緒申					  build_string ("PrivateColormap"),
+
鐃緒申��申鐃緒申					  Qnil, Qnil);
+
鐃緒申��申鐃緒申	  if (STRINGP (value)
+
鐃緒申��申鐃緒申	      && (!strcmp (XSTRING (value)->data, "true")
+
鐃緒申��申鐃緒申		  || !strcmp (XSTRING (value)->data, "on")))
+
鐃緒申��申鐃緒申	    dpyinfo->cmap = XCopyColormapAndFree (dpyinfo->display, dpyinfo->cmap);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    dpyinfo->cmap = XCreateColormap (dpyinfo->display, dpyinfo->root_window,
+
鐃緒申��申鐃緒申				     dpyinfo->visual, AllocNone);
+
鐃緒申��申鐃緒申      
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    int screen_number = XScreenNumberOfScreen (dpyinfo->screen);
+
鐃緒申��申鐃緒申    double pixels = DisplayHeight (dpyinfo->display, screen_number);
+
鐃緒申��申鐃緒申    double mm = DisplayHeightMM (dpyinfo->display, screen_number);
+
鐃緒申��申鐃緒申    dpyinfo->resy = pixels * 25.4 / mm;
+
鐃緒申��申鐃緒申    pixels = DisplayWidth (dpyinfo->display, screen_number);
+
鐃緒申��申鐃緒申    mm = DisplayWidthMM (dpyinfo->display, screen_number);
+
鐃緒申��申鐃緒申    dpyinfo->resx = pixels * 25.4 / mm;
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_wm_protocols
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "WM_PROTOCOLS", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_wm_take_focus
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "WM_TAKE_FOCUS", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_wm_save_yourself
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "WM_SAVE_YOURSELF", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_wm_delete_window
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "WM_DELETE_WINDOW", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_wm_change_state
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "WM_CHANGE_STATE", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_wm_configure_denied
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "WM_CONFIGURE_DENIED", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_wm_window_moved
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "WM_MOVED", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_editres
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "Editres", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_CLIPBOARD
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "CLIPBOARD", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_TIMESTAMP
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "TIMESTAMP", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_TEXT
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "TEXT", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_COMPOUND_TEXT
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "COMPOUND_TEXT", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_DELETE
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "DELETE", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_MULTIPLE
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "MULTIPLE", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_INCR
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "INCR", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_EMACS_TMP
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "_EMACS_TMP_", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_TARGETS
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "TARGETS", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_NULL
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "NULL", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_ATOM_PAIR
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "ATOM_PAIR", False);
+
鐃緒申��申鐃緒申  /* For properties of font.  */
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_PIXEL_SIZE
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "PIXEL_SIZE", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_MULE_BASELINE_OFFSET
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "_MULE_BASELINE_OFFSET", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_MULE_RELATIVE_COMPOSE
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "_MULE_RELATIVE_COMPOSE", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_MULE_DEFAULT_ASCENT
+
鐃緒申��申鐃緒申    = XInternAtom (dpyinfo->display, "_MULE_DEFAULT_ASCENT", False);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Ghostscript support.  */
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_PAGE = XInternAtom (dpyinfo->display, "PAGE", False);
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_DONE = XInternAtom (dpyinfo->display, "DONE", False);
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  dpyinfo->Xatom_Scrollbar = XInternAtom (dpyinfo->display, "SCROLLBAR",
+
鐃緒申��申鐃緒申					  False);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  dpyinfo->cut_buffers_initialized = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  connection = ConnectionNumber (dpyinfo->display);
+
鐃緒申��申鐃緒申  dpyinfo->connection = connection;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    char null_bits[1];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    null_bits[0] = 0x00;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    dpyinfo->null_pixel
+
鐃緒申��申鐃緒申      = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window, 
+
鐃緒申��申鐃緒申				     null_bits, 1, 1, (long) 0, (long) 0,
+
鐃緒申��申鐃緒申				     1);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    extern int gray_bitmap_width, gray_bitmap_height;
+
鐃緒申��申鐃緒申    extern char *gray_bitmap_bits;
+
鐃緒申��申鐃緒申    dpyinfo->gray
+
鐃緒申��申鐃緒申      = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
+
鐃緒申��申鐃緒申				     gray_bitmap_bits,
+
鐃緒申��申鐃緒申				     gray_bitmap_width, gray_bitmap_height,
+
鐃緒申��申鐃緒申				     (unsigned long) 1, (unsigned long) 0, 1);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申  xim_initialize (dpyinfo, resource_name);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#ifdef subprocesses
+
鐃緒申��申鐃緒申  /* This is only needed for distinguishing keyboard and process input.  */
+
鐃緒申��申鐃緒申  if (connection != 0)
+
鐃緒申��申鐃緒申    add_keyboard_wait_descriptor (connection);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef F_SETOWN_BUG
+
鐃緒申��申鐃緒申#ifdef F_SETOWN
+
鐃緒申��申鐃緒申#ifdef F_SETOWN_SOCK_NEG
+
鐃緒申��申鐃緒申  /* stdin is a socket here */
+
鐃緒申��申鐃緒申  fcntl (connection, F_SETOWN, -getpid ());
+
鐃緒申��申鐃緒申#else /* ! defined (F_SETOWN_SOCK_NEG) */
+
鐃緒申��申鐃緒申  fcntl (connection, F_SETOWN, getpid ());
+
鐃緒申��申鐃緒申#endif /* ! defined (F_SETOWN_SOCK_NEG) */
+
鐃緒申��申鐃緒申#endif /* ! defined (F_SETOWN) */
+
鐃緒申��申鐃緒申#endif /* F_SETOWN_BUG */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef SIGIO
+
鐃緒申��申鐃緒申  if (interrupt_input)
+
鐃緒申��申鐃緒申    init_sigio (connection);
+
鐃緒申��申鐃緒申#endif /* ! defined (SIGIO) */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_LUCID
+
鐃緒申��申鐃緒申#ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer.  */
+
鐃緒申��申鐃緒申  /* Make sure that we have a valid font for dialog boxes
+
鐃緒申��申鐃緒申     so that Xt does not crash.  */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    Display *dpy = dpyinfo->display;
+
鐃緒申��申鐃緒申    XrmValue d, fr, to;
+
鐃緒申��申鐃緒申    Font font;
+
鐃緒申��申鐃緒申    int count;
+
鐃緒申��申鐃緒申    
+
鐃緒申��申鐃緒申    d.addr = (XPointer)&dpy;
+
鐃緒申��申鐃緒申    d.size = sizeof (Display *);
+
鐃緒申��申鐃緒申    fr.addr = XtDefaultFont;
+
鐃緒申��申鐃緒申    fr.size = sizeof (XtDefaultFont);
+
鐃緒申��申鐃緒申    to.size = sizeof (Font *);
+
鐃緒申��申鐃緒申    to.addr = (XPointer)&font;
+
鐃緒申��申鐃緒申    count = x_catch_errors (dpy);
+
鐃緒申��申鐃緒申    if (!XtCallConverter (dpy, XtCvtStringToFont, &d, 1, &fr, &to, NULL))
+
鐃緒申��申鐃緒申      abort ();
+
鐃緒申��申鐃緒申    if (x_had_errors_p (dpy) || !XQueryFont (dpy, font))
+
鐃緒申��申鐃緒申      XrmPutLineResource (&xrdb, "Emacs.dialog.*.font: 9x15");
+
鐃緒申��申鐃緒申    x_uncatch_errors (dpy, count);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* See if we should run in synchronous mode.  This is useful
+
鐃緒申��申鐃緒申     for debugging X code.  */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    Lisp_Object value;
+
鐃緒申��申鐃緒申    value = display_x_get_resource (dpyinfo,
+
鐃緒申��申鐃緒申				    build_string ("synchronous"),
+
鐃緒申��申鐃緒申				    build_string ("Synchronous"),
+
鐃緒申��申鐃緒申				    Qnil, Qnil);
+
鐃緒申��申鐃緒申    if (STRINGP (value)
+
鐃緒申��申鐃緒申	&& (!strcmp (XSTRING (value)->data, "true")
+
鐃緒申��申鐃緒申	    || !strcmp (XSTRING (value)->data, "on")))
+
鐃緒申��申鐃緒申      XSynchronize (dpyinfo->display, True);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return dpyinfo;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Get rid of display DPYINFO, assuming all frames are already gone,
+
鐃緒申��申鐃緒申   and without sending any more commands to the X server.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_delete_display (dpyinfo)
+
鐃緒申��申鐃緒申     struct x_display_info *dpyinfo;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  delete_keyboard_wait_descriptor (dpyinfo->connection);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Discard this display from x_display_name_list and x_display_list.
+
鐃緒申��申鐃緒申     We can't use Fdelq because that can quit.  */
+
鐃緒申��申鐃緒申  if (! NILP (x_display_name_list)
+
鐃緒申��申鐃緒申      && EQ (XCAR (x_display_name_list), dpyinfo->name_list_element))
+
鐃緒申��申鐃緒申    x_display_name_list = XCDR (x_display_name_list);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object tail;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      tail = x_display_name_list;
+
鐃緒申��申鐃緒申      while (CONSP (tail) && CONSP (XCDR (tail)))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      XCDR (tail) = XCDR (XCDR (tail));
+
鐃緒申��申鐃緒申	      break;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  tail = XCDR (tail);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (next_noop_dpyinfo == dpyinfo)
+
鐃緒申��申鐃緒申    next_noop_dpyinfo = dpyinfo->next;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (x_display_list == dpyinfo)
+
鐃緒申��申鐃緒申    x_display_list = dpyinfo->next;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct x_display_info *tail;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      for (tail = x_display_list; tail; tail = tail->next)
+
鐃緒申��申鐃緒申	if (tail->next == dpyinfo)
+
鐃緒申��申鐃緒申	  tail->next = tail->next->next;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifndef USE_X_TOOLKIT   /* I'm told Xt does this itself.  */
+
鐃緒申��申鐃緒申#ifndef AIX		/* On AIX, XCloseDisplay calls this.  */
+
鐃緒申��申鐃緒申  XrmDestroyDatabase (dpyinfo->xrdb);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef MULTI_KBOARD
+
鐃緒申��申鐃緒申  if (--dpyinfo->kboard->reference_count == 0)
+
鐃緒申��申鐃緒申    delete_kboard (dpyinfo->kboard);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#ifdef HAVE_X_I18N
+
鐃緒申��申鐃緒申  if (dpyinfo->xim)
+
鐃緒申��申鐃緒申    xim_close_dpy (dpyinfo);
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  xfree (dpyinfo->font_table);
+
鐃緒申��申鐃緒申  xfree (dpyinfo->x_id_name);
+
鐃緒申��申鐃緒申  xfree (dpyinfo->color_cells);
+
鐃緒申��申鐃緒申  xfree (dpyinfo);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Set up use of X before we make the first connection.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static struct redisplay_interface x_redisplay_interface =
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  x_produce_glyphs,
+
鐃緒申��申鐃緒申  x_write_glyphs,
+
鐃緒申��申鐃緒申  x_insert_glyphs,
+
鐃緒申��申鐃緒申  x_clear_end_of_line,
+
鐃緒申��申鐃緒申  x_scroll_run,
+
鐃緒申��申鐃緒申  x_after_update_window_line,
+
鐃緒申��申鐃緒申  x_update_window_begin,
+
鐃緒申��申鐃緒申  x_update_window_end,
+
鐃緒申��申鐃緒申  XTcursor_to,
+
鐃緒申��申鐃緒申  x_flush,
+
鐃緒申��申鐃緒申  x_clear_mouse_face,
+
鐃緒申��申鐃緒申  x_get_glyph_overhangs,
+
鐃緒申��申鐃緒申  x_fix_overlapping_area
+
鐃緒申��申鐃緒申};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申x_initialize ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  rif = &x_redisplay_interface;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  clear_frame_hook = x_clear_frame;
+
鐃緒申��申鐃緒申  ins_del_lines_hook = x_ins_del_lines;
+
鐃緒申��申鐃緒申  change_line_highlight_hook = x_change_line_highlight;
+
鐃緒申��申鐃緒申  delete_glyphs_hook = x_delete_glyphs;
+
鐃緒申��申鐃緒申  ring_bell_hook = XTring_bell;
+
鐃緒申��申鐃緒申  reset_terminal_modes_hook = XTreset_terminal_modes;
+
鐃緒申��申鐃緒申  set_terminal_modes_hook = XTset_terminal_modes;
+
鐃緒申��申鐃緒申  update_begin_hook = x_update_begin;
+
鐃緒申��申鐃緒申  update_end_hook = x_update_end;
+
鐃緒申��申鐃緒申  set_terminal_window_hook = XTset_terminal_window;
+
鐃緒申��申鐃緒申  read_socket_hook = XTread_socket;
+
鐃緒申��申鐃緒申  frame_up_to_date_hook = XTframe_up_to_date;
+
鐃緒申��申鐃緒申  reassert_line_highlight_hook = XTreassert_line_highlight;
+
鐃緒申��申鐃緒申  mouse_position_hook = XTmouse_position;
+
鐃緒申��申鐃緒申  frame_rehighlight_hook = XTframe_rehighlight;
+
鐃緒申��申鐃緒申  frame_raise_lower_hook = XTframe_raise_lower;
+
鐃緒申��申鐃緒申  set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
+
鐃緒申��申鐃緒申  condemn_scroll_bars_hook = XTcondemn_scroll_bars;
+
鐃緒申��申鐃緒申  redeem_scroll_bar_hook = XTredeem_scroll_bar;
+
鐃緒申��申鐃緒申  judge_scroll_bars_hook = XTjudge_scroll_bars;
+
鐃緒申��申鐃緒申  estimate_mode_line_height_hook = x_estimate_mode_line_height;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  scroll_region_ok = 1;		/* we'll scroll partial frames */
+
鐃緒申��申鐃緒申  char_ins_del_ok = 1;
+
鐃緒申��申鐃緒申  line_ins_del_ok = 1;		/* we'll just blt 'em */
+
鐃緒申��申鐃緒申  fast_clear_end_of_line = 1;	/* X does this well */
+
鐃緒申��申鐃緒申  memory_below_frame = 0;	/* we don't remember what scrolls
+
鐃緒申��申鐃緒申				   off the bottom */
+
鐃緒申��申鐃緒申  baud_rate = 19200;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  x_noop_count = 0;
+
鐃緒申��申鐃緒申  last_tool_bar_item = -1;
+
鐃緒申��申鐃緒申  any_help_event_p = 0;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Try to use interrupt input; if we can't, then start polling.  */
+
鐃緒申��申鐃緒申  Fset_input_mode (Qt, Qnil, Qt, Qnil);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef USE_X_TOOLKIT
+
鐃緒申��申鐃緒申  XtToolkitInitialize ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Xt_app_con = XtCreateApplicationContext ();
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  /* Register a converter from strings to pixels, which uses
+
鐃緒申��申鐃緒申     Emacs' color allocation infrastructure.  */
+
鐃緒申��申鐃緒申  XtAppSetTypeConverter (Xt_app_con,
+
鐃緒申��申鐃緒申			 XtRString, XtRPixel, cvt_string_to_pixel,
+
鐃緒申��申鐃緒申			 cvt_string_to_pixel_args,
+
鐃緒申��申鐃緒申			 XtNumber (cvt_string_to_pixel_args),
+
鐃緒申��申鐃緒申			 XtCacheByDisplay, cvt_pixel_dtor);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  XtAppSetFallbackResources (Xt_app_con, Xt_default_resources);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Install an asynchronous timer that processes Xt timeout events
+
鐃緒申��申鐃緒申     every 0.1s.  This is necessary because some widget sets use
+
鐃緒申��申鐃緒申     timeouts internally, for example the LessTif menu bar, or the
+
鐃緒申��申鐃緒申     Xaw3d scroll bar.  When Xt timouts aren't processed, these
+
鐃緒申��申鐃緒申     widgets don't behave normally.  */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    EMACS_TIME interval;
+
鐃緒申��申鐃緒申    EMACS_SET_SECS_USECS (interval, 0, 100000);
+
鐃緒申��申鐃緒申    start_atimer (ATIMER_CONTINUOUS, interval, x_process_timeouts, 0);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申  xaw3d_arrow_scroll = False;
+
鐃緒申��申鐃緒申  xaw3d_pick_top = True;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Note that there is no real way portable across R3/R4 to get the
+
鐃緒申��申鐃緒申     original error handler.  */
+
鐃緒申��申鐃緒申  XSetErrorHandler (x_error_handler);
+
鐃緒申��申鐃緒申  XSetIOErrorHandler (x_io_error_quitter);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Disable Window Change signals;  they are handled by X events.  */
+
鐃緒申��申鐃緒申#ifdef SIGWINCH
+
鐃緒申��申鐃緒申  signal (SIGWINCH, SIG_DFL);
+
鐃緒申��申鐃緒申#endif /* ! defined (SIGWINCH) */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  signal (SIGPIPE, x_connection_signal);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申syms_of_xterm ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  staticpro (&x_error_message_string);
+
鐃緒申��申鐃緒申  x_error_message_string = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  staticpro (&x_display_name_list);
+
鐃緒申��申鐃緒申  x_display_name_list = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  staticpro (&last_mouse_scroll_bar);
+
鐃緒申��申鐃緒申  last_mouse_scroll_bar = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  staticpro (&Qvendor_specific_keysyms);
+
鐃緒申��申鐃緒申  Qvendor_specific_keysyms = intern ("vendor-specific-keysyms");
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  staticpro (&last_mouse_press_frame);
+
鐃緒申��申鐃緒申  last_mouse_press_frame = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  help_echo = Qnil;
+
鐃緒申��申鐃緒申  staticpro (&help_echo);
+
鐃緒申��申鐃緒申  help_echo_object = Qnil;
+
鐃緒申��申鐃緒申  staticpro (&help_echo_object);
+
鐃緒申��申鐃緒申  help_echo_window = Qnil;
+
鐃緒申��申鐃緒申  staticpro (&help_echo_window);
+
鐃緒申��申鐃緒申  previous_help_echo = Qnil;
+
鐃緒申��申鐃緒申  staticpro (&previous_help_echo);
+
鐃緒申��申鐃緒申  help_echo_pos = -1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p,
+
鐃緒申��申鐃緒申    "*Non-nil means draw block cursor as wide as the glyph under it.\n\
+
鐃緒申��申鐃緒申For example, if a block cursor is over a tab, it will be drawn as\n\
+
鐃緒申��申鐃緒申wide as that tab on the display.");
+
鐃緒申��申鐃緒申  x_stretch_cursor_p = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  DEFVAR_BOOL ("x-use-underline-position-properties",
+
鐃緒申��申鐃緒申	       &x_use_underline_position_properties,
+
鐃緒申��申鐃緒申     "*Non-nil means make use of UNDERLINE_POSITION font properties.\n\
+
鐃緒申��申鐃緒申Nil means ignore them.  If you encounter fonts with bogus\n\
+
鐃緒申��申鐃緒申UNDERLINE_POSITION font properties, for example 7x13 on XFree prior\n\
+
鐃緒申��申鐃緒申to 4.1, set this to nil.");
+
鐃緒申��申鐃緒申  x_use_underline_position_properties = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
+
鐃緒申��申鐃緒申    "What X toolkit scroll bars Emacs uses.\n\
+
鐃緒申��申鐃緒申A value of nil means Emacs doesn't use X toolkit scroll bars.\n\
+
鐃緒申��申鐃緒申Otherwise, value is a symbol describing the X toolkit.");
+
鐃緒申��申鐃緒申#ifdef USE_TOOLKIT_SCROLL_BARS
+
鐃緒申��申鐃緒申#ifdef USE_MOTIF
+
鐃緒申��申鐃緒申  Vx_toolkit_scroll_bars = intern ("motif");
+
鐃緒申��申鐃緒申#elif defined HAVE_XAW3D
+
鐃緒申��申鐃緒申  Vx_toolkit_scroll_bars = intern ("xaw3d");
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申  Vx_toolkit_scroll_bars = intern ("xaw");
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申  Vx_toolkit_scroll_bars = Qnil;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  staticpro (&last_mouse_motion_frame);
+
鐃緒申��申鐃緒申  last_mouse_motion_frame = Qnil;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#endif /* not HAVE_X_WINDOWS */