1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 // MARKER(update_precomp.py): autogen include statement, do not remove 23 #include "precompiled_sfx2.hxx" 24 25 #include <sfx2/filedlghelper.hxx> 26 #include <sal/types.h> 27 #include <com/sun/star/lang/XInitialization.hpp> 28 #include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp> 29 #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp> 30 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp> 31 #include <com/sun/star/ui/dialogs/FilePreviewImageFormats.hpp> 32 #include <com/sun/star/ui/dialogs/ControlActions.hpp> 33 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp> 34 #include <com/sun/star/ui/dialogs/XControlInformation.hpp> 35 #include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp> 36 #include <com/sun/star/ui/dialogs/XFilePickerNotifier.hpp> 37 #include <com/sun/star/ui/dialogs/XFilePreview.hpp> 38 #include <com/sun/star/ui/dialogs/XFilterManager.hpp> 39 #include <com/sun/star/ui/dialogs/XFilterGroupManager.hpp> 40 #include <com/sun/star/ui/dialogs/XFolderPicker.hpp> 41 #include <com/sun/star/ui/dialogs/XFilePicker2.hpp> 42 #include <com/sun/star/ui/dialogs/XAsynchronousExecutableDialog.hpp> 43 #include <com/sun/star/lang/XServiceInfo.hpp> 44 #include <com/sun/star/beans/XPropertySet.hpp> 45 #include <com/sun/star/beans/NamedValue.hpp> 46 #include <com/sun/star/embed/ElementModes.hpp> 47 #include <com/sun/star/container/XEnumeration.hpp> 48 #include <com/sun/star/container/XContainerQuery.hpp> 49 #include <com/sun/star/task/XInteractionRequest.hpp> 50 #include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp> 51 52 #include <comphelper/processfactory.hxx> 53 #include <comphelper/types.hxx> 54 #include <comphelper/sequenceashashmap.hxx> 55 #include <comphelper/stillreadwriteinteraction.hxx> 56 #include <tools/urlobj.hxx> 57 #include <vcl/help.hxx> 58 #include <unotools/ucbstreamhelper.hxx> 59 #include <unotools/ucbhelper.hxx> 60 #include <unotools/localfilehelper.hxx> 61 #include <vos/thread.hxx> 62 #include <vos/mutex.hxx> 63 #include <vos/security.hxx> 64 #include <vcl/cvtgrf.hxx> 65 #include <vcl/msgbox.hxx> 66 #include <vcl/mnemonic.hxx> 67 #include <unotools/pathoptions.hxx> 68 #include <unotools/securityoptions.hxx> 69 #include <svl/itemset.hxx> 70 #include <svl/eitem.hxx> 71 #include <svl/intitem.hxx> 72 #include <svl/stritem.hxx> 73 #include <svtools/filter.hxx> 74 #include <unotools/viewoptions.hxx> 75 #include <unotools/moduleoptions.hxx> 76 #include <svtools/helpid.hrc> 77 #include <comphelper/docpasswordrequest.hxx> 78 #include <comphelper/docpasswordhelper.hxx> 79 #include <ucbhelper/content.hxx> 80 #include <ucbhelper/commandenvironment.hxx> 81 #include <comphelper/storagehelper.hxx> 82 #include <toolkit/helper/vclunohelper.hxx> 83 #include <sfx2/app.hxx> 84 #include <sfx2/frame.hxx> 85 #include <sfx2/docfile.hxx> 86 #include <sfx2/docfac.hxx> 87 #include "openflag.hxx" 88 #include <sfx2/passwd.hxx> 89 #include "sfx2/sfxresid.hxx" 90 #include <sfx2/sfxsids.hrc> 91 #include "filedlghelper.hrc" 92 #include "filtergrouping.hxx" 93 #include <sfx2/request.hxx> 94 #include "filedlgimpl.hxx" 95 #include <helpid.hrc> 96 #include <sfxlocal.hrc> 97 #include <vcl/dibtools.hxx> 98 99 //----------------------------------------------------------------------------- 100 101 using namespace ::com::sun::star; 102 using namespace ::com::sun::star::container; 103 using namespace ::com::sun::star::lang; 104 using namespace ::com::sun::star::ui::dialogs; 105 using namespace ::com::sun::star::ui::dialogs::TemplateDescription; 106 using namespace ::com::sun::star::uno; 107 using namespace ::com::sun::star::beans; 108 using namespace ::rtl; 109 using namespace ::cppu; 110 111 //----------------------------------------------------------------------------- 112 113 #define IODLG_CONFIGNAME String(DEFINE_CONST_UNICODE("FilePicker_Save")) 114 #define IMPGRF_CONFIGNAME String(DEFINE_CONST_UNICODE("FilePicker_Graph")) 115 #define USERITEM_NAME ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "UserItem" )) 116 117 //----------------------------------------------------------------------------- 118 119 namespace sfx2 120 { 121 122 const OUString* GetLastFilterConfigId( FileDialogHelper::Context _eContext ) 123 { 124 static const OUString aSD_EXPORT_IDENTIFIER( RTL_CONSTASCII_USTRINGPARAM( "SdExportLastFilter" ) ); 125 static const OUString aSI_EXPORT_IDENTIFIER( RTL_CONSTASCII_USTRINGPARAM( "SiExportLastFilter" ) ); 126 static const OUString aSW_EXPORT_IDENTIFIER( RTL_CONSTASCII_USTRINGPARAM( "SwExportLastFilter" ) ); 127 128 const OUString* pRet = NULL; 129 130 switch( _eContext ) 131 { 132 case FileDialogHelper::SD_EXPORT: pRet = &aSD_EXPORT_IDENTIFIER; break; 133 case FileDialogHelper::SI_EXPORT: pRet = &aSI_EXPORT_IDENTIFIER; break; 134 case FileDialogHelper::SW_EXPORT: pRet = &aSW_EXPORT_IDENTIFIER; break; 135 default: break; 136 } 137 138 return pRet; 139 } 140 141 String EncodeSpaces_Impl( const String& rSource ); 142 String DecodeSpaces_Impl( const String& rSource ); 143 144 // ------------------------------------------------------------------------ 145 // ----------- FileDialogHelper_Impl --------------------------- 146 // ------------------------------------------------------------------------ 147 148 // ------------------------------------------------------------------------ 149 // XFilePickerListener Methods 150 // ------------------------------------------------------------------------ 151 void SAL_CALL FileDialogHelper_Impl::fileSelectionChanged( const FilePickerEvent& aEvent ) throw ( RuntimeException ) 152 { 153 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 154 mpAntiImpl->FileSelectionChanged( aEvent ); 155 } 156 157 // ------------------------------------------------------------------------ 158 void SAL_CALL FileDialogHelper_Impl::directoryChanged( const FilePickerEvent& aEvent ) throw ( RuntimeException ) 159 { 160 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 161 mpAntiImpl->DirectoryChanged( aEvent ); 162 } 163 164 // ------------------------------------------------------------------------ 165 OUString SAL_CALL FileDialogHelper_Impl::helpRequested( const FilePickerEvent& aEvent ) throw ( RuntimeException ) 166 { 167 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 168 return mpAntiImpl->HelpRequested( aEvent ); 169 } 170 171 // ------------------------------------------------------------------------ 172 void SAL_CALL FileDialogHelper_Impl::controlStateChanged( const FilePickerEvent& aEvent ) throw ( RuntimeException ) 173 { 174 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 175 mpAntiImpl->ControlStateChanged( aEvent ); 176 } 177 178 // ------------------------------------------------------------------------ 179 void SAL_CALL FileDialogHelper_Impl::dialogSizeChanged() throw ( RuntimeException ) 180 { 181 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 182 mpAntiImpl->DialogSizeChanged(); 183 } 184 185 // ------------------------------------------------------------------------ 186 // XDialogClosedListener Methods 187 // ------------------------------------------------------------------------ 188 void SAL_CALL FileDialogHelper_Impl::dialogClosed( const DialogClosedEvent& _rEvent ) throw ( RuntimeException ) 189 { 190 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 191 mpAntiImpl->DialogClosed( _rEvent ); 192 postExecute( _rEvent.DialogResult ); 193 } 194 195 // ------------------------------------------------------------------------ 196 // handle XFilePickerListener events 197 // ------------------------------------------------------------------------ 198 void FileDialogHelper_Impl::handleFileSelectionChanged( const FilePickerEvent& ) 199 { 200 if ( mbHasVersions ) 201 updateVersions(); 202 203 if ( mbShowPreview ) 204 maPreViewTimer.Start(); 205 } 206 207 // ------------------------------------------------------------------------ 208 void FileDialogHelper_Impl::handleDirectoryChanged( const FilePickerEvent& ) 209 { 210 if ( mbShowPreview ) 211 TimeOutHdl_Impl( NULL ); 212 } 213 214 // ------------------------------------------------------------------------ 215 OUString FileDialogHelper_Impl::handleHelpRequested( const FilePickerEvent& aEvent ) 216 { 217 //!!! todo: cache the help strings (here or TRA) 218 219 rtl::OString sHelpId; 220 // mapping from element id -> help id 221 switch ( aEvent.ElementId ) 222 { 223 case ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION : 224 sHelpId = HID_FILESAVE_AUTOEXTENSION; 225 break; 226 227 case ExtendedFilePickerElementIds::CHECKBOX_PASSWORD : 228 sHelpId = HID_FILESAVE_SAVEWITHPASSWORD; 229 break; 230 231 case ExtendedFilePickerElementIds::CHECKBOX_FILTEROPTIONS : 232 sHelpId = HID_FILESAVE_CUSTOMIZEFILTER; 233 break; 234 235 case ExtendedFilePickerElementIds::CHECKBOX_READONLY : 236 sHelpId = HID_FILEOPEN_READONLY; 237 break; 238 239 case ExtendedFilePickerElementIds::CHECKBOX_LINK : 240 sHelpId = HID_FILEDLG_LINK_CB; 241 break; 242 243 case ExtendedFilePickerElementIds::CHECKBOX_PREVIEW : 244 sHelpId = HID_FILEDLG_PREVIEW_CB; 245 break; 246 247 case ExtendedFilePickerElementIds::PUSHBUTTON_PLAY : 248 sHelpId = HID_FILESAVE_DOPLAY; 249 break; 250 251 case ExtendedFilePickerElementIds::LISTBOX_VERSION_LABEL : 252 case ExtendedFilePickerElementIds::LISTBOX_VERSION : 253 sHelpId = HID_FILEOPEN_VERSION; 254 break; 255 256 case ExtendedFilePickerElementIds::LISTBOX_TEMPLATE_LABEL : 257 case ExtendedFilePickerElementIds::LISTBOX_TEMPLATE : 258 sHelpId = HID_FILESAVE_TEMPLATE; 259 break; 260 261 case ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE_LABEL : 262 case ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE : 263 sHelpId = HID_FILEOPEN_IMAGE_TEMPLATE; 264 break; 265 266 case ExtendedFilePickerElementIds::CHECKBOX_SELECTION : 267 sHelpId = HID_FILESAVE_SELECTION; 268 break; 269 270 default: 271 DBG_ERRORFILE( "invalid element id" ); 272 } 273 274 OUString aHelpText; 275 Help* pHelp = Application::GetHelp(); 276 if ( pHelp ) 277 aHelpText = String( pHelp->GetHelpText( String( ByteString(sHelpId), RTL_TEXTENCODING_UTF8), NULL ) ); 278 return aHelpText; 279 } 280 281 // ------------------------------------------------------------------------ 282 void FileDialogHelper_Impl::handleControlStateChanged( const FilePickerEvent& aEvent ) 283 { 284 switch ( aEvent.ElementId ) 285 { 286 case CommonFilePickerElementIds::LISTBOX_FILTER: 287 updateFilterOptionsBox(); 288 enablePasswordBox( sal_False ); 289 updateSelectionBox(); 290 // only use it for export and with our own dialog 291 if ( mbExport && !mbSystemPicker ) 292 updateExportButton(); 293 break; 294 295 case ExtendedFilePickerElementIds::CHECKBOX_PREVIEW: 296 updatePreviewState(); 297 break; 298 } 299 } 300 301 // ------------------------------------------------------------------------ 302 void FileDialogHelper_Impl::handleDialogSizeChanged() 303 { 304 if ( mbShowPreview ) 305 TimeOutHdl_Impl( NULL ); 306 } 307 308 // ------------------------------------------------------------------------ 309 // XEventListener Methods 310 // ------------------------------------------------------------------------ 311 void SAL_CALL FileDialogHelper_Impl::disposing( const EventObject& ) throw ( RuntimeException ) 312 { 313 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 314 dispose(); 315 } 316 317 // ------------------------------------------------------------------------ 318 // ------------------------------------------------------------------------ 319 // ------------------------------------------------------------------------ 320 void FileDialogHelper_Impl::dispose() 321 { 322 if ( mxFileDlg.is() ) 323 { 324 // remove the event listener 325 uno::Reference< XFilePickerNotifier > xNotifier( mxFileDlg, UNO_QUERY ); 326 if ( xNotifier.is() ) 327 xNotifier->removeFilePickerListener( this ); 328 329 ::comphelper::disposeComponent( mxFileDlg ); 330 mxFileDlg.clear(); 331 } 332 } 333 334 // ------------------------------------------------------------------------ 335 String FileDialogHelper_Impl::getCurrentFilterUIName() const 336 { 337 String aFilterName; 338 uno::Reference< XFilterManager > xFltMgr( mxFileDlg, UNO_QUERY ); 339 340 if( xFltMgr.is() ) 341 { 342 aFilterName = xFltMgr->getCurrentFilter(); 343 344 if ( aFilterName.Len() && isShowFilterExtensionEnabled() ) 345 aFilterName = getFilterName( aFilterName ); 346 } 347 348 return aFilterName; 349 } 350 351 // ------------------------------------------------------------------------ 352 void FileDialogHelper_Impl::LoadLastUsedFilter( const OUString& _rContextIdentifier ) 353 { 354 SvtViewOptions aDlgOpt( E_DIALOG, IODLG_CONFIGNAME ); 355 356 if( aDlgOpt.Exists() ) 357 { 358 OUString aLastFilter; 359 if( aDlgOpt.GetUserItem( _rContextIdentifier ) >>= aLastFilter ) 360 setFilter( aLastFilter ); 361 } 362 } 363 364 // ------------------------------------------------------------------------ 365 void FileDialogHelper_Impl::SaveLastUsedFilter( const OUString& _rContextIdentifier ) 366 { 367 SvtViewOptions( E_DIALOG, IODLG_CONFIGNAME ).SetUserItem( _rContextIdentifier, 368 makeAny( getFilterWithExtension( getFilter() ) ) ); 369 } 370 371 // ------------------------------------------------------------------------ 372 void FileDialogHelper_Impl::SaveLastUsedFilter( void ) 373 { 374 const OUString* pConfigId = GetLastFilterConfigId( meContext ); 375 if( pConfigId ) 376 SaveLastUsedFilter( *pConfigId ); 377 } 378 379 // ------------------------------------------------------------------------ 380 const SfxFilter* FileDialogHelper_Impl::getCurentSfxFilter() 381 { 382 String aFilterName = getCurrentFilterUIName(); 383 384 const SfxFilter* pFilter = NULL; 385 if ( mpMatcher && aFilterName.Len() ) 386 pFilter = mpMatcher->GetFilter4UIName( aFilterName, m_nMustFlags, m_nDontFlags ); 387 388 return pFilter; 389 } 390 391 // ------------------------------------------------------------------------ 392 sal_Bool FileDialogHelper_Impl::updateExtendedControl( sal_Int16 _nExtendedControlId, sal_Bool _bEnable ) 393 { 394 sal_Bool bIsEnabled = sal_False; 395 396 uno::Reference < XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY ); 397 if ( xCtrlAccess.is() ) 398 { 399 try 400 { 401 xCtrlAccess->enableControl( _nExtendedControlId, _bEnable ); 402 bIsEnabled = _bEnable; 403 } 404 catch( const IllegalArgumentException& ) 405 { 406 DBG_ERROR( "FileDialogHelper_Impl::updateExtendedControl: caught an exception!" ); 407 } 408 } 409 return bIsEnabled; 410 } 411 412 // ------------------------------------------------------------------------ 413 sal_Bool FileDialogHelper_Impl::CheckFilterOptionsCapability( const SfxFilter* _pFilter ) 414 { 415 sal_Bool bResult = sal_False; 416 417 if( mxFilterCFG.is() && _pFilter ) 418 { 419 try { 420 Sequence < PropertyValue > aProps; 421 Any aAny = mxFilterCFG->getByName( _pFilter->GetName() ); 422 if ( aAny >>= aProps ) 423 { 424 ::rtl::OUString aServiceName; 425 sal_Int32 nPropertyCount = aProps.getLength(); 426 for( sal_Int32 nProperty=0; nProperty < nPropertyCount; ++nProperty ) 427 { 428 if( aProps[nProperty].Name.equals( DEFINE_CONST_OUSTRING( "UIComponent") ) ) 429 { 430 aProps[nProperty].Value >>= aServiceName; 431 if( aServiceName.getLength() ) 432 bResult = sal_True; 433 } 434 } 435 } 436 } 437 catch( Exception& ) 438 { 439 } 440 } 441 442 return bResult; 443 } 444 445 // ------------------------------------------------------------------------ 446 sal_Bool FileDialogHelper_Impl::isInOpenMode() const 447 { 448 sal_Bool bRet = sal_False; 449 450 switch ( m_nDialogType ) 451 { 452 case FILEOPEN_SIMPLE: 453 case FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE: 454 case FILEOPEN_PLAY: 455 case FILEOPEN_READONLY_VERSION: 456 case FILEOPEN_LINK_PREVIEW: 457 bRet = sal_True; 458 } 459 460 return bRet; 461 } 462 463 // ------------------------------------------------------------------------ 464 465 void FileDialogHelper_Impl::updateFilterOptionsBox() 466 { 467 if ( !m_bHaveFilterOptions ) 468 return; 469 470 updateExtendedControl( 471 ExtendedFilePickerElementIds::CHECKBOX_FILTEROPTIONS, 472 CheckFilterOptionsCapability( getCurentSfxFilter() ) 473 ); 474 } 475 476 // ------------------------------------------------------------------------ 477 478 void FileDialogHelper_Impl::updateExportButton() 479 { 480 uno::Reference < XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY ); 481 if ( xCtrlAccess.is() ) 482 { 483 OUString sEllipses( RTL_CONSTASCII_USTRINGPARAM( "..." ) ); 484 OUString sOldLabel( xCtrlAccess->getLabel( CommonFilePickerElementIds::PUSHBUTTON_OK ) ); 485 486 // initialize button label; we need the label with the mnemonic char 487 if ( !maButtonLabel.getLength() || maButtonLabel.indexOf( MNEMONIC_CHAR ) == -1 ) 488 { 489 // cut the ellipses, if necessary 490 sal_Int32 nIndex = sOldLabel.indexOf( sEllipses ); 491 if ( -1 == nIndex ) 492 nIndex = sOldLabel.getLength(); 493 maButtonLabel = sOldLabel.copy( 0, nIndex ); 494 } 495 496 OUString sLabel = maButtonLabel; 497 // filter with options -> append ellipses on export button label 498 if ( CheckFilterOptionsCapability( getCurentSfxFilter() ) ) 499 sLabel += OUString( RTL_CONSTASCII_USTRINGPARAM( "..." ) ); 500 501 if ( sOldLabel != sLabel ) 502 { 503 try 504 { 505 xCtrlAccess->setLabel( CommonFilePickerElementIds::PUSHBUTTON_OK, sLabel ); 506 } 507 catch( const IllegalArgumentException& ) 508 { 509 DBG_ERRORFILE( "FileDialogHelper_Impl::updateExportButton: caught an exception!" ); 510 } 511 } 512 } 513 } 514 515 // ------------------------------------------------------------------------ 516 void FileDialogHelper_Impl::updateSelectionBox() 517 { 518 if ( !mbHasSelectionBox ) 519 return; 520 521 // Does the selection box exist? 522 sal_Bool bSelectionBoxFound = sal_False; 523 uno::Reference< XControlInformation > xCtrlInfo( mxFileDlg, UNO_QUERY ); 524 if ( xCtrlInfo.is() ) 525 { 526 Sequence< ::rtl::OUString > aCtrlList = xCtrlInfo->getSupportedControls(); 527 sal_uInt32 nCount = aCtrlList.getLength(); 528 for ( sal_uInt32 nCtrl = 0; nCtrl < nCount; ++nCtrl ) 529 if ( aCtrlList[ nCtrl ].equalsAscii("SelectionBox") ) 530 { 531 bSelectionBoxFound = sal_False; 532 break; 533 } 534 } 535 536 if ( bSelectionBoxFound ) 537 { 538 const SfxFilter* pFilter = getCurentSfxFilter(); 539 mbSelectionFltrEnabled = updateExtendedControl( 540 ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 541 ( mbSelectionEnabled && pFilter && ( pFilter->GetFilterFlags() & SFX_FILTER_SUPPORTSSELECTION ) != 0 ) ); 542 uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY ); 543 xCtrlAccess->setValue( ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 0, makeAny( (sal_Bool)mbSelection ) ); 544 } 545 } 546 547 // ------------------------------------------------------------------------ 548 void FileDialogHelper_Impl::enablePasswordBox( sal_Bool bInit ) 549 { 550 if ( ! mbHasPassword ) 551 return; 552 553 sal_Bool bWasEnabled = mbIsPwdEnabled; 554 555 const SfxFilter* pCurrentFilter = getCurentSfxFilter(); 556 mbIsPwdEnabled = updateExtendedControl( 557 ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 558 pCurrentFilter && ( pCurrentFilter->GetFilterFlags() & SFX_FILTER_ENCRYPTION ) 559 ); 560 561 if( bInit ) 562 { 563 // in case of inintialization previous state is not interesting 564 if( mbIsPwdEnabled ) 565 { 566 uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY ); 567 if( mbPwdCheckBoxState ) 568 xCtrlAccess->setValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0, makeAny( sal_True ) ); 569 } 570 } 571 else if( !bWasEnabled && mbIsPwdEnabled ) 572 { 573 uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY ); 574 if( mbPwdCheckBoxState ) 575 xCtrlAccess->setValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0, makeAny( sal_True ) ); 576 } 577 else if( bWasEnabled && !mbIsPwdEnabled ) 578 { 579 // remember user settings until checkbox is enabled 580 uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY ); 581 Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0 ); 582 sal_Bool bPassWord = sal_False; 583 mbPwdCheckBoxState = ( aValue >>= bPassWord ) && bPassWord; 584 xCtrlAccess->setValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0, makeAny( sal_False ) ); 585 } 586 } 587 588 // ------------------------------------------------------------------------ 589 void FileDialogHelper_Impl::updatePreviewState( sal_Bool _bUpdatePreviewWindow ) 590 { 591 if ( mbHasPreview ) 592 { 593 uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY ); 594 595 // check, wether or not we have to display a preview 596 if ( xCtrlAccess.is() ) 597 { 598 try 599 { 600 Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_PREVIEW, 0 ); 601 sal_Bool bShowPreview = sal_False; 602 603 if ( aValue >>= bShowPreview ) 604 { 605 mbShowPreview = bShowPreview; 606 607 // #97633 608 // setShowState has currently no effect for the 609 // OpenOffice FilePicker (see svtools/source/filepicker/iodlg.cxx) 610 uno::Reference< XFilePreview > xFilePreview( mxFileDlg, UNO_QUERY ); 611 if ( xFilePreview.is() ) 612 xFilePreview->setShowState( mbShowPreview ); 613 614 if ( _bUpdatePreviewWindow ) 615 TimeOutHdl_Impl( NULL ); 616 } 617 } 618 catch( Exception ) 619 { 620 DBG_ERRORFILE( "FileDialogHelper_Impl::updatePreviewState: caught an exception!" ); 621 } 622 } 623 } 624 } 625 626 // ------------------------------------------------------------------------ 627 void FileDialogHelper_Impl::updateVersions() 628 { 629 Sequence < OUString > aEntries; 630 Sequence < OUString > aPathSeq = mxFileDlg->getFiles(); 631 632 if ( aPathSeq.getLength() == 1 ) 633 { 634 INetURLObject aObj( aPathSeq[0] ); 635 636 if ( ( aObj.GetProtocol() == INET_PROT_FILE ) && 637 ( utl::UCBContentHelper::IsDocument( aObj.GetMainURL( INetURLObject::NO_DECODE ) ) ) ) 638 { 639 try 640 { 641 uno::Reference< embed::XStorage > xStorage = ::comphelper::OStorageHelper::GetStorageFromURL( 642 aObj.GetMainURL( INetURLObject::NO_DECODE ), 643 embed::ElementModes::READ ); 644 645 DBG_ASSERT( xStorage.is(), "The method must return the storage or throw an exception!" ); 646 if ( !xStorage.is() ) 647 throw uno::RuntimeException(); 648 649 uno::Sequence < util::RevisionTag > xVersions = SfxMedium::GetVersionList( xStorage ); 650 651 aEntries.realloc( xVersions.getLength() + 1 ); 652 aEntries[0] = OUString( String ( SfxResId( STR_SFX_FILEDLG_ACTUALVERSION ) ) ); 653 654 for ( sal_Int32 i=0; i<xVersions.getLength(); i++ ) 655 aEntries[ i + 1 ] = xVersions[i].Identifier; 656 657 // TODO/LATER: not sure that this information must be shown in future ( binfilter? ) 658 //REMOVE else 659 //REMOVE { 660 //REMOVE SfxFilterFlags nMust = SFX_FILTER_IMPORT | SFX_FILTER_OWN; 661 //REMOVE SfxFilterFlags nDont = SFX_FILTER_NOTINSTALLED | SFX_FILTER_STARONEFILTER; 662 //REMOVE if ( SFX_APP()->GetFilterMatcher().GetFilter4ClipBoardId( pStor->GetFormat(), nMust, nDont ) ) 663 //REMOVE { 664 //REMOVE aEntries.realloc( 1 ); 665 //REMOVE aEntries[0] = OUString( String ( SfxResId( STR_SFX_FILEDLG_ACTUALVERSION ) ) ); 666 //REMOVE } 667 //REMOVE } 668 } 669 catch( uno::Exception& ) 670 { 671 } 672 } 673 } 674 675 uno::Reference < XFilePickerControlAccess > xDlg( mxFileDlg, UNO_QUERY ); 676 Any aValue; 677 678 try 679 { 680 xDlg->setValue( ExtendedFilePickerElementIds::LISTBOX_VERSION, 681 ControlActions::DELETE_ITEMS, aValue ); 682 } 683 catch( IllegalArgumentException ){} 684 685 sal_Int32 nCount = aEntries.getLength(); 686 687 if ( nCount ) 688 { 689 try 690 { 691 aValue <<= aEntries; 692 xDlg->setValue( ExtendedFilePickerElementIds::LISTBOX_VERSION, 693 ControlActions::ADD_ITEMS, aValue ); 694 695 Any aPos; 696 aPos <<= (sal_Int32) 0; 697 xDlg->setValue( ExtendedFilePickerElementIds::LISTBOX_VERSION, 698 ControlActions::SET_SELECT_ITEM, aPos ); 699 } 700 catch( IllegalArgumentException ){} 701 } 702 } 703 704 // ----------------------------------------------------------------------- 705 class OReleaseSolarMutex 706 { 707 private: 708 const sal_Int32 m_nAquireCount; 709 public: 710 OReleaseSolarMutex( ) 711 :m_nAquireCount( Application::ReleaseSolarMutex() ) 712 { 713 } 714 ~OReleaseSolarMutex( ) 715 { 716 Application::AcquireSolarMutex( m_nAquireCount ); 717 } 718 }; 719 720 // ----------------------------------------------------------------------- 721 IMPL_LINK( FileDialogHelper_Impl, TimeOutHdl_Impl, Timer*, EMPTYARG ) 722 { 723 if ( !mbHasPreview ) 724 return 0; 725 726 maGraphic.Clear(); 727 728 Any aAny; 729 uno::Reference < XFilePreview > xFilePicker( mxFileDlg, UNO_QUERY ); 730 731 if ( ! xFilePicker.is() ) 732 return 0; 733 734 Sequence < OUString > aPathSeq = mxFileDlg->getFiles(); 735 736 if ( mbShowPreview && ( aPathSeq.getLength() == 1 ) ) 737 { 738 OUString aURL = aPathSeq[0]; 739 740 if ( ERRCODE_NONE == getGraphic( aURL, maGraphic ) ) 741 { 742 // #89491 743 // changed the code slightly; 744 // before: the bitmap was scaled and 745 // surrounded a white frame 746 // now: the bitmap will only be scaled 747 // and the filepicker implementation 748 // is responsible for placing it at its 749 // proper position and painting a frame 750 751 Bitmap aBmp = maGraphic.GetBitmap(); 752 if ( !aBmp.IsEmpty() ) 753 { 754 // scale the bitmap to the correct size 755 sal_Int32 nOutWidth = xFilePicker->getAvailableWidth(); 756 sal_Int32 nOutHeight = xFilePicker->getAvailableHeight(); 757 sal_Int32 nBmpWidth = aBmp.GetSizePixel().Width(); 758 sal_Int32 nBmpHeight = aBmp.GetSizePixel().Height(); 759 760 double nXRatio = (double) nOutWidth / nBmpWidth; 761 double nYRatio = (double) nOutHeight / nBmpHeight; 762 763 if ( nXRatio < nYRatio ) 764 aBmp.Scale( nXRatio, nXRatio ); 765 else 766 aBmp.Scale( nYRatio, nYRatio ); 767 768 // #94505# Convert to true color, to allow CopyPixel 769 aBmp.Convert( BMP_CONVERSION_24BIT ); 770 771 // and copy it into the Any 772 SvMemoryStream aData; 773 774 WriteDIB(aBmp, aData, false, true); 775 776 const Sequence < sal_Int8 > aBuffer( 777 static_cast< const sal_Int8* >(aData.GetData()), 778 aData.GetEndOfData() ); 779 780 aAny <<= aBuffer; 781 } 782 } 783 } 784 785 try 786 { 787 OReleaseSolarMutex aReleaseForCallback; 788 // clear the preview window 789 xFilePicker->setImage( FilePreviewImageFormats::BITMAP, aAny ); 790 } 791 catch( IllegalArgumentException ) 792 { 793 } 794 795 return 0; 796 } 797 798 // ------------------------------------------------------------------------ 799 ErrCode FileDialogHelper_Impl::getGraphic( const OUString& rURL, 800 Graphic& rGraphic ) const 801 { 802 if ( utl::UCBContentHelper::IsFolder( rURL ) ) 803 return ERRCODE_IO_NOTAFILE; 804 805 if ( !mpGraphicFilter ) 806 return ERRCODE_IO_NOTSUPPORTED; 807 808 // select graphic filter from dialog filter selection 809 OUString aCurFilter( getFilter() ); 810 811 sal_uInt16 nFilter = aCurFilter.getLength() && mpGraphicFilter->GetImportFormatCount() 812 ? mpGraphicFilter->GetImportFormatNumber( aCurFilter ) 813 : GRFILTER_FORMAT_DONTKNOW; 814 815 INetURLObject aURLObj( rURL ); 816 817 if ( aURLObj.HasError() || INET_PROT_NOT_VALID == aURLObj.GetProtocol() ) 818 { 819 aURLObj.SetSmartProtocol( INET_PROT_FILE ); 820 aURLObj.SetSmartURL( rURL ); 821 } 822 823 ErrCode nRet = ERRCODE_NONE; 824 825 sal_uInt32 nFilterImportFlags = GRFILTER_I_FLAGS_SET_LOGSIZE_FOR_JPEG; 826 // non-local? 827 if ( INET_PROT_FILE != aURLObj.GetProtocol() ) 828 { 829 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( rURL, STREAM_READ ); 830 831 if( pStream ) 832 nRet = mpGraphicFilter->ImportGraphic( rGraphic, rURL, *pStream, nFilter, NULL, nFilterImportFlags ); 833 else 834 nRet = mpGraphicFilter->ImportGraphic( rGraphic, aURLObj, nFilter, NULL, nFilterImportFlags ); 835 delete pStream; 836 } 837 else 838 { 839 nRet = mpGraphicFilter->ImportGraphic( rGraphic, aURLObj, nFilter, NULL, nFilterImportFlags ); 840 } 841 842 return nRet; 843 } 844 845 // ------------------------------------------------------------------------ 846 ErrCode FileDialogHelper_Impl::getGraphic( Graphic& rGraphic ) const 847 { 848 ErrCode nRet = ERRCODE_NONE; 849 850 if ( ! maGraphic ) 851 { 852 OUString aPath;; 853 Sequence < OUString > aPathSeq = mxFileDlg->getFiles(); 854 855 if ( aPathSeq.getLength() == 1 ) 856 { 857 aPath = aPathSeq[0]; 858 } 859 860 if ( aPath.getLength() ) 861 nRet = getGraphic( aPath, rGraphic ); 862 else 863 nRet = ERRCODE_IO_GENERAL; 864 } 865 else 866 rGraphic = maGraphic; 867 868 return nRet; 869 } 870 871 // ------------------------------------------------------------------------ 872 sal_Bool lcl_isSystemFilePicker( const uno::Reference< XFilePicker >& _rxFP ) 873 { 874 try 875 { 876 uno::Reference< XServiceInfo > xSI( _rxFP, UNO_QUERY ); 877 if ( xSI.is() && xSI->supportsService( DEFINE_CONST_OUSTRING( "com.sun.star.ui.dialogs.SystemFilePicker" ) ) ) 878 return sal_True; 879 } 880 catch( const Exception& ) 881 { 882 } 883 return sal_False; 884 } 885 886 887 // ------------------------------------------------------------------------ 888 // ----------- FileDialogHelper_Impl --------------------------- 889 // ------------------------------------------------------------------------ 890 891 FileDialogHelper_Impl::FileDialogHelper_Impl( 892 FileDialogHelper* _pAntiImpl, 893 sal_Int16 nDialogType, 894 sal_Int64 nFlags, 895 sal_Int16 nDialog, 896 Window* _pPreferredParentWindow, 897 const String& sStandardDir, 898 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& rBlackList 899 ) 900 :m_nDialogType ( nDialogType ) 901 ,meContext ( FileDialogHelper::UNKNOWN_CONTEXT ) 902 { 903 const char* pServiceName=0; 904 if ( nDialog == SFX2_IMPL_DIALOG_SYSTEM ) 905 pServiceName = FILE_OPEN_SERVICE_NAME_OOO; 906 else if ( nDialog == SFX2_IMPL_DIALOG_OOO ) 907 pServiceName = FILE_OPEN_SERVICE_NAME_OOO; 908 else 909 pServiceName = FILE_OPEN_SERVICE_NAME; 910 OUString aService = ::rtl::OUString::createFromAscii( pServiceName ); 911 912 uno::Reference< XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() ); 913 914 // create the file open dialog 915 // the flags can be SFXWB_INSERT or SFXWB_MULTISELECTION 916 917 mpPreferredParentWindow = _pPreferredParentWindow; 918 mpAntiImpl = _pAntiImpl; 919 mnError = ERRCODE_NONE; 920 mbHasAutoExt = sal_False; 921 mbHasPassword = sal_False; 922 m_bHaveFilterOptions = sal_False; 923 mbIsPwdEnabled = sal_True; 924 mbHasVersions = sal_False; 925 mbHasPreview = sal_False; 926 mbShowPreview = sal_False; 927 mbHasLink = sal_False; 928 mbDeleteMatcher = sal_False; 929 mbInsert = SFXWB_INSERT == ( nFlags & SFXWB_INSERT ); 930 mbExport = SFXWB_EXPORT == ( nFlags & SFXWB_EXPORT ); 931 mbIsSaveDlg = sal_False; 932 mbPwdCheckBoxState = sal_False; 933 mbSelection = sal_False; 934 mbSelectionEnabled = sal_True; 935 mbHasSelectionBox = sal_False; 936 mbSelectionFltrEnabled = sal_False; 937 938 // default settings 939 m_nDontFlags = SFX_FILTER_INTERNAL | SFX_FILTER_NOTINFILEDLG | SFX_FILTER_NOTINSTALLED; 940 if( WB_OPEN == ( nFlags & WB_OPEN ) ) 941 m_nMustFlags = SFX_FILTER_IMPORT; 942 else 943 m_nMustFlags = SFX_FILTER_EXPORT; 944 945 946 mpMatcher = NULL; 947 mpGraphicFilter = NULL; 948 mnPostUserEventId = 0; 949 950 // create the picker component 951 mxFileDlg = mxFileDlg.query( xFactory->createInstance( aService ) ); 952 mbSystemPicker = lcl_isSystemFilePicker( mxFileDlg ); 953 954 uno::Reference< XFilePickerNotifier > xNotifier( mxFileDlg, UNO_QUERY ); 955 uno::Reference< XInitialization > xInit( mxFileDlg, UNO_QUERY ); 956 957 if ( ! mxFileDlg.is() || ! xNotifier.is() ) 958 { 959 mnError = ERRCODE_ABORT; 960 return; 961 } 962 963 964 if ( xInit.is() ) 965 { 966 sal_Int16 nTemplateDescription = TemplateDescription::FILEOPEN_SIMPLE; 967 968 switch ( m_nDialogType ) 969 { 970 case FILEOPEN_SIMPLE: 971 nTemplateDescription = TemplateDescription::FILEOPEN_SIMPLE; 972 break; 973 974 case FILESAVE_SIMPLE: 975 nTemplateDescription = TemplateDescription::FILESAVE_SIMPLE; 976 mbIsSaveDlg = sal_True; 977 break; 978 979 case FILESAVE_AUTOEXTENSION_PASSWORD: 980 nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD; 981 mbHasPassword = sal_True; 982 mbHasAutoExt = sal_True; 983 mbIsSaveDlg = sal_True; 984 break; 985 986 case FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS: 987 nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS; 988 mbHasPassword = sal_True; 989 990 m_bHaveFilterOptions = sal_True; 991 if( xFactory.is() ) 992 { 993 mxFilterCFG = uno::Reference< XNameAccess >( 994 xFactory->createInstance( DEFINE_CONST_OUSTRING( "com.sun.star.document.FilterFactory" ) ), 995 UNO_QUERY ); 996 } 997 998 mbHasAutoExt = sal_True; 999 mbIsSaveDlg = sal_True; 1000 break; 1001 1002 case FILESAVE_AUTOEXTENSION_SELECTION: 1003 nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION_SELECTION; 1004 mbHasAutoExt = sal_True; 1005 mbIsSaveDlg = sal_True; 1006 mbHasSelectionBox = sal_True; 1007 if ( mbExport && !mxFilterCFG.is() && xFactory.is() ) 1008 { 1009 mxFilterCFG = uno::Reference< XNameAccess >( 1010 xFactory->createInstance( DEFINE_CONST_OUSTRING( "com.sun.star.document.FilterFactory" ) ), 1011 UNO_QUERY ); 1012 } 1013 break; 1014 1015 case FILESAVE_AUTOEXTENSION_TEMPLATE: 1016 nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION_TEMPLATE; 1017 mbHasAutoExt = sal_True; 1018 mbIsSaveDlg = sal_True; 1019 break; 1020 1021 case FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE: 1022 nTemplateDescription = TemplateDescription::FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE; 1023 mbHasPreview = sal_True; 1024 mbHasLink = sal_True; 1025 1026 // aPreviewTimer 1027 maPreViewTimer.SetTimeout( 500 ); 1028 maPreViewTimer.SetTimeoutHdl( LINK( this, FileDialogHelper_Impl, TimeOutHdl_Impl ) ); 1029 break; 1030 1031 case FILEOPEN_PLAY: 1032 nTemplateDescription = TemplateDescription::FILEOPEN_PLAY; 1033 break; 1034 1035 case FILEOPEN_READONLY_VERSION: 1036 nTemplateDescription = TemplateDescription::FILEOPEN_READONLY_VERSION; 1037 mbHasVersions = sal_True; 1038 break; 1039 1040 case FILEOPEN_LINK_PREVIEW: 1041 nTemplateDescription = TemplateDescription::FILEOPEN_LINK_PREVIEW; 1042 mbHasPreview = sal_True; 1043 mbHasLink = sal_True; 1044 // aPreviewTimer 1045 maPreViewTimer.SetTimeout( 500 ); 1046 maPreViewTimer.SetTimeoutHdl( LINK( this, FileDialogHelper_Impl, TimeOutHdl_Impl ) ); 1047 break; 1048 1049 case FILESAVE_AUTOEXTENSION: 1050 nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION; 1051 mbHasAutoExt = sal_True; 1052 mbIsSaveDlg = sal_True; 1053 break; 1054 1055 default: 1056 DBG_ERRORFILE( "FileDialogHelper::ctor with unknown type" ); 1057 break; 1058 } 1059 1060 1061 1062 //Sequence < Any > aInitArguments( mbSystemPicker || !mpPreferredParentWindow ? 1 : 3 ); 1063 Sequence < Any > aInitArguments( !mpPreferredParentWindow ? 3 : 4 ); 1064 1065 // This is a hack. We currently know that the internal file picker implementation 1066 // supports the extended arguments as specified below. 1067 // TODO: 1068 // a) adjust the service description so that it includes the TemplateDescription and ParentWindow args 1069 // b) adjust the implementation of the system file picker to that it recognizes it 1070 if ( mbSystemPicker ) 1071 { 1072 aInitArguments[0] <<= nTemplateDescription; 1073 } 1074 else 1075 { 1076 aInitArguments[0] <<= NamedValue( 1077 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TemplateDescription" ) ), 1078 makeAny( nTemplateDescription ) 1079 ); 1080 1081 ::rtl::OUString sStandardDirTemp = ::rtl::OUString( sStandardDir ); 1082 1083 aInitArguments[1] <<= NamedValue( 1084 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StandardDir" ) ), 1085 makeAny( sStandardDirTemp ) 1086 ); 1087 1088 aInitArguments[2] <<= NamedValue( 1089 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "BlackList" ) ), 1090 makeAny( rBlackList ) 1091 ); 1092 1093 1094 if ( mpPreferredParentWindow ) 1095 aInitArguments[3] <<= NamedValue( 1096 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ParentWindow" ) ), 1097 makeAny( VCLUnoHelper::GetInterface( mpPreferredParentWindow ) ) 1098 ); 1099 1100 1101 } 1102 1103 try 1104 { 1105 xInit->initialize( aInitArguments ); 1106 } 1107 catch( const Exception& ) 1108 { 1109 DBG_ERROR( "FileDialogHelper_Impl::FileDialogHelper_Impl: could not initialize the picker!" ); 1110 } 1111 } 1112 1113 1114 // set multiselection mode 1115 if ( nFlags & SFXWB_MULTISELECTION ) 1116 mxFileDlg->setMultiSelectionMode( sal_True ); 1117 1118 if ( mbHasLink ) // generate graphic filter only on demand 1119 addGraphicFilter(); 1120 1121 // Export dialog 1122 if ( mbExport ) 1123 { 1124 mxFileDlg->setTitle( OUString( String( SfxResId( STR_SFX_EXPLORERFILE_EXPORT ) ) ) ); 1125 try { 1126 com::sun::star::uno::Reference < XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY_THROW ); 1127 xCtrlAccess->enableControl( ExtendedFilePickerElementIds::LISTBOX_FILTER_SELECTOR, sal_True ); 1128 } 1129 catch( const Exception & ) { } 1130 } 1131 1132 // the "insert file" dialog needs another title 1133 if ( mbInsert ) 1134 { 1135 mxFileDlg->setTitle( OUString( String( SfxResId( STR_SFX_EXPLORERFILE_INSERT ) ) ) ); 1136 uno::Reference < XFilePickerControlAccess > xExtDlg( mxFileDlg, UNO_QUERY ); 1137 if ( xExtDlg.is() ) 1138 { 1139 try 1140 { 1141 xExtDlg->setLabel( CommonFilePickerElementIds::PUSHBUTTON_OK, 1142 OUString( String( SfxResId( STR_SFX_EXPLORERFILE_BUTTONINSERT ) ) ) ); 1143 } 1144 catch( IllegalArgumentException ){} 1145 } 1146 } 1147 1148 // add the event listener 1149 xNotifier->addFilePickerListener( this ); 1150 } 1151 1152 // ------------------------------------------------------------------------ 1153 FileDialogHelper_Impl::~FileDialogHelper_Impl() 1154 { 1155 // Remove user event if we haven't received it yet 1156 if ( mnPostUserEventId ) 1157 Application::RemoveUserEvent( mnPostUserEventId ); 1158 mnPostUserEventId = 0; 1159 1160 delete mpGraphicFilter; 1161 1162 if ( mbDeleteMatcher ) 1163 delete mpMatcher; 1164 1165 maPreViewTimer.SetTimeoutHdl( Link() ); 1166 1167 ::comphelper::disposeComponent( mxFileDlg ); 1168 } 1169 1170 #define nMagic -1 1171 1172 class PickerThread_Impl : public ::vos::OThread 1173 { 1174 uno::Reference < XFilePicker > mxPicker; 1175 ::vos::OMutex maMutex; 1176 virtual void SAL_CALL run(); 1177 sal_Int16 mnRet; 1178 public: 1179 PickerThread_Impl( const uno::Reference < XFilePicker >& rPicker ) 1180 : mxPicker( rPicker ), mnRet(nMagic) {} 1181 1182 sal_Int16 GetReturnValue() 1183 { ::vos::OGuard aGuard( maMutex ); return mnRet; } 1184 1185 void SetReturnValue( sal_Int16 aRetValue ) 1186 { ::vos::OGuard aGuard( maMutex ); mnRet = aRetValue; } 1187 }; 1188 1189 void SAL_CALL PickerThread_Impl::run() 1190 { 1191 try 1192 { 1193 sal_Int16 n = mxPicker->execute(); 1194 SetReturnValue( n ); 1195 } 1196 catch( RuntimeException& ) 1197 { 1198 SetReturnValue( ExecutableDialogResults::CANCEL ); 1199 DBG_ERRORFILE( "RuntimeException caught" ); 1200 } 1201 } 1202 1203 // ------------------------------------------------------------------------ 1204 void FileDialogHelper_Impl::setControlHelpIds( const sal_Int16* _pControlId, const char** _pHelpId ) 1205 { 1206 DBG_ASSERT( _pControlId && _pHelpId, "FileDialogHelper_Impl::setControlHelpIds: invalid array pointers!" ); 1207 if ( !_pControlId || !_pHelpId ) 1208 return; 1209 1210 // forward these ids to the file picker 1211 try 1212 { 1213 const ::rtl::OUString sHelpIdPrefix( RTL_CONSTASCII_USTRINGPARAM( INET_HID_SCHEME ) ); 1214 // the ids for the single controls 1215 uno::Reference< XFilePickerControlAccess > xControlAccess( mxFileDlg, UNO_QUERY ); 1216 if ( xControlAccess.is() ) 1217 { 1218 while ( *_pControlId ) 1219 { 1220 DBG_ASSERT( INetURLObject( rtl::OStringToOUString( *_pHelpId, RTL_TEXTENCODING_UTF8 ) ).GetProtocol() == INET_PROT_NOT_VALID, "Wrong HelpId!" ); 1221 ::rtl::OUString sId( sHelpIdPrefix ); 1222 sId += ::rtl::OUString( *_pHelpId, strlen( *_pHelpId ), RTL_TEXTENCODING_UTF8 ); 1223 xControlAccess->setValue( *_pControlId, ControlActions::SET_HELP_URL, makeAny( sId ) ); 1224 1225 ++_pControlId; ++_pHelpId; 1226 } 1227 } 1228 } 1229 catch( const Exception& ) 1230 { 1231 DBG_ERROR( "FileDialogHelper_Impl::setControlHelpIds: caught an exception while setting the help ids!" ); 1232 } 1233 } 1234 1235 // ------------------------------------------------------------------------ 1236 IMPL_LINK( FileDialogHelper_Impl, InitControls, void*, NOTINTERESTEDIN ) 1237 { 1238 (void)NOTINTERESTEDIN; 1239 mnPostUserEventId = 0; 1240 enablePasswordBox( sal_True ); 1241 updateFilterOptionsBox( ); 1242 updateSelectionBox( ); 1243 1244 return 0L; 1245 } 1246 1247 // ------------------------------------------------------------------------ 1248 void FileDialogHelper_Impl::preExecute() 1249 { 1250 loadConfig( ); 1251 setDefaultValues( ); 1252 updatePreviewState( sal_False ); 1253 1254 implInitializeFileName( ); 1255 // #106079# / 2002-12-09 / fs@openoffice.org 1256 1257 #if !(defined(MACOSX) && defined(QUARTZ)) && !defined(WNT) 1258 // allow for dialog implementations which need to be executed before they return valid values for 1259 // current filter and such 1260 1261 // On Vista (at least SP1) it's the same as on MacOSX, the modal dialog won't let message pass 1262 // through before it returns from execution 1263 mnPostUserEventId = Application::PostUserEvent( LINK( this, FileDialogHelper_Impl, InitControls ) ); 1264 #else 1265 // However, the Mac OS X implementation's pickers run modally in execute and so the event doesn't 1266 // get through in time... so we call the methods directly 1267 enablePasswordBox( sal_True ); 1268 updateFilterOptionsBox( ); 1269 updateSelectionBox( ); 1270 #endif 1271 } 1272 1273 // ------------------------------------------------------------------------ 1274 void FileDialogHelper_Impl::postExecute( sal_Int16 _nResult ) 1275 { 1276 if ( ExecutableDialogResults::CANCEL != _nResult ) 1277 saveConfig(); 1278 } 1279 1280 // ------------------------------------------------------------------------ 1281 void FileDialogHelper_Impl::implInitializeFileName( ) 1282 { 1283 if ( maFileName.getLength() ) 1284 { 1285 INetURLObject aObj( maPath ); 1286 aObj.Append( maFileName ); 1287 1288 // in case we're operating as save dialog, and "auto extension" is checked, 1289 // cut the extension from the name 1290 // #106079# / 2002-12-09 / fs@openoffice.org 1291 if ( mbIsSaveDlg && mbHasAutoExt ) 1292 { 1293 try 1294 { 1295 sal_Bool bAutoExtChecked = sal_False; 1296 1297 uno::Reference < XFilePickerControlAccess > xControlAccess( mxFileDlg, UNO_QUERY ); 1298 if ( xControlAccess.is() 1299 && ( xControlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0 ) 1300 >>= bAutoExtChecked 1301 ) 1302 ) 1303 { 1304 if ( bAutoExtChecked ) 1305 { // cut the extension 1306 aObj.removeExtension( ); 1307 mxFileDlg->setDefaultName( aObj.GetName( INetURLObject::DECODE_WITH_CHARSET ) ); 1308 } 1309 } 1310 } 1311 catch( const Exception& ) 1312 { 1313 DBG_ERROR( "FileDialogHelper_Impl::implInitializeFileName: could not ask for the auto-extension current-value!" ); 1314 } 1315 } 1316 } 1317 } 1318 1319 // ------------------------------------------------------------------------ 1320 sal_Int16 FileDialogHelper_Impl::implDoExecute() 1321 { 1322 preExecute(); 1323 1324 sal_Int16 nRet = ExecutableDialogResults::CANCEL; 1325 1326 //On MacOSX the native file picker has to run in the primordial thread because of drawing issues 1327 //On Linux the native gtk file picker, when backed by gnome-vfs2, needs to be run in the same 1328 //primordial thread as the ucb gnome-vfs2 provider was initialized in. 1329 /* 1330 #ifdef WNT 1331 if ( mbSystemPicker ) 1332 { 1333 PickerThread_Impl* pThread = new PickerThread_Impl( mxFileDlg ); 1334 pThread->create(); 1335 while ( pThread->GetReturnValue() == nMagic ) 1336 Application::Yield(); 1337 pThread->join(); 1338 nRet = pThread->GetReturnValue(); 1339 delete pThread; 1340 } 1341 else 1342 #endif 1343 */ 1344 { 1345 try 1346 { 1347 #ifdef WNT 1348 if ( mbSystemPicker ) 1349 { 1350 OReleaseSolarMutex aSolarMutex; 1351 nRet = mxFileDlg->execute(); 1352 } 1353 else 1354 #endif 1355 nRet = mxFileDlg->execute(); 1356 } 1357 catch( const Exception& ) 1358 { 1359 DBG_ERRORFILE( "FileDialogHelper_Impl::implDoExecute: caught an exception!" ); 1360 } 1361 } 1362 1363 postExecute( nRet ); 1364 1365 return nRet; 1366 } 1367 1368 // ------------------------------------------------------------------------ 1369 void FileDialogHelper_Impl::implStartExecute() 1370 { 1371 DBG_ASSERT( mxFileDlg.is(), "invalid file dialog" ); 1372 1373 preExecute(); 1374 1375 if ( mbSystemPicker ) 1376 { 1377 } 1378 else 1379 { 1380 try 1381 { 1382 uno::Reference< XAsynchronousExecutableDialog > xAsyncDlg( mxFileDlg, UNO_QUERY ); 1383 if ( xAsyncDlg.is() ) 1384 xAsyncDlg->startExecuteModal( this ); 1385 } 1386 catch( const Exception& ) 1387 { 1388 DBG_ERRORFILE( "FileDialogHelper_Impl::implDoExecute: caught an exception!" ); 1389 } 1390 } 1391 } 1392 1393 // ------------------------------------------------------------------------ 1394 String FileDialogHelper_Impl::implEnsureURLExtension(const String& sURL, 1395 const String& /*sExtension*/) 1396 { 1397 return sURL; 1398 /* 1399 // This feature must be active for file save/export only ! 1400 if ( 1401 (! mbIsSaveDlg) && 1402 (! mbExport ) 1403 ) 1404 return sURL; 1405 1406 // no extension available (because "ALL *.*" was selected) ? 1407 // Nod idea what else should happen here .-) 1408 if (sExtension.Len() < 1) 1409 return sURL; 1410 1411 // Some FilePicker implementations already add the right extension ... 1412 // or might be the user used the right one already ... 1413 // Dont create duplicate extension. 1414 INetURLObject aURL(sURL); 1415 if (aURL.getExtension().equals(sExtension)) 1416 return sURL; 1417 1418 // Ignore any other extension set by the user. 1419 // Make sure suitable extension is used always. 1420 // e.g. "test.bla.odt" for "ODT" 1421 ::rtl::OUStringBuffer sNewURL(256); 1422 sNewURL.append (sURL ); 1423 sNewURL.appendAscii("." ); 1424 sNewURL.append (sExtension); 1425 return sNewURL.makeStringAndClear(); 1426 */ 1427 } 1428 1429 // ------------------------------------------------------------------------ 1430 void lcl_saveLastURLs(SvStringsDtor*& rpURLList , 1431 ::comphelper::SequenceAsVector< ::rtl::OUString >& lLastURLs ) 1432 { 1433 lLastURLs.clear(); 1434 sal_uInt16 c = rpURLList->Count(); 1435 sal_uInt16 i = 0; 1436 for (i=0; i<c; ++i) 1437 lLastURLs.push_back(*(rpURLList->GetObject(i))); 1438 } 1439 1440 // ------------------------------------------------------------------------ 1441 void FileDialogHelper_Impl::implGetAndCacheFiles(const uno::Reference< XInterface >& xPicker , 1442 SvStringsDtor*& rpURLList, 1443 const SfxFilter* pFilter ) 1444 { 1445 rpURLList = NULL; 1446 1447 String sExtension; 1448 if (pFilter) 1449 { 1450 sExtension = pFilter->GetDefaultExtension (); 1451 sExtension.EraseAllChars( '*' ); 1452 sExtension.EraseAllChars( '.' ); 1453 } 1454 1455 // a) the new way (optional!) 1456 uno::Reference< XFilePicker2 > xPickNew(xPicker, UNO_QUERY); 1457 if (xPickNew.is()) 1458 { 1459 rpURLList = new SvStringsDtor; 1460 Sequence< OUString > lFiles = xPickNew->getSelectedFiles(); 1461 ::sal_Int32 nFiles = lFiles.getLength(); 1462 for (::sal_Int32 i = 0; i < nFiles; i++) 1463 { 1464 String* pURL = new String(implEnsureURLExtension(lFiles[i], sExtension)); 1465 rpURLList->Insert( pURL, rpURLList->Count() ); 1466 } 1467 } 1468 1469 // b) the olde way ... non optional. 1470 else 1471 { 1472 uno::Reference< XFilePicker > xPickOld(xPicker, UNO_QUERY_THROW); 1473 Sequence< OUString > lFiles = xPickOld->getFiles(); 1474 ::sal_Int32 nFiles = lFiles.getLength(); 1475 if ( nFiles == 1 ) 1476 { 1477 rpURLList = new SvStringsDtor; 1478 String* pURL = new String(implEnsureURLExtension(lFiles[0], sExtension)); 1479 rpURLList->Insert( pURL, 0 ); 1480 } 1481 else 1482 if ( nFiles > 1 ) 1483 { 1484 rpURLList = new SvStringsDtor; 1485 1486 INetURLObject aPath( lFiles[0] ); 1487 aPath.setFinalSlash(); 1488 1489 for (::sal_Int32 i = 1; i < nFiles; i++) 1490 { 1491 if (i == 1) 1492 aPath.Append( lFiles[i] ); 1493 else 1494 aPath.setName( lFiles[i] ); 1495 1496 String* pURL = new String(implEnsureURLExtension(aPath.GetMainURL( INetURLObject::NO_DECODE ), sExtension) ); 1497 rpURLList->Insert( pURL, rpURLList->Count() ); 1498 } 1499 } 1500 } 1501 1502 lcl_saveLastURLs(rpURLList, mlLastURLs); 1503 } 1504 1505 // ------------------------------------------------------------------------ 1506 ErrCode FileDialogHelper_Impl::execute( SvStringsDtor*& rpURLList, 1507 SfxItemSet *& rpSet, 1508 String& rFilter ) 1509 { 1510 // rFilter is a pure output parameter, it shouldn't be used for anything else 1511 // changing this would surely break code 1512 // rpSet is in/out parameter, usually just a media-descriptor that can be changed by dialog 1513 1514 uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY ); 1515 1516 // retrieves parameters from rpSet 1517 // for now only Password is used 1518 if ( rpSet ) 1519 { 1520 // check password checkbox if the document had password before 1521 if( mbHasPassword ) 1522 { 1523 SFX_ITEMSET_ARG( rpSet, pPassItem, SfxBoolItem, SID_PASSWORDINTERACTION, sal_False ); 1524 mbPwdCheckBoxState = ( pPassItem != NULL && pPassItem->GetValue() ); 1525 1526 // in case the document has password to modify, the dialog should be shown 1527 SFX_ITEMSET_ARG( rpSet, pPassToModifyItem, SfxUnoAnyItem, SID_MODIFYPASSWORDINFO, sal_False ); 1528 mbPwdCheckBoxState |= ( pPassToModifyItem && pPassToModifyItem->GetValue().hasValue() ); 1529 } 1530 1531 SFX_ITEMSET_ARG( rpSet, pSelectItem, SfxBoolItem, SID_SELECTION, sal_False ); 1532 if ( pSelectItem ) 1533 mbSelection = pSelectItem->GetValue(); 1534 else 1535 mbSelectionEnabled = sal_False; 1536 1537 // the password will be set in case user decide so 1538 rpSet->ClearItem( SID_PASSWORDINTERACTION ); 1539 rpSet->ClearItem( SID_PASSWORD ); 1540 rpSet->ClearItem( SID_ENCRYPTIONDATA ); 1541 rpSet->ClearItem( SID_RECOMMENDREADONLY ); 1542 rpSet->ClearItem( SID_MODIFYPASSWORDINFO ); 1543 1544 } 1545 1546 if ( mbHasPassword && !mbPwdCheckBoxState ) 1547 { 1548 SvtSecurityOptions aSecOpt; 1549 mbPwdCheckBoxState = ( 1550 aSecOpt.IsOptionSet( SvtSecurityOptions::E_DOCWARN_RECOMMENDPASSWORD ) ); 1551 } 1552 1553 rpURLList = NULL; 1554 1555 if ( ! mxFileDlg.is() ) 1556 return ERRCODE_ABORT; 1557 1558 if ( ExecutableDialogResults::CANCEL != implDoExecute() ) 1559 { 1560 // create an itemset if there is no 1561 if( !rpSet ) 1562 rpSet = new SfxAllItemSet( SFX_APP()->GetPool() ); 1563 1564 // the item should remain only if it was set by the dialog 1565 rpSet->ClearItem( SID_SELECTION ); 1566 1567 if( mbExport && mbHasSelectionBox ) 1568 { 1569 try 1570 { 1571 Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 0 ); 1572 sal_Bool bSelection = sal_False; 1573 if ( aValue >>= bSelection ) 1574 rpSet->Put( SfxBoolItem( SID_SELECTION, bSelection ) ); 1575 } 1576 catch( IllegalArgumentException ) 1577 { 1578 DBG_ERROR( "FileDialogHelper_Impl::execute: caught an IllegalArgumentException!" ); 1579 } 1580 } 1581 1582 1583 // set the read-only flag. When inserting a file, this flag is always set 1584 if ( mbInsert ) 1585 rpSet->Put( SfxBoolItem( SID_DOC_READONLY, sal_True ) ); 1586 else 1587 { 1588 if ( ( FILEOPEN_READONLY_VERSION == m_nDialogType ) && xCtrlAccess.is() ) 1589 { 1590 try 1591 { 1592 Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_READONLY, 0 ); 1593 sal_Bool bReadOnly = sal_False; 1594 if ( ( aValue >>= bReadOnly ) && bReadOnly ) 1595 rpSet->Put( SfxBoolItem( SID_DOC_READONLY, bReadOnly ) ); 1596 } 1597 catch( IllegalArgumentException ) 1598 { 1599 DBG_ERROR( "FileDialogHelper_Impl::execute: caught an IllegalArgumentException!" ); 1600 } 1601 } 1602 } 1603 if ( mbHasVersions && xCtrlAccess.is() ) 1604 { 1605 try 1606 { 1607 Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::LISTBOX_VERSION, 1608 ControlActions::GET_SELECTED_ITEM_INDEX ); 1609 sal_Int32 nVersion = 0; 1610 if ( ( aValue >>= nVersion ) && nVersion > 0 ) 1611 // open a special version; 0 == current version 1612 rpSet->Put( SfxInt16Item( SID_VERSION, (short)nVersion ) ); 1613 } 1614 catch( IllegalArgumentException ){} 1615 } 1616 1617 // set the filter 1618 getRealFilter( rFilter ); 1619 1620 const SfxFilter* pCurrentFilter = getCurentSfxFilter(); 1621 1622 // fill the rpURLList 1623 implGetAndCacheFiles( mxFileDlg, rpURLList, pCurrentFilter ); 1624 if ( rpURLList == NULL || rpURLList->GetObject(0) == NULL ) 1625 return ERRCODE_ABORT; 1626 1627 // check, wether or not we have to display a password box 1628 if ( pCurrentFilter && mbHasPassword && mbIsPwdEnabled && xCtrlAccess.is() ) 1629 { 1630 try 1631 { 1632 Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0 ); 1633 sal_Bool bPassWord = sal_False; 1634 if ( ( aValue >>= bPassWord ) && bPassWord ) 1635 { 1636 // ask for a password 1637 uno::Reference < ::com::sun::star::task::XInteractionHandler > xInteractionHandler( ::comphelper::getProcessServiceFactory()->createInstance(::rtl::OUString::createFromAscii("com.sun.star.comp.uui.UUIInteractionHandler")), UNO_QUERY ); 1638 1639 if( xInteractionHandler.is() ) 1640 { 1641 // TODO: need a save way to distinguish MS filters from other filters 1642 // for now MS-filters are the only alien filters that support encryption 1643 sal_Bool bMSType = !pCurrentFilter->IsOwnFormat(); 1644 ::comphelper::DocPasswordRequestType eType = bMSType ? 1645 ::comphelper::DocPasswordRequestType_MS : 1646 ::comphelper::DocPasswordRequestType_STANDARD; 1647 1648 ::rtl::Reference< ::comphelper::DocPasswordRequest > pPasswordRequest( new ::comphelper::DocPasswordRequest( eType, ::com::sun::star::task::PasswordRequestMode_PASSWORD_CREATE, *(rpURLList->GetObject(0)), ( pCurrentFilter->GetFilterFlags() & SFX_FILTER_PASSWORDTOMODIFY ) != 0 ) ); 1649 1650 uno::Reference< com::sun::star::task::XInteractionRequest > rRequest( pPasswordRequest.get() ); 1651 xInteractionHandler->handle( rRequest ); 1652 if ( pPasswordRequest->isPassword() ) 1653 { 1654 if ( pPasswordRequest->getPassword().getLength() ) 1655 { 1656 // TODO/LATER: The filters should show the password dialog themself in future 1657 if ( bMSType ) 1658 { 1659 // all the current MS-filters use MSCodec_Std97 implementation 1660 uno::Sequence< sal_Int8 > aUniqueID = ::comphelper::DocPasswordHelper::GenerateRandomByteSequence( 16 ); 1661 uno::Sequence< sal_Int8 > aEncryptionKey = ::comphelper::DocPasswordHelper::GenerateStd97Key( pPasswordRequest->getPassword(), aUniqueID ); 1662 1663 if ( aEncryptionKey.getLength() ) 1664 { 1665 ::comphelper::SequenceAsHashMap aHashData; 1666 aHashData[ ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "STD97EncryptionKey" ) ) ] <<= aEncryptionKey; 1667 aHashData[ ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "STD97UniqueID" ) ) ] <<= aUniqueID; 1668 1669 rpSet->Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, uno::makeAny( aHashData.getAsConstNamedValueList() ) ) ); 1670 } 1671 else 1672 return ERRCODE_IO_NOTSUPPORTED; 1673 } 1674 else 1675 { 1676 rpSet->Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, uno::makeAny( ::comphelper::OStorageHelper::CreatePackageEncryptionData( pPasswordRequest->getPassword() ) ) ) ); 1677 } 1678 } 1679 1680 if ( pPasswordRequest->getRecommendReadOnly() ) 1681 rpSet->Put( SfxBoolItem( SID_RECOMMENDREADONLY, sal_True ) ); 1682 1683 if ( bMSType ) 1684 { 1685 // the empty password has 0 as Hash 1686 sal_Int32 nHash = SfxMedium::CreatePasswordToModifyHash( pPasswordRequest->getPasswordToModify(), ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.text.TextDocument" ) ).equals( pCurrentFilter->GetServiceName() ) ); 1687 if ( nHash ) 1688 rpSet->Put( SfxUnoAnyItem( SID_MODIFYPASSWORDINFO, uno::makeAny( nHash ) ) ); 1689 } 1690 else 1691 { 1692 uno::Sequence< beans::PropertyValue > aModifyPasswordInfo = ::comphelper::DocPasswordHelper::GenerateNewModifyPasswordInfo( pPasswordRequest->getPasswordToModify() ); 1693 if ( aModifyPasswordInfo.getLength() ) 1694 rpSet->Put( SfxUnoAnyItem( SID_MODIFYPASSWORDINFO, uno::makeAny( aModifyPasswordInfo ) ) ); 1695 } 1696 } 1697 else 1698 return ERRCODE_ABORT; 1699 } 1700 } 1701 } 1702 catch( IllegalArgumentException ){} 1703 } 1704 1705 SaveLastUsedFilter(); 1706 return ERRCODE_NONE; 1707 } 1708 else 1709 return ERRCODE_ABORT; 1710 } 1711 1712 // ------------------------------------------------------------------------ 1713 ErrCode FileDialogHelper_Impl::execute() 1714 { 1715 if ( ! mxFileDlg.is() ) 1716 return ERRCODE_ABORT; 1717 1718 sal_Int16 nRet = implDoExecute(); 1719 1720 maPath = mxFileDlg->getDisplayDirectory(); 1721 1722 if ( ExecutableDialogResults::CANCEL == nRet ) 1723 return ERRCODE_ABORT; 1724 else 1725 { 1726 return ERRCODE_NONE; 1727 } 1728 } 1729 1730 // ------------------------------------------------------------------------ 1731 OUString FileDialogHelper_Impl::getPath() const 1732 { 1733 OUString aPath; 1734 1735 if ( mxFileDlg.is() ) 1736 aPath = mxFileDlg->getDisplayDirectory(); 1737 1738 if ( !aPath.getLength() ) 1739 aPath = maPath; 1740 1741 return aPath; 1742 } 1743 1744 // ------------------------------------------------------------------------ 1745 OUString FileDialogHelper_Impl::getFilter() const 1746 { 1747 String aFilter = getCurrentFilterUIName(); 1748 1749 if( !aFilter.Len() ) 1750 aFilter = maCurFilter; 1751 1752 return aFilter; 1753 } 1754 1755 // ------------------------------------------------------------------------ 1756 void FileDialogHelper_Impl::getRealFilter( String& _rFilter ) const 1757 { 1758 _rFilter = getCurrentFilterUIName(); 1759 1760 if ( !_rFilter.Len() ) 1761 _rFilter = maCurFilter; 1762 1763 if ( _rFilter.Len() && mpMatcher ) 1764 { 1765 const SfxFilter* pFilter = 1766 mpMatcher->GetFilter4UIName( _rFilter, m_nMustFlags, m_nDontFlags ); 1767 _rFilter = pFilter ? pFilter->GetFilterName() : _rFilter.Erase(); 1768 } 1769 } 1770 1771 // ------------------------------------------------------------------------ 1772 void FileDialogHelper_Impl::displayFolder( const ::rtl::OUString& _rPath ) 1773 { 1774 if ( ! _rPath.getLength() ) 1775 // nothing to do 1776 return; 1777 1778 /* 1779 if ( !::utl::UCBContentHelper::IsFolder( _rPath ) ) 1780 // only valid folders accepted here 1781 return; 1782 */ 1783 1784 maPath = _rPath; 1785 if ( mxFileDlg.is() ) 1786 { 1787 try 1788 { 1789 mxFileDlg->setDisplayDirectory( maPath ); 1790 } 1791 catch( const IllegalArgumentException& ) 1792 { 1793 DBG_ERROR( "FileDialogHelper_Impl::displayFolder: caught an exception!" ); 1794 } 1795 } 1796 } 1797 1798 // ------------------------------------------------------------------------ 1799 void FileDialogHelper_Impl::setFileName( const ::rtl::OUString& _rFile ) 1800 { 1801 maFileName = _rFile; 1802 if ( mxFileDlg.is() ) 1803 { 1804 try 1805 { 1806 mxFileDlg->setDefaultName( maFileName ); 1807 } 1808 catch( const IllegalArgumentException& ) 1809 { 1810 DBG_ERROR( "FileDialogHelper_Impl::setFileName: caught an exception!" ); 1811 } 1812 } 1813 } 1814 1815 // ------------------------------------------------------------------------ 1816 void FileDialogHelper_Impl::setFilter( const OUString& rFilter ) 1817 { 1818 DBG_ASSERT( rFilter.indexOf(':') == -1, "Old filter name used!"); 1819 1820 maCurFilter = rFilter; 1821 1822 if ( rFilter.getLength() && mpMatcher ) 1823 { 1824 const SfxFilter* pFilter = mpMatcher->GetFilter4FilterName( 1825 rFilter, m_nMustFlags, m_nDontFlags ); 1826 if ( pFilter ) 1827 maCurFilter = pFilter->GetUIName(); 1828 } 1829 1830 uno::Reference< XFilterManager > xFltMgr( mxFileDlg, UNO_QUERY ); 1831 1832 if ( maCurFilter.getLength() && xFltMgr.is() ) 1833 { 1834 try 1835 { 1836 xFltMgr->setCurrentFilter( maCurFilter ); 1837 } 1838 catch( IllegalArgumentException ){} 1839 } 1840 } 1841 1842 // ------------------------------------------------------------------------ 1843 void FileDialogHelper_Impl::createMatcher( const String& rFactory ) 1844 { 1845 mpMatcher = new SfxFilterMatcher( SfxObjectShell::GetServiceNameFromFactory(rFactory) ); 1846 mbDeleteMatcher = sal_True; 1847 } 1848 1849 // ------------------------------------------------------------------------ 1850 void FileDialogHelper_Impl::addFilters( sal_Int64 nFlags, 1851 const String& rFactory, 1852 SfxFilterFlags nMust, 1853 SfxFilterFlags nDont ) 1854 { 1855 uno::Reference< XFilterManager > xFltMgr( mxFileDlg, UNO_QUERY ); 1856 1857 if ( ! xFltMgr.is() ) 1858 return; 1859 1860 // we still need a matcher to convert UI names to filter names 1861 if ( !rFactory.Len() ) 1862 { 1863 SfxApplication *pSfxApp = SFX_APP(); 1864 mpMatcher = &pSfxApp->GetFilterMatcher(); 1865 mbDeleteMatcher = sal_False; 1866 } 1867 else 1868 { 1869 mpMatcher = new SfxFilterMatcher( rFactory ); 1870 mbDeleteMatcher = sal_True; 1871 } 1872 1873 uno::Reference< XMultiServiceFactory > xSMGR = ::comphelper::getProcessServiceFactory(); 1874 uno::Reference< XContainerQuery > xFilterCont( 1875 xSMGR->createInstance(::rtl::OUString::createFromAscii("com.sun.star.document.FilterFactory")), 1876 UNO_QUERY); 1877 if ( ! xFilterCont.is() ) 1878 return; 1879 1880 m_nMustFlags |= nMust; 1881 m_nDontFlags |= nDont; 1882 1883 // create the list of filters 1884 ::rtl::OUStringBuffer sQuery(256); 1885 sQuery.appendAscii("getSortedFilterList()"); 1886 sQuery.appendAscii(":module=" ); 1887 sQuery.append (rFactory ); // use long name here ! 1888 sQuery.appendAscii(":iflags=" ); 1889 sQuery.append (::rtl::OUString::valueOf((sal_Int32)m_nMustFlags)); 1890 sQuery.appendAscii(":eflags=" ); 1891 sQuery.append (::rtl::OUString::valueOf((sal_Int32)m_nDontFlags)); 1892 1893 uno::Reference< XEnumeration > xResult; 1894 try 1895 { 1896 xResult = xFilterCont->createSubSetEnumerationByQuery(sQuery.makeStringAndClear()); 1897 } 1898 catch( uno::Exception& ) 1899 { 1900 DBG_ERRORFILE( "Could not get filters from the configuration!" ); 1901 } 1902 1903 TSortedFilterList aIter (xResult); 1904 1905 // no matcher any longer used ... 1906 mbDeleteMatcher = sal_False; 1907 1908 // append the filters 1909 ::rtl::OUString sFirstFilter; 1910 if ( WB_OPEN == ( nFlags & WB_OPEN ) ) 1911 ::sfx2::appendFiltersForOpen( aIter, xFltMgr, sFirstFilter, *this ); 1912 else if ( mbExport ) 1913 ::sfx2::appendExportFilters( aIter, xFltMgr, sFirstFilter, *this ); 1914 else 1915 ::sfx2::appendFiltersForSave( aIter, xFltMgr, sFirstFilter, *this, rFactory ); 1916 1917 // set our initial selected filter (if we do not already have one) 1918 if ( !maSelectFilter.getLength() ) 1919 maSelectFilter = sFirstFilter; 1920 } 1921 1922 // ------------------------------------------------------------------------ 1923 void FileDialogHelper_Impl::addFilter( const OUString& rFilterName, 1924 const OUString& rExtension ) 1925 { 1926 uno::Reference< XFilterManager > xFltMgr( mxFileDlg, UNO_QUERY ); 1927 1928 if ( ! xFltMgr.is() ) 1929 return; 1930 1931 try 1932 { 1933 xFltMgr->appendFilter( rFilterName, rExtension ); 1934 1935 if ( !maSelectFilter.getLength() ) 1936 maSelectFilter = rFilterName; 1937 } 1938 catch( IllegalArgumentException ) 1939 { 1940 #ifdef DBG_UTIL 1941 ByteString aMsg( "Could not append Filter" ); 1942 aMsg += ByteString( String( rFilterName ), RTL_TEXTENCODING_UTF8 ); 1943 DBG_ERRORFILE( aMsg.GetBuffer() ); 1944 #endif 1945 } 1946 } 1947 1948 // ------------------------------------------------------------------------ 1949 void FileDialogHelper_Impl::addGraphicFilter() 1950 { 1951 uno::Reference< XFilterManager > xFltMgr( mxFileDlg, UNO_QUERY ); 1952 1953 if ( ! xFltMgr.is() ) 1954 return; 1955 1956 // create the list of filters 1957 mpGraphicFilter = new GraphicFilter; 1958 sal_uInt16 i, j, nCount = mpGraphicFilter->GetImportFormatCount(); 1959 1960 // compute the extension string for all known import filters 1961 String aExtensions; 1962 1963 for ( i = 0; i < nCount; i++ ) 1964 { 1965 j = 0; 1966 String sWildcard; 1967 while( sal_True ) 1968 { 1969 sWildcard = mpGraphicFilter->GetImportWildcard( i, j++ ); 1970 if ( !sWildcard.Len() ) 1971 break; 1972 if ( aExtensions.Search( sWildcard ) == STRING_NOTFOUND ) 1973 { 1974 if ( aExtensions.Len() ) 1975 aExtensions += sal_Unicode(';'); 1976 aExtensions += sWildcard; 1977 } 1978 } 1979 } 1980 1981 #if defined(WNT) 1982 if ( aExtensions.Len() > 240 ) 1983 aExtensions = DEFINE_CONST_UNICODE( FILEDIALOG_FILTER_ALL ); 1984 #endif 1985 sal_Bool bIsInOpenMode = isInOpenMode(); 1986 1987 try 1988 { 1989 OUString aAllFilterName = String( SfxResId( STR_SFX_IMPORT_ALL ) ); 1990 aAllFilterName = ::sfx2::addExtension( aAllFilterName, aExtensions, bIsInOpenMode, *this ); 1991 1992 xFltMgr->appendFilter( aAllFilterName, aExtensions ); 1993 maSelectFilter = aAllFilterName; 1994 } 1995 catch( IllegalArgumentException ) 1996 { 1997 DBG_ERRORFILE( "Could not append Filter" ); 1998 } 1999 2000 // Now add the filter 2001 for ( i = 0; i < nCount; i++ ) 2002 { 2003 String aName = mpGraphicFilter->GetImportFormatName( i ); 2004 String aExt; 2005 j = 0; 2006 String sWildcard; 2007 while( sal_True ) 2008 { 2009 sWildcard = mpGraphicFilter->GetImportWildcard( i, j++ ); 2010 if ( !sWildcard.Len() ) 2011 break; 2012 if ( aExt.Search( sWildcard ) == STRING_NOTFOUND ) 2013 { 2014 if ( aExt.Len() ) 2015 aExt += sal_Unicode(';'); 2016 aExt += sWildcard; 2017 } 2018 } 2019 aName = ::sfx2::addExtension( aName, aExt, bIsInOpenMode, *this ); 2020 try 2021 { 2022 xFltMgr->appendFilter( aName, aExt ); 2023 } 2024 catch( IllegalArgumentException ) 2025 { 2026 DBG_ERRORFILE( "Could not append Filter" ); 2027 } 2028 } 2029 } 2030 2031 // ------------------------------------------------------------------------ 2032 #define GRF_CONFIG_STR " " 2033 #define STD_CONFIG_STR "1 " 2034 2035 void FileDialogHelper_Impl::saveConfig() 2036 { 2037 uno::Reference < XFilePickerControlAccess > xDlg( mxFileDlg, UNO_QUERY ); 2038 Any aValue; 2039 2040 if ( ! xDlg.is() ) 2041 return; 2042 2043 if ( mbHasPreview ) 2044 { 2045 SvtViewOptions aDlgOpt( E_DIALOG, IMPGRF_CONFIGNAME ); 2046 String aUserData = DEFINE_CONST_UNICODE( GRF_CONFIG_STR ); 2047 2048 try 2049 { 2050 aValue = xDlg->getValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0 ); 2051 sal_Bool bValue = sal_False; 2052 aValue >>= bValue; 2053 aUserData.SetToken( 0, ' ', String::CreateFromInt32( (sal_Int32) bValue ) ); 2054 2055 aValue = xDlg->getValue( ExtendedFilePickerElementIds::CHECKBOX_PREVIEW, 0 ); 2056 bValue = sal_False; 2057 aValue >>= bValue; 2058 aUserData.SetToken( 1, ' ', String::CreateFromInt32( (sal_Int32) bValue ) ); 2059 2060 INetURLObject aObj( getPath() ); 2061 2062 if ( aObj.GetProtocol() == INET_PROT_FILE ) 2063 aUserData.SetToken( 2, ' ', aObj.GetMainURL( INetURLObject::NO_DECODE ) ); 2064 2065 String aFilter = getFilter(); 2066 aFilter = EncodeSpaces_Impl( aFilter ); 2067 aUserData.SetToken( 3, ' ', aFilter ); 2068 2069 aDlgOpt.SetUserItem( USERITEM_NAME, makeAny( OUString( aUserData ) ) ); 2070 } 2071 catch( IllegalArgumentException ){} 2072 } 2073 else 2074 { 2075 sal_Bool bWriteConfig = sal_False; 2076 SvtViewOptions aDlgOpt( E_DIALOG, IODLG_CONFIGNAME ); 2077 String aUserData = DEFINE_CONST_UNICODE( STD_CONFIG_STR ); 2078 2079 if ( aDlgOpt.Exists() ) 2080 { 2081 Any aUserItem = aDlgOpt.GetUserItem( USERITEM_NAME ); 2082 OUString aTemp; 2083 if ( aUserItem >>= aTemp ) 2084 aUserData = String( aTemp ); 2085 } 2086 2087 if ( mbHasAutoExt ) 2088 { 2089 try 2090 { 2091 aValue = xDlg->getValue( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0 ); 2092 sal_Bool bAutoExt = sal_True; 2093 aValue >>= bAutoExt; 2094 aUserData.SetToken( 0, ' ', String::CreateFromInt32( (sal_Int32) bAutoExt ) ); 2095 bWriteConfig = sal_True; 2096 } 2097 catch( IllegalArgumentException ){} 2098 } 2099 2100 if ( ! mbIsSaveDlg ) 2101 { 2102 OUString aPath = getPath(); 2103 if ( aPath.getLength() && 2104 utl::LocalFileHelper::IsLocalFile( aPath ) ) 2105 { 2106 aUserData.SetToken( 1, ' ', aPath ); 2107 bWriteConfig = sal_True; 2108 } 2109 } 2110 2111 if( mbHasSelectionBox && mbSelectionFltrEnabled ) 2112 { 2113 try 2114 { 2115 aValue = xDlg->getValue( ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 0 ); 2116 sal_Bool bSelection = sal_True; 2117 aValue >>= bSelection; 2118 if ( aUserData.GetTokenCount(' ') < 3 ) 2119 aUserData.Append(' '); 2120 aUserData.SetToken( 2, ' ', String::CreateFromInt32( (sal_Int32) bSelection ) ); 2121 bWriteConfig = sal_True; 2122 } 2123 catch( IllegalArgumentException ){} 2124 } 2125 2126 if ( bWriteConfig ) 2127 aDlgOpt.SetUserItem( USERITEM_NAME, makeAny( OUString( aUserData ) ) ); 2128 } 2129 2130 SfxApplication *pSfxApp = SFX_APP(); 2131 pSfxApp->SetLastDir_Impl( getPath() ); 2132 } 2133 2134 // ------------------------------------------------------------------------ 2135 namespace 2136 { 2137 static ::rtl::OUString getInitPath( const String& _rFallback, const xub_StrLen _nFallbackToken ) 2138 { 2139 SfxApplication *pSfxApp = SFX_APP(); 2140 String sPath = pSfxApp->GetLastDir_Impl(); 2141 2142 if ( !sPath.Len() ) 2143 sPath = _rFallback.GetToken( _nFallbackToken, ' ' ); 2144 2145 // check if the path points to a valid (accessible) directory 2146 sal_Bool bValid = sal_False; 2147 if ( sPath.Len() ) 2148 { 2149 String sPathCheck( sPath ); 2150 if ( sPathCheck.GetBuffer()[ sPathCheck.Len() - 1 ] != '/' ) 2151 sPathCheck += '/'; 2152 sPathCheck += '.'; 2153 try 2154 { 2155 ::ucbhelper::Content aContent( sPathCheck, uno::Reference< ucb::XCommandEnvironment >() ); 2156 bValid = aContent.isFolder(); 2157 } 2158 catch( Exception& ) {} 2159 } 2160 2161 if ( !bValid ) 2162 sPath.Erase(); 2163 2164 return sPath; 2165 } 2166 } 2167 2168 // ------------------------------------------------------------------------ 2169 void FileDialogHelper_Impl::loadConfig() 2170 { 2171 uno::Reference < XFilePickerControlAccess > xDlg( mxFileDlg, UNO_QUERY ); 2172 Any aValue; 2173 2174 if ( ! xDlg.is() ) 2175 return; 2176 2177 if ( mbHasPreview ) 2178 { 2179 SvtViewOptions aViewOpt( E_DIALOG, IMPGRF_CONFIGNAME ); 2180 String aUserData; 2181 2182 if ( aViewOpt.Exists() ) 2183 { 2184 Any aUserItem = aViewOpt.GetUserItem( USERITEM_NAME ); 2185 OUString aTemp; 2186 if ( aUserItem >>= aTemp ) 2187 aUserData = String( aTemp ); 2188 } 2189 2190 if ( aUserData.Len() > 0 ) 2191 { 2192 try 2193 { 2194 // respect the last "insert as link" state 2195 sal_Bool bLink = (sal_Bool) aUserData.GetToken( 0, ' ' ).ToInt32(); 2196 aValue <<= bLink; 2197 xDlg->setValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0, aValue ); 2198 2199 // respect the last "show preview" state 2200 sal_Bool bShowPreview = (sal_Bool) aUserData.GetToken( 1, ' ' ).ToInt32(); 2201 aValue <<= bShowPreview; 2202 xDlg->setValue( ExtendedFilePickerElementIds::CHECKBOX_PREVIEW, 0, aValue ); 2203 2204 if ( !maPath.getLength() ) 2205 displayFolder( getInitPath( aUserData, 2 ) ); 2206 2207 if ( ! maCurFilter.getLength() ) 2208 { 2209 String aFilter = aUserData.GetToken( 3, ' ' ); 2210 aFilter = DecodeSpaces_Impl( aFilter ); 2211 setFilter( aFilter ); 2212 } 2213 2214 // set the member so we know that we have to show the preview 2215 mbShowPreview = bShowPreview; 2216 } 2217 catch( IllegalArgumentException ){} 2218 } 2219 2220 if ( !maPath.getLength() ) 2221 displayFolder( SvtPathOptions().GetGraphicPath() ); 2222 } 2223 else 2224 { 2225 SvtViewOptions aViewOpt( E_DIALOG, IODLG_CONFIGNAME ); 2226 String aUserData; 2227 2228 if ( aViewOpt.Exists() ) 2229 { 2230 Any aUserItem = aViewOpt.GetUserItem( USERITEM_NAME ); 2231 OUString aTemp; 2232 if ( aUserItem >>= aTemp ) 2233 aUserData = String( aTemp ); 2234 } 2235 2236 if ( ! aUserData.Len() ) 2237 aUserData = DEFINE_CONST_UNICODE( STD_CONFIG_STR ); 2238 2239 if ( ! maPath.getLength() ) 2240 displayFolder( getInitPath( aUserData, 1 ) ); 2241 2242 if ( mbHasAutoExt ) 2243 { 2244 sal_Int32 nFlag = aUserData.GetToken( 0, ' ' ).ToInt32(); 2245 aValue <<= (sal_Bool) nFlag; 2246 try 2247 { 2248 xDlg->setValue( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0, aValue ); 2249 } 2250 catch( IllegalArgumentException ){} 2251 } 2252 2253 if( mbHasSelectionBox ) 2254 { 2255 sal_Int32 nFlag = aUserData.GetToken( 2, ' ' ).ToInt32(); 2256 aValue <<= (sal_Bool) nFlag; 2257 try 2258 { 2259 xDlg->setValue( ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 0, aValue ); 2260 } 2261 catch( IllegalArgumentException ){} 2262 } 2263 2264 if ( !maPath.getLength() ) 2265 displayFolder( SvtPathOptions().GetWorkPath() ); 2266 } 2267 } 2268 2269 // ------------------------------------------------------------------------ 2270 void FileDialogHelper_Impl::setDefaultValues() 2271 { 2272 // when no filter is set, we set the curentFilter to <all> 2273 if ( !maCurFilter.getLength() && maSelectFilter.getLength() ) 2274 { 2275 uno::Reference< XFilterManager > xFltMgr( mxFileDlg, UNO_QUERY ); 2276 try 2277 { 2278 xFltMgr->setCurrentFilter( maSelectFilter ); 2279 } 2280 catch( IllegalArgumentException ) 2281 {} 2282 } 2283 2284 // when no path is set, we use the standard 'work' folder 2285 if ( ! maPath.getLength() ) 2286 { 2287 OUString aWorkFolder = SvtPathOptions().GetWorkPath(); 2288 try 2289 { 2290 mxFileDlg->setDisplayDirectory( aWorkFolder ); 2291 } 2292 catch( const Exception& ) 2293 { 2294 DBG_ERROR( "FileDialogHelper_Impl::setDefaultValues: caught an exception while setting the display directory!" ); 2295 } 2296 2297 // INetURLObject aStdDirObj( SvtPathOptions().GetWorkPath() ); 2298 //SetStandardDir( aStdDirObj.GetMainURL( INetURLObject::NO_DECODE ) ); 2299 } 2300 } 2301 2302 sal_Bool FileDialogHelper_Impl::isShowFilterExtensionEnabled() const 2303 { 2304 return !maFilters.empty(); 2305 } 2306 2307 void FileDialogHelper_Impl::addFilterPair( const OUString& rFilter, 2308 const OUString& rFilterWithExtension ) 2309 { 2310 maFilters.push_back( FilterPair( rFilter, rFilterWithExtension ) ); 2311 2312 } 2313 2314 OUString FileDialogHelper_Impl::getFilterName( const OUString& rFilterWithExtension ) const 2315 { 2316 OUString sRet; 2317 for( ::std::vector< FilterPair >::const_iterator pIter = maFilters.begin(); pIter != maFilters.end(); ++pIter ) 2318 { 2319 if ( (*pIter).Second == rFilterWithExtension ) 2320 { 2321 sRet = (*pIter).First; 2322 break; 2323 } 2324 } 2325 return sRet; 2326 } 2327 2328 OUString FileDialogHelper_Impl::getFilterWithExtension( const OUString& rFilter ) const 2329 { 2330 OUString sRet; 2331 for( ::std::vector< FilterPair >::const_iterator pIter = maFilters.begin(); pIter != maFilters.end(); ++pIter ) 2332 { 2333 if ( (*pIter).First == rFilter ) 2334 { 2335 sRet = (*pIter).Second; 2336 break; 2337 } 2338 } 2339 return sRet; 2340 } 2341 2342 void FileDialogHelper_Impl::SetContext( FileDialogHelper::Context _eNewContext ) 2343 { 2344 meContext = _eNewContext; 2345 2346 sal_Int32 nNewHelpId = 0; 2347 OUString aConfigId; 2348 2349 switch( _eNewContext ) 2350 { 2351 // #104952# dependency to SVX not allowed! When used again, another solution has to be found 2352 // case FileDialogHelper::SW_INSERT_GRAPHIC: 2353 // case FileDialogHelper::SC_INSERT_GRAPHIC: 2354 // case FileDialogHelper::SD_INSERT_GRAPHIC: nNewHelpId = SID_INSERT_GRAPHIC; break; 2355 case FileDialogHelper::SW_INSERT_SOUND: 2356 case FileDialogHelper::SC_INSERT_SOUND: 2357 case FileDialogHelper::SD_INSERT_SOUND: nNewHelpId = SID_INSERT_SOUND; break; 2358 case FileDialogHelper::SW_INSERT_VIDEO: 2359 case FileDialogHelper::SC_INSERT_VIDEO: 2360 case FileDialogHelper::SD_INSERT_VIDEO: nNewHelpId = SID_INSERT_VIDEO; break; 2361 default: break; 2362 } 2363 2364 const OUString* pConfigId = GetLastFilterConfigId( _eNewContext ); 2365 if( pConfigId ) 2366 LoadLastUsedFilter( *pConfigId ); 2367 } 2368 2369 // ------------------------------------------------------------------------ 2370 // ----------- FileDialogHelper --------------------------- 2371 // ------------------------------------------------------------------------ 2372 2373 FileDialogHelper::FileDialogHelper( 2374 sal_Int64 nFlags, 2375 const String& rFact, 2376 SfxFilterFlags nMust, 2377 SfxFilterFlags nDont ) 2378 { 2379 mpImp = new FileDialogHelper_Impl( this, getDialogType( nFlags ), nFlags ); 2380 mxImp = mpImp; 2381 2382 // create the list of filters 2383 mpImp->addFilters( nFlags, SfxObjectShell::GetServiceNameFromFactory(rFact), nMust, nDont ); 2384 } 2385 2386 FileDialogHelper::FileDialogHelper( 2387 sal_Int64 nFlags, 2388 const String& rFact, 2389 sal_Int16 nDialog, 2390 SfxFilterFlags nMust, 2391 SfxFilterFlags nDont, 2392 const String& rStandardDir, 2393 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& rBlackList) 2394 { 2395 mpImp = new FileDialogHelper_Impl( this, getDialogType( nFlags ), nFlags, nDialog, NULL , rStandardDir, rBlackList ); 2396 mxImp = mpImp; 2397 2398 // create the list of filters 2399 mpImp->addFilters( nFlags, SfxObjectShell::GetServiceNameFromFactory(rFact), nMust, nDont ); 2400 } 2401 2402 FileDialogHelper::FileDialogHelper( 2403 sal_Int64 nFlags, 2404 const String& rFact, 2405 sal_Int16 nDialog, 2406 SfxFilterFlags nMust, 2407 SfxFilterFlags nDont ) 2408 { 2409 mpImp = new FileDialogHelper_Impl( this, getDialogType( nFlags ), nFlags, nDialog ); 2410 mxImp = mpImp; 2411 2412 // create the list of filters 2413 mpImp->addFilters( nFlags, SfxObjectShell::GetServiceNameFromFactory(rFact), nMust, nDont ); 2414 } 2415 2416 // ------------------------------------------------------------------------ 2417 FileDialogHelper::FileDialogHelper( sal_Int64 nFlags ) 2418 { 2419 sal_Int16 nDialogType = getDialogType( nFlags ); 2420 2421 mpImp = new FileDialogHelper_Impl( this, nDialogType, nFlags ); 2422 mxImp = mpImp; 2423 } 2424 2425 // ------------------------------------------------------------------------ 2426 FileDialogHelper::FileDialogHelper( 2427 sal_Int16 nDialogType, 2428 sal_Int64 nFlags, 2429 const String& rFact, 2430 SfxFilterFlags nMust, 2431 SfxFilterFlags nDont ) 2432 { 2433 mpImp = new FileDialogHelper_Impl( this, nDialogType, nFlags ); 2434 mxImp = mpImp; 2435 2436 // create the list of filters 2437 mpImp->addFilters( nFlags, SfxObjectShell::GetServiceNameFromFactory(rFact), nMust, nDont ); 2438 } 2439 2440 // ------------------------------------------------------------------------ 2441 FileDialogHelper::FileDialogHelper( 2442 sal_Int16 nDialogType, 2443 sal_Int64 nFlags, 2444 const String& rFact, 2445 sal_Int16 nDialog, 2446 SfxFilterFlags nMust, 2447 SfxFilterFlags nDont, 2448 const String& rStandardDir, 2449 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& rBlackList) 2450 { 2451 mpImp = new FileDialogHelper_Impl( this, nDialogType, nFlags, nDialog, NULL, rStandardDir, rBlackList ); 2452 mxImp = mpImp; 2453 2454 // create the list of filters 2455 mpImp->addFilters( nFlags, SfxObjectShell::GetServiceNameFromFactory(rFact), nMust, nDont ); 2456 } 2457 2458 // ------------------------------------------------------------------------ 2459 FileDialogHelper::FileDialogHelper( 2460 sal_Int16 nDialogType, 2461 sal_Int64 nFlags, 2462 Window* _pPreferredParent ) 2463 { 2464 mpImp = new FileDialogHelper_Impl( this, nDialogType, nFlags, SFX2_IMPL_DIALOG_CONFIG, _pPreferredParent ); 2465 mxImp = mpImp; 2466 } 2467 2468 // ------------------------------------------------------------------------ 2469 FileDialogHelper::FileDialogHelper( 2470 sal_Int16 nDialogType, 2471 sal_Int64 nFlags, 2472 const ::rtl::OUString& aFilterUIName, 2473 const ::rtl::OUString& aExtName, 2474 const ::rtl::OUString& rStandardDir, 2475 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& rBlackList, 2476 Window* _pPreferredParent ) 2477 { 2478 mpImp = new FileDialogHelper_Impl( this, nDialogType, nFlags, SFX2_IMPL_DIALOG_CONFIG, _pPreferredParent,rStandardDir, rBlackList ); 2479 mxImp = mpImp; 2480 2481 // the wildcard here is expected in form "*.extension" 2482 ::rtl::OUString aWildcard; 2483 if ( aExtName.indexOf( (sal_Unicode)'*' ) != 0 ) 2484 { 2485 if ( aExtName.getLength() && aExtName.indexOf( (sal_Unicode)'.' ) != 0 ) 2486 aWildcard = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "*." ) ); 2487 else 2488 aWildcard = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "*" ) ); 2489 } 2490 2491 aWildcard += aExtName; 2492 2493 ::rtl::OUString aUIString = 2494 ::sfx2::addExtension( aFilterUIName, aWildcard, ( WB_OPEN == ( nFlags & WB_OPEN ) ), *mpImp ); 2495 AddFilter( aUIString, aWildcard ); 2496 } 2497 2498 // ------------------------------------------------------------------------ 2499 FileDialogHelper::~FileDialogHelper() 2500 { 2501 mpImp->dispose(); 2502 mxImp.clear(); 2503 } 2504 2505 // ------------------------------------------------------------------------ 2506 void FileDialogHelper::CreateMatcher( const String& rFactory ) 2507 { 2508 mpImp->createMatcher( SfxObjectShell::GetServiceNameFromFactory(rFactory) ); 2509 } 2510 2511 // ------------------------------------------------------------------------ 2512 void FileDialogHelper::SetControlHelpIds( const sal_Int16* _pControlId, const char** _pHelpId ) 2513 { 2514 mpImp->setControlHelpIds( _pControlId, _pHelpId ); 2515 } 2516 2517 void FileDialogHelper::SetContext( Context _eNewContext ) 2518 { 2519 mpImp->SetContext( _eNewContext ); 2520 } 2521 2522 // ------------------------------------------------------------------------ 2523 IMPL_LINK( FileDialogHelper, ExecuteSystemFilePicker, void*, EMPTYARG ) 2524 { 2525 m_nError = mpImp->execute(); 2526 if ( m_aDialogClosedLink.IsSet() ) 2527 m_aDialogClosedLink.Call( this ); 2528 2529 return 0L; 2530 } 2531 2532 // ------------------------------------------------------------------------ 2533 // rDirPath has to be a directory 2534 ErrCode FileDialogHelper::Execute( SvStringsDtor*& rpURLList, 2535 SfxItemSet *& rpSet, 2536 String& rFilter, 2537 const String& rDirPath ) 2538 { 2539 SetDisplayFolder( rDirPath ); 2540 return mpImp->execute( rpURLList, rpSet, rFilter ); 2541 } 2542 2543 2544 // ------------------------------------------------------------------------ 2545 ErrCode FileDialogHelper::Execute() 2546 { 2547 return mpImp->execute(); 2548 } 2549 2550 // ------------------------------------------------------------------------ 2551 ErrCode FileDialogHelper::Execute( SfxItemSet *& rpSet, 2552 String& rFilter ) 2553 { 2554 ErrCode nRet; 2555 SvStringsDtor* pURLList; 2556 2557 nRet = mpImp->execute( pURLList, rpSet, rFilter ); 2558 2559 delete pURLList; 2560 2561 return nRet; 2562 } 2563 2564 void FileDialogHelper::StartExecuteModal( const Link& rEndDialogHdl ) 2565 { 2566 m_aDialogClosedLink = rEndDialogHdl; 2567 m_nError = ERRCODE_NONE; 2568 if ( mpImp->isSystemFilePicker() ) 2569 Application::PostUserEvent( LINK( this, FileDialogHelper, ExecuteSystemFilePicker ) ); 2570 else 2571 mpImp->implStartExecute(); 2572 } 2573 2574 // ------------------------------------------------------------------------ 2575 2576 short FileDialogHelper::GetDialogType() const 2577 { 2578 return mpImp ? mpImp->m_nDialogType : 0; 2579 } 2580 2581 // ------------------------------------------------------------------------ 2582 2583 sal_Bool FileDialogHelper::IsPasswordEnabled() const 2584 { 2585 return mpImp ? mpImp->isPasswordEnabled() : sal_False; 2586 } 2587 2588 // ------------------------------------------------------------------------ 2589 2590 String FileDialogHelper::GetRealFilter() const 2591 { 2592 String sFilter; 2593 if ( mpImp ) 2594 mpImp->getRealFilter( sFilter ); 2595 return sFilter; 2596 } 2597 2598 // ------------------------------------------------------------------------ 2599 void FileDialogHelper::SetTitle( const String& rNewTitle ) 2600 { 2601 if ( mpImp->mxFileDlg.is() ) 2602 mpImp->mxFileDlg->setTitle( rNewTitle ); 2603 } 2604 2605 // ------------------------------------------------------------------------ 2606 String FileDialogHelper::GetPath() const 2607 { 2608 OUString aPath; 2609 2610 if ( mpImp->mlLastURLs.size() > 0) 2611 return mpImp->mlLastURLs[0]; 2612 2613 if ( mpImp->mxFileDlg.is() ) 2614 { 2615 Sequence < OUString > aPathSeq = mpImp->mxFileDlg->getFiles(); 2616 2617 if ( aPathSeq.getLength() == 1 ) 2618 { 2619 aPath = aPathSeq[0]; 2620 } 2621 } 2622 2623 return aPath; 2624 } 2625 2626 // ------------------------------------------------------------------------ 2627 Sequence < OUString > FileDialogHelper::GetMPath() const 2628 { 2629 if ( mpImp->mlLastURLs.size() > 0) 2630 return mpImp->mlLastURLs.getAsConstList(); 2631 2632 if ( mpImp->mxFileDlg.is() ) 2633 return mpImp->mxFileDlg->getFiles(); 2634 else 2635 { 2636 Sequence < OUString > aEmpty; 2637 return aEmpty; 2638 } 2639 } 2640 2641 // ------------------------------------------------------------------------ 2642 Sequence< ::rtl::OUString > FileDialogHelper::GetSelectedFiles() const 2643 { 2644 // a) the new way (optional!) 2645 uno::Sequence< ::rtl::OUString > aResultSeq; 2646 uno::Reference< XFilePicker2 > xPickNew(mpImp->mxFileDlg, UNO_QUERY); 2647 if (xPickNew.is()) 2648 { 2649 aResultSeq = xPickNew->getSelectedFiles(); 2650 } 2651 // b) the olde way ... non optional. 2652 else 2653 { 2654 uno::Reference< XFilePicker > xPickOld(mpImp->mxFileDlg, UNO_QUERY_THROW); 2655 Sequence< OUString > lFiles = xPickOld->getFiles(); 2656 ::sal_Int32 nFiles = lFiles.getLength(); 2657 if ( nFiles > 1 ) 2658 { 2659 aResultSeq = Sequence< ::rtl::OUString >( nFiles-1 ); 2660 2661 INetURLObject aPath( lFiles[0] ); 2662 aPath.setFinalSlash(); 2663 2664 for (::sal_Int32 i = 1; i < nFiles; i++) 2665 { 2666 if (i == 1) 2667 aPath.Append( lFiles[i] ); 2668 else 2669 aPath.setName( lFiles[i] ); 2670 2671 aResultSeq[i-1] = ::rtl::OUString(aPath.GetMainURL( INetURLObject::NO_DECODE )); 2672 } 2673 } 2674 else 2675 aResultSeq = lFiles; 2676 } 2677 2678 return aResultSeq; 2679 } 2680 2681 // ------------------------------------------------------------------------ 2682 String FileDialogHelper::GetDisplayDirectory() const 2683 { 2684 return mpImp->getPath(); 2685 } 2686 2687 // ------------------------------------------------------------------------ 2688 String FileDialogHelper::GetCurrentFilter() const 2689 { 2690 return mpImp->getFilter(); 2691 } 2692 2693 // ------------------------------------------------------------------------ 2694 ErrCode FileDialogHelper::GetGraphic( Graphic& rGraphic ) const 2695 { 2696 return mpImp->getGraphic( rGraphic ); 2697 } 2698 2699 // ------------------------------------------------------------------------ 2700 static int impl_isFolder( const OUString& rPath ) 2701 { 2702 uno::Reference< task::XInteractionHandler > xHandler; 2703 try 2704 { 2705 uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW ); 2706 xHandler.set( xFactory->createInstance( DEFINE_CONST_OUSTRING( "com.sun.star.task.InteractionHandler" ) ), 2707 uno::UNO_QUERY_THROW ); 2708 } 2709 catch ( Exception const & ) 2710 { 2711 } 2712 2713 ::rtl::Reference< ::comphelper::StillReadWriteInteraction > aHandler = new ::comphelper::StillReadWriteInteraction( xHandler ); 2714 2715 try 2716 { 2717 ::ucbhelper::Content aContent( 2718 rPath, new ::ucbhelper::CommandEnvironment( static_cast< task::XInteractionHandler* > ( aHandler.get() ), uno::Reference< ucb::XProgressHandler >() ) ); 2719 if ( aContent.isFolder() ) 2720 return 1; 2721 2722 return 0; 2723 } 2724 catch ( Exception const & ) 2725 { 2726 } 2727 2728 return -1; 2729 } 2730 2731 void FileDialogHelper::SetDisplayDirectory( const String& _rPath ) 2732 { 2733 if ( !_rPath.Len() ) 2734 return; 2735 2736 // if the given path isn't a folder, we cut off the last part 2737 // and take it as filename and the rest of the path should be 2738 // the folder 2739 2740 INetURLObject aObj( _rPath ); 2741 2742 ::rtl::OUString sFileName = aObj.GetName( INetURLObject::DECODE_WITH_CHARSET ); 2743 aObj.removeSegment(); 2744 ::rtl::OUString sPath = aObj.GetMainURL( INetURLObject::NO_DECODE ); 2745 2746 int nIsFolder = impl_isFolder( _rPath ); 2747 if ( nIsFolder == 0 || 2748 ( nIsFolder == -1 && impl_isFolder( sPath ) == 1 ) ) 2749 { 2750 mpImp->setFileName( sFileName ); 2751 mpImp->displayFolder( sPath ); 2752 } 2753 else 2754 { 2755 INetURLObject aObjPathName( _rPath ); 2756 ::rtl::OUString sFolder( aObjPathName.GetMainURL( INetURLObject::NO_DECODE ) ); 2757 if ( sFolder.getLength() == 0 ) 2758 { 2759 // _rPath is not a valid path -> fallback to home directory 2760 vos:: OSecurity aSecurity; 2761 aSecurity.getHomeDir( sFolder ); 2762 } 2763 mpImp->displayFolder( sFolder ); 2764 } 2765 } 2766 2767 // ------------------------------------------------------------------------ 2768 void FileDialogHelper::SetDisplayFolder( const String& _rURL ) 2769 { 2770 mpImp->displayFolder( _rURL ); 2771 } 2772 2773 // ------------------------------------------------------------------------ 2774 void FileDialogHelper::SetFileName( const String& _rFileName ) 2775 { 2776 mpImp->setFileName( _rFileName ); 2777 } 2778 2779 // ------------------------------------------------------------------------ 2780 void FileDialogHelper::AddFilter( const String& rFilterName, 2781 const String& rExtension ) 2782 { 2783 mpImp->addFilter( rFilterName, rExtension ); 2784 } 2785 2786 // ------------------------------------------------------------------------ 2787 void FileDialogHelper::SetCurrentFilter( const String& rFilter ) 2788 { 2789 String sFilter( rFilter ); 2790 if ( mpImp->isShowFilterExtensionEnabled() ) 2791 sFilter = mpImp->getFilterWithExtension( rFilter ); 2792 mpImp->setFilter( sFilter ); 2793 } 2794 2795 // ------------------------------------------------------------------------ 2796 uno::Reference < XFilePicker > FileDialogHelper::GetFilePicker() const 2797 { 2798 return mpImp->mxFileDlg; 2799 } 2800 2801 // ------------------------------------------------------------------------ 2802 sal_Int16 FileDialogHelper::getDialogType( sal_Int64 nFlags ) const 2803 { 2804 sal_Int16 nDialogType = FILEOPEN_SIMPLE; 2805 2806 if ( nFlags & WB_SAVEAS ) 2807 { 2808 if ( nFlags & SFXWB_PASSWORD ) 2809 nDialogType = FILESAVE_AUTOEXTENSION_PASSWORD; 2810 else 2811 nDialogType = FILESAVE_SIMPLE; 2812 } 2813 else if ( nFlags & SFXWB_GRAPHIC ) 2814 { 2815 if ( nFlags & SFXWB_SHOWSTYLES ) 2816 nDialogType = FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE; 2817 else 2818 nDialogType = FILEOPEN_LINK_PREVIEW; 2819 } 2820 else if ( SFXWB_INSERT != ( nFlags & SFXWB_INSERT ) ) 2821 nDialogType = FILEOPEN_READONLY_VERSION; 2822 2823 return nDialogType; 2824 } 2825 2826 // ------------------------------------------------------------------------ 2827 // XFilePickerListener Methods 2828 // ------------------------------------------------------------------------ 2829 void SAL_CALL FileDialogHelper::FileSelectionChanged( const FilePickerEvent& aEvent ) 2830 { 2831 mpImp->handleFileSelectionChanged( aEvent ); 2832 } 2833 2834 // ------------------------------------------------------------------------ 2835 void SAL_CALL FileDialogHelper::DirectoryChanged( const FilePickerEvent& aEvent ) 2836 { 2837 mpImp->handleDirectoryChanged( aEvent ); 2838 } 2839 2840 // ------------------------------------------------------------------------ 2841 OUString SAL_CALL FileDialogHelper::HelpRequested( const FilePickerEvent& aEvent ) 2842 { 2843 return mpImp->handleHelpRequested( aEvent ); 2844 } 2845 2846 // ------------------------------------------------------------------------ 2847 void SAL_CALL FileDialogHelper::ControlStateChanged( const FilePickerEvent& aEvent ) 2848 { 2849 mpImp->handleControlStateChanged( aEvent ); 2850 } 2851 2852 // ------------------------------------------------------------------------ 2853 void SAL_CALL FileDialogHelper::DialogSizeChanged() 2854 { 2855 mpImp->handleDialogSizeChanged(); 2856 } 2857 2858 // ------------------------------------------------------------------------ 2859 void SAL_CALL FileDialogHelper::DialogClosed( const DialogClosedEvent& _rEvent ) 2860 { 2861 m_nError = ( RET_OK == _rEvent.DialogResult ) ? ERRCODE_NONE : ERRCODE_ABORT; 2862 if ( m_aDialogClosedLink.IsSet() ) 2863 m_aDialogClosedLink.Call( this ); 2864 } 2865 2866 // ------------------------------------------------------------------------ 2867 // ------------------------------------------------------------------------ 2868 // ------------------------------------------------------------------------ 2869 2870 ErrCode FileOpenDialog_Impl( sal_Int64 nFlags, 2871 const String& rFact, 2872 SvStringsDtor *& rpURLList, 2873 String& rFilter, 2874 SfxItemSet *& rpSet, 2875 const String* pPath, 2876 sal_Int16 nDialog, 2877 const String& rStandardDir, 2878 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& rBlackList ) 2879 { 2880 ErrCode nRet; 2881 FileDialogHelper aDialog( nFlags, rFact, nDialog, 0, 0, rStandardDir, rBlackList ); 2882 2883 String aPath; 2884 if ( pPath ) 2885 aPath = *pPath; 2886 2887 nRet = aDialog.Execute( rpURLList, rpSet, rFilter, aPath ); 2888 DBG_ASSERT( rFilter.SearchAscii(": ") == STRING_NOTFOUND, "Old filter name used!"); 2889 2890 return nRet; 2891 } 2892 2893 2894 // ------------------------------------------------------------------------ 2895 String EncodeSpaces_Impl( const String& rSource ) 2896 { 2897 String sRet( rSource ); 2898 sRet.SearchAndReplaceAll( DEFINE_CONST_UNICODE( " " ), DEFINE_CONST_UNICODE( "%20" ) ); 2899 return sRet; 2900 } 2901 2902 // ------------------------------------------------------------------------ 2903 String DecodeSpaces_Impl( const String& rSource ) 2904 { 2905 String sRet( rSource ); 2906 sRet.SearchAndReplaceAll( DEFINE_CONST_UNICODE( "%20" ), DEFINE_CONST_UNICODE( " " ) ); 2907 return sRet; 2908 } 2909 2910 // ------------------------------------------------------------------------ 2911 2912 } // end of namespace sfx2 2913 2914