avmedia/source/viewer/mediawindow_impl.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 <iostream>
  23 #include "mediawindow_impl.hxx"
  24 #include "mediaevent_impl.hxx"
  25 #include "mediamisc.hxx"
  26 #include "mediawindow.hrc"
  27 #include "helpids.hrc"
  28
  29 #include <algorithm>
  30 #include <cmath>
  31
  32 #include <comphelper/processfactory.hxx>
  33 #include <osl/mutex.hxx>
  34 #include <tools/urlobj.hxx>
  35 #include <unotools/securityoptions.hxx>
  36 #include <vcl/svapp.hxx>
  37
  38 #include <com/sun/star/awt/SystemPointer.hpp>
  39 #include <com/sun/star/lang/XComponent.hpp>
  40 #include <com/sun/star/media/XManager.hpp>
  41 #include <vcl/sysdata.hxx>
  42 #include <vcl/opengl/OpenGLContext.hxx>
  43
  44 using namespace ::com::sun::star;
  45
  46 namespace avmedia { namespace priv {
  47
  48 MediaWindowControl::MediaWindowControl(vcl::Window* pParent)
  49     : MediaControl(pParent, MEDIACONTROLSTYLE_MULTILINE)
  50 {
  51 }
  52
  53 void MediaWindowControl::update()
  54 {
  55     MediaItem aItem;
  56
  57     static_cast< MediaWindowImpl* >( GetParent() )->updateMediaItem( aItem );
  58     setState(aItem);
  59 }
  60
  61 void MediaWindowControl::execute(const MediaItem& rItem)
  62 {
  63     static_cast<MediaWindowImpl*>(GetParent())->executeMediaItem(rItem);
  64 }
  65
  66 MediaChildWindow::MediaChildWindow(vcl::Window* pParent)
  67     : SystemChildWindow(pParent, WB_CLIPCHILDREN)
  68 {
  69 }
  70
  71 #if HAVE_FEATURE_GLTF
  72 MediaChildWindow::MediaChildWindow(vcl::Window* pParent, SystemWindowData* pData)
  73     : SystemChildWindow(pParent, WB_CLIPCHILDREN, pData)
  74 {
  75 }
  76 #endif
  77
  78 void MediaChildWindow::MouseMove( const MouseEvent& rMEvt )
  79 {
  80     const MouseEvent aTransformedEvent( GetParent()->ScreenToOutputPixel( OutputToScreenPixel( rMEvt.GetPosPixel() ) ),
  81                                           rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(), rMEvt.GetModifier() );
  82
  83     SystemChildWindow::MouseMove( rMEvt );
  84     GetParent()->MouseMove( aTransformedEvent );
  85 }
  86
  87 void MediaChildWindow::MouseButtonDown( const MouseEvent& rMEvt )
  88 {
  89     const MouseEvent aTransformedEvent( GetParent()->ScreenToOutputPixel( OutputToScreenPixel( rMEvt.GetPosPixel() ) ),
  90                                           rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(), rMEvt.GetModifier() );
  91
  92     SystemChildWindow::MouseButtonDown( rMEvt );
  93     GetParent()->MouseButtonDown( aTransformedEvent );
  94 }
  95
  96 void MediaChildWindow::MouseButtonUp( const MouseEvent& rMEvt )
  97 {
  98     const MouseEvent aTransformedEvent( GetParent()->ScreenToOutputPixel( OutputToScreenPixel( rMEvt.GetPosPixel() ) ),
  99                                           rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(), rMEvt.GetModifier() );
 100
 101     SystemChildWindow::MouseButtonUp( rMEvt );
 102     GetParent()->MouseButtonUp( aTransformedEvent );
 103 }
 104
 105 void MediaChildWindow::KeyInput( const KeyEvent& rKEvt )
 106 {
 107     SystemChildWindow::KeyInput( rKEvt );
 108     GetParent()->KeyInput( rKEvt );
 109 }
 110
 111 void MediaChildWindow::KeyUp( const KeyEvent& rKEvt )
 112 {
 113     SystemChildWindow::KeyUp( rKEvt );
 114     GetParent()->KeyUp( rKEvt );
 115 }
 116
 117 void MediaChildWindow::Command( const CommandEvent& rCEvt )
 118 {
 119     const CommandEvent aTransformedEvent( GetParent()->ScreenToOutputPixel( OutputToScreenPixel( rCEvt.GetMousePosPixel() ) ),
 120                                             rCEvt.GetCommand(), rCEvt.IsMouseEvent(), rCEvt.GetEventData() );
 121
 122     SystemChildWindow::Command( rCEvt );
 123     GetParent()->Command( aTransformedEvent );
 124 }
 125
 126 MediaWindowImpl::MediaWindowImpl(vcl::Window* pParent, MediaWindow* pMediaWindow, bool bInternalMediaControl)
 127     : Control(pParent)
 128     , DropTargetHelper(this)
 129     , DragSourceHelper(this)
 130     , mpMediaWindow(pMediaWindow)
 131     , mpEvents(nullptr)
 132     , mbEventTransparent(true)
 133     , mpMediaWindowControl(bInternalMediaControl ? VclPtr<MediaWindowControl>::Create(this) : nullptr)
 134     , mpEmptyBmpEx(nullptr)
 135     , mpAudioBmpEx(nullptr)
 136 {
 137     if (mpMediaWindowControl)
 138     {
 139         mpMediaWindowControl->SetSizePixel(mpMediaWindowControl->getMinSizePixel());
 140         mpMediaWindowControl->Show();
 141     }
 142 }
 143
 144 MediaWindowImpl::~MediaWindowImpl()
 145 {
 146     disposeOnce();
 147 }
 148
 149 void MediaWindowImpl::dispose()
 150 {
 151     if (mpEvents)
 152         mpEvents->cleanUp();
 153
 154     if (mxPlayerWindow.is())
 155     {
 156         mxPlayerWindow->removeKeyListener( uno::Reference< awt::XKeyListener >( mxEventsIf, uno::UNO_QUERY ) );
 157         mxPlayerWindow->removeMouseListener( uno::Reference< awt::XMouseListener >( mxEventsIf, uno::UNO_QUERY ) );
 158         mxPlayerWindow->removeMouseMotionListener( uno::Reference< awt::XMouseMotionListener >( mxEventsIf, uno::UNO_QUERY ) );
 159
 160         uno::Reference< lang::XComponent > xComponent( mxPlayerWindow, uno::UNO_QUERY );
 161         if (xComponent.is())
 162             xComponent->dispose();
 163
 164         mxPlayerWindow.clear();
 165     }
 166
 167     uno::Reference< lang::XComponent > xComponent( mxPlayer, uno::UNO_QUERY );
 168     if (xComponent.is()) // this stops the player
 169         xComponent->dispose();
 170
 171     mxPlayer.clear();
 172
 173     mpMediaWindow = NULL;
 174
 175     delete mpEmptyBmpEx;
 176     mpEmptyBmpEx = NULL;
 177     delete mpAudioBmpEx;
 178     mpAudioBmpEx = NULL;
 179     mpMediaWindowControl.disposeAndClear();
 180     mpChildWindow.disposeAndClear();
 181
 182     Control::dispose();
 183 }
 184
 185 uno::Reference<media::XPlayer> MediaWindowImpl::createPlayer(const OUString& rURL, const OUString& rReferer, const OUString* pMimeType)
 186 {
 187     uno::Reference<media::XPlayer> xPlayer;
 188
 189     if( rURL.isEmpty() )
 190         return xPlayer;
 191
 192     if (SvtSecurityOptions().isUntrustedReferer(rReferer))
 193     {
 194         return xPlayer;
 195     }
 196     uno::Reference<uno::XComponentContext> xContext(::comphelper::getProcessComponentContext());
 197
 198     if (!pMimeType || *pMimeType == AVMEDIA_MIMETYPE_COMMON)
 199     {
 200
 201         static const char * aServiceManagers[] =
 202         {
 203             AVMEDIA_MANAGER_SERVICE_PREFERRED,
 204             AVMEDIA_MANAGER_SERVICE_NAME,
 205 // a fallback path just for gstreamer which has
 206 // two significant versions deployed at once ...
 207 #ifdef AVMEDIA_MANAGER_SERVICE_NAME_OLD
 208             AVMEDIA_MANAGER_SERVICE_NAME_OLD
 209 #endif
 210 // fallback to AVMedia framework on OS X
 211 #ifdef AVMEDIA_MANAGER_SERVICE_NAME_FALLBACK1
 212             AVMEDIA_MANAGER_SERVICE_NAME_FALLBACK1
 213 #endif
 214         };
 215
 216         for (sal_uInt32 i = 0; !xPlayer.is() && i < SAL_N_ELEMENTS( aServiceManagers ); ++i)
 217         {
 218             const OUString aServiceName(aServiceManagers[i],
 219                                         strlen( aServiceManagers[i]),
 220                                         RTL_TEXTENCODING_ASCII_US);
 221
 222             xPlayer = createPlayer(rURL, aServiceName, xContext);
 223         }
 224     }
 225 #if HAVE_FEATURE_GLTF
 226     else if ( *pMimeType == AVMEDIA_MIMETYPE_JSON )
 227     {
 228         xPlayer = createPlayer(rURL, AVMEDIA_OPENGL_MANAGER_SERVICE_NAME, xContext);
 229     }
 230 #endif
 231
 232     return xPlayer;
 233 }
 234
 235 uno::Reference< media::XPlayer > MediaWindowImpl::createPlayer(
 236     const OUString& rURL, const OUString& rManagerServName,
 237     uno::Reference< uno::XComponentContext > xContext)
 238 {
 239     uno::Reference< media::XPlayer > xPlayer;
 240     try
 241     {
 242         uno::Reference< media::XManager > xManager (
 243             xContext->getServiceManager()->createInstanceWithContext(rManagerServName, xContext),
 244             uno::UNO_QUERY );
 245         if( xManager.is() )
 246             xPlayer = uno::Reference< media::XPlayer >( xManager->createPlayer( rURL ), uno::UNO_QUERY );
 247         else
 248             SAL_WARN( "avmedia", "failed to create media player service " << rManagerServName );
 249     } catch ( const uno::Exception &e )
 250     {
 251         SAL_WARN( "avmedia", "couldn't create media player " << rManagerServName
 252                               << ", exception '" << e.Message << '\'');
 253     }
 254     return xPlayer;
 255 }
 256
 257 void MediaWindowImpl::setURL( const OUString& rURL,
 258         OUString const& rTempURL, OUString const& rReferer)
 259 {
 260     maReferer = rReferer;
 261     if( rURL != getURL() )
 262     {
 263         if( mxPlayer.is() )
 264             mxPlayer->stop();
 265
 266         if( mxPlayerWindow.is() )
 267         {
 268             mxPlayerWindow->setVisible( false );
 269             mxPlayerWindow.clear();
 270         }
 271
 272         mxPlayer.clear();
 273         mTempFileURL.clear();
 274
 275         if (!rTempURL.isEmpty())
 276         {
 277             maFileURL = rURL;
 278             mTempFileURL = rTempURL;
 279         }
 280         else
 281         {
 282             INetURLObject aURL( rURL );
 283
 284             if (aURL.GetProtocol() != INetProtocol::NotValid)
 285                 maFileURL = aURL.GetMainURL(INetURLObject::DECODE_UNAMBIGUOUS);
 286             else
 287                 maFileURL = rURL;
 288         }
 289
 290         mxPlayer = createPlayer((!mTempFileURL.isEmpty()) ? mTempFileURL : maFileURL, rReferer, &m_sMimeType );
 291         onURLChanged();
 292     }
 293 }
 294
 295 const OUString& MediaWindowImpl::getURL() const
 296 {
 297     return maFileURL;
 298 }
 299
 300 bool MediaWindowImpl::isValid() const
 301 {
 302     return( mxPlayer.is() );
 303 }
 304
 305 Size MediaWindowImpl::getPreferredSize() const
 306 {
 307     Size aRet;
 308
 309     if( mxPlayer.is() )
 310     {
 311         awt::Size aPrefSize( mxPlayer->getPreferredPlayerWindowSize() );
 312
 313         aRet.Width() = aPrefSize.Width;
 314         aRet.Height() = aPrefSize.Height;
 315     }
 316
 317     return aRet;
 318 }
 319
 320 bool MediaWindowImpl::start()
 321 {
 322     return mxPlayer.is() && ( mxPlayer->start(), true );
 323 }
 324
 325 void MediaWindowImpl::updateMediaItem( MediaItem& rItem ) const
 326 {
 327     if( isPlaying() )
 328         rItem.setState( MEDIASTATE_PLAY );
 329     else
 330         rItem.setState( ( 0.0 == getMediaTime() ) ? MEDIASTATE_STOP : MEDIASTATE_PAUSE );
 331
 332     rItem.setDuration( getDuration() );
 333     rItem.setTime( getMediaTime() );
 334     rItem.setLoop( isPlaybackLoop() );
 335     rItem.setMute( isMute() );
 336     rItem.setVolumeDB( getVolumeDB() );
 337     rItem.setZoom( getZoom() );
 338     rItem.setURL( getURL(), mTempFileURL, maReferer );
 339 }
 340
 341 void MediaWindowImpl::executeMediaItem( const MediaItem& rItem )
 342 {
 343     const AVMediaSetMask nMaskSet = rItem.getMaskSet();
 344
 345     // set URL first
 346     if (nMaskSet & AVMediaSetMask::URL)
 347     {
 348         m_sMimeType = rItem.getMimeType();
 349         setURL(rItem.getURL(), rItem.getTempURL(), rItem.getReferer());
 350     }
 351
 352     // set different states next
 353     if (nMaskSet & AVMediaSetMask::TIME)
 354         setMediaTime(std::min(rItem.getTime(), getDuration()));
 355
 356     if (nMaskSet & AVMediaSetMask::LOOP)
 357         setPlaybackLoop(rItem.isLoop());
 358
 359     if (nMaskSet & AVMediaSetMask::MUTE)
 360         setMute(rItem.isMute());
 361
 362     if (nMaskSet & AVMediaSetMask::VOLUMEDB)
 363         setVolumeDB(rItem.getVolumeDB());
 364
 365     if (nMaskSet & AVMediaSetMask::ZOOM)
 366         setZoom(rItem.getZoom());
 367
 368     // set play state at last
 369     if (nMaskSet & AVMediaSetMask::STATE)
 370     {
 371         switch (rItem.getState())
 372         {
 373             case MEDIASTATE_PLAY:
 374             {
 375                 if (!isPlaying())
 376                     start();
 377             }
 378             break;
 379
 380             case MEDIASTATE_PAUSE:
 381             {
 382                 if (isPlaying())
 383                     stop();
 384             }
 385             break;
 386
 387             case MEDIASTATE_STOP:
 388             {
 389                 if (isPlaying())
 390                 {
 391                     setMediaTime( 0.0 );
 392                     stop();
 393                     setMediaTime( 0.0 );
 394                 }
 395             }
 396             break;
 397         }
 398     }
 399 }
 400
 401 bool MediaWindowImpl::setZoom(css::media::ZoomLevel eLevel)
 402 {
 403     return mxPlayerWindow.is() && mxPlayerWindow->setZoomLevel( eLevel );
 404 }
 405
 406 css::media::ZoomLevel MediaWindowImpl::getZoom() const
 407 {
 408     return( mxPlayerWindow.is() ? mxPlayerWindow->getZoomLevel() : media::ZoomLevel_NOT_AVAILABLE );
 409 }
 410
 411 void MediaWindowImpl::stop()
 412 {
 413     if( mxPlayer.is() )
 414         mxPlayer->stop();
 415 }
 416
 417 bool MediaWindowImpl::isPlaying() const
 418 {
 419     return( mxPlayer.is() && mxPlayer->isPlaying() );
 420 }
 421
 422 double MediaWindowImpl::getDuration() const
 423 {
 424     return( mxPlayer.is() ? mxPlayer->getDuration() : 0.0 );
 425 }
 426
 427 void MediaWindowImpl::setMediaTime( double fTime )
 428 {
 429     if( mxPlayer.is() )
 430         mxPlayer->setMediaTime( fTime );
 431 }
 432
 433 double MediaWindowImpl::getMediaTime() const
 434 {
 435     return( mxPlayer.is() ? mxPlayer->getMediaTime() : 0.0 );
 436 }
 437
 438 void MediaWindowImpl::setPlaybackLoop( bool bSet )
 439 {
 440     if( mxPlayer.is() )
 441         mxPlayer->setPlaybackLoop( bSet );
 442 }
 443
 444 bool MediaWindowImpl::isPlaybackLoop() const
 445 {
 446     return mxPlayer.is() && mxPlayer->isPlaybackLoop();
 447 }
 448
 449 void MediaWindowImpl::setMute( bool bSet )
 450 {
 451     if( mxPlayer.is() )
 452         mxPlayer->setMute( bSet );
 453 }
 454
 455 bool MediaWindowImpl::isMute() const
 456 {
 457     return mxPlayer.is() && mxPlayer->isMute();
 458 }
 459
 460 void MediaWindowImpl::setVolumeDB( sal_Int16 nVolumeDB )
 461 {
 462     if( mxPlayer.is() )
 463         mxPlayer->setVolumeDB( nVolumeDB );
 464 }
 465
 466 sal_Int16 MediaWindowImpl::getVolumeDB() const
 467 {
 468     return (mxPlayer.is() ? mxPlayer->getVolumeDB() : 0);
 469 }
 470
 471 void MediaWindowImpl::stopPlayingInternal(bool bStop)
 472 {
 473     if (isPlaying())
 474     {
 475         bStop ? mxPlayer->stop() : mxPlayer->start();
 476     }
 477 }
 478
 479 void MediaWindowImpl::onURLChanged()
 480 {
 481     if (m_sMimeType == AVMEDIA_MIMETYPE_COMMON)
 482     {
 483         mpChildWindow.disposeAndClear();
 484         mpChildWindow.reset(VclPtr<MediaChildWindow>::Create(this));
 485     }
 486 #if HAVE_FEATURE_GLTF
 487     else if (m_sMimeType == AVMEDIA_MIMETYPE_JSON)
 488     {
 489         SystemWindowData aWinData = OpenGLContext::generateWinData(this, false);
 490         mpChildWindow.disposeAndClear();
 491         mpChildWindow.reset(VclPtr<MediaChildWindow>::Create(this,&aWinData));
 492         mbEventTransparent = false;
 493     }
 494 #endif
 495     if (!mpChildWindow)
 496         return;
 497     mpChildWindow->SetHelpId(HID_AVMEDIA_PLAYERWINDOW);
 498     mxEventsIf.set(static_cast<cppu::OWeakObject*>(mpEvents = new MediaEventListenersImpl(*mpChildWindow.get())));
 499
 500     if (mxPlayer.is())
 501     {
 502         Resize();
 503         uno::Sequence<uno::Any> aArgs( 3 );
 504         uno::Reference<media::XPlayerWindow> xPlayerWindow;
 505         const Point aPoint;
 506         const Size aSize(mpChildWindow->GetSizePixel());
 507
 508         aArgs[0] = uno::makeAny(mpChildWindow->GetParentWindowHandle());
 509         aArgs[1] = uno::makeAny(awt::Rectangle(aPoint.X(), aPoint.Y(), aSize.Width(), aSize.Height()));
 510         aArgs[2] = uno::makeAny(reinterpret_cast<sal_IntPtr>(mpChildWindow.get()));
 511
 512         try
 513         {
 514             xPlayerWindow = mxPlayer->createPlayerWindow( aArgs );
 515         }
 516         catch( const uno::RuntimeException& )
 517         {
 518             // happens eg, on MacOSX where Java frames cannot be created from X11 window handles
 519         }
 520
 521         mxPlayerWindow = xPlayerWindow;
 522
 523         if( xPlayerWindow.is() )
 524         {
 525             xPlayerWindow->addKeyListener( uno::Reference< awt::XKeyListener >( mxEventsIf, uno::UNO_QUERY ) );
 526             xPlayerWindow->addMouseListener( uno::Reference< awt::XMouseListener >( mxEventsIf, uno::UNO_QUERY ) );
 527             xPlayerWindow->addMouseMotionListener( uno::Reference< awt::XMouseMotionListener >( mxEventsIf, uno::UNO_QUERY ) );
 528             xPlayerWindow->addFocusListener( uno::Reference< awt::XFocusListener >( mxEventsIf, uno::UNO_QUERY ) );
 529         }
 530     }
 531     else
 532         mxPlayerWindow.clear();
 533
 534     if( mxPlayerWindow.is() )
 535         mpChildWindow->Show();
 536     else
 537         mpChildWindow->Hide();
 538
 539     if( mpMediaWindowControl )
 540     {
 541         MediaItem aItem;
 542
 543         updateMediaItem( aItem );
 544         mpMediaWindowControl->setState( aItem );
 545     }
 546 }
 547
 548 void MediaWindowImpl::setPosSize(const Rectangle& rRect)
 549 {
 550     SetPosSizePixel(rRect.TopLeft(), rRect.GetSize());
 551 }
 552
 553 void MediaWindowImpl::setPointer(const Pointer& rPointer)
 554 {
 555     SetPointer(rPointer);
 556
 557     if (mpChildWindow)
 558         mpChildWindow->SetPointer(rPointer);
 559
 560     if (mxPlayerWindow.is())
 561     {
 562         long nPointer;
 563
 564         switch (rPointer.GetStyle())
 565         {
 566             case PointerStyle::Cross:
 567                 nPointer = awt::SystemPointer::CROSS;
 568                 break;
 569             case PointerStyle::Hand:
 570                 nPointer = awt::SystemPointer::HAND;
 571                 break;
 572             case PointerStyle::Move:
 573                 nPointer = awt::SystemPointer::MOVE;
 574                 break;
 575             case PointerStyle::Wait:
 576                 nPointer = awt::SystemPointer::WAIT;
 577                 break;
 578             default:
 579                 nPointer = awt::SystemPointer::ARROW;
 580                 break;
 581         }
 582
 583         mxPlayerWindow->setPointerType(nPointer);
 584     }
 585 }
 586
 587 void MediaWindowImpl::Resize()
 588 {
 589     const Size aCurSize(GetOutputSizePixel());
 590     const sal_Int32 nOffset(mpMediaWindowControl ? AVMEDIA_CONTROLOFFSET : 0);
 591
 592     Size aPlayerWindowSize(aCurSize.Width() - (nOffset << 1),
 593                            aCurSize.Height() - (nOffset << 1));
 594
 595     if (mpMediaWindowControl)
 596     {
 597         const sal_Int32 nControlHeight = mpMediaWindowControl->GetSizePixel().Height();
 598         const sal_Int32 nControlY = ::std::max(aCurSize.Height() - nControlHeight - nOffset, 0L);
 599
 600         aPlayerWindowSize.Height() = (nControlY - (nOffset << 1));
 601         mpMediaWindowControl->SetPosSizePixel(Point(nOffset, nControlY ), Size(aCurSize.Width() - (nOffset << 1), nControlHeight));
 602     }
 603     if (mpChildWindow)
 604         mpChildWindow->SetPosSizePixel(Point(0, 0), aPlayerWindowSize);
 605
 606     if (mxPlayerWindow.is())
 607         mxPlayerWindow->setPosSize(0, 0, aPlayerWindowSize.Width(), aPlayerWindowSize.Height(), 0);
 608 }
 609
 610 void MediaWindowImpl::StateChanged(StateChangedType eType)
 611 {
 612     if (mxPlayerWindow.is())
 613     {
 614         // stop playing when going disabled or hidden
 615         switch (eType)
 616         {
 617             case StateChangedType::Visible:
 618             {
 619                 stopPlayingInternal(!IsVisible());
 620                 mxPlayerWindow->setVisible(IsVisible());
 621             }
 622             break;
 623
 624             case StateChangedType::Enable:
 625             {
 626                 stopPlayingInternal(!IsEnabled());
 627                 mxPlayerWindow->setEnable(IsEnabled());
 628             }
 629             break;
 630
 631             default:
 632             break;
 633         }
 634     }
 635 }
 636
 637 void MediaWindowImpl::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
 638 {
 639     if (mxPlayerWindow.is())
 640         mxPlayerWindow->update();
 641
 642     BitmapEx* pLogo = NULL;
 643
 644     if (!mxPlayer.is())
 645     {
 646         if (!mpEmptyBmpEx)
 647             mpEmptyBmpEx = new BitmapEx(AVMEDIA_RESID(AVMEDIA_BMP_EMPTYLOGO));
 648
 649         pLogo = mpEmptyBmpEx;
 650     }
 651     else if (!mxPlayerWindow.is())
 652     {
 653         if (!mpAudioBmpEx)
 654             mpAudioBmpEx = new BitmapEx(AVMEDIA_RESID(AVMEDIA_BMP_AUDIOLOGO));
 655
 656         pLogo = mpAudioBmpEx;
 657     }
 658
 659     if (!mpChildWindow)
 660         return;
 661
 662     const Point aBasePos(mpChildWindow->GetPosPixel());
 663     const Rectangle aVideoRect(aBasePos, mpChildWindow->GetSizePixel());
 664
 665     if (pLogo && !pLogo->IsEmpty() && (aVideoRect.GetWidth() > 0) && (aVideoRect.GetHeight() > 0))
 666     {
 667         Size aLogoSize(pLogo->GetSizePixel());
 668         const Color aBackgroundColor(67, 67, 67);
 669
 670         rRenderContext.SetLineColor(aBackgroundColor);
 671         rRenderContext.SetFillColor(aBackgroundColor);
 672         rRenderContext.DrawRect(aVideoRect);
 673
 674         if ((aLogoSize.Width() > aVideoRect.GetWidth() || aLogoSize.Height() > aVideoRect.GetHeight() ) &&
 675             (aLogoSize.Height() > 0))
 676         {
 677             const double fLogoWH = double(aLogoSize.Width()) / aLogoSize.Height();
 678
 679             if (fLogoWH < (double(aVideoRect.GetWidth()) / aVideoRect.GetHeight()))
 680             {
 681                 aLogoSize.Width() = long(aVideoRect.GetHeight() * fLogoWH);
 682                 aLogoSize.Height() = aVideoRect.GetHeight();
 683             }
 684             else
 685             {
 686                 aLogoSize.Width() = aVideoRect.GetWidth();
 687                 aLogoSize.Height()= long(aVideoRect.GetWidth() / fLogoWH);
 688             }
 689         }
 690
 691         Point aPoint(aBasePos.X() + ((aVideoRect.GetWidth() - aLogoSize.Width()) >> 1),
 692                      aBasePos.Y() + ((aVideoRect.GetHeight() - aLogoSize.Height()) >> 1));
 693
 694         rRenderContext.DrawBitmapEx(aPoint, aLogoSize, *pLogo);
 695     }
 696 }
 697
 698 void MediaWindowImpl::GetFocus()
 699 {
 700 }
 701
 702 void MediaWindowImpl::MouseMove(const MouseEvent& rMEvt)
 703 {
 704     if (mpMediaWindow && mbEventTransparent)
 705         mpMediaWindow->MouseMove(rMEvt);
 706 }
 707
 708 void MediaWindowImpl::MouseButtonDown(const MouseEvent& rMEvt)
 709 {
 710     if (mpMediaWindow && mbEventTransparent)
 711         mpMediaWindow->MouseButtonDown(rMEvt);
 712 }
 713
 714 void MediaWindowImpl::MouseButtonUp(const MouseEvent& rMEvt)
 715 {
 716     if (mpMediaWindow && mbEventTransparent)
 717         mpMediaWindow->MouseButtonUp(rMEvt);
 718 }
 719
 720 void MediaWindowImpl::KeyInput(const KeyEvent& rKEvt)
 721 {
 722     if (mpMediaWindow && mbEventTransparent)
 723         mpMediaWindow->KeyInput(rKEvt);
 724 }
 725
 726 void MediaWindowImpl::KeyUp(const KeyEvent& rKEvt)
 727 {
 728     if (mpMediaWindow && mbEventTransparent)
 729         mpMediaWindow->KeyUp(rKEvt);
 730 }
 731
 732 void MediaWindowImpl::Command(const CommandEvent& rCEvt)
 733 {
 734     if (mpMediaWindow && mbEventTransparent)
 735         mpMediaWindow->Command(rCEvt);
 736 }
 737
 738 sal_Int8 MediaWindowImpl::AcceptDrop(const AcceptDropEvent& rEvt)
 739 {
 740     return (mpMediaWindow && mbEventTransparent ? mpMediaWindow->AcceptDrop(rEvt) : 0);
 741 }
 742
 743 sal_Int8 MediaWindowImpl::ExecuteDrop(const ExecuteDropEvent& rEvt)
 744 {
 745     return (mpMediaWindow && mbEventTransparent ? mpMediaWindow->ExecuteDrop(rEvt) : 0);
 746 }
 747
 748 void MediaWindowImpl::StartDrag(sal_Int8 nAction, const Point& rPosPixel)
 749 {
 750     if (mpMediaWindow && mbEventTransparent)
 751         mpMediaWindow->StartDrag(nAction, rPosPixel);
 752 }
 753
 754 } // namespace priv
 755 } // namespace avmedia
 756
 757 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */