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