/** * @file media_plugin_webkit.cpp * @brief Webkit plugin for LLMedia API plugin system * * @cond * $LicenseInfo:firstyear=2008&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ * @endcond */ #include "llqtwebkit.h" #include "linden_common.h" #include "indra_constants.h" // for indra keyboard codes #include "lltimer.h" #include "llgl.h" #include "llplugininstance.h" #include "llpluginmessage.h" #include "llpluginmessageclasses.h" #include "media_plugin_base.h" // set to 1 if you're using the version of llqtwebkit that's QPixmap-ified #if LL_LINUX # define LL_QTWEBKIT_USES_PIXMAPS 0 extern "C" { # include <glib.h> # include <glib-object.h> } #else # define LL_QTWEBKIT_USES_PIXMAPS 0 #endif // LL_LINUX # include "volume_catcher.h" #if LL_WINDOWS # include <direct.h> #else # include <unistd.h> # include <stdlib.h> #endif #if LL_WINDOWS // *NOTE:Mani - This captures the module handle for the dll. This is used below // to get the path to this dll for webkit initialization. // I don't know how/if this can be done with apr... namespace { HMODULE gModuleHandle;}; BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { gModuleHandle = (HMODULE) hinstDLL; return TRUE; } #endif //////////////////////////////////////////////////////////////////////////////// // class MediaPluginWebKit : public MediaPluginBase, public LLEmbeddedBrowserWindowObserver { public: MediaPluginWebKit(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data); ~MediaPluginWebKit(); /*virtual*/ void receiveMessage(const char *message_string); private: std::string mProfileDir; std::string mHostLanguage; std::string mUserAgent; bool mCookiesEnabled; bool mJavascriptEnabled; bool mPluginsEnabled; bool mEnableMediaPluginDebugging; enum { INIT_STATE_UNINITIALIZED, // LLQtWebkit hasn't been set up yet INIT_STATE_INITIALIZED, // LLQtWebkit has been set up, but no browser window has been created yet. INIT_STATE_NAVIGATING, // Browser instance has been set up and initial navigate to about:blank has been issued INIT_STATE_NAVIGATE_COMPLETE, // initial navigate to about:blank has completed INIT_STATE_WAIT_REDRAW, // First real navigate begin has been received, waiting for page changed event to start handling redraws INIT_STATE_WAIT_COMPLETE, // Waiting for first real navigate complete event INIT_STATE_RUNNING // All initialization gymnastics are complete. }; int mBrowserWindowId; int mInitState; std::string mInitialNavigateURL; bool mNeedsUpdate; bool mCanCut; bool mCanCopy; bool mCanPaste; int mLastMouseX; int mLastMouseY; bool mFirstFocus; F32 mBackgroundR; F32 mBackgroundG; F32 mBackgroundB; std::string mTarget; LLTimer mElapsedTime; VolumeCatcher mVolumeCatcher; void postDebugMessage( const std::string& msg ) { if ( mEnableMediaPluginDebugging ) { std::stringstream str; str << "@Media Msg> " << "[" << (double)mElapsedTime.getElapsedTimeF32() << "] -- " << msg; LLPluginMessage debug_message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "debug_message"); debug_message.setValue("message_text", str.str()); debug_message.setValue("message_level", "info"); sendMessage(debug_message); } } void setInitState(int state) { // std::cerr << "changing init state to " << state << std::endl; mInitState = state; } //////////////////////////////////////////////////////////////////////////////// // void update(int milliseconds) { #if LL_QTLINUX_DOESNT_HAVE_GLIB // pump glib generously, as Linux browser plugins are on the // glib main loop, even if the browser itself isn't - ugh // This is NOT NEEDED if Qt itself was built with glib // mainloop integration. GMainContext *mainc = g_main_context_default(); while(g_main_context_iteration(mainc, FALSE)); #endif // LL_QTLINUX_DOESNT_HAVE_GLIB // pump qt LLQtWebKit::getInstance()->pump( milliseconds ); mVolumeCatcher.pump(); checkEditState(); if(mInitState == INIT_STATE_NAVIGATE_COMPLETE) { if(!mInitialNavigateURL.empty()) { // We already have the initial navigate URL -- kick off the navigate. LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, mInitialNavigateURL ); mInitialNavigateURL.clear(); } } if ( (mInitState > INIT_STATE_WAIT_REDRAW) && mNeedsUpdate ) { const unsigned char* browser_pixels = LLQtWebKit::getInstance()->grabBrowserWindow( mBrowserWindowId ); unsigned int rowspan = LLQtWebKit::getInstance()->getBrowserRowSpan( mBrowserWindowId ); unsigned int height = LLQtWebKit::getInstance()->getBrowserHeight( mBrowserWindowId ); #if !LL_QTWEBKIT_USES_PIXMAPS unsigned int buffer_size = rowspan * height; #endif // !LL_QTWEBKIT_USES_PIXMAPS // std::cerr << "webkit plugin: updating" << std::endl; // TODO: should get rid of this memcpy if possible if ( mPixels && browser_pixels ) { // std::cerr << " memcopy of " << buffer_size << " bytes" << std::endl; #if LL_QTWEBKIT_USES_PIXMAPS // copy the pixel data upside-down because of the co-ord system for (int y=0; y<height; ++y) { memcpy( &mPixels[(height-y-1)*rowspan], &browser_pixels[y*rowspan], rowspan ); } #else memcpy( mPixels, browser_pixels, buffer_size ); #endif // LL_QTWEBKIT_USES_PIXMAPS } if ( mWidth > 0 && mHeight > 0 ) { // std::cerr << "Setting dirty, " << mWidth << " x " << mHeight << std::endl; setDirty( 0, 0, mWidth, mHeight ); } mNeedsUpdate = false; }; }; //////////////////////////////////////////////////////////////////////////////// // bool initBrowser() { // already initialized if ( mInitState > INIT_STATE_UNINITIALIZED ) return true; // set up directories char cwd[ FILENAME_MAX ]; // I *think* this is defined on all platforms we use if (NULL == getcwd( cwd, FILENAME_MAX - 1 )) { llwarns << "Couldn't get cwd - probably too long - failing to init." << llendl; return false; } std::string application_dir = std::string( cwd ); #if LL_LINUX // take care to initialize glib properly, because some // versions of Qt don't, and we indirectly need it for (some // versions of) Flash to not crash the browser. if (!g_thread_supported ()) g_thread_init (NULL); g_type_init(); #endif #if LL_DARWIN // When running under the Xcode debugger, there's a setting called "Break on Debugger()/DebugStr()" which defaults to being turned on. // This causes the environment variable USERBREAK to be set to 1, which causes these legacy calls to break into the debugger. // This wouldn't cause any problems except for the fact that the current release version of the Flash plugin has a call to Debugger() in it // which gets hit when the plugin is probed by webkit. // Unsetting the environment variable here works around this issue. unsetenv("USERBREAK"); #endif #if LL_WINDOWS //*NOTE:Mani - On windows, at least, the component path is the // location of this dll's image file. std::string component_dir; char dll_path[_MAX_PATH]; DWORD len = GetModuleFileNameA(gModuleHandle, (LPCH)&dll_path, _MAX_PATH); while(len && dll_path[ len ] != ('\\') ) { len--; } if(len >= 0) { dll_path[len] = 0; component_dir = dll_path; } else { // *NOTE:Mani - This case should be an rare exception. // GetModuleFileNameA should always give you a full path, no? component_dir = application_dir; } #else std::string component_dir = application_dir; #endif // debug spam sent to viewer and displayed in the log as usual postDebugMessage( "Component dir set to: " + component_dir ); // window handle - needed on Windows and must be app window. #if LL_WINDOWS char window_title[ MAX_PATH ]; GetConsoleTitleA( window_title, MAX_PATH ); void* native_window_handle = (void*)FindWindowA( NULL, window_title ); #else void* native_window_handle = 0; #endif // main browser initialization bool result = LLQtWebKit::getInstance()->init( application_dir, component_dir, mProfileDir, native_window_handle ); if ( result ) { mInitState = INIT_STATE_INITIALIZED; // debug spam sent to viewer and displayed in the log as usual postDebugMessage( "browser initialized okay" ); return true; }; // debug spam sent to viewer and displayed in the log as usual postDebugMessage( "browser nOT initialized." ); return false; }; //////////////////////////////////////////////////////////////////////////////// // bool initBrowserWindow() { // already initialized if ( mInitState > INIT_STATE_INITIALIZED ) return true; // not enough information to initialize the browser yet. if ( mWidth < 0 || mHeight < 0 || mDepth < 0 || mTextureWidth < 0 || mTextureHeight < 0 ) { return false; }; // Set up host language before creating browser window if(!mHostLanguage.empty()) { LLQtWebKit::getInstance()->setHostLanguage(mHostLanguage); postDebugMessage( "Setting language to " + mHostLanguage ); } // turn on/off cookies based on what host app tells us LLQtWebKit::getInstance()->enableCookies( mCookiesEnabled ); // turn on/off plugins based on what host app tells us LLQtWebKit::getInstance()->enablePlugins( mPluginsEnabled ); // turn on/off Javascript based on what host app tells us #if LLQTWEBKIT_API_VERSION >= 11 LLQtWebKit::getInstance()->enableJavaScript( mJavascriptEnabled ); #else LLQtWebKit::getInstance()->enableJavascript( mJavascriptEnabled ); #endif std::stringstream str; str << "Cookies enabled = " << mCookiesEnabled << ", plugins enabled = " << mPluginsEnabled << ", Javascript enabled = " << mJavascriptEnabled; postDebugMessage( str.str() ); // create single browser window mBrowserWindowId = LLQtWebKit::getInstance()->createBrowserWindow( mWidth, mHeight, mTarget); str.str(""); str.clear(); str << "Setting browser window size to " << mWidth << " x " << mHeight; postDebugMessage( str.str() ); // tell LLQtWebKit about the size of the browser window LLQtWebKit::getInstance()->setSize( mBrowserWindowId, mWidth, mHeight ); // observer events that LLQtWebKit emits LLQtWebKit::getInstance()->addObserver( mBrowserWindowId, this ); // append details to agent string LLQtWebKit::getInstance()->setBrowserAgentId( mUserAgent ); postDebugMessage( "Updating user agent with " + mUserAgent ); #if !LL_QTWEBKIT_USES_PIXMAPS // don't flip bitmap LLQtWebKit::getInstance()->flipWindow( mBrowserWindowId, true ); #endif // !LL_QTWEBKIT_USES_PIXMAPS // set background color // convert background color channels from [0.0, 1.0] to [0, 255]; LLQtWebKit::getInstance()->setBackgroundColor( mBrowserWindowId, int(mBackgroundR * 255.0f), int(mBackgroundG * 255.0f), int(mBackgroundB * 255.0f) ); // Set state _before_ starting the navigate, since onNavigateBegin might get called before this call returns. setInitState(INIT_STATE_NAVIGATING); // Don't do this here -- it causes the dreaded "white flash" when loading a browser instance. // FIXME: Re-added this because navigating to a "page" initializes things correctly - especially // for the HTTP AUTH dialog issues (DEV-41731). Will fix at a later date. // Build a data URL like this: "data:text/html,%3Chtml%3E%3Cbody bgcolor=%22#RRGGBB%22%3E%3C/body%3E%3C/html%3E" // where RRGGBB is the background color in HTML style std::stringstream url; url << "data:text/html,%3Chtml%3E%3Cbody%20bgcolor=%22#"; // convert background color channels from [0.0, 1.0] to [0, 255]; url << std::setfill('0') << std::setw(2) << std::hex << int(mBackgroundR * 255.0f); url << std::setfill('0') << std::setw(2) << std::hex << int(mBackgroundG * 255.0f); url << std::setfill('0') << std::setw(2) << std::hex << int(mBackgroundB * 255.0f); url << "%22%3E%3C/body%3E%3C/html%3E"; //lldebugs << "data url is: " << url.str() << llendl; // always display loading overlay now #if LLQTWEBKIT_API_VERSION >= 16 LLQtWebKit::getInstance()->enableLoadingOverlay(mBrowserWindowId, true); #else llwarns << "Ignoring enableLoadingOverlay() call (llqtwebkit version is too old)." << llendl; #endif str.clear(); str << "Loading overlay enabled = " << mEnableMediaPluginDebugging << " for mBrowserWindowId = " << mBrowserWindowId; postDebugMessage( str.str() ); LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, url.str() ); // LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, "about:blank" ); return true; } void setVolume(F32 vol); //////////////////////////////////////////////////////////////////////////////// // virtual void onCursorChanged(const EventType& event) { LLQtWebKit::ECursor llqt_cursor = (LLQtWebKit::ECursor)event.getIntValue(); std::string name; switch(llqt_cursor) { case LLQtWebKit::C_ARROW: name = "arrow"; break; case LLQtWebKit::C_IBEAM: name = "ibeam"; break; case LLQtWebKit::C_SPLITV: name = "splitv"; break; case LLQtWebKit::C_SPLITH: name = "splith"; break; case LLQtWebKit::C_POINTINGHAND: name = "hand"; break; default: llwarns << "Unknown cursor ID: " << (int)llqt_cursor << llendl; break; } LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "cursor_changed"); message.setValue("name", name); sendMessage(message); } //////////////////////////////////////////////////////////////////////////////// // virtual void onPageChanged( const EventType& event ) { if(mInitState == INIT_STATE_WAIT_REDRAW) { setInitState(INIT_STATE_WAIT_COMPLETE); } // flag that an update is required mNeedsUpdate = true; }; //////////////////////////////////////////////////////////////////////////////// // virtual void onNavigateBegin(const EventType& event) { if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_begin"); message.setValue("uri", event.getEventUri()); message.setValueBoolean("history_back_available", LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_BACK)); message.setValueBoolean("history_forward_available", LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_FORWARD)); sendMessage(message); // debug spam sent to viewer and displayed in the log as usual postDebugMessage( "Navigate begin event at: " + event.getEventUri() ); setStatus(STATUS_LOADING); } if(mInitState == INIT_STATE_NAVIGATE_COMPLETE) { // Skip the WAIT_REDRAW state now -- with the right background color set, it should no longer be necessary. // setInitState(INIT_STATE_WAIT_REDRAW); setInitState(INIT_STATE_WAIT_COMPLETE); } } //////////////////////////////////////////////////////////////////////////////// // virtual void onNavigateComplete(const EventType& event) { if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE) { if(mInitState < INIT_STATE_RUNNING) { setInitState(INIT_STATE_RUNNING); // Clear the history, so the "back" button doesn't take you back to "about:blank". LLQtWebKit::getInstance()->clearHistory(mBrowserWindowId); } LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_complete"); message.setValue("uri", event.getEventUri()); message.setValueS32("result_code", event.getIntValue()); message.setValue("result_string", event.getStringValue()); message.setValueBoolean("history_back_available", LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_BACK)); message.setValueBoolean("history_forward_available", LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_FORWARD)); sendMessage(message); setStatus(STATUS_LOADED); } else if(mInitState == INIT_STATE_NAVIGATING) { setInitState(INIT_STATE_NAVIGATE_COMPLETE); } // debug spam sent to viewer and displayed in the log as usual postDebugMessage( "Navigate complete event at: " + event.getEventUri() ); } //////////////////////////////////////////////////////////////////////////////// // virtual void onUpdateProgress(const EventType& event) { if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "progress"); message.setValueS32("percent", event.getIntValue()); sendMessage(message); } } //////////////////////////////////////////////////////////////////////////////// // virtual void onStatusTextChange(const EventType& event) { if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "status_text"); message.setValue("status", event.getStringValue()); sendMessage(message); } } //////////////////////////////////////////////////////////////////////////////// // virtual void onTitleChange(const EventType& event) { if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text"); message.setValue("name", event.getStringValue()); sendMessage(message); } } //////////////////////////////////////////////////////////////////////////////// // virtual void onNavigateErrorPage(const EventType& event) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_error_page"); message.setValueS32("status_code", event.getIntValue()); sendMessage(message); } //////////////////////////////////////////////////////////////////////////////// // virtual void onLocationChange(const EventType& event) { if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "location_changed"); message.setValue("uri", event.getEventUri()); sendMessage(message); } } //////////////////////////////////////////////////////////////////////////////// // virtual void onClickLinkHref(const EventType& event) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "click_href"); message.setValue("uri", event.getEventUri()); message.setValue("target", event.getStringValue()); message.setValue("uuid", event.getStringValue2()); sendMessage(message); } //////////////////////////////////////////////////////////////////////////////// // virtual void onClickLinkNoFollow(const EventType& event) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "click_nofollow"); message.setValue("uri", event.getEventUri()); #if LLQTWEBKIT_API_VERSION >= 7 message.setValue("nav_type", event.getNavigationType()); #else message.setValue("nav_type", "clicked"); #endif sendMessage(message); } //////////////////////////////////////////////////////////////////////////////// // virtual void onCookieChanged(const EventType& event) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "cookie_set"); message.setValue("cookie", event.getStringValue()); // These could be passed through as well, but aren't really needed. // message.setValue("uri", event.getEventUri()); // message.setValueBoolean("dead", (event.getIntValue() != 0)) // debug spam postDebugMessage( "Sending cookie_set message from plugin: " + event.getStringValue() ); sendMessage(message); } //////////////////////////////////////////////////////////////////////////////// // virtual void onWindowCloseRequested(const EventType& event) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "close_request"); message.setValue("uuid", event.getStringValue()); sendMessage(message); } //////////////////////////////////////////////////////////////////////////////// // virtual void onWindowGeometryChangeRequested(const EventType& event) { int x, y, width, height; event.getRectValue(x, y, width, height); // This sometimes gets called with a zero-size request. Don't pass these along. if(width > 0 && height > 0) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "geometry_change"); message.setValue("uuid", event.getStringValue()); message.setValueS32("x", x); message.setValueS32("y", y); message.setValueS32("width", width); message.setValueS32("height", height); sendMessage(message); } } //////////////////////////////////////////////////////////////////////////////// // virtual std::string onRequestFilePicker( const EventType& eventIn ) { return blockingPickFile(); } std::string mAuthUsername; std::string mAuthPassword; bool mAuthOK; //////////////////////////////////////////////////////////////////////////////// // virtual bool onAuthRequest(const std::string &in_url, const std::string &in_realm, std::string &out_username, std::string &out_password) { mAuthOK = false; LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "auth_request"); message.setValue("url", in_url); message.setValue("realm", in_realm); message.setValueBoolean("blocking_request", true); // The "blocking_request" key in the message means this sendMessage call will block until a response is received. sendMessage(message); if(mAuthOK) { out_username = mAuthUsername; out_password = mAuthPassword; } return mAuthOK; } void authResponse(LLPluginMessage &message) { mAuthOK = message.getValueBoolean("ok"); if(mAuthOK) { mAuthUsername = message.getValue("username"); mAuthPassword = message.getValue("password"); } } //////////////////////////////////////////////////////////////////////////////// // virtual void onLinkHovered(const EventType& event) { if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "link_hovered"); message.setValue("link", event.getEventUri()); message.setValue("title", event.getStringValue()); message.setValue("text", event.getStringValue2()); sendMessage(message); } } LLQtWebKit::EKeyboardModifier decodeModifiers(std::string &modifiers) { int result = 0; if(modifiers.find("shift") != std::string::npos) result |= LLQtWebKit::KM_MODIFIER_SHIFT; if(modifiers.find("alt") != std::string::npos) result |= LLQtWebKit::KM_MODIFIER_ALT; if(modifiers.find("control") != std::string::npos) result |= LLQtWebKit::KM_MODIFIER_CONTROL; if(modifiers.find("meta") != std::string::npos) result |= LLQtWebKit::KM_MODIFIER_META; return (LLQtWebKit::EKeyboardModifier)result; } //////////////////////////////////////////////////////////////////////////////// // void deserializeKeyboardData( LLSD native_key_data, uint32_t& native_scan_code, uint32_t& native_virtual_key, uint32_t& native_modifiers ) { native_scan_code = 0; native_virtual_key = 0; native_modifiers = 0; if( native_key_data.isMap() ) { #if LL_DARWIN native_scan_code = (uint32_t)(native_key_data["char_code"].asInteger()); native_virtual_key = (uint32_t)(native_key_data["key_code"].asInteger()); native_modifiers = (uint32_t)(native_key_data["modifiers"].asInteger()); #elif LL_WINDOWS native_scan_code = (uint32_t)(native_key_data["scan_code"].asInteger()); native_virtual_key = (uint32_t)(native_key_data["virtual_key"].asInteger()); // TODO: I don't think we need to do anything with native modifiers here -- please verify #elif LL_LINUX native_scan_code = (uint32_t)(native_key_data["scan_code"].asInteger()); native_virtual_key = (uint32_t)(native_key_data["virtual_key"].asInteger()); native_modifiers = (uint32_t)(native_key_data["modifiers"].asInteger()); #else // Add other platforms here as needed #endif }; }; //////////////////////////////////////////////////////////////////////////////// // void keyEvent(LLQtWebKit::EKeyEvent key_event, int key, LLQtWebKit::EKeyboardModifier modifiers, LLSD native_key_data = LLSD::emptyMap()) { // The incoming values for 'key' will be the ones from indra_constants.h std::string utf8_text; if(key < KEY_SPECIAL) { // Low-ascii characters need to get passed through. utf8_text = (char)key; } // Any special-case handling we want to do for particular keys... switch((KEY)key) { // ASCII codes for some standard keys case LLQtWebKit::KEY_BACKSPACE: utf8_text = (char)8; break; case LLQtWebKit::KEY_TAB: utf8_text = (char)9; break; case LLQtWebKit::KEY_RETURN: utf8_text = (char)13; break; case LLQtWebKit::KEY_PAD_RETURN: utf8_text = (char)13; break; case LLQtWebKit::KEY_ESCAPE: utf8_text = (char)27; break; default: break; } // std::cerr << "key event " << (int)key_event << ", native_key_data = " << native_key_data << std::endl; 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 ); LLQtWebKit::getInstance()->keyboardEvent( mBrowserWindowId, key_event, (uint32_t)key, utf8_text.c_str(), modifiers, native_scan_code, native_virtual_key, native_modifiers); checkEditState(); }; //////////////////////////////////////////////////////////////////////////////// // void unicodeInput( const std::string &utf8str, LLQtWebKit::EKeyboardModifier modifiers, LLSD native_key_data = LLSD::emptyMap()) { uint32_t key = LLQtWebKit::KEY_NONE; // std::cerr << "unicode input, native_key_data = " << native_key_data << std::endl; if(utf8str.size() == 1) { // The only way a utf8 string can be one byte long is if it's actually a single 7-bit ascii character. // In this case, use it as the key value. key = utf8str[0]; } 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 ); LLQtWebKit::getInstance()->keyboardEvent( mBrowserWindowId, LLQtWebKit::KE_KEY_DOWN, (uint32_t)key, utf8str.c_str(), modifiers, native_scan_code, native_virtual_key, native_modifiers); LLQtWebKit::getInstance()->keyboardEvent( mBrowserWindowId, LLQtWebKit::KE_KEY_UP, (uint32_t)key, utf8str.c_str(), modifiers, native_scan_code, native_virtual_key, native_modifiers); checkEditState(); }; void checkEditState(void) { bool can_cut = LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_EDIT_CUT); bool can_copy = LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_EDIT_COPY); bool can_paste = LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_EDIT_PASTE); if((can_cut != mCanCut) || (can_copy != mCanCopy) || (can_paste != mCanPaste)) { LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "edit_state"); if(can_cut != mCanCut) { mCanCut = can_cut; message.setValueBoolean("cut", can_cut); } if(can_copy != mCanCopy) { mCanCopy = can_copy; message.setValueBoolean("copy", can_copy); } if(can_paste != mCanPaste) { mCanPaste = can_paste; message.setValueBoolean("paste", can_paste); } sendMessage(message); } } std::string mPickedFile; std::string blockingPickFile(void) { mPickedFile.clear(); LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "pick_file"); message.setValueBoolean("blocking_request", true); // The "blocking_request" key in the message means this sendMessage call will block until a response is received. sendMessage(message); return mPickedFile; } void onPickFileResponse(const std::string &file) { mPickedFile = file; } }; MediaPluginWebKit::MediaPluginWebKit(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data) : MediaPluginBase(host_send_func, host_user_data) { // std::cerr << "MediaPluginWebKit constructor" << std::endl; mBrowserWindowId = 0; mInitState = INIT_STATE_UNINITIALIZED; mNeedsUpdate = true; mCanCut = false; mCanCopy = false; mCanPaste = false; mLastMouseX = 0; mLastMouseY = 0; mFirstFocus = true; mBackgroundR = 0.0f; mBackgroundG = 0.0f; mBackgroundB = 0.0f; mHostLanguage = "en"; // default to english mJavascriptEnabled = true; // default to on mPluginsEnabled = true; // default to on mEnableMediaPluginDebugging = false; mUserAgent = "LLPluginMedia Web Browser"; mElapsedTime.reset(); } MediaPluginWebKit::~MediaPluginWebKit() { // unhook observer LLQtWebKit::getInstance()->remObserver( mBrowserWindowId, this ); // clean up LLQtWebKit::getInstance()->reset(); // std::cerr << "MediaPluginWebKit destructor" << std::endl; } void MediaPluginWebKit::receiveMessage(const char *message_string) { // std::cerr << "MediaPluginWebKit::receiveMessage: received message: \"" << message_string << "\"" << std::endl; LLPluginMessage message_in; if(message_in.parse(message_string) >= 0) { std::string message_class = message_in.getClass(); std::string message_name = message_in.getName(); if(message_class == LLPLUGIN_MESSAGE_CLASS_BASE) { if(message_name == "init") { LLPluginMessage message("base", "init_response"); LLSD versions = LLSD::emptyMap(); versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION; versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION; versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER] = LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION; message.setValueLLSD("versions", versions); std::string plugin_version = "Webkit media plugin, Webkit version "; plugin_version += LLQtWebKit::getInstance()->getVersion(); message.setValue("plugin_version", plugin_version); sendMessage(message); } else if(message_name == "idle") { // no response is necessary here. F64 time = message_in.getValueReal("time"); // Convert time to milliseconds for update() update((int)(time * 1000.0f)); } else if(message_name == "cleanup") { // DTOR most likely won't be called but the recent change to the way this process // is (not) killed means we see this message and can do what we need to here. // Note: this cleanup is ultimately what writes cookies to the disk LLQtWebKit::getInstance()->remObserver( mBrowserWindowId, this ); LLQtWebKit::getInstance()->reset(); } else if(message_name == "shm_added") { SharedSegmentInfo info; info.mAddress = message_in.getValuePointer("address"); info.mSize = (size_t)message_in.getValueS32("size"); std::string name = message_in.getValue("name"); // std::cerr << "MediaPluginWebKit::receiveMessage: shared memory added, name: " << name // << ", size: " << info.mSize // << ", address: " << info.mAddress // << std::endl; mSharedSegments.insert(SharedSegmentMap::value_type(name, info)); } else if(message_name == "shm_remove") { std::string name = message_in.getValue("name"); // std::cerr << "MediaPluginWebKit::receiveMessage: shared memory remove, name = " << name << std::endl; SharedSegmentMap::iterator iter = mSharedSegments.find(name); if(iter != mSharedSegments.end()) { if(mPixels == iter->second.mAddress) { // This is the currently active pixel buffer. Make sure we stop drawing to it. mPixels = NULL; mTextureSegmentName.clear(); } mSharedSegments.erase(iter); } else { // std::cerr << "MediaPluginWebKit::receiveMessage: unknown shared memory region!" << std::endl; } // Send the response so it can be cleaned up. LLPluginMessage message("base", "shm_remove_response"); message.setValue("name", name); sendMessage(message); } else { // std::cerr << "MediaPluginWebKit::receiveMessage: unknown base message: " << message_name << std::endl; } } else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME) { if(message_name == "set_volume") { F32 volume = (F32)message_in.getValueReal("volume"); setVolume(volume); } } else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA) { if(message_name == "init") { mTarget = message_in.getValue("target"); // This is the media init message -- all necessary data for initialization should have been received. if(initBrowser()) { // Plugin gets to decide the texture parameters to use. mDepth = 4; LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params"); message.setValueS32("default_width", 1024); message.setValueS32("default_height", 1024); message.setValueS32("depth", mDepth); message.setValueU32("internalformat", GL_RGBA); #if LL_QTWEBKIT_USES_PIXMAPS message.setValueU32("format", GL_BGRA_EXT); // I hope this isn't system-dependant... is it? If so, we'll have to check the root window's pixel layout or something... yuck. #else message.setValueU32("format", GL_RGBA); #endif // LL_QTWEBKIT_USES_PIXMAPS message.setValueU32("type", GL_UNSIGNED_BYTE); message.setValueBoolean("coords_opengl", true); sendMessage(message); } else { // if initialization failed, we're done. mDeleteMe = true; } } else if(message_name == "set_user_data_path") { std::string user_data_path = message_in.getValue("path"); // n.b. always has trailing platform-specific dir-delimiter mProfileDir = user_data_path + "browser_profile"; // FIXME: Should we do anything with this if it comes in after the browser has been initialized? } else if(message_name == "set_language_code") { mHostLanguage = message_in.getValue("language"); // FIXME: Should we do anything with this if it comes in after the browser has been initialized? } else if(message_name == "plugins_enabled") { mPluginsEnabled = message_in.getValueBoolean("enable"); } else if(message_name == "javascript_enabled") { mJavascriptEnabled = message_in.getValueBoolean("enable"); } else if(message_name == "size_change") { std::string name = message_in.getValue("name"); S32 width = message_in.getValueS32("width"); S32 height = message_in.getValueS32("height"); S32 texture_width = message_in.getValueS32("texture_width"); S32 texture_height = message_in.getValueS32("texture_height"); mBackgroundR = (F32)message_in.getValueReal("background_r"); mBackgroundG = (F32)message_in.getValueReal("background_g"); mBackgroundB = (F32)message_in.getValueReal("background_b"); // mBackgroundA = message_in.setValueReal("background_a"); // Ignore any alpha if(!name.empty()) { // Find the shared memory region with this name SharedSegmentMap::iterator iter = mSharedSegments.find(name); if(iter != mSharedSegments.end()) { mPixels = (unsigned char*)iter->second.mAddress; mWidth = width; mHeight = height; if(initBrowserWindow()) { // size changed so tell the browser LLQtWebKit::getInstance()->setSize( mBrowserWindowId, mWidth, mHeight ); // std::cerr << "webkit plugin: set size to " << mWidth << " x " << mHeight // << ", rowspan is " << LLQtWebKit::getInstance()->getBrowserRowSpan(mBrowserWindowId) << std::endl; S32 real_width = LLQtWebKit::getInstance()->getBrowserRowSpan(mBrowserWindowId) / LLQtWebKit::getInstance()->getBrowserDepth(mBrowserWindowId); // The actual width the browser will be drawing to is probably smaller... let the host know by modifying texture_width in the response. if(real_width <= texture_width) { texture_width = real_width; } else { // This won't work -- it'll be bigger than the allocated memory. This is a fatal error. // std::cerr << "Fatal error: browser rowbytes greater than texture width" << std::endl; mDeleteMe = true; return; } } else { // Setting up the browser window failed. This is a fatal error. mDeleteMe = true; } mTextureWidth = texture_width; mTextureHeight = texture_height; }; }; LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response"); message.setValue("name", name); message.setValueS32("width", width); message.setValueS32("height", height); message.setValueS32("texture_width", texture_width); message.setValueS32("texture_height", texture_height); sendMessage(message); } else if(message_name == "load_uri") { std::string uri = message_in.getValue("uri"); // std::cout << "loading URI: " << uri << std::endl; if(!uri.empty()) { if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE) { LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, uri ); } else { mInitialNavigateURL = uri; } } } else if(message_name == "mouse_event") { std::string event = message_in.getValue("event"); S32 button = message_in.getValueS32("button"); mLastMouseX = message_in.getValueS32("x"); mLastMouseY = message_in.getValueS32("y"); std::string modifiers = message_in.getValue("modifiers"); // Treat unknown mouse events as mouse-moves. LLQtWebKit::EMouseEvent mouse_event = LLQtWebKit::ME_MOUSE_MOVE; if(event == "down") { mouse_event = LLQtWebKit::ME_MOUSE_DOWN; } else if(event == "up") { mouse_event = LLQtWebKit::ME_MOUSE_UP; } else if(event == "double_click") { mouse_event = LLQtWebKit::ME_MOUSE_DOUBLE_CLICK; } LLQtWebKit::getInstance()->mouseEvent( mBrowserWindowId, mouse_event, button, mLastMouseX, mLastMouseY, decodeModifiers(modifiers)); checkEditState(); } else if(message_name == "scroll_event") { S32 x = message_in.getValueS32("x"); S32 y = message_in.getValueS32("y"); std::string modifiers = message_in.getValue("modifiers"); // Incoming scroll events are adjusted so that 1 detent is approximately 1 unit. // Qt expects 1 detent to be 120 units. // It also seems that our y scroll direction is inverted vs. what Qt expects. x *= 120; y *= -120; LLQtWebKit::getInstance()->scrollWheelEvent(mBrowserWindowId, mLastMouseX, mLastMouseY, x, y, decodeModifiers(modifiers)); } else if(message_name == "key_event") { std::string event = message_in.getValue("event"); S32 key = message_in.getValueS32("key"); std::string modifiers = message_in.getValue("modifiers"); LLSD native_key_data = message_in.getValueLLSD("native_key_data"); // Treat unknown events as key-up for safety. LLQtWebKit::EKeyEvent key_event = LLQtWebKit::KE_KEY_UP; if(event == "down") { key_event = LLQtWebKit::KE_KEY_DOWN; } else if(event == "repeat") { key_event = LLQtWebKit::KE_KEY_REPEAT; } keyEvent(key_event, key, decodeModifiers(modifiers), native_key_data); } else if(message_name == "text_event") { std::string text = message_in.getValue("text"); std::string modifiers = message_in.getValue("modifiers"); LLSD native_key_data = message_in.getValueLLSD("native_key_data"); unicodeInput(text, decodeModifiers(modifiers), native_key_data); } if(message_name == "edit_cut") { LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_EDIT_CUT ); checkEditState(); } if(message_name == "edit_copy") { LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_EDIT_COPY ); checkEditState(); } if(message_name == "edit_paste") { LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_EDIT_PASTE ); checkEditState(); } if(message_name == "pick_file_response") { onPickFileResponse(message_in.getValue("file")); } if(message_name == "auth_response") { authResponse(message_in); } else if(message_name == "enable_media_plugin_debugging") { mEnableMediaPluginDebugging = message_in.getValueBoolean( "enable" ); } else if(message_name == "js_enable_object") { #if LLQTWEBKIT_API_VERSION >= 9 bool enable = message_in.getValueBoolean( "enable" ); LLQtWebKit::getInstance()->setSLObjectEnabled( enable ); #endif } else if(message_name == "js_agent_location") { #if LLQTWEBKIT_API_VERSION >= 9 F32 x = (F32)message_in.getValueReal("x"); F32 y = (F32)message_in.getValueReal("y"); F32 z = (F32)message_in.getValueReal("z"); LLQtWebKit::getInstance()->setAgentLocation( x, y, z ); LLQtWebKit::getInstance()->emitLocation(); #endif } else if(message_name == "js_agent_global_location") { #if LLQTWEBKIT_API_VERSION >= 9 F32 x = (F32)message_in.getValueReal("x"); F32 y = (F32)message_in.getValueReal("y"); F32 z = (F32)message_in.getValueReal("z"); LLQtWebKit::getInstance()->setAgentGlobalLocation( x, y, z ); LLQtWebKit::getInstance()->emitLocation(); #endif } else if(message_name == "js_agent_orientation") { #if LLQTWEBKIT_API_VERSION >= 9 F32 angle = (F32)message_in.getValueReal("angle"); LLQtWebKit::getInstance()->setAgentOrientation( angle ); LLQtWebKit::getInstance()->emitLocation(); #endif } else if(message_name == "js_agent_region") { #if LLQTWEBKIT_API_VERSION >= 9 const std::string& region = message_in.getValue("region"); LLQtWebKit::getInstance()->setAgentRegion( region ); LLQtWebKit::getInstance()->emitLocation(); #endif } else if(message_name == "js_agent_maturity") { #if LLQTWEBKIT_API_VERSION >= 9 const std::string& maturity = message_in.getValue("maturity"); LLQtWebKit::getInstance()->setAgentMaturity( maturity ); LLQtWebKit::getInstance()->emitMaturity(); #endif } else if(message_name == "js_agent_language") { #if LLQTWEBKIT_API_VERSION >= 9 const std::string& language = message_in.getValue("language"); LLQtWebKit::getInstance()->setAgentLanguage( language ); LLQtWebKit::getInstance()->emitLanguage(); #endif } else { // std::cerr << "MediaPluginWebKit::receiveMessage: unknown media message: " << message_string << std::endl; } } else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER) { if(message_name == "focus") { bool val = message_in.getValueBoolean("focused"); LLQtWebKit::getInstance()->focusBrowser( mBrowserWindowId, val ); if(mFirstFocus && val) { // On the first focus, post a tab key event. This fixes a problem with initial focus. std::string empty; keyEvent(LLQtWebKit::KE_KEY_DOWN, KEY_TAB, decodeModifiers(empty)); keyEvent(LLQtWebKit::KE_KEY_UP, KEY_TAB, decodeModifiers(empty)); mFirstFocus = false; } } else if(message_name == "set_page_zoom_factor") { #if LLQTWEBKIT_API_VERSION >= 15 F32 factor = (F32)message_in.getValueReal("factor"); LLQtWebKit::getInstance()->setPageZoomFactor(factor); #else llwarns << "Ignoring setPageZoomFactor message (llqtwebkit version is too old)." << llendl; #endif } else if(message_name == "clear_cache") { LLQtWebKit::getInstance()->clearCache(); } else if(message_name == "clear_cookies") { LLQtWebKit::getInstance()->clearAllCookies(); } else if(message_name == "enable_cookies") { mCookiesEnabled = message_in.getValueBoolean("enable"); LLQtWebKit::getInstance()->enableCookies( mCookiesEnabled ); } else if(message_name == "enable_plugins") { mPluginsEnabled = message_in.getValueBoolean("enable"); LLQtWebKit::getInstance()->enablePlugins( mPluginsEnabled ); } else if(message_name == "enable_javascript") { mJavascriptEnabled = message_in.getValueBoolean("enable"); //LLQtWebKit::getInstance()->enableJavascript( mJavascriptEnabled ); } else if(message_name == "set_cookies") { LLQtWebKit::getInstance()->setCookies(message_in.getValue("cookies")); // debug spam postDebugMessage( "Plugin setting cookie: " + message_in.getValue("cookies") ); } else if(message_name == "proxy_setup") { bool val = message_in.getValueBoolean("enable"); std::string host = message_in.getValue("host"); int port = message_in.getValueS32("port"); LLQtWebKit::getInstance()->enableProxy( val, host, port ); } else if(message_name == "browse_stop") { LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_STOP ); } else if(message_name == "browse_reload") { // foo = message_in.getValueBoolean("ignore_cache"); LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_RELOAD ); } else if(message_name == "browse_forward") { LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_FORWARD ); } else if(message_name == "browse_back") { LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_BACK ); } else if(message_name == "set_status_redirect") { int code = message_in.getValueS32("code"); std::string url = message_in.getValue("url"); if ( 404 == code ) // browser lib only supports 404 right now { #if LLQTWEBKIT_API_VERSION < 8 LLQtWebKit::getInstance()->set404RedirectUrl( mBrowserWindowId, url ); #endif }; } else if(message_name == "set_user_agent") { mUserAgent = message_in.getValue("user_agent"); LLQtWebKit::getInstance()->setBrowserAgentId( mUserAgent ); } else if(message_name == "show_web_inspector") { #if LLQTWEBKIT_API_VERSION >= 10 bool val = message_in.getValueBoolean("show"); LLQtWebKit::getInstance()->showWebInspector( val ); #else llwarns << "Ignoring showWebInspector message (llqtwebkit version is too old)." << llendl; #endif } else if(message_name == "ignore_ssl_cert_errors") { #if LLQTWEBKIT_API_VERSION >= 3 LLQtWebKit::getInstance()->setIgnoreSSLCertErrors( message_in.getValueBoolean("ignore") ); #else llwarns << "Ignoring ignore_ssl_cert_errors message (llqtwebkit version is too old)." << llendl; #endif } else if(message_name == "add_certificate_file_path") { #if LLQTWEBKIT_API_VERSION >= 6 LLQtWebKit::getInstance()->setCAFile( message_in.getValue("path") ); #else llwarns << "Ignoring add_certificate_file_path message (llqtwebkit version is too old)." << llendl; #endif } else if(message_name == "init_history") { // Initialize browser history LLSD history = message_in.getValueLLSD("history"); // First, clear the URL history LLQtWebKit::getInstance()->clearHistory(mBrowserWindowId); // Then, add the history items in order LLSD::array_iterator iter_history = history.beginArray(); LLSD::array_iterator end_history = history.endArray(); for(; iter_history != end_history; ++iter_history) { std::string url = (*iter_history).asString(); if(! url.empty()) { LLQtWebKit::getInstance()->prependHistoryUrl(mBrowserWindowId, url); } } } else if(message_name == "proxy_window_opened") { std::string target = message_in.getValue("target"); std::string uuid = message_in.getValue("uuid"); LLQtWebKit::getInstance()->proxyWindowOpened(mBrowserWindowId, target, uuid); } else if(message_name == "proxy_window_closed") { std::string uuid = message_in.getValue("uuid"); LLQtWebKit::getInstance()->proxyWindowClosed(mBrowserWindowId, uuid); } else { // std::cerr << "MediaPluginWebKit::receiveMessage: unknown media_browser message: " << message_string << std::endl; }; } else { // std::cerr << "MediaPluginWebKit::receiveMessage: unknown message class: " << message_class << std::endl; }; } } void MediaPluginWebKit::setVolume(F32 volume) { mVolumeCatcher.setVolume(volume); } int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data) { MediaPluginWebKit *self = new MediaPluginWebKit(host_send_func, host_user_data); *plugin_send_func = MediaPluginWebKit::staticReceiveMessage; *plugin_user_data = (void*)self; return 0; }