Merge.

autobuild.xml

@@ -1698,11 +1698,11 @@
             <key>archive</key>
             <map>
               <key>hash</key>
-              <string>594967d448010267ca5023e2dc9ee934</string>
+              <string>f222975b084f8ef74b91fcca0c3ef922</string>
               <key>hash_algorithm</key>
               <string>md5</string>
               <key>url</key>
-              <string>http://automated-builds-secondlife-com.s3.amazonaws.com/hg/repo/3p-llceflib_3p-llceflib/rev/306495/arch/Darwin/installer/llceflib-1.2.0.306495-darwin-306495.tar.bz2</string>
+              <string>http://automated-builds-secondlife-com.s3.amazonaws.com/hg/repo/3p-llceflib_3p-llceflib/rev/307407/arch/Darwin/installer/llceflib-1.3.1.307407-darwin-307407.tar.bz2</string>
             </map>
             <key>name</key>
             <string>darwin</string>
@@ -1737,7 +1737,7 @@
           </map>
         </map>
         <key>version</key>
-        <string>1.2.0.306495</string>
+        <string>1.3.1.307407</string>
       </map>
       <key>llphysicsextensions_source</key>
       <map>

indra/llui/llfocusmgr.cpp

@@ -58,6 +58,18 @@ BOOL LLFocusableElement::handleUnicodeChar(llwchar uni_char, BOOL called_from_pa
 	return FALSE;
 }
 
+// virtual 
+bool LLFocusableElement::wantsKeyUpKeyDown() const
+{
+    return false;
+}
+
+//virtual 
+bool LLFocusableElement::wantsReturnKey() const
+{
+    return false;
+}
+
 // virtual
 LLFocusableElement::~LLFocusableElement()
 {

indra/llui/llfocusmgr.h

@@ -60,6 +60,14 @@ public:
 	virtual BOOL	handleKeyUp(KEY key, MASK mask, BOOL called_from_parent);
 	virtual BOOL	handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
 
+    /**
+     * If true this LLFocusableElement wants to receive KEYUP and KEYDOWN messages 
+     * even for normal character strokes.  
+     * Default implementation returns false.
+     */
+    virtual bool    wantsKeyUpKeyDown() const;
+    virtual bool    wantsReturnKey() const;
+
 	virtual void	onTopLost();	// called when registered as top ctrl and user clicks elsewhere
 protected:	
 	virtual void	onFocusReceived();

indra/llwindow/llkeyboardwin32.cpp

@@ -262,7 +262,7 @@ void LLKeyboardWin32::scanKeyboard()
 			// *TODO: I KNOW there must be a better way of
 			// interrogating the key state than this, using async key
 			// state can cause ALL kinds of bugs - Doug
-			if (key < KEY_BUTTON0)
+            if ((key < KEY_BUTTON0) && ((key < '0') || (key > '9')))
 			{
 				// ...under windows make sure the key actually still is down.
 				// ...translate back to windows key
@@ -271,7 +271,7 @@ void LLKeyboardWin32::scanKeyboard()
 				if (!pending_key_events && !(GetAsyncKeyState(virtual_key) & 0x8000))
 				{
  					//LL_INFOS() << "Key up event missed, resetting" << LL_ENDL;
-					mKeyLevel[key] = FALSE;
+    				mKeyLevel[key] = FALSE;
 				}
 			}
 		}

indra/llwindow/llopenglview-objc.mm

@@ -42,6 +42,7 @@
     return screen;
 }
 
+
 - (NSPoint)convertPointToScreenCoordinates:(NSPoint)aPoint
 {
     float normalizedX = fabs(fabs(self.frame.origin.x) - fabs(aPoint.x));
@@ -57,6 +58,24 @@
 
 @end
 
+void extractKeyDataFromEvent (NSEvent *theEvent, NativeKeyEventData * eventData)
+{
+    if ([theEvent characters].length)
+    {
+        eventData->mCharacter = (wchar_t)[[theEvent characters] characterAtIndex:0];
+    }
+    else
+    {
+        eventData->mCharacter = [theEvent keyCode];
+    }
+    eventData->mKeyEvent = NativeKeyEventData::KEYUNKNOWN;
+    eventData->mKeyCode = [theEvent keyCode];
+    eventData->mKeyModifiers = [theEvent modifierFlags];
+    eventData->mScanCode = [theEvent keyCode ];
+    eventData->mKeyboardType = 0;
+}
+
+
 attributedStringInfo getSegments(NSAttributedString *str)
 {
 	attributedStringInfo segments;
@@ -413,11 +432,20 @@ attributedStringInfo getSegments(NSAttributedString *str)
 
 - (void) keyUp:(NSEvent *)theEvent
 {
-	callKeyUp([theEvent keyCode], [theEvent modifierFlags]);
+    NativeKeyEventData eventData;
+ 
+    extractKeyDataFromEvent( theEvent, &eventData );
+    eventData.mKeyEvent = NativeKeyEventData::KEYUP;
+	callKeyUp(&eventData, [theEvent keyCode], [theEvent modifierFlags]);
 }
 
 - (void) keyDown:(NSEvent *)theEvent
 {
+    NativeKeyEventData eventData;
+    
+    extractKeyDataFromEvent( theEvent, &eventData );
+    eventData.mKeyEvent = NativeKeyEventData::KEYDOWN;
+   
     uint keycode = [theEvent keyCode];
     // We must not depend on flagsChange event to detect modifier flags changed,
     // must depend on the modifire flags in the event parameter.
@@ -425,7 +453,7 @@ attributedStringInfo getSegments(NSAttributedString *str)
     // e.g. OS Window for upload something or Input Window...
     // mModifiers instance variable is for insertText: or insertText:replacementRange:  (by Pell Smit)
 	mModifiers = [theEvent modifierFlags];
-    bool acceptsText = mHasMarkedText ? false : callKeyDown(keycode, mModifiers);
+    bool acceptsText = mHasMarkedText ? false : callKeyDown(&eventData, keycode, mModifiers);
     unichar ch;
     if (acceptsText &&
         !mMarkedTextAllowed &&
@@ -447,6 +475,7 @@ attributedStringInfo getSegments(NSAttributedString *str)
     // <FS:Ansariel> Cinder Roxley's fix for FIRE-11648
     //if (mModifiers & NSCommandKeyMask && !mHasMarkedText)
     //{
+    //    eventData.mKeyEvent = NativeKeyEventData::KEYUP;
     //    callKeyUp([theEvent keyCode], mModifiers);
     //}
     // </FS:Ansariel>
@@ -454,6 +483,10 @@ attributedStringInfo getSegments(NSAttributedString *str)
 
 - (void)flagsChanged:(NSEvent *)theEvent
 {
+    NativeKeyEventData eventData;
+    
+    extractKeyDataFromEvent( theEvent, &eventData );
+ 
 	mModifiers = [theEvent modifierFlags];
 	callModifier([theEvent modifierFlags]);
      
@@ -475,11 +508,13 @@ attributedStringInfo getSegments(NSAttributedString *str)
     
     if (mModifiers & mask)
     {
-        callKeyDown([theEvent keyCode], 0);
+        eventData.mKeyEvent = NativeKeyEventData::KEYDOWN;
+        callKeyDown(&eventData, [theEvent keyCode], 0);
     }
     else
     {
-        callKeyUp([theEvent keyCode], 0);
+        eventData.mKeyEvent = NativeKeyEventData::KEYUP;
+        callKeyUp(&eventData, [theEvent keyCode], 0);
     }  
 }
 

indra/llwindow/llwindowmacosx-objc.h

@@ -46,6 +46,25 @@ typedef void *CursorRef;
 typedef void *NSWindowRef;
 typedef void *GLViewRef;
 
+
+struct NativeKeyEventData {
+    enum EventType {
+        KEYUNKNOWN,
+        KEYUP,
+        KEYDOWN,
+        KEYCHAR
+    };
+    
+    EventType   mKeyEvent;
+    uint32_t    mKeyCode;
+    uint32_t    mScanCode;
+    uint32_t    mKeyModifiers;
+    uint32_t    mKeyboardType;
+    wchar_t     mCharacter;
+};
+
+typedef const NativeKeyEventData * NSKeyEventRef;
+
 // These are defined in llappviewermacosx.cpp.
 bool initViewer();
 void handleQuit();
@@ -103,8 +122,8 @@ void setupInputWindow(NSWindowRef window, GLViewRef view);
 
 // These are all implemented in llwindowmacosx.cpp.
 // This is largely for easier interop between Obj-C and C++ (at least in the viewer's case due to the BOOL vs. BOOL conflict)
-bool callKeyUp(unsigned short key, unsigned int mask);
+bool callKeyUp(NSKeyEventRef event, unsigned short key, unsigned int mask);
-bool callKeyDown(unsigned short key, unsigned int mask);
+bool callKeyDown(NSKeyEventRef event, unsigned short key, unsigned int mask);
 void callResetKeys();
 bool callUnicodeCallback(wchar_t character, unsigned int mask);
 void callRightMouseDown(float *pos, unsigned int mask);

indra/llwindow/llwindowmacosx.cpp

@@ -51,6 +51,10 @@ BOOL check_for_card(const char* RENDERER, const char* bad_card);
 const char* cursorIDToName(int id);
 // </FS:CR>
 
+namespace
+{
+    NSKeyEventRef mRawKeyEvent = NULL;
+}
 //
 // LLWindowMacOSX
 //
@@ -203,14 +207,20 @@ LLWindowMacOSX::LLWindowMacOSX(LLWindowCallbacks* callbacks,
 // These functions are used as wrappers for our internal event handling callbacks.
 // It's a good idea to wrap these to avoid reworking more code than we need to within LLWindow.
 
-bool callKeyUp(unsigned short key, unsigned int mask)
+bool callKeyUp(NSKeyEventRef event, unsigned short key, unsigned int mask)
 {
-	return gKeyboard->handleKeyUp(key, mask);
+    mRawKeyEvent = event;
+	bool retVal = gKeyboard->handleKeyUp(key, mask);
+    mRawKeyEvent = NULL;
+    return retVal;
 }
 
-bool callKeyDown(unsigned short key, unsigned int mask)
+bool callKeyDown(NSKeyEventRef event, unsigned short key, unsigned int mask)
 {
-	return gKeyboard->handleKeyDown(key, mask);
+    mRawKeyEvent = event;
+	bool retVal = gKeyboard->handleKeyDown(key, mask);
+    mRawKeyEvent = NULL;
+    return retVal;
 }
 
 void callResetKeys()
@@ -1766,23 +1776,15 @@ void LLWindowMacOSX::openFile(const std::string& file_name )
 LLSD LLWindowMacOSX::getNativeKeyData()
 {
 	LLSD result = LLSD::emptyMap();
-#if 0
+#if 1
 	if(mRawKeyEvent)
 	{
-		char char_code = 0;
-		UInt32 key_code = 0;
-		UInt32 modifiers = 0;
-		UInt32 keyboard_type = 0;
 
-		GetEventParameter (mRawKeyEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &char_code);
+        result["char_code"] = (S32)(mRawKeyEvent)->mCharacter;
-		GetEventParameter (mRawKeyEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &key_code);
+        result["scan_code"] = (S32)(mRawKeyEvent)->mScanCode;
-		GetEventParameter (mRawKeyEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
+		result["key_code"] = (S32)(mRawKeyEvent->mKeyCode);
-		GetEventParameter (mRawKeyEvent, kEventParamKeyboardType, typeUInt32, NULL, sizeof(UInt32), NULL, &keyboard_type);
+		result["modifiers"] = (S32)(mRawKeyEvent->mKeyModifiers);
-
+		result["keyboard_type"] = (S32)(mRawKeyEvent->mKeyboardType);
-		result["char_code"] = (S32)char_code;
-		result["key_code"] = (S32)key_code;
-		result["modifiers"] = (S32)modifiers;
-		result["keyboard_type"] = (S32)keyboard_type;
 
 #if 0
 		// This causes trouble for control characters -- apparently character codes less than 32 (escape, control-A, etc)

indra/llwindow/llwindowwin32.h

@@ -132,7 +132,7 @@ protected:
 	HCURSOR loadColorCursor(LPCTSTR name);
 	BOOL	isValid();
 	void	moveWindow(const LLCoordScreen& position,const LLCoordScreen& size);
-	LLSD	getNativeKeyData();
+	virtual LLSD	getNativeKeyData();
 
 	// Changes display resolution. Returns true if successful
 	BOOL	setDisplayResolution(S32 width, S32 height, S32 bits, S32 refresh);

indra/media_plugins/cef/media_plugin_cef.cpp

@@ -138,7 +138,7 @@ MediaPluginBase(host_send_func, host_user_data)
 //
 MediaPluginCEF::~MediaPluginCEF()
 {
-	mLLCEFLib->reset();
+	mLLCEFLib->requestExit();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -555,11 +555,12 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 			}
 			else if (message_name == "scroll_event")
 			{
+				S32 x = message_in.getValueS32("y");
 				S32 y = message_in.getValueS32("y");
 				const int scaling_factor = 40;
 				y *= -scaling_factor;
 
-				mLLCEFLib->mouseWheel(y);
+				mLLCEFLib->mouseWheel(x, y);
 			}
 			else if (message_name == "text_event")
 			{
@@ -574,6 +575,9 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 #if LL_DARWIN
 				std::string event = message_in.getValue("event");
 				S32 key = message_in.getValueS32("key");
+                LLSD native_key_data = message_in.getValueLLSD("native_key_data");
+
+#if 0
 				if (event == "down")
 				{
 					//mLLCEFLib->keyPress(key, true);
@@ -585,7 +589,21 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 					//mLLCEFLib->keyPress(key, false);
 					mLLCEFLib->keyboardEvent(LLCEFLib::KE_KEY_UP, (uint32_t)key, 0, LLCEFLib::KM_MODIFIER_NONE, 0, 0, 0);
 				}
+#else
+                // Treat unknown events as key-up for safety.
+                LLCEFLib::EKeyEvent key_event = LLCEFLib::KE_KEY_UP;
+                if (event == "down")
+                {
+                    key_event = LLCEFLib::KE_KEY_DOWN;
+                }
+                else if (event == "repeat")
+                {
+                    key_event = LLCEFLib::KE_KEY_REPEAT;
+                }
 
+                keyEvent(key_event, key, LLCEFLib::KM_MODIFIER_NONE, native_key_data);
+
+#endif
 #elif LL_WINDOWS
 				std::string event = message_in.getValue("event");
 				S32 key = message_in.getValueS32("key");
@@ -745,12 +763,20 @@ void MediaPluginCEF::keyEvent(LLCEFLib::EKeyEvent key_event, int key, LLCEFLib::
 #if LL_DARWIN || LL_LINUX
 	std::string utf8_text;
 
+    uint32_t native_char_code = native_key_data["char_code"].asInteger();
+    uint32_t native_scan_code = native_key_data["scan_code"].asInteger();
+    uint32_t native_virtual_key = native_key_data["key_code"].asInteger();
+    uint32_t native_modifiers = native_key_data["modifiers"].asInteger();
+
+
+
 	if (key < 128)
 	{
-		utf8_text = (char)key;
+		utf8_text = (char)native_virtual_key;
 	}
 
 	switch ((KEY)key)
+
 	{
 		case KEY_BACKSPACE:		utf8_text = (char)8;		break;
 		case KEY_TAB:			utf8_text = (char)9;		break;
@@ -762,16 +788,16 @@ void MediaPluginCEF::keyEvent(LLCEFLib::EKeyEvent key_event, int key, LLCEFLib::
 		break;
 	}
 
-	uint32_t native_scan_code = 0;
+	mLLCEFLib->keyboardEvent(key_event, native_char_code,
-	uint32_t native_virtual_key = 0;
+							  utf8_text.c_str(), modifiers,
-	uint32_t native_modifiers = 0;
+							  native_scan_code, native_virtual_key,
-	deserializeKeyboardData(native_key_data, native_scan_code, native_virtual_key, native_modifiers);
+							  native_modifiers);
 
-	mLLCEFLib->keyboardEvent(key_event, (uint32_t)key, utf8_text.c_str(), modifiers, native_scan_code, native_virtual_key, native_modifiers);
 #elif LL_WINDOWS
 	U32 msg = ll_U32_from_sd(native_key_data["msg"]);
 	U32 wparam = ll_U32_from_sd(native_key_data["w_param"]);
 	U64 lparam = ll_U32_from_sd(native_key_data["l_param"]);
+
 	mLLCEFLib->nativeKeyboardEvent(msg, wparam, lparam);
 #endif
 };
@@ -780,7 +806,7 @@ void MediaPluginCEF::unicodeInput(const std::string &utf8str, LLCEFLib::EKeyboar
 {
 #if LL_DARWIN
 	//mLLCEFLib->keyPress(utf8str[0], true);
-	mLLCEFLib->keyboardEvent(LLCEFLib::KE_KEY_DOWN, (uint32_t)(utf8str[0]), 0, LLCEFLib::KM_MODIFIER_NONE, 0, 0, 0);
+	//mLLCEFLib->keyboardEvent(LLCEFLib::KE_KEY_DOWN, (uint32_t)(utf8str[0]), 0, LLCEFLib::KM_MODIFIER_NONE, 0, 0, 0);
 #elif LL_WINDOWS
 	U32 msg = ll_U32_from_sd(native_key_data["msg"]);
 	U32 wparam = ll_U32_from_sd(native_key_data["w_param"]);

indra/newview/llappviewer.cpp

@@ -3311,7 +3311,7 @@ bool LLAppViewer::initConfiguration()
 	//
 	gWindowTitle = LLVersionInfo::getChannelAndVersion();	// <FS:CR>
 #if LL_DEBUG
-	gWindowTitle += std::string(" [DEBUG]")
+    gWindowTitle += std::string(" [DEBUG]");
 #endif
 	if (!gArgs.empty())
 	{

indra/newview/llmediactrl.cpp

@@ -1212,3 +1212,13 @@ void LLMediaCtrl::updateContextMenuParent(LLView* pNewParent)
 {
 	mContextMenu->updateParent(pNewParent);
 }
+
+bool LLMediaCtrl::wantsKeyUpKeyDown() const
+{
+    return true;
+}
+
+bool LLMediaCtrl::wantsReturnKey() const
+{
+    return true;
+}

indra/newview/llmediactrl.h

@@ -173,6 +173,10 @@ public:
 
 		void updateContextMenuParent(LLView* pNewParent);
 
+        // The Browser windows want keyup and keydown events. Overridden from LLFocusableElement to return true.
+        virtual bool    wantsKeyUpKeyDown() const;
+        virtual bool    wantsReturnKey() const;
+
 	protected:
 		void convertInputCoords(S32& x, S32& y);
 

indra/newview/llviewermedia.cpp

@@ -1478,7 +1478,8 @@ void LLViewerMedia::setOpenIDCookie(const std::string& url)
 				std::string cookie_name = "";
 				std::string cookie_value = "";
 				std::string cookie_path = "";
-				if (parseRawCookie(sOpenIDCookie, cookie_name, cookie_value, cookie_path))
+				if (parseRawCookie(sOpenIDCookie, cookie_name, cookie_value, cookie_path) &&
+                    media_instance->getMediaPlugin())
 				{
 					media_instance->getMediaPlugin()->setCookie(url, cookie_name, cookie_value, cookie_host, cookie_path);
 				}
@@ -2808,8 +2809,7 @@ bool LLViewerMediaImpl::handleKeyHere(KEY key, MASK mask)
 
 		if (!result)
 		{
-
+            LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
-			LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
 			result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_DOWN, key, mask, native_key_data);
 		}
 	}

indra/newview/llviewermediafocus.cpp

@@ -354,7 +354,12 @@ BOOL LLViewerMediaFocus::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 
 BOOL LLViewerMediaFocus::handleKeyUp(KEY key, MASK mask, BOOL called_from_parent)
 {
-	return true;
+    LLViewerMediaImpl* media_impl = getFocusedMediaImpl();
+    if (media_impl)
+    {
+        media_impl->handleKeyUpHere(key, mask);
+    }
+    return true;
 }
 
 
@@ -610,3 +615,13 @@ LLUUID LLViewerMediaFocus::getControlsMediaID()
 	
 	return LLUUID::null;
 }
+
+bool LLViewerMediaFocus::wantsKeyUpKeyDown() const
+{
+    return true;
+}
+
+bool LLViewerMediaFocus::wantsReturnKey() const
+{
+    return true;
+}

indra/newview/llviewermediafocus.h

@@ -88,6 +88,10 @@ public:
 	// Return the ID of the media instance the controls are currently attached to (either focus or hover).
 	LLUUID getControlsMediaID();
 
+    // The MoaP object wants keyup and keydown events.  Overridden to return true.
+    virtual bool    wantsKeyUpKeyDown() const;
+    virtual bool    wantsReturnKey() const;
+
 protected:
 	/*virtual*/ void	onFocusReceived();
 	/*virtual*/ void	onFocusLost();

indra/newview/llviewermessage.cpp

@@ -7117,6 +7117,7 @@ static void process_money_balance_reply_extended(LLMessageSystem* msg)
 			}
 		}
 		final_args["SLURLMESSAGE"] = message;
+		payload["dest_id"] = dest_id;
 
 		args["NAME"] = dest_slurl_name;
 		if (!reason.empty())

indra/newview/llviewerwindow.cpp

@@ -1463,7 +1463,11 @@ BOOL LLViewerWindow::handleTranslatedKeyDown(KEY key,  MASK mask, BOOL repeated)
 	// it's all entered/processed.
 	if (key == KEY_RETURN && mask == MASK_NONE)
 	{
-		return FALSE;
+        // RIDER: although, at times some of the controlls (in particular the CEF viewer
+        // would like to know about the KEYDOWN for an enter key... so ask and pass it along.
+        LLFocusableElement* keyboard_focus = gFocusMgr.getKeyboardFocus();
+        if (keyboard_focus && !keyboard_focus->wantsReturnKey())
+    		return FALSE;
 	}
 
 	return gViewerKeyboard.handleKey(key, mask, repeated);
@@ -2906,22 +2910,27 @@ void LLViewerWindow::setTitle(const std::string& win_title)
 }
 //-TT
 
-// Takes a single keydown event, usually when UI is visible
+// Takes a single keyup event, usually when UI is visible
 BOOL LLViewerWindow::handleKeyUp(KEY key, MASK mask)
 {
-	if (gFocusMgr.getKeyboardFocus()
+    LLFocusableElement* keyboard_focus = gFocusMgr.getKeyboardFocus();
+
+    if (keyboard_focus
 		&& !(mask & (MASK_CONTROL | MASK_ALT))
 		&& !gFocusMgr.getKeystrokesOnly())
 	{
 		// We have keyboard focus, and it's not an accelerator
-		if (key < 0x80)
+        if (keyboard_focus && keyboard_focus->wantsKeyUpKeyDown())
+        {
+            return keyboard_focus->handleKeyUp(key, mask, FALSE);
+        }
+        else if (key < 0x80)
 		{
 			// Not a special key, so likely (we hope) to generate a character.  Let it fall through to character handler first.
 			return (gFocusMgr.getKeyboardFocus() != NULL);
 		}
 	}
 
-	LLFocusableElement* keyboard_focus = gFocusMgr.getKeyboardFocus();
 	if (keyboard_focus)
 	{
 		if (keyboard_focus->handleKeyUp(key, mask, FALSE))
@@ -2947,15 +2956,21 @@ BOOL LLViewerWindow::handleKey(KEY key, MASK mask)
 	// hide tooltips on keypress
 	LLToolTipMgr::instance().blockToolTips();
 
-	if (gFocusMgr.getKeyboardFocus() 
+    LLFocusableElement* keyboard_focus = gFocusMgr.getKeyboardFocus();
+
+    if (keyboard_focus
 		&& !(mask & (MASK_CONTROL | MASK_ALT))
 		&& !gFocusMgr.getKeystrokesOnly())
 	{
 		// We have keyboard focus, and it's not an accelerator
-		if (key < 0x80)
+        if (keyboard_focus && keyboard_focus->wantsKeyUpKeyDown())
+        {
+            return keyboard_focus->handleKey(key, mask, FALSE );
+        }
+		else if (key < 0x80)
 		{
 			// Not a special key, so likely (we hope) to generate a character.  Let it fall through to character handler first.
-			return (gFocusMgr.getKeyboardFocus() != NULL);
+            return (keyboard_focus != NULL);
 		}
 	}
 
@@ -2969,7 +2984,6 @@ BOOL LLViewerWindow::handleKey(KEY key, MASK mask)
 		return TRUE;
 	}
 
-	LLFocusableElement* keyboard_focus = gFocusMgr.getKeyboardFocus();
 
 	// give menus a chance to handle modified (Ctrl, Alt) shortcut keys before current focus 
 	// as long as focus isn't locked
@@ -2995,7 +3009,7 @@ BOOL LLViewerWindow::handleKey(KEY key, MASK mask)
 	// give floaters first chance to handle TAB key
 	// so frontmost floater gets focus
 	// if nothing has focus, go to first or last UI element as appropriate
-	if (key == KEY_TAB && (mask & MASK_CONTROL || gFocusMgr.getKeyboardFocus() == NULL))
+    if (key == KEY_TAB && (mask & MASK_CONTROL || keyboard_focus == NULL))
 	{
 		LL_WARNS() << "LLviewerWindow::handleKey give floaters first chance at tab key " << LL_ENDL;
 		if (gMenuHolder) gMenuHolder->hideMenus();