1178 lines
37 KiB
C++
1178 lines
37 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2000, 2010 Oracle and/or its affiliates.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
|
|
#include "OfficeFilePicker.hxx"
|
|
#include "iodlg.hxx"
|
|
|
|
#ifndef _LIST_
|
|
#include <list>
|
|
#endif
|
|
#ifndef _FUNCTIONAL_
|
|
#include <functional>
|
|
#endif
|
|
#ifndef _ALGORITHM_
|
|
#include <algorithm>
|
|
#endif
|
|
#include <tools/urlobj.hxx>
|
|
#include "svl/svstdarr.hxx"
|
|
#include <com/sun/star/uno/Any.hxx>
|
|
#include <com/sun/star/ui/dialogs/FilePickerEvent.hpp>
|
|
#include <com/sun/star/ui/dialogs/FilePreviewImageFormats.hpp>
|
|
#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
|
|
#include <com/sun/star/beans/PropertyValue.hpp>
|
|
#include <com/sun/star/beans/XPropertySet.hpp>
|
|
#include <com/sun/star/awt/XWindow.hpp>
|
|
#include <com/sun/star/beans/StringPair.hpp>
|
|
#include <com/sun/star/uno/Sequence.hxx>
|
|
#include <com/sun/star/beans/NamedValue.hpp>
|
|
#include <unotools/ucbhelper.hxx>
|
|
#include <unotools/pathoptions.hxx>
|
|
#include <comphelper/sequence.hxx>
|
|
#include <cppuhelper/typeprovider.hxx>
|
|
#include "osl/mutex.hxx"
|
|
#include "vcl/svapp.hxx"
|
|
|
|
// using ----------------------------------------------------------------
|
|
|
|
using namespace ::com::sun::star::container;
|
|
using namespace ::com::sun::star::lang;
|
|
using namespace ::com::sun::star::ui::dialogs;
|
|
using namespace ::com::sun::star::uno;
|
|
using namespace ::com::sun::star::beans;
|
|
using namespace ::com::sun::star::awt;
|
|
using namespace ::utl;
|
|
|
|
//=====================================================================
|
|
|
|
//=====================================================================
|
|
|
|
struct FilterEntry
|
|
{
|
|
protected:
|
|
::rtl::OUString m_sTitle;
|
|
::rtl::OUString m_sFilter;
|
|
|
|
UnoFilterList m_aSubFilters;
|
|
|
|
public:
|
|
FilterEntry( const ::rtl::OUString& _rTitle, const ::rtl::OUString& _rFilter )
|
|
:m_sTitle( _rTitle )
|
|
,m_sFilter( _rFilter )
|
|
{
|
|
}
|
|
|
|
FilterEntry( const ::rtl::OUString& _rTitle, const UnoFilterList& _rSubFilters );
|
|
|
|
::rtl::OUString getTitle() const { return m_sTitle; }
|
|
::rtl::OUString getFilter() const { return m_sFilter; }
|
|
|
|
/// determines if the filter has sub filter (i.e., the filter is a filter group in real)
|
|
sal_Bool hasSubFilters( ) const;
|
|
|
|
/** retrieves the filters belonging to the entry
|
|
@return
|
|
the number of sub filters
|
|
*/
|
|
sal_Int32 getSubFilters( UnoFilterList& _rSubFilterList );
|
|
|
|
// helpers for iterating the sub filters
|
|
const UnoFilterEntry* beginSubFilters() const { return m_aSubFilters.getConstArray(); }
|
|
const UnoFilterEntry* endSubFilters() const { return m_aSubFilters.getConstArray() + m_aSubFilters.getLength(); }
|
|
};
|
|
|
|
//=====================================================================
|
|
|
|
//---------------------------------------------------------------------
|
|
FilterEntry::FilterEntry( const ::rtl::OUString& _rTitle, const UnoFilterList& _rSubFilters )
|
|
:m_sTitle( _rTitle )
|
|
,m_aSubFilters( _rSubFilters )
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
sal_Bool FilterEntry::hasSubFilters( ) const
|
|
{
|
|
return ( 0 < m_aSubFilters.getLength() );
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
sal_Int32 FilterEntry::getSubFilters( UnoFilterList& _rSubFilterList )
|
|
{
|
|
_rSubFilterList = m_aSubFilters;
|
|
return m_aSubFilters.getLength();
|
|
}
|
|
|
|
// struct ElementEntry_Impl ----------------------------------------------
|
|
|
|
struct ElementEntry_Impl
|
|
{
|
|
sal_Int16 m_nElementID;
|
|
sal_Int16 m_nControlAction;
|
|
Any m_aValue;
|
|
rtl::OUString m_aLabel;
|
|
sal_Bool m_bEnabled : 1;
|
|
|
|
sal_Bool m_bHasValue : 1;
|
|
sal_Bool m_bHasLabel : 1;
|
|
sal_Bool m_bHasEnabled : 1;
|
|
|
|
ElementEntry_Impl( sal_Int16 nId );
|
|
|
|
void setValue( const Any& rVal ) { m_aValue = rVal; m_bHasValue = sal_True; }
|
|
void setAction( sal_Int16 nAction ) { m_nControlAction = nAction; }
|
|
void setLabel( const rtl::OUString& rVal ) { m_aLabel = rVal; m_bHasLabel = sal_True; }
|
|
void setEnabled( sal_Bool bEnabled ) { m_bEnabled = bEnabled; m_bHasEnabled = sal_True; }
|
|
};
|
|
|
|
ElementEntry_Impl::ElementEntry_Impl( sal_Int16 nId )
|
|
: m_nElementID( nId )
|
|
, m_nControlAction( 0 )
|
|
, m_bEnabled( sal_False )
|
|
, m_bHasValue( sal_False )
|
|
, m_bHasLabel( sal_False )
|
|
, m_bHasEnabled( sal_False )
|
|
{}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SvtFilePicker::prepareExecute()
|
|
{
|
|
// set the default directory
|
|
// --**-- doesn't match the spec yet
|
|
if ( !m_aDisplayDirectory.isEmpty() || !m_aDefaultName.isEmpty() )
|
|
{
|
|
if ( !m_aDisplayDirectory.isEmpty() )
|
|
{
|
|
|
|
INetURLObject aPath( m_aDisplayDirectory );
|
|
if ( !m_aDefaultName.isEmpty() )
|
|
{
|
|
aPath.insertName( m_aDefaultName );
|
|
getDialog()->SetHasFilename( true );
|
|
}
|
|
String sPath = aPath.GetMainURL( INetURLObject::NO_DECODE );
|
|
getDialog()->SetPath( aPath.GetMainURL( INetURLObject::NO_DECODE ) );
|
|
}
|
|
else if ( !m_aDefaultName.isEmpty() )
|
|
{
|
|
getDialog()->SetPath( m_aDefaultName );
|
|
getDialog()->SetHasFilename( true );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Default-Standard-Dir setzen
|
|
INetURLObject aStdDirObj( SvtPathOptions().GetWorkPath() );
|
|
getDialog()->SetPath( aStdDirObj.GetMainURL( INetURLObject::NO_DECODE ) );
|
|
}
|
|
|
|
// set the control values and set the control labels, too
|
|
if ( m_pElemList && !m_pElemList->empty() )
|
|
{
|
|
::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
|
|
|
|
ElementList::iterator aListIter;
|
|
for ( aListIter = m_pElemList->begin();
|
|
aListIter != m_pElemList->end(); ++aListIter )
|
|
{
|
|
ElementEntry_Impl& rEntry = *aListIter;
|
|
if ( rEntry.m_bHasValue )
|
|
aAccess.setValue( rEntry.m_nElementID, rEntry.m_nControlAction, rEntry.m_aValue );
|
|
if ( rEntry.m_bHasLabel )
|
|
aAccess.setLabel( rEntry.m_nElementID, rEntry.m_aLabel );
|
|
if ( rEntry.m_bHasEnabled )
|
|
aAccess.enableControl( rEntry.m_nElementID, rEntry.m_bEnabled );
|
|
}
|
|
|
|
getDialog()->updateListboxLabelSizes();
|
|
}
|
|
|
|
if ( m_pFilterList && !m_pFilterList->empty() )
|
|
{
|
|
for ( FilterList::iterator aListIter = m_pFilterList->begin();
|
|
aListIter != m_pFilterList->end();
|
|
++aListIter
|
|
)
|
|
{
|
|
if ( aListIter->hasSubFilters() )
|
|
{ // it's a filter group
|
|
UnoFilterList aSubFilters;
|
|
aListIter->getSubFilters( aSubFilters );
|
|
|
|
getDialog()->AddFilterGroup( aListIter->getTitle(), aSubFilters );
|
|
}
|
|
else
|
|
// it's a single filter
|
|
getDialog()->AddFilter( aListIter->getTitle(), aListIter->getFilter() );
|
|
}
|
|
}
|
|
|
|
// set the default filter
|
|
if ( !m_aCurrentFilter.isEmpty() )
|
|
getDialog()->SetCurFilter( m_aCurrentFilter );
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
IMPL_LINK( SvtFilePicker, DialogClosedHdl, Dialog*, pDlg )
|
|
{
|
|
if ( m_xDlgClosedListener.is() )
|
|
{
|
|
sal_Int16 nRet = static_cast< sal_Int16 >( pDlg->GetResult() );
|
|
::com::sun::star::ui::dialogs::DialogClosedEvent aEvent( *this, nRet );
|
|
m_xDlgClosedListener->dialogClosed( aEvent );
|
|
m_xDlgClosedListener.clear();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// SvtFilePicker
|
|
//------------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------------
|
|
WinBits SvtFilePicker::getWinBits( WinBits& rExtraBits )
|
|
{
|
|
// set the winbits for creating the filedialog
|
|
WinBits nBits = 0L;
|
|
rExtraBits = 0L;
|
|
|
|
// set the standard bits acording to the service name
|
|
if ( m_nServiceType == TemplateDescription::FILEOPEN_SIMPLE )
|
|
{
|
|
nBits = WB_OPEN;
|
|
}
|
|
else if ( m_nServiceType == TemplateDescription::FILESAVE_SIMPLE )
|
|
{
|
|
nBits = WB_SAVEAS;
|
|
}
|
|
else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION )
|
|
{
|
|
nBits = WB_SAVEAS;
|
|
rExtraBits = SFX_EXTRA_AUTOEXTENSION;
|
|
}
|
|
else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD )
|
|
{
|
|
nBits = WB_SAVEAS | SFXWB_PASSWORD;
|
|
rExtraBits = SFX_EXTRA_AUTOEXTENSION;
|
|
}
|
|
else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS )
|
|
{
|
|
nBits = WB_SAVEAS | SFXWB_PASSWORD;
|
|
rExtraBits = SFX_EXTRA_AUTOEXTENSION | SFX_EXTRA_FILTEROPTIONS;
|
|
}
|
|
else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_TEMPLATE )
|
|
{
|
|
nBits = WB_SAVEAS;
|
|
rExtraBits = SFX_EXTRA_AUTOEXTENSION | SFX_EXTRA_TEMPLATES;
|
|
}
|
|
else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_SELECTION )
|
|
{
|
|
nBits = WB_SAVEAS;
|
|
rExtraBits = SFX_EXTRA_AUTOEXTENSION | SFX_EXTRA_SELECTION;
|
|
}
|
|
|
|
else if ( m_nServiceType == TemplateDescription::FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE )
|
|
{
|
|
nBits = WB_OPEN;
|
|
rExtraBits = SFX_EXTRA_INSERTASLINK | SFX_EXTRA_SHOWPREVIEW | SFX_EXTRA_IMAGE_TEMPLATE;
|
|
}
|
|
else if ( m_nServiceType == TemplateDescription::FILEOPEN_PLAY )
|
|
{
|
|
nBits = WB_OPEN;
|
|
rExtraBits = SFX_EXTRA_PLAYBUTTON;
|
|
}
|
|
else if ( m_nServiceType == TemplateDescription::FILEOPEN_READONLY_VERSION )
|
|
{
|
|
nBits = WB_OPEN | SFXWB_READONLY;
|
|
rExtraBits = SFX_EXTRA_SHOWVERSIONS;
|
|
}
|
|
else if ( m_nServiceType == TemplateDescription::FILEOPEN_LINK_PREVIEW )
|
|
{
|
|
nBits = WB_OPEN;
|
|
rExtraBits = SFX_EXTRA_INSERTASLINK | SFX_EXTRA_SHOWPREVIEW;
|
|
}
|
|
if ( m_bMultiSelection && ( ( nBits & WB_OPEN ) == WB_OPEN ) )
|
|
nBits |= SFXWB_MULTISELECTION;
|
|
|
|
return nBits;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SvtFilePicker::notify( sal_Int16 _nEventId, sal_Int16 _nControlId )
|
|
{
|
|
if ( !m_xListener.is() )
|
|
return;
|
|
|
|
FilePickerEvent aEvent( *this, _nControlId );
|
|
|
|
switch ( _nEventId )
|
|
{
|
|
case FILE_SELECTION_CHANGED:
|
|
m_xListener->fileSelectionChanged( aEvent );
|
|
break;
|
|
case DIRECTORY_CHANGED:
|
|
m_xListener->directoryChanged( aEvent );
|
|
break;
|
|
case HELP_REQUESTED:
|
|
m_xListener->helpRequested( aEvent );
|
|
break;
|
|
case CTRL_STATE_CHANGED:
|
|
m_xListener->controlStateChanged( aEvent );
|
|
break;
|
|
case DIALOG_SIZE_CHANGED:
|
|
m_xListener->dialogSizeChanged();
|
|
break;
|
|
default:
|
|
SAL_WARN( "fpicker.office", "SvtFilePicker::notify(): Unknown event id!" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
namespace {
|
|
//................................................................................
|
|
struct FilterTitleMatch : public ::std::unary_function< FilterEntry, bool >
|
|
{
|
|
protected:
|
|
const ::rtl::OUString& rTitle;
|
|
|
|
public:
|
|
FilterTitleMatch( const ::rtl::OUString& _rTitle ) : rTitle( _rTitle ) { }
|
|
|
|
//............................................................................
|
|
bool operator () ( const FilterEntry& _rEntry )
|
|
{
|
|
sal_Bool bMatch;
|
|
if ( !_rEntry.hasSubFilters() )
|
|
// a real filter
|
|
bMatch = ( _rEntry.getTitle() == rTitle );
|
|
else
|
|
// a filter group -> search the sub filters
|
|
bMatch =
|
|
_rEntry.endSubFilters() != ::std::find_if(
|
|
_rEntry.beginSubFilters(),
|
|
_rEntry.endSubFilters(),
|
|
*this
|
|
);
|
|
|
|
return bMatch ? true : false;
|
|
}
|
|
bool operator () ( const UnoFilterEntry& _rEntry )
|
|
{
|
|
return _rEntry.First == rTitle ? true : false;
|
|
}
|
|
};
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
sal_Bool SvtFilePicker::FilterNameExists( const ::rtl::OUString& rTitle )
|
|
{
|
|
sal_Bool bRet = sal_False;
|
|
|
|
if ( m_pFilterList )
|
|
bRet =
|
|
m_pFilterList->end() != ::std::find_if(
|
|
m_pFilterList->begin(),
|
|
m_pFilterList->end(),
|
|
FilterTitleMatch( rTitle )
|
|
);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
sal_Bool SvtFilePicker::FilterNameExists( const UnoFilterList& _rGroupedFilters )
|
|
{
|
|
sal_Bool bRet = sal_False;
|
|
|
|
if ( m_pFilterList )
|
|
{
|
|
const UnoFilterEntry* pStart = _rGroupedFilters.getConstArray();
|
|
const UnoFilterEntry* pEnd = pStart + _rGroupedFilters.getLength();
|
|
for ( ; pStart != pEnd; ++pStart )
|
|
if ( m_pFilterList->end() != ::std::find_if( m_pFilterList->begin(), m_pFilterList->end(), FilterTitleMatch( pStart->First ) ) )
|
|
break;
|
|
|
|
bRet = pStart != pEnd;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SvtFilePicker::ensureFilterList( const ::rtl::OUString& _rInitialCurrentFilter )
|
|
{
|
|
if ( !m_pFilterList )
|
|
{
|
|
m_pFilterList = new FilterList;
|
|
|
|
// set the first filter to the current filter
|
|
if ( m_aCurrentFilter.isEmpty() )
|
|
m_aCurrentFilter = _rInitialCurrentFilter;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// class SvtFilePicker
|
|
//------------------------------------------------------------------------------------
|
|
SvtFilePicker::SvtFilePicker( const Reference < XMultiServiceFactory >& xFactory )
|
|
:OCommonPicker( xFactory )
|
|
,m_pFilterList ( NULL )
|
|
,m_pElemList ( NULL )
|
|
,m_bMultiSelection ( sal_False )
|
|
,m_nServiceType ( TemplateDescription::FILEOPEN_SIMPLE )
|
|
{
|
|
}
|
|
|
|
SvtFilePicker::~SvtFilePicker()
|
|
{
|
|
if ( m_pFilterList && !m_pFilterList->empty() )
|
|
m_pFilterList->erase( m_pFilterList->begin(), m_pFilterList->end() );
|
|
delete m_pFilterList;
|
|
|
|
if ( m_pElemList && !m_pElemList->empty() )
|
|
m_pElemList->erase( m_pElemList->begin(), m_pElemList->end() );
|
|
delete m_pElemList;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
sal_Int16 SvtFilePicker::implExecutePicker( )
|
|
{
|
|
getDialog()->SetFileCallback( this );
|
|
|
|
prepareExecute();
|
|
|
|
getDialog()->EnableAutocompletion( sal_True );
|
|
// now we are ready to execute the dialog
|
|
sal_Int16 nRet = getDialog()->Execute();
|
|
|
|
// the execution of the dialog yields, so it is possible the at this point the window or the dialog is closed
|
|
if ( getDialog() )
|
|
getDialog()->SetFileCallback( NULL );
|
|
|
|
return nRet;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
SvtFileDialog* SvtFilePicker::implCreateDialog( Window* _pParent )
|
|
{
|
|
WinBits nExtraBits;
|
|
WinBits nBits = getWinBits( nExtraBits );
|
|
|
|
SvtFileDialog* dialog = new SvtFileDialog( _pParent, nBits, nExtraBits );
|
|
|
|
// Set StandardDir if present
|
|
if ( !m_aStandardDir.isEmpty())
|
|
{
|
|
String sStandardDir = String( m_aStandardDir );
|
|
dialog->SetStandardDir( sStandardDir );
|
|
dialog->SetBlackList( m_aBlackList );
|
|
}
|
|
|
|
return dialog;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// disambiguate XInterface
|
|
//------------------------------------------------------------------------------------
|
|
IMPLEMENT_FORWARD_XINTERFACE2( SvtFilePicker, OCommonPicker, SvtFilePicker_Base )
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// disambiguate XTypeProvider
|
|
//------------------------------------------------------------------------------------
|
|
IMPLEMENT_FORWARD_XTYPEPROVIDER2( SvtFilePicker, OCommonPicker, SvtFilePicker_Base )
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XExecutableDialog functions
|
|
//------------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SAL_CALL SvtFilePicker::setTitle( const ::rtl::OUString& _rTitle ) throw (RuntimeException)
|
|
{
|
|
OCommonPicker::setTitle( _rTitle );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
sal_Int16 SAL_CALL SvtFilePicker::execute( ) throw (RuntimeException)
|
|
{
|
|
return OCommonPicker::execute();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XAsynchronousExecutableDialog functions
|
|
//------------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SAL_CALL SvtFilePicker::setDialogTitle( const ::rtl::OUString& _rTitle ) throw (RuntimeException)
|
|
{
|
|
setTitle( _rTitle );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SAL_CALL SvtFilePicker::startExecuteModal( const Reference< ::com::sun::star::ui::dialogs::XDialogClosedListener >& xListener ) throw (RuntimeException)
|
|
{
|
|
m_xDlgClosedListener = xListener;
|
|
prepareDialog();
|
|
prepareExecute();
|
|
getDialog()->EnableAutocompletion( sal_True );
|
|
getDialog()->StartExecuteModal( LINK( this, SvtFilePicker, DialogClosedHdl ) );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XFilePicker functions
|
|
//------------------------------------------------------------------------------------
|
|
|
|
void SAL_CALL SvtFilePicker::setMultiSelectionMode( sal_Bool bMode ) throw( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
m_bMultiSelection = bMode;
|
|
}
|
|
|
|
void SAL_CALL SvtFilePicker::setDefaultName( const rtl::OUString& aName ) throw( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
m_aDefaultName = aName;
|
|
}
|
|
|
|
void SAL_CALL SvtFilePicker::setDisplayDirectory( const rtl::OUString& aDirectory )
|
|
throw( IllegalArgumentException, RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
m_aDisplayDirectory = aDirectory;
|
|
}
|
|
|
|
rtl::OUString SAL_CALL SvtFilePicker::getDisplayDirectory() throw( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
if ( getDialog() )
|
|
{
|
|
rtl::OUString aPath = getDialog()->GetPath();
|
|
|
|
// #97148# ----
|
|
if( m_aOldHideDirectory == aPath )
|
|
return m_aOldDisplayDirectory;
|
|
m_aOldHideDirectory = aPath;
|
|
|
|
// #102204# -----
|
|
if( !getDialog()->ContentIsFolder( aPath ) )
|
|
{
|
|
INetURLObject aFolder( aPath );
|
|
aFolder.CutLastName();
|
|
aPath = aFolder.GetMainURL( INetURLObject::NO_DECODE );
|
|
}
|
|
m_aOldDisplayDirectory = aPath;
|
|
return aPath;
|
|
}
|
|
else
|
|
return m_aDisplayDirectory;
|
|
}
|
|
|
|
Sequence< rtl::OUString > SAL_CALL SvtFilePicker::getFiles() throw( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
if ( ! getDialog() )
|
|
{
|
|
Sequence< rtl::OUString > aEmpty;
|
|
return aEmpty;
|
|
}
|
|
|
|
// if there is more than one path we have to return the path to the
|
|
// files first and then the list of the selected entries
|
|
|
|
std::vector<rtl::OUString> aPathList(getDialog()->GetPathList());
|
|
size_t nCount = aPathList.size();
|
|
size_t nTotal = nCount > 1 ? nCount+1: nCount;
|
|
|
|
Sequence< rtl::OUString > aPath( nTotal );
|
|
|
|
if ( nCount == 1 )
|
|
aPath[0] = rtl::OUString(aPathList[0]);
|
|
else if ( nCount > 1 )
|
|
{
|
|
INetURLObject aObj(aPathList[0]);
|
|
aObj.removeSegment();
|
|
aPath[0] = aObj.GetMainURL( INetURLObject::NO_DECODE );
|
|
|
|
for(size_t i = 0; i < aPathList.size(); ++i)
|
|
{
|
|
aObj.SetURL(aPathList[i]);
|
|
aPath[i] = aObj.getName();
|
|
}
|
|
}
|
|
|
|
return aPath;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XFilePickerControlAccess functions
|
|
//------------------------------------------------------------------------------------
|
|
|
|
void SAL_CALL SvtFilePicker::setValue( sal_Int16 nElementID,
|
|
sal_Int16 nControlAction,
|
|
const Any& rValue )
|
|
throw( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
if ( getDialog() )
|
|
{
|
|
::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
|
|
aAccess.setValue( nElementID, nControlAction, rValue );
|
|
}
|
|
else
|
|
{
|
|
if ( !m_pElemList )
|
|
m_pElemList = new ElementList;
|
|
|
|
sal_Bool bFound = sal_False;
|
|
ElementList::iterator aListIter;
|
|
|
|
for ( aListIter = m_pElemList->begin();
|
|
aListIter != m_pElemList->end(); ++aListIter )
|
|
{
|
|
ElementEntry_Impl& rEntry = *aListIter;
|
|
if ( ( rEntry.m_nElementID == nElementID ) &&
|
|
( !rEntry.m_bHasValue || ( rEntry.m_nControlAction == nControlAction ) ) )
|
|
{
|
|
rEntry.setAction( nControlAction );
|
|
rEntry.setValue( rValue );
|
|
bFound = sal_True;
|
|
}
|
|
}
|
|
|
|
if ( !bFound )
|
|
{
|
|
ElementEntry_Impl aNew( nElementID );
|
|
aNew.setAction( nControlAction );
|
|
aNew.setValue( rValue );
|
|
m_pElemList->insert( m_pElemList->end(), aNew );
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
Any SAL_CALL SvtFilePicker::getValue( sal_Int16 nElementID, sal_Int16 nControlAction )
|
|
throw( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
Any aAny;
|
|
|
|
// execute() called?
|
|
if ( getDialog() )
|
|
{
|
|
::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
|
|
aAny = aAccess.getValue( nElementID, nControlAction );
|
|
}
|
|
else if ( m_pElemList && !m_pElemList->empty() )
|
|
{
|
|
ElementList::iterator aListIter;
|
|
for ( aListIter = m_pElemList->begin();
|
|
aListIter != m_pElemList->end(); ++aListIter )
|
|
{
|
|
ElementEntry_Impl& rEntry = *aListIter;
|
|
if ( ( rEntry.m_nElementID == nElementID ) &&
|
|
( rEntry.m_bHasValue ) &&
|
|
( rEntry.m_nControlAction == nControlAction ) )
|
|
{
|
|
aAny = rEntry.m_aValue;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return aAny;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SAL_CALL SvtFilePicker::setLabel( sal_Int16 nLabelID, const rtl::OUString& rValue )
|
|
throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
if ( getDialog() )
|
|
{
|
|
::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
|
|
aAccess.setLabel( nLabelID, rValue );
|
|
}
|
|
else
|
|
{
|
|
if ( !m_pElemList )
|
|
m_pElemList = new ElementList;
|
|
|
|
sal_Bool bFound = sal_False;
|
|
ElementList::iterator aListIter;
|
|
|
|
for ( aListIter = m_pElemList->begin();
|
|
aListIter != m_pElemList->end(); ++aListIter )
|
|
{
|
|
ElementEntry_Impl& rEntry = *aListIter;
|
|
if ( rEntry.m_nElementID == nLabelID )
|
|
{
|
|
rEntry.setLabel( rValue );
|
|
bFound = sal_True;
|
|
}
|
|
}
|
|
|
|
if ( !bFound )
|
|
{
|
|
ElementEntry_Impl aNew( nLabelID );
|
|
aNew.setLabel( rValue );
|
|
m_pElemList->insert( m_pElemList->end(), aNew );
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
rtl::OUString SAL_CALL SvtFilePicker::getLabel( sal_Int16 nLabelID )
|
|
throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
rtl::OUString aLabel;
|
|
|
|
if ( getDialog() )
|
|
{
|
|
::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
|
|
aLabel = aAccess.getLabel( nLabelID );
|
|
}
|
|
else if ( m_pElemList && !m_pElemList->empty() )
|
|
{
|
|
ElementList::iterator aListIter;
|
|
for ( aListIter = m_pElemList->begin();
|
|
aListIter != m_pElemList->end(); ++aListIter )
|
|
{
|
|
ElementEntry_Impl& rEntry = *aListIter;
|
|
if ( rEntry.m_nElementID == nLabelID )
|
|
{
|
|
if ( rEntry.m_bHasLabel )
|
|
aLabel = rEntry.m_aLabel;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return aLabel;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SAL_CALL SvtFilePicker::enableControl( sal_Int16 nElementID, sal_Bool bEnable )
|
|
throw( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
if ( getDialog() )
|
|
{
|
|
::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
|
|
aAccess.enableControl( nElementID, bEnable );
|
|
}
|
|
else
|
|
{
|
|
if ( !m_pElemList )
|
|
m_pElemList = new ElementList;
|
|
|
|
sal_Bool bFound = sal_False;
|
|
ElementList::iterator aListIter;
|
|
|
|
for ( aListIter = m_pElemList->begin();
|
|
aListIter != m_pElemList->end(); ++aListIter )
|
|
{
|
|
ElementEntry_Impl& rEntry = *aListIter;
|
|
if ( rEntry.m_nElementID == nElementID )
|
|
{
|
|
rEntry.setEnabled( bEnable );
|
|
bFound = sal_True;
|
|
}
|
|
}
|
|
|
|
if ( !bFound )
|
|
{
|
|
ElementEntry_Impl aNew( nElementID );
|
|
aNew.setEnabled( bEnable );
|
|
m_pElemList->insert( m_pElemList->end(), aNew );
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XFilePickerNotifier functions
|
|
//------------------------------------------------------------------------------------
|
|
|
|
void SAL_CALL SvtFilePicker::addFilePickerListener( const Reference< XFilePickerListener >& xListener ) throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
m_xListener = xListener;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SAL_CALL SvtFilePicker::removeFilePickerListener( const Reference< XFilePickerListener >& ) throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
m_xListener.clear();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XFilePreview functions
|
|
//------------------------------------------------------------------------------------
|
|
|
|
Sequence< sal_Int16 > SAL_CALL SvtFilePicker::getSupportedImageFormats()
|
|
throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
Sequence< sal_Int16 > aFormats( 1 );
|
|
|
|
aFormats[0] = FilePreviewImageFormats::BITMAP;
|
|
|
|
return aFormats;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
sal_Int32 SAL_CALL SvtFilePicker::getTargetColorDepth() throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
sal_Int32 nDepth = 0;
|
|
|
|
if ( getDialog() )
|
|
nDepth = getDialog()->getTargetColorDepth();
|
|
|
|
return nDepth;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
sal_Int32 SAL_CALL SvtFilePicker::getAvailableWidth() throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
sal_Int32 nWidth = 0;
|
|
|
|
if ( getDialog() )
|
|
nWidth = getDialog()->getAvailableWidth();
|
|
|
|
return nWidth;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
sal_Int32 SAL_CALL SvtFilePicker::getAvailableHeight() throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
sal_Int32 nHeigth = 0;
|
|
|
|
if ( getDialog() )
|
|
nHeigth = getDialog()->getAvailableHeight();
|
|
|
|
return nHeigth;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SAL_CALL SvtFilePicker::setImage( sal_Int16 aImageFormat, const Any& rImage )
|
|
throw ( IllegalArgumentException, RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
if ( getDialog() )
|
|
getDialog()->setImage( aImageFormat, rImage );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
sal_Bool SAL_CALL SvtFilePicker::setShowState( sal_Bool bShowState )
|
|
throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
sal_Bool bRet = sal_False;
|
|
|
|
if ( getDialog() )
|
|
bRet = getDialog()->setShowState( bShowState );
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
sal_Bool SAL_CALL SvtFilePicker::getShowState() throw ( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
sal_Bool bRet = sal_False;
|
|
|
|
if ( getDialog() )
|
|
bRet = getDialog()->getShowState();
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XFilterGroupManager functions
|
|
//------------------------------------------------------------------------------------
|
|
|
|
void SAL_CALL SvtFilePicker::appendFilterGroup( const ::rtl::OUString& sGroupTitle,
|
|
const Sequence< StringPair >& aFilters )
|
|
throw ( IllegalArgumentException, RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
|
|
// check the names
|
|
if ( FilterNameExists( aFilters ) )
|
|
throw IllegalArgumentException(
|
|
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("filter name exists")),
|
|
static_cast< OWeakObject * >(this), 1);
|
|
|
|
// ensure that we have a filter list
|
|
::rtl::OUString sInitialCurrentFilter;
|
|
if ( aFilters.getLength() )
|
|
sInitialCurrentFilter = aFilters[0].First;
|
|
ensureFilterList( sInitialCurrentFilter );
|
|
|
|
// append the filter
|
|
m_pFilterList->insert( m_pFilterList->end(), FilterEntry( sGroupTitle, aFilters ) );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XFilterManager functions
|
|
//------------------------------------------------------------------------------------
|
|
|
|
void SAL_CALL SvtFilePicker::appendFilter( const rtl::OUString& aTitle,
|
|
const rtl::OUString& aFilter )
|
|
throw( IllegalArgumentException, RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
// check the name
|
|
if ( FilterNameExists( aTitle ) )
|
|
// TODO: a more precise exception message
|
|
throw IllegalArgumentException();
|
|
|
|
// ensure that we have a filter list
|
|
ensureFilterList( aTitle );
|
|
|
|
// append the filter
|
|
m_pFilterList->insert( m_pFilterList->end(), FilterEntry( aTitle, aFilter ) );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
void SAL_CALL SvtFilePicker::setCurrentFilter( const rtl::OUString& aTitle )
|
|
throw( IllegalArgumentException, RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
if ( ! FilterNameExists( aTitle ) )
|
|
throw IllegalArgumentException();
|
|
|
|
m_aCurrentFilter = aTitle;
|
|
|
|
if ( getDialog() )
|
|
getDialog()->SetCurFilter( aTitle );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
rtl::OUString SAL_CALL SvtFilePicker::getCurrentFilter()
|
|
throw( RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
SolarMutexGuard aGuard;
|
|
rtl::OUString aFilter = getDialog() ? rtl::OUString( getDialog()->GetCurFilter() ) :
|
|
rtl::OUString( m_aCurrentFilter );
|
|
return aFilter;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XInitialization functions
|
|
//------------------------------------------------------------------------------------
|
|
|
|
void SAL_CALL SvtFilePicker::initialize( const Sequence< Any >& _rArguments )
|
|
throw ( Exception, RuntimeException )
|
|
{
|
|
checkAlive();
|
|
|
|
Sequence< Any > aArguments( _rArguments.getLength());
|
|
|
|
m_nServiceType = TemplateDescription::FILEOPEN_SIMPLE;
|
|
|
|
if ( _rArguments.getLength() >= 1 )
|
|
{
|
|
// compatibility: one argument, type sal_Int16 , specifies the service type
|
|
int index = 0;
|
|
|
|
if (_rArguments[0] >>= m_nServiceType)
|
|
{
|
|
// skip the first entry if it was the ServiceType, because it's not needed in OCommonPicker::initialize and it's not a NamedValue
|
|
NamedValue emptyNamedValue;
|
|
aArguments[0] <<= emptyNamedValue;
|
|
index = 1;
|
|
|
|
}
|
|
for ( int i = index; i < _rArguments.getLength(); i++)
|
|
{
|
|
NamedValue namedValue;
|
|
aArguments[i] <<= _rArguments[i];
|
|
|
|
if (aArguments[i] >>= namedValue )
|
|
{
|
|
|
|
if ( namedValue.Name.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StandardDir" ) ) ) )
|
|
{
|
|
::rtl::OUString sStandardDir;
|
|
|
|
namedValue.Value >>= sStandardDir;
|
|
|
|
// Set the directory for the "back to the default dir" button
|
|
if ( !sStandardDir.isEmpty() )
|
|
{
|
|
m_aStandardDir = sStandardDir;
|
|
}
|
|
}
|
|
else if ( namedValue.Name.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "BlackList" ) ) ) )
|
|
{
|
|
namedValue.Value >>= m_aBlackList;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// let the base class analyze the sequence (will call into implHandleInitializationArgument)
|
|
OCommonPicker::initialize( aArguments );
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
sal_Bool SvtFilePicker::implHandleInitializationArgument( const ::rtl::OUString& _rName, const Any& _rValue ) SAL_THROW( ( Exception, RuntimeException ) )
|
|
{
|
|
if ( _rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "TemplateDescription" ) ) )
|
|
{
|
|
m_nServiceType = TemplateDescription::FILEOPEN_SIMPLE;
|
|
OSL_VERIFY( _rValue >>= m_nServiceType );
|
|
return sal_True;
|
|
}
|
|
if ( _rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "StandardDir" ) ) )
|
|
{
|
|
OSL_VERIFY( _rValue >>= m_aStandardDir );
|
|
return sal_True;
|
|
}
|
|
|
|
if ( _rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "BlackList" ) ) )
|
|
{
|
|
OSL_VERIFY( _rValue >>= m_aBlackList );
|
|
return sal_True;
|
|
}
|
|
|
|
|
|
|
|
return OCommonPicker::implHandleInitializationArgument( _rName, _rValue );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// XServiceInfo
|
|
//------------------------------------------------------------------------------------
|
|
|
|
/* XServiceInfo */
|
|
rtl::OUString SAL_CALL SvtFilePicker::getImplementationName() throw( RuntimeException )
|
|
{
|
|
return impl_getStaticImplementationName();
|
|
}
|
|
|
|
/* XServiceInfo */
|
|
sal_Bool SAL_CALL SvtFilePicker::supportsService( const rtl::OUString& sServiceName ) throw( RuntimeException )
|
|
{
|
|
Sequence< rtl::OUString > seqServiceNames = getSupportedServiceNames();
|
|
const rtl::OUString* pArray = seqServiceNames.getConstArray();
|
|
for ( sal_Int32 i = 0; i < seqServiceNames.getLength(); i++ )
|
|
{
|
|
if ( sServiceName == pArray[i] )
|
|
{
|
|
return sal_True ;
|
|
}
|
|
}
|
|
return sal_False ;
|
|
}
|
|
|
|
/* XServiceInfo */
|
|
Sequence< rtl::OUString > SAL_CALL SvtFilePicker::getSupportedServiceNames() throw( RuntimeException )
|
|
{
|
|
return impl_getStaticSupportedServiceNames();
|
|
}
|
|
|
|
/* Helper for XServiceInfo */
|
|
Sequence< rtl::OUString > SvtFilePicker::impl_getStaticSupportedServiceNames()
|
|
{
|
|
Sequence< rtl::OUString > seqServiceNames( 1 );
|
|
rtl::OUString* pArray = seqServiceNames.getArray();
|
|
pArray[0] = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ui.dialogs.OfficeFilePicker" ));
|
|
return seqServiceNames ;
|
|
}
|
|
|
|
/* Helper for XServiceInfo */
|
|
rtl::OUString SvtFilePicker::impl_getStaticImplementationName()
|
|
{
|
|
return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.svtools.OfficeFilePicker" ));
|
|
}
|
|
|
|
/* Helper for registry */
|
|
Reference< XInterface > SAL_CALL SvtFilePicker::impl_createInstance(
|
|
const Reference< XComponentContext >& rxContext) throw( Exception )
|
|
{
|
|
Reference< XMultiServiceFactory > xServiceManager (rxContext->getServiceManager(), UNO_QUERY_THROW);
|
|
return Reference< XInterface >( *new SvtFilePicker( xServiceManager ) );
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|