Merged in changes from CVS trunk.

Patches applied:

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-667
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-668
   Merge from gnus--rel--5.10

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-669
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-670
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-157
   Merge from emacs--cvs-trunk--0

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-158
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-159
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-160
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-161
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-162
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-163
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-164
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-165
   Update from CVS: texi/message.texi: Fix default values.

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-166
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-167
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-168
   Update from CVS


git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-448

12 files changed, 1036 insertions, 504 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 4fa4093631f..4994e7e8d6a 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,100 @@
+2005-12-11  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * emacs.c (main) [MAC_OS8]: Undo previous change.
+
+        * macselect.c (syms_of_macselect) <mac-apple-event-map>:
+        Initialize to nil.  Keymap is now created in lisp/term/mac-win.el.
+
+2005-12-10  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * Makefile.in (macselect.o): Depend on keymap.h.
+
+        * emacs.c (main) [MAC_OS8]: Call syms_of_keymap before
+        syms_of_macselect.
+
+        * image.c (init_image) [MAC_OS]: Don't call EnterMovies.
+        [!HAVE_GIF && MAC_OS] (gif_load): Call EnterMovies.
+
+        * keyboard.c (Qmac_apple_event) [MAC_OS]: New variable.
+        (syms_of_keyboard) [MAC_OS]: Initialize it.
+        (make_lispy_event) [MAC_OS]: Build lisp event for MAC_APPLE_EVENT.
+
+        * mac.c (Qundecoded_file_name): New variable.
+        (syms_of_mac): Initialize it.
+        (mac_aelist_to_lisp, mac_aedesc_to_lisp): New functions.
+        [TARGET_API_MAC_CARBON] (create_apple_event_from_event_ref): New
+        function.
+        (Fmac_coerce_ae_data): New defun.
+        (syms_of_mac): Defsubr it.
+
+        * macselect.c: Include keymap.h.
+        (mac_ready_for_apple_events): New variable.
+        (Vmac_apple_event_map, Qmac_apple_event_class)
+        (Qmac_apple_event_id): New variables.
+        (syms_of_macselect): Initialize them.
+        (Qundefined, mac_store_apple_event): Add externs.
+        (struct apple_event_binding): New struct.
+        (find_event_binding_fun, find_event_binding)
+        (mac_find_apple_event_spec, defer_apple_events)
+        (mac_handle_apple_event, init_apple_event_handler)
+        (copy_scrap_flavor_data): New functions.
+        (Fmac_process_deferred_apple_events): New defun.
+        (syms_of_macselect): Defsubr it.
+        (mac_store_services_event): Fix extern.
+        (mac_handle_service_event): Don't allocate Lisp objects during
+        asynchronous input processing.  Use mac_store_services_event
+        instead of mac_store_application_menu_event.
+
+        * macterm.c (Qmac_ready_for_drag_n_drop, Qapplication, Qabout)
+        (Qpreferences): Remove variables.
+        (syms_of_macterm) : Don't initialize them.
+        (Qhicommand) [USE_CARBON_EVENTS]: New variable.
+        (syms_of_macterm) [USE_CARBON_EVENTS]: Initialize it.
+        (init_required_apple_events, do_ae_open_application)
+        (do_ae_print_documents, do_ae_open_documents)
+        (do_ae_quit_application): Remove functions and prototypes.
+        (mac_ready_for_apple_events, Qundefined, init_apple_event_handler)
+        (mac_find_apple_event_spec): Add externs.
+        (mac_store_application_menu_event): Remove function.
+        (mac_store_apple_event, mac_make_lispy_event_code): New functions.
+        (mac_handle_command_event): Create Apple event from Carbon event.
+        Use mac_store_apple_event instead of mac_store_application_menu_event.
+        [MAC_OSX] (mac_store_services_event): Likewise.
+        (struct SelectionRange, SelectionRange): Remove struct and typedef.
+        [MAC_OS8] (main): Call init_apple_event_handler instead of
+        init_required_apple_events.
+        (mac_initialize) [MAC_OSX]: Likewise.
+        [!USE_CARBON_EVENTS] (mac_wait_next_event): Use
+        mac_ready_for_apple_events instead of Qmac_ready_for_drag_n_drop.
+
+        * macterm.h (mac_make_lispy_event_code, mac_aedesc_to_lisp): Add
+        externs.
+        (create_apple_event_from_event_ref) [TARGET_API_MAC_CARBON]: Likewise.
+        (Fmac_get_preference): Add EXFUN.
+
+        * termhooks.h (enum event_kind) [MAC_OS]: Add new MAC_APPLE_EVENT
+        event.
+
+2005-12-09  Richard M. Stallman  <rms@gnu.org>
+
+        * xfns.c (Fx_create_frame): Reinstate previous change.
+
+2005-12-09  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c (w32_abort) [__GNUC__]: Add instructions for attaching
+        GDB to the abort dialog.
+
+2005-12-09  Kyotaro HORIGUCHI <horiguti@meadowy.org>  (tiny change)
+
+        * indent.c (Fvertical_motion): Force move if starting on
+        stretch glyph.
+
+2005-12-08  Richard M. Stallman  <rms@gnu.org>
+
+        * lread.c (read_escape) <\s>: Don't treat strings specially.
+
+        * xfns.c (Fx_create_frame): Comment out previous change.
+
 2005-12-07  L$,1 q(Brentey K,Aa(Broly  <lorentey@elte.hu>
 
         * xfns.c (Fx_create_frame): Initialize Vdefault_minibuffer_frame,
diff --git a/src/Makefile.in b/src/Makefile.in
index 7c9203d11ff..2799b3ff46b 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -1261,7 +1261,7 @@ macterm.o: blockinput.h atimer.h systime.h syssignal.h macterm.h macgui.h \
   frame.h charset.h ccl.h dispextern.h fontset.h termhooks.h termopts.h \
   termchar.h gnu.h disptab.h buffer.h window.h keyboard.h $(INTERVAL_SRC) \
   process.h coding.h $(config_h)
-macselect.o: blockinput.h macterm.h macgui.h frame.h $(config_h)
+macselect.o: blockinput.h macterm.h macgui.h frame.h keymap.h $(config_h)
 
 ${emacsapp}Contents/Resources/English.lproj:
         mkdir -p $@
diff --git a/src/image.c b/src/image.c
index d020b2ac394..8a6d40ae34f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -7778,6 +7778,9 @@ gif_load (f, img)
   specified_file = image_spec_value (img->spec, QCfile, NULL);
   specified_data = image_spec_value (img->spec, QCdata, NULL);
 
+  /* Animated gifs use QuickTime Movie Toolbox.  So initialize it here. */
+  EnterMovies ();
+
   if (NILP (specified_data))
     {
       /* Read from a file */
@@ -8500,14 +8503,9 @@ meaning don't clear the cache.  */);
 void
 init_image ()
 {
-#ifdef MAC_OS
-  /* Animated gifs use QuickTime Movie Toolbox.  So initialize it here. */
-  if (!inhibit_window_system)
-    EnterMovies ();
-#ifdef MAC_OSX
+#if defined (MAC_OSX) && TARGET_API_MAC_CARBON
   init_image_func_pointer ();
 #endif
-#endif
 }
 
 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
diff --git a/src/indent.c b/src/indent.c
index 68544e8059d..6ca15c67345 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -2076,7 +2076,7 @@ whether or not it is currently displayed in some window.  */)
     {
       int it_start;
       int oselective;
-      int start_on_image_p;
+      int start_on_image_or_stretch_p;
 
       SET_TEXT_POS (pt, PT, PT_BYTE);
       start_display (&it, w, pt);
@@ -2088,7 +2088,8 @@ whether or not it is currently displayed in some window.  */)
          while the end position is really at some X > 0, the same X that
          PT had.  */
       it_start = IT_CHARPOS (it);
-      start_on_image_p = (it.method == GET_FROM_IMAGE);
+      start_on_image_or_stretch_p = (it.method == GET_FROM_IMAGE
+                                     || it.method == GET_FROM_STRETCH);
       reseat_at_previous_visible_line_start (&it);
       it.current_x = it.hpos = 0;
       /* Temporarily disable selective display so we don't move too far */
@@ -2099,9 +2100,10 @@ whether or not it is currently displayed in some window.  */)
 
       /* Move back if we got too far.  This may happen if
          truncate-lines is on and PT is beyond right margin.
-         It may also happen if it_start is on an image --
-         in that case, don't go back.  */
-      if (IT_CHARPOS (it) > it_start && XINT (lines) > 0 && !start_on_image_p)
+         It may also happen if it_start is on an image or a stretch
+         glyph -- in that case, don't go back.  */
+      if (IT_CHARPOS (it) > it_start && XINT (lines) > 0
+          && !start_on_image_or_stretch_p)
         move_it_by_lines (&it, -1, 0);
 
       it.vpos = 0;
diff --git a/src/keyboard.c b/src/keyboard.c
index 7a918608dd7..51b59432214 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -514,6 +514,9 @@ Lisp_Object Qlanguage_change;
 #endif
 Lisp_Object Qdrag_n_drop;
 Lisp_Object Qsave_session;
+#ifdef MAC_OS
+Lisp_Object Qmac_apple_event;
+#endif
 
 /* Lisp_Object Qmouse_movement; - also an event header */
 
@@ -5915,6 +5918,20 @@ make_lispy_event (event)
     case SAVE_SESSION_EVENT:
       return Qsave_session;
 
+#ifdef MAC_OS
+    case MAC_APPLE_EVENT:
+      {
+        Lisp_Object spec[2];
+
+        spec[0] = event->x;
+        spec[1] = event->y;
+        return Fcons (Qmac_apple_event,
+                      Fcons (Fvector (2, spec),
+                             Fcons (mac_make_lispy_event_code (event->code),
+                                    Qnil)));
+      }
+#endif
+
       /* The 'kind' field of the event is something we don't recognize.  */
     default:
       abort ();
@@ -11074,6 +11091,11 @@ syms_of_keyboard ()
   Qsave_session = intern ("save-session");
   staticpro (&Qsave_session);
 
+#ifdef MAC_OS
+  Qmac_apple_event = intern ("mac-apple-event");
+  staticpro (&Qmac_apple_event);
+#endif
+
   Qusr1_signal = intern ("usr1-signal");
   staticpro (&Qusr1_signal);
   Qusr2_signal = intern ("usr2-signal");
diff --git a/src/lread.c b/src/lread.c
index 234fbe6e395..e6f1987a50b 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1739,13 +1739,12 @@ read_escape (readcharfun, stringp, byterep)
       return c | alt_modifier;
 
     case 's':
-      if (stringp)
-        return ' ';
       c = READCHAR;
-      if (c != '-') {
-        UNREAD (c);
-        return ' ';
-      }
+      if (c != '-')
+        {
+          UNREAD (c);
+          return ' ';
+        }
       c = READCHAR;
       if (c == '\\')
         c = read_escape (readcharfun, 0, byterep);
diff --git a/src/mac.c b/src/mac.c
index 76ba3d41798..1d306c429d7 100644
--- a/src/mac.c
+++ b/src/mac.c
@@ -259,6 +259,216 @@ posix_to_mac_pathname (const char *ufn, char *mfn, int mfnbuflen)
 
 
 /***********************************************************************
+                  Conversions on Apple event objects
+ ***********************************************************************/
+
+static Lisp_Object Qundecoded_file_name;
+
+static Lisp_Object
+mac_aelist_to_lisp (desc_list)
+     AEDescList *desc_list;
+{
+  OSErr err;
+  long count;
+  Lisp_Object result, elem;
+  DescType desc_type;
+  Size size;
+  AEKeyword keyword;
+  AEDesc desc;
+
+  err = AECountItems (desc_list, &count);
+  if (err != noErr)
+    return Qnil;
+  result = Qnil;
+  while (count > 0)
+    {
+      err = AESizeOfNthItem (desc_list, count, &desc_type, &size);
+      if (err == noErr)
+        switch (desc_type)
+          {
+          case typeAEList:
+          case typeAERecord:
+          case typeAppleEvent:
+            err = AEGetNthDesc (desc_list, count, typeWildCard,
+                                &keyword, &desc);
+            if (err != noErr)
+              break;
+            elem = mac_aelist_to_lisp (&desc);
+            AEDisposeDesc (&desc);
+            break;
+
+          default:
+            if (desc_type == typeNull)
+              elem = Qnil;
+            else
+              {
+                elem = make_uninit_string (size);
+                err = AEGetNthPtr (desc_list, count, typeWildCard, &keyword,
+                                   &desc_type, SDATA (elem), size, &size);
+              }
+            if (err != noErr)
+              break;
+            desc_type = EndianU32_NtoB (desc_type);
+            elem = Fcons (make_unibyte_string ((char *) &desc_type, 4), elem);
+            break;
+        }
+
+      if (err != noErr)
+        elem = Qnil;
+      else if (desc_list->descriptorType != typeAEList)
+        {
+          keyword = EndianU32_NtoB (keyword);
+          elem = Fcons (make_unibyte_string ((char *) &keyword, 4), elem);
+        }
+
+      result = Fcons (elem, result);
+      count--;
+    }
+
+  desc_type = EndianU32_NtoB (desc_list->descriptorType);
+  return Fcons (make_unibyte_string ((char *) &desc_type, 4), result);
+}
+
+Lisp_Object
+mac_aedesc_to_lisp (desc)
+     AEDesc *desc;
+{
+  OSErr err;
+  DescType desc_type = desc->descriptorType;
+  Lisp_Object result;
+
+  switch (desc_type)
+    {
+    case typeNull:
+      result = Qnil;
+      break;
+
+    case typeAEList:
+    case typeAERecord:
+    case typeAppleEvent:
+      return mac_aelist_to_lisp (desc);
+#if 0
+      /* The following one is much simpler, but creates and disposes
+         of Apple event descriptors many times.  */
+      {
+        long count;
+        Lisp_Object elem;
+        AEKeyword keyword;
+        AEDesc desc1;
+
+        err = AECountItems (desc, &count);
+        if (err != noErr)
+          break;
+        result = Qnil;
+        while (count > 0)
+          {
+            err = AEGetNthDesc (desc, count, typeWildCard, &keyword, &desc1);
+            if (err != noErr)
+              break;
+            elem = mac_aedesc_to_lisp (&desc1);
+            AEDisposeDesc (&desc1);
+            if (desc_type != typeAEList)
+              {
+                keyword = EndianU32_NtoB (keyword);
+                elem = Fcons (make_unibyte_string ((char *) &keyword, 4), elem);
+              }
+            result = Fcons (elem, result);
+            count--;
+          }
+      }
+#endif
+      break;
+
+    default:
+#if TARGET_API_MAC_CARBON
+      result = make_uninit_string (AEGetDescDataSize (desc));
+      err = AEGetDescData (desc, SDATA (result), SBYTES (result));
+#else
+      result = make_uninit_string (GetHandleSize (desc->dataHandle));
+      memcpy (SDATA (result), *(desc->dataHandle), SBYTES (result));
+#endif
+      break;
+    }
+
+  if (err != noErr)
+    return Qnil;
+
+  desc_type = EndianU32_NtoB (desc_type);
+  return Fcons (make_unibyte_string ((char *) &desc_type, 4), result);
+}
+
+#if TARGET_API_MAC_CARBON
+OSErr
+create_apple_event_from_event_ref (event, num_params, names,
+                                   types, sizes, result)
+     EventRef event;
+     UInt32 num_params;
+     EventParamName *names;
+     EventParamType *types;
+     UInt32 *sizes;
+     AppleEvent *result;
+{
+  OSErr err;
+  static const ProcessSerialNumber psn = {0, kCurrentProcess};
+  AEAddressDesc address_desc;
+  UInt32 i;
+  CFStringRef string;
+  CFDataRef data;
+  char *buf;
+
+  err = AECreateDesc (typeProcessSerialNumber, &psn,
+                      sizeof (ProcessSerialNumber), &address_desc);
+  if (err == noErr)
+    {
+      err = AECreateAppleEvent (0, 0, /* Dummy class and ID.   */
+                                &address_desc, /* NULL is not allowed
+                                                  on Mac OS Classic. */
+                                kAutoGenerateReturnID,
+                                kAnyTransactionID, result);
+      AEDisposeDesc (&address_desc);
+    }
+  if (err != noErr)
+    return err;
+
+  for (i = 0; i < num_params; i++)
+    switch (types[i])
+      {
+#ifdef MAC_OSX
+      case typeCFStringRef:
+        err = GetEventParameter (event, names[i], typeCFStringRef, NULL,
+                                 sizeof (CFStringRef), NULL, &string);
+        if (err != noErr)
+          break;
+        data = CFStringCreateExternalRepresentation (NULL, string,
+                                                     kCFStringEncodingUTF8,
+                                                     '?');
+        if (data == NULL)
+          break;
+        /* typeUTF8Text is not available on Mac OS X 10.1.  */
+        AEPutParamPtr (result, names[i], 'utf8',
+                       CFDataGetBytePtr (data), CFDataGetLength (data));
+        CFRelease (data);
+        break;
+#endif
+
+      default:
+        buf = xmalloc (sizes[i]);
+        if (buf == NULL)
+          break;
+        err = GetEventParameter (event, names[i], types[i], NULL,
+                                 sizes[i], NULL, buf);
+        if (err == noErr)
+          AEPutParamPtr (result, names[i], types[i], buf, sizes[i]);
+        xfree (buf);
+        break;
+      }
+
+  return noErr;
+}
+#endif
+
+
+/***********************************************************************
          Conversion between Lisp and Core Foundation objects
  ***********************************************************************/
 
@@ -3887,6 +4097,116 @@ DEFUN ("posix-file-name-to-mac", Fposix_file_name_to_mac,
 }
 
 
+DEFUN ("mac-coerce-ae-data", Fmac_coerce_ae_data, Smac_coerce_ae_data, 3, 3, 0,
+       doc: /* Coerce Apple event data SRC-DATA of type SRC-TYPE to DST-TYPE.
+Each type should be a string of length 4 or the symbol
+`undecoded-file-name'.  */)
+  (src_type, src_data, dst_type)
+     Lisp_Object src_type, src_data, dst_type;
+{
+  OSErr err;
+  Lisp_Object result = Qnil;
+  DescType src_desc_type, dst_desc_type;
+  AEDesc dst_desc;
+#ifdef MAC_OSX
+  FSRef fref;
+#else
+  FSSpec fs;
+#endif
+
+  CHECK_STRING (src_data);
+  if (EQ (src_type, Qundecoded_file_name))
+    {
+#ifdef MAC_OSX
+      src_desc_type = typeFileURL;
+#else
+      src_desc_type = typeFSS;
+#endif
+    }
+  else
+    src_desc_type = mac_get_code_from_arg (src_type, 0);
+
+  if (EQ (dst_type, Qundecoded_file_name))
+    {
+#ifdef MAC_OSX
+    dst_desc_type = typeFSRef;
+#else
+    dst_desc_type = typeFSS;
+#endif
+    }
+  else
+    dst_desc_type = mac_get_code_from_arg (dst_type, 0);
+
+  BLOCK_INPUT;
+  if (EQ (src_type, Qundecoded_file_name))
+    {
+#ifdef MAC_OSX
+      CFStringRef str;
+      CFURLRef url = NULL;
+      CFDataRef data = NULL;
+
+      str = cfstring_create_with_utf8_cstring (SDATA (src_data));
+      if (str)
+        {
+          url = CFURLCreateWithFileSystemPath (NULL, str,
+                                               kCFURLPOSIXPathStyle, false);
+          CFRelease (str);
+        }
+      if (url)
+        {
+          data = CFURLCreateData (NULL, url, kCFStringEncodingUTF8, true);
+          CFRelease (url);
+        }
+      if (data)
+        err = AECoercePtr (src_desc_type, CFDataGetBytePtr (data),
+                           CFDataGetLength (data),
+                           dst_desc_type, &dst_desc);
+      else
+        err = memFullErr;
+#else
+      err = posix_pathname_to_fsspec (SDATA (src_data), &fs);
+      if (err == noErr)
+        AECoercePtr (src_desc_type, &fs, sizeof (FSSpec),
+                     dst_desc_type, &dst_desc);
+#endif
+    }
+  else
+    err = AECoercePtr (src_desc_type, SDATA (src_data), SBYTES (src_data),
+                       dst_desc_type, &dst_desc);
+
+  if (err == noErr)
+    {
+      if (EQ (dst_type, Qundecoded_file_name))
+        {
+          char file_name[MAXPATHLEN];
+
+#ifdef MAC_OSX
+          err = AEGetDescData (&dst_desc, &fref, sizeof (FSRef));
+          if (err == noErr)
+            err = FSRefMakePath (&fref, file_name, sizeof (file_name));
+#else
+#if TARGET_API_MAC_CARBON
+          err = AEGetDescData (&dst_desc, &fs, sizeof (FSSpec));
+#else
+          memcpy (&fs, *(dst_desc.dataHandle), sizeof (FSSpec));
+#endif
+          if (err == noErr)
+            err = fsspec_to_posix_pathname (&fs, file_name,
+                                            sizeof (file_name) - 1);
+#endif
+          if (err == noErr)
+            result = make_unibyte_string (file_name, strlen (file_name));
+        }
+      else
+        result = Fcdr (mac_aedesc_to_lisp (&dst_desc));
+      AEDisposeDesc (&dst_desc);
+    }
+  UNBLOCK_INPUT;
+
+  return result;
+}
+
+
 #if TARGET_API_MAC_CARBON
 static Lisp_Object Qxml, Qmime_charset;
 static Lisp_Object QNFD, QNFKD, QNFC, QNFKC, QHFS_plus_D, QHFS_plus_C;
@@ -4676,6 +4996,9 @@ init_mac_osx_environment ()
 void
 syms_of_mac ()
 {
+  Qundecoded_file_name = intern ("undecoded-file-name");
+  staticpro (&Qundecoded_file_name);
+
 #if TARGET_API_MAC_CARBON
   Qstring  = intern ("string");         staticpro (&Qstring);
   Qnumber  = intern ("number");         staticpro (&Qnumber);
@@ -4699,6 +5022,7 @@ syms_of_mac ()
   QHFS_plus_C = intern ("HFS+C");       staticpro (&QHFS_plus_C);
 #endif
 
+  defsubr (&Smac_coerce_ae_data);
 #if TARGET_API_MAC_CARBON
   defsubr (&Smac_get_preference);
   defsubr (&Smac_code_convert_string);
diff --git a/src/macselect.c b/src/macselect.c
index 63221ba3a90..066892adce0 100644
--- a/src/macselect.c
+++ b/src/macselect.c
@@ -23,6 +23,7 @@ Boston, MA 02110-1301, USA.  */
 #include "lisp.h"
 #include "macterm.h"
 #include "blockinput.h"
+#include "keymap.h"
 
 #if !TARGET_API_MAC_CARBON
 #include <Endian.h>
@@ -908,6 +909,253 @@ and t is the same as `SECONDARY'.  */)
 }
 
 
+int mac_ready_for_apple_events = 0;
+static Lisp_Object Vmac_apple_event_map;
+static Lisp_Object Qmac_apple_event_class, Qmac_apple_event_id;
+static struct
+{
+  AppleEvent *buf;
+  int size, count;
+} deferred_apple_events;
+extern Lisp_Object Qundefined;
+extern OSErr mac_store_apple_event P_ ((Lisp_Object, Lisp_Object,
+                                        const AEDesc *));
+
+struct apple_event_binding
+{
+  UInt32 code;                  /* Apple event class or ID.  */
+  Lisp_Object key, binding;
+};
+
+static void
+find_event_binding_fun (key, binding, args, data)
+     Lisp_Object key, binding, args;
+     void *data;
+{
+  struct apple_event_binding *event_binding =
+    (struct apple_event_binding *)data;
+  Lisp_Object code_string;
+
+  if (!SYMBOLP (key))
+    return;
+  code_string = Fget (key, args);
+  if (STRINGP (code_string) && SBYTES (code_string) == 4
+      && (EndianU32_BtoN (*((UInt32 *) SDATA (code_string)))
+          == event_binding->code))
+    {
+      event_binding->key = key;
+      event_binding->binding = binding;
+    }
+}
+
+static void
+find_event_binding (keymap, event_binding, class_p)
+     Lisp_Object keymap;
+     struct apple_event_binding *event_binding;
+     int class_p;
+{
+  if (event_binding->code == 0)
+    event_binding->binding =
+      access_keymap (keymap, event_binding->key, 0, 1, 0);
+  else
+    {
+      event_binding->binding = Qnil;
+      map_keymap (keymap, find_event_binding_fun,
+                  class_p ? Qmac_apple_event_class : Qmac_apple_event_id,
+                  event_binding, 0);
+    }
+}
+
+void
+mac_find_apple_event_spec (class, id, class_key, id_key, binding)
+     AEEventClass class;
+     AEEventID id;
+     Lisp_Object *class_key, *id_key, *binding;
+{
+  struct apple_event_binding event_binding;
+  Lisp_Object keymap;
+
+  *binding = Qnil;
+
+  keymap = get_keymap (Vmac_apple_event_map, 0, 0);
+  if (NILP (keymap))
+    return;
+
+  event_binding.code = class;
+  event_binding.key = *class_key;
+  event_binding.binding = Qnil;
+  find_event_binding (keymap, &event_binding, 1);
+  *class_key = event_binding.key;
+  keymap = get_keymap (event_binding.binding, 0, 0);
+  if (NILP (keymap))
+    return;
+
+  event_binding.code = id;
+  event_binding.key = *id_key;
+  event_binding.binding = Qnil;
+  find_event_binding (keymap, &event_binding, 0);
+  *id_key = event_binding.key;
+  *binding = event_binding.binding;
+}
+
+static OSErr
+defer_apple_events (apple_event, reply)
+     const AppleEvent *apple_event, *reply;
+{
+  OSErr err;
+
+  err = AESuspendTheCurrentEvent (apple_event);
+
+  /* Mac OS 10.3 Xcode manual says AESuspendTheCurrentEvent makes
+     copies of the Apple event and the reply, but Mac OS 10.4 Xcode
+     manual says it doesn't.  Anyway we create copies of them and save
+     it in `deferred_apple_events'.  */
+  if (err == noErr)
+    {
+      if (deferred_apple_events.buf == NULL)
+        {
+          deferred_apple_events.size = 16;
+          deferred_apple_events.count = 0;
+          deferred_apple_events.buf =
+            xmalloc (sizeof (AppleEvent) * deferred_apple_events.size);
+          if (deferred_apple_events.buf == NULL)
+            err = memFullErr;
+        }
+      else if (deferred_apple_events.count == deferred_apple_events.size)
+        {
+          AppleEvent *newbuf;
+
+          deferred_apple_events.size *= 2;
+          newbuf = xrealloc (deferred_apple_events.buf,
+                             sizeof (AppleEvent) * deferred_apple_events.size);
+          if (newbuf)
+            deferred_apple_events.buf = newbuf;
+          else
+            err = memFullErr;
+        }
+    }
+
+  if (err == noErr)
+    {
+      int count = deferred_apple_events.count;
+
+      AEDuplicateDesc (apple_event, deferred_apple_events.buf + count);
+      AEDuplicateDesc (reply, deferred_apple_events.buf + count + 1);
+      deferred_apple_events.count += 2;
+    }
+
+  return err;
+}
+
+static pascal OSErr
+mac_handle_apple_event (apple_event, reply, refcon)
+     const AppleEvent *apple_event;
+     AppleEvent *reply;
+     SInt32 refcon;
+{
+  OSErr err;
+  AEEventClass event_class;
+  AEEventID event_id;
+  Lisp_Object class_key, id_key, binding;
+
+  /* We can't handle an Apple event that requests a reply, but this
+     seems to be too restrictive.  */
+#if 0
+  if (reply->descriptorType != typeNull)
+    return errAEEventNotHandled;
+#endif
+
+  if (!mac_ready_for_apple_events)
+    {
+      err = defer_apple_events (apple_event, reply);
+      if (err != noErr)
+        return errAEEventNotHandled;
+      return noErr;
+    }
+
+  err = AEGetAttributePtr (apple_event, keyEventClassAttr, typeType, NULL,
+                           &event_class, sizeof (AEEventClass), NULL);
+  if (err == noErr)
+    err = AEGetAttributePtr (apple_event, keyEventIDAttr, typeType, NULL,
+                             &event_id, sizeof (AEEventID), NULL);
+  if (err == noErr)
+    {
+      mac_find_apple_event_spec (event_class, event_id,
+                                 &class_key, &id_key, &binding);
+      if (!NILP (binding) && !EQ (binding, Qundefined))
+        {
+          if (INTEGERP (binding))
+            return XINT (binding);
+          err = mac_store_apple_event (class_key, id_key, apple_event);
+          if (err == noErr)
+            return noErr;
+        }
+    }
+  return errAEEventNotHandled;
+}
+
+void
+init_apple_event_handler ()
+{
+  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 ();
+
+  err = AEInstallEventHandler (typeWildCard, typeWildCard,
+#if TARGET_API_MAC_CARBON
+                               NewAEEventHandlerUPP (mac_handle_apple_event),
+#else
+                               NewAEEventHandlerProc (mac_handle_apple_event),
+#endif
+                               0L, false);
+  if (err != noErr)
+    abort ();
+}
+
+DEFUN ("mac-process-deferred-apple-events", Fmac_process_deferred_apple_events, Smac_process_deferred_apple_events, 0, 0, 0,
+       doc: /* Process Apple events that are deferred at the startup time.  */)
+  ()
+{
+  OSErr err;
+  Lisp_Object result = Qnil;
+  long i, count;
+  AppleEvent apple_event, reply;
+  AEKeyword keyword;
+
+  if (mac_ready_for_apple_events)
+    return Qnil;
+
+  BLOCK_INPUT;
+  mac_ready_for_apple_events = 1;
+  if (deferred_apple_events.buf)
+    {
+      for (i = 0; i < deferred_apple_events.count; i += 2)
+        {
+          AEResumeTheCurrentEvent (deferred_apple_events.buf + i,
+                                   deferred_apple_events.buf + i + 1,
+                                   ((AEEventHandlerUPP)
+                                    kAEUseStandardDispatch), 0);
+          AEDisposeDesc (deferred_apple_events.buf + i);
+          AEDisposeDesc (deferred_apple_events.buf + i + 1);
+        }
+      xfree (deferred_apple_events.buf);
+      bzero (&deferred_apple_events, sizeof (deferred_apple_events));
+
+      result = Qt;
+    }
+  UNBLOCK_INPUT;
+
+  return result;
+}
+
+
 #ifdef MAC_OSX
 void
 init_service_handler ()
@@ -920,7 +1168,56 @@ init_service_handler ()
                                   GetEventTypeCount (specs), specs, NULL, NULL);
 }
 
-extern void mac_store_services_event P_ ((EventRef));
+extern OSErr mac_store_services_event P_ ((EventRef));
+
+static OSStatus
+copy_scrap_flavor_data (from_scrap, to_scrap, flavor_type)
+     ScrapRef from_scrap, to_scrap;
+     ScrapFlavorType flavor_type;
+{
+  OSStatus err;
+  Size size, size_allocated;
+  char *buf = NULL;
+
+  err = GetScrapFlavorSize (from_scrap, flavor_type, &size);
+  if (err == noErr)
+    buf = xmalloc (size);
+  while (buf)
+    {
+      size_allocated = size;
+      err = GetScrapFlavorData (from_scrap, flavor_type, &size, buf);
+      if (err != noErr)
+        {
+          xfree (buf);
+          buf = NULL;
+        }
+      else if (size_allocated < size)
+        {
+          char *newbuf = xrealloc (buf, size);
+
+          if (newbuf)
+            buf = newbuf;
+          else
+            {
+              xfree (buf);
+              buf = NULL;
+            }
+        }
+      else
+        break;
+    }
+  if (err == noErr)
+    if (buf == NULL)
+      err = memFullErr;
+    else
+      {
+        err = PutScrapFlavor (to_scrap, flavor_type, kScrapFlavorMaskNone,
+                              size, buf);
+        xfree (buf);
+      }
+
+  return err;
+}
 
 static OSStatus
 mac_handle_service_event (call_ref, event, data)
@@ -929,7 +1226,12 @@ mac_handle_service_event (call_ref, event, data)
      void *data;
 {
   OSStatus err = noErr;
-  ScrapRef cur_scrap;
+  ScrapRef cur_scrap, specific_scrap;
+  UInt32 event_kind = GetEventKind (event);
+  CFMutableArrayRef copy_types, paste_types;
+  CFStringRef type;
+  Lisp_Object rest;
+  ScrapFlavorType flavor_type;
 
   /* Check if Vmac_services_selection is a valid selection that has a
      corresponding scrap.  */
@@ -940,86 +1242,103 @@ mac_handle_service_event (call_ref, event, data)
   if (!(err == noErr && cur_scrap))
     return eventNotHandledErr;
 
-  switch (GetEventKind (event))
+  switch (event_kind)
     {
     case kEventServiceGetTypes:
-      {
-        CFMutableArrayRef copy_types, paste_types;
-        CFStringRef type;
-        Lisp_Object rest;
-        ScrapFlavorType flavor_type;
-
-        /* Set paste types. */
-        err = GetEventParameter (event, kEventParamServicePasteTypes,
-                                 typeCFMutableArrayRef, NULL,
-                                 sizeof (CFMutableArrayRef), NULL,
-                                 &paste_types);
-        if (err == noErr)
-          for (rest = Vselection_converter_alist; CONSP (rest);
-               rest = XCDR (rest))
-            if (CONSP (XCAR (rest)) && SYMBOLP (XCAR (XCAR (rest)))
-                && (flavor_type =
-                    get_flavor_type_from_symbol (XCAR (XCAR (rest)))))
+      /* Set paste types. */
+      err = GetEventParameter (event, kEventParamServicePasteTypes,
+                               typeCFMutableArrayRef, NULL,
+                               sizeof (CFMutableArrayRef), NULL,
+                               &paste_types);
+      if (err != noErr)
+        break;
+
+      for (rest = Vselection_converter_alist; CONSP (rest);
+           rest = XCDR (rest))
+        if (CONSP (XCAR (rest)) && SYMBOLP (XCAR (XCAR (rest)))
+            && (flavor_type =
+                get_flavor_type_from_symbol (XCAR (XCAR (rest)))))
+          {
+            type = CreateTypeStringWithOSType (flavor_type);
+            if (type)
               {
-                type = CreateTypeStringWithOSType (flavor_type);
-                if (type)
-                  {
-                    CFArrayAppendValue (paste_types, type);
-                    CFRelease (type);
-                  }
+                CFArrayAppendValue (paste_types, type);
+                CFRelease (type);
               }
+          }
 
-        /* Set copy types.  */
-        err = GetEventParameter (event, kEventParamServiceCopyTypes,
-                                 typeCFMutableArrayRef, NULL,
-                                 sizeof (CFMutableArrayRef), NULL,
-                                 &copy_types);
-        if (err == noErr
-            && !NILP (Fx_selection_owner_p (Vmac_services_selection)))
-          for (rest = get_scrap_target_type_list (cur_scrap);
-               CONSP (rest) && SYMBOLP (XCAR (rest)); rest = XCDR (rest))
-            {
-              flavor_type = get_flavor_type_from_symbol (XCAR (rest));
-              if (flavor_type)
-                {
-                  type = CreateTypeStringWithOSType (flavor_type);
-                  if (type)
-                    {
-                      CFArrayAppendValue (copy_types, type);
-                      CFRelease (type);
-                    }
-                }
-            }
-      }
-      break;
+      /* Set copy types.  */
+      err = GetEventParameter (event, kEventParamServiceCopyTypes,
+                               typeCFMutableArrayRef, NULL,
+                               sizeof (CFMutableArrayRef), NULL,
+                               &copy_types);
+      if (err != noErr)
+        break;
+
+      if (NILP (Fx_selection_owner_p (Vmac_services_selection)))
+        break;
+      else
+        goto copy_all_flavors;
 
     case kEventServiceCopy:
-      {
-        ScrapRef specific_scrap;
-        Lisp_Object rest, data;
-
-        err = GetEventParameter (event, kEventParamScrapRef,
-                                 typeScrapRef, NULL,
-                                 sizeof (ScrapRef), NULL, &specific_scrap);
-        if (err == noErr
-            && !NILP (Fx_selection_owner_p (Vmac_services_selection)))
-          for (rest = get_scrap_target_type_list (cur_scrap);
-               CONSP (rest) && SYMBOLP (XCAR (rest)); rest = XCDR (rest))
-            {
-              data = get_scrap_string (cur_scrap, XCAR (rest));
-              if (STRINGP (data))
-                err = put_scrap_string (specific_scrap, XCAR (rest), data);
-            }
-        else
+      err = GetEventParameter (event, kEventParamScrapRef,
+                               typeScrapRef, NULL,
+                               sizeof (ScrapRef), NULL, &specific_scrap);
+      if (err != noErr
+          || NILP (Fx_selection_owner_p (Vmac_services_selection)))
+        {
           err = eventNotHandledErr;
+          break;
+        }
+
+    copy_all_flavors:
+      {
+        UInt32 count, i;
+        ScrapFlavorInfo *flavor_info = NULL;
+        ScrapFlavorFlags flags;
+
+        err = GetScrapFlavorCount (cur_scrap, &count);
+        if (err == noErr)
+          flavor_info = xmalloc (sizeof (ScrapFlavorInfo) * count);
+        if (flavor_info)
+          {
+            err = GetScrapFlavorInfoList (cur_scrap, &count, flavor_info);
+            if (err != noErr)
+              {
+                xfree (flavor_info);
+                flavor_info = NULL;
+              }
+          }
+        if (flavor_info == NULL)
+          break;
+
+        for (i = 0; i < count; i++)
+          {
+            flavor_type = flavor_info[i].flavorType;
+            err = GetScrapFlavorFlags (cur_scrap, flavor_type, &flags);
+            if (err == noErr && !(flags & kScrapFlavorMaskSenderOnly))
+              {
+                if (event_kind == kEventServiceCopy)
+                  err = copy_scrap_flavor_data (cur_scrap, specific_scrap,
+                                                flavor_type);
+                else         /* event_kind == kEventServiceGetTypes */
+                  {
+                    type = CreateTypeStringWithOSType (flavor_type);
+                    if (type)
+                      {
+                        CFArrayAppendValue (copy_types, type);
+                        CFRelease (type);
+                      }
+                  }
+              }
+          }
+        xfree (flavor_info);
       }
       break;
 
     case kEventServicePaste:
     case kEventServicePerform:
       {
-        ScrapRef specific_scrap;
-        Lisp_Object rest, data;
         int data_exists_p = 0;
 
         err = GetEventParameter (event, kEventParamScrapRef, typeScrapRef,
@@ -1033,25 +1352,24 @@ mac_handle_service_event (call_ref, event, data)
             {
               if (! (CONSP (XCAR (rest)) && SYMBOLP (XCAR (XCAR (rest)))))
                 continue;
-              data = get_scrap_string (specific_scrap, XCAR (XCAR (rest)));
-              if (STRINGP (data))
-                {
-                  err = put_scrap_string (cur_scrap, XCAR (XCAR (rest)),
-                                          data);
-                  if (err != noErr)
-                    break;
-                  data_exists_p = 1;
-                }
+              flavor_type = get_flavor_type_from_symbol (XCAR (XCAR (rest)));
+              if (flavor_type == 0)
+                continue;
+              err = copy_scrap_flavor_data (specific_scrap, cur_scrap,
+                                            flavor_type);
+              if (err == noErr)
+                data_exists_p = 1;
             }
-        if (err == noErr)
-          if (data_exists_p)
-            mac_store_application_menu_event (event);
-          else
-            err = eventNotHandledErr;
+        if (!data_exists_p)
+          err = eventNotHandledErr;
+        else
+          err = mac_store_services_event (event);
       }
       break;
     }
 
+  if (err != noErr)
+    err = eventNotHandledErr;
   return err;
 }
 #endif
@@ -1065,6 +1383,7 @@ syms_of_macselect ()
   defsubr (&Sx_disown_selection_internal);
   defsubr (&Sx_selection_owner_p);
   defsubr (&Sx_selection_exists_p);
+  defsubr (&Smac_process_deferred_apple_events);
 
   Vselection_alist = Qnil;
   staticpro (&Vselection_alist);
@@ -1106,6 +1425,10 @@ next communication only.  After the communication, this variable is
 set to nil.  */);
   Vnext_selection_coding_system = Qnil;
 
+  DEFVAR_LISP ("mac-apple-event-map", &Vmac_apple_event_map,
+               doc: /* Keymap for Apple events handled by Emacs.  */);
+  Vmac_apple_event_map = Qnil;
+
 #ifdef MAC_OSX
   DEFVAR_LISP ("mac-services-selection", &Vmac_services_selection,
                doc: /* Selection name for communication via Services menu.  */);
@@ -1125,6 +1448,12 @@ set to nil.  */);
 
   Qmac_ostype = intern ("mac-ostype");
   staticpro (&Qmac_ostype);
+
+  Qmac_apple_event_class = intern ("mac-apple-event-class");
+  staticpro (&Qmac_apple_event_class);
+
+  Qmac_apple_event_id = intern ("mac-apple-event-id");
+  staticpro (&Qmac_apple_event_id);
 }
 
 /* arch-tag: f3c91ad8-99e0-4bd6-9eef-251b2f848732
diff --git a/src/macterm.c b/src/macterm.c
index 2976a84e190..ae2942c4cf9 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -622,7 +622,7 @@ atsu_get_text_layout_with_text_ptr (text, text_length, style, text_layout)
       ByteCount sizes[] = {sizeof (ATSLineLayoutOptions)};
       static ATSLineLayoutOptions line_layout =
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
-        kATSLineDisableAllLayoutOperations  | kATSLineUseDeviceMetrics
+        kATSLineDisableAllLayoutOperations | kATSLineUseDeviceMetrics
 #else
         kATSLineIsDisplayOnly | kATSLineFractDisable
 #endif
@@ -8127,20 +8127,18 @@ Lisp_Object Vmac_pass_control_to_system;
    Carbon/Apple event handlers.  */
 static struct input_event *read_socket_inev = NULL;
 
-/* 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;
-
 Point saved_menu_event_location;
 
 /* 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);
+#if USE_CARBON_EVENTS
+static Lisp_Object Qhicommand;
+#endif
+extern int mac_ready_for_apple_events;
+extern Lisp_Object Qundefined;
+extern void init_apple_event_handler P_ ((void));
+extern void mac_find_apple_event_spec P_ ((AEEventClass, AEEventID,
+                                           Lisp_Object *, Lisp_Object *,
+                                           Lisp_Object *));
 
 #if TARGET_API_MAC_CARBON
 /* Drag and Drop */
@@ -8150,11 +8148,10 @@ static DragTrackingHandlerUPP mac_do_track_dragUPP = NULL;
 static DragReceiveHandlerUPP mac_do_receive_dragUPP = NULL;
 #endif
 
-static Lisp_Object Qapplication, Qabout;
 #if USE_CARBON_EVENTS
 #ifdef MAC_OSX
 extern void init_service_handler ();
-static Lisp_Object Qpreferences, Qservices, Qpaste, Qperform;
+static Lisp_Object Qservices, Qpaste, Qperform;
 #endif
 /* Window Event Handler */
 static pascal OSStatus mac_handle_window_event (EventHandlerCallRef,
@@ -8699,179 +8696,49 @@ do_zoom_window (WindowPtr w, int zoom_in_or_out)
   x_real_positions (f, &f->left_pos, &f->top_pos);
 }
 
-/* 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 ();
-}
-
-void
-mac_store_application_menu_event (event)
-#if USE_CARBON_EVENTS
-     EventRef event;
-#else
-     UInt32 event;
-#endif
+OSErr
+mac_store_apple_event (class, id, desc)
+     Lisp_Object class, id;
+     const AEDesc *desc;
 {
+  OSErr err = noErr;
   struct input_event buf;
-  Lisp_Object frame, entry;
-
-  EVENT_INIT (buf);
-
-  XSETFRAME (frame, mac_focus_frame (&one_mac_display_info));
-  buf.kind = MENU_BAR_EVENT;
-  buf.frame_or_window = frame;
-  buf.arg = frame;
-  kbd_buffer_store_event (&buf);
-
-  buf.arg = Qapplication;
-  kbd_buffer_store_event (&buf);
+  AEDesc *desc_copy;
 
-#if USE_CARBON_EVENTS
-  switch (GetEventClass (event))
+  desc_copy = xmalloc (sizeof (AEDesc));
+  if (desc_copy == NULL)
+    err = memFullErr;
+  else
+    err = AEDuplicateDesc (desc, desc_copy);
+  if (err == noErr)
     {
-#ifdef MAC_OSX
-    case kEventClassService:
-      buf.arg = Qservices;
-      kbd_buffer_store_event (&buf);
-      switch (GetEventKind (event))
-        {
-        case kEventServicePaste:
-          entry = Qpaste;
-          break;
+      EVENT_INIT (buf);
 
-        case kEventServicePerform:
-          {
-            OSErr err;
-            CFStringRef message;
-
-            err = GetEventParameter (event, kEventParamServiceMessageName,
-                                     typeCFStringRef, NULL,
-                                     sizeof (CFStringRef), NULL, &message);
-            buf.arg = Qperform;
-            kbd_buffer_store_event (&buf);
-            if (err == noErr && message)
-              entry = intern (SDATA (cfstring_to_lisp (message)));
-            else
-              entry = Qnil;
-          }
-          break;
+      buf.kind = MAC_APPLE_EVENT;
+      buf.x = class;
+      buf.y = id;
+      buf.code = (int)desc_copy;
+      XSETFRAME (buf.frame_or_window,
+                 mac_focus_frame (&one_mac_display_info));
+      buf.arg = Qnil;
+      kbd_buffer_store_event (&buf);
+    }
 
-        default:
-          abort ();
-        }
-      break;
-#endif  /* MAC_OSX */
-    case kEventClassCommand:
-      {
-        HICommand command;
+  return err;
+}
 
-        GetEventParameter(event, kEventParamDirectObject, typeHICommand,
-                          NULL, sizeof (HICommand), NULL, &command);
-        switch (command.commandID)
-          {
-          case kHICommandAbout:
-            entry = Qabout;
-            break;
-#ifdef MAC_OSX
-          case kHICommandPreferences:
-            entry = Qpreferences;
-            break;
-#endif /* MAC_OSX */
-          case kHICommandQuit:
-            entry = Qquit;
-            break;
-          default:
-            abort ();
-          }
-      }
-      break;
+Lisp_Object
+mac_make_lispy_event_code (code)
+     int code;
+{
+  AEDesc *desc = (AEDesc *)code;
+  Lisp_Object obj;
 
-    default:
-      abort ();
-    }
-#else  /* USE_CARBON_EVENTS */
-  switch (event)
-    {
-    case kHICommandAbout:
-      entry = Qabout;
-      break;
-    case kHICommandQuit:
-      entry = Qquit;
-      break;
-    default:
-      abort ();
-    }
-#endif
+  obj = mac_aedesc_to_lisp (desc);
+  AEDisposeDesc (desc);
+  xfree (desc);
 
-  buf.arg = entry;
-  kbd_buffer_store_event (&buf);
+  return obj;
 }
 
 #if USE_CARBON_EVENTS
@@ -8881,28 +8748,49 @@ mac_handle_command_event (next_handler, event, data)
      EventRef event;
      void *data;
 {
+  OSStatus result;
+  OSErr err;
   HICommand command;
-  OSErr result;
+  Lisp_Object class_key, id_key, binding;
 
-  GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL,
-                    sizeof (HICommand), NULL, &command);
+  result = CallNextEventHandler (next_handler, event);
+  if (result != eventNotHandledErr)
+    return result;
 
-  switch (command.commandID)
-    {
-    case kHICommandAbout:
-#ifdef MAC_OSX
-    case kHICommandPreferences:
-#endif  /* MAC_OSX */
-      result = CallNextEventHandler (next_handler, event);
-      if (result != eventNotHandledErr)
-        return result;
+  GetEventParameter (event, kEventParamDirectObject, typeHICommand, NULL,
+                     sizeof (HICommand), NULL, &command);
 
-      mac_store_application_menu_event (event);
-      return noErr;
+  if (command.commandID == 0)
+    return eventNotHandledErr;
 
-    default:
-      break;
-    }
+  /* A HICommand event is mapped to an Apple event whose event class
+     symbol is `hicommand' and event ID is its command ID.  */
+  class_key = Qhicommand;
+  mac_find_apple_event_spec (0, command.commandID,
+                             &class_key, &id_key, &binding);
+  if (!NILP (binding) && !EQ (binding, Qundefined))
+    if (INTEGERP (binding))
+      return XINT (binding);
+    else
+      {
+        AppleEvent apple_event;
+        UInt32 modifiers;
+        static EventParamName names[] = {kEventParamDirectObject,
+                                         kEventParamKeyModifiers};
+        static EventParamType types[] = {typeHICommand,
+                                         typeUInt32};
+        static UInt32 sizes[] = {sizeof (HICommand),
+                                 sizeof (UInt32)};
+        err = create_apple_event_from_event_ref (event, 2, names, types,
+                                                 sizes, &apple_event);
+        if (err == noErr)
+          {
+            err = mac_store_apple_event (class_key, id_key, &apple_event);
+            AEDisposeDesc (&apple_event);
+          }
+        if (err == noErr)
+          return noErr;
+      }
 
   return eventNotHandledErr;
 }
@@ -9064,6 +8952,52 @@ mac_handle_mouse_event (next_handler, event, data)
 
   return eventNotHandledErr;
 }
+
+#ifdef MAC_OSX
+OSErr
+mac_store_services_event (event)
+     EventRef event;
+{
+  OSErr err;
+  AppleEvent apple_event;
+  Lisp_Object id_key;
+
+  switch (GetEventKind (event))
+    {
+    case kEventServicePaste:
+      id_key = Qpaste;
+      err = create_apple_event_from_event_ref (event, 0, NULL,
+                                               NULL, NULL, &apple_event);
+      break;
+
+    case kEventServicePerform:
+      {
+        static EventParamName names[] = {kEventParamServiceMessageName,
+                                         kEventParamServiceUserData};
+        static EventParamType types[] = {typeCFStringRef,
+                                         typeCFStringRef};
+        static UInt32 sizes[] = {sizeof (CFStringRef),
+                                 sizeof (CFStringRef)};
+
+        id_key = Qperform;
+        err = create_apple_event_from_event_ref (event, 2, names, types,
+                                                 sizes, &apple_event);
+      }
+      break;
+
+    default:
+      abort ();
+    }
+
+  if (err == noErr)
+    {
+      err = mac_store_apple_event (Qservices, id_key, &apple_event);
+      AEDisposeDesc (&apple_event);
+    }
+
+  return err;
+}
+#endif  /* MAC_OSX */
 #endif  /* USE_CARBON_EVENTS */
 
 
@@ -9122,159 +9056,6 @@ remove_window_handler (window)
 #endif
 }
 
-/* Open Application Apple Event */
-static pascal OSErr
-do_ae_open_application(const AppleEvent *pae, AppleEvent *preply, long prefcon)
-{
-  return noErr;
-}
-
-
-/* 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.  */
-#pragma options align=mac68k
-typedef struct SelectionRange {
-  short unused1; // 0 (not used)
-  short lineNum; // line to select (<0 to specify range)
-  long startRange; // start of selection range (if line < 0)
-  long endRange; // end of selection range (if line < 0)
-  long unused2; // 0 (not used)
-  long theDate; // modification date/time
-} SelectionRange;
-#pragma options align=reset
-
-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;
-  SelectionRange position;
-  Lisp_Object file_list = Qnil;
-
-  xassert (read_socket_inev);
-
-  err = AEGetParamDesc (message, keyDirectObject, typeAEList, &the_desc);
-  if (err != noErr)
-    goto descriptor_error_exit;
-
-  err = AEGetParamPtr (message, keyAEPosition, typeChar, &actual_type, &position, sizeof(SelectionRange), &actual_size);
-  if (err == noErr)
-    file_list = Fcons (list3 (make_number (position.lineNum + 1),
-                              make_number (position.startRange + 1),
-                              make_number (position.endRange + 1)),
-                       file_list);
-
-  /* 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; i <= num_files_to_open; i++)
-          {
-            char unix_path_name[MAXPATHLEN];
-#ifdef MAC_OSX
-            FSRef fref;
-
-            err = AEGetNthPtr (&the_desc, i, typeFSRef, &keyword,
-                               &actual_type, &fref, sizeof (FSRef),
-                               &actual_size);
-            if (err != noErr || actual_type != typeFSRef)
-              continue;
-
-            if (FSRefMakePath (&fref, unix_path_name, sizeof (unix_path_name))
-                == noErr)
-#else
-            FSSpec fs;
-
-            err = AEGetNthPtr(&the_desc, i, typeFSS, &keyword, &actual_type,
-                              (Ptr) &fs, sizeof (fs), &actual_size);
-            if (err != noErr) continue;
-
-            if (fsspec_to_posix_pathname (&fs, unix_path_name,
-                                          sizeof (unix_path_name) - 1) == noErr)
-#endif
-              /* x-dnd functions expect undecoded filenames.  */
-              file_list = Fcons (make_unibyte_string (unix_path_name,
-                                                      strlen (unix_path_name)),
-                                 file_list);
-          }
-      }
-
-    /* Build a DRAG_N_DROP_EVENT type event as is done in
-       constuct_drag_n_drop in w32term.c.  */
-    if (!NILP (file_list))
-      {
-        struct frame *f = mac_focus_frame (&one_mac_display_info);
-        WindowPtr wp;
-        Lisp_Object frame;
-
-        read_socket_inev->kind = DRAG_N_DROP_EVENT;
-        read_socket_inev->code = 0;
-        read_socket_inev->modifiers = 0;
-
-        XSETINT (read_socket_inev->x, 0);
-        XSETINT (read_socket_inev->y, 0);
-
-        XSETFRAME (frame, f);
-        read_socket_inev->frame_or_window = Fcons (frame, file_list);
-
-#if 0
-        /* 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.  */
-        wp = FRAME_MAC_WINDOW (f);
-        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 */
-#endif
-      }
-  }
-
-error_exit:
-  /* Nuke the coerced file list in any case */
-  err2 = AEDisposeDesc(&the_desc);
-
-descriptor_error_exit:
-  /* InvalRect(&(gFrontMacWindowP->mWP->portRect)); */
-  return err;
-}
-
-
 #if TARGET_API_MAC_CARBON
 static pascal OSErr
 mac_do_track_drag (DragTrackingMessage message, WindowPtr window,
@@ -9429,44 +9210,6 @@ mac_do_receive_drag (WindowPtr window, void *handlerRefCon,
 #endif
 
 
-/* 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)
-{
-#if USE_CARBON_EVENTS
-  OSErr err;
-  EventRef event = NULL;
-  static const HICommand quit_command = {kEventAttributeNone, kHICommandQuit};
-
-  err = CreateEvent (NULL, kEventClassCommand, kEventCommandProcess, 0,
-                     kEventAttributeUserEvent, &event);
-  if (err == noErr)
-    err = SetEventParameter (event, kEventParamDirectObject, typeHICommand,
-                             sizeof (HICommand), &quit_command);
-  if (err == noErr)
-    mac_store_application_menu_event (event);
-  if (event)
-    ReleaseEvent (event);
-
-  if (err == noErr)
-    return noErr;
-  else
-    return errAEEventNotHandled;
-#else
-  mac_store_application_menu_event (kHICommandQuit);
-
-  return noErr;
-#endif
-}
-
-
 #if __profile__
 void
 profiler_exit_proc ()
@@ -9520,7 +9263,7 @@ main (void)
 
   initialize_applescript ();
 
-  init_required_apple_events ();
+  init_apple_event_handler ();
 
   {
     char **argv;
@@ -9724,7 +9467,7 @@ mac_wait_next_event (er, sleep_time, dequeue)
     mouse_region = NewRgn ();
 
   event_mask = everyEvent;
-  if (NILP (Fboundp (Qmac_ready_for_drag_n_drop)))
+  if (!mac_ready_for_apple_events)
     event_mask -= highLevelEventMask;
 
   current_tick = TickCount ();
@@ -10892,7 +10635,6 @@ mac_initialize ()
   BLOCK_INPUT;
 
 #if TARGET_API_MAC_CARBON
-  init_required_apple_events ();
 
 #if USE_CARBON_EVENTS
 #ifdef MAC_OSX
@@ -10907,6 +10649,8 @@ mac_initialize ()
 #endif  /* USE_CARBON_EVENTS */
 
 #ifdef MAC_OSX
+  init_apple_event_handler ();
+
   if (!inhibit_window_system)
     MakeMeTheFrontProcess ();
 #endif
@@ -10937,15 +10681,14 @@ syms_of_macterm ()
   Fput (Qhyper,   Qmodifier_value, make_number (hyper_modifier));
   Fput (Qsuper,   Qmodifier_value, make_number (super_modifier));
 
-  Qapplication = intern ("application");  staticpro (&Qapplication);
-  Qabout       = intern ("about");        staticpro (&Qabout);
-
-#if USE_CARBON_EVENTS && defined (MAC_OSX)
-  Qpreferences = intern ("preferences");  staticpro (&Qpreferences);
+#if USE_CARBON_EVENTS
+  Qhicommand   = intern ("hicommand");    staticpro (&Qhicommand);
+#ifdef MAC_OSX
   Qservices    = intern ("services");     staticpro (&Qservices);
   Qpaste       = intern ("paste");        staticpro (&Qpaste);
   Qperform     = intern ("perform");      staticpro (&Qperform);
 #endif
+#endif
 
 #ifdef MAC_OSX
   Fprovide (intern ("mac-carbon"), Qnil);
@@ -10954,9 +10697,6 @@ syms_of_macterm ()
   staticpro (&Qreverse);
   Qreverse = intern ("reverse");
 
-  staticpro (&Qmac_ready_for_drag_n_drop);
-  Qmac_ready_for_drag_n_drop = intern ("mac-ready-for-drag-n-drop");
-
   staticpro (&x_display_name_list);
   x_display_name_list = Qnil;
 
diff --git a/src/macterm.h b/src/macterm.h
index 214037c3346..916a461f67e 100644
--- a/src/macterm.h
+++ b/src/macterm.h
@@ -79,7 +79,7 @@ struct mac_display_info
   /* Number of planes on this screen.  */
   int n_planes;
 
-  /* Whether the screen supports color */ 
+  /* Whether the screen supports color */
   int color_p;
 
   /* Dimensions of this screen.  */
@@ -564,6 +564,7 @@ extern void mac_clear_area P_ ((struct frame *, int, int,
 extern void mac_unload_font P_ ((struct mac_display_info *, XFontStruct *));
 extern OSErr install_window_handler P_ ((WindowPtr));
 extern void remove_window_handler P_ ((WindowPtr));
+extern Lisp_Object mac_make_lispy_event_code P_ ((int));
 
 #define FONT_TYPE_FOR_UNIBYTE(font, ch) 0
 #define FONT_TYPE_FOR_MULTIBYTE(font, ch) 0
@@ -577,7 +578,12 @@ extern void x_clear_frame_selections P_ ((struct frame *));
 extern OSErr posix_pathname_to_fsspec P_ ((const char *, FSSpec *));
 extern OSErr fsspec_to_posix_pathname P_ ((const FSSpec *, char *, int));
 extern void mac_clear_font_name_table P_ ((void));
+extern Lisp_Object mac_aedesc_to_lisp P_ ((AEDesc *));
 #if TARGET_API_MAC_CARBON
+extern OSErr create_apple_event_from_event_ref P_ ((EventRef, UInt32,
+                                                    EventParamName *,
+                                                    EventParamType *,
+                                                    UInt32 *, AppleEvent *));
 extern CFStringRef cfstring_create_with_utf8_cstring P_ ((const char *));
 extern CFStringRef cfstring_create_with_string P_ ((Lisp_Object));
 extern Lisp_Object cfdata_to_lisp P_ ((CFDataRef));
@@ -592,6 +598,7 @@ extern Lisp_Object cfproperty_list_to_lisp P_ ((CFPropertyListRef, int, int));
 extern void xrm_merge_string_database P_ ((XrmDatabase, char *));
 extern Lisp_Object xrm_get_resource P_ ((XrmDatabase, char *, char *));
 extern XrmDatabase xrm_get_preference_database P_ ((char *));
+EXFUN (Fmac_get_preference, 4);
 
 /* arch-tag: 6b4ca125-5bef-476d-8ee8-31ed808b7e79
    (do not change this comment) */
diff --git a/src/termhooks.h b/src/termhooks.h
index 3fea7c366fb..cb68c9e2c27 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -129,7 +129,7 @@ enum event_kind
                                    by MS-Windows scroll bar controls. */
 #endif
   SELECTION_REQUEST_EVENT,      /* Another X client wants a selection from us.
-                                   See `struct selection_event'.  */
+                                   See `struct selection_input_event'.  */
   SELECTION_CLEAR_EVENT,        /* Another X client cleared our selection.  */
   BUFFER_SWITCH_EVENT,          /* A process filter has switched buffers.  */
   DELETE_WINDOW_EVENT,          /* An X client said "delete this window".  */
@@ -177,12 +177,22 @@ enum event_kind
 
   /* Queued from XTread_socket when session manager sends
      save yourself before shutdown. */
-  SAVE_SESSION_EVENT
+  SAVE_SESSION_EVENT,
+
+#ifdef MAC_OS
+  /* Generated when an Apple event, a HICommand event, or a Services
+     menu event is received and the corresponding handler is
+     registered.  Members `x' and `y' are for the event class and ID
+     symbols, respectively.  Member `code' points to the Apple event
+     descriptor.  Parameters for Non-Apple events are converted to
+     those in Apple events.  */
+  MAC_APPLE_EVENT
+#endif
 };
 
 /* If a struct input_event has a kind which is SELECTION_REQUEST_EVENT
    or SELECTION_CLEAR_EVENT, then its contents are really described
-   by `struct selection_event'; see xterm.h.  */
+   by `struct selection_input_event'; see xterm.h.  */
 
 /* The keyboard input buffer is an array of these structures.  Each one
    represents some sort of input event - a keystroke, a mouse click, or
@@ -208,7 +218,7 @@ struct input_event
   unsigned long timestamp;
 
   /* This is padding just to put the frame_or_window field
-     past the size of struct selection_event.  */
+     past the size of struct selection_input_event.  */
   int *padding[2];
 
   /* This field is copied into a vector while the event is in the queue,
diff --git a/src/w32fns.c b/src/w32fns.c
index 6fc6c860808..d1e4e49bb03 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -8939,8 +8939,12 @@ w32_abort()
   button = MessageBox (NULL,
                        "A fatal error has occurred!\n\n"
                        "Would you like to attach a debugger?\n\n"
-                       "Select YES to debug, NO to abort Emacs",
-                       "Emacs Abort Dialog",
+                       "Select YES to debug, NO to abort Emacs"
+#if __GNUC__
+                       "\n\n(type \"gdb -p <emacs-PID>\" and\n"
+                       "\"continue\" inside GDB before clicking YES.)"
+#endif
+                       , "Emacs Abort Dialog",
                        MB_ICONEXCLAMATION | MB_TASKMODAL
                        | MB_SETFOREGROUND | MB_YESNO);
   switch (button)