fpicker/source/office/OfficeFilePicker.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
  21 #include "OfficeFilePicker.hxx"
  22 #include "iodlg.hxx"
  23 #include "RemoteFilesDialog.hxx"
  24
  25 #include <list>
  26 #include <functional>
  27 #include <algorithm>
  28 #include <tools/urlobj.hxx>
  29 #include <com/sun/star/uno/Any.hxx>
  30 #include <com/sun/star/ui/dialogs/FilePickerEvent.hpp>
  31 #include <com/sun/star/ui/dialogs/FilePreviewImageFormats.hpp>
  32 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
  33 #include <com/sun/star/beans/PropertyValue.hpp>
  34 #include <com/sun/star/beans/XPropertySet.hpp>
  35 #include <com/sun/star/awt/XWindow.hpp>
  36 #include <com/sun/star/beans/StringPair.hpp>
  37 #include <com/sun/star/uno/Sequence.hxx>
  38 #include <com/sun/star/beans/NamedValue.hpp>
  39 #include <unotools/ucbhelper.hxx>
  40 #include <unotools/pathoptions.hxx>
  41 #include <comphelper/sequence.hxx>
  42 #include <cppuhelper/supportsservice.hxx>
  43 #include <cppuhelper/typeprovider.hxx>
  44 #include "osl/mutex.hxx"
  45 #include <vcl/svapp.hxx>
  46
  47 using namespace     ::com::sun::star::container;
  48 using namespace     ::com::sun::star::lang;
  49 using namespace     ::com::sun::star::ui::dialogs;
  50 using namespace     ::com::sun::star::uno;
  51 using namespace     ::com::sun::star::beans;
  52 using namespace     ::com::sun::star::awt;
  53 using namespace     ::utl;
  54
  55
  56 struct FilterEntry
  57 {
  58 protected:
  59     OUString     m_sTitle;
  60     OUString     m_sFilter;
  61
  62     UnoFilterList       m_aSubFilters;
  63
  64 public:
  65     FilterEntry( const OUString& _rTitle, const OUString& _rFilter )
  66         :m_sTitle( _rTitle )
  67         ,m_sFilter( _rFilter )
  68     {
  69     }
  70
  71     FilterEntry( const OUString& _rTitle, const UnoFilterList& _rSubFilters );
  72
  73     const OUString& getTitle() const { return m_sTitle; }
  74     const OUString& getFilter() const { return m_sFilter; }
  75
  76     /// determines if the filter has sub filter (i.e., the filter is a filter group in real)
  77     bool            hasSubFilters( ) const;
  78
  79     /** retrieves the filters belonging to the entry
  80     */
  81     void            getSubFilters( UnoFilterList& _rSubFilterList );
  82
  83     // helpers for iterating the sub filters
  84     const UnoFilterEntry*   beginSubFilters() const { return m_aSubFilters.getConstArray(); }
  85     const UnoFilterEntry*   endSubFilters() const { return m_aSubFilters.getConstArray() + m_aSubFilters.getLength(); }
  86 };
  87
  88
  89 FilterEntry::FilterEntry( const OUString& _rTitle, const UnoFilterList& _rSubFilters )
  90     :m_sTitle( _rTitle )
  91     ,m_aSubFilters( _rSubFilters )
  92 {
  93 }
  94
  95
  96 bool FilterEntry::hasSubFilters( ) const
  97 {
  98     return ( 0 < m_aSubFilters.getLength() );
  99 }
 100
 101
 102 void FilterEntry::getSubFilters( UnoFilterList& _rSubFilterList )
 103 {
 104     _rSubFilterList = m_aSubFilters;
 105 }
 106
 107 struct ElementEntry_Impl
 108 {
 109     sal_Int16       m_nElementID;
 110     sal_Int16       m_nControlAction;
 111     Any         m_aValue;
 112     OUString       m_aLabel;
 113     bool        m_bEnabled      : 1;
 114
 115     bool        m_bHasValue     : 1;
 116     bool        m_bHasLabel     : 1;
 117     bool        m_bHasEnabled   : 1;
 118
 119     explicit        ElementEntry_Impl( sal_Int16 nId );
 120
 121     void            setValue( const Any& rVal ) { m_aValue = rVal; m_bHasValue = true; }
 122     void            setAction( sal_Int16 nAction ) { m_nControlAction = nAction; }
 123     void            setLabel( const OUString& rVal ) { m_aLabel = rVal; m_bHasLabel = true; }
 124     void            setEnabled( bool bEnabled ) { m_bEnabled = bEnabled; m_bHasEnabled = true; }
 125 };
 126
 127 ElementEntry_Impl::ElementEntry_Impl( sal_Int16 nId )
 128     : m_nElementID( nId )
 129     , m_nControlAction( 0 )
 130     , m_bEnabled( false )
 131     , m_bHasValue( false )
 132     , m_bHasLabel( false )
 133     , m_bHasEnabled( false )
 134 {}
 135
 136
 137 void SvtFilePicker::prepareExecute()
 138 {
 139     // set the default directory
 140     // --**-- doesn't match the spec yet
 141     if ( !m_aDisplayDirectory.isEmpty() || !m_aDefaultName.isEmpty() )
 142     {
 143         bool isFileSet = false;
 144         if ( !m_aDisplayDirectory.isEmpty() )
 145         {
 146
 147             INetURLObject aPath;
 148             INetURLObject givenPath( m_aDisplayDirectory );
 149             if (!givenPath.HasError())
 150                 aPath = givenPath;
 151             else
 152             {
 153                 INetURLObject aStdDirObj( SvtPathOptions().GetWorkPath() );
 154                 aPath = aStdDirObj;
 155             }
 156             if ( !m_aDefaultName.isEmpty() )
 157             {
 158                 aPath.insertName( m_aDefaultName );
 159                 getDialog()->SetHasFilename( true );
 160             }
 161             getDialog()->SetPath( aPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
 162             isFileSet = true;
 163         }
 164         if ( !isFileSet && !m_aDefaultName.isEmpty() )
 165         {
 166             getDialog()->SetPath( m_aDefaultName );
 167             getDialog()->SetHasFilename( true );
 168         }
 169     }
 170     else
 171     {
 172         // Default-Standard-Dir setzen
 173         INetURLObject aStdDirObj( SvtPathOptions().GetWorkPath() );
 174         getDialog()->SetPath( aStdDirObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
 175     }
 176
 177     // set the control values and set the control labels, too
 178     if ( m_pElemList && !m_pElemList->empty() )
 179     {
 180         ::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
 181
 182         ElementList::iterator aListIter;
 183         for ( aListIter = m_pElemList->begin();
 184               aListIter != m_pElemList->end(); ++aListIter )
 185         {
 186             ElementEntry_Impl& rEntry = *aListIter;
 187             if ( rEntry.m_bHasValue )
 188                 aAccess.setValue( rEntry.m_nElementID, rEntry.m_nControlAction, rEntry.m_aValue );
 189             if ( rEntry.m_bHasLabel )
 190                 aAccess.setLabel( rEntry.m_nElementID, rEntry.m_aLabel );
 191             if ( rEntry.m_bHasEnabled )
 192                 aAccess.enableControl( rEntry.m_nElementID, rEntry.m_bEnabled );
 193         }
 194
 195     }
 196
 197     if ( m_pFilterList && !m_pFilterList->empty() )
 198     {
 199         for (   FilterList::iterator aListIter = m_pFilterList->begin();
 200                 aListIter != m_pFilterList->end();
 201                 ++aListIter
 202             )
 203         {
 204             if ( aListIter->hasSubFilters() )
 205             {   // it's a filter group
 206                 UnoFilterList aSubFilters;
 207                 aListIter->getSubFilters( aSubFilters );
 208
 209                 getDialog()->AddFilterGroup( aListIter->getTitle(), aSubFilters );
 210              }
 211             else
 212                 // it's a single filter
 213                 getDialog()->AddFilter( aListIter->getTitle(), aListIter->getFilter() );
 214         }
 215     }
 216
 217     // set the default filter
 218     if ( !m_aCurrentFilter.isEmpty() )
 219         getDialog()->SetCurFilter( m_aCurrentFilter );
 220
 221 }
 222
 223
 224 IMPL_LINK( SvtFilePicker, DialogClosedHdl, Dialog&, rDlg, void )
 225 {
 226     if ( m_xDlgClosedListener.is() )
 227     {
 228         sal_Int16 nRet = static_cast< sal_Int16 >( rDlg.GetResult() );
 229         css::ui::dialogs::DialogClosedEvent aEvent( *this, nRet );
 230         m_xDlgClosedListener->dialogClosed( aEvent );
 231         m_xDlgClosedListener.clear();
 232     }
 233 }
 234
 235
 236 // SvtFilePicker
 237
 238
 239 PickerFlags SvtFilePicker::getPickerFlags()
 240 {
 241     // set the winbits for creating the filedialog
 242     PickerFlags nBits = PickerFlags::NONE;
 243
 244     // set the standard bits according to the service name
 245     if ( m_nServiceType == TemplateDescription::FILEOPEN_SIMPLE )
 246     {
 247         nBits = PickerFlags::Open;
 248     }
 249     else if ( m_nServiceType == TemplateDescription::FILESAVE_SIMPLE )
 250     {
 251         nBits = PickerFlags::SaveAs;
 252     }
 253     else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION )
 254     {
 255         nBits = PickerFlags::SaveAs | PickerFlags::AutoExtension;
 256     }
 257     else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD )
 258     {
 259         nBits = PickerFlags::SaveAs | PickerFlags::Password | PickerFlags::AutoExtension;
 260     }
 261     else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS )
 262     {
 263         nBits = PickerFlags::SaveAs | PickerFlags::Password | PickerFlags::AutoExtension | PickerFlags::FilterOptions;
 264     }
 265     else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_TEMPLATE )
 266     {
 267         nBits = PickerFlags::SaveAs | PickerFlags::AutoExtension | PickerFlags::Templates;
 268     }
 269     else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_SELECTION )
 270     {
 271         nBits = PickerFlags::SaveAs | PickerFlags::AutoExtension | PickerFlags::Selection;
 272     }
 273
 274     else if ( m_nServiceType == TemplateDescription::FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE )
 275     {
 276         nBits = PickerFlags::Open | PickerFlags::InsertAsLink | PickerFlags::ShowPreview | PickerFlags::ImageTemplate;
 277     }
 278     else if ( m_nServiceType == TemplateDescription::FILEOPEN_PLAY )
 279     {
 280         nBits = PickerFlags::Open | PickerFlags::PlayButton;
 281     }
 282     else if ( m_nServiceType == TemplateDescription::FILEOPEN_LINK_PLAY )
 283     {
 284         nBits = PickerFlags::Open | PickerFlags::InsertAsLink | PickerFlags::PlayButton;
 285     }
 286     else if ( m_nServiceType == TemplateDescription::FILEOPEN_READONLY_VERSION )
 287     {
 288         nBits = PickerFlags::Open | PickerFlags::ReadOnly | PickerFlags::ShowVersions;
 289     }
 290     else if ( m_nServiceType == TemplateDescription::FILEOPEN_LINK_PREVIEW )
 291     {
 292         nBits = PickerFlags::Open | PickerFlags::InsertAsLink | PickerFlags::ShowPreview;
 293     }
 294     else if ( m_nServiceType == TemplateDescription::FILEOPEN_PREVIEW )
 295     {
 296         nBits = PickerFlags::Open | PickerFlags::ShowPreview;
 297     }
 298     if ( m_bMultiSelection && ( nBits & PickerFlags::Open ) )
 299         nBits |= PickerFlags::MultiSelection;
 300
 301     return nBits;
 302 }
 303
 304
 305 void SvtFilePicker::notify( sal_Int16 _nEventId, sal_Int16 _nControlId )
 306 {
 307     if ( !m_xListener.is() )
 308         return;
 309
 310     FilePickerEvent aEvent( *this, _nControlId );
 311
 312     switch ( _nEventId )
 313     {
 314         case FILE_SELECTION_CHANGED:
 315             m_xListener->fileSelectionChanged( aEvent );
 316             break;
 317         case DIRECTORY_CHANGED:
 318             m_xListener->directoryChanged( aEvent );
 319             break;
 320         case CTRL_STATE_CHANGED:
 321             m_xListener->controlStateChanged( aEvent );
 322             break;
 323         case DIALOG_SIZE_CHANGED:
 324             m_xListener->dialogSizeChanged();
 325             break;
 326         default:
 327             SAL_WARN( "fpicker.office", "SvtFilePicker::notify(): Unknown event id!" );
 328             break;
 329     }
 330 }
 331
 332
 333 namespace {
 334
 335     struct FilterTitleMatch : public ::std::unary_function< FilterEntry, bool >
 336     {
 337     protected:
 338         const OUString& rTitle;
 339
 340     public:
 341         explicit FilterTitleMatch( const OUString& _rTitle ) : rTitle( _rTitle ) { }
 342
 343
 344         bool operator () ( const FilterEntry& _rEntry )
 345         {
 346             bool bMatch;
 347             if ( !_rEntry.hasSubFilters() )
 348                 // a real filter
 349                 bMatch = ( _rEntry.getTitle() == rTitle );
 350             else
 351                 // a filter group -> search the sub filters
 352                 bMatch =
 353                     ::std::any_of(
 354                         _rEntry.beginSubFilters(),
 355                         _rEntry.endSubFilters(),
 356                         *this
 357                     );
 358
 359             return bMatch;
 360         }
 361         bool operator () ( const UnoFilterEntry& _rEntry )
 362         {
 363             return _rEntry.First == rTitle;
 364         }
 365     };
 366 }
 367
 368
 369 bool SvtFilePicker::FilterNameExists( const OUString& rTitle )
 370 {
 371     bool bRet = false;
 372
 373     if ( m_pFilterList )
 374         bRet =
 375             ::std::any_of(
 376                 m_pFilterList->begin(),
 377                 m_pFilterList->end(),
 378                 FilterTitleMatch( rTitle )
 379             );
 380
 381     return bRet;
 382 }
 383
 384
 385 bool SvtFilePicker::FilterNameExists( const UnoFilterList& _rGroupedFilters )
 386 {
 387     bool bRet = false;
 388
 389     if ( m_pFilterList )
 390     {
 391         const UnoFilterEntry* pStart = _rGroupedFilters.getConstArray();
 392         const UnoFilterEntry* pEnd = pStart + _rGroupedFilters.getLength();
 393         for ( ; pStart != pEnd; ++pStart )
 394             if ( ::std::any_of( m_pFilterList->begin(), m_pFilterList->end(), FilterTitleMatch( pStart->First ) ) )
 395                 break;
 396
 397         bRet = pStart != pEnd;
 398     }
 399
 400     return bRet;
 401 }
 402
 403
 404 void SvtFilePicker::ensureFilterList( const OUString& _rInitialCurrentFilter )
 405 {
 406     if ( !m_pFilterList )
 407     {
 408         m_pFilterList = new FilterList;
 409
 410         // set the first filter to the current filter
 411         if ( m_aCurrentFilter.isEmpty() )
 412             m_aCurrentFilter = _rInitialCurrentFilter;
 413     }
 414 }
 415
 416
 417 // class SvtFilePicker
 418
 419 SvtFilePicker::SvtFilePicker()
 420     :m_pFilterList      ( nullptr )
 421     ,m_pElemList        ( nullptr )
 422     ,m_bMultiSelection  ( false )
 423     ,m_nServiceType     ( TemplateDescription::FILEOPEN_SIMPLE )
 424 {
 425 }
 426
 427 SvtFilePicker::~SvtFilePicker()
 428 {
 429     if ( m_pFilterList && !m_pFilterList->empty() )
 430         m_pFilterList->erase( m_pFilterList->begin(), m_pFilterList->end() );
 431     delete m_pFilterList;
 432
 433     if ( m_pElemList && !m_pElemList->empty() )
 434         m_pElemList->erase( m_pElemList->begin(), m_pElemList->end() );
 435     delete m_pElemList;
 436 }
 437
 438
 439 sal_Int16 SvtFilePicker::implExecutePicker( )
 440 {
 441     getDialog()->SetFileCallback( this );
 442
 443     prepareExecute();
 444
 445     getDialog()->EnableAutocompletion();
 446     // now we are ready to execute the dialog
 447     sal_Int16 nRet = getDialog()->Execute();
 448
 449     // the execution of the dialog yields, so it is possible the at this point the window or the dialog is closed
 450     if ( getDialog() )
 451         getDialog()->SetFileCallback( nullptr );
 452
 453     return nRet;
 454 }
 455
 456
 457 VclPtr<SvtFileDialog_Base> SvtFilePicker::implCreateDialog( vcl::Window* _pParent )
 458 {
 459     PickerFlags nBits = getPickerFlags();
 460
 461     VclPtrInstance<SvtFileDialog> dialog( _pParent, nBits );
 462
 463     // Set StandardDir if present
 464     if ( !m_aStandardDir.isEmpty())
 465     {
 466         OUString sStandardDir = m_aStandardDir;
 467         dialog->SetStandardDir( sStandardDir );
 468         dialog->SetBlackList( m_aBlackList );
 469     }
 470
 471     return dialog;
 472 }
 473
 474
 475 // disambiguate XInterface
 476
 477 IMPLEMENT_FORWARD_XINTERFACE2( SvtFilePicker, OCommonPicker, SvtFilePicker_Base )
 478
 479
 480 // disambiguate XTypeProvider
 481
 482 IMPLEMENT_FORWARD_XTYPEPROVIDER2( SvtFilePicker, OCommonPicker, SvtFilePicker_Base )
 483
 484 IMPLEMENT_FORWARD_XINTERFACE3( SvtRemoteFilePicker, SvtFilePicker, OCommonPicker, SvtFilePicker_Base )
 485
 486
 487 // disambiguate XTypeProvider
 488
 489 IMPLEMENT_FORWARD_XTYPEPROVIDER3( SvtRemoteFilePicker, SvtFilePicker, OCommonPicker, SvtFilePicker_Base )
 490
 491
 492 // XExecutableDialog functions
 493
 494
 495 void SAL_CALL SvtFilePicker::setTitle( const OUString& _rTitle ) throw (RuntimeException, std::exception)
 496 {
 497     OCommonPicker::setTitle( _rTitle );
 498 }
 499
 500
 501 sal_Int16 SAL_CALL SvtFilePicker::execute(  ) throw (RuntimeException, std::exception)
 502 {
 503     return OCommonPicker::execute();
 504 }
 505
 506
 507 // XAsynchronousExecutableDialog functions
 508
 509
 510 void SAL_CALL SvtFilePicker::setDialogTitle( const OUString& _rTitle ) throw (RuntimeException, std::exception)
 511 {
 512     setTitle( _rTitle );
 513 }
 514
 515
 516 void SAL_CALL SvtFilePicker::startExecuteModal( const Reference< css::ui::dialogs::XDialogClosedListener >& xListener )
 517     throw (RuntimeException,
 518            std::exception)
 519 {
 520     m_xDlgClosedListener = xListener;
 521     prepareDialog();
 522     prepareExecute();
 523     getDialog()->EnableAutocompletion();
 524     getDialog()->StartExecuteModal( LINK( this, SvtFilePicker, DialogClosedHdl ) );
 525 }
 526
 527
 528 // XFilePicker functions
 529
 530
 531 void SAL_CALL SvtFilePicker::setMultiSelectionMode( sal_Bool bMode ) throw( RuntimeException, std::exception )
 532 {
 533     checkAlive();
 534
 535     SolarMutexGuard aGuard;
 536     m_bMultiSelection = bMode;
 537 }
 538
 539 void SAL_CALL SvtFilePicker::setDefaultName( const OUString& aName ) throw( RuntimeException, std::exception )
 540 {
 541     checkAlive();
 542
 543     SolarMutexGuard aGuard;
 544     m_aDefaultName = aName;
 545 }
 546
 547 void SAL_CALL SvtFilePicker::setDisplayDirectory( const OUString& aDirectory )
 548     throw( IllegalArgumentException, RuntimeException, std::exception )
 549 {
 550     checkAlive();
 551
 552     SolarMutexGuard aGuard;
 553     m_aDisplayDirectory = aDirectory;
 554 }
 555
 556 OUString SAL_CALL SvtFilePicker::getDisplayDirectory() throw( RuntimeException, std::exception )
 557 {
 558     checkAlive();
 559
 560     SolarMutexGuard aGuard;
 561     if ( getDialog() )
 562     {
 563         OUString aPath = getDialog()->GetPath();
 564
 565         if( m_aOldHideDirectory == aPath )
 566             return m_aOldDisplayDirectory;
 567         m_aOldHideDirectory = aPath;
 568
 569         if( !getDialog()->ContentIsFolder( aPath ) )
 570         {
 571             INetURLObject aFolder( aPath );
 572             aFolder.CutLastName();
 573             aPath = aFolder.GetMainURL( INetURLObject::DecodeMechanism::NONE );
 574         }
 575         m_aOldDisplayDirectory = aPath;
 576         return aPath;
 577     }
 578     else
 579         return m_aDisplayDirectory;
 580 }
 581
 582 Sequence< OUString > SAL_CALL SvtFilePicker::getSelectedFiles() throw( RuntimeException, std::exception )
 583 {
 584     checkAlive();
 585
 586     SolarMutexGuard aGuard;
 587     if ( ! getDialog() )
 588     {
 589         Sequence< OUString > aEmpty;
 590         return aEmpty;
 591     }
 592
 593     std::vector<OUString> aPathList(getDialog()->GetPathList());
 594     size_t nCount = aPathList.size();
 595
 596     Sequence< OUString > aFiles(nCount);
 597
 598     for(size_t i = 0; i < aPathList.size(); ++i)
 599     {
 600         aFiles[i] = aPathList[i];
 601     }
 602
 603     return aFiles;
 604 }
 605
 606 Sequence< OUString > SAL_CALL SvtFilePicker::getFiles() throw( RuntimeException, std::exception )
 607 {
 608     Sequence< OUString > aFiles = getSelectedFiles();
 609     if (aFiles.getLength() > 1)
 610         aFiles.realloc(1);
 611     return aFiles;
 612 }
 613
 614
 615 // XFilePickerControlAccess functions
 616
 617
 618 void SAL_CALL SvtFilePicker::setValue( sal_Int16 nElementID,
 619                                        sal_Int16 nControlAction,
 620                                        const Any& rValue )
 621     throw( RuntimeException, std::exception )
 622 {
 623     checkAlive();
 624
 625     SolarMutexGuard aGuard;
 626     if ( getDialog() )
 627     {
 628         ::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
 629         aAccess.setValue( nElementID, nControlAction, rValue );
 630     }
 631     else
 632     {
 633         if ( !m_pElemList )
 634             m_pElemList = new ElementList;
 635
 636         bool bFound = false;
 637         ElementList::iterator aListIter;
 638
 639         for ( aListIter = m_pElemList->begin();
 640               aListIter != m_pElemList->end(); ++aListIter )
 641         {
 642             ElementEntry_Impl& rEntry = *aListIter;
 643             if ( ( rEntry.m_nElementID == nElementID ) &&
 644                  ( !rEntry.m_bHasValue || ( rEntry.m_nControlAction == nControlAction ) ) )
 645             {
 646                 rEntry.setAction( nControlAction );
 647                 rEntry.setValue( rValue );
 648                 bFound = true;
 649             }
 650         }
 651
 652         if ( !bFound )
 653         {
 654             ElementEntry_Impl aNew( nElementID );
 655             aNew.setAction( nControlAction );
 656             aNew.setValue( rValue );
 657             m_pElemList->insert( m_pElemList->end(), aNew );
 658         }
 659     }
 660 }
 661
 662
 663 Any SAL_CALL SvtFilePicker::getValue( sal_Int16 nElementID, sal_Int16 nControlAction )
 664     throw( RuntimeException, std::exception )
 665 {
 666     checkAlive();
 667
 668     SolarMutexGuard aGuard;
 669     Any      aAny;
 670
 671     // execute() called?
 672     if ( getDialog() )
 673     {
 674         ::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
 675         aAny = aAccess.getValue( nElementID, nControlAction );
 676     }
 677     else if ( m_pElemList && !m_pElemList->empty() )
 678     {
 679         ElementList::iterator aListIter;
 680         for ( aListIter = m_pElemList->begin();
 681               aListIter != m_pElemList->end(); ++aListIter )
 682         {
 683             ElementEntry_Impl& rEntry = *aListIter;
 684             if ( ( rEntry.m_nElementID == nElementID ) &&
 685                  ( rEntry.m_bHasValue ) &&
 686                  ( rEntry.m_nControlAction == nControlAction ) )
 687             {
 688                 aAny = rEntry.m_aValue;
 689                 break;
 690             }
 691         }
 692     }
 693
 694     return aAny;
 695 }
 696
 697
 698 void SAL_CALL SvtFilePicker::setLabel( sal_Int16 nLabelID, const OUString& rValue )
 699     throw ( RuntimeException, std::exception )
 700 {
 701     checkAlive();
 702
 703     SolarMutexGuard aGuard;
 704     if ( getDialog() )
 705     {
 706         ::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
 707         aAccess.setLabel( nLabelID, rValue );
 708     }
 709     else
 710     {
 711         if ( !m_pElemList )
 712             m_pElemList = new ElementList;
 713
 714         bool bFound = false;
 715         ElementList::iterator aListIter;
 716
 717         for ( aListIter = m_pElemList->begin();
 718               aListIter != m_pElemList->end(); ++aListIter )
 719         {
 720             ElementEntry_Impl& rEntry = *aListIter;
 721             if ( rEntry.m_nElementID == nLabelID )
 722             {
 723                 rEntry.setLabel( rValue );
 724                 bFound = true;
 725             }
 726         }
 727
 728         if ( !bFound )
 729         {
 730             ElementEntry_Impl aNew( nLabelID );
 731             aNew.setLabel( rValue );
 732             m_pElemList->insert( m_pElemList->end(), aNew );
 733         }
 734     }
 735 }
 736
 737
 738 OUString SAL_CALL SvtFilePicker::getLabel( sal_Int16 nLabelID )
 739     throw ( RuntimeException, std::exception )
 740 {
 741     checkAlive();
 742
 743     SolarMutexGuard aGuard;
 744     OUString aLabel;
 745
 746     if ( getDialog() )
 747     {
 748         ::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
 749         aLabel = aAccess.getLabel( nLabelID );
 750     }
 751     else if ( m_pElemList && !m_pElemList->empty() )
 752     {
 753         ElementList::iterator aListIter;
 754         for ( aListIter = m_pElemList->begin();
 755               aListIter != m_pElemList->end(); ++aListIter )
 756         {
 757             ElementEntry_Impl& rEntry = *aListIter;
 758             if ( rEntry.m_nElementID == nLabelID )
 759             {
 760                 if ( rEntry.m_bHasLabel )
 761                     aLabel = rEntry.m_aLabel;
 762                 break;
 763             }
 764         }
 765     }
 766
 767     return aLabel;
 768 }
 769
 770
 771 void SAL_CALL SvtFilePicker::enableControl( sal_Int16 nElementID, sal_Bool bEnable )
 772     throw( RuntimeException, std::exception )
 773 {
 774     checkAlive();
 775
 776     SolarMutexGuard aGuard;
 777     if ( getDialog() )
 778     {
 779         ::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
 780         aAccess.enableControl( nElementID, bEnable );
 781     }
 782     else
 783     {
 784         if ( !m_pElemList )
 785             m_pElemList = new ElementList;
 786
 787         bool bFound = false;
 788         ElementList::iterator aListIter;
 789
 790         for ( aListIter = m_pElemList->begin();
 791               aListIter != m_pElemList->end(); ++aListIter )
 792         {
 793             ElementEntry_Impl& rEntry = *aListIter;
 794             if ( rEntry.m_nElementID == nElementID )
 795             {
 796                 rEntry.setEnabled( bEnable );
 797                 bFound = true;
 798             }
 799         }
 800
 801         if ( !bFound )
 802         {
 803             ElementEntry_Impl aNew( nElementID );
 804             aNew.setEnabled( bEnable );
 805             m_pElemList->insert( m_pElemList->end(), aNew );
 806         }
 807     }
 808 }
 809
 810
 811 // XFilePickerNotifier functions
 812
 813
 814 void SAL_CALL SvtFilePicker::addFilePickerListener( const Reference< XFilePickerListener >& xListener ) throw ( RuntimeException, std::exception )
 815 {
 816     checkAlive();
 817
 818     SolarMutexGuard aGuard;
 819     m_xListener = xListener;
 820 }
 821
 822
 823 void SAL_CALL SvtFilePicker::removeFilePickerListener( const Reference< XFilePickerListener >& ) throw ( RuntimeException, std::exception )
 824 {
 825     checkAlive();
 826
 827     SolarMutexGuard aGuard;
 828     m_xListener.clear();
 829 }
 830
 831
 832 // XFilePreview functions
 833
 834
 835 Sequence< sal_Int16 > SAL_CALL SvtFilePicker::getSupportedImageFormats()
 836     throw ( RuntimeException, std::exception )
 837 {
 838     checkAlive();
 839
 840     SolarMutexGuard aGuard;
 841     Sequence< sal_Int16 > aFormats( 1 );
 842
 843     aFormats[0] = FilePreviewImageFormats::BITMAP;
 844
 845     return aFormats;
 846 }
 847
 848
 849 sal_Int32 SAL_CALL SvtFilePicker::getTargetColorDepth() throw ( RuntimeException, std::exception )
 850 {
 851     checkAlive();
 852
 853     SolarMutexGuard aGuard;
 854     sal_Int32 nDepth = 0;
 855
 856     if ( getDialog() )
 857         nDepth = getDialog()->getTargetColorDepth();
 858
 859     return nDepth;
 860 }
 861
 862
 863 sal_Int32 SAL_CALL SvtFilePicker::getAvailableWidth() throw ( RuntimeException, std::exception )
 864 {
 865     checkAlive();
 866
 867     SolarMutexGuard aGuard;
 868     sal_Int32 nWidth = 0;
 869
 870     if ( getDialog() )
 871         nWidth = getDialog()->getAvailableWidth();
 872
 873     return nWidth;
 874 }
 875
 876
 877 sal_Int32 SAL_CALL SvtFilePicker::getAvailableHeight() throw ( RuntimeException, std::exception )
 878 {
 879     checkAlive();
 880
 881     SolarMutexGuard aGuard;
 882     sal_Int32 nHeight = 0;
 883
 884     if ( getDialog() )
 885         nHeight = getDialog()->getAvailableHeight();
 886
 887     return nHeight;
 888 }
 889
 890
 891 void SAL_CALL SvtFilePicker::setImage( sal_Int16 aImageFormat, const Any& rImage )
 892     throw ( IllegalArgumentException, RuntimeException, std::exception )
 893 {
 894     checkAlive();
 895
 896     SolarMutexGuard aGuard;
 897     if ( getDialog() )
 898         getDialog()->setImage( aImageFormat, rImage );
 899 }
 900
 901
 902 sal_Bool SAL_CALL SvtFilePicker::setShowState( sal_Bool )
 903     throw ( RuntimeException, std::exception )
 904 {
 905     checkAlive();
 906
 907     SolarMutexGuard aGuard;
 908     bool bRet = false;
 909
 910     if ( getDialog() )
 911     {
 912     // #97633 for the system filedialog it's
 913     // useful to make the preview switchable
 914     // because the preview occupies
 915     // half of the size of the file listbox
 916     // which is not the case here,
 917     // so we (TRA/FS) decided not to make
 918     // the preview window switchable because
 919     // else we would have to change the layout
 920     // of the file dialog dynamically
 921     // support for set/getShowState is opionally
 922     // see css::ui::dialogs::XFilePreview
 923
 924         bRet = false;
 925     }
 926
 927     return bRet;
 928 }
 929
 930
 931 sal_Bool SAL_CALL SvtFilePicker::getShowState() throw ( RuntimeException, std::exception )
 932 {
 933     checkAlive();
 934
 935     SolarMutexGuard aGuard;
 936     bool bRet = false;
 937
 938     if ( getDialog() )
 939         bRet = getDialog()->getShowState();
 940
 941     return bRet;
 942 }
 943
 944
 945 // XFilterGroupManager functions
 946
 947
 948 void SAL_CALL SvtFilePicker::appendFilterGroup( const OUString& sGroupTitle,
 949                                                 const Sequence< StringPair >& aFilters )
 950     throw ( IllegalArgumentException, RuntimeException, std::exception )
 951 {
 952     checkAlive();
 953
 954     SolarMutexGuard aGuard;
 955
 956     // check the names
 957     if ( FilterNameExists( aFilters ) )
 958         throw IllegalArgumentException(
 959             "filter name exists",
 960             static_cast< OWeakObject * >(this), 1);
 961
 962     // ensure that we have a filter list
 963     OUString sInitialCurrentFilter;
 964     if ( aFilters.getLength() )
 965         sInitialCurrentFilter = aFilters[0].First;
 966     ensureFilterList( sInitialCurrentFilter );
 967
 968     // append the filter
 969     m_pFilterList->insert( m_pFilterList->end(), FilterEntry( sGroupTitle, aFilters ) );
 970 }
 971
 972
 973 // XFilterManager functions
 974
 975
 976 void SAL_CALL SvtFilePicker::appendFilter( const OUString& aTitle,
 977                                            const OUString& aFilter )
 978     throw( IllegalArgumentException, RuntimeException, std::exception )
 979 {
 980     checkAlive();
 981
 982     SolarMutexGuard aGuard;
 983     // check the name
 984     if ( FilterNameExists( aTitle ) )
 985         // TODO: a more precise exception message
 986         throw IllegalArgumentException();
 987
 988     // ensure that we have a filter list
 989     ensureFilterList( aTitle );
 990
 991     // append the filter
 992     m_pFilterList->insert( m_pFilterList->end(), FilterEntry( aTitle, aFilter ) );
 993 }
 994
 995
 996 void SAL_CALL SvtFilePicker::setCurrentFilter( const OUString& aTitle )
 997     throw( IllegalArgumentException, RuntimeException, std::exception )
 998 {
 999     checkAlive();
1000
1001     SolarMutexGuard aGuard;
1002     if ( ! FilterNameExists( aTitle ) )
1003         throw IllegalArgumentException();
1004
1005     m_aCurrentFilter = aTitle;
1006
1007     if ( getDialog() )
1008         getDialog()->SetCurFilter( aTitle );
1009 }
1010
1011
1012 OUString SAL_CALL SvtFilePicker::getCurrentFilter()
1013     throw( RuntimeException, std::exception )
1014 {
1015     checkAlive();
1016
1017     SolarMutexGuard aGuard;
1018     OUString aFilter = getDialog() ? OUString( getDialog()->GetCurFilter() ) :
1019                                             OUString( m_aCurrentFilter );
1020     return aFilter;
1021 }
1022
1023
1024 // XInitialization functions
1025
1026
1027 void SAL_CALL SvtFilePicker::initialize( const Sequence< Any >& _rArguments )
1028     throw ( Exception, RuntimeException, std::exception )
1029 {
1030     checkAlive();
1031
1032     Sequence< Any > aArguments( _rArguments.getLength());
1033
1034     m_nServiceType = TemplateDescription::FILEOPEN_SIMPLE;
1035
1036     if ( _rArguments.getLength() >= 1 )
1037     {
1038         // compatibility: one argument, type sal_Int16 , specifies the service type
1039         int index = 0;
1040
1041         if (_rArguments[0] >>= m_nServiceType)
1042         {
1043             // skip the first entry if it was the ServiceType, because it's not needed in OCommonPicker::initialize and it's not a NamedValue
1044             NamedValue emptyNamedValue;
1045             aArguments[0] <<= emptyNamedValue;
1046             index = 1;
1047
1048         }
1049         for ( int i = index; i < _rArguments.getLength(); i++)
1050         {
1051             NamedValue namedValue;
1052             aArguments[i] = _rArguments[i];
1053
1054             if (aArguments[i] >>= namedValue )
1055             {
1056
1057                 if ( namedValue.Name == "StandardDir" )
1058                 {
1059                     OUString sStandardDir;
1060
1061                     namedValue.Value >>= sStandardDir;
1062
1063                     // Set the directory for the "back to the default dir" button
1064                         if ( !sStandardDir.isEmpty() )
1065                     {
1066                         m_aStandardDir = sStandardDir;
1067                     }
1068                 }
1069                 else if ( namedValue.Name == "BlackList" )
1070                 {
1071                     namedValue.Value >>= m_aBlackList;
1072                 }
1073             }
1074         }
1075     }
1076
1077     // let the base class analyze the sequence (will call into implHandleInitializationArgument)
1078     OCommonPicker::initialize( aArguments );
1079 }
1080
1081
1082 bool SvtFilePicker::implHandleInitializationArgument( const OUString& _rName, const Any& _rValue )
1083 {
1084     if ( _rName == "TemplateDescription" )
1085     {
1086         m_nServiceType = TemplateDescription::FILEOPEN_SIMPLE;
1087         OSL_VERIFY( _rValue >>= m_nServiceType );
1088         return true;
1089     }
1090     if ( _rName == "StandardDir" )
1091     {
1092         OSL_VERIFY( _rValue >>= m_aStandardDir );
1093         return true;
1094     }
1095
1096     if ( _rName == "BlackList" )
1097     {
1098         OSL_VERIFY( _rValue >>= m_aBlackList );
1099         return true;
1100     }
1101
1102
1103     return OCommonPicker::implHandleInitializationArgument( _rName, _rValue );
1104 }
1105
1106
1107 // XServiceInfo
1108
1109
1110 /* XServiceInfo */
1111 OUString SAL_CALL SvtFilePicker::getImplementationName() throw( RuntimeException, std::exception )
1112 {
1113     return impl_getStaticImplementationName();
1114 }
1115
1116 /* XServiceInfo */
1117 sal_Bool SAL_CALL SvtFilePicker::supportsService( const OUString& sServiceName ) throw( RuntimeException, std::exception )
1118 {
1119     return cppu::supportsService(this, sServiceName);
1120 }
1121
1122 /* XServiceInfo */
1123 Sequence< OUString > SAL_CALL SvtFilePicker::getSupportedServiceNames() throw( RuntimeException, std::exception )
1124 {
1125     return impl_getStaticSupportedServiceNames();
1126 }
1127
1128 /* Helper for XServiceInfo */
1129 Sequence< OUString > SvtFilePicker::impl_getStaticSupportedServiceNames()
1130 {
1131     Sequence<OUString> seqServiceNames { "com.sun.star.ui.dialogs.OfficeFilePicker" };
1132     return seqServiceNames ;
1133 }
1134
1135 /* Helper for XServiceInfo */
1136 OUString SvtFilePicker::impl_getStaticImplementationName()
1137 {
1138     return OUString( "com.sun.star.svtools.OfficeFilePicker" );
1139 }
1140
1141 /* Helper for registry */
1142 Reference< XInterface > SAL_CALL SvtFilePicker::impl_createInstance(
1143     const Reference< XComponentContext >& ) throw( Exception )
1144 {
1145     return Reference< XInterface >( *new SvtFilePicker );
1146 }
1147
1148 // SvtRemoteFilePicker
1149
1150 SvtRemoteFilePicker::SvtRemoteFilePicker()
1151 {
1152 }
1153
1154 VclPtr<SvtFileDialog_Base> SvtRemoteFilePicker::implCreateDialog( vcl::Window* _pParent )
1155 {
1156     PickerFlags nBits = getPickerFlags();
1157
1158     VclPtrInstance<RemoteFilesDialog> dialog( _pParent, nBits);
1159
1160     // Set StandardDir if present
1161     if ( !m_aStandardDir.isEmpty())
1162     {
1163         OUString sStandardDir = m_aStandardDir;
1164         dialog->SetStandardDir( sStandardDir );
1165         dialog->SetBlackList( m_aBlackList );
1166     }
1167
1168     return dialog;
1169 }
1170
1171 // XServiceInfo
1172
1173
1174 /* XServiceInfo */
1175 OUString SAL_CALL SvtRemoteFilePicker::getImplementationName() throw( RuntimeException, std::exception )
1176 {
1177     return impl_getStaticImplementationName();
1178 }
1179
1180 /* XServiceInfo */
1181 sal_Bool SAL_CALL SvtRemoteFilePicker::supportsService( const OUString& sServiceName ) throw( RuntimeException, std::exception )
1182 {
1183     return cppu::supportsService(this, sServiceName);
1184 }
1185
1186 /* XServiceInfo */
1187 Sequence< OUString > SAL_CALL SvtRemoteFilePicker::getSupportedServiceNames() throw( RuntimeException, std::exception )
1188 {
1189     return impl_getStaticSupportedServiceNames();
1190 }
1191
1192 /* Helper for XServiceInfo */
1193 Sequence< OUString > SvtRemoteFilePicker::impl_getStaticSupportedServiceNames()
1194 {
1195     Sequence<OUString> seqServiceNames { "com.sun.star.ui.dialogs.RemoteFilePicker" };
1196     return seqServiceNames ;
1197 }
1198
1199 /* Helper for XServiceInfo */
1200 OUString SvtRemoteFilePicker::impl_getStaticImplementationName()
1201 {
1202     return OUString( "com.sun.star.svtools.RemoteFilePicker" );
1203 }
1204
1205 /* Helper for registry */
1206 Reference< XInterface > SAL_CALL SvtRemoteFilePicker::impl_createInstance(
1207     const Reference< XComponentContext >& ) throw( Exception )
1208 {
1209     return Reference< XInterface >( *new SvtRemoteFilePicker );
1210 }
1211
1212 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */