// things we need
// ----------------------------------------------------------------------------
-// RN: I'm not sure why this is here - even minimal doesn't check for
+// 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"
// wxID_ABOUT, [built-in to wxWidgets]
// wxID_EXIT, [built-in to wxWidgets]
// Control event IDs
- wxID_SLIDER,
- wxID_NOTEBOOK,
- wxID_MEDIACTRL,
+ wxID_SLIDER,
+ wxID_NOTEBOOK,
+ wxID_MEDIACTRL,
wxID_BUTTONNEXT,
wxID_BUTTONPREV,
wxID_BUTTONSTOP,
{
public:
#ifdef __WXMAC__
- virtual void MacOpenFile(const wxString & fileName )
- {
- //Called when a user drags a file over our app
- m_frame->DoOpenFile(fileName);
- }
+ virtual void MacOpenFile(const wxString & fileName );
#endif
+
virtual bool OnInit();
protected:
void OnMediaLoaded(wxMediaEvent& event);
// Close event handlers
- void OnClose(wxCloseEvent& event);
+ void OnClose(wxCloseEvent& event);
private:
// Rebuild base status string (see Implementation)
void DoOpenFile(const wxString& path, bool bNewPage);
void DoPlayFile(const wxString& path);
- // Get the controls of current notebook page
- wxMediaCtrl* GetCurrentMediaCtrl();
- wxSlider* GetCurrentSlider();
- wxGauge* GetCurrentGauge();
-
- int m_nLastFileId; //List ID of played file in listctrl
- wxString m_szFile; //Name of currently playing file/location
class wxMediaPlayerTimer* m_timer; //Timer to write info to status bar
wxString m_basestatus; //Base status string (see ResetStatus())
wxNotebook* m_notebook; //Notebook containing our pages
class wxMediaPlayerNotebookPage : public wxPanel
{
- wxMediaPlayerNotebookPage(wxMediaPlayerFrame* parentFrame,
+ wxMediaPlayerNotebookPage(wxMediaPlayerFrame* parentFrame,
wxNotebook* book, const wxString& be = wxEmptyString);
// Slider event handlers
bool IsBeingDragged(); //accessor for m_bIsBeingDragged
//make wxMediaPlayerFrame able to access the private members
- friend class wxMediaPlayerFrame;
+ 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
wxListItem kNewItem;
kNewItem.SetAlign(wxLIST_FORMAT_LEFT);
- int nID;
-
- kNewItem.SetId(nID = this->GetItemCount());
+ int nID = this->GetItemCount();
+ kNewItem.SetId(nID);
kNewItem.SetMask(wxLIST_MASK_DATA);
kNewItem.SetData(new wxString(szString));
this->InsertItem(kNewItem);
- this->SetItem(nID, 0, _T("*"));
+ this->SetItem(nID, 0, wxT("*"));
this->SetItem(nID, 1, wxFileName(szString).GetName());
if (nID % 2)
listitem.SetId(nLastSelected == -1 ? nLast : nLastSelected);
this->GetItem(listitem);
}
-
};
// ----------------------------------------------------------------------------
// wxPlayListDropTarget
//
-// Drop target for playlist (i.e. user drags a file from explorer unto
+// Drop target for playlist (i.e. user drags a file from explorer unto
// playlist it adds the file)
// ----------------------------------------------------------------------------
class wxPlayListDropTarget : public wxFileDropTarget
// ----------------------------------------------------------------------------
bool wxMediaPlayerApp::OnInit()
{
- wxMediaPlayerFrame *frame =
- new wxMediaPlayerFrame(_T("MediaPlayer wxWidgets Sample"));
+ wxMediaPlayerFrame *frame =
+ new wxMediaPlayerFrame(wxT("MediaPlayer wxWidgets Sample"));
frame->Show(true);
#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
//
wxCmdLineParser parser (cmdLineDesc, argc, argv);
// get filenames from the commandline
- if (parser.Parse() == 0)
+ if (parser.Parse() == 0)
{
- for (size_t paramNr=0; paramNr < parser.GetParamCount(); ++paramNr)
+ for (size_t paramNr=0; paramNr < parser.GetParamCount(); ++paramNr)
{
frame->AddToPlayList((parser.GetParam (paramNr)));
}
return true;
}
+#ifdef __WXMAC__
+
+void wxMediaPlayerApp::MacOpenFile(const wxString & fileName )
+{
+ //Called when a user drags a file over our app
+ m_frame->DoOpenFile(fileName, true /* new page */);
+}
+
+#endif // __WXMAC__
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// ----------------------------------------------------------------------------
wxMediaPlayerFrame::wxMediaPlayerFrame(const wxString& title)
- : wxFrame(NULL, wxID_ANY, title, wxDefaultPosition, wxSize(600,600)),
- m_nLastFileId(-1)
+ : wxFrame(NULL, wxID_ANY, title, wxDefaultPosition, wxSize(600,600))
{
//
// Create Menus
wxMenu *helpMenu = new wxMenu;
wxMenu *debugMenu = new wxMenu;
- fileMenu->Append(wxID_OPENFILESAMEPAGE, _T("&Open File\tCtrl-Shift-O"),
- _T("Open a File in the current notebook page"));
- fileMenu->Append(wxID_OPENFILENEWPAGE, _T("&Open File in a new page"),
- _T("Open a File in a new notebook page"));
- fileMenu->Append(wxID_OPENURLSAMEPAGE, _T("&Open URL"),
- _T("Open a URL in the current notebook page"));
- fileMenu->Append(wxID_OPENURLNEWPAGE, _T("&Open URL in a new page"),
- _T("Open a URL in a new notebook page"));
+ 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, _T("&Close Current Page\tCtrl-C"),
- _T("Close current notebook page"));
+ fileMenu->Append(wxID_CLOSECURRENTPAGE, wxT("&Close Current Page\tCtrl-C"),
+ wxT("Close current notebook page"));
fileMenu->AppendSeparator();
fileMenu->Append(wxID_EXIT,
- _T("E&xit\tAlt-X"),
- _T("Quit this program"));
+ wxT("E&xit\tAlt-X"),
+ wxT("Quit this program"));
- controlsMenu->Append(wxID_PLAY, _T("&Play/Pause\tCtrl-P"), _T("Resume/Pause playback"));
- controlsMenu->Append(wxID_STOP, _T("&Stop\tCtrl-S"), _T("Stop playback"));
+ 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, _T("&Previous\tCtrl-B"), _T("Go to previous track"));
- controlsMenu->Append(wxID_NEXT, _T("&Next\tCtrl-N"), _T("Skip to next track"));
+ 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,
- _T("&Loop\tCtrl-L"),
- _T("Loop Selected Media"));
+ wxT("&Loop\tCtrl-L"),
+ wxT("Loop Selected Media"));
optionsMenu->AppendCheckItem(wxID_SHOWINTERFACE,
- _T("&Show Interface\tCtrl-I"),
- _T("Show wxMediaCtrl native controls"));
+ wxT("&Show Interface\tCtrl-I"),
+ wxT("Show wxMediaCtrl native controls"));
debugMenu->Append(wxID_SELECTBACKEND,
- _T("&Select Backend...\tCtrl-D"),
- _T("Select a backend manually"));
+ wxT("&Select Backend...\tCtrl-D"),
+ wxT("Select a backend manually"));
helpMenu->Append(wxID_ABOUT,
- _T("&About...\tF1"),
- _T("Show about dialog"));
+ wxT("&About...\tF1"),
+ wxT("Show about dialog"));
wxMenuBar *menuBar = new wxMenuBar();
- menuBar->Append(fileMenu, _T("&File"));
- menuBar->Append(controlsMenu, _T("&Controls"));
- menuBar->Append(optionsMenu, _T("&Options"));
- menuBar->Append(debugMenu, _T("&Debug"));
- menuBar->Append(helpMenu, _T("&Help"));
+ 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);
//
//
// Close events
//
- this->Connect(wxID_ANY, wxEVT_CLOSE_WINDOW,
+ this->Connect(wxID_ANY, wxEVT_CLOSE_WINDOW,
wxCloseEventHandler(wxMediaPlayerFrame::OnClose));
//
//
//
- // Create an initial notebook page so the user has something
+ // Create an initial notebook page so the user has something
// to work with without having to go file->open every time :).
//
- m_notebook->AddPage(new wxMediaPlayerNotebookPage(this, m_notebook),
- wxT(""),
+ wxMediaPlayerNotebookPage* page =
+ new wxMediaPlayerNotebookPage(this, m_notebook);
+ m_notebook->AddPage(page,
+ wxT(""),
true);
+ //
+ // 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.
+ //
+ wxConfigBase* conf = wxConfigBase::Get();
+ 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
//
// 2) Delete our timer explicitly
// ----------------------------------------------------------------------------
wxMediaPlayerFrame::~wxMediaPlayerFrame()
-{
- delete m_timer;
-
-}
-
-// ----------------------------------------------------------------------------
-// wxMediaPlayerFrame::OnClose
-// ----------------------------------------------------------------------------
-void wxMediaPlayerFrame::OnClose(wxCloseEvent& event)
{
//
// Here we save our info to the registry or whatever
// 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
+ // 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
//
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
+ // 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;
wxConfigBase* conf = wxConfigBase::Get();
conf->DeleteAll();
- for(int i = 0; i < m_playlist->GetItemCount(); ++i)
+ for(int i = 0; i < playlist->GetItemCount(); ++i)
{
- wxString* pData = (wxString*) m_playlist->GetItemData(i);
+ wxString* pData = (wxString*) playlist->GetItemData(i);
wxString s;
s << i;
conf->Write(s, *(pData));
delete pData;
}
+ delete m_timer;
+}
+
+// ----------------------------------------------------------------------------
+// wxMediaPlayerFrame::OnClose
+// ----------------------------------------------------------------------------
+void wxMediaPlayerFrame::OnClose(wxCloseEvent& event)
+{
event.Skip(); //really close the frame
}
// wxMediaPlayerFrame::AddToPlayList
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::AddToPlayList(const wxString& szString)
-{
- wxMediaPlayerNotebookPage* currentpage =
+{
+ wxMediaPlayerNotebookPage* currentpage =
((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage());
-
- currentpage->m_playlist->AddToPlayList(szString);
+
+ currentpage->m_playlist->AddToPlayList(szString);
}
-
+
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame::ResetStatus
//
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::ResetStatus()
{
- wxMediaCtrl* currentMediaCtrl = GetCurrentMediaCtrl();
+ wxMediaCtrl* currentMediaCtrl =
+ ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_mediactrl;
- m_basestatus = wxString::Format(_T("Size(x,y):%i,%i ")
- _T("Length(Seconds):%u Speed:%1.1fx"),
+ m_basestatus = wxString::Format(wxT("Size(x,y):%i,%i ")
+ wxT("Length(Seconds):%u Speed:%1.1fx"),
currentMediaCtrl->GetBestSize().x,
currentMediaCtrl->GetBestSize().y,
(unsigned)((currentMediaCtrl->Length() / 1000)),
);
}
-// ----------------------------------------------------------------------------
-// wxMediaPlayerFrame::GetCurrentMediaCtrl
-//
-// Obtains the media control of the current page, or NULL if there are no
-// pages open
-// ----------------------------------------------------------------------------
-wxMediaCtrl* wxMediaPlayerFrame::GetCurrentMediaCtrl()
-{
- return ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_mediactrl;
-}
-
-// ----------------------------------------------------------------------------
-// wxMediaPlayerFrame::GetCurrentSlider
-//
-// Obtains the slider of the current page
-// ----------------------------------------------------------------------------
-wxSlider* wxMediaPlayerFrame::GetCurrentSlider()
-{
- return ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_slider;
-}
-
-// ----------------------------------------------------------------------------
-// wxMediaPlayerFrame::GetCurrentGauge
-//
-// Obtains the gauge of the current page
-// ----------------------------------------------------------------------------
-wxGauge* wxMediaPlayerFrame::GetCurrentGauge()
-{
- return ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_gauge;
-}
-
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame::OnQuit
//
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")
+ wxT("Welcome to %s"), wxVERSION_STRING);
- wxMessageBox(msg, _T("About wxMediaCtrl test"), wxOK | wxICON_INFORMATION, this);
+ wxMessageBox(msg, wxT("About wxMediaCtrl test"), wxOK | wxICON_INFORMATION, this);
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnLoop(wxCommandEvent& WXUNUSED(event))
{
- if(!m_notebook->GetCurrentPage())
- {
- wxMessageBox(wxT("No files are currently open!"));
- return;
- }
+ wxMediaPlayerNotebookPage* currentpage =
+ ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage());
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_bLoop =
- !((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_bLoop;
+ currentpage->m_bLoop = !currentpage->m_bLoop;
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnShowInterface(wxCommandEvent& event)
{
- if(!m_notebook->GetCurrentPage())
+ wxMediaPlayerNotebookPage* currentpage =
+ ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage());
+
+ if( !currentpage->m_mediactrl->ShowPlayerControls(event.IsChecked() ?
+ wxMEDIACTRLPLAYERCONTROLS_DEFAULT :
+ wxMEDIACTRLPLAYERCONTROLS_NONE) )
{
- wxMessageBox(wxT("No files are currently open!"));
- return;
+ //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"));
}
-
- GetCurrentMediaCtrl()->ShowPlayerControls(event.IsChecked() ?
- wxMEDIACTRLPLAYERCONTROLS_DEFAULT :
- wxMEDIACTRLPLAYERCONTROLS_NONE);
}
// ----------------------------------------------------------------------------
if(bNewPage)
{
m_notebook->AddPage(
- new wxMediaPlayerNotebookPage(this, m_notebook),
- path,
+ new wxMediaPlayerNotebookPage(this, m_notebook),
+ path,
true);
}
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
- if(m_nLastFileId != -1)
- m_playlist->SetItemState(m_nLastFileId, 0, wxLIST_STATE_SELECTED);
+ 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 = m_playlist->GetItemCount());
+ 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));
- m_playlist->InsertItem(newlistitem);
- m_playlist->SetItem(nID, 0, _T("*"));
- m_playlist->SetItem(nID, 1, wxFileName(path).GetName());
-
+ 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));
- m_playlist->SetItem(newlistitem);
+ currentpage->m_playlist->SetItem(newlistitem);
}
DoPlayFile(path);
- // m_playlist->Focus(nID);
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::DoPlayFile(const wxString& path)
{
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
wxListItem listitem;
- m_playlist->GetSelectedItem(listitem);
-
- if(listitem.GetData() != NULL &&
- m_szFile.compare(path) == 0 &&
- m_nLastFileId == listitem.GetId())
+ 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(GetCurrentMediaCtrl()->GetState() == wxMEDIASTATE_PLAYING)
+ if(currentpage->m_mediactrl->GetState() == wxMEDIASTATE_PLAYING)
{
- if( !GetCurrentMediaCtrl()->Pause() )
+ if( !currentpage->m_mediactrl->Pause() )
wxMessageBox(wxT("Couldn't pause movie!"));
else
- m_playlist->SetItem(listitem.GetId(), 0, _T("||"));
+ currentpage->m_playlist->SetItem(
+ currentpage->m_nLastFileId, 0, wxT("||"));
}
else
{
- if( !GetCurrentMediaCtrl()->Play() )
- wxMessageBox(wxT("Couldn't pause movie!"));
+ if( !currentpage->m_mediactrl->Play() )
+ wxMessageBox(wxT("Couldn't play movie!"));
else
- m_playlist->SetItem(listitem.GetId(), 0, _T(">"));
+ currentpage->m_playlist->SetItem(
+ currentpage->m_nLastFileId, 0, wxT(">"));
}
}
else
{
- m_notebook->SetPageText(m_notebook->GetSelection(),
+ int nNewId = listitem.GetData() ? listitem.GetId() :
+ currentpage->m_playlist->GetItemCount()-1;
+ m_notebook->SetPageText(m_notebook->GetSelection(),
wxFileName(path).GetName());
- if(m_nLastFileId != -1)
- m_playlist->SetItem(m_nLastFileId, 0, _T("*"));
+ if(currentpage->m_nLastFileId != -1)
+ currentpage->m_playlist->SetItem(
+ currentpage->m_nLastFileId, 0, wxT("*"));
wxURI uripath(path);
if( uripath.IsReference() )
{
- if( !GetCurrentMediaCtrl()->Load(path) )
+ if( !currentpage->m_mediactrl->Load(path) )
{
wxMessageBox(wxT("Couldn't load file!"));
- m_playlist->SetItem(listitem.GetId(), 0, _T("E"));
+ currentpage->m_playlist->SetItem(nNewId, 0, wxT("E"));
}
else
{
- m_playlist->SetItem(listitem.GetId(), 0, _T("O"));
+ currentpage->m_playlist->SetItem(nNewId, 0, wxT("O"));
}
}
else
{
- if( !GetCurrentMediaCtrl()->Load(uripath) )
+ if( !currentpage->m_mediactrl->Load(uripath) )
{
- wxMessageBox(wxT("Couldn't load file!"));
- m_playlist->SetItem(listitem.GetId(), 0, _T("E"));
+ wxMessageBox(wxT("Couldn't load URL!"));
+ currentpage->m_playlist->SetItem(nNewId, 0, wxT("E"));
}
else
{
- m_playlist->SetItem(listitem.GetId(), 0, _T("O"));
+ currentpage->m_playlist->SetItem(nNewId, 0, wxT("O"));
}
}
- m_nLastFileId = listitem.GetId();
- m_szFile = path;
- m_playlist->SetItem(m_nLastFileId, 1, wxFileName(path).GetName());
- m_playlist->SetItem(m_nLastFileId, 2, wxT(""));
+ 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(""));
}
}
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnMediaLoaded(wxMediaEvent& WXUNUSED(evt))
{
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
- wxListItem listitem;
- m_playlist->GetSelectedItem(listitem);
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
- if( !GetCurrentMediaCtrl()->Play() )
+ if( !currentpage->m_mediactrl->Play() )
{
wxMessageBox(wxT("Couldn't play movie!"));
- m_playlist->SetItem(listitem.GetId(), 0, _T("E"));
+ currentpage->m_playlist->SetItem(currentpage->m_nLastFileId, 0, wxT("E"));
}
else
{
- m_playlist->SetItem(listitem.GetId(), 0, _T(">"));
+ currentpage->m_playlist->SetItem(currentpage->m_nLastFileId, 0, wxT(">"));
}
- m_playlist->SetItem(listitem.GetId(), 2, wxString::Format(wxT("%u"),
- (unsigned) GetCurrentMediaCtrl()->Length() / 1000) );
+ currentpage->m_playlist->SetItem(currentpage->m_nLastFileId,
+ 2, wxString::Format(wxT("%u"),
+ (unsigned) currentpage->m_mediactrl->Length() / 1000)
+ );
ResetStatus();
- GetCurrentSlider()->SetRange(0,
- (int)(GetCurrentMediaCtrl()->Length() / 1000));
- GetCurrentGauge()->SetRange((int)(GetCurrentMediaCtrl()->Length() / 1000));
+ currentpage->m_slider->SetRange(0,
+ (int)(currentpage->m_mediactrl->Length() / 1000));
+ currentpage->m_gauge->SetRange((int)(currentpage->m_mediactrl->Length() / 1000));
}
// ----------------------------------------------------------------------------
m_notebook->DeletePage(sel);
}
- m_notebook->AddPage(new wxMediaPlayerNotebookPage(this, m_notebook,
+ m_notebook->AddPage(new wxMediaPlayerNotebookPage(this, m_notebook,
sBackend
), wxT(""), true);
- DoOpenFile(m_szFile, false);
+
+ DoOpenFile(
+ ((wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage())->m_szFile,
+ false);
}
}
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnPlay(wxCommandEvent& WXUNUSED(event))
{
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
wxListItem listitem;
- m_playlist->GetSelectedItem(listitem);
- if (listitem.GetData() == NULL)
+ currentpage->m_playlist->GetSelectedItem(listitem);
+ if ( !listitem.GetData() )
{
int nLast = -1;
- if ((nLast = m_playlist->GetNextItem(nLast,
+ if ((nLast = currentpage->m_playlist->GetNextItem(nLast,
wxLIST_NEXT_ALL,
wxLIST_STATE_DONTCARE)) == -1)
{
//no items in list
- wxMessageBox(_T("No items in playlist!"));
- return;
+ wxMessageBox(wxT("No items in playlist!"));
}
- wxListItem listitem;
+ else
+ {
listitem.SetId(nLast);
- m_playlist->GetItem(listitem);
+ currentpage->m_playlist->GetItem(listitem);
listitem.SetMask(listitem.GetMask() | wxLIST_MASK_STATE);
listitem.SetState(listitem.GetState() | wxLIST_STATE_SELECTED);
- m_playlist->SetItem(listitem);
- wxListEvent event;
- OnChangeSong(event);
+ currentpage->m_playlist->SetItem(listitem);
+ wxASSERT(listitem.GetData());
+ DoPlayFile((*((wxString*) listitem.GetData())));
+ }
}
else
{
- wxListEvent event;
- OnChangeSong(event);
+ wxASSERT(listitem.GetData());
+ DoPlayFile((*((wxString*) listitem.GetData())));
}
}
{
if(event.GetKeyCode() == WXK_BACK/*DELETE*/)
{
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
//delete all selected items
while(true)
{
- wxInt32 nSelectedItem = m_playlist->GetNextItem(
+ wxInt32 nSelectedItem = currentpage->m_playlist->GetNextItem(
-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (nSelectedItem == -1)
break;
wxListItem listitem;
listitem.SetId(nSelectedItem);
- m_playlist->GetItem(listitem);
+ currentpage->m_playlist->GetItem(listitem);
delete (wxString*) listitem.GetData();
- m_playlist->DeleteItem(nSelectedItem);
+ currentpage->m_playlist->DeleteItem(nSelectedItem);
}
}
//Could be wxGetTextFromUser or something else important
if(event.GetEventObject() != this)
- event.Skip();
+ event.Skip();
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnStop(wxCommandEvent& WXUNUSED(evt))
{
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
-
- wxListItem listitem;
- m_playlist->GetSelectedItem(listitem);
- m_playlist->SetItem(listitem.GetId(), 0, _T("[]"));
-
- if(!m_notebook->GetCurrentPage())
- {
- wxMessageBox(wxT("No files are currently open!"));
- return;
- }
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
- if( !GetCurrentMediaCtrl()->Stop() )
+ if( !currentpage->m_mediactrl->Stop() )
wxMessageBox(wxT("Couldn't stop movie!"));
+ else
+ currentpage->m_playlist->SetItem(
+ currentpage->m_nLastFileId, 0, wxT("[]"));
}
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnChangeSong(wxListEvent& WXUNUSED(evt))
{
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
wxListItem listitem;
- m_playlist->GetSelectedItem(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
+// 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))
{
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
- if (m_playlist->GetItemCount() == 0)
+ if (currentpage->m_playlist->GetItemCount() == 0)
return;
wxInt32 nLastSelectedItem = -1;
while(true)
{
- wxInt32 nSelectedItem = m_playlist->GetNextItem(nLastSelectedItem,
+ wxInt32 nSelectedItem = currentpage->m_playlist->GetNextItem(nLastSelectedItem,
wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (nSelectedItem == -1)
break;
nLastSelectedItem = nSelectedItem;
- m_playlist->SetItemState(nSelectedItem, 0, wxLIST_STATE_SELECTED);
+ currentpage->m_playlist->SetItemState(nSelectedItem, 0, wxLIST_STATE_SELECTED);
}
- if (nLastSelectedItem <= 0)
- nLastSelectedItem = m_playlist->GetItemCount() - 1;
+ 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);
- m_playlist->GetItem(listitem);
+ 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);
- m_playlist->SetItem(listitem);
+ currentpage->m_playlist->SetItem(listitem);
- wxListEvent emptyEvent;
- OnChangeSong(emptyEvent);
+ wxASSERT(listitem.GetData());
+ DoPlayFile((*((wxString*) listitem.GetData())));
}
// ----------------------------------------------------------------------------
// wxMediaPlayerFrame::OnNext
//
-// Tedious wxListCtrl stuff. Goes to next song in list, or if at the
+// 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))
{
- wxMediaPlayerListCtrl* m_playlist =
- ((wxMediaPlayerNotebookPage*)m_notebook->GetCurrentPage())->m_playlist;
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
- if (m_playlist->GetItemCount() == 0)
+ if (currentpage->m_playlist->GetItemCount() == 0)
return;
wxInt32 nLastSelectedItem = -1;
while(true)
{
- wxInt32 nSelectedItem = m_playlist->GetNextItem(nLastSelectedItem,
+ wxInt32 nSelectedItem = currentpage->m_playlist->GetNextItem(nLastSelectedItem,
wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (nSelectedItem == -1)
break;
nLastSelectedItem = nSelectedItem;
- m_playlist->SetItemState(nSelectedItem, 0, wxLIST_STATE_SELECTED);
+ currentpage->m_playlist->SetItemState(nSelectedItem, 0, wxLIST_STATE_SELECTED);
}
if (nLastSelectedItem == -1)
+ {
+ if(currentpage->m_nLastFileId == currentpage->m_playlist->GetItemCount() - 1)
nLastSelectedItem = 0;
else
- {
- if (nLastSelectedItem == m_playlist->GetItemCount() - 1)
+ 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);
- m_playlist->GetItem(listitem);
+ currentpage->m_playlist->GetItem(listitem);
listitem.SetMask(listitem.GetMask() | wxLIST_MASK_STATE);
listitem.SetState(listitem.GetState() | wxLIST_STATE_SELECTED);
- m_playlist->SetItem(listitem);
+ currentpage->m_playlist->SetItem(listitem);
- wxListEvent emptyEvent;
- OnChangeSong(emptyEvent);
+ wxASSERT(listitem.GetData());
+ DoPlayFile((*((wxString*) listitem.GetData())));
}
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnVolumeDown(wxCommandEvent& WXUNUSED(event))
{
- double dVolume = GetCurrentMediaCtrl()->GetVolume();
- GetCurrentMediaCtrl()->SetVolume(dVolume < 0.1 ? 0.0 : dVolume - .1);
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
+
+ double dVolume = currentpage->m_mediactrl->GetVolume();
+ currentpage->m_mediactrl->SetVolume(dVolume < 0.1 ? 0.0 : dVolume - .1);
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void wxMediaPlayerFrame::OnVolumeUp(wxCommandEvent& WXUNUSED(event))
{
- double dVolume = GetCurrentMediaCtrl()->GetVolume();
- GetCurrentMediaCtrl()->SetVolume(dVolume > 0.9 ? 1.0 : dVolume + .1);
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_notebook->GetCurrentPage();
+
+ double dVolume = currentpage->m_mediactrl->GetVolume();
+ currentpage->m_mediactrl->SetVolume(dVolume > 0.9 ? 1.0 : dVolume + .1);
}
// ----------------------------------------------------------------------------
-// wxMediaPlayerFrame::OnCloseCurrentPage
+// wxMediaPlayerFrame::OnPageChange
//
-// Called when the user wants to closes the current notebook page
+// Called when the user changes the current notebook page shown
// ----------------------------------------------------------------------------
-
void wxMediaPlayerFrame::OnPageChange(wxNotebookEvent& WXUNUSED(event))
{
ResetStatus();
// ----------------------------------------------------------------------------
void wxMediaPlayerTimer::Notify()
{
- if(m_frame->m_notebook->GetCurrentPage())
- {
- // get some control pointers from current notebook page
- wxMediaCtrl* mediactrl =
- ((wxMediaPlayerNotebookPage*)m_frame->m_notebook->GetCurrentPage())->m_mediactrl;
- wxSlider* slider =
- ((wxMediaPlayerNotebookPage*)m_frame->m_notebook->GetCurrentPage())->m_slider;
- wxGauge* gauge =
- ((wxMediaPlayerNotebookPage*)m_frame->m_notebook->GetCurrentPage())->m_gauge;
+ wxMediaPlayerNotebookPage* currentpage =
+ (wxMediaPlayerNotebookPage*) m_frame->m_notebook->GetCurrentPage();
+ if(currentpage)
+ {
// if the slider is being dragged then update it with the song position
- if(((wxMediaPlayerNotebookPage*)m_frame->m_notebook->GetCurrentPage())->IsBeingDragged() == false)
+ if(currentpage->IsBeingDragged() == false)
{
- long lPosition = (long)( mediactrl->Tell() / 1000 );
- slider->SetValue(lPosition);
+ long lPosition = (long)( currentpage->m_mediactrl->Tell() / 1000 );
+ currentpage->m_slider->SetValue(lPosition);
}
// update guage with value from slider
- gauge->SetValue(slider->GetValue());
+ currentpage->m_gauge->SetValue(currentpage->m_slider->GetValue());
#if wxUSE_STATUSBAR
m_frame->SetStatusText(wxString::Format(
wxT("%s Pos:%u State:%s Loops:%i D/T:[%i]/[%i] V:%i%%"),
m_frame->m_basestatus.c_str(),
- slider->GetValue(),
- wxGetMediaStateText(mediactrl->GetState()),
- ((wxMediaPlayerNotebookPage*)m_frame->m_notebook->GetCurrentPage())->m_nLoops,
- (int)mediactrl->GetDownloadProgress(),
- (int)mediactrl->GetDownloadTotal(),
- (int)(mediactrl->GetVolume() * 100)));
+ currentpage->m_slider->GetValue(),
+ wxGetMediaStateText(currentpage->m_mediactrl->GetState()),
+ currentpage->m_nLoops,
+ (int)currentpage->m_mediactrl->GetDownloadProgress(),
+ (int)currentpage->m_mediactrl->GetDownloadTotal(),
+ (int)(currentpage->m_mediactrl->GetVolume() * 100)));
#endif // wxUSE_STATUSBAR
}
}
// 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_bIsBeingDragged(false),
- m_nLoops(0), m_bLoop(false), m_parentFrame(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)
{
//
// [5 control buttons]
// [slider]
// [gauge]
- //
+ //
//
// Create and attach the sizer
// Create the playlist/listctrl
//
m_playlist = new wxMediaPlayerListCtrl();
- m_playlist->Create(this, wxID_LISTCTRL, wxDefaultPosition,
+ m_playlist->Create(this, wxID_LISTCTRL, wxDefaultPosition,
wxDefaultSize,
wxLC_REPORT //wxLC_LIST
| wxSUNKEN_BORDER);
//
// Where Column one is a character representing the state the file is in:
// * - not the current file
- // E - Error has occured
+ // E - Error has occured
// > - Currently Playing
// [] - Stopped
// || - Paused
sizer->Add(m_playlist, 0, wxALIGN_CENTER_HORIZONTAL|wxALL|wxEXPAND, 5);
//
- // 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
- //
- // TODO: This is probably not the best practice since
- // the user will load multiple notebook pages with multiple
- // wxMediaCtrl elements.
- //
- // 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.
- //
- wxConfigBase* conf = wxConfigBase::Get();
- wxString key, outstring;
- for(int i = 0; ; ++i)
- {
- key.clear();
- key << i;
- if(!conf->Read(key, &outstring))
- break;
- m_playlist->AddToPlayList(outstring);
- }
-
- //
- // Create the control buttons
+ // Create the control buttons
// TODO/FIXME/HACK: This part about sizers is really a nice hack
// and probably isn't proper
//
m_vdButton = new wxButton();
m_vuButton = new wxButton();
- m_prevButton->Create(this, wxID_BUTTONPREV, _T("|<"));
- m_playButton->Create(this, wxID_BUTTONPLAY, _T(">"));
- m_stopButton->Create(this, wxID_BUTTONSTOP, _T("[]"));
- m_nextButton->Create(this, wxID_BUTTONNEXT, _T(">|"));
- m_vdButton->Create(this, wxID_BUTTONVD, _T("(("));
- m_vuButton->Create(this, wxID_BUTTONVU, _T("))"));
+ 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);
m_gauge->Create(this, wxID_GAUGE, 0, wxDefaultPosition, wxDefaultSize,
wxGA_HORIZONTAL | wxGA_SMOOTH);
sizer->Add(m_gauge, 0, wxALIGN_CENTER_HORIZONTAL|wxALL|wxEXPAND , 5);
-
+
//
// ListCtrl events
//
- this->Connect( wxID_LISTCTRL, wxEVT_COMMAND_LIST_ITEM_ACTIVATED,
+ this->Connect( wxID_LISTCTRL, wxEVT_COMMAND_LIST_ITEM_ACTIVATED,
wxListEventHandler(wxMediaPlayerFrame::OnChangeSong),
(wxObject*)0, parentFrame);
this->Connect(wxID_MEDIACTRL, wxEVT_MEDIA_FINISHED,
wxMediaEventHandler(wxMediaPlayerNotebookPage::OnMediaFinished));
this->Connect(wxID_MEDIACTRL, wxEVT_MEDIA_LOADED,
- wxMediaEventHandler(wxMediaPlayerFrame::OnMediaLoaded),
+ wxMediaEventHandler(wxMediaPlayerFrame::OnMediaLoaded),
(wxObject*)0, parentFrame);
//
// Button events
//
- this->Connect( wxID_BUTTONPREV, wxEVT_COMMAND_BUTTON_CLICKED,
+ this->Connect( wxID_BUTTONPREV, wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxMediaPlayerFrame::OnPrev),
(wxObject*)0, parentFrame);
- this->Connect( wxID_BUTTONPLAY, wxEVT_COMMAND_BUTTON_CLICKED,
+ this->Connect( wxID_BUTTONPLAY, wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxMediaPlayerFrame::OnPlay),
(wxObject*)0, parentFrame);
- this->Connect( wxID_BUTTONSTOP, wxEVT_COMMAND_BUTTON_CLICKED,
+ this->Connect( wxID_BUTTONSTOP, wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxMediaPlayerFrame::OnStop),
(wxObject*)0, parentFrame);
- this->Connect( wxID_BUTTONNEXT, wxEVT_COMMAND_BUTTON_CLICKED,
+ this->Connect( wxID_BUTTONNEXT, wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxMediaPlayerFrame::OnNext),
(wxObject*)0, parentFrame);
- this->Connect( wxID_BUTTONVD, wxEVT_COMMAND_BUTTON_CLICKED,
+ this->Connect( wxID_BUTTONVD, wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxMediaPlayerFrame::OnVolumeDown),
(wxObject*)0, parentFrame);
- this->Connect( wxID_BUTTONVU, wxEVT_COMMAND_BUTTON_CLICKED,
+ this->Connect( wxID_BUTTONVU, wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxMediaPlayerFrame::OnVolumeUp),
(wxObject*)0, parentFrame);
}
// Returns true if the user is dragging the slider
// ----------------------------------------------------------------------------
bool wxMediaPlayerNotebookPage::IsBeingDragged()
-{
- return m_bIsBeingDragged;
+{
+ return m_bIsBeingDragged;
}
// ----------------------------------------------------------------------------
if ( !m_mediactrl->Play() )
{
wxMessageBox(wxT("Couldn't loop movie!"));
- m_playlist->SetItem(m_parentFrame->m_nLastFileId, 0, _T("E"));
+ m_playlist->SetItem(m_nLastFileId, 0, wxT("E"));
}
else
++m_nLoops;
}
else
{
- m_playlist->SetItem(m_parentFrame->m_nLastFileId, 0, _T("[]"));
+ m_playlist->SetItem(m_nLastFileId, 0, wxT("[]"));
}
}
projects / wxWidgets.git / blobdiff