| 1 | ///////////////////////////////////////////////////////////////////////////// |
| 2 | // Name: src/msw/mediactrl_wmp10.cpp |
| 3 | // Purpose: Windows Media Player 9/10 Media Backend for Windows |
| 4 | // Author: Ryan Norton <wxprojects@comcast.net> |
| 5 | // Modified by: |
| 6 | // Created: 11/07/04 |
| 7 | // RCS-ID: $Id$ |
| 8 | // Copyright: (c) Ryan Norton |
| 9 | // Licence: wxWindows licence |
| 10 | ///////////////////////////////////////////////////////////////////////////// |
| 11 | |
| 12 | //-----------------Introduction---------------------------------------------- |
| 13 | // This backend is for Desktops with either WMP 9 or 10 and Windows |
| 14 | // mobile (5.0, some 2003 SmartPhones etc.) WMP 10 only (9 has no automation |
| 15 | // interface but you can hack it with message hacks to play through |
| 16 | // a currently running instance of media player). |
| 17 | // |
| 18 | // There are quite a few WMP 10 interfaces and unlike other media |
| 19 | // backends we actually set it to automatically play files as it has |
| 20 | // as huge caveat that you cannot (technically) obtain media information |
| 21 | // from IWMPMedia including duration and video size until a media file |
| 22 | // has literally started to play. There is a hack (and indeed we have |
| 23 | // it within this file) to enable duration getting from a non-playing |
| 24 | // file, but there is no hack I (RN) know of to get the video size from |
| 25 | // a file that isn't playing. |
| 26 | // |
| 27 | // The workaround for this is to send the wxEVT_MEDIA_LOADED when the file |
| 28 | // is about to be played - and if the user didn't change the state of the |
| 29 | // media (m_bWasStateChanged), when set it back to the stop state. |
| 30 | // |
| 31 | // The ActiveX control itself is particularily stubborn, calling |
| 32 | // IOleInPlaceSite::OnPosRectChange every file change trying to set itself |
| 33 | // to something different then what we told it to before. |
| 34 | // |
| 35 | // The docs are at |
| 36 | // http://msdn.microsoft.com/library/en-us/wmplay10/mmp_sdk/windowsmediaplayer10sdk.asp |
| 37 | |
| 38 | //=========================================================================== |
| 39 | // DECLARATIONS |
| 40 | //=========================================================================== |
| 41 | |
| 42 | //--------------------------------------------------------------------------- |
| 43 | // Pre-compiled header stuff |
| 44 | //--------------------------------------------------------------------------- |
| 45 | |
| 46 | // For compilers that support precompilation, includes "wx.h". |
| 47 | #include "wx/wxprec.h" |
| 48 | |
| 49 | #ifdef __BORLANDC__ |
| 50 | #pragma hdrstop |
| 51 | #endif |
| 52 | |
| 53 | #if wxUSE_MEDIACTRL && wxUSE_ACTIVEX |
| 54 | |
| 55 | #include "wx/mediactrl.h" |
| 56 | |
| 57 | #ifndef WX_PRECOMP |
| 58 | #include "wx/log.h" |
| 59 | #endif |
| 60 | |
| 61 | #include "wx/msw/private.h" // user info and wndproc setting/getting |
| 62 | #include "wx/msw/ole/activex.h" // wxActiveXContainer - COM-specific stuff |
| 63 | |
| 64 | //--------------------------------------------------------------------------- |
| 65 | // ATL Includes - define WXTEST_ATL if you |
| 66 | // want to use CAxWindow instead of wxActiveXContainer (note that |
| 67 | // this is mainly for testing as the activex events arn't implemented here) |
| 68 | //--------------------------------------------------------------------------- |
| 69 | #if 0 |
| 70 | #define WXTEST_ATL |
| 71 | #endif |
| 72 | |
| 73 | #ifdef WXTEST_ATL |
| 74 | #include <atlbase.h> |
| 75 | CComModule _Module; |
| 76 | #define min(x,y) (x < y ? x : y) |
| 77 | #include <atlcom.h> |
| 78 | #include <atlhost.h> |
| 79 | #include <atlctl.h> |
| 80 | #endif |
| 81 | |
| 82 | //--------------------------------------------------------------------------- |
| 83 | // Other defines |
| 84 | //--------------------------------------------------------------------------- |
| 85 | |
| 86 | // disable "cast truncates constant value" for VARIANT_BOOL values |
| 87 | // passed as parameters in VC6 |
| 88 | #ifdef _MSC_VER |
| 89 | #pragma warning (disable:4310) |
| 90 | #endif |
| 91 | |
| 92 | // error logger for HRESULTS (nothing really now) |
| 93 | #define wxWMP10LOG(x) |
| 94 | |
| 95 | //--------------------------------------------------------------------------- |
| 96 | // Various definitions dumped from wmp.IDL |
| 97 | //--------------------------------------------------------------------------- |
| 98 | |
| 99 | // CLSID_WMP10ALT is on CE and in some MS docs - on others it is the plain ver |
| 100 | const CLSID CLSID_WMP10 = {0x6BF52A50,0x394A,0x11D3,{0xB1,0x53,0x00,0xC0,0x4F,0x79,0xFA,0xA6}}; |
| 101 | const CLSID CLSID_WMP10ALT = {0x6BF52A52,0x394A,0x11D3,{0xB1,0x53,0x00,0xC0,0x4F,0x79,0xFA,0xA6}}; |
| 102 | |
| 103 | const IID IID_IWMPSettings = {0x9104D1AB,0x80C9,0x4FED,{0xAB,0xF0,0x2E,0x64,0x17,0xA6,0xDF,0x14}}; |
| 104 | const IID IID_IWMPCore = {0xD84CCA99,0xCCE2,0x11D2,{0x9E,0xCC,0x00,0x00,0xF8,0x08,0x59,0x81}}; |
| 105 | #ifndef WXTEST_ATL |
| 106 | const IID IID_IWMPPlayer = {0x6BF52A4F,0x394A,0x11D3,{0xB1,0x53,0x00,0xC0,0x4F,0x79,0xFA,0xA6}}; |
| 107 | #endif |
| 108 | |
| 109 | const IID IID_IWMPMedia = {0x94D55E95,0x3FAC,0x11D3,{0xB1,0x55,0x00,0xC0,0x4F,0x79,0xFA,0xA6}}; |
| 110 | const IID IID_IWMPControls = {0x74C09E02,0xF828,0x11D2,{0xA7,0x4B,0x00,0xA0,0xC9,0x05,0xF3,0x6E}}; |
| 111 | const IID IID_IWMPPlayer2 = {0x0E6B01D1,0xD407,0x4C85,{0xBF,0x5F,0x1C,0x01,0xF6,0x15,0x02,0x80}}; |
| 112 | const IID IID_IWMPCore2 = {0xBC17E5B7,0x7561,0x4C18,{0xBB,0x90,0x17,0xD4,0x85,0x77,0x56,0x59}}; |
| 113 | const IID IID_IWMPCore3 = {0x7587C667,0x628F,0x499F,{0x88,0xE7,0x6A,0x6F,0x4E,0x88,0x84,0x64}}; |
| 114 | const IID IID_IWMPNetwork = {0xEC21B779,0xEDEF,0x462D,{0xBB,0xA4,0xAD,0x9D,0xDE,0x2B,0x29,0xA7}}; |
| 115 | |
| 116 | enum WMPOpenState |
| 117 | { |
| 118 | wmposUndefined = 0, |
| 119 | wmposPlaylistChanging = 1, |
| 120 | wmposPlaylistLocating = 2, |
| 121 | wmposPlaylistConnecting = 3, |
| 122 | wmposPlaylistLoading = 4, |
| 123 | wmposPlaylistOpening = 5, |
| 124 | wmposPlaylistOpenNoMedia = 6, |
| 125 | wmposPlaylistChanged = 7, |
| 126 | wmposMediaChanging = 8, |
| 127 | wmposMediaLocating = 9, |
| 128 | wmposMediaConnecting = 10, |
| 129 | wmposMediaLoading = 11, |
| 130 | wmposMediaOpening = 12, |
| 131 | wmposMediaOpen = 13, |
| 132 | wmposBeginCodecAcquisition = 14, |
| 133 | wmposEndCodecAcquisition = 15, |
| 134 | wmposBeginLicenseAcquisition = 16, |
| 135 | wmposEndLicenseAcquisition = 17, |
| 136 | wmposBeginIndividualization = 18, |
| 137 | wmposEndIndividualization = 19, |
| 138 | wmposMediaWaiting = 20, |
| 139 | wmposOpeningUnknownURL = 21 |
| 140 | }; |
| 141 | |
| 142 | enum WMPPlayState |
| 143 | { |
| 144 | wmppsUndefined = 0, |
| 145 | wmppsStopped = 1, |
| 146 | wmppsPaused = 2, |
| 147 | wmppsPlaying = 3, |
| 148 | wmppsScanForward = 4, |
| 149 | wmppsScanReverse = 5, |
| 150 | wmppsBuffering = 6, |
| 151 | wmppsWaiting = 7, |
| 152 | wmppsMediaEnded = 8, |
| 153 | wmppsTransitioning = 9, |
| 154 | wmppsReady = 10, |
| 155 | wmppsReconnecting = 11, |
| 156 | wmppsLast = 12 |
| 157 | }; |
| 158 | |
| 159 | |
| 160 | struct IWMPMedia : public IDispatch |
| 161 | { |
| 162 | public: |
| 163 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_isIdentical( |
| 164 | /* [in] */ IWMPMedia __RPC_FAR *pIWMPMedia, |
| 165 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pvbool) = 0; |
| 166 | |
| 167 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_sourceURL( |
| 168 | /* [retval][out] */ BSTR __RPC_FAR *pbstrSourceURL) = 0; |
| 169 | |
| 170 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_name( |
| 171 | /* [retval][out] */ BSTR __RPC_FAR *pbstrName) = 0; |
| 172 | |
| 173 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_name( |
| 174 | /* [in] */ BSTR pbstrName) = 0; |
| 175 | |
| 176 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_imageSourceWidth( |
| 177 | /* [retval][out] */ long __RPC_FAR *pWidth) = 0; |
| 178 | |
| 179 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_imageSourceHeight( |
| 180 | /* [retval][out] */ long __RPC_FAR *pHeight) = 0; |
| 181 | |
| 182 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_markerCount( |
| 183 | /* [retval][out] */ long __RPC_FAR *pMarkerCount) = 0; |
| 184 | |
| 185 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getMarkerTime( |
| 186 | /* [in] */ long MarkerNum, |
| 187 | /* [retval][out] */ double __RPC_FAR *pMarkerTime) = 0; |
| 188 | |
| 189 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getMarkerName( |
| 190 | /* [in] */ long MarkerNum, |
| 191 | /* [retval][out] */ BSTR __RPC_FAR *pbstrMarkerName) = 0; |
| 192 | |
| 193 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_duration( |
| 194 | /* [retval][out] */ double __RPC_FAR *pDuration) = 0; |
| 195 | |
| 196 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_durationString( |
| 197 | /* [retval][out] */ BSTR __RPC_FAR *pbstrDuration) = 0; |
| 198 | |
| 199 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_attributeCount( |
| 200 | /* [retval][out] */ long __RPC_FAR *plCount) = 0; |
| 201 | |
| 202 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getAttributeName( |
| 203 | /* [in] */ long lIndex, |
| 204 | /* [retval][out] */ BSTR __RPC_FAR *pbstrItemName) = 0; |
| 205 | |
| 206 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getItemInfo( |
| 207 | /* [in] */ BSTR bstrItemName, |
| 208 | /* [retval][out] */ BSTR __RPC_FAR *pbstrVal) = 0; |
| 209 | |
| 210 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE setItemInfo( |
| 211 | /* [in] */ BSTR bstrItemName, |
| 212 | /* [in] */ BSTR bstrVal) = 0; |
| 213 | |
| 214 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getItemInfoByAtom( |
| 215 | /* [in] */ long lAtom, |
| 216 | /* [retval][out] */ BSTR __RPC_FAR *pbstrVal) = 0; |
| 217 | |
| 218 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE isMemberOf( |
| 219 | /* [in] */ IUnknown __RPC_FAR *pPlaylist, |
| 220 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pvarfIsMemberOf) = 0; |
| 221 | |
| 222 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE isReadOnlyItem( |
| 223 | /* [in] */ BSTR bstrItemName, |
| 224 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pvarfIsReadOnly) = 0; |
| 225 | |
| 226 | }; |
| 227 | |
| 228 | struct IWMPControls : public IDispatch |
| 229 | { |
| 230 | public: |
| 231 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_isAvailable( |
| 232 | /* [in] */ BSTR bstrItem, |
| 233 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pIsAvailable) = 0; |
| 234 | |
| 235 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE play( void) = 0; |
| 236 | |
| 237 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE stop( void) = 0; |
| 238 | |
| 239 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE pause( void) = 0; |
| 240 | |
| 241 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE fastForward( void) = 0; |
| 242 | |
| 243 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE fastReverse( void) = 0; |
| 244 | |
| 245 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_currentPosition( |
| 246 | /* [retval][out] */ double __RPC_FAR *pdCurrentPosition) = 0; |
| 247 | |
| 248 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_currentPosition( |
| 249 | /* [in] */ double pdCurrentPosition) = 0; |
| 250 | |
| 251 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_currentPositionString( |
| 252 | /* [retval][out] */ BSTR __RPC_FAR *pbstrCurrentPosition) = 0; |
| 253 | |
| 254 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE next( void) = 0; |
| 255 | |
| 256 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE previous( void) = 0; |
| 257 | |
| 258 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_currentItem( |
| 259 | /* [retval][out] */ IWMPMedia __RPC_FAR *__RPC_FAR *ppIWMPMedia) = 0; |
| 260 | |
| 261 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_currentItem( |
| 262 | /* [in] */ IWMPMedia __RPC_FAR *ppIWMPMedia) = 0; |
| 263 | |
| 264 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_currentMarker( |
| 265 | /* [retval][out] */ long __RPC_FAR *plMarker) = 0; |
| 266 | |
| 267 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_currentMarker( |
| 268 | /* [in] */ long plMarker) = 0; |
| 269 | |
| 270 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE playItem( |
| 271 | /* [in] */ IWMPMedia __RPC_FAR *pIWMPMedia) = 0; |
| 272 | |
| 273 | }; |
| 274 | |
| 275 | |
| 276 | struct IWMPSettings : public IDispatch |
| 277 | { |
| 278 | public: |
| 279 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_isAvailable( |
| 280 | /* [in] */ BSTR bstrItem, |
| 281 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pIsAvailable) = 0; |
| 282 | |
| 283 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_autoStart( |
| 284 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pfAutoStart) = 0; |
| 285 | |
| 286 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_autoStart( |
| 287 | /* [in] */ VARIANT_BOOL pfAutoStart) = 0; |
| 288 | |
| 289 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_baseURL( |
| 290 | /* [retval][out] */ BSTR __RPC_FAR *pbstrBaseURL) = 0; |
| 291 | |
| 292 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_baseURL( |
| 293 | /* [in] */ BSTR pbstrBaseURL) = 0; |
| 294 | |
| 295 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_defaultFrame( |
| 296 | /* [retval][out] */ BSTR __RPC_FAR *pbstrDefaultFrame) = 0; |
| 297 | |
| 298 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_defaultFrame( |
| 299 | /* [in] */ BSTR pbstrDefaultFrame) = 0; |
| 300 | |
| 301 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_invokeURLs( |
| 302 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pfInvokeURLs) = 0; |
| 303 | |
| 304 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_invokeURLs( |
| 305 | /* [in] */ VARIANT_BOOL pfInvokeURLs) = 0; |
| 306 | |
| 307 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_mute( |
| 308 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pfMute) = 0; |
| 309 | |
| 310 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_mute( |
| 311 | /* [in] */ VARIANT_BOOL pfMute) = 0; |
| 312 | |
| 313 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_playCount( |
| 314 | /* [retval][out] */ long __RPC_FAR *plCount) = 0; |
| 315 | |
| 316 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_playCount( |
| 317 | /* [in] */ long plCount) = 0; |
| 318 | |
| 319 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_rate( |
| 320 | /* [retval][out] */ double __RPC_FAR *pdRate) = 0; |
| 321 | |
| 322 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_rate( |
| 323 | /* [in] */ double pdRate) = 0; |
| 324 | |
| 325 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_balance( |
| 326 | /* [retval][out] */ long __RPC_FAR *plBalance) = 0; |
| 327 | |
| 328 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_balance( |
| 329 | /* [in] */ long plBalance) = 0; |
| 330 | |
| 331 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_volume( |
| 332 | /* [retval][out] */ long __RPC_FAR *plVolume) = 0; |
| 333 | |
| 334 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_volume( |
| 335 | /* [in] */ long plVolume) = 0; |
| 336 | |
| 337 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getMode( |
| 338 | /* [in] */ BSTR bstrMode, |
| 339 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pvarfMode) = 0; |
| 340 | |
| 341 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE setMode( |
| 342 | /* [in] */ BSTR bstrMode, |
| 343 | /* [in] */ VARIANT_BOOL varfMode) = 0; |
| 344 | |
| 345 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_enableErrorDialogs( |
| 346 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pfEnableErrorDialogs) = 0; |
| 347 | |
| 348 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_enableErrorDialogs( |
| 349 | /* [in] */ VARIANT_BOOL pfEnableErrorDialogs) = 0; |
| 350 | |
| 351 | }; |
| 352 | |
| 353 | struct IWMPNetwork : public IDispatch |
| 354 | { |
| 355 | public: |
| 356 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_bandWidth( |
| 357 | /* [retval][out] */ long __RPC_FAR *plBandwidth) = 0; |
| 358 | |
| 359 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_recoveredPackets( |
| 360 | /* [retval][out] */ long __RPC_FAR *plRecoveredPackets) = 0; |
| 361 | |
| 362 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_sourceProtocol( |
| 363 | /* [retval][out] */ BSTR __RPC_FAR *pbstrSourceProtocol) = 0; |
| 364 | |
| 365 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_receivedPackets( |
| 366 | /* [retval][out] */ long __RPC_FAR *plReceivedPackets) = 0; |
| 367 | |
| 368 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_lostPackets( |
| 369 | /* [retval][out] */ long __RPC_FAR *plLostPackets) = 0; |
| 370 | |
| 371 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_receptionQuality( |
| 372 | /* [retval][out] */ long __RPC_FAR *plReceptionQuality) = 0; |
| 373 | |
| 374 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_bufferingCount( |
| 375 | /* [retval][out] */ long __RPC_FAR *plBufferingCount) = 0; |
| 376 | |
| 377 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_bufferingProgress( |
| 378 | /* [retval][out] */ long __RPC_FAR *plBufferingProgress) = 0; |
| 379 | |
| 380 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_bufferingTime( |
| 381 | /* [retval][out] */ long __RPC_FAR *plBufferingTime) = 0; |
| 382 | |
| 383 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_bufferingTime( |
| 384 | /* [in] */ long plBufferingTime) = 0; |
| 385 | |
| 386 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_frameRate( |
| 387 | /* [retval][out] */ long __RPC_FAR *plFrameRate) = 0; |
| 388 | |
| 389 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_maxBitRate( |
| 390 | /* [retval][out] */ long __RPC_FAR *plBitRate) = 0; |
| 391 | |
| 392 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_bitRate( |
| 393 | /* [retval][out] */ long __RPC_FAR *plBitRate) = 0; |
| 394 | |
| 395 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getProxySettings( |
| 396 | /* [in] */ BSTR bstrProtocol, |
| 397 | /* [retval][out] */ long __RPC_FAR *plProxySetting) = 0; |
| 398 | |
| 399 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE setProxySettings( |
| 400 | /* [in] */ BSTR bstrProtocol, |
| 401 | /* [in] */ long lProxySetting) = 0; |
| 402 | |
| 403 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getProxyName( |
| 404 | /* [in] */ BSTR bstrProtocol, |
| 405 | /* [retval][out] */ BSTR __RPC_FAR *pbstrProxyName) = 0; |
| 406 | |
| 407 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE setProxyName( |
| 408 | /* [in] */ BSTR bstrProtocol, |
| 409 | /* [in] */ BSTR bstrProxyName) = 0; |
| 410 | |
| 411 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getProxyPort( |
| 412 | /* [in] */ BSTR bstrProtocol, |
| 413 | /* [retval][out] */ long __RPC_FAR *lProxyPort) = 0; |
| 414 | |
| 415 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE setProxyPort( |
| 416 | /* [in] */ BSTR bstrProtocol, |
| 417 | /* [in] */ long lProxyPort) = 0; |
| 418 | |
| 419 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getProxyExceptionList( |
| 420 | /* [in] */ BSTR bstrProtocol, |
| 421 | /* [retval][out] */ BSTR __RPC_FAR *pbstrExceptionList) = 0; |
| 422 | |
| 423 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE setProxyExceptionList( |
| 424 | /* [in] */ BSTR bstrProtocol, |
| 425 | /* [in] */ BSTR pbstrExceptionList) = 0; |
| 426 | |
| 427 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE getProxyBypassForLocal( |
| 428 | /* [in] */ BSTR bstrProtocol, |
| 429 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pfBypassForLocal) = 0; |
| 430 | |
| 431 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE setProxyBypassForLocal( |
| 432 | /* [in] */ BSTR bstrProtocol, |
| 433 | /* [in] */ VARIANT_BOOL fBypassForLocal) = 0; |
| 434 | |
| 435 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_maxBandwidth( |
| 436 | /* [retval][out] */ long __RPC_FAR *lMaxBandwidth) = 0; |
| 437 | |
| 438 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_maxBandwidth( |
| 439 | /* [in] */ long lMaxBandwidth) = 0; |
| 440 | |
| 441 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_downloadProgress( |
| 442 | /* [retval][out] */ long __RPC_FAR *plDownloadProgress) = 0; |
| 443 | |
| 444 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_encodedFrameRate( |
| 445 | /* [retval][out] */ long __RPC_FAR *plFrameRate) = 0; |
| 446 | |
| 447 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_framesSkipped( |
| 448 | /* [retval][out] */ long __RPC_FAR *plFrames) = 0; |
| 449 | |
| 450 | }; |
| 451 | |
| 452 | struct IWMPCore : public IDispatch |
| 453 | { |
| 454 | public: |
| 455 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE close( void) = 0; |
| 456 | |
| 457 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_URL( |
| 458 | /* [retval][out] */ BSTR __RPC_FAR *pbstrURL) = 0; |
| 459 | |
| 460 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_URL( |
| 461 | /* [in] */ BSTR pbstrURL) = 0; |
| 462 | |
| 463 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_openState( |
| 464 | /* [retval][out] */ WMPOpenState __RPC_FAR *pwmpos) = 0; |
| 465 | |
| 466 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_playState( |
| 467 | /* [retval][out] */ WMPPlayState __RPC_FAR *pwmpps) = 0; |
| 468 | |
| 469 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_controls( |
| 470 | /* [retval][out] */ IWMPControls __RPC_FAR *__RPC_FAR *ppControl) = 0; |
| 471 | |
| 472 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_settings( |
| 473 | /* [retval][out] */ IWMPSettings __RPC_FAR *__RPC_FAR *ppSettings) = 0; |
| 474 | |
| 475 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_currentMedia( |
| 476 | /* [retval][out] */ IWMPMedia __RPC_FAR *__RPC_FAR *ppMedia) = 0; |
| 477 | |
| 478 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_currentMedia( |
| 479 | /* [in] */ IUnknown __RPC_FAR *ppMedia) = 0; |
| 480 | |
| 481 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_mediaCollection( |
| 482 | /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppMediaCollection) = 0; |
| 483 | |
| 484 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_playlistCollection( |
| 485 | /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppPlaylistCollection) = 0; |
| 486 | |
| 487 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_versionInfo( |
| 488 | /* [retval][out] */ BSTR __RPC_FAR *pbstrVersionInfo) = 0; |
| 489 | |
| 490 | virtual /* [id] */ HRESULT STDMETHODCALLTYPE launchURL( |
| 491 | /* [in] */ BSTR bstrURL) = 0; |
| 492 | |
| 493 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_network( |
| 494 | /* [retval][out] */ IWMPNetwork __RPC_FAR *__RPC_FAR *ppQNI) = 0; |
| 495 | |
| 496 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_currentPlaylist( |
| 497 | /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppPL) = 0; |
| 498 | |
| 499 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_currentPlaylist( |
| 500 | /* [in] */ IUnknown __RPC_FAR *ppPL) = 0; |
| 501 | |
| 502 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_cdromCollection( |
| 503 | /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppCdromCollection) = 0; |
| 504 | |
| 505 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_closedCaption( |
| 506 | /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppClosedCaption) = 0; |
| 507 | |
| 508 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_isOnline( |
| 509 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pfOnline) = 0; |
| 510 | |
| 511 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_Error( |
| 512 | /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppError) = 0; |
| 513 | |
| 514 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_status( |
| 515 | /* [retval][out] */ BSTR __RPC_FAR *pbstrStatus) = 0; |
| 516 | |
| 517 | }; |
| 518 | |
| 519 | struct IWMPCore2 : public IWMPCore |
| 520 | { |
| 521 | public: |
| 522 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_dvd( |
| 523 | /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppDVD) = 0; |
| 524 | |
| 525 | }; |
| 526 | |
| 527 | struct IWMPCore3 : public IWMPCore2 |
| 528 | { |
| 529 | public: |
| 530 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE newPlaylist( |
| 531 | /* [in] */ BSTR bstrName, |
| 532 | /* [in] */ BSTR bstrURL, |
| 533 | /* [retval][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppPlaylist) = 0; |
| 534 | |
| 535 | virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE newMedia( |
| 536 | /* [in] */ BSTR bstrURL, |
| 537 | /* [retval][out] */ IWMPMedia __RPC_FAR *__RPC_FAR *ppMedia) = 0; |
| 538 | |
| 539 | }; |
| 540 | |
| 541 | #ifdef WXTEST_ATL |
| 542 | MIDL_INTERFACE("6BF52A4F-394A-11D3-B153-00C04F79FAA6") |
| 543 | #else |
| 544 | struct |
| 545 | #endif |
| 546 | IWMPPlayer : public IWMPCore |
| 547 | { |
| 548 | public: |
| 549 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_enabled( |
| 550 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pbEnabled) = 0; |
| 551 | |
| 552 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_enabled( |
| 553 | /* [in] */ VARIANT_BOOL pbEnabled) = 0; |
| 554 | |
| 555 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_fullScreen( |
| 556 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pbFullScreen) = 0; |
| 557 | |
| 558 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_fullScreen( |
| 559 | VARIANT_BOOL pbFullScreen) = 0; |
| 560 | |
| 561 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_enableContextMenu( |
| 562 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pbEnableContextMenu) = 0; |
| 563 | |
| 564 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_enableContextMenu( |
| 565 | VARIANT_BOOL pbEnableContextMenu) = 0; |
| 566 | |
| 567 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_uiMode( |
| 568 | /* [in] */ BSTR pbstrMode) = 0; |
| 569 | |
| 570 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_uiMode( |
| 571 | /* [retval][out] */ BSTR __RPC_FAR *pbstrMode) = 0; |
| 572 | }; |
| 573 | |
| 574 | struct IWMPPlayer2 : public IWMPCore |
| 575 | { |
| 576 | public: |
| 577 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_enabled( |
| 578 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pbEnabled) = 0; |
| 579 | |
| 580 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_enabled( |
| 581 | /* [in] */ VARIANT_BOOL pbEnabled) = 0; |
| 582 | |
| 583 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_fullScreen( |
| 584 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pbFullScreen) = 0; |
| 585 | |
| 586 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_fullScreen( |
| 587 | VARIANT_BOOL pbFullScreen) = 0; |
| 588 | |
| 589 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_enableContextMenu( |
| 590 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pbEnableContextMenu) = 0; |
| 591 | |
| 592 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_enableContextMenu( |
| 593 | VARIANT_BOOL pbEnableContextMenu) = 0; |
| 594 | |
| 595 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_uiMode( |
| 596 | /* [in] */ BSTR pbstrMode) = 0; |
| 597 | |
| 598 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_uiMode( |
| 599 | /* [retval][out] */ BSTR __RPC_FAR *pbstrMode) = 0; |
| 600 | |
| 601 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_stretchToFit( |
| 602 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pbEnabled) = 0; |
| 603 | |
| 604 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_stretchToFit( |
| 605 | /* [in] */ VARIANT_BOOL pbEnabled) = 0; |
| 606 | |
| 607 | virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_windowlessVideo( |
| 608 | /* [retval][out] */ VARIANT_BOOL __RPC_FAR *pbEnabled) = 0; |
| 609 | |
| 610 | virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_windowlessVideo( |
| 611 | /* [in] */ VARIANT_BOOL pbEnabled) = 0; |
| 612 | |
| 613 | }; |
| 614 | |
| 615 | //--------------------------------------------------------------------------- |
| 616 | // |
| 617 | // wxWMP10MediaBackend |
| 618 | // |
| 619 | //--------------------------------------------------------------------------- |
| 620 | |
| 621 | class WXDLLIMPEXP_MEDIA wxWMP10MediaBackend : public wxMediaBackendCommonBase |
| 622 | { |
| 623 | public: |
| 624 | wxWMP10MediaBackend(); |
| 625 | virtual ~wxWMP10MediaBackend(); |
| 626 | |
| 627 | virtual bool CreateControl(wxControl* ctrl, wxWindow* parent, |
| 628 | wxWindowID id, |
| 629 | const wxPoint& pos, |
| 630 | const wxSize& size, |
| 631 | long style, |
| 632 | const wxValidator& validator, |
| 633 | const wxString& name); |
| 634 | |
| 635 | virtual bool Play(); |
| 636 | virtual bool Pause(); |
| 637 | virtual bool Stop(); |
| 638 | |
| 639 | virtual bool Load(const wxString& fileName); |
| 640 | virtual bool Load(const wxURI& location); |
| 641 | virtual bool Load(const wxURI& location, const wxURI& proxy); |
| 642 | |
| 643 | bool DoLoad(const wxString& location); |
| 644 | void FinishLoad(); |
| 645 | |
| 646 | virtual wxMediaState GetState(); |
| 647 | |
| 648 | virtual bool SetPosition(wxLongLong where); |
| 649 | virtual wxLongLong GetPosition(); |
| 650 | virtual wxLongLong GetDuration(); |
| 651 | |
| 652 | virtual void Move(int x, int y, int w, int h); |
| 653 | wxSize GetVideoSize() const; |
| 654 | |
| 655 | virtual double GetPlaybackRate(); |
| 656 | virtual bool SetPlaybackRate(double); |
| 657 | |
| 658 | virtual double GetVolume(); |
| 659 | virtual bool SetVolume(double); |
| 660 | |
| 661 | virtual bool ShowPlayerControls(wxMediaCtrlPlayerControls flags); |
| 662 | |
| 663 | virtual wxLongLong GetDownloadProgress(); |
| 664 | virtual wxLongLong GetDownloadTotal(); |
| 665 | |
| 666 | |
| 667 | #ifdef WXTEST_ATL |
| 668 | CAxWindow m_wndView; |
| 669 | #else |
| 670 | wxActiveXContainer* m_pAX; |
| 671 | #endif |
| 672 | IWMPPlayer* m_pWMPPlayer; // Main activex interface |
| 673 | IWMPSettings* m_pWMPSettings; // Settings such as volume |
| 674 | IWMPControls* m_pWMPControls; // Control interface (play etc.) |
| 675 | wxSize m_bestSize; // Actual movie size |
| 676 | |
| 677 | bool m_bWasStateChanged; // See the "introduction" |
| 678 | |
| 679 | friend class wxWMP10MediaEvtHandler; |
| 680 | DECLARE_DYNAMIC_CLASS(wxWMP10MediaBackend) |
| 681 | }; |
| 682 | |
| 683 | #ifndef WXTEST_ATL |
| 684 | class WXDLLIMPEXP_MEDIA wxWMP10MediaEvtHandler : public wxEvtHandler |
| 685 | { |
| 686 | public: |
| 687 | wxWMP10MediaEvtHandler(wxWMP10MediaBackend *amb) : |
| 688 | m_amb(amb) |
| 689 | { |
| 690 | m_amb->m_pAX->Connect(m_amb->m_pAX->GetId(), |
| 691 | wxEVT_ACTIVEX, |
| 692 | wxActiveXEventHandler(wxWMP10MediaEvtHandler::OnActiveX), |
| 693 | NULL, this |
| 694 | ); |
| 695 | } |
| 696 | |
| 697 | void OnActiveX(wxActiveXEvent& event); |
| 698 | |
| 699 | private: |
| 700 | wxWMP10MediaBackend *m_amb; |
| 701 | |
| 702 | DECLARE_NO_COPY_CLASS(wxWMP10MediaEvtHandler) |
| 703 | }; |
| 704 | #endif |
| 705 | |
| 706 | //=========================================================================== |
| 707 | // IMPLEMENTATION |
| 708 | //=========================================================================== |
| 709 | |
| 710 | //--------------------------------------------------------------------------- |
| 711 | // |
| 712 | // wxWMP10MediaBackend |
| 713 | // |
| 714 | //--------------------------------------------------------------------------- |
| 715 | |
| 716 | IMPLEMENT_DYNAMIC_CLASS(wxWMP10MediaBackend, wxMediaBackend) |
| 717 | |
| 718 | //--------------------------------------------------------------------------- |
| 719 | // wxWMP10MediaBackend Constructor |
| 720 | //--------------------------------------------------------------------------- |
| 721 | wxWMP10MediaBackend::wxWMP10MediaBackend() |
| 722 | : |
| 723 | #ifndef WXTEST_ATL |
| 724 | m_pAX(NULL), |
| 725 | #endif |
| 726 | m_pWMPPlayer(NULL) |
| 727 | |
| 728 | { |
| 729 | } |
| 730 | |
| 731 | //--------------------------------------------------------------------------- |
| 732 | // wxWMP10MediaBackend Destructor |
| 733 | //--------------------------------------------------------------------------- |
| 734 | wxWMP10MediaBackend::~wxWMP10MediaBackend() |
| 735 | { |
| 736 | if(m_pWMPPlayer) |
| 737 | { |
| 738 | #ifndef WXTEST_ATL |
| 739 | m_pAX->DissociateHandle(); |
| 740 | delete m_pAX; |
| 741 | |
| 742 | m_ctrl->PopEventHandler(true); |
| 743 | #else |
| 744 | AtlAxWinTerm(); |
| 745 | _Module.Term(); |
| 746 | #endif |
| 747 | |
| 748 | m_pWMPPlayer->Release(); |
| 749 | m_pWMPSettings->Release(); |
| 750 | m_pWMPControls->Release(); |
| 751 | } |
| 752 | } |
| 753 | |
| 754 | //--------------------------------------------------------------------------- |
| 755 | // wxWMP10MediaBackend::CreateControl |
| 756 | //--------------------------------------------------------------------------- |
| 757 | bool wxWMP10MediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, |
| 758 | wxWindowID id, |
| 759 | const wxPoint& pos, |
| 760 | const wxSize& size, |
| 761 | long style, |
| 762 | const wxValidator& validator, |
| 763 | const wxString& name) |
| 764 | { |
| 765 | #ifndef WXTEST_ATL |
| 766 | if( ::CoCreateInstance(CLSID_WMP10, NULL, |
| 767 | CLSCTX_INPROC_SERVER, |
| 768 | IID_IWMPPlayer, (void**)&m_pWMPPlayer) != 0 ) |
| 769 | { |
| 770 | if( ::CoCreateInstance(CLSID_WMP10ALT, NULL, |
| 771 | CLSCTX_INPROC_SERVER, |
| 772 | IID_IWMPPlayer, (void**)&m_pWMPPlayer) != 0 ) |
| 773 | return false; |
| 774 | |
| 775 | if( m_pWMPPlayer->get_settings(&m_pWMPSettings) != 0) |
| 776 | { |
| 777 | m_pWMPPlayer->Release(); |
| 778 | wxLogSysError(wxT("Could not obtain settings from WMP10!")); |
| 779 | return false; |
| 780 | } |
| 781 | |
| 782 | if( m_pWMPPlayer->get_controls(&m_pWMPControls) != 0) |
| 783 | { |
| 784 | m_pWMPSettings->Release(); |
| 785 | m_pWMPPlayer->Release(); |
| 786 | wxLogSysError(wxT("Could not obtain controls from WMP10!")); |
| 787 | return false; |
| 788 | } |
| 789 | } |
| 790 | #endif |
| 791 | |
| 792 | // |
| 793 | // Create window |
| 794 | // By default wxWindow(s) is created with a border - |
| 795 | // so we need to get rid of those |
| 796 | // |
| 797 | // Since we don't have a child window like most other |
| 798 | // backends, we don't need wxCLIP_CHILDREN |
| 799 | // |
| 800 | if ( !ctrl->wxControl::Create(parent, id, pos, size, |
| 801 | (style & ~wxBORDER_MASK) | wxBORDER_NONE, |
| 802 | validator, name) ) |
| 803 | return false; |
| 804 | |
| 805 | // |
| 806 | // Now create the ActiveX container along with the media player |
| 807 | // interface and query them |
| 808 | // |
| 809 | m_ctrl = wxStaticCast(ctrl, wxMediaCtrl); |
| 810 | |
| 811 | #ifndef WXTEST_ATL |
| 812 | m_pAX = new wxActiveXContainer(ctrl, IID_IWMPPlayer, m_pWMPPlayer); |
| 813 | |
| 814 | // Connect for events |
| 815 | m_ctrl->PushEventHandler(new wxWMP10MediaEvtHandler(this)); |
| 816 | #else |
| 817 | _Module.Init(NULL, ::GetModuleHandle(NULL)); |
| 818 | AtlAxWinInit(); |
| 819 | CComPtr<IAxWinHostWindow> spHost; |
| 820 | |
| 821 | HRESULT hr; |
| 822 | RECT rcClient; |
| 823 | ::GetClientRect((HWND)ctrl->GetHandle(), &rcClient); |
| 824 | m_wndView.Create((HWND)ctrl->GetHandle(), rcClient, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN, WS_EX_CLIENTEDGE); |
| 825 | hr = m_wndView.QueryHost(&spHost); |
| 826 | hr = spHost->CreateControl(CComBSTR(_T("{6BF52A52-394A-11d3-B153-00C04F79FAA6}")), m_wndView, 0); |
| 827 | hr = m_wndView.QueryControl(&m_pWMPPlayer); |
| 828 | |
| 829 | if( m_pWMPPlayer->get_settings(&m_pWMPSettings) != 0) |
| 830 | { |
| 831 | m_pWMPPlayer->Release(); |
| 832 | wxLogSysError(wxT("Could not obtain settings from WMP10!")); |
| 833 | return false; |
| 834 | } |
| 835 | |
| 836 | if( m_pWMPPlayer->get_controls(&m_pWMPControls) != 0) |
| 837 | { |
| 838 | m_pWMPSettings->Release(); |
| 839 | m_pWMPPlayer->Release(); |
| 840 | wxLogSysError(wxT("Could not obtain controls from WMP10!")); |
| 841 | return false; |
| 842 | } |
| 843 | #endif |
| 844 | |
| 845 | // |
| 846 | // Here we set up wx-specific stuff for the default |
| 847 | // settings wxMediaCtrl says it will stay to |
| 848 | // |
| 849 | |
| 850 | IWMPPlayer2* pWMPPlayer2; // Only 2 has windowless video and stretchtofit |
| 851 | if(m_pWMPPlayer->QueryInterface(IID_IWMPPlayer2, (void**)&pWMPPlayer2) == 0) |
| 852 | { |
| 853 | // We don't check errors here as these arn't particularily important |
| 854 | // and may not be implemented (i.e. stretchToFit on CE) |
| 855 | pWMPPlayer2->put_windowlessVideo(VARIANT_TRUE); |
| 856 | pWMPPlayer2->put_stretchToFit(VARIANT_TRUE); |
| 857 | pWMPPlayer2->Release(); |
| 858 | } |
| 859 | |
| 860 | // by default true (see the "introduction") |
| 861 | m_pWMPSettings->put_autoStart(VARIANT_TRUE); |
| 862 | // by default enabled |
| 863 | wxWMP10MediaBackend::ShowPlayerControls(wxMEDIACTRLPLAYERCONTROLS_NONE); |
| 864 | // by default with AM only 0.5 |
| 865 | wxWMP10MediaBackend::SetVolume(1.0); |
| 866 | |
| 867 | // don't erase the background of our control window so that resizing is a |
| 868 | // bit smoother |
| 869 | m_ctrl->SetBackgroundStyle(wxBG_STYLE_CUSTOM); |
| 870 | |
| 871 | // success |
| 872 | return true; |
| 873 | } |
| 874 | |
| 875 | //--------------------------------------------------------------------------- |
| 876 | // wxWMP10MediaBackend::Load (file version) |
| 877 | //--------------------------------------------------------------------------- |
| 878 | bool wxWMP10MediaBackend::Load(const wxString& fileName) |
| 879 | { |
| 880 | return DoLoad(fileName); |
| 881 | } |
| 882 | |
| 883 | //--------------------------------------------------------------------------- |
| 884 | // wxWMP10MediaBackend::Load (URL Version) |
| 885 | //--------------------------------------------------------------------------- |
| 886 | bool wxWMP10MediaBackend::Load(const wxURI& location) |
| 887 | { |
| 888 | return DoLoad(location.BuildURI()); |
| 889 | } |
| 890 | |
| 891 | //--------------------------------------------------------------------------- |
| 892 | // wxWMP10MediaBackend::Load (URL Version with Proxy) |
| 893 | //--------------------------------------------------------------------------- |
| 894 | bool wxWMP10MediaBackend::Load(const wxURI& location, |
| 895 | const wxURI& proxy) |
| 896 | { |
| 897 | bool bOK = false; |
| 898 | |
| 899 | IWMPNetwork* pWMPNetwork; |
| 900 | if( m_pWMPPlayer->get_network(&pWMPNetwork) == 0 ) |
| 901 | { |
| 902 | long lOldSetting; |
| 903 | if( pWMPNetwork->getProxySettings( |
| 904 | wxBasicString(location.GetScheme()).Get(), &lOldSetting |
| 905 | ) == 0 && |
| 906 | |
| 907 | pWMPNetwork->setProxySettings( |
| 908 | wxBasicString(location.GetScheme()).Get(), // protocol |
| 909 | 2) == 0) // 2 == manually specify |
| 910 | { |
| 911 | BSTR bsOldName = NULL; |
| 912 | long lOldPort = 0; |
| 913 | |
| 914 | pWMPNetwork->getProxyName( |
| 915 | wxBasicString(location.GetScheme()).Get(), |
| 916 | &bsOldName); |
| 917 | pWMPNetwork->getProxyPort( |
| 918 | wxBasicString(location.GetScheme()).Get(), |
| 919 | &lOldPort); |
| 920 | |
| 921 | long lPort; |
| 922 | wxString server; |
| 923 | if(proxy.IsReference()) |
| 924 | { |
| 925 | server = proxy.GetScheme(); |
| 926 | lPort = wxAtoi(proxy.GetPath()); |
| 927 | } |
| 928 | else |
| 929 | { |
| 930 | server = proxy.GetServer(); |
| 931 | lPort = wxAtoi(proxy.GetPort()); |
| 932 | } |
| 933 | |
| 934 | if( pWMPNetwork->setProxyName( |
| 935 | wxBasicString(location.GetScheme()).Get(), // proto |
| 936 | wxBasicString(server).Get() ) == 0 && |
| 937 | |
| 938 | pWMPNetwork->setProxyPort( |
| 939 | wxBasicString(location.GetScheme()).Get(), // proto |
| 940 | lPort |
| 941 | ) == 0 |
| 942 | ) |
| 943 | { |
| 944 | bOK = DoLoad(location.BuildURI()); |
| 945 | |
| 946 | pWMPNetwork->setProxySettings( |
| 947 | wxBasicString(location.GetScheme()).Get(), // protocol |
| 948 | lOldSetting); |
| 949 | if(bsOldName) |
| 950 | pWMPNetwork->setProxyName( |
| 951 | wxBasicString(location.GetScheme()).Get(), // protocol |
| 952 | bsOldName); |
| 953 | |
| 954 | if(lOldPort) |
| 955 | pWMPNetwork->setProxyPort( |
| 956 | wxBasicString(location.GetScheme()).Get(), // protocol |
| 957 | lOldPort); |
| 958 | |
| 959 | pWMPNetwork->Release(); |
| 960 | } |
| 961 | else |
| 962 | pWMPNetwork->Release(); |
| 963 | |
| 964 | } |
| 965 | else |
| 966 | pWMPNetwork->Release(); |
| 967 | |
| 968 | } |
| 969 | |
| 970 | return bOK; |
| 971 | } |
| 972 | |
| 973 | //--------------------------------------------------------------------------- |
| 974 | // wxWMP10MediaBackend::DoLoad |
| 975 | // |
| 976 | // Called by all functions - this actually renders |
| 977 | // the file and sets up the filter graph |
| 978 | //--------------------------------------------------------------------------- |
| 979 | bool wxWMP10MediaBackend::DoLoad(const wxString& location) |
| 980 | { |
| 981 | HRESULT hr; |
| 982 | |
| 983 | #if 0 // See the "introduction" - this is the duration hack |
| 984 | // ------------------ BLATENT HACK ALERT ------------------------- |
| 985 | // Normally we can only get the duration of things already in an |
| 986 | // existing playlist or playing - however this clever "workaround" |
| 987 | // enables us to get the duration even when stopped :) |
| 988 | // http://weblogs.asp.net/rweigelt/archive/2003/07/02/9613.aspx |
| 989 | |
| 990 | IWMPCore3* pWMPCore3; |
| 991 | double outDuration; |
| 992 | if(m_pWMPPlayer->QueryInterface(IID_IWMPCore3, (void**) &pWMPCore3) == 0) |
| 993 | { |
| 994 | IWMPMedia* pWMPMedia; |
| 995 | |
| 996 | if( (hr = pWMPCore3->newMedia(wxBasicString(location).Get(), |
| 997 | &pWMPMedia)) == 0) |
| 998 | { |
| 999 | // this (get_duration) will actually FAIL, but it will work. |
| 1000 | pWMPMedia->get_duration(&outDuration); |
| 1001 | pWMPCore3->put_currentMedia(pWMPMedia); |
| 1002 | pWMPMedia->Release(); |
| 1003 | } |
| 1004 | |
| 1005 | pWMPCore3->Release(); |
| 1006 | } |
| 1007 | else |
| 1008 | #endif |
| 1009 | { |
| 1010 | // just load it the "normal" way |
| 1011 | hr = m_pWMPPlayer->put_URL( wxBasicString(location).Get() ); |
| 1012 | } |
| 1013 | |
| 1014 | if(FAILED(hr)) |
| 1015 | { |
| 1016 | wxWMP10LOG(hr); |
| 1017 | return false; |
| 1018 | } |
| 1019 | |
| 1020 | return true; |
| 1021 | } |
| 1022 | |
| 1023 | //--------------------------------------------------------------------------- |
| 1024 | // wxWMP10MediaBackend::FinishLoad |
| 1025 | // |
| 1026 | // Called when our media is about to play (a.k.a. wmposMediaOpen) |
| 1027 | //--------------------------------------------------------------------------- |
| 1028 | void wxWMP10MediaBackend::FinishLoad() |
| 1029 | { |
| 1030 | // Get the original video size |
| 1031 | // THIS WILL NOT WORK UNLESS THE MEDIA IS ABOUT TO PLAY |
| 1032 | // See the "introduction" - also get_currentMedia will return |
| 1033 | // "1" which is a VALID HRESULT value |
| 1034 | // and a NULL pWMPMedia if the media isn't the "current" one |
| 1035 | // which is rather unintuitive in the sense that it uses it |
| 1036 | // (i.e. basically not currently playing)... |
| 1037 | IWMPMedia* pWMPMedia; |
| 1038 | if(m_pWMPPlayer->get_currentMedia(&pWMPMedia) == 0) |
| 1039 | { |
| 1040 | pWMPMedia->get_imageSourceWidth((long*)&m_bestSize.x); |
| 1041 | pWMPMedia->get_imageSourceHeight((long*)&m_bestSize.y); |
| 1042 | pWMPMedia->Release(); |
| 1043 | } |
| 1044 | else |
| 1045 | { |
| 1046 | wxLogDebug(wxT("Could not get media")); |
| 1047 | } |
| 1048 | |
| 1049 | NotifyMovieLoaded(); |
| 1050 | } |
| 1051 | |
| 1052 | //--------------------------------------------------------------------------- |
| 1053 | // wxWMP10MediaBackend::ShowPlayerControls |
| 1054 | //--------------------------------------------------------------------------- |
| 1055 | bool wxWMP10MediaBackend::ShowPlayerControls(wxMediaCtrlPlayerControls flags) |
| 1056 | { |
| 1057 | if(!flags) |
| 1058 | { |
| 1059 | m_pWMPPlayer->put_enabled(VARIANT_FALSE); |
| 1060 | m_pWMPPlayer->put_uiMode(wxBasicString(wxT("none")).Get()); |
| 1061 | } |
| 1062 | else |
| 1063 | { |
| 1064 | // TODO: use "custom"? (note that CE only supports none/full) |
| 1065 | m_pWMPPlayer->put_uiMode(wxBasicString(wxT("full")).Get()); |
| 1066 | m_pWMPPlayer->put_enabled(VARIANT_TRUE); |
| 1067 | } |
| 1068 | |
| 1069 | return true; |
| 1070 | } |
| 1071 | |
| 1072 | //--------------------------------------------------------------------------- |
| 1073 | // wxWMP10MediaBackend::Play |
| 1074 | // |
| 1075 | // Plays the stream. If it is non-seekable, it will restart it (implicit). |
| 1076 | // |
| 1077 | // TODO: We use SUCCEEDED due to pickiness on IMediaPlayer are doing it here |
| 1078 | // but do we need to? |
| 1079 | //--------------------------------------------------------------------------- |
| 1080 | bool wxWMP10MediaBackend::Play() |
| 1081 | { |
| 1082 | // Actually try to play the movie (will fail if not loaded completely) |
| 1083 | HRESULT hr = m_pWMPControls->play(); |
| 1084 | if(SUCCEEDED(hr)) |
| 1085 | { |
| 1086 | m_bWasStateChanged = true; |
| 1087 | return true; |
| 1088 | } |
| 1089 | wxWMP10LOG(hr); |
| 1090 | return false; |
| 1091 | } |
| 1092 | |
| 1093 | //--------------------------------------------------------------------------- |
| 1094 | // wxWMP10MediaBackend::Pause |
| 1095 | // |
| 1096 | // Pauses the stream. |
| 1097 | //--------------------------------------------------------------------------- |
| 1098 | bool wxWMP10MediaBackend::Pause() |
| 1099 | { |
| 1100 | HRESULT hr = m_pWMPControls->pause(); |
| 1101 | if(SUCCEEDED(hr)) |
| 1102 | { |
| 1103 | m_bWasStateChanged = true; |
| 1104 | return true; |
| 1105 | } |
| 1106 | wxWMP10LOG(hr); |
| 1107 | return false; |
| 1108 | } |
| 1109 | |
| 1110 | //--------------------------------------------------------------------------- |
| 1111 | // wxWMP10MediaBackend::Stop |
| 1112 | // |
| 1113 | // Stops the stream. |
| 1114 | //--------------------------------------------------------------------------- |
| 1115 | bool wxWMP10MediaBackend::Stop() |
| 1116 | { |
| 1117 | HRESULT hr = m_pWMPControls->stop(); |
| 1118 | if(SUCCEEDED(hr)) |
| 1119 | { |
| 1120 | // Seek to beginning |
| 1121 | wxWMP10MediaBackend::SetPosition(0); |
| 1122 | m_bWasStateChanged = true; |
| 1123 | return true; |
| 1124 | } |
| 1125 | wxWMP10LOG(hr); |
| 1126 | return false; |
| 1127 | } |
| 1128 | |
| 1129 | //--------------------------------------------------------------------------- |
| 1130 | // wxWMP10MediaBackend::SetPosition |
| 1131 | // |
| 1132 | // WMP10 position values are a double in seconds - we just translate |
| 1133 | // to our base here |
| 1134 | //--------------------------------------------------------------------------- |
| 1135 | bool wxWMP10MediaBackend::SetPosition(wxLongLong where) |
| 1136 | { |
| 1137 | HRESULT hr = m_pWMPControls->put_currentPosition( |
| 1138 | ((LONGLONG)where.GetValue()) / 1000.0 |
| 1139 | ); |
| 1140 | if(FAILED(hr)) |
| 1141 | { |
| 1142 | wxWMP10LOG(hr); |
| 1143 | return false; |
| 1144 | } |
| 1145 | |
| 1146 | return true; |
| 1147 | } |
| 1148 | |
| 1149 | //--------------------------------------------------------------------------- |
| 1150 | // wxWMP10MediaBackend::GetPosition |
| 1151 | // |
| 1152 | // WMP10 position values are a double in seconds - we just translate |
| 1153 | // to our base here |
| 1154 | //--------------------------------------------------------------------------- |
| 1155 | wxLongLong wxWMP10MediaBackend::GetPosition() |
| 1156 | { |
| 1157 | double outCur; |
| 1158 | HRESULT hr = m_pWMPControls->get_currentPosition(&outCur); |
| 1159 | if(FAILED(hr)) |
| 1160 | { |
| 1161 | wxWMP10LOG(hr); |
| 1162 | return 0; |
| 1163 | } |
| 1164 | |
| 1165 | // h,m,s,milli - outCur is in 1 second (double) |
| 1166 | outCur *= 1000; |
| 1167 | wxLongLong ll; |
| 1168 | ll.Assign(outCur); |
| 1169 | |
| 1170 | return ll; |
| 1171 | } |
| 1172 | |
| 1173 | //--------------------------------------------------------------------------- |
| 1174 | // wxWMP10MediaBackend::GetVolume |
| 1175 | // |
| 1176 | // Volume 0-100 |
| 1177 | //--------------------------------------------------------------------------- |
| 1178 | double wxWMP10MediaBackend::GetVolume() |
| 1179 | { |
| 1180 | long lVolume; |
| 1181 | HRESULT hr = m_pWMPSettings->get_volume(&lVolume); |
| 1182 | if(FAILED(hr)) |
| 1183 | { |
| 1184 | wxWMP10LOG(hr); |
| 1185 | return 0.0; |
| 1186 | } |
| 1187 | |
| 1188 | return (double)lVolume / 100.0; |
| 1189 | } |
| 1190 | |
| 1191 | //--------------------------------------------------------------------------- |
| 1192 | // wxWMP10MediaBackend::SetVolume |
| 1193 | // |
| 1194 | // Volume 0-100 |
| 1195 | //--------------------------------------------------------------------------- |
| 1196 | bool wxWMP10MediaBackend::SetVolume(double dVolume) |
| 1197 | { |
| 1198 | HRESULT hr = m_pWMPSettings->put_volume( (long) (dVolume * 100.0) ); |
| 1199 | if(FAILED(hr)) |
| 1200 | { |
| 1201 | wxWMP10LOG(hr); |
| 1202 | return false; |
| 1203 | } |
| 1204 | return true; |
| 1205 | } |
| 1206 | |
| 1207 | //--------------------------------------------------------------------------- |
| 1208 | // wxWMP10MediaBackend::GetDuration |
| 1209 | // |
| 1210 | // Obtains the duration of the media. |
| 1211 | // |
| 1212 | // See the "introduction" |
| 1213 | // |
| 1214 | // The good news is that this doesn't appear to have the XING header |
| 1215 | // parser problem that WMP6 SDK/IActiveMovie/IMediaPlayer/IWMP has |
| 1216 | //--------------------------------------------------------------------------- |
| 1217 | wxLongLong wxWMP10MediaBackend::GetDuration() |
| 1218 | { |
| 1219 | double outDuration = 0.0; |
| 1220 | |
| 1221 | IWMPMedia* pWMPMedia; |
| 1222 | if(m_pWMPPlayer->get_currentMedia(&pWMPMedia) == 0) |
| 1223 | { |
| 1224 | if(pWMPMedia->get_duration(&outDuration) != 0) |
| 1225 | { |
| 1226 | wxLogDebug(wxT("get_duration failed")); |
| 1227 | } |
| 1228 | pWMPMedia->Release(); |
| 1229 | } |
| 1230 | |
| 1231 | |
| 1232 | // h,m,s,milli - outDuration is in 1 second (double) |
| 1233 | outDuration *= 1000; |
| 1234 | wxLongLong ll; |
| 1235 | ll.Assign(outDuration); |
| 1236 | |
| 1237 | return ll; |
| 1238 | } |
| 1239 | |
| 1240 | //--------------------------------------------------------------------------- |
| 1241 | // wxWMP10MediaBackend::GetState |
| 1242 | // |
| 1243 | // Returns the current state |
| 1244 | //--------------------------------------------------------------------------- |
| 1245 | wxMediaState wxWMP10MediaBackend::GetState() |
| 1246 | { |
| 1247 | WMPPlayState nState; |
| 1248 | HRESULT hr = m_pWMPPlayer->get_playState(&nState); |
| 1249 | if(FAILED(hr)) |
| 1250 | { |
| 1251 | wxWMP10LOG(hr); |
| 1252 | return wxMEDIASTATE_STOPPED; |
| 1253 | } |
| 1254 | |
| 1255 | switch(nState) |
| 1256 | { |
| 1257 | case wmppsPaused: |
| 1258 | return wxMEDIASTATE_PAUSED; |
| 1259 | case wmppsPlaying: |
| 1260 | return wxMEDIASTATE_PLAYING; |
| 1261 | default: |
| 1262 | return wxMEDIASTATE_STOPPED; |
| 1263 | } |
| 1264 | } |
| 1265 | |
| 1266 | //--------------------------------------------------------------------------- |
| 1267 | // wxWMP10MediaBackend::GetPlaybackRate |
| 1268 | // |
| 1269 | // Just get the rate from WMP10 |
| 1270 | //--------------------------------------------------------------------------- |
| 1271 | double wxWMP10MediaBackend::GetPlaybackRate() |
| 1272 | { |
| 1273 | double dRate; |
| 1274 | HRESULT hr = m_pWMPSettings->get_rate(&dRate); |
| 1275 | if(FAILED(hr)) |
| 1276 | { |
| 1277 | wxWMP10LOG(hr); |
| 1278 | return 0.0; |
| 1279 | } |
| 1280 | return dRate; |
| 1281 | } |
| 1282 | |
| 1283 | //--------------------------------------------------------------------------- |
| 1284 | // wxWMP10MediaBackend::SetPlaybackRate |
| 1285 | // |
| 1286 | // Sets the playback rate of the media - DirectShow is pretty good |
| 1287 | // about this, actually |
| 1288 | //--------------------------------------------------------------------------- |
| 1289 | bool wxWMP10MediaBackend::SetPlaybackRate(double dRate) |
| 1290 | { |
| 1291 | HRESULT hr = m_pWMPSettings->put_rate(dRate); |
| 1292 | if(FAILED(hr)) |
| 1293 | { |
| 1294 | wxWMP10LOG(hr); |
| 1295 | return false; |
| 1296 | } |
| 1297 | |
| 1298 | return true; |
| 1299 | } |
| 1300 | |
| 1301 | //--------------------------------------------------------------------------- |
| 1302 | // wxWMP10MediaBackend::GetVideoSize |
| 1303 | // |
| 1304 | // Obtains the cached original video size |
| 1305 | //--------------------------------------------------------------------------- |
| 1306 | wxSize wxWMP10MediaBackend::GetVideoSize() const |
| 1307 | { |
| 1308 | return m_bestSize; |
| 1309 | } |
| 1310 | |
| 1311 | //--------------------------------------------------------------------------- |
| 1312 | // wxWMP10MediaBackend::Move |
| 1313 | // |
| 1314 | // We take care of this in our redrawing |
| 1315 | //--------------------------------------------------------------------------- |
| 1316 | void wxWMP10MediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y), |
| 1317 | #ifdef WXTEST_ATL |
| 1318 | int w, int h |
| 1319 | #else |
| 1320 | int WXUNUSED(w), int WXUNUSED(h) |
| 1321 | #endif |
| 1322 | ) |
| 1323 | { |
| 1324 | #ifdef WXTEST_ATL |
| 1325 | m_wndView.MoveWindow(0,0,w,h); |
| 1326 | #endif |
| 1327 | } |
| 1328 | |
| 1329 | //--------------------------------------------------------------------------- |
| 1330 | // wxWMP10MediaBackend::GetDownloadProgress() |
| 1331 | //--------------------------------------------------------------------------- |
| 1332 | wxLongLong wxWMP10MediaBackend::GetDownloadProgress() |
| 1333 | { |
| 1334 | IWMPNetwork* pWMPNetwork; |
| 1335 | if( m_pWMPPlayer->get_network(&pWMPNetwork) == 0 ) |
| 1336 | { |
| 1337 | long lPercentProg; |
| 1338 | if(pWMPNetwork->get_downloadProgress(&lPercentProg) == 0) |
| 1339 | { |
| 1340 | pWMPNetwork->Release(); |
| 1341 | return (GetDownloadTotal() * lPercentProg) / 100; |
| 1342 | } |
| 1343 | pWMPNetwork->Release(); |
| 1344 | } |
| 1345 | return 0; |
| 1346 | } |
| 1347 | |
| 1348 | //--------------------------------------------------------------------------- |
| 1349 | // wxWMP10MediaBackend::GetDownloadTotal() |
| 1350 | //--------------------------------------------------------------------------- |
| 1351 | wxLongLong wxWMP10MediaBackend::GetDownloadTotal() |
| 1352 | { |
| 1353 | IWMPMedia* pWMPMedia; |
| 1354 | if(m_pWMPPlayer->get_currentMedia(&pWMPMedia) == 0) |
| 1355 | { |
| 1356 | BSTR bsOut; |
| 1357 | pWMPMedia->getItemInfo(wxBasicString(wxT("FileSize")).Get(), |
| 1358 | &bsOut); |
| 1359 | |
| 1360 | wxString sFileSize = wxConvertStringFromOle(bsOut); |
| 1361 | long lFS; |
| 1362 | sFileSize.ToLong(&lFS); |
| 1363 | pWMPMedia->Release(); |
| 1364 | return lFS; |
| 1365 | } |
| 1366 | |
| 1367 | return 0; |
| 1368 | } |
| 1369 | |
| 1370 | |
| 1371 | //--------------------------------------------------------------------------- |
| 1372 | // wxWMP10MediaBackend::OnActiveX |
| 1373 | // |
| 1374 | // Handle events sent from our activex control (_WMPOCXEvents actually). |
| 1375 | // |
| 1376 | // The weird numbers in the switch statement here are "dispatch ids" |
| 1377 | // (the numbers in the id field like ( id(xxx) ) ) from amcompat.idl |
| 1378 | // and wmp.IDL. |
| 1379 | //--------------------------------------------------------------------------- |
| 1380 | #ifndef WXTEST_ATL |
| 1381 | void wxWMP10MediaEvtHandler::OnActiveX(wxActiveXEvent& event) |
| 1382 | { |
| 1383 | switch(event.GetDispatchId()) |
| 1384 | { |
| 1385 | case 0x000013ed: // playstatechange |
| 1386 | if(event.ParamCount() >= 1) |
| 1387 | { |
| 1388 | switch (event[0].GetInteger()) |
| 1389 | { |
| 1390 | case wmppsMediaEnded: // media ended |
| 1391 | if ( m_amb->SendStopEvent() ) |
| 1392 | { |
| 1393 | // NB: If we do Stop() or similar here the media |
| 1394 | // actually starts over and plays a bit before |
| 1395 | // stopping. It stops by default, however, so |
| 1396 | // there is no real need to do anything here... |
| 1397 | |
| 1398 | // send the event to our child |
| 1399 | m_amb->QueueFinishEvent(); |
| 1400 | } |
| 1401 | break; |
| 1402 | |
| 1403 | case wmppsStopped: // stopping |
| 1404 | m_amb->QueueStopEvent(); |
| 1405 | break; |
| 1406 | case wmppsPaused: // pause |
| 1407 | m_amb->QueuePauseEvent(); |
| 1408 | break; |
| 1409 | case wmppsPlaying: // play |
| 1410 | m_amb->QueuePlayEvent(); |
| 1411 | break; |
| 1412 | default: |
| 1413 | break; |
| 1414 | } |
| 1415 | } |
| 1416 | else |
| 1417 | event.Skip(); |
| 1418 | break; |
| 1419 | |
| 1420 | case 0x00001389: // openstatechange |
| 1421 | if(event.ParamCount() >= 1) |
| 1422 | { |
| 1423 | int nState = event[0].GetInteger(); |
| 1424 | if(nState == wmposMediaOpen) |
| 1425 | { |
| 1426 | // See the "introduction" |
| 1427 | m_amb->m_bWasStateChanged = false; |
| 1428 | m_amb->FinishLoad(); |
| 1429 | if(!m_amb->m_bWasStateChanged) |
| 1430 | m_amb->Stop(); |
| 1431 | } |
| 1432 | } |
| 1433 | else |
| 1434 | event.Skip(); |
| 1435 | break; |
| 1436 | |
| 1437 | case 0x0000196e: // mousedown |
| 1438 | m_amb->m_ctrl->SetFocus(); |
| 1439 | break; |
| 1440 | |
| 1441 | default: |
| 1442 | event.Skip(); |
| 1443 | return; |
| 1444 | } |
| 1445 | } |
| 1446 | |
| 1447 | #endif |
| 1448 | // in source file that contains stuff you don't directly use |
| 1449 | #include "wx/html/forcelnk.h" |
| 1450 | FORCE_LINK_ME(wxmediabackend_wmp10) |
| 1451 | |
| 1452 | #if 0 // Windows Media Player Mobile 9 hacks |
| 1453 | |
| 1454 | //------------------WMP Mobile 9 hacks----------------------------------- |
| 1455 | // It was mentioned in the introduction that while there was no official |
| 1456 | // programming interface on WMP mobile 9 |
| 1457 | // (SmartPhone/Pocket PC 2003 emulator etc.) |
| 1458 | // there were some windows message hacks that are able to get |
| 1459 | // you playing a file through WMP. |
| 1460 | // |
| 1461 | // Here are those hacks. They do indeed "work" as expected - just call |
| 1462 | // SendMessage with one of those myterious values layed out in |
| 1463 | // Peter Foot's Friday, May 21, 2004 Blog Post on the issue. |
| 1464 | // (He says they are in a registery section entitled "Pendant Bus") |
| 1465 | // |
| 1466 | // How do you play a certain file? Simply calling "start [file]" or |
| 1467 | // wxWinCEExecute([file]) should do the trick |
| 1468 | |
| 1469 | bool wxWinCEExecute(const wxString& path, int nShowStyle = SW_SHOWNORMAL) |
| 1470 | { |
| 1471 | WinStruct<SHELLEXECUTEINFO> sei; |
| 1472 | sei.lpFile = path.c_str(); |
| 1473 | sei.lpVerb = _T("open"); |
| 1474 | sei.nShow = nShowStyle; |
| 1475 | |
| 1476 | ::ShellExecuteEx(&sei); |
| 1477 | |
| 1478 | return ((int) sei.hInstApp) > 32; |
| 1479 | } |
| 1480 | |
| 1481 | bool MyApp::OnInit() |
| 1482 | { |
| 1483 | HWND hwnd = ::FindWindow(TEXT("WMP for Mobile Devices"), TEXT("Windows Media")); |
| 1484 | if(!hwnd) |
| 1485 | { |
| 1486 | if( wxWinCEExecute(wxT("\\Windows\\wmplayer.exe"), SW_MINIMIZE) ) |
| 1487 | { |
| 1488 | hwnd = ::FindWindow(TEXT("WMP for Mobile Devices"), TEXT("Windows Media")); |
| 1489 | } |
| 1490 | } |
| 1491 | |
| 1492 | if(hwnd) |
| 1493 | { |
| 1494 | // hide wmp window |
| 1495 | ::SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, 0, 0, |
| 1496 | SWP_NOMOVE|SWP_NOSIZE|SWP_HIDEWINDOW); |
| 1497 | |
| 1498 | // Stop == 32970 |
| 1499 | // Prev Track == 32971 |
| 1500 | // Next Track == 32972 |
| 1501 | // Shuffle == 32973 |
| 1502 | // Repeat == 32974 |
| 1503 | // Vol Up == 32975 |
| 1504 | // Vol Down == 32976 |
| 1505 | // Play == 32978 |
| 1506 | ::SendMessage(hwnd, 32978, NULL, 0); |
| 1507 | } |
| 1508 | } |
| 1509 | |
| 1510 | #endif // WMP mobile 9 hacks |
| 1511 | |
| 1512 | #endif // wxUSE_MEDIACTRL && wxUSE_ACTIVEX |