fpicker/source/office/OfficeFilePicker.cxx

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