]>
Commit | Line | Data |
---|---|---|
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 |