10:53 p.m.
I don’t propose to commit this right now, but I suppose it’s worth posting
as a putative solution on the lines of
http://mid.gmane.org/18187.60360.900893.282407＠parhasard.net .
lisp/ChangeLog addition:
2007-10-18 Aidan Kehoe <kehoea(a)parhasard.net>
* mule/mule-cmds.el (init-locale-at-early-startup):
Use the Carbon locale if it is available.
* mule/mule-cmds.el (init-mule-at-startup):
Init carbon-current-language-unicode-set from the current language
environment's input method if necessary
src/ChangeLog addition:
2007-10-18 Aidan Kehoe <kehoea(a)parhasard.net>
* event-carbon.c:
Add much more debugging infrastructure.
* event-carbon.c (carbon_modifiers_to_emacs_modifiers):
Support the Option key as meta.
* event-carbon.c (retranslate_option):
Add; retranslate the option key if that is appropriate, that is,
if the character generated with option both:
1. Differs from the character generated without option and
2. Is either ASCII (because our users are programmers) or is necessary to
write the currently active language
then option + char-without-option should generate char-with-option;
otherwise option + char-without-option should generate
M-char-without-option.
* event-carbon.c (text_input_event_handler):
* event-carbon.c (handle_apple_event):
* event-carbon.c (generic_send_event_to_target):
* event-carbon.c (vars_of_event_carbon):
Provide mac-command-key-is-meta.
* intl-carbon.c:
* intl-carbon.c (carbon_get_pseudo_posix_locale):
New function, to pull a simulacrum of the current Carbon locale in
POSIX form based on the script, language and region codes.
* intl-carbon.c (Fcarbon_current_locale):
New function, on the model of mswindows-current-locale; algorithm
and code based on that of Mozilla.
* intl-carbon.c (syms_of_intl_carbon):
Make carbon-current-locale available.
* scrollbar-carbon.c (carbon_update_scrollbar_instance_status):
First argument is unused, mark it as so for the sake of the
compiler.
XEmacs Trunk source patch:
Diff command: cvs -q diff -Nu
Files affected: src/scrollbar-carbon.c
===================================================================
RCS src/intl-carbon.c
===================================================================
RCS src/event-carbon.c
===================================================================
RCS lisp/mule/mule-cmds.el
===================================================================
RCS
Index: lisp/mule/mule-cmds.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/lisp/mule/mule-cmds.el,v
retrieving revision 1.23.2.1
diff -u -u -r1.23.2.1 mule-cmds.el
--- lisp/mule/mule-cmds.el 2007/09/30 18:33:20 1.23.2.1
+++ lisp/mule/mule-cmds.el 2007/10/18 21:44:11
＠＠ -1464,17 +1464,25 ＠＠
(declare-fboundp (mswindows-set-current-locale userdef)))
;; Unix:
(let (locstring)
- ;; Init the POSIX locale from the environment--this calls the C
- ;; library's setlocale(3).
- (set-current-locale "")
- ;; Can't let locstring be the result of (set-current-locale "")
- ;; because that can return a more detailed string than we know how
- ;; to handle.
- (setq locstring (current-locale)
- ;; assume C lib locale and LANG env var are set correctly.
- ;; use them to find the langenv.
- langenv
- (and locstring (get-language-environment-from-locale
+ (unless (and-fboundp
+ #'carbon-current-locale
+ ;; If Carbon provides us with the locale string, we want
+ ;; to use that, instead of the code that checks the
+ ;; C environment below.
+ (setq locstring
+ (carbon-current-locale)))
+ ;; Init the POSIX locale from the environment--this calls the C
+ ;; library's setlocale(3).
+ (set-current-locale "")
+ ;; Can't let locstring be the result of (set-current-locale "")
+ ;; because that can return a more detailed string than we know how
+ ;; to handle.
+ (setq locstring (current-locale)))
+
+ ;; assume C lib locale and LANG env var are set correctly.
+ ;; use them to find the langenv.
+ (setq langenv
+ (and locstring (get-language-environment-from-locale
locstring)))))
;; All systems:
(unless langenv (setq langenv "English"))
＠＠ -1515,8 +1523,36 ＠＠
(setq Manual-use-rosetta-man nil))
;; Register available input methods by loading LEIM list file.
- (load "leim-list.el" 'noerror 'nomessage 'nosuffix)
- )
+ (load leim-list-file-name 'noerror 'nomessage 'nosuffix)
+
+ (when-boundp 'carbon-current-language-unicode-set
+ (unless carbon-current-language-unicode-set
+ (setq carbon-current-language-unicode-set
+ (make-hash-table :size 256)))
+ (loop
+ for i from #x20 to #x7e
+ do (puthash i t carbon-current-language-unicode-set))
+ (let ((input-method (get-language-info current-language-environment
'input-method)))
+ (when (assoc input-method input-method-alist)
+ (flet ((map-tree
+ (tree)
+ (loop for branch in tree
+ do
+ (cond ((consp branch)
+ (map-tree branch))
+ ((or (stringp branch) (vectorp branch))
+ (map-tree (append branch nil)))
+ ((characterp branch)
+ (unless (< branch #x80)
+ (puthash (encode-char branch 'ucs) t
+ carbon-current-language-unicode-set))))))
+ (append-message (&rest args) ())
+ (clear-message (&rest args) ()))
+ (set-input-method input-method)
+ (loop for mapped in (mapcar #'cdr (cdr (quail-map)))
+ do
+ (map-tree mapped)))
+ (inactivate-input-method)))))
;; Code deleted: init-mule-tm (Enable the tm package by default)
Index: src/event-carbon.c
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/Attic/event-carbon.c,v
retrieving revision 1.1.2.3
diff -u -u -r1.1.2.3 event-carbon.c
--- src/event-carbon.c 2007/09/30 19:48:26 1.1.2.3
+++ src/event-carbon.c 2007/10/18 21:44:11
＠＠ -30,13 +30,31 ＠＠
#include "console-carbon-impl.h"
+#ifdef DEBUG_XEMACS
+static Fixnum debug_carbon_events;
+# define DEBUG_CARBON_EVENTS(FORMAT, ...) \
+ do { if (debug_carbon_events) stderr_out(FORMAT, __VA_ARGS__); } while (0)
+#else /* DEBUG_XEMACS */
+# define DEBUG_CARBON_EVENTS(format, ...)
+#endif /* DEBUG_XEMACS */
+
+
+#ifdef DEBUG_XEMACS
+extern Fixnum debug_emacs_events;
+#endif
+
EXFUN (Funicode_to_char, 2); /* In unicode.c. */
+extern Lisp_Object Vcarbon_current_language_unicode_set;
+
extern Lisp_Object Qcarbon_unicode; /* From intl-carbon.c. */
extern SELECT_TYPE process_only_mask; /* From event-unixoid.c. */
extern int track_mouse_down_on_scrollbar (void); /* from scrollbar-carbon.c. */
+/* true if using command key as meta key */
+Lisp_Object Vmac_command_key_is_meta;
+
static struct event_stream *carbon_event_stream;
static Lisp_Object carbon_user_event_queue;
＠＠ -50,8 +68,6 ＠＠
static EventLoopTimerUPP timer_proc_UPP;
-static int debug_carbon_events = 0;
-
/* Used in frame-carbon.c. */
void carbon_enqueue_user_event (Lisp_Object);
＠＠ -250,7 +266,7 ＠＠
{
int emacs_modifiers = 0;
- if (modifiers & cmdKey)
+ if (modifiers & (NILP (Vmac_command_key_is_meta) ? optionKey : cmdKey))
emacs_modifiers |= XEMACS_MOD_META;
if (modifiers & controlKey)
emacs_modifiers |= XEMACS_MOD_CONTROL;
＠＠ -343,6 +359,108 ＠＠
}
}
+static void
+retranslate_option (EventRef keyboard_event, UInt32 modifiers,
+ UniChar *text, UInt32 text_size)
+{
+ UInt32 new_modifiers = modifiers & ~optionKey;
+ UInt32 keycode;
+ KeyboardLayoutRef layoutRef;
+ KeyboardLayoutKind layout_kind;
+
+ GetEventParameter (keyboard_event, kEventParamKeyCode, typeUInt32, NULL,
+ sizeof (keycode), NULL, &keycode);
+
+ if (KLGetCurrentKeyboardLayout (&layoutRef) != noErr)
+ invalid_operation ("Can't get keyboard layout ref", Qunbound);
+
+ if (KLGetKeyboardLayoutProperty (layoutRef, kKLKind,
+ (const void **)&layout_kind) != noErr)
+ invalid_operation ("Can't get keyboard layout kind", Qunbound);
+
+ /* Depending on whether KCHR or uchr keyboard layout data is
+ available, call KeyTranslate or UCKeyTranslate to determine the
+ actual character code that should be enqueued. */
+ if (layout_kind == kKLKCHRKind)
+ {
+ void *kchr_ptr;
+ UInt16 new_keycode;
+ static UInt32 deadKeyState = 0;
+ UniChar char_code;
+
+ DEBUG_CARBON_EVENTS ("%s", "layout kind is KCHR\n");
+
+ if (KLGetKeyboardLayoutProperty (layoutRef, kKLKCHRData,
+ (const void **)&kchr_ptr) != noErr)
+ invalid_operation ("Can't get KCHR keyboard layout", Qunbound);
+
+ new_keycode = new_modifiers & 0xff00;
+
+ if (GetEventKind (keyboard_event) == kEventRawKeyUp)
+ new_keycode |= (1 << 7);
+
+ new_keycode |= (keycode & 0x7f);
+
+ deadKeyState = 0;
+ char_code = KeyTranslate (kchr_ptr, new_keycode, &deadKeyState);
+
+ DEBUG_CARBON_EVENTS ("char_code is %x, text[0] is %x, check is %x\n",
+ char_code, text[0],
+ (!NILP (Vcarbon_current_language_unicode_set) &&
+ !NILP (Fgethash (make_int (text[0]),
+ Vcarbon_current_language_unicode_set,
Qnil))));
+
+ if (2 == text_size && char_code != text[0] &&
+ (!NILP (Vcarbon_current_language_unicode_set) &&
+ !NILP (Fgethash (make_int (text[0]),
+ Vcarbon_current_language_unicode_set, Qnil))))
+ {
+ DEBUG_CARBON_EVENTS ("%s", "with a normal keylayout, are
modifying event\n");
+ enqueue_input (text, text_size / 2, new_modifiers);
+ }
+ else
+ {
+ DEBUG_CARBON_EVENTS ("%s", "with a normal keylayout, not
modifying event\n");
+ enqueue_input (&char_code, 1, modifiers);
+ }
+ }
+ else /* layout_kind == kKLuchrKind || layout_kind == kKLKCHRuchrKind */
+ {
+ UCKeyboardLayout *layout;
+ static UInt32 deadKeyState = 0;
+ UniChar output[16];
+ UniCharCount output_length;
+
+ DEBUG_CARBON_EVENTS ("%s", "layout kind is Unicode\n");
+
+ if (KLGetKeyboardLayoutProperty (layoutRef, kKLuchrData,
+ (const void**)&layout) != noErr)
+ invalid_operation ("Can't get uchr keyboard layout", Qunbound);
+
+ if (UCKeyTranslate (layout, keycode, kUCKeyActionDown, new_modifiers >> 8,
+ LMGetKbdType (), 0, &deadKeyState, 16,
+ &output_length, output) != noErr)
+ invalid_operation ("Can't translate key using uchr", Qunbound);
+
+ DEBUG_CARBON_EVENTS ("output[0] is %x, text[0] is %x\n", output[0],
text[0]);
+
+
+ if (2 == text_size && char_code != text[0] &&
+ (!NILP (Vcarbon_current_language_unicode_set) &&
+ !NILP (Fgethash (make_int (text[0]),
+ Vcarbon_current_language_unicode_set, Qnil))))
+ {
+ DEBUG_CARBON_EVENTS ("%s", "with a normal keylayout, are
modifying event\n");
+ enqueue_input (text, text_size / 2, new_modifiers);
+ }
+ else
+ {
+ DEBUG_CARBON_EVENTS ("%s", "with a normal keylayout, not
modifying event\n");
+ enqueue_input (&char_code, 1, modifiers);
+ }
+ }
+}
+
static char *ascii_to_keysymstr_table[] = {
/*0x00*/ 0, "home", 0, "kp-enter", "end",
"help", 0, 0,
/*0x08*/ "backspace", "tab", 0, "prior",
"next", "return", 0, 0,
＠＠ -419,34 +537,49 ＠＠
UniChar *text = (UniChar *)alloca_extbytes (text_size);
if (GetEventParameter (event, kEventParamTextInputSendText, typeUnicodeText, NULL,
text_size, NULL, text) != noErr)
invalid_operation ("Can't get input text", Qunbound);
+
+ DEBUG_CARBON_EVENTS ("modifiers are %x, keycode is %x, text_size is %x\n",
+ modifiers, keycode, text_size);
+ DEBUG_CARBON_EVENTS ("optionKey is %x\n",
+ optionKey);
+
+ if (text_size == 2 && text[0] <= 127 &&
+ (modifiers & (controlKey | cmdKey)) &&
keycode_needs_retranslate[keycode])
+ {
+ retranslate_keycode (keyboard_event, modifiers);
+ return noErr;
+ }
+ if (NILP(Vmac_command_key_is_meta) && (modifiers & optionKey))
+ {
+ DEBUG_CARBON_EVENTS ("%s",
+ "command key is not meta, and the modifiers include
option\n");
+ retranslate_option (keyboard_event, modifiers, text, text_size);
+ return noErr;
+ }
+
if (text_size == 2 && text[0] <= 127)
{
- if ((modifiers & (controlKey | cmdKey)) &&
keycode_needs_retranslate[keycode])
- retranslate_keycode (keyboard_event, modifiers);
+ char *keysymstr = ascii_to_keysymstr_table[text[0]];
+ if (keysymstr)
+ enqueue_one_input_event (KEYSYM (keysymstr), carbon_modifiers_to_emacs_modifiers
(modifiers));
else
- {
- char *keysymstr = ascii_to_keysymstr_table[text[0]];
- if (keysymstr)
- enqueue_one_input_event (KEYSYM (keysymstr), carbon_modifiers_to_emacs_modifiers
(modifiers));
- else
- {
- if (ascii_needs_keycode_lookup[text[0]])
- {
- char *keysymstr = keycode_to_keysymstr_table[keycode];
- if (keysymstr)
- enqueue_one_input_event (KEYSYM (keysymstr), carbon_modifiers_to_emacs_modifiers
(modifiers));
- else
- enqueue_input (text, text_size / 2, modifiers);
- }
- else
- enqueue_input (text, text_size / 2, modifiers);
- }
- }
+ {
+ if (ascii_needs_keycode_lookup[text[0]])
+ {
+ char *keysymstr = keycode_to_keysymstr_table[keycode];
+ if (keysymstr)
+ enqueue_one_input_event (KEYSYM (keysymstr),
carbon_modifiers_to_emacs_modifiers (modifiers));
+ else
+ enqueue_input (text, text_size / 2, modifiers);
+ }
+ else
+ enqueue_input (text, text_size / 2, modifiers);
+ }
+ return noErr;
}
- else
- enqueue_input (text, text_size / 2, modifiers);
-
+
+ enqueue_input (text, text_size / 2, modifiers);
return noErr;
}
＠＠ -503,8 +636,12 ＠＠
stderr_out ("Can't convert to event record.\n");
OSErr s = AEProcessAppleEvent (&event_record);
- if (s != noErr && debug_carbon_events)
- stderr_out ("Apple event not processed (error = %d).\n", s);
+
+
+ if (s != noErr)
+ {
+ DEBUG_CARBON_EVENTS ("Apple event not processed (error = %d).\n", s);
+ }
}
static void
＠＠ -517,9 +654,9 ＠＠
EventClass event_class = GetEventClass (event);
UInt32 event_kind = GetEventKind (event);
- stderr_out ("Event not sent to or ignored by target: ");
+ DEBUG_CARBON_EVENTS ("%s", "Event not sent to or ignored by target:
");
debug_print_event (event_class, event_kind);
- stderr_out ("\n");
+ DEBUG_CARBON_EVENTS ("%s", "\n");
}
}
＠＠ -922,6 +1059,10 ＠＠
vars_of_event_carbon (void)
{
/* reinit_vars_of_event_carbon (); */
+ DEFVAR_LISP ("mac-command-key-is-meta", &Vmac_command_key_is_meta /*
+Non-nil means that the command key is used as the XEmacs meta key.
+Otherwise the option key is used. */ );
+ Vmac_command_key_is_meta = Qt;
}
void
Index: src/intl-carbon.c
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/Attic/intl-carbon.c,v
retrieving revision 1.1.2.3
diff -u -u -r1.1.2.3 intl-carbon.c
--- src/intl-carbon.c 2007/09/30 21:40:13 1.1.2.3
+++ src/intl-carbon.c 2007/10/18 21:44:12
＠＠ -20,13 +20,322 ＠＠
#include <config.h>
#include "lisp.h"
+#include "text.h"
+#include <Carbon/Carbon.h>
+#include <ApplicationServices/ApplicationServices.h>
+
+Lisp_Object Vcarbon_current_language_unicode_set;
+
+#if !defined(__COREFOUNDATION_CFLOCALE__)
+typedef void* CFLocaleRef;
+#endif
+
+struct iso_lang_map
+{
+ Ascbyte* iso_code;
+ short mac_lang_code;
+ short mac_script_code;
+};
+
+typedef struct iso_lang_map iso_lang_map;
+
+iso_lang_map lang_list[] = {
+ { "sq", langAlbanian, smRoman },
+ { "am", langAmharic, smEthiopic },
+ { "ar", langArabic, smArabic },
+ { "hy", langArmenian, smArmenian},
+ { "as", langAssamese, smBengali },
+ { "ay", langAymara, smRoman},
+ { "eu", langBasque, smRoman},
+ { "bn", langBengali, smBengali },
+ { "dz", langDzongkha, smTibetan },
+ { "br", langBreton, smRoman },
+ { "bg", langBulgarian, smCyrillic },
+ { "my", langBurmese, smBurmese },
+ { "km", langKhmer, smKhmer },
+ { "ca", langCatalan, smRoman },
+ { "zh", langTradChinese, smTradChinese },
+ { "hr", langCroatian, smRoman },
+ { "cs", langCzech, smCentralEuroRoman },
+ { "da", langDanish, smRoman },
+ { "nl", langDutch, smRoman },
+ { "en", langEnglish, smRoman },
+ { "eo", langEsperanto, smRoman },
+ { "et", langEstonian, smCentralEuroRoman},
+ { "fo", langFaeroese, smRoman },
+ { "fa", langFarsi, smArabic },
+ { "fi", langFinnish, smRoman },
+ { "fr", langFrench, smRoman },
+ { "ka", langGeorgian, smGeorgian },
+ { "de", langGerman, smRoman },
+ { "el", langGreek, smGreek },
+ { "gn", langGuarani, smRoman },
+ { "gu", langGujarati, smGujarati },
+ { "he", langHebrew, smHebrew },
+ { "iw", langHebrew, smHebrew },
+ { "hu", langHungarian, smCentralEuroRoman },
+ { "is", langIcelandic, smRoman },
+ { "in", langIndonesian, smRoman },
+ { "id", langIndonesian, smRoman },
+ { "iu", langInuktitut, smEthiopic },
+ { "ga", langIrish, smRoman },
+ { "it", langItalian, smRoman },
+ { "ja", langJapanese, smJapanese },
+ { "jw", langJavaneseRom, smRoman },
+ { "kn", langKannada, smKannada },
+ { "ks", langKashmiri, smArabic },
+ { "kk", langKazakh, smCyrillic },
+ { "ky", langKirghiz, smCyrillic },
+ { "ko", langKorean, smKorean },
+ { "ku", langKurdish, smArabic },
+ { "lo", langLao, smLao },
+ { "la", langLatin, smRoman },
+ { "lv", langLatvian, smCentralEuroRoman },
+ { "lt", langLithuanian, smCentralEuroRoman },
+ { "mk", langMacedonian, smCyrillic },
+ { "mg", langMalagasy, smRoman },
+ { "ml", langMalayalam, smMalayalam },
+ { "mt", langMaltese, smRoman },
+ { "mr", langMarathi, smDevanagari },
+ { "mo", langMoldavian, smCyrillic },
+ { "ne", langNepali, smDevanagari },
+ { "no", langNorwegian, smRoman },
+ { "or", langOriya, smOriya },
+ { "om", langOromo, smEthiopic },
+ { "ps", langPashto, smArabic },
+ { "pl", langPolish, smCentralEuroRoman },
+ { "pt", langPortuguese, smRoman },
+ { "pa", langPunjabi, smGurmukhi },
+ { "ro", langRomanian, smRoman },
+ { "ru", langRussian, smCyrillic },
+ { "sa", langSanskrit, smDevanagari },
+ { "sr", langSerbian, smCyrillic },
+ { "sd", langSindhi, smArabic },
+ { "si", langSinhalese, smSinhalese },
+ { "sk", langSlovak, smCentralEuroRoman },
+ { "sl", langSlovenian, smRoman },
+ { "so", langSomali, smRoman },
+ { "es", langSpanish, smRoman },
+ { "su", langSundaneseRom, smRoman },
+ { "sw", langSwahili, smRoman },
+ { "sv", langSwedish, smRoman },
+ { "tl", langTagalog, smRoman },
+ { "tg", langTajiki, smCyrillic },
+ { "ta", langTamil, smTamil },
+ { "tt", langTatar, smCyrillic },
+ { "te", langTelugu, smTelugu },
+ { "th", langThai, smThai },
+ { "bo", langTibetan, smTibetan },
+ { "ti", langTigrinya, smEthiopic },
+ { "tr", langTurkish, smRoman },
+ { "tk", langTurkmen, smCyrillic },
+ { "ug", langUighur, smCyrillic },
+ { "uk", langUkrainian, smCyrillic },
+ { "ur", langUrdu, smArabic },
+ { "uz", langUzbek, smCyrillic },
+ { "vi", langVietnamese, smVietnamese },
+ { "cy", langWelsh, smRoman },
+ { "ji", langYiddish, smHebrew },
+ { "yi", langYiddish, smHebrew },
+ { NULL, 0, 0}
+};
+
+struct iso_country_map
+{
+ Ascbyte* iso_code;
+ short mac_region_code;
+};
+
+typedef struct iso_country_map iso_country_map;
+
+iso_country_map country_list[] = {
+ { "US", verUS},
+ { "EG", verArabic},
+ { "DZ", verArabic},
+ { "AU", verAustralia},
+ { "BE", verFrBelgium },
+ { "CA", verEngCanada },
+ { "CN", verChina },
+ { "HR", verYugoCroatian },
+ { "CY", verCyprus },
+ { "DK", verDenmark },
+ { "EE", verEstonia },
+ { "FI", verFinland },
+ { "FR", verFrance },
+ { "DE", verGermany },
+ { "EL", verGreece },
+ { "HU", verHungary },
+ { "IS", verIceland },
+ { "IN", verIndiaHindi},
+ { "IR", verIran },
+ { "IQ", verArabic },
+ { "IE", verIreland },
+ { "IL", verIsrael },
+ { "IT", verItaly },
+ { "JP", verJapan },
+ { "KP", verKorea },
+ { "LV", verLatvia },
+ { "LY", verArabic },
+ { "LT", verLithuania },
+ { "LU", verFrBelgiumLux },
+ { "MT", verMalta },
+ { "MA", verArabic },
+ { "NL", verNetherlands },
+ { "NO", verNorway },
+ { "PK", verPakistan },
+ { "PL", verPoland },
+ { "PT", verPortugal },
+ { "RU", verRussia },
+ { "SA", verArabic },
+ { "ES", verSpain },
+ { "SE", verSweden },
+ { "CH", verFrSwiss },
+ { "TW", verTaiwan},
+ { "TH", verThailand },
+ { "TN", verArabic},
+ { "TR", verTurkey },
+ { "GB", verBritain },
+ { NULL, 0 }
+};
+
+typedef CFLocaleRef (*fpCFLocaleCopyCurrent_type) (void);
+typedef CFStringRef (*fpCFLocaleGetIdentifier_type) (CFLocaleRef);
+
+static Ibyte *
+carbon_get_pseudo_posix_locale (short scriptCode, short langCode, short regionCode)
+{
+ int i;
+ Bytecount len;
+ int validResultFound = 0;
+ DECLARE_EISTRING (res);
+
+ /* parse language */
+ for (i=0; NULL != lang_list[i].iso_code; i++)
+ {
+ if (langCode == lang_list[i].mac_lang_code &&
+ scriptCode == lang_list[i].mac_script_code)
+ {
+ eicpy_ascii (res, lang_list[i].iso_code);
+ validResultFound = true;
+ break;
+ }
+ }
+
+ /* parse region */
+ for (i=0; NULL != country_list[i].iso_code; i++)
+ {
+ if (regionCode==country_list[i].mac_region_code)
+ {
+ eicat_ch (res, '-');
+ eicat_ascii (res, country_list[i].iso_code);
+ validResultFound = true;
+ break;
+ }
+ }
+
+ if (validResultFound)
+ {
+ len = eilen (res);
+ return eicpyout_malloc (res, &len);
+ }
+
+ return NULL;
+}
+
Lisp_Object Qcarbon_unicode;
+DEFUN ("carbon-current-locale", Fcarbon_current_locale, 0, 0, 0, /*
+Return the current OS X locale.
+
+This reflects the locale used by the Carbon programs on your system, and
+follows the POSIX format, that is, ab_BC, where ab is a language code and BC
+is a country code.
+*/
+ ())
+{
+ /* On MacOSX, the recommended way to get the user's current locale is to use
+ the CFLocale APIs. However, these are only available on 10.3 and later.
+ So for the older systems, we have to keep using the Script Manager APIs. */
+ static int checked = 0;
+ static fpCFLocaleCopyCurrent_type fpCFLocaleCopyCurrent = NULL;
+ static fpCFLocaleGetIdentifier_type fpCFLocaleGetIdentifier = NULL;
+ Lisp_Object res = Qnil;
+
+ if (!checked)
+ {
+ CFBundleRef bundle =
+ CFBundleGetBundleWithIdentifier(CFSTR("com.apple.Carbon"));
+ if (bundle)
+ {
+ // We dynamically load these two functions and only use them if
+ // they are available (OS 10.3+).
+ fpCFLocaleCopyCurrent = (fpCFLocaleCopyCurrent_type)
+ CFBundleGetFunctionPointerForName(bundle,
+ CFSTR("CFLocaleCopyCurrent"));
+ fpCFLocaleGetIdentifier = (fpCFLocaleGetIdentifier_type)
+ CFBundleGetFunctionPointerForName(bundle,
+
CFSTR("CFLocaleGetIdentifier"));
+ }
+ checked = 1;
+ }
+
+ if (fpCFLocaleCopyCurrent)
+ {
+ // Get string representation of user's current locale
+ CFLocaleRef userLocaleRef = fpCFLocaleCopyCurrent();
+ CFStringRef userLocaleStr = fpCFLocaleGetIdentifier(userLocaleRef);
+ int size;
+ Extbyte *buf;
+
+ CFRetain(userLocaleStr);
+
+ size = CFStringGetLength(userLocaleStr);
+ size = (size + 1) * 2;
+ buf = alloca_extbytes (size);
+
+ if (!CFStringGetCString (userLocaleStr, (char *) buf, size,
+ kCFStringEncodingUnicode))
+ {
+ signal_error (Qtext_conversion_error,
+ "Error converting from Carbon text format for locale",
+ Qunbound);
+ }
+
+ res = make_ext_string (buf, size - 2, Qcarbon_unicode);
+
+ CFRelease(userLocaleStr);
+ CFRelease(userLocaleRef);
+ }
+ else
+ {
+ /* Legacy MacOSX locale code */
+ long script = GetScriptManagerVariable(smSysScript);
+ long lang = GetScriptVariable(smSystemScript,smScriptLang);
+ long region = GetScriptManagerVariable(smRegionCode);
+
+ Ibyte *text = carbon_get_pseudo_posix_locale((short)script, (short)lang,
+ (short)region);
+ if (text)
+ {
+ res = make_string (text, qxestrlen(text));
+ }
+ }
+ return res;
+}
+
void
syms_of_intl_carbon (void)
{
+ DEFSUBR (Fcarbon_current_locale);
DEFSYMBOL (Qcarbon_unicode);
+ DEFVAR_LISP ("carbon-current-language-unicode-set",
+ &Vcarbon_current_language_unicode_set /*
+Hash table mapping those Unicode code points needed for the current langenv to t.
+
+Can also be nil; if it is non-nil will normally include all of ASCII.
+*/);
+ Vcarbon_current_language_unicode_set = Qnil;
}
void
Index: src/scrollbar-carbon.c
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/Attic/scrollbar-carbon.c,v
retrieving revision 1.1.2.3
diff -u -u -r1.1.2.3 scrollbar-carbon.c
--- src/scrollbar-carbon.c 2007/09/30 19:48:31 1.1.2.3
+++ src/scrollbar-carbon.c 2007/10/18 21:44:12
＠＠ -307,7 +307,7 ＠＠
}
static void
-carbon_update_scrollbar_instance_status (struct window *w, int active, int size, struct
scrollbar_instance *sb)
+carbon_update_scrollbar_instance_status (struct window * UNUSED (w), int active, int
size, struct scrollbar_instance *sb)
{
SetControlVisibility ((ControlRef) sb->scrollbar_data, active && size,
TRUE);
}
--
On the quay of the little Black Sea port, where the rescued pair came once
more into contact with civilization, Dobrinton was bitten by a dog which was
assumed to be mad, though it may only have been indiscriminating. (Saki)
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://calypso.tux.org/cgi-bin/mailman/listinfo/xemacs-patches