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