avmedia/source/viewer/mediawindow.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 <avmedia/mediawindow.hxx>
  21 #include "mediawindow_impl.hxx"
  22 #include "mediamisc.hxx"
  23 #include "bitmaps.hlst"
  24 #include "mediawindow.hrc"
  25 #include <tools/urlobj.hxx>
  26 #include <vcl/layout.hxx>
  27 #include <unotools/pathoptions.hxx>
  28 #include <sfx2/filedlghelper.hxx>
  29 #include <comphelper/processfactory.hxx>
  30 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  31 #include <com/sun/star/media/XManager.hpp>
  32 #include "com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp"
  33 #include "com/sun/star/ui/dialogs/TemplateDescription.hpp"
  34 #include "com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp"
  35 #include <memory>
  36
  37 #define AVMEDIA_FRAMEGRABBER_DEFAULTFRAME_MEDIATIME 3.0
  38
  39 using namespace ::com::sun::star;
  40
  41 namespace avmedia {
  42
  43 MediaWindow::MediaWindow( vcl::Window* parent, bool bInternalMediaControl ) :
  44     mpImpl( VclPtr<priv::MediaWindowImpl>::Create( parent, this, bInternalMediaControl ) )
  45 {
  46     mpImpl->Show();
  47 }
  48
  49
  50 MediaWindow::~MediaWindow()
  51 {
  52     mpImpl.disposeAndClear();
  53 }
  54
  55
  56 void MediaWindow::setURL( const OUString& rURL, const OUString& rReferer )
  57 {
  58     mpImpl->setURL( rURL, OUString(), rReferer );
  59 }
  60
  61
  62 const OUString& MediaWindow::getURL() const
  63 {
  64     return mpImpl->getURL();
  65 }
  66
  67
  68 bool MediaWindow::isValid() const
  69 {
  70     return mpImpl->isValid();
  71 }
  72
  73
  74 void MediaWindow::MouseMove( const MouseEvent& )
  75 {
  76 }
  77
  78
  79 void MediaWindow::MouseButtonDown( const MouseEvent& )
  80 {
  81 }
  82
  83
  84 void MediaWindow::MouseButtonUp( const MouseEvent& )
  85 {
  86 }
  87
  88
  89 void MediaWindow::KeyInput( const KeyEvent& )
  90 {
  91 }
  92
  93
  94 void MediaWindow::KeyUp( const KeyEvent& )
  95 {
  96 }
  97
  98 void MediaWindow::Command( const CommandEvent& )
  99 {
 100 }
 101
 102
 103 sal_Int8 MediaWindow::AcceptDrop( const AcceptDropEvent& )
 104 {
 105     return 0;
 106 }
 107
 108
 109 sal_Int8 MediaWindow::ExecuteDrop( const ExecuteDropEvent& )
 110 {
 111     return 0;
 112 }
 113
 114
 115 void MediaWindow::StartDrag( sal_Int8, const Point& )
 116 {
 117 }
 118
 119
 120 Size MediaWindow::getPreferredSize() const
 121 {
 122     return mpImpl->getPreferredSize();
 123 }
 124
 125
 126 void MediaWindow::setPosSize( const tools::Rectangle& rNewRect )
 127 {
 128     mpImpl->setPosSize( rNewRect );
 129 }
 130
 131
 132 void MediaWindow::setPointer( const Pointer& rPointer )
 133 {
 134     mpImpl->setPointer( rPointer );
 135 }
 136
 137
 138 bool MediaWindow::start()
 139 {
 140     return mpImpl->start();
 141 }
 142
 143
 144 void MediaWindow::updateMediaItem( MediaItem& rItem ) const
 145 {
 146     mpImpl->updateMediaItem( rItem );
 147 }
 148
 149
 150 void MediaWindow::executeMediaItem( const MediaItem& rItem )
 151 {
 152     mpImpl->executeMediaItem( rItem );
 153 }
 154
 155
 156 void MediaWindow::show()
 157 {
 158     mpImpl->Show();
 159 }
 160
 161
 162 void MediaWindow::hide()
 163 {
 164     mpImpl->Hide();
 165 }
 166
 167
 168 vcl::Window* MediaWindow::getWindow() const
 169 {
 170     return mpImpl.get();
 171 }
 172
 173
 174 void MediaWindow::getMediaFilters( FilterNameVector& rFilterNameVector )
 175 {
 176     static const char* pFilters[] = { "Advanced Audio Coding", "aac",
 177                                       "AIF Audio", "aif;aiff",
 178                                       "Advanced Systems Format", "asf;wma;wmv",
 179                                       "AU Audio", "au",
 180                                       "AC3 Audio", "ac3",
 181                                       "AVI", "avi",
 182                                       "CD Audio", "cda",
 183                                       "Digital Video", "dv",
 184                                       "FLAC Audio", "flac",
 185                                       "Flash Video", "flv",
 186                                       "Matroska Media", "mkv",
 187                                       "MIDI Audio", "mid;midi",
 188                                       "MPEG Audio", "mp2;mp3;mpa;m4a",
 189                                       "MPEG Video", "mpg;mpeg;mpv;mp4;m4v",
 190                                       "Ogg Audio", "ogg;oga;opus",
 191                                       "Ogg Video", "ogv;ogx",
 192                                       "Real Audio", "ra",
 193                                       "Real Media", "rm",
 194                                       "RMI MIDI Audio", "rmi",
 195                                       "SND (SouND) Audio", "snd",
 196                                       "Quicktime Video", "mov",
 197                                       "Vivo Video", "viv",
 198                                       "WAVE Audio", "wav",
 199                                       "WebM Video", "webm",
 200                                       "Windows Media Audio", "wma",
 201                                       "Windows Media Video", "wmv"};
 202
 203     for( size_t i = 0; i < SAL_N_ELEMENTS(pFilters); i += 2 )
 204     {
 205         rFilterNameVector.push_back( std::make_pair< OUString, OUString >(
 206                                         OUString::createFromAscii(pFilters[i]),
 207                                         OUString::createFromAscii(pFilters[i+1]) ) );
 208     }
 209 }
 210
 211
 212 bool MediaWindow::executeMediaURLDialog(OUString& rURL, bool *const o_pbLink)
 213 {
 214     ::sfx2::FileDialogHelper        aDlg( o_pbLink
 215             ? ui::dialogs::TemplateDescription::FILEOPEN_LINK_PREVIEW
 216             : ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE );
 217     static const char               aWildcard[] = "*.";
 218     FilterNameVector                aFilters;
 219     static const char               aSeparator[] = ";";
 220     OUString                        aAllTypes;
 221
 222     aDlg.SetTitle( AvmResId( (o_pbLink)
 223                 ? AVMEDIA_STR_INSERTMEDIA_DLG : AVMEDIA_STR_OPENMEDIA_DLG ) );
 224
 225     getMediaFilters( aFilters );
 226
 227     for( FilterNameVector::size_type i = 0; i < aFilters.size(); ++i )
 228     {
 229         for( sal_Int32 nIndex = 0; nIndex >= 0; )
 230         {
 231             if( !aAllTypes.isEmpty() )
 232                 aAllTypes += aSeparator;
 233
 234             ( aAllTypes += aWildcard ) += aFilters[ i ].second.getToken( 0, ';', nIndex );
 235         }
 236     }
 237
 238     // add filter for all media types
 239     aDlg.AddFilter( AvmResId( AVMEDIA_STR_ALL_MEDIAFILES ), aAllTypes );
 240
 241     for( FilterNameVector::size_type i = 0; i < aFilters.size(); ++i )
 242     {
 243         OUString aTypes;
 244
 245         for( sal_Int32 nIndex = 0; nIndex >= 0; )
 246         {
 247             if( !aTypes.isEmpty() )
 248                 aTypes += aSeparator;
 249
 250             ( aTypes += aWildcard ) += aFilters[ i ].second.getToken( 0, ';', nIndex );
 251         }
 252
 253         // add single filters
 254         aDlg.AddFilter( aFilters[ i ].first, aTypes );
 255     }
 256
 257     // add filter for all types
 258     aDlg.AddFilter( AvmResId( AVMEDIA_STR_ALL_FILES ), "*.*" );
 259
 260     uno::Reference<ui::dialogs::XFilePicker2> const xFP(aDlg.GetFilePicker());
 261     uno::Reference<ui::dialogs::XFilePickerControlAccess> const xCtrlAcc(xFP,
 262             uno::UNO_QUERY_THROW);
 263     if (o_pbLink)
 264     {
 265         // for video link should be the default
 266         xCtrlAcc->setValue(
 267                 ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_LINK, 0,
 268                 uno::Any(true) );
 269         // disabled for now: TODO: preview?
 270         xCtrlAcc->enableControl(
 271                 ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_PREVIEW,
 272                 false);
 273     }
 274
 275     if( aDlg.Execute() == ERRCODE_NONE )
 276     {
 277         const INetURLObject aURL( aDlg.GetPath() );
 278         rURL = aURL.GetMainURL( INetURLObject::DecodeMechanism::Unambiguous );
 279
 280         if (o_pbLink)
 281         {
 282             uno::Any const any = xCtrlAcc->getValue(
 283                 ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_LINK, 0);
 284             if (!(any >>= *o_pbLink))
 285             {
 286                 SAL_WARN("avmedia", "invalid link property");
 287                 *o_pbLink = true;
 288             }
 289         }
 290     }
 291     else if( !rURL.isEmpty() )
 292         rURL.clear();
 293
 294     return !rURL.isEmpty();
 295 }
 296
 297
 298 void MediaWindow::executeFormatErrorBox( vcl::Window* pParent )
 299 {
 300     ScopedVclPtrInstance< MessageDialog > aErrBox( pParent, AvmResId( AVMEDIA_STR_ERR_URL ) );
 301
 302     aErrBox->Execute();
 303     aErrBox.disposeAndClear();
 304 }
 305
 306
 307 bool MediaWindow::isMediaURL( const OUString& rURL, const OUString& rReferer, bool bDeep, Size* pPreferredSizePixel )
 308 {
 309     const INetURLObject aURL( rURL );
 310     bool                bRet = false;
 311
 312     if( aURL.GetProtocol() != INetProtocol::NotValid )
 313     {
 314         if( bDeep || pPreferredSizePixel )
 315         {
 316             try
 317             {
 318                 uno::Reference< media::XPlayer > xPlayer( priv::MediaWindowImpl::createPlayer(
 319                                                             aURL.GetMainURL( INetURLObject::DecodeMechanism::Unambiguous ),
 320                                                             rReferer, nullptr ) );
 321
 322                 if( xPlayer.is() )
 323                 {
 324                     bRet = true;
 325
 326                     if( pPreferredSizePixel )
 327                     {
 328                         const awt::Size aAwtSize( xPlayer->getPreferredPlayerWindowSize() );
 329
 330                         pPreferredSizePixel->Width() = aAwtSize.Width;
 331                         pPreferredSizePixel->Height() = aAwtSize.Height;
 332                     }
 333                 }
 334             }
 335             catch( ... )
 336             {
 337             }
 338         }
 339         else
 340         {
 341             FilterNameVector        aFilters;
 342             const OUString          aExt( aURL.getExtension() );
 343
 344             getMediaFilters( aFilters );
 345
 346             for( FilterNameVector::size_type i = 0; ( i < aFilters.size() ) && !bRet; ++i )
 347             {
 348                 for( sal_Int32 nIndex = 0; nIndex >= 0 && !bRet; )
 349                 {
 350                     if( aExt.equalsIgnoreAsciiCase( aFilters[ i ].second.getToken( 0, ';', nIndex ) ) )
 351                         bRet = true;
 352                 }
 353             }
 354         }
 355     }
 356
 357     return bRet;
 358 }
 359
 360
 361 uno::Reference< media::XPlayer > MediaWindow::createPlayer( const OUString& rURL, const OUString& rReferer, const OUString* pMimeType )
 362 {
 363     return priv::MediaWindowImpl::createPlayer( rURL, rReferer, pMimeType );
 364 }
 365
 366
 367 uno::Reference< graphic::XGraphic > MediaWindow::grabFrame( const OUString& rURL,
 368                                                             const OUString& rReferer,
 369                                                             const OUString& sMimeType )
 370 {
 371     uno::Reference< media::XPlayer >    xPlayer( createPlayer( rURL, rReferer, &sMimeType ) );
 372     uno::Reference< graphic::XGraphic > xRet;
 373     std::unique_ptr< Graphic > xGraphic;
 374
 375     if( xPlayer.is() )
 376     {
 377         uno::Reference< media::XFrameGrabber > xGrabber( xPlayer->createFrameGrabber() );
 378
 379         if( xGrabber.is() )
 380         {
 381             double fMediaTime = AVMEDIA_FRAMEGRABBER_DEFAULTFRAME_MEDIATIME;
 382
 383             if( fMediaTime >= xPlayer->getDuration() )
 384                 fMediaTime = ( xPlayer->getDuration() * 0.5 );
 385
 386             xRet = xGrabber->grabFrame( fMediaTime );
 387         }
 388
 389         if( !xRet.is() )
 390         {
 391             awt::Size aPrefSize( xPlayer->getPreferredPlayerWindowSize() );
 392
 393             if( !aPrefSize.Width && !aPrefSize.Height )
 394             {
 395                 const BitmapEx aBmpEx(AVMEDIA_BMP_AUDIOLOGO);
 396                 xGraphic.reset( new Graphic( aBmpEx ) );
 397             }
 398         }
 399     }
 400
 401     if( !xRet.is() && !xGraphic.get() )
 402     {
 403         const BitmapEx aBmpEx(AVMEDIA_BMP_EMPTYLOGO);
 404         xGraphic.reset( new Graphic( aBmpEx ) );
 405     }
 406
 407     if( xGraphic.get() )
 408         xRet = xGraphic->GetXGraphic();
 409
 410     return xRet;
 411 }
 412
 413
 414 } // namespace avmedia
 415
 416 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */