开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
media_plugin_webkit.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：33k
源码类别：

游戏引擎

开发平台：

C++ Builder

media_plugin_webkit.cpp：源码内容
  1. /** 
  2.  * @file media_plugin_webkit.cpp
  3.  * @brief Webkit plugin for LLMedia API plugin system
  4.  *
  5.  * @cond
  6.  * $LicenseInfo:firstyear=2008&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2008-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  * @endcond
  33.  */
  35. #include "llqtwebkit.h"
  37. #include "linden_common.h"
  38. #include "indra_constants.h" // for indra keyboard codes
  40. #include "llgl.h"
  42. #include "llplugininstance.h"
  43. #include "llpluginmessage.h"
  44. #include "llpluginmessageclasses.h"
  45. #include "media_plugin_base.h"
  47. #if LL_WINDOWS
  48. #include <direct.h>
  49. #else
  50. #include <unistd.h>
  51. #include <stdlib.h>
  52. #endif
  54. #if LL_WINDOWS
  55. // *NOTE:Mani - This captures the module handle fo rthe dll. This is used below
  56. // to get the path to this dll for webkit initialization.
  57. // I don't know how/if this can be done with apr...
  58. namespace { HMODULE gModuleHandle;};
  59. BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  60. {
  61. gModuleHandle = (HMODULE) hinstDLL;
  62. return TRUE;
  63. }
  64. #endif
  66. ////////////////////////////////////////////////////////////////////////////////
  67. //
  68. class MediaPluginWebKit : 
  69. public MediaPluginBase,
  70. public LLEmbeddedBrowserWindowObserver
  71. {
  72. public:
  73. MediaPluginWebKit(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
  74. ~MediaPluginWebKit();
  76. /*virtual*/ void receiveMessage(const char *message_string);
  78. private:
  80. std::string mProfileDir;
  82. enum
  83. {
  84. INIT_STATE_UNINITIALIZED, // Browser instance hasn't been set up yet
  85. INIT_STATE_NAVIGATING, // Browser instance has been set up and initial navigate to about:blank has been issued
  86. INIT_STATE_NAVIGATE_COMPLETE, // initial navigate to about:blank has completed
  87. INIT_STATE_WAIT_REDRAW, // First real navigate begin has been received, waiting for page changed event to start handling redraws
  88. INIT_STATE_WAIT_COMPLETE, // Waiting for first real navigate complete event
  89. INIT_STATE_RUNNING // All initialization gymnastics are complete.
  90. };
  91. int mBrowserWindowId;
  92. int mInitState;
  93. std::string mInitialNavigateURL;
  94. bool mNeedsUpdate;
  96. bool mCanCut;
  97. bool mCanCopy;
  98. bool mCanPaste;
  99. int mLastMouseX;
  100. int mLastMouseY;
  101. bool mFirstFocus;
  102. F32 mBackgroundR;
  103. F32 mBackgroundG;
  104. F32 mBackgroundB;
  106. void setInitState(int state)
  107. {
  108. // std::cerr << "changing init state to " << state << std::endl;
  109. mInitState = state;
  110. }
  112. ////////////////////////////////////////////////////////////////////////////////
  113. //
  114. void update(int milliseconds)
  115. {
  116. LLQtWebKit::getInstance()->pump( milliseconds );
  118. checkEditState();
  120. if(mInitState == INIT_STATE_NAVIGATE_COMPLETE)
  121. {
  122. if(!mInitialNavigateURL.empty())
  123. {
  124. // We already have the initial navigate URL -- kick off the navigate.
  125. LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, mInitialNavigateURL );
  126. mInitialNavigateURL.clear();
  127. }
  128. }
  130. if ( (mInitState > INIT_STATE_WAIT_REDRAW) && mNeedsUpdate )
  131. {
  132. const unsigned char* browser_pixels = LLQtWebKit::getInstance()->grabBrowserWindow( mBrowserWindowId );
  134. unsigned int buffer_size = LLQtWebKit::getInstance()->getBrowserRowSpan( mBrowserWindowId ) * LLQtWebKit::getInstance()->getBrowserHeight( mBrowserWindowId );
  136. // std::cerr << "webkit plugin: updating" << std::endl;
  138. // TODO: should get rid of this memcpy if possible
  139. if ( mPixels && browser_pixels )
  140. {
  141. // std::cerr << "    memcopy of " << buffer_size << " bytes" << std::endl;
  142. memcpy( mPixels, browser_pixels, buffer_size );
  143. }
  145. if ( mWidth > 0 && mHeight > 0 )
  146. {
  147. // std::cerr << "Setting dirty, " << mWidth << " x " << mHeight << std::endl;
  148. setDirty( 0, 0, mWidth, mHeight );
  149. }
  151. mNeedsUpdate = false;
  152. };
  153. };
  155. ////////////////////////////////////////////////////////////////////////////////
  156. //
  157. bool initBrowser()
  158. {
  159. // already initialized
  160. if ( mInitState > INIT_STATE_UNINITIALIZED )
  161. return true;
  163. // not enough information to initialize the browser yet.
  164. if ( mWidth < 0 || mHeight < 0 || mDepth < 0 || 
  165. mTextureWidth < 0 || mTextureHeight < 0 )
  166. {
  167. return false;
  168. };
  170. // set up directories
  171. char cwd[ FILENAME_MAX ]; // I *think* this is defined on all platforms we use
  172. if (NULL == getcwd( cwd, FILENAME_MAX - 1 ))
  173. {
  174. llwarns << "Couldn't get cwd - probably too long - failing to init." << llendl;
  175. return false;
  176. }
  177. std::string application_dir = std::string( cwd );
  179. #if LL_DARWIN
  180. // When running under the Xcode debugger, there's a setting called "Break on Debugger()/DebugStr()" which defaults to being turned on.
  181. // This causes the environment variable USERBREAK to be set to 1, which causes these legacy calls to break into the debugger.
  182. // 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
  183. // which gets hit when the plugin is probed by webkit.
  184. // Unsetting the environment variable here works around this issue.
  185. unsetenv("USERBREAK");
  186. #endif
  188. #if LL_WINDOWS
  189. //*NOTE:Mani - On windows, at least, the component path is the
  190. // location of this dll's image file. 
  191. std::string component_dir;
  192. char dll_path[_MAX_PATH];
  193. DWORD len = GetModuleFileNameA(gModuleHandle, (LPCH)&dll_path, _MAX_PATH);
  194. while(len && dll_path[ len ] != ('\') )
  195. {
  196. len--;
  197. }
  198. if(len >= 0)
  199. {
  200. dll_path[len] = 0;
  201. component_dir = dll_path;
  202. }
  203. else
  204. {
  205. // *NOTE:Mani - This case should be an rare exception. 
  206. // GetModuleFileNameA should always give you a full path, no?
  207. component_dir = application_dir;
  208. }
  209. #else
  210. std::string component_dir = application_dir;
  211. #endif
  213. // window handle - needed on Windows and must be app window.
  214. #if LL_WINDOWS
  215. char window_title[ MAX_PATH ];
  216. GetConsoleTitleA( window_title, MAX_PATH );
  217. void* native_window_handle = (void*)FindWindowA( NULL, window_title );
  218. #else
  219. void* native_window_handle = 0;
  220. #endif
  222. // main browser initialization
  223. bool result = LLQtWebKit::getInstance()->init( application_dir, component_dir, mProfileDir, native_window_handle );
  224. if ( result )
  225. {
  226. // create single browser window
  227. mBrowserWindowId = LLQtWebKit::getInstance()->createBrowserWindow( mWidth, mHeight );
  228. #if LL_WINDOWS
  229. // Enable plugins
  230. LLQtWebKit::getInstance()->enablePlugins(true);
  231. #elif LL_DARWIN
  232. // Enable plugins
  233. LLQtWebKit::getInstance()->enablePlugins(true);
  234. #elif LL_LINUX
  235. // Enable plugins
  236. LLQtWebKit::getInstance()->enablePlugins(true);
  237. #endif
  238. // Enable cookies
  239. LLQtWebKit::getInstance()->enableCookies( true );
  241. // tell LLQtWebKit about the size of the browser window
  242. LLQtWebKit::getInstance()->setSize( mBrowserWindowId, mWidth, mHeight );
  244. // observer events that LLQtWebKit emits
  245. LLQtWebKit::getInstance()->addObserver( mBrowserWindowId, this );
  247. // append details to agent string
  248. LLQtWebKit::getInstance()->setBrowserAgentId( "LLPluginMedia Web Browser" );
  250. // don't flip bitmap
  251. LLQtWebKit::getInstance()->flipWindow( mBrowserWindowId, true );
  253. // set background color
  254. // convert background color channels from [0.0, 1.0] to [0, 255];
  255. LLQtWebKit::getInstance()->setBackgroundColor( mBrowserWindowId, int(mBackgroundR * 255.0f), int(mBackgroundG * 255.0f), int(mBackgroundB * 255.0f) );
  257. // Set state _before_ starting the navigate, since onNavigateBegin might get called before this call returns.
  258. setInitState(INIT_STATE_NAVIGATING);
  260. // Don't do this here -- it causes the dreaded "white flash" when loading a browser instance.
  261. // FIXME: Re-added this because navigating to a "page" initializes things correctly - especially
  262. // for the HTTP AUTH dialog issues (DEV-41731). Will fix at a later date.
  263. // Build a data URL like this: "data:text/html,%3Chtml%3E%3Cbody bgcolor=%22#RRGGBB%22%3E%3C/body%3E%3C/html%3E"
  264. // where RRGGBB is the background color in HTML style
  265. std::stringstream url;
  267. url << "data:text/html,%3Chtml%3E%3Cbody%20bgcolor=%22#";
  268. // convert background color channels from [0.0, 1.0] to [0, 255];
  269. url << std::setfill('0') << std::setw(2) << std::hex << int(mBackgroundR * 255.0f);
  270. url << std::setfill('0') << std::setw(2) << std::hex << int(mBackgroundG * 255.0f);
  271. url << std::setfill('0') << std::setw(2) << std::hex << int(mBackgroundB * 255.0f);
  272. url << "%22%3E%3C/body%3E%3C/html%3E";
  274. lldebugs << "data url is: " << url.str() << llendl;
  276. LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, url.str() );
  277. // LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, "about:blank" );
  279. return true;
  280. };
  282. return false;
  283. };
  286. ////////////////////////////////////////////////////////////////////////////////
  287. // virtual
  288. void onCursorChanged(const EventType& event)
  289. {
  290. LLQtWebKit::ECursor llqt_cursor = (LLQtWebKit::ECursor)event.getIntValue();
  291. std::string name;
  293. switch(llqt_cursor)
  294. {
  295. case LLQtWebKit::C_ARROW:
  296. name = "arrow";
  297. break;
  298. case LLQtWebKit::C_IBEAM:
  299. name = "ibeam";
  300. break;
  301. case LLQtWebKit::C_SPLITV:
  302. name = "splitv";
  303. break;
  304. case LLQtWebKit::C_SPLITH:
  305. name = "splith";
  306. break;
  307. case LLQtWebKit::C_POINTINGHAND:
  308. name = "hand";
  309. break;
  311. default:
  312. llwarns << "Unknown cursor ID: " << (int)llqt_cursor << llendl;
  313. break;
  314. }
  316. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "cursor_changed");
  317. message.setValue("name", name);
  318. sendMessage(message);
  319. }
  321. ////////////////////////////////////////////////////////////////////////////////
  322. // virtual
  323. void onPageChanged( const EventType& event )
  324. {
  325. if(mInitState == INIT_STATE_WAIT_REDRAW)
  326. {
  327. setInitState(INIT_STATE_WAIT_COMPLETE);
  328. }
  330. // flag that an update is required
  331. mNeedsUpdate = true;
  332. };
  334. ////////////////////////////////////////////////////////////////////////////////
  335. // virtual
  336. void onNavigateBegin(const EventType& event)
  337. {
  338. if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE)
  339. {
  340. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_begin");
  341. message.setValue("uri", event.getEventUri());
  342. sendMessage(message);
  344. setStatus(STATUS_LOADING);
  345. }
  347. if(mInitState == INIT_STATE_NAVIGATE_COMPLETE)
  348. {
  349. // Skip the WAIT_REDRAW state now -- with the right background color set, it should no longer be necessary.
  350. // setInitState(INIT_STATE_WAIT_REDRAW);
  351. setInitState(INIT_STATE_WAIT_COMPLETE);
  352. }
  354. }
  356. ////////////////////////////////////////////////////////////////////////////////
  357. // virtual
  358. void onNavigateComplete(const EventType& event)
  359. {
  360. if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE)
  361. {
  362. if(mInitState < INIT_STATE_RUNNING)
  363. {
  364. setInitState(INIT_STATE_RUNNING);
  366. // Clear the history, so the "back" button doesn't take you back to "about:blank".
  367. LLQtWebKit::getInstance()->clearHistory(mBrowserWindowId);
  368. }
  370. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_complete");
  371. message.setValue("uri", event.getEventUri());
  372. message.setValueS32("result_code", event.getIntValue());
  373. message.setValue("result_string", event.getStringValue());
  374. message.setValueBoolean("history_back_available", LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_BACK));
  375. message.setValueBoolean("history_forward_available", LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_FORWARD));
  376. sendMessage(message);
  378. setStatus(STATUS_LOADED);
  379. }
  380. else if(mInitState == INIT_STATE_NAVIGATING)
  381. {
  382. setInitState(INIT_STATE_NAVIGATE_COMPLETE);
  383. }
  385. }
  387. ////////////////////////////////////////////////////////////////////////////////
  388. // virtual
  389. void onUpdateProgress(const EventType& event)
  390. {
  391. if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE)
  392. {
  393. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "progress");
  394. message.setValueS32("percent", event.getIntValue());
  395. sendMessage(message);
  396. }
  397. }
  399. ////////////////////////////////////////////////////////////////////////////////
  400. // virtual
  401. void onStatusTextChange(const EventType& event)
  402. {
  403. if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE)
  404. {
  405. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "status_text");
  406. message.setValue("status", event.getStringValue());
  407. sendMessage(message);
  408. }
  409. }
  411. ////////////////////////////////////////////////////////////////////////////////
  412. // virtual
  413. void onTitleChange(const EventType& event)
  414. {
  415. if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE)
  416. {
  417. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text");
  418. message.setValue("name", event.getStringValue());
  419. sendMessage(message);
  420. }
  421. }
  423. ////////////////////////////////////////////////////////////////////////////////
  424. // virtual
  425. void onLocationChange(const EventType& event)
  426. {
  427. if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE)
  428. {
  429. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "location_changed");
  430. message.setValue("uri", event.getEventUri());
  431. sendMessage(message);
  432. }
  433. }
  435. ////////////////////////////////////////////////////////////////////////////////
  436. // virtual
  437. void onClickLinkHref(const EventType& event)
  438. {
  439. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "click_href");
  440. message.setValue("uri", event.getStringValue());
  441. message.setValue("target", event.getStringValue2());
  442. message.setValueU32("target_type", event.getLinkType());
  443. sendMessage(message);
  444. }
  446. ////////////////////////////////////////////////////////////////////////////////
  447. // virtual
  448. void onClickLinkNoFollow(const EventType& event)
  449. {
  450. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "click_nofollow");
  451. message.setValue("uri", event.getStringValue());
  452. sendMessage(message);
  453. }
  455. LLQtWebKit::EKeyboardModifier decodeModifiers(std::string &modifiers)
  456. {
  457. int result = 0;
  459. if(modifiers.find("shift") != std::string::npos)
  460. result |= LLQtWebKit::KM_MODIFIER_SHIFT;
  462. if(modifiers.find("alt") != std::string::npos)
  463. result |= LLQtWebKit::KM_MODIFIER_ALT;
  465. if(modifiers.find("control") != std::string::npos)
  466. result |= LLQtWebKit::KM_MODIFIER_CONTROL;
  468. if(modifiers.find("meta") != std::string::npos)
  469. result |= LLQtWebKit::KM_MODIFIER_META;
  471. return (LLQtWebKit::EKeyboardModifier)result;
  472. }
  474. ////////////////////////////////////////////////////////////////////////////////
  475. //
  476. void deserializeKeyboardData( LLSD native_key_data, uint32_t& native_scan_code, uint32_t& native_virtual_key, uint32_t& native_modifiers )
  477. {
  478. native_scan_code = 0;
  479. native_virtual_key = 0;
  480. native_modifiers = 0;
  482. if( native_key_data.isMap() )
  483. {
  484. #if LL_DARWIN
  485. native_scan_code = (uint32_t)(native_key_data["char_code"].asInteger());
  486. native_virtual_key = (uint32_t)(native_key_data["key_code"].asInteger());
  487. native_modifiers = (uint32_t)(native_key_data["modifiers"].asInteger());
  488. #elif LL_WINDOWS
  489. native_scan_code = (uint32_t)(native_key_data["scan_code"].asInteger());
  490. native_virtual_key = (uint32_t)(native_key_data["virtual_key"].asInteger());
  491. // TODO: I don't think we need to do anything with native modifiers here -- please verify
  492. #elif LL_LINUX
  493. native_scan_code = (uint32_t)(native_key_data["scan_code"].asInteger());
  494. native_virtual_key = (uint32_t)(native_key_data["virtual_key"].asInteger());
  495. native_modifiers = (uint32_t)(native_key_data["modifiers"].asInteger());
  496. #else
  497. // Add other platforms here as needed
  498. #endif
  499. };
  500. };
  502. ////////////////////////////////////////////////////////////////////////////////
  503. //
  504. void keyEvent(LLQtWebKit::EKeyEvent key_event, int key, LLQtWebKit::EKeyboardModifier modifiers, LLSD native_key_data = LLSD::emptyMap())
  505. {
  506. // The incoming values for 'key' will be the ones from indra_constants.h
  507. std::string utf8_text;
  509. if(key < KEY_SPECIAL)
  510. {
  511. // Low-ascii characters need to get passed through.
  512. utf8_text = (char)key;
  513. }
  515. // Any special-case handling we want to do for particular keys...
  516. switch((KEY)key)
  517. {
  518. // ASCII codes for some standard keys
  519. case LLQtWebKit::KEY_BACKSPACE: utf8_text = (char)8; break;
  520. case LLQtWebKit::KEY_TAB: utf8_text = (char)9; break;
  521. case LLQtWebKit::KEY_RETURN: utf8_text = (char)13; break;
  522. case LLQtWebKit::KEY_PAD_RETURN: utf8_text = (char)13; break;
  523. case LLQtWebKit::KEY_ESCAPE: utf8_text = (char)27; break;
  525. default:  
  526. break;
  527. }
  529. // std::cerr << "key event " << (int)key_event << ", native_key_data = " << native_key_data << std::endl;
  531. uint32_t native_scan_code = 0;
  532. uint32_t native_virtual_key = 0;
  533. uint32_t native_modifiers = 0;
  534. deserializeKeyboardData( native_key_data, native_scan_code, native_virtual_key, native_modifiers );
  536. LLQtWebKit::getInstance()->keyboardEvent( mBrowserWindowId, key_event, (uint32_t)key, utf8_text.c_str(), modifiers, native_scan_code, native_virtual_key, native_modifiers);
  538. checkEditState();
  539. };
  541. ////////////////////////////////////////////////////////////////////////////////
  542. //
  543. void unicodeInput( const std::string &utf8str, LLQtWebKit::EKeyboardModifier modifiers, LLSD native_key_data = LLSD::emptyMap())
  544. {
  545. uint32_t key = LLQtWebKit::KEY_NONE;
  547. // std::cerr << "unicode input, native_key_data = " << native_key_data << std::endl;
  549. if(utf8str.size() == 1)
  550. {
  551. // The only way a utf8 string can be one byte long is if it's actually a single 7-bit ascii character.
  552. // In this case, use it as the key value.
  553. key = utf8str[0];
  554. }
  556. uint32_t native_scan_code = 0;
  557. uint32_t native_virtual_key = 0;
  558. uint32_t native_modifiers = 0;
  559. deserializeKeyboardData( native_key_data, native_scan_code, native_virtual_key, native_modifiers );
  561. LLQtWebKit::getInstance()->keyboardEvent( mBrowserWindowId, LLQtWebKit::KE_KEY_DOWN, (uint32_t)key, utf8str.c_str(), modifiers, native_scan_code, native_virtual_key, native_modifiers);
  562. LLQtWebKit::getInstance()->keyboardEvent( mBrowserWindowId, LLQtWebKit::KE_KEY_UP, (uint32_t)key, utf8str.c_str(), modifiers, native_scan_code, native_virtual_key, native_modifiers);
  564. checkEditState();
  565. };
  567. void checkEditState(void)
  568. {
  569. bool can_cut = LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_EDIT_CUT);
  570. bool can_copy = LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_EDIT_COPY);
  571. bool can_paste = LLQtWebKit::getInstance()->userActionIsEnabled( mBrowserWindowId, LLQtWebKit::UA_EDIT_PASTE);
  573. if((can_cut != mCanCut) || (can_copy != mCanCopy) || (can_paste != mCanPaste))
  574. {
  575. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "edit_state");
  577. if(can_cut != mCanCut)
  578. {
  579. mCanCut = can_cut;
  580. message.setValueBoolean("cut", can_cut);
  581. }
  583. if(can_copy != mCanCopy)
  584. {
  585. mCanCopy = can_copy;
  586. message.setValueBoolean("copy", can_copy);
  587. }
  589. if(can_paste != mCanPaste)
  590. {
  591. mCanPaste = can_paste;
  592. message.setValueBoolean("paste", can_paste);
  593. }
  595. sendMessage(message);
  597. }
  598. }
  600. };
  602. MediaPluginWebKit::MediaPluginWebKit(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data) :
  603. MediaPluginBase(host_send_func, host_user_data)
  604. {
  605. // std::cerr << "MediaPluginWebKit constructor" << std::endl;
  607. mBrowserWindowId = 0;
  608. mInitState = INIT_STATE_UNINITIALIZED;
  609. mNeedsUpdate = true;
  610. mCanCut = false;
  611. mCanCopy = false;
  612. mCanPaste = false;
  613. mLastMouseX = 0;
  614. mLastMouseY = 0;
  615. mFirstFocus = true;
  616. mBackgroundR = 0.0f;
  617. mBackgroundG = 0.0f;
  618. mBackgroundB = 0.0f;
  619. }
  621. MediaPluginWebKit::~MediaPluginWebKit()
  622. {
  623. // unhook observer
  624. LLQtWebKit::getInstance()->remObserver( mBrowserWindowId, this );
  626. // clean up
  627. LLQtWebKit::getInstance()->reset();
  629. // std::cerr << "MediaPluginWebKit destructor" << std::endl;
  630. }
  632. void MediaPluginWebKit::receiveMessage(const char *message_string)
  633. {
  634. // std::cerr << "MediaPluginWebKit::receiveMessage: received message: "" << message_string << """ << std::endl;
  635. LLPluginMessage message_in;
  637. if(message_in.parse(message_string) >= 0)
  638. {
  639. std::string message_class = message_in.getClass();
  640. std::string message_name = message_in.getName();
  641. if(message_class == LLPLUGIN_MESSAGE_CLASS_BASE)
  642. {
  643. if(message_name == "init")
  644. {
  645. std::string user_data_path = message_in.getValue("user_data_path"); // n.b. always has trailing platform-specific dir-delimiter
  646. mProfileDir = user_data_path + "browser_profile";
  648. LLPluginMessage message("base", "init_response");
  649. LLSD versions = LLSD::emptyMap();
  650. versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
  651. versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
  652. versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER] = LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION;
  653. message.setValueLLSD("versions", versions);
  655. std::string plugin_version = "Webkit media plugin, Webkit version ";
  656. plugin_version += LLQtWebKit::getInstance()->getVersion();
  657. message.setValue("plugin_version", plugin_version);
  658. sendMessage(message);
  660. // Plugin gets to decide the texture parameters to use.
  661. mDepth = 4;
  663. message.setMessage(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
  664. message.setValueS32("default_width", 1024);
  665. message.setValueS32("default_height", 1024);
  666. message.setValueS32("depth", mDepth);
  667. message.setValueU32("internalformat", GL_RGBA);
  668. message.setValueU32("format", GL_RGBA);
  669. message.setValueU32("type", GL_UNSIGNED_BYTE);
  670. message.setValueBoolean("coords_opengl", true);
  671. sendMessage(message);
  672. }
  673. else if(message_name == "idle")
  674. {
  675. // no response is necessary here.
  676. F64 time = message_in.getValueReal("time");
  678. // Convert time to milliseconds for update()
  679. update((int)(time * 1000.0f));
  680. }
  681. else if(message_name == "cleanup")
  682. {
  683. // DTOR most likely won't be called but the recent change to the way this process
  684. // is (not) killed means we see this message and can do what we need to here.
  685. // Note: this cleanup is ultimately what writes cookies to the disk
  686. LLQtWebKit::getInstance()->remObserver( mBrowserWindowId, this );
  687. LLQtWebKit::getInstance()->reset();
  688. }
  689. else if(message_name == "shm_added")
  690. {
  691. SharedSegmentInfo info;
  692. info.mAddress = message_in.getValuePointer("address");
  693. info.mSize = (size_t)message_in.getValueS32("size");
  694. std::string name = message_in.getValue("name");
  696. // std::cerr << "MediaPluginWebKit::receiveMessage: shared memory added, name: " << name 
  697. // << ", size: " << info.mSize 
  698. // << ", address: " << info.mAddress 
  699. // << std::endl;
  701. mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
  703. }
  704. else if(message_name == "shm_remove")
  705. {
  706. std::string name = message_in.getValue("name");
  708. // std::cerr << "MediaPluginWebKit::receiveMessage: shared memory remove, name = " << name << std::endl;
  710. SharedSegmentMap::iterator iter = mSharedSegments.find(name);
  711. if(iter != mSharedSegments.end())
  712. {
  713. if(mPixels == iter->second.mAddress)
  714. {
  715. // This is the currently active pixel buffer.  Make sure we stop drawing to it.
  716. mPixels = NULL;
  717. mTextureSegmentName.clear();
  718. }
  719. mSharedSegments.erase(iter);
  720. }
  721. else
  722. {
  723. // std::cerr << "MediaPluginWebKit::receiveMessage: unknown shared memory region!" << std::endl;
  724. }
  726. // Send the response so it can be cleaned up.
  727. LLPluginMessage message("base", "shm_remove_response");
  728. message.setValue("name", name);
  729. sendMessage(message);
  730. }
  731. else
  732. {
  733. // std::cerr << "MediaPluginWebKit::receiveMessage: unknown base message: " << message_name << std::endl;
  734. }
  735. }
  736. else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
  737. {
  738. if(message_name == "size_change")
  739. {
  740. std::string name = message_in.getValue("name");
  741. S32 width = message_in.getValueS32("width");
  742. S32 height = message_in.getValueS32("height");
  743. S32 texture_width = message_in.getValueS32("texture_width");
  744. S32 texture_height = message_in.getValueS32("texture_height");
  745. mBackgroundR = message_in.getValueReal("background_r");
  746. mBackgroundG = message_in.getValueReal("background_g");
  747. mBackgroundB = message_in.getValueReal("background_b");
  748. // mBackgroundA = message_in.setValueReal("background_a"); // Ignore any alpha
  750. if(!name.empty())
  751. {
  752. // Find the shared memory region with this name
  753. SharedSegmentMap::iterator iter = mSharedSegments.find(name);
  754. if(iter != mSharedSegments.end())
  755. {
  756. mPixels = (unsigned char*)iter->second.mAddress;
  757. mWidth = width;
  758. mHeight = height;
  760. // initialize (only gets called once)
  761. initBrowser();
  763. // size changed so tell the browser
  764. LLQtWebKit::getInstance()->setSize( mBrowserWindowId, mWidth, mHeight );
  766. // std::cerr << "webkit plugin: set size to " << mWidth << " x " << mHeight 
  767. // << ", rowspan is " << LLQtWebKit::getInstance()->getBrowserRowSpan(mBrowserWindowId) << std::endl;
  769. S32 real_width = LLQtWebKit::getInstance()->getBrowserRowSpan(mBrowserWindowId) / LLQtWebKit::getInstance()->getBrowserDepth(mBrowserWindowId); 
  771. // The actual width the browser will be drawing to is probably smaller... let the host know by modifying texture_width in the response.
  772. if(real_width <= texture_width)
  773. {
  774. texture_width = real_width;
  775. }
  776. else
  777. {
  778. // This won't work -- it'll be bigger than the allocated memory.  This is a fatal error.
  779. // std::cerr << "Fatal error: browser rowbytes greater than texture width" << std::endl;
  780. mDeleteMe = true;
  781. return;
  782. }
  784. mTextureWidth = texture_width;
  785. mTextureHeight = texture_height;
  787. };
  788. };
  790. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response");
  791. message.setValue("name", name);
  792. message.setValueS32("width", width);
  793. message.setValueS32("height", height);
  794. message.setValueS32("texture_width", texture_width);
  795. message.setValueS32("texture_height", texture_height);
  796. sendMessage(message);
  798. }
  799. else if(message_name == "load_uri")
  800. {
  801. std::string uri = message_in.getValue("uri");
  803. // std::cout << "loading URI: " << uri << std::endl;
  805. if(!uri.empty())
  806. {
  807. if(mInitState >= INIT_STATE_NAVIGATE_COMPLETE)
  808. {
  809. LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, uri );
  810. }
  811. else
  812. {
  813. mInitialNavigateURL = uri;
  814. }
  815. }
  816. }
  817. else if(message_name == "mouse_event")
  818. {
  819. std::string event = message_in.getValue("event");
  820. S32 button = message_in.getValueS32("button");
  821. mLastMouseX = message_in.getValueS32("x");
  822. mLastMouseY = message_in.getValueS32("y");
  823. std::string modifiers = message_in.getValue("modifiers");
  825. // Treat unknown mouse events as mouse-moves.
  826. LLQtWebKit::EMouseEvent mouse_event = LLQtWebKit::ME_MOUSE_MOVE;
  827. if(event == "down")
  828. {
  829. mouse_event = LLQtWebKit::ME_MOUSE_DOWN;
  830. }
  831. else if(event == "up")
  832. {
  833. mouse_event = LLQtWebKit::ME_MOUSE_UP;
  834. }
  835. else if(event == "double_click")
  836. {
  837. mouse_event = LLQtWebKit::ME_MOUSE_DOUBLE_CLICK;
  838. }
  840. LLQtWebKit::getInstance()->mouseEvent( mBrowserWindowId, mouse_event, button, mLastMouseX, mLastMouseY, decodeModifiers(modifiers));
  841. checkEditState();
  842. }
  843. else if(message_name == "scroll_event")
  844. {
  845. S32 x = message_in.getValueS32("x");
  846. S32 y = message_in.getValueS32("y");
  847. std::string modifiers = message_in.getValue("modifiers");
  849. // Incoming scroll events are adjusted so that 1 detent is approximately 1 unit.
  850. // Qt expects 1 detent to be 120 units.
  851. // It also seems that our y scroll direction is inverted vs. what Qt expects.
  853. x *= 120;
  854. y *= -120;
  856. LLQtWebKit::getInstance()->scrollWheelEvent(mBrowserWindowId, mLastMouseX, mLastMouseY, x, y, decodeModifiers(modifiers));
  857. }
  858. else if(message_name == "key_event")
  859. {
  860. std::string event = message_in.getValue("event");
  861. S32 key = message_in.getValueS32("key");
  862. std::string modifiers = message_in.getValue("modifiers");
  863. LLSD native_key_data = message_in.getValueLLSD("native_key_data");
  865. // Treat unknown events as key-up for safety.
  866. LLQtWebKit::EKeyEvent key_event = LLQtWebKit::KE_KEY_UP;
  867. if(event == "down")
  868. {
  869. key_event = LLQtWebKit::KE_KEY_DOWN;
  870. }
  871. else if(event == "repeat")
  872. {
  873. key_event = LLQtWebKit::KE_KEY_REPEAT;
  874. }
  876. keyEvent(key_event, key, decodeModifiers(modifiers), native_key_data);
  877. }
  878. else if(message_name == "text_event")
  879. {
  880. std::string text = message_in.getValue("text");
  881. std::string modifiers = message_in.getValue("modifiers");
  882. LLSD native_key_data = message_in.getValueLLSD("native_key_data");
  884. unicodeInput(text, decodeModifiers(modifiers), native_key_data);
  885. }
  886. if(message_name == "edit_cut")
  887. {
  888. LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_EDIT_CUT );
  889. checkEditState();
  890. }
  891. if(message_name == "edit_copy")
  892. {
  893. LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_EDIT_COPY );
  894. checkEditState();
  895. }
  896. if(message_name == "edit_paste")
  897. {
  898. LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_EDIT_PASTE );
  899. checkEditState();
  900. }
  901. else
  902. {
  903. // std::cerr << "MediaPluginWebKit::receiveMessage: unknown media message: " << message_string << std::endl;
  904. };
  905. }
  906. else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER)
  907. {
  908. if(message_name == "focus")
  909. {
  910. bool val = message_in.getValueBoolean("focused");
  911. LLQtWebKit::getInstance()->focusBrowser( mBrowserWindowId, val );
  913. if(mFirstFocus && val)
  914. {
  915. // On the first focus, post a tab key event.  This fixes a problem with initial focus.
  916. std::string empty;
  917. keyEvent(LLQtWebKit::KE_KEY_DOWN, KEY_TAB, decodeModifiers(empty));
  918. keyEvent(LLQtWebKit::KE_KEY_UP, KEY_TAB, decodeModifiers(empty));
  919. mFirstFocus = false;
  920. }
  921. }
  922. else if(message_name == "clear_cache")
  923. {
  924. LLQtWebKit::getInstance()->clearCache();
  925. }
  926. else if(message_name == "clear_cookies")
  927. {
  928. LLQtWebKit::getInstance()->clearAllCookies();
  929. }
  930. else if(message_name == "enable_cookies")
  931. {
  932. bool val = message_in.getValueBoolean("enable");
  933. LLQtWebKit::getInstance()->enableCookies( val );
  934. }
  935. else if(message_name == "proxy_setup")
  936. {
  937. bool val = message_in.getValueBoolean("enable");
  938. std::string host = message_in.getValue("host");
  939. int port = message_in.getValueS32("port");
  940. LLQtWebKit::getInstance()->enableProxy( val, host, port );
  941. }
  942. else if(message_name == "browse_stop")
  943. {
  944. LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_STOP );
  945. }
  946. else if(message_name == "browse_reload")
  947. {
  948. // foo = message_in.getValueBoolean("ignore_cache");
  949. LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_RELOAD );
  950. }
  951. else if(message_name == "browse_forward")
  952. {
  953. LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_FORWARD );
  954. }
  955. else if(message_name == "browse_back")
  956. {
  957. LLQtWebKit::getInstance()->userAction( mBrowserWindowId, LLQtWebKit::UA_NAVIGATE_BACK );
  958. }
  959. else if(message_name == "set_status_redirect")
  960. {
  961. int code = message_in.getValueS32("code");
  962. std::string url = message_in.getValue("url");
  963. if ( 404 == code ) // browser lib only supports 404 right now
  964. {
  965. LLQtWebKit::getInstance()->set404RedirectUrl( mBrowserWindowId, url );
  966. };
  967. }
  968. else if(message_name == "set_user_agent")
  969. {
  970. std::string user_agent = message_in.getValue("user_agent");
  971. LLQtWebKit::getInstance()->setBrowserAgentId( user_agent );
  972. }
  973. else if(message_name == "init_history")
  974. {
  975. // Initialize browser history
  976. LLSD history = message_in.getValueLLSD("history");
  977. // First, clear the URL history
  978. LLQtWebKit::getInstance()->clearHistory(mBrowserWindowId);
  979. // Then, add the history items in order
  980. LLSD::array_iterator iter_history = history.beginArray();
  981. LLSD::array_iterator end_history = history.endArray();
  982. for(; iter_history != end_history; ++iter_history)
  983. {
  984. std::string url = (*iter_history).asString();
  985. if(! url.empty()) {
  986. LLQtWebKit::getInstance()->prependHistoryUrl(mBrowserWindowId, url);
  987. }
  988. }
  989. }
  990. else
  991. {
  992. // std::cerr << "MediaPluginWebKit::receiveMessage: unknown media_browser message: " << message_string << std::endl;
  993. };
  994. }
  995. else
  996. {
  997. // std::cerr << "MediaPluginWebKit::receiveMessage: unknown message class: " << message_class << std::endl;
  998. };
  999. }
  1000. }
  1002. int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
  1003. {
  1004. MediaPluginWebKit *self = new MediaPluginWebKit(host_send_func, host_user_data);
  1005. *plugin_send_func = MediaPluginWebKit::staticReceiveMessage;
  1006. *plugin_user_data = (void*)self;
  1008. return 0;
  1009. }