libVLC examples, from GCI work

 - Gtk+ player
 - wx   player
 - Qt   player
 - DVD ripper using Gtk

doc/libvlc/QtPlayer/LICENSE

+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO. 

doc/libvlc/QtPlayer/QtVLC.pro

+TEMPLATE = app
+TARGET = qtvlc
+DEPENDPATH += .
+INCLUDEPATH += .
+LIBS += -lvlc -lX11
+
+# Input
+HEADERS += player.h
+SOURCES += main.cpp player.cpp

doc/libvlc/QtPlayer/main.cpp

+/******************************
+ * Qt player using libVLC     *
+ * By protonux                *
+ *                            *
+ * Under WTFPL                *
+ ******************************/
+
+#include <QApplication>
+#include "player.h"
+
+#ifdef Q_WS_X11
+    #include <X11/Xlib.h>
+#endif
+
+int main(int argc, char *argv[]) {
+#ifdef Q_WS_X11
+    XInitThreads();
+#endif
+
+    QApplication app(argc, argv);
+
+    Mwindow player;
+    player.show();
+
+    return app.exec();
+}

doc/libvlc/QtPlayer/player.cpp

+/******************************
+ * Qt player using libVLC     *
+ * By protonux                *
+ *                            *
+ * Under WTFPL                *
+ ******************************/
+#include "player.h"
+#include <vlc/vlc.h>
+
+#define qtu( i ) ((i).toUtf8().constData())
+
+#include <QtGui>
+
+Mwindow::Mwindow() {
+    vlcPlayer = NULL;
+
+    /* Init libVLC */
+    if((vlcObject = libvlc_new(0,NULL)) == NULL) {
+        printf("Could not init libVLC");
+        exit(1);
+    }
+
+    /* Display libVLC version */
+    printf("libVLC version: %s\n",libvlc_get_version());
+
+    /* Interface initialisation */
+    initMenus();
+    initComponents();
+}
+
+Mwindow::~Mwindow() {
+    if(vlcObject)
+        libvlc_release(vlcObject);
+}
+
+void Mwindow::initMenus() {
+
+    centralWidget = new QWidget;
+
+    videoWidget = new QWidget;
+    videoWidget->setAutoFillBackground( true );
+    QPalette plt = palette();
+    plt.setColor( QPalette::Window, Qt::black );
+    videoWidget->setPalette( plt );
+
+    QMenu *fileMenu = menuBar()->addMenu("&File");
+    QMenu *editMenu = menuBar()->addMenu("&Edit");
+
+    QAction *Open = new QAction("&Open", this);
+    QAction *Quit = new QAction("&Quit", this);
+    QAction *playAc = new QAction("&Play/Pause", this);
+
+    Open->setShortcut(QKeySequence("Ctrl+O"));
+    Quit->setShortcut(QKeySequence("Ctrl+Q"));
+
+    fileMenu->addAction(Open);
+    fileMenu->addAction(Quit);
+    editMenu->addAction(playAc);
+
+    connect(Open, SIGNAL(triggered()), this, SLOT(openFile()));
+    connect(playAc, SIGNAL(triggered()), this, SLOT(play()));
+    connect(Quit, SIGNAL(triggered()), qApp, SLOT(quit()));
+}
+
+void Mwindow::initComponents() {
+
+    playBut = new QPushButton("Play");
+    QObject::connect(playBut, SIGNAL(clicked()), this, SLOT(play()));
+
+    stopBut = new QPushButton("Stop");
+    QObject::connect(stopBut, SIGNAL(clicked()), this, SLOT(stop()));
+
+    muteBut = new QPushButton("Mute");
+    QObject::connect(muteBut, SIGNAL(clicked()), this, SLOT(mute()));
+
+    volumeSlider = new QSlider(Qt::Horizontal);
+    QObject::connect(volumeSlider, SIGNAL(sliderMoved(int)), this, SLOT(changeVolume(int)));
+    volumeSlider->setValue(80);
+
+    slider = new QSlider(Qt::Horizontal);
+    slider->setMaximum(1000);
+    QObject::connect(slider, SIGNAL(sliderMoved(int)), this, SLOT(changePosition(int)));
+
+    QTimer *timer = new QTimer(this);
+    connect(timer, SIGNAL(timeout()), this, SLOT(updateInterface()));
+    timer->start(100);
+
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(playBut);
+    layout->addWidget(stopBut);
+    layout->addWidget(muteBut);
+    layout->addWidget(volumeSlider);
+
+    QVBoxLayout *layout2 = new QVBoxLayout;
+    layout2->addWidget(videoWidget);
+    layout2->addWidget(slider);
+    layout2->addLayout(layout);
+
+    centralWidget->setLayout(layout2);
+    setCentralWidget(centralWidget);
+    resize( 600, 400);
+}
+
+void Mwindow::openFile() {
+    /* Just the basic file-select box */
+    QString fileOpen = QFileDialog::getOpenFileName(this,tr("Load a file"), "~");
+
+    /* Stop if something is playing */
+    if( vlcPlayer && libvlc_media_player_is_playing(vlcPlayer) )
+        stop();
+
+    /* New Media */
+    libvlc_media_t *vlcMedia = libvlc_media_new_path(vlcObject,qtu(fileOpen));
+    if( !vlcMedia )
+        return;
+
+    vlcPlayer = libvlc_media_player_new_from_media (vlcMedia);
+    libvlc_media_release(vlcMedia);
+
+    /* Integrate the video in the interface */
+#if defined(Q_OS_MAC)
+    libvlc_media_player_set_nsobject(vlcPlayer, videoWidget->winId());
+#elif defined(Q_OS_UNIX)
+    libvlc_media_player_set_xwindow(vlcPlayer, videoWidget->winId());
+#elif defined(Q_OS_WIN)
+    libvlc_media_player_set_hwnd(vlcPlayer, videoWidget->winId());
+#endif
+
+    /* And play */
+    libvlc_media_player_play (vlcPlayer);
+
+    //Set vars and text correctly
+    playBut->setText("Pause");
+}
+
+void Mwindow::play() {
+
+    if(vlcPlayer)
+    {
+        if (libvlc_media_player_is_playing(vlcPlayer))
+        {
+            libvlc_media_player_pause(vlcPlayer);
+            playBut->setText("Play");
+        }
+        else
+        {
+            libvlc_media_player_play(vlcPlayer);
+            playBut->setText("Pause");
+        }
+    }
+}
+
+int Mwindow::changeVolume(int vol) { //Called if you change the volume slider
+
+    if(vlcPlayer)
+        return libvlc_audio_set_volume (vlcPlayer,vol);
+
+    return 0;
+}
+
+void Mwindow::changePosition(int pos) { //Called if you change the position slider
+
+    if(vlcPlayer) //It segfault if vlcPlayer don't exist
+        libvlc_media_player_set_position(vlcPlayer,(float)pos/(float)1000);
+}
+
+void Mwindow::updateInterface() { //Update interface and check if song is finished
+
+    if(vlcPlayer) //It segfault if vlcPlayer don't exist
+    {
+        /* update the timeline */
+        float pos = libvlc_media_player_get_position(vlcPlayer);
+        int siderPos=(int)(pos*(float)(1000));
+        slider->setValue(siderPos);
+
+        /* Stop the media */
+        if (libvlc_media_player_get_state(vlcPlayer) == 6) { this->stop(); }
+    }
+}
+
+void Mwindow::stop() {
+    if(vlcPlayer) {
+        libvlc_media_player_stop(vlcPlayer);
+        libvlc_media_player_release(vlcPlayer);
+        slider->setValue(0);
+        playBut->setText("Play");
+    }
+    vlcPlayer = NULL;
+}
+
+void Mwindow::mute() {
+    if(vlcPlayer) {
+        if(volumeSlider->value() == 0) { //if already muted...
+
+                this->changeVolume(80);
+                volumeSlider->setValue(80);
+
+        } else { //else mute volume
+
+                this->changeVolume(0);
+                volumeSlider->setValue(0);
+
+        }
+    }
+}
+
+void Mwindow::closeEvent(QCloseEvent *event) {
+    stop();
+    event->accept();
+}

doc/libvlc/QtPlayer/player.h

+/******************************
+ * Qt player using libVLC     *
+ * By protonux                *
+ *                            *
+ * Under WTFPL                *
+ ******************************/
+
+#ifndef PLAYER
+#define PLAYER
+
+#include <QtGui>
+#include <vlc/vlc.h>
+
+class Mwindow : public QMainWindow {
+
+    Q_OBJECT
+
+        public:
+               Mwindow();
+               virtual ~Mwindow();
+
+        private slots:
+               void openFile();
+               void play();
+               void stop();
+               void mute();
+
+               int changeVolume(int);
+               void changePosition(int);
+               void updateInterface();
+
+        protected:
+               virtual void closeEvent(QCloseEvent*);
+
+        private:
+               QString current;
+               QPushButton *playBut;
+               QPushButton *stopBut;
+               QPushButton *muteBut;
+               QSlider *volumeSlider;
+               QSlider *slider;
+               QWidget *videoWidget;
+               QWidget *centralWidget;
+               libvlc_instance_t *vlcObject;
+               libvlc_media_player_t *vlcPlayer;
+
+               void initMenus();
+               void initComponents();
+};
+
+
+#endif

doc/libvlc/gtk_player.c

+// gcc -o gtk_player gtk_player.c `pkg-config --libs gtk+-2.0 libvlc` `pkg-config --cflags gtk+-2.0 libvlc`
+
+/* License WTFPL http://sam.zoy.org/wtfpl/ */
+/* Written by Vincent Schüßler */
+
+#include <stdlib.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <vlc/vlc.h>
+
+#define BORDER_WIDTH 6
+
+void destroy(GtkWidget *widget, gpointer data);
+void player_widget_on_realize(GtkWidget *widget, gpointer data);
+void on_open(GtkWidget *widget, gpointer data);
+void open_media(const char* uri);
+void play(void);
+void pause_player(void);
+void on_playpause(GtkWidget *widget, gpointer data);
+void on_stop(GtkWidget *widget, gpointer data);
+
+libvlc_media_player_t *media_player;
+libvlc_instance_t *vlc_inst;
+GtkWidget *playpause_button;
+
+void destroy(GtkWidget *widget, gpointer data) {
+    gtk_main_quit();
+}
+
+void player_widget_on_realize(GtkWidget *widget, gpointer data) {
+    libvlc_media_player_set_xwindow(media_player, GDK_WINDOW_XID(gtk_widget_get_window(widget)));
+}
+
+void on_open(GtkWidget *widget, gpointer data) {
+    GtkWidget *dialog;
+    dialog = gtk_file_chooser_dialog_new("Choose Media", data, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
+    if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+        char *uri;
+        uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));
+        open_media(uri);
+        g_free(uri);
+    }
+    gtk_widget_destroy(dialog);
+}
+
+void open_media(const char* uri) {
+    libvlc_media_t *media;
+    media = libvlc_media_new_location(vlc_inst, uri);
+    libvlc_media_player_set_media(media_player, media);
+    play();
+    libvlc_media_release(media);
+}
+
+void on_playpause(GtkWidget *widget, gpointer data) {
+    if(libvlc_media_player_is_playing(media_player) == 1) {
+        pause_player();
+    }
+    else {
+        play();
+    }
+}
+
+void on_stop(GtkWidget *widget, gpointer data) {
+    pause_player();
+    libvlc_media_player_stop(media_player);
+}
+
+void play(void) {
+    libvlc_media_player_play(media_player);
+    gtk_button_set_label(GTK_BUTTON(playpause_button), "gtk-media-pause");
+}
+
+void pause_player(void) {
+    libvlc_media_player_pause(media_player);
+    gtk_button_set_label(GTK_BUTTON(playpause_button), "gtk-media-play");
+}
+
+int main( int argc, char *argv[] ) {
+    GtkWidget *window,
+              *vbox,
+              *menubar,
+              *filemenu,
+              *fileitem,
+              *filemenu_openitem,
+              *player_widget,
+              *hbuttonbox,
+              *stop_button;
+    
+    gtk_init (&argc, &argv);
+    // setup window
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_default_size(GTK_WINDOW(window), 400, 300);
+    g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
+    gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+    gtk_window_set_title(GTK_WINDOW(window), "GTK+ libVLC Demo");
+
+    //setup vbox
+    vbox = gtk_vbox_new(FALSE, 0);
+    gtk_container_add(GTK_CONTAINER(window), vbox);
+
+    //setup menu
+    menubar = gtk_menu_bar_new();
+    filemenu = gtk_menu_new();
+    fileitem = gtk_menu_item_new_with_label ("File");
+    filemenu_openitem = gtk_menu_item_new_with_label("Open");
+    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), filemenu_openitem);
+    gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileitem), filemenu);
+    gtk_menu_bar_append(GTK_MENU_BAR(menubar), fileitem);
+    gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
+    g_signal_connect(filemenu_openitem, "activate", G_CALLBACK(on_open), window);
+
+    //setup player widget
+    player_widget = gtk_drawing_area_new();
+    gtk_box_pack_start(GTK_BOX(vbox), player_widget, TRUE, TRUE, 0);
+
+    //setup controls
+    //playpause_button = gtk_button_new_from_stock(GTK_STOCK_MEDIA_PLAY);
+    playpause_button = gtk_button_new_with_label("gtk-media-play");
+    gtk_button_set_use_stock(GTK_BUTTON(playpause_button), TRUE);
+    stop_button = gtk_button_new_from_stock(GTK_STOCK_MEDIA_STOP);
+    g_signal_connect(playpause_button, "clicked", G_CALLBACK(on_playpause), NULL);
+    g_signal_connect(stop_button, "clicked", G_CALLBACK(on_stop), NULL);
+    hbuttonbox = gtk_hbutton_box_new();
+    gtk_container_set_border_width(GTK_CONTAINER(hbuttonbox), BORDER_WIDTH);
+    gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox), GTK_BUTTONBOX_START);
+    gtk_box_pack_start(GTK_BOX(hbuttonbox), playpause_button, FALSE, FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbuttonbox), stop_button, FALSE, FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, FALSE, 0);
+
+    //setup vlc
+    vlc_inst = libvlc_new(0, NULL);
+    media_player = libvlc_media_player_new(vlc_inst);
+    g_signal_connect(G_OBJECT(player_widget), "realize", G_CALLBACK(player_widget_on_realize), NULL);
+
+    gtk_widget_show_all(window);
+    gtk_main ();
+
+    libvlc_media_player_release(media_player);
+    libvlc_release(vlc_inst);
+    return 0;
+}

doc/libvlc/wx_player.cpp

+// g++ wx_player.cpp `wx-config --libs` `wx-config --cxxflags` `pkg-config --cflags gtk+-2.0 libvlc` `pkg-config --libs gtk+-2.0 libvlc` -o wx_player
+
+/* License WTFPL http://sam.zoy.org/wtfpl/ */
+/* Written by Vincent Schüßler */
+
+#include <wx/wx.h>
+#include <wx/filename.h>
+#include <vlc/vlc.h>
+#include <climits>
+
+#ifdef __WXGTK__
+    #include <gdk/gdkx.h>
+    #include <gtk/gtk.h>
+    #include <wx/gtk/win_gtk.h>
+    #define GET_XID(window) GDK_WINDOW_XWINDOW(GTK_PIZZA(window->m_wxwindow)->bin_window)
+#endif
+
+#define myID_PLAYPAUSE wxID_HIGHEST+1
+#define myID_STOP wxID_HIGHEST+2
+#define myID_TIMELINE wxID_HIGHEST+3
+#define myID_VOLUME wxID_HIGHEST+4
+
+#define TIMELINE_MAX (INT_MAX-9)
+#define VOLUME_MAX 100
+
+DECLARE_EVENT_TYPE(vlcEVT_END, -1)
+DECLARE_EVENT_TYPE(vlcEVT_POS, -1)
+DEFINE_EVENT_TYPE(vlcEVT_END)
+DEFINE_EVENT_TYPE(vlcEVT_POS)
+
+void OnPositionChanged_VLC(const libvlc_event_t *event, void *data);
+void OnEndReached_VLC(const libvlc_event_t *event, void *data);
+
+class MainWindow : public wxFrame {
+    public:
+        MainWindow(const wxString& title);
+        ~MainWindow();
+
+    private:
+        void initVLC();
+
+        void OnOpen(wxCommandEvent& event);
+        void OnPlayPause(wxCommandEvent& event);
+        void OnStop(wxCommandEvent& event);
+        void OnPositionChanged_USR(wxCommandEvent& event);
+        void OnPositionChanged_VLC(wxCommandEvent& event);
+        void OnEndReached_VLC(wxCommandEvent& event);
+        void OnVolumeChanged(wxCommandEvent& event);
+        void OnVolumeClicked(wxMouseEvent& event);
+        void OnTimelineClicked(wxMouseEvent& event);
+
+        void play();
+        void pause();
+        void stop();
+        void setTimeline(float value);
+        void connectTimeline();
+
+        wxButton *playpause_button;
+        wxButton *stop_button;
+        wxSlider *timeline;
+        wxSlider *volume_slider;
+        wxWindow *player_widget;
+
+        libvlc_media_player_t *media_player;
+        libvlc_instance_t *vlc_inst;
+        libvlc_event_manager_t *vlc_evt_man;
+};
+
+MainWindow *mainWindow;
+
+MainWindow::MainWindow(const wxString& title) : wxFrame(NULL, wxID_ANY, title, wxDefaultPosition) {
+    // setup menubar
+    wxMenuBar *menubar;
+    wxMenu *file;
+    menubar = new wxMenuBar;
+    file = new wxMenu;
+    file->Append(wxID_OPEN, wxT("&Open"));
+    menubar->Append(file, wxT("&File"));
+    SetMenuBar(menubar);
+    Connect(wxID_OPEN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainWindow::OnOpen));
+
+    // setup vbox
+    wxBoxSizer *vbox = new wxBoxSizer(wxVERTICAL);
+    this->SetSizer(vbox);
+
+    //setup player widget
+    player_widget = new wxWindow(this, wxID_ANY);
+    player_widget->SetBackgroundColour(wxColour(wxT("black")));
+    vbox->Add(player_widget, 1, wxEXPAND | wxALIGN_TOP);
+
+    //setup timeline slider
+    timeline = new wxSlider(this, myID_TIMELINE, 0, 0, TIMELINE_MAX);
+    timeline->Enable(false);
+    vbox->Add(timeline, 0, wxEXPAND);
+    connectTimeline();
+    timeline->Connect(myID_TIMELINE, wxEVT_LEFT_UP, wxMouseEventHandler(MainWindow::OnTimelineClicked));
+
+    //setup control panel
+    wxPanel *controlPanel = new wxPanel(this, wxID_ANY);
+
+    //setup hbox
+    wxBoxSizer *hbox = new wxBoxSizer(wxHORIZONTAL);
+    controlPanel->SetSizer(hbox);
+    vbox->Add(controlPanel, 0, wxEXPAND);
+
+    //setup controls
+    playpause_button = new wxButton(controlPanel, myID_PLAYPAUSE, wxT("Play"));
+    stop_button = new wxButton(controlPanel, myID_STOP, wxT("Stop"));
+    volume_slider = new wxSlider(controlPanel, myID_VOLUME, VOLUME_MAX, 0, VOLUME_MAX, wxDefaultPosition, wxSize(100, -1));
+    playpause_button->Enable(false);
+    stop_button->Enable(false);
+    hbox->Add(playpause_button);
+    hbox->Add(stop_button);
+    hbox->AddStretchSpacer();
+    hbox->Add(volume_slider);
+    Connect(myID_PLAYPAUSE, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MainWindow::OnPlayPause));
+    Connect(myID_STOP, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MainWindow::OnStop));
+    Connect(myID_VOLUME, wxEVT_COMMAND_SLIDER_UPDATED, wxCommandEventHandler(MainWindow::OnVolumeChanged));
+    volume_slider->Connect(myID_VOLUME, wxEVT_LEFT_UP, wxMouseEventHandler(MainWindow::OnVolumeClicked));
+
+    //setup vlc
+    vlc_inst = libvlc_new(0, NULL);
+    media_player = libvlc_media_player_new(vlc_inst);
+    vlc_evt_man = libvlc_media_player_event_manager(media_player);
+    libvlc_event_attach(vlc_evt_man, libvlc_MediaPlayerEndReached, ::OnEndReached_VLC, NULL);
+    libvlc_event_attach(vlc_evt_man, libvlc_MediaPlayerPositionChanged, ::OnPositionChanged_VLC, NULL);
+    Connect(wxID_ANY, vlcEVT_END, wxCommandEventHandler(MainWindow::OnEndReached_VLC));
+    Connect(wxID_ANY, vlcEVT_POS, wxCommandEventHandler(MainWindow::OnPositionChanged_VLC));
+
+    Show(true);
+    initVLC();
+}
+
+MainWindow::~MainWindow() {
+    libvlc_media_player_release(media_player);
+    libvlc_release(vlc_inst);
+}
+
+void MainWindow::initVLC() {
+    #ifdef __WXGTK__
+        libvlc_media_player_set_xwindow(media_player, GET_XID(this->player_widget));
+    #else
+        libvlc_media_player_set_hwnd(media_player, this->player_widget->GetHandle());
+    #endif
+}
+
+void MainWindow::OnOpen(wxCommandEvent& event) {
+    wxFileDialog openFileDialog(this, wxT("Choose File"));
+
+    if (openFileDialog.ShowModal() == wxID_CANCEL) {
+        return;
+    }
+    else {
+        libvlc_media_t *media;
+        wxFileName filename = wxFileName::FileName(openFileDialog.GetPath());
+        filename.MakeRelativeTo();
+        media = libvlc_media_new_path(vlc_inst, filename.GetFullPath().mb_str());
+        libvlc_media_player_set_media(media_player, media);
+        play();
+        libvlc_media_release(media);
+    }
+}
+
+void MainWindow::OnPlayPause(wxCommandEvent& event) {
+    if(libvlc_media_player_is_playing(media_player) == 1) {
+        pause();
+    }
+    else {
+        play();
+    }
+}
+
+void MainWindow::OnStop(wxCommandEvent& event) {
+    stop();
+}
+
+void MainWindow::OnPositionChanged_USR(wxCommandEvent& event) {
+    libvlc_media_player_set_position(media_player, (float) event.GetInt() / (float) TIMELINE_MAX);
+}
+
+void MainWindow::OnPositionChanged_VLC(wxCommandEvent& event) {
+    float factor = libvlc_media_player_get_position(media_player);
+    setTimeline(factor);
+}
+
+void MainWindow::OnEndReached_VLC(wxCommandEvent& event) {
+    stop();
+}
+
+void MainWindow::OnVolumeChanged(wxCommandEvent& event) {
+    libvlc_audio_set_volume(media_player, volume_slider->GetValue());
+}
+
+void MainWindow::OnVolumeClicked(wxMouseEvent& event) {
+    wxSize size = mainWindow->volume_slider->GetSize();
+    float position = (float) event.GetX() / (float) size.GetWidth();
+    mainWindow->volume_slider->SetValue(position*VOLUME_MAX);
+    libvlc_audio_set_volume(mainWindow->media_player, position*VOLUME_MAX);
+    event.Skip();
+}
+
+void MainWindow::OnTimelineClicked(wxMouseEvent& event) {
+    wxSize size = mainWindow->timeline->GetSize();
+    float position = (float) event.GetX() / (float) size.GetWidth();
+    libvlc_media_player_set_position(mainWindow->media_player, position);
+    mainWindow->setTimeline(position);
+    event.Skip();
+}
+
+void MainWindow::play() {
+    libvlc_media_player_play(media_player);
+    playpause_button->SetLabel(wxT("Pause"));
+    playpause_button->Enable(true);
+    stop_button->Enable(true);
+    timeline->Enable(true);
+}
+
+void MainWindow::pause() {
+    libvlc_media_player_pause(media_player);
+    playpause_button->SetLabel(wxT("Play"));
+}
+
+void MainWindow::stop() {
+    pause();
+    libvlc_media_player_stop(media_player);
+    stop_button->Enable(false);
+    setTimeline(0.0);
+    timeline->Enable(false);
+}
+
+void MainWindow::setTimeline(float value) {
+    if(value < 0.0) value = 0.0;
+    if(value > 1.0) value = 1.0;
+    Disconnect(myID_TIMELINE);
+    timeline->SetValue((int) (value * TIMELINE_MAX));
+    connectTimeline();
+}
+
+void MainWindow::connectTimeline() {
+    Connect(myID_TIMELINE, wxEVT_COMMAND_SLIDER_UPDATED, wxCommandEventHandler(MainWindow::OnPositionChanged_USR));
+}
+
+class MyApp : public wxApp {
+    public:
+        virtual bool OnInit();
+};
+
+void OnPositionChanged_VLC(const libvlc_event_t *event, void *data) {
+    wxCommandEvent evt(vlcEVT_POS, wxID_ANY);
+    mainWindow->AddPendingEvent(evt);
+}
+
+void OnEndReached_VLC(const libvlc_event_t *event, void *data) {
+    wxCommandEvent evt(vlcEVT_END, wxID_ANY);
+    mainWindow->AddPendingEvent(evt);
+}
+
+bool MyApp::OnInit() {
+    mainWindow = new MainWindow(wxT("wxWidgets libVLC demo"));
+    return true;
+}
+
+IMPLEMENT_APP(MyApp)