livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge.

master
Nicky 2015-11-09 12:21:49 +01:00
parent 0b90789973 8b8331feab
commit b260451633
17 changed files with 204 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
autobuild.xml
View File

@ -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>

12
indra/llui/llfocusmgr.cpp
View File

@ -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()
{

8
indra/llui/llfocusmgr.h
View File

@ -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();

4
indra/llwindow/llkeyboardwin32.cpp
View File

@ -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;
}
}
}

43
indra/llwindow/llopenglview-objc.mm
View File

@ -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);
}
}

23
indra/llwindow/llwindowmacosx-objc.h
View File

@ -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 callKeyDown(unsigned short key, unsigned int mask);
bool callKeyUp(NSKeyEventRef event, 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);

38
indra/llwindow/llwindowmacosx.cpp
View File

@ -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);
GetEventParameter (mRawKeyEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &key_code);
GetEventParameter (mRawKeyEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
GetEventParameter (mRawKeyEvent, kEventParamKeyboardType, typeUInt32, NULL, sizeof(UInt32), NULL, &keyboard_type);
result["char_code"] = (S32)char_code;
result["key_code"] = (S32)key_code;
result["modifiers"] = (S32)modifiers;
result["keyboard_type"] = (S32)keyboard_type;
result["char_code"] = (S32)(mRawKeyEvent)->mCharacter;
result["scan_code"] = (S32)(mRawKeyEvent)->mScanCode;
result["key_code"] = (S32)(mRawKeyEvent->mKeyCode);
result["modifiers"] = (S32)(mRawKeyEvent->mKeyModifiers);
result["keyboard_type"] = (S32)(mRawKeyEvent->mKeyboardType);
#if 0
// This causes trouble for control characters -- apparently character codes less than 32 (escape, control-A, etc)

2
indra/llwindow/llwindowwin32.h
View File

@ -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);

44
indra/media_plugins/cef/media_plugin_cef.cpp
View File

@ -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;
uint32_t native_virtual_key = 0;
uint32_t native_modifiers = 0;
deserializeKeyboardData(native_key_data, native_scan_code, native_virtual_key, native_modifiers);
mLLCEFLib->keyboardEvent(key_event, native_char_code,
utf8_text.c_str(), modifiers,
native_scan_code, native_virtual_key,
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"]);

2
indra/newview/llappviewer.cpp
View File

@ -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())
{

10
indra/newview/llmediactrl.cpp
View File

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

4
indra/newview/llmediactrl.h
View File

@ -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);

6
indra/newview/llviewermedia.cpp
View File

@ -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);
}
}

17
indra/newview/llviewermediafocus.cpp
View File

@ -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;
}

4
indra/newview/llviewermediafocus.h
View File

@ -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();

1
indra/newview/llviewermessage.cpp
View File

@ -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())

34
indra/newview/llviewerwindow.cpp
View File

@ -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();