diff -ur fltk-1.3.0r9619.org/configure.in fltk-1.3.0r9619/configure.in

--- fltk-1.3.0r9619.org/configure.in	2012-04-22 04:45:09.000000000 +0200

+++ fltk-1.3.0r9619/configure.in	2012-06-18 13:47:33.290447462 +0200

@@ -865,6 +865,8 @@

     Darwin*)

         # MacOS X uses Cocoa for graphics.

         LIBS="$LIBS -framework Cocoa"

+        # And some Carbon for keyboard handling

+        LIBS="$LIBS -framework Carbon"

 	if test x$have_pthread = xyes; then

 	    AC_DEFINE(HAVE_PTHREAD)

diff -ur fltk-1.3.0r9619.org/src/Fl_cocoa.mm fltk-1.3.0r9619/src/Fl_cocoa.mm

--- fltk-1.3.0r9619.org/src/Fl_cocoa.mm	2012-06-16 10:49:52.000000000 +0200

+++ fltk-1.3.0r9619/src/Fl_cocoa.mm	2012-06-18 13:47:42.944910782 +0200

@@ -53,6 +53,7 @@

 #include <math.h>

 #import <Cocoa/Cocoa.h>

+#import <Carbon/Carbon.h>

 #ifndef NSINTEGER_DEFINED // appears with 10.5 in NSObjCRuntime.h

 #if defined(__LP64__) && __LP64__

@@ -114,6 +115,8 @@

 extern Fl_Window* fl_xmousewin;

 #endif

+bool use_simple_keyboard = false;

+

 enum { FLTKTimerEvent = 1, FLTKDataReadyEvent };

@@ -130,6 +133,39 @@

 {

 }

+// Undocumented voodoo. Taken from Mozilla.

+#define ENABLE_ROMAN_KYBDS_ONLY -23

+

+void fl_update_focus(void)

+{

+  Fl_Widget *focus;

+

+  focus = Fl::grab();

+  if (!focus)

+    focus = Fl::focus();

+  if (!focus)

+    return;

+

+  if (focus->simple_keyboard())

+    use_simple_keyboard = true;

+  else

+    use_simple_keyboard = false;

+

+  // Force a "Roman" or "ASCII" keyboard, which both the Mozilla and

+  // Safari people seem to think implies turning off advanced IME stuff

+  // (see nsTSMManager::SyncKeyScript in Mozilla and enableSecureTextInput

+  // in Safari/Webcore). Should be good enough for us then...

+#if (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)

+  CFArrayRef inputSources = TISCreateASCIICapableInputSourceList();

+  TSMSetDocumentProperty(TSMGetActiveDocument(),

+                         kTSMDocumentEnabledInputSourcesPropertyTag,

+                         sizeof(CFArrayRef), &inputSources);

+  CFRelease(inputSources);

+#else

+  KeyScript(use_simple_keyboard ? ENABLE_ROMAN_KYBDS_ONLY : smKeyEnableKybds);

+#endif  

+}

+

 /*

  * Mac keyboard lookup table

  */

@@ -908,6 +944,25 @@

 }

 @end

+static const char* cocoaDead2FLTK(const char *in)

+{

+  if (strcmp(in, "\140") == 0)      // GRAVE ACCENT

+    return "\314\200";              // COMBINING GRAVE ACCENT

+  if (strcmp(in, "\302\264") == 0)  // ACUTE ACCENT

+    return "\314\201";              // COMBINING ACUTE ACCENT

+  if (strcmp(in, "\136") == 0)      // CIRCUMFLEX ACCENT

+    return "\314\202";              // COMBINING CIRCUMFLEX ACCENT

+  if (strcmp(in, "\176") == 0)      // TILDE

+    return "\314\203";              // COMBINING TILDE

+  if (strcmp(in, "\302\250") == 0)  // DIAERESIS

+    return "\314\210";              // COMBINING DIAERESIS

+  // FIXME: OS X dead key behaviour isn't documented and I don't have

+  //        any more keyboards to test with...

+

+  // hope that OS X gave us something proper to begin with

+  return in;

+}

+

 /*

 Handle cocoa keyboard events

 Events during a character composition sequence:

@@ -1648,6 +1703,7 @@

 - (void)rightMouseDragged:(NSEvent *)theEvent;

 - (void)otherMouseDragged:(NSEvent *)theEvent;

 - (void)scrollWheel:(NSEvent *)theEvent;

++ (NSString *)keyTranslate:(UInt16)keyCode withModifierFlags:(UInt32)modifierFlags;

 - (BOOL)handleKeyDown:(NSEvent *)theEvent;

 - (void)keyDown:(NSEvent *)theEvent;

 - (void)keyUp:(NSEvent *)theEvent;

@@ -1726,6 +1782,130 @@

 - (void)scrollWheel:(NSEvent *)theEvent {

   cocoaMouseWheelHandler(theEvent);

 }

++ (NSString *)keyTranslate:(UInt16)keyCode withModifierFlags:(UInt32)modifierFlags {

+  const UCKeyboardLayout *layout;

+  OSStatus err;

+

+  layout = NULL;

+

+#if (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)

+  TISInputSourceRef keyboard;

+  CFDataRef uchr;

+

+  keyboard = TISCopyCurrentKeyboardInputSource();

+  uchr = (CFDataRef)TISGetInputSourceProperty(keyboard,

+                                              kTISPropertyUnicodeKeyLayoutData);

+  if (uchr == NULL)

+    return nil;

+

+  layout = (const UCKeyboardLayout*)CFDataGetBytePtr(uchr);

+#else

+  KeyboardLayoutRef old_layout;

+  int kind;

+

+  err = KLGetCurrentKeyboardLayout(&old_layout);

+  if (err != noErr)

+    return nil;

+

+  err = KLGetKeyboardLayoutProperty(old_layout, kKLKind,

+                                    (const void**)&kind);

+  if (err != noErr)

+    return nil;

+

+  // Old, crufty layout format?

+  if (kind == kKLKCHRKind) {

+    void *kchr_layout;

+

+    UInt32 chars, state;

+    char buf[3];

+

+    unichar result[16];

+    ByteCount in_len, out_len;

+

+    err = KLGetKeyboardLayoutProperty(old_layout, kKLKCHRData,

+                                      (const void**)&kchr_layout);

+    if (err != noErr)

+      return nil;

+

+    state = 0;

+

+    keyCode &= 0x7f;

+    modifierFlags &= 0xff00;

+

+    chars = KeyTranslate(kchr_layout, keyCode | modifierFlags, &state);

+

+    buf[0] = (chars >> 16) & 0xff;

+    buf[1] = chars & 0xff;

+    buf[2] = '\0';

+

+    if (buf[0] == '\0') {

+      buf[0] = buf[1];

+      buf[1] = '\0';

+    }

+

+    // The data is now in some layout specific encoding. Need to convert

+    // this to unicode.

+

+    ScriptCode script;

+    TextEncoding encoding;

+    TECObjectRef converter;

+

+    script = (ScriptCode)GetScriptManagerVariable(smKeyScript);

+

+    err = UpgradeScriptInfoToTextEncoding(script, kTextLanguageDontCare,

+                                          kTextRegionDontCare, NULL,

+                                          &encoding);

+    if (err != noErr)

+      return nil;

+

+    err = TECCreateConverter(&converter, encoding, kTextEncodingUnicodeV4_0);

+    if (err != noErr)

+      return nil;

+

+    in_len = strlen(buf);

+    out_len = sizeof(result);

+

+    err = TECConvertText(converter, (ConstTextPtr)buf, in_len, &in_len,

+                         (TextPtr)result, out_len, &out_len);

+

+    TECDisposeConverter(converter);

+

+    if (err != noErr)

+      return nil;

+

+    return [NSString stringWithCharacters:result

+                     length:(out_len / sizeof(unichar))];

+  }

+

+  if ((kind != kKLKCHRuchrKind) && (kind != kKLuchrKind))

+    return nil;

+

+  err = KLGetKeyboardLayoutProperty(old_layout, kKLuchrData,

+                                    (const void**)&layout);

+  if (err != noErr)

+    return nil;

+#endif

+ 

+  if (layout == NULL)

+    return nil;

+

+  UInt32 dead_state;

+  UniCharCount max_len, actual_len;

+  UniChar string[255];

+

+  dead_state = 0;

+  max_len = sizeof(string)/sizeof(*string);

+

+  modifierFlags = (modifierFlags >> 8) & 0xff;

+

+  err = UCKeyTranslate(layout, keyCode, kUCKeyActionDown, modifierFlags,

+                       LMGetKbdType(), 0, &dead_state, max_len, &actual_len,

+                       string);

+  if (err != noErr)

+    return nil;

+

+  return [NSString stringWithCharacters:string length:actual_len];

+}

 - (BOOL)handleKeyDown:(NSEvent *)theEvent {

   //NSLog(@"handleKeyDown");

   fl_lock_function();

@@ -1752,14 +1932,47 @@

       break;

     }

   }

-  if (!no_text_key && !(Fl::e_state & FL_META) ) {

-    // Don't send cmd-<key> to interpretKeyEvents because it beeps.

+  if (!no_text_key) {

+    // The simple keyboard model will ignore insertText, so we need to grab

+    // the symbol directly from the event. Note that we still use setMarkedText.

+    if (use_simple_keyboard) {

+      NSString *simple_chars;

+      UInt32 modifiers;

+

+      // We want a "normal" symbol out of the event, which basically means

+      // we only respect the shift and alt/altgr modifiers. Cocoa can help

+      // us if we only wanted shift, but as we also want alt/altgr, we'll

+      // have to do some lookup ourselves. This matches our behaviour on

+      // other platforms.

+

+      modifiers = 0;

+      if ([theEvent modifierFlags] & NSAlphaShiftKeyMask)

+        modifiers |= alphaLock;

+      if ([theEvent modifierFlags] & NSShiftKeyMask)

+        modifiers |= shiftKey;

+      if ([theEvent modifierFlags] & NSAlternateKeyMask)

+        modifiers |= optionKey;

+

+      simple_chars = [FLView keyTranslate:[theEvent keyCode]

+                             withModifierFlags:modifiers];

+      if (simple_chars == nil) {

+        // Something went wrong. Fall back to what Cocoa gave us...

+        simple_chars = [theEvent charactersIgnoringModifiers];

+      }

+

+      [FLView prepareEtext:simple_chars];

+    }

+

     // Then we can let the OS have a stab at it and see if it thinks it

     // should result in some text

-    NSText *edit = [[theEvent window]  fieldEditor:YES forObject:nil];

-    in_key_event = true;

-    [edit interpretKeyEvents:[NSArray arrayWithObject:theEvent]];

-    in_key_event = false;

+

+    // Don't send cmd-<key> to interpretKeyEvents because it beeps.

+    if (!(Fl::e_state & FL_META)) {

+      NSText *edit = [[theEvent window]  fieldEditor:YES forObject:nil];

+      in_key_event = true;

+      [edit interpretKeyEvents:[NSArray arrayWithObject:theEvent]];

+      in_key_event = false;

+    }

   }

   //NSLog(@"to text=%@ l=%d", [NSString stringWithUTF8String:Fl::e_text], Fl::e_length);

   int handled = Fl::handle(FL_KEYDOWN, window);

@@ -1937,21 +2150,30 @@

   //NSLog(@"insertText: received=%@",received);

   if (!in_key_event) fl_lock_function();

+

+  // Simple keyboard widgets do not want these side channel inputs.

+  if (use_simple_keyboard)

+    goto end;

+

   [FLView prepareEtext:received];

+

   // We can get called outside of key events (e.g. from the character

-  // palette). Transform such actions to FL_PASTE events.

+  // palette). We need to fake our own key event at that point.

   if (!in_key_event) {

     Fl_Window *target = [(FLWindow*)[self window] getFl_Window];

-    Fl::handle(FL_PASTE, target);

+    Fl::e_keysym = Fl::e_original_keysym = 0;

+    Fl::handle(FL_KEYDOWN, target);

     // for some reason, the window does not redraw until the next mouse move or button push

     // sending a 'redraw()' or 'awake()' does not solve the issue!

     Fl::flush();

   }

+

+end:

   if (!in_key_event) fl_unlock_function();

 }

 - (void)setMarkedText:(id)aString selectedRange:(NSRange)newSelection  {

-  NSString *received;

+  NSString *received, *current, *aggregate;

   if (newSelection.location == 0) {

     [self unmarkText];

     return;

@@ -1962,11 +2184,47 @@

     received = (NSString*)aString;

   }

   //NSLog(@"setMarkedText: %@ %d %d",received,newSelection.location,newSelection.length);

+

+  fl_lock_function();

+

+  // Simple keyboard widgets generally do not want these side channel

+  // inputs, but we have no other way of getting dead keys so we make

+  // an exception in that case.

+  if (use_simple_keyboard) {

+    if (in_key_event && (Fl::e_length == 0)) {

+      [FLView prepareEtext:received];

+

+      Fl::e_text = (char*)cocoaDead2FLTK(Fl::e_text);

+      Fl::e_length = strlen(Fl::e_text);

+    }

+    goto end;

+  }

+

   // This code creates the OS X behaviour of seeing dead keys as things

   // are being composed.

+  //

+  // Note: The concatenation thing is because of how OS X deals with

+  //       invalid sequences. At that point it will spit out one call

+  //       to insertText with the now aborted sequence, and one new

+  //       call to setMarkedText with the new sequence. Since we want

+  //       both to be visible, we need to concatenate.

   next_compose_length = newSelection.location;

-  [FLView prepareEtext:received];

-  //NSLog(@"Fl::e_text=%@ Fl::e_length=%d next_compose_length=%d", received, Fl::e_length, next_compose_length);

+  current = [NSString stringWithUTF8String:Fl::e_text];

+  aggregate = [current stringByAppendingString:received];

+

+  [FLView prepareEtext:aggregate];

+  //NSLog(@"Fl::e_text=%@ Fl::e_length=%d next_compose_length=%d", aggregate, Fl::e_length, next_compose_length);

+

+  // We can get called outside of key events (e.g. from the character

+  // palette). We need to fake our own key event at that point.

+  if (!in_key_event) {

+    Fl_Window *target = [(FLWindow*)[self window] getFl_Window];

+    Fl::e_keysym = Fl::e_original_keysym = 0;

+    Fl::handle(FL_KEYDOWN, target);

+  }

+

+end:

+  fl_unlock_function();

 }

 - (void)unmarkText {