diff options
Diffstat (limited to '')
| -rw-r--r-- | fpicker/source/office/iodlg.cxx | 2332 |
1 files changed, 2332 insertions, 0 deletions
diff --git a/fpicker/source/office/iodlg.cxx b/fpicker/source/office/iodlg.cxx new file mode 100644 index 000000000..d2dcef40a --- /dev/null +++ b/fpicker/source/office/iodlg.cxx @@ -0,0 +1,2332 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <sal/config.h> + +#include <sal/log.hxx> +#include "fileview.hxx" +#include "iodlg.hxx" +#include <svtools/PlaceEditDialog.hxx> +#include "OfficeControlAccess.hxx" +#include "PlacesListBox.hxx" +#include <fpsofficeResMgr.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <tools/stream.hxx> +#include <tools/urlobj.hxx> +#include <vcl/graph.hxx> +#include <vcl/svapp.hxx> +#include <vcl/timer.hxx> +#include <unotools/ucbhelper.hxx> +#include <unotools/pathoptions.hxx> +#include <unotools/viewoptions.hxx> +#include <svtools/sfxecode.hxx> + +#include <fpicker/strings.hrc> +#include <svtools/helpids.h> +#include <strings.hrc> +#include <bitmaps.hlst> +#include "asyncfilepicker.hxx" +#include "iodlgimp.hxx" +#include <svtools/inettbc.hxx> +#include "QueryFolderName.hxx" +#include <rtl/ustring.hxx> +#include <com/sun/star/ucb/UniversalContentBroker.hpp> +#include <com/sun/star/ucb/CommandAbortedException.hpp> +#include <com/sun/star/ucb/ContentCreationException.hpp> +#include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp> +#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/sdbc/XResultSet.hpp> +#include <com/sun/star/uno/Exception.hpp> +#include <com/sun/star/uno/Reference.hxx> +#include <com/sun/star/beans/XPropertySet.hpp> + +#include <comphelper/interaction.hxx> +#include <comphelper/lok.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/string.hxx> + +#include <osl/file.hxx> +#include <vcl/dibtools.hxx> +#include <vcl/settings.hxx> + +#include <com/sun/star/task/InteractionHandler.hpp> +#include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp> +#include "fpinteraction.hxx" +#include <osl/process.h> + +#include <officecfg/Office/Common.hxx> + +#include <algorithm> +#include <memory> + +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::ui::dialogs; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::ucb; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::task; +using namespace ::com::sun::star::sdbc; +using namespace ::utl; +using namespace ::svt; + +using namespace ExtendedFilePickerElementIds; +using namespace CommonFilePickerElementIds; +using namespace InternalFilePickerElementIds; + +// functions ------------------------------------------------------------- + +namespace +{ + OUString getMostCurrentFilter( std::unique_ptr<SvtExpFileDlg_Impl> const & pImpl ) + { + assert( pImpl && "invalid impl pointer" ); + const SvtFileDialogFilter_Impl* pFilter = pImpl->m_xUserFilter.get(); + + if ( !pFilter ) + pFilter = pImpl->GetCurFilter(); + + if ( !pFilter ) + return OUString(); + + return pFilter->GetType(); + } + + void restoreCurrentFilter( std::unique_ptr<SvtExpFileDlg_Impl> const & pImpl ) + { + SAL_WARN_IF( !pImpl->GetCurFilter(), "fpicker.office", "restoreCurrentFilter: no current filter!" ); + SAL_WARN_IF( pImpl->GetCurFilterDisplayName().isEmpty(), "fpicker.office", "restoreCurrentFilter: no current filter (no display name)!" ); + + pImpl->SelectFilterListEntry( pImpl->GetCurFilterDisplayName() ); + +#ifdef DBG_UTIL + OUString sSelectedDisplayName; + DBG_ASSERT( ( pImpl->GetSelectedFilterEntry( sSelectedDisplayName ) == pImpl->GetCurFilter() ) + && ( sSelectedDisplayName == pImpl->GetCurFilterDisplayName() ), + "restoreCurrentFilter: inconsistence!" ); +#endif + } + + + OUString GetFsysExtension_Impl( const OUString& rFile, const OUString& rLastFilterExt ) + { + sal_Int32 nDotPos = rFile.lastIndexOf( '.' ); + if ( nDotPos != -1 ) + { + if ( !rLastFilterExt.isEmpty() ) + { + if ( rFile.copy( nDotPos + 1 ).equalsIgnoreAsciiCase( rLastFilterExt ) ) + return rLastFilterExt; + } + else + return rFile.copy( nDotPos ); + } + return OUString(); + } + + + void SetFsysExtension_Impl( OUString& rFile, const OUString& rExtension ) + { + const sal_Int32 nDotPos{ rFile.lastIndexOf('.') }; + if (nDotPos>=0) + { + if (!rExtension.isEmpty()) + rFile = rFile.copy(0, nDotPos) + rExtension; // replace old extension with new (not empty) one + else if (nDotPos) + rFile = rFile.copy(0, nDotPos-1); // truncate extension (new one is empty) + else + rFile.clear(); // Filename was just an extension + } + else if (!rExtension.isEmpty()) + rFile += "." + rExtension; // no extension was present, append new one if not empty + } + + void lcl_autoUpdateFileExtension( SvtFileDialog* _pDialog, const OUString& _rLastFilterExt ) + { + // if auto extension is enabled... + if ( !_pDialog->isAutoExtensionEnabled() ) + return; + + // automatically switch to the extension of the (maybe just newly selected) extension + OUString aNewFile = _pDialog->getCurrentFileText( ); + OUString aExt = GetFsysExtension_Impl( aNewFile, _rLastFilterExt ); + + // but only if there already is an extension + if ( aExt.isEmpty() ) + return; + + // check if it is a real file extension, and not only the "post-dot" part in + // a directory name + bool bRealExtensions = true; + if ( -1 != aExt.indexOf( '/' ) ) + bRealExtensions = false; + else if ( -1 != aExt.indexOf( '\\' ) ) + bRealExtensions = false; + else + { + // no easy way to tell, because the part containing the dot already is the last + // segment of the complete file name + // So we have to check if the file name denotes a folder or a file. + // For performance reasons, we do this for file urls only + INetURLObject aURL( aNewFile ); + if ( INetProtocol::NotValid == aURL.GetProtocol() ) + { + OUString sURL; + if ( osl::FileBase::getFileURLFromSystemPath( aNewFile, sURL ) + == osl::FileBase::E_None ) + aURL = INetURLObject( sURL ); + } + if ( INetProtocol::File == aURL.GetProtocol() ) + { + try + { + bRealExtensions = !_pDialog->ContentIsFolder( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + } + catch( const css::uno::Exception& ) + { + SAL_INFO( "fpicker.office", "Exception in lcl_autoUpdateFileExtension" ); + } + } + } + + if ( bRealExtensions ) + { + SetFsysExtension_Impl( aNewFile, _pDialog->GetDefaultExt() ); + _pDialog->setCurrentFileText( aNewFile ); + } + } + +#if defined( UNX ) + bool lcl_getHomeDirectory( const OUString& _rForURL, OUString& /* [out] */ _rHomeDir ) + { + _rHomeDir.clear(); + + // now ask the content broker for a provider for this scheme + + try + { + // get the provider for the current scheme + Reference< XContentProvider > xProvider( + UniversalContentBroker::create( + comphelper::getProcessComponentContext() )-> + queryContentProvider( _rForURL ) ); + + SAL_WARN_IF( !xProvider.is(), "fpicker.office", "lcl_getHomeDirectory: could not find a (valid) content provider for the current URL!" ); + Reference< XPropertySet > xProviderProps( xProvider, UNO_QUERY ); + if ( xProviderProps.is() ) + { + Reference< XPropertySetInfo > xPropInfo = xProviderProps->getPropertySetInfo(); + const OUString sHomeDirPropertyName( "HomeDirectory" ); + if ( !xPropInfo.is() || xPropInfo->hasPropertyByName( sHomeDirPropertyName ) ) + { + OUString sHomeDirectory; + xProviderProps->getPropertyValue( sHomeDirPropertyName ) >>= sHomeDirectory; + _rHomeDir = sHomeDirectory; + } + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "fpicker", "lcl_getHomeDirectory" ); + } + return !_rHomeDir.isEmpty(); + } +#endif + + OUString lcl_ensureFinalSlash( const OUString& _rDir ) + { + INetURLObject aWorkPathObj( _rDir, INetProtocol::File ); + aWorkPathObj.setFinalSlash(); + return aWorkPathObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + } + + + /** retrieves the value of an environment variable + @return <TRUE/> if and only if the retrieved string value is not empty + */ + bool getEnvironmentValue( const char* _pAsciiEnvName, OUString& _rValue ) + { + _rValue.clear(); + OUString sEnvName = OUString::createFromAscii( _pAsciiEnvName ); + osl_getEnvironment( sEnvName.pData, &_rValue.pData ); + return !_rValue.isEmpty(); + } +} + +// SvtFileDialog +SvtFileDialog::SvtFileDialog(weld::Window* pParent, PickerFlags nStyle) + : SvtFileDialog_Base(pParent, "fps/ui/explorerfiledialog.ui", "ExplorerFileDialog") + , m_xCbReadOnly(m_xBuilder->weld_check_button("readonly")) + , m_xCbLinkBox(m_xBuilder->weld_check_button("link")) + , m_xCbPreviewBox(m_xBuilder->weld_check_button("cb_preview")) + , m_xCbSelection(m_xBuilder->weld_check_button("selection")) + , m_xPbPlay(m_xBuilder->weld_button("play")) + , m_xPreviewFrame(m_xBuilder->weld_widget("previewframe")) + , m_xPrevBmp(m_xBuilder->weld_image("preview")) + , m_pFileNotifier(nullptr) + , m_xImpl(new SvtExpFileDlg_Impl) + , m_nPickerFlags(nStyle) + , m_bIsInExecute(false) + , m_bInExecuteAsync(false) + , m_bHasFilename(false) + , m_xContext(comphelper::getProcessComponentContext()) +{ + m_xImpl->m_xCbOptions = m_xBuilder->weld_check_button("options"); + m_xImpl->m_xFtFileName = m_xBuilder->weld_label("file_name_label"); + m_xImpl->m_xEdFileName.reset(new SvtURLBox(m_xBuilder->weld_combo_box("file_name"))); + m_xImpl->m_xFtFileType = m_xBuilder->weld_label("file_type_label"); + m_xImpl->m_xLbFilter = m_xBuilder->weld_combo_box("file_type"); + m_xImpl->m_xEdCurrentPath.reset(new SvtURLBox(m_xBuilder->weld_combo_box("current_path"))); + m_xImpl->m_xBtnFileOpen = m_xBuilder->weld_button("open"); + m_xImpl->m_xBtnCancel = m_xBuilder->weld_button("cancel"); + m_xImpl->m_xBtnHelp = m_xBuilder->weld_button("help"); + m_xImpl->m_xBtnConnectToServer = m_xBuilder->weld_button("connect_to_server"); + m_xImpl->m_xBtnNewFolder = m_xBuilder->weld_button("new_folder"); + m_xImpl->m_xCbPassword = m_xBuilder->weld_check_button("password"); + m_xImpl->m_xCbGPGEncrypt = m_xBuilder->weld_check_button("gpgencrypt"); + m_xImpl->m_xCbAutoExtension = m_xBuilder->weld_check_button("extension"); + m_xImpl->m_xSharedLabel = m_xBuilder->weld_label("shared_label"); + m_xImpl->m_xSharedListBox = m_xBuilder->weld_combo_box("shared"); + + // because the "<All Formats> (*.bmp,*...)" entry is too wide, + // we need to disable the auto width feature of the filter box + int nWidth = m_xImpl->m_xLbFilter->get_approximate_digit_width() * 60; + m_xImpl->m_xSharedListBox->set_size_request(nWidth, -1); + m_xImpl->m_xLbFilter->set_size_request(nWidth, -1); + + m_xImpl->m_xBtnUp.reset(new SvtUpButton_Impl(m_xBuilder->weld_toolbar("up_bar"), + m_xBuilder->weld_menu("up_menu"), + this)); + m_xImpl->m_xBtnUp->set_help_id(HID_FILEOPEN_LEVELUP); + m_xImpl->m_xBtnUp->show(); + + m_xImpl->m_nStyle = nStyle; + m_xImpl->m_eMode = ( nStyle & PickerFlags::SaveAs ) ? FILEDLG_MODE_SAVE : FILEDLG_MODE_OPEN; + m_xImpl->m_eDlgType = FILEDLG_TYPE_FILEDLG; + + if (nStyle & PickerFlags::PathDialog) + m_xImpl->m_eDlgType = FILEDLG_TYPE_PATHDLG; + + // Set the directory for the "back to the default dir" button + INetURLObject aStdDirObj( SvtPathOptions().GetWorkPath() ); + SetStandardDir( aStdDirObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + // Create control element, the order defines the tab control. + m_xImpl->m_xEdFileName->connect_changed( LINK( this, SvtFileDialog, EntrySelectHdl_Impl ) ); + m_xImpl->m_xEdFileName->connect_entry_activate( LINK( this, SvtFileDialog, OpenUrlHdl_Impl ) ); + + // in folder picker mode, only auto-complete directories (no files) + bool bIsFolderPicker = m_xImpl->m_eDlgType == FILEDLG_TYPE_PATHDLG; + m_xImpl->m_xEdFileName->SetOnlyDirectories( bIsFolderPicker ); + + // in save mode, don't use the autocompletion as selection in the edit part + bool bSaveMode = FILEDLG_MODE_SAVE == m_xImpl->m_eMode; + m_xImpl->m_xEdFileName->SetNoURLSelection( bSaveMode ); + + if (nStyle & PickerFlags::MultiSelection) + m_xImpl->m_bMultiSelection = true; + + m_xContainer = m_xBuilder->weld_container("container"); + m_xContainer->set_size_request(m_xContainer->get_approximate_digit_width() * 95, -1); + + m_xFileView.reset(new SvtFileView(m_xDialog.get(), + m_xBuilder->weld_tree_view("fileview"), + m_xBuilder->weld_icon_view("iconview"), + FILEDLG_TYPE_PATHDLG == m_xImpl->m_eDlgType, + m_xImpl->m_bMultiSelection)); + m_xFileView->set_help_id( HID_FILEDLG_STANDARD ); + + if ( nStyle & PickerFlags::ReadOnly ) + { + m_xCbReadOnly->set_help_id( HID_FILEOPEN_READONLY ); + m_xCbReadOnly->set_label( FpsResId( STR_SVT_FILEPICKER_READONLY ) ); + m_xCbReadOnly->connect_clicked( LINK( this, SvtFileDialog, ClickHdl_Impl ) ); + m_xCbReadOnly->show(); + } + + if ( nStyle & PickerFlags::Password ) + { + m_xImpl->m_xCbPassword->set_label( FpsResId( STR_SVT_FILEPICKER_PASSWORD ) ); + m_xImpl->m_xCbPassword->connect_clicked( LINK( this, SvtFileDialog, ClickHdl_Impl ) ); + m_xImpl->m_xCbPassword->show(); + m_xImpl->m_xCbGPGEncrypt->connect_clicked( LINK( this, SvtFileDialog, ClickHdl_Impl ) ); + m_xImpl->m_xCbGPGEncrypt->show(); + } + + // set the ini file for extracting the size + m_xImpl->m_aIniKey = "FileDialog"; + + AddControls_Impl( ); + + // adjust the labels to the mode + const char* pResId = STR_EXPLORERFILE_OPEN; + const char* pButtonResId = nullptr; + + if ( nStyle & PickerFlags::SaveAs ) + { + pResId = STR_EXPLORERFILE_SAVE; + pButtonResId = STR_EXPLORERFILE_BUTTONSAVE; + } + + if ( nStyle & PickerFlags::PathDialog ) + { + m_xImpl->m_xFtFileName->set_label( FpsResId( STR_PATHNAME ) ); + pResId = STR_PATHSELECT; + pButtonResId = STR_BUTTONSELECT; + } + + m_xDialog->set_title(FpsResId(pResId)); + + if ( pButtonResId ) + m_xImpl->m_xBtnFileOpen->set_label( FpsResId( pButtonResId ) ); + + if ( FILEDLG_TYPE_FILEDLG != m_xImpl->m_eDlgType ) + { + m_xImpl->m_xFtFileType->hide(); + m_xImpl->GetFilterListControl()->hide(); + } + + // Setting preferences of the control elements. + m_xImpl->m_xBtnNewFolder->connect_clicked( LINK( this, SvtFileDialog, NewFolderHdl_Impl ) ); + m_xImpl->m_xBtnFileOpen->connect_clicked( LINK( this, SvtFileDialog, OpenClickHdl_Impl ) ); + m_xImpl->m_xBtnCancel->connect_clicked( LINK( this, SvtFileDialog, CancelHdl_Impl ) ); + m_xImpl->SetFilterListSelectHdl( LINK( this, SvtFileDialog, FilterSelectHdl_Impl ) ); + m_xImpl->m_xEdFileName->connect_focus_in( LINK( this, SvtFileDialog, FileNameGetFocusHdl_Impl ) ); + m_xImpl->m_xEdFileName->connect_changed( LINK( this, SvtFileDialog, FileNameModifiedHdl_Impl ) ); + m_xImpl->m_xEdCurrentPath->connect_entry_activate( LINK( this, SvtFileDialog, URLBoxModifiedHdl_Impl ) ); + m_xImpl->m_xBtnConnectToServer->connect_clicked( LINK ( this, SvtFileDialog, ConnectToServerPressed_Hdl ) ); + + m_xFileView->SetSelectHdl( LINK( this, SvtFileDialog, SelectHdl_Impl ) ); + m_xFileView->SetDoubleClickHdl( LINK( this, SvtFileDialog, DblClickHdl_Impl ) ); + m_xFileView->SetOpenDoneHdl( LINK( this, SvtFileDialog, OpenDoneHdl_Impl ) ); + + // set timer for the filterbox travel + m_xImpl->m_aFilterIdle.SetPriority(TaskPriority::LOWEST); + m_xImpl->m_aFilterIdle.SetInvokeHandler( LINK( this, SvtFileDialog, FilterSelectTimerHdl_Impl ) ); + + if ( PickerFlags::SaveAs & nStyle ) + { + // different help ids if in save-as mode + m_xDialog->set_help_id( HID_FILESAVE_DIALOG ); + + m_xImpl->m_xEdFileName->set_help_id( HID_FILESAVE_FILEURL ); + m_xImpl->m_xBtnFileOpen->set_help_id( HID_FILESAVE_DOSAVE ); + m_xImpl->m_xBtnNewFolder->set_help_id( HID_FILESAVE_CREATEDIRECTORY ); + m_xImpl->m_xBtnUp->set_help_id( HID_FILESAVE_LEVELUP ); + m_xImpl->GetFilterListControl()->set_help_id( HID_FILESAVE_FILETYPE ); + m_xFileView->set_help_id( HID_FILESAVE_FILEVIEW ); + + // formerly, there was only _pLbFileVersion, which was used for 3 different + // use cases. For reasons of maintainability, I introduced extra members (_pLbTemplates, _pLbImageTemplates) + // for the extra use cases, and separated _pLbFileVersion + // I did not find out in which cases the help ID is really needed HID_FILESAVE_TEMPLATE - all + // tests I made lead to a dialog where _no_ of the three list boxes was present. + if (m_xImpl->m_xSharedListBox) + m_xImpl->m_xSharedListBox->set_help_id( HID_FILESAVE_TEMPLATE ); + + if ( m_xImpl->m_xCbPassword ) m_xImpl->m_xCbPassword->set_help_id( HID_FILESAVE_SAVEWITHPASSWORD ); + if ( m_xImpl->m_xCbAutoExtension ) m_xImpl->m_xCbAutoExtension->set_help_id( HID_FILESAVE_AUTOEXTENSION ); + if ( m_xImpl->m_xCbOptions ) m_xImpl->m_xCbOptions->set_help_id( HID_FILESAVE_CUSTOMIZEFILTER ); + if ( m_xCbSelection ) m_xCbSelection->set_help_id( HID_FILESAVE_SELECTION ); + } + + /// read our settings from the configuration + m_aConfiguration = OConfigurationTreeRoot::createWithComponentContext( + ::comphelper::getProcessComponentContext(), + "/org.openoffice.Office.UI/FilePicker" + ); + + m_xDialog->connect_size_allocate(LINK(this, SvtFileDialog, SizeAllocHdl)); + SizeAllocHdl(Size()); + + m_xImpl->m_xEdFileName->grab_focus(); +} + +SvtFileDialog::~SvtFileDialog() +{ + if (!m_xImpl->m_aIniKey.isEmpty()) + { + // save window state + SvtViewOptions aDlgOpt( EViewType::Dialog, m_xImpl->m_aIniKey ); + aDlgOpt.SetWindowState(OStringToOUString(m_xDialog->get_window_state(WindowStateMask::All), RTL_TEXTENCODING_UTF8)); + OUString sUserData = m_xFileView->GetConfigString(); + aDlgOpt.SetUserItem( "UserData", + makeAny( sUserData ) ); + } + + m_xFileView->SetSelectHdl(Link<SvtFileView*,void>()); + + // Save bookmarked places + if (!m_xImpl->m_xPlaces->IsUpdated()) + return; + + const std::vector<PlacePtr> aPlaces = m_xImpl->m_xPlaces->GetPlaces(); + Sequence< OUString > placesUrlsList(m_xImpl->m_xPlaces->GetNbEditablePlaces()); + Sequence< OUString > placesNamesList(m_xImpl->m_xPlaces->GetNbEditablePlaces()); + int i(0); + for (auto const& place : aPlaces) + { + if(place->IsEditable()) { + placesUrlsList[i] = place->GetUrl(); + placesNamesList[i] = place->GetName(); + ++i; + } + } + + std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create(m_xContext)); + officecfg::Office::Common::Misc::FilePickerPlacesUrls::set(placesUrlsList, batch); + officecfg::Office::Common::Misc::FilePickerPlacesNames::set(placesNamesList, batch); + batch->commit(); +} + +IMPL_LINK_NOARG(SvtFileDialog, NewFolderHdl_Impl, weld::Button&, void) +{ + m_xFileView->EndInplaceEditing(); + + SmartContent aContent( m_xFileView->GetViewURL( ) ); + OUString aTitle; + aContent.getTitle( aTitle ); + QueryFolderNameDialog aDlg(m_xDialog.get(), aTitle, FpsResId(STR_SVT_NEW_FOLDER)); + bool bHandled = false; + + while ( !bHandled ) + { + if (aDlg.run() == RET_OK) + { + OUString aUrl = aContent.createFolder(aDlg.GetName()); + if ( !aUrl.isEmpty( ) ) + { + m_xFileView->CreatedFolder(aUrl, aDlg.GetName()); + bHandled = true; + } + } + else + bHandled = true; + } +} + +void SvtFileDialog::createNewUserFilter( const OUString& _rNewFilter ) +{ + // delete the old user filter and create a new one + m_xImpl->m_xUserFilter.reset( new SvtFileDialogFilter_Impl( _rNewFilter, _rNewFilter ) ); + + // remember the extension + bool bIsAllFiles = _rNewFilter == FILEDIALOG_FILTER_ALL; + if ( bIsAllFiles ) + EraseDefaultExt(); + else + SetDefaultExt( _rNewFilter.copy( 2 ) ); + // TODO: this is nonsense. In the whole file there are a lot of places where we assume that a user filter + // is always "*.<something>". But changing this would take some more time than I have now... + + // now, the default extension is set to the one of the user filter (or empty) + if ( m_xImpl->GetCurFilter( ) ) + SetDefaultExt( m_xImpl->GetCurFilter( )->GetExtension() ); + else + EraseDefaultExt(); +} + + +AdjustFilterFlags SvtFileDialog::adjustFilter( const OUString& rFilter ) +{ + AdjustFilterFlags nReturn = AdjustFilterFlags::NONE; + + const bool bNonEmpty = !rFilter.isEmpty(); + if ( bNonEmpty ) + { + nReturn |= AdjustFilterFlags::NonEmpty; + + bool bFilterChanged = true; + + // search for a corresponding filter + SvtFileDialogFilter_Impl* pFilter = FindFilter_Impl( rFilter, false, bFilterChanged ); + + // look for multi-ext filters if necessary + if ( !pFilter ) + pFilter = FindFilter_Impl( rFilter, true, bFilterChanged ); + + if ( bFilterChanged ) + nReturn |= AdjustFilterFlags::Changed; + + if ( !pFilter ) + { + nReturn |= AdjustFilterFlags::UserFilter; + // no filter found : use it as user defined filter + createNewUserFilter( rFilter ); + } + } + + return nReturn; +} + +IMPL_LINK_NOARG(SvtFileDialog, CancelHdl_Impl, weld::Button&, void) +{ + if ( m_pCurrentAsyncAction.is() ) + { + m_pCurrentAsyncAction->cancel(); + onAsyncOperationFinished(); + } + else + { + m_xDialog->response(RET_CANCEL); + } +} + +IMPL_LINK( SvtFileDialog, OpenClickHdl_Impl, weld::Button&, rVoid, void ) +{ + OpenHdl_Impl(&rVoid); +} + +IMPL_LINK( SvtFileDialog, OpenUrlHdl_Impl, weld::ComboBox&, rVoid, bool ) +{ + OpenHdl_Impl(&rVoid); + return true; +} + +void SvtFileDialog::OpenHdl_Impl(void const * pVoid) +{ + if ( m_xImpl->m_bMultiSelection && m_xFileView->GetSelectionCount() > 1 ) + { + // special open in case of multiselection + OpenMultiSelection_Impl(); + return; + } + + OUString aFileName; + OUString aOldPath(m_xFileView->GetViewURL()); + if ( m_xImpl->m_bDoubleClick || m_xFileView->has_focus() ) + { + // Selection done by doubleclicking in the view, get filename from the view + aFileName = m_xFileView->GetCurrentURL(); + } + + if ( aFileName.isEmpty() ) + { + // if an entry is selected in the view... + if ( m_xFileView->GetSelectionCount() ) + { // -> use this one. This will allow us to step down this folder + aFileName = m_xFileView->GetCurrentURL(); + } + } + + if ( aFileName.isEmpty() ) + { + // get the URL from the edit field ( if not empty ) + if ( !m_xImpl->m_xEdFileName->get_active_text().isEmpty() ) + { + OUString aText = m_xImpl->m_xEdFileName->get_active_text(); + + // did we reach the root? + if ( !INetURLObject( aOldPath ).getSegmentCount() ) + { + if ( ( aText.getLength() == 2 && aText == ".." ) || + ( aText.getLength() == 3 && ( aText == "..\\" || aText == "../" ) ) ) + // don't go higher than the root + return; + } + +#if defined( UNX ) + if ( ( 1 == aText.getLength() ) && ( '~' == aText[0] ) ) + { + // go to the home directory + if ( lcl_getHomeDirectory( m_xFileView->GetViewURL(), aFileName ) ) + // in case we got a home dir, reset the text of the edit + m_xImpl->m_xEdFileName->set_entry_text( OUString() ); + } + if ( aFileName.isEmpty() ) +#endif + { + // get url from autocomplete edit + aFileName = m_xImpl->m_xEdFileName->GetURL(); + } + } + else if ( pVoid == m_xImpl->m_xBtnFileOpen.get() ) + // OpenHdl was called for the "Open" Button; if edit field is empty, use selected element in the view + aFileName = m_xFileView->GetCurrentURL(); + } + + // MBA->PB: ?! + if ( aFileName.isEmpty() && pVoid == m_xImpl->m_xEdFileName.get() && m_xImpl->m_xUserFilter ) + { + m_xImpl->m_xUserFilter.reset(); + return; + } + + sal_Int32 nLen = aFileName.getLength(); + if ( !nLen ) + { + // if the dialog was opened to select a folder, the last selected folder should be selected + if( m_xImpl->m_eDlgType == FILEDLG_TYPE_PATHDLG ) + { + aFileName = m_xImpl->m_xEdCurrentPath->get_active_text(); + nLen = aFileName.getLength(); + } + else + // no file selected ! + return; + } + + // mark input as selected + m_xImpl->m_xEdFileName->select_entry_region(0, nLen); + + // if a path with wildcards is given, divide the string into path and wildcards + OUString aFilter; + if ( !SvtFileDialog::IsolateFilterFromPath_Impl( aFileName, aFilter ) ) + return; + + // if a filter was retrieved, there were wildcards ! + AdjustFilterFlags nNewFilterFlags = adjustFilter( aFilter ); + if ( nNewFilterFlags & AdjustFilterFlags::Changed ) + { + // cut off all text before wildcard in edit and select wildcard + m_xImpl->m_xEdFileName->set_entry_text( aFilter ); + m_xImpl->m_xEdFileName->select_entry_region(0, -1); + } + + { + INetURLObject aFileObject( aFileName ); + if ( ( aFileObject.GetProtocol() == INetProtocol::NotValid ) && !aFileName.isEmpty() ) + { + OUString sCompleted = SvtURLBox::ParseSmart( aFileName, m_xFileView->GetViewURL() ); + if ( !sCompleted.isEmpty() ) + aFileName = sCompleted; + } + } + + // check if it is a folder + bool bIsFolder = false; + + // first thing before doing anything with the content: Reset it. When the user presses "open" (or "save" or "export", + // for that matter), s/he wants the complete handling, including all possible error messages, even if s/he + // does the same thing for the same content twice, s/he wants both fails to be displayed. + // Without the reset, it could be that the content cached all relevant information, and will not display any + // error messages for the same content a second time... + m_aContent.bindTo( OUString( ) ); + + if ( !aFileName.isEmpty() ) + { + // Make sure we have own Interaction Handler in place. We do not need + // to intercept interactions here, but to record the fact that there + // was an interaction. + SmartContent::InteractionHandlerType eInterActionHandlerType + = m_aContent.queryCurrentInteractionHandler(); + if ( ( eInterActionHandlerType == SmartContent::IHT_NONE ) || + ( eInterActionHandlerType == SmartContent::IHT_DEFAULT ) ) + m_aContent.enableOwnInteractionHandler( + OFilePickerInteractionHandler::E_NOINTERCEPTION ); + + bIsFolder = m_aContent.isFolder( aFileName ); + + // access denied to the given resource - and interaction was already + // used => break following operations + OFilePickerInteractionHandler* pHandler + = m_aContent.getOwnInteractionHandler(); + + OSL_ENSURE( pHandler, "Got no Interaction Handler!!!" ); + + if ( pHandler->wasAccessDenied() ) + return; + + if ( m_aContent.isInvalid() && + ( m_xImpl->m_eMode == FILEDLG_MODE_OPEN ) ) + { + if ( !pHandler->wasUsed() ) + ErrorHandler::HandleError( ERRCODE_IO_NOTEXISTS ); + + return; + } + + // restore previous Interaction Handler + if ( eInterActionHandlerType == SmartContent::IHT_NONE ) + m_aContent.disableInteractionHandler(); + else if ( eInterActionHandlerType == SmartContent::IHT_DEFAULT ) + m_aContent.enableDefaultInteractionHandler(); + } + + if ( !bIsFolder // no existent folder + && m_xImpl->m_xCbAutoExtension // auto extension is enabled in general + && m_xImpl->m_xCbAutoExtension->get_active()// auto extension is really to be used + && !GetDefaultExt().isEmpty() // there is a default extension + && GetDefaultExt() != "*" // the default extension is not "all" + && !( FILEDLG_MODE_SAVE == m_xImpl->m_eMode // we're saving a file + && m_xFileView->GetSelectionCount() // there is a selected file in the file view -> it will later on + ) // (in SvtFileDialog::GetPathList) be taken as file to save to + + && FILEDLG_MODE_OPEN != m_xImpl->m_eMode // #i83408# don't append extension on open + ) + { + // check extension and append the default extension if necessary + appendDefaultExtension(aFileName, + GetDefaultExt(), + m_xImpl->GetCurFilter()->GetType()); + } + + bool bOpenFolder = ( FILEDLG_TYPE_PATHDLG == m_xImpl->m_eDlgType ) && + !m_xImpl->m_bDoubleClick && pVoid != m_xImpl->m_xEdFileName.get(); + if ( bIsFolder ) + { + if ( bOpenFolder ) + { + m_aPath = aFileName; + } + else + { + if ( aFileName != m_xFileView->GetViewURL() ) + { + OpenURL_Impl( aFileName ); + } + else + { + if ( nNewFilterFlags & AdjustFilterFlags::Changed ) + ExecuteFilter(); + } + + return; + } + } + else if ( !( nNewFilterFlags & AdjustFilterFlags::NonEmpty ) ) + { + // if applicable save URL + m_aPath = aFileName; + } + else + { + // if applicable filter again + if ( nNewFilterFlags & AdjustFilterFlags::Changed ) + ExecuteFilter(); + return; + } + + INetURLObject aFileObj( aFileName ); + if ( aFileObj.HasError() ) + { + ErrorHandler::HandleError( ERRCODE_IO_GENERAL ); + return; + } + + switch (m_xImpl->m_eMode) + { + case FILEDLG_MODE_SAVE: + { + if ( ::utl::UCBContentHelper::Exists( aFileObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) ) + { + OUString aMsg = FpsResId(STR_SVT_ALREADYEXISTOVERWRITE); + aMsg = aMsg.replaceFirst( + "$filename$", + aFileObj.getName(INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset) + ); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Question, VclButtonsType::YesNo, aMsg)); + if (xBox->run() != RET_YES) + return; + } + else + { + OUString aCurPath; + if (osl::FileBase::getSystemPathFromFileURL(aFileName, aCurPath) == osl::FileBase::E_None) + { + // if content does not exist: at least its path must exist + INetURLObject aPathObj = aFileObj; + aPathObj.removeSegment(); + bool bFolder = m_aContent.isFolder( aPathObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + if ( !bFolder ) + { + ErrorHandler::HandleError( ERRCODE_IO_NOTEXISTSPATH ); + return; + } + } + } + } + break; + + case FILEDLG_MODE_OPEN: + { + // do an existence check herein, again + + if ( INetProtocol::File == aFileObj.GetProtocol( ) ) + { + bool bExists = m_aContent.is( aFileObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + if ( !bExists ) + { + OUString sError(FpsResId(RID_FILEOPEN_NOTEXISTENTFILE)); + + OUString sInvalidFile( aFileObj.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ) ); + if ( INetProtocol::File == aFileObj.GetProtocol() ) + { // if it's a file URL, transform the URL into system notation + OUString sURL( sInvalidFile ); + OUString sSystem; + osl_getSystemPathFromFileURL( sURL.pData, &sSystem.pData ); + sInvalidFile = sSystem; + } + sError = sError.replaceFirst( "$name$", sInvalidFile ); + + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, sError)); + xBox->run(); + return; + } + } + } + break; + + default: + OSL_FAIL("SvtFileDialog, OpenHdl_Impl: invalid mode!"); + } + + m_xDialog->response(RET_OK); +} + +void SvtFileDialog::EnableAutocompletion(bool bEnable) +{ + m_xImpl->m_xEdFileName->EnableAutocomplete(bEnable); +} + +IMPL_LINK_NOARG( SvtFileDialog, FilterSelectHdl_Impl, weld::ComboBox&, void ) +{ + OUString sSelectedFilterDisplayName; + SvtFileDialogFilter_Impl* pSelectedFilter = m_xImpl->GetSelectedFilterEntry( sSelectedFilterDisplayName ); + if ( !pSelectedFilter ) + { // there is no current selection. This happens if for instance the user selects a group separator using + // the keyboard, and then presses enter: When the selection happens, we immediately deselect the entry, + // so in this situation there is no current selection. + restoreCurrentFilter( m_xImpl ); + } + else + { + if ( ( pSelectedFilter != m_xImpl->GetCurFilter() ) + || m_xImpl->m_xUserFilter + ) + { + // Store the old filter for the auto extension handling + OUString sLastFilterExt = m_xImpl->GetCurFilter()->GetExtension(); + m_xImpl->m_xUserFilter.reset(); + + // if applicable remove filter of the user + m_xImpl->SetCurFilter( pSelectedFilter, sSelectedFilterDisplayName ); + + // if applicable show extension + SetDefaultExt( pSelectedFilter->GetExtension() ); + sal_Int32 nSepPos = GetDefaultExt().indexOf( FILEDIALOG_DEF_EXTSEP ); + + if ( nSepPos != -1 ) + EraseDefaultExt( nSepPos ); + + // update the extension of the current file if necessary + lcl_autoUpdateFileExtension( this, sLastFilterExt ); + + // if the user is traveling fast through the filterbox + // do not filter instantly + // FilterSelectHdl_Impl should be started again at idle + m_xImpl->m_aFilterIdle.Start(); + } + } +} + +IMPL_LINK_NOARG(SvtFileDialog, FilterSelectTimerHdl_Impl, Timer*, void) +{ + // filter the view again + ExecuteFilter(); +} + +IMPL_LINK_NOARG( SvtFileDialog, FileNameGetFocusHdl_Impl, weld::Widget&, void ) +{ + m_xFileView->SetNoSelection(); +} + +IMPL_LINK( SvtFileDialog, FileNameModifiedHdl_Impl, weld::ComboBox&, rComboBox, void ) +{ + FileNameGetFocusHdl_Impl(rComboBox); +} + +IMPL_LINK_NOARG(SvtFileDialog, URLBoxModifiedHdl_Impl, weld::ComboBox&, bool) +{ + OUString aPath = m_xImpl->m_xEdCurrentPath->GetURL(); + OpenURL_Impl(aPath); + return true; +} + +IMPL_LINK_NOARG( SvtFileDialog, ConnectToServerPressed_Hdl, weld::Button&, void ) +{ + m_xFileView->EndInplaceEditing(); + + PlaceEditDialog aDlg(m_xDialog.get()); + short aRetCode = aDlg.run(); + + switch (aRetCode) { + case RET_OK : + { + PlacePtr newPlace = aDlg.GetPlace(); + m_xImpl->m_xPlaces->AppendPlace(newPlace); + + break; + } + case RET_CANCEL : + default : + // Do Nothing + break; + } +} + +IMPL_LINK_NOARG ( SvtFileDialog, AddPlacePressed_Hdl, weld::Button&, void ) +{ + // Maybe open the PlacesDialog would have been a better idea + // there is an ux choice to make we did not make... + INetURLObject aURLObj( m_xFileView->GetViewURL() ); + PlacePtr newPlace = + std::make_shared<Place>( aURLObj.GetLastName(INetURLObject::DecodeMechanism::WithCharset), + m_xFileView->GetViewURL(), true); + m_xImpl->m_xPlaces->AppendPlace(newPlace); +} + +IMPL_LINK_NOARG ( SvtFileDialog, RemovePlacePressed_Hdl, weld::Button&, void ) +{ + m_xImpl->m_xPlaces->RemoveSelectedPlace(); +} + +SvtFileDialogFilter_Impl* SvtFileDialog::FindFilter_Impl +( + const OUString& rFilter, + bool bMultiExt,/* TRUE - regard filter with several extensions + FALSE - do not ... + */ + bool& rFilterChanged +) + +/* [Description] + + This method looks for the specified extension in the included filters. +*/ + +{ + SvtFileDialogFilter_Impl* pFoundFilter = nullptr; + SvtFileDialogFilterList_Impl& rList = m_xImpl->m_aFilter; + sal_uInt16 nFilter = rList.size(); + + while ( nFilter-- ) + { + SvtFileDialogFilter_Impl* pFilter = rList[ nFilter ].get(); + const OUString& rType = pFilter->GetType(); + + if ( bMultiExt ) + { + sal_Int32 nIdx = 0; + while ( !pFoundFilter && nIdx != -1 ) + { + const OUString aSingleType = rType.getToken( 0, FILEDIALOG_DEF_EXTSEP, nIdx ); +#ifdef UNX + if ( aSingleType == rFilter ) +#else + if ( aSingleType.equalsIgnoreAsciiCase( rFilter ) ) +#endif + pFoundFilter = pFilter; + } + } +#ifdef UNX + else if ( rType == rFilter ) +#else + else if ( rType.equalsIgnoreAsciiCase( rFilter ) ) +#endif + pFoundFilter = pFilter; + + if ( pFoundFilter ) + { + // activate filter + rFilterChanged = m_xImpl->m_xUserFilter || ( m_xImpl->GetCurFilter() != pFilter ); + + createNewUserFilter( rFilter ); + + break; + } + } + return pFoundFilter; +} + + +void SvtFileDialog::ExecuteFilter() +{ + executeAsync( AsyncPickerAction::eExecuteFilter, OUString(), getMostCurrentFilter(m_xImpl) ); +} + +/* [Description] + + OpenHandler for MultiSelection +*/ +void SvtFileDialog::OpenMultiSelection_Impl() +{ + SvtContentEntry* pEntry = m_xFileView->FirstSelected(); + + if (pEntry) + m_aPath = pEntry->maURL; + + m_xDialog->response(RET_OK); +} + +void SvtFileDialog::UpdateControls( const OUString& rURL ) +{ + m_xImpl->m_xEdFileName->SetBaseURL( rURL ); + + INetURLObject aObj( rURL ); + + { + OUString sText; + SAL_WARN_IF( INetProtocol::NotValid == aObj.GetProtocol(), "fpicker.office", "SvtFileDialog::UpdateControls: Invalid URL!" ); + + if ( aObj.getSegmentCount() ) + { + osl::FileBase::getSystemPathFromFileURL(rURL, sText); + if ( !sText.isEmpty() ) + { + // no Fsys path for server file system ( only UCB has mountpoints! ) + if ( INetProtocol::File != aObj.GetProtocol() ) + sText = rURL.copy( INetURLObject::GetScheme( aObj.GetProtocol() ).getLength() ); + } + + if ( sText.isEmpty() && aObj.getSegmentCount() ) + sText = rURL; + } + + // path mode ? + if ( FILEDLG_TYPE_PATHDLG == m_xImpl->m_eDlgType ) + // -> set new path in the edit field + m_xImpl->m_xEdFileName->set_entry_text( sText ); + + // in the "current path" field, truncate the trailing slash + if ( aObj.hasFinalSlash() ) + { + aObj.removeFinalSlash(); + OUString sURL( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + if (osl::FileBase::getSystemPathFromFileURL(sURL, sText) != osl::FileBase::E_None) + sText = sURL; + } + + if ( sText.isEmpty() && !rURL.isEmpty() ) + // happens, for instance, for URLs which the INetURLObject does not know to belong to a hierarchical scheme + sText = rURL; + m_xImpl->m_xEdCurrentPath->set_entry_text(sText); + } + + m_aPath = rURL; + + m_xImpl->m_xBtnUp->FillURLMenu(); + + if (m_pFileNotifier) + m_pFileNotifier->notify( DIRECTORY_CHANGED, 0 ); +} + +IMPL_LINK( SvtFileDialog, SelectHdl_Impl, SvtFileView*, pBox, void ) +{ + SvtContentEntry* pUserData = pBox->FirstSelected(); + if (pUserData) + { + INetURLObject aObj( pUserData->maURL ); + if ( FILEDLG_TYPE_PATHDLG == m_xImpl->m_eDlgType ) + { + if ( aObj.GetProtocol() == INetProtocol::File ) + { + if ( !pUserData->mbIsFolder ) + aObj.removeSegment(); + OUString aName = aObj.getFSysPath( static_cast<FSysStyle>(FSysStyle::Detect & ~FSysStyle::Vos) ); + m_xImpl->m_xEdFileName->set_entry_text( aName ); + m_xImpl->m_xEdFileName->select_entry_region(0, -1); + m_aPath = pUserData->maURL; + } + else if ( !pUserData->mbIsFolder ) + { + m_xImpl->m_xEdFileName->set_entry_text( pUserData->maURL ); + m_xImpl->m_xEdFileName->select_entry_region(0, -1); + m_aPath = pUserData->maURL; + } + else + m_xImpl->m_xEdFileName->set_entry_text( OUString() ); + } + else + { + if ( !pUserData->mbIsFolder ) + { + OUString aName = pBox->get_selected_text(); + m_xImpl->m_xEdFileName->set_entry_text( aName ); + m_xImpl->m_xEdFileName->select_entry_region(0, -1); + m_aPath = pUserData->maURL; + } + } + } + + if ( m_xImpl->m_bMultiSelection && m_xFileView->GetSelectionCount() > 1 ) + { + // clear the file edit for multiselection + m_xImpl->m_xEdFileName->set_entry_text( OUString() ); + } + + FileSelect(); +} + +IMPL_LINK_NOARG(SvtFileDialog, DblClickHdl_Impl, SvtFileView*, bool) +{ + m_xImpl->m_bDoubleClick = true; + OpenHdl_Impl( nullptr ); + m_xImpl->m_bDoubleClick = false; + return true; +} + +IMPL_LINK_NOARG(SvtFileDialog, EntrySelectHdl_Impl, weld::ComboBox&, void) +{ + FileSelect(); +} + +IMPL_LINK( SvtFileDialog, OpenDoneHdl_Impl, SvtFileView*, pView, void ) +{ + const OUString& sCurrentFolder( pView->GetViewURL() ); + // check if we can create new folders + EnableControl( m_xImpl->m_xBtnNewFolder.get(), ContentCanMakeFolder( sCurrentFolder ) ); + + // check if we can travel one level up + bool bCanTravelUp = ContentHasParentFolder( pView->GetViewURL() ); + if ( bCanTravelUp ) + { + // additional check: the parent folder should not be prohibited + INetURLObject aCurrentFolder( sCurrentFolder ); + SAL_WARN_IF( INetProtocol::NotValid == aCurrentFolder.GetProtocol(), + "fpicker.office", "SvtFileDialog::OpenDoneHdl_Impl: invalid current URL!" ); + + aCurrentFolder.removeSegment(); + } + EnableControl( m_xImpl->m_xBtnUp->getWidget(), bCanTravelUp ); +} + +IMPL_LINK_NOARG(SvtFileDialog, AutoExtensionHdl_Impl, weld::Button&, void) +{ + if (m_pFileNotifier) + m_pFileNotifier->notify(CTRL_STATE_CHANGED, CHECKBOX_AUTOEXTENSION); + + // update the extension of the current file if necessary + lcl_autoUpdateFileExtension( this, m_xImpl->GetCurFilter()->GetExtension() ); +} + +IMPL_LINK( SvtFileDialog, ClickHdl_Impl, weld::Button&, rCheckBox, void ) +{ + if (!m_pFileNotifier) + return; + + sal_Int16 nId = -1; + + if ( &rCheckBox == m_xImpl->m_xCbOptions.get() ) + nId = CHECKBOX_FILTEROPTIONS; + else if ( &rCheckBox == m_xCbSelection.get() ) + nId = CHECKBOX_SELECTION; + else if ( &rCheckBox == m_xCbReadOnly.get() ) + nId = CHECKBOX_READONLY; + else if ( &rCheckBox == m_xImpl->m_xCbPassword.get() ) + nId = CHECKBOX_PASSWORD; + else if ( &rCheckBox == m_xImpl->m_xCbGPGEncrypt.get() ) + nId = CHECKBOX_GPGENCRYPTION; + else if ( &rCheckBox == m_xCbLinkBox.get() ) + nId = CHECKBOX_LINK; + else if ( &rCheckBox == m_xCbPreviewBox.get() ) + nId = CHECKBOX_PREVIEW; + + if ( nId != -1 ) + m_pFileNotifier->notify( CTRL_STATE_CHANGED, nId ); +} + + +IMPL_LINK_NOARG(SvtFileDialog, PlayButtonHdl_Impl, weld::Button&, void) +{ + if (m_pFileNotifier) + m_pFileNotifier->notify(CTRL_STATE_CHANGED, PUSHBUTTON_PLAY); +} + +namespace +{ + +bool implIsInvalid( const OUString & rURL ) +{ + SmartContent aContent( rURL ); + aContent.enableOwnInteractionHandler( ::svt::OFilePickerInteractionHandler::E_DOESNOTEXIST ); + aContent.isFolder(); // do this _before_ asking isInvalid! Otherwise result might be wrong. + return aContent.isInvalid(); +} + +} + + +OUString SvtFileDialog::implGetInitialURL( const OUString& _rPath, const OUString& _rFallback ) +{ + // a URL parser for the fallback + INetURLObject aURLParser; + + // set the path + bool bWasAbsolute = false; + aURLParser = aURLParser.smartRel2Abs( _rPath, bWasAbsolute ); + + // is it a valid folder? + m_aContent.bindTo( aURLParser.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + bool bIsFolder = m_aContent.isFolder( ); // do this _before_ asking isInvalid! + bool bIsInvalid = m_aContent.isInvalid(); + + if ( bIsInvalid && m_bHasFilename && !aURLParser.hasFinalSlash() ) + { // check if the parent folder exists + INetURLObject aParent( aURLParser ); + aParent.removeSegment( ); + aParent.setFinalSlash( ); + bIsInvalid = implIsInvalid( aParent.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + } + + if ( bIsInvalid ) + { + INetURLObject aFallback( _rFallback ); + bIsInvalid = implIsInvalid( aFallback.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + if ( !bIsInvalid ) + aURLParser = aFallback; + } + + if ( bIsInvalid ) + { + INetURLObject aParent( aURLParser ); + while ( bIsInvalid && aParent.removeSegment() ) + { + aParent.setFinalSlash( ); + bIsInvalid = implIsInvalid( aParent.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + } + + if ( !bIsInvalid ) + aURLParser = aParent; + } + + if ( !bIsInvalid && bIsFolder ) + { + aURLParser.setFinalSlash(); + } + return aURLParser.GetMainURL( INetURLObject::DecodeMechanism::NONE ); +} + + +short SvtFileDialog::run() +{ + if ( !PrepareExecute() ) + return 0; + + // start the dialog + m_bIsInExecute = true; + short nResult = GenericDialogController::run(); + m_bIsInExecute = false; + + SAL_WARN_IF( m_pCurrentAsyncAction.is(), "fpicker.office", "SvtFilePicker::run: still running an async action!" ); + // the dialog should not be cancellable while an async action is running - first, the action + // needs to be cancelled + + // remember last directory + if ( RET_OK == nResult ) + { + INetURLObject aURL( m_aPath ); + if ( aURL.GetProtocol() == INetProtocol::File ) + { + // remember the selected directory only for file URLs not for virtual folders + sal_Int32 nLevel = aURL.getSegmentCount(); + bool bDir = m_aContent.isFolder( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + if ( nLevel > 1 && ( FILEDLG_TYPE_FILEDLG == m_xImpl->m_eDlgType || !bDir ) ) + aURL.removeSegment(); + } + } + + return nResult; +} + +void SvtFileDialog::onAsyncOperationStarted() +{ + EnableUI( false ); + // the cancel button must be always enabled + m_xImpl->m_xBtnCancel->set_sensitive(true); + m_xImpl->m_xBtnCancel->grab_focus(); +} + +void SvtFileDialog::onAsyncOperationFinished() +{ + EnableUI( true ); + m_pCurrentAsyncAction = nullptr; + if ( !m_bInExecuteAsync ) + m_xImpl->m_xEdFileName->grab_focus(); + // (if m_bInExecuteAsync is true, then the operation was finished within the minimum wait time, + // and to the user, the operation appears to be synchronous) +} + +void SvtFileDialog::RemovablePlaceSelected(bool enable) +{ + m_xImpl->m_xPlaces->SetDelEnabled( enable ); +} + +void SvtFileDialog::displayIOException( const OUString& _rURL, IOErrorCode _eCode ) +{ + try + { + // create make a human-readable string from the URL + OUString sDisplayPath; + if (osl::FileBase::getSystemPathFromFileURL(_rURL, sDisplayPath) + == osl::FileBase::E_None) + { + sDisplayPath = _rURL; + } + + // build an own exception which tells "access denied" + InteractiveAugmentedIOException aException; + aException.Arguments.realloc( 2 ); + aException.Arguments[ 0 ] <<= sDisplayPath; + aException.Arguments[ 1 ] <<= PropertyValue( + "Uri", + -1, aException.Arguments[ 0 ], PropertyState_DIRECT_VALUE + ); + // (formerly, it was sufficient to put the URL first parameter. Nowadays, + // the services expects the URL in a PropertyValue named "Uri" ...) + aException.Code = _eCode; + aException.Classification = InteractionClassification_ERROR; + + // let and interaction handler handle this exception + ::comphelper::OInteractionRequest* pRequest = nullptr; + Reference< css::task::XInteractionRequest > xRequest = pRequest = + new ::comphelper::OInteractionRequest( makeAny( aException ) ); + pRequest->addContinuation( new ::comphelper::OInteractionAbort( ) ); + + Reference< XInteractionHandler2 > xHandler( + InteractionHandler::createWithParent( ::comphelper::getProcessComponentContext(), nullptr ) ); + xHandler->handle( xRequest ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "fpicker", "iodlg::displayIOException" ); + } +} + +void SvtFileDialog::EnableUI(bool bEnable) +{ + m_xDialog->set_sensitive(bEnable); + + if (bEnable) + { + for (auto& rxControl : m_aDisabledControls) + { + rxControl->set_sensitive(false); + } + } +} + +void SvtFileDialog::EnableControl(weld::Widget* pControl, bool bEnable) +{ + if (!pControl) + { + SAL_WARN( "fpicker.office", "SvtFileDialog::EnableControl: invalid control!" ); + return; + } + + pControl->set_sensitive(bEnable); + + if (bEnable) + { + auto aPos = m_aDisabledControls.find( pControl ); + if ( m_aDisabledControls.end() != aPos ) + m_aDisabledControls.erase( aPos ); + } + else + m_aDisabledControls.insert( pControl ); +} + +bool SvtFileDialog::PrepareExecute() +{ + if (comphelper::LibreOfficeKit::isActive()) + return false; + + OUString aEnvValue; + if ( getEnvironmentValue( "WorkDirMustContainRemovableMedia", aEnvValue ) && aEnvValue == "1" ) + { + try + { + INetURLObject aStdDir( GetStandardDir() ); + ::ucbhelper::Content aCnt( aStdDir.GetMainURL( + INetURLObject::DecodeMechanism::NONE ), + Reference< XCommandEnvironment >(), + comphelper::getProcessComponentContext() ); + Sequence< OUString > aProps(2); + aProps[0] = "IsVolume"; + aProps[1] = "IsRemoveable"; + + Reference< XResultSet > xResultSet + = aCnt.createCursor( aProps, ::ucbhelper::INCLUDE_FOLDERS_ONLY ); + if ( xResultSet.is() && !xResultSet->next() ) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + FpsResId(STR_SVT_NOREMOVABLEDEVICE))); + xBox->run(); + return false; + } + } + catch ( ContentCreationException const & ) + { + } + catch ( CommandAbortedException const & ) + { + } + } + + if ( ( m_xImpl->m_nStyle & PickerFlags::SaveAs ) && m_bHasFilename ) + // when doing a save-as, we do not want the handler to handle "this file does not exist" messages + // - finally we're going to save that file, aren't we? + m_aContent.enableOwnInteractionHandler(::svt::OFilePickerInteractionHandler::E_DOESNOTEXIST); + else + m_aContent.enableDefaultInteractionHandler(); + + // possibly just a filename without a path + OUString aFileNameOnly; + if( !m_aPath.isEmpty() && (m_xImpl->m_eMode == FILEDLG_MODE_SAVE) + && (m_aPath.indexOf(':') == -1) + && (m_aPath.indexOf('\\') == -1) + && (m_aPath.indexOf('/') == -1)) + { + aFileNameOnly = m_aPath; + m_aPath.clear(); + } + + // no starting path specified? + if ( m_aPath.isEmpty() ) + { + // then use the standard directory + m_aPath = lcl_ensureFinalSlash( m_xImpl->GetStandardDir() ); + + // attach given filename to path + if ( !aFileNameOnly.isEmpty() ) + m_aPath += aFileNameOnly; + } + + + m_aPath = implGetInitialURL( m_aPath, GetStandardDir() ); + + if ( m_xImpl->m_nStyle & PickerFlags::SaveAs && !m_bHasFilename ) + // when doing a save-as, we do not want the handler to handle "this file does not exist" messages + // - finally we're going to save that file, aren't we? + m_aContent.enableOwnInteractionHandler(::svt::OFilePickerInteractionHandler::E_DOESNOTEXIST); + + // if applicable show filter + m_xImpl->InitFilterList(); + + // set up initial filter + sal_uInt16 nFilterCount = GetFilterCount(); + OUString aAll = FpsResId( STR_FILTERNAME_ALL ); + bool bHasAll = m_xImpl->HasFilterListEntry( aAll ); + if ( m_xImpl->GetCurFilter() || nFilterCount == 1 || ( nFilterCount == 2 && bHasAll ) ) + { + // if applicable set the only filter or the only filter that + // does not refer to all files, as the current one + if ( !m_xImpl->GetCurFilter() ) + { + sal_uInt16 nPos = 0; + if ( 2 == nFilterCount && bHasAll ) + { + nPos = nFilterCount; + while ( nPos-- ) + { + if ( aAll != GetFilterName( nPos ) ) + break; + } + } + SvtFileDialogFilter_Impl* pNewCurFilter = m_xImpl->m_aFilter[ nPos ].get(); + assert( pNewCurFilter && "SvtFileDialog::run: invalid filter pos!" ); + m_xImpl->SetCurFilter( pNewCurFilter, pNewCurFilter->GetName() ); + } + + // adjust view + m_xImpl->SelectFilterListEntry( m_xImpl->GetCurFilter()->GetName() ); + SetDefaultExt( m_xImpl->GetCurFilter()->GetExtension() ); + sal_Int32 nSepPos = GetDefaultExt().indexOf( FILEDIALOG_DEF_EXTSEP ); + if ( nSepPos != -1 ) + EraseDefaultExt( nSepPos ); + } + else + { + // if applicable set respectively create filter for all files + if ( !bHasAll ) + { + SvtFileDialogFilter_Impl* pAllFilter = implAddFilter( aAll, FILEDIALOG_FILTER_ALL ); + m_xImpl->InsertFilterListEntry( pAllFilter ); + m_xImpl->SetCurFilter( pAllFilter, aAll ); + } + m_xImpl->SelectFilterListEntry( aAll ); + } + + // if applicable isolate filter + OUString aFilter; + + if ( !IsolateFilterFromPath_Impl( m_aPath, aFilter ) ) + return false; + + AdjustFilterFlags nNewFilterFlags = adjustFilter( aFilter ); + if ( nNewFilterFlags & ( AdjustFilterFlags::NonEmpty | AdjustFilterFlags::UserFilter ) ) + { + m_xImpl->m_xEdFileName->set_entry_text( aFilter ); + } + + // create and show instance for set path + INetURLObject aFolderURL( m_aPath ); + OUString aFileName( aFolderURL.getName( INetURLObject::LAST_SEGMENT, false ) ); + sal_Int32 nFileNameLen = aFileName.getLength(); + bool bFileToSelect = nFileNameLen != 0; + if ( bFileToSelect && aFileName[ nFileNameLen - 1 ] != '/' ) + { + OUString aDecodedName = aFolderURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ); + m_xImpl->m_xEdFileName->set_entry_text( aDecodedName ); + aFolderURL.removeSegment(); + } + + INetURLObject aObj = aFolderURL; + if ( aObj.GetProtocol() == INetProtocol::File ) + { + // set folder as current directory + aObj.setFinalSlash(); + } + + UpdateControls( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + // Somebody might want to enable some controls according to the current filter + FilterSelect(); + + OpenURL_Impl( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + // if applicable read and set size from ini + InitSize(); + + return true; +} + +void SvtFileDialog::executeAsync( ::svt::AsyncPickerAction::Action eAction, + const OUString& rURL, const OUString& rFilter ) +{ + SAL_WARN_IF( m_pCurrentAsyncAction.is(), "fpicker.office", "SvtFileDialog::executeAsync: previous async action not yet finished!" ); + + m_pCurrentAsyncAction = new AsyncPickerAction( this, m_xFileView.get(), eAction ); + + bool bReallyAsync = true; + m_aConfiguration.getNodeValue( OUString( "FillAsynchronously" ) ) >>= bReallyAsync; + + sal_Int32 nMinTimeout = 0; + m_aConfiguration.getNodeValue( OUString( "Timeout/Min" ) ) >>= nMinTimeout; + sal_Int32 nMaxTimeout = 0; + m_aConfiguration.getNodeValue( OUString( "Timeout/Max" ) ) >>= nMaxTimeout; + + m_bInExecuteAsync = true; + m_pCurrentAsyncAction->execute(rURL, rFilter, bReallyAsync ? nMinTimeout : -1, nMaxTimeout, GetBlackList()); + m_bInExecuteAsync = false; +} + + +void SvtFileDialog::FileSelect() +{ + if (m_pFileNotifier) + m_pFileNotifier->notify( FILE_SELECTION_CHANGED, 0 ); +} + + +void SvtFileDialog::FilterSelect() +{ + if (m_pFileNotifier) + m_pFileNotifier->notify( CTRL_STATE_CHANGED, + LISTBOX_FILTER ); +} + + +/* [Description] + + This method sets the path for the default button. +*/ +void SvtFileDialog::SetStandardDir( const OUString& rStdDir ) +{ + INetURLObject aObj( rStdDir ); + SAL_WARN_IF( aObj.GetProtocol() == INetProtocol::NotValid, "fpicker.office", "Invalid protocol!" ); + aObj.setFinalSlash(); + m_xImpl->SetStandardDir( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); +} + +void SvtFileDialog::SetBlackList( const css::uno::Sequence< OUString >& rBlackList ) +{ + m_xImpl->SetBlackList( rBlackList ); +} + + +const css::uno::Sequence< OUString >& SvtFileDialog::GetBlackList() const +{ + return m_xImpl->GetBlackList(); +} + + +/* [Description] + + This method returns the standard path. +*/ +const OUString& SvtFileDialog::GetStandardDir() const +{ + return m_xImpl->GetStandardDir(); +} + + +void SvtFileDialog::PrevLevel_Impl() +{ + m_xFileView->EndInplaceEditing(); + + OUString sDummy; + executeAsync( AsyncPickerAction::ePrevLevel, sDummy, sDummy ); +} + +void SvtFileDialog::OpenURL_Impl( const OUString& _rURL ) +{ + m_xFileView->EndInplaceEditing(); + + executeAsync( AsyncPickerAction::eOpenURL, _rURL, getMostCurrentFilter( m_xImpl ) ); +} + +SvtFileDialogFilter_Impl* SvtFileDialog::implAddFilter( const OUString& rFilter, const OUString& _rType ) +{ + SvtFileDialogFilter_Impl* pNewFilter = new SvtFileDialogFilter_Impl( rFilter, _rType ); + m_xImpl->m_aFilter.push_front( std::unique_ptr<SvtFileDialogFilter_Impl>( pNewFilter ) ); + + if ( !m_xImpl->GetCurFilter() ) + m_xImpl->SetCurFilter( pNewFilter, rFilter ); + + return pNewFilter; +} + +void SvtFileDialog::AddFilter( const OUString& rFilter, const OUString& _rType ) +{ + SAL_WARN_IF( m_bIsInExecute, "fpicker.office", "SvtFileDialog::AddFilter: currently executing!" ); + implAddFilter ( rFilter, _rType ); +} + + +void SvtFileDialog::AddFilterGroup( const OUString& rFilter, const Sequence< StringPair >& rFilters ) +{ + SAL_WARN_IF( m_bIsInExecute, "fpicker.office", "SvtFileDialog::AddFilter: currently executing!" ); + + implAddFilter( rFilter, OUString() ); + const StringPair* pSubFilters = rFilters.getConstArray(); + const StringPair* pSubFiltersEnd = pSubFilters + rFilters.getLength(); + for ( ; pSubFilters != pSubFiltersEnd; ++pSubFilters ) + implAddFilter( pSubFilters->First, pSubFilters->Second ); +} + + +void SvtFileDialog::SetCurFilter( const OUString& rFilter ) +{ + SAL_WARN_IF( m_bIsInExecute, "fpicker.office", "SvtFileDialog::SetCurFilter: currently executing!" ); + + // look for corresponding filter + sal_uInt16 nPos = m_xImpl->m_aFilter.size(); + + while ( nPos-- ) + { + SvtFileDialogFilter_Impl* pFilter = m_xImpl->m_aFilter[ nPos ].get(); + if ( pFilter->GetName() == rFilter ) + { + m_xImpl->SetCurFilter( pFilter, rFilter ); + break; + } + } +} + +OUString SvtFileDialog::GetCurFilter() const +{ + OUString aFilter; + + const SvtFileDialogFilter_Impl* pCurrentFilter = m_xImpl->GetCurFilter(); + if ( pCurrentFilter ) + aFilter = pCurrentFilter->GetName(); + + return aFilter; +} + +OUString SvtFileDialog::getCurFilter( ) const +{ + return GetCurFilter(); +} + +sal_uInt16 SvtFileDialog::GetFilterCount() const +{ + return m_xImpl->m_aFilter.size(); +} + +const OUString& SvtFileDialog::GetFilterName( sal_uInt16 nPos ) const +{ + assert( nPos < GetFilterCount() && "invalid index" ); + return m_xImpl->m_aFilter[ nPos ]->GetName(); +} + +void SvtFileDialog::InitSize() +{ + if (m_xImpl->m_aIniKey.isEmpty()) + return; + + // initialize from config + SvtViewOptions aDlgOpt( EViewType::Dialog, m_xImpl->m_aIniKey ); + + if ( aDlgOpt.Exists() ) + { + m_xDialog->set_window_state(OUStringToOString(aDlgOpt.GetWindowState(), RTL_TEXTENCODING_UTF8)); + + Any aUserData = aDlgOpt.GetUserItem( "UserData"); + OUString sCfgStr; + if ( aUserData >>= sCfgStr ) + m_xFileView->SetConfigString( sCfgStr ); + } +} + +std::vector<OUString> SvtFileDialog::GetPathList() const +{ + std::vector<OUString> aList; + + m_xFileView->selected_foreach([this, &aList](weld::TreeIter& rCurEntry){ + aList.push_back(m_xFileView->GetURL(rCurEntry)); + return false; + }); + + if (aList.empty()) + { + if ( !m_xImpl->m_xEdFileName->get_active_text().isEmpty() && m_bIsInExecute ) + aList.push_back(m_xImpl->m_xEdFileName->GetURL()); + else + aList.push_back(m_aPath); + } + + return aList; +} + +bool SvtFileDialog::IsolateFilterFromPath_Impl( OUString& rPath, OUString& rFilter ) +{ + OUString aReversePath = comphelper::string::reverseString(rPath); + sal_Int32 nQuestionMarkPos = rPath.indexOf( '?' ); + sal_Int32 nWildCardPos = rPath.indexOf( FILEDIALOG_DEF_WILDCARD ); + + if ( nQuestionMarkPos != -1 ) + { + // use question mark as wildcard only for files + INetProtocol eProt = INetURLObject::CompareProtocolScheme( rPath ); + + if ( INetProtocol::NotValid != eProt && INetProtocol::File != eProt ) + nQuestionMarkPos = -1; + + nWildCardPos = std::min( nWildCardPos, nQuestionMarkPos ); + } + + rFilter.clear(); + + if ( nWildCardPos != -1 ) + { + sal_Int32 nPathTokenPos = aReversePath.indexOf( '/' ); + + if ( nPathTokenPos == -1 ) + { + OUString aDelim( +#if defined(_WIN32) + '\\' +#else + '/' +#endif + ); + + nPathTokenPos = aReversePath.indexOf( aDelim ); +#if !defined( UNX ) + if ( nPathTokenPos == -1 ) + { + nPathTokenPos = aReversePath.indexOf( ':' ); + } +#endif + } + + // check syntax + if ( nPathTokenPos != -1 ) + { + if ( nPathTokenPos < (rPath.getLength() - nWildCardPos - 1) ) + { + ErrorHandler::HandleError( ERRCODE_SFX_INVALIDSYNTAX ); + return false; + } + + // cut off filter + rFilter = aReversePath.copy( 0, nPathTokenPos ); + rFilter = comphelper::string::reverseString(rFilter); + + // determine folder + rPath = aReversePath.copy( nPathTokenPos ); + rPath = comphelper::string::reverseString(rPath); + } + else + { + rFilter = rPath; + rPath.clear(); + } + } + + return true; +} + +IMPL_LINK_NOARG(SvtFileDialog, SizeAllocHdl, const Size&, void) +{ + if (m_pFileNotifier) + m_pFileNotifier->notify(DIALOG_SIZE_CHANGED, 0); +} + +weld::Widget* SvtFileDialog::getControl( sal_Int16 nControlId, bool bLabelControl ) const +{ + weld::Widget* pReturn = nullptr; + + switch ( nControlId ) + { + case CONTROL_FILEVIEW: + pReturn = bLabelControl ? nullptr : m_xFileView->identifier(); + break; + + case EDIT_FILEURL: + pReturn = bLabelControl + ? static_cast<weld::Widget*>(m_xImpl->m_xFtFileName.get()) + : static_cast<weld::Widget*>(m_xImpl->m_xEdFileName->getWidget()); + break; + + case EDIT_FILEURL_LABEL: + pReturn = m_xImpl->m_xFtFileName.get(); + break; + + case CHECKBOX_AUTOEXTENSION: + pReturn = m_xImpl->m_xCbAutoExtension.get(); + break; + + case CHECKBOX_PASSWORD: + pReturn = m_xImpl->m_xCbPassword.get(); + break; + + case CHECKBOX_GPGENCRYPTION: + pReturn = m_xImpl->m_xCbGPGEncrypt.get(); + break; + + case CHECKBOX_FILTEROPTIONS: + pReturn = m_xImpl->m_xCbOptions.get(); + break; + + case CHECKBOX_READONLY: + pReturn = m_xCbReadOnly.get(); + break; + + case CHECKBOX_LINK: + pReturn = m_xCbLinkBox.get(); + break; + + case CHECKBOX_PREVIEW: + pReturn = m_xCbPreviewBox.get(); + break; + + case CHECKBOX_SELECTION: + pReturn = m_xCbSelection.get(); + break; + + case LISTBOX_FILTER: + pReturn = bLabelControl ? m_xImpl->m_xFtFileType.get() : m_xImpl->GetFilterListControl(); + break; + + case LISTBOX_FILTER_LABEL: + pReturn = m_xImpl->m_xFtFileType.get(); + break; + + case FIXEDTEXT_CURRENTFOLDER: + pReturn = m_xImpl->m_xEdCurrentPath->getWidget(); + break; + + case LISTBOX_VERSION: + pReturn = bLabelControl + ? static_cast<weld::Widget*>(m_xImpl->m_xSharedLabel.get()) + : static_cast<weld::Widget*>(m_xImpl->m_xSharedListBox.get()); + break; + + case LISTBOX_TEMPLATE: + pReturn = bLabelControl + ? static_cast<weld::Widget*>(m_xImpl->m_xSharedLabel.get()) + : static_cast<weld::Widget*>(m_xImpl->m_xSharedListBox.get()); + break; + + case LISTBOX_IMAGE_TEMPLATE: + pReturn = bLabelControl + ? static_cast<weld::Widget*>(m_xImpl->m_xSharedLabel.get()) + : static_cast<weld::Widget*>(m_xImpl->m_xSharedListBox.get()); + break; + + case LISTBOX_IMAGE_ANCHOR: + pReturn = bLabelControl + ? static_cast<weld::Widget*>(m_xImpl->m_xSharedLabel.get()) + : static_cast<weld::Widget*>(m_xImpl->m_xSharedListBox.get()); + break; + + case LISTBOX_VERSION_LABEL: + pReturn = m_xImpl->m_xSharedLabel.get(); + break; + + case LISTBOX_TEMPLATE_LABEL: + pReturn = m_xImpl->m_xSharedLabel.get(); + break; + + case LISTBOX_IMAGE_TEMPLATE_LABEL: + pReturn = m_xImpl->m_xSharedLabel.get(); + break; + + case LISTBOX_IMAGE_ANCHOR_LABEL: + pReturn = m_xImpl->m_xSharedLabel.get(); + break; + + case PUSHBUTTON_OK: + pReturn = m_xImpl->m_xBtnFileOpen.get(); + break; + + case PUSHBUTTON_CANCEL: + pReturn = m_xImpl->m_xBtnCancel.get(); + break; + + case PUSHBUTTON_PLAY: + pReturn = m_xPbPlay.get(); + break; + + case PUSHBUTTON_HELP: + pReturn = m_xImpl->m_xBtnHelp.get(); + break; + + case TOOLBOXBUTOON_LEVEL_UP: + pReturn = m_xImpl->m_xBtnUp->getWidget(); + break; + + case TOOLBOXBUTOON_NEW_FOLDER: + pReturn = m_xImpl->m_xBtnNewFolder.get(); + break; + + case LISTBOX_FILTER_SELECTOR: + // only exists on SalGtkFilePicker + break; + + default: + SAL_WARN( "fpicker.office", "SvtFileDialog::getControl: invalid id!" ); + } + return pReturn; +} + +void SvtFileDialog::enableControl(sal_Int16 nControlId, bool bEnable) +{ + weld::Widget* pControl = getControl(nControlId); + if (pControl) + EnableControl(pControl, bEnable); + weld::Widget* pLabel = getControl(nControlId, true); + if (pLabel) + EnableControl(pLabel, bEnable); +} + +void SvtFileDialog::AddControls_Impl( ) +{ + // create the "insert as link" checkbox, if needed + if ( m_nPickerFlags & PickerFlags::InsertAsLink ) + { + m_xCbLinkBox->set_label( FpsResId( STR_SVT_FILEPICKER_INSERT_AS_LINK ) ); + m_xCbLinkBox->set_help_id( HID_FILEDLG_LINK_CB ); + m_xCbLinkBox->connect_clicked( LINK( this, SvtFileDialog, ClickHdl_Impl ) ); + m_xCbLinkBox->show(); + } + + // create the "show preview" checkbox ( and the preview window, too ), if needed + if ( m_nPickerFlags & PickerFlags::ShowPreview ) + { + m_xImpl->m_aIniKey = "ImportGraphicDialog"; + + // "preview" + m_xCbPreviewBox->set_label( FpsResId( STR_SVT_FILEPICKER_SHOW_PREVIEW ) ); + m_xCbPreviewBox->set_help_id( HID_FILEDLG_PREVIEW_CB ); + m_xCbPreviewBox->connect_clicked( LINK( this, SvtFileDialog, ClickHdl_Impl ) ); + m_xCbPreviewBox->show(); + + // generate preview window just here + m_aPreviewSize = Size(200, 300); + m_xPrevBmp->set_size_request(m_aPreviewSize.Width(), m_aPreviewSize.Height()); + m_xPrevBmp->connect_size_allocate(LINK(this, SvtFileDialog, PreviewSizeAllocHdl)); + m_xPreviewFrame->show(); + m_xPrevBmp->set_accessible_name(FpsResId(STR_PREVIEW)); + } + + if ( m_nPickerFlags & PickerFlags::AutoExtension ) + { + m_xImpl->m_xCbAutoExtension->set_label( FpsResId( STR_SVT_FILEPICKER_AUTO_EXTENSION ) ); + m_xImpl->m_xCbAutoExtension->set_active(true); + m_xImpl->m_xCbAutoExtension->connect_clicked( LINK( this, SvtFileDialog, AutoExtensionHdl_Impl ) ); + m_xImpl->m_xCbAutoExtension->show(); + } + + if ( m_nPickerFlags & PickerFlags::FilterOptions ) + { + m_xImpl->m_xCbOptions->set_label( FpsResId( STR_SVT_FILEPICKER_FILTER_OPTIONS ) ); + m_xImpl->m_xCbOptions->connect_clicked( LINK( this, SvtFileDialog, ClickHdl_Impl ) ); + m_xImpl->m_xCbOptions->show(); + } + + if ( m_nPickerFlags & PickerFlags::Selection ) + { + m_xCbSelection->set_label( FpsResId( STR_SVT_FILEPICKER_SELECTION ) ); + m_xCbSelection->connect_clicked( LINK( this, SvtFileDialog, ClickHdl_Impl ) ); + m_xCbSelection->show(); + } + + if ( m_nPickerFlags & PickerFlags::PlayButton ) + { + m_xPbPlay->set_label( FpsResId( STR_SVT_FILEPICKER_PLAY ) ); + m_xPbPlay->set_help_id( HID_FILESAVE_DOPLAY ); + m_xPbPlay->connect_clicked( LINK( this, SvtFileDialog, PlayButtonHdl_Impl ) ); + m_xPbPlay->show(); + } + + if ( m_nPickerFlags & PickerFlags::ShowVersions ) + { + m_xImpl->m_xSharedLabel->set_label( FpsResId( STR_SVT_FILEPICKER_VERSION ) ); + m_xImpl->m_xSharedLabel->show(); + + m_xImpl->m_xSharedListBox->set_help_id( HID_FILEOPEN_VERSION ); + m_xImpl->m_xSharedListBox->show(); + } + else if ( m_nPickerFlags & PickerFlags::Templates ) + { + m_xImpl->m_xSharedLabel->set_label( FpsResId( STR_SVT_FILEPICKER_TEMPLATES ) ); + m_xImpl->m_xSharedLabel->show(); + + m_xImpl->m_xSharedListBox->set_help_id( HID_FILEOPEN_VERSION ); + m_xImpl->m_xSharedListBox->show(); + // This is strange. During the re-factoring during 96930, I discovered that this help id + // is set in the "Templates mode". This was hidden in the previous implementation. + // Shouldn't this be a more meaningful help id. + } + else if ( m_nPickerFlags & PickerFlags::ImageTemplate ) + { + m_xImpl->m_xSharedLabel->set_label( FpsResId( STR_SVT_FILEPICKER_IMAGE_TEMPLATE ) ); + m_xImpl->m_xSharedLabel->show(); + + m_xImpl->m_xSharedListBox->set_help_id( HID_FILEOPEN_IMAGE_TEMPLATE ); + m_xImpl->m_xSharedListBox->show(); + } + else if ( m_nPickerFlags & PickerFlags::ImageAnchor ) + { + m_xImpl->m_xSharedLabel->set_label( FpsResId( STR_SVT_FILEPICKER_IMAGE_ANCHOR ) ); + m_xImpl->m_xSharedLabel->show(); + + m_xImpl->m_xSharedListBox->set_help_id( HID_FILEOPEN_IMAGE_ANCHOR ); + m_xImpl->m_xSharedListBox->show(); + } + + m_xImpl->m_xPlaces.reset(new PlacesListBox(m_xBuilder->weld_tree_view("places"), + m_xBuilder->weld_button("add"), + m_xBuilder->weld_button("del"), + this)); + m_xImpl->m_xPlaces->set_help_id("SVT_HID_FILESAVE_PLACES_LISTBOX"); + m_xImpl->m_xPlaces->SetAddHdl( LINK ( this, SvtFileDialog, AddPlacePressed_Hdl ) ); + m_xImpl->m_xPlaces->SetDelHdl( LINK ( this, SvtFileDialog, RemovePlacePressed_Hdl ) ); + + initDefaultPlaces(); +} + +IMPL_LINK(SvtFileDialog, PreviewSizeAllocHdl, const Size&, rSize, void) +{ + m_aPreviewSize = rSize; +} + +sal_Int32 SvtFileDialog::getAvailableWidth() +{ + if (m_xPrevBmp) + return m_aPreviewSize.Width(); + else + return 0; +} + +sal_Int32 SvtFileDialog::getAvailableHeight() +{ + if (m_xPrevBmp) + return m_aPreviewSize.Height(); + else + return 0; +} + +void SvtFileDialog::setImage(const Any& rImage) +{ + if (!m_xPrevBmp || !m_xPreviewFrame->get_visible()) + return; + + Sequence < sal_Int8 > aBmpSequence; + + if ( rImage >>= aBmpSequence ) + { + BitmapEx aBmp; + SvMemoryStream aData( aBmpSequence.getArray(), + aBmpSequence.getLength(), + StreamMode::READ ); + ReadDIBBitmapEx(aBmp, aData); + + m_xPrevBmp->set_image(Graphic(aBmp).GetXGraphic()); + } + else + { + m_xPrevBmp->set_image(nullptr); + } +} + +OUString SvtFileDialog::getCurrentFileText( ) const +{ + OUString sReturn; + if (m_xImpl && m_xImpl->m_xEdFileName) + sReturn = m_xImpl->m_xEdFileName->get_active_text(); + return sReturn; +} + +void SvtFileDialog::setCurrentFileText( const OUString& _rText, bool m_bSelectAll ) +{ + if (m_xImpl && m_xImpl->m_xEdFileName) + { + m_xImpl->m_xEdFileName->set_entry_text( _rText ); + if ( m_bSelectAll ) + m_xImpl->m_xEdFileName->select_entry_region(0, -1); + } +} + +bool SvtFileDialog::isAutoExtensionEnabled() const +{ + return m_xImpl->m_xCbAutoExtension && m_xImpl->m_xCbAutoExtension->get_active(); +} + +bool SvtFileDialog::getShowState() +{ + if (m_xPreviewFrame) + return m_xPreviewFrame->get_visible(); + else + return false; +} + +bool SvtFileDialog::ContentHasParentFolder( const OUString& rURL ) +{ + m_aContent.bindTo( rURL ); + + if ( m_aContent.isInvalid() ) + return false; + + return m_aContent.hasParentFolder( ) && m_aContent.isValid(); +} + +bool SvtFileDialog::ContentCanMakeFolder( const OUString& rURL ) +{ + m_aContent.bindTo( rURL ); + + if ( m_aContent.isInvalid() ) + return false; + + return m_aContent.canCreateFolder( ) && m_aContent.isValid(); +} + +bool SvtFileDialog::ContentGetTitle( const OUString& rURL, OUString& rTitle ) +{ + m_aContent.bindTo( rURL ); + + if ( m_aContent.isInvalid() ) + return false; + + OUString sTitle; + m_aContent.getTitle( sTitle ); + rTitle = sTitle; + + return m_aContent.isValid(); +} + +void SvtFileDialog::appendDefaultExtension(OUString& rFileName, + const OUString& rFilterDefaultExtension, + const OUString& rFilterExtensions) +{ + const OUString aType(rFilterExtensions.toAsciiLowerCase()); + + if ( aType == FILEDIALOG_FILTER_ALL ) + return; + + const OUString aTemp(rFileName.toAsciiLowerCase()); + sal_Int32 nPos = 0; + + do + { + if (nPos+1<aType.getLength() && aType[nPos]=='*') // take care of a leading * + ++nPos; + const OUString aExt(aType.getToken( 0, FILEDIALOG_DEF_EXTSEP, nPos )); + if (aExt.isEmpty()) + continue; + if (aTemp.endsWith(aExt)) + return; + } + while (nPos>=0); + + rFileName += "." + rFilterDefaultExtension; +} + +void SvtFileDialog::initDefaultPlaces( ) +{ + PlacePtr pRootPlace = std::make_shared<Place>( FpsResId(STR_DEFAULT_DIRECTORY), GetStandardDir() ); + m_xImpl->m_xPlaces->AppendPlace( pRootPlace ); + + // Load from user settings + Sequence< OUString > placesUrlsList(officecfg::Office::Common::Misc::FilePickerPlacesUrls::get(m_xContext)); + Sequence< OUString > placesNamesList(officecfg::Office::Common::Misc::FilePickerPlacesNames::get(m_xContext)); + + for(sal_Int32 nPlace = 0; nPlace < placesUrlsList.getLength() && nPlace < placesNamesList.getLength(); ++nPlace) + { + PlacePtr pPlace = std::make_shared<Place>(placesNamesList[nPlace], placesUrlsList[nPlace], true); + m_xImpl->m_xPlaces->AppendPlace(pPlace); + } + + // Reset the placesList "updated" state + m_xImpl->m_xPlaces->IsUpdated(); +} + +QueryFolderNameDialog::QueryFolderNameDialog(weld::Window* _pParent, + const OUString& rTitle, const OUString& rDefaultText) + : GenericDialogController(_pParent, "fps/ui/foldernamedialog.ui", "FolderNameDialog") + , m_xNameEdit(m_xBuilder->weld_entry("entry")) + , m_xOKBtn(m_xBuilder->weld_button("ok")) +{ + m_xDialog->set_title(rTitle); + m_xNameEdit->set_text(rDefaultText); + m_xNameEdit->select_region(0, -1); + m_xOKBtn->connect_clicked(LINK(this, QueryFolderNameDialog, OKHdl)); + m_xNameEdit->connect_changed(LINK(this, QueryFolderNameDialog, NameHdl)); +}; + +QueryFolderNameDialog::~QueryFolderNameDialog() +{ +} + +IMPL_LINK_NOARG(QueryFolderNameDialog, OKHdl, weld::Button&, void) +{ + // trim the strings + m_xNameEdit->set_text(comphelper::string::strip(m_xNameEdit->get_text(), ' ')); + m_xDialog->response(RET_OK); +} + +IMPL_LINK_NOARG(QueryFolderNameDialog, NameHdl, weld::Entry&, void) +{ + // trim the strings + OUString aName = comphelper::string::strip(m_xNameEdit->get_text(), ' '); + m_xOKBtn->set_sensitive(!aName.isEmpty()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |