slideshow/source/engine/shapes/viewmediashape.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
  20 #include <config_features.h>
  21
  22 #include <tools/diagnose_ex.h>
  23
  24 #include <math.h>
  25
  26 #include <comphelper/anytostring.hxx>
  27 #include <cppuhelper/exc_hlp.hxx>
  28
  29 #include <vcl/canvastools.hxx>
  30 #include <vcl/syschild.hxx>
  31 #include <vcl/sysdata.hxx>
  32 #include <vcl/window.hxx>
  33 #include <vcl/graph.hxx>
  34
  35 #include <basegfx/utils/canvastools.hxx>
  36 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  37 #include <basegfx/numeric/ftools.hxx>
  38 #include <basegfx/polygon/b2dpolygon.hxx>
  39 #include <basegfx/point/b2dpoint.hxx>
  40 #include <basegfx/matrix/b2dhommatrix.hxx>
  41 #include <basegfx/polygon/b2dpolygontools.hxx>
  42 #include <basegfx/range/b2irange.hxx>
  43 #include <canvas/canvastools.hxx>
  44 #include <cppcanvas/vclfactory.hxx>
  45 #include <cppcanvas/basegfxfactory.hxx>
  46 #include <avmedia/mediawindow.hxx>
  47
  48 #if HAVE_FEATURE_OPENGL
  49 #include <vcl/opengl/OpenGLContext.hxx>
  50 #endif
  51
  52 #include <com/sun/star/awt/XWindow.hpp>
  53 #include <com/sun/star/beans/XPropertySet.hpp>
  54 #include <com/sun/star/lang/XComponent.hpp>
  55 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
  56 #include <com/sun/star/lang/NoSupportException.hpp>
  57 #include <com/sun/star/media/XManager.hpp>
  58 #include <com/sun/star/media/XPlayer.hpp>
  59 #include <com/sun/star/media/XPlayerWindow.hpp>
  60 #include <com/sun/star/presentation/XSlideShowView.hpp>
  61 #include <com/sun/star/rendering/XCanvas.hpp>
  62
  63 #include "viewmediashape.hxx"
  64 #include "mediashape.hxx"
  65 #include <tools.hxx>
  66 #include <unoview.hxx>
  67
  68 using namespace ::com::sun::star;
  69
  70 namespace slideshow
  71 {
  72     namespace internal
  73     {
  74         ViewMediaShape::ViewMediaShape( const ViewLayerSharedPtr&                       rViewLayer,
  75                                         const uno::Reference< drawing::XShape >&        rxShape,
  76                                         const uno::Reference< uno::XComponentContext >& rxContext ) :
  77             mpViewLayer( rViewLayer ),
  78             mpEventHandlerParent(nullptr),
  79             maWindowOffset( 0, 0 ),
  80             maBounds(),
  81             mxShape( rxShape ),
  82             mxPlayer(),
  83             mxPlayerWindow(),
  84             mxComponentContext( rxContext ),
  85             mbIsSoundEnabled(true)
  86         {
  87             ENSURE_OR_THROW( mxShape.is(), "ViewMediaShape::ViewMediaShape(): Invalid Shape" );
  88             ENSURE_OR_THROW( mpViewLayer, "ViewMediaShape::ViewMediaShape(): Invalid View" );
  89             ENSURE_OR_THROW( mpViewLayer->getCanvas(), "ViewMediaShape::ViewMediaShape(): Invalid ViewLayer canvas" );
  90             ENSURE_OR_THROW( mxComponentContext.is(), "ViewMediaShape::ViewMediaShape(): Invalid component context" );
  91
  92             UnoViewSharedPtr xUnoView(std::dynamic_pointer_cast<UnoView>(rViewLayer));
  93             if (xUnoView)
  94             {
  95                 mbIsSoundEnabled = xUnoView->isSoundEnabled();
  96             }
  97         }
  98
  99         ViewMediaShape::~ViewMediaShape()
 100         {
 101             try
 102             {
 103                 endMedia();
 104             }
 105             catch (const uno::Exception &e)
 106             {
 107                 SAL_WARN("slideshow", e);
 108             }
 109         }
 110
 111         const ViewLayerSharedPtr& ViewMediaShape::getViewLayer() const
 112         {
 113             return mpViewLayer;
 114         }
 115
 116         void ViewMediaShape::startMedia()
 117         {
 118             if( !mxPlayer.is() )
 119                 implInitialize( maBounds );
 120
 121             if (mxPlayer.is())
 122                 mxPlayer->start();
 123         }
 124
 125         void ViewMediaShape::endMedia()
 126         {
 127             // shutdown player window
 128             if( mxPlayerWindow.is() )
 129             {
 130                 uno::Reference< lang::XComponent > xComponent( mxPlayerWindow, uno::UNO_QUERY );
 131
 132                 if( xComponent.is() )
 133                     xComponent->dispose();
 134
 135                 mxPlayerWindow.clear();
 136             }
 137
 138             mpMediaWindow.disposeAndClear();
 139             mpEventHandlerParent.disposeAndClear();
 140
 141             // shutdown player
 142             if( mxPlayer.is() )
 143             {
 144                 mxPlayer->stop();
 145
 146                 uno::Reference< lang::XComponent > xComponent( mxPlayer, uno::UNO_QUERY );
 147
 148                 if( xComponent.is() )
 149                     xComponent->dispose();
 150
 151                 mxPlayer.clear();
 152             }
 153         }
 154
 155         void ViewMediaShape::pauseMedia()
 156         {
 157             if (mxPlayer.is())
 158                 mxPlayer->stop();
 159         }
 160
 161         void ViewMediaShape::setMediaTime(double fTime)
 162         {
 163             if (mxPlayer.is())
 164                 mxPlayer->setMediaTime(fTime);
 165         }
 166
 167         bool ViewMediaShape::render( const ::basegfx::B2DRectangle& rBounds ) const
 168         {
 169 #if !HAVE_FEATURE_AVMEDIA
 170             (void) rBounds;
 171 #else
 172             ::cppcanvas::CanvasSharedPtr pCanvas = mpViewLayer->getCanvas();
 173
 174             if( !pCanvas )
 175                 return false;
 176
 177             if( !mpMediaWindow.get() && !mxPlayerWindow.is() )
 178             {
 179                 uno::Reference< graphic::XGraphic > xGraphic;
 180                 uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY );
 181                 if (xPropSet.is())
 182                 {
 183                     xPropSet->getPropertyValue("FallbackGraphic") >>= xGraphic;
 184                 }
 185
 186                 Graphic aGraphic(xGraphic);
 187                 const BitmapEx aBmp = aGraphic.GetBitmapEx();
 188
 189                 uno::Reference< rendering::XBitmap > xBitmap(vcl::unotools::xBitmapFromBitmapEx(aBmp));
 190
 191                 rendering::ViewState aViewState;
 192                 aViewState.AffineTransform = pCanvas->getViewState().AffineTransform;
 193
 194                 rendering::RenderState aRenderState;
 195                 ::canvas::tools::initRenderState( aRenderState );
 196
 197                 const ::Size aBmpSize( aBmp.GetSizePixel() );
 198
 199                 const ::basegfx::B2DVector aScale( rBounds.getWidth() / aBmpSize.Width(),
 200                                                    rBounds.getHeight() / aBmpSize.Height() );
 201                 const basegfx::B2DHomMatrix aTranslation(basegfx::utils::createScaleTranslateB2DHomMatrix(
 202                     aScale, rBounds.getMinimum()));
 203                 ::canvas::tools::setRenderStateTransform( aRenderState, aTranslation );
 204
 205                 pCanvas->getUNOCanvas()->drawBitmap( xBitmap,
 206                                                      aViewState,
 207                                                      aRenderState );
 208             }
 209 #endif
 210             return true;
 211         }
 212
 213         bool ViewMediaShape::resize( const ::basegfx::B2DRectangle& rNewBounds ) const
 214         {
 215             maBounds = rNewBounds;
 216
 217             ::cppcanvas::CanvasSharedPtr pCanvas = mpViewLayer->getCanvas();
 218
 219             if( !pCanvas )
 220                 return false;
 221
 222             if( !mxPlayerWindow.is() )
 223                 return true;
 224
 225             uno::Reference< beans::XPropertySet > xPropSet( pCanvas->getUNOCanvas()->getDevice(),
 226                                                             uno::UNO_QUERY );
 227
 228             uno::Reference< awt::XWindow > xParentWindow;
 229             if( xPropSet.is() &&
 230                 getPropertyValue( xParentWindow,
 231                                   xPropSet,
 232                                   "Window") )
 233             {
 234                 const awt::Rectangle aRect( xParentWindow->getPosSize() );
 235
 236                 maWindowOffset.X = aRect.X;
 237                 maWindowOffset.Y = aRect.Y;
 238             }
 239
 240             ::basegfx::B2DRange aTmpRange;
 241             ::canvas::tools::calcTransformedRectBounds( aTmpRange,
 242                                                         rNewBounds,
 243                                                         mpViewLayer->getTransformation() );
 244             const ::basegfx::B2IRange& rRangePix(
 245                 ::basegfx::unotools::b2ISurroundingRangeFromB2DRange( aTmpRange ));
 246
 247             mxPlayerWindow->setEnable( !rRangePix.isEmpty() );
 248
 249             if( rRangePix.isEmpty() )
 250                 return true;
 251
 252             const Point aPosPixel( rRangePix.getMinX() + maWindowOffset.X,
 253                                    rRangePix.getMinY() + maWindowOffset.Y );
 254             const Size  aSizePixel( rRangePix.getMaxX() - rRangePix.getMinX(),
 255                                     rRangePix.getMaxY() - rRangePix.getMinY() );
 256
 257             if( mpMediaWindow.get() )
 258             {
 259                 if( mpEventHandlerParent )
 260                 {
 261                     mpEventHandlerParent->SetPosSizePixel( aPosPixel, aSizePixel );
 262                     mpMediaWindow->SetPosSizePixel( Point(0,0), aSizePixel );
 263                 }
 264                 else
 265                 {
 266                     mpMediaWindow->SetPosSizePixel( aPosPixel, aSizePixel );
 267                 }
 268                 mxPlayerWindow->setPosSize( 0, 0,
 269                                             aSizePixel.Width(), aSizePixel.Height(),
 270                                             0 );
 271             }
 272             else
 273             {
 274                 mxPlayerWindow->setPosSize( aPosPixel.X(), aPosPixel.Y(),
 275                                             aSizePixel.Width(), aSizePixel.Height(),
 276                                             0 );
 277             }
 278
 279             return true;
 280         }
 281
 282
 283         bool ViewMediaShape::implInitialize( const ::basegfx::B2DRectangle& rBounds )
 284         {
 285             if( !mxPlayer.is() && mxShape.is() )
 286             {
 287                 ENSURE_OR_RETURN_FALSE( mpViewLayer->getCanvas(),
 288                                    "ViewMediaShape::implInitialize(): Invalid layer canvas" );
 289
 290                 uno::Reference< rendering::XCanvas > xCanvas( mpViewLayer->getCanvas()->getUNOCanvas() );
 291
 292                 if( xCanvas.is() )
 293                 {
 294                     uno::Reference< beans::XPropertySet >   xPropSet;
 295                     try
 296                     {
 297                         xPropSet.set( mxShape, uno::UNO_QUERY );
 298                         OUString sMimeType;
 299
 300                         // create Player
 301                         if (xPropSet.is())
 302                         {
 303                             OUString aURL;
 304                             xPropSet->getPropertyValue("MediaMimeType") >>= sMimeType;
 305                             if ((xPropSet->getPropertyValue("PrivateTempFileURL") >>= aURL)
 306                                 && !aURL.isEmpty())
 307                             {
 308                                 implInitializeMediaPlayer( aURL, sMimeType );
 309                             }
 310                             else if (xPropSet->getPropertyValue("MediaURL") >>= aURL)
 311                             {
 312                                 implInitializeMediaPlayer( aURL, sMimeType );
 313                             }
 314                         }
 315
 316                         // create visible object
 317                         uno::Sequence< uno::Any > aDeviceParams;
 318
 319                         if( ::canvas::tools::getDeviceInfo( xCanvas, aDeviceParams ).getLength() > 1 )
 320                         {
 321                             implInitializePlayerWindow( rBounds, aDeviceParams, sMimeType );
 322                         }
 323
 324                         // set player properties
 325                         implSetMediaProperties( xPropSet );
 326                     }
 327                     catch( uno::RuntimeException& )
 328                     {
 329                         throw;
 330                     }
 331                     catch( uno::Exception& )
 332                     {
 333                         SAL_WARN( "slideshow", comphelper::anyToString( cppu::getCaughtException() ) );
 334                     }
 335                 }
 336             }
 337
 338             return mxPlayer.is() || mxPlayerWindow.is();
 339         }
 340
 341
 342         void ViewMediaShape::implSetMediaProperties( const uno::Reference< beans::XPropertySet >& rxProps )
 343         {
 344             if( mxPlayer.is() )
 345             {
 346                 mxPlayer->setMediaTime( 0.0 );
 347
 348                 if( rxProps.is() )
 349                 {
 350                     bool bLoop( false );
 351                     getPropertyValue( bLoop,
 352                                       rxProps,
 353                                       "Loop");
 354                     mxPlayer->setPlaybackLoop( bLoop );
 355
 356                     bool bMute( false );
 357                     getPropertyValue( bMute,
 358                                       rxProps,
 359                                       "Mute");
 360                     mxPlayer->setMute( bMute || !mbIsSoundEnabled);
 361
 362                     sal_Int16 nVolumeDB(0);
 363                     getPropertyValue( nVolumeDB,
 364                                       rxProps,
 365                                       "VolumeDB");
 366                     mxPlayer->setVolumeDB( nVolumeDB );
 367
 368                     if( mxPlayerWindow.is() )
 369                     {
 370                         media::ZoomLevel eZoom(media::ZoomLevel_FIT_TO_WINDOW);
 371                         getPropertyValue( eZoom,
 372                                           rxProps,
 373                                           "Zoom");
 374                         mxPlayerWindow->setZoomLevel( eZoom );
 375                     }
 376                 }
 377             }
 378         }
 379
 380
 381         void ViewMediaShape::implInitializeMediaPlayer( const OUString& rMediaURL, const OUString& rMimeType )
 382         {
 383 #if !HAVE_FEATURE_AVMEDIA
 384             (void) rMediaURL;
 385             (void) rMimeType;
 386 #else
 387             if( !mxPlayer.is() )
 388             {
 389                 try
 390                 {
 391                     if( !rMediaURL.isEmpty() )
 392                     {
 393                         mxPlayer.set( avmedia::MediaWindow::createPlayer( rMediaURL, ""/*TODO!*/, &rMimeType ),
 394                             uno::UNO_QUERY );
 395                     }
 396                 }
 397                 catch( uno::RuntimeException& )
 398                 {
 399                     throw;
 400                 }
 401                 catch( const uno::Exception& )
 402                 {
 403                     throw lang::NoSupportException( "No video support for " + rMediaURL );
 404                 }
 405             }
 406 #endif
 407         }
 408
 409
 410         void ViewMediaShape::implInitializePlayerWindow( const ::basegfx::B2DRectangle&   rBounds,
 411                                                                  const uno::Sequence< uno::Any >& rVCLDeviceParams,
 412                                                                  const OUString& )
 413         {
 414             SAL_INFO("slideshow", "ViewMediaShape::implInitializePlayerWindow" );
 415             if( !mpMediaWindow.get() && !rBounds.isEmpty() )
 416             {
 417                 try
 418                 {
 419                     sal_Int64 aVal=0;
 420
 421                     rVCLDeviceParams[ 1 ] >>= aVal;
 422
 423                     vcl::Window* pWindow = reinterpret_cast< vcl::Window* >( aVal );
 424
 425                     if( pWindow )
 426                     {
 427                         ::basegfx::B2DRange aTmpRange;
 428                         ::canvas::tools::calcTransformedRectBounds( aTmpRange,
 429                                                                     rBounds,
 430                                                                     mpViewLayer->getTransformation() );
 431                         const ::basegfx::B2IRange& rRangePix(
 432                             ::basegfx::unotools::b2ISurroundingRangeFromB2DRange( aTmpRange ));
 433
 434                         if( !rRangePix.isEmpty() )
 435                         {
 436                             uno::Sequence< uno::Any >   aArgs( 3 );
 437                             awt::Rectangle              aAWTRect( rRangePix.getMinX(),
 438                                                                   rRangePix.getMinY(),
 439                                                                     rRangePix.getMaxX() - rRangePix.getMinX(),
 440                                                                     rRangePix.getMaxY() - rRangePix.getMinY() );
 441                             {
 442                                 mpMediaWindow.disposeAndClear();
 443                                 mpMediaWindow = VclPtr<SystemChildWindow>::Create( pWindow, WB_CLIPCHILDREN );
 444                                 UnoViewSharedPtr xUnoView(std::dynamic_pointer_cast<UnoView>(mpViewLayer));
 445                                 if (xUnoView)
 446                                 {
 447                                     awt::Rectangle aCanvasArea = xUnoView->getUnoView()->getCanvasArea();
 448                                     aAWTRect.X += aCanvasArea.X;
 449                                     aAWTRect.Y += aCanvasArea.Y;
 450                                 }
 451                                 mpMediaWindow->SetPosSizePixel( Point( aAWTRect.X, aAWTRect.Y ),
 452                                                            Size( aAWTRect.Width, aAWTRect.Height ) );
 453                             }
 454                             mpMediaWindow->SetBackground( Color( COL_BLACK ) );
 455                             mpMediaWindow->SetParentClipMode( ParentClipMode::NoClip );
 456                             mpMediaWindow->EnableEraseBackground( false );
 457                             mpMediaWindow->EnablePaint( false );
 458                             mpMediaWindow->SetForwardKey( true );
 459                             mpMediaWindow->SetMouseTransparent( true );
 460                             mpMediaWindow->Show();
 461
 462                             if( mxPlayer.is() )
 463                             {
 464                                 aArgs[ 0 ] <<=
 465                                     sal::static_int_cast< sal_IntPtr >( mpMediaWindow->GetParentWindowHandle() );
 466
 467                                 aAWTRect.X = aAWTRect.Y = 0;
 468                                 aArgs[ 1 ] <<= aAWTRect;
 469                                 aArgs[ 2 ] <<= reinterpret_cast< sal_IntPtr >( mpMediaWindow.get() );
 470
 471                                 mxPlayerWindow.set( mxPlayer->createPlayerWindow( aArgs ) );
 472
 473                                 if( mxPlayerWindow.is() )
 474                                 {
 475                                     mxPlayerWindow->setVisible( true );
 476                                     mxPlayerWindow->setEnable( true );
 477                                 }
 478                             }
 479
 480                             if( !mxPlayerWindow.is() )
 481                             {
 482                                 //if there was no playerwindow, then clear the mpMediaWindow too
 483                                 //so that we can draw a placeholder instead in that space
 484                                 mpMediaWindow.disposeAndClear();
 485                                 mpEventHandlerParent.disposeAndClear();
 486                             }
 487                         }
 488                     }
 489                 }
 490                 catch( uno::RuntimeException& )
 491                 {
 492                     throw;
 493                 }
 494                 catch( uno::Exception& )
 495                 {
 496                     SAL_WARN( "slideshow", comphelper::anyToString( cppu::getCaughtException() ) );
 497                 }
 498             }
 499         }
 500     }
 501 }
 502
 503 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */