diff options
Diffstat (limited to 'osframework/source/SexyAppFramework/FlashWidget.cpp')
| -rw-r--r-- | osframework/source/SexyAppFramework/FlashWidget.cpp | 1384 |
1 files changed, 1384 insertions, 0 deletions
diff --git a/osframework/source/SexyAppFramework/FlashWidget.cpp b/osframework/source/SexyAppFramework/FlashWidget.cpp new file mode 100644 index 0000000..caf5d6f --- /dev/null +++ b/osframework/source/SexyAppFramework/FlashWidget.cpp @@ -0,0 +1,1384 @@ +#include "FlashWidget.h"
+#include "DDImage.h"
+#include "SexyAppBase.h"
+#include "WidgetManager.h"
+#include "Debug.h"
+
+using namespace Sexy;
+
+#pragma comment(lib, "comsuppw.lib")
+
+//////////////////////////////////////////////////////////////////////////
+// Interfaces imported from flash.ocx
+
+#include <comdef.h>
+
+#pragma pack(push, 8)
+
+namespace ShockwaveFlashObjects
+{
+
+//
+// Forward references and typedefs
+//
+
+struct __declspec(uuid("d27cdb6b-ae6d-11cf-96b8-444553540000"))
+/* LIBID */ __ShockwaveFlashObjects;
+struct __declspec(uuid("d27cdb6c-ae6d-11cf-96b8-444553540000"))
+/* dual interface */ IShockwaveFlash;
+struct __declspec(uuid("d27cdb6d-ae6d-11cf-96b8-444553540000"))
+/* dispinterface */ _IShockwaveFlashEvents;
+struct /* coclass */ ShockwaveFlash;
+struct /* coclass */ FlashProp;
+struct __declspec(uuid("d27cdb70-ae6d-11cf-96b8-444553540000"))
+/* interface */ IFlashFactory;
+struct __declspec(uuid("d27cdb72-ae6d-11cf-96b8-444553540000"))
+/* interface */ IFlashObjectInterface;
+struct __declspec(uuid("a6ef9860-c720-11d0-9337-00a0c90dcaa9"))
+/* interface */ IDispatchEx;
+struct /* coclass */ FlashObjectInterface;
+
+//
+// Smart pointer typedef declarations
+//
+
+_COM_SMARTPTR_TYPEDEF(IShockwaveFlash, __uuidof(IShockwaveFlash));
+_COM_SMARTPTR_TYPEDEF(_IShockwaveFlashEvents, __uuidof(_IShockwaveFlashEvents));
+_COM_SMARTPTR_TYPEDEF(IFlashFactory, __uuidof(IFlashFactory));
+_COM_SMARTPTR_TYPEDEF(IDispatchEx, __uuidof(IDispatchEx));
+_COM_SMARTPTR_TYPEDEF(IFlashObjectInterface, __uuidof(IFlashObjectInterface));
+
+//
+// Type library items
+//
+
+struct __declspec(uuid("d27cdb6c-ae6d-11cf-96b8-444553540000"))
+IShockwaveFlash : IDispatch
+{
+ //
+ // Property data
+ //
+
+ __declspec(property(get=GetStacking,put=PutStacking))
+ _bstr_t Stacking;
+ __declspec(property(get=GetWMode,put=PutWMode))
+ _bstr_t WMode;
+ __declspec(property(get=GetMovie,put=PutMovie))
+ _bstr_t Movie;
+ __declspec(property(get=GetSAlign,put=PutSAlign))
+ _bstr_t SAlign;
+ __declspec(property(get=GetMenu,put=PutMenu))
+ VARIANT_BOOL Menu;
+ __declspec(property(get=GetQuality,put=PutQuality))
+ int Quality;
+ __declspec(property(get=GetLoop,put=PutLoop))
+ VARIANT_BOOL Loop;
+ __declspec(property(get=GetFrameNum,put=PutFrameNum))
+ long FrameNum;
+ __declspec(property(get=GetBase,put=PutBase))
+ _bstr_t Base;
+ __declspec(property(get=Getscale,put=Putscale))
+ _bstr_t scale;
+ __declspec(property(get=GetDeviceFont,put=PutDeviceFont))
+ VARIANT_BOOL DeviceFont;
+ __declspec(property(get=GetEmbedMovie,put=PutEmbedMovie))
+ VARIANT_BOOL EmbedMovie;
+ __declspec(property(get=GetBGColor,put=PutBGColor))
+ _bstr_t BGColor;
+ __declspec(property(get=GetQuality2,put=PutQuality2))
+ _bstr_t Quality2;
+ __declspec(property(get=GetReadyState))
+ long ReadyState;
+ __declspec(property(get=GetScaleMode,put=PutScaleMode))
+ int ScaleMode;
+ __declspec(property(get=GetAlignMode,put=PutAlignMode))
+ int AlignMode;
+ __declspec(property(get=GetBackgroundColor,put=PutBackgroundColor))
+ long BackgroundColor;
+ __declspec(property(get=GetTotalFrames))
+ long TotalFrames;
+ __declspec(property(get=GetPlaying,put=PutPlaying))
+ VARIANT_BOOL Playing;
+ __declspec(property(get=GetSWRemote,put=PutSWRemote))
+ _bstr_t SWRemote;
+
+ //
+ // Raw methods provided by interface
+ //
+
+ virtual HRESULT __stdcall get_ReadyState (
+ /*[out,retval]*/ long * thestate ) = 0;
+ virtual HRESULT __stdcall get_TotalFrames (
+ /*[out,retval]*/ long * numframes ) = 0;
+ virtual HRESULT __stdcall get_Playing (
+ /*[out,retval]*/ VARIANT_BOOL * Playing ) = 0;
+ virtual HRESULT __stdcall put_Playing (
+ /*[in]*/ VARIANT_BOOL Playing ) = 0;
+ virtual HRESULT __stdcall get_Quality (
+ /*[out,retval]*/ int * Quality ) = 0;
+ virtual HRESULT __stdcall put_Quality (
+ /*[in]*/ int Quality ) = 0;
+ virtual HRESULT __stdcall get_ScaleMode (
+ /*[out,retval]*/ int * scale ) = 0;
+ virtual HRESULT __stdcall put_ScaleMode (
+ /*[in]*/ int scale ) = 0;
+ virtual HRESULT __stdcall get_AlignMode (
+ /*[out,retval]*/ int * align ) = 0;
+ virtual HRESULT __stdcall put_AlignMode (
+ /*[in]*/ int align ) = 0;
+ virtual HRESULT __stdcall get_BackgroundColor (
+ /*[out,retval]*/ long * color ) = 0;
+ virtual HRESULT __stdcall put_BackgroundColor (
+ /*[in]*/ long color ) = 0;
+ virtual HRESULT __stdcall get_Loop (
+ /*[out,retval]*/ VARIANT_BOOL * Loop ) = 0;
+ virtual HRESULT __stdcall put_Loop (
+ /*[in]*/ VARIANT_BOOL Loop ) = 0;
+ virtual HRESULT __stdcall get_Movie (
+ /*[out,retval]*/ BSTR * path ) = 0;
+ virtual HRESULT __stdcall put_Movie (
+ /*[in]*/ BSTR path ) = 0;
+ virtual HRESULT __stdcall get_FrameNum (
+ /*[out,retval]*/ long * FrameNum ) = 0;
+ virtual HRESULT __stdcall put_FrameNum (
+ /*[in]*/ long FrameNum ) = 0;
+ virtual HRESULT __stdcall SetZoomRect (
+ /*[in]*/ long left,
+ /*[in]*/ long top,
+ /*[in]*/ long right,
+ /*[in]*/ long bottom ) = 0;
+ virtual HRESULT __stdcall Zoom (
+ /*[in]*/ int factor ) = 0;
+ virtual HRESULT __stdcall Pan (
+ /*[in]*/ long x,
+ /*[in]*/ long y,
+ /*[in]*/ int mode ) = 0;
+ virtual HRESULT __stdcall Play ( ) = 0;
+ virtual HRESULT __stdcall Stop ( ) = 0;
+ virtual HRESULT __stdcall Back ( ) = 0;
+ virtual HRESULT __stdcall Forward ( ) = 0;
+ virtual HRESULT __stdcall Rewind ( ) = 0;
+ virtual HRESULT __stdcall StopPlay ( ) = 0;
+ virtual HRESULT __stdcall GotoFrame (
+ /*[in]*/ long FrameNum ) = 0;
+ virtual HRESULT __stdcall CurrentFrame (
+ /*[out,retval]*/ long * FrameNum ) = 0;
+ virtual HRESULT __stdcall IsPlaying (
+ /*[out,retval]*/ VARIANT_BOOL * Playing ) = 0;
+ virtual HRESULT __stdcall PercentLoaded (
+ /*[out,retval]*/ long * __MIDL_0011 ) = 0;
+ virtual HRESULT __stdcall FrameLoaded (
+ /*[in]*/ long FrameNum,
+ /*[out,retval]*/ VARIANT_BOOL * loaded ) = 0;
+ virtual HRESULT __stdcall FlashVersion (
+ /*[out,retval]*/ long * version ) = 0;
+ virtual HRESULT __stdcall get_WMode (
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall put_WMode (
+ /*[in]*/ BSTR pVal ) = 0;
+ virtual HRESULT __stdcall get_SAlign (
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall put_SAlign (
+ /*[in]*/ BSTR pVal ) = 0;
+ virtual HRESULT __stdcall get_Menu (
+ /*[out,retval]*/ VARIANT_BOOL * pVal ) = 0;
+ virtual HRESULT __stdcall put_Menu (
+ /*[in]*/ VARIANT_BOOL pVal ) = 0;
+ virtual HRESULT __stdcall get_Base (
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall put_Base (
+ /*[in]*/ BSTR pVal ) = 0;
+ virtual HRESULT __stdcall get_scale (
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall put_scale (
+ /*[in]*/ BSTR pVal ) = 0;
+ virtual HRESULT __stdcall get_DeviceFont (
+ /*[out,retval]*/ VARIANT_BOOL * pVal ) = 0;
+ virtual HRESULT __stdcall put_DeviceFont (
+ /*[in]*/ VARIANT_BOOL pVal ) = 0;
+ virtual HRESULT __stdcall get_EmbedMovie (
+ /*[out,retval]*/ VARIANT_BOOL * pVal ) = 0;
+ virtual HRESULT __stdcall put_EmbedMovie (
+ /*[in]*/ VARIANT_BOOL pVal ) = 0;
+ virtual HRESULT __stdcall get_BGColor (
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall put_BGColor (
+ /*[in]*/ BSTR pVal ) = 0;
+ virtual HRESULT __stdcall get_Quality2 (
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall put_Quality2 (
+ /*[in]*/ BSTR pVal ) = 0;
+ virtual HRESULT __stdcall LoadMovie (
+ /*[in]*/ int layer,
+ /*[in]*/ BSTR url ) = 0;
+ virtual HRESULT __stdcall TGotoFrame (
+ /*[in]*/ BSTR target,
+ /*[in]*/ long FrameNum ) = 0;
+ virtual HRESULT __stdcall TGotoLabel (
+ /*[in]*/ BSTR target,
+ /*[in]*/ BSTR label ) = 0;
+ virtual HRESULT __stdcall TCurrentFrame (
+ /*[in]*/ BSTR target,
+ /*[out,retval]*/ long * FrameNum ) = 0;
+ virtual HRESULT __stdcall TCurrentLabel (
+ /*[in]*/ BSTR target,
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall TPlay (
+ /*[in]*/ BSTR target ) = 0;
+ virtual HRESULT __stdcall TStopPlay (
+ /*[in]*/ BSTR target ) = 0;
+ virtual HRESULT __stdcall SetVariable (
+ /*[in]*/ BSTR name,
+ /*[in]*/ BSTR value ) = 0;
+ virtual HRESULT __stdcall GetVariable (
+ /*[in]*/ BSTR name,
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall TSetProperty (
+ /*[in]*/ BSTR target,
+ /*[in]*/ int property,
+ /*[in]*/ BSTR value ) = 0;
+ virtual HRESULT __stdcall TGetProperty (
+ /*[in]*/ BSTR target,
+ /*[in]*/ int property,
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall TCallFrame (
+ /*[in]*/ BSTR target,
+ /*[in]*/ int FrameNum ) = 0;
+ virtual HRESULT __stdcall TCallLabel (
+ /*[in]*/ BSTR target,
+ /*[in]*/ BSTR label ) = 0;
+ virtual HRESULT __stdcall TSetPropertyNum (
+ /*[in]*/ BSTR target,
+ /*[in]*/ int property,
+ /*[in]*/ double value ) = 0;
+ virtual HRESULT __stdcall TGetPropertyNum (
+ /*[in]*/ BSTR target,
+ /*[in]*/ int property,
+ /*[out,retval]*/ double * pVal ) = 0;
+ virtual HRESULT __stdcall get_SWRemote (
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall put_SWRemote (
+ /*[in]*/ BSTR pVal ) = 0;
+ virtual HRESULT __stdcall get_Stacking (
+ /*[out,retval]*/ BSTR * pVal ) = 0;
+ virtual HRESULT __stdcall put_Stacking (
+ /*[in]*/ BSTR pVal ) = 0;
+};
+
+struct __declspec(uuid("d27cdb6d-ae6d-11cf-96b8-444553540000"))
+_IShockwaveFlashEvents : IDispatch
+{
+ //
+ // Wrapper methods for error-handling
+ //
+
+ // Methods:
+ HRESULT OnReadyStateChange (
+ long newState );
+ HRESULT OnProgress (
+ long percentDone );
+ HRESULT FSCommand (
+ _bstr_t command,
+ _bstr_t args );
+};
+
+struct __declspec(uuid("d27cdb6e-ae6d-11cf-96b8-444553540000"))
+ShockwaveFlash;
+ // [ default ] interface IShockwaveFlash
+ // [ default, source ] dispinterface _IShockwaveFlashEvents
+
+struct __declspec(uuid("1171a62f-05d2-11d1-83fc-00a0c9089c5a"))
+FlashProp;
+ // [ default ] interface IUnknown
+
+struct __declspec(uuid("d27cdb70-ae6d-11cf-96b8-444553540000"))
+IFlashFactory : IUnknown
+{};
+
+struct __declspec(uuid("a6ef9860-c720-11d0-9337-00a0c90dcaa9"))
+IDispatchEx : IDispatch
+{
+ //
+ // Wrapper methods for error-handling
+ //
+
+ HRESULT GetDispID (
+ _bstr_t bstrName,
+ unsigned long grfdex,
+ long * pid );
+ HRESULT RemoteInvokeEx (
+ long id,
+ unsigned long lcid,
+ unsigned long dwFlags,
+ struct DISPPARAMS * pdp,
+ VARIANT * pvarRes,
+ struct EXCEPINFO * pei,
+ struct IServiceProvider * pspCaller,
+ unsigned int cvarRefArg,
+ unsigned int * rgiRefArg,
+ VARIANT * rgvarRefArg );
+ HRESULT DeleteMemberByName (
+ _bstr_t bstrName,
+ unsigned long grfdex );
+ HRESULT DeleteMemberByDispID (
+ long id );
+ HRESULT GetMemberProperties (
+ long id,
+ unsigned long grfdexFetch,
+ unsigned long * pgrfdex );
+ HRESULT GetMemberName (
+ long id,
+ BSTR * pbstrName );
+ HRESULT GetNextDispID (
+ unsigned long grfdex,
+ long id,
+ long * pid );
+ HRESULT GetNameSpaceParent (
+ IUnknown * * ppunk );
+
+ //
+ // Raw methods provided by interface
+ //
+
+ virtual HRESULT __stdcall raw_GetDispID (
+ /*[in]*/ BSTR bstrName,
+ /*[in]*/ unsigned long grfdex,
+ /*[out]*/ long * pid ) = 0;
+ virtual HRESULT __stdcall raw_RemoteInvokeEx (
+ /*[in]*/ long id,
+ /*[in]*/ unsigned long lcid,
+ /*[in]*/ unsigned long dwFlags,
+ /*[in]*/ struct DISPPARAMS * pdp,
+ /*[out]*/ VARIANT * pvarRes,
+ /*[out]*/ struct EXCEPINFO * pei,
+ /*[in]*/ struct IServiceProvider * pspCaller,
+ /*[in]*/ unsigned int cvarRefArg,
+ /*[in]*/ unsigned int * rgiRefArg,
+ /*[in,out]*/ VARIANT * rgvarRefArg ) = 0;
+ virtual HRESULT __stdcall raw_DeleteMemberByName (
+ /*[in]*/ BSTR bstrName,
+ /*[in]*/ unsigned long grfdex ) = 0;
+ virtual HRESULT __stdcall raw_DeleteMemberByDispID (
+ /*[in]*/ long id ) = 0;
+ virtual HRESULT __stdcall raw_GetMemberProperties (
+ /*[in]*/ long id,
+ /*[in]*/ unsigned long grfdexFetch,
+ /*[out]*/ unsigned long * pgrfdex ) = 0;
+ virtual HRESULT __stdcall raw_GetMemberName (
+ /*[in]*/ long id,
+ /*[out]*/ BSTR * pbstrName ) = 0;
+ virtual HRESULT __stdcall raw_GetNextDispID (
+ /*[in]*/ unsigned long grfdex,
+ /*[in]*/ long id,
+ /*[out]*/ long * pid ) = 0;
+ virtual HRESULT __stdcall raw_GetNameSpaceParent (
+ /*[out]*/ IUnknown * * ppunk ) = 0;
+};
+
+struct __declspec(uuid("d27cdb72-ae6d-11cf-96b8-444553540000"))
+IFlashObjectInterface : IDispatchEx
+{};
+
+struct __declspec(uuid("d27cdb71-ae6d-11cf-96b8-444553540000"))
+FlashObjectInterface;
+ // [ default ] interface IFlashObjectInterface
+
+} // namespace ShockwaveFlashObjects
+
+#pragma pack(pop)
+
+//////////////////////////////////////////////////////////////////////////
+// FlashSink - Receives flash events
+
+namespace Sexy
+{
+
+class FlashSink : public ShockwaveFlashObjects::_IShockwaveFlashEvents
+{
+public:
+ LPCONNECTIONPOINT mConnectionPoint;
+ DWORD mCookie;
+ int mRefCount;
+ FlashWidget* mFlashWidget;
+
+public:
+ FlashSink()
+ {
+ mCookie = 0;
+ mConnectionPoint = NULL;
+ mRefCount = 0;
+ mFlashWidget = NULL;
+ }
+
+ virtual ~FlashSink()
+ {
+ mFlashWidget->mCOMCount--;
+ }
+
+ HRESULT Init(FlashWidget* theFlashWidget)
+ {
+ mFlashWidget = theFlashWidget;
+ mFlashWidget->mCOMCount++;
+
+ HRESULT aResult = NOERROR;
+ LPCONNECTIONPOINTCONTAINER aConnectionPoint = NULL;
+
+ if ((mFlashWidget->mFlashInterface->QueryInterface(IID_IConnectionPointContainer, (void**) &aConnectionPoint) == S_OK) &&
+ (aConnectionPoint->FindConnectionPoint(__uuidof(ShockwaveFlashObjects::_IShockwaveFlashEvents), &mConnectionPoint) == S_OK))
+ {
+ IDispatch* aDispatch = NULL;
+ QueryInterface(__uuidof(IDispatch), (void**) &aDispatch);
+ if (aDispatch != NULL)
+ {
+ aResult = mConnectionPoint->Advise((LPUNKNOWN)aDispatch, &mCookie);
+ aDispatch->Release();
+ }
+ }
+
+ if (aConnectionPoint != NULL)
+ aConnectionPoint->Release();
+
+ return aResult;
+ }
+
+ HRESULT Shutdown()
+ {
+ HRESULT aResult = S_OK;
+
+ if (mConnectionPoint)
+ {
+ if (mCookie)
+ {
+ aResult = mConnectionPoint->Unadvise(mCookie);
+ mCookie = 0;
+ }
+
+ mConnectionPoint->Release();
+ mConnectionPoint = NULL;
+ }
+
+ return aResult;
+ }
+
+ HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, LPVOID* ppv)
+ {
+ *ppv = NULL;
+
+ if (riid == IID_IUnknown)
+ {
+ *ppv = (LPUNKNOWN)this;
+ AddRef();
+ return S_OK;
+ }
+ else if (riid == IID_IDispatch)
+ {
+ *ppv = (IDispatch*)this;
+ AddRef();
+ return S_OK;
+ }
+ else if (riid == __uuidof(ShockwaveFlashObjects::_IShockwaveFlashEvents))
+ {
+ *ppv = (ShockwaveFlashObjects::_IShockwaveFlashEvents*) this;
+ AddRef();
+ return S_OK;
+ }
+ else
+ {
+ return E_NOTIMPL;
+ }
+ }
+
+ ULONG STDMETHODCALLTYPE AddRef()
+ {
+ return ++mRefCount;
+ }
+
+ ULONG STDMETHODCALLTYPE Release()
+ {
+ int aRefCount = --mRefCount;
+ if (aRefCount == 0)
+ delete this;
+
+ return aRefCount;
+ }
+
+ // IDispatch method
+ virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT* pctinfo)
+ { return E_NOTIMPL; }
+
+ virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
+ UINT cNames, LCID lcid,DISPID* rgDispId)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
+ WORD wFlags, ::DISPPARAMS __RPC_FAR *pDispParams, VARIANT __RPC_FAR *pVarResult,
+ ::EXCEPINFO __RPC_FAR *pExcepInfo, UINT __RPC_FAR *puArgErr)
+ {
+ switch(dispIdMember)
+ {
+ case 0x7a6:
+ break;
+ case 0x96:
+ if ((pDispParams->cArgs == 2) &&
+ (pDispParams->rgvarg[0].vt == VT_BSTR) &&
+ (pDispParams->rgvarg[1].vt == VT_BSTR))
+ {
+ FSCommand(pDispParams->rgvarg[1].bstrVal, pDispParams->rgvarg[0].bstrVal);
+ }
+ break;
+ case DISPID_READYSTATECHANGE:
+ break;
+ default:
+ return DISP_E_MEMBERNOTFOUND;
+ }
+
+ return NOERROR;
+ }
+
+ HRESULT OnReadyStateChange (long newState)
+ {
+ return S_OK;
+ }
+
+ HRESULT OnProgress(long percentDone )
+ {
+ return S_OK;
+ }
+
+ HRESULT FSCommand (_bstr_t command, _bstr_t args)
+ {
+ if (mFlashWidget->mFlashListener != NULL)
+ mFlashWidget->mFlashListener->FlashCommand(mFlashWidget->mId, (char*) command, (char*) args);
+ return S_OK;
+ }
+};
+
+}
+
+using namespace ShockwaveFlashObjects;
+
+//////////////////////////////////////////////////////////////////////////
+// ControlSite - container that holds the flash control
+
+namespace Sexy
+{
+
+class ControlSite :
+ public IOleInPlaceSiteWindowless,
+ public IOleClientSite
+{
+public:
+ int mRefCount;
+ FlashWidget* mFlashWidget;
+
+public:
+ ControlSite()
+ {
+ mRefCount = 0;
+ mFlashWidget = NULL;
+ }
+
+ virtual ~ControlSite()
+ {
+ if (mFlashWidget != NULL)
+ mFlashWidget->mCOMCount--;
+ }
+
+ void Init(FlashWidget* theFlashWidget)
+ {
+ mFlashWidget = theFlashWidget;
+ mFlashWidget->mCOMCount++;
+ }
+
+ HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, LPVOID* ppv)
+ {
+ *ppv = NULL;
+
+ if (riid == IID_IUnknown)
+ {
+ *ppv = (IUnknown*) (IOleWindow*) this;
+ AddRef();
+ return S_OK;
+ }
+ else if (riid == IID_IOleWindow)
+ {
+ *ppv = (IOleWindow*)this;
+ AddRef();
+ return S_OK;
+ }
+ else if (riid == IID_IOleInPlaceSite)
+ {
+ *ppv = (IOleInPlaceSite*)this;
+ AddRef();
+ return S_OK;
+ }
+ else if (riid == IID_IOleInPlaceSiteEx)
+ {
+ *ppv = (IOleInPlaceSiteEx*)this;
+ AddRef();
+ return S_OK;
+ }
+ else if (riid == IID_IOleInPlaceSiteWindowless)
+ {
+ *ppv = (IOleInPlaceSiteWindowless*)this;
+ AddRef();
+ return S_OK;
+ }
+ else if (riid == IID_IOleClientSite)
+ {
+ *ppv = (IOleClientSite*)this;
+ AddRef();
+ return S_OK;
+ }
+ else if (riid == __uuidof(ShockwaveFlashObjects::_IShockwaveFlashEvents))
+ {
+ *ppv = (ShockwaveFlashObjects::_IShockwaveFlashEvents*) this;
+ AddRef();
+ return S_OK;
+ }
+ else
+ {
+ return E_NOTIMPL;
+ }
+ }
+
+ ULONG STDMETHODCALLTYPE AddRef()
+ {
+ return ++mRefCount;
+ }
+
+ ULONG STDMETHODCALLTYPE Release()
+ {
+ int aRefCount = --mRefCount;
+ if (aRefCount == 0)
+ delete this;
+
+ return aRefCount;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+
+ virtual HRESULT STDMETHODCALLTYPE SaveObject(void)
+ {
+ return S_OK;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker,IMoniker** ppmk )
+ {
+ *ppmk = NULL;
+ return E_NOTIMPL;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetContainer(IOleContainer ** theContainerP)
+ {
+ //return QueryInterface(__uuidof(IOleContainer), (void**) theContainerP);
+ return E_NOINTERFACE;
+ }
+
+
+ virtual HRESULT STDMETHODCALLTYPE ShowObject(void)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE OnShowWindow(BOOL)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE RequestNewObjectLayout(void)
+ {
+ return E_NOTIMPL;
+ }
+ //
+
+
+ HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(/* [in] */ BOOL fEnterMode)
+ {
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE GetWindow(/* [out] */ HWND __RPC_FAR* theWnndow)
+ {
+ return E_FAIL;
+
+ //*theWnndow = NULL;
+ //*theWnndow = gSexyAppBase->mHWnd;
+ //return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE CanInPlaceActivate(void)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE OnInPlaceActivate(void)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE OnUIActivate(void)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE GetWindowContext(/* [out] */ IOleInPlaceFrame __RPC_FAR *__RPC_FAR *ppFrame, /* [out] */ IOleInPlaceUIWindow __RPC_FAR *__RPC_FAR *ppDoc, /* [out] */ LPRECT lprcPosRect, /* [out] */ LPRECT lprcClipRect, /* [out][in] */ LPOLEINPLACEFRAMEINFO lpFrameInfo)
+ {
+ RECT aRect = mFlashWidget->GetRect().ToRECT();
+
+ *lprcPosRect = aRect;
+ *lprcClipRect = aRect;
+
+ *ppFrame = NULL;
+ QueryInterface(__uuidof(IOleInPlaceFrame), (void**) ppFrame);
+ *ppDoc = NULL;
+
+ lpFrameInfo->fMDIApp = FALSE;
+ lpFrameInfo->hwndFrame = NULL;
+ lpFrameInfo->haccel = NULL;
+ lpFrameInfo->cAccelEntries = 0;
+
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE Scroll(/* [in] */ SIZE scrollExtant)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE OnUIDeactivate(/* [in] */ BOOL fUndoable)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE OnInPlaceDeactivate(void)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE DiscardUndoState(void)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE DeactivateAndUndo(void)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE OnPosRectChange(/* [in] */ LPCRECT lprcPosRect)
+ {
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE OnInPlaceActivateEx(/* [out] */ BOOL __RPC_FAR *pfNoRedraw, /* [in] */ DWORD dwFlags)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE OnInPlaceDeactivateEx(/* [in] */ BOOL fNoRedraw)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE RequestUIActivate(void)
+ {
+ return S_FALSE;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE CanWindowlessActivate(void)
+ {
+ // Allow windowless activation?
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE GetCapture(void)
+ {
+ // TODO capture the mouse for the object
+ return S_FALSE;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE SetCapture(/* [in] */ BOOL fCapture)
+ {
+ // TODO capture the mouse for the object
+ return S_FALSE;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE GetFocus(void)
+ {
+ return S_OK;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE SetFocus(/* [in] */ BOOL fFocus)
+ {
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE GetDC(/* [in] */ LPCRECT pRect, /* [in] */ DWORD grfFlags, /* [out] */ HDC __RPC_FAR *phDC)
+ {
+ return E_INVALIDARG;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE ReleaseDC(/* [in] */ HDC hDC)
+ {
+ return E_INVALIDARG;
+ }
+
+
+ HRESULT STDMETHODCALLTYPE InvalidateRect(/* [in] */ LPCRECT pRect, /* [in] */ BOOL fErase)
+ {
+ if (pRect == NULL)
+ {
+ mFlashWidget->mDirtyRect = mFlashWidget->GetRect();
+ mFlashWidget->mFlashDirty = true;
+ }
+ else if (!mFlashWidget->mFlashDirty)
+ {
+ mFlashWidget->mDirtyRect = Rect(pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top);
+ mFlashWidget->mFlashDirty = true;
+ }
+ else
+ {
+ mFlashWidget->mDirtyRect = mFlashWidget->mDirtyRect.Union(Rect(pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top));
+ }
+
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE InvalidateRgn(/* [in] */ HRGN hRGN, /* [in] */ BOOL fErase)
+ {
+ mFlashWidget->mDirtyRect = mFlashWidget->GetRect();
+ mFlashWidget->mFlashDirty = true;
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE ScrollRect(/* [in] */ INT dx, /* [in] */ INT dy, /* [in] */ LPCRECT pRectScroll, /* [in] */ LPCRECT pRectClip)
+ {
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE AdjustRect(/* [out][in] */ LPRECT prc)
+ {
+ if (prc == NULL)
+ {
+ return E_INVALIDARG;
+ }
+
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE OnDefWindowMessage(/* [in] */ UINT msg, /* [in] */ WPARAM wParam, /* [in] */ LPARAM lParam, /* [out] */ LRESULT __RPC_FAR *plResult)
+ {
+ return S_FALSE;
+ }
+};
+
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+const CLSID CLSID_ShockwaveFlash =
+ { 0xD27CDB6E, 0xAE6D, 0x11cf, {0x96, 0xB8, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00} };
+
+typedef HRESULT (__stdcall *DllGetClassObjectFunc)(REFCLSID rclsid, REFIID riid, LPVOID * ppv);
+
+FlashWidget::FlashWidget(int theId, FlashListener* theFlashListener)
+{
+ HRESULT aResult;
+
+ mState = STATE_IDLE;
+
+ mCurCursor = CURSOR_POINTER;
+ mCurOverrideCursor = NULL;
+
+ mCOMCount = 0;
+ mPauseCount = 0;
+ mAutoPause = true;
+ mHasLostFocus = !gSexyAppBase->mHasFocus;
+ mFlashDirty = true;
+
+ mBkgColor.mAlpha = 0;
+ mId = theId;
+ mFlashListener = theFlashListener;
+
+ mFlashSink = NULL;
+
+ mImage = NULL;
+ mFlashInterface = NULL;
+ mOleObject = NULL;
+ mWindowlessObject = NULL;
+
+ mBkgImage = NULL;
+ mFlashLibHandle = NULL;
+
+ CoInitialize(NULL);
+
+ mControlSite = new ControlSite();
+ mControlSite->AddRef();
+ mControlSite->Init(this);
+
+ mFlashLibHandle = LoadLibraryA("flash.ocx");
+ if (mFlashLibHandle != NULL)
+ {
+ IClassFactory* aClassFactory = NULL;
+ DllGetClassObjectFunc aDllGetClassObjectFunc = (DllGetClassObjectFunc) GetProcAddress(mFlashLibHandle, "DllGetClassObject");
+ aResult = aDllGetClassObjectFunc(CLSID_ShockwaveFlash, IID_IClassFactory, (void**)&aClassFactory);
+ aClassFactory->CreateInstance(NULL, IID_IOleObject, (void**)&mOleObject);
+ aClassFactory->Release();
+ }
+ else
+ {
+ CoCreateInstance(CLSID_ShockwaveFlash, NULL,
+ CLSCTX_INPROC_SERVER,
+ IID_IOleObject,
+ (void**)&mOleObject);
+ }
+
+ IOleClientSite* aClientSite = NULL;
+ mControlSite->QueryInterface(__uuidof(IOleClientSite), (void**) &aClientSite);
+ mOleObject->SetClientSite(aClientSite);
+
+ mOleObject->QueryInterface(__uuidof(IShockwaveFlash), (LPVOID*) &mFlashInterface);
+ _bstr_t aTrans = "Transparent";
+ mFlashInterface->put_WMode(aTrans);
+
+ aResult = mOleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, aClientSite, 0, NULL, NULL);
+ aClientSite->Release();
+
+ mOleObject->QueryInterface(__uuidof(IOleInPlaceObjectWindowless), (LPVOID*) &mWindowlessObject);
+
+ mFlashSink = new FlashSink();
+ mFlashSink->AddRef();
+ mFlashSink->Init(this);
+}
+
+FlashWidget::~FlashWidget()
+{
+ CleanupImages();
+
+ if (mWindowlessObject != NULL)
+ mWindowlessObject->Release();
+ if (mFlashInterface != NULL)
+ mFlashInterface->Release();
+
+ if (mFlashSink != NULL)
+ {
+ mFlashSink->Shutdown();
+ mFlashSink->Release();
+ }
+
+ mOleObject->Close(OLECLOSE_NOSAVE);
+
+ if (mOleObject != NULL)
+ mOleObject->Release();
+
+ if (mControlSite != NULL)
+ mControlSite->Release();
+
+ // Make sure all our COM objects were actually destroyed
+ DBG_ASSERTE(mCOMCount == 0);
+
+ if (mFlashLibHandle != NULL)
+ FreeLibrary(mFlashLibHandle);
+}
+
+double FlashWidget::GetFlashVersion()
+{
+ CoInitialize(NULL);
+
+ IOleObject* anOleObject = NULL;
+ if (FAILED(CoCreateInstance(CLSID_ShockwaveFlash, NULL,
+ CLSCTX_INPROC_SERVER,
+ IID_IOleObject,
+ (void**) &anOleObject)))
+ return 0.0;
+
+ IShockwaveFlash* aFlashInterface = NULL;
+ if (FAILED(anOleObject->QueryInterface(__uuidof(IShockwaveFlash), (LPVOID*) &aFlashInterface)))
+ return 0.0;
+
+ long aVersion = 0;
+ aFlashInterface->FlashVersion(&aVersion);
+
+ aFlashInterface->Release();
+ anOleObject->Release();
+
+ return aVersion / 65536.0;
+}
+
+void FlashWidget::CleanupImages()
+{
+ if (mImage != NULL)
+ {
+ delete mImage;
+ mImage = NULL;
+ }
+}
+
+void FlashWidget::RebuildImages()
+{
+ CleanupImages();
+
+ mImage = new DDImage(gSexyAppBase->mDDInterface);
+ mImage->Create(mWidth, mHeight);
+ mImage->SetImageMode(false, false);
+}
+
+void FlashWidget::CheckCursor()
+{
+ HCURSOR aCursor = GetCursor();
+ if (aCursor == ::LoadCursor(NULL, IDC_ARROW))
+ {
+ mCurCursor = CURSOR_POINTER;
+ gSexyAppBase->mOverrideCursor = NULL;
+ gSexyAppBase->SetCursor(mCurCursor);
+ }
+ else if (aCursor != NULL)
+ {
+ gSexyAppBase->mOverrideCursor = aCursor;
+ mCurCursor = CURSOR_HAND;
+ gSexyAppBase->SetCursor(mCurCursor);
+ }
+}
+
+void FlashWidget::DrawFlashBackground(Graphics* g)
+{
+ if (mBkgColor.mAlpha != 0)
+ {
+ g->SetColor(mBkgColor);
+ g->FillRect(0, 0, mWidth, mHeight);
+ }
+
+ if (mBkgImage != NULL)
+ {
+ if ((mBkgImageSrcRect.mWidth != 0) && (mBkgImageSrcRect.mHeight != 0))
+ g->DrawImage(mBkgImage, 0, 0, mBkgImageSrcRect);
+ else
+ g->DrawImage(mBkgImage, 0, 0);
+ }
+}
+
+bool FlashWidget::StartAnimation(const std::string& theFileName)
+{
+ std::string aFullPath = GetFullPath(theFileName);
+
+ _bstr_t bstr((char*) aFullPath.c_str());
+ mFlashInterface->put_Movie(bstr); // you have to change the path here
+ if ((mPauseCount == 0) && (mFlashInterface->Play() != S_OK))
+ return false;
+
+ if ((mWidgetManager != NULL) && (mIsOver))
+ MouseMove(mWidgetManager->mLastMouseX - mX, mWidgetManager->mLastMouseY - mY);
+
+ mState = STATE_PLAYING;
+ return true;
+}
+
+void FlashWidget::SetQuality(int theQuality)
+{
+ static char* aQualityNames[3] = {"Low", "Medium", "High"};
+
+ _bstr_t aNewStr = aQualityNames[theQuality];
+ mFlashInterface->put_Quality2(aNewStr);
+}
+
+void FlashWidget::Pause()
+{
+ mPauseCount++;
+
+ if (mState != STATE_STOPPED)
+ mState = STATE_IDLE;
+
+ if ((mPauseCount == 1) && (mFlashInterface != NULL) && (mState != STATE_STOPPED))
+ mFlashInterface->StopPlay();
+}
+
+void FlashWidget::Unpause()
+{
+ mPauseCount--;
+ if ((mPauseCount == 0) && (mFlashInterface != NULL) && (mState != STATE_STOPPED))
+ {
+ mState = STATE_PLAYING;
+ mFlashInterface->Play();
+ }
+}
+
+void FlashWidget::Rewind()
+{
+ if (mFlashInterface != NULL)
+ {
+ mFlashInterface->Rewind();
+ mFlashInterface->Play();
+ }
+}
+
+void FlashWidget::GotoFrame(int theFrameNum)
+{
+ if (mFlashInterface != NULL)
+ {
+ mFlashInterface->GotoFrame(theFrameNum);
+ mFlashInterface->Play();
+ }
+}
+
+void FlashWidget::Back()
+{
+ if (mFlashInterface != NULL)
+ {
+ mFlashInterface->Back();
+ mFlashInterface->Play();
+ }
+}
+
+void FlashWidget::Forward()
+{
+ if (mFlashInterface != NULL)
+ {
+ mFlashInterface->Forward();
+ mFlashInterface->Play();
+ }
+}
+
+bool FlashWidget::IsPlaying()
+{
+ VARIANT_BOOL aBool = 0;
+ if (mFlashInterface != NULL)
+ mFlashInterface->IsPlaying(&aBool);
+ return aBool != 0;
+}
+
+int FlashWidget::GetCurrentFrame()
+{
+ long aCurrentFrame = -1;
+ if (mFlashInterface != NULL)
+ mFlashInterface->CurrentFrame(&aCurrentFrame);
+ return aCurrentFrame;
+}
+
+std::string FlashWidget::GetCurrentLabel(const std::string& theTimeline)
+{
+ BSTR aBStr = L"";
+ if (mFlashInterface != NULL)
+ mFlashInterface->TCurrentLabel(_bstr_t(theTimeline.c_str()), &aBStr);
+ return (const char*) _bstr_t(aBStr);
+}
+
+void FlashWidget::CallFrame(const std::string& theTimeline, int theFrameNum)
+{
+ if (mFlashInterface != NULL)
+ mFlashInterface->TCallFrame(_bstr_t(theTimeline.c_str()), theFrameNum);
+}
+
+void FlashWidget::CallLabel(const std::string& theTimeline, const std::string& theLabel)
+{
+ if (mFlashInterface != NULL)
+ mFlashInterface->TCallLabel(_bstr_t(theTimeline.c_str()), _bstr_t(theLabel.c_str()));
+}
+
+std::string FlashWidget::GetVariable(const std::string& theName)
+{
+ BSTR aBStr = L"";
+ if (mFlashInterface != NULL)
+ mFlashInterface->GetVariable(_bstr_t(theName.c_str()), &aBStr);
+ return (const char*) _bstr_t(aBStr);
+}
+
+void FlashWidget::SetVariable(const std::string& theName, const std::string& theValue)
+{
+ if (mFlashInterface != NULL)
+ mFlashInterface->SetVariable(_bstr_t(theName.c_str()), _bstr_t(theValue.c_str()));
+}
+
+void FlashWidget::Update()
+{
+ if (mAutoPause)
+ {
+ if (!gSexyAppBase->mHasFocus)
+ {
+ if (!mHasLostFocus)
+ {
+ if (mAutoPause)
+ Pause();
+ mHasLostFocus = true;
+ }
+
+ return;
+ }
+ else
+ {
+ if (mHasLostFocus)
+ {
+ if (mAutoPause)
+ Unpause();
+ mHasLostFocus = false;
+ }
+ }
+ }
+
+ if (mState == STATE_PLAYING)
+ {
+ VARIANT_BOOL isPlaying = 0;
+ mFlashInterface->IsPlaying(&isPlaying);
+ if (!isPlaying)
+ {
+ mState = STATE_STOPPED;
+ if ((mFlashListener != NULL) && (mPauseCount == 0))
+ mFlashListener->FlashAnimEnded(mId);
+ }
+ }
+
+ if (mFlashDirty)
+ MarkDirty();
+}
+
+void FlashWidget::Resize(int theX, int theY, int theWidth, int theHeight)
+{
+ Widget::Resize(theX, theY, theWidth, theHeight);
+
+ mDirtyRect = Rect(theX, theY, theWidth, theHeight);
+
+ RebuildImages();
+
+ IOleInPlaceObject* anInPlaceObject = NULL;
+ mOleObject->QueryInterface(__uuidof(IOleInPlaceObject), (LPVOID*) &anInPlaceObject);
+
+ if (anInPlaceObject != NULL)
+ {
+ RECT aRect = GetRect().ToRECT();
+ anInPlaceObject->SetObjectRects(&aRect, &aRect);
+ anInPlaceObject->Release();
+ }
+}
+
+void FlashWidget::Draw(Graphics* g)
+{
+ if (mFlashDirty)
+ {
+ Graphics anImageG(mImage);
+ DrawFlashBackground(&anImageG);
+
+ LPDIRECTDRAWSURFACE aSurface = mImage->GetSurface();
+ if (aSurface == NULL)
+ return;
+
+ HDC aDC = NULL;
+ if (aSurface->GetDC(&aDC) != S_OK)
+ return;
+
+ IViewObject* aViewObject = NULL;
+ mFlashInterface->QueryInterface(IID_IViewObject, (LPVOID*) &aViewObject);
+ if (aViewObject != NULL)
+ {
+ RECTL aRect = {0, 0, mWidth, mHeight};
+
+ Point anAbsPos = GetAbsPos();
+
+ HRGN aRgn = CreateRectRgn(mDirtyRect.mX - anAbsPos.mX, mDirtyRect.mY - anAbsPos.mY,
+ mDirtyRect.mX + mDirtyRect.mWidth - anAbsPos.mX,
+ mDirtyRect.mY + mDirtyRect.mHeight - anAbsPos.mY);
+ SelectClipRgn(aDC, aRgn);
+ DeleteObject(aRgn);
+
+ aViewObject->Draw(DVASPECT_CONTENT, 1,
+ NULL, NULL, NULL, aDC, &aRect, NULL, NULL,
+ 0);
+
+ aViewObject->Release();
+ }
+
+ aSurface->ReleaseDC(aDC);
+
+ mFlashDirty = false;
+ }
+
+ g->DrawImage(mImage, 0, 0);
+}
+
+void FlashWidget::MouseMove(int x, int y)
+{
+ Widget::MouseMove(x, y);
+
+ LRESULT aResult;
+ Point anAbsPos = GetAbsPos();
+ mWindowlessObject->OnWindowMessage(WM_MOUSEMOVE, 0, MAKELPARAM(x + anAbsPos.mX, y + anAbsPos.mY), &aResult);
+
+ if (mIsOver)
+ CheckCursor();
+}
+
+void FlashWidget::MouseDown(int x, int y, int theBtnNum, int theClickCount)
+{
+ if (theBtnNum == 0)
+ {
+ LRESULT aResult;
+ Point anAbsPos = GetAbsPos();
+ mWindowlessObject->OnWindowMessage(WM_LBUTTONDOWN, MK_LBUTTON, MAKELPARAM(x + anAbsPos.mX, y + anAbsPos.mY), &aResult);
+ CheckCursor();
+ }
+}
+
+void FlashWidget::MouseUp(int x, int y, int theBtnNum, int theClickCount)
+{
+ if (theBtnNum == 0)
+ {
+ LRESULT aResult;
+ Point anAbsPos = GetAbsPos();
+ mWindowlessObject->OnWindowMessage(WM_LBUTTONUP, 0, MAKELPARAM(x + anAbsPos.mX, y + anAbsPos.mY), &aResult);
+ CheckCursor();
+ }
+}
+
+void FlashWidget::MouseDrag(int x, int y)
+{
+ if (mWidgetManager->IsLeftButtonDown())
+ {
+ LRESULT aResult;
+ Point anAbsPos = GetAbsPos();
+ mWindowlessObject->OnWindowMessage(WM_MOUSEMOVE, MK_LBUTTON, MAKELPARAM(x + anAbsPos.mX, y + anAbsPos.mY), &aResult);
+ CheckCursor();
+ }
+}
+
+void FlashWidget::MouseLeave()
+{
+ Widget::MouseLeave();
+
+ // To prevent Flash control from setting our cursor if it thinks
+ // our mouse is still over something
+ MouseMove(-1, -1);
+
+ gSexyAppBase->mOverrideCursor = NULL;
+ gSexyAppBase->SetCursor(CURSOR_POINTER);
+}
+
+void FlashWidget::SysColorChanged()
+{
+ mFlashDirty = true;
+ mDirtyRect = GetRect();
+
+ MarkDirty();
+}
|