[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to emacs/src/macterm.c [gnus-5_10-branch]
From: |
Miles Bader |
Subject: |
[Emacs-diffs] Changes to emacs/src/macterm.c [gnus-5_10-branch] |
Date: |
Sat, 04 Sep 2004 08:30:40 -0400 |
Index: emacs/src/macterm.c
diff -c /dev/null emacs/src/macterm.c:1.76.2.1
*** /dev/null Sat Sep 4 12:03:34 2004
--- emacs/src/macterm.c Sat Sep 4 12:01:18 2004
***************
*** 0 ****
--- 1,9307 ----
+ /* Implementation of GUI terminal on the Mac OS.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004 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. */
+
+ /* Contributed by Andrew Choi (address@hidden). */
+
+ #include <config.h>
+ #include <signal.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include "lisp.h"
+ #include "charset.h"
+ #include "blockinput.h"
+
+ #include "macterm.h"
+
+ #ifndef MAC_OSX
+ #include <alloca.h>
+ #endif
+
+ #ifdef MAC_OSX
+ /* USE_CARBON_EVENTS determines if the Carbon Event Manager is used to
+ obtain events from the event queue. If set to 0, WaitNextEvent is
+ used instead. */
+ #define USE_CARBON_EVENTS 1
+ #else /* not MAC_OSX */
+ #include <Quickdraw.h>
+ #include <ToolUtils.h>
+ #include <Sound.h>
+ #include <Events.h>
+ #include <Script.h>
+ #include <Resources.h>
+ #include <Fonts.h>
+ #include <TextUtils.h>
+ #include <LowMem.h>
+ #include <Controls.h>
+ #if defined (__MRC__) || (__MSL__ >= 0x6000)
+ #include <ControlDefinitions.h>
+ #endif
+
+ #if __profile__
+ #include <profiler.h>
+ #endif
+ #endif /* not MAC_OSX */
+
+ #include "systty.h"
+ #include "systime.h"
+ #include "atimer.h"
+ #include "keymap.h"
+
+ #include <ctype.h>
+ #include <errno.h>
+ #include <setjmp.h>
+ #include <sys/stat.h>
+
+ #include "keyboard.h"
+ #include "frame.h"
+ #include "dispextern.h"
+ #include "fontset.h"
+ #include "termhooks.h"
+ #include "termopts.h"
+ #include "termchar.h"
+ #include "gnu.h"
+ #include "disptab.h"
+ #include "buffer.h"
+ #include "window.h"
+ #include "intervals.h"
+ #include "composite.h"
+ #include "coding.h"
+
+ /* Set of macros that handle mapping of Mac modifier keys to emacs. */
+ #define macCtrlKey (NILP (Vmac_reverse_ctrl_meta) ? controlKey : \
+ (NILP (Vmac_command_key_is_meta) ? optionKey : cmdKey))
+ #define macShiftKey (shiftKey)
+ #define macMetaKey (NILP (Vmac_reverse_ctrl_meta) ?
\
+ (NILP (Vmac_command_key_is_meta) ? optionKey : cmdKey) \
+ : controlKey)
+ #define macAltKey (NILP (Vmac_command_key_is_meta) ? cmdKey : optionKey)
+
+
+
+ /* Non-nil means Emacs uses toolkit scroll bars. */
+
+ Lisp_Object Vx_toolkit_scroll_bars;
+
+ /* Non-zero means that a HELP_EVENT has been generated since Emacs
+ start. */
+
+ static int any_help_event_p;
+
+ /* Non-zero means autoselect window with the mouse cursor. */
+
+ int x_autoselect_window_p;
+
+ /* Non-zero means make use of UNDERLINE_POSITION font properties. */
+
+ int x_use_underline_position_properties;
+
+ /* 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. */
+
+
+ /* 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;
+
+ /* This is display since Mac does not support multiple ones. */
+ struct mac_display_info one_mac_display_info;
+
+ /* 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;
+
+ /* 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. */
+
+ static Rect 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;
+
+ struct scroll_bar *tracked_scroll_bar = NULL;
+
+ /* 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 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;
+
+ #if 0
+ extern XrmDatabase x_load_resources P_ ((Display *, char *, char *, char *));
+ #endif
+
+ extern int inhibit_window_system;
+
+ #if __MRC__
+ QDGlobals qd; /* QuickDraw global information structure. */
+ #endif
+
+
+ struct frame * x_window_to_frame (struct mac_display_info *, WindowPtr);
+ struct mac_display_info *mac_display_info_for_display (Display *);
+ static void x_update_window_end P_ ((struct window *, int, int));
+ static void mac_handle_tool_bar_click P_ ((struct frame *, EventRecord *));
+ 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 mac_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_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 x_clear_frame P_ ((void));
+ 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,
+ enum text_cursor_kinds));
+
+ static void x_clip_to_row P_ ((struct window *, struct glyph_row *, GC));
+ 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_after_update_window_line P_ ((struct glyph_row *));
+
+ void activate_scroll_bars (FRAME_PTR);
+ void deactivate_scroll_bars (FRAME_PTR);
+
+ static int is_emacs_window (WindowPtr);
+
+ int x_bitmap_icon (struct frame *, Lisp_Object);
+ void x_make_frame_visible (struct frame *);
+
+ extern void window_scroll (Lisp_Object, int, int, int);
+
+ /* Defined in macmenu.h. */
+ extern void menubar_selection_callback (FRAME_PTR, int);
+ extern void set_frame_menubar (FRAME_PTR, int, int);
+
+ /* X display function emulation */
+
+ void
+ XFreePixmap (display, pixmap)
+ Display *display; /* not used */
+ Pixmap pixmap;
+ {
+ DisposeGWorld (pixmap);
+ }
+
+
+ /* Set foreground color for subsequent QuickDraw commands. Assume
+ graphic port has already been set. */
+
+ static void
+ mac_set_forecolor (unsigned long color)
+ {
+ RGBColor fg_color;
+
+ fg_color.red = RED16_FROM_ULONG (color);
+ fg_color.green = GREEN16_FROM_ULONG (color);
+ fg_color.blue = BLUE16_FROM_ULONG (color);
+
+ RGBForeColor (&fg_color);
+ }
+
+
+ /* Set background color for subsequent QuickDraw commands. Assume
+ graphic port has already been set. */
+
+ static void
+ mac_set_backcolor (unsigned long color)
+ {
+ RGBColor bg_color;
+
+ bg_color.red = RED16_FROM_ULONG (color);
+ bg_color.green = GREEN16_FROM_ULONG (color);
+ bg_color.blue = BLUE16_FROM_ULONG (color);
+
+ RGBBackColor (&bg_color);
+ }
+
+ /* Set foreground and background color for subsequent QuickDraw
+ commands. Assume that the graphic port has already been set. */
+
+ static void
+ mac_set_colors (GC gc)
+ {
+ mac_set_forecolor (gc->foreground);
+ mac_set_backcolor (gc->background);
+ }
+
+ /* Mac version of XDrawLine. */
+
+ static void
+ XDrawLine (display, w, gc, x1, y1, x2, y2)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int x1, y1, x2, y2;
+ {
+ SetPortWindowPort (w);
+
+ mac_set_colors (gc);
+
+ MoveTo (x1, y1);
+ LineTo (x2, y2);
+ }
+
+ void
+ mac_draw_line_to_pixmap (display, p, gc, x1, y1, x2, y2)
+ Display *display;
+ Pixmap p;
+ GC gc;
+ int x1, y1, x2, y2;
+ {
+ CGrafPtr old_port;
+ GDHandle old_gdh;
+
+ GetGWorld (&old_port, &old_gdh);
+ SetGWorld (p, NULL);
+
+ mac_set_colors (gc);
+
+ LockPixels (GetGWorldPixMap (p));
+ MoveTo (x1, y1);
+ LineTo (x2, y2);
+ UnlockPixels (GetGWorldPixMap (p));
+
+ SetGWorld (old_port, old_gdh);
+ }
+
+ /* Mac version of XClearArea. */
+
+ void
+ XClearArea (display, w, x, y, width, height, exposures)
+ Display *display;
+ WindowPtr w;
+ int x, y;
+ unsigned int width, height;
+ int exposures;
+ {
+ struct mac_output *mwp = (mac_output *) GetWRefCon (w);
+ Rect r;
+ XGCValues xgc;
+
+ xgc.foreground = mwp->x_compatible.foreground_pixel;
+ xgc.background = mwp->x_compatible.background_pixel;
+
+ SetPortWindowPort (w);
+
+ mac_set_colors (&xgc);
+ SetRect (&r, x, y, x + width, y + height);
+
+ EraseRect (&r);
+ }
+
+ /* Mac version of XClearWindow. */
+
+ static void
+ XClearWindow (display, w)
+ Display *display;
+ WindowPtr w;
+ {
+ struct mac_output *mwp = (mac_output *) GetWRefCon (w);
+ XGCValues xgc;
+
+ xgc.foreground = mwp->x_compatible.foreground_pixel;
+ xgc.background = mwp->x_compatible.background_pixel;
+
+ SetPortWindowPort (w);
+
+ mac_set_colors (&xgc);
+
+ #if TARGET_API_MAC_CARBON
+ {
+ Rect r;
+
+ GetWindowPortBounds (w, &r);
+ EraseRect (&r);
+ }
+ #else /* not TARGET_API_MAC_CARBON */
+ EraseRect (&(w->portRect));
+ #endif /* not TARGET_API_MAC_CARBON */
+ }
+
+
+ /* Mac replacement for XCopyArea. */
+
+ static void
+ mac_draw_bitmap (display, w, gc, x, y, width, height, bits, overlay_p)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int x, y, width, height;
+ unsigned short *bits;
+ int overlay_p;
+ {
+ BitMap bitmap;
+ Rect r;
+
+ bitmap.rowBytes = sizeof(unsigned short);
+ bitmap.baseAddr = (char *)bits;
+ SetRect (&(bitmap.bounds), 0, 0, width, height);
+
+ SetPortWindowPort (w);
+
+ mac_set_colors (gc);
+ SetRect (&r, x, y, x + width, y + height);
+
+ #if TARGET_API_MAC_CARBON
+ LockPortBits (GetWindowPort (w));
+ CopyBits (&bitmap, GetPortBitMapForCopyBits (GetWindowPort (w)),
+ &(bitmap.bounds), &r, overlay_p ? srcOr : srcCopy, 0);
+ UnlockPortBits (GetWindowPort (w));
+ #else /* not TARGET_API_MAC_CARBON */
+ CopyBits (&bitmap, &(w->portBits), &(bitmap.bounds), &r,
+ overlay_p ? srcOr : srcCopy, 0);
+ #endif /* not TARGET_API_MAC_CARBON */
+ }
+
+
+ /* Mac replacement for XSetClipRectangles. */
+
+ static void
+ mac_set_clip_rectangle (display, w, r)
+ Display *display;
+ WindowPtr w;
+ Rect *r;
+ {
+ SetPortWindowPort (w);
+
+ ClipRect (r);
+ }
+
+
+ /* Mac replacement for XSetClipMask. */
+
+ static void
+ mac_reset_clipping (display, w)
+ Display *display;
+ WindowPtr w;
+ {
+ Rect r;
+
+ SetPortWindowPort (w);
+
+ SetRect (&r, -32767, -32767, 32767, 32767);
+ ClipRect (&r);
+ }
+
+
+ /* XBM bits seem to be backward within bytes compared with how
+ Mac does things. */
+ static unsigned char
+ reflect_byte (orig)
+ unsigned char orig;
+ {
+ int i;
+ unsigned char reflected = 0x00;
+ for (i = 0; i < 8; i++)
+ {
+ if (orig & (0x01 << i))
+ reflected |= 0x80 >> i;
+ }
+ return reflected;
+ }
+
+
+ /* Mac replacement for XCreateBitmapFromBitmapData. */
+
+ static void
+ mac_create_bitmap_from_bitmap_data (bitmap, bits, w, h)
+ BitMap *bitmap;
+ char *bits;
+ int w, h;
+ {
+ int i, j, w1;
+ char *p;
+
+ w1 = (w + 7) / 8; /* nb of 8bits elt in X bitmap */
+ bitmap->rowBytes = ((w + 15) / 16) * 2; /* nb of 16bits elt in Mac bitmap */
+ bitmap->baseAddr = xmalloc (bitmap->rowBytes * h);
+ bzero (bitmap->baseAddr, bitmap->rowBytes * h);
+ for (i = 0; i < h; i++)
+ {
+ p = bitmap->baseAddr + i * bitmap->rowBytes;
+ for (j = 0; j < w1; j++)
+ *p++ = reflect_byte (*bits++);
+ }
+
+ SetRect (&(bitmap->bounds), 0, 0, w, h);
+ }
+
+
+ static void
+ mac_free_bitmap (bitmap)
+ BitMap *bitmap;
+ {
+ xfree (bitmap->baseAddr);
+ }
+
+
+ Pixmap
+ XCreatePixmap (display, w, width, height, depth)
+ Display *display; /* not used */
+ WindowPtr w;
+ unsigned int width, height;
+ unsigned int depth; /* not used */
+ {
+ Pixmap pixmap;
+ Rect r;
+ QDErr err;
+
+ SetPortWindowPort (w);
+
+ SetRect (&r, 0, 0, width, height);
+ err = NewGWorld (&pixmap, depth, &r, NULL, NULL, 0);
+ if (err != noErr)
+ return NULL;
+ return pixmap;
+ }
+
+
+ Pixmap
+ XCreatePixmapFromBitmapData (display, w, data, width, height, fg, bg, depth)
+ Display *display; /* not used */
+ WindowPtr w;
+ char *data;
+ unsigned int width, height;
+ unsigned long fg, bg;
+ unsigned int depth; /* not used */
+ {
+ Pixmap pixmap;
+ BitMap bitmap;
+ CGrafPtr old_port;
+ GDHandle old_gdh;
+
+ pixmap = XCreatePixmap (display, w, width, height, depth);
+ if (pixmap == NULL)
+ return NULL;
+
+ GetGWorld (&old_port, &old_gdh);
+ SetGWorld (pixmap, NULL);
+ mac_create_bitmap_from_bitmap_data (&bitmap, data, width, height);
+ mac_set_forecolor (fg);
+ mac_set_backcolor (bg);
+ LockPixels (GetGWorldPixMap (pixmap));
+ #if TARGET_API_MAC_CARBON
+ CopyBits (&bitmap, GetPortBitMapForCopyBits (pixmap),
+ &bitmap.bounds, &bitmap.bounds, srcCopy, 0);
+ #else /* not TARGET_API_MAC_CARBON */
+ CopyBits (&bitmap, &(((GrafPtr)pixmap)->portBits),
+ &bitmap.bounds, &bitmap.bounds, srcCopy, 0);
+ #endif /* not TARGET_API_MAC_CARBON */
+ UnlockPixels (GetGWorldPixMap (pixmap));
+ SetGWorld (old_port, old_gdh);
+ mac_free_bitmap (&bitmap);
+
+ return pixmap;
+ }
+
+
+ /* Mac replacement for XFillRectangle. */
+
+ static void
+ XFillRectangle (display, w, gc, x, y, width, height)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int x, y;
+ unsigned int width, height;
+ {
+ Rect r;
+
+ SetPortWindowPort (w);
+
+ mac_set_colors (gc);
+ SetRect (&r, x, y, x + width, y + height);
+
+ PaintRect (&r); /* using foreground color of gc */
+ }
+
+
+ static void
+ mac_fill_rectangle_to_pixmap (display, p, gc, x, y, width, height)
+ Display *display;
+ Pixmap p;
+ GC gc;
+ int x, y;
+ unsigned int width, height;
+ {
+ CGrafPtr old_port;
+ GDHandle old_gdh;
+ Rect r;
+
+ GetGWorld (&old_port, &old_gdh);
+ SetGWorld (p, NULL);
+ mac_set_colors (gc);
+ SetRect (&r, x, y, x + width, y + height);
+
+ LockPixels (GetGWorldPixMap (p));
+ PaintRect (&r); /* using foreground color of gc */
+ UnlockPixels (GetGWorldPixMap (p));
+
+ SetGWorld (old_port, old_gdh);
+ }
+
+
+ /* Mac replacement for XDrawRectangle: dest is a window. */
+
+ static void
+ mac_draw_rectangle (display, w, gc, x, y, width, height)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int x, y;
+ unsigned int width, height;
+ {
+ Rect r;
+
+ SetPortWindowPort (w);
+
+ mac_set_colors (gc);
+ SetRect (&r, x, y, x + width + 1, y + height + 1);
+
+ FrameRect (&r); /* using foreground color of gc */
+ }
+
+
+ /* Mac replacement for XDrawRectangle: dest is a Pixmap. */
+
+ static void
+ mac_draw_rectangle_to_pixmap (display, p, gc, x, y, width, height)
+ Display *display;
+ Pixmap p;
+ GC gc;
+ int x, y;
+ unsigned int width, height;
+ {
+ CGrafPtr old_port;
+ GDHandle old_gdh;
+ Rect r;
+
+ GetGWorld (&old_port, &old_gdh);
+ SetGWorld (p, NULL);
+ mac_set_colors (gc);
+ SetRect (&r, x, y, x + width + 1, y + height + 1);
+
+ LockPixels (GetGWorldPixMap (p));
+ FrameRect (&r); /* using foreground color of gc */
+ UnlockPixels (GetGWorldPixMap (p));
+
+ SetGWorld (old_port, old_gdh);
+ }
+
+
+ static void
+ mac_draw_string_common (display, w, gc, x, y, buf, nchars, mode,
+ bytes_per_char)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int x, y;
+ char *buf;
+ int nchars, mode, bytes_per_char;
+ {
+ SetPortWindowPort (w);
+
+ mac_set_colors (gc);
+
+ TextFont (gc->font->mac_fontnum);
+ TextSize (gc->font->mac_fontsize);
+ TextFace (gc->font->mac_fontface);
+ TextMode (mode);
+
+ MoveTo (x, y);
+ DrawText (buf, 0, nchars * bytes_per_char);
+ }
+
+
+ /* Mac replacement for XDrawString. */
+
+ static void
+ XDrawString (display, w, gc, x, y, buf, nchars)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int x, y;
+ char *buf;
+ int nchars;
+ {
+ mac_draw_string_common (display, w, gc, x, y, buf, nchars, srcOr, 1);
+ }
+
+
+ /* Mac replacement for XDrawString16. */
+
+ static void
+ XDrawString16 (display, w, gc, x, y, buf, nchars)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int x, y;
+ XChar2b *buf;
+ int nchars;
+ {
+ mac_draw_string_common (display, w, gc, x, y, (char *) buf, nchars, srcOr,
+ 2);
+ }
+
+
+ /* Mac replacement for XDrawImageString. */
+
+ static void
+ XDrawImageString (display, w, gc, x, y, buf, nchars)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int x, y;
+ char *buf;
+ int nchars;
+ {
+ mac_draw_string_common (display, w, gc, x, y, buf, nchars, srcCopy, 1);
+ }
+
+
+ /* Mac replacement for XDrawString16. */
+
+ static void
+ XDrawImageString16 (display, w, gc, x, y, buf, nchars)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int x, y;
+ XChar2b *buf;
+ int nchars;
+ {
+ mac_draw_string_common (display, w, gc, x, y, (char *) buf, nchars, srcCopy,
+ 2);
+ }
+
+
+ /* Mac replacement for XCopyArea: dest must be window. */
+
+ static void
+ mac_copy_area (display, src, dest, gc, src_x, src_y, width, height, dest_x,
+ dest_y)
+ Display *display;
+ Pixmap src;
+ WindowPtr dest;
+ GC gc;
+ int src_x, src_y;
+ unsigned int width, height;
+ int dest_x, dest_y;
+ {
+ Rect src_r, dest_r;
+
+ SetPortWindowPort (dest);
+
+ SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
+ SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
+
+ ForeColor (blackColor);
+ BackColor (whiteColor);
+
+ LockPixels (GetGWorldPixMap (src));
+ #if TARGET_API_MAC_CARBON
+ LockPortBits (GetWindowPort (dest));
+ CopyBits (GetPortBitMapForCopyBits (src),
+ GetPortBitMapForCopyBits (GetWindowPort (dest)),
+ &src_r, &dest_r, srcCopy, 0);
+ UnlockPortBits (GetWindowPort (dest));
+ #else /* not TARGET_API_MAC_CARBON */
+ CopyBits (&(((GrafPtr)src)->portBits), &(dest->portBits),
+ &src_r, &dest_r, srcCopy, 0);
+ #endif /* not TARGET_API_MAC_CARBON */
+ UnlockPixels (GetGWorldPixMap (src));
+ }
+
+
+ static void
+ mac_copy_area_with_mask (display, src, mask, dest, gc, src_x, src_y,
+ width, height, dest_x, dest_y)
+ Display *display;
+ Pixmap src, mask;
+ WindowPtr dest;
+ GC gc;
+ int src_x, src_y;
+ unsigned int width, height;
+ int dest_x, dest_y;
+ {
+ Rect src_r, dest_r;
+
+ SetPortWindowPort (dest);
+
+ SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
+ SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
+
+ ForeColor (blackColor);
+ BackColor (whiteColor);
+
+ LockPixels (GetGWorldPixMap (src));
+ LockPixels (GetGWorldPixMap (mask));
+ #if TARGET_API_MAC_CARBON
+ LockPortBits (GetWindowPort (dest));
+ CopyMask (GetPortBitMapForCopyBits (src), GetPortBitMapForCopyBits (mask),
+ GetPortBitMapForCopyBits (GetWindowPort (dest)),
+ &src_r, &src_r, &dest_r);
+ UnlockPortBits (GetWindowPort (dest));
+ #else /* not TARGET_API_MAC_CARBON */
+ CopyMask (&(((GrafPtr)src)->portBits), &(((GrafPtr)mask)->portBits),
+ &(dest->portBits), &src_r, &src_r, &dest_r);
+ #endif /* not TARGET_API_MAC_CARBON */
+ UnlockPixels (GetGWorldPixMap (mask));
+ UnlockPixels (GetGWorldPixMap (src));
+ }
+
+
+ #if 0
+ /* Convert a pair of local coordinates to global (screen) coordinates.
+ Assume graphic port has been properly set. */
+ static void
+ local_to_global_coord (short *h, short *v)
+ {
+ Point p;
+
+ p.h = *h;
+ p.v = *v;
+
+ LocalToGlobal (&p);
+
+ *h = p.h;
+ *v = p.v;
+ }
+ #endif
+
+ /* Mac replacement for XCopyArea: used only for scrolling. */
+
+ static void
+ mac_scroll_area (display, w, gc, src_x, src_y, width, height, dest_x, dest_y)
+ Display *display;
+ WindowPtr w;
+ GC gc;
+ int src_x, src_y;
+ unsigned int width, height;
+ int dest_x, dest_y;
+ {
+ #if TARGET_API_MAC_CARBON
+ Rect gw_r, src_r, dest_r;
+
+ SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
+ SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
+
+ SetPortWindowPort (w);
+
+ ForeColor (blackColor);
+ BackColor (whiteColor);
+
+ LockPortBits (GetWindowPort (w));
+ {
+ const BitMap *bitmap = GetPortBitMapForCopyBits (GetWindowPort (w));
+ CopyBits (bitmap, bitmap, &src_r, &dest_r, srcCopy, 0);
+ }
+ UnlockPortBits (GetWindowPort (w));
+
+ mac_set_colors (gc);
+ #else /* not TARGET_API_MAC_CARBON */
+ Rect src_r, dest_r;
+
+ SetPort (w);
+ #if 0
+ mac_set_colors (gc);
+ #endif
+
+ SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
+ SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
+
+ #if 0
+ /* Need to use global coordinates and screenBits since src and dest
+ areas overlap in general. */
+ local_to_global_coord (&src_r.left, &src_r.top);
+ local_to_global_coord (&src_r.right, &src_r.bottom);
+ local_to_global_coord (&dest_r.left, &dest_r.top);
+ local_to_global_coord (&dest_r.right, &dest_r.bottom);
+
+ CopyBits (&qd.screenBits, &qd.screenBits, &src_r, &dest_r, srcCopy, 0);
+ #else
+ /* In Color QuickDraw, set ForeColor and BackColor as follows to avoid
+ color mapping in CopyBits. Otherwise, it will be slow. */
+ ForeColor (blackColor);
+ BackColor (whiteColor);
+ CopyBits (&(w->portBits), &(w->portBits), &src_r, &dest_r, srcCopy, 0);
+
+ mac_set_colors (gc);
+ #endif
+ #endif /* not TARGET_API_MAC_CARBON */
+ }
+
+
+ /* Mac replacement for XCopyArea: dest must be Pixmap. */
+
+ static void
+ mac_copy_area_to_pixmap (display, src, dest, gc, src_x, src_y, width, height,
+ dest_x, dest_y)
+ Display *display;
+ Pixmap src, dest;
+ GC gc;
+ int src_x, src_y;
+ unsigned int width, height;
+ int dest_x, dest_y;
+ {
+ CGrafPtr old_port;
+ GDHandle old_gdh;
+ Rect src_r, dest_r;
+
+ GetGWorld (&old_port, &old_gdh);
+ SetGWorld (dest, NULL);
+ ForeColor (blackColor);
+ BackColor (whiteColor);
+
+ SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
+ SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
+
+ LockPixels (GetGWorldPixMap (src));
+ LockPixels (GetGWorldPixMap (dest));
+ #if TARGET_API_MAC_CARBON
+ CopyBits (GetPortBitMapForCopyBits (src), GetPortBitMapForCopyBits (dest),
+ &src_r, &dest_r, srcCopy, 0);
+ #else /* not TARGET_API_MAC_CARBON */
+ CopyBits (&(((GrafPtr)src)->portBits), &(((GrafPtr)dest)->portBits),
+ &src_r, &dest_r, srcCopy, 0);
+ #endif /* not TARGET_API_MAC_CARBON */
+ UnlockPixels (GetGWorldPixMap (dest));
+ UnlockPixels (GetGWorldPixMap (src));
+
+ SetGWorld (old_port, old_gdh);
+ }
+
+
+ static void
+ mac_copy_area_with_mask_to_pixmap (display, src, mask, dest, gc, src_x, src_y,
+ width, height, dest_x, dest_y)
+ Display *display;
+ Pixmap src, mask, dest;
+ GC gc;
+ int src_x, src_y;
+ unsigned int width, height;
+ int dest_x, dest_y;
+ {
+ CGrafPtr old_port;
+ GDHandle old_gdh;
+ Rect src_r, dest_r;
+
+ GetGWorld (&old_port, &old_gdh);
+ SetGWorld (dest, NULL);
+ ForeColor (blackColor);
+ BackColor (whiteColor);
+
+ SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
+ SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
+
+ LockPixels (GetGWorldPixMap (src));
+ LockPixels (GetGWorldPixMap (mask));
+ LockPixels (GetGWorldPixMap (dest));
+ #if TARGET_API_MAC_CARBON
+ CopyMask (GetPortBitMapForCopyBits (src), GetPortBitMapForCopyBits (mask),
+ GetPortBitMapForCopyBits (dest), &src_r, &src_r, &dest_r);
+ #else /* not TARGET_API_MAC_CARBON */
+ CopyMask (&(((GrafPtr)src)->portBits), &(((GrafPtr)mask)->portBits),
+ &(((GrafPtr)dest)->portBits), &src_r, &src_r, &dest_r);
+ #endif /* not TARGET_API_MAC_CARBON */
+ UnlockPixels (GetGWorldPixMap (dest));
+ UnlockPixels (GetGWorldPixMap (mask));
+ UnlockPixels (GetGWorldPixMap (src));
+
+ SetGWorld (old_port, old_gdh);
+ }
+
+
+ /* Mac replacement for XChangeGC. */
+
+ static void
+ XChangeGC (void * ignore, XGCValues* gc, unsigned long mask,
+ XGCValues *xgcv)
+ {
+ if (mask & GCForeground)
+ gc->foreground = xgcv->foreground;
+ if (mask & GCBackground)
+ gc->background = xgcv->background;
+ if (mask & GCFont)
+ gc->font = xgcv->font;
+ }
+
+
+ /* Mac replacement for XCreateGC. */
+
+ XGCValues *
+ XCreateGC (void * ignore, Window window, unsigned long mask,
+ XGCValues *xgcv)
+ {
+ XGCValues *gc = (XGCValues *) xmalloc (sizeof (XGCValues));
+ bzero (gc, sizeof (XGCValues));
+
+ XChangeGC (ignore, gc, mask, xgcv);
+
+ return gc;
+ }
+
+
+ /* Used in xfaces.c. */
+
+ void
+ XFreeGC (display, gc)
+ Display *display;
+ GC gc;
+ {
+ xfree (gc);
+ }
+
+
+ /* Mac replacement for XGetGCValues. */
+
+ static void
+ XGetGCValues (void* ignore, XGCValues *gc,
+ unsigned long mask, XGCValues *xgcv)
+ {
+ XChangeGC (ignore, xgcv, mask, gc);
+ }
+
+
+ /* Mac replacement for XSetForeground. */
+
+ void
+ XSetForeground (display, gc, color)
+ Display *display;
+ GC gc;
+ unsigned long color;
+ {
+ gc->foreground = color;
+ }
+
+
+ /* Mac replacement for XSetFont. */
+
+ static void
+ XSetFont (display, gc, font)
+ Display *display;
+ GC gc;
+ XFontStruct *font;
+ {
+ gc->font = font;
+ }
+
+
+ static void
+ XTextExtents16 (XFontStruct *font, XChar2b *text, int nchars,
+ int *direction,int *font_ascent,
+ int *font_descent, XCharStruct *cs)
+ {
+ /* MAC_TODO: Use GetTextMetrics to do this and inline it below. */
+ }
+
+
+ /* x_sync is a no-op on Mac. */
+ void
+ x_sync (f)
+ void *f;
+ {
+ }
+
+
+ /* 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. */
+
+ #if TARGET_API_MAC_CARBON
+ #define XFlush(DISPLAY) QDFlushPortBuffer (GetQDGlobalsThePort (), NULL)
+ #else
+ #define XFlush(DISPLAY) (void) 0
+ #endif
+
+ /* Flush display of frame F, or of all frames if F is null. */
+
+ void
+ x_flush (f)
+ struct frame *f;
+ {
+ #if TARGET_API_MAC_CARBON
+ BLOCK_INPUT;
+ if (f == NULL)
+ {
+ Lisp_Object rest, frame;
+ FOR_EACH_FRAME (rest, frame)
+ x_flush (XFRAME (frame));
+ }
+ else if (FRAME_MAC_P (f))
+ XFlush (FRAME_MAC_DISPLAY (f));
+ UNBLOCK_INPUT;
+ #endif /* TARGET_API_MAC_CARBON */
+ }
+
+
+
+ /* Return the struct mac_display_info corresponding to DPY. There's
+ only one. */
+
+ struct mac_display_info *
+ mac_display_info_for_display (dpy)
+ Display *dpy;
+ {
+ return &one_mac_display_info;
+ }
+
+
+
+ /***********************************************************************
+ 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. */
+
+ 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 mac_display_info *display_info = FRAME_MAC_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 from (x,y0) to (x,y1) */
+
+ static void
+ mac_draw_vertical_window_border (w, x, y0, y1)
+ struct window *w;
+ int x, y0, y1;
+ {
+ struct frame *f = XFRAME (WINDOW_FRAME (w));
+
+ XDrawLine (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ f->output_data.mac->normal_gc, x, y0, x, 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 mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (XFRAME
(w->frame));
+
+ if (!w->pseudo_window_p)
+ {
+ BLOCK_INPUT;
+
+ if (cursor_on_p)
+ display_and_set_cursor (w, 1, output_cursor.hpos,
+ output_cursor.vpos,
+ output_cursor.x, output_cursor.y);
+
+ x_draw_vertical_border (w);
+
+ draw_window_fringes (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;
+ }
+
+ #if 0
+ /* Unhide the caret. This won't actually show the cursor, unless it
+ was visible before the corresponding call to HideCaret in
+ x_update_window_begin. */
+ if (w32_use_visible_system_caret)
+ SendMessage (w32_system_caret_hwnd, WM_EMACS_SHOW_CARET, 0, 0);
+ #endif
+
+ 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_MAC_DISPLAY_INFO (f)->mouse_face_defer = 0;
+
+ BLOCK_INPUT;
+ /* Reset the background color of Mac OS Window to that of the frame after
+ update so that it is used by Mac Toolbox to clear the update region
before
+ an update event is generated. */
+ SetPortWindowPort (FRAME_MAC_WINDOW (f));
+
+ mac_set_backcolor (FRAME_BACKGROUND_PIXEL (f));
+
+ XFlush (FRAME_MAC_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_MAC_P (f))
+ {
+ struct mac_display_info *dpyinfo = FRAME_MAC_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 fringes if no bitmaps are required
+ before DESIRED_ROW is made current. The window being updated is
+ found in updated_window. This function 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;
+ struct frame *f;
+ int width, height;
+
+ xassert (w);
+
+ if (!desired_row->mode_line_p && !w->pseudo_window_p)
+ desired_row->redraw_fringe_bitmaps_p = 1;
+
+ /* When a window has disappeared, make sure that no rest of
+ full-width rows stays visible in the internal border. Could
+ check here if updated_window is the leftmost/rightmost window,
+ but I guess it's not worth doing since vertically split windows
+ are almost never used, internal border is rarely set, and the
+ overhead is very small. */
+ if (windows_or_buffers_changed
+ && desired_row->full_width_p
+ && (f = XFRAME (w->frame),
+ width = FRAME_INTERNAL_BORDER_WIDTH (f),
+ width != 0)
+ && (height = desired_row->visible_height,
+ height > 0))
+ {
+ int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
+ /* Internal border is drawn below the tool bar. */
+ if (WINDOWP (f->tool_bar_window)
+ && w == XWINDOW (f->tool_bar_window))
+ y -= width;
+
+ BLOCK_INPUT;
+
+ XClearArea (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ 0, y, width, height, 0);
+ XClearArea (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ FRAME_PIXEL_WIDTH (f) - width, y,
+ width, height, 0);
+
+ UNBLOCK_INPUT;
+ }
+ }
+
+
+ /* Draw the bitmap WHICH in one of the left or right fringes 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_fringe_bitmap (w, row, p)
+ struct window *w;
+ struct glyph_row *row;
+ struct draw_fringe_bitmap_params *p;
+ {
+ struct frame *f = XFRAME (WINDOW_FRAME (w));
+ Display *display = FRAME_MAC_DISPLAY (f);
+ WindowPtr window = FRAME_MAC_WINDOW (f);
+ XGCValues gcv;
+ GC gc = f->output_data.mac->normal_gc;
+ struct face *face = p->face;
+ int rowY;
+
+ /* Must clip because of partially visible lines. */
+ rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
+ if (p->y < rowY)
+ {
+ /* Adjust position of "bottom aligned" bitmap on partially
+ visible last row. */
+ int oldY = row->y;
+ int oldVH = row->visible_height;
+ row->visible_height = p->h;
+ row->y -= rowY - p->y;
+ x_clip_to_row (w, row, gc);
+ row->y = oldY;
+ row->visible_height = oldVH;
+ }
+ else
+ x_clip_to_row (w, row, gc);
+
+ if (p->bx >= 0 && !p->overlay_p)
+ {
+ XGCValues gcv;
+ gcv.foreground = face->background;
+
+ #if 0 /* MAC_TODO: stipple */
+ /* In case the same realized face is used for fringes 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);
+ #endif
+
+ XFillRectangle (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ &gcv,
+ p->bx, p->by, p->nx, p->ny);
+
+ #if 0 /* MAC_TODO: stipple */
+ if (!face->stipple)
+ XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
+ #endif
+ }
+
+ if (p->which)
+ {
+ unsigned short *bits = p->bits + p->dh;
+
+ gcv.foreground = (p->cursor_p
+ ? (p->overlay_p ? face->background
+ : f->output_data.mac->cursor_pixel)
+ : face->foreground);
+ gcv.background = face->background;
+
+ mac_draw_bitmap (display, window, &gcv, p->x, p->y,
+ p->wd, p->h, bits, p->overlay_p);
+ }
+
+ mac_reset_clipping (display, window);
+ }
+
+
+ /* This is called when starting Emacs and when restarting after
+ suspend. When starting Emacs, no 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 windows go away, and suspending requires no action. */
+
+ static void
+ XTreset_terminal_modes ()
+ {
+ }
+
+
+ /***********************************************************************
+ Display Iterator
+ ***********************************************************************/
+
+ /* Function prototypes of this page. */
+
+ static XCharStruct *x_per_char_metric P_ ((XFontStruct *, XChar2b *));
+ static int mac_encode_char P_ ((int, XChar2b *, struct font_info *, int *));
+
+
+ /* Return a pointer to per-char metric information in FONT of a
+ character pointed by B which is a pointer to an XChar2b. */
+
+ #define PER_CHAR_METRIC(font, b) \
+ ((font)->per_char \
+ ? ((font)->per_char + (b)->byte2 - (font)->min_char_or_byte2
\
+ + (((font)->min_byte1 || (font)->max_byte1) \
+ ? (((b)->byte1 - (font)->min_byte1) \
+ * ((font)->max_char_or_byte2 - (font)->min_char_or_byte2 + 1)) \
+ : 0)) \
+ : &((font)->max_bounds))
+
+
+ /* 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);
+ }
+
+ /* RIF:
+ */
+
+ static XCharStruct *
+ mac_per_char_metric (font, char2b, font_type)
+ XFontStruct *font;
+ XChar2b *char2b;
+ int font_type;
+ {
+ return x_per_char_metric (font, char2b);
+ }
+
+ /* RIF:
+ Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
+ the two-byte form of C. Encoding is returned in *CHAR2B. */
+
+ static int
+ mac_encode_char (c, char2b, font_info, two_byte_p)
+ int c;
+ XChar2b *char2b;
+ struct font_info *font_info;
+ int *two_byte_p;
+ {
+ 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;
+
+ if (enc == 4)
+ {
+ int sjis1, sjis2;
+
+ ENCODE_SJIS (char2b->byte1, char2b->byte2, sjis1, sjis2);
+ char2b->byte1 = sjis1;
+ char2b->byte2 = sjis2;
+ }
+ }
+
+ if (two_byte_p)
+ *two_byte_p = ((XFontStruct *) (font_info->font))->max_byte1 > 0;
+
+ return FONT_TYPE_UNKNOWN;
+ }
+
+
+
+ /***********************************************************************
+ Glyph display
+ ***********************************************************************/
+
+
+ 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_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 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_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, int, int,
+ Rect *));
+ static void x_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
+ int, int, int, Rect *));
+
+ #if GLYPH_DEBUG
+ static void x_check_font P_ ((struct frame *, XFontStruct *));
+ #endif
+
+
+ /* 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.mac->cursor_gc;
+ else
+ {
+ /* Cursor on non-default face: must merge. */
+ XGCValues xgcv;
+ unsigned long mask;
+
+ xgcv.background = s->f->output_data.mac->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.mac->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;
+ mask = GCForeground | GCBackground | GCFont;
+
+ if (FRAME_MAC_DISPLAY_INFO (s->f)->scratch_cursor_gc)
+ XChangeGC (s->display, FRAME_MAC_DISPLAY_INFO (s->f)->scratch_cursor_gc,
+ mask, &xgcv);
+ else
+ FRAME_MAC_DISPLAY_INFO (s->f)->scratch_cursor_gc
+ = XCreateGC (s->display, s->window, mask, &xgcv);
+
+ s->gc = FRAME_MAC_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;
+ mask = GCForeground | GCBackground | GCFont;
+
+ if (FRAME_MAC_DISPLAY_INFO (s->f)->scratch_cursor_gc)
+ XChangeGC (s->display, FRAME_MAC_DISPLAY_INFO (s->f)->scratch_cursor_gc,
+ mask, &xgcv);
+ else
+ FRAME_MAC_DISPLAY_INFO (s->f)->scratch_cursor_gc
+ = XCreateGC (s->display, s->window, mask, &xgcv);
+
+ s->gc = FRAME_MAC_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);
+ }
+
+
+ /* 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;
+ {
+ Rect r;
+ get_glyph_string_clip_rect (s, &r);
+ mac_set_clip_rectangle (s->display, s->window, &r);
+ }
+
+
+ /* RIF:
+ Compute left and right overhang of glyph string S. If S is a glyph
+ string for a composition, assume overhangs don't exist. */
+
+ static void
+ mac_compute_glyph_string_overhangs (s)
+ struct glyph_string *s;
+ {
+ #if 0
+ /* MAC_TODO: XTextExtents16 does nothing yet... */
+
+ 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;
+ }
+ #endif
+ }
+
+
+ /* 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;
+
+ xgcv.foreground = s->gc->background;
+ XFillRectangle (s->display, s->window, &xgcv, x, y, w, h);
+ }
+
+
+ /* 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 0 /* MAC_TODO: stipple */
+ 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
+ #endif
+ 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;
+ mac_draw_rectangle (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)
+ mac_draw_rectangle (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));
+
+
+ /* 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);
+ }
+
+
+ #endif /* USE_X_TOOLKIT */
+
+ #if 0 /* MAC_TODO */
+
+ /* Allocate the color COLOR->pixel on SCREEN of 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. */
+
+ int
+ x_alloc_nearest_color (f, cmap, color)
+ struct frame *f;
+ Colormap cmap;
+ XColor *color;
+ {
+ Display *display = FRAME_X_DISPLAY (f);
+ Screen *screen = FRAME_X_SCREEN (f);
+ int rc;
+
+ gamma_correct (f, color);
+ rc = XAllocColor (display, 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 = XDisplayCells (display, XScreenNumberOfScreen (screen));
+ XColor *cells = (XColor *) alloca (ncells * sizeof *cells);
+
+ for (i = 0; i < ncells; ++i)
+ cells[i].pixel = i;
+ XQueryColors (display, cmap, cells, 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 (display, cmap, color);
+ }
+
+ #ifdef DEBUG_X_COLORS
+ if (rc)
+ register_color (color->pixel);
+ #endif /* DEBUG_X_COLORS */
+
+ return rc;
+ }
+
+
+ /* 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;
+ XQueryColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (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;
+ }
+
+ #endif /* MAC_TODO */
+
+
+ /* 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-255) have to
+ 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 187
+
+
+ /* Allocate a color which is lighter or darker than *COLOR by FACTOR
+ or DELTA. Try a color with RGB values multiplied by FACTOR first.
+ If this produces the same color as COLOR, try a color where all RGB
+ values have DELTA added. Return the allocated color in *COLOR.
+ DISPLAY is the X display, CMAP is the colormap to operate on.
+ Value is non-zero if successful. */
+
+ static int
+ mac_alloc_lighter_color (f, color, factor, delta)
+ struct frame *f;
+ unsigned long *color;
+ double factor;
+ int delta;
+ {
+ unsigned long new;
+ long bright;
+
+ /* On Mac, RGB values are 0-255, not 0-65535, so scale delta. */
+ delta /= 256;
+
+ /* Change RGB values by specified FACTOR. Avoid overflow! */
+ xassert (factor >= 0);
+ new = RGB_TO_ULONG (min (0xff, (int) (factor * RED_FROM_ULONG (*color))),
+ min (0xff, (int) (factor * GREEN_FROM_ULONG (*color))),
+ min (0xff, (int) (factor * BLUE_FROM_ULONG (*color))));
+
+ /* Calculate brightness of COLOR. */
+ bright = (2 * RED_FROM_ULONG (*color) + 3 * GREEN_FROM_ULONG (*color)
+ + BLUE_FROM_ULONG (*color)) / 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 = RGB_TO_ULONG (max (0, min (0xff, (int) (RED_FROM_ULONG
(*color)) - min_delta)),
+ max (0, min (0xff, (int) (GREEN_FROM_ULONG
(*color)) - min_delta)),
+ max (0, min (0xff, (int) (BLUE_FROM_ULONG (*color))
- min_delta)));
+ else
+ new = RGB_TO_ULONG (max (0, min (0xff, (int) (min_delta +
RED_FROM_ULONG (*color)))),
+ max (0, min (0xff, (int) (min_delta +
GREEN_FROM_ULONG (*color)))),
+ max (0, min (0xff, (int) (min_delta +
BLUE_FROM_ULONG (*color)))));
+ }
+
+ if (new == *color)
+ new = RGB_TO_ULONG (max (0, min (0xff, (int) (delta + RED_FROM_ULONG
(*color)))),
+ max (0, min (0xff, (int) (delta + GREEN_FROM_ULONG
(*color)))),
+ max (0, min (0xff, (int) (delta + BLUE_FROM_ULONG
(*color)))));
+
+ /* MAC_TODO: Map to palette and retry with delta if same? */
+ /* MAC_TODO: Free colors (if using palette)? */
+
+ if (new == *color)
+ return 0;
+
+ *color = new;
+
+ return 1;
+ }
+
+
+ /* 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 mac_output *di = f->output_data.mac;
+ unsigned long mask = GCForeground;
+ unsigned long pixel;
+ unsigned long background = di->relief_background;
+ struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+
+ /* MAC_TODO: Free colors (if using palette)? */
+
+ /* Allocate new color. */
+ xgcv.foreground = default_pixel;
+ pixel = background;
+ if (dpyinfo->n_planes != 1
+ && mac_alloc_lighter_color (f, &pixel, factor, delta))
+ {
+ relief->allocated_p = 1;
+ xgcv.foreground = relief->pixel = pixel;
+ }
+
+ if (relief->gc == 0)
+ {
+ #if 0 /* MAC_TODO: stipple */
+ xgcv.stipple = dpyinfo->gray;
+ mask |= GCStipple;
+ #endif
+ relief->gc = XCreateGC (NULL, FRAME_MAC_WINDOW (f), mask, &xgcv);
+ }
+ else
+ XChangeGC (NULL, 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 mac_output *di = s->f->output_data.mac;
+ unsigned long color;
+
+ if (s->face->use_box_color_for_shadows_p)
+ color = s->face->box_color;
+ else if (s->first_glyph->type == IMAGE_GLYPH
+ && s->img->pixmap
+ && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
+ color = IMAGE_BACKGROUND (s->img, s->f, 0);
+ 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, top_p, bot_p, left_p, right_p, clip_rect)
+ struct frame *f;
+ int left_x, top_y, right_x, bottom_y, width;
+ int top_p, bot_p, left_p, right_p, raised_p;
+ Rect *clip_rect;
+ {
+ Display *dpy = FRAME_MAC_DISPLAY (f);
+ Window window = FRAME_MAC_WINDOW (f);
+ int i;
+ GC gc;
+
+ if (raised_p)
+ gc = f->output_data.mac->white_relief.gc;
+ else
+ gc = f->output_data.mac->black_relief.gc;
+ mac_set_clip_rectangle (dpy, window, clip_rect);
+
+ /* Top. */
+ if (top_p)
+ for (i = 0; i < width; ++i)
+ XDrawLine (dpy, window, gc,
+ left_x + i * left_p, top_y + i,
+ right_x - i * right_p, top_y + i);
+
+ /* Left. */
+ if (left_p)
+ for (i = 0; i < width; ++i)
+ XDrawLine (dpy, window, gc,
+ left_x + i, top_y + i, left_x + i, bottom_y - i);
+
+ mac_reset_clipping (dpy, window);
+ if (raised_p)
+ gc = f->output_data.mac->black_relief.gc;
+ else
+ gc = f->output_data.mac->white_relief.gc;
+ mac_set_clip_rectangle (dpy, window,
+ clip_rect);
+
+ /* Bottom. */
+ if (bot_p)
+ for (i = 0; i < width; ++i)
+ XDrawLine (dpy, window, gc,
+ left_x + i * left_p, bottom_y - i,
+ right_x - i * right_p, bottom_y - i);
+
+ /* Right. */
+ if (right_p)
+ for (i = 0; i < width; ++i)
+ XDrawLine (dpy, window, gc,
+ right_x - i, top_y + i + 1, right_x - i, bottom_y - i - 1);
+
+ mac_reset_clipping (dpy, window);
+ }
+
+
+ /* 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, width, left_p, right_p;
+ Rect *clip_rect;
+ {
+ XGCValues xgcv;
+
+ xgcv.foreground = s->face->box_color;
+ mac_set_clip_rectangle (s->display, s->window, clip_rect);
+
+ /* Top. */
+ XFillRectangle (s->display, s->window, &xgcv,
+ left_x, top_y, right_x - left_x + 1, width);
+
+ /* Left. */
+ if (left_p)
+ XFillRectangle (s->display, s->window, &xgcv,
+ left_x, top_y, width, bottom_y - top_y + 1);
+
+ /* Bottom. */
+ XFillRectangle (s->display, s->window, &xgcv,
+ left_x, bottom_y - width + 1, right_x - left_x + 1, width);
+
+ /* Right. */
+ if (right_p)
+ XFillRectangle (s->display, s->window, &xgcv,
+ right_x - width + 1, top_y, width, bottom_y - top_y + 1);
+
+ mac_reset_clipping (s->display, s->window);
+ }
+
+
+ /* 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;
+ Rect clip_rect;
+
+ last_x = window_box_right (s->w, s->area);
+ if (s->row->full_width_p
+ && !s->w->pseudo_window_p)
+ {
+ last_x += WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH (s->w);
+ if (s->area != RIGHT_MARGIN_AREA
+ || WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (s->w))
+ last_x += WINDOW_RIGHT_FRINGE_WIDTH (s->w);
+ }
+
+ /* 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)));
+
+ 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, 1, 1, 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 = s->x;
+ int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
+
+ /* 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
+ && s->slice.x == 0)
+ x += abs (s->face->box_line_width);
+
+ /* If there is a margin around the image, adjust x- and y-position
+ by that margin. */
+ if (s->slice.x == 0)
+ x += s->img->hmargin;
+ if (s->slice.y == 0)
+ y += s->img->vmargin;
+
+ if (s->img->pixmap)
+ {
+ if (s->img->mask)
+ {
+ Rect nr;
+ XRectangle clip_rect, image_rect, r;
+
+ get_glyph_string_clip_rect (s, &nr);
+ CONVERT_TO_XRECT (clip_rect, nr);
+ image_rect.x = x;
+ image_rect.y = y;
+ image_rect.width = s->slice.width;
+ image_rect.height = s->slice.height;
+ if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
+ mac_copy_area_with_mask (s->display, s->img->pixmap, s->img->mask,
+ s->window, s->gc,
+ s->slice.x + r.x - x, s->slice.y + r.y - y,
+ r.width, r.height, r.x, r.y);
+ }
+ else
+ {
+ Rect nr;
+ XRectangle clip_rect, image_rect, r;
+
+ get_glyph_string_clip_rect (s, &nr);
+ CONVERT_TO_XRECT (clip_rect, nr);
+ image_rect.x = x;
+ image_rect.y = y;
+ image_rect.width = s->slice.width;
+ image_rect.height = s->slice.height;
+ if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
+ mac_copy_area (s->display, s->img->pixmap, s->window, s->gc,
+ s->slice.x + r.x - x, s->slice.y + 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)
+ {
+ int r = s->img->relief;
+ if (r < 0) r = -r;
+ mac_draw_rectangle (s->display, s->window, s->gc,
+ x - r, y - r,
+ s->slice.width + r*2 - 1,
+ s->slice.height + r*2 - 1);
+ }
+ }
+ }
+ else
+ /* Draw a rectangle if image could not be loaded. */
+ mac_draw_rectangle (s->display, s->window, s->gc, x, y,
+ s->slice.width - 1, s->slice.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;
+ Rect r;
+ int x = s->x;
+ int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
+
+ /* 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
+ && s->slice.x == 0)
+ x += abs (s->face->box_line_width);
+
+ /* If there is a margin around the image, adjust x- and y-position
+ by that margin. */
+ if (s->slice.x == 0)
+ x += s->img->hmargin;
+ if (s->slice.y == 0)
+ 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 :
DEFAULT_TOOL_BAR_BUTTON_RELIEF;
+ 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->slice.width + thick - 1;
+ y1 = y + s->slice.height + thick - 1;
+
+ x_setup_relief_colors (s);
+ get_glyph_string_clip_rect (s, &r);
+ x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p,
+ s->slice.y == 0,
+ s->slice.y + s->slice.height == s->img->height,
+ s->slice.x == 0,
+ s->slice.x + s->slice.width == s->img->width,
+ &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 = 0;
+ int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
+
+ /* 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
+ && s->slice.x == 0)
+ x += abs (s->face->box_line_width);
+
+ /* If there is a margin around the image, adjust x- and y-position
+ by that margin. */
+ if (s->slice.x == 0)
+ x += s->img->hmargin;
+ if (s->slice.y == 0)
+ y += s->img->vmargin;
+
+ if (s->img->pixmap)
+ {
+ if (s->img->mask)
+ mac_copy_area_with_mask_to_pixmap (s->display, s->img->pixmap,
+ s->img->mask, pixmap, s->gc,
+ s->slice.x, s->slice.y,
+ s->slice.width, s->slice.height,
+ x, y);
+ else
+ {
+ mac_copy_area_to_pixmap (s->display, s->img->pixmap, pixmap, s->gc,
+ s->slice.x, s->slice.y,
+ s->slice.width, s->slice.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)
+ {
+ int r = s->img->relief;
+ if (r < 0) r = -r;
+ mac_draw_rectangle (s->display, s->window, s->gc, x - r, y - r,
+ s->slice.width + r*2 - 1,
+ s->slice.height + r*2 - 1);
+ }
+ }
+ }
+ else
+ /* Draw a rectangle if image could not be loaded. */
+ mac_draw_rectangle_to_pixmap (s->display, pixmap, s->gc, x, y,
+ s->slice.width - 1, s->slice.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 0 /* MAC_TODO: stipple */
+ 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
+ #endif /* MAC_TODO */
+ 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 = 0;
+
+ 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->slice.height
+ || s->img->hmargin
+ || s->img->vmargin
+ || s->img->mask
+ || s->img->pixmap == 0
+ || s->width != s->background_width)
+ {
+ x = s->x;
+ if (s->first_glyph->left_box_line_p
+ && s->slice.x == 0)
+ x += box_line_hwidth;
+
+ y = s->y;
+ if (s->slice.y == 0)
+ 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. */
+ int depth = one_mac_display_info.n_planes;
+
+ /* Create a pixmap as large as the glyph string. */
+ pixmap = XCreatePixmap (s->display, s->window,
+ s->background_width,
+ s->height, depth);
+
+ /* Fill the pixmap with the background color/stipple. */
+ #if 0 /* TODO: 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
+ #endif
+ {
+ XGCValues xgcv;
+ XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
+ &xgcv);
+ XSetForeground (s->display, s->gc, xgcv.background);
+ mac_fill_rectangle_to_pixmap (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 != 0)
+ {
+ x_draw_image_foreground_1 (s, pixmap);
+ x_set_glyph_string_clipping (s);
+ mac_copy_area (s->display, pixmap, s->window, s->gc,
+ 0, 0, s->background_width, s->height, s->x, s->y);
+ mac_reset_clipping (s->display, s->window);
+ 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 (FRAME_COLUMN_WIDTH (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)
+ {
+ int x = s->x + width, y = s->y;
+ int w = s->background_width - width, h = s->height;
+ Rect r;
+ GC gc;
+
+ if (s->row->mouse_face_p
+ && cursor_in_mouse_face_p (s->w))
+ {
+ x_set_mouse_face_gc (s);
+ gc = s->gc;
+ }
+ else
+ gc = s->face->gc;
+
+ get_glyph_string_clip_rect (s, &r);
+ mac_set_clip_rectangle (s->display, s->window, &r);
+
+ #if 0 /* MAC_TODO: stipple */
+ 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
+ #endif /* MAC_TODO */
+ {
+ 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);
+ }
+
+ mac_reset_clipping (s->display, s->window);
+ }
+ }
+ 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);
+
+ /* 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_set_glyph_string_clipping (s);
+ x_draw_glyph_string_background (s, 1);
+ x_draw_glyph_string_box (s);
+ x_set_glyph_string_clipping (s);
+ relief_drawn_p = 1;
+ }
+ else
+ x_set_glyph_string_clipping (s);
+
+ 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 h = 1;
+ unsigned long dy = s->height - h;
+
+ if (s->face->underline_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->underline_color);
+ XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
+ 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. */
+ mac_reset_clipping (s->display, s->window);
+ }
+
+ /* Shift display to make room for inserted glyphs. */
+
+ void
+ mac_shift_glyphs_for_insert (f, x, y, width, height, shift_by)
+ struct frame *f;
+ int x, y, width, height, shift_by;
+ {
+ mac_scroll_area (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ f->output_data.mac->normal_gc,
+ x, y, width, height,
+ x + shift_by, y);
+ }
+
+ /* Delete N glyphs at the nominal cursor position. Not implemented
+ for X frames. */
+
+ static void
+ x_delete_glyphs (n)
+ register int n;
+ {
+ abort ();
+ }
+
+
+ /* 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_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f));
+
+ #if 0 /* Clearing frame on Mac OS clears scroll bars. */
+ /* 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);
+ #endif
+
+ XFlush (FRAME_MAC_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;
+
+ FlashMenuBar (0);
+
+ {
+ 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. */
+ while (1)
+ {
+ struct timeval timeout;
+
+ EMACS_GET_TIME (timeout);
+
+ /* In effect, timeout = wakeup - timeout.
+ Break if result would be negative. */
+ if (timeval_subtract (&timeout, wakeup, timeout))
+ break;
+
+ /* Try to wait that long--but we might wake up sooner. */
+ select (0, NULL, NULL, NULL, &timeout);
+ }
+ }
+
+ FlashMenuBar (0);
+
+ UNBLOCK_INPUT;
+ }
+
+ #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
+
+
+ /* Make audible bell. */
+
+ void
+ XTring_bell ()
+ {
+ struct frame *f = SELECTED_FRAME ();
+
+ #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
+ if (visible_bell)
+ XTflash (f);
+ else
+ #endif
+ {
+ BLOCK_INPUT;
+ SysBeep (1);
+ XFlush (FRAME_MAC_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 left and right
+ fringe of W. */
+ window_box (w, -1, &x, &y, &width, &height);
+
+ 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);
+
+ mac_scroll_area (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ f->output_data.mac->normal_gc,
+ x, from_y,
+ width, height,
+ x, to_y);
+
+ UNBLOCK_INPUT;
+ }
+
+
+
+ /***********************************************************************
+ Exposure Events
+ ***********************************************************************/
+
+
+ static void
+ frame_highlight (f)
+ struct frame *f;
+ {
+ x_update_cursor (f, 1);
+ }
+
+ static void
+ frame_unhighlight (f)
+ struct frame *f;
+ {
+ 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, Qnil);
+ 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. */
+
+ #if 0 /* MAC_TODO */
+ /* 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);
+ }
+
+ #endif /* MAC_TODO */
+
+ /* Convert between the modifier bits X uses and the modifier bits
+ Emacs uses. */
+
+ static unsigned int
+ x_mac_to_emacs_modifiers (dpyinfo, state)
+ struct x_display_info *dpyinfo;
+ unsigned short state;
+ {
+ return (((state & shiftKey) ? shift_modifier : 0)
+ | ((state & controlKey) ? ctrl_modifier : 0)
+ | ((state & cmdKey) ? meta_modifier : 0)
+ | ((state & optionKey) ? alt_modifier : 0));
+ }
+
+ #if 0 /* MAC_TODO */
+ static unsigned short
+ 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));
+ }
+ #endif /* MAC_TODO */
+
+ /* Convert a keysym to its name. */
+
+ char *
+ x_get_keysym_name (keysym)
+ int keysym;
+ {
+ char *value;
+
+ BLOCK_INPUT;
+ #if 0
+ value = XKeysymToString (keysym);
+ #else
+ value = 0;
+ #endif
+ UNBLOCK_INPUT;
+
+ return value;
+ }
+
+
+
+ /* Mouse clicks and mouse movement. Rah. */
+
+ /* 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;
+ EventRecord *event;
+ struct frame *f;
+ {
+ Point mouseLoc;
+
+ result->kind = MOUSE_CLICK_EVENT;
+ result->code = 0; /* only one mouse button */
+ result->timestamp = event->when;
+ result->modifiers = event->what == mouseDown ? down_modifier : up_modifier;
+
+ mouseLoc = event->where;
+
+ SetPortWindowPort (FRAME_MAC_WINDOW (f));
+
+ GlobalToLocal (&mouseLoc);
+ XSETINT (result->x, mouseLoc.h);
+ XSETINT (result->y, mouseLoc.v);
+
+ 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 Point last_mouse_motion_position;
+ static Lisp_Object last_mouse_motion_frame;
+
+ static void
+ note_mouse_movement (frame, pos)
+ FRAME_PTR frame;
+ Point *pos;
+ {
+ struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (frame);
+ #if TARGET_API_MAC_CARBON
+ Rect r;
+ #endif
+
+ last_mouse_movement_time = TickCount () * (1000 / 60); /* to milliseconds
*/
+ last_mouse_motion_position = *pos;
+ XSETFRAME (last_mouse_motion_frame, frame);
+
+ #if TARGET_API_MAC_CARBON
+ if (!PtInRect (*pos, GetWindowPortBounds (FRAME_MAC_WINDOW (frame), &r)))
+ #else
+ if (!PtInRect (*pos, &FRAME_MAC_WINDOW (frame)->portRect))
+ #endif
+ {
+ if (frame == dpyinfo->mouse_face_mouse_frame)
+ /* This case corresponds to LeaveNotify in X11. */
+ {
+ /* 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;
+ if (!dpyinfo->grabbed)
+ rif->define_frame_cursor (frame,
+ frame->output_data.mac->nontext_cursor);
+ }
+ }
+ /* Has the mouse moved off the glyph it was on at the last sighting? */
+ else if (pos->h < last_mouse_glyph.left
+ || pos->h >= last_mouse_glyph.right
+ || pos->v < last_mouse_glyph.top
+ || pos->v >= last_mouse_glyph.bottom)
+ {
+ frame->mouse_moved = 1;
+ last_mouse_scroll_bar = Qnil;
+ note_mouse_highlight (frame, pos->h, pos->v);
+ }
+ }
+
+ /* This is used for debugging, to turn off note_mouse_highlight. */
+
+ int disable_mouse_highlight;
+
+
+
+ /************************************************************************
+ Mouse Face
+ ************************************************************************/
+
+ static struct scroll_bar *x_window_to_scroll_bar ();
+ static void x_scroll_bar_report_motion ();
+ static void x_check_fullscreen P_ ((struct frame *));
+ static void x_check_fullscreen_move P_ ((struct frame *));
+ static int glyph_rect P_ ((struct frame *f, int, int, Rect *));
+
+
+ /* MAC TODO: This should be called from somewhere (or removed) ++KFS */
+
+ 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_position.h,
+ last_mouse_motion_position.v);
+ }
+
+
+ /* 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;
+ Rect *rect;
+ {
+ Lisp_Object window;
+
+ window = window_from_coordinates (f, x, y, 0, &x, &y, 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;
+
+ for (; r < end && r->enabled_p; ++r)
+ if (r->y <= y && r->y + r->height > y)
+ {
+ /* Found the row at y. */
+ struct glyph *g = r->glyphs[TEXT_AREA];
+ struct glyph *end = g + r->used[TEXT_AREA];
+ int gx;
+
+ rect->top = WINDOW_TO_FRAME_PIXEL_Y (w, r->y);
+ rect->bottom = rect->top + r->height;
+
+ if (x < r->x)
+ {
+ /* x is to the left of the first glyph in the row. */
+ /* Shouldn't this be a pixel value?
+ WINDOW_LEFT_EDGE_X (w) seems to be the right value.
+ ++KFS */
+ rect->left = WINDOW_LEFT_EDGE_COL (w);
+ rect->right = WINDOW_TO_FRAME_PIXEL_X (w, r->x);
+ return 1;
+ }
+
+ for (gx = r->x; g < end; gx += g->pixel_width, ++g)
+ if (gx <= x && gx + g->pixel_width > x)
+ {
+ /* x is on a glyph. */
+ rect->left = WINDOW_TO_FRAME_PIXEL_X (w, gx);
+ rect->right = rect->left + g->pixel_width;
+ return 1;
+ }
+
+ /* x is to the right of the last glyph in the row. */
+ rect->left = WINDOW_TO_FRAME_PIXEL_X (w, gx);
+ /* Shouldn't this be a pixel value?
+ WINDOW_RIGHT_EDGE_X (w) seems to be the right value.
+ ++KFS */
+ rect->right = WINDOW_RIGHT_EDGE_COL (w);
+ return 1;
+ }
+ }
+
+ /* The y is not on any row. */
+ return 0;
+ }
+
+ /* MAC TODO: This should be called from somewhere (or removed) ++KFS */
+
+ /* Record the position of the mouse in last_mouse_glyph. */
+ static void
+ remember_mouse_glyph (f1, gx, gy)
+ struct frame * f1;
+ int gx, gy;
+ {
+ if (!glyph_rect (f1, gx, gy, &last_mouse_glyph))
+ {
+ int width = FRAME_SMALLEST_CHAR_WIDTH (f1);
+ int height = FRAME_SMALLEST_FONT_HEIGHT (f1);
+
+ /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
+ round down even for negative values. */
+ if (gx < 0)
+ gx -= width - 1;
+ if (gy < 0)
+ gy -= height - 1;
+ #if 0
+ /* This was the original code from XTmouse_position, but it seems
+ to give the position of the glyph diagonally next to the one
+ the mouse is over. */
+ gx = (gx + width - 1) / width * width;
+ gy = (gy + height - 1) / height * height;
+ #else
+ gx = gx / width * width;
+ gy = gy / height * height;
+ #endif
+
+ last_mouse_glyph.left = gx;
+ last_mouse_glyph.top = gy;
+ last_mouse_glyph.right = gx + width;
+ last_mouse_glyph.bottom = gy + height;
+ }
+ }
+
+
+ static WindowPtr
+ mac_front_window ()
+ {
+ #if TARGET_API_MAC_CARBON
+ return GetFrontWindowOfClass (kDocumentWindowClass, true);
+ #else
+ WindowPtr front_window = FrontWindow ();
+
+ if (tip_window && front_window == tip_window)
+ return GetNextWindow (front_window);
+ else
+ return front_window;
+ #endif
+ }
+
+ #define mac_window_to_frame(wp) (((mac_output *) GetWRefCon (wp))->mFP)
+
+ /* 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;
+ {
+ Point mouse_pos;
+ int ignore1, ignore2;
+ WindowPtr wp = mac_front_window ();
+ struct frame *f;
+ Lisp_Object frame, tail;
+
+ if (is_emacs_window(wp))
+ f = mac_window_to_frame (wp);
+
+ BLOCK_INPUT;
+
+ if (! NILP (last_mouse_scroll_bar) && insist == 0)
+ x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
+ else
+ {
+ /* Clear the mouse-moved flag for every frame on this display. */
+ FOR_EACH_FRAME (tail, frame)
+ XFRAME (frame)->mouse_moved = 0;
+
+ last_mouse_scroll_bar = Qnil;
+
+ SetPortWindowPort (wp);
+
+ GetMouse (&mouse_pos);
+
+ pixel_to_glyph_coords (f, mouse_pos.h, mouse_pos.v, &ignore1, &ignore2,
+ &last_mouse_glyph, insist);
+
+ *bar_window = Qnil;
+ *part = scroll_bar_handle;
+ *fp = f;
+ XSETINT (*x, mouse_pos.h);
+ XSETINT (*y, mouse_pos.v);
+ *time = last_mouse_movement_time;
+ }
+
+ UNBLOCK_INPUT;
+ }
+
+
+ /***********************************************************************
+ Tool-bars
+ ***********************************************************************/
+
+ /* 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
+ mac_handle_tool_bar_click (f, button_event)
+ struct frame *f;
+ EventRecord *button_event;
+ {
+ int x = button_event->where.h;
+ int y = button_event->where.v;
+
+ if (button_event->what == mouseDown)
+ handle_tool_bar_click (f, x, y, 1, 0);
+ else
+ handle_tool_bar_click (f, x, y, 0,
+ x_mac_to_emacs_modifiers (FRAME_MAC_DISPLAY_INFO (f),
+ button_event->modifiers));
+ }
+
+
+ /************************************************************************
+ 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, disp_top, disp_height)
+ struct window *w;
+ int top, left, width, height, disp_top, disp_height;
+ {
+ struct frame *f = XFRAME (w->frame);
+ struct scroll_bar *bar
+ = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
+ Rect r;
+ ControlHandle ch;
+
+ BLOCK_INPUT;
+
+ r.left = left;
+ r.top = disp_top;
+ r.right = left + width;
+ r.bottom = disp_top + disp_height;
+
+ #ifdef TARGET_API_MAC_CARBON
+ ch = NewControl (FRAME_MAC_WINDOW (f), &r, "\p", 1, 0, 0, 0,
+ kControlScrollBarProc, 0L);
+ #else
+ ch = NewControl (FRAME_MAC_WINDOW (f), &r, "\p", 1, 0, 0, 0, scrollBarProc,
+ 0L);
+ #endif
+ SET_SCROLL_BAR_CONTROL_HANDLE (bar, ch);
+ SetControlReference (ch, (long) bar);
+
+ 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);
+
+ 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. */
+
+ 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);
+ ControlHandle ch = SCROLL_BAR_CONTROL_HANDLE (bar);
+ FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+ int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
+ int length = end - start;
+
+ /* If the display is already accurate, do nothing. */
+ if (! rebuild
+ && start == XINT (bar->start)
+ && end == XINT (bar->end))
+ return;
+
+ BLOCK_INPUT;
+
+ /* Make sure the values are reasonable, and try to preserve the
+ distance between start and end. */
+ 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;
+
+ SetControlMinimum (ch, 0);
+ /* Don't inadvertently activate deactivated scroll bars */
+ if (GetControlMaximum (ch) != -1)
+ SetControlMaximum (ch, top_range + VERTICAL_SCROLL_BAR_MIN_HANDLE
+ - (end - start));
+ SetControlValue (ch, start);
+ #if TARGET_API_MAC_CARBON
+ SetControlViewSize (ch, end - start);
+ #endif
+
+ UNBLOCK_INPUT;
+ }
+
+
+ /* 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;
+ {
+ FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+
+ BLOCK_INPUT;
+
+ /* Destroy the Mac scroll bar control */
+ DisposeControl (SCROLL_BAR_CONTROL_HANDLE (bar));
+
+ /* 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, disp_top, disp_height;
+ int window_y, window_height;
+
+ /* Get window dimensions. */
+ window_box (w, -1, 0, &window_y, 0, &window_height);
+ top = window_y;
+ #ifdef MAC_OSX
+ width = 16;
+ #else
+ width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
+ #endif
+ height = window_height;
+
+ /* Compute the left edge of the scroll bar area. */
+ left = WINDOW_SCROLL_BAR_AREA_X (w);
+
+ /* Compute the width of the scroll bar which might be less than
+ the width of the area reserved for the scroll bar. */
+ if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w) > 0)
+ sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
+ else
+ sb_width = width;
+
+ /* Compute the left edge of the scroll bar. */
+ if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
+ sb_left = left + width - sb_width - (width - sb_width) / 2;
+ else
+ sb_left = left + (width - sb_width) / 2;
+
+ /* Adjustments according to Inside Macintosh to make it look nice */
+ disp_top = top;
+ disp_height = height;
+ if (disp_top == 0)
+ {
+ disp_top = -1;
+ disp_height++;
+ }
+ else if (disp_top == FRAME_PIXEL_HEIGHT (f) - 16)
+ {
+ disp_top++;
+ disp_height--;
+ }
+
+ if (sb_left + sb_width == FRAME_PIXEL_WIDTH (f))
+ sb_left++;
+
+ /* Does the scroll bar exist yet? */
+ if (NILP (w->vertical_scroll_bar))
+ {
+ BLOCK_INPUT;
+ XClearArea (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ left, top, width, height, 0);
+ UNBLOCK_INPUT;
+ bar = x_scroll_bar_create (w, top, sb_left, sb_width, height, disp_top,
+ disp_height);
+ XSETVECTOR (w->vertical_scroll_bar, bar);
+ }
+ else
+ {
+ /* It may just need to be moved and resized. */
+ ControlHandle ch;
+
+ bar = XSCROLL_BAR (w->vertical_scroll_bar);
+ ch = SCROLL_BAR_CONTROL_HANDLE (bar);
+
+ BLOCK_INPUT;
+
+ /* If already correctly positioned, do nothing. */
+ if (XINT (bar->left) == sb_left
+ && XINT (bar->top) == top
+ && XINT (bar->width) == sb_width
+ && XINT (bar->height) == height)
+ Draw1Control (ch);
+ else
+ {
+ /* 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 = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
+ XClearArea (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ left, top, area_width, height, 0);
+
+ #if 0
+ if (sb_left + sb_width >= FRAME_PIXEL_WIDTH (f))
+ XClearArea (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ sb_left - 1, top, 1, height, 0);
+ #endif
+
+ HideControl (ch);
+ MoveControl (ch, sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
disp_top);
+ SizeControl (ch, sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
+ disp_height);
+ ShowControl (ch);
+
+ /* Remember new settings. */
+ XSETINT (bar->left, sb_left);
+ XSETINT (bar->top, top);
+ XSETINT (bar->width, sb_width);
+ XSETINT (bar->height, height);
+ }
+
+ UNBLOCK_INPUT;
+ }
+
+ /* 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);
+ }
+ }
+ }
+
+
+ /* 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;
+
+ /* 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. */
+ {
+ FRAME_PTR 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. */
+ }
+
+
+ void
+ activate_scroll_bars (frame)
+ FRAME_PTR frame;
+ {
+ Lisp_Object bar;
+ ControlHandle ch;
+
+ bar = FRAME_SCROLL_BARS (frame);
+ while (! NILP (bar))
+ {
+ ch = SCROLL_BAR_CONTROL_HANDLE (XSCROLL_BAR (bar));
+ #ifdef TARGET_API_MAC_CARBON
+ ActivateControl (ch);
+ #else
+ SetControlMaximum (ch,
+ VERTICAL_SCROLL_BAR_TOP_RANGE (frame,
+ XINT (XSCROLL_BAR (bar)
+ ->height)) - 1);
+ #endif
+ bar = XSCROLL_BAR (bar)->next;
+ }
+ }
+
+
+ void
+ deactivate_scroll_bars (frame)
+ FRAME_PTR frame;
+ {
+ Lisp_Object bar;
+ ControlHandle ch;
+
+ bar = FRAME_SCROLL_BARS (frame);
+ while (! NILP (bar))
+ {
+ ch = SCROLL_BAR_CONTROL_HANDLE (XSCROLL_BAR (bar));
+ #ifdef TARGET_API_MAC_CARBON
+ DeactivateControl (ch);
+ #else
+ SetControlMaximum (ch, XINT (-1));
+ #endif
+ bar = XSCROLL_BAR (bar)->next;
+ }
+ }
+
+ /* 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. */
+
+ static void
+ x_scroll_bar_handle_click (bar, part_code, er, bufp)
+ struct scroll_bar *bar;
+ int part_code;
+ EventRecord *er;
+ struct input_event *bufp;
+ {
+ int win_y, top_range;
+
+ if (! GC_WINDOWP (bar->window))
+ abort ();
+
+ bufp->kind = SCROLL_BAR_CLICK_EVENT;
+ bufp->frame_or_window = bar->window;
+ bufp->arg = Qnil;
+
+ bar->dragging = Qnil;
+
+ switch (part_code)
+ {
+ case kControlUpButtonPart:
+ bufp->part = scroll_bar_up_arrow;
+ break;
+ case kControlDownButtonPart:
+ bufp->part = scroll_bar_down_arrow;
+ break;
+ case kControlPageUpPart:
+ bufp->part = scroll_bar_above_handle;
+ break;
+ case kControlPageDownPart:
+ bufp->part = scroll_bar_below_handle;
+ break;
+ #ifdef TARGET_API_MAC_CARBON
+ default:
+ #else
+ case kControlIndicatorPart:
+ #endif
+ if (er->what == mouseDown)
+ bar->dragging = make_number (0);
+ XSETVECTOR (last_mouse_scroll_bar, bar);
+ bufp->part = scroll_bar_handle;
+ break;
+ }
+
+ win_y = XINT (bufp->y) - XINT (bar->top);
+ top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (0/*dummy*/, XINT (bar->height));
+
+ win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
+
+ win_y -= 24;
+
+ 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;
+
+ XSETINT (bufp->x, win_y);
+ XSETINT (bufp->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, y_pos, t)
+ struct scroll_bar *bar;
+ int y_pos;
+ Time t;
+ {
+ FRAME_PTR f = XFRAME (XWINDOW (bar->window)->frame);
+
+ last_mouse_movement_time = t;
+
+ 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 = y_pos - 24;
+
+ 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);
+ }
+ }
+ }
+
+
+ /* 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);
+ WindowPtr wp = mac_front_window ();
+ Point mouse_pos;
+ struct frame *f = mac_window_to_frame (wp);
+ int win_y, top_range;
+
+ SetPortWindowPort (wp);
+
+ GetMouse (&mouse_pos);
+
+ win_y = mouse_pos.v - XINT (bar->top);
+ top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
+
+ win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
+
+ win_y -= 24;
+
+ 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;
+ }
+
+ /***********************************************************************
+ Text Cursor
+ ***********************************************************************/
+
+ /* 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.
+
+ 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)
+ struct window *w;
+ struct glyph_row *row;
+ GC gc;
+ {
+ struct frame *f = XFRAME (WINDOW_FRAME (w));
+ Rect clip_rect;
+ int window_y, window_width;
+
+ window_box (w, -1, 0, &window_y, &window_width, 0);
+
+ clip_rect.left = WINDOW_TO_FRAME_PIXEL_X (w, 0);
+ clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
+ clip_rect.top = max (clip_rect.top, window_y);
+ clip_rect.right = clip_rect.left + window_width;
+ clip_rect.bottom = clip_rect.top + row->visible_height;
+
+ mac_set_clip_rectangle (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
&clip_rect);
+ }
+
+
+ /* 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 mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+ Display *dpy = FRAME_MAC_DISPLAY (f);
+ int x, y, wd, h;
+ XGCValues xgcv;
+ struct glyph *cursor_glyph;
+ GC gc;
+
+ /* 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 (FRAME_COLUMN_WIDTH (f), wd);
+ w->phys_cursor_width = wd;
+
+ /* 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);
+
+ /* Compute the proper height and ascent of the rectangle, based
+ on the actual glyph. Using the full height of the row looks
+ bad when there are tall images on that row. */
+ h = max (min (FRAME_LINE_HEIGHT (f), row->height),
+ cursor_glyph->ascent + cursor_glyph->descent);
+ if (h < row->height)
+ y += row->ascent /* - w->phys_cursor_ascent */ + cursor_glyph->descent -
h;
+ h--;
+
+ /* 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.mac->cursor_pixel;
+ if (dpyinfo->scratch_cursor_gc)
+ XChangeGC (dpy, dpyinfo->scratch_cursor_gc, GCForeground, &xgcv);
+ else
+ dpyinfo->scratch_cursor_gc = XCreateGC (dpy, FRAME_MAC_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);
+ mac_draw_rectangle (dpy, FRAME_MAC_WINDOW (f), gc, x, y, wd, h);
+ mac_reset_clipping (dpy, FRAME_MAC_WINDOW (f));
+ }
+
+
+ /* 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, kind)
+ struct window *w;
+ struct glyph_row *row;
+ int width;
+ enum text_cursor_kinds kind;
+ {
+ struct frame *f = XFRAME (w->frame);
+ struct glyph *cursor_glyph;
+
+ /* 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);
+ draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
+ }
+ else
+ {
+ Display *dpy = FRAME_MAC_DISPLAY (f);
+ Window window = FRAME_MAC_WINDOW (f);
+ GC gc = FRAME_MAC_DISPLAY_INFO (f)->scratch_cursor_gc;
+ unsigned long mask = GCForeground | GCBackground;
+ struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id);
+ XGCValues xgcv;
+
+ /* If the glyph's background equals the color we normally draw
+ the bar cursor in, the bar cursor in its normal color is
+ invisible. Use the glyph's foreground color instead in this
+ case, on the assumption that the glyph's colors are chosen so
+ that the glyph is legible. */
+ if (face->background == f->output_data.mac->cursor_pixel)
+ xgcv.background = xgcv.foreground = face->foreground;
+ else
+ xgcv.background = xgcv.foreground = f->output_data.mac->cursor_pixel;
+
+ if (gc)
+ XChangeGC (dpy, gc, mask, &xgcv);
+ else
+ {
+ gc = XCreateGC (dpy, window, mask, &xgcv);
+ FRAME_MAC_DISPLAY_INFO (f)->scratch_cursor_gc = gc;
+ }
+
+ if (width < 0)
+ width = FRAME_CURSOR_WIDTH (f);
+ width = min (cursor_glyph->pixel_width, width);
+
+ w->phys_cursor_width = width;
+ x_clip_to_row (w, row, gc);
+
+ if (kind == BAR_CURSOR)
+ XFillRectangle (dpy, window, gc,
+ WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
+ WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
+ width, row->height);
+ else
+ XFillRectangle (dpy, window, gc,
+ WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
+ WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
+ row->height - width),
+ cursor_glyph->pixel_width,
+ width);
+
+ mac_reset_clipping (dpy, FRAME_MAC_WINDOW (f));
+ }
+ }
+
+
+ /* RIF: Define cursor CURSOR on frame F. */
+
+ static void
+ mac_define_frame_cursor (f, cursor)
+ struct frame *f;
+ Cursor cursor;
+ {
+ #if TARGET_API_MAC_CARBON
+ SetThemeCursor (cursor);
+ #else
+ SetCursor (*cursor);
+ #endif
+ }
+
+
+ /* RIF: Clear area on frame F. */
+
+ static void
+ mac_clear_frame_area (f, x, y, width, height)
+ struct frame *f;
+ int x, y, width, height;
+ {
+ XClearArea (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
+ x, y, width, height, 0);
+ }
+
+
+ /* RIF: Draw cursor on window W. */
+
+ static void
+ mac_draw_window_cursor (w, glyph_row, x, y, cursor_type, cursor_width, on_p,
active_p)
+ struct window *w;
+ struct glyph_row *glyph_row;
+ int x, y;
+ int cursor_type, cursor_width;
+ int on_p, active_p;
+ {
+ if (on_p)
+ {
+ w->phys_cursor_type = cursor_type;
+ w->phys_cursor_on_p = 1;
+
+ if (glyph_row->exact_window_width_line_p
+ && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
+ {
+ glyph_row->cursor_in_fringe_p = 1;
+ draw_fringe_bitmap (w, glyph_row, 0);
+ }
+ else
+ switch (cursor_type)
+ {
+ case HOLLOW_BOX_CURSOR:
+ x_draw_hollow_cursor (w, glyph_row);
+ break;
+
+ case FILLED_BOX_CURSOR:
+ draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
+ break;
+
+ case BAR_CURSOR:
+ x_draw_bar_cursor (w, glyph_row, cursor_width, BAR_CURSOR);
+ break;
+
+ case HBAR_CURSOR:
+ x_draw_bar_cursor (w, glyph_row, cursor_width, HBAR_CURSOR);
+ break;
+
+ case NO_CURSOR:
+ w->phys_cursor_width = 0;
+ break;
+
+ default:
+ abort ();
+ }
+ }
+ }
+
+
+ /* Icons. */
+
+ #if 0 /* MAC_TODO: no icon support yet. */
+ int
+ x_bitmap_icon (f, icon)
+ struct frame *f;
+ Lisp_Object icon;
+ {
+ HANDLE hicon;
+
+ if (FRAME_W32_WINDOW (f) == 0)
+ return 1;
+
+ if (NILP (icon))
+ hicon = LoadIcon (hinst, EMACS_CLASS);
+ else if (STRINGP (icon))
+ hicon = LoadImage (NULL, (LPCTSTR) SDATA (icon), IMAGE_ICON, 0, 0,
+ LR_DEFAULTSIZE | LR_LOADFROMFILE);
+ else if (SYMBOLP (icon))
+ {
+ LPCTSTR name;
+
+ if (EQ (icon, intern ("application")))
+ name = (LPCTSTR) IDI_APPLICATION;
+ else if (EQ (icon, intern ("hand")))
+ name = (LPCTSTR) IDI_HAND;
+ else if (EQ (icon, intern ("question")))
+ name = (LPCTSTR) IDI_QUESTION;
+ else if (EQ (icon, intern ("exclamation")))
+ name = (LPCTSTR) IDI_EXCLAMATION;
+ else if (EQ (icon, intern ("asterisk")))
+ name = (LPCTSTR) IDI_ASTERISK;
+ else if (EQ (icon, intern ("winlogo")))
+ name = (LPCTSTR) IDI_WINLOGO;
+ else
+ return 1;
+
+ hicon = LoadIcon (NULL, name);
+ }
+ else
+ return 1;
+
+ if (hicon == NULL)
+ return 1;
+
+ PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_BIG,
+ (LPARAM) hicon);
+
+ return 0;
+ }
+ #endif /* MAC_TODO */
+
+ /************************************************************************
+ Handling X errors
+ ************************************************************************/
+
+ /* Display Error Handling functions not used on W32. Listing them here
+ helps diff stay in step when comparing w32term.c with xterm.c.
+
+ x_error_catcher (display, error)
+ x_catch_errors (dpy)
+ x_catch_errors_unwind (old_val)
+ x_check_errors (dpy, format)
+ x_had_errors_p (dpy)
+ x_clear_errors (dpy)
+ x_uncatch_errors (dpy, count)
+ x_trace_wire ()
+ x_connection_signal (signalnum)
+ x_connection_closed (dpy, error_message)
+ x_error_quitter (display, error)
+ x_error_handler (display, error)
+ x_io_error_quitter (display)
+
+ */
+
+
+ /* 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;
+
+ FRAME_FONT (f) = (XFontStruct *) (fontp->font);
+ FRAME_BASELINE_OFFSET (f) = fontp->baseline_offset;
+ FRAME_FONTSET (f) = -1;
+
+ FRAME_COLUMN_WIDTH (f) = FONT_WIDTH (FRAME_FONT (f));
+ FRAME_LINE_HEIGHT (f) = FONT_HEIGHT (FRAME_FONT (f));
+
+ compute_fringe_widths (f, 1);
+
+ /* Compute the scroll bar width in character columns. */
+ if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
+ {
+ int wid = FRAME_COLUMN_WIDTH (f);
+ FRAME_CONFIG_SCROLL_BAR_COLS (f)
+ = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid-1) / wid;
+ }
+ else
+ {
+ int wid = FRAME_COLUMN_WIDTH (f);
+ FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
+ }
+
+ /* Now make the frame display the given font. */
+ if (FRAME_MAC_WINDOW (f) != 0)
+ {
+ XSetFont (FRAME_MAC_DISPLAY (f), f->output_data.mac->normal_gc,
+ FRAME_FONT (f));
+ XSetFont (FRAME_MAC_DISPLAY (f), f->output_data.mac->reverse_gc,
+ FRAME_FONT (f));
+ XSetFont (FRAME_MAC_DISPLAY (f), f->output_data.mac->cursor_gc,
+ FRAME_FONT (f));
+
+ if (NILP (tip_frame) || XFRAME (tip_frame) != f)
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ }
+
+ 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 (FRAME_FONTSET (f) == fontset)
+ /* This fontset is already set in frame F. There's nothing more
+ to do. */
+ return fontset_name (fontset);
+
+ result = x_new_font (f, (SDATA (fontset_ascii (fontset))));
+
+ if (!STRINGP (result))
+ /* Can't load ASCII font. */
+ return Qnil;
+
+ /* Since x_new_font doesn't update any fontset information, do it now. */
+ FRAME_FONTSET(f) = fontset;
+
+ return build_string (fontsetname);
+ }
+
+
+ /***********************************************************************
+ TODO: W32 Input Methods
+ ***********************************************************************/
+ /* Listing missing functions from xterm.c helps diff stay in step.
+
+ xim_destroy_callback (xim, client_data, call_data)
+ xim_open_dpy (dpyinfo, resource_name)
+ struct xim_inst_t
+ xim_instantiate_callback (display, client_data, call_data)
+ xim_initialize (dpyinfo, resource_name)
+ xim_close_dpy (dpyinfo)
+
+ */
+
+
+ /* Calculate the absolute position in frame F
+ from its current recorded position values and gravity. */
+
+ void
+ x_calc_absolute_position (f)
+ struct frame *f;
+ {
+ Point pt;
+ int flags = f->size_hint_flags;
+
+ pt.h = pt.v = 0;
+
+ /* Find the position of the outside upper-left corner of
+ the inner window, with respect to the outer window. */
+ if (f->output_data.mac->parent_desc != FRAME_MAC_DISPLAY_INFO
(f)->root_window)
+ {
+ GrafPtr savePort;
+ GetPort (&savePort);
+
+ SetPortWindowPort (FRAME_MAC_WINDOW (f));
+
+ #if TARGET_API_MAC_CARBON
+ {
+ Rect r;
+
+ GetWindowPortBounds (FRAME_MAC_WINDOW (f), &r);
+ SetPt(&pt, r.left, r.top);
+ }
+ #else /* not TARGET_API_MAC_CARBON */
+ SetPt(&pt, FRAME_MAC_WINDOW (f)->portRect.left, FRAME_MAC_WINDOW
(f)->portRect.top);
+ #endif /* not TARGET_API_MAC_CARBON */
+ LocalToGlobal (&pt);
+ SetPort (savePort);
+ }
+
+ /* Treat negative positions as relative to the leftmost bottommost
+ position that fits on the screen. */
+ if (flags & XNegative)
+ f->left_pos = (FRAME_MAC_DISPLAY_INFO (f)->width
+ - 2 * f->border_width - pt.h
+ - FRAME_PIXEL_WIDTH (f)
+ + f->left_pos);
+ /* NTEMACS_TODO: Subtract menubar height? */
+ if (flags & YNegative)
+ f->top_pos = (FRAME_MAC_DISPLAY_INFO (f)->height
+ - 2 * f->border_width - pt.v
+ - FRAME_PIXEL_HEIGHT (f)
+ + f->top_pos);
+ /* The left_pos and top_pos
+ are now relative to the top and left screen edges,
+ so the flags should correspond. */
+ f->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->top_pos = yoff;
+ f->left_pos = xoff;
+ f->size_hint_flags &= ~ (XNegative | YNegative);
+ if (xoff < 0)
+ f->size_hint_flags |= XNegative;
+ if (yoff < 0)
+ f->size_hint_flags |= YNegative;
+ f->win_gravity = NorthWestGravity;
+ }
+ x_calc_absolute_position (f);
+
+ BLOCK_INPUT;
+ x_wm_set_size_hint (f, (long) 0, 0);
+
+ modified_left = f->left_pos;
+ modified_top = f->top_pos;
+
+ MoveWindow (FRAME_MAC_WINDOW (f), modified_left + 6,
+ modified_top + 42, false);
+
+ UNBLOCK_INPUT;
+ }
+
+ /* 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;
+ {
+ int pixelwidth, pixelheight;
+
+ BLOCK_INPUT;
+
+ check_frame_size (f, &rows, &cols);
+ f->scroll_bar_actual_width
+ = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
+
+ compute_fringe_widths (f, 0);
+
+ pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols);
+ pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
+
+ f->win_gravity = NorthWestGravity;
+ x_wm_set_size_hint (f, (long) 0, 0);
+
+ SizeWindow (FRAME_MAC_WINDOW (f), pixelwidth, pixelheight, 0);
+
+ /* 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);
+ FRAME_PIXEL_WIDTH (f) = pixelwidth;
+ FRAME_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));
+
+ /* 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_pixel_position (struct frame *f, int pix_x, int pix_y);
+
+ void
+ x_set_mouse_position (f, x, y)
+ struct frame *f;
+ int x, y;
+ {
+ int pix_x, pix_y;
+
+ pix_x = FRAME_COL_TO_PIXEL_X (f, x) + FRAME_COLUMN_WIDTH (f) / 2;
+ pix_y = FRAME_LINE_TO_PIXEL_Y (f, y) + FRAME_LINE_HEIGHT (f) / 2;
+
+ if (pix_x < 0) pix_x = 0;
+ if (pix_x > FRAME_PIXEL_WIDTH (f)) pix_x = FRAME_PIXEL_WIDTH (f);
+
+ if (pix_y < 0) pix_y = 0;
+ if (pix_y > FRAME_PIXEL_HEIGHT (f)) pix_y = FRAME_PIXEL_HEIGHT (f);
+
+ x_set_mouse_pixel_position (f, pix_x, pix_y);
+ }
+
+ void
+ x_set_mouse_pixel_position (f, pix_x, pix_y)
+ struct frame *f;
+ int pix_x, pix_y;
+ {
+ #if 0 /* MAC_TODO: CursorDeviceMoveTo is non-Carbon */
+ BLOCK_INPUT;
+
+ XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
+ 0, 0, 0, 0, pix_x, pix_y);
+ UNBLOCK_INPUT;
+ #endif
+ }
+
+
+ /* 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;
+ {
+ }
+
+ /* Raise frame F. */
+ void
+ x_raise_frame (f)
+ struct frame *f;
+ {
+ if (f->async_visible)
+ SelectWindow (FRAME_MAC_WINDOW (f));
+ }
+
+ /* Lower frame F. */
+ void
+ x_lower_frame (f)
+ struct frame *f;
+ {
+ if (f->async_visible)
+ SendBehind (FRAME_MAC_WINDOW (f), nil);
+ }
+
+ 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;
+
+ BLOCK_INPUT;
+
+ 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.mac->asked_for_visible)
+ x_set_offset (f, f->left_pos, f->top_pos, 0);
+
+ f->output_data.mac->asked_for_visible = 1;
+
+ ShowWindow (FRAME_MAC_WINDOW (f));
+ }
+
+ XFlush (FRAME_MAC_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 come after we set COUNT. */
+ 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);
+ }
+ }
+ }
+
+ /* Change from mapped state to withdrawn state. */
+
+ /* Make the frame visible (mapped and not iconified). */
+
+ void
+ x_make_frame_invisible (f)
+ struct frame *f;
+ {
+ /* Don't keep the highlight on an invisible frame. */
+ if (FRAME_MAC_DISPLAY_INFO (f)->x_highlight_frame == f)
+ FRAME_MAC_DISPLAY_INFO (f)->x_highlight_frame = 0;
+
+ BLOCK_INPUT;
+
+ HideWindow (FRAME_MAC_WINDOW (f));
+
+ /* 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;
+
+ UNBLOCK_INPUT;
+ }
+
+ /* Change window state from mapped to iconified. */
+
+ void
+ x_iconify_frame (f)
+ struct frame *f;
+ {
+ /* Don't keep the highlight on an invisible frame. */
+ if (FRAME_MAC_DISPLAY_INFO (f)->x_highlight_frame == f)
+ FRAME_MAC_DISPLAY_INFO (f)->x_highlight_frame = 0;
+
+ #if 0
+ /* Review: Since window is still visible in dock, still allow updates? */
+ if (f->async_iconified)
+ return;
+ #endif
+
+ BLOCK_INPUT;
+
+ CollapseWindow (FRAME_MAC_WINDOW (f), true);
+
+ UNBLOCK_INPUT;
+ }
+
+
+ /* Free X resources of frame F. */
+
+ void
+ x_free_frame_resources (f)
+ struct frame *f;
+ {
+ struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+ WindowPtr wp = FRAME_MAC_WINDOW (f);
+
+ BLOCK_INPUT;
+
+ DisposeWindow (wp);
+ if (wp == tip_window)
+ /* Neither WaitNextEvent nor ReceiveNextEvent receives `window
+ closed' event. So we reset tip_window here. */
+ tip_window = NULL;
+
+ free_frame_menubar (f);
+
+ if (FRAME_FACE_CACHE (f))
+ free_frame_faces (f);
+
+ x_free_gcs (f);
+
+ xfree (f->output_data.mac);
+ f->output_data.mac = 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 mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+
+ 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;
+ {
+ #if 0 /* MAC_TODO: connect this to the Appearance Manager */
+ 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->left_pos;
+ size_hints.y = f->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 = FRAME_PIXEL_HEIGHT (f);
+ size_hints.width = FRAME_PIXEL_WIDTH (f);
+ #endif /* not USE_X_TOOLKIT */
+
+ size_hints.width_inc = FRAME_COLUMN_WIDTH (f);
+ size_hints.height_inc = FRAME_LINE_HEIGHT (f);
+ size_hints.max_width
+ = FRAME_X_DISPLAY_INFO (f)->width - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0);
+ size_hints.max_height
+ = FRAME_X_DISPLAY_INFO (f)->height - FRAME_TEXT_LINES_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 = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0);
+ base_height = FRAME_TEXT_LINES_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->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
+ #endif /* MAC_TODO */
+ }
+
+ #if 0 /* MAC_TODO: hide application instead of iconify? */
+ /* 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 */
+ }
+
+ #endif /* MAC_TODO */
+
+ void
+ x_wm_set_icon_position (f, icon_x, icon_y)
+ struct frame *f;
+ int icon_x, icon_y;
+ {
+ #if 0 /* MAC_TODO: no icons on Mac */
+ #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);
+ #endif /* MAC_TODO */
+ }
+
+
+ /***********************************************************************
+ 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_MAC_FONT_TABLE (f) + font_idx);
+ }
+
+ /* the global font name table */
+ char **font_name_table = NULL;
+ int font_name_table_size = 0;
+ int font_name_count = 0;
+
+ #if 0
+ /* compare two strings ignoring case */
+ static int
+ stricmp (const char *s, const char *t)
+ {
+ for ( ; tolower (*s) == tolower (*t); s++, t++)
+ if (*s == '\0')
+ return 0;
+ return tolower (*s) - tolower (*t);
+ }
+
+ /* compare two strings ignoring case and handling wildcard */
+ static int
+ wildstrieq (char *s1, char *s2)
+ {
+ if (strcmp (s1, "*") == 0 || strcmp (s2, "*") == 0)
+ return true;
+
+ return stricmp (s1, s2) == 0;
+ }
+
+ /* Assume parameter 1 is fully qualified, no wildcards. */
+ static int
+ mac_font_pattern_match (fontname, pattern)
+ char * fontname;
+ char * pattern;
+ {
+ char *regex = (char *) alloca (strlen (pattern) * 2 + 3);
+ char *font_name_copy = (char *) alloca (strlen (fontname) + 1);
+ char *ptr;
+
+ /* Copy fontname so we can modify it during comparison. */
+ strcpy (font_name_copy, fontname);
+
+ ptr = regex;
+ *ptr++ = '^';
+
+ /* Turn pattern into a regexp and do a regexp match. */
+ for (; *pattern; pattern++)
+ {
+ if (*pattern == '?')
+ *ptr++ = '.';
+ else if (*pattern == '*')
+ {
+ *ptr++ = '.';
+ *ptr++ = '*';
+ }
+ else
+ *ptr++ = *pattern;
+ }
+ *ptr = '$';
+ *(ptr + 1) = '\0';
+
+ return (fast_c_string_match_ignore_case (build_string (regex),
+ font_name_copy) >= 0);
+ }
+
+ /* Two font specs are considered to match if their foundry, family,
+ weight, slant, and charset match. */
+ static int
+ mac_font_match (char *mf, char *xf)
+ {
+ char m_foundry[50], m_family[50], m_weight[20], m_slant[2], m_charset[20];
+ char x_foundry[50], x_family[50], x_weight[20], x_slant[2], x_charset[20];
+
+ if (sscanf (mf,
"-%49[^-]-%49[^-]-%19[^-]-%1[^-]-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%19s",
+ m_foundry, m_family, m_weight, m_slant, m_charset) != 5)
+ return mac_font_pattern_match (mf, xf);
+
+ if (sscanf (xf,
"-%49[^-]-%49[^-]-%19[^-]-%1[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%19s",
+ x_foundry, x_family, x_weight, x_slant, x_charset) != 5)
+ return mac_font_pattern_match (mf, xf);
+
+ return (wildstrieq (m_foundry, x_foundry)
+ && wildstrieq (m_family, x_family)
+ && wildstrieq (m_weight, x_weight)
+ && wildstrieq (m_slant, x_slant)
+ && wildstrieq (m_charset, x_charset))
+ || mac_font_pattern_match (mf, xf);
+ }
+ #endif
+
+ static Lisp_Object Qbig5, Qcn_gb, Qsjis, Qeuc_kr;
+
+ static void
+ decode_mac_font_name (char *name, int size, short scriptcode)
+ {
+ Lisp_Object coding_system;
+ struct coding_system coding;
+ char *buf;
+
+ switch (scriptcode)
+ {
+ case smTradChinese:
+ coding_system = Qbig5;
+ break;
+ case smSimpChinese:
+ coding_system = Qcn_gb;
+ break;
+ case smJapanese:
+ coding_system = Qsjis;
+ break;
+ case smKorean:
+ coding_system = Qeuc_kr;
+ break;
+ default:
+ return;
+ }
+
+ setup_coding_system (coding_system, &coding);
+ coding.src_multibyte = 0;
+ coding.dst_multibyte = 1;
+ coding.mode |= CODING_MODE_LAST_BLOCK;
+ coding.composing = COMPOSITION_DISABLED;
+ buf = (char *) alloca (size);
+
+ decode_coding (&coding, name, buf, strlen (name), size - 1);
+ bcopy (buf, name, coding.produced);
+ name[coding.produced] = '\0';
+ }
+
+
+ static char *
+ mac_to_x_fontname (char *name, int size, Style style, short scriptcode)
+ {
+ char foundry[32], family[32], cs[32];
+ char xf[256], *result, *p;
+
+ if (sscanf (name, "%31[^-]-%31[^-]-%31s", foundry, family, cs) != 3)
+ {
+ strcpy(foundry, "Apple");
+ strcpy(family, name);
+
+ switch (scriptcode)
+ {
+ case smTradChinese:
+ strcpy(cs, "big5-0");
+ break;
+ case smSimpChinese:
+ strcpy(cs, "gb2312.1980-0");
+ break;
+ case smJapanese:
+ strcpy(cs, "jisx0208.1983-sjis");
+ break;
+ case -smJapanese:
+ /* Each Apple Japanese font is entered into the font table
+ twice: once as a jisx0208.1983-sjis font and once as a
+ jisx0201.1976-0 font. The latter can be used to display
+ the ascii charset and katakana-jisx0201 charset. A
+ negative script code signals that the name of this latter
+ font is being built. */
+ strcpy(cs, "jisx0201.1976-0");
+ break;
+ case smKorean:
+ strcpy(cs, "ksc5601.1989-0");
+ break;
+ default:
+ strcpy(cs, "mac-roman");
+ break;
+ }
+ }
+
+ sprintf(xf, "-%s-%s-%s-%c-normal--%d-%d-75-75-m-%d-%s",
+ foundry, family, style & bold ? "bold" : "medium",
+ style & italic ? 'i' : 'r', size, size * 10, size * 10, cs);
+
+ result = (char *) xmalloc (strlen (xf) + 1);
+ strcpy (result, xf);
+ for (p = result; *p; p++)
+ *p = tolower(*p);
+ return result;
+ }
+
+
+ /* Convert an X font spec to the corresponding mac font name, which
+ can then be passed to GetFNum after conversion to a Pascal string.
+ For ordinary Mac fonts, this should just be their names, like
+ "monaco", "Taipei", etc. Fonts converted from the GNU intlfonts
+ collection contain their charset designation in their names, like
+ "ETL-Fixed-iso8859-1", "ETL-Fixed-koi8-r", etc. Both types of font
+ names are handled accordingly. */
+ static void
+ x_font_name_to_mac_font_name (char *xf, char *mf)
+ {
+ char foundry[32], family[32], weight[20], slant[2], cs[32];
+ Lisp_Object coding_system = Qnil;
+ struct coding_system coding;
+
+ strcpy (mf, "");
+
+ if (sscanf (xf,
"-%31[^-]-%31[^-]-%19[^-]-%1[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%31s",
+ foundry, family, weight, slant, cs) != 5 &&
+ sscanf (xf,
"-%31[^-]-%31[^-]-%19[^-]-%1[^-]-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%31s",
+ foundry, family, weight, slant, cs) != 5)
+ return;
+
+ if (strcmp (cs, "big5-0") == 0)
+ coding_system = Qbig5;
+ else if (strcmp (cs, "gb2312.1980-0") == 0)
+ coding_system = Qcn_gb;
+ else if (strcmp (cs, "jisx0208.1983-sjis") == 0
+ || strcmp (cs, "jisx0201.1976-0") == 0)
+ coding_system = Qsjis;
+ else if (strcmp (cs, "ksc5601.1989-0") == 0)
+ coding_system = Qeuc_kr;
+ else if (strcmp (cs, "mac-roman") == 0)
+ strcpy (mf, family);
+ else
+ sprintf (mf, "%s-%s-%s", foundry, family, cs);
+
+ if (!NILP (coding_system))
+ {
+ setup_coding_system (coding_system, &coding);
+ coding.src_multibyte = 1;
+ coding.dst_multibyte = 1;
+ coding.mode |= CODING_MODE_LAST_BLOCK;
+ encode_coding (&coding, family, mf, strlen (family), sizeof (Str32) -
1);
+ mf[coding.produced] = '\0';
+ }
+ }
+
+
+ static void
+ add_font_name_table_entry (char *font_name)
+ {
+ if (font_name_table_size == 0)
+ {
+ font_name_table_size = 16;
+ font_name_table = (char **)
+ xmalloc (font_name_table_size * sizeof (char *));
+ }
+ else if (font_name_count + 1 >= font_name_table_size)
+ {
+ font_name_table_size += 16;
+ font_name_table = (char **)
+ xrealloc (font_name_table,
+ font_name_table_size * sizeof (char *));
+ }
+
+ font_name_table[font_name_count++] = font_name;
+ }
+
+ /* Sets up the table font_name_table to contain the list of all fonts
+ in the system the first time the table is used so that the Resource
+ Manager need not be accessed every time this information is
+ needed. */
+
+ static void
+ init_font_name_table ()
+ {
+ #if TARGET_API_MAC_CARBON
+ SInt32 sv;
+
+ if (Gestalt (gestaltSystemVersion, &sv) == noErr && sv >= 0x1000)
+ {
+ FMFontFamilyIterator ffi;
+ FMFontFamilyInstanceIterator ffii;
+ FMFontFamily ff;
+
+ /* Create a dummy instance iterator here to avoid creating and
+ destroying it in the loop. */
+ if (FMCreateFontFamilyInstanceIterator (0, &ffii) != noErr)
+ return;
+ /* Create an iterator to enumerate the font families. */
+ if (FMCreateFontFamilyIterator (NULL, NULL, kFMDefaultOptions, &ffi)
+ != noErr)
+ {
+ FMDisposeFontFamilyInstanceIterator (&ffii);
+ return;
+ }
+
+ while (FMGetNextFontFamily (&ffi, &ff) == noErr)
+ {
+ Str255 name;
+ FMFont font;
+ FMFontStyle style;
+ FMFontSize size;
+ SInt16 sc;
+
+ if (FMGetFontFamilyName (ff, name) != noErr)
+ break;
+ p2cstr (name);
+ if (*name == '.')
+ continue;
+
+ sc = FontToScript (ff);
+ decode_mac_font_name (name, sizeof (name), sc);
+
+ /* Point the instance iterator at the current font family. */
+ if (FMResetFontFamilyInstanceIterator (ff, &ffii) != noErr)
+ break;
+
+ while (FMGetNextFontFamilyInstance (&ffii, &font, &style, &size)
+ == noErr)
+ {
+ /* Both jisx0208.1983-sjis and jisx0201.1976-0 parts are
+ contained in Apple Japanese (SJIS) font. */
+ again:
+ if (size == 0)
+ {
+ add_font_name_table_entry (mac_to_x_fontname (name, size,
+ style, sc));
+ add_font_name_table_entry (mac_to_x_fontname (name, size,
+ italic, sc));
+ add_font_name_table_entry (mac_to_x_fontname (name, size,
+ bold, sc));
+ add_font_name_table_entry (mac_to_x_fontname (name, size,
+ italic | bold,
+ sc));
+ }
+ else
+ add_font_name_table_entry (mac_to_x_fontname (name, size,
+ style, sc));
+ if (sc == smJapanese)
+ {
+ sc = -smJapanese;
+ goto again;
+ }
+ else if (sc == -smJapanese)
+ sc = smJapanese;
+ }
+ }
+
+ /* Dispose of the iterators. */
+ FMDisposeFontFamilyIterator (&ffi);
+ FMDisposeFontFamilyInstanceIterator (&ffii);
+ }
+ else
+ {
+ #endif /* TARGET_API_MAC_CARBON */
+ GrafPtr port;
+ SInt16 fontnum, old_fontnum;
+ int num_mac_fonts = CountResources('FOND');
+ int i, j;
+ Handle font_handle, font_handle_2;
+ short id, scriptcode;
+ ResType type;
+ Str32 name;
+ struct FontAssoc *fat;
+ struct AsscEntry *assc_entry;
+
+ GetPort (&port); /* save the current font number used */
+ #if TARGET_API_MAC_CARBON
+ old_fontnum = GetPortTextFont (port);
+ #else
+ old_fontnum = port->txFont;
+ #endif
+
+ for (i = 1; i <= num_mac_fonts; i++) /* get all available fonts */
+ {
+ font_handle = GetIndResource ('FOND', i);
+ if (!font_handle)
+ continue;
+
+ GetResInfo (font_handle, &id, &type, name);
+ GetFNum (name, &fontnum);
+ p2cstr (name);
+ if (fontnum == 0)
+ continue;
+
+ TextFont (fontnum);
+ scriptcode = FontToScript (fontnum);
+ decode_mac_font_name (name, sizeof (name), scriptcode);
+ do
+ {
+ HLock (font_handle);
+
+ if (GetResourceSizeOnDisk (font_handle)
+ >= sizeof (struct FamRec))
+ {
+ fat = (struct FontAssoc *) (*font_handle
+ + sizeof (struct FamRec));
+ assc_entry
+ = (struct AsscEntry *) (*font_handle
+ + sizeof (struct FamRec)
+ + sizeof (struct FontAssoc));
+
+ for (j = 0; j <= fat->numAssoc; j++, assc_entry++)
+ {
+ if (font_name_table_size == 0)
+ {
+ font_name_table_size = 16;
+ font_name_table = (char **)
+ xmalloc (font_name_table_size * sizeof (char *));
+ }
+ else if (font_name_count >= font_name_table_size)
+ {
+ font_name_table_size += 16;
+ font_name_table = (char **)
+ xrealloc (font_name_table,
+ font_name_table_size * sizeof (char *));
+ }
+ font_name_table[font_name_count++]
+ = mac_to_x_fontname (name,
+ assc_entry->fontSize,
+ assc_entry->fontStyle,
+ scriptcode);
+ /* Both jisx0208.1983-sjis and jisx0201.1976-0
+ parts are contained in Apple Japanese (SJIS)
+ font. */
+ if (smJapanese == scriptcode)
+ {
+ font_name_table[font_name_count++]
+ = mac_to_x_fontname (name,
+ assc_entry->fontSize,
+ assc_entry->fontStyle,
+ -smJapanese);
+ }
+ }
+ }
+
+ HUnlock (font_handle);
+ font_handle_2 = GetNextFOND (font_handle);
+ ReleaseResource (font_handle);
+ font_handle = font_handle_2;
+ }
+ while (ResError () == noErr && font_handle);
+ }
+
+ TextFont (old_fontnum);
+ #if TARGET_API_MAC_CARBON
+ }
+ #endif /* TARGET_API_MAC_CARBON */
+ }
+
+
+ enum xlfd_scalable_field_index
+ {
+ XLFD_SCL_PIXEL_SIZE,
+ XLFD_SCL_POINT_SIZE,
+ XLFD_SCL_AVGWIDTH,
+ XLFD_SCL_LAST
+ };
+
+ static int xlfd_scalable_fields[] =
+ {
+ 6, /* PIXEL_SIZE */
+ 7, /* POINT_SIZE */
+ 11, /* AVGWIDTH */
+ -1
+ };
+
+ static Lisp_Object
+ mac_do_list_fonts (pattern, maxnames)
+ char *pattern;
+ int maxnames;
+ {
+ int i, n_fonts = 0;
+ Lisp_Object font_list = Qnil, pattern_regex, fontname;
+ char *regex = (char *) alloca (strlen (pattern) * 2 + 3);
+ char scaled[256];
+ char *ptr;
+ int scl_val[XLFD_SCL_LAST], *field, *val;
+
+ for (i = 0; i < XLFD_SCL_LAST; i++)
+ scl_val[i] = -1;
+
+ /* If the pattern contains 14 dashes and one of PIXEL_SIZE,
+ POINT_SIZE, and AVGWIDTH fields is explicitly specified, scalable
+ fonts are scaled according to the specified size. */
+ ptr = pattern;
+ i = 0;
+ field = xlfd_scalable_fields;
+ val = scl_val;
+ if (*ptr == '-')
+ do
+ {
+ ptr++;
+ if (i == *field)
+ {
+ if ('1' <= *ptr && *ptr <= '9')
+ {
+ *val = *ptr++ - '0';
+ while ('0' <= *ptr && *ptr <= '9' && *val < 10000)
+ *val = *val * 10 + *ptr++ - '0';
+ if (*ptr != '-')
+ *val = -1;
+ }
+ field++;
+ val++;
+ }
+ ptr = strchr (ptr, '-');
+ i++;
+ }
+ while (ptr && i < 14);
+
+ if (i == 14 && ptr == NULL)
+ {
+ if (scl_val[XLFD_SCL_POINT_SIZE] > 0)
+ {
+ scl_val[XLFD_SCL_PIXEL_SIZE] = scl_val[XLFD_SCL_POINT_SIZE] / 10;
+ scl_val[XLFD_SCL_AVGWIDTH] = scl_val[XLFD_SCL_POINT_SIZE];
+ }
+ else if (scl_val[XLFD_SCL_PIXEL_SIZE] > 0)
+ {
+ scl_val[XLFD_SCL_POINT_SIZE] =
+ scl_val[XLFD_SCL_AVGWIDTH] = scl_val[XLFD_SCL_PIXEL_SIZE] * 10;
+ }
+ else if (scl_val[XLFD_SCL_AVGWIDTH] > 0)
+ {
+ scl_val[XLFD_SCL_PIXEL_SIZE] = scl_val[XLFD_SCL_AVGWIDTH] / 10;
+ scl_val[XLFD_SCL_POINT_SIZE] = scl_val[XLFD_SCL_AVGWIDTH];
+ }
+ }
+ else
+ scl_val[XLFD_SCL_PIXEL_SIZE] = -1;
+
+ ptr = regex;
+ *ptr++ = '^';
+
+ /* Turn pattern into a regexp and do a regexp match. */
+ for (; *pattern; pattern++)
+ {
+ if (*pattern == '?')
+ *ptr++ = '.';
+ else if (*pattern == '*')
+ {
+ *ptr++ = '.';
+ *ptr++ = '*';
+ }
+ else
+ *ptr++ = tolower (*pattern);
+ }
+ *ptr = '$';
+ *(ptr + 1) = '\0';
+
+ pattern_regex = build_string (regex);
+
+ for (i = 0; i < font_name_count; i++)
+ {
+ fontname = build_string (font_name_table[i]);
+ if (fast_string_match (pattern_regex, fontname) >= 0)
+ {
+ font_list = Fcons (fontname, font_list);
+
+ n_fonts++;
+ if (maxnames > 0 && n_fonts >= maxnames)
+ break;
+ }
+ else if (scl_val[XLFD_SCL_PIXEL_SIZE] > 0
+ && (ptr = strstr (font_name_table[i], "-0-0-75-75-m-0-")))
+ {
+ int former_len = ptr - font_name_table[i];
+
+ memcpy (scaled, font_name_table[i], former_len);
+ sprintf (scaled + former_len,
+ "-%d-%d-75-75-m-%d-%s",
+ scl_val[XLFD_SCL_PIXEL_SIZE],
+ scl_val[XLFD_SCL_POINT_SIZE],
+ scl_val[XLFD_SCL_AVGWIDTH],
+ ptr + sizeof ("-0-0-75-75-m-0-") - 1);
+ fontname = build_string (scaled);
+ if (fast_string_match (pattern_regex, fontname) >= 0)
+ {
+ font_list = Fcons (fontname, font_list);
+
+ n_fonts++;
+ if (maxnames > 0 && n_fonts >= maxnames)
+ break;
+ }
+ }
+ }
+ return font_list;
+ }
+
+ /* Return a list of at most MAXNAMES font specs matching the one in
+ PATTERN. Cache matching fonts for patterns in
+ dpyinfo->name_list_element to avoid looking them up again by
+ calling mac_font_pattern_match (slow). Return as many matching
+ fonts as possible if MAXNAMES = -1. */
+
+ Lisp_Object
+ x_list_fonts (struct frame *f,
+ Lisp_Object pattern,
+ int size,
+ int maxnames)
+ {
+ Lisp_Object newlist = Qnil, tem, key;
+ struct mac_display_info *dpyinfo = f ? FRAME_MAC_DISPLAY_INFO (f) : NULL;
+
+ if (font_name_table == NULL) /* Initialize when first used. */
+ init_font_name_table ();
+
+ if (dpyinfo)
+ {
+ tem = XCDR (dpyinfo->name_list_element);
+ key = Fcons (pattern, make_number (maxnames));
+
+ newlist = Fassoc (key, tem);
+ if (!NILP (newlist))
+ {
+ newlist = Fcdr_safe (newlist);
+ goto label_cached;
+ }
+ }
+
+ newlist = mac_do_list_fonts (SDATA (pattern), maxnames);
+
+ /* MAC_TODO: add code for matching outline fonts here */
+
+ if (dpyinfo)
+ {
+ XSETCDR (dpyinfo->name_list_element,
+ Fcons (Fcons (key, newlist),
+ XCDR (dpyinfo->name_list_element)));
+ }
+ label_cached:
+
+ 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, address@hidden 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)
+ MacFontStruct *font;
+ int *w, *h;
+ {
+ /*
+ * TODO: Windows does not appear to offer min bound, only
+ * average and maximum width, and maximum height.
+ */
+ *h = FONT_HEIGHT (font);
+ *w = FONT_WIDTH (font);
+ }
+
+
+ /* 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. */
+
+ int
+ x_compute_min_glyph_bounds (f)
+ struct frame *f;
+ {
+ int i;
+ struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+ MacFontStruct *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 = (MacFontStruct *) fontp->font;
+ xassert (font != (MacFontStruct *) ~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);
+ }
+
+
+ /* Determine whether given string is a fully-specified XLFD: all 14
+ fields are present, none is '*'. */
+
+ static int
+ is_fully_specified_xlfd (char *p)
+ {
+ int i;
+ char *q;
+
+ if (*p != '-')
+ return 0;
+
+ for (i = 0; i < 13; i++)
+ {
+ q = strchr (p + 1, '-');
+ if (q == NULL)
+ return 0;
+ if (q - p == 2 && *(p + 1) == '*')
+ return 0;
+ p = q;
+ }
+
+ if (strchr (p + 1, '-') != NULL)
+ return 0;
+
+ if (*(p + 1) == '*' && *(p + 2) == '\0')
+ return 0;
+
+ return 1;
+ }
+
+
+ const int kDefaultFontSize = 9;
+
+
+ /* XLoadQueryFont creates and returns an internal representation for a
+ font in a MacFontStruct struct. There is really no concept
+ corresponding to "loading" a font on the Mac. But we check its
+ existence and find the font number and all other information for it
+ and store them in the returned MacFontStruct. */
+
+ static MacFontStruct *
+ XLoadQueryFont (Display *dpy, char *fontname)
+ {
+ int i, size, is_two_byte_font, char_width;
+ char *name;
+ GrafPtr port;
+ SInt16 old_fontnum, old_fontsize;
+ Style old_fontface;
+ Str32 mfontname;
+ SInt16 fontnum;
+ Style fontface = normal;
+ MacFontStruct *font;
+ FontInfo the_fontinfo;
+ char s_weight[7], c_slant;
+
+ if (is_fully_specified_xlfd (fontname))
+ name = fontname;
+ else
+ {
+ Lisp_Object matched_fonts;
+
+ matched_fonts = mac_do_list_fonts (fontname, 1);
+ if (NILP (matched_fonts))
+ return NULL;
+ name = SDATA (XCAR (matched_fonts));
+ }
+
+ GetPort (&port); /* save the current font number used */
+ #if TARGET_API_MAC_CARBON
+ old_fontnum = GetPortTextFont (port);
+ old_fontsize = GetPortTextSize (port);
+ old_fontface = GetPortTextFace (port);
+ #else
+ old_fontnum = port->txFont;
+ old_fontsize = port->txSize;
+ old_fontface = port->txFace;
+ #endif
+
+ if (sscanf (name,
"-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]--%d-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%*s",
&size) != 1)
+ size = kDefaultFontSize;
+
+ if (sscanf (name,
"-%*[^-]-%*[^-]-%6[^-]-%*c-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%*s",
s_weight) == 1)
+ if (strcmp (s_weight, "bold") == 0)
+ fontface |= bold;
+
+ if (sscanf (name,
"-%*[^-]-%*[^-]-%*[^-]-%c-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%*s",
&c_slant) == 1)
+ if (c_slant == 'i')
+ fontface |= italic;
+
+ x_font_name_to_mac_font_name (name, mfontname);
+ c2pstr (mfontname);
+ GetFNum (mfontname, &fontnum);
+ if (fontnum == 0)
+ return NULL;
+
+ font = (MacFontStruct *) xmalloc (sizeof (struct MacFontStruct));
+
+ font->fontname = (char *) xmalloc (strlen (name) + 1);
+ bcopy (name, font->fontname, strlen (name) + 1);
+
+ font->mac_fontnum = fontnum;
+ font->mac_fontsize = size;
+ font->mac_fontface = fontface;
+ font->mac_scriptcode = FontToScript (fontnum);
+
+ /* Apple Japanese (SJIS) font is listed as both
+ "*-jisx0208.1983-sjis" (Japanese script) and "*-jisx0201.1976-0"
+ (Roman script) in init_font_name_table (). The latter should be
+ treated as a one-byte font. */
+ {
+ char cs[32];
+
+ if (sscanf (name,
+
"-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%31s",
+ cs) == 1
+ && 0 == strcmp (cs, "jisx0201.1976-0"))
+ font->mac_scriptcode = smRoman;
+ }
+
+ is_two_byte_font = font->mac_scriptcode == smJapanese ||
+ font->mac_scriptcode == smTradChinese ||
+ font->mac_scriptcode == smSimpChinese ||
+ font->mac_scriptcode == smKorean;
+
+ TextFont (fontnum);
+ TextSize (size);
+ TextFace (fontface);
+
+ GetFontInfo (&the_fontinfo);
+
+ font->ascent = the_fontinfo.ascent;
+ font->descent = the_fontinfo.descent;
+
+ font->min_byte1 = 0;
+ if (is_two_byte_font)
+ font->max_byte1 = 1;
+ else
+ font->max_byte1 = 0;
+ font->min_char_or_byte2 = 0x20;
+ font->max_char_or_byte2 = 0xff;
+
+ if (is_two_byte_font)
+ {
+ /* Use the width of an "ideographic space" of that font because
+ the_fontinfo.widMax returns the wrong width for some fonts. */
+ switch (font->mac_scriptcode)
+ {
+ case smJapanese:
+ char_width = StringWidth("\p\x81\x40");
+ break;
+ case smTradChinese:
+ char_width = StringWidth("\p\xa1\x40");
+ break;
+ case smSimpChinese:
+ char_width = StringWidth("\p\xa1\xa1");
+ break;
+ case smKorean:
+ char_width = StringWidth("\p\xa1\xa1");
+ break;
+ }
+ }
+ else
+ /* Do this instead of use the_fontinfo.widMax, which incorrectly
+ returns 15 for 12-point Monaco! */
+ char_width = CharWidth ('m');
+
+ font->max_bounds.rbearing = char_width;
+ font->max_bounds.lbearing = 0;
+ font->max_bounds.width = char_width;
+ font->max_bounds.ascent = the_fontinfo.ascent;
+ font->max_bounds.descent = the_fontinfo.descent;
+
+ font->min_bounds = font->max_bounds;
+
+ if (is_two_byte_font || CharWidth ('m') == CharWidth ('i'))
+ font->per_char = NULL;
+ else
+ {
+ font->per_char = (XCharStruct *)
+ xmalloc (sizeof (XCharStruct) * (0xff - 0x20 + 1));
+ {
+ int c;
+
+ for (c = 0x20; c <= 0xff; c++)
+ {
+ font->per_char[c - 0x20] = font->max_bounds;
+ font->per_char[c - 0x20].width =
+ font->per_char[c - 0x20].rbearing = CharWidth (c);
+ }
+ }
+ }
+
+ TextFont (old_fontnum); /* restore previous font number, size and face */
+ TextSize (old_fontsize);
+ TextFace (old_fontface);
+
+ return font;
+ }
+
+
+ /* 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 mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+ Lisp_Object font_names;
+
+ /* 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,
+ SDATA (XCAR (tail)))
+ || !strcmp (dpyinfo->font_table[i].full_name,
+ SDATA (XCAR (tail)))))
+ return (dpyinfo->font_table + i);
+ }
+
+ /* Load the font and add it to the table. */
+ {
+ char *full_name;
+ struct MacFontStruct *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 *) SDATA (XCAR (font_names));
+
+ font = (MacFontStruct *) XLoadQueryFont (FRAME_MAC_DISPLAY (f), fontname);
+ 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;
+ bzero (fontp, sizeof (*fontp));
+ fontp->font = font;
+ fontp->font_idx = i;
+ fontp->name = (char *) xmalloc (strlen (font->fontname) + 1);
+ bcopy (font->fontname, fontp->name, strlen (font->fontname) + 1);
+
+ fontp->full_name = fontp->name;
+
+ fontp->size = font->max_bounds.width;
+ fontp->height = FONT_HEIGHT (font);
+ {
+ /* For some font, ascent and descent in max_bounds field is
+ larger than the above value. */
+ int max_height = font->max_bounds.ascent + font->max_bounds.descent;
+ if (max_height > fontp->height)
+ fontp->height = max_height;
+ }
+
+ /* 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. */
+ if (font->mac_scriptcode == smJapanese)
+ fontp->encoding[1] = 4;
+ else
+ {
+ 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 */
+ }
+
+ #if 0 /* MAC_TODO: fill these out with more reasonably values */
+ 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);
+ #else
+ fontp->baseline_offset = 0;
+ fontp->relative_compose = 0;
+ fontp->default_ascent = 0;
+ #endif
+
+ /* 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 mac_display_info *dpyinfo = FRAME_MAC_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;
+
+ 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))
+ 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;
+ }
+ }
+
+
+
+ /* The Mac Event loop code */
+
+ #ifndef MAC_OSX
+ #include <Events.h>
+ #include <Quickdraw.h>
+ #include <Balloons.h>
+ #include <Devices.h>
+ #include <Fonts.h>
+ #include <Gestalt.h>
+ #include <Menus.h>
+ #include <Processes.h>
+ #include <Sound.h>
+ #include <ToolUtils.h>
+ #include <TextUtils.h>
+ #include <Dialogs.h>
+ #include <Script.h>
+ #include <Types.h>
+ #include <TextEncodingConverter.h>
+ #include <Resources.h>
+
+ #if __MWERKS__
+ #include <unix.h>
+ #endif
+ #endif /* ! MAC_OSX */
+
+ #define M_APPLE 128
+ #define I_ABOUT 1
+
+ #define WINDOW_RESOURCE 128
+ #define TERM_WINDOW_RESOURCE 129
+
+ #define DEFAULT_NUM_COLS 80
+
+ #define MIN_DOC_SIZE 64
+ #define MAX_DOC_SIZE 32767
+
+ /* sleep time for WaitNextEvent */
+ #define WNE_SLEEP_AT_SUSPEND 10
+ #define WNE_SLEEP_AT_RESUME 1
+
+ /* true when cannot handle any Mac OS events */
+ static int handling_window_update = 0;
+
+ /* the flag appl_is_suspended is used both for determining the sleep
+ time to be passed to WaitNextEvent and whether the cursor should be
+ drawn when updating the display. The cursor is turned off when
+ Emacs is suspended. Redrawing it is unnecessary and what needs to
+ be done depends on whether the cursor lies inside or outside the
+ redraw region. So we might as well skip drawing it when Emacs is
+ suspended. */
+ static Boolean app_is_suspended = false;
+ static long app_sleep_time = WNE_SLEEP_AT_RESUME;
+
+ #define EXTRA_STACK_ALLOC (256 * 1024)
+
+ #define ARGV_STRING_LIST_ID 129
+ #define ABOUT_ALERT_ID 128
+ #define RAM_TOO_LARGE_ALERT_ID 129
+
+ Boolean terminate_flag = false;
+
+ /* Contains the string "reverse", which is a constant for mouse button emu.*/
+ Lisp_Object Qreverse;
+
+ /* True if using command key as meta key. */
+ Lisp_Object Vmac_command_key_is_meta;
+
+ /* True if the ctrl and meta keys should be reversed. */
+ Lisp_Object Vmac_reverse_ctrl_meta;
+
+ /* True if the option and command modifiers should be used to emulate
+ a three button mouse */
+ Lisp_Object Vmac_emulate_three_button_mouse;
+
+ #if USE_CARBON_EVENTS
+ /* True if the mouse wheel button (i.e. button 4) should map to
+ mouse-2, instead of mouse-3. */
+ Lisp_Object Vmac_wheel_button_is_mouse_2;
+
+ /* If Non-nil, the Mac "Command" key is passed on to the Mac Toolbox
+ for processing before Emacs sees it. */
+ Lisp_Object Vmac_pass_command_to_system;
+
+ /* If Non-nil, the Mac "Control" key is passed on to the Mac Toolbox
+ for processing before Emacs sees it. */
+ Lisp_Object Vmac_pass_control_to_system;
+ #endif
+
+ /* convert input from Mac keyboard (assumed to be in Mac Roman coding)
+ to this text encoding */
+ int mac_keyboard_text_encoding;
+ int current_mac_keyboard_text_encoding = kTextEncodingMacRoman;
+
+ /* Set in term/mac-win.el to indicate that event loop can now generate
+ drag and drop events. */
+ Lisp_Object Qmac_ready_for_drag_n_drop;
+
+ Lisp_Object drag_and_drop_file_list;
+
+ Point saved_menu_event_location;
+
+ #if !TARGET_API_MAC_CARBON
+ /* Place holder for the default arrow cursor. */
+ CursPtr arrow_cursor;
+ #endif
+
+ /* Apple Events */
+ static void init_required_apple_events (void);
+ static pascal OSErr
+ do_ae_open_application (const AppleEvent *, AppleEvent *, long);
+ static pascal OSErr
+ do_ae_print_documents (const AppleEvent *, AppleEvent *, long);
+ static pascal OSErr do_ae_open_documents (AppleEvent *, AppleEvent *, long);
+ static pascal OSErr do_ae_quit_application (AppleEvent *, AppleEvent *, long);
+
+ /* Drag and Drop */
+ static OSErr init_mac_drag_n_drop ();
+ static pascal OSErr mac_do_receive_drag (WindowPtr, void*, DragReference);
+
+ #if USE_CARBON_EVENTS
+ /* Preliminary Support for the OSX Services Menu */
+ static OSStatus mac_handle_service_event (EventHandlerCallRef,EventRef,void*);
+ static void init_service_handler ();
+ #endif
+
+ extern void init_emacs_passwd_dir ();
+ extern int emacs_main (int, char **, char **);
+ extern void check_alarm ();
+
+ extern void initialize_applescript();
+ extern void terminate_applescript();
+
+ static unsigned int
+ #if USE_CARBON_EVENTS
+ mac_to_emacs_modifiers (UInt32 mods)
+ #else
+ mac_to_emacs_modifiers (EventModifiers mods)
+ #endif
+ {
+ unsigned int result = 0;
+ if (mods & macShiftKey)
+ result |= shift_modifier;
+ if (mods & macCtrlKey)
+ result |= ctrl_modifier;
+ if (mods & macMetaKey)
+ result |= meta_modifier;
+ if (NILP (Vmac_command_key_is_meta) && (mods & macAltKey))
+ result |= alt_modifier;
+ return result;
+ }
+
+ static int
+ mac_get_emulated_btn ( UInt32 modifiers )
+ {
+ int result = 0;
+ if (!NILP (Vmac_emulate_three_button_mouse)) {
+ int cmdIs3 = !EQ (Vmac_emulate_three_button_mouse, Qreverse);
+ if (modifiers & cmdKey)
+ result = cmdIs3 ? 2 : 1;
+ else if (modifiers & optionKey)
+ result = cmdIs3 ? 1 : 2;
+ }
+ return result;
+ }
+
+ #if USE_CARBON_EVENTS
+ /* Obtains the event modifiers from the event ref and then calls
+ mac_to_emacs_modifiers. */
+ static int
+ mac_event_to_emacs_modifiers (EventRef eventRef)
+ {
+ UInt32 mods = 0;
+ GetEventParameter (eventRef, kEventParamKeyModifiers, typeUInt32, NULL,
+ sizeof (UInt32), NULL, &mods);
+ if (!NILP (Vmac_emulate_three_button_mouse) &&
+ GetEventClass(eventRef) == kEventClassMouse)
+ {
+ mods &= ~(optionKey | cmdKey);
+ }
+ return mac_to_emacs_modifiers (mods);
+ }
+
+ /* Given an event ref, return the code to use for the mouse button
+ code in the emacs input_event. */
+ static int
+ mac_get_mouse_btn (EventRef ref)
+ {
+ EventMouseButton result = kEventMouseButtonPrimary;
+ GetEventParameter (ref, kEventParamMouseButton, typeMouseButton, NULL,
+ sizeof (EventMouseButton), NULL, &result);
+ switch (result)
+ {
+ case kEventMouseButtonPrimary:
+ if (NILP (Vmac_emulate_three_button_mouse))
+ return 0;
+ else {
+ UInt32 mods = 0;
+ GetEventParameter (ref, kEventParamKeyModifiers, typeUInt32, NULL,
+ sizeof (UInt32), NULL, &mods);
+ return mac_get_emulated_btn(mods);
+ }
+ case kEventMouseButtonSecondary:
+ return NILP (Vmac_wheel_button_is_mouse_2) ? 1 : 2;
+ case kEventMouseButtonTertiary:
+ case 4: /* 4 is the number for the mouse wheel button */
+ return NILP (Vmac_wheel_button_is_mouse_2) ? 2 : 1;
+ default:
+ return 0;
+ }
+ }
+
+ /* Normally, ConvertEventRefToEventRecord will correctly handle all
+ events. However the click of the mouse wheel is not converted to a
+ mouseDown or mouseUp event. This calls ConvertEventRef, but then
+ checks to see if it is a mouse up or down carbon event that has not
+ been converted, and if so, converts it by hand (to be picked up in
+ the XTread_socket loop). */
+ static Boolean mac_convert_event_ref (EventRef eventRef, EventRecord
*eventRec)
+ {
+ Boolean result = ConvertEventRefToEventRecord (eventRef, eventRec);
+ /* Do special case for mouse wheel button. */
+ if (!result && GetEventClass (eventRef) == kEventClassMouse)
+ {
+ UInt32 kind = GetEventKind (eventRef);
+ if (kind == kEventMouseDown && !(eventRec->what == mouseDown))
+ {
+ eventRec->what = mouseDown;
+ result=1;
+ }
+ if (kind == kEventMouseUp && !(eventRec->what == mouseUp))
+ {
+ eventRec->what = mouseUp;
+ result=1;
+ }
+ if (result)
+ {
+ /* Need where and when. */
+ UInt32 mods;
+ GetEventParameter (eventRef, kEventParamMouseLocation,
+ typeQDPoint, NULL, sizeof (Point),
+ NULL, &eventRec->where);
+ /* Use two step process because new event modifiers are
+ 32-bit and old are 16-bit. Currently, only loss is
+ NumLock & Fn. */
+ GetEventParameter (eventRef, kEventParamKeyModifiers,
+ typeUInt32, NULL, sizeof (UInt32),
+ NULL, &mods);
+ eventRec->modifiers = mods;
+
+ eventRec->when = EventTimeToTicks (GetEventTime (eventRef));
+ }
+ }
+ return result;
+ }
+
+ #endif
+
+ static void
+ do_get_menus (void)
+ {
+ Handle menubar_handle;
+ MenuHandle menu_handle;
+
+ menubar_handle = GetNewMBar (128);
+ if(menubar_handle == NULL)
+ abort ();
+ SetMenuBar (menubar_handle);
+ DrawMenuBar ();
+
+ menu_handle = GetMenuHandle (M_APPLE);
+ if(menu_handle != NULL)
+ AppendResMenu (menu_handle,'DRVR');
+ else
+ abort ();
+ }
+
+
+ static void
+ do_init_managers (void)
+ {
+ #if !TARGET_API_MAC_CARBON
+ InitGraf (&qd.thePort);
+ InitFonts ();
+ FlushEvents (everyEvent, 0);
+ InitWindows ();
+ InitMenus ();
+ TEInit ();
+ InitDialogs (NULL);
+ #endif /* !TARGET_API_MAC_CARBON */
+ InitCursor ();
+
+ #if !TARGET_API_MAC_CARBON
+ arrow_cursor = &qd.arrow;
+
+ /* set up some extra stack space for use by emacs */
+ SetApplLimit ((Ptr) ((long) GetApplLimit () - EXTRA_STACK_ALLOC));
+
+ /* MaxApplZone must be called for AppleScript to execute more
+ complicated scripts */
+ MaxApplZone ();
+ MoreMasters ();
+ #endif /* !TARGET_API_MAC_CARBON */
+ }
+
+ static void
+ do_check_ram_size (void)
+ {
+ SInt32 physical_ram_size, logical_ram_size;
+
+ if (Gestalt (gestaltPhysicalRAMSize, &physical_ram_size) != noErr
+ || Gestalt (gestaltLogicalRAMSize, &logical_ram_size) != noErr
+ || physical_ram_size > (1 << VALBITS)
+ || logical_ram_size > (1 << VALBITS))
+ {
+ StopAlert (RAM_TOO_LARGE_ALERT_ID, NULL);
+ exit (1);
+ }
+ }
+
+ static void
+ do_window_update (WindowPtr win)
+ {
+ struct frame *f = mac_window_to_frame (win);
+
+ if (win == tip_window)
+ /* The tooltip has been drawn already. Avoid the
+ SET_FRAME_GARBAGED below. */
+ return;
+
+ if (f)
+ {
+ if (f->async_visible == 0)
+ {
+ f->async_visible = 1;
+ f->async_iconified = 0;
+ SET_FRAME_GARBAGED (f);
+
+ /* An update event is equivalent to MapNotify on X, so report
+ visibility changes properly. */
+ 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 ();
+ }
+ else
+ {
+ BeginUpdate (win);
+ handling_window_update = 1;
+
+ XClearWindow (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f));
+
+ expose_frame (f, 0, 0, 0, 0);
+
+ handling_window_update = 0;
+ EndUpdate (win);
+ }
+ }
+ }
+
+ static int
+ is_emacs_window (WindowPtr win)
+ {
+ Lisp_Object tail, frame;
+
+ if (!win)
+ return 0;
+
+ FOR_EACH_FRAME (tail, frame)
+ if (FRAME_MAC_P (XFRAME (frame)))
+ if (FRAME_MAC_WINDOW (XFRAME (frame)) == win)
+ return 1;
+
+ return 0;
+ }
+
+ static void
+ do_app_resume ()
+ {
+ WindowPtr wp;
+ struct frame *f;
+
+ wp = mac_front_window ();
+ if (is_emacs_window (wp))
+ {
+ f = mac_window_to_frame (wp);
+
+ if (f)
+ {
+ x_new_focus_frame (FRAME_MAC_DISPLAY_INFO (f), f);
+ activate_scroll_bars (f);
+ }
+ }
+
+ app_is_suspended = false;
+ app_sleep_time = WNE_SLEEP_AT_RESUME;
+ }
+
+ static void
+ do_app_suspend ()
+ {
+ WindowPtr wp;
+ struct frame *f;
+
+ wp = mac_front_window ();
+ if (is_emacs_window (wp))
+ {
+ f = mac_window_to_frame (wp);
+
+ if (f == FRAME_MAC_DISPLAY_INFO (f)->x_focus_frame)
+ {
+ x_new_focus_frame (FRAME_MAC_DISPLAY_INFO (f), 0);
+ deactivate_scroll_bars (f);
+ }
+ }
+
+ app_is_suspended = true;
+ app_sleep_time = WNE_SLEEP_AT_SUSPEND;
+ }
+
+
+ static void
+ do_mouse_moved (mouse_pos, f)
+ Point mouse_pos;
+ FRAME_PTR *f;
+ {
+ WindowPtr wp = mac_front_window ();
+ struct x_display_info *dpyinfo;
+
+ if (is_emacs_window (wp))
+ {
+ *f = mac_window_to_frame (wp);
+ dpyinfo = FRAME_MAC_DISPLAY_INFO (*f);
+
+ if (dpyinfo->mouse_face_hidden)
+ {
+ dpyinfo->mouse_face_hidden = 0;
+ clear_mouse_face (dpyinfo);
+ }
+
+ SetPortWindowPort (wp);
+
+ GlobalToLocal (&mouse_pos);
+
+ if (dpyinfo->grabbed && tracked_scroll_bar)
+ x_scroll_bar_note_movement (tracked_scroll_bar,
+ mouse_pos.v
+ - XINT (tracked_scroll_bar->top),
+ TickCount() * (1000 / 60));
+ else
+ note_mouse_movement (*f, &mouse_pos);
+ }
+ }
+
+
+ static void
+ do_apple_menu (SInt16 menu_item)
+ {
+ #if !TARGET_API_MAC_CARBON
+ Str255 item_name;
+ SInt16 da_driver_refnum;
+
+ if (menu_item == I_ABOUT)
+ NoteAlert (ABOUT_ALERT_ID, NULL);
+ else
+ {
+ GetMenuItemText (GetMenuHandle (M_APPLE), menu_item, item_name);
+ da_driver_refnum = OpenDeskAcc (item_name);
+ }
+ #endif /* !TARGET_API_MAC_CARBON */
+ }
+
+ void
+ do_menu_choice (SInt32 menu_choice)
+ {
+ SInt16 menu_id, menu_item;
+
+ menu_id = HiWord (menu_choice);
+ menu_item = LoWord (menu_choice);
+
+ if (menu_id == 0)
+ return;
+
+ switch (menu_id)
+ {
+ case M_APPLE:
+ do_apple_menu (menu_item);
+ break;
+
+ default:
+ {
+ struct frame *f = mac_window_to_frame (mac_front_window ());
+ MenuHandle menu = GetMenuHandle (menu_id);
+ if (menu)
+ {
+ UInt32 refcon;
+
+ GetMenuItemRefCon (menu, menu_item, &refcon);
+ menubar_selection_callback (f, refcon);
+ }
+ }
+ }
+
+ HiliteMenu (0);
+ }
+
+
+ /* Handle drags in size box. Based on code contributed by Ben
+ Mesander and IM - Window Manager A. */
+
+ static void
+ do_grow_window (WindowPtr w, EventRecord *e)
+ {
+ long grow_size;
+ Rect limit_rect;
+ int rows, columns;
+ struct frame *f = mac_window_to_frame (w);
+
+ SetRect(&limit_rect, MIN_DOC_SIZE, MIN_DOC_SIZE, MAX_DOC_SIZE,
MAX_DOC_SIZE);
+
+ grow_size = GrowWindow (w, e->where, &limit_rect);
+
+ /* see if it really changed size */
+ if (grow_size != 0)
+ {
+ rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, HiWord (grow_size));
+ columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, LoWord (grow_size));
+
+ x_set_window_size (f, 0, columns, rows);
+ }
+ }
+
+
+ /* Handle clicks in zoom box. Calculation of "standard state" based
+ on code in IM - Window Manager A and code contributed by Ben
+ Mesander. The standard state of an Emacs window is 80-characters
+ wide (DEFAULT_NUM_COLS) and as tall as will fit on the screen. */
+
+ static void
+ do_zoom_window (WindowPtr w, int zoom_in_or_out)
+ {
+ GrafPtr save_port;
+ Rect zoom_rect, port_rect;
+ Point top_left;
+ int w_title_height, columns, rows, width, height, dummy, x, y;
+ struct frame *f = mac_window_to_frame (w);
+
+ GetPort (&save_port);
+
+ SetPortWindowPort (w);
+
+ /* Clear window to avoid flicker. */
+ #if TARGET_API_MAC_CARBON
+ {
+ Rect r;
+ BitMap bm;
+
+ GetWindowPortBounds (w, &r);
+ EraseRect (&r);
+
+ if (zoom_in_or_out == inZoomOut)
+ {
+ /* calculate height of window's title bar (hard card it for now). */
+ w_title_height = 20 + GetMBarHeight ();
+
+ /* get maximum height of window into zoom_rect.bottom -
+ zoom_rect.top */
+ GetQDGlobalsScreenBits (&bm);
+ zoom_rect = bm.bounds;
+ zoom_rect.top += w_title_height;
+ InsetRect (&zoom_rect, 8, 4); /* not too tight */
+
+ zoom_rect.right = zoom_rect.left
+ + FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, DEFAULT_NUM_COLS);
+
+ SetWindowStandardState (w, &zoom_rect);
+ }
+ }
+ #else /* not TARGET_API_MAC_CARBON */
+ EraseRect (&(w->portRect));
+ if (zoom_in_or_out == inZoomOut)
+ {
+ SetPt (&top_left, w->portRect.left, w->portRect.top);
+ LocalToGlobal (&top_left);
+
+ /* calculate height of window's title bar */
+ w_title_height = top_left.v - 1
+ - (**((WindowPeek) w)->strucRgn).rgnBBox.top + GetMBarHeight ();
+
+ /* get maximum height of window into zoom_rect.bottom - zoom_rect.top */
+ zoom_rect = qd.screenBits.bounds;
+ zoom_rect.top += w_title_height;
+ InsetRect (&zoom_rect, 8, 4); /* not too tight */
+
+ zoom_rect.right = zoom_rect.left
+ + FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, DEFAULT_NUM_COLS);
+
+ (**((WStateDataHandle) ((WindowPeek) w)->dataHandle)).stdState
+ = zoom_rect;
+ }
+ #endif /* not TARGET_API_MAC_CARBON */
+
+ ZoomWindow (w, zoom_in_or_out, w == mac_front_window ());
+
+ /* retrieve window size and update application values */
+ #if TARGET_API_MAC_CARBON
+ GetWindowPortBounds (w, &port_rect);
+ #else
+ port_rect = w->portRect;
+ #endif
+ rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, port_rect.bottom -
port_rect.top);
+ columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, port_rect.right -
port_rect.left);
+ x_set_window_size (f, 0, columns, rows);
+
+ SetPort (save_port);
+ }
+
+ /* Initialize Drag And Drop to allow files to be dropped onto emacs frames */
+ static OSErr
+ init_mac_drag_n_drop ()
+ {
+ OSErr result = InstallReceiveHandler (mac_do_receive_drag, 0L, NULL);
+ return result;
+ }
+
+ /* Intialize AppleEvent dispatcher table for the required events. */
+ void
+ init_required_apple_events ()
+ {
+ OSErr err;
+ long result;
+
+ /* Make sure we have apple events before starting. */
+ err = Gestalt (gestaltAppleEventsAttr, &result);
+ if (err != noErr)
+ abort ();
+
+ if (!(result & (1 << gestaltAppleEventsPresent)))
+ abort ();
+
+ #if TARGET_API_MAC_CARBON
+ err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication,
+ NewAEEventHandlerUPP
+ ((AEEventHandlerProcPtr) do_ae_open_application),
+ 0L, false);
+ #else
+ err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication,
+ NewAEEventHandlerProc
+ ((AEEventHandlerProcPtr) do_ae_open_application),
+ 0L, false);
+ #endif
+ if (err != noErr)
+ abort ();
+
+ #if TARGET_API_MAC_CARBON
+ err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
+ NewAEEventHandlerUPP
+ ((AEEventHandlerProcPtr) do_ae_open_documents),
+ 0L, false);
+ #else
+ err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
+ NewAEEventHandlerProc
+ ((AEEventHandlerProcPtr) do_ae_open_documents),
+ 0L, false);
+ #endif
+ if (err != noErr)
+ abort ();
+
+ #if TARGET_API_MAC_CARBON
+ err = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments,
+ NewAEEventHandlerUPP
+ ((AEEventHandlerProcPtr) do_ae_print_documents),
+ 0L, false);
+ #else
+ err = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments,
+ NewAEEventHandlerProc
+ ((AEEventHandlerProcPtr) do_ae_print_documents),
+ 0L, false);
+ #endif
+ if (err != noErr)
+ abort ();
+
+ #if TARGET_API_MAC_CARBON
+ err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
+ NewAEEventHandlerUPP
+ ((AEEventHandlerProcPtr) do_ae_quit_application),
+ 0L, false);
+ #else
+ err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
+ NewAEEventHandlerProc
+ ((AEEventHandlerProcPtr) do_ae_quit_application),
+ 0L, false);
+ #endif
+ if (err != noErr)
+ abort ();
+ }
+
+ #if USE_CARBON_EVENTS
+
+ void
+ init_service_handler ()
+ {
+ EventTypeSpec specs[] = {{kEventClassService, kEventServiceGetTypes},
+ {kEventClassService, kEventServiceCopy},
+ {kEventClassService, kEventServicePaste}};
+ InstallApplicationEventHandler (NewEventHandlerUPP
(mac_handle_service_event),
+ 3, specs, NULL, NULL);
+ }
+
+ /*
+ MAC_TODO: Check to see if this is called by AEProcessDesc...
+ */
+ OSStatus
+ mac_handle_service_event (EventHandlerCallRef callRef,
+ EventRef event, void *data)
+ {
+ OSStatus err = noErr;
+ switch (GetEventKind (event))
+ {
+ case kEventServiceGetTypes:
+ {
+ CFMutableArrayRef copyTypes, pasteTypes;
+ CFStringRef type;
+ Boolean selection = true;
+ /*
+ GetEventParameter(event, kEventParamServicePasteTypes,
+ typeCFMutableArrayRef, NULL,
+ sizeof (CFMutableArrayRef), NULL, &pasteTypes);
+ */
+ GetEventParameter(event, kEventParamServiceCopyTypes,
+ typeCFMutableArrayRef, NULL,
+ sizeof (CFMutableArrayRef), NULL, ©Types);
+ type = CreateTypeStringWithOSType (kScrapFlavorTypeText);
+ if (type) {
+ CFArrayAppendValue (copyTypes, type);
+ //CFArrayAppendValue (pasteTypes, type);
+ CFRelease (type);
+ }
+ }
+ case kEventServiceCopy:
+ {
+ ScrapRef currentScrap, specificScrap;
+ char * buf = "";
+ Size byteCount = 0;
+
+ GetCurrentScrap (¤tScrap);
+
+ err = GetScrapFlavorSize (currentScrap, kScrapFlavorTypeText,
&byteCount);
+ if (err == noErr)
+ {
+ void *buffer = xmalloc (byteCount);
+ if (buffer != NULL)
+ {
+ GetEventParameter (event, kEventParamScrapRef, typeScrapRef,
NULL,
+ sizeof (ScrapRef), NULL, &specificScrap);
+
+ err = GetScrapFlavorData (currentScrap, kScrapFlavorTypeText,
+ &byteCount, buffer);
+ if (err == noErr)
+ PutScrapFlavor (specificScrap, kScrapFlavorTypeText,
+ kScrapFlavorMaskNone, byteCount, buffer);
+ xfree (buffer);
+ }
+ }
+ err = noErr;
+ }
+ case kEventServicePaste:
+ {
+ /*
+ // Get the current location
+ Size byteCount;
+ ScrapRef specificScrap;
+ GetEventParameter(event, kEventParamScrapRef, typeScrapRef, NULL,
+ sizeof(ScrapRef), NULL, &specificScrap);
+ err = GetScrapFlavorSize(specificScrap, kScrapFlavorTypeText,
&byteCount);
+ if (err == noErr) {
+ void * buffer = xmalloc(byteCount);
+ if (buffer != NULL ) {
+ err = GetScrapFlavorData(specificScrap, kScrapFlavorTypeText,
+ &byteCount, buffer);
+ if (err == noErr) {
+ // Actually place in the buffer
+ BLOCK_INPUT;
+ // Get the current "selection" string here
+ UNBLOCK_INPUT;
+ }
+ }
+ xfree(buffer);
+ }
+ */
+ }
+ }
+ return err;
+ }
+ #endif
+
+ /* Open Application Apple Event */
+ static pascal OSErr
+ do_ae_open_application(const AppleEvent *pae, AppleEvent *preply, long
prefcon)
+ {
+ return noErr;
+ }
+
+
+ /* Defined in mac.c. */
+ extern int
+ path_from_vol_dir_name (char *, int, short, long, char *);
+
+
+ /* Called when we receive an AppleEvent with an ID of
+ "kAEOpenDocuments". This routine gets the direct parameter,
+ extracts the FSSpecs in it, and puts their names on a list. */
+ static pascal OSErr
+ do_ae_open_documents(AppleEvent *message, AppleEvent *reply, long refcon)
+ {
+ OSErr err, err2;
+ AEDesc the_desc;
+ AEKeyword keyword;
+ DescType actual_type;
+ Size actual_size;
+
+ err = AEGetParamDesc (message, keyDirectObject, typeAEList, &the_desc);
+ if (err != noErr)
+ goto descriptor_error_exit;
+
+ /* Check to see that we got all of the required parameters from the
+ event descriptor. For an 'odoc' event this should just be the
+ file list. */
+ err = AEGetAttributePtr(message, keyMissedKeywordAttr, typeWildCard,
+ &actual_type, (Ptr) &keyword,
+ sizeof (keyword), &actual_size);
+ /* No error means that we found some unused parameters.
+ errAEDescNotFound means that there are no more parameters. If we
+ get an error code other than that, flag it. */
+ if ((err == noErr) || (err != errAEDescNotFound))
+ {
+ err = errAEEventNotHandled;
+ goto error_exit;
+ }
+ err = noErr;
+
+ /* Got all the parameters we need. Now, go through the direct
+ object list and parse it up. */
+ {
+ long num_files_to_open;
+
+ err = AECountItems (&the_desc, &num_files_to_open);
+ if (err == noErr)
+ {
+ int i;
+
+ /* AE file list is one based so just use that for indexing here. */
+ for (i = 1; (err == noErr) && (i <= num_files_to_open); i++)
+ {
+ FSSpec fs;
+ Str255 path_name, unix_path_name;
+ #ifdef MAC_OSX
+ FSRef fref;
+ #endif
+
+ err = AEGetNthPtr(&the_desc, i, typeFSS, &keyword, &actual_type,
+ (Ptr) &fs, sizeof (fs), &actual_size);
+ if (err != noErr) break;
+
+ #ifdef MAC_OSX
+ err = FSpMakeFSRef (&fs, &fref);
+ if (err != noErr) break;
+
+ if (FSRefMakePath (&fref, unix_path_name, 255) == noErr)
+ #else
+ if (path_from_vol_dir_name (path_name, 255, fs.vRefNum, fs.parID,
+ fs.name) &&
+ mac_to_posix_pathname (path_name, unix_path_name, 255))
+ #endif
+ drag_and_drop_file_list = Fcons (build_string (unix_path_name),
+ drag_and_drop_file_list);
+ }
+ }
+ }
+
+ error_exit:
+ /* Nuke the coerced file list in any case */
+ err2 = AEDisposeDesc(&the_desc);
+
+ descriptor_error_exit:
+ /* InvalRect(&(gFrontMacWindowP->mWP->portRect)); */
+ return err;
+ }
+
+
+ static pascal OSErr
+ mac_do_receive_drag (WindowPtr window, void *handlerRefCon,
+ DragReference theDrag)
+ {
+ short items;
+ short index;
+ FlavorFlags theFlags;
+ Point mouse;
+ OSErr result;
+ ItemReference theItem;
+ HFSFlavor data;
+ FSRef fref;
+ Size size = sizeof (HFSFlavor);
+
+ drag_and_drop_file_list = Qnil;
+ GetDragMouse (theDrag, &mouse, 0L);
+ CountDragItems (theDrag, &items);
+ for (index = 1; index <= items; index++)
+ {
+ /* Only handle file references. */
+ GetDragItemReferenceNumber (theDrag, index, &theItem);
+ result = GetFlavorFlags (theDrag, theItem, flavorTypeHFS, &theFlags);
+ if (result == noErr)
+ {
+ #ifdef MAC_OSX
+ FSRef frref;
+ #else
+ Str255 path_name;
+ #endif
+ Str255 unix_path_name;
+ GetFlavorData (theDrag, theItem, flavorTypeHFS, &data, &size, 0L);
+ #ifdef MAC_OSX
+ /* Use Carbon routines, otherwise it converts the file name
+ to /Macintosh HD/..., which is not correct. */
+ FSpMakeFSRef (&data.fileSpec, &fref);
+ if (! FSRefMakePath (&fref, unix_path_name, sizeof (unix_path_name)));
+ #else
+ if (path_from_vol_dir_name (path_name, 255, data.fileSpec.vRefNum,
+ data.fileSpec.parID, data.fileSpec.name)
&&
+ mac_to_posix_pathname (path_name, unix_path_name, 255))
+ #endif
+ drag_and_drop_file_list = Fcons (build_string (unix_path_name),
+ drag_and_drop_file_list);
+ }
+ else
+ return;
+ }
+ /* If there are items in the list, construct an event and post it to
+ the queue like an interrupt using kbd_buffer_store_event. */
+ if (!NILP (drag_and_drop_file_list))
+ {
+ struct input_event event;
+ Lisp_Object frame;
+ struct frame *f = mac_window_to_frame (window);
+ SetPortWindowPort (window);
+ GlobalToLocal (&mouse);
+
+ event.kind = DRAG_N_DROP_EVENT;
+ event.code = 0;
+ event.modifiers = 0;
+ event.timestamp = TickCount () * (1000 / 60);
+ XSETINT (event.x, mouse.h);
+ XSETINT (event.y, mouse.v);
+ XSETFRAME (frame, f);
+ event.frame_or_window = Fcons (frame, drag_and_drop_file_list);
+ event.arg = Qnil;
+ /* Post to the interrupt queue */
+ kbd_buffer_store_event (&event);
+ /* MAC_TODO: Mimic behavior of windows by switching contexts to Emacs */
+ {
+ ProcessSerialNumber psn;
+ GetCurrentProcess (&psn);
+ SetFrontProcess (&psn);
+ }
+ }
+ }
+
+
+ /* Print Document Apple Event */
+ static pascal OSErr
+ do_ae_print_documents (const AppleEvent *pAE, AppleEvent *reply, long refcon)
+ {
+ return errAEEventNotHandled;
+ }
+
+
+ static pascal OSErr
+ do_ae_quit_application (AppleEvent* message, AppleEvent *reply, long refcon)
+ {
+ /* FixMe: Do we need an unwind-protect or something here? And what
+ do we do about unsaved files. Currently just forces quit rather
+ than doing recursive callback to get user input. */
+
+ terminate_flag = true;
+
+ /* Fkill_emacs doesn't return. We have to return. (TI) */
+ return noErr;
+ }
+
+
+ #if __profile__
+ void
+ profiler_exit_proc ()
+ {
+ ProfilerDump ("\pEmacs.prof");
+ ProfilerTerm ();
+ }
+ #endif
+
+ /* These few functions implement Emacs as a normal Mac application
+ (almost): set up the heap and the Toolbox, handle necessary
+ system events plus a few simple menu events. They also set up
+ Emacs's access to functions defined in the rest of this file.
+ Emacs uses function hooks to perform all its terminal I/O. A
+ complete list of these functions appear in termhooks.h. For what
+ they do, read the comments there and see also w32term.c and
+ xterm.c. What's noticeably missing here is the event loop, which
+ is normally present in most Mac application. After performing the
+ necessary Mac initializations, main passes off control to
+ emacs_main (corresponding to main in emacs.c). Emacs_main calls
+ mac_read_socket (defined further below) to read input. This is
+ where WaitNextEvent is called to process Mac events. This is also
+ where check_alarm in sysdep.c is called to simulate alarm signals.
+ This makes the cursor jump back to its correct position after
+ briefly jumping to that of the matching parenthesis, print useful
+ hints and prompts in the minibuffer after the user stops typing for
+ a wait, etc. */
+
+ #if !TARGET_API_MAC_CARBON
+ #undef main
+ int
+ main (void)
+ {
+ #if __profile__ /* is the profiler on? */
+ if (ProfilerInit(collectDetailed, bestTimeBase, 5000, 200))
+ exit(1);
+ #endif
+
+ #if __MWERKS__
+ /* set creator and type for files created by MSL */
+ _fcreator = 'EMAx';
+ _ftype = 'TEXT';
+ #endif
+
+ do_init_managers ();
+
+ do_get_menus ();
+
+ #ifndef USE_LSB_TAG
+ do_check_ram_size ();
+ #endif
+
+ init_emacs_passwd_dir ();
+
+ init_environ ();
+
+ initialize_applescript ();
+
+ init_required_apple_events ();
+
+ {
+ char **argv;
+ int argc = 0;
+
+ /* set up argv array from STR# resource */
+ get_string_list (&argv, ARGV_STRING_LIST_ID);
+ while (argv[argc])
+ argc++;
+
+ /* free up AppleScript resources on exit */
+ atexit (terminate_applescript);
+
+ #if __profile__ /* is the profiler on? */
+ atexit (profiler_exit_proc);
+ #endif
+
+ /* 3rd param "envp" never used in emacs_main */
+ (void) emacs_main (argc, argv, 0);
+ }
+
+ /* Never reached - real exit in Fkill_emacs */
+ return 0;
+ }
+ #endif
+
+ /* Table for translating Mac keycode to X keysym values. Contributed
+ by Sudhir Shenoy. */
+ static unsigned char keycode_to_xkeysym_table[] = {
+ /*0x00*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /*0x10*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /*0x20*/ 0, 0, 0, 0, 0x0d /*return*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+ /*0x30*/ 0x09 /*tab*/, 0 /*0x0020 space*/, 0, 0x08 /*backspace*/,
+ /*0x34*/ 0, 0x1b /*escape*/, 0, 0,
+ /*0x38*/ 0, 0, 0, 0,
+ /*0x3C*/ 0, 0, 0, 0,
+
+ /*0x40*/ 0, 0xae /*kp-.*/, 0, 0xaa /*kp-**/,
+ /*0x44*/ 0, 0xab /*kp-+*/, 0, 0x7f /*kp-clear*/,
+ /*0x48*/ 0, 0, 0, 0xaf /*kp-/*/,
+ /*0x4C*/ 0x8d /*kp-enter*/, 0, 0xad /*kp--*/, 0,
+
+ /*0x50*/ 0, 0xbd /*kp-=*/, 0xb0 /*kp-0*/, 0xb1 /*kp-1*/,
+ /*0x54*/ 0xb2 /*kp-2*/, 0xb3 /*kp-3*/, 0xb4 /*kp-4*/, 0xb5 /*kp-5*/,
+ /*0x58*/ 0xb6 /*kp-6*/, 0xb7 /*kp-7*/, 0, 0xb8 /*kp-8*/,
+ /*0x5C*/ 0xb9 /*kp-9*/, 0, 0, 0,
+
+ /*0x60*/ 0xc2 /*f5*/, 0xc3 /*f6*/, 0xc4 /*f7*/, 0xc0 /*f3*/,
+ /*0x64*/ 0xc5 /*f8*/, 0xc6 /*f9*/, 0, 0xc8 /*f11*/,
+ /*0x68*/ 0, 0xca /*f13*/, 0, 0xcb /*f14*/,
+ /*0x6C*/ 0, 0xc7 /*f10*/, 0, 0xc9 /*f12*/,
+
+ /*0x70*/ 0, 0xcc /*f15*/, 0x9e /*insert (or 0x6a==help)*/, 0x95 /*home*/,
+ /*0x74*/ 0x9a /*pgup*/, 0x9f /*delete*/, 0xc1 /*f4*/, 0x9c /*end*/,
+ /*0x78*/ 0xbf /*f2*/, 0x9b /*pgdown*/, 0xbe /*f1*/, 0x51 /*left*/,
+ /*0x7C*/ 0x53 /*right*/, 0x54 /*down*/, 0x52 /*up*/, 0
+ };
+
+ static int
+ keycode_to_xkeysym (int keyCode, int *xKeySym)
+ {
+ *xKeySym = keycode_to_xkeysym_table [keyCode & 0x7f];
+ return *xKeySym != 0;
+ }
+
+ /* Emacs calls this whenever it wants to read an input event from the
+ user. */
+ int
+ XTread_socket (sd, expected, hold_quit)
+ int sd, expected;
+ struct input_event *hold_quit;
+ {
+ struct input_event inev;
+ int count = 0;
+ #if USE_CARBON_EVENTS
+ EventRef eventRef;
+ EventTargetRef toolbox_dispatcher = GetEventDispatcherTarget ();
+ #else
+ EventMask event_mask;
+ #endif
+ EventRecord er;
+ struct mac_display_info *dpyinfo = &one_mac_display_info;
+
+ 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++;
+
+ /* Don't poll for events to process (specifically updateEvt) if
+ window update currently already in progress. A call to redisplay
+ (in do_window_update) can be preempted by another call to
+ redisplay, causing blank regions to be left on the screen and the
+ cursor to be left at strange places. */
+ if (handling_window_update)
+ {
+ UNBLOCK_INPUT;
+ return 0;
+ }
+
+ if (terminate_flag)
+ Fkill_emacs (make_number (1));
+
+ #if !USE_CARBON_EVENTS
+ event_mask = everyEvent;
+ if (NILP (Fboundp (Qmac_ready_for_drag_n_drop)))
+ event_mask -= highLevelEventMask;
+
+ while (WaitNextEvent (event_mask, &er,
+ (expected ? app_sleep_time : 0L), NULL))
+ #else
+ while (!ReceiveNextEvent (0, NULL,
+ (expected ? TicksToEventTime (app_sleep_time) : 0),
+ kEventRemoveFromQueue, &eventRef))
+ #endif /* !USE_CARBON_EVENTS */
+ {
+ int do_help = 0;
+ struct frame *f;
+
+ expected = 0;
+
+ /* It is necessary to set this (additional) argument slot of an
+ event to nil because keyboard.c protects incompletely
+ processed event from being garbage collected by placing them
+ in the kbd_buffer_gcpro vector. */
+ EVENT_INIT (inev);
+ inev.kind = NO_EVENT;
+ inev.arg = Qnil;
+
+ #if USE_CARBON_EVENTS
+ /* Handle new events */
+ if (!mac_convert_event_ref (eventRef, &er))
+ switch (GetEventClass (eventRef))
+ {
+ case kEventClassWindow:
+ if (GetEventKind (eventRef) == kEventWindowBoundsChanged)
+ {
+ WindowPtr window_ptr;
+ GetEventParameter(eventRef, kEventParamDirectObject,
+ typeWindowRef, NULL, sizeof(WindowPtr),
+ NULL, &window_ptr);
+ f = mac_window_to_frame (window_ptr);
+ if (f && !f->async_iconified)
+ {
+ int x, y;
+
+ x_real_positions (f, &x, &y);
+ f->left_pos = x;
+ f->top_pos = y;
+ }
+ SendEventToEventTarget (eventRef, toolbox_dispatcher);
+ }
+ break;
+ case kEventClassMouse:
+ if (GetEventKind (eventRef) == kEventMouseWheelMoved)
+ {
+ SInt32 delta;
+ Point point;
+ WindowPtr window_ptr = mac_front_window ();
+
+ if (!IsValidWindowPtr (window_ptr))
+ {
+ SysBeep(1);
+ break;
+ }
+
+ GetEventParameter(eventRef, kEventParamMouseWheelDelta,
+ typeSInt32, NULL, sizeof (SInt32),
+ NULL, &delta);
+ GetEventParameter(eventRef, kEventParamMouseLocation,
+ typeQDPoint, NULL, sizeof (Point),
+ NULL, &point);
+ inev.kind = WHEEL_EVENT;
+ inev.code = 0;
+ inev.modifiers = (mac_event_to_emacs_modifiers (eventRef)
+ | ((delta < 0) ? down_modifier
+ : up_modifier));
+ SetPortWindowPort (window_ptr);
+ GlobalToLocal (&point);
+ XSETINT (inev.x, point.h);
+ XSETINT (inev.y, point.v);
+ XSETFRAME (inev.frame_or_window,
+ mac_window_to_frame (window_ptr));
+ inev.timestamp = EventTimeToTicks (GetEventTime
(eventRef))*(1000/60);
+ }
+ else
+ SendEventToEventTarget (eventRef, toolbox_dispatcher);
+
+ break;
+ default:
+ /* Send the event to the appropriate receiver. */
+ SendEventToEventTarget (eventRef, toolbox_dispatcher);
+ }
+ else
+ #endif /* USE_CARBON_EVENTS */
+ switch (er.what)
+ {
+ case mouseDown:
+ case mouseUp:
+ {
+ WindowPtr window_ptr;
+ SInt16 part_code;
+ int tool_bar_p = 0;
+
+ #if USE_CARBON_EVENTS
+ /* This is needed to send mouse events like aqua window
+ buttons to the correct handler. */
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
+ break;
+ #endif
+
+ if (dpyinfo->grabbed && last_mouse_frame
+ && FRAME_LIVE_P (last_mouse_frame))
+ {
+ window_ptr = FRAME_MAC_WINDOW (last_mouse_frame);
+ part_code = inContent;
+ }
+ else
+ {
+ window_ptr = FrontWindow ();
+ if (tip_window && window_ptr == tip_window)
+ {
+ HideWindow (tip_window);
+ window_ptr = FrontWindow ();
+ }
+
+ if (!is_emacs_window (window_ptr))
+ break;
+
+ part_code = FindWindow (er.where, &window_ptr);
+ }
+
+ switch (part_code)
+ {
+ case inMenuBar:
+ if (er.what == mouseDown)
+ {
+ f = mac_window_to_frame (mac_front_window ());
+ saved_menu_event_location = er.where;
+ inev.kind = MENU_BAR_ACTIVATE_EVENT;
+ XSETFRAME (inev.frame_or_window, f);
+ }
+ break;
+
+ case inContent:
+ if (window_ptr != mac_front_window ())
+ SelectWindow (window_ptr);
+ else
+ {
+ SInt16 control_part_code;
+ ControlHandle ch;
+ Point mouse_loc = er.where;
+
+ f = mac_window_to_frame (window_ptr);
+ /* convert to local coordinates of new window */
+ SetPortWindowPort (window_ptr);
+
+ GlobalToLocal (&mouse_loc);
+ #if TARGET_API_MAC_CARBON
+ ch = FindControlUnderMouse (mouse_loc, window_ptr,
+ &control_part_code);
+ #else
+ control_part_code = FindControl (mouse_loc, window_ptr,
+ &ch);
+ #endif
+
+ #if USE_CARBON_EVENTS
+ inev.code = mac_get_mouse_btn (eventRef);
+ inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
+ #else
+ inev.code = mac_get_emulated_btn (er.modifiers);
+ inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
+ #endif
+ XSETINT (inev.x, mouse_loc.h);
+ XSETINT (inev.y, mouse_loc.v);
+ inev.timestamp = er.when * (1000 / 60);
+ /* ticks to milliseconds */
+
+ if (dpyinfo->grabbed && tracked_scroll_bar
+ #if TARGET_API_MAC_CARBON
+ || ch != 0
+ #else
+ || control_part_code != 0
+ #endif
+ )
+ {
+ struct scroll_bar *bar;
+
+ if (dpyinfo->grabbed && tracked_scroll_bar)
+ {
+ bar = tracked_scroll_bar;
+ control_part_code = kControlIndicatorPart;
+ }
+ else
+ bar = (struct scroll_bar *) GetControlReference (ch);
+ x_scroll_bar_handle_click (bar, control_part_code,
+ &er, &inev);
+ if (er.what == mouseDown
+ && control_part_code == kControlIndicatorPart)
+ tracked_scroll_bar = bar;
+ else
+ tracked_scroll_bar = NULL;
+ }
+ else
+ {
+ Lisp_Object window;
+ int x = mouse_loc.h;
+ int y = mouse_loc.v;
+
+ window = window_from_coordinates (f, x, y, 0, 0, 0, 1);
+ if (EQ (window, f->tool_bar_window))
+ {
+ if (er.what == mouseDown)
+ handle_tool_bar_click (f, x, y, 1, 0);
+ else
+ handle_tool_bar_click (f, x, y, 0,
+ inev.modifiers);
+ tool_bar_p = 1;
+ }
+ else
+ {
+ XSETFRAME (inev.frame_or_window, f);
+ inev.kind = MOUSE_CLICK_EVENT;
+ }
+ }
+
+ if (er.what == mouseDown)
+ {
+ dpyinfo->grabbed |= (1 << inev.code);
+ 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
+ {
+ if (dpyinfo->grabbed & (1 << inev.code) == 0)
+ /* If a button is released though it was not
+ previously pressed, that would be because
+ of multi-button emulation. */
+ dpyinfo->grabbed = 0;
+ else
+ dpyinfo->grabbed &= ~(1 << inev.code);
+ }
+
+ switch (er.what)
+ {
+ case mouseDown:
+ inev.modifiers |= down_modifier;
+ break;
+ case mouseUp:
+ inev.modifiers |= up_modifier;
+ break;
+ }
+ }
+ break;
+
+ case inDrag:
+ #if TARGET_API_MAC_CARBON
+ if (er.what == mouseDown)
+ {
+ BitMap bm;
+
+ GetQDGlobalsScreenBits (&bm);
+ DragWindow (window_ptr, er.where, &bm.bounds);
+ }
+ #else /* not TARGET_API_MAC_CARBON */
+ DragWindow (window_ptr, er.where, &qd.screenBits.bounds);
+ #endif /* not TARGET_API_MAC_CARBON */
+ /* Update the frame parameters. */
+ {
+ struct frame *f = mac_window_to_frame (window_ptr);
+ if (f && !f->async_iconified)
+ {
+ int x, y;
+
+ x_real_positions (f, &x, &y);
+ f->left_pos = x;
+ f->top_pos = y;
+ }
+ }
+ break;
+
+ case inGoAway:
+ if (TrackGoAway (window_ptr, er.where))
+ {
+ inev.kind = DELETE_WINDOW_EVENT;
+ XSETFRAME (inev.frame_or_window,
+ mac_window_to_frame (window_ptr));
+ }
+ break;
+
+ /* window resize handling added --ben */
+ case inGrow:
+ if (er.what == mouseDown)
+ {
+ do_grow_window(window_ptr, &er);
+ break;
+ }
+
+ /* window zoom handling added --ben */
+ case inZoomIn:
+ case inZoomOut:
+ if (TrackBox (window_ptr, er.where, part_code))
+ do_zoom_window (window_ptr, part_code);
+ break;
+
+ default:
+ break;
+ }
+ }
+ break;
+
+ case updateEvt:
+ #if USE_CARBON_EVENTS
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
+ break;
+ #endif
+ do_window_update ((WindowPtr) er.message);
+ break;
+
+ case osEvt:
+ #if USE_CARBON_EVENTS
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
+ break;
+ #endif
+ switch ((er.message >> 24) & 0x000000FF)
+ {
+ case suspendResumeMessage:
+ if ((er.message & resumeFlag) == 1)
+ do_app_resume ();
+ else
+ do_app_suspend ();
+ break;
+
+ case mouseMovedMessage:
+ previous_help_echo_string = help_echo_string;
+ help_echo_string = help_echo_object = help_echo_window = Qnil;
+ help_echo_pos = -1;
+
+ do_mouse_moved (er.where, &f);
+
+ /* If the contents of the global variable
+ help_echo_string has changed, generate a
+ HELP_EVENT. */
+ if (!NILP (help_echo_string) || !NILP (previous_help_echo_string))
+ do_help = 1;
+ break;
+ }
+ break;
+
+ case activateEvt:
+ {
+ WindowPtr window_ptr = (WindowPtr) er.message;
+
+ #if USE_CARBON_EVENTS
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
+ break;
+ #endif
+ if (window_ptr == tip_window)
+ {
+ HideWindow (tip_window);
+ break;
+ }
+
+ if (!is_emacs_window (window_ptr))
+ break;
+
+ f = mac_window_to_frame (window_ptr);
+
+ if ((er.modifiers & activeFlag) != 0)
+ {
+ /* A window has been activated */
+ Point mouse_loc = er.where;
+
+ x_new_focus_frame (dpyinfo, f);
+ activate_scroll_bars (f);
+
+ SetPortWindowPort (window_ptr);
+ GlobalToLocal (&mouse_loc);
+ /* Window-activated event counts as mouse movement,
+ so update things that depend on mouse position. */
+ note_mouse_movement (mac_window_to_frame (window_ptr),
+ &mouse_loc);
+ }
+ else
+ {
+ /* A window has been deactivated */
+ dpyinfo->grabbed = 0;
+
+ if (f == dpyinfo->x_focus_frame)
+ {
+ x_new_focus_frame (dpyinfo, 0);
+ deactivate_scroll_bars (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)
+ do_help = -1;
+ }
+ }
+ break;
+
+ case keyDown:
+ case autoKey:
+ {
+ int keycode = (er.message & keyCodeMask) >> 8;
+ int xkeysym;
+
+ #if USE_CARBON_EVENTS
+ /* When using Carbon Events, we need to pass raw keyboard
+ events to the TSM ourselves. If TSM handles it, it
+ will pass back noErr, otherwise it will pass back
+ "eventNotHandledErr" and we can process it
+ normally. */
+ if ((!NILP (Vmac_pass_command_to_system)
+ || !(er.modifiers & cmdKey))
+ && (!NILP (Vmac_pass_control_to_system)
+ || !(er.modifiers & controlKey)))
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
+ break;
+ #endif
+
+ #if TARGET_API_MAC_CARBON
+ if (!IsValidWindowPtr (mac_front_window ()))
+ {
+ SysBeep (1);
+ break;
+ }
+ #endif
+
+ ObscureCursor ();
+
+ if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
+ {
+ clear_mouse_face (dpyinfo);
+ dpyinfo->mouse_face_hidden = 1;
+ }
+
+ if (keycode_to_xkeysym (keycode, &xkeysym))
+ {
+ inev.code = 0xff00 | xkeysym;
+ inev.kind = NON_ASCII_KEYSTROKE_EVENT;
+ }
+ else
+ {
+ if (er.modifiers & (controlKey |
+ (NILP (Vmac_command_key_is_meta) ? optionKey
+ : cmdKey)))
+ {
+ /* This code comes from Keyboard Resource,
+ Appendix C of IM - Text. This is necessary
+ since shift is ignored in KCHR table
+ translation when option or command is pressed.
+ It also does not translate correctly
+ control-shift chars like C-% so mask off shift
+ here also */
+ int new_modifiers = er.modifiers & 0xe600;
+ /* mask off option and command */
+ int new_keycode = keycode | new_modifiers;
+ Ptr kchr_ptr = (Ptr) GetScriptManagerVariable (smKCHRCache);
+ unsigned long some_state = 0;
+ inev.code = KeyTranslate (kchr_ptr, new_keycode,
+ &some_state) & 0xff;
+ }
+ else
+ inev.code = er.message & charCodeMask;
+ inev.kind = ASCII_KEYSTROKE_EVENT;
+ }
+ }
+
+ /* If variable mac-convert-keyboard-input-to-latin-1 is
+ non-nil, convert non-ASCII characters typed at the Mac
+ keyboard (presumed to be in the Mac Roman encoding) to
+ iso-latin-1 encoding before they are passed to Emacs.
+ This enables the Mac keyboard to be used to enter
+ non-ASCII iso-latin-1 characters directly. */
+ if (mac_keyboard_text_encoding != kTextEncodingMacRoman
+ && inev.kind == ASCII_KEYSTROKE_EVENT && inev.code >= 128)
+ {
+ static TECObjectRef converter = NULL;
+ OSStatus the_err = noErr;
+ OSStatus convert_status = noErr;
+
+ if (converter == NULL)
+ {
+ the_err = TECCreateConverter (&converter,
+ kTextEncodingMacRoman,
+ mac_keyboard_text_encoding);
+ current_mac_keyboard_text_encoding
+ = mac_keyboard_text_encoding;
+ }
+ else if (mac_keyboard_text_encoding
+ != current_mac_keyboard_text_encoding)
+ {
+ /* Free the converter for the current encoding
+ before creating a new one. */
+ TECDisposeConverter (converter);
+ the_err = TECCreateConverter (&converter,
+ kTextEncodingMacRoman,
+ mac_keyboard_text_encoding);
+ current_mac_keyboard_text_encoding
+ = mac_keyboard_text_encoding;
+ }
+
+ if (the_err == noErr)
+ {
+ unsigned char ch = inev.code;
+ ByteCount actual_input_length, actual_output_length;
+ unsigned char outch;
+
+ convert_status = TECConvertText (converter, &ch, 1,
+ &actual_input_length,
+ &outch, 1,
+ &actual_output_length);
+ if (convert_status == noErr
+ && actual_input_length == 1
+ && actual_output_length == 1)
+ inev.code = outch;
+ }
+ }
+
+ #if USE_CARBON_EVENTS
+ inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
+ #else
+ inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
+ #endif
+ XSETFRAME (inev.frame_or_window,
+ mac_window_to_frame (mac_front_window ()));
+ inev.timestamp = er.when * (1000 / 60); /* ticks to milliseconds */
+ break;
+
+ case kHighLevelEvent:
+ drag_and_drop_file_list = Qnil;
+
+ AEProcessAppleEvent(&er);
+
+ /* Build a DRAG_N_DROP_EVENT type event as is done in
+ constuct_drag_n_drop in w32term.c. */
+ if (!NILP (drag_and_drop_file_list))
+ {
+ struct frame *f = NULL;
+ WindowPtr wp;
+ Lisp_Object frame;
+
+ wp = mac_front_window ();
+
+ if (!wp)
+ {
+ struct frame *f = XFRAME (XCAR (Vframe_list));
+ CollapseWindow (FRAME_MAC_WINDOW (f), false);
+ wp = mac_front_window ();
+ }
+
+ if (wp && is_emacs_window (wp))
+ f = mac_window_to_frame (wp);
+
+ inev.kind = DRAG_N_DROP_EVENT;
+ inev.code = 0;
+ inev.timestamp = er.when * (1000 / 60);
+ /* ticks to milliseconds */
+ #if USE_CARBON_EVENTS
+ inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
+ #else
+ inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
+ #endif
+
+ XSETINT (inev.x, 0);
+ XSETINT (inev.y, 0);
+
+ XSETFRAME (frame, f);
+ inev.frame_or_window = Fcons (frame, drag_and_drop_file_list);
+
+ /* Regardless of whether Emacs was suspended or in the
+ foreground, ask it to redraw its entire screen.
+ Otherwise parts of the screen can be left in an
+ inconsistent state. */
+ if (wp)
+ #if TARGET_API_MAC_CARBON
+ {
+ Rect r;
+
+ GetWindowPortBounds (wp, &r);
+ InvalWindowRect (wp, &r);
+ }
+ #else /* not TARGET_API_MAC_CARBON */
+ InvalRect (&(wp->portRect));
+ #endif /* not TARGET_API_MAC_CARBON */
+ }
+ default:
+ break;
+ }
+ #if USE_CARBON_EVENTS
+ ReleaseEvent (eventRef);
+ #endif
+
+ if (inev.kind != NO_EVENT)
+ {
+ kbd_buffer_store_event_hold (&inev, hold_quit);
+ count++;
+ }
+
+ if (do_help
+ && !(hold_quit && hold_quit->kind != NO_EVENT))
+ {
+ Lisp_Object frame;
+
+ if (f)
+ XSETFRAME (frame, f);
+ else
+ frame = Qnil;
+
+ if (do_help > 0)
+ {
+ any_help_event_p = 1;
+ gen_help_event (help_echo_string, frame, help_echo_window,
+ help_echo_object, help_echo_pos);
+ }
+ else
+ {
+ help_echo_string = Qnil;
+ gen_help_event (Qnil, frame, Qnil, Qnil, 0);
+ }
+ count++;
+ }
+
+ }
+
+ /* If the focus was just given to an autoraising 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;
+ }
+
+ #if !TARGET_API_MAC_CARBON
+ check_alarm (); /* simulate the handling of a SIGALRM */
+ #endif
+
+ UNBLOCK_INPUT;
+ return count;
+ }
+
+
+ /* Need to override CodeWarrior's input function so no conversion is
+ done on newlines Otherwise compiled functions in .elc files will be
+ read incorrectly. Defined in ...:MSL C:MSL
+ Common:Source:buffer_io.c. */
+ #ifdef __MWERKS__
+ void
+ __convert_to_newlines (unsigned char * p, size_t * n)
+ {
+ #pragma unused(p,n)
+ }
+
+ void
+ __convert_from_newlines (unsigned char * p, size_t * n)
+ {
+ #pragma unused(p,n)
+ }
+ #endif
+
+
+ /* Initialize the struct pointed to by MW to represent a new COLS x
+ ROWS Macintosh window, using font with name FONTNAME and size
+ FONTSIZE. */
+ void
+ make_mac_frame (FRAME_PTR fp)
+ {
+ mac_output *mwp;
+ #if TARGET_API_MAC_CARBON
+ static int making_terminal_window = 0;
+ #else
+ static int making_terminal_window = 1;
+ #endif
+
+ mwp = fp->output_data.mac;
+
+ if (making_terminal_window)
+ {
+ if (!(mwp->mWP = GetNewCWindow (TERM_WINDOW_RESOURCE, NULL,
+ (WindowPtr) -1)))
+ abort ();
+ making_terminal_window = 0;
+ }
+ else
+ {
+ #if TARGET_API_MAC_CARBON
+ Rect r;
+
+ SetRect (&r, 0, 0, 1, 1);
+ if (CreateNewWindow (kDocumentWindowClass,
+ kWindowStandardDocumentAttributes
+ /* | kWindowToolbarButtonAttribute */,
+ &r, &mwp->mWP) != noErr)
+ #else
+ if (!(mwp->mWP = GetNewCWindow (WINDOW_RESOURCE, NULL, (WindowPtr) -1)))
+ #endif
+ abort ();
+ }
+
+ SetWRefCon (mwp->mWP, (long) mwp);
+ /* so that update events can find this mac_output struct */
+ mwp->mFP = fp; /* point back to emacs frame */
+
+ SetPortWindowPort (mwp->mWP);
+
+ SizeWindow (mwp->mWP, FRAME_PIXEL_WIDTH (fp), FRAME_PIXEL_HEIGHT (fp),
false);
+ }
+
+
+ void
+ make_mac_terminal_frame (struct frame *f)
+ {
+ Lisp_Object frame;
+
+ XSETFRAME (frame, f);
+
+ f->output_method = output_mac;
+ f->output_data.mac = (struct mac_output *)
+ xmalloc (sizeof (struct mac_output));
+ bzero (f->output_data.mac, sizeof (struct mac_output));
+
+ XSETFRAME (FRAME_KBOARD (f)->Vdefault_minibuffer_frame, f);
+
+ FRAME_COLS (f) = 96;
+ FRAME_LINES (f) = 4;
+
+ FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
+ FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_right;
+
+ FRAME_DESIRED_CURSOR (f) = FILLED_BOX_CURSOR;
+
+ f->output_data.mac->cursor_pixel = 0;
+ f->output_data.mac->border_pixel = 0x00ff00;
+ f->output_data.mac->mouse_pixel = 0xff00ff;
+ f->output_data.mac->cursor_foreground_pixel = 0x0000ff;
+
+ FRAME_FONTSET (f) = -1;
+ f->output_data.mac->explicit_parent = 0;
+ f->left_pos = 4;
+ f->top_pos = 4;
+ f->border_width = 0;
+
+ f->internal_border_width = 0;
+
+ f->auto_raise = 1;
+ f->auto_lower = 1;
+
+ f->new_text_cols = 0;
+ f->new_text_lines = 0;
+
+ make_mac_frame (f);
+
+ x_make_gc (f);
+
+ /* Need to be initialized for unshow_buffer in window.c. */
+ selected_window = f->selected_window;
+
+ Fmodify_frame_parameters (frame,
+ Fcons (Fcons (Qfont,
+ build_string
("-*-monaco-medium-r-*--*-90-*-*-*-*-mac-roman")), Qnil));
+ Fmodify_frame_parameters (frame,
+ Fcons (Fcons (Qforeground_color,
+ build_string ("black")), Qnil));
+ Fmodify_frame_parameters (frame,
+ Fcons (Fcons (Qbackground_color,
+ build_string ("white")), Qnil));
+
+ ShowWindow (f->output_data.mac->mWP);
+ }
+
+
+ /***********************************************************************
+ Initialization
+ ***********************************************************************/
+
+ int mac_initialized = 0;
+
+ void
+ mac_initialize_display_info ()
+ {
+ struct mac_display_info *dpyinfo = &one_mac_display_info;
+ GDHandle main_device_handle;
+
+ bzero (dpyinfo, sizeof (*dpyinfo));
+
+ /* Put it on x_display_name_list. */
+ x_display_name_list = Fcons (Fcons (build_string ("Mac"), Qnil),
+ x_display_name_list);
+ dpyinfo->name_list_element = XCAR (x_display_name_list);
+
+ #if 0
+ dpyinfo->mac_id_name
+ = (char *) xmalloc (SCHARS (Vinvocation_name)
+ + SCHARS (Vsystem_name)
+ + 2);
+ sprintf (dpyinfo->mac_id_name, "address@hidden",
+ SDATA (Vinvocation_name), SDATA (Vsystem_name));
+ #else
+ dpyinfo->mac_id_name = (char *) xmalloc (strlen ("Mac Display") + 1);
+ strcpy (dpyinfo->mac_id_name, "Mac Display");
+ #endif
+
+ main_device_handle = LMGetMainDevice();
+
+ dpyinfo->reference_count = 0;
+ dpyinfo->resx = 75.0;
+ dpyinfo->resy = 75.0;
+ dpyinfo->color_p = TestDeviceAttribute (main_device_handle, gdDevType);
+ #ifdef MAC_OSX
+ /* HasDepth returns true if it is possible to have a 32 bit display,
+ but this may not be what is actually used. Mac OSX can do better.
+ CGMainDisplayID is only available on OSX 10.2 and higher, but the
+ header for CGGetActiveDisplayList says that the first display returned
+ is the active one, so we use that. */
+ {
+ CGDirectDisplayID disp_id[1];
+ CGDisplayCount disp_count;
+ CGDisplayErr error_code;
+
+ error_code = CGGetActiveDisplayList (1, disp_id, &disp_count);
+ if (error_code != 0)
+ error ("No display found, CGGetActiveDisplayList error %d", error_code);
+
+ dpyinfo->n_planes = CGDisplayBitsPerPixel (disp_id[0]);
+ }
+ #else
+ for (dpyinfo->n_planes = 32; dpyinfo->n_planes > 0; dpyinfo->n_planes >>= 1)
+ if (HasDepth (main_device_handle, dpyinfo->n_planes,
+ gdDevType, dpyinfo->color_p))
+ break;
+ #endif
+ dpyinfo->height = (**main_device_handle).gdRect.bottom;
+ dpyinfo->width = (**main_device_handle).gdRect.right;
+ dpyinfo->grabbed = 0;
+ dpyinfo->root_window = NULL;
+ dpyinfo->image_cache = make_image_cache ();
+
+ 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_hidden = 0;
+ }
+
+ struct mac_display_info *
+ mac_term_init (display_name, xrm_option, resource_name)
+ Lisp_Object display_name;
+ char *xrm_option;
+ char *resource_name;
+ {
+ struct mac_display_info *dpyinfo;
+ GDHandle main_device_handle;
+
+ if (!mac_initialized)
+ {
+ mac_initialize ();
+ mac_initialized = 1;
+ }
+
+ mac_initialize_display_info (display_name);
+
+ dpyinfo = &one_mac_display_info;
+
+ main_device_handle = LMGetMainDevice();
+
+ dpyinfo->height = (**main_device_handle).gdRect.bottom;
+ dpyinfo->width = (**main_device_handle).gdRect.right;
+
+ return dpyinfo;
+ }
+
+ #ifdef MAC_OSX
+ void
+ mac_check_bundle()
+ {
+ extern int inhibit_window_system;
+ extern int noninteractive;
+ CFBundleRef appsBundle;
+ pid_t child;
+
+ /* No need to test if already -nw*/
+ if (inhibit_window_system || noninteractive)
+ return;
+
+ appsBundle = CFBundleGetMainBundle();
+ if (appsBundle != NULL)
+ {
+ CFStringRef cfBI = CFSTR("CFBundleIdentifier");
+ CFTypeRef res = CFBundleGetValueForInfoDictionaryKey(appsBundle, cfBI);
+ /* We found the bundle identifier, now we know we are valid. */
+ if (res != NULL)
+ {
+ CFRelease(res);
+ return;
+ }
+ }
+ /* MAC_TODO: Have this start the bundled executable */
+
+ /* For now, prevent the fatal error by bringing it up in the terminal */
+ inhibit_window_system = 1;
+ }
+
+ void
+ MakeMeTheFrontProcess ()
+ {
+ ProcessSerialNumber psn;
+ OSErr err;
+
+ err = GetCurrentProcess (&psn);
+ if (err == noErr)
+ (void) SetFrontProcess (&psn);
+ }
+
+ /***** Code to handle C-g testing *****/
+
+ /* Contains the Mac modifier formed from quit_char */
+ static mac_quit_char_modifiers = 0;
+ static mac_quit_char_keycode;
+ extern int quit_char;
+
+ static void
+ mac_determine_quit_char_modifiers()
+ {
+ /* Todo: Determine modifiers from quit_char. */
+ UInt32 qc_modifiers = ctrl_modifier;
+
+ /* Map modifiers */
+ mac_quit_char_modifiers = 0;
+ if (qc_modifiers & ctrl_modifier) mac_quit_char_modifiers |= macCtrlKey;
+ if (qc_modifiers & shift_modifier) mac_quit_char_modifiers |= macShiftKey;
+ if (qc_modifiers & meta_modifier) mac_quit_char_modifiers |= macMetaKey;
+ if (qc_modifiers & alt_modifier) mac_quit_char_modifiers |= macAltKey;
+ }
+
+ static void
+ init_quit_char_handler ()
+ {
+ /* TODO: Let this support keys other the 'g' */
+ mac_quit_char_keycode = 5;
+ /* Look at <architecture/adb_kb_map.h> for details */
+ /*
http://gemma.apple.com/techpubs/mac/Toolbox/Toolbox-40.html#MARKER-9-184*/
+
+ mac_determine_quit_char_modifiers();
+ }
+
+ static Boolean
+ quit_char_comp (EventRef inEvent, void *inCompData)
+ {
+ if (GetEventClass(inEvent) != kEventClassKeyboard)
+ return false;
+ if (GetEventKind(inEvent) != kEventRawKeyDown)
+ return false;
+ {
+ UInt32 keyCode;
+ UInt32 keyModifiers;
+ GetEventParameter(inEvent, kEventParamKeyCode,
+ typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode);
+ if (keyCode != mac_quit_char_keycode)
+ return false;
+ GetEventParameter(inEvent, kEventParamKeyModifiers,
+ typeUInt32, NULL, sizeof(UInt32), NULL, &keyModifiers);
+ if (keyModifiers != mac_quit_char_modifiers)
+ return false;
+ }
+ return true;
+ }
+
+ void
+ mac_check_for_quit_char ()
+ {
+ EventRef event;
+ static EMACS_TIME last_check_time = { 0, 0 };
+ static EMACS_TIME one_second = { 1, 0 };
+ EMACS_TIME now, t;
+
+ /* If windows are not initialized, return immediately (keep it bouncin').
*/
+ if (!mac_quit_char_modifiers)
+ return;
+
+ /* Don't check if last check is less than a second ago. */
+ EMACS_GET_TIME (now);
+ EMACS_SUB_TIME (t, now, last_check_time);
+ if (EMACS_TIME_LT (t, one_second))
+ return;
+ last_check_time = now;
+
+ /* Redetermine modifiers because they are based on lisp variables */
+ mac_determine_quit_char_modifiers ();
+
+ /* Fill the queue with events */
+ BLOCK_INPUT;
+ ReceiveNextEvent (0, NULL, kEventDurationNoWait, false, &event);
+ event = FindSpecificEventInQueue (GetMainEventQueue (), quit_char_comp,
+ NULL);
+ UNBLOCK_INPUT;
+ if (event)
+ {
+ struct input_event e;
+
+ /* Use an input_event to emulate what the interrupt handler does. */
+ EVENT_INIT (e);
+ e.kind = ASCII_KEYSTROKE_EVENT;
+ e.code = quit_char;
+ e.arg = Qnil;
+ e.modifiers = NULL;
+ e.timestamp = EventTimeToTicks (GetEventTime (event)) * (1000/60);
+ XSETFRAME (e.frame_or_window, mac_window_to_frame (mac_front_window
()));
+ /* Remove event from queue to prevent looping. */
+ RemoveEventFromQueue (GetMainEventQueue (), event);
+ ReleaseEvent (event);
+ kbd_buffer_store_event (&e);
+ }
+ }
+
+ #endif /* MAC_OSX */
+
+ /* Set up use of X before we make the first connection. */
+
+ extern frame_parm_handler mac_frame_parm_handlers[];
+
+ static struct redisplay_interface x_redisplay_interface =
+ {
+ mac_frame_parm_handlers,
+ 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,
+ x_cursor_to,
+ x_flush,
+ x_flush,
+ x_clear_window_mouse_face,
+ x_get_glyph_overhangs,
+ x_fix_overlapping_area,
+ x_draw_fringe_bitmap,
+ 0, /* define_fringe_bitmap */
+ 0, /* destroy_fringe_bitmap */
+ mac_per_char_metric,
+ mac_encode_char,
+ NULL, /* mac_compute_glyph_string_overhangs */
+ x_draw_glyph_string,
+ mac_define_frame_cursor,
+ mac_clear_frame_area,
+ mac_draw_window_cursor,
+ mac_draw_vertical_window_border,
+ mac_shift_glyphs_for_insert
+ };
+
+ void
+ mac_initialize ()
+ {
+ rif = &x_redisplay_interface;
+
+ clear_frame_hook = x_clear_frame;
+ ins_del_lines_hook = x_ins_del_lines;
+ 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;
+ 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;
+
+ 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 ();
+ 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
+
+ #if USE_TOOLKIT_SCROLL_BARS
+ xaw3d_arrow_scroll = False;
+ xaw3d_pick_top = True;
+ #endif
+
+ #if 0
+ /* 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);
+ #endif
+
+ mac_initialize_display_info ();
+
+ #if TARGET_API_MAC_CARBON
+ init_required_apple_events ();
+
+ init_mac_drag_n_drop ();
+
+ #if USE_CARBON_EVENTS
+ init_service_handler ();
+
+ init_quit_char_handler ();
+ #endif
+
+ DisableMenuCommand (NULL, kHICommandQuit);
+
+ if (!inhibit_window_system)
+ MakeMeTheFrontProcess ();
+ #endif
+ }
+
+
+ void
+ syms_of_macterm ()
+ {
+ #if 0
+ staticpro (&x_error_message_string);
+ x_error_message_string = Qnil;
+ #endif
+
+ Fprovide (intern ("mac-carbon"), Qnil);
+
+ staticpro (&Qreverse);
+ Qreverse = intern ("reverse");
+
+ 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;
+
+ Qmac_ready_for_drag_n_drop = intern ("mac-ready-for-drag-n-drop");
+ staticpro (&Qmac_ready_for_drag_n_drop);
+
+ Qbig5 = intern ("big5");
+ staticpro (&Qbig5);
+
+ Qcn_gb = intern ("cn-gb");
+ staticpro (&Qcn_gb);
+
+ Qsjis = intern ("sjis");
+ staticpro (&Qsjis);
+
+ Qeuc_kr = intern ("euc-kr");
+ staticpro (&Qeuc_kr);
+
+ DEFVAR_BOOL ("x-autoselect-window", &x_autoselect_window_p,
+ doc: /* *Non-nil means autoselect window with mouse pointer. */);
+ x_autoselect_window_p = 0;
+
+ DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
+ doc: /* If not nil, Emacs uses toolkit scroll bars. */);
+ Vx_toolkit_scroll_bars = Qt;
+
+ DEFVAR_BOOL ("x-use-underline-position-properties",
+ &x_use_underline_position_properties,
+ doc: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
+ nil means ignore them. If you encounter fonts with bogus
+ UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
+ to 4.1, set this to nil. */);
+ x_use_underline_position_properties = 0;
+
+ staticpro (&last_mouse_motion_frame);
+ last_mouse_motion_frame = Qnil;
+
+ DEFVAR_LISP ("mac-command-key-is-meta", &Vmac_command_key_is_meta,
+ doc: /* Non-nil means that the command key is used as the Emacs meta key.
+ Otherwise the option key is used. */);
+ Vmac_command_key_is_meta = Qt;
+
+ DEFVAR_LISP ("mac-reverse-ctrl-meta", &Vmac_reverse_ctrl_meta,
+ doc: /* Non-nil means that the control and meta keys are reversed. This
is
+ useful for non-standard keyboard layouts. */);
+ Vmac_reverse_ctrl_meta = Qnil;
+
+ DEFVAR_LISP ("mac-emulate-three-button-mouse",
+ &Vmac_emulate_three_button_mouse,
+ doc: /* t means that when the option-key is held down while pressing the
+ mouse button, the click will register as mouse-2 and while the
+ command-key is held down, the click will register as mouse-3.
+ 'reverse means that the the option-key will register for mouse-3
+ and the command-key will register for mouse-2. nil means that
+ not emulation should be done and the modifiers should be placed
+ on the mouse-1 event. */);
+ Vmac_emulate_three_button_mouse = Qnil;
+
+ #if USE_CARBON_EVENTS
+ DEFVAR_LISP ("mac-wheel-button-is-mouse-2", &Vmac_wheel_button_is_mouse_2,
+ doc: /* Non-nil means that the wheel button will be treated as mouse-2 and
+ the right click will be mouse-3.
+ Otherwise, the right click will be mouse-2 and the wheel button mouse-3.*/);
+ Vmac_wheel_button_is_mouse_2 = Qt;
+
+ DEFVAR_LISP ("mac-pass-command-to-system", &Vmac_pass_command_to_system,
+ doc: /* If non-nil, the Mac \"Command\" key is passed on to the Mac
+ Toolbox for processing before Emacs sees it. */);
+ Vmac_pass_command_to_system = Qt;
+
+ DEFVAR_LISP ("mac-pass-control-to-system", &Vmac_pass_control_to_system,
+ doc: /* If non-nil, the Mac \"Control\" key is passed on to the Mac
+ Toolbox for processing before Emacs sees it. */);
+ Vmac_pass_control_to_system = Qt;
+ #endif
+
+ DEFVAR_INT ("mac-keyboard-text-encoding", &mac_keyboard_text_encoding,
+ doc: /* One of the Text Encoding Base constant values defined in the
+ Basic Text Constants section of Inside Macintosh - Text Encoding
+ Conversion Manager. Its value determines the encoding characters
+ typed at the Mac keyboard (presumed to be in the MacRoman encoding)
+ will convert into. E.g., if it is set to kTextEncodingMacRoman (0),
+ its default value, no conversion takes place. If it is set to
+ kTextEncodingISOLatin1 (0x201) or kTextEncodingISOLatin2 (0x202),
+ characters typed on Mac keyboard are first converted into the
+ ISO Latin-1 or ISO Latin-2 encoding, respectively before being
+ passed to Emacs. Together with Emacs's set-keyboard-coding-system
+ command, this enables the Mac keyboard to be used to enter non-ASCII
+ characters directly. */);
+ mac_keyboard_text_encoding = kTextEncodingMacRoman;
+ }
+
+ /* arch-tag: f2259165-4454-4c04-a029-a133c8af7b5b
+ (do not change this comment) */
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] Changes to emacs/src/macterm.c [gnus-5_10-branch],
Miles Bader <=