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