summaryrefslogtreecommitdiff
path: root/indra/media_plugins
diff options
context:
space:
mode:
Diffstat (limited to 'indra/media_plugins')
-rw-r--r--indra/media_plugins/CMakeLists.txt2
-rw-r--r--indra/media_plugins/base/media_plugin_base.cpp1
-rw-r--r--indra/media_plugins/base/media_plugin_base.h1
-rw-r--r--indra/media_plugins/example/CMakeLists.txt74
-rw-r--r--indra/media_plugins/example/media_plugin_example.cpp488
-rw-r--r--indra/media_plugins/quicktime/CMakeLists.txt8
-rw-r--r--indra/media_plugins/quicktime/media_plugin_quicktime.cpp219
-rw-r--r--indra/media_plugins/webkit/CMakeLists.txt8
-rw-r--r--indra/media_plugins/webkit/media_plugin_webkit.cpp186
9 files changed, 880 insertions, 107 deletions
diff --git a/indra/media_plugins/CMakeLists.txt b/indra/media_plugins/CMakeLists.txt
index d35afd8cbd..cc03d9cb72 100644
--- a/indra/media_plugins/CMakeLists.txt
+++ b/indra/media_plugins/CMakeLists.txt
@@ -9,3 +9,5 @@ add_subdirectory(gstreamer010)
if (WINDOWS OR DARWIN)
add_subdirectory(quicktime)
endif (WINDOWS OR DARWIN)
+
+add_subdirectory(example)
diff --git a/indra/media_plugins/base/media_plugin_base.cpp b/indra/media_plugins/base/media_plugin_base.cpp
index 0b7092fad6..6acac07423 100644
--- a/indra/media_plugins/base/media_plugin_base.cpp
+++ b/indra/media_plugins/base/media_plugin_base.cpp
@@ -64,6 +64,7 @@ std::string MediaPluginBase::statusString()
case STATUS_ERROR: result = "error"; break;
case STATUS_PLAYING: result = "playing"; break;
case STATUS_PAUSED: result = "paused"; break;
+ case STATUS_DONE: result = "done"; break;
default:
// keep the empty string
break;
diff --git a/indra/media_plugins/base/media_plugin_base.h b/indra/media_plugins/base/media_plugin_base.h
index 8f600cb8d6..f1e96335f9 100644
--- a/indra/media_plugins/base/media_plugin_base.h
+++ b/indra/media_plugins/base/media_plugin_base.h
@@ -56,6 +56,7 @@ protected:
STATUS_ERROR,
STATUS_PLAYING,
STATUS_PAUSED,
+ STATUS_DONE
} EStatus;
class SharedSegmentInfo
diff --git a/indra/media_plugins/example/CMakeLists.txt b/indra/media_plugins/example/CMakeLists.txt
new file mode 100644
index 0000000000..4d82f2747c
--- /dev/null
+++ b/indra/media_plugins/example/CMakeLists.txt
@@ -0,0 +1,74 @@
+# -*- cmake -*-
+
+project(media_plugin_example)
+
+include(00-Common)
+include(LLCommon)
+include(LLImage)
+include(LLPlugin)
+include(LLMath)
+include(LLRender)
+include(LLWindow)
+include(Linking)
+include(PluginAPI)
+include(MediaPluginBase)
+include(FindOpenGL)
+
+include(ExamplePlugin)
+
+include_directories(
+ ${LLPLUGIN_INCLUDE_DIRS}
+ ${MEDIA_PLUGIN_BASE_INCLUDE_DIRS}
+ ${LLCOMMON_INCLUDE_DIRS}
+ ${LLMATH_INCLUDE_DIRS}
+ ${LLIMAGE_INCLUDE_DIRS}
+ ${LLRENDER_INCLUDE_DIRS}
+ ${LLWINDOW_INCLUDE_DIRS}
+)
+
+
+### media_plugin_example
+
+set(media_plugin_example_SOURCE_FILES
+ media_plugin_example.cpp
+ )
+
+add_library(media_plugin_example
+ SHARED
+ ${media_plugin_example_SOURCE_FILES}
+)
+
+target_link_libraries(media_plugin_example
+ ${LLPLUGIN_LIBRARIES}
+ ${MEDIA_PLUGIN_BASE_LIBRARIES}
+ ${LLCOMMON_LIBRARIES}
+ ${EXAMPLE_PLUGIN_LIBRARIES}
+ ${PLUGIN_API_WINDOWS_LIBRARIES}
+)
+
+add_dependencies(media_plugin_example
+ ${LLPLUGIN_LIBRARIES}
+ ${MEDIA_PLUGIN_BASE_LIBRARIES}
+ ${LLCOMMON_LIBRARIES}
+)
+
+if (WINDOWS)
+ set_target_properties(
+ media_plugin_example
+ PROPERTIES
+ LINK_FLAGS "/MANIFEST:NO"
+ )
+endif (WINDOWS)
+
+if (DARWIN)
+ # Don't prepend 'lib' to the executable name, and don't embed a full path in the library's install name
+ set_target_properties(
+ media_plugin_example
+ PROPERTIES
+ PREFIX ""
+ BUILD_WITH_INSTALL_RPATH 1
+ INSTALL_NAME_DIR "@executable_path"
+ LINK_FLAGS "-exported_symbols_list ${CMAKE_CURRENT_SOURCE_DIR}/../base/media_plugin_base.exp"
+ )
+
+endif (DARWIN) \ No newline at end of file
diff --git a/indra/media_plugins/example/media_plugin_example.cpp b/indra/media_plugins/example/media_plugin_example.cpp
new file mode 100644
index 0000000000..99e0199a29
--- /dev/null
+++ b/indra/media_plugins/example/media_plugin_example.cpp
@@ -0,0 +1,488 @@
+/**
+ * @file media_plugin_example.cpp
+ * @brief Example plugin for LLMedia API plugin system
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ *
+ * Copyright (c) 2009, Linden Research, Inc.
+ *
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab. Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ *
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ *
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llgl.h"
+#include "llplugininstance.h"
+#include "llpluginmessage.h"
+#include "llpluginmessageclasses.h"
+#include "media_plugin_base.h"
+
+#include <time.h>
+
+////////////////////////////////////////////////////////////////////////////////
+//
+class MediaPluginExample :
+ public MediaPluginBase
+{
+ public:
+ MediaPluginExample( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data );
+ ~MediaPluginExample();
+
+ /*virtual*/ void receiveMessage( const char* message_string );
+
+ private:
+ bool init();
+ void update( F64 milliseconds );
+ void write_pixel( int x, int y, unsigned char r, unsigned char g, unsigned char b );
+ bool mFirstTime;
+
+ time_t mLastUpdateTime;
+ enum Constants { ENumObjects = 10 };
+ unsigned char* mBackgroundPixels;
+ int mColorR[ ENumObjects ];
+ int mColorG[ ENumObjects ];
+ int mColorB[ ENumObjects ];
+ int mXpos[ ENumObjects ];
+ int mYpos[ ENumObjects ];
+ int mXInc[ ENumObjects ];
+ int mYInc[ ENumObjects ];
+ int mBlockSize[ ENumObjects ];
+ bool mMouseButtonDown;
+ bool mStopAction;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+MediaPluginExample::MediaPluginExample( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data ) :
+ MediaPluginBase( host_send_func, host_user_data )
+{
+ mFirstTime = true;
+ mWidth = 0;
+ mHeight = 0;
+ mDepth = 4;
+ mPixels = 0;
+ mMouseButtonDown = false;
+ mStopAction = false;
+ mLastUpdateTime = 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+MediaPluginExample::~MediaPluginExample()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void MediaPluginExample::receiveMessage( const char* message_string )
+{
+ 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 = "Example media plugin, Example Version 1.0.0.0";
+ message.setValue( "plugin_version", plugin_version );
+ sendMessage( message );
+
+ // Plugin gets to decide the texture parameters to use.
+ message.setMessage( LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params" );
+ message.setValueS32( "default_width", mWidth );
+ message.setValueS32( "default_height", mHeight );
+ message.setValueS32( "depth", mDepth );
+ message.setValueU32( "internalformat", GL_RGBA );
+ message.setValueU32( "format", GL_RGBA );
+ message.setValueU32( "type", GL_UNSIGNED_BYTE );
+ message.setValueBoolean( "coords_opengl", false );
+ 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( time );
+ }
+ else
+ if ( message_name == "cleanup" )
+ {
+ // clean up here
+ }
+ 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" );
+
+ mSharedSegments.insert( SharedSegmentMap::value_type( name, info ) );
+
+ }
+ else
+ if ( message_name == "shm_remove" )
+ {
+ std::string name = message_in.getValue( "name" );
+
+ 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 << "MediaPluginExample::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 << "MediaPluginExample::receiveMessage: unknown base message: " << message_name << std::endl;
+ };
+ }
+ else
+ if ( message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA )
+ {
+ 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" );
+
+ 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;
+
+ mTextureWidth = texture_width;
+ mTextureHeight = texture_height;
+
+ init();
+ };
+ };
+
+ 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" );
+ if ( ! uri.empty() )
+ {
+ };
+ }
+ else
+ if ( message_name == "mouse_event" )
+ {
+ std::string event = message_in.getValue( "event" );
+ S32 button = message_in.getValueS32( "button" );
+
+ // left mouse button
+ if ( button == 0 )
+ {
+ int mouse_x = message_in.getValueS32( "x" );
+ int mouse_y = message_in.getValueS32( "y" );
+ std::string modifiers = message_in.getValue( "modifiers" );
+
+ if ( event == "move" )
+ {
+ if ( mMouseButtonDown )
+ write_pixel( mouse_x, mouse_y, rand() % 0x80 + 0x80, rand() % 0x80 + 0x80, rand() % 0x80 + 0x80 );
+ }
+ else
+ if ( event == "down" )
+ {
+ mMouseButtonDown = true;
+ }
+ else
+ if ( event == "up" )
+ {
+ mMouseButtonDown = false;
+ }
+ else
+ if ( event == "double_click" )
+ {
+ };
+ };
+ }
+ 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" );
+
+ if ( event == "down" )
+ {
+ if ( key == ' ')
+ {
+ mLastUpdateTime = 0;
+ update( 0.0f );
+ };
+ };
+ }
+ else
+ {
+ //std::cerr << "MediaPluginExample::receiveMessage: unknown media message: " << message_string << std::endl;
+ };
+ }
+ else
+ if ( message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER )
+ {
+ if ( message_name == "browse_reload" )
+ {
+ mLastUpdateTime = 0;
+ mFirstTime = true;
+ mStopAction = false;
+ update( 0.0f );
+ }
+ else
+ if ( message_name == "browse_stop" )
+ {
+ for( int n = 0; n < ENumObjects; ++n )
+ mXInc[ n ] = mYInc[ n ] = 0;
+
+ mStopAction = true;
+ update( 0.0f );
+ }
+ else
+ {
+ //std::cerr << "MediaPluginExample::receiveMessage: unknown media_browser message: " << message_string << std::endl;
+ };
+ }
+ else
+ {
+ //std::cerr << "MediaPluginExample::receiveMessage: unknown message class: " << message_class << std::endl;
+ };
+ };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void MediaPluginExample::write_pixel( int x, int y, unsigned char r, unsigned char g, unsigned char b )
+{
+ // make sure we don't write outside the buffer
+ if ( ( x < 0 ) || ( x >= mWidth ) || ( y < 0 ) || ( y >= mHeight ) )
+ return;
+
+ if ( mBackgroundPixels != NULL )
+ {
+ unsigned char *pixel = mBackgroundPixels;
+ pixel += y * mWidth * mDepth;
+ pixel += ( x * mDepth );
+ pixel[ 0 ] = b;
+ pixel[ 1 ] = g;
+ pixel[ 2 ] = r;
+
+ setDirty( x, y, x + 1, y + 1 );
+ };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void MediaPluginExample::update( F64 milliseconds )
+{
+ if ( mWidth < 1 || mWidth > 2048 || mHeight < 1 || mHeight > 2048 )
+ return;
+
+ if ( mPixels == 0 )
+ return;
+
+ if ( mFirstTime )
+ {
+ for( int n = 0; n < ENumObjects; ++n )
+ {
+ mXpos[ n ] = ( mWidth / 2 ) + rand() % ( mWidth / 16 ) - ( mWidth / 32 );
+ mYpos[ n ] = ( mHeight / 2 ) + rand() % ( mHeight / 16 ) - ( mHeight / 32 );
+
+ mColorR[ n ] = rand() % 0x60 + 0x60;
+ mColorG[ n ] = rand() % 0x60 + 0x60;
+ mColorB[ n ] = rand() % 0x60 + 0x60;
+
+ mXInc[ n ] = 0;
+ while ( mXInc[ n ] == 0 )
+ mXInc[ n ] = rand() % 7 - 3;
+
+ mYInc[ n ] = 0;
+ while ( mYInc[ n ] == 0 )
+ mYInc[ n ] = rand() % 9 - 4;
+
+ mBlockSize[ n ] = rand() % 0x30 + 0x10;
+ };
+
+ delete [] mBackgroundPixels;
+
+ mBackgroundPixels = new unsigned char[ mWidth * mHeight * mDepth ];
+
+ mFirstTime = false;
+ };
+
+ if ( mStopAction )
+ return;
+
+ if ( time( NULL ) > mLastUpdateTime + 3 )
+ {
+ const int num_squares = rand() % 20 + 4;
+ int sqr1_r = rand() % 0x80 + 0x20;
+ int sqr1_g = rand() % 0x80 + 0x20;
+ int sqr1_b = rand() % 0x80 + 0x20;
+ int sqr2_r = rand() % 0x80 + 0x20;
+ int sqr2_g = rand() % 0x80 + 0x20;
+ int sqr2_b = rand() % 0x80 + 0x20;
+
+ for ( int y1 = 0; y1 < num_squares; ++y1 )
+ {
+ for ( int x1 = 0; x1 < num_squares; ++x1 )
+ {
+ int px_start = mWidth * x1 / num_squares;
+ int px_end = ( mWidth * ( x1 + 1 ) ) / num_squares;
+ int py_start = mHeight * y1 / num_squares;
+ int py_end = ( mHeight * ( y1 + 1 ) ) / num_squares;
+
+ for( int y2 = py_start; y2 < py_end; ++y2 )
+ {
+ for( int x2 = px_start; x2 < px_end; ++x2 )
+ {
+ int rowspan = mWidth * mDepth;
+
+ if ( ( y1 % 2 ) ^ ( x1 % 2 ) )
+ {
+ mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 0 ] = sqr1_r;
+ mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 1 ] = sqr1_g;
+ mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 2 ] = sqr1_b;
+ }
+ else
+ {
+ mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 0 ] = sqr2_r;
+ mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 1 ] = sqr2_g;
+ mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 2 ] = sqr2_b;
+ };
+ };
+ };
+ };
+ };
+
+ time( &mLastUpdateTime );
+ };
+
+ memcpy( mPixels, mBackgroundPixels, mWidth * mHeight * mDepth );
+
+ for( int n = 0; n < ENumObjects; ++n )
+ {
+ if ( rand() % 50 == 0 )
+ {
+ mXInc[ n ] = 0;
+ while ( mXInc[ n ] == 0 )
+ mXInc[ n ] = rand() % 7 - 3;
+
+ mYInc[ n ] = 0;
+ while ( mYInc[ n ] == 0 )
+ mYInc[ n ] = rand() % 9 - 4;
+ };
+
+ if ( mXpos[ n ] + mXInc[ n ] < 0 || mXpos[ n ] + mXInc[ n ] >= mWidth - mBlockSize[ n ] )
+ mXInc[ n ] =- mXInc[ n ];
+
+ if ( mYpos[ n ] + mYInc[ n ] < 0 || mYpos[ n ] + mYInc[ n ] >= mHeight - mBlockSize[ n ] )
+ mYInc[ n ] =- mYInc[ n ];
+
+ mXpos[ n ] += mXInc[ n ];
+ mYpos[ n ] += mYInc[ n ];
+
+ for( int y = 0; y < mBlockSize[ n ]; ++y )
+ {
+ for( int x = 0; x < mBlockSize[ n ]; ++x )
+ {
+ mPixels[ ( mXpos[ n ] + x ) * mDepth + ( mYpos[ n ] + y ) * mDepth * mWidth + 0 ] = mColorR[ n ];
+ mPixels[ ( mXpos[ n ] + x ) * mDepth + ( mYpos[ n ] + y ) * mDepth * mWidth + 1 ] = mColorG[ n ];
+ mPixels[ ( mXpos[ n ] + x ) * mDepth + ( mYpos[ n ] + y ) * mDepth * mWidth + 2 ] = mColorB[ n ];
+ };
+ };
+ };
+
+ setDirty( 0, 0, mWidth, mHeight );
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+bool MediaPluginExample::init()
+{
+ LLPluginMessage message( LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text" );
+ message.setValue( "name", "Example Plugin" );
+ sendMessage( message );
+
+ return true;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+int init_media_plugin( LLPluginInstance::sendMessageFunction host_send_func,
+ void* host_user_data,
+ LLPluginInstance::sendMessageFunction *plugin_send_func,
+ void **plugin_user_data )
+{
+ MediaPluginExample* self = new MediaPluginExample( host_send_func, host_user_data );
+ *plugin_send_func = MediaPluginExample::staticReceiveMessage;
+ *plugin_user_data = ( void* )self;
+
+ return 0;
+}
diff --git a/indra/media_plugins/quicktime/CMakeLists.txt b/indra/media_plugins/quicktime/CMakeLists.txt
index db11c9ae21..f0b8f0d167 100644
--- a/indra/media_plugins/quicktime/CMakeLists.txt
+++ b/indra/media_plugins/quicktime/CMakeLists.txt
@@ -56,6 +56,14 @@ add_dependencies(media_plugin_quicktime
${LLCOMMON_LIBRARIES}
)
+if (WINDOWS)
+ set_target_properties(
+ media_plugin_quicktime
+ PROPERTIES
+ LINK_FLAGS "/MANIFEST:NO"
+ )
+endif (WINDOWS)
+
if (QUICKTIME)
add_definitions(-DLL_QUICKTIME_ENABLED=1)
diff --git a/indra/media_plugins/quicktime/media_plugin_quicktime.cpp b/indra/media_plugins/quicktime/media_plugin_quicktime.cpp
index fbda65120d..de927de1cd 100644
--- a/indra/media_plugins/quicktime/media_plugin_quicktime.cpp
+++ b/indra/media_plugins/quicktime/media_plugin_quicktime.cpp
@@ -1,4 +1,4 @@
-/**
+/**
* @file media_plugin_quicktime.cpp
* @brief QuickTime plugin for LLMedia API plugin system
*
@@ -48,6 +48,7 @@
#include "Movies.h"
#include "QDoffscreen.h"
#include "FixMath.h"
+ #include "QTLoadLibraryUtils.h"
#endif
// TODO: Make sure that the only symbol exported from this library is LLPluginInitEntryPoint
@@ -71,11 +72,14 @@ private:
int mCurVolume;
bool mMediaSizeChanging;
bool mIsLooping;
+ std::string mMovieTitle;
+ bool mReceivedTitle;
const int mMinWidth;
const int mMaxWidth;
const int mMinHeight;
const int mMaxHeight;
F64 mPlayRate;
+ std::string mNavigateURL;
enum ECommand {
COMMAND_NONE,
@@ -97,14 +101,14 @@ private:
message.setValueS32("top", top);
message.setValueS32("right", right);
message.setValueS32("bottom", bottom);
-
+
if(mMovieHandle)
{
message.setValueReal("current_time", getCurrentTime());
message.setValueReal("duration", getDuration());
message.setValueReal("current_rate", Fix2X(GetMovieRate(mMovieHandle)));
}
-
+
sendMessage(message);
}
@@ -112,16 +116,16 @@ private:
static Rect rectFromSize(int width, int height)
{
Rect result;
-
+
result.left = 0;
result.top = 0;
result.right = width;
result.bottom = height;
-
+
return result;
}
-
+
Fixed getPlayRate(void)
{
Fixed result;
@@ -140,25 +144,27 @@ private:
{
result = X2Fix(mPlayRate);
}
-
+
return result;
}
-
+
void load( const std::string url )
{
+
if ( url.empty() )
return;
-
+
// Stop and unload any existing movie before starting another one.
unload();
-
+
setStatus(STATUS_LOADING);
-
+
//In case std::string::c_str() makes a copy of the url data,
//make sure there is memory to hold it before allocating memory for handle.
//if fails, NewHandleClear(...) should return NULL.
const char* url_string = url.c_str() ;
Handle handle = NewHandleClear( ( Size )( url.length() + 1 ) );
+
if ( NULL == handle || noErr != MemError() || NULL == *handle )
{
setStatus(STATUS_ERROR);
@@ -174,6 +180,11 @@ private:
setStatus(STATUS_ERROR);
return;
};
+
+ mNavigateURL = url;
+ LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_begin");
+ message.setValue("uri", mNavigateURL);
+ sendMessage(message);
// do pre-roll actions (typically fired for streaming movies but not always)
PrePrerollMovie( mMovieHandle, 0, getPlayRate(), moviePrePrerollCompleteCallback, ( void * )this );
@@ -192,12 +203,15 @@ private:
SetMovieDrawingCompleteProc( mMovieHandle, movieDrawingCallWhenChanged, movieDrawingCompleteCallback, ( long )this );
setStatus(STATUS_LOADED);
-
+
sizeChanged();
};
bool unload()
{
+ // new movie and have to get title again
+ mReceivedTitle = false;
+
if ( mMovieHandle )
{
StopMovie( mMovieHandle );
@@ -226,7 +240,7 @@ private:
DisposeGWorld( mGWorldHandle );
mGWorldHandle = NULL;
};
-
+
setStatus(STATUS_NONE);
return true;
@@ -236,7 +250,7 @@ private:
{
unload();
load( url );
-
+
return true;
};
@@ -244,7 +258,7 @@ private:
{
if ( ! mMovieHandle )
return false;
-
+
// Check to see whether the movie's natural size has updated
{
int width, height;
@@ -262,14 +276,14 @@ private:
//std::cerr << "<--- Sending size change request to application with name: " << mTextureSegmentName << " - size is " << width << " x " << height << std::endl;
}
}
-
+
// sanitize destination size
Rect dest_rect = rectFromSize(mWidth, mHeight);
// media depth won't change
int depth_bits = mDepth * 8;
long rowbytes = mDepth * mTextureWidth;
-
+
GWorldPtr old_gworld_handle = mGWorldHandle;
if(mPixels != NULL)
@@ -301,7 +315,7 @@ private:
{
DisposeGWorld( old_gworld_handle );
}
-
+
// Set up the movie display matrix
{
// scale movie to fit rect and invert vertically to match opengl image format
@@ -314,7 +328,7 @@ private:
ScaleMatrix( &transform, X2Fix( scaleX ), X2Fix( scaleY ), X2Fix( centerX ), X2Fix( centerY ) );
SetMovieMatrix( mMovieHandle, &transform );
}
-
+
// update movie controller
if ( mMovieController )
{
@@ -332,7 +346,6 @@ private:
return true;
}
-
static Boolean mcActionFilterCallBack( MovieController mc, short action, void *params, long ref )
{
Boolean result = false;
@@ -342,9 +355,9 @@ private:
switch( action )
{
// handle window resizing
- case mcActionControllerSizeChanged:
+ case mcActionControllerSizeChanged:
// Ensure that the movie draws correctly at the new size
- self->sizeChanged();
+ self->sizeChanged();
break;
// Block any movie controller actions that open URLs.
@@ -373,6 +386,7 @@ private:
// self->updateQuickTime();
// TODO ^^^
+
if ( self->mWidth > 0 && self->mHeight > 0 )
self->setDirty( 0, 0, self->mWidth, self->mHeight );
@@ -381,11 +395,18 @@ private:
static void moviePrePrerollCompleteCallback( Movie movie, OSErr preroll_err, void *ref )
{
- //MediaPluginQuickTime* self = ( MediaPluginQuickTime* )ref;
+ MediaPluginQuickTime* self = ( MediaPluginQuickTime* )ref;
// TODO:
//LLMediaEvent event( self );
//self->mEventEmitter.update( &LLMediaObserver::onMediaPreroll, event );
+
+ // Send a "navigate complete" event.
+ LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_complete");
+ message.setValue("uri", self->mNavigateURL);
+ message.setValueS32("result_code", 200);
+ message.setValue("result_string", "OK");
+ self->sendMessage(message);
};
@@ -399,7 +420,7 @@ private:
{
if ( mCommand == COMMAND_PLAY )
{
- if ( mStatus == STATUS_LOADED || mStatus == STATUS_PAUSED || mStatus == STATUS_PLAYING )
+ if ( mStatus == STATUS_LOADED || mStatus == STATUS_PAUSED || mStatus == STATUS_PLAYING || mStatus == STATUS_DONE )
{
long state = GetMovieLoadState( mMovieHandle );
@@ -414,7 +435,7 @@ private:
MCDoAction( mMovieController, mcActionPlay, (void*)rate );
rewind();
};
-
+
MCDoAction( mMovieController, mcActionPrerollAndPlay, (void*)getPlayRate() );
MCDoAction( mMovieController, mcActionSetVolume, (void*)mCurVolume );
setStatus(STATUS_PLAYING);
@@ -425,7 +446,7 @@ private:
else
if ( mCommand == COMMAND_STOP )
{
- if ( mStatus == STATUS_PLAYING || mStatus == STATUS_PAUSED )
+ if ( mStatus == STATUS_PLAYING || mStatus == STATUS_PAUSED || mStatus == STATUS_DONE )
{
if ( GetMovieLoadState( mMovieHandle ) >= kMovieLoadStatePlaythroughOK )
{
@@ -442,7 +463,7 @@ private:
if ( mCommand == COMMAND_PAUSE )
{
if ( mStatus == STATUS_PLAYING )
- {
+ {
if ( GetMovieLoadState( mMovieHandle ) >= kMovieLoadStatePlaythroughOK )
{
Fixed rate = X2Fix( 0.0 );
@@ -475,7 +496,7 @@ private:
void getMovieNaturalSize(int *movie_width, int *movie_height)
{
Rect rect;
-
+
GetMovieNaturalBoundsRect( mMovieHandle, &rect );
int width = ( rect.right - rect.left );
@@ -498,7 +519,7 @@ private:
*movie_width = width;
*movie_height = height;
}
-
+
void updateQuickTime(int milliseconds)
{
if ( ! mMovieHandle )
@@ -524,11 +545,14 @@ private:
// update state machine
processState();
- // special code for looping - need to rewind at the end of the movie
- if ( mIsLooping )
+ // see if title arrived and if so, update member variable with contents
+ checkTitle();
+
+ // QT call to see if we are at the end - can't do with controller
+ if ( IsMovieDone( mMovieHandle ) )
{
- // QT call to see if we are at the end - can't do with controller
- if ( IsMovieDone( mMovieHandle ) )
+ // special code for looping - need to rewind at the end of the movie
+ if ( mIsLooping )
{
// go back to start
rewind();
@@ -541,8 +565,16 @@ private:
// set the volume
MCDoAction( mMovieController, mcActionSetVolume, (void*)mCurVolume );
};
- };
- };
+ }
+ else
+ {
+ if(mStatus == STATUS_PLAYING)
+ {
+ setStatus(STATUS_DONE);
+ }
+ }
+ }
+
};
int getDataWidth() const
@@ -585,6 +617,19 @@ private:
};
};
+ F64 getLoadedDuration()
+ {
+ TimeValue duration;
+ if(GetMaxLoadedTimeInMovie( mMovieHandle, &duration ) != noErr)
+ {
+ // If GetMaxLoadedTimeInMovie returns an error, return the full duration of the movie.
+ duration = GetMovieDuration( mMovieHandle );
+ }
+ TimeValue scale = GetMovieTimeScale( mMovieHandle );
+
+ return (F64)duration / (F64)scale;
+ };
+
F64 getDuration()
{
TimeValue duration = GetMovieDuration( mMovieHandle );
@@ -642,6 +687,71 @@ private:
{
};
+ ////////////////////////////////////////////////////////////////////////////////
+ // Grab movie title into mMovieTitle - should be called repeatedly
+ // until it returns true since movie title takes a while to become
+ // available.
+ const bool getMovieTitle()
+ {
+ // grab meta data from movie
+ QTMetaDataRef media_data_ref;
+ OSErr result = QTCopyMovieMetaData( mMovieHandle, &media_data_ref );
+ if ( noErr != result )
+ return false;
+
+ // look up "Display Name" in meta data
+ OSType meta_data_key = kQTMetaDataCommonKeyDisplayName;
+ QTMetaDataItem item = kQTMetaDataItemUninitialized;
+ result = QTMetaDataGetNextItem( media_data_ref, kQTMetaDataStorageFormatWildcard,
+ 0, kQTMetaDataKeyFormatCommon,
+ (const UInt8 *)&meta_data_key,
+ sizeof( meta_data_key ), &item );
+ if ( noErr != result )
+ return false;
+
+ // find the size of the title
+ ByteCount size;
+ result = QTMetaDataGetItemValue( media_data_ref, item, NULL, 0, &size );
+ if ( noErr != result || size <= 0 )
+ return false;
+
+ // allocate some space and grab it
+ UInt8* item_data = new UInt8( size );
+ memset( item_data, 0, size * sizeof( UInt8* ) );
+ result = QTMetaDataGetItemValue( media_data_ref, item, item_data, size, NULL );
+ if ( noErr != result )
+ return false;
+
+ // save it
+ mMovieTitle = std::string( (char* )item_data );
+
+ // clean up
+ delete [] item_data;
+
+ return true;
+ };
+
+ // called regularly to see if title changed
+ void checkTitle()
+ {
+ // we did already receive title so keep checking
+ if ( ! mReceivedTitle )
+ {
+ // grab title from movie meta data
+ if ( getMovieTitle() )
+ {
+ // pass back to host application
+ LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text");
+ message.setValue("name", mMovieTitle );
+ sendMessage( message );
+
+ // stop looking once we find a title for this movie.
+ // TODO: this may to be reset if movie title changes
+ // during playback but this is okay for now
+ mReceivedTitle = true;
+ };
+ };
+ };
};
MediaPluginQuickTime::MediaPluginQuickTime(
@@ -663,6 +773,8 @@ MediaPluginQuickTime::MediaPluginQuickTime(
mCurVolume = 0x99;
mMediaSizeChanging = false;
mIsLooping = false;
+ mMovieTitle = std::string();
+ mReceivedTitle = false;
mCommand = COMMAND_NONE;
mPlayRate = 0.0f;
mStatus = STATUS_NONE;
@@ -699,22 +811,29 @@ void MediaPluginQuickTime::receiveMessage(const char *message_string)
versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
// Normally a plugin would only specify one of these two subclasses, but this is a demo...
-// versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER] = LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION;
versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION;
message.setValueLLSD("versions", versions);
#ifdef LL_WINDOWS
- if ( InitializeQTML( 0L ) != noErr )
+
+ // QuickTime 7.6.4 has an issue (that was not present in 7.6.2) with initializing QuickTime
+ // according to this article: http://lists.apple.com/archives/QuickTime-API/2009/Sep/msg00097.html
+ // The solution presented there appears to work.
+ QTLoadLibrary("qtcf.dll");
+
+ // main initialization for QuickTime - only required on Windows
+ OSErr result = InitializeQTML( 0L );
+ if ( result != noErr )
{
//TODO: If no QT on Windows, this fails - respond accordingly.
- //return false;
}
else
{
-// std::cerr << "QuickTime initialized" << std::endl;
+ //std::cerr << "QuickTime initialized" << std::endl;
};
#endif
+ // required for both Windows and Mac
EnterMovies();
std::string plugin_version = "QuickTime media plugin, QuickTime version ";
@@ -731,7 +850,7 @@ void MediaPluginQuickTime::receiveMessage(const char *message_string)
message.setMessage(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
#if defined(LL_WINDOWS)
// Values for Windows
- mDepth = 3;
+ mDepth = 3;
message.setValueU32("format", GL_RGB);
message.setValueU32("type", GL_UNSIGNED_BYTE);
@@ -740,7 +859,7 @@ void MediaPluginQuickTime::receiveMessage(const char *message_string)
message.setValueU32("padding", 32 * 3);
#else
// Values for Mac
- mDepth = 4;
+ mDepth = 4;
message.setValueU32("format", GL_BGRA_EXT);
#ifdef __BIG_ENDIAN__
message.setValueU32("type", GL_UNSIGNED_INT_8_8_8_8_REV );
@@ -761,7 +880,7 @@ void MediaPluginQuickTime::receiveMessage(const char *message_string)
{
// no response is necessary here.
F64 time = message_in.getValueReal("time");
-
+
// Convert time to milliseconds for update()
update((int)(time * 1000.0f));
}
@@ -775,8 +894,6 @@ void MediaPluginQuickTime::receiveMessage(const char *message_string)
info.mAddress = message_in.getValuePointer("address");
info.mSize = (size_t)message_in.getValueS32("size");
std::string name = message_in.getValue("name");
-
-
// std::cerr << "MediaPluginQuickTime::receiveMessage: shared memory added, name: " << name
// << ", size: " << info.mSize
// << ", address: " << info.mAddress
@@ -799,9 +916,9 @@ void MediaPluginQuickTime::receiveMessage(const char *message_string)
// This is the currently active pixel buffer. Make sure we stop drawing to it.
mPixels = NULL;
mTextureSegmentName.clear();
-
+
// Make sure the movie GWorld is no longer pointed at the shared segment.
- sizeChanged();
+ sizeChanged();
}
mSharedSegments.erase(iter);
}
@@ -858,9 +975,9 @@ void MediaPluginQuickTime::receiveMessage(const char *message_string)
mTextureHeight = texture_height;
mMediaSizeChanging = false;
-
+
sizeChanged();
-
+
update();
};
};
@@ -869,14 +986,14 @@ void MediaPluginQuickTime::receiveMessage(const char *message_string)
{
std::string uri = message_in.getValue("uri");
load( uri );
- sendStatus();
+ sendStatus();
}
else if(message_name == "mouse_event")
{
std::string event = message_in.getValue("event");
S32 x = message_in.getValueS32("x");
S32 y = message_in.getValueS32("y");
-
+
if(event == "down")
{
mouseDown(x, y);
@@ -969,7 +1086,7 @@ MediaPluginQuickTime::~MediaPluginQuickTime()
void MediaPluginQuickTime::receiveMessage(const char *message_string)
{
- // no-op
+ // no-op
}
// We're building without quicktime enabled. Just refuse to initialize.
diff --git a/indra/media_plugins/webkit/CMakeLists.txt b/indra/media_plugins/webkit/CMakeLists.txt
index d96477279d..5bccd589d8 100644
--- a/indra/media_plugins/webkit/CMakeLists.txt
+++ b/indra/media_plugins/webkit/CMakeLists.txt
@@ -52,6 +52,14 @@ add_dependencies(media_plugin_webkit
${LLCOMMON_LIBRARIES}
)
+if (WINDOWS)
+ set_target_properties(
+ media_plugin_webkit
+ PROPERTIES
+ LINK_FLAGS "/MANIFEST:NO"
+ )
+endif (WINDOWS)
+
if (DARWIN)
# Don't prepend 'lib' to the executable name, and don't embed a full path in the library's install name
set_target_properties(
diff --git a/indra/media_plugins/webkit/media_plugin_webkit.cpp b/indra/media_plugins/webkit/media_plugin_webkit.cpp
index eb2457744a..3ce8ff3deb 100644
--- a/indra/media_plugins/webkit/media_plugin_webkit.cpp
+++ b/indra/media_plugins/webkit/media_plugin_webkit.cpp
@@ -48,6 +48,18 @@
#include <stdlib.h>
#endif
+#if LL_WINDOWS
+ // *NOTE:Mani - This captures the module handle fo rthe 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 :
@@ -69,6 +81,9 @@ private:
bool mCanCut;
bool mCanCopy;
bool mCanPaste;
+ int mLastMouseX;
+ int mLastMouseY;
+ bool mFirstFocus;
////////////////////////////////////////////////////////////////////////////////
//
@@ -126,7 +141,31 @@ private:
return false;
}
std::string application_dir = std::string( cwd );
+
+#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
std::string profileDir = application_dir + "/" + "browser_profile"; // cross platform?
// window handle - needed on Windows and must be app window.
@@ -147,7 +186,7 @@ private:
#if LL_WINDOWS
// Enable plugins
- LLQtWebKit::getInstance()->enablePlugins(false);
+ LLQtWebKit::getInstance()->enablePlugins(true);
#elif LL_DARWIN
// Disable plugins
LLQtWebKit::getInstance()->enablePlugins(false);
@@ -168,14 +207,13 @@ private:
// don't flip bitmap
LLQtWebKit::getInstance()->flipWindow( mBrowserWindowId, true );
- // Set the background color to black
- LLQtWebKit::getInstance()->
// set background color to be black - mostly for initial login page
LLQtWebKit::getInstance()->setBackgroundColor( mBrowserWindowId, 0x00, 0x00, 0x00 );
- // go to the "home page"
// Don't do this here -- it causes the dreaded "white flash" when loading a browser instance.
-// LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, "about:blank" );
+ // 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.
+ LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, "about:blank" );
// set flag so we don't do this again
mBrowserInitialized = true;
@@ -272,7 +310,16 @@ private:
message.setValue("status", event.getStringValue());
sendMessage(message);
}
-
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // virtual
+ void onTitleChange(const EventType& event)
+ {
+ LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text");
+ message.setValue("name", event.getStringValue());
+ sendMessage(message);
+ }
+
////////////////////////////////////////////////////////////////////////////////
// virtual
void onLocationChange(const EventType& event)
@@ -300,33 +347,30 @@ private:
message.setValue("uri", event.getStringValue());
sendMessage(message);
}
-
- ////////////////////////////////////////////////////////////////////////////////
- //
- void mouseDown( int x, int y )
- {
- LLQtWebKit::getInstance()->mouseDown( mBrowserWindowId, x, y );
- };
-
- ////////////////////////////////////////////////////////////////////////////////
- //
- void mouseUp( int x, int y )
+
+ LLQtWebKit::EKeyboardModifier decodeModifiers(std::string &modifiers)
{
- LLQtWebKit::getInstance()->mouseUp( mBrowserWindowId, x, y );
- LLQtWebKit::getInstance()->focusBrowser( mBrowserWindowId, true );
- checkEditState();
- };
+ int result = 0;
+
+ if(modifiers.find("shift") != std::string::npos)
+ result |= LLQtWebKit::KM_MODIFIER_SHIFT;
- ////////////////////////////////////////////////////////////////////////////////
- //
- void mouseMove( int x, int y )
- {
- LLQtWebKit::getInstance()->mouseMove( mBrowserWindowId, x, y );
- };
+ 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 keyPress( int key )
+ void keyEvent(LLQtWebKit::EKeyEvent key_event, int key, LLQtWebKit::EKeyboardModifier modifiers)
{
int llqt_key;
@@ -380,7 +424,7 @@ private:
if(llqt_key != 0)
{
- LLQtWebKit::getInstance()->keyPress( mBrowserWindowId, llqt_key );
+ LLQtWebKit::getInstance()->keyEvent( mBrowserWindowId, key_event, llqt_key, modifiers);
}
checkEditState();
@@ -388,7 +432,7 @@ private:
////////////////////////////////////////////////////////////////////////////////
//
- void unicodeInput( const std::string &utf8str )
+ void unicodeInput( const std::string &utf8str, LLQtWebKit::EKeyboardModifier modifiers)
{
LLWString wstr = utf8str_to_wstring(utf8str);
@@ -397,7 +441,7 @@ private:
{
// std::cerr << "unicode input, code = 0x" << std::hex << (unsigned long)(wstr[i]) << std::dec << std::endl;
- LLQtWebKit::getInstance()->unicodeInput(mBrowserWindowId, wstr[i]);
+ LLQtWebKit::getInstance()->unicodeInput(mBrowserWindowId, wstr[i], modifiers);
}
checkEditState();
@@ -449,6 +493,9 @@ MediaPluginWebKit::MediaPluginWebKit(LLPluginInstance::sendMessageFunction host_
mCanCut = false;
mCanCopy = false;
mCanPaste = false;
+ mLastMouseX = 0;
+ mLastMouseY = 0;
+ mFirstFocus = true;
}
MediaPluginWebKit::~MediaPluginWebKit()
@@ -633,66 +680,84 @@ void MediaPluginWebKit::receiveMessage(const char *message_string)
else if(message_name == "mouse_event")
{
std::string event = message_in.getValue("event");
- S32 x = message_in.getValueS32("x");
- S32 y = message_in.getValueS32("y");
- // std::string modifiers = message.getValue("modifiers");
-
+ 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")
{
- mouseDown(x, y);
- //std::cout << "Mouse down at " << x << " x " << y << std::endl;
+ mouse_event = LLQtWebKit::ME_MOUSE_DOWN;
}
else if(event == "up")
{
- mouseUp(x, y);
- //std::cout << "Mouse up at " << x << " x " << y << std::endl;
+ mouse_event = LLQtWebKit::ME_MOUSE_UP;
}
- else if(event == "move")
+ else if(event == "double_click")
{
- mouseMove(x, y);
- //std::cout << ">>>>>>>>>>>>>>>>>>>> Mouse move at " << x << " x " << y << std::endl;
+ 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 x = message_in.getValueS32("x");
S32 y = message_in.getValueS32("y");
- // std::string modifiers = message.getValue("modifiers");
+ 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.
- // We currently ignore horizontal scrolling.
- // The scroll values are roughly 1 per wheel click, so we need to magnify them by some factor.
- // Arbitrarily, I choose 16.
- y *= 16;
- LLQtWebKit::getInstance()->scrollByLines(mBrowserWindowId, y);
+ 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");
-
- // act on "key down" or "key repeat"
- if ( (event == "down") || (event == "repeat") )
+ S32 key = message_in.getValueS32("key");
+ std::string modifiers = message_in.getValue("modifiers");
+
+ // Treat unknown events as key-up for safety.
+ LLQtWebKit::EKeyEvent key_event = LLQtWebKit::KE_KEY_UP;
+ if(event == "down")
{
- S32 key = message_in.getValueS32("key");
- keyPress( key );
- };
+ key_event = LLQtWebKit::KE_KEY_DOWN;
+ }
+ else if(event == "repeat")
+ {
+ key_event = LLQtWebKit::KE_KEY_REPEAT;
+ }
+
+ keyEvent(key_event, key, decodeModifiers(modifiers));
}
else if(message_name == "text_event")
{
std::string text = message_in.getValue("text");
+ std::string modifiers = message_in.getValue("modifiers");
- unicodeInput(text);
+ unicodeInput(text, decodeModifiers(modifiers));
}
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();
}
else
{
@@ -705,6 +770,15 @@ void MediaPluginWebKit::receiveMessage(const char *message_string)
{
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 == "clear_cache")
{
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-03 00:52:49 +0000