X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a2d9b7d02e8c1d5c0b2501b5811a57f72b32a28b..a9a56347b84be54a9d48df2cfe08ddf761aaf491:/samples/mediaplayer/mediaplayer.cpp diff --git a/samples/mediaplayer/mediaplayer.cpp b/samples/mediaplayer/mediaplayer.cpp index faf3dbfc23..7b94f1ff19 100644 --- a/samples/mediaplayer/mediaplayer.cpp +++ b/samples/mediaplayer/mediaplayer.cpp @@ -1,4 +1,4 @@ -///////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// // Name: mediaplayer.cpp // Purpose: wxMediaCtrl sample // Author: Ryan Norton @@ -7,14 +7,37 @@ // RCS-ID: $Id$ // Copyright: (c) Ryan Norton // Licence: wxWindows licence -///////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +// MediaPlayer +// +// This is a somewhat comprehensive 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, +// select the file you want to play - and MediaPlayer will play the file in a +// the current notebook page, showing video if necessary. +// +// You can select one of the menu options, or move the slider around +// to manipulate what is playing. +// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +// Known bugs with wxMediaCtrl: +// +// 1) Certain backends can't play the same media file at the same time (MCI, +// Cocoa NSMovieView-Quicktime). +// 2) Positioning on Mac Carbon is messed up if put in a sub-control like a +// Notebook (like this sample does). +// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // ============================================================================ -// declarations +// Definitions // ============================================================================ // ---------------------------------------------------------------------------- -// headers +// Pre-compiled header stuff // ---------------------------------------------------------------------------- #include "wx/wxprec.h" @@ -28,7 +51,7 @@ #endif // ---------------------------------------------------------------------------- -// resources +// Headers // ---------------------------------------------------------------------------- #include "wx/mediactrl.h" //for wxMediaCtrl @@ -36,88 +59,313 @@ #include "wx/slider.h" //for a slider for seeking within media #include "wx/sizer.h" //for positioning controls/wxBoxSizer #include "wx/timer.h" //timer for updating status bar -#include "wx/textdlg.h" //for getting user text from OpenURL +#include "wx/textdlg.h" //for getting user text from OpenURL/Debug +#include "wx/notebook.h" //for wxNotebook and putting movies in pages +#include "wx/cmdline.h" //for wxCmdLineParser (optional) +#include "wx/listctrl.h" //for wxListCtrl +#include "wx/dnd.h" //drag and drop for the playlist +#include "wx/filename.h" //For wxFileName::GetName() +#include "wx/config.h" //for native wxConfig + +// ---------------------------------------------------------------------------- +// Bail out if the user doesn't want one of the +// things we need +// ---------------------------------------------------------------------------- +// RN: I'm not sure why this is here - even minimal doesn't check for +// wxUSE_GUI. I may have added it myself though... +#if !wxUSE_GUI +#error "This is a GUI sample" +#endif -#if !wxUSE_MEDIACTRL -#error "wxUSE_MEDIACTRL must be enabled to use this sample!" +#if !wxUSE_MEDIACTRL || !wxUSE_MENUS || !wxUSE_SLIDER || !wxUSE_TIMER || \ + !wxUSE_NOTEBOOK || !wxUSE_LISTCTRL +#error "Not all required elements are enabled. Please modify setup.h!" #endif -// ---------------------------------------------------------------------------- +// ============================================================================ // Declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// Enumurations +// ---------------------------------------------------------------------------- + +// IDs for the controls and the menu commands +enum +{ + // Menu event IDs + wxID_LOOP = 1, + wxID_OPENFILESAMEPAGE, + wxID_OPENFILENEWPAGE, + wxID_OPENURLSAMEPAGE, + wxID_OPENURLNEWPAGE, + wxID_CLOSECURRENTPAGE, + wxID_PLAY, + wxID_PAUSE, + wxID_NEXT, + wxID_PREV, + wxID_SELECTBACKEND, + wxID_SHOWINTERFACE, +// wxID_STOP, [built-in to wxWidgets] +// wxID_ABOUT, [built-in to wxWidgets] +// wxID_EXIT, [built-in to wxWidgets] + // Control event IDs + wxID_SLIDER, + wxID_PBSLIDER, + wxID_VOLSLIDER, + wxID_NOTEBOOK, + wxID_MEDIACTRL, + wxID_BUTTONNEXT, + wxID_BUTTONPREV, + wxID_BUTTONSTOP, + wxID_BUTTONPLAY, + wxID_BUTTONVD, + wxID_BUTTONVU, + wxID_LISTCTRL, + wxID_GAUGE +}; + +// ---------------------------------------------------------------------------- +// wxMediaPlayerApp // ---------------------------------------------------------------------------- -class MyApp : public wxApp +class wxMediaPlayerApp : public wxApp { public: +#ifdef __WXMAC__ + virtual void MacOpenFile(const wxString & fileName ); +#endif + virtual bool OnInit(); + +protected: + class wxMediaPlayerFrame* m_frame; }; -class MyFrame : public wxFrame +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame +// ---------------------------------------------------------------------------- + +class wxMediaPlayerFrame : public wxFrame { public: - // ctor(s) - MyFrame(const wxString& title); - ~MyFrame(); + // Ctor/Dtor + wxMediaPlayerFrame(const wxString& title); + ~wxMediaPlayerFrame(); - // event handlers (these functions should _not_ be virtual) + // Menu event handlers void OnQuit(wxCommandEvent& event); void OnAbout(wxCommandEvent& event); - void OnLoop(wxCommandEvent& event); - void OnOpenFile(wxCommandEvent& event); - void OnOpenURL(wxCommandEvent& event); + void OnOpenFileSamePage(wxCommandEvent& event); + void OnOpenFileNewPage(wxCommandEvent& event); + void OnOpenURLSamePage(wxCommandEvent& event); + void OnOpenURLNewPage(wxCommandEvent& event); + void OnCloseCurrentPage(wxCommandEvent& event); void OnPlay(wxCommandEvent& event); void OnPause(wxCommandEvent& event); void OnStop(wxCommandEvent& event); + void OnNext(wxCommandEvent& event); + void OnPrev(wxCommandEvent& event); + void OnVolumeDown(wxCommandEvent& event); + void OnVolumeUp(wxCommandEvent& event); - void OnSeek(wxCommandEvent& event); + void OnLoop(wxCommandEvent& event); + void OnShowInterface(wxCommandEvent& event); - void OnMediaFinished(wxMediaEvent& event); + void OnSelectBackend(wxCommandEvent& event); + + // Key event handlers + void OnKeyDown(wxKeyEvent& event); + + // Quickie for playing from command line + void AddToPlayList(const wxString& szString); + + // ListCtrl event handlers + void OnChangeSong(wxListEvent& event); + + // Media event handlers + void OnMediaLoaded(wxMediaEvent& event); + + // Close event handlers + void OnClose(wxCloseEvent& event); private: - void ResetStatus(); + // Common open file code + void OpenFile(bool bNewPage); + void OpenURL(bool bNewPage); + void DoOpenFile(const wxString& path, bool bNewPage); + void DoPlayFile(const wxString& path); + + class wxMediaPlayerTimer* m_timer; //Timer to write info to status bar + wxNotebook* m_notebook; //Notebook containing our pages + + // Maybe I should use more accessors, but for simplicity + // I'll allow the other classes access to our members + friend class wxMediaPlayerApp; + friend class wxMediaPlayerNotebookPage; + friend class wxMediaPlayerTimer; +}; + + - wxMediaCtrl* m_mediactrl; - wxSlider* m_slider; - wxBoxSizer* m_sizer; - class MyTimer* m_timer; - friend class MyTimer; - wxString m_basestatus; +// ---------------------------------------------------------------------------- +// wxMediaPlayerNotebookPage +// ---------------------------------------------------------------------------- - bool m_bLoop; +class wxMediaPlayerNotebookPage : public wxPanel +{ + wxMediaPlayerNotebookPage(wxMediaPlayerFrame* parentFrame, + wxNotebook* book, const wxString& be = wxEmptyString); + + // Slider event handlers + void OnBeginSeek(wxScrollEvent& event); + void OnEndSeek(wxScrollEvent& event); + void OnPBChange(wxScrollEvent& event); + void OnVolChange(wxScrollEvent& event); + + // Media event handlers + void OnMediaPlay(wxMediaEvent& event); + void OnMediaPause(wxMediaEvent& event); + void OnMediaStop(wxMediaEvent& event); + void OnMediaFinished(wxMediaEvent& event); - // any class wishing to process wxWidgets events must use this macro - DECLARE_EVENT_TABLE() +public: + bool IsBeingDragged(); //accessor for m_bIsBeingDragged + + //make wxMediaPlayerFrame able to access the private members + friend class wxMediaPlayerFrame; + + int m_nLastFileId; //List ID of played file in listctrl + wxString m_szFile; //Name of currently playing file/location + + wxMediaCtrl* m_mediactrl; //Our media control + class wxMediaPlayerListCtrl* m_playlist; //Our playlist + wxSlider* m_slider; //The slider below our media control + wxSlider* m_pbSlider; //Lower-left slider for adjusting speed + wxSlider* m_volSlider; //Lower-right slider for adjusting volume + int m_nLoops; //Number of times media has looped + bool m_bLoop; //Whether we are looping or not + bool m_bIsBeingDragged; //Whether the user is dragging the scroll bar + wxMediaPlayerFrame* m_parentFrame; //Main wxFrame of our sample + wxButton* m_prevButton; //Go to previous file button + wxButton* m_playButton; //Play/pause file button + wxButton* m_stopButton; //Stop playing file button + wxButton* m_nextButton; //Next file button + wxButton* m_vdButton; //Volume down button + wxButton* m_vuButton; //Volume up button + wxGauge* m_gauge; //Gauge to keep in line with slider }; +// ---------------------------------------------------------------------------- +// wxMediaPlayerTimer +// ---------------------------------------------------------------------------- + +class wxMediaPlayerTimer : public wxTimer +{ +public: + //Ctor + wxMediaPlayerTimer(wxMediaPlayerFrame* frame) {m_frame = frame;} + + //Called each time the timer's timeout expires + void Notify(); + + wxMediaPlayerFrame* m_frame; //The wxMediaPlayerFrame +}; + +// ---------------------------------------------------------------------------- +// wxMediaPlayerListCtrl +// ---------------------------------------------------------------------------- +class wxMediaPlayerListCtrl : public wxListCtrl +{ +public: + void AddToPlayList(const wxString& szString) + { + wxListItem kNewItem; + kNewItem.SetAlign(wxLIST_FORMAT_LEFT); + + int nID = this->GetItemCount(); + kNewItem.SetId(nID); + kNewItem.SetMask(wxLIST_MASK_DATA); + kNewItem.SetData(new wxString(szString)); + + this->InsertItem(kNewItem); + this->SetItem(nID, 0, wxT("*")); + this->SetItem(nID, 1, wxFileName(szString).GetName()); + + if (nID % 2) + { + kNewItem.SetBackgroundColour(wxColour(192,192,192)); + this->SetItem(kNewItem); + } + } + + void GetSelectedItem(wxListItem& listitem) + { + listitem.SetMask(wxLIST_MASK_TEXT | wxLIST_MASK_DATA); + int nLast = -1, nLastSelected = -1; + while ((nLast = this->GetNextItem(nLast, + wxLIST_NEXT_ALL, + wxLIST_STATE_SELECTED)) != -1) + { + listitem.SetId(nLast); + this->GetItem(listitem); + if ((listitem.GetState() & wxLIST_STATE_FOCUSED) ) + break; + nLastSelected = nLast; + } + if (nLast == -1 && nLastSelected == -1) + return; + listitem.SetId(nLastSelected == -1 ? nLast : nLastSelected); + this->GetItem(listitem); + } +}; + +// ---------------------------------------------------------------------------- +// wxPlayListDropTarget // -//ResetStatus -//----------- -//Here we just make a simple status string -//with some useful info about the media -//We display info here in seconds (wxMediaCtrl -//uses milliseconds - that's why we divide by 1000) -// -void MyFrame::ResetStatus() +// Drop target for playlist (i.e. user drags a file from explorer unto +// playlist it adds the file) +// ---------------------------------------------------------------------------- +#if wxUSE_DRAG_AND_DROP +class wxPlayListDropTarget : public wxFileDropTarget { - m_basestatus = wxString::Format(_T("Size(x,y):%i,%i Length(Seconds):%u Speed:%1.1fx"), - m_mediactrl->GetBestSize().x, - m_mediactrl->GetBestSize().y, - m_mediactrl->GetDuration() / 1000, - m_mediactrl->GetPlaybackRate() - ); - - m_slider->SetRange(0, m_mediactrl->GetDuration() / 1000); -} +public: + wxPlayListDropTarget(wxMediaPlayerListCtrl& list) : m_list(list) {} + ~wxPlayListDropTarget(){} + virtual bool OnDropFiles(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), + const wxArrayString& files) + { + for (size_t i = 0; i < files.GetCount(); ++i) + { + m_list.AddToPlayList(files[i]); + } + return true; + } + wxMediaPlayerListCtrl& m_list; +}; +#endif + +// ============================================================================ +// +// Implementation +// +// ============================================================================ +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +// [Functions] // -//wxGetMediaStateText -//------------------- -//Converts a wxMediaCtrl state into something -//useful that we can display +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +// ---------------------------------------------------------------------------- +// wxGetMediaStateText // +// Converts a wxMediaCtrl state into something useful that we can display +// to the user +// ---------------------------------------------------------------------------- const wxChar* wxGetMediaStateText(int nState) { switch(nState) @@ -132,333 +380,1469 @@ const wxChar* wxGetMediaStateText(int nState) } } -class MyTimer : public wxTimer -{ -public: - MyTimer(MyFrame* frame) {m_frame = frame;} - - // - //Notify - //----------- - //Updates the main frame's status bar with the current - //position within the media and state the media is in - // - void Notify() - { - long lPosition = m_frame->m_mediactrl->GetPosition() / 1000; - m_frame->m_slider->SetValue(lPosition); - - - m_frame->SetStatusText(wxString::Format(_T("%s Pos:%u State:%s"), - m_frame->m_basestatus.c_str(), - lPosition, - wxGetMediaStateText(m_frame->m_mediactrl->GetState()) - ) - ); - - } - - MyFrame* m_frame; -}; - +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +// wxMediaPlayerApp +// +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // ---------------------------------------------------------------------------- -// constants +// This sets up this wxApp as the global wxApp that gui calls in wxWidgets +// use. For example, if you were to be in windows and use a file dialog, +// wxWidgets would use wxTheApp->GetHInstance() which would get the instance +// handle of the application. These routines in wx _DO NOT_ check to see if +// 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 +// not desire this behavior. // ---------------------------------------------------------------------------- +IMPLEMENT_APP(wxMediaPlayerApp) -// IDs for the controls and the menu commands -enum +// ---------------------------------------------------------------------------- +// wxMediaPlayerApp::OnInit +// +// Where execution starts - akin to a main or WinMain. +// 1) Create the frame and show it to the user +// 2) Process filenames from the commandline +// 3) return true specifying that we want execution to continue past OnInit +// ---------------------------------------------------------------------------- +bool wxMediaPlayerApp::OnInit() { - // menu items - Minimal_Quit = wxID_EXIT, - Minimal_Loop, - Minimal_OpenFile, - Minimal_Play, - Minimal_Pause, - Minimal_Stop, - Minimal_About = wxID_ABOUT, + if ( !wxApp::OnInit() ) + return false; - // id for our slider - Minimal_Slider = 1, - - // id for our wxMediaCtrl - Minimal_Media -}; + // SetAppName() lets wxConfig and others know where to write + SetAppName(wxT("wxMediaPlayer")); -// ---------------------------------------------------------------------------- -// event tables and other macros for wxWidgets -// ---------------------------------------------------------------------------- + wxMediaPlayerFrame *frame = + new wxMediaPlayerFrame(wxT("MediaPlayer wxWidgets Sample")); + frame->Show(true); -BEGIN_EVENT_TABLE(MyFrame, wxFrame) - //Menu events - EVT_MENU(Minimal_Quit, MyFrame::OnQuit) - EVT_MENU(Minimal_About, MyFrame::OnAbout) - EVT_MENU(Minimal_Loop, MyFrame::OnLoop) - EVT_MENU(Minimal_OpenFile, MyFrame::OnOpenFile) - EVT_MENU(Minimal_Play, MyFrame::OnPlay) - EVT_MENU(Minimal_Pause, MyFrame::OnPause) - EVT_MENU(Minimal_Stop, MyFrame::OnStop) +#if wxUSE_CMDLINE_PARSER + // + // What this does is get all the command line arguments + // and treat each one as a file to put to the initial playlist + // + wxCmdLineEntryDesc cmdLineDesc[2]; + cmdLineDesc[0].kind = wxCMD_LINE_PARAM; + cmdLineDesc[0].shortName = NULL; + cmdLineDesc[0].longName = NULL; + cmdLineDesc[0].description = wxT("input files"); + cmdLineDesc[0].type = wxCMD_LINE_VAL_STRING; + cmdLineDesc[0].flags = wxCMD_LINE_PARAM_OPTIONAL | wxCMD_LINE_PARAM_MULTIPLE; - //Slider events - EVT_SLIDER(Minimal_Slider, MyFrame::OnSeek) + cmdLineDesc[1].kind = wxCMD_LINE_NONE; - //wxMediaCtrl events - EVT_MEDIA_FINISHED(Minimal_Media, MyFrame::OnMediaFinished) -END_EVENT_TABLE() + //gets the passed media files from cmd line + wxCmdLineParser parser (cmdLineDesc, argc, argv); -//main/WinMain() -IMPLEMENT_APP(MyApp) + // get filenames from the commandline + if (parser.Parse() == 0) + { + for (size_t paramNr=0; paramNr < parser.GetParamCount(); ++paramNr) + { + frame->AddToPlayList((parser.GetParam (paramNr))); + } + wxCommandEvent theEvent(wxEVT_COMMAND_MENU_SELECTED, wxID_NEXT); + frame->AddPendingEvent(theEvent); + } +#endif -// ============================================================================ -// implementation -// ============================================================================ + return true; +} -// ---------------------------------------------------------------------------- -// MyApp -// ---------------------------------------------------------------------------- +#ifdef __WXMAC__ -// 'Main program' equivalent: the program execution "starts" here -bool MyApp::OnInit() +void wxMediaPlayerApp::MacOpenFile(const wxString & fileName ) { - MyFrame *frame = new MyFrame(_T("Minimal wxWidgets App")); - frame->Show(true); - - return true; + //Called when a user drags a file over our app + m_frame->DoOpenFile(fileName, true /* new page */); } -// ---------------------------------------------------------------------------- -// main frame -// ---------------------------------------------------------------------------- +#endif // __WXMAC__ +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +// wxMediaPlayerFrame // -//MyFrame -//------- -//Creates our menus and controls +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame Constructor // -MyFrame::MyFrame(const wxString& title) - : wxFrame(NULL, wxID_ANY, title), m_timer(NULL) +// 1) Create our menus +// 2) Create our notebook control and add it to the frame +// 3) Create our status bar +// 4) Connect our events +// 5) Start our timer +// ---------------------------------------------------------------------------- + +wxMediaPlayerFrame::wxMediaPlayerFrame(const wxString& title) + : wxFrame(NULL, wxID_ANY, title, wxDefaultPosition, wxSize(600,600)) { // // Create Menus // -#if wxUSE_MENUS - wxMenu *menuFile = new wxMenu; - + wxMenu *fileMenu = new wxMenu; + wxMenu *controlsMenu = new wxMenu; + wxMenu *optionsMenu = new wxMenu; wxMenu *helpMenu = new wxMenu; - helpMenu->Append(Minimal_About, _T("&About...\tF1"), _T("Show about dialog")); - - menuFile->Append(Minimal_OpenFile, _T("&Open File"), _T("Open a File")); - menuFile->AppendSeparator(); - menuFile->Append(Minimal_Play, _T("&Play"), _T("Resume playback")); - menuFile->Append(Minimal_Pause, _T("P&ause"), _T("Pause playback")); - menuFile->Append(Minimal_Stop, _T("&Stop"), _T("Stop playback")); - menuFile->AppendSeparator(); - menuFile->AppendCheckItem(Minimal_Loop, _T("&Loop"), _T("Loop Selected Media")); - menuFile->AppendSeparator(); - menuFile->Append(Minimal_Quit, _T("E&xit\tAlt-X"), _T("Quit this program")); + wxMenu *debugMenu = new wxMenu; + + fileMenu->Append(wxID_OPENFILESAMEPAGE, wxT("&Open File\tCtrl-Shift-O"), + wxT("Open a File in the current notebook page")); + fileMenu->Append(wxID_OPENFILENEWPAGE, wxT("&Open File in a new page"), + wxT("Open a File in a new notebook page")); + fileMenu->Append(wxID_OPENURLSAMEPAGE, wxT("&Open URL"), + wxT("Open a URL in the current notebook page")); + fileMenu->Append(wxID_OPENURLNEWPAGE, wxT("&Open URL in a new page"), + wxT("Open a URL in a new notebook page")); + fileMenu->AppendSeparator(); + fileMenu->Append(wxID_CLOSECURRENTPAGE, wxT("&Close Current Page\tCtrl-C"), + wxT("Close current notebook page")); + fileMenu->AppendSeparator(); + fileMenu->Append(wxID_EXIT, + wxT("E&xit\tAlt-X"), + wxT("Quit this program")); + + controlsMenu->Append(wxID_PLAY, wxT("&Play/Pause\tCtrl-P"), wxT("Resume/Pause playback")); + controlsMenu->Append(wxID_STOP, wxT("&Stop\tCtrl-S"), wxT("Stop playback")); + controlsMenu->AppendSeparator(); + controlsMenu->Append(wxID_PREV, wxT("&Previous\tCtrl-B"), wxT("Go to previous track")); + controlsMenu->Append(wxID_NEXT, wxT("&Next\tCtrl-N"), wxT("Skip to next track")); + + optionsMenu->AppendCheckItem(wxID_LOOP, + wxT("&Loop\tCtrl-L"), + wxT("Loop Selected Media")); + optionsMenu->AppendCheckItem(wxID_SHOWINTERFACE, + wxT("&Show Interface\tCtrl-I"), + wxT("Show wxMediaCtrl native controls")); + + debugMenu->Append(wxID_SELECTBACKEND, + wxT("&Select Backend...\tCtrl-D"), + wxT("Select a backend manually")); + + helpMenu->Append(wxID_ABOUT, + wxT("&About...\tF1"), + wxT("Show about dialog")); - wxMenuBar *menuBar = new wxMenuBar(); - menuBar->Append(menuFile, _T("&File")); - menuBar->Append(helpMenu, _T("&Help")); + wxMenuBar *menuBar = new wxMenuBar(); + menuBar->Append(fileMenu, wxT("&File")); + menuBar->Append(controlsMenu, wxT("&Controls")); + menuBar->Append(optionsMenu, wxT("&Options")); + menuBar->Append(debugMenu, wxT("&Debug")); + menuBar->Append(helpMenu, wxT("&Help")); SetMenuBar(menuBar); -#endif // wxUSE_MENUS // - // Create and attach the first/main sizer + // Create our notebook - using wxNotebook is luckily pretty + // simple and self-explanatory in most cases // - - m_sizer = new wxBoxSizer(wxVERTICAL); - this->SetSizer(m_sizer); - this->SetAutoLayout(true); + m_notebook = new wxNotebook(this, wxID_NOTEBOOK); // - // Create our media control + // Create our status bar // +#if wxUSE_STATUSBAR + // create a status bar just for fun (by default with 1 pane only) + CreateStatusBar(1); +#endif // wxUSE_STATUSBAR - m_mediactrl = new wxMediaCtrl(this, Minimal_Media, wxT("")); - m_sizer->Add(m_mediactrl, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5); + // + // Connect events. + // + // There are two ways in wxWidgets to use events - + // Message Maps and Connections. + // + // Message Maps are implemented by putting + // DECLARE_MESSAGE_MAP in your wxEvtHandler-derived + // class you want to use for events, such as wxMediaPlayerFrame. + // + // Then after your class declaration you put + // BEGIN_EVENT_TABLE(wxMediaPlayerFrame, wxFrame) + // EVT_XXX(XXX)... + // END_EVENT_TABLE() + // + // Where wxMediaPlayerFrame is the class with the DECLARE_MESSAGE_MAP + // 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. + // + // However, with wxEvtHandler::Connect you can avoid a + // global message map for your class and those annoying + // macros. You can also change the context in which + // the call the handler (more later). + // + // The downside is that due to the limitation that + // wxWidgets doesn't use templates in certain areas, + // You have to triple-cast the event function. + // + // There are five parameters to wxEvtHandler::Connect - + // + // The first is the id of the instance whose events + // you want to handle - i.e. a menu id for menus, + // a control id for controls (wxControl::GetId()) + // and so on. + // + // The second is the event id. This is the same + // as the message maps (EVT_MENU) except prefixed + // with "wx" (wxEVT_MENU). + // + // 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 + // wxObjectEventFunction - I.E. + // (wxObjectEventFunction)(wxEventFunction) + // (wxCommandEventFunction) &wxMediaPlayerFrame::MyHandler + // + // Or, you can use the new (2.5.5+) event handler + // conversion macros - for instance the above could + // be done as + // wxCommandEventHandler(wxMediaPlayerFrame::MyHandler) + // pretty simple, eh? + // + // The fourth is an optional userdata param - + // this is of historical relevance only and is + // there only for backwards compatibility. + // + // 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()" + // it would literally do this->MyFunc. However, + // if you were to pass myHandler as the fifth + // parameter, for instance, you would _really_ + // be calling myHandler->MyFunc, even though + // the compiler doesn't really know it. + // // - // Create our slider + // Menu events // + this->Connect(wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnQuit)); - m_slider = new wxSlider(this, Minimal_Slider, 0, //init - 0, //start - 0, //end - wxDefaultPosition, wxDefaultSize, - wxSL_HORIZONTAL ); - m_sizer->Add(m_slider, 0, wxALIGN_CENTER_HORIZONTAL|wxALL|wxEXPAND , 5); + this->Connect(wxID_ABOUT, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnAbout)); + + this->Connect(wxID_LOOP, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnLoop)); + + this->Connect(wxID_SHOWINTERFACE, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnShowInterface)); + + this->Connect(wxID_OPENFILENEWPAGE, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnOpenFileNewPage)); + + this->Connect(wxID_OPENFILESAMEPAGE, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnOpenFileSamePage)); + this->Connect(wxID_OPENURLNEWPAGE, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnOpenURLNewPage)); + + this->Connect(wxID_OPENURLSAMEPAGE, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnOpenURLSamePage)); + + this->Connect(wxID_CLOSECURRENTPAGE, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnCloseCurrentPage)); + + this->Connect(wxID_PLAY, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnPlay)); + + this->Connect(wxID_STOP, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnStop)); + + this->Connect(wxID_NEXT, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnNext)); + + this->Connect(wxID_PREV, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnPrev)); + + this->Connect(wxID_SELECTBACKEND, wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxMediaPlayerFrame::OnSelectBackend)); // - // Create the second sizer which will position things - // vertically - + // Key events // - // -------Menu---------- - // [m_mediactrl] + wxTheApp->Connect(wxID_ANY, wxEVT_KEY_DOWN, + wxKeyEventHandler(wxMediaPlayerFrame::OnKeyDown), + (wxObject*)0, this); + // - // [m_slider] + // Close events // - - wxBoxSizer* horzsizer = new wxBoxSizer(wxHORIZONTAL); - m_sizer->Add(horzsizer, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5); + this->Connect(wxID_ANY, wxEVT_CLOSE_WINDOW, + wxCloseEventHandler(wxMediaPlayerFrame::OnClose)); // - // We arn't looping initially + // End of Events // - m_bLoop = false; + // + // Create an initial notebook page so the user has something + // to work with without having to go file->open every time :). + // + wxMediaPlayerNotebookPage* page = + new wxMediaPlayerNotebookPage(this, m_notebook); + m_notebook->AddPage(page, + wxT(""), + true); // - // Create our status bar + // Here we load the our configuration - + // in our case we load all the files that were left in + // the playlist the last time the user closed our application // -#if wxUSE_STATUSBAR - // create a status bar just for fun (by default with 1 pane only) - CreateStatusBar(1); - ResetStatus(); - SetStatusText(m_basestatus); -#endif // wxUSE_STATUSBAR + // As an exercise to the reader try modifying it so that + // it properly loads the playlist for each page without + // conflicting (loading the same data) with the other ones. + // + wxConfig conf; + wxString key, outstring; + for(int i = 0; ; ++i) + { + key.clear(); + key << i; + if(!conf.Read(key, &outstring)) + break; + page->m_playlist->AddToPlayList(outstring); + } // // Create a timer to update our status bar // - - m_timer = new MyTimer(this); - m_timer->Start(100); + m_timer = new wxMediaPlayerTimer(this); + m_timer->Start(500); } +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame Destructor // -//~MyFrame -//------- -//Deletes child objects implicitly and our timer explicitly -// -MyFrame::~MyFrame() +// 1) Deletes child objects implicitly +// 2) Delete our timer explicitly +// ---------------------------------------------------------------------------- +wxMediaPlayerFrame::~wxMediaPlayerFrame() { + // Shut down our timer delete m_timer; + + // + // Here we save our info to the registry or whatever + // mechanism the OS uses. + // + // This makes it so that when mediaplayer loads up again + // it restores the same files that were in the playlist + // this time, rather than the user manually re-adding them. + // + // We need to do conf->DeleteAll() here because by default + // the config still contains the same files as last time + // so we need to clear it before writing our new ones. + // + // TODO: Maybe you could add a menu option to the + // options menu to delete the configuration on exit - + // all you'd need to do is just remove everything after + // conf->DeleteAll() here + // + // As an exercise to the reader, try modifying this so + // that it saves the data for each notebook page + // + wxMediaPlayerListCtrl* playlist = + ((wxMediaPlayerNotebookPage*)m_notebook->GetPage(0))->m_playlist; + + wxConfig conf; + conf.DeleteAll(); + + for(int i = 0; i < playlist->GetItemCount(); ++i) + { + wxString* pData = (wxString*) playlist->GetItemData(i); + wxString s; + s << i; + conf.Write(s, *(pData)); + delete pData; + } } +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnClose +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnClose(wxCloseEvent& event) +{ + event.Skip(); //really close the frame +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::AddToPlayList +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::AddToPlayList(const wxString& szString) +{ + wxMediaPlayerNotebookPage* currentpage = + ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage()); + + currentpage->m_playlist->AddToPlayList(szString); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnQuit // -//OnQuit -//------- -//Called from file->quit. -//Closes this application. -// -void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event)) +// Called from file->quit. +// Closes this application. +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnQuit(wxCommandEvent& WXUNUSED(event)) { // true is to force the frame to close Close(true); } +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnAbout // -//OnAbout -//------- -//Called from help->about. -//Gets some info about this application. -// -void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event)) +// Called from help->about. +// Gets some info about this application. +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnAbout(wxCommandEvent& WXUNUSED(event)) { wxString msg; - msg.Printf( _T("This is a test of wxMediaCtrl.\n") - _T("Welcome to %s"), wxVERSION_STRING); + msg.Printf( wxT("This is a test of wxMediaCtrl.\n\n") + + wxT("Intructions:\n") + + wxT("The top slider shows the current the current position, ") + wxT("which you can change by dragging and releasing it.\n") + + wxT("The gauge (progress bar) shows the progress in ") + wxT("downloading data of the current file - it may always be ") + wxT("Empty due to lack of support from the current backend.\n") + + wxT("The lower-left slider controls the volume and the lower-") + wxT("right slider controls the playback rate/speed of the ") + wxT("media\n\n") + + wxT("Currently using: %s"), wxVERSION_STRING); - wxMessageBox(msg, _T("About wxMediaCtrl test"), wxOK | wxICON_INFORMATION, this); + wxMessageBox(msg, wxT("About wxMediaCtrl test"), + wxOK | wxICON_INFORMATION, this); } +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnLoop // -//OnLoop -//------- -//Called from file->loop. -//Changes the state of whether we want to loop or not. -// -void MyFrame::OnLoop(wxCommandEvent& WXUNUSED(event)) +// Called from file->loop. +// Changes the state of whether we want to loop or not. +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnLoop(wxCommandEvent& WXUNUSED(event)) { - m_bLoop = !m_bLoop; + wxMediaPlayerNotebookPage* currentpage = + ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage()); + + currentpage->m_bLoop = !currentpage->m_bLoop; } +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnLoop // -//OnOpenFile -//------- -//Called from file->openfile. -//Opens and plays a media file -// -void MyFrame::OnOpenFile(wxCommandEvent& WXUNUSED(event)) +// Called from file->loop. +// Changes the state of whether we want to loop or not. +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnShowInterface(wxCommandEvent& event) { - wxFileDialog fd(this); + wxMediaPlayerNotebookPage* currentpage = + ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage()); - if(fd.ShowModal() == wxID_OK) + if( !currentpage->m_mediactrl->ShowPlayerControls(event.IsChecked() ? + wxMEDIACTRLPLAYERCONTROLS_DEFAULT : + wxMEDIACTRLPLAYERCONTROLS_NONE) ) { - if( !m_mediactrl->Load(fd.GetPath()) ) - wxMessageBox(wxT("Couldn't load file!")); - - if( !m_mediactrl->Play() ) - wxMessageBox(wxT("Couldn't play movie!")); - - ResetStatus(); + //error - uncheck and warn user + wxMenuItem* pSIItem = GetMenuBar()->FindItem(wxID_SHOWINTERFACE); + wxASSERT(pSIItem); + pSIItem->Check(!event.IsChecked()); + + if(event.IsChecked()) + wxMessageBox(wxT("Could not show player controls")); + else + wxMessageBox(wxT("Could not hide player controls")); } } +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnOpenFileSamePage // -//OnPlay -//------- -//Called from file->play. -//Resumes the media if it is paused or stopped. -// -void MyFrame::OnPlay(wxCommandEvent& WXUNUSED(event)) +// Called from file->openfile. +// Opens and plays a media file in the current notebook page +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnOpenFileSamePage(wxCommandEvent& WXUNUSED(event)) { - if( !m_mediactrl->Play() ) - wxMessageBox(wxT("Couldn't play movie!")); + OpenFile(false); } +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnOpenFileNewPage // -//OnPause -//------- -//Called from file->pause. -//Pauses the media in-place. -// -void MyFrame::OnPause(wxCommandEvent& WXUNUSED(event)) +// Called from file->openfileinnewpage. +// Opens and plays a media file in a new notebook page +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnOpenFileNewPage(wxCommandEvent& WXUNUSED(event)) { - if( !m_mediactrl->Pause() ) - wxMessageBox(wxT("Couldn't pause movie!")); + OpenFile(true); } +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OpenFile // -//OnStop -//------- -//Called from file->stop. -//Note that where the media stops is undefined - -//it could stop at the end or beginning. -// -void MyFrame::OnStop(wxCommandEvent& WXUNUSED(event)) +// Opens a file dialog asking the user for a filename, then +// calls DoOpenFile which will add the file to the playlist and play it +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OpenFile(bool bNewPage) { - if( !m_mediactrl->Stop() ) - wxMessageBox(wxT("Couldn't stop movie!")); -} + wxFileDialog fd(this); -// -//OnSeek -//------- -//Called from file->seek. -//Called when the user moves the slider - -//seeks to a position within the media -// -void MyFrame::OnSeek(wxCommandEvent& WXUNUSED(event)) -{ - if( !m_mediactrl->SetPosition( m_slider->GetValue() * 1000 ) ) - wxMessageBox(wxT("Couldn't seek in movie!")); + if(fd.ShowModal() == wxID_OK) + { + DoOpenFile(fd.GetPath(), bNewPage); + } } +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::DoOpenFile // -//OnMediaFinished -//------- -//Called when the media stops playing. -//Here we loop it if the user wants to (has been selected from file menu) -// -void MyFrame::OnMediaFinished(wxMediaEvent& WXUNUSED(event)) +// Adds the file to our playlist, selects it in the playlist, +// and then calls DoPlayFile to play it +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::DoOpenFile(const wxString& path, bool bNewPage) { - if(m_bLoop) + if(bNewPage) { - if ( !m_mediactrl->SetPosition(0) || !m_mediactrl->Play() ) - wxMessageBox(wxT("Couldn't seek or play to loop movie!")); + m_notebook->AddPage( + new wxMediaPlayerNotebookPage(this, m_notebook), + path, + true); } -} \ No newline at end of file + + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + if(currentpage->m_nLastFileId != -1) + currentpage->m_playlist->SetItemState(currentpage->m_nLastFileId, + 0, wxLIST_STATE_SELECTED); + + wxListItem newlistitem; + newlistitem.SetAlign(wxLIST_FORMAT_LEFT); + + int nID; + + newlistitem.SetId(nID = currentpage->m_playlist->GetItemCount()); + newlistitem.SetMask(wxLIST_MASK_DATA | wxLIST_MASK_STATE); + newlistitem.SetState(wxLIST_STATE_SELECTED); + newlistitem.SetData(new wxString(path)); + + currentpage->m_playlist->InsertItem(newlistitem); + currentpage->m_playlist->SetItem(nID, 0, wxT("*")); + currentpage->m_playlist->SetItem(nID, 1, wxFileName(path).GetName()); + + if (nID % 2) + { + newlistitem.SetBackgroundColour(wxColour(192,192,192)); + currentpage->m_playlist->SetItem(newlistitem); + } + + DoPlayFile(path); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::DoPlayFile +// +// Pauses the file if its the currently playing file, +// otherwise it plays the file +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::DoPlayFile(const wxString& path) +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + wxListItem listitem; + currentpage->m_playlist->GetSelectedItem(listitem); + + if( ( listitem.GetData() && + currentpage->m_nLastFileId == listitem.GetId() && + currentpage->m_szFile.compare(path) == 0 ) || + ( !listitem.GetData() && + currentpage->m_nLastFileId != -1 && + currentpage->m_szFile.compare(path) == 0) + ) + { + if(currentpage->m_mediactrl->GetState() == wxMEDIASTATE_PLAYING) + { + if( !currentpage->m_mediactrl->Pause() ) + wxMessageBox(wxT("Couldn't pause movie!")); + } + else + { + if( !currentpage->m_mediactrl->Play() ) + wxMessageBox(wxT("Couldn't play movie!")); + } + } + else + { + int nNewId = listitem.GetData() ? listitem.GetId() : + currentpage->m_playlist->GetItemCount()-1; + m_notebook->SetPageText(m_notebook->GetSelection(), + wxFileName(path).GetName()); + + if(currentpage->m_nLastFileId != -1) + currentpage->m_playlist->SetItem( + currentpage->m_nLastFileId, 0, wxT("*")); + + wxURI uripath(path); + if( uripath.IsReference() ) + { + if( !currentpage->m_mediactrl->Load(path) ) + { + wxMessageBox(wxT("Couldn't load file!")); + currentpage->m_playlist->SetItem(nNewId, 0, wxT("E")); + } + else + { + currentpage->m_playlist->SetItem(nNewId, 0, wxT("O")); + } + } + else + { + if( !currentpage->m_mediactrl->Load(uripath) ) + { + wxMessageBox(wxT("Couldn't load URL!")); + currentpage->m_playlist->SetItem(nNewId, 0, wxT("E")); + } + else + { + currentpage->m_playlist->SetItem(nNewId, 0, wxT("O")); + } + } + + currentpage->m_nLastFileId = nNewId; + currentpage->m_szFile = path; + currentpage->m_playlist->SetItem(currentpage->m_nLastFileId, + 1, wxFileName(path).GetName()); + currentpage->m_playlist->SetItem(currentpage->m_nLastFileId, + 2, wxT("")); + } +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnMediaLoaded +// +// Called when the media is ready to be played - and does +// so, also gets the length of media and shows that in the list control +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnMediaLoaded(wxMediaEvent& WXUNUSED(evt)) +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + if( !currentpage->m_mediactrl->Play() ) + { + wxMessageBox(wxT("Couldn't play movie!")); + currentpage->m_playlist->SetItem(currentpage->m_nLastFileId, 0, wxT("E")); + } + else + { + currentpage->m_playlist->SetItem(currentpage->m_nLastFileId, 0, wxT(">")); + } + +} + + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnSelectBackend +// +// Little debugging routine - enter the class name of a backend and it +// will use that instead of letting wxMediaCtrl search the wxMediaBackend +// RTTI class list. +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnSelectBackend(wxCommandEvent& WXUNUSED(evt)) +{ + wxString sBackend = wxGetTextFromUser(wxT("Enter backend to use")); + + if(sBackend.empty() == false) //could have been cancelled by the user + { + int sel = m_notebook->GetSelection(); + + if (sel != wxNOT_FOUND) + { + m_notebook->DeletePage(sel); + } + + m_notebook->AddPage(new wxMediaPlayerNotebookPage(this, m_notebook, + sBackend + ), wxT(""), true); + + DoOpenFile( + ((wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage())->m_szFile, + false); + } +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnOpenURLSamePage +// +// Called from file->openurl. +// Opens and plays a media file from a URL in the current notebook page +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnOpenURLSamePage(wxCommandEvent& WXUNUSED(event)) +{ + OpenURL(false); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnOpenURLNewPage +// +// Called from file->openurlinnewpage. +// Opens and plays a media file from a URL in a new notebook page +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnOpenURLNewPage(wxCommandEvent& WXUNUSED(event)) +{ + OpenURL(true); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OpenURL +// +// Just calls DoOpenFile with the url path - which calls DoPlayFile +// which handles the real dirty work +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OpenURL(bool bNewPage) +{ + wxString sUrl = wxGetTextFromUser( + wxT("Enter the URL that has the movie to play") + ); + + if(sUrl.empty() == false) //could have been cancelled by user + { + DoOpenFile(sUrl, bNewPage); + } +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnCloseCurrentPage +// +// Called when the user wants to close the current notebook page +// +// 1) Get the current page number (wxControl::GetSelection) +// 2) If there is no current page, break out +// 3) Delete the current page +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnCloseCurrentPage(wxCommandEvent& WXUNUSED(event)) +{ + if( m_notebook->GetPageCount() > 1 ) + { + int sel = m_notebook->GetSelection(); + + if (sel != wxNOT_FOUND) + { + m_notebook->DeletePage(sel); + } + } + else + { + wxMessageBox(wxT("Cannot close main page")); + } +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnPlay +// +// Called from file->play. +// Resumes the media if it is paused or stopped. +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnPlay(wxCommandEvent& WXUNUSED(event)) +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + wxListItem listitem; + currentpage->m_playlist->GetSelectedItem(listitem); + if ( !listitem.GetData() ) + { + int nLast = -1; + if ((nLast = currentpage->m_playlist->GetNextItem(nLast, + wxLIST_NEXT_ALL, + wxLIST_STATE_DONTCARE)) == -1) + { + //no items in list + wxMessageBox(wxT("No items in playlist!")); + } + else + { + listitem.SetId(nLast); + currentpage->m_playlist->GetItem(listitem); + listitem.SetMask(listitem.GetMask() | wxLIST_MASK_STATE); + listitem.SetState(listitem.GetState() | wxLIST_STATE_SELECTED); + currentpage->m_playlist->SetItem(listitem); + wxASSERT(listitem.GetData()); + DoPlayFile((*((wxString*) listitem.GetData()))); + } + } + else + { + wxASSERT(listitem.GetData()); + DoPlayFile((*((wxString*) listitem.GetData()))); + } +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnKeyDown +// +// Deletes all selected files from the playlist if the backspace key is pressed +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnKeyDown(wxKeyEvent& event) +{ + if(event.GetKeyCode() == WXK_BACK/*DELETE*/) + { + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + //delete all selected items + while(true) + { + wxInt32 nSelectedItem = currentpage->m_playlist->GetNextItem( + -1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); + if (nSelectedItem == -1) + break; + + wxListItem listitem; + listitem.SetId(nSelectedItem); + currentpage->m_playlist->GetItem(listitem); + delete (wxString*) listitem.GetData(); + + currentpage->m_playlist->DeleteItem(nSelectedItem); + } + } + + //Could be wxGetTextFromUser or something else important + if(event.GetEventObject() != this) + event.Skip(); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::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, +// otherwise it will appear to be at the end - but it will start over again +// when Play() is called +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnStop(wxCommandEvent& WXUNUSED(evt)) +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + if( !currentpage->m_mediactrl->Stop() ) + wxMessageBox(wxT("Couldn't stop movie!")); + else + currentpage->m_playlist->SetItem( + currentpage->m_nLastFileId, 0, wxT("[]")); +} + + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnChangeSong +// +// Routine that plays the currently selected file in the playlist. +// Called when the user actives the song from the playlist, +// and from other various places in the sample +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnChangeSong(wxListEvent& WXUNUSED(evt)) +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + wxListItem listitem; + currentpage->m_playlist->GetSelectedItem(listitem); + if(listitem.GetData()) + DoPlayFile((*((wxString*) listitem.GetData()))); + else + wxMessageBox(wxT("No selected item!")); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnPrev +// +// Tedious wxListCtrl stuff. Goes to prevous song in list, or if at the +// beginning goes to the last in the list. +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnPrev(wxCommandEvent& WXUNUSED(event)) +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + if (currentpage->m_playlist->GetItemCount() == 0) + return; + + wxInt32 nLastSelectedItem = -1; + while(true) + { + wxInt32 nSelectedItem = currentpage->m_playlist->GetNextItem(nLastSelectedItem, + wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); + if (nSelectedItem == -1) + break; + nLastSelectedItem = nSelectedItem; + currentpage->m_playlist->SetItemState(nSelectedItem, 0, wxLIST_STATE_SELECTED); + } + + if (nLastSelectedItem == -1) + { + //nothing selected, default to the file before the currently playing one + if(currentpage->m_nLastFileId == 0) + nLastSelectedItem = currentpage->m_playlist->GetItemCount() - 1; + else + nLastSelectedItem = currentpage->m_nLastFileId - 1; + } + else if (nLastSelectedItem == 0) + nLastSelectedItem = currentpage->m_playlist->GetItemCount() - 1; + else + nLastSelectedItem -= 1; + + if(nLastSelectedItem == currentpage->m_nLastFileId) + return; //already playing... nothing to do + + wxListItem listitem; + listitem.SetId(nLastSelectedItem); + listitem.SetMask(wxLIST_MASK_TEXT | wxLIST_MASK_DATA); + currentpage->m_playlist->GetItem(listitem); + listitem.SetMask(listitem.GetMask() | wxLIST_MASK_STATE); + listitem.SetState(listitem.GetState() | wxLIST_STATE_SELECTED); + currentpage->m_playlist->SetItem(listitem); + + wxASSERT(listitem.GetData()); + DoPlayFile((*((wxString*) listitem.GetData()))); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnNext +// +// Tedious wxListCtrl stuff. Goes to next song in list, or if at the +// end goes to the first in the list. +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnNext(wxCommandEvent& WXUNUSED(event)) +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + if (currentpage->m_playlist->GetItemCount() == 0) + return; + + wxInt32 nLastSelectedItem = -1; + while(true) + { + wxInt32 nSelectedItem = currentpage->m_playlist->GetNextItem(nLastSelectedItem, + wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); + if (nSelectedItem == -1) + break; + nLastSelectedItem = nSelectedItem; + currentpage->m_playlist->SetItemState(nSelectedItem, 0, wxLIST_STATE_SELECTED); + } + + if (nLastSelectedItem == -1) + { + if(currentpage->m_nLastFileId == currentpage->m_playlist->GetItemCount() - 1) + nLastSelectedItem = 0; + else + nLastSelectedItem = currentpage->m_nLastFileId + 1; + } + else if (nLastSelectedItem == currentpage->m_playlist->GetItemCount() - 1) + nLastSelectedItem = 0; + else + nLastSelectedItem += 1; + + if(nLastSelectedItem == currentpage->m_nLastFileId) + return; //already playing... nothing to do + + wxListItem listitem; + listitem.SetMask(wxLIST_MASK_TEXT | wxLIST_MASK_DATA); + listitem.SetId(nLastSelectedItem); + currentpage->m_playlist->GetItem(listitem); + listitem.SetMask(listitem.GetMask() | wxLIST_MASK_STATE); + listitem.SetState(listitem.GetState() | wxLIST_STATE_SELECTED); + currentpage->m_playlist->SetItem(listitem); + + wxASSERT(listitem.GetData()); + DoPlayFile((*((wxString*) listitem.GetData()))); +} + + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnVolumeDown +// +// Lowers the volume of the media control by 5% +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnVolumeDown(wxCommandEvent& WXUNUSED(event)) +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + double dVolume = currentpage->m_mediactrl->GetVolume(); + currentpage->m_mediactrl->SetVolume(dVolume < 0.05 ? 0.0 : dVolume - .05); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerFrame::OnVolumeUp +// +// Increases the volume of the media control by 5% +// ---------------------------------------------------------------------------- +void wxMediaPlayerFrame::OnVolumeUp(wxCommandEvent& WXUNUSED(event)) +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage(); + + double dVolume = currentpage->m_mediactrl->GetVolume(); + currentpage->m_mediactrl->SetVolume(dVolume > 0.95 ? 1.0 : dVolume + .05); +} + +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +// wxMediaPlayerTimer +// +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +// ---------------------------------------------------------------------------- +// wxMediaPlayerTimer::Notify +// +// 1) Updates media information on the status bar +// 2) Sets the max/min length of the slider and guage +// +// Note that the reason we continually do this and don't cache it is because +// some backends such as GStreamer are dynamic change values all the time +// and often don't have things like duration or video size available +// until the media is actually being played +// ---------------------------------------------------------------------------- +void wxMediaPlayerTimer::Notify() +{ + wxMediaPlayerNotebookPage* currentpage = + (wxMediaPlayerNotebookPage*) m_frame->m_notebook->GetCurrentPage(); + wxMediaCtrl* currentMediaCtrl = currentpage->m_mediactrl; + + if(currentpage) + { + // Number of minutes/seconds total + wxLongLong llLength = currentpage->m_mediactrl->Length(); + int nMinutes = (int) (llLength / 60000).GetValue(); + int nSeconds = (int) ((llLength % 60000)/1000).GetValue(); + + // Duration string (i.e. MM:SS) + wxString sDuration; + sDuration.Printf(wxT("%2i:%02i"), nMinutes, nSeconds); + + + // Number of minutes/seconds total + wxLongLong llTell = currentpage->m_mediactrl->Tell(); + nMinutes = (int) (llTell / 60000).GetValue(); + nSeconds = (int) ((llTell % 60000)/1000).GetValue(); + + // Position string (i.e. MM:SS) + wxString sPosition; + sPosition.Printf(wxT("%2i:%02i"), nMinutes, nSeconds); + + + // Set the third item in the listctrl entry to the duration string + if(currentpage->m_nLastFileId >= 0) + currentpage->m_playlist->SetItem( + currentpage->m_nLastFileId, 2, sDuration); + + // Setup the slider and gauge min/max values + currentpage->m_slider->SetRange(0, (int)(llLength / 1000).GetValue()); + currentpage->m_gauge->SetRange(100); + + + // if the slider is not being dragged then update it with the song position + if(currentpage->IsBeingDragged() == false) + currentpage->m_slider->SetValue((long)(llTell / 1000).GetValue()); + + + // Update the gauge with the download progress + wxLongLong llDownloadProgress = + currentpage->m_mediactrl->GetDownloadProgress(); + wxLongLong llDownloadTotal = + currentpage->m_mediactrl->GetDownloadTotal(); + + if(llDownloadTotal.GetValue() != 0) + { + currentpage->m_gauge->SetValue( + (int) ((llDownloadProgress * 100) / llDownloadTotal).GetValue() + ); + } + + // GetBestSize holds the original video size + wxSize videoSize = currentMediaCtrl->GetBestSize(); + + // Now the big part - set the status bar text to + // hold various metadata about the media +#if wxUSE_STATUSBAR + m_frame->SetStatusText(wxString::Format( + wxT("Size(x,y):%i,%i ") + wxT("Position:%s/%s Speed:%1.1fx ") + wxT("State:%s Loops:%i D/T:[%i]/[%i] V:%i%%"), + videoSize.x, + videoSize.y, + sPosition.c_str(), + sDuration.c_str(), + currentMediaCtrl->GetPlaybackRate(), + wxGetMediaStateText(currentpage->m_mediactrl->GetState()), + currentpage->m_nLoops, + (int)llDownloadProgress.GetValue(), + (int)llDownloadTotal.GetValue(), + (int)(currentpage->m_mediactrl->GetVolume() * 100))); +#endif // wxUSE_STATUSBAR + } +} + +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +// wxMediaPlayerNotebookPage +// +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +// ---------------------------------------------------------------------------- +// wxMediaPlayerNotebookPage Constructor +// +// Creates a media control and slider and adds it to this panel, +// along with some sizers for positioning +// ---------------------------------------------------------------------------- +wxMediaPlayerNotebookPage::wxMediaPlayerNotebookPage(wxMediaPlayerFrame* parentFrame, + wxNotebook* theBook, + const wxString& szBackend) + : wxPanel(theBook, wxID_ANY), + m_nLastFileId(-1), + m_nLoops(0), + m_bLoop(false), + m_bIsBeingDragged(false), + m_parentFrame(parentFrame) +{ + // + // Layout + // + // [wxMediaCtrl] + // [playlist] + // [5 control buttons] + // [slider] + // [gauge] + // + + // + // Create and attach the sizer + // + wxFlexGridSizer* sizer = new wxFlexGridSizer(2, 1, 0, 0); + this->SetSizer(sizer); + this->SetAutoLayout(true); + sizer->AddGrowableRow(0); + sizer->AddGrowableCol(0); + + // + // Create our media control + // + m_mediactrl = new wxMediaCtrl(); + + // Make sure creation was successful + bool bOK = m_mediactrl->Create(this, wxID_MEDIACTRL, wxEmptyString, + wxDefaultPosition, wxDefaultSize, 0, +//you could specify a macrod backend here like +// wxMEDIABACKEND_WMP10); +// wxT("wxPDFMediaBackend")); + szBackend); +//you could change the cursor here like +// m_mediactrl->SetCursor(wxCURSOR_BLANK); +//note that this may not effect it if SetPlayerControls +//is set to something else than wxMEDIACTRLPLAYERCONTROLS_NONE + wxASSERT_MSG(bOK, wxT("Could not create media control!")); + wxUnusedVar(bOK); + + sizer->Add(m_mediactrl, 0, wxALIGN_CENTER_HORIZONTAL|wxALL|wxEXPAND, 5); + + // + // Create the playlist/listctrl + // + m_playlist = new wxMediaPlayerListCtrl(); + m_playlist->Create(this, wxID_LISTCTRL, wxDefaultPosition, + wxDefaultSize, + wxLC_REPORT //wxLC_LIST + | wxSUNKEN_BORDER); + + // Set the background of our listctrl to white + m_playlist->SetBackgroundColour(wxColour(255,255,255)); + + // The layout of the headers of the listctrl are like + // | | File | Length + // + // Where Column one is a character representing the state the file is in: + // * - not the current file + // E - Error has occured + // > - Currently Playing + // [] - Stopped + // || - Paused + // (( - Volume Down 5% + // )) - Volume Up 5% + // + // Column two is the name of the file + // + // Column three is the length in seconds of the file + m_playlist->InsertColumn(0,_(""), wxLIST_FORMAT_CENTER, 20); + m_playlist->InsertColumn(1,_("File"), wxLIST_FORMAT_LEFT, /*wxLIST_AUTOSIZE_USEHEADER*/305); + m_playlist->InsertColumn(2,_("Length"), wxLIST_FORMAT_CENTER, 75); + +#if wxUSE_DRAG_AND_DROP + m_playlist->SetDropTarget(new wxPlayListDropTarget(*m_playlist)); +#endif + + sizer->Add(m_playlist, 0, wxALIGN_CENTER_HORIZONTAL|wxALL|wxEXPAND, 5); + + // + // Create the control buttons + // TODO/FIXME/HACK: This part about sizers is really a nice hack + // and probably isn't proper + // + wxBoxSizer* horsizer1 = new wxBoxSizer(wxHORIZONTAL); + wxBoxSizer* vertsizer = new wxBoxSizer(wxHORIZONTAL); + + m_prevButton = new wxButton(); + m_playButton = new wxButton(); + m_stopButton = new wxButton(); + m_nextButton = new wxButton(); + m_vdButton = new wxButton(); + m_vuButton = new wxButton(); + + m_prevButton->Create(this, wxID_BUTTONPREV, wxT("|<")); + m_playButton->Create(this, wxID_BUTTONPLAY, wxT(">")); + m_stopButton->Create(this, wxID_BUTTONSTOP, wxT("[]")); + m_nextButton->Create(this, wxID_BUTTONNEXT, wxT(">|")); + m_vdButton->Create(this, wxID_BUTTONVD, wxT("((")); + m_vuButton->Create(this, wxID_BUTTONVU, wxT("))")); + vertsizer->Add(m_prevButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); + vertsizer->Add(m_playButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); + vertsizer->Add(m_stopButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); + vertsizer->Add(m_nextButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); + vertsizer->Add(m_vdButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); + vertsizer->Add(m_vuButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); + horsizer1->Add(vertsizer, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); + sizer->Add(horsizer1, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_CENTER_HORIZONTAL|wxALL, 5); + + + // + // Create our slider + // + m_slider = new wxSlider(this, wxID_SLIDER, 0, //init + 0, //start + 0, //end + wxDefaultPosition, wxDefaultSize, + wxSL_HORIZONTAL ); + sizer->Add(m_slider, 0, wxALIGN_CENTER_HORIZONTAL|wxALL|wxEXPAND , 5); + + // + // Create the gauge + // + m_gauge = new wxGauge(); + m_gauge->Create(this, wxID_GAUGE, 0, wxDefaultPosition, wxDefaultSize, + wxGA_HORIZONTAL | wxGA_SMOOTH); + sizer->Add(m_gauge, 0, wxALIGN_CENTER_HORIZONTAL|wxALL|wxEXPAND , 5); + + // + // Create the speed/volume sliders + // + wxBoxSizer* horsizer3 = new wxBoxSizer(wxHORIZONTAL); + + m_volSlider = new wxSlider(this, wxID_VOLSLIDER, 100, // init + 0, // start + 100, // end + wxDefaultPosition, wxSize(250,20), + wxSL_HORIZONTAL ); + horsizer3->Add(m_volSlider, 1, wxALL, 5); + + m_pbSlider = new wxSlider(this, wxID_PBSLIDER, 4, // init + 1, // start + 16, // end + wxDefaultPosition, wxSize(250,20), + wxSL_HORIZONTAL ); + horsizer3->Add(m_pbSlider, 1, wxALL, 5); + sizer->Add(horsizer3, 1, wxCENTRE | wxALL, 5); + + // + // ListCtrl events + // + this->Connect( wxID_LISTCTRL, wxEVT_COMMAND_LIST_ITEM_ACTIVATED, + wxListEventHandler(wxMediaPlayerFrame::OnChangeSong), + (wxObject*)0, parentFrame); + + // + // Slider events + // + this->Connect(wxID_SLIDER, wxEVT_SCROLL_THUMBTRACK, + wxScrollEventHandler(wxMediaPlayerNotebookPage::OnBeginSeek)); + this->Connect(wxID_SLIDER, wxEVT_SCROLL_THUMBRELEASE, + wxScrollEventHandler(wxMediaPlayerNotebookPage::OnEndSeek)); + this->Connect(wxID_PBSLIDER, wxEVT_SCROLL_THUMBRELEASE, + wxScrollEventHandler(wxMediaPlayerNotebookPage::OnPBChange)); + this->Connect(wxID_VOLSLIDER, wxEVT_SCROLL_THUMBRELEASE, + wxScrollEventHandler(wxMediaPlayerNotebookPage::OnVolChange)); + + // + // Media Control events + // + this->Connect(wxID_MEDIACTRL, wxEVT_MEDIA_PLAY, + wxMediaEventHandler(wxMediaPlayerNotebookPage::OnMediaPlay)); + this->Connect(wxID_MEDIACTRL, wxEVT_MEDIA_PAUSE, + wxMediaEventHandler(wxMediaPlayerNotebookPage::OnMediaPause)); + this->Connect(wxID_MEDIACTRL, wxEVT_MEDIA_STOP, + wxMediaEventHandler(wxMediaPlayerNotebookPage::OnMediaStop)); + this->Connect(wxID_MEDIACTRL, wxEVT_MEDIA_FINISHED, + wxMediaEventHandler(wxMediaPlayerNotebookPage::OnMediaFinished)); + this->Connect(wxID_MEDIACTRL, wxEVT_MEDIA_LOADED, + wxMediaEventHandler(wxMediaPlayerFrame::OnMediaLoaded), + (wxObject*)0, parentFrame); + + // + // Button events + // + this->Connect( wxID_BUTTONPREV, wxEVT_COMMAND_BUTTON_CLICKED, + wxCommandEventHandler(wxMediaPlayerFrame::OnPrev), + (wxObject*)0, parentFrame); + this->Connect( wxID_BUTTONPLAY, wxEVT_COMMAND_BUTTON_CLICKED, + wxCommandEventHandler(wxMediaPlayerFrame::OnPlay), + (wxObject*)0, parentFrame); + this->Connect( wxID_BUTTONSTOP, wxEVT_COMMAND_BUTTON_CLICKED, + wxCommandEventHandler(wxMediaPlayerFrame::OnStop), + (wxObject*)0, parentFrame); + this->Connect( wxID_BUTTONNEXT, wxEVT_COMMAND_BUTTON_CLICKED, + wxCommandEventHandler(wxMediaPlayerFrame::OnNext), + (wxObject*)0, parentFrame); + this->Connect( wxID_BUTTONVD, wxEVT_COMMAND_BUTTON_CLICKED, + wxCommandEventHandler(wxMediaPlayerFrame::OnVolumeDown), + (wxObject*)0, parentFrame); + this->Connect( wxID_BUTTONVU, wxEVT_COMMAND_BUTTON_CLICKED, + wxCommandEventHandler(wxMediaPlayerFrame::OnVolumeUp), + (wxObject*)0, parentFrame); +} + +// ---------------------------------------------------------------------------- +// MyNotebook::OnBeginSeek +// +// Sets m_bIsBeingDragged to true to stop the timer from changing the position +// of our slider +// ---------------------------------------------------------------------------- +void wxMediaPlayerNotebookPage::OnBeginSeek(wxScrollEvent& WXUNUSED(event)) +{ + m_bIsBeingDragged = true; +} + +// ---------------------------------------------------------------------------- +// MyNotebook::OnEndSeek +// +// Called from file->seek. +// Called when the user moves the slider - +// seeks to a position within the media +// then sets m_bIsBeingDragged to false to ok the timer to change the position +// ---------------------------------------------------------------------------- +void wxMediaPlayerNotebookPage::OnEndSeek(wxScrollEvent& WXUNUSED(event)) +{ + if( m_mediactrl->Seek( + m_slider->GetValue() * 1000 + ) == wxInvalidOffset ) + wxMessageBox(wxT("Couldn't seek in movie!")); + + m_bIsBeingDragged = false; +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerNotebookPage::IsBeingDragged +// +// Returns true if the user is dragging the slider +// ---------------------------------------------------------------------------- +bool wxMediaPlayerNotebookPage::IsBeingDragged() +{ + return m_bIsBeingDragged; +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerNotebookPage::OnVolChange +// +// Called when the user is done dragging the volume-changing slider +// ---------------------------------------------------------------------------- +void wxMediaPlayerNotebookPage::OnVolChange(wxScrollEvent& WXUNUSED(event)) +{ + if( m_mediactrl->SetVolume( + m_volSlider->GetValue() / 100.0 + ) == false ) + wxMessageBox(wxT("Couldn't set volume!")); + +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerNotebookPage::OnPBChange +// +// Called when the user is done dragging the speed-changing slider +// ---------------------------------------------------------------------------- +void wxMediaPlayerNotebookPage::OnPBChange(wxScrollEvent& WXUNUSED(event)) +{ + if( m_mediactrl->SetPlaybackRate( + m_pbSlider->GetValue() * .25 + ) == false ) + wxMessageBox(wxT("Couldn't set playbackrate!")); + +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerNotebookPage::OnMediaPlay +// +// Called when the media plays. +// ---------------------------------------------------------------------------- +void wxMediaPlayerNotebookPage::OnMediaPlay(wxMediaEvent& WXUNUSED(event)) +{ + m_playlist->SetItem(m_nLastFileId, 0, wxT(">")); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerNotebookPage::OnMediaPause +// +// Called when the media is paused. +// ---------------------------------------------------------------------------- +void wxMediaPlayerNotebookPage::OnMediaPause(wxMediaEvent& WXUNUSED(event)) +{ + m_playlist->SetItem(m_nLastFileId, 0, wxT("||")); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerNotebookPage::OnMediaStop +// +// Called when the media stops. +// ---------------------------------------------------------------------------- +void wxMediaPlayerNotebookPage::OnMediaStop(wxMediaEvent& WXUNUSED(event)) +{ + m_playlist->SetItem(m_nLastFileId, 0, wxT("[]")); +} + +// ---------------------------------------------------------------------------- +// wxMediaPlayerNotebookPage::OnMediaFinished +// +// Called when the media finishes playing. +// Here we loop it if the user wants to (has been selected from file menu) +// ---------------------------------------------------------------------------- +void wxMediaPlayerNotebookPage::OnMediaFinished(wxMediaEvent& WXUNUSED(event)) +{ + if(m_bLoop) + { + if ( !m_mediactrl->Play() ) + { + wxMessageBox(wxT("Couldn't loop movie!")); + m_playlist->SetItem(m_nLastFileId, 0, wxT("E")); + } + else + ++m_nLoops; + } + else + { + m_playlist->SetItem(m_nLastFileId, 0, wxT("[]")); + } +} + +// +// End of MediaPlayer sample +//