avmedia/source/viewer/mediawindowbase_impl.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: mediawindowbase_impl.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "mediawindowbase_impl.hxx"
  32 #include <avmedia/mediaitem.hxx>
  33 #include "mediamisc.hxx"
  34 #include "mediawindow.hrc"
  35 #include <tools/urlobj.hxx>
  36 #include <comphelper/processfactory.hxx>
  37 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  38 #include <com/sun/star/media/XManager.hpp>
  39 #ifndef _COM_SUN_STAR_LANG_XCOMPONENT_HDL_
  40 #include <com/sun/star/lang/XComponent.hdl>
  41 #endif
  42
  43 #define MEDIA_TIMER_TIMEOUT 100
  44
  45 using namespace ::com::sun::star;
  46
  47 namespace avmedia { namespace priv {
  48
  49 // -----------------------
  50 // - MediaWindowBaseImpl -
  51 // -----------------------
  52
  53 MediaWindowBaseImpl::MediaWindowBaseImpl( MediaWindow* pMediaWindow ) :
  54     mpMediaWindow( pMediaWindow )
  55 {
  56 }
  57
  58 // ---------------------------------------------------------------------
  59
  60 MediaWindowBaseImpl::~MediaWindowBaseImpl()
  61 {
  62     uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() );
  63 }
  64
  65 // -------------------------------------------------------------------------
  66
  67 uno::Reference< media::XPlayer > MediaWindowBaseImpl::createPlayer( const ::rtl::OUString& rURL )
  68 {
  69     uno::Reference< lang::XMultiServiceFactory >    xFactory( ::comphelper::getProcessServiceFactory() );
  70     uno::Reference< media::XPlayer >                xPlayer;
  71
  72     if( xFactory.is() )
  73     {
  74         try
  75         {
  76
  77             uno::Reference< ::com::sun::star::media::XManager > xManager(
  78                 xFactory->createInstance( ::rtl::OUString::createFromAscii( AVMEDIA_MANAGER_SERVICE_NAME ) ),
  79                 uno::UNO_QUERY );
  80
  81             if( xManager.is() )
  82             {
  83                 xPlayer = uno::Reference< ::com::sun::star::media::XPlayer >(
  84                     xManager->createPlayer( rURL ), uno::UNO_QUERY );
  85             }
  86         }
  87         catch( ... )
  88         {
  89         }
  90     }
  91
  92     return xPlayer;
  93 }
  94
  95
  96 // ---------------------------------------------------------------------
  97
  98 void MediaWindowBaseImpl::setURL( const ::rtl::OUString& rURL )
  99 {
 100     if( rURL != getURL() )
 101     {
 102         INetURLObject aURL( maFileURL = rURL );
 103
 104         if( mxPlayer.is() )
 105             mxPlayer->stop();
 106
 107         if( mxPlayerWindow.is() )
 108         {
 109             mxPlayerWindow->setVisible( false );
 110             mxPlayerWindow.clear();
 111         }
 112
 113         mxPlayer.clear();
 114
 115         if( aURL.GetProtocol() != INET_PROT_NOT_VALID )
 116             maFileURL = aURL.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS );
 117
 118         mxPlayer = createPlayer( maFileURL );
 119         onURLChanged();
 120     }
 121 }
 122
 123 // ---------------------------------------------------------------------
 124
 125 void MediaWindowBaseImpl::onURLChanged()
 126 {
 127 }
 128
 129 // ---------------------------------------------------------------------
 130
 131 const ::rtl::OUString& MediaWindowBaseImpl::getURL() const
 132 {
 133     return maFileURL;
 134 }
 135
 136 // ---------------------------------------------------------------------
 137
 138 bool MediaWindowBaseImpl::isValid() const
 139 {
 140     return( getPlayer().is() );
 141 }
 142
 143 // ---------------------------------------------------------------------
 144
 145 void MediaWindowBaseImpl::stopPlayingInternal( bool bStop )
 146 {
 147     if( isPlaying() )
 148     {
 149         if( bStop )
 150             mxPlayer->start();
 151         else
 152             mxPlayer->stop();
 153     }
 154 }
 155
 156 // ---------------------------------------------------------------------
 157
 158 MediaWindow* MediaWindowBaseImpl::getMediaWindow() const
 159 {
 160     return mpMediaWindow;
 161 }
 162
 163 // ---------------------------------------------------------------------
 164
 165 uno::Reference< media::XPlayer > MediaWindowBaseImpl::getPlayer() const
 166 {
 167     return mxPlayer;
 168 }
 169
 170 // ---------------------------------------------------------------------
 171
 172 uno::Reference< media::XPlayerWindow > MediaWindowBaseImpl::getPlayerWindow() const
 173 {
 174     return mxPlayerWindow;
 175 }
 176
 177 // ---------------------------------------------------------------------
 178
 179 void MediaWindowBaseImpl::setPlayerWindow( const uno::Reference< media::XPlayerWindow >& rxPlayerWindow )
 180 {
 181     mxPlayerWindow = rxPlayerWindow;
 182 }
 183
 184 // ---------------------------------------------------------------------
 185
 186 void MediaWindowBaseImpl::cleanUp()
 187 {
 188     if( mxPlayer.is() )
 189     {
 190         mxPlayer->stop();
 191
 192         uno::Reference< lang::XComponent > xComponent( mxPlayer, uno::UNO_QUERY );
 193
 194         if( xComponent.is() )
 195             xComponent->dispose();
 196
 197         mxPlayer.clear();
 198     }
 199
 200     mpMediaWindow = NULL;
 201 }
 202
 203 // ---------------------------------------------------------------------
 204
 205 bool MediaWindowBaseImpl::hasPreferredSize() const
 206 {
 207     return( mxPlayerWindow.is() );
 208 }
 209
 210 // ---------------------------------------------------------------------
 211
 212 Size MediaWindowBaseImpl::getPreferredSize() const
 213 {
 214     Size aRet;
 215
 216     if( mxPlayer.is() )
 217     {
 218         awt::Size aPrefSize( mxPlayer->getPreferredPlayerWindowSize() );
 219
 220         aRet.Width() = aPrefSize.Width;
 221         aRet.Height() = aPrefSize.Height;
 222     }
 223
 224     return aRet;
 225 }
 226
 227 // ---------------------------------------------------------------------
 228
 229 bool MediaWindowBaseImpl::setZoom( ::com::sun::star::media::ZoomLevel eLevel )
 230 {
 231     return( mxPlayerWindow.is() ? mxPlayerWindow->setZoomLevel( eLevel ) : false );
 232 }
 233
 234 // -------------------------------------------------------------------------
 235
 236 ::com::sun::star::media::ZoomLevel MediaWindowBaseImpl::getZoom() const
 237 {
 238     return( mxPlayerWindow.is() ? mxPlayerWindow->getZoomLevel() : ::com::sun::star::media::ZoomLevel_NOT_AVAILABLE );
 239 }
 240
 241 // ---------------------------------------------------------------------
 242
 243 bool MediaWindowBaseImpl::start()
 244 {
 245     return( mxPlayer.is() ? ( mxPlayer->start(), true ) : false );
 246 }
 247
 248 // ---------------------------------------------------------------------
 249
 250 void MediaWindowBaseImpl::stop()
 251 {
 252     if( mxPlayer.is() )
 253         mxPlayer->stop();
 254 }
 255
 256 // ---------------------------------------------------------------------
 257
 258 bool MediaWindowBaseImpl::isPlaying() const
 259 {
 260     return( mxPlayer.is() && mxPlayer->isPlaying() );
 261 }
 262
 263 // ---------------------------------------------------------------------
 264
 265 double MediaWindowBaseImpl::getDuration() const
 266 {
 267     return( mxPlayer.is() ? mxPlayer->getDuration() : 0.0 );
 268 }
 269
 270 // ---------------------------------------------------------------------
 271
 272 void MediaWindowBaseImpl::setMediaTime( double fTime )
 273 {
 274     if( mxPlayer.is() )
 275         mxPlayer->setMediaTime( fTime );
 276 }
 277
 278 // ---------------------------------------------------------------------
 279
 280 double MediaWindowBaseImpl::getMediaTime() const
 281 {
 282     return( mxPlayer.is() ? mxPlayer->getMediaTime() : 0.0 );
 283 }
 284
 285 // ---------------------------------------------------------------------
 286
 287 void MediaWindowBaseImpl::setStopTime( double fTime )
 288 {
 289     if( mxPlayer.is() )
 290         mxPlayer->setStopTime( fTime );
 291 }
 292
 293 // ---------------------------------------------------------------------
 294
 295 double MediaWindowBaseImpl::getStopTime() const
 296 {
 297     return( mxPlayer.is() ? mxPlayer->getStopTime() : 0.0 );
 298 }
 299
 300 // ---------------------------------------------------------------------
 301
 302 void MediaWindowBaseImpl::setRate( double fRate )
 303 {
 304     if( mxPlayer.is() )
 305         mxPlayer->setRate( fRate );
 306 }
 307
 308 // ---------------------------------------------------------------------
 309
 310 double MediaWindowBaseImpl::getRate() const
 311 {
 312     return( mxPlayer.is() ? mxPlayer->getRate() : 0.0 );
 313 }
 314
 315 // ---------------------------------------------------------------------
 316
 317 void MediaWindowBaseImpl::setPlaybackLoop( bool bSet )
 318 {
 319     if( mxPlayer.is() )
 320         mxPlayer->setPlaybackLoop( bSet );
 321 }
 322
 323 // ---------------------------------------------------------------------
 324
 325 bool MediaWindowBaseImpl::isPlaybackLoop() const
 326 {
 327     return( mxPlayer.is() ? mxPlayer->isPlaybackLoop() : false );
 328 }
 329
 330 // ---------------------------------------------------------------------
 331
 332 void MediaWindowBaseImpl::setMute( bool bSet )
 333 {
 334     if( mxPlayer.is() )
 335         mxPlayer->setMute( bSet );
 336 }
 337
 338 // ---------------------------------------------------------------------
 339
 340 bool MediaWindowBaseImpl::isMute() const
 341 {
 342     return( mxPlayer.is() ? mxPlayer->isMute() : false );
 343 }
 344
 345 // ---------------------------------------------------------------------
 346
 347 void MediaWindowBaseImpl::setVolumeDB( sal_Int16 nVolumeDB )
 348 {
 349     if( mxPlayer.is() )
 350         mxPlayer->setVolumeDB( nVolumeDB );
 351 }
 352
 353 // ---------------------------------------------------------------------
 354
 355 sal_Int16 MediaWindowBaseImpl::getVolumeDB() const
 356 {
 357     return( mxPlayer.is() ? mxPlayer->getVolumeDB() : 0 );
 358 }
 359
 360 // -------------------------------------------------------------------------
 361
 362 void MediaWindowBaseImpl::updateMediaItem( MediaItem& rItem ) const
 363 {
 364     if( isPlaying() )
 365         rItem.setState( ( getRate() > 1.0 ) ? MEDIASTATE_PLAYFFW : MEDIASTATE_PLAY );
 366     else
 367         rItem.setState( ( 0.0 == getMediaTime() ) ? MEDIASTATE_STOP : MEDIASTATE_PAUSE );
 368
 369     rItem.setDuration( getDuration() );
 370     rItem.setTime( getMediaTime() );
 371     rItem.setLoop( isPlaybackLoop() );
 372     rItem.setMute( isMute() );
 373     rItem.setVolumeDB( getVolumeDB() );
 374     rItem.setZoom( getZoom() );
 375     rItem.setURL( getURL() );
 376 }
 377
 378 // -------------------------------------------------------------------------
 379
 380 void MediaWindowBaseImpl::executeMediaItem( const MediaItem& rItem )
 381 {
 382     const sal_uInt32 nMaskSet = rItem.getMaskSet();
 383
 384     // set URL first
 385     if( nMaskSet & AVMEDIA_SETMASK_URL )
 386         setURL( rItem.getURL() );
 387
 388     // set different states next
 389     if( nMaskSet & AVMEDIA_SETMASK_TIME )
 390         setMediaTime( ::std::min( rItem.getTime(), getDuration() ) );
 391
 392     if( nMaskSet & AVMEDIA_SETMASK_LOOP )
 393         setPlaybackLoop( rItem.isLoop() );
 394
 395     if( nMaskSet & AVMEDIA_SETMASK_MUTE )
 396         setMute( rItem.isMute() );
 397
 398     if( nMaskSet & AVMEDIA_SETMASK_VOLUMEDB )
 399         setVolumeDB( rItem.getVolumeDB() );
 400
 401     if( nMaskSet & AVMEDIA_SETMASK_ZOOM )
 402         setZoom( rItem.getZoom() );
 403
 404     // set play state at last
 405     if( nMaskSet & AVMEDIA_SETMASK_STATE )
 406     {
 407         switch( rItem.getState() )
 408         {
 409             case( MEDIASTATE_PLAY ):
 410             case( MEDIASTATE_PLAYFFW ):
 411             {
 412 /*
 413                 const double fNewRate = ( ( MEDIASTATE_PLAYFFW == rItem.getState() ) ? AVMEDIA_FFW_PLAYRATE : 1.0 );
 414
 415                 if( getRate() != fNewRate )
 416                     setRate( fNewRate );
 417 */
 418                 if( !isPlaying() )
 419                     start();
 420             }
 421             break;
 422
 423             case( MEDIASTATE_PAUSE ):
 424             {
 425                 if( isPlaying() )
 426                     stop();
 427             }
 428             break;
 429
 430             case( MEDIASTATE_STOP ):
 431             {
 432                 if( isPlaying() )
 433                 {
 434                     setMediaTime( 0.0 );
 435                     stop();
 436                     setMediaTime( 0.0 );
 437                 }
 438             }
 439             break;
 440         }
 441     }
 442 }
 443
 444 } // namespace priv
 445 } // namespace avemdia