extern int extra_keyboard_modifiers;
+/* The keysyms to use for the various modifiers. */
+
+static Lisp_Object Qalt, Qhyper, Qsuper, Qmodifier_value;
+
static Lisp_Object Qvendor_specific_keysyms;
#if 0
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_clip_to_row P_ ((struct window *, struct glyph_row *, int, 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 *));
Display *display; /* not used */
WindowPtr w;
unsigned int width, height;
- unsigned int depth; /* not used */
+ unsigned int depth;
{
Pixmap pixmap;
Rect r;
}
+#if 0 /* TODO: figure out if we need to do this on Mac. */
static void
mac_fill_rectangle_to_pixmap (display, p, gc, x, y, width, height)
Display *display;
SetGWorld (old_port, old_gdh);
}
+#endif
/* Mac replacement for XDrawRectangle: dest is a window. */
}
+#if 0 /* TODO: figure out if we need to do this on Mac. */
/* Mac replacement for XDrawRectangle: dest is a Pixmap. */
static void
SetGWorld (old_port, old_gdh);
}
+#endif
static void
int dest_x, dest_y;
{
#if TARGET_API_MAC_CARBON
- Rect gw_r, src_r, dest_r;
+ Rect src_r;
+ RgnHandle dummy = NewRgn (); /* For avoiding update events. */
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);
+ ScrollWindowRect (w, &src_r, dest_x - src_x, dest_y - src_y,
+ kScrollWindowNoOptions, dummy);
+ DisposeRgn (dummy);
#else /* not TARGET_API_MAC_CARBON */
Rect src_r, dest_r;
}
+#if 0 /* TODO: figure out if we need to do this on Mac. */
/* Mac replacement for XCopyArea: dest must be Pixmap. */
static void
SetGWorld (old_port, old_gdh);
}
+#endif
/* Mac replacement for XChangeGC. */
}
-/* 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
+static 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));
+ if (f)
+ QDFlushPortBuffer (GetWindowPort (FRAME_MAC_WINDOW (f)), NULL);
+ else
+ QDFlushPortBuffer (GetQDGlobalsThePort (), NULL);
UNBLOCK_INPUT;
-#endif /* TARGET_API_MAC_CARBON */
+#endif
}
+/* Remove calls to XFlush by defining XFlush to an empty replacement.
+ Calls to XFlush should be unnecessary because the X output buffer
+ is flushed automatically as needed by calls to XPending,
+ XNextEvent, or XWindowEvent according to the XFlush man page.
+ XTread_socket calls XPending. Removing XFlush improves
+ performance. */
+
+#define XFlush(DISPLAY) (void) 0
+
\f
/* Return the struct mac_display_info corresponding to DPY. There's
only one. */
output_cursor.vpos,
output_cursor.x, output_cursor.y);
- x_draw_vertical_border (w);
-
- draw_window_fringes (w);
+ if (draw_window_fringes (w, 1))
+ x_draw_vertical_border (w);
UNBLOCK_INPUT;
}
int oldVH = row->visible_height;
row->visible_height = p->h;
row->y -= rowY - p->y;
- x_clip_to_row (w, row, gc);
+ x_clip_to_row (w, row, -1, gc);
row->y = oldY;
row->visible_height = oldVH;
}
else
- x_clip_to_row (w, row, gc);
+ x_clip_to_row (w, row, -1, gc);
if (p->bx >= 0 && !p->overlay_p)
{
}
+/* We prefer not to use XDrawImageString (srcCopy text transfer mode)
+ on Mac OS X because:
+ - Screen is double-buffered. (In srcCopy mode, a text is drawn
+ into an offscreen graphics world first. So performance gain
+ cannot be expected.)
+ - It lowers rendering quality.
+ - Some fonts leave garbage on cursor movement. */
+
/* 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
}
else
#endif
+#if 0 /* defined(MAC_OS8)*/
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)
+#endif
{
x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
s->background_width,
for (i = 0; i < s->nchars; ++i)
char1b[i] = s->char2b[i].byte2;
+#if 0 /* defined(MAC_OS8) */
/* Draw text with XDrawString if background has already been
filled. Otherwise, use XDrawImageString. (Note that
XDrawImageString is usually faster than XDrawString.) Always
no chance that characters under a box cursor are invisible. */
if (s->for_overlaps_p
|| (s->background_filled_p && s->hl != DRAW_CURSOR))
+#endif
{
/* Draw characters with 16-bit or 8-bit functions. */
if (s->two_byte_p)
XDrawString (s->display, s->window, s->gc, x,
s->ybase - boff, char1b, s->nchars);
}
+#if 0 /* defined(MAC_OS8)*/
else
{
if (s->two_byte_p)
XDrawImageString (s->display, s->window, s->gc, x,
s->ybase - boff, char1b, s->nchars);
}
+#endif
}
}
if (s->img->pixmap)
{
+ x_set_glyph_string_clipping (s);
+
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);
- }
+ mac_copy_area_with_mask (s->display, s->img->pixmap, s->img->mask,
+ s->window, s->gc, s->slice.x, s->slice.y,
+ s->slice.width, s->slice.height, x, 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);
+ mac_copy_area (s->display, s->img->pixmap,
+ s->window, 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
}
+#if 0 /* TODO: figure out if we need to do this on Mac. */
/* Draw the foreground of image glyph string S to PIXMAP. */
static void
mac_draw_rectangle_to_pixmap (s->display, pixmap, s->gc, x, y,
s->slice.width - 1, s->slice.height - 1);
}
+#endif
/* Draw part of the background of glyph string S. X, Y, W, and H
if (s->slice.y == 0)
y += box_line_vwidth;
+#if 0 /* TODO: figure out if we need to do this on Mac. */
if (s->img->mask)
{
/* Create a pixmap as large as the glyph string. Fill it
}
}
else
+#endif
x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
s->background_filled_p = 1;
}
/* Draw the foreground. */
+#if 0 /* TODO: figure out if we need to do this on Mac. */
if (pixmap != 0)
{
x_draw_image_foreground_1 (s, pixmap);
XFreePixmap (s->display, pixmap);
}
else
+#endif
x_draw_image_foreground (s);
/* If we must draw a relief around the image, do it. */
mode lines must be clipped to the whole window. */
static void
-x_clip_to_row (w, row, gc)
+x_clip_to_row (w, row, area, gc)
struct window *w;
struct glyph_row *row;
+ int area;
GC gc;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
Rect clip_rect;
- int window_y, window_width;
+ int window_x, window_y, window_width;
- window_box (w, -1, 0, &window_y, &window_width, 0);
+ window_box (w, area, &window_x, &window_y, &window_width, 0);
- clip_rect.left = WINDOW_TO_FRAME_PIXEL_X (w, 0);
+ clip_rect.left = window_x;
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;
gc = dpyinfo->scratch_cursor_gc;
/* Set clipping, draw the rectangle, and reset clipping again. */
- x_clip_to_row (w, row, gc);
+ x_clip_to_row (w, row, TEXT_AREA, gc);
mac_draw_rectangle (dpy, FRAME_MAC_WINDOW (f), gc, x, y, wd, h);
mac_reset_clipping (dpy, FRAME_MAC_WINDOW (f));
}
width = min (cursor_glyph->pixel_width, width);
w->phys_cursor_width = width;
- x_clip_to_row (w, row, gc);
+ x_clip_to_row (w, row, TEXT_AREA, gc);
if (kind == BAR_CURSOR)
XFillRectangle (dpy, window, gc,
GetWindowBounds (FRAME_MAC_WINDOW (f), kWindowStructureRgn, outer);
#else /* not TARGET_API_MAC_CARBON */
RgnHandle region = NewRgn ();
-
+
GetWindowRegion (FRAME_MAC_WINDOW (f), kWindowContentRgn, region);
*inner = (*region)->rgnBBox;
GetWindowRegion (FRAME_MAC_WINDOW (f), kWindowStructureRgn, region);
{
Rect inner, outer, screen_rect, dummy;
RgnHandle region = NewRgn ();
-
+
mac_get_window_bounds (f, &inner, &outer);
f->x_pixels_diff = inner.left - outer.left;
f->y_pixels_diff = inner.top - outer.top;
struct frame *f;
{
if (f->async_visible)
- SelectWindow (FRAME_MAC_WINDOW (f));
+ {
+ BLOCK_INPUT;
+ SelectWindow (FRAME_MAC_WINDOW (f));
+ UNBLOCK_INPUT;
+ }
}
/* Lower frame F. */
struct frame *f;
{
if (f->async_visible)
- SendBehind (FRAME_MAC_WINDOW (f), nil);
+ {
+ BLOCK_INPUT;
+ SendBehind (FRAME_MAC_WINDOW (f), nil);
+ UNBLOCK_INPUT;
+ }
}
static void
static Lisp_Object Qbig5, Qcn_gb, Qsjis, Qeuc_kr;
static void
-decode_mac_font_name (char *name, int size, short scriptcode)
+decode_mac_font_name (name, size, scriptcode)
+ char *name;
+ int size;
+#if TARGET_API_MAC_CARBON
+ int scriptcode;
+#else
+ short scriptcode;
+#endif
{
Lisp_Object coding_system;
struct coding_system coding;
static char *
-mac_to_x_fontname (char *name, int size, Style style, short scriptcode)
+mac_to_x_fontname (name, size, style, scriptcode, encoding_base)
+ char *name;
+ int size;
+ Style style;
+#if TARGET_API_MAC_CARBON
+ int scriptcode;
+#else
+ short scriptcode;
+#endif
{
char foundry[32], family[32], cs[32];
char xf[256], *result, *p;
switch (scriptcode)
{
- case smTradChinese:
+ case smTradChinese: /* == kTextEncodingMacChineseTrad */
strcpy(cs, "big5-0");
break;
- case smSimpChinese:
+ case smSimpChinese: /* == kTextEncodingMacChineseSimp */
strcpy(cs, "gb2312.1980-0");
break;
- case smJapanese:
+ case smJapanese: /* == kTextEncodingMacJapanese */
strcpy(cs, "jisx0208.1983-sjis");
break;
case -smJapanese:
font is being built. */
strcpy(cs, "jisx0201.1976-0");
break;
- case smKorean:
+ case smKorean: /* == kTextEncodingMacKorean */
strcpy(cs, "ksc5601.1989-0");
break;
+#if TARGET_API_MAC_CARBON
+ case kTextEncodingMacCyrillic:
+ strcpy(cs, "mac-cyrillic");
+ break;
+ case kTextEncodingMacCentralEurRoman:
+ strcpy(cs, "mac-centraleurroman");
+ break;
+ case kTextEncodingMacSymbol:
+ case kTextEncodingMacDingbats:
+ strcpy(cs, "adobe-fontspecific");
+ break;
+#endif
default:
- strcpy(cs, "mac-roman");
- break;
+ strcpy(cs, "mac-roman");
+ break;
}
}
coding_system = Qsjis;
else if (strcmp (cs, "ksc5601.1989-0") == 0)
coding_system = Qeuc_kr;
- else if (strcmp (cs, "mac-roman") == 0)
+ else if (strcmp (cs, "mac-roman") == 0
+ || strcmp (cs, "mac-cyrillic") == 0
+ || strcmp (cs, "mac-centraleurroman") == 0
+ || strcmp (cs, "adobe-fontspecific") == 0)
strcpy (mf, family);
else
sprintf (mf, "%s-%s-%s", foundry, family, cs);
FMFont font;
FMFontStyle style;
FMFontSize size;
- SInt16 sc;
+ TextEncoding encoding;
+ TextEncodingBase sc;
if (FMGetFontFamilyName (ff, name) != noErr)
break;
if (*name == '.')
continue;
- sc = FontToScript (ff);
+ if (FMGetFontFamilyTextEncoding (ff, &encoding) != noErr)
+ break;
+ sc = GetTextEncodingBase (encoding);
decode_mac_font_name (name, sizeof (name), sc);
-
+
/* Point the instance iterator at the current font family. */
if (FMResetFontFamilyInstanceIterator (ff, &ffii) != noErr)
break;
-1
};
+static Lisp_Object
+mac_c_string_match (regexp, string, nonspecial, exact)
+ Lisp_Object regexp;
+ const char *string, *nonspecial;
+ int exact;
+{
+ if (exact)
+ {
+ if (strcmp (string, nonspecial) == 0)
+ return build_string (string);
+ }
+ else if (strstr (string, nonspecial))
+ {
+ Lisp_Object str = build_string (string);
+
+ if (fast_string_match (regexp, str) >= 0)
+ return str;
+ }
+
+ return Qnil;
+}
+
static Lisp_Object
mac_do_list_fonts (pattern, maxnames)
char *pattern;
char scaled[256];
char *ptr;
int scl_val[XLFD_SCL_LAST], *field, *val;
+ char *longest_start, *cur_start, *nonspecial;
+ int longest_len, cur_len, exact;
for (i = 0; i < XLFD_SCL_LAST; i++)
scl_val[i] = -1;
ptr = regex;
*ptr++ = '^';
- /* Turn pattern into a regexp and do a regexp match. */
+ longest_start = cur_start = ptr;
+ longest_len = cur_len = 0;
+ exact = 1;
+
+ /* Turn pattern into a regexp and do a regexp match. Also find the
+ longest substring containing no special characters. */
for (; *pattern; pattern++)
{
- if (*pattern == '?')
- *ptr++ = '.';
- else if (*pattern == '*')
- {
- *ptr++ = '.';
- *ptr++ = '*';
- }
+ if (*pattern == '?' || *pattern == '*')
+ {
+ if (cur_len > longest_len)
+ {
+ longest_start = cur_start;
+ longest_len = cur_len;
+ }
+ cur_len = 0;
+ exact = 0;
+
+ if (*pattern == '?')
+ *ptr++ = '.';
+ else /* if (*pattern == '*') */
+ {
+ *ptr++ = '.';
+ *ptr++ = '*';
+ }
+ }
else
- *ptr++ = tolower (*pattern);
+ {
+ if (cur_len == 0)
+ cur_start = ptr;
+ cur_len++;
+
+ *ptr++ = tolower (*pattern);
+ }
}
+
+ if (cur_len > longest_len)
+ {
+ longest_start = cur_start;
+ longest_len = cur_len;
+ }
+
*ptr = '$';
*(ptr + 1) = '\0';
+ nonspecial = xmalloc (longest_len + 1);
+ strncpy (nonspecial, longest_start, longest_len);
+ nonspecial[longest_len] = '\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)
+ fontname = mac_c_string_match (pattern_regex, font_name_table[i],
+ nonspecial, exact);
+ if (!NILP (fontname))
{
font_list = Fcons (fontname, font_list);
-
- n_fonts++;
- if (maxnames > 0 && n_fonts >= maxnames)
- break;
+ if (exact || 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-")))
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)
+ fontname = mac_c_string_match (pattern_regex, scaled,
+ nonspecial, exact);
+ if (!NILP (fontname))
{
font_list = Fcons (fontname, font_list);
-
- n_fonts++;
- if (maxnames > 0 && n_fonts >= maxnames)
+ if (exact || maxnames > 0 && ++n_fonts >= maxnames)
break;
}
}
}
+
+ xfree (nonspecial);
+
return font_list;
}
/* True if using command key as meta key. */
Lisp_Object Vmac_command_key_is_meta;
+/* Modifier associated with the option key, or nil for normal behavior. */
+Lisp_Object Vmac_option_modifier;
+
/* True if the ctrl and meta keys should be reversed. */
Lisp_Object Vmac_reverse_ctrl_meta;
result |= meta_modifier;
if (NILP (Vmac_command_key_is_meta) && (mods & macAltKey))
result |= alt_modifier;
+ if (!NILP (Vmac_option_modifier) && (mods & optionKey)) {
+ Lisp_Object val = Fget(Vmac_option_modifier, Qmodifier_value);
+ if (!NILP(val))
+ result |= XUINT(val);
+ }
+
return result;
}
switch (GetEventClass (eventRef))
{
case kEventClassWindow:
- if (GetEventKind (eventRef) == kEventWindowBoundsChanged)
+ if (GetEventKind (eventRef) == kEventWindowBoundsChanged)
{
WindowPtr window_ptr;
GetEventParameter(eventRef, kEventParamDirectObject,
if (!is_emacs_window (window_ptr))
break;
-
+
f = mac_window_to_frame (window_ptr);
if ((er.modifiers & activeFlag) != 0)
unsigned long some_state = 0;
inev.code = KeyTranslate (kchr_ptr, new_keycode,
&some_state) & 0xff;
- }
+ } else if (!NILP(Vmac_option_modifier) && (er.modifiers & optionKey))
+ {
+ /* When using the option key as an emacs modifier, convert
+ the pressed key code back to one without the Mac option
+ modifier applied. */
+ int new_modifiers = er.modifiers & ~optionKey;
+ 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;
{
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;
- }
+ unsigned char outbuf[32];
+
+ convert_status = TECConvertText (converter, &ch, 1,
+ &actual_input_length,
+ outbuf, 1,
+ &actual_output_length);
+ if (convert_status == noErr
+ && actual_input_length == 1
+ && actual_output_length == 1)
+ inev.code = *outbuf;
+
+ /* Reset internal states of the converter object.
+ If it fails, create another one. */
+ convert_status = TECFlushText (converter, outbuf,
+ sizeof (outbuf),
+ &actual_output_length);
+ if (convert_status != noErr)
+ {
+ TECDisposeConverter (converter);
+ TECCreateConverter (&converter,
+ kTextEncodingMacRoman,
+ mac_keyboard_text_encoding);
+ }
+ }
}
#if USE_CARBON_EVENTS
mwp = fp->output_data.mac;
+ BLOCK_INPUT;
if (making_terminal_window)
{
if (!(mwp->mWP = GetNewCWindow (TERM_WINDOW_RESOURCE, NULL,
/* 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);
+ UNBLOCK_INPUT;
}
x_update_window_end,
x_cursor_to,
x_flush,
- x_flush,
+ 0, /* flush_display_optional */
x_clear_window_mouse_face,
x_get_glyph_overhangs,
x_fix_overlapping_area,
signal (SIGPIPE, x_connection_signal);
#endif
+ BLOCK_INPUT;
mac_initialize_display_info ();
#if TARGET_API_MAC_CARBON
if (!inhibit_window_system)
MakeMeTheFrontProcess ();
#endif
+ UNBLOCK_INPUT;
}
x_error_message_string = Qnil;
#endif
+ Qmodifier_value = intern ("modifier-value");
+ Qalt = intern ("alt");
+ Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
+ Qhyper = intern ("hyper");
+ Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
+ Qsuper = intern ("super");
+ Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
+
Fprovide (intern ("mac-carbon"), Qnil);
staticpro (&Qreverse);
Otherwise the option key is used. */);
Vmac_command_key_is_meta = Qt;
+ DEFVAR_LISP ("mac-option-modifier", &Vmac_option_modifier,
+ doc: /* Modifier to use for the Mac alt/option key. The value can
+be alt, hyper, or super for the respective modifier. If the value is
+nil then the key will act as the normal Mac option modifier. */);
+ Vmac_option_modifier = Qnil;
+
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. */);
HCoop / bpt / emacs.git / blobdiff