From 226ec5a71a9b3f82591c0d1557ce1639a8f615d1 Mon Sep 17 00:00:00 2001 From: =?utf8?q?W=C5=82odzimierz=20Skiba?= Date: Tue, 16 Nov 2004 13:49:27 +0000 Subject: [PATCH] Define wxMediaEvent before it is used. Make OnMediaFinish compatible to wxObjectEventFunction. Warning fix. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@30568 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- include/wx/mediactrl.h | 150 ++++++++-------- samples/mediaplayer/mediaplayer.cpp | 94 +++++----- src/common/mediactrlcmn.cpp | 36 ++-- src/msw/mediactrl.cpp | 258 ++++++++++++++-------------- 4 files changed, 269 insertions(+), 269 deletions(-) diff --git a/include/wx/mediactrl.h b/include/wx/mediactrl.h index fec8e979c5..54b0573eac 100644 --- a/include/wx/mediactrl.h +++ b/include/wx/mediactrl.h @@ -2,7 +2,7 @@ // Name: wx/mediactrl.h // Purpose: wxMediaCtrl class // Author: Ryan Norton -// Modified by: +// Modified by: // Created: 11/07/04 // RCS-ID: $Id$ // Copyright: (c) Ryan Norton @@ -64,6 +64,47 @@ enum wxMediaTimeFormat #define wxMEDIABACKEND_MCI wxT("wxMCIMediaBackend") #define wxMEDIABACKEND_QUICKTIME wxT("wxQTMediaBackend") +// ---------------------------------------------------------------------------- +// +// wxMediaEvent +// +// ---------------------------------------------------------------------------- + +class WXDLLEXPORT wxMediaEvent : public wxNotifyEvent +{ +public: + // ------------------------------------------------------------------------ + // wxMediaEvent Constructor + // + // Normal constructor, much the same as wxNotifyEvent + // ------------------------------------------------------------------------ + wxMediaEvent(wxEventType commandType = wxEVT_NULL, int id = 0) + : wxNotifyEvent(commandType, id) + { } + + // ------------------------------------------------------------------------ + // wxMediaEvent Copy Constructor + // + // Normal copy constructor, much the same as wxNotifyEvent + // ------------------------------------------------------------------------ + wxMediaEvent(const wxMediaEvent &clone) + : wxNotifyEvent(clone) + { } + + // ------------------------------------------------------------------------ + // wxMediaEvent::Clone + // + // Allocates a copy of this object. + // Required for wxEvtHandler::AddPendingEvent + // ------------------------------------------------------------------------ + virtual wxEvent *Clone() const + { return new wxMediaEvent(*this); } + + + // Put this class on wxWidget's RTTI table + DECLARE_DYNAMIC_CLASS(wxMediaEvent) +}; + // ---------------------------------------------------------------------------- // // wxMediaCtrl @@ -76,55 +117,55 @@ public: wxMediaCtrl() : m_imp(NULL), m_bLoaded(false), m_bLoop(false) { } - wxMediaCtrl(wxWindow* parent, wxWindowID id, + wxMediaCtrl(wxWindow* parent, wxWindowID id, const wxString& fileName = wxT(""), - const wxPoint& pos = wxDefaultPosition, + const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, - long style = 0, + long style = 0, const wxString& szBackend = wxT(""), const wxValidator& validator = wxDefaultValidator, const wxString& name = wxT("mediaCtrl")) : m_imp(NULL), m_bLoaded(false), m_bLoop(false) - { Create(parent, id, fileName, pos, size, style, + { Create(parent, id, fileName, pos, size, style, szBackend, validator, name); } - wxMediaCtrl(wxWindow* parent, wxWindowID id, + wxMediaCtrl(wxWindow* parent, wxWindowID id, const wxURI& location, - const wxPoint& pos = wxDefaultPosition, + const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, - long style = 0, + long style = 0, const wxString& szBackend = wxT(""), const wxValidator& validator = wxDefaultValidator, const wxString& name = wxT("mediaCtrl")) : m_imp(NULL), m_bLoop(false) - { Create(parent, id, location, pos, size, style, + { Create(parent, id, location, pos, size, style, szBackend, validator, name); } ~wxMediaCtrl(); bool Create(wxWindow* parent, wxWindowID id, const wxString& fileName = wxT(""), - const wxPoint& pos = wxDefaultPosition, + const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, - long style = 0, + long style = 0, const wxString& szBackend = wxT(""), const wxValidator& validator = wxDefaultValidator, const wxString& name = wxT("mediaCtrl")); bool Create(wxWindow* parent, wxWindowID id, const wxURI& location, - const wxPoint& pos = wxDefaultPosition, + const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, - long style = 0, + long style = 0, const wxString& szBackend = wxT(""), const wxValidator& validator = wxDefaultValidator, const wxString& name = wxT("mediaCtrl")); bool DoCreate(wxClassInfo* instance, wxWindow* parent, wxWindowID id, - const wxPoint& pos = wxDefaultPosition, + const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, - long style = 0, + long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = wxT("mediaCtrl")); @@ -151,7 +192,7 @@ public: wxLongLong GetDuration(); protected: - void OnMediaFinished(const class wxMediaEvent& evt); + void OnMediaFinished(wxMediaEvent& evt); virtual void DoMoveWindow(int x, int y, int w, int h); wxSize DoGetBestSize() const; @@ -178,44 +219,44 @@ public: virtual ~wxMediaBackend(); - virtual bool CreateControl(wxControl* WXUNUSED(ctrl), - wxWindow* WXUNUSED(parent), - wxWindowID WXUNUSED(id), - const wxPoint& WXUNUSED(pos), + virtual bool CreateControl(wxControl* WXUNUSED(ctrl), + wxWindow* WXUNUSED(parent), + wxWindowID WXUNUSED(id), + const wxPoint& WXUNUSED(pos), const wxSize& WXUNUSED(size), - long WXUNUSED(style), + long WXUNUSED(style), const wxValidator& WXUNUSED(validator), const wxString& WXUNUSED(name)) { return false; } - virtual bool Play() + virtual bool Play() { return false; } - virtual bool Pause() + virtual bool Pause() { return false; } - virtual bool Stop() + virtual bool Stop() { return false; } - virtual bool Load(const wxString& WXUNUSED(fileName)) + virtual bool Load(const wxString& WXUNUSED(fileName)) { return false; } - virtual bool Load(const wxURI& WXUNUSED(location)) + virtual bool Load(const wxURI& WXUNUSED(location)) { return false; } - virtual bool SetPosition(wxLongLong WXUNUSED(where)) + virtual bool SetPosition(wxLongLong WXUNUSED(where)) { return 0; } - virtual wxLongLong GetPosition() + virtual wxLongLong GetPosition() { return 0; } - virtual wxLongLong GetDuration() + virtual wxLongLong GetDuration() { return 0; } - virtual void Move(int WXUNUSED(x), int WXUNUSED(y), - int WXUNUSED(w), int WXUNUSED(h)) + virtual void Move(int WXUNUSED(x), int WXUNUSED(y), + int WXUNUSED(w), int WXUNUSED(h)) { } - virtual wxSize GetVideoSize() const + virtual wxSize GetVideoSize() const { return wxSize(0,0); } - virtual double GetPlaybackRate() + virtual double GetPlaybackRate() { return 0.0; } - virtual bool SetPlaybackRate(double WXUNUSED(dRate)) + virtual bool SetPlaybackRate(double WXUNUSED(dRate)) { return false; } virtual wxMediaState GetState() @@ -224,47 +265,6 @@ public: DECLARE_CLASS(wxMediaBackend) }; -// ---------------------------------------------------------------------------- -// -// wxMediaEvent -// -// ---------------------------------------------------------------------------- - -class WXDLLEXPORT wxMediaEvent : public wxNotifyEvent -{ -public: - // ------------------------------------------------------------------------ - // wxMediaEvent Constructor - // - // Normal constructor, much the same as wxNotifyEvent - // ------------------------------------------------------------------------ - wxMediaEvent(wxEventType commandType = wxEVT_NULL, int id = 0) - : wxNotifyEvent(commandType, id) - { } - - // ------------------------------------------------------------------------ - // wxMediaEvent Copy Constructor - // - // Normal copy constructor, much the same as wxNotifyEvent - // ------------------------------------------------------------------------ - wxMediaEvent(const wxMediaEvent &clone) - : wxNotifyEvent(clone) - { } - - // ------------------------------------------------------------------------ - // wxMediaEvent::Clone - // - // Allocates a copy of this object. - // Required for wxEvtHandler::AddPendingEvent - // ------------------------------------------------------------------------ - virtual wxEvent *Clone() const - { return new wxMediaEvent(*this); } - - - // Put this class on wxWidget's RTTI table - DECLARE_DYNAMIC_CLASS(wxMediaEvent) -}; - //Event ID to give to our events #define wxMEDIA_FINISHED_ID 13000 #define wxMEDIA_STOP_ID 13001 diff --git a/samples/mediaplayer/mediaplayer.cpp b/samples/mediaplayer/mediaplayer.cpp index c7f1b38a07..87561fd4f9 100644 --- a/samples/mediaplayer/mediaplayer.cpp +++ b/samples/mediaplayer/mediaplayer.cpp @@ -12,7 +12,7 @@ // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // MediaPlayer // -// This is a simple example of how to use all the funtionality of +// This is a simple example of how to use all the funtionality of // the wxMediaCtrl class in wxWidgets. // // To use this sample, simply select Open File from the file menu, @@ -53,7 +53,7 @@ #include "wx/textdlg.h" //for getting user text from OpenURL // ---------------------------------------------------------------------------- -// Bail out if the user doesn't want one of the +// Bail out if the user doesn't want one of the // things we need // ---------------------------------------------------------------------------- @@ -207,7 +207,7 @@ const wxChar* wxGetMediaStateText(int nState) // the wxApp exists, and thus will crash the application if you try it. // // IMPLEMENT_APP does this, and also implements the platform-specific entry -// routine, such as main or WinMain(). Use IMPLEMENT_APP_NO_MAIN if you do +// routine, such as main or WinMain(). Use IMPLEMENT_APP_NO_MAIN if you do // not desire this behavior. // ---------------------------------------------------------------------------- IMPLEMENT_APP(MyApp) @@ -253,8 +253,8 @@ MyFrame::MyFrame(const wxString& title) wxMenu *menuFile = new wxMenu; wxMenu *helpMenu = new wxMenu; - helpMenu->Append(wxID_ABOUT, - _T("&About...\tF1"), + helpMenu->Append(wxID_ABOUT, + _T("&About...\tF1"), _T("Show about dialog")); menuFile->Append(wxID_OPENFILE, _T("&Open File"), _T("Open a File")); @@ -263,12 +263,12 @@ MyFrame::MyFrame(const wxString& title) menuFile->Append(wxID_PAUSE, _T("P&ause"), _T("Pause playback")); menuFile->Append(wxID_STOP, _T("&Stop"), _T("Stop playback")); menuFile->AppendSeparator(); - menuFile->AppendCheckItem(wxID_LOOP, - _T("&Loop"), + menuFile->AppendCheckItem(wxID_LOOP, + _T("&Loop"), _T("Loop Selected Media")); menuFile->AppendSeparator(); - menuFile->Append(wxID_EXIT, - _T("E&xit\tAlt-X"), + menuFile->Append(wxID_EXIT, + _T("E&xit\tAlt-X"), _T("Quit this program")); wxMenuBar *menuBar = new wxMenuBar(); @@ -322,10 +322,10 @@ MyFrame::MyFrame(const wxString& title) ResetStatus(); SetStatusText(m_basestatus); #endif // wxUSE_STATUSBAR - + // // Connect events. - // + // // There are two ways in wxWidgets to use events - // Message Maps and Connections. // @@ -339,7 +339,7 @@ MyFrame::MyFrame(const wxString& title) // END_EVENT_TABLE() // // Where MyFrame is the class with the DECLARE_MESSAGE_MAP - // in it. EVT_XXX(XXX) are each of your handlers, such + // in it. EVT_XXX(XXX) are each of your handlers, such // as EVT_MENU for menu events and the XXX inside // is the parameters to the event macro - in the case // of EVT_MENU the menu id and then the function to call. @@ -366,19 +366,19 @@ MyFrame::MyFrame(const wxString& title) // // The third is the function handler for the event - // You need to cast it to the specific event handler - // type, then to a wxEventFunction, then to a + // type, then to a wxEventFunction, then to a // wxObjectEventFunction - I.E. // (wxObjectEventFunction)(wxEventFunction) // (wxCommandEventFunction) &MyFrame::MyHandler // - // The fourth is an optional userdata param - + // The fourth is an optional userdata param - // this is of historical relevance only and is // there only for backwards compatability. // // The fifth is the context in which to call the // handler - by default (this param is optional) // this. For example in your event handler - // if you were to call "this->MyFunc()" + // if you were to call "this->MyFunc()" // it would literally do this->MyFunc. However, // if you were to pass myHandler as the fifth // parameter, for instance, you would _really_ @@ -389,48 +389,48 @@ MyFrame::MyFrame(const wxString& title) // // Menu events // - this->Connect(wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED, - (wxObjectEventFunction) (wxEventFunction) + this->Connect(wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED, + (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) &MyFrame::OnQuit); - - this->Connect(wxID_ABOUT, wxEVT_COMMAND_MENU_SELECTED, - (wxObjectEventFunction) (wxEventFunction) + + this->Connect(wxID_ABOUT, wxEVT_COMMAND_MENU_SELECTED, + (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) &MyFrame::OnAbout); - this->Connect(wxID_LOOP, wxEVT_COMMAND_MENU_SELECTED, - (wxObjectEventFunction) (wxEventFunction) + this->Connect(wxID_LOOP, wxEVT_COMMAND_MENU_SELECTED, + (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) &MyFrame::OnLoop); - this->Connect(wxID_OPENFILE, wxEVT_COMMAND_MENU_SELECTED, - (wxObjectEventFunction) (wxEventFunction) + this->Connect(wxID_OPENFILE, wxEVT_COMMAND_MENU_SELECTED, + (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) &MyFrame::OnOpenFile); - this->Connect(wxID_PLAY, wxEVT_COMMAND_MENU_SELECTED, - (wxObjectEventFunction) (wxEventFunction) + this->Connect(wxID_PLAY, wxEVT_COMMAND_MENU_SELECTED, + (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) &MyFrame::OnPlay); - this->Connect(wxID_PAUSE, wxEVT_COMMAND_MENU_SELECTED, - (wxObjectEventFunction) (wxEventFunction) + this->Connect(wxID_PAUSE, wxEVT_COMMAND_MENU_SELECTED, + (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) &MyFrame::OnPause); - this->Connect(wxID_STOP, wxEVT_COMMAND_MENU_SELECTED, - (wxObjectEventFunction) (wxEventFunction) + this->Connect(wxID_STOP, wxEVT_COMMAND_MENU_SELECTED, + (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) &MyFrame::OnStop); // // Slider events // - this->Connect(wxID_SLIDER, wxEVT_COMMAND_SLIDER_UPDATED, - (wxObjectEventFunction) (wxEventFunction) + this->Connect(wxID_SLIDER, wxEVT_COMMAND_SLIDER_UPDATED, + (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) &MyFrame::OnSeek); // // Media Control events // - this->Connect(wxID_MEDIACTRL, wxEVT_MEDIA_STOP, - (wxObjectEventFunction) (wxEventFunction) - (wxCommandEventFunction) &MyFrame::OnMediaStop); + this->Connect(wxID_MEDIACTRL, wxEVT_MEDIA_STOP, + (wxObjectEventFunction) (wxEventFunction) + (wxMediaEventFunction) &MyFrame::OnMediaStop); // // End of Events @@ -451,7 +451,7 @@ MyFrame::MyFrame(const wxString& title) // ---------------------------------------------------------------------------- // MyFrame Destructor // -// 1) Deletes child objects implicitly +// 1) Deletes child objects implicitly // 2) Delete our timer explicitly // ---------------------------------------------------------------------------- MyFrame::~MyFrame() @@ -462,16 +462,16 @@ MyFrame::~MyFrame() // ---------------------------------------------------------------------------- // MyFrame::ResetStatus // -// Here we just make a simple status string with some useful info about +// Here we just make a simple status string with some useful info about // the media that we won't change later - such as the length of the media. // // We then append some other info that changes in MyTimer::Notify, then -// set the status bar to this text. +// set the status bar to this text. // // In real applications, you'd want to find a better way to do this, // such as static text controls (wxStaticText). -// -// We display info here in seconds (wxMediaCtrl uses milliseconds - that's why +// +// We display info here in seconds (wxMediaCtrl uses milliseconds - that's why // we divide by 1000). // // We also reset our loop counter here. @@ -505,7 +505,7 @@ void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event)) // ---------------------------------------------------------------------------- // MyFrame::OnAbout -// +// // Called from help->about. // Gets some info about this application. // ---------------------------------------------------------------------------- @@ -553,7 +553,7 @@ void MyFrame::OnOpenFile(wxCommandEvent& WXUNUSED(event)) // ---------------------------------------------------------------------------- // MyFrame::OnPlay -// +// // Called from file->play. // Resumes the media if it is paused or stopped. // ---------------------------------------------------------------------------- @@ -565,7 +565,7 @@ void MyFrame::OnPlay(wxCommandEvent& WXUNUSED(event)) // ---------------------------------------------------------------------------- // MyFrame::OnPause -// +// // Called from file->pause. // Pauses the media in-place. // ---------------------------------------------------------------------------- @@ -577,7 +577,7 @@ void MyFrame::OnPause(wxCommandEvent& WXUNUSED(event)) // ---------------------------------------------------------------------------- // MyFrame::OnStop -// +// // Called from file->stop. // Where it stops depends on whether you can seek in the // media control or not - if you can it stops and seeks to the beginning, @@ -592,7 +592,7 @@ void MyFrame::OnStop(wxCommandEvent& WXUNUSED(event)) // ---------------------------------------------------------------------------- // MyFrame::OnSeek -// +// // Called from file->seek. // Called when the user moves the slider - // seeks to a position within the media @@ -605,7 +605,7 @@ void MyFrame::OnSeek(wxCommandEvent& WXUNUSED(event)) // ---------------------------------------------------------------------------- // MyFrame::OnMediaStop -// +// // Called when the media is about to stop playing. // Here we just increase our loop counter // ---------------------------------------------------------------------------- @@ -625,7 +625,7 @@ void MyFrame::OnMediaStop(wxMediaEvent& WXUNUSED(event)) // // 1) Update our slider with the position were are in in the media // 2) Update our status bar with the base text from MyFrame::ResetStatus, -// append some non-static (changing) info to it, then set the +// append some non-static (changing) info to it, then set the // status bar text to that result // ---------------------------------------------------------------------------- void MyTimer::Notify() diff --git a/src/common/mediactrlcmn.cpp b/src/common/mediactrlcmn.cpp index 53ba95509a..3d91560123 100644 --- a/src/common/mediactrlcmn.cpp +++ b/src/common/mediactrlcmn.cpp @@ -41,7 +41,7 @@ //=========================================================================== // // Implementation -// +// //=========================================================================== //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -67,7 +67,7 @@ DEFINE_EVENT_TYPE(wxEVT_MEDIA_STOP); // Searches for a backend that is installed on the system (backends // starting with lower characters in the alphabet are given priority), // and creates the control from it -// +// // This searches by searching the global RTTI hashtable, class by class, // attempting to call CreateControl on each one found that is a derivative // of wxMediaBackend - if it succeededs Create returns true, otherwise @@ -75,9 +75,9 @@ DEFINE_EVENT_TYPE(wxEVT_MEDIA_STOP); //--------------------------------------------------------------------------- bool wxMediaCtrl::Create(wxWindow* parent, wxWindowID id, const wxString& fileName, - const wxPoint& pos, + const wxPoint& pos, const wxSize& size, - long style, + long style, const wxString& szBackend, const wxValidator& validator, const wxString& name) @@ -113,7 +113,7 @@ bool wxMediaCtrl::Create(wxWindow* parent, wxWindowID id, { if(!DoCreate(classInfo, parent, id, pos, size, style, validator, name)) - continue; + continue; if (!fileName.empty()) { @@ -135,9 +135,9 @@ bool wxMediaCtrl::Create(wxWindow* parent, wxWindowID id, bool wxMediaCtrl::Create(wxWindow* parent, wxWindowID id, const wxURI& location, - const wxPoint& pos, + const wxPoint& pos, const wxSize& size, - long style, + long style, const wxString& szBackend, const wxValidator& validator, const wxString& name) @@ -170,7 +170,7 @@ bool wxMediaCtrl::Create(wxWindow* parent, wxWindowID id, { if(!DoCreate(classInfo, parent, id, pos, size, style, validator, name)) - continue; + continue; if (m_imp->Load(location)) return true; @@ -192,24 +192,24 @@ bool wxMediaCtrl::Create(wxWindow* parent, wxWindowID id, //--------------------------------------------------------------------------- bool wxMediaCtrl::DoCreate(wxClassInfo* classInfo, wxWindow* parent, wxWindowID id, - const wxPoint& pos, + const wxPoint& pos, const wxSize& size, - long style, + long style, const wxValidator& validator, const wxString& name) { m_imp = (wxMediaBackend*)classInfo->CreateObject(); - + if( m_imp->CreateControl(this, parent, id, pos, size, style, validator, name) ) { - this->Connect(GetId(), wxEVT_MEDIA_FINISHED, + this->Connect(GetId(), wxEVT_MEDIA_FINISHED, (wxObjectEventFunction) (wxEventFunction) - (wxMediaEventFunction) + (wxMediaEventFunction) &wxMediaCtrl::OnMediaFinished); return true; } - + delete m_imp; return false; } @@ -221,7 +221,7 @@ bool wxMediaCtrl::DoCreate(wxClassInfo* classInfo, // Search through the RTTI hashmap one at a // time, attempting to create each derivative // of wxMediaBackend -// +// // // STL isn't compatable with and will have a compilation error // on a wxNode, however, wxHashTable::compatibility_iterator is @@ -295,7 +295,7 @@ bool wxMediaCtrl::Load(const wxURI& location) // wxMediaCtrl::GetDuration // wxMediaCtrl::GetState // wxMediaCtrl::DoGetBestSize -// +// // 1) Check to see whether the backend exists and is loading // 2) Call the backend's version of the method, returning success // if the backend's version succeeds @@ -372,7 +372,7 @@ wxSize wxMediaCtrl::DoGetBestSize() const //--------------------------------------------------------------------------- // wxMediaCtrl::DoMoveWindow -// +// // 1) Call parent's version so that our control's window moves where // it's supposed to // 2) If the backend exists and is loaded, move the video @@ -396,7 +396,7 @@ bool wxMediaCtrl::IsLooped() return m_bLoop; } -void wxMediaCtrl::OnMediaFinished(const wxMediaEvent& WXUNUSED(evt)) +void wxMediaCtrl::OnMediaFinished(wxMediaEvent& WXUNUSED(evt)) { if(m_bLoop) { diff --git a/src/msw/mediactrl.cpp b/src/msw/mediactrl.cpp index 287192c158..80521b517b 100644 --- a/src/msw/mediactrl.cpp +++ b/src/msw/mediactrl.cpp @@ -75,11 +75,11 @@ public: virtual ~wxAMMediaBackend(); - virtual bool CreateControl(wxControl* ctrl, wxWindow* parent, + virtual bool CreateControl(wxControl* ctrl, wxWindow* parent, wxWindowID id, - const wxPoint& pos, + const wxPoint& pos, const wxSize& size, - long style, + long style, const wxValidator& validator, const wxString& name); @@ -106,15 +106,15 @@ public: bool m_bVideo; - static LRESULT CALLBACK NotifyWndProc(HWND hWnd, UINT nMsg, + static LRESULT CALLBACK NotifyWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam); - - LRESULT CALLBACK OnNotifyWndProc(HWND hWnd, UINT nMsg, + + LRESULT CALLBACK OnNotifyWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam); wxControl* m_ctrl; - IGraphBuilder* m_pGB; + IGraphBuilder* m_pGB; IMediaControl* m_pMC; IMediaEventEx* m_pME; IVideoWindow* m_pVW; @@ -148,11 +148,11 @@ public: wxMCIMediaBackend(); ~wxMCIMediaBackend(); - virtual bool CreateControl(wxControl* ctrl, wxWindow* parent, + virtual bool CreateControl(wxControl* ctrl, wxWindow* parent, wxWindowID id, - const wxPoint& pos, + const wxPoint& pos, const wxSize& size, - long style, + long style, const wxValidator& validator, const wxString& name); @@ -175,10 +175,10 @@ public: virtual double GetPlaybackRate(); virtual bool SetPlaybackRate(double dRate); - static LRESULT CALLBACK NotifyWndProc(HWND hWnd, UINT nMsg, + static LRESULT CALLBACK NotifyWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam); - LRESULT CALLBACK OnNotifyWndProc(HWND hWnd, UINT nMsg, + LRESULT CALLBACK OnNotifyWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam); MCIDEVICEID m_hDev; //Our MCI Device ID/Handler @@ -213,11 +213,11 @@ public: wxQTMediaBackend(); ~wxQTMediaBackend(); - virtual bool CreateControl(wxControl* ctrl, wxWindow* parent, + virtual bool CreateControl(wxControl* ctrl, wxWindow* parent, wxWindowID id, - const wxPoint& pos, + const wxPoint& pos, const wxSize& size, - long style, + long style, const wxValidator& validator, const wxString& name); @@ -316,7 +316,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxAMMediaBackend, wxMediaBackend); // wxAMMediaBackend Constructor // // Sets m_hNotifyWnd to NULL to signify that we haven't loaded anything yet -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- wxAMMediaBackend::wxAMMediaBackend() : m_hNotifyWnd(NULL) { } @@ -324,8 +324,8 @@ wxAMMediaBackend::wxAMMediaBackend() : m_hNotifyWnd(NULL) //--------------------------------------------------------------------------- // wxAMMediaBackend Destructor // -// Cleans up everything -//--------------------------------------------------------------------------- +// Cleans up everything +//--------------------------------------------------------------------------- wxAMMediaBackend::~wxAMMediaBackend() { if (m_hNotifyWnd) @@ -339,15 +339,15 @@ wxAMMediaBackend::~wxAMMediaBackend() // so we just create a normal control with a black background. // // We also check to see if ActiveMovie is installed -//--------------------------------------------------------------------------- -bool wxAMMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, +//--------------------------------------------------------------------------- +bool wxAMMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, wxWindowID id, - const wxPoint& pos, + const wxPoint& pos, const wxSize& size, - long style, + long style, const wxValidator& validator, const wxString& name) -{ +{ //create our filter graph HRESULT hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, (void**)&m_pGB); @@ -376,7 +376,7 @@ bool wxAMMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, //Set our background color to black by default // ctrl->SetBackgroundColour(*wxBLACK); - + m_ctrl = ctrl; return true; } @@ -386,7 +386,7 @@ bool wxAMMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, // wxAMMediaBackend::Load (file version) // // Creates an Active Movie filter graph from a file or url -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxAMMediaBackend::Load(const wxString& fileName) { if(m_hNotifyWnd) @@ -407,7 +407,7 @@ bool wxAMMediaBackend::Load(const wxString& fileName) wxAMVERIFY( m_pGB->QueryInterface(IID_IBasicAudio, (void**)&m_pBA) ); wxAMVERIFY( m_pGB->QueryInterface(IID_IBasicVideo, (void**)&m_pBV) ); - //We could tell if the media has audio or not by + //We could tell if the media has audio or not by //something like //----- //long lVolume; @@ -418,12 +418,12 @@ bool wxAMMediaBackend::Load(const wxString& fileName) // //Obtain the _actual_ size of the movie & remember it // - long nX, + long nX, nY; m_bestSize.x = m_bestSize.y = 0; - m_bVideo = SUCCEEDED( m_pVW->GetWindowPosition( &nX, + m_bVideo = SUCCEEDED( m_pVW->GetWindowPosition( &nX, &nY, (long*)&m_bestSize.x, (long*)&m_bestSize.y) ); @@ -443,9 +443,9 @@ bool wxAMMediaBackend::Load(const wxString& fileName) // // Create a hidden window and register to handle // directshow events for this graph - // Note that wxCanvasClassName is already registered + // Note that wxCanvasClassName is already registered // and used by all wxWindows and normal wxControls - // + // m_hNotifyWnd = ::CreateWindow ( wxCanvasClassName, @@ -465,14 +465,14 @@ bool wxAMMediaBackend::Load(const wxString& fileName) return false; } - - ::SetWindowLongPtr(m_hNotifyWnd, GWLP_WNDPROC, + + ::SetWindowLongPtr(m_hNotifyWnd, GWLP_WNDPROC, (LONG_PTR)wxAMMediaBackend::NotifyWndProc); ::SetWindowLong(m_hNotifyWnd, GWL_USERDATA, (LONG) this); - wxAMVERIFY( m_pME->SetNotifyWindow((OAHWND)m_hNotifyWnd, + wxAMVERIFY( m_pME->SetNotifyWindow((OAHWND)m_hNotifyWnd, WM_GRAPHNOTIFY, 0) ); // @@ -499,7 +499,7 @@ bool wxAMMediaBackend::Load(const wxString& fileName) // Loads media from a URL. Interestingly enough DirectShow // appears (?) to escape the URL for us, at least on normal // files -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxAMMediaBackend::Load(const wxURI& location) { return Load(location.BuildUnescapedURI()); @@ -509,7 +509,7 @@ bool wxAMMediaBackend::Load(const wxURI& location) // wxAMMediaBackend::Play // // Plays the stream. If it is non-seekable, it will restart it. -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxAMMediaBackend::Play() { return SUCCEEDED( m_pMC->Run() ); @@ -519,7 +519,7 @@ bool wxAMMediaBackend::Play() // wxAMMediaBackend::Pause // // Pauses the stream. -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxAMMediaBackend::Pause() { return SUCCEEDED( m_pMC->Pause() ); @@ -529,7 +529,7 @@ bool wxAMMediaBackend::Pause() // wxAMMediaBackend::Stop // // Stops the stream. -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxAMMediaBackend::Stop() { bool bOK = SUCCEEDED( m_pMC->Stop() ); @@ -544,12 +544,12 @@ bool wxAMMediaBackend::Stop() //--------------------------------------------------------------------------- // wxAMMediaBackend::SetPosition // -// 1) Translates the current position's time to directshow time, +// 1) Translates the current position's time to directshow time, // which is in a scale of 100 nanoseconds // 2) Sets the play position of the IMediaSeeking interface - // passing NULL as the stop position means to keep the old // stop position -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxAMMediaBackend::SetPosition(wxLongLong where) { LONGLONG pos = ((LONGLONG)where.GetValue()) * 10000; @@ -567,7 +567,7 @@ bool wxAMMediaBackend::SetPosition(wxLongLong where) // // 1) Obtains the current play and stop positions from IMediaSeeking // 2) Returns the play position translated to our time base -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- wxLongLong wxAMMediaBackend::GetPosition() { LONGLONG outCur, outStop; @@ -582,7 +582,7 @@ wxLongLong wxAMMediaBackend::GetPosition() // // 1) Obtains the duration of the media from the IMediaSeeking interface // 2) Converts that value to our time base, and returns it -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- wxLongLong wxAMMediaBackend::GetDuration() { LONGLONG outDuration; @@ -598,9 +598,9 @@ wxLongLong wxAMMediaBackend::GetDuration() // Obtains the state from the IMediaControl interface. // Note that it's enumeration values for stopping/playing // etc. are the same as ours, so we just do a straight cast. -// TODO: MS recommends against INFINITE here for +// TODO: MS recommends against INFINITE here for // IMediaControl::GetState- do it in stages -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- wxMediaState wxAMMediaBackend::GetState() { HRESULT hr; @@ -622,7 +622,7 @@ wxMediaState wxAMMediaBackend::GetState() // // Pretty simple way of obtaining the playback rate from // the IMediaSeeking interface -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- double wxAMMediaBackend::GetPlaybackRate() { double dRate; @@ -635,7 +635,7 @@ double wxAMMediaBackend::GetPlaybackRate() // // Sets the playback rate of the media - DirectShow is pretty good // about this, actually -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxAMMediaBackend::SetPlaybackRate(double dRate) { return SUCCEEDED( m_pMS->SetRate(dRate) ); @@ -644,12 +644,12 @@ bool wxAMMediaBackend::SetPlaybackRate(double dRate) //--------------------------------------------------------------------------- // wxAMMediaBackend::NotifyWndProc // -// Here we check to see if DirectShow tells us we've reached the stop +// Here we check to see if DirectShow tells us we've reached the stop // position in our stream - if it has, it may not actually stop // the stream - which we need to do... -//--------------------------------------------------------------------------- -LRESULT CALLBACK wxAMMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg, - WPARAM wParam, +//--------------------------------------------------------------------------- +LRESULT CALLBACK wxAMMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg, + WPARAM wParam, LPARAM lParam) { wxAMMediaBackend* backend = (wxAMMediaBackend*) @@ -658,14 +658,14 @@ LRESULT CALLBACK wxAMMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg, return backend->OnNotifyWndProc(hWnd, nMsg, wParam, lParam); } -LRESULT CALLBACK wxAMMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg, - WPARAM wParam, +LRESULT CALLBACK wxAMMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg, + WPARAM wParam, LPARAM lParam) { if (nMsg == WM_GRAPHNOTIFY) { - LONG evCode, - evParam1, + LONG evCode, + evParam1, evParam2; // @@ -694,9 +694,9 @@ LRESULT CALLBACK wxAMMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg, //Interestingly enough, DirectShow does not actually stop //the filters - even when it reaches the end! wxVERIFY( Stop() ); - + //send the event to our child - wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED, + wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED, m_ctrl->GetId()); m_ctrl->ProcessEvent(theEvent); } @@ -709,13 +709,13 @@ LRESULT CALLBACK wxAMMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg, //--------------------------------------------------------------------------- // wxAMMediaBackend::Cleanup // -// 1) Hide/disowns the video window (MS says bad things will happen if +// 1) Hide/disowns the video window (MS says bad things will happen if // you don't) // 2) Releases all the directshow interfaces we use // TODO: Maybe there's a way to redirect the IGraphBuilder each time // we load, rather then creating and destroying the interfaces // each time? -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- void wxAMMediaBackend::Cleanup() { // Hide then disown the window @@ -733,7 +733,7 @@ void wxAMMediaBackend::Cleanup() SAFE_RELEASE(m_pBV); SAFE_RELEASE(m_pVW); SAFE_RELEASE(m_pGB); - + // Get rid of our hidden Window DestroyWindow(m_hNotifyWnd); m_hNotifyWnd = NULL; @@ -744,7 +744,7 @@ void wxAMMediaBackend::Cleanup() // wxAMMediaBackend::GetVideoSize // // Obtains the cached original video size -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- wxSize wxAMMediaBackend::GetVideoSize() const { return m_bestSize; @@ -754,7 +754,7 @@ wxSize wxAMMediaBackend::GetVideoSize() const // wxAMMediaBackend::Move // // Resizes the IVideoWindow to the size of the control window -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- void wxAMMediaBackend::Move(int x, int y, int w, int h) { if(m_hNotifyWnd && m_bVideo) @@ -771,7 +771,7 @@ void wxAMMediaBackend::Move(int x, int y, int w, int h) //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // // wxMCIMediaBackend -// +// //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -800,7 +800,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxMCIMediaBackend, wxMediaBackend); // Simulation for // // Mingw and possibly other compilers don't have the digitalv.h header -// that is needed to have some essential features of mci work with +// that is needed to have some essential features of mci work with // windows - so we provide the declarations for the types we use here //--------------------------------------------------------------------------- @@ -809,7 +809,7 @@ typedef struct { #ifdef MCI_USE_OFFEXT POINT ptOffset; POINT ptExtent; -#else +#else RECT rc; #endif } MCI_DGV_RECT_PARMS; @@ -828,12 +828,12 @@ typedef struct { } MCI_DGV_WINDOW_PARMS; typedef struct { - DWORD_PTR dwCallback; - DWORD dwTimeFormat; - DWORD dwAudio; - DWORD dwFileFormat; - DWORD dwSpeed; -} MCI_DGV_SET_PARMS; + DWORD_PTR dwCallback; + DWORD dwTimeFormat; + DWORD dwAudio; + DWORD dwFileFormat; + DWORD dwSpeed; +} MCI_DGV_SET_PARMS; //--------------------------------------------------------------------------- // wxMCIMediaBackend Constructor @@ -866,11 +866,11 @@ wxMCIMediaBackend::~wxMCIMediaBackend() // Here we just tell wxMediaCtrl that mci does exist (which it does, on all // msw systems, at least in some form dating back to win16 days) //--------------------------------------------------------------------------- -bool wxMCIMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, +bool wxMCIMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, wxWindowID id, - const wxPoint& pos, + const wxPoint& pos, const wxSize& size, - long style, + long style, const wxValidator& validator, const wxString& name) { @@ -916,14 +916,14 @@ bool wxMCIMediaBackend::Load(const wxString& fileName) // //Opens a file and has MCI select a device. Normally you'd put //MCI_OPEN_TYPE in addition to MCI_OPEN_ELEMENT - however if you - //omit this it tells MCI to select the device instead. This is + //omit this it tells MCI to select the device instead. This is //good because we have no reliable way of "enumerating" the devices //in MCI // MCI_OPEN_PARMS openParms; openParms.lpstrElementName = (wxChar*) fileName.c_str(); - if ( mciSendCommand(0, MCI_OPEN, MCI_OPEN_ELEMENT, + if ( mciSendCommand(0, MCI_OPEN, MCI_OPEN_ELEMENT, (DWORD)(LPVOID)&openParms) != 0) return false; @@ -946,16 +946,16 @@ bool wxMCIMediaBackend::Load(const wxString& fileName) MCI_DGV_WINDOW_PARMS windowParms; windowParms.hWnd = (HWND)m_ctrl->GetHandle(); - m_bVideo = (mciSendCommand(m_hDev, MCI_WINDOW, + m_bVideo = (mciSendCommand(m_hDev, MCI_WINDOW, 0x00010000L, //MCI_DGV_WINDOW_HWND (DWORD)(LPVOID)&windowParms) == 0); // // Create a hidden window and register to handle // MCI events - // Note that wxCanvasClassName is already registered + // Note that wxCanvasClassName is already registered // and used by all wxWindows and normal wxControls - // + // m_hNotifyWnd = ::CreateWindow ( wxCanvasClassName, @@ -975,8 +975,8 @@ bool wxMCIMediaBackend::Load(const wxString& fileName) return false; } - - ::SetWindowLong(m_hNotifyWnd, GWL_WNDPROC, + + ::SetWindowLong(m_hNotifyWnd, GWL_WNDPROC, (LONG)wxMCIMediaBackend::NotifyWndProc); ::SetWindowLong(m_hNotifyWnd, GWL_USERDATA, @@ -1014,7 +1014,7 @@ bool wxMCIMediaBackend::Load(const wxURI& WXUNUSED(location)) // 1) Certain drivers will crash and burn if we don't pass them an // MCI_PLAY_PARMS, despite the documentation that says otherwise... // 2) There is a MCI_RESUME command, but MCI_PLAY does the same thing -// and will resume from a stopped state also, so there's no need to +// and will resume from a stopped state also, so there's no need to // call both, for example //--------------------------------------------------------------------------- bool wxMCIMediaBackend::Play() @@ -1022,7 +1022,7 @@ bool wxMCIMediaBackend::Play() MCI_PLAY_PARMS playParms; playParms.dwCallback = (DWORD)m_hNotifyWnd; - return ( mciSendCommand(m_hDev, MCI_PLAY, MCI_NOTIFY, + return ( mciSendCommand(m_hDev, MCI_PLAY, MCI_NOTIFY, (DWORD)(LPVOID)&playParms) == 0 ); } @@ -1030,7 +1030,7 @@ bool wxMCIMediaBackend::Play() // wxMCIMediaBackend::Pause // // Pauses the MCI device - nothing special -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxMCIMediaBackend::Pause() { return (mciSendCommand(m_hDev, MCI_PAUSE, MCI_WAIT, 0) == 0); @@ -1040,7 +1040,7 @@ bool wxMCIMediaBackend::Pause() // wxMCIMediaBackend::Stop // // Stops the MCI device & seeks to the beginning as wxMediaCtrl docs outline -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxMCIMediaBackend::Stop() { return (mciSendCommand(m_hDev, MCI_STOP, MCI_WAIT, 0) == 0) && @@ -1054,7 +1054,7 @@ bool wxMCIMediaBackend::Stop() // since we use direct comparisons with MCI_MODE_PLAY and // MCI_MODE_PAUSE, we don't care if the MCI_STATUS call // fails or not -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- wxMediaState wxMCIMediaBackend::GetState() { MCI_STATUS_PARMS statusParms; @@ -1075,20 +1075,20 @@ wxMediaState wxMCIMediaBackend::GetState() // wxMCIMediaBackend::SetPosition // // Here we set the position of the device in the stream. -// Note that MCI actually stops the device after you seek it if the +// Note that MCI actually stops the device after you seek it if the // device is playing/paused, so we need to play the file after -// MCI seeks like normal APIs would -//--------------------------------------------------------------------------- +// MCI seeks like normal APIs would +//--------------------------------------------------------------------------- bool wxMCIMediaBackend::SetPosition(wxLongLong where) { MCI_SEEK_PARMS seekParms; seekParms.dwCallback = 0; - seekParms.dwTo = where.GetValue(); + seekParms.dwTo = (DWORD)where.GetValue(); //device was playing? bool bReplay = GetState() == wxMEDIASTATE_PLAYING; - if( mciSendCommand(m_hDev, MCI_SEEK, MCI_TO, + if( mciSendCommand(m_hDev, MCI_SEEK, MCI_TO, (DWORD)(LPVOID)&seekParms) != 0) return false; @@ -1104,7 +1104,7 @@ bool wxMCIMediaBackend::SetPosition(wxLongLong where) // // Gets the position of the device in the stream using the current // time format... nothing special here... -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- wxLongLong wxMCIMediaBackend::GetPosition() { MCI_STATUS_PARMS statusParms; @@ -1121,7 +1121,7 @@ wxLongLong wxMCIMediaBackend::GetPosition() // wxMCIMediaBackend::GetDuration // // Gets the duration of the stream... nothing special -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- wxLongLong wxMCIMediaBackend::GetDuration() { MCI_STATUS_PARMS statusParms; @@ -1138,8 +1138,8 @@ wxLongLong wxMCIMediaBackend::GetDuration() // wxMCIMediaBackend::Move // // Moves the window to a location -//--------------------------------------------------------------------------- -void wxMCIMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y), +//--------------------------------------------------------------------------- +void wxMCIMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y), int w, int h) { if (m_hNotifyWnd && m_bVideo) @@ -1150,7 +1150,7 @@ void wxMCIMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y), putParms.rc.right = w; putParms.rc.bottom = h; - wxMCIVERIFY( mciSendCommand(m_hDev, MCI_PUT, + wxMCIVERIFY( mciSendCommand(m_hDev, MCI_PUT, 0x00040000L, //MCI_DGV_PUT_DESTINATION (DWORD)(LPSTR)&putParms) ); } @@ -1160,17 +1160,17 @@ void wxMCIMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y), // wxMCIMediaBackend::GetVideoSize // // Gets the original size of the movie for sizers -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- wxSize wxMCIMediaBackend::GetVideoSize() const { if(m_bVideo) { MCI_DGV_RECT_PARMS whereParms; //ifdefed MCI_DGV_WHERE_PARMS - wxMCIVERIFY( mciSendCommand(m_hDev, MCI_WHERE, + wxMCIVERIFY( mciSendCommand(m_hDev, MCI_WHERE, 0x00020000L, //MCI_DGV_WHERE_SOURCE (DWORD)(LPSTR)&whereParms) ); - + return wxSize(whereParms.rc.right, whereParms.rc.bottom); } return wxSize(0,0); @@ -1180,7 +1180,7 @@ wxSize wxMCIMediaBackend::GetVideoSize() const // wxMCIMediaBackend::GetPlaybackRate // // TODO -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- double wxMCIMediaBackend::GetPlaybackRate() { return 1.0; @@ -1190,7 +1190,7 @@ double wxMCIMediaBackend::GetPlaybackRate() // wxMCIMediaBackend::SetPlaybackRate // // TODO -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- bool wxMCIMediaBackend::SetPlaybackRate(double WXUNUSED(dRate)) { /* @@ -1198,7 +1198,7 @@ bool wxMCIMediaBackend::SetPlaybackRate(double WXUNUSED(dRate)) MCI_DGV_SET_PARMS setParms; setParms.dwSpeed = (DWORD) (dRate * 1000.0); - return (mciSendCommand(m_hDev, MCI_SET, + return (mciSendCommand(m_hDev, MCI_SET, 0x00020000L, //MCI_DGV_SET_SPEED (DWORD)(LPSTR)&setParms) == 0); */ @@ -1208,11 +1208,11 @@ bool wxMCIMediaBackend::SetPlaybackRate(double WXUNUSED(dRate)) //--------------------------------------------------------------------------- // [static] wxMCIMediaBackend::MSWWindowProc // -// Here we process a message when MCI reaches the stopping point +// Here we process a message when MCI reaches the stopping point // in the stream -//--------------------------------------------------------------------------- -LRESULT CALLBACK wxMCIMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg, - WPARAM wParam, +//--------------------------------------------------------------------------- +LRESULT CALLBACK wxMCIMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg, + WPARAM wParam, LPARAM lParam) { wxMCIMediaBackend* backend = (wxMCIMediaBackend*) @@ -1222,8 +1222,8 @@ LRESULT CALLBACK wxMCIMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg, return backend->OnNotifyWndProc(hWnd, nMsg, wParam, lParam); } -LRESULT CALLBACK wxMCIMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg, - WPARAM wParam, +LRESULT CALLBACK wxMCIMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg, + WPARAM wParam, LPARAM lParam) { if(nMsg == MM_MCINOTIFY) @@ -1236,11 +1236,11 @@ LRESULT CALLBACK wxMCIMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg, if(theEvent.IsAllowed()) { - wxMCIVERIFY( mciSendCommand(m_hDev, MCI_SEEK, + wxMCIVERIFY( mciSendCommand(m_hDev, MCI_SEEK, MCI_SEEK_TO_START, 0) ); //send the event to our child - wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED, + wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED, m_ctrl->GetId()); m_ctrl->ProcessEvent(theEvent); } @@ -1251,7 +1251,7 @@ LRESULT CALLBACK wxMCIMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg, //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // // wxQTMediaBackend -// +// // TODO: Use a less cludgy way to pause/get state/set state // TODO: Dynamically load from qtml.dll //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -1296,10 +1296,10 @@ public: if (!m_bPaused) { if(!IsMovieDone(m_movie)) - MoviesTask(m_movie, MOVIE_DELAY); + MoviesTask(m_movie, MOVIE_DELAY); else { - wxMediaEvent theEvent(wxEVT_MEDIA_STOP, + wxMediaEvent theEvent(wxEVT_MEDIA_STOP, m_parent->m_ctrl->GetId()); m_parent->m_ctrl->ProcessEvent(theEvent); @@ -1310,7 +1310,7 @@ public: wxASSERT(::GetMoviesError() == noErr); //send the event to our child - wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED, + wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED, m_parent->m_ctrl->GetId()); m_parent->m_ctrl->ProcessEvent(theEvent); } @@ -1359,11 +1359,11 @@ wxQTMediaBackend::~wxQTMediaBackend() // 1) Intializes QuickTime // 2) Creates the control window //--------------------------------------------------------------------------- -bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, +bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, wxWindowID id, - const wxPoint& pos, + const wxPoint& pos, const wxSize& size, - long style, + long style, const wxValidator& validator, const wxString& name) { @@ -1403,7 +1403,7 @@ bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent, // 1) Get an FSSpec from the Windows path name // 2) Open the movie // 3) Obtain the movie instance from the movie resource -// 4) +// 4) //--------------------------------------------------------------------------- bool wxQTMediaBackend::Load(const wxString& fileName) { @@ -1414,10 +1414,10 @@ bool wxQTMediaBackend::Load(const wxString& fileName) short movieResFile; FSSpec sfFile; - if (NativePathNameToFSSpec ((char*) (const char*) fileName.mb_str(), + if (NativePathNameToFSSpec ((char*) (const char*) fileName.mb_str(), &sfFile, 0) != noErr) return false; - + if (OpenMovieFile (&sfFile, &movieResFile, fsRdPerm) != noErr) return false; @@ -1462,8 +1462,8 @@ bool wxQTMediaBackend::Load(const wxURI& location) BlockMove(theURI.mb_str(), *theHandle, theURI.length() + 1); //create the movie from the handle that refers to the URI - err = NewMovieFromDataRef(&m_movie, newMovieActive, - NULL, theHandle, + err = NewMovieFromDataRef(&m_movie, newMovieActive, + NULL, theHandle, URLDataHandlerSubType); DisposeHandle(theHandle); @@ -1503,17 +1503,17 @@ void wxQTMediaBackend::FinishLoad() m_bestSize.x = outRect.right - outRect.left; m_bestSize.y = outRect.bottom - outRect.top; - + //reparent movie/*AudioMediaCharacteristic*/ - if(GetMovieIndTrackType(m_movie, 1, - VisualMediaCharacteristic, - movieTrackCharacteristic | + if(GetMovieIndTrackType(m_movie, 1, + VisualMediaCharacteristic, + movieTrackCharacteristic | movieTrackEnabledOnly) != NULL) { CreatePortAssociation(m_ctrl->GetHWND(), NULL, 0L); - - SetMovieGWorld(m_movie, - (CGrafPtr) GetNativeWindowPort(m_ctrl->GetHWND()), + + SetMovieGWorld(m_movie, + (CGrafPtr) GetNativeWindowPort(m_ctrl->GetHWND()), nil); } @@ -1571,7 +1571,7 @@ bool wxQTMediaBackend::Stop() ::StopMovie(m_movie); if(::GetMoviesError() != noErr) return false; - + ::GoToBeginningOfMovie(m_movie); return ::GetMoviesError() == noErr; } @@ -1644,7 +1644,7 @@ wxLongLong wxQTMediaBackend::GetDuration() //--------------------------------------------------------------------------- wxMediaState wxQTMediaBackend::GetState() { - if ( !m_timer || (m_timer->IsRunning() == false && + if ( !m_timer || (m_timer->IsRunning() == false && m_timer->GetPaused() == false) ) return wxMEDIASTATE_STOPPED; -- 2.45.2