AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
b5028f267d
wxWidgets/samples/mediaplayer/mediaplayer.cpp
Blake Eryx 65827a0572 Remove unnecessary c_str() calls from the samples 
Pass wxStrings directly to wxString::Format("%s") and similar
pseudo-vararg functions, there is no need for c_str() there since
wxWidgets 2.9.

Closes https://github.com/wxWidgets/wxWidgets/pull/1009
2018-11-03 22:52:57 +01:00

1802 lines
62 KiB
C++
Raw Blame History

///////////////////////////////////////////////////////////////////////////////
// Name: mediaplayer.cpp
// Purpose: wxMediaCtrl sample
// Author: Ryan Norton
// Modified by:
// Created: 11/10/04
// 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).
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// ============================================================================
// Definitions
// ============================================================================
// ----------------------------------------------------------------------------
// Pre-compiled header stuff
// ----------------------------------------------------------------------------
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
// ----------------------------------------------------------------------------
// Headers
// ----------------------------------------------------------------------------
#include "wx/mediactrl.h" // for wxMediaCtrl
#include "wx/filedlg.h" // for opening files from OpenFile
#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/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
#include "wx/vector.h"
// Under MSW we have several different backends but when linking statically
// they may be discarded by the linker (this definitely happens with MSVC) so
// force linking them. You don't have to do this in your code if you don't plan
// to use them, of course.
#if defined(__WXMSW__) && !defined(WXUSINGDLL)
#include "wx/link.h"
wxFORCE_LINK_MODULE(wxmediabackend_am)
wxFORCE_LINK_MODULE(wxmediabackend_qt)
wxFORCE_LINK_MODULE(wxmediabackend_wmp10)
#endif // static wxMSW build
#ifndef wxHAS_IMAGES_IN_RESOURCES
#include "../sample.xpm"
#endif
// ----------------------------------------------------------------------------
// Bail out if the user doesn't want one of the
// things we need
// ----------------------------------------------------------------------------
#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 wxMediaPlayerApp : public wxApp
{
public:
#ifdef __WXMAC__
virtual void MacOpenFiles(const wxArrayString & fileNames ) wxOVERRIDE;
#endif
#if wxUSE_CMDLINE_PARSER
virtual void OnInitCmdLine(wxCmdLineParser& parser) wxOVERRIDE;
virtual bool OnCmdLineParsed(wxCmdLineParser& parser) wxOVERRIDE;
// Files specified on the command line, if any.
wxVector<wxString> m_params;
#endif // wxUSE_CMDLINE_PARSER
virtual bool OnInit() wxOVERRIDE;
protected:
class wxMediaPlayerFrame* m_frame;
};
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame
// ----------------------------------------------------------------------------
class wxMediaPlayerFrame : public wxFrame
{
public:
// Ctor/Dtor
wxMediaPlayerFrame(const wxString& title);
~wxMediaPlayerFrame();
// Menu event handlers
void OnQuit(wxCommandEvent& event);
void OnAbout(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 OnLoop(wxCommandEvent& event);
void OnShowInterface(wxCommandEvent& 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:
// 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;
};
// ----------------------------------------------------------------------------
// wxMediaPlayerNotebookPage
// ----------------------------------------------------------------------------
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);
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() wxOVERRIDE;
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, "*");
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
//
// Drop target for playlist (i.e. allows users to drag a file from explorer into
// the playlist to add that file)
// ----------------------------------------------------------------------------
#if wxUSE_DRAG_AND_DROP
class wxPlayListDropTarget : public wxFileDropTarget
{
public:
wxPlayListDropTarget(wxMediaPlayerListCtrl& list) : m_list(list) {}
~wxPlayListDropTarget(){}
virtual bool OnDropFiles(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
const wxArrayString& files) wxOVERRIDE
{
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
// to the user
// ----------------------------------------------------------------------------
const wxString wxGetMediaStateText(int nState)
{
switch(nState)
{
case wxMEDIASTATE_PLAYING:
return "Playing";
case wxMEDIASTATE_STOPPED:
return "Stopped";
///case wxMEDIASTATE_PAUSED:
default:
return "Paused";
}
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// wxMediaPlayerApp
//
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ----------------------------------------------------------------------------
// 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.
//
// wxIMPLEMENT_APP does this, and also implements the platform-specific entry
// routine, such as main or WinMain(). Use wxIMPLEMENT_APP_NO_MAIN if you do
// not desire this behaviour.
// ----------------------------------------------------------------------------
wxIMPLEMENT_APP(wxMediaPlayerApp);
// ----------------------------------------------------------------------------
// wxMediaPlayerApp command line parsing
// ----------------------------------------------------------------------------
#if wxUSE_CMDLINE_PARSER
void wxMediaPlayerApp::OnInitCmdLine(wxCmdLineParser& parser)
{
wxApp::OnInitCmdLine(parser);
parser.AddParam("input files",
wxCMD_LINE_VAL_STRING,
wxCMD_LINE_PARAM_OPTIONAL | wxCMD_LINE_PARAM_MULTIPLE);
}
bool wxMediaPlayerApp::OnCmdLineParsed(wxCmdLineParser& parser)
{
if ( !wxApp::OnCmdLineParsed(parser) )
return false;
for (size_t paramNr=0; paramNr < parser.GetParamCount(); ++paramNr)
m_params.push_back(parser.GetParam(paramNr));
return true;
}
#endif // wxUSE_CMDLINE_PARSER
// ----------------------------------------------------------------------------
// 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()
{
if ( !wxApp::OnInit() )
return false;
// SetAppName() lets wxConfig and others know where to write
SetAppName("wxMediaPlayer");
wxMediaPlayerFrame *frame =
new wxMediaPlayerFrame("MediaPlayer wxWidgets Sample");
frame->Show(true);
#if wxUSE_CMDLINE_PARSER
if ( !m_params.empty() )
{
for ( size_t n = 0; n < m_params.size(); n++ )
frame->AddToPlayList(m_params[n]);
wxCommandEvent theEvent(wxEVT_MENU, wxID_NEXT);
frame->AddPendingEvent(theEvent);
}
#endif // wxUSE_CMDLINE_PARSER
return true;
}
#ifdef __WXMAC__
void wxMediaPlayerApp::MacOpenFiles(const wxArrayString & fileNames )
{
// Called when a user drags files over our app
m_frame->DoOpenFile(fileNames[0], true /* new page */);
}
#endif // __WXMAC__
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// wxMediaPlayerFrame
//
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame Constructor
//
// 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))
{
SetIcon(wxICON(sample));
//
// Create Menus
//
wxMenu *fileMenu = new wxMenu;
wxMenu *controlsMenu = new wxMenu;
wxMenu *optionsMenu = new wxMenu;
wxMenu *helpMenu = new wxMenu;
wxMenu *debugMenu = new wxMenu;
fileMenu->Append(wxID_OPENFILESAMEPAGE, "&Open File\tCtrl-Shift-O",
"Open a File in the current notebook page");
fileMenu->Append(wxID_OPENFILENEWPAGE, "&Open File in a new page",
"Open a File in a new notebook page");
fileMenu->Append(wxID_OPENURLSAMEPAGE, "&Open URL",
"Open a URL in the current notebook page");
fileMenu->Append(wxID_OPENURLNEWPAGE, "&Open URL in a new page",
"Open a URL in a new notebook page");
fileMenu->AppendSeparator();
fileMenu->Append(wxID_CLOSECURRENTPAGE, "&Close Current Page\tCtrl-C",
"Close current notebook page");
fileMenu->AppendSeparator();
fileMenu->Append(wxID_EXIT,
"E&xit\tAlt-X",
"Quit this program");
controlsMenu->Append(wxID_PLAY, "&Play/Pause\tCtrl-P", "Resume/Pause playback");
controlsMenu->Append(wxID_STOP, "&Stop\tCtrl-S", "Stop playback");
controlsMenu->AppendSeparator();
controlsMenu->Append(wxID_PREV, "&Previous\tCtrl-B", "Go to previous track");
controlsMenu->Append(wxID_NEXT, "&Next\tCtrl-N", "Skip to next track");
optionsMenu->AppendCheckItem(wxID_LOOP,
"&Loop\tCtrl-L",
"Loop Selected Media");
optionsMenu->AppendCheckItem(wxID_SHOWINTERFACE,
"&Show Interface\tCtrl-I",
"Show wxMediaCtrl native controls");
debugMenu->Append(wxID_SELECTBACKEND,
"&Select Backend...\tCtrl-D",
"Select a backend manually");
helpMenu->Append(wxID_ABOUT,
"&About\tF1",
"Show about dialog");
wxMenuBar *menuBar = new wxMenuBar();
menuBar->Append(fileMenu, "&File");
menuBar->Append(controlsMenu, "&Controls");
menuBar->Append(optionsMenu, "&Options");
menuBar->Append(debugMenu, "&Debug");
menuBar->Append(helpMenu, "&Help");
SetMenuBar(menuBar);
//
// Create our notebook - using wxNotebook is luckily pretty
// simple and self-explanatory in most cases
//
m_notebook = new wxNotebook(this, wxID_NOTEBOOK);
//
// 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
//
// Connect events.
//
//
// Menu events
//
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnQuit, this,
wxID_EXIT);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnAbout, this,
wxID_ABOUT);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnLoop, this,
wxID_LOOP);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnShowInterface, this,
wxID_SHOWINTERFACE);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnOpenFileNewPage, this,
wxID_OPENFILENEWPAGE);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnOpenFileSamePage, this,
wxID_OPENFILESAMEPAGE);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnOpenURLNewPage, this,
wxID_OPENURLNEWPAGE);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnOpenURLSamePage, this,
wxID_OPENURLSAMEPAGE);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnCloseCurrentPage, this,
wxID_CLOSECURRENTPAGE);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnPlay, this,
wxID_PLAY);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnStop, this,
wxID_STOP);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnNext, this,
wxID_NEXT);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnPrev, this,
wxID_PREV);
Bind(wxEVT_MENU, &wxMediaPlayerFrame::OnSelectBackend, this,
wxID_SELECTBACKEND);
//
// Key events
//
wxTheApp->Bind(wxEVT_KEY_DOWN, &wxMediaPlayerFrame::OnKeyDown, this);
//
// Close events
//
Bind(wxEVT_CLOSE_WINDOW, &wxMediaPlayerFrame::OnClose, this);
//
// End of Events
//
//
// 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,
"",
true);
// Don't load previous files if we have some specified on the command line,
// we wouldn't play them otherwise (they'd have to be inserted into the
// play list at the beginning instead of being appended but we don't
// support this).
#if wxUSE_CMDLINE_PARSER
if ( wxGetApp().m_params.empty() )
#endif // wxUSE_CMDLINE_PARSER
{
//
// 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
//
// 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 wxMediaPlayerTimer(this);
m_timer->Start(500);
}
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame Destructor
//
// 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
//
// 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
//
// Called from help->about.
// Gets some info about this application.
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
wxString msg;
msg.Printf( "This is a test of wxMediaCtrl.\n\n"
"Instructions:\n"
"The top slider shows the current the current position, "
"which you can change by dragging and releasing it.\n"
"The gauge (progress bar) shows the progress in "
"downloading data of the current file - it may always be "
"empty due to lack of support from the current backend.\n"
"The lower-left slider controls the volume and the lower-"
"right slider controls the playback rate/speed of the "
"media\n\n"
"Currently using: %s", wxVERSION_STRING);
wxMessageBox(msg, "About wxMediaCtrl test",
wxOK | wxICON_INFORMATION, this);
}
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame::OnLoop
//
// Called from file->loop.
// Changes the state of whether we want to loop or not.
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnLoop(wxCommandEvent& WXUNUSED(event))
{
wxMediaPlayerNotebookPage* currentpage =
((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage());
currentpage->m_bLoop = !currentpage->m_bLoop;
}
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame::OnLoop
//
// Called from file->loop.
// Changes the state of whether we want to loop or not.
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnShowInterface(wxCommandEvent& event)
{
wxMediaPlayerNotebookPage* currentpage =
((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage());
if( !currentpage->m_mediactrl->ShowPlayerControls(event.IsChecked() ?
wxMEDIACTRLPLAYERCONTROLS_DEFAULT :
wxMEDIACTRLPLAYERCONTROLS_NONE) )
{
// error - uncheck and warn user
wxMenuItem* pSIItem = GetMenuBar()->FindItem(wxID_SHOWINTERFACE);
wxASSERT(pSIItem);
pSIItem->Check(!event.IsChecked());
if(event.IsChecked())
wxMessageBox("Could not show player controls");
else
wxMessageBox("Could not hide player controls");
}
}
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame::OnOpenFileSamePage
//
// Called from file->openfile.
// Opens and plays a media file in the current notebook page
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnOpenFileSamePage(wxCommandEvent& WXUNUSED(event))
{
OpenFile(false);
}
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame::OnOpenFileNewPage
//
// Called from file->openfileinnewpage.
// Opens and plays a media file in a new notebook page
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnOpenFileNewPage(wxCommandEvent& WXUNUSED(event))
{
OpenFile(true);
}
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame::OpenFile
//
// 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)
{
wxFileDialog fd(this);
if(fd.ShowModal() == wxID_OK)
{
DoOpenFile(fd.GetPath(), bNewPage);
}
}
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame::DoOpenFile
//
// 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(bNewPage)
{
m_notebook->AddPage(
new wxMediaPlayerNotebookPage(this, m_notebook),
path,
true);
}
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, "*");
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("Couldn't pause movie!");
}
else
{
if( !currentpage->m_mediactrl->Play() )
wxMessageBox("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, "*");
wxURI uripath(path);
if( uripath.IsReference() )
{
if( !currentpage->m_mediactrl->Load(path) )
{
wxMessageBox("Couldn't load file!");
currentpage->m_playlist->SetItem(nNewId, 0, "E");
}
else
{
currentpage->m_playlist->SetItem(nNewId, 0, "O");
}
}
else
{
if( !currentpage->m_mediactrl->Load(uripath) )
{
wxMessageBox("Couldn't load URL!");
currentpage->m_playlist->SetItem(nNewId, 0, "E");
}
else
{
currentpage->m_playlist->SetItem(nNewId, 0, "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, "");
}
}
// ----------------------------------------------------------------------------
// 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("Couldn't play movie!");
currentpage->m_playlist->SetItem(currentpage->m_nLastFileId, 0, "E");
}
else
{
currentpage->m_playlist->SetItem(currentpage->m_nLastFileId, 0, ">");
}
}
// ----------------------------------------------------------------------------
// 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("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
), "", 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(
"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("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("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("Couldn't stop movie!");
else
currentpage->m_playlist->SetItem(
currentpage->m_nLastFileId, 0, "[]");
}
// ----------------------------------------------------------------------------
// 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("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;
// 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("%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("%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(
"Size(x,y):%i,%i "
"Position:%s/%s Speed:%1.1fx "
"State:%s Loops:%i D/T:[%i]/[%i] V:%i%%",
videoSize.x,
videoSize.y,
sPosition,
sDuration,
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 a 2-column grid sizer
//
wxFlexGridSizer* sizer = new wxFlexGridSizer(2);
sizer->AddGrowableCol(0);
this->SetSizer(sizer);
//
// 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 macro backend here like
// wxMEDIABACKEND_WMP10);
// "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, "Could not create media control!");
wxUnusedVar(bOK);
sizer->Add(m_mediactrl, wxSizerFlags().Expand().Border());
//
// 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(*wxWHITE);
// 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->AppendColumn(_(""), wxLIST_FORMAT_CENTER, 20);
m_playlist->AppendColumn(_("File"), wxLIST_FORMAT_LEFT, /*wxLIST_AUTOSIZE_USEHEADER*/305);
m_playlist->AppendColumn(_("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, "|<");
m_prevButton->SetToolTip("Previous");
m_playButton->Create(this, wxID_BUTTONPLAY, ">");
m_playButton->SetToolTip("Play");
m_stopButton->Create(this, wxID_BUTTONSTOP, "[]");
m_stopButton->SetToolTip("Stop");
m_nextButton->Create(this, wxID_BUTTONNEXT, ">|");
m_nextButton->SetToolTip("Next");
m_vdButton->Create(this, wxID_BUTTONVD, "((");
m_vdButton->SetToolTip("Volume down");
m_vuButton->Create(this, wxID_BUTTONVU, "))");
m_vuButton->SetToolTip("Volume up");
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
1, // end, dummy but must be greater than start
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);
// Now that we have all our rows make some of them growable
sizer->AddGrowableRow(0);
//
// ListCtrl events
//
Bind(wxEVT_LIST_ITEM_ACTIVATED, &wxMediaPlayerFrame::OnChangeSong, parentFrame,
wxID_LISTCTRL);
//
// Slider events
//
Bind(wxEVT_SCROLL_THUMBTRACK, &wxMediaPlayerNotebookPage::OnBeginSeek, this,
wxID_SLIDER);
Bind(wxEVT_SCROLL_THUMBRELEASE, &wxMediaPlayerNotebookPage::OnEndSeek, this,
wxID_SLIDER);
Bind(wxEVT_SCROLL_THUMBRELEASE, &wxMediaPlayerNotebookPage::OnPBChange, this,
wxID_PBSLIDER);
Bind(wxEVT_SCROLL_THUMBRELEASE, &wxMediaPlayerNotebookPage::OnVolChange, this,
wxID_VOLSLIDER);
//
// Media Control events
//
Bind(wxEVT_MEDIA_PLAY, &wxMediaPlayerNotebookPage::OnMediaPlay, this,
wxID_MEDIACTRL);
Bind(wxEVT_MEDIA_PAUSE, &wxMediaPlayerNotebookPage::OnMediaPause, this,
wxID_MEDIACTRL);
Bind(wxEVT_MEDIA_STOP, &wxMediaPlayerNotebookPage::OnMediaStop, this,
wxID_MEDIACTRL);
Bind(wxEVT_MEDIA_FINISHED, &wxMediaPlayerNotebookPage::OnMediaFinished, this,
wxID_MEDIACTRL);
Bind(wxEVT_MEDIA_LOADED, &wxMediaPlayerFrame::OnMediaLoaded, parentFrame,
wxID_MEDIACTRL);
//
// Button events
//
Bind(wxEVT_BUTTON, &wxMediaPlayerFrame::OnPrev, parentFrame,
wxID_BUTTONPREV);
Bind(wxEVT_BUTTON, &wxMediaPlayerFrame::OnPlay, parentFrame,
wxID_BUTTONPLAY);
Bind(wxEVT_BUTTON, &wxMediaPlayerFrame::OnStop, parentFrame,
wxID_BUTTONSTOP);
Bind(wxEVT_BUTTON, &wxMediaPlayerFrame::OnNext, parentFrame,
wxID_BUTTONNEXT);
Bind(wxEVT_BUTTON, &wxMediaPlayerFrame::OnVolumeDown, parentFrame,
wxID_BUTTONVD);
Bind(wxEVT_BUTTON, &wxMediaPlayerFrame::OnVolumeUp, parentFrame,
wxID_BUTTONVU);
}
// ----------------------------------------------------------------------------
// 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("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("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("Couldn't set playbackrate!");
}
// ----------------------------------------------------------------------------
// wxMediaPlayerNotebookPage::OnMediaPlay
//
// Called when the media plays.
// ----------------------------------------------------------------------------
void wxMediaPlayerNotebookPage::OnMediaPlay(wxMediaEvent& WXUNUSED(event))
{
m_playlist->SetItem(m_nLastFileId, 0, ">");
}
// ----------------------------------------------------------------------------
// wxMediaPlayerNotebookPage::OnMediaPause
//
// Called when the media is paused.
// ----------------------------------------------------------------------------
void wxMediaPlayerNotebookPage::OnMediaPause(wxMediaEvent& WXUNUSED(event))
{
m_playlist->SetItem(m_nLastFileId, 0, "||");
}
// ----------------------------------------------------------------------------
// wxMediaPlayerNotebookPage::OnMediaStop
//
// Called when the media stops.
// ----------------------------------------------------------------------------
void wxMediaPlayerNotebookPage::OnMediaStop(wxMediaEvent& WXUNUSED(event))
{
m_playlist->SetItem(m_nLastFileId, 0, "[]");
}
// ----------------------------------------------------------------------------
// 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("Couldn't loop movie!");
m_playlist->SetItem(m_nLastFileId, 0, "E");
}
else
++m_nLoops;
}
else
{
m_playlist->SetItem(m_nLastFileId, 0, "[]");
}
}
//
// End of MediaPlayer sample
//
Reference in New Issue View Git Blame Copy Permalink