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