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