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/mediawindow.hxx>
  21 #include <avmedia/mediaplayer.hxx>
  22 #include <vcl/edit.hxx>
  23 #include <vcl/slider.hxx>
  24 #include <vcl/toolbox.hxx>
  25 #include <avmedia/mediaitem.hxx>
  26 #include <svtools/miscopt.hxx>
  27 #include <tools/time.hxx>
  28 #include <vcl/lstbox.hxx>
  29 #include "bitmaps.hlst"
  30 #include "mediacontrol.hrc"
  31 #include "helpids.hrc"
  32 #include "mediamisc.hxx"
  33
  34 using ::rtl::OUString;
  35
  36 namespace avmedia {
  37
  38 MediaControlBase::MediaControlBase()
  39 {
  40 }
  41
  42 void MediaControlBase::UpdateTimeField( MediaItem aMediaItem, double fTime )
  43 {
  44     if( !aMediaItem.getURL().isEmpty())
  45     {
  46         OUString aTimeString;
  47
  48         SvtSysLocale aSysLocale;
  49         const LocaleDataWrapper& rLocaleData = aSysLocale.GetLocaleData();
  50
  51         aTimeString += rLocaleData.getDuration( tools::Time( 0, 0, static_cast< sal_uInt32 >( floor( fTime ) ) ) ) +
  52             " / " +
  53             rLocaleData.getDuration( tools::Time( 0, 0, static_cast< sal_uInt32 >( floor( aMediaItem.getDuration() ) )) );
  54
  55         if( mpTimeEdit->GetText() != aTimeString )
  56             mpTimeEdit->SetText( aTimeString );
  57     }
  58 }
  59
  60 void MediaControlBase::UpdateVolumeSlider( MediaItem aMediaItem )
  61 {
  62     if( aMediaItem.getURL().isEmpty() )
  63         mpVolumeSlider->Disable();
  64     else
  65     {
  66         mpVolumeSlider->Enable();
  67         const sal_Int32 nVolumeDB = aMediaItem.getVolumeDB();
  68         mpVolumeSlider->SetThumbPos( std::min( std::max( nVolumeDB, static_cast< sal_Int32 >( AVMEDIA_DB_RANGE ) ),
  69                                                 static_cast< sal_Int32 >( 0 ) ) );
  70     }
  71 }
  72
  73 void MediaControlBase::UpdateTimeSlider( MediaItem aMediaItem )
  74 {
  75     if( aMediaItem.getURL().isEmpty() )
  76         mpTimeSlider->Disable();
  77     else
  78     {
  79         mpTimeSlider->Enable();
  80
  81         const double fDuration = aMediaItem.getDuration();
  82
  83         if( fDuration > 0.0 )
  84         {
  85             const double fTime = std::min( aMediaItem.getTime(), fDuration );
  86
  87             if( !mpTimeSlider->GetLineSize() )
  88                 mpTimeSlider->SetLineSize( static_cast< sal_uInt32 >( AVMEDIA_TIME_RANGE * AVMEDIA_LINEINCREMENT / fDuration ) );
  89
  90             if( !mpTimeSlider->GetPageSize() )
  91                 mpTimeSlider->SetPageSize( static_cast< sal_uInt32 >( AVMEDIA_TIME_RANGE * AVMEDIA_PAGEINCREMENT / fDuration ) );
  92
  93             mpTimeSlider->SetThumbPos( static_cast< sal_Int32 >( fTime / fDuration * AVMEDIA_TIME_RANGE ) );
  94         }
  95     }
  96 }
  97
  98 void MediaControlBase::InitializeWidgets()
  99 {
 100     mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_PLAY, GetImage(AVMEDIA_TOOLBOXITEM_PLAY), OUString( AvmResId( AVMEDIA_STR_PLAY ) ), ToolBoxItemBits::CHECKABLE );
 101     mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_PLAY, HID_AVMEDIA_TOOLBOXITEM_PLAY );
 102
 103     mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_PAUSE, GetImage(AVMEDIA_TOOLBOXITEM_PAUSE), OUString( AvmResId( AVMEDIA_STR_PAUSE ) ), ToolBoxItemBits::CHECKABLE );
 104     mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_PAUSE, HID_AVMEDIA_TOOLBOXITEM_PAUSE );
 105
 106     mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_STOP, GetImage(AVMEDIA_TOOLBOXITEM_STOP), OUString( AvmResId( AVMEDIA_STR_STOP ) ), ToolBoxItemBits::CHECKABLE );
 107     mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_STOP, HID_AVMEDIA_TOOLBOXITEM_STOP );
 108
 109     mpPlayToolBox->InsertSeparator();
 110
 111     mpPlayToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_LOOP, GetImage(AVMEDIA_TOOLBOXITEM_LOOP), OUString( AvmResId( AVMEDIA_STR_LOOP ) ) );
 112     mpPlayToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_LOOP, HID_AVMEDIA_TOOLBOXITEM_LOOP );
 113
 114     mpMuteToolBox->InsertItem( AVMEDIA_TOOLBOXITEM_MUTE, GetImage(AVMEDIA_TOOLBOXITEM_MUTE), OUString( AvmResId( AVMEDIA_STR_MUTE ) ) );
 115     mpMuteToolBox->SetHelpId( AVMEDIA_TOOLBOXITEM_MUTE, HID_AVMEDIA_TOOLBOXITEM_MUTE );
 116
 117     mpZoomListBox->InsertEntry( OUString( AvmResId( AVMEDIA_STR_ZOOM_50 ) ), AVMEDIA_ZOOMLEVEL_50 );
 118     mpZoomListBox->InsertEntry( OUString( AvmResId( AVMEDIA_STR_ZOOM_100 ) ), AVMEDIA_ZOOMLEVEL_100 );
 119     mpZoomListBox->InsertEntry( OUString( AvmResId( AVMEDIA_STR_ZOOM_200 ) ), AVMEDIA_ZOOMLEVEL_200 );
 120     mpZoomListBox->InsertEntry( OUString( AvmResId( AVMEDIA_STR_ZOOM_FIT ) ), AVMEDIA_ZOOMLEVEL_FIT );
 121     mpZoomListBox->SetHelpId( HID_AVMEDIA_ZOOMLISTBOX );
 122
 123     const OUString aTimeText( " 00:00:00/00:00:00 " );
 124     mpTimeEdit->SetText( aTimeText );
 125     mpTimeEdit->SetUpdateMode( true );
 126     mpTimeEdit->SetHelpId( HID_AVMEDIA_TIMEEDIT );
 127     mpTimeEdit->Disable();
 128     mpTimeEdit->Show();
 129
 130     mpVolumeSlider->SetRange( Range( AVMEDIA_DB_RANGE, 0 ) );
 131     mpVolumeSlider->SetUpdateMode( true );
 132     mpVolumeSlider->SetHelpId( HID_AVMEDIA_VOLUMESLIDER );
 133
 134     mpTimeSlider->SetRange( Range( 0, AVMEDIA_TIME_RANGE ) );
 135     mpTimeSlider->SetUpdateMode( true );
 136     mpTimeSlider->SetStyle(WB_HORZ | WB_DRAG | WB_3DLOOK | WB_SLIDERSET);
 137 }
 138
 139 void MediaControlBase::UpdateToolBoxes(MediaItem aMediaItem)
 140 {
 141     const bool bValidURL = !aMediaItem.getURL().isEmpty();
 142     mpPlayToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_PLAY, bValidURL );
 143     mpPlayToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_PAUSE, bValidURL );
 144     mpPlayToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_STOP, bValidURL );
 145     mpPlayToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_LOOP, bValidURL );
 146     mpMuteToolBox->EnableItem( AVMEDIA_TOOLBOXITEM_MUTE, bValidURL );
 147     if( !bValidURL )
 148     {
 149         mpZoomListBox->Disable();
 150         mpMuteToolBox->Disable();
 151     }
 152     else
 153     {
 154         mpPlayToolBox->Enable();
 155         mpMuteToolBox->Enable();
 156         if( aMediaItem.getState() == MediaState::Play )
 157         {
 158             mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PLAY );
 159             mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PAUSE, false );
 160             mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_STOP, false );
 161         }
 162         else if( aMediaItem.getTime() > 0.0 && ( aMediaItem.getTime() < aMediaItem.getDuration() ) )
 163         {
 164             mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PLAY, false );
 165             mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PAUSE );
 166             mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_STOP, false );
 167         }
 168         else
 169         {
 170             mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PLAY, false );
 171             mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_PAUSE, false );
 172             mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_STOP );
 173         }
 174         mpPlayToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_LOOP, aMediaItem.isLoop() );
 175         mpMuteToolBox->CheckItem( AVMEDIA_TOOLBOXITEM_MUTE, aMediaItem.isMute() );
 176         if( !mpZoomListBox->IsTravelSelect() && !mpZoomListBox->IsInDropDown() )
 177         {
 178             sal_uInt16 nSelectEntryPos ;
 179
 180             switch( aMediaItem.getZoom() )
 181             {
 182                 case( css::media::ZoomLevel_ZOOM_1_TO_2 ):
 183                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_50;
 184                     break;
 185                 case( css::media::ZoomLevel_ORIGINAL ):
 186                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_100;
 187                     break;
 188                 case( css::media::ZoomLevel_ZOOM_2_TO_1 ):
 189                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_200;
 190                     break;
 191                 case( css::media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT ):
 192                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_FIT;
 193                     break;
 194                 case( css::media::ZoomLevel_FIT_TO_WINDOW ):
 195                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_SCALED;
 196                     break;
 197
 198                 default:
 199                     nSelectEntryPos = AVMEDIA_ZOOMLEVEL_INVALID;
 200                     break;
 201             }
 202
 203             if( nSelectEntryPos != AVMEDIA_ZOOMLEVEL_INVALID )
 204             {
 205                 mpZoomListBox->Enable();
 206                 mpZoomListBox->SelectEntryPos( nSelectEntryPos );
 207             }
 208             else
 209                 mpZoomListBox->Disable();
 210         }
 211     }
 212 }
 213
 214 void MediaControlBase::SelectPlayToolBoxItem( MediaItem& aExecItem, MediaItem aItem, sal_uInt16 nId)
 215 {
 216     switch( nId )
 217     {
 218         case AVMEDIA_TOOLBOXITEM_INSERT:
 219         {
 220             MediaFloater* pFloater = avmedia::getMediaFloater();
 221
 222             if( pFloater )
 223                 pFloater->dispatchCurrentURL();
 224         }
 225         break;
 226
 227         case AVMEDIA_TOOLBOXITEM_PLAY:
 228         {
 229             aExecItem.setState( MediaState::Play );
 230
 231             if( aItem.getTime() == aItem.getDuration() )
 232                 aExecItem.setTime( 0.0 );
 233             else
 234                 aExecItem.setTime( aItem.getTime() );
 235         }
 236         break;
 237
 238         case AVMEDIA_TOOLBOXITEM_PAUSE:
 239         {
 240             aExecItem.setState( MediaState::Pause );
 241         }
 242         break;
 243
 244         case AVMEDIA_TOOLBOXITEM_STOP:
 245         {
 246             aExecItem.setState( MediaState::Stop );
 247             aExecItem.setTime( 0.0 );
 248         }
 249         break;
 250
 251         case AVMEDIA_TOOLBOXITEM_MUTE:
 252         {
 253             aExecItem.setMute( !mpMuteToolBox->IsItemChecked( AVMEDIA_TOOLBOXITEM_MUTE ) );
 254         }
 255         break;
 256
 257         case AVMEDIA_TOOLBOXITEM_LOOP:
 258         {
 259             aExecItem.setLoop( !mpPlayToolBox->IsItemChecked( AVMEDIA_TOOLBOXITEM_LOOP ) );
 260         }
 261         break;
 262
 263         default:
 264         break;
 265     }
 266 }
 267
 268 Image MediaControlBase::GetImage(sal_Int32 nImageId)
 269 {
 270     const bool bLarge = SvtMiscOptions().AreCurrentSymbolsLarge();
 271
 272     OUString sImageId;
 273
 274     if (bLarge)
 275     {
 276         switch (nImageId)
 277         {
 278             default:
 279             case AVMEDIA_TOOLBOXITEM_PLAY:
 280                 sImageId = AVMEDIA_IMG_PLAY_LARGE;
 281                 break;
 282             case AVMEDIA_TOOLBOXITEM_PAUSE:
 283                 sImageId = AVMEDIA_IMG_PAUSE_LARGE;
 284                 break;
 285             case AVMEDIA_TOOLBOXITEM_STOP:
 286                 sImageId = AVMEDIA_IMG_STOP_LARGE;
 287                 break;
 288             case AVMEDIA_TOOLBOXITEM_MUTE:
 289                 sImageId = AVMEDIA_IMG_MUTE_LARGE;
 290                 break;
 291             case AVMEDIA_TOOLBOXITEM_LOOP:
 292                 sImageId = AVMEDIA_IMG_LOOP_LARGE;
 293                 break;
 294             case AVMEDIA_TOOLBOXITEM_OPEN:
 295                 sImageId = AVMEDIA_IMG_OPEN_LARGE;
 296                 break;
 297             case AVMEDIA_TOOLBOXITEM_INSERT:
 298                 sImageId = AVMEDIA_IMG_INSERT_LARGE;
 299                 break;
 300
 301         }
 302     }
 303     else
 304     {
 305         switch (nImageId)
 306         {
 307             default:
 308             case AVMEDIA_TOOLBOXITEM_PLAY:
 309                 sImageId = AVMEDIA_IMG_PLAY_NORMAL;
 310                 break;
 311             case AVMEDIA_TOOLBOXITEM_PAUSE:
 312                 sImageId = AVMEDIA_IMG_PAUSE_NORMAL;
 313                 break;
 314             case AVMEDIA_TOOLBOXITEM_STOP:
 315                 sImageId = AVMEDIA_IMG_STOP_NORMAL;
 316                 break;
 317             case AVMEDIA_TOOLBOXITEM_MUTE:
 318                 sImageId = AVMEDIA_IMG_MUTE_NORMAL;
 319                 break;
 320             case AVMEDIA_TOOLBOXITEM_LOOP:
 321                 sImageId = AVMEDIA_IMG_LOOP_NORMAL;
 322                 break;
 323             case AVMEDIA_TOOLBOXITEM_OPEN:
 324                 sImageId = AVMEDIA_IMG_OPEN_NORMAL;
 325                 break;
 326             case AVMEDIA_TOOLBOXITEM_INSERT:
 327                 sImageId = AVMEDIA_IMG_INSERT_NORMAL;
 328                 break;
 329         }
 330     }
 331
 332     return Image(BitmapEx(sImageId));
 333 }
 334
 335 }
 336
 337 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */