avmedia/source/framework/MediaControlBase.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #include <avmedia/MediaControlBase.hxx>
  20 #include <avmedia/mediaplayer.hxx>
  21 #include <avmedia/mediaitem.hxx>
  22 #include <tools/time.hxx>
  23 #include <unotools/localedatawrapper.hxx>
  24 #include <strings.hrc>
  25 #include <helpids.h>
  26 #include <mediamisc.hxx>
  27
  28 constexpr sal_Int32 AVMEDIA_DB_RANGE = -40;
  29 constexpr double AVMEDIA_LINEINCREMENT = 1.0;
  30 constexpr double AVMEDIA_PAGEINCREMENT = 10.0;
  31
  32 namespace avmedia {
  33
  34 MediaControlBase::MediaControlBase()
  35     : mbCurrentlySettingZoom(false)
  36 {
  37 }
  38
  39 void MediaControlBase::UpdateTimeField( MediaItem const & aMediaItem, double fTime )
  40 {
  41     if( aMediaItem.getURL().isEmpty())
  42         return;
  43
  44     OUString aTimeString;
  45
  46     SvtSysLocale aSysLocale;
  47     const LocaleDataWrapper& rLocaleData = aSysLocale.GetLocaleData();
  48
  49     aTimeString += rLocaleData.getDuration( tools::Time( 0, 0, static_cast< sal_uInt32 >( floor( fTime ) ) ) ) +
  50         " / " +
  51         rLocaleData.getDuration( tools::Time( 0, 0, static_cast< sal_uInt32 >( floor( aMediaItem.getDuration() ) )) );
  52
  53     if( mxTimeEdit->get_text() != aTimeString )
  54         mxTimeEdit->set_text( aTimeString );
  55 }
  56
  57 void MediaControlBase::UpdateVolumeSlider( MediaItem const & aMediaItem )
  58 {
  59     if( aMediaItem.getURL().isEmpty() )
  60         mxVolumeSlider->set_sensitive(false);
  61     else
  62     {
  63         mxVolumeSlider->set_sensitive(true);
  64         const sal_Int32 nVolumeDB = aMediaItem.getVolumeDB();
  65         mxVolumeSlider->set_value( std::clamp( nVolumeDB, AVMEDIA_DB_RANGE, sal_Int32(0)) );
  66     }
  67 }
  68
  69 void MediaControlBase::UpdateTimeSlider( MediaItem const & aMediaItem )
  70 {
  71     if( aMediaItem.getURL().isEmpty() )
  72         mxTimeSlider->set_sensitive(false);
  73     else
  74     {
  75         mxTimeSlider->set_sensitive(true);
  76
  77         const double fDuration = aMediaItem.getDuration();
  78
  79         if( fDuration > 0.0 )
  80         {
  81             const double fTime = std::min( aMediaItem.getTime(), fDuration );
  82
  83             bool bChanged(false);
  84             int nStep(0), nPage(0);
  85             mxTimeSlider->get_increments(nStep, nPage);
  86             if (!nStep)
  87             {
  88                 nStep = AVMEDIA_TIME_RANGE * AVMEDIA_LINEINCREMENT / fDuration;
  89                 bChanged = true;
  90             }
  91             if (!nPage)
  92             {
  93                 nPage = AVMEDIA_TIME_RANGE * AVMEDIA_PAGEINCREMENT / fDuration;
  94                 bChanged = true;
  95             }
  96             if (bChanged)
  97                 mxTimeSlider->set_increments(nStep, nPage);
  98
  99             mxTimeSlider->set_value(fTime / fDuration * AVMEDIA_TIME_RANGE);
 100         }
 101     }
 102 }
 103
 104 void MediaControlBase::InitializeWidgets()
 105 {
 106     mxPlayToolBox->set_item_help_id("play", HID_AVMEDIA_TOOLBOXITEM_PLAY);
 107     mxPlayToolBox->set_item_help_id("pause", HID_AVMEDIA_TOOLBOXITEM_PAUSE);
 108     mxPlayToolBox->set_item_help_id("stop", HID_AVMEDIA_TOOLBOXITEM_STOP);
 109     mxPlayToolBox->set_item_help_id("loop", HID_AVMEDIA_TOOLBOXITEM_LOOP);
 110     mxMuteToolBox->set_item_help_id("mute", HID_AVMEDIA_TOOLBOXITEM_MUTE);
 111
 112     mxZoomListBox->append(OUString::number(AVMEDIA_ZOOMLEVEL_50), AvmResId( AVMEDIA_STR_ZOOM_50 ));
 113     mxZoomListBox->append(OUString::number(AVMEDIA_ZOOMLEVEL_100), AvmResId( AVMEDIA_STR_ZOOM_100 ));
 114     mxZoomListBox->append(OUString::number(AVMEDIA_ZOOMLEVEL_200), AvmResId( AVMEDIA_STR_ZOOM_200 ));
 115     mxZoomListBox->append(OUString::number(AVMEDIA_ZOOMLEVEL_FIT),  AvmResId( AVMEDIA_STR_ZOOM_FIT ));
 116     mxZoomListBox->set_help_id( HID_AVMEDIA_ZOOMLISTBOX );
 117     mxZoomListBox->set_tooltip_text(AvmResId( AVMEDIA_STR_ZOOM_TOOLTIP ));
 118
 119     mxTimeEdit->set_text( " 00:00:00/00:00:00 " );
 120     mxTimeEdit->set_help_id( HID_AVMEDIA_TIMEEDIT );
 121     mxTimeEdit->set_sensitive(false);
 122
 123     mxVolumeSlider->set_range(AVMEDIA_DB_RANGE, 0);
 124     mxVolumeSlider->set_tooltip_text( AvmResId( AVMEDIA_STR_VOLUME ));
 125     mxVolumeSlider->set_help_id( HID_AVMEDIA_VOLUMESLIDER );
 126
 127     mxTimeSlider->set_range( 0, AVMEDIA_TIME_RANGE );
 128     mxTimeSlider->set_tooltip_text( AvmResId( AVMEDIA_STR_POSITION ));
 129 }
 130
 131 void MediaControlBase::UpdatePlayState(const MediaItem& rMediaItem)
 132 {
 133     if (rMediaItem.getState() == MediaState::Play)
 134     {
 135         mxPlayToolBox->set_item_active("play", true);
 136         mxPlayToolBox->set_item_active("pause", false);
 137         mxPlayToolBox->set_item_active("stop", false);
 138     }
 139     else if( rMediaItem.getState() == MediaState::Pause )
 140     {
 141         mxPlayToolBox->set_item_active("play", false);
 142         mxPlayToolBox->set_item_active("pause", true);
 143         mxPlayToolBox->set_item_active("stop", false);
 144     }
 145     else
 146     {
 147         mxPlayToolBox->set_item_active("play", false);
 148         mxPlayToolBox->set_item_active("pause", false);
 149         mxPlayToolBox->set_item_active("stop", true);
 150     }
 151 }
 152
 153 void MediaControlBase::UpdateToolBoxes(const MediaItem& rMediaItem)
 154 {
 155     const bool bValidURL = !rMediaItem.getURL().isEmpty();
 156     mxPlayToolBox->set_item_sensitive("play", bValidURL);
 157     mxPlayToolBox->set_item_sensitive("pause", bValidURL);
 158     mxPlayToolBox->set_item_sensitive("stop", bValidURL);
 159     mxPlayToolBox->set_item_sensitive("loop", bValidURL);
 160     mxMuteToolBox->set_item_sensitive("mute", bValidURL);
 161     if( !bValidURL )
 162     {
 163         mxZoomListBox->set_sensitive(false);
 164         mxMuteToolBox->set_sensitive(false);
 165     }
 166     else
 167     {
 168         mxPlayToolBox->set_sensitive(true);
 169         mxMuteToolBox->set_sensitive(true);
 170         UpdatePlayState(rMediaItem);
 171         mxPlayToolBox->set_item_active("loop", rMediaItem.isLoop());
 172         mxMuteToolBox->set_item_active("mute", rMediaItem.isMute());
 173         if (!mbCurrentlySettingZoom)
 174         {
 175             sal_uInt16 nSelectEntryPos ;
 176
 177             switch( rMediaItem.getZoom() )
 178             {
 179                 case css::media::ZoomLevel_ZOOM_1_TO_2:
 180                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_50;
 181                     break;
 182                 case css::media::ZoomLevel_ORIGINAL:
 183                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_100;
 184                     break;
 185                 case css::media::ZoomLevel_ZOOM_2_TO_1:
 186                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_200;
 187                     break;
 188                 case css::media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT:
 189                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_FIT;
 190                     break;
 191                 case css::media::ZoomLevel_FIT_TO_WINDOW:
 192                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_SCALED;
 193                     break;
 194
 195                 default:
 196                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_INVALID;
 197                     break;
 198             }
 199
 200             if( nSelectEntryPos != AVMEDIA_ZOOMLEVEL_INVALID )
 201             {
 202                 mxZoomListBox->show();
 203                 mxZoomListBox->set_sensitive(true);
 204                 mxZoomListBox->set_active(nSelectEntryPos);
 205             }
 206             else
 207                 mxZoomListBox->set_sensitive(false);
 208         }
 209     }
 210 }
 211
 212 void MediaControlBase::SelectPlayToolBoxItem( MediaItem& aExecItem, MediaItem const & aItem, std::u16string_view rId)
 213 {
 214     if (rId == u"apply")
 215     {
 216         MediaFloater* pFloater = avmedia::getMediaFloater();
 217
 218         if( pFloater )
 219             pFloater->dispatchCurrentURL();
 220     }
 221     else if (rId == u"play")
 222     {
 223         aExecItem.setState( MediaState::Play );
 224
 225         if( aItem.getTime() == aItem.getDuration() )
 226             aExecItem.setTime( 0.0 );
 227         else
 228             aExecItem.setTime( aItem.getTime() );
 229
 230         UpdatePlayState(aExecItem);
 231     }
 232     else if (rId == u"pause")
 233     {
 234         aExecItem.setState( MediaState::Pause );
 235
 236         UpdatePlayState(aExecItem);
 237     }
 238     else if (rId == u"stop")
 239     {
 240         aExecItem.setState( MediaState::Stop );
 241         aExecItem.setTime( 0.0 );
 242
 243         UpdatePlayState(aExecItem);
 244     }
 245     else if (rId == u"mute")
 246     {
 247         aExecItem.setMute( mxMuteToolBox->get_item_active("mute") );
 248     }
 249     else if (rId == u"loop")
 250     {
 251         aExecItem.setLoop( mxPlayToolBox->get_item_active("loop") );
 252     }
 253 }
 254
 255 void MediaControlBase::disposeWidgets()
 256 {
 257     mxZoomListBox.reset();
 258     mxTimeEdit.reset();
 259     mxVolumeSlider.reset();
 260     mxMuteToolBox.reset();
 261     mxTimeSlider.reset();
 262     mxPlayToolBox.reset();
 263 }
 264
 265 }
 266
 267 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */