weld MediaPlaybackPanel

Change-Id: I84c9e6f37de3b22b896f8109e49a5a0391630ac2
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/87754
Tested-by: Jenkins
Reviewed-by: Caolán McNamara <caolanm@redhat.com>

7 files changed, 226 insertions, 409 deletions

diff --git a/avmedia/inc/bitmaps.hlst b/avmedia/inc/bitmaps.hlst
index 24441a26f688..682d090fe7b1 100644
--- a/avmedia/inc/bitmaps.hlst
+++ b/avmedia/inc/bitmaps.hlst
@@ -10,20 +10,6 @@
 #ifndef INCLUDED_AVMEDIA_INC_BITMAPS_HRC
 #define INCLUDED_AVMEDIA_INC_BITMAPS_HRC
 
-#define AVMEDIA_IMG_OPEN_NORMAL     "avmedia/res/av02048.png"
-#define AVMEDIA_IMG_PLAY_NORMAL     "avmedia/res/av02049.png"
-#define AVMEDIA_IMG_PAUSE_NORMAL    "avmedia/res/av02050.png"
-#define AVMEDIA_IMG_STOP_NORMAL     "avmedia/res/av02051.png"
-#define AVMEDIA_IMG_LOOP_NORMAL     "avmedia/res/av02052.png"
-#define AVMEDIA_IMG_INSERT_NORMAL   "avmedia/res/av02053.png"
-#define AVMEDIA_IMG_MUTE_NORMAL     "avmedia/res/av02054.png"
-#define AVMEDIA_IMG_OPEN_LARGE      "avmedia/res/avl02048.png"
-#define AVMEDIA_IMG_PLAY_LARGE      "avmedia/res/avl02049.png"
-#define AVMEDIA_IMG_PAUSE_LARGE     "avmedia/res/avl02050.png"
-#define AVMEDIA_IMG_STOP_LARGE      "avmedia/res/avl02051.png"
-#define AVMEDIA_IMG_LOOP_LARGE      "avmedia/res/avl02052.png"
-#define AVMEDIA_IMG_INSERT_LARGE    "avmedia/res/avl02053.png"
-#define AVMEDIA_IMG_MUTE_LARGE      "avmedia/res/avl02054.png"
 #define AVMEDIA_BMP_AUDIOLOGO       "avmedia/res/avaudiologo.png"
 #define AVMEDIA_BMP_EMPTYLOGO       "avmedia/res/avemptylogo.png"
 
diff --git a/avmedia/inc/mediacontrol.hxx b/avmedia/inc/mediacontrol.hxx
index 9172195eea71..b67ac0a36808 100644
--- a/avmedia/inc/mediacontrol.hxx
+++ b/avmedia/inc/mediacontrol.hxx
@@ -22,17 +22,14 @@
 
 #include <avmedia/mediaitem.hxx>
 
+#include <vcl/ctrl.hxx>
 #include <vcl/timer.hxx>
 #include <vcl/idle.hxx>
-#include <vcl/slider.hxx>
-#include <vcl/toolbox.hxx>
-#include <vcl/fixed.hxx>
+#include <vcl/weld.hxx>
 #include <avmedia/MediaControlBase.hxx>
 
 #define AVMEDIA_CONTROLOFFSET 6
 
-class ListBox;
-
 namespace avmedia
 {
 
@@ -41,12 +38,11 @@ class MediaItem;
 class MediaControl : public Control, public MediaControlBase
 {
 public:
-
                         MediaControl( vcl::Window* pParent, MediaControlStyle eControlStyle );
     virtual             ~MediaControl() override;
     virtual void        dispose() override;
 
-    const Size&         getMinSizePixel() const;
+    Size                getMinSizePixel() const;
 
     void                setState( const MediaItem& rItem );
     void                UpdateURLField( MediaItem const & maItem );
@@ -58,21 +54,24 @@ protected:
 
     virtual void        Resize() override;
     virtual void        InitializeWidgets() override;
-    VclPtr<FixedText>        mpMediaPath;
+    std::unique_ptr<weld::Label> mxMediaPath;
 
 private:
 
-                        DECL_LINK( implTimeHdl, Slider*, void );
-                        DECL_LINK( implTimeEndHdl, Slider*, void );
-                        DECL_LINK( implVolumeHdl, Slider*, void );
-                        DECL_LINK( implSelectHdl, ToolBox*, void );
-                        DECL_LINK( implZoomSelectHdl, ListBox&, void );
-                        DECL_LINK(implTimeoutHdl, Timer *, void);
+                        DECL_LINK(implTimeHdl, weld::Scale&, void);
+                        DECL_LINK(implTimeEndHdl, Timer*, void);
+                        DECL_LINK(implVolumeHdl, weld::Scale&, void);
+                        DECL_LINK(implSelectHdl, const OString&, void);
+                        DECL_LINK(implZoomSelectHdl, weld::ComboBox&, void);
+                        DECL_LINK(implTimeoutHdl, Timer*, void);
+
+    std::unique_ptr<weld::Builder> m_xBuilder;
+    VclPtr<vcl::Window> m_xVclContentArea;
+    std::unique_ptr<weld::Container> m_xContainer;
 
     Idle                maIdle;
+    Idle                maChangeTimeIdle;
     MediaItem           maItem;
-    VclPtr<ToolBox>     mpZoomToolBox;
-    Size                maMinSize;
     bool                mbLocked;
     MediaControlStyle   meControlStyle;
     double mfTime;
diff --git a/avmedia/inc/strings.hrc b/avmedia/inc/strings.hrc
index cc1692a220b3..d9103dd545a1 100644
--- a/avmedia/inc/strings.hrc
+++ b/avmedia/inc/strings.hrc
@@ -44,7 +44,8 @@
 #define AVMEDIA_STR_ALL_MEDIAFILES  NC_("AVMEDIA_STR_ALL_MEDIAFILES", "All audio and video files")
 #define AVMEDIA_STR_ALL_FILES       NC_("AVMEDIA_STR_ALL_FILES", "All files")
 #define AVMEDIA_STR_ERR_URL         NC_("AVMEDIA_STR_ERR_URL", "The format of the selected file is not supported.")
+#define AVMEDIA_STR_ZOOM_TOOLTIP    NC_("AVMEDIA_STR_ZOOM_TOOLTIP", "View")
 
 #endif
 
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
\ No newline at end of file
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/avmedia/source/framework/MediaControlBase.cxx b/avmedia/source/framework/MediaControlBase.cxx
index f2e32cf7a182..c3df197f4f15 100644
--- a/avmedia/source/framework/MediaControlBase.cxx
+++ b/avmedia/source/framework/MediaControlBase.cxx
@@ -18,9 +18,6 @@
  */
 #include <avmedia/MediaControlBase.hxx>
 #include <avmedia/mediaplayer.hxx>
-#include <vcl/edit.hxx>
-#include <vcl/slider.hxx>
-#include <vcl/toolbox.hxx>
 #include <avmedia/mediaitem.hxx>
 #include <svtools/miscopt.hxx>
 #include <tools/time.hxx>
@@ -36,6 +33,7 @@ using ::rtl::OUString;
 namespace avmedia {
 
 MediaControlBase::MediaControlBase()
+    : mbCurrentlySettingZoom(false)
 {
 }
 
@@ -52,20 +50,20 @@ void MediaControlBase::UpdateTimeField( MediaItem const & aMediaItem, double fTi
             " / " +
             rLocaleData.getDuration( tools::Time( 0, 0, static_cast< sal_uInt32 >( floor( aMediaItem.getDuration() ) )) );
 
-        if( mpTimeEdit->GetText() != aTimeString )
-            mpTimeEdit->SetText( aTimeString );
+        if( mxTimeEdit->get_text() != aTimeString )
+            mxTimeEdit->set_text( aTimeString );
     }
 }
 
 void MediaControlBase::UpdateVolumeSlider( MediaItem const & aMediaItem )
 {
     if( aMediaItem.getURL().isEmpty() )
-        mpVolumeSlider->Disable();
+        mxVolumeSlider->set_sensitive(false);
     else
     {
-        mpVolumeSlider->Enable();
+        mxVolumeSlider->set_sensitive(true);
         const sal_Int32 nVolumeDB = aMediaItem.getVolumeDB();
-        mpVolumeSlider->SetThumbPos( std::min( std::max( nVolumeDB, static_cast< sal_Int32 >( AVMEDIA_DB_RANGE ) ),
+        mxVolumeSlider->set_value( std::min( std::max( nVolumeDB, static_cast< sal_Int32 >( AVMEDIA_DB_RANGE ) ),
                                                 static_cast< sal_Int32 >( 0 ) ) );
     }
 }
@@ -73,10 +71,10 @@ void MediaControlBase::UpdateVolumeSlider( MediaItem const & aMediaItem )
 void MediaControlBase::UpdateTimeSlider( MediaItem const & aMediaItem )
 {
     if( aMediaItem.getURL().isEmpty() )
-        mpTimeSlider->Disable();
+        mxTimeSlider->set_sensitive(false);
     else
     {
-        mpTimeSlider->Enable();
+        mxTimeSlider->set_sensitive(true);
 
         const double fDuration = aMediaItem.getDuration();
 
@@ -84,103 +82,101 @@ void MediaControlBase::UpdateTimeSlider( MediaItem const & aMediaItem )
         {
             const double fTime = std::min( aMediaItem.getTime(), fDuration );
 
-            if( !mpTimeSlider->GetLineSize() )
-                mpTimeSlider->SetLineSize( static_cast< sal_uInt32 >( AVMEDIA_TIME_RANGE * AVMEDIA_LINEINCREMENT / fDuration ) );
-
-            if( !mpTimeSlider->GetPageSize() )
-                mpTimeSlider->SetPageSize( static_cast< sal_uInt32 >( AVMEDIA_TIME_RANGE * AVMEDIA_PAGEINCREMENT / fDuration ) );
+            bool bChanged(false);
+            int nStep(0), nPage(0);
+            if (!nStep)
+            {
+                nStep = AVMEDIA_TIME_RANGE * AVMEDIA_LINEINCREMENT / fDuration;
+                bChanged = true;
+            }
+            if (!nPage)
+            {
+                nPage = AVMEDIA_TIME_RANGE * AVMEDIA_PAGEINCREMENT / fDuration;
+                bChanged = true;
+            }
+            if (bChanged)
+                mxTimeSlider->set_increments(nStep, nPage);
 
-            mpTimeSlider->SetThumbPos( static_cast< sal_Int32 >( fTime / fDuration * AVMEDIA_TIME_RANGE ) );
+            mxTimeSlider->set_value(fTime / fDuration * AVMEDIA_TIME_RANGE);
         }
     }
 }
 
 void MediaControlBase::InitializeWidgets()
 {
-    mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_PLAY, GetImage(AVMEDIA_TOOLBOXITEM_PLAY), AvmResId( AVMEDIA_STR_PLAY ), ToolBoxItemBits::CHECKABLE );
-    mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_PLAY, HID_AVMEDIA_TOOLBOXITEM_PLAY );
-
-    mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_PAUSE, GetImage(AVMEDIA_TOOLBOXITEM_PAUSE), AvmResId( AVMEDIA_STR_PAUSE ), ToolBoxItemBits::CHECKABLE );
-    mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_PAUSE, HID_AVMEDIA_TOOLBOXITEM_PAUSE );
-
-    mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_STOP, GetImage(AVMEDIA_TOOLBOXITEM_STOP), AvmResId( AVMEDIA_STR_STOP ), ToolBoxItemBits::CHECKABLE );
-    mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_STOP, HID_AVMEDIA_TOOLBOXITEM_STOP );
-
-    mpPlayToolBox->InsertSeparator();
-
-    mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_LOOP, GetImage(AVMEDIA_TOOLBOXITEM_LOOP), AvmResId( AVMEDIA_STR_LOOP ) );
-    mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_LOOP, HID_AVMEDIA_TOOLBOXITEM_LOOP );
-
-    mpMuteToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_MUTE, GetImage(AVMEDIA_TOOLBOXITEM_MUTE), AvmResId( AVMEDIA_STR_MUTE ) );
-    mpMuteToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_MUTE, HID_AVMEDIA_TOOLBOXITEM_MUTE );
-
-    mpZoomListBox->InsertEntry( AvmResId( AVMEDIA_STR_ZOOM_50 ), AVMEDIA_ZOOMLEVEL_50 );
-    mpZoomListBox->InsertEntry( AvmResId( AVMEDIA_STR_ZOOM_100 ), AVMEDIA_ZOOMLEVEL_100 );
-    mpZoomListBox->InsertEntry( AvmResId( AVMEDIA_STR_ZOOM_200 ), AVMEDIA_ZOOMLEVEL_200 );
-    mpZoomListBox->InsertEntry( AvmResId( AVMEDIA_STR_ZOOM_FIT ), AVMEDIA_ZOOMLEVEL_FIT );
-    mpZoomListBox->SetHelpId( HID_AVMEDIA_ZOOMLISTBOX );
+    mxPlayToolBox->set_item_help_id("play", HID_AVMEDIA_TOOLBOXITEM_PLAY);
+    mxPlayToolBox->set_item_label("play", AvmResId(AVMEDIA_STR_PLAY));
+    mxPlayToolBox->set_item_help_id("pause", HID_AVMEDIA_TOOLBOXITEM_PAUSE);
+    mxPlayToolBox->set_item_label("pause", AvmResId(AVMEDIA_STR_PAUSE));
+    mxPlayToolBox->set_item_help_id("stop", HID_AVMEDIA_TOOLBOXITEM_STOP);
+    mxPlayToolBox->set_item_label("stop", AvmResId(AVMEDIA_STR_STOP));
+    mxPlayToolBox->set_item_help_id("loop", HID_AVMEDIA_TOOLBOXITEM_LOOP);
+    mxPlayToolBox->set_item_label("loop", AvmResId(AVMEDIA_STR_LOOP));
+    mxMuteToolBox->set_item_help_id("mute", HID_AVMEDIA_TOOLBOXITEM_MUTE);
+    mxMuteToolBox->set_item_label("mute", AvmResId(AVMEDIA_STR_MUTE));
+
+    mxZoomListBox->append(OUString::number(AVMEDIA_ZOOMLEVEL_50), AvmResId( AVMEDIA_STR_ZOOM_50 ));
+    mxZoomListBox->append(OUString::number(AVMEDIA_ZOOMLEVEL_100), AvmResId( AVMEDIA_STR_ZOOM_100 ));
+    mxZoomListBox->append(OUString::number(AVMEDIA_ZOOMLEVEL_200), AvmResId( AVMEDIA_STR_ZOOM_200 ));
+    mxZoomListBox->append(OUString::number(AVMEDIA_ZOOMLEVEL_FIT),  AvmResId( AVMEDIA_STR_ZOOM_FIT ));
+    mxZoomListBox->set_help_id( HID_AVMEDIA_ZOOMLISTBOX );
+    mxZoomListBox->set_tooltip_text(AvmResId( AVMEDIA_STR_ZOOM_TOOLTIP ));
 
     const OUString aTimeText( " 00:00:00/00:00:00 " );
-    mpTimeEdit->SetText( aTimeText );
-    mpTimeEdit->SetUpdateMode( true );
-    mpTimeEdit->SetHelpId( HID_AVMEDIA_TIMEEDIT );
-    mpTimeEdit->Disable();
-    mpTimeEdit->Show();
+    mxTimeEdit->set_text( aTimeText );
+    mxTimeEdit->set_help_id( HID_AVMEDIA_TIMEEDIT );
+    mxTimeEdit->set_sensitive(false);
 
-    mpVolumeSlider->SetRange( Range( AVMEDIA_DB_RANGE, 0 ) );
-    mpVolumeSlider->SetUpdateMode( true );
-    mpVolumeSlider->SetQuickHelpText( AvmResId( AVMEDIA_STR_VOLUME ));
-    mpVolumeSlider->SetHelpId( HID_AVMEDIA_VOLUMESLIDER );
+    mxVolumeSlider->set_range(AVMEDIA_DB_RANGE, 0);
+    mxVolumeSlider->set_tooltip_text( AvmResId( AVMEDIA_STR_VOLUME ));
+    mxVolumeSlider->set_help_id( HID_AVMEDIA_VOLUMESLIDER );
 
-    mpTimeSlider->SetRange( Range( 0, AVMEDIA_TIME_RANGE ) );
-    mpTimeSlider->SetUpdateMode( true );
-    mpTimeSlider->SetQuickHelpText( AvmResId( AVMEDIA_STR_POSITION ));
-    mpTimeSlider->SetStyle(WB_HORZ | WB_DRAG | WB_3DLOOK);
-    mpTimeSlider->SetScrollTypeSet(true);
+    mxTimeSlider->set_range( 0, AVMEDIA_TIME_RANGE );
+    mxTimeSlider->set_tooltip_text( AvmResId( AVMEDIA_STR_POSITION ));
 }
 
-void MediaControlBase::UpdateToolBoxes(MediaItem aMediaItem)
+void MediaControlBase::UpdateToolBoxes(const MediaItem& rMediaItem)
 {
-    const bool bValidURL = !aMediaItem.getURL().isEmpty();
-    mpPlayToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_PLAY, bValidURL );
-    mpPlayToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_PAUSE, bValidURL );
-    mpPlayToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_STOP, bValidURL );
-    mpPlayToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_LOOP, bValidURL );
-    mpMuteToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_MUTE, bValidURL );
+    const bool bValidURL = !rMediaItem.getURL().isEmpty();
+    mxPlayToolBox->set_item_sensitive("play", bValidURL);
+    mxPlayToolBox->set_item_sensitive("pause", bValidURL);
+    mxPlayToolBox->set_item_sensitive("stop", bValidURL);
+    mxPlayToolBox->set_item_sensitive("loop", bValidURL);
+    mxMuteToolBox->set_item_sensitive("mute", bValidURL);
     if( !bValidURL )
     {
-        mpZoomListBox->Disable();
-        mpMuteToolBox->Disable();
+        mxZoomListBox->set_sensitive(false);
+        mxMuteToolBox->set_sensitive(false);
     }
     else
     {
-        mpPlayToolBox->Enable();
-        mpMuteToolBox->Enable();
-        if( aMediaItem.getState() == MediaState::Play )
+        mxPlayToolBox->set_sensitive(true);
+        mxMuteToolBox->set_sensitive(true);
+        if( rMediaItem.getState() == MediaState::Play )
         {
-            mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PLAY );
-            mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PAUSE, false );
-            mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_STOP, false );
+            mxPlayToolBox->set_item_active("play", true);
+            mxPlayToolBox->set_item_active("pause", false);
+            mxPlayToolBox->set_item_active("stop", false);
         }
-        else if( aMediaItem.getState() == MediaState::Pause )
+        else if( rMediaItem.getState() == MediaState::Pause )
         {
-            mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PLAY, false );
-            mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PAUSE );
-            mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_STOP, false );
+            mxPlayToolBox->set_item_active("play", false);
+            mxPlayToolBox->set_item_active("pause", true);
+            mxPlayToolBox->set_item_active("stop", false);
         }
         else
         {
-            mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PLAY, false );
-            mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PAUSE, false );
-            mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_STOP );
+            mxPlayToolBox->set_item_active("play", false);
+            mxPlayToolBox->set_item_active("pause", false);
+            mxPlayToolBox->set_item_active("stop", true);
         }
-        mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_LOOP, aMediaItem.isLoop() );
-        mpMuteToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_MUTE, aMediaItem.isMute() );
-        if( !mpZoomListBox->IsTravelSelect() && !mpZoomListBox->IsInDropDown() )
+        mxPlayToolBox->set_item_active("loop", rMediaItem.isLoop());
+        mxMuteToolBox->set_item_active("mute", rMediaItem.isMute());
+        if (!mbCurrentlySettingZoom)
         {
             sal_uInt16 nSelectEntryPos ;
 
-            switch( aMediaItem.getZoom() )
+            switch( rMediaItem.getZoom() )
             {
                 case css::media::ZoomLevel_ZOOM_1_TO_2:
                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_50;
@@ -205,134 +201,61 @@ void MediaControlBase::UpdateToolBoxes(MediaItem aMediaItem)
 
             if( nSelectEntryPos != AVMEDIA_ZOOMLEVEL_INVALID )
             {
-                mpZoomListBox->Enable();
-                mpZoomListBox->SelectEntryPos( nSelectEntryPos );
+                mxZoomListBox->show();
+                mxZoomListBox->set_sensitive(true);
+                mxZoomListBox->set_active(nSelectEntryPos);
             }
             else
-                mpZoomListBox->Disable();
+                mxZoomListBox->set_sensitive(false);
         }
     }
 }
 
-void MediaControlBase::SelectPlayToolBoxItem( MediaItem& aExecItem, MediaItem const & aItem, sal_uInt16 nId)
+void MediaControlBase::SelectPlayToolBoxItem( MediaItem& aExecItem, MediaItem const & aItem, const OString& rId)
 {
-    switch( nId )
+    if (rId == "apply")
     {
-        case AVMEDIA_TOOLBOXITEM_INSERT:
-        {
-            MediaFloater* pFloater = avmedia::getMediaFloater();
+        MediaFloater* pFloater = avmedia::getMediaFloater();
 
-            if( pFloater )
-                pFloater->dispatchCurrentURL();
-        }
-        break;
-
-        case AVMEDIA_TOOLBOXITEM_PLAY:
-        {
-            aExecItem.setState( MediaState::Play );
-
-            if( aItem.getTime() == aItem.getDuration() )
-                aExecItem.setTime( 0.0 );
-            else
-                aExecItem.setTime( aItem.getTime() );
-        }
-        break;
-
-        case AVMEDIA_TOOLBOXITEM_PAUSE:
-        {
-            aExecItem.setState( MediaState::Pause );
-        }
-        break;
+        if( pFloater )
+            pFloater->dispatchCurrentURL();
+    }
+    else if (rId == "play")
+    {
+        aExecItem.setState( MediaState::Play );
 
-        case AVMEDIA_TOOLBOXITEM_STOP:
-        {
-            aExecItem.setState( MediaState::Stop );
+        if( aItem.getTime() == aItem.getDuration() )
             aExecItem.setTime( 0.0 );
-        }
-        break;
-
-        case AVMEDIA_TOOLBOXITEM_MUTE:
-        {
-            aExecItem.setMute( !mpMuteToolBox->IsItemChecked( AVMEDIA_TOOLBOXITEM_MUTE ) );
-        }
-        break;
-
-        case AVMEDIA_TOOLBOXITEM_LOOP:
-        {
-            aExecItem.setLoop( !mpPlayToolBox->IsItemChecked( AVMEDIA_TOOLBOXITEM_LOOP ) );
-        }
-        break;
-
-        default:
-        break;
+        else
+            aExecItem.setTime( aItem.getTime() );
     }
-}
-
-Image MediaControlBase::GetImage(sal_Int32 nImageId)
-{
-    const bool bLarge = SvtMiscOptions().AreCurrentSymbolsLarge();
-
-    OUString sImageId;
-
-    if (bLarge)
+    else if (rId == "pause")
     {
-        switch (nImageId)
-        {
-            default:
-            case AVMEDIA_TOOLBOXITEM_PLAY:
-                sImageId = AVMEDIA_IMG_PLAY_LARGE;
-                break;
-            case AVMEDIA_TOOLBOXITEM_PAUSE:
-                sImageId = AVMEDIA_IMG_PAUSE_LARGE;
-                break;
-            case AVMEDIA_TOOLBOXITEM_STOP:
-                sImageId = AVMEDIA_IMG_STOP_LARGE;
-                break;
-            case AVMEDIA_TOOLBOXITEM_MUTE:
-                sImageId = AVMEDIA_IMG_MUTE_LARGE;
-                break;
-            case AVMEDIA_TOOLBOXITEM_LOOP:
-                sImageId = AVMEDIA_IMG_LOOP_LARGE;
-                break;
-            case AVMEDIA_TOOLBOXITEM_OPEN:
-                sImageId = AVMEDIA_IMG_OPEN_LARGE;
-                break;
-            case AVMEDIA_TOOLBOXITEM_INSERT:
-                sImageId = AVMEDIA_IMG_INSERT_LARGE;
-                break;
-
-        }
+        aExecItem.setState( MediaState::Pause );
     }
-    else
+    else if (rId == "stop")
     {
-        switch (nImageId)
-        {
-            default:
-            case AVMEDIA_TOOLBOXITEM_PLAY:
-                sImageId = AVMEDIA_IMG_PLAY_NORMAL;
-                break;
-            case AVMEDIA_TOOLBOXITEM_PAUSE:
-                sImageId = AVMEDIA_IMG_PAUSE_NORMAL;
-                break;
-            case AVMEDIA_TOOLBOXITEM_STOP:
-                sImageId = AVMEDIA_IMG_STOP_NORMAL;
-                break;
-            case AVMEDIA_TOOLBOXITEM_MUTE:
-                sImageId = AVMEDIA_IMG_MUTE_NORMAL;
-                break;
-            case AVMEDIA_TOOLBOXITEM_LOOP:
-                sImageId = AVMEDIA_IMG_LOOP_NORMAL;
-                break;
-            case AVMEDIA_TOOLBOXITEM_OPEN:
-                sImageId = AVMEDIA_IMG_OPEN_NORMAL;
-                break;
-            case AVMEDIA_TOOLBOXITEM_INSERT:
-                sImageId = AVMEDIA_IMG_INSERT_NORMAL;
-                break;
-        }
+        aExecItem.setState( MediaState::Stop );
+        aExecItem.setTime( 0.0 );
     }
+    else if (rId == "mute")
+    {
+        aExecItem.setMute( mxMuteToolBox->get_item_active("mute") );
+    }
+    else if (rId == "loop")
+    {
+        aExecItem.setLoop( mxPlayToolBox->get_item_active("loop") );
+    }
+}
 
-    return Image(StockImage::Yes, sImageId);
+void MediaControlBase::disposeWidgets()
+{
+    mxZoomListBox.reset();
+    mxTimeEdit.reset();
+    mxVolumeSlider.reset();
+    mxMuteToolBox.reset();
+    mxTimeSlider.reset();
+    mxPlayToolBox.reset();
 }
 
 }
diff --git a/avmedia/source/framework/mediacontrol.cxx b/avmedia/source/framework/mediacontrol.cxx
index 43f04ce40b3e..fc83dd1baa79 100644
--- a/avmedia/source/framework/mediacontrol.cxx
+++ b/avmedia/source/framework/mediacontrol.cxx
@@ -24,7 +24,12 @@
 #include <helpids.h>
 #include <vcl/svapp.hxx>
 #include <vcl/settings.hxx>
-#include <vcl/lstbox.hxx>
+#include <vcl/layout.hxx>
+#include <vcl/weld.hxx>
+#include <unotools/syslocale.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <math.h>
+#include <algorithm>
 #include <avmedia/MediaControlBase.hxx>
 
 namespace avmedia
@@ -34,21 +39,31 @@ MediaControl::MediaControl( vcl::Window* pParent, MediaControlStyle eControlStyl
     Control( pParent ),
     MediaControlBase(),
     maIdle( "avmedia MediaControl Idle" ),
+    maChangeTimeIdle( "avmedia MediaControl Change Time Idle" ),
     maItem( 0, AVMediaSetMask::ALL ),
     mbLocked( false ),
     meControlStyle( eControlStyle ),
     mfTime(0.0)
 {
-    mpPlayToolBox =  VclPtr<ToolBox>::Create(this, WB_3DLOOK) ;
-    mpTimeSlider = VclPtr<Slider>::Create(this, WB_HORZ | WB_DRAG | WB_3DLOOK) ;
-    mpTimeSlider->SetScrollTypeSet(true);
-    mpMuteToolBox = VclPtr<ToolBox>::Create(this, WB_3DLOOK) ;
-    mpVolumeSlider = VclPtr<Slider>::Create(this, WB_HORZ | WB_DRAG) ;
-    mpVolumeSlider->SetScrollTypeSet(true);
-    mpZoomToolBox = VclPtr<ToolBox>::Create(this, WB_3DLOOK) ;
-    mpZoomListBox = VclPtr<ListBox>::Create( mpZoomToolBox.get(), WB_BORDER | WB_DROPDOWN | WB_AUTOHSCROLL | WB_3DLOOK ) ;
-    mpTimeEdit = VclPtr<Edit>::Create(this, WB_CENTER | WB_READONLY | WB_BORDER | WB_3DLOOK ) ;
-    mpMediaPath = VclPtr<FixedText>::Create(this, WB_VCENTER | WB_READONLY | WB_BORDER | WB_3DLOOK ) ;
+    SetStyle(GetStyle() | WB_DIALOGCONTROL);
+
+    m_xVclContentArea = VclPtr<VclVBox>::Create(this);
+    m_xVclContentArea->Show();
+    // MEDIACONTROLSTYLE_MULTILINE is the normal docking windows of tools->media player
+    // MEDIACONTROLSTYLE_SINGLELINE is the toolbar of view->toolbar->media playback
+    m_xBuilder.reset(Application::CreateInterimBuilder(m_xVclContentArea,
+                eControlStyle == MEDIACONTROLSTYLE_MULTILINE ?
+                    OUString("svx/ui/mediawindow.ui") :
+                    OUString("svx/ui/medialine.ui")));
+    m_xContainer = m_xBuilder->weld_container("MediaWindow");
+
+    mxPlayToolBox = m_xBuilder->weld_toolbar("playtoolbox");
+    mxTimeSlider = m_xBuilder->weld_scale("timeslider");
+    mxMuteToolBox = m_xBuilder->weld_toolbar("mutetoolbox");
+    mxVolumeSlider = m_xBuilder->weld_scale("volumeslider");
+    mxZoomListBox = m_xBuilder->weld_combo_box("zoombox");
+    mxTimeEdit = m_xBuilder->weld_entry("timeedit");
+    mxMediaPath = m_xBuilder->weld_label("url");
 
     SetBackground();
     SetPaintTransparent( true );
@@ -56,59 +71,31 @@ MediaControl::MediaControl( vcl::Window* pParent, MediaControlStyle eControlStyl
 
     InitializeWidgets();
 
-    mpPlayToolBox->SetSelectHdl( LINK( this, MediaControl, implSelectHdl ) );
-    mpPlayToolBox->SetSizePixel( mpPlayToolBox->CalcWindowSizePixel() );
-    mpPlayToolBox->Show();
-    maMinSize = mpPlayToolBox->GetSizePixel();
+    mxPlayToolBox->connect_clicked( LINK( this, MediaControl, implSelectHdl ) );
 
-    mpTimeSlider->SetSlideHdl( LINK( this, MediaControl, implTimeHdl ) );
-    mpTimeSlider->SetEndSlideHdl( LINK( this, MediaControl, implTimeEndHdl ) );
-    mpTimeSlider->SetSizePixel( Size( 128, mpPlayToolBox->GetSizePixel().Height() ) );
-    mpTimeSlider->Show();
-    maMinSize.AdjustWidth(mpTimeSlider->GetSizePixel().Width() );
+    mxTimeSlider->connect_value_changed( LINK( this, MediaControl, implTimeHdl ) );
+    // when changint the time, use this to do the time change after active scrolling
+    // has stopped for a little which
+    maChangeTimeIdle.SetPriority( TaskPriority::LOWEST );
+    maChangeTimeIdle.SetInvokeHandler( LINK( this, MediaControl, implTimeEndHdl ) );
 
     const OUString aTimeText( " 00:00:00/00:00:00 " );
-    mpTimeEdit->SetSizePixel( Size( mpTimeEdit->GetTextWidth( aTimeText ) + 8, mpPlayToolBox->GetSizePixel().Height() ) );
-    mpTimeEdit->SetControlBackground( Application::GetSettings().GetStyleSettings().GetWindowColor() );
-    maMinSize.AdjustWidth(mpTimeEdit->GetSizePixel().Width() );
+    mxTimeEdit->set_text(aTimeText);
+    Size aTextSize = mxTimeEdit->get_preferred_size();
+    mxTimeEdit->set_size_request(aTextSize.Width(), aTextSize.Height());
+    mxTimeEdit->set_text(OUString());
 
-    mpMuteToolBox->SetSelectHdl( LINK( this, MediaControl, implSelectHdl ) );
-    mpMuteToolBox->SetSizePixel( mpMuteToolBox->CalcWindowSizePixel() );
-    mpMuteToolBox->Show();
-    maMinSize.AdjustWidth(mpMuteToolBox->GetSizePixel().Width() );
+    mxMuteToolBox->connect_clicked( LINK( this, MediaControl, implSelectHdl ) );
+    mxVolumeSlider->connect_value_changed( LINK( this, MediaControl, implVolumeHdl ) );
 
-    mpVolumeSlider->SetSlideHdl( LINK( this, MediaControl, implVolumeHdl ) );
-    mpVolumeSlider->SetSizePixel( Size( 48, mpPlayToolBox->GetSizePixel().Height() ) );
-    mpVolumeSlider->Show();
-    maMinSize.AdjustWidth(mpVolumeSlider->GetSizePixel().Width() );
-
-    mpZoomListBox->SetSizePixel( Size( mpTimeEdit->GetSizePixel().Width(), 260 ) );
-    mpZoomListBox->SetSelectHdl( LINK( this, MediaControl, implZoomSelectHdl ) );
-
-    mpZoomToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_ZOOM, AvmResId( AVMEDIA_STR_ZOOM ) );
-    mpZoomToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_ZOOM, HID_AVMEDIA_ZOOMLISTBOX );
-
-    mpZoomToolBox->SetItemWindow( AVMEDIA_TOOLBOXITEM_ZOOM, mpZoomListBox );
-    mpZoomToolBox->SetSelectHdl( LINK( this, MediaControl, implSelectHdl ) );
-    mpZoomToolBox->SetSizePixel( mpZoomToolBox->CalcWindowSizePixel() );
-    mpZoomToolBox->Show();
-    maMinSize.AdjustWidth(mpZoomToolBox->GetSizePixel().Width() );
+    mxZoomListBox->connect_changed( LINK( this, MediaControl, implZoomSelectHdl ) );
+    mxZoomListBox->set_help_id(HID_AVMEDIA_ZOOMLISTBOX);
 
     const OUString aMediaPath( AvmResId( AVMEDIA_MEDIA_PATH_DEFAULT ) );
-    mpMediaPath->SetText(aMediaPath);
-    mpMediaPath->SetUpdateMode( false );
-    mpMediaPath->SetSizePixel( Size( mpMediaPath->GetTextWidth( aMediaPath ) + 400, mpPlayToolBox->GetSizePixel().Height() ) ); // maybe extend the no. 400 to span the screen width
-    mpMediaPath->SetControlBackground( Application::GetSettings().GetStyleSettings().GetWindowColor() );
-    mpMediaPath->Show();
-    maMinSize.AdjustWidth(mpMediaPath->GetSizePixel().Width() );
-
-    if( meControlStyle == MEDIACONTROLSTYLE_MULTILINE )
-    {
-        maMinSize.setWidth( 256 );
-        maMinSize.setHeight( ( maMinSize.Height() << 1 ) + AVMEDIA_CONTROLOFFSET );
-        mpZoomToolBox->SetBackground();
-        mpZoomToolBox->SetPaintTransparent( true );
-    }
+    mxMediaPath->set_label(aMediaPath);
+    if (meControlStyle == MEDIACONTROLSTYLE_SINGLELINE)
+        mxMediaPath->set_size_request(mxMediaPath->get_preferred_size().Width() + 400, -1); // maybe extend the no. 400 to span the screen width
+
     // we want time field + progress slider to update as the media plays
     // give this task a lower prio than REPAINT so that UI updates are not starved
     maIdle.SetPriority( TaskPriority::POST_PAINT );
@@ -119,25 +106,12 @@ void MediaControl::InitializeWidgets()
 {
     if( meControlStyle != MEDIACONTROLSTYLE_SINGLELINE )
     {
-        mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_OPEN, GetImage(AVMEDIA_TOOLBOXITEM_OPEN), AvmResId( AVMEDIA_STR_OPEN ) );
-        mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_OPEN, HID_AVMEDIA_TOOLBOXITEM_OPEN );
-        mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_INSERT, GetImage(AVMEDIA_TOOLBOXITEM_INSERT), AvmResId( AVMEDIA_STR_INSERT ) );
-        mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_INSERT, HID_AVMEDIA_TOOLBOXITEM_INSERT );
-        mpPlayToolBox->InsertSeparator();
-    }
-    else
-    {
-        mpZoomListBox->SetBackground();
-        mpPlayToolBox->SetBackground();
-        mpPlayToolBox->SetPaintTransparent( true );
-        mpMuteToolBox->SetBackground();
-        mpMuteToolBox->SetPaintTransparent( true );
-        mpMuteToolBox->InsertSeparator();
+        mxPlayToolBox->set_item_help_id("open", HID_AVMEDIA_TOOLBOXITEM_OPEN);
+        mxPlayToolBox->set_item_label("open", AvmResId(AVMEDIA_STR_OPEN));
+        mxPlayToolBox->set_item_help_id("apply", HID_AVMEDIA_TOOLBOXITEM_INSERT);
+        mxPlayToolBox->set_item_label("apply", AvmResId(AVMEDIA_STR_INSERT));
     }
     avmedia::MediaControlBase::InitializeWidgets();
-
-    if( meControlStyle == MEDIACONTROLSTYLE_SINGLELINE )
-        mpPlayToolBox->InsertSeparator();
 }
 
 MediaControl::~MediaControl()
@@ -147,95 +121,32 @@ MediaControl::~MediaControl()
 
 void MediaControl::dispose()
 {
-    mpZoomToolBox->SetItemWindow( AVMEDIA_TOOLBOXITEM_ZOOM, nullptr );
-    mpZoomListBox.disposeAndClear();
-    mpTimeEdit.disposeAndClear();
-    mpMediaPath.disposeAndClear();
-    mpZoomToolBox.disposeAndClear();
-    mpVolumeSlider.disposeAndClear();
-    mpMuteToolBox.disposeAndClear();
-    mpTimeSlider.disposeAndClear();
-    mpPlayToolBox.disposeAndClear();
+    disposeWidgets();
+    mxMediaPath.reset();
+    m_xContainer.reset();
+    m_xBuilder.reset();
+    m_xVclContentArea.disposeAndClear();
     Control::dispose();
 }
 
-const Size& MediaControl::getMinSizePixel() const
+Size MediaControl::getMinSizePixel() const
 {
-    return maMinSize;
+    return VclContainer::getLayoutRequisition(*GetWindow(GetWindowType::FirstChild));
 }
 
 void MediaControl::UpdateURLField(MediaItem const & tempItem)
 {
     const OUString aURL( AvmResId(AVMEDIA_MEDIA_PATH) + ":  " + tempItem.getURL() ) ;
-    mpMediaPath->SetText(aURL);
-    mpMediaPath->SetUpdateMode( false );
-    mpMediaPath->SetSizePixel( Size( mpMediaPath->GetTextWidth( aURL ) + 8, mpPlayToolBox->GetSizePixel().Height() ) );
-    mpMediaPath->SetControlBackground( Application::GetSettings().GetStyleSettings().GetWindowColor() );
-    mpMediaPath->Show();
-    maMinSize.AdjustWidth(mpMediaPath->GetSizePixel().Width() );
+    mxMediaPath->set_label(aURL);
 }
 
 void MediaControl::Resize()
 {
-    Point           aPos( 0, 0 );
-    const sal_Int32 nPlayToolBoxWidth = mpPlayToolBox->GetSizePixel().Width();
-    const sal_Int32 nMuteToolBoxWidth = mpMuteToolBox->GetSizePixel().Width();
-    const sal_Int32 nVolumeSliderWidth = mpVolumeSlider->GetSizePixel().Width();
-    const sal_Int32 nZoomToolBoxWidth = mpZoomToolBox->GetSizePixel().Width();
-    const sal_Int32 nTimeEditWidth = mpTimeEdit->GetSizePixel().Width();
-    const sal_Int32 nMediaPathWidth = mpMediaPath->GetSizePixel().Width();
-    const sal_Int32 nTimeSliderHeight = mpTimeSlider->GetSizePixel().Height();
-
-    if( meControlStyle == MEDIACONTROLSTYLE_SINGLELINE )
-    {
-        const sal_Int32 nTimeSliderWidth = GetSizePixel().Width() - ( AVMEDIA_CONTROLOFFSET * 4 ) -
-                                           nPlayToolBoxWidth - nMuteToolBoxWidth - nVolumeSliderWidth - nTimeEditWidth - nZoomToolBoxWidth - nMediaPathWidth;
-
-        mpPlayToolBox->SetPosSizePixel( aPos, mpPlayToolBox->GetSizePixel() );
-
-        aPos.AdjustX(nPlayToolBoxWidth );
-        mpTimeSlider->SetPosSizePixel( aPos, Size( nTimeSliderWidth, nTimeSliderHeight ) );
-
-        aPos.AdjustX(nTimeSliderWidth + AVMEDIA_CONTROLOFFSET );
-        mpTimeEdit->SetPosSizePixel( aPos, mpTimeEdit->GetSizePixel() );
-
-        aPos.AdjustX(nTimeEditWidth + AVMEDIA_CONTROLOFFSET );
-        mpMuteToolBox->SetPosSizePixel( aPos, mpMuteToolBox->GetSizePixel() );
-
-        aPos.AdjustX(nMuteToolBoxWidth );
-        mpVolumeSlider->SetPosSizePixel( aPos, mpVolumeSlider->GetSizePixel() );
-
-        aPos.AdjustX(nVolumeSliderWidth + AVMEDIA_CONTROLOFFSET );
-        mpZoomToolBox->SetPosSizePixel( aPos, mpZoomToolBox->GetSizePixel() );
-
-        aPos.AdjustX(nZoomToolBoxWidth + AVMEDIA_CONTROLOFFSET );
-        mpMediaPath->SetPosSizePixel( aPos, mpMediaPath->GetSizePixel() );
-    }
-    else
-    {
-        const sal_Int32 nTimeSliderWidth = GetSizePixel().Width() - AVMEDIA_CONTROLOFFSET - nTimeEditWidth;
-
-        mpTimeSlider->SetPosSizePixel( aPos, Size( nTimeSliderWidth, nTimeSliderHeight ) );
-
-        aPos.AdjustX(nTimeSliderWidth + AVMEDIA_CONTROLOFFSET );
-        mpTimeEdit->SetPosSizePixel( aPos, mpTimeEdit->GetSizePixel() );
-
-        aPos.setX( 0 );
-        aPos.AdjustY(nTimeSliderHeight + AVMEDIA_CONTROLOFFSET );
-        mpPlayToolBox->SetPosSizePixel( aPos, mpPlayToolBox->GetSizePixel() );
-
-        aPos.setX( GetSizePixel().Width() - nVolumeSliderWidth - nMuteToolBoxWidth - nZoomToolBoxWidth - AVMEDIA_CONTROLOFFSET );
-        mpMuteToolBox->SetPosSizePixel( aPos, mpMuteToolBox->GetSizePixel() );
-
-        aPos.AdjustX(nMuteToolBoxWidth );
-        mpVolumeSlider->SetPosSizePixel( aPos, mpVolumeSlider->GetSizePixel() );
-
-        aPos.setX( GetSizePixel().Width() - nZoomToolBoxWidth );
-        mpZoomToolBox->SetPosSizePixel( aPos, mpZoomToolBox->GetSizePixel() );
-    }
+    vcl::Window *pChild = GetWindow(GetWindowType::FirstChild);
+    assert(pChild);
+    VclContainer::setLayoutAllocation(*pChild, Point(0, 0), GetSizePixel());
 }
 
-
 void MediaControl::setState( const MediaItem& rItem )
 {
     double fTime = rItem.getTime();
@@ -244,7 +155,7 @@ void MediaControl::setState( const MediaItem& rItem )
         mfTime = fTime;
         maItem.merge( rItem );
         if( rItem.getURL().isEmpty() && meControlStyle == MEDIACONTROLSTYLE_SINGLELINE )
-            mpPlayToolBox->Disable();
+            mxPlayToolBox->set_sensitive(false);
         UpdateToolBoxes( maItem );
         UpdateTimeSlider( maItem );
         UpdateVolumeSlider( maItem );
@@ -253,19 +164,19 @@ void MediaControl::setState( const MediaItem& rItem )
     }
 }
 
-IMPL_LINK( MediaControl, implTimeHdl, Slider*, p, void )
+IMPL_LINK( MediaControl, implTimeHdl, weld::Scale&, rSlider, void )
 {
     mbLocked = true;
     maIdle.Stop();
-    UpdateTimeField( maItem, p->GetThumbPos() * maItem.getDuration() / AVMEDIA_TIME_RANGE );
+    UpdateTimeField(maItem, rSlider.get_value() * maItem.getDuration() / AVMEDIA_TIME_RANGE);
+    maChangeTimeIdle.Start();
 }
 
-
-IMPL_LINK( MediaControl, implTimeEndHdl, Slider*, p, void )
+IMPL_LINK_NOARG(MediaControl, implTimeEndHdl, Timer*, void)
 {
     MediaItem aExecItem;
 
-    aExecItem.setTime( p->GetThumbPos() * maItem.getDuration() / AVMEDIA_TIME_RANGE );
+    aExecItem.setTime( mxTimeSlider->get_value() * maItem.getDuration() / AVMEDIA_TIME_RANGE );
     // keep state (if the media was playing, keep it playing)
     aExecItem.setState(maItem.getState());
     execute( aExecItem );
@@ -274,63 +185,56 @@ IMPL_LINK( MediaControl, implTimeEndHdl, Slider*, p, void )
     mbLocked = false;
 }
 
-
-IMPL_LINK( MediaControl, implVolumeHdl, Slider*, p, void )
+IMPL_LINK( MediaControl, implVolumeHdl, weld::Scale&, rSlider, void )
 {
     MediaItem aExecItem;
 
-    aExecItem.setVolumeDB( static_cast< sal_Int16 >( p->GetThumbPos() ) );
+    aExecItem.setVolumeDB(rSlider.get_value());
     execute( aExecItem );
     update();
 }
 
-
-IMPL_LINK( MediaControl, implSelectHdl, ToolBox*, p, void )
+IMPL_LINK( MediaControl, implSelectHdl, const OString&, rIdent, void )
 {
-    if( p )
+    MediaItem aExecItem;
+    if (rIdent == "open")
     {
-        MediaItem aExecItem;
-        if( p->GetCurItemId() == AVMEDIA_TOOLBOXITEM_OPEN )
+        OUString aURL;
+        if (MediaWindow::executeMediaURLDialog(GetFrameWeld(), aURL, nullptr))
         {
-            OUString aURL;
-            if (MediaWindow::executeMediaURLDialog(GetFrameWeld(), aURL, nullptr))
+            if( !MediaWindow::isMediaURL( aURL, ""/*TODO?*/, true ) )
+                MediaWindow::executeFormatErrorBox(GetFrameWeld());
+            else
             {
-                if( !MediaWindow::isMediaURL( aURL, ""/*TODO?*/, true ) )
-                    MediaWindow::executeFormatErrorBox(GetFrameWeld());
-                else
-                {
-                    aExecItem.setURL( aURL, "", ""/*TODO?*/ );
-                    aExecItem.setState( MediaState::Play );
-                }
+                aExecItem.setURL( aURL, "", ""/*TODO?*/ );
+                aExecItem.setState( MediaState::Play );
             }
         }
-        else
-            SelectPlayToolBoxItem( aExecItem, maItem, p->GetCurItemId() );
+    }
+    else
+        SelectPlayToolBoxItem( aExecItem, maItem, rIdent );
 
-        if (aExecItem.getState() == MediaState::Play)
-            maIdle.Start();
-        else if (aExecItem.getState() == MediaState::Pause ||
-                 aExecItem.getState() == MediaState::Stop)
-            maIdle.Stop();
+    if (aExecItem.getState() == MediaState::Play)
+        maIdle.Start();
+    else if (aExecItem.getState() == MediaState::Pause ||
+             aExecItem.getState() == MediaState::Stop)
+        maIdle.Stop();
 
-        if( aExecItem.getMaskSet() != AVMediaSetMask::NONE )
-            execute( aExecItem );
-    }
+    if( aExecItem.getMaskSet() != AVMediaSetMask::NONE )
+        execute( aExecItem );
 
     update();
-    if(p)
-    {
-        p->Invalidate( InvalidateFlags::Update );
-    }
 }
 
-
-IMPL_LINK( MediaControl, implZoomSelectHdl, ListBox&, p, void )
+IMPL_LINK( MediaControl, implZoomSelectHdl, weld::ComboBox&, rBox, void )
 {
+    bool bCurrentlySettingZoom = mbCurrentlySettingZoom;
+    mbCurrentlySettingZoom = true;
+
     MediaItem aExecItem;
     css::media::ZoomLevel eLevel;
 
-    switch( p.GetSelectedEntryPos() )
+    switch (rBox.get_active())
     {
         case AVMEDIA_ZOOMLEVEL_50: eLevel = css::media::ZoomLevel_ZOOM_1_TO_2; break;
         case AVMEDIA_ZOOMLEVEL_100: eLevel = css::media::ZoomLevel_ORIGINAL; break;
@@ -344,8 +248,9 @@ IMPL_LINK( MediaControl, implZoomSelectHdl, ListBox&, p, void )
     aExecItem.setZoom( eLevel );
     execute( aExecItem );
     update();
-}
 
+    mbCurrentlySettingZoom = bCurrentlySettingZoom;
+}
 
 IMPL_LINK_NOARG(MediaControl, implTimeoutHdl, Timer *, void)
 {
diff --git a/avmedia/source/framework/mediatoolbox.cxx b/avmedia/source/framework/mediatoolbox.cxx
index 69aeb220295c..b085d8a77f39 100644
--- a/avmedia/source/framework/mediatoolbox.cxx
+++ b/avmedia/source/framework/mediatoolbox.cxx
@@ -23,6 +23,7 @@
 
 #include <tools/debug.hxx>
 #include <sfx2/sfxsids.hrc>
+#include <vcl/toolbox.hxx>
 
 #include <comphelper/propertysequence.hxx>
 
diff --git a/avmedia/source/viewer/mediawindow_impl.cxx b/avmedia/source/viewer/mediawindow_impl.cxx
index e34b7fb0d6a0..fdc78575f8b7 100644
--- a/avmedia/source/viewer/mediawindow_impl.cxx
+++ b/avmedia/source/viewer/mediawindow_impl.cxx
@@ -31,6 +31,8 @@
 #include <tools/diagnose_ex.h>
 #include <tools/urlobj.hxx>
 #include <unotools/securityoptions.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/svapp.hxx>
 #include <vcl/commandevent.hxx>
 #include <vcl/event.hxx>
 #include <vcl/ptrstyle.hxx>