/************************************************************** * * 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 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_cui.hxx" // include --------------------------------------------------------------- #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define _SVX_OPTPATH_CXX #include "optpath.hxx" #include #include "optpath.hrc" #include #include "helpid.hrc" #include #include #include #include #include #include #include #include #include "optHeaderTabListbox.hxx" #include #include using namespace ::com::sun::star::beans; using namespace ::com::sun::star::lang; using namespace ::com::sun::star::ui::dialogs; using namespace ::com::sun::star::uno; using namespace svx; // define ---------------------------------------------------------------- #define TAB_WIDTH1 80 #define TAB_WIDTH_MIN 10 #define TAB_WIDTH2 1000 #define ITEMID_TYPE 1 #define ITEMID_PATH 2 #define POSTFIX_INTERNAL String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "_internal" ) ) #define POSTFIX_USER String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "_user" ) ) #define POSTFIX_WRITABLE String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "_writable" ) ) #define POSTFIX_READONLY String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "_readonly" ) ) #define VAR_ONE String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "%1" ) ) #define IODLG_CONFIGNAME String(DEFINE_CONST_UNICODE("FilePicker_Save")) // struct OptPath_Impl --------------------------------------------------- struct OptPath_Impl { SvtDefaultOptions m_aDefOpt; Image m_aLockImage; Image m_aLockImageHC; String m_sMultiPathDlg; Reference< XPropertySet > m_xPathSettings; OptPath_Impl(const ResId& rLockRes, const ResId& rLockResHC) : m_aLockImage(rLockRes), m_aLockImageHC(rLockResHC){} }; // struct PathUserData_Impl ---------------------------------------------- struct PathUserData_Impl { sal_uInt16 nRealId; SfxItemState eState; String sUserPath; String sWritablePath; PathUserData_Impl( sal_uInt16 nId ) : nRealId( nId ), eState( SFX_ITEM_UNKNOWN ) {} }; struct Handle2CfgNameMapping_Impl { sal_uInt16 m_nHandle; const char* m_pCfgName; }; static Handle2CfgNameMapping_Impl __READONLY_DATA Hdl2CfgMap_Impl[] = { { SvtPathOptions::PATH_AUTOCORRECT, "AutoCorrect" }, { SvtPathOptions::PATH_AUTOTEXT, "AutoText" }, { SvtPathOptions::PATH_BACKUP, "Backup" }, { SvtPathOptions::PATH_GALLERY, "Gallery" }, { SvtPathOptions::PATH_GRAPHIC, "Graphic" }, { SvtPathOptions::PATH_TEMP, "Temp" }, { SvtPathOptions::PATH_TEMPLATE, "Template" }, { SvtPathOptions::PATH_WORK, "Work" }, #if OSL_DEBUG_LEVEL > 1 { SvtPathOptions::PATH_LINGUISTIC, "Linguistic" }, { SvtPathOptions::PATH_DICTIONARY, "Dictionary" }, #endif { USHRT_MAX, NULL } }; static String getCfgName_Impl( sal_uInt16 _nHandle ) { String sCfgName; sal_uInt16 nIndex = 0; while ( Hdl2CfgMap_Impl[ nIndex ].m_nHandle != USHRT_MAX ) { if ( Hdl2CfgMap_Impl[ nIndex ].m_nHandle == _nHandle ) { // config name found sCfgName = String::CreateFromAscii( Hdl2CfgMap_Impl[ nIndex ].m_pCfgName ); break; } ++nIndex; } return sCfgName; } #define MULTIPATH_DELIMITER ';' String Convert_Impl( const String& rValue ) { char cDelim = MULTIPATH_DELIMITER; sal_uInt16 nCount = rValue.GetTokenCount( cDelim ); String aReturn; for ( sal_uInt16 i=0; iGrabFocus(); return nRet; } // functions ------------------------------------------------------------- sal_Bool IsMultiPath_Impl( const sal_uInt16 nIndex ) { #if OSL_DEBUG_LEVEL > 1 return ( SvtPathOptions::PATH_AUTOCORRECT == nIndex || SvtPathOptions::PATH_AUTOTEXT == nIndex || SvtPathOptions::PATH_BASIC == nIndex || SvtPathOptions::PATH_GALLERY == nIndex || SvtPathOptions::PATH_TEMPLATE == nIndex ); #else return ( SvtPathOptions::PATH_AUTOCORRECT == nIndex || SvtPathOptions::PATH_AUTOTEXT == nIndex || SvtPathOptions::PATH_BASIC == nIndex || SvtPathOptions::PATH_GALLERY == nIndex || SvtPathOptions::PATH_TEMPLATE == nIndex || SvtPathOptions::PATH_LINGUISTIC == nIndex || SvtPathOptions::PATH_DICTIONARY == nIndex ); #endif } // class SvxPathTabPage -------------------------------------------------- SvxPathTabPage::SvxPathTabPage( Window* pParent, const SfxItemSet& rSet ) : SfxTabPage( pParent, CUI_RES( RID_SFXPAGE_PATH ), rSet ), aStdBox ( this, CUI_RES( GB_STD ) ), aTypeText ( this, CUI_RES( FT_TYPE ) ), aPathText ( this, CUI_RES( FT_PATH ) ), aPathCtrl ( this, CUI_RES( LB_PATH ) ), aStandardBtn ( this, CUI_RES( BTN_STANDARD ) ), aPathBtn ( this, CUI_RES( BTN_PATH ) ), pHeaderBar ( NULL ), pPathBox ( NULL ), pImpl ( new OptPath_Impl( CUI_RES(IMG_LOCK), CUI_RES(IMG_LOCK_HC) ) ), xDialogListener ( new ::svt::DialogClosedListener() ) { pImpl->m_sMultiPathDlg = String( CUI_RES( STR_MULTIPATHDLG ) ); aStandardBtn.SetClickHdl( LINK( this, SvxPathTabPage, StandardHdl_Impl ) ); Link aLink = LINK( this, SvxPathTabPage, PathHdl_Impl ); aPathBtn.SetClickHdl( aLink ); Size aBoxSize = aPathCtrl.GetOutputSizePixel(); pHeaderBar = new HeaderBar( &aPathCtrl, WB_BUTTONSTYLE | WB_BOTTOMBORDER ); pHeaderBar->SetPosSizePixel( Point( 0, 0 ), Size( aBoxSize.Width(), 16 ) ); pHeaderBar->SetSelectHdl( LINK( this, SvxPathTabPage, HeaderSelect_Impl ) ); pHeaderBar->SetEndDragHdl( LINK( this, SvxPathTabPage, HeaderEndDrag_Impl ) ); Size aSz; aSz.Width() = TAB_WIDTH1; pHeaderBar->InsertItem( ITEMID_TYPE, aTypeText.GetText(), LogicToPixel( aSz, MapMode( MAP_APPFONT ) ).Width(), HIB_LEFT | HIB_VCENTER | HIB_CLICKABLE | HIB_UPARROW ); aSz.Width() = TAB_WIDTH2; pHeaderBar->InsertItem( ITEMID_PATH, aPathText.GetText(), LogicToPixel( aSz, MapMode( MAP_APPFONT ) ).Width(), HIB_LEFT | HIB_VCENTER ); static long nTabs[] = {3, 0, TAB_WIDTH1, TAB_WIDTH1 + TAB_WIDTH2 }; Size aHeadSize = pHeaderBar->GetSizePixel(); WinBits nBits = WB_SORT | WB_HSCROLL | WB_CLIPCHILDREN | WB_TABSTOP; pPathBox = new svx::OptHeaderTabListBox( &aPathCtrl, nBits ); aPathCtrl.SetFocusControl( pPathBox ); pPathBox->SetDoubleClickHdl( aLink ); pPathBox->SetSelectHdl( LINK( this, SvxPathTabPage, PathSelect_Impl ) ); pPathBox->SetSelectionMode( MULTIPLE_SELECTION ); pPathBox->SetPosSizePixel( Point( 0, aHeadSize.Height() ), Size( aBoxSize.Width(), aBoxSize.Height() - aHeadSize.Height() ) ); pPathBox->SetTabs( &nTabs[0], MAP_APPFONT ); pPathBox->InitHeaderBar( pHeaderBar ); pPathBox->SetHighlightRange(); pPathBox->SetHelpId( HID_OPTPATH_CTL_PATH ); pHeaderBar->SetHelpId( HID_OPTPATH_HEADERBAR ); pPathBox->Show(); pHeaderBar->Show(); FreeResource(); xDialogListener->SetDialogClosedLink( LINK( this, SvxPathTabPage, DialogClosedHdl ) ); } // ----------------------------------------------------------------------- SvxPathTabPage::~SvxPathTabPage() { // #110603# do not grab focus to a destroyed window !!! aPathCtrl.SetFocusControl( NULL ); pHeaderBar->Hide(); for ( sal_uInt16 i = 0; i < pPathBox->GetEntryCount(); ++i ) delete (PathUserData_Impl*)pPathBox->GetEntry(i)->GetUserData(); delete pPathBox; delete pHeaderBar; delete pImpl; } // ----------------------------------------------------------------------- SfxTabPage* SvxPathTabPage::Create( Window* pParent, const SfxItemSet& rAttrSet ) { return ( new SvxPathTabPage( pParent, rAttrSet ) ); } // ----------------------------------------------------------------------- sal_Bool SvxPathTabPage::FillItemSet( SfxItemSet& ) { SvtPathOptions aPathOpt; for ( sal_uInt16 i = 0; i < pPathBox->GetEntryCount(); ++i ) { PathUserData_Impl* pPathImpl = (PathUserData_Impl*)pPathBox->GetEntry(i)->GetUserData(); sal_uInt16 nRealId = pPathImpl->nRealId; if ( pPathImpl->eState == SFX_ITEM_SET ) SetPathList( nRealId, pPathImpl->sUserPath, pPathImpl->sWritablePath ); } return sal_True; } // ----------------------------------------------------------------------- void SvxPathTabPage::Reset( const SfxItemSet& ) { pPathBox->Clear(); SvtPathOptions aPathOpt; //! deprecated for( sal_uInt16 i = 0; i <= (sal_uInt16)SvtPathOptions::PATH_WORK; ++i ) { // only writer uses autotext if ( i == SvtPathOptions::PATH_AUTOTEXT && !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::E_SWRITER ) ) continue; switch (i) { case SvtPathOptions::PATH_AUTOCORRECT: case SvtPathOptions::PATH_AUTOTEXT: case SvtPathOptions::PATH_BACKUP: case SvtPathOptions::PATH_GALLERY: case SvtPathOptions::PATH_GRAPHIC: case SvtPathOptions::PATH_TEMP: case SvtPathOptions::PATH_TEMPLATE: #if OSL_DEBUG_LEVEL > 1 case SvtPathOptions::PATH_LINGUISTIC: case SvtPathOptions::PATH_DICTIONARY: #endif case SvtPathOptions::PATH_WORK: { String aStr( CUI_RES( RID_SVXSTR_PATH_NAME_START + i ) ); String sInternal, sUser, sWritable; sal_Bool bReadOnly = sal_False; GetPathList( i, sInternal, sUser, sWritable, bReadOnly ); String sTmpPath = sUser; if ( sTmpPath.Len() > 0 && sWritable.Len() > 0 ) sTmpPath += MULTIPATH_DELIMITER; sTmpPath += sWritable; String aValue( sTmpPath ); aStr += '\t'; aStr += Convert_Impl( aValue ); SvLBoxEntry* pEntry = pPathBox->InsertEntry( aStr ); if ( bReadOnly ) { pPathBox->SetCollapsedEntryBmp( pEntry, pImpl->m_aLockImage, BMP_COLOR_NORMAL ); pPathBox->SetCollapsedEntryBmp( pEntry, pImpl->m_aLockImageHC, BMP_COLOR_HIGHCONTRAST ); } PathUserData_Impl* pPathImpl = new PathUserData_Impl(i); pPathImpl->sUserPath = sUser; pPathImpl->sWritablePath = sWritable; pEntry->SetUserData( pPathImpl ); } } } String aUserData = GetUserData(); if ( aUserData.Len() ) { // Spaltenbreite restaurieren pHeaderBar->SetItemSize( ITEMID_TYPE, aUserData.GetToken(0).ToInt32() ); HeaderEndDrag_Impl( NULL ); // Sortierrichtung restaurieren sal_Bool bUp = (sal_Bool)(sal_uInt16)aUserData.GetToken(1).ToInt32(); HeaderBarItemBits nBits = pHeaderBar->GetItemBits(ITEMID_TYPE); if ( bUp ) { nBits &= ~HIB_UPARROW; nBits |= HIB_DOWNARROW; } else { nBits &= ~HIB_DOWNARROW; nBits |= HIB_UPARROW; } pHeaderBar->SetItemBits( ITEMID_TYPE, nBits ); HeaderSelect_Impl( NULL ); } PathSelect_Impl( NULL ); } // ----------------------------------------------------------------------- void SvxPathTabPage::FillUserData() { String aUserData = String::CreateFromInt32( pHeaderBar->GetItemSize( ITEMID_TYPE ) ); aUserData += ';'; HeaderBarItemBits nBits = pHeaderBar->GetItemBits( ITEMID_TYPE ); sal_Bool bUp = ( ( nBits & HIB_UPARROW ) == HIB_UPARROW ); aUserData += bUp ? '1' : '0'; SetUserData( aUserData ); } // ----------------------------------------------------------------------- IMPL_LINK( SvxPathTabPage, PathSelect_Impl, svx::OptHeaderTabListBox *, EMPTYARG ) /* [Beschreibung] */ { sal_uInt16 nSelCount = 0; SvLBoxEntry* pEntry = pPathBox->FirstSelected(); //the entry image indicates whether the path is write protected Image aEntryImage; if(pEntry) aEntryImage = pPathBox->GetCollapsedEntryBmp( pEntry ); sal_Bool bEnable = !aEntryImage; while ( pEntry && ( nSelCount < 2 ) ) { nSelCount++; pEntry = pPathBox->NextSelected( pEntry ); } aPathBtn.Enable( 1 == nSelCount && bEnable); aStandardBtn.Enable( nSelCount > 0 && bEnable); return 0; } // ----------------------------------------------------------------------- IMPL_LINK( SvxPathTabPage, StandardHdl_Impl, PushButton *, EMPTYARG ) { SvLBoxEntry* pEntry = pPathBox->FirstSelected(); while ( pEntry ) { PathUserData_Impl* pPathImpl = (PathUserData_Impl*)pEntry->GetUserData(); String aOldPath = pImpl->m_aDefOpt.GetDefaultPath( pPathImpl->nRealId ); if ( aOldPath.Len() ) { String sInternal, sUser, sWritable, sTemp; sal_Bool bReadOnly = sal_False; GetPathList( pPathImpl->nRealId, sInternal, sUser, sWritable, bReadOnly ); sal_uInt16 i; sal_uInt16 nOldCount = aOldPath.GetTokenCount( MULTIPATH_DELIMITER ); sal_uInt16 nIntCount = sInternal.GetTokenCount( MULTIPATH_DELIMITER ); for ( i = 0; i < nOldCount; ++i ) { bool bFound = false; String sOnePath = aOldPath.GetToken( i, MULTIPATH_DELIMITER ); for ( sal_uInt16 j = 0; !bFound && j < nIntCount; ++j ) { if ( sInternal.GetToken( i, MULTIPATH_DELIMITER ) == sOnePath ) bFound = true; } if ( !bFound ) { if ( sTemp.Len() > 0 ) sTemp += MULTIPATH_DELIMITER; sTemp += sOnePath; } } String sUserPath, sWritablePath; nOldCount = sTemp.GetTokenCount( MULTIPATH_DELIMITER ); for ( i = 0; nOldCount > 0 && i < nOldCount - 1; ++i ) { if ( sUserPath.Len() > 0 ) sUserPath += MULTIPATH_DELIMITER; sUserPath += sTemp.GetToken( i, MULTIPATH_DELIMITER ); } sWritablePath = sTemp.GetToken( nOldCount - 1, MULTIPATH_DELIMITER ); pPathBox->SetEntryText( Convert_Impl( sTemp ), pEntry, 1 ); pPathImpl->eState = SFX_ITEM_SET; pPathImpl->sUserPath = sUserPath; pPathImpl->sWritablePath = sWritablePath; } pEntry = pPathBox->NextSelected( pEntry ); } return 0; } // ----------------------------------------------------------------------- void SvxPathTabPage::ChangeCurrentEntry( const String& _rFolder ) { SvLBoxEntry* pEntry = pPathBox->GetCurEntry(); if ( !pEntry ) { DBG_ERRORFILE( "SvxPathTabPage::ChangeCurrentEntry(): no entry" ); return; } String sInternal, sUser, sWritable; PathUserData_Impl* pPathImpl = (PathUserData_Impl*)pEntry->GetUserData(); sal_Bool bReadOnly = sal_False; GetPathList( pPathImpl->nRealId, sInternal, sUser, sWritable, bReadOnly ); sUser = pPathImpl->sUserPath; sWritable = pPathImpl->sWritablePath; sal_uInt16 nPos = pPathImpl->nRealId; // old path is an URL? INetURLObject aObj( sWritable ); FASTBOOL bURL = ( aObj.GetProtocol() != INET_PROT_NOT_VALID ); rtl::OUString aPathStr( _rFolder ); INetURLObject aNewObj( aPathStr ); aNewObj.removeFinalSlash(); // then the new path also an URL else system path String sNewPathStr = bURL ? aPathStr : aNewObj.getFSysPath( INetURLObject::FSYS_DETECT ); FASTBOOL bChanged = #ifdef UNX // Unix is case sensitive ( sNewPathStr != sWritable ); #else ( sNewPathStr.CompareIgnoreCaseToAscii( sWritable ) != COMPARE_EQUAL ); #endif if ( bChanged ) { pPathBox->SetEntryText( Convert_Impl( sNewPathStr ), pEntry, 1 ); nPos = (sal_uInt16)pPathBox->GetModel()->GetAbsPos( pEntry ); pPathImpl = (PathUserData_Impl*)pPathBox->GetEntry(nPos)->GetUserData(); pPathImpl->eState = SFX_ITEM_SET; pPathImpl->sWritablePath = sNewPathStr; if ( SvtPathOptions::PATH_WORK == pPathImpl->nRealId ) { // Remove view options entry so the new work path // will be used for the next open dialog. SvtViewOptions aDlgOpt( E_DIALOG, IODLG_CONFIGNAME ); aDlgOpt.Delete(); // Reset also last used dir in the sfx application instance SfxApplication *pSfxApp = SFX_APP(); pSfxApp->ResetLastDir(); // Set configuration flag to notify file picker that it's necessary // to take over the path provided. Reference < XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() ); ::comphelper::ConfigurationHelper::writeDirectKey(xFactory, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("org.openoffice.Office.Common/")), ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Path/Info")), ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("WorkPathChanged")), ::com::sun::star::uno::makeAny(true), ::comphelper::ConfigurationHelper::E_STANDARD); } } } // ----------------------------------------------------------------------- IMPL_LINK( SvxPathTabPage, PathHdl_Impl, PushButton *, EMPTYARG ) { SvLBoxEntry* pEntry = pPathBox->GetCurEntry(); sal_uInt16 nPos = ( pEntry != NULL ) ? ( (PathUserData_Impl*)pEntry->GetUserData() )->nRealId : 0; String sInternal, sUser, sWritable; if ( pEntry ) { PathUserData_Impl* pPathImpl = (PathUserData_Impl*)pEntry->GetUserData(); sal_Bool bReadOnly = sal_False; GetPathList( pPathImpl->nRealId, sInternal, sUser, sWritable, bReadOnly ); sUser = pPathImpl->sUserPath; sWritable = pPathImpl->sWritablePath; } if(pEntry && !(!((OptHeaderTabListBox*)pPathBox)->GetCollapsedEntryBmp(pEntry))) return 0; if ( IsMultiPath_Impl( nPos ) ) { SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); if ( pFact ) { AbstractSvxMultiPathDialog* pMultiDlg = pFact->CreateSvxMultiPathDialog( this ); DBG_ASSERT( pMultiDlg, "Dialogdiet fail!" ); pMultiDlg->EnableRadioButtonMode(); String sPath( sUser ); if ( sPath.Len() > 0 ) sPath += MULTIPATH_DELIMITER; sPath += sWritable; pMultiDlg->SetPath( sPath ); String sPathName = pPathBox->GetEntryText( pEntry, 0 ); String sNewTitle( pImpl->m_sMultiPathDlg ); sNewTitle.SearchAndReplace( VAR_ONE, sPathName ); pMultiDlg->SetTitle( sNewTitle ); if ( pMultiDlg->Execute() == RET_OK && pEntry ) { sUser.Erase(); sWritable.Erase(); String sFullPath; String sNewPath = pMultiDlg->GetPath(); char cDelim = MULTIPATH_DELIMITER; sal_uInt16 nCount = sNewPath.GetTokenCount( cDelim ); if ( nCount > 0 ) { sal_uInt16 i = 0; for ( ; i < nCount - 1; ++i ) { if ( sUser.Len() > 0 ) sUser += cDelim; sUser += sNewPath.GetToken( i, cDelim ); } if ( sFullPath.Len() > 0 ) sFullPath += cDelim; sFullPath += sUser; sWritable += sNewPath.GetToken( i, cDelim ); if ( sFullPath.Len() > 0 ) sFullPath += cDelim; sFullPath += sWritable; } pPathBox->SetEntryText( Convert_Impl( sFullPath ), pEntry, 1 ); // save modified flag PathUserData_Impl* pPathImpl = (PathUserData_Impl*)pEntry->GetUserData(); pPathImpl->eState = SFX_ITEM_SET; pPathImpl->sUserPath = sUser; pPathImpl->sWritablePath = sWritable; } delete pMultiDlg; } } else if ( pEntry ) { try { rtl::OUString aService( RTL_CONSTASCII_USTRINGPARAM( FOLDER_PICKER_SERVICE_NAME ) ); Reference < XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() ); xFolderPicker = ::com::sun::star::uno::Reference< XFolderPicker >( xFactory->createInstance( aService ), UNO_QUERY ); INetURLObject aURL( sWritable, INET_PROT_FILE ); xFolderPicker->setDisplayDirectory( aURL.GetMainURL( INetURLObject::NO_DECODE ) ); Reference< XAsynchronousExecutableDialog > xAsyncDlg( xFolderPicker, UNO_QUERY ); if ( xAsyncDlg.is() ) xAsyncDlg->startExecuteModal( xDialogListener.get() ); else { short nRet = xFolderPicker->execute(); if ( ExecutableDialogResults::OK != nRet ) return 0; String sFolder( xFolderPicker->getDirectory() ); ChangeCurrentEntry( sFolder ); } } catch( Exception& ) { DBG_ERRORFILE( "SvxPathTabPage::PathHdl_Impl: exception from folder picker" ); } } return 0; } // ----------------------------------------------------------------------- IMPL_LINK( SvxPathTabPage, HeaderSelect_Impl, HeaderBar*, pBar ) { if ( pBar && pBar->GetCurItemId() != ITEMID_TYPE ) return 0; HeaderBarItemBits nBits = pHeaderBar->GetItemBits(ITEMID_TYPE); sal_Bool bUp = ( ( nBits & HIB_UPARROW ) == HIB_UPARROW ); SvSortMode eMode = SortAscending; if ( bUp ) { nBits &= ~HIB_UPARROW; nBits |= HIB_DOWNARROW; eMode = SortDescending; } else { nBits &= ~HIB_DOWNARROW; nBits |= HIB_UPARROW; } pHeaderBar->SetItemBits( ITEMID_TYPE, nBits ); SvTreeList* pModel = pPathBox->GetModel(); pModel->SetSortMode( eMode ); pModel->Resort(); return 1; } // ----------------------------------------------------------------------- IMPL_LINK( SvxPathTabPage, HeaderEndDrag_Impl, HeaderBar*, pBar ) { if ( pBar && !pBar->GetCurItemId() ) return 0; if ( !pHeaderBar->IsItemMode() ) { Size aSz; sal_uInt16 nTabs = pHeaderBar->GetItemCount(); long nTmpSz = 0; long nWidth = pHeaderBar->GetItemSize(ITEMID_TYPE); long nBarWidth = pHeaderBar->GetSizePixel().Width(); if(nWidth < TAB_WIDTH_MIN) pHeaderBar->SetItemSize( ITEMID_TYPE, TAB_WIDTH_MIN); else if ( ( nBarWidth - nWidth ) < TAB_WIDTH_MIN ) pHeaderBar->SetItemSize( ITEMID_TYPE, nBarWidth - TAB_WIDTH_MIN ); for ( sal_uInt16 i = 1; i <= nTabs; ++i ) { long _nWidth = pHeaderBar->GetItemSize(i); aSz.Width() = _nWidth + nTmpSz; nTmpSz += _nWidth; pPathBox->SetTab( i, PixelToLogic( aSz, MapMode(MAP_APPFONT) ).Width(), MAP_APPFONT ); } } return 1; } // ----------------------------------------------------------------------- IMPL_LINK( SvxPathTabPage, DialogClosedHdl, DialogClosedEvent*, pEvt ) { if ( RET_OK == pEvt->DialogResult ) { DBG_ASSERT( xFolderPicker.is() == sal_True, "SvxPathTabPage::DialogClosedHdl(): no folder picker" ); String sURL = String( xFolderPicker->getDirectory() ); ChangeCurrentEntry( sURL ); } return 0L; } // ----------------------------------------------------------------------- void SvxPathTabPage::GetPathList( sal_uInt16 _nPathHandle, String& _rInternalPath, String& _rUserPath, String& _rWritablePath, sal_Bool& _rReadOnly ) { String sCfgName = getCfgName_Impl( _nPathHandle ); // load PathSettings service if necessary if ( !pImpl->m_xPathSettings.is() ) { Reference< XMultiServiceFactory > xSMgr = comphelper::getProcessServiceFactory(); pImpl->m_xPathSettings = Reference< XPropertySet >( xSMgr->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.util.PathSettings") ) ), UNO_QUERY ); } try { if ( pImpl->m_xPathSettings.is() ) { // load internal paths String sProp( sCfgName ); sProp = sCfgName; sProp += POSTFIX_INTERNAL; Any aAny = pImpl->m_xPathSettings->getPropertyValue( sProp ); Sequence< ::rtl::OUString > aPathSeq; if ( aAny >>= aPathSeq ) { long i, nCount = aPathSeq.getLength(); const ::rtl::OUString* pPaths = aPathSeq.getConstArray(); for ( i = 0; i < nCount; ++i ) { if ( _rInternalPath.Len() > 0 ) _rInternalPath += ';'; _rInternalPath += String( pPaths[i] ); } } // load user paths sProp = sCfgName; sProp += POSTFIX_USER; aAny = pImpl->m_xPathSettings->getPropertyValue( sProp ); if ( aAny >>= aPathSeq ) { long i, nCount = aPathSeq.getLength(); const ::rtl::OUString* pPaths = aPathSeq.getConstArray(); for ( i = 0; i < nCount; ++i ) { if ( _rUserPath.Len() > 0 ) _rUserPath += ';'; _rUserPath += String( pPaths[i] ); } } // then the writable path sProp = sCfgName; sProp += POSTFIX_WRITABLE; aAny = pImpl->m_xPathSettings->getPropertyValue( sProp ); ::rtl::OUString sWritablePath; if ( aAny >>= sWritablePath ) _rWritablePath = String( sWritablePath ); // and the readonly flag sProp = sCfgName; Reference< XPropertySetInfo > xInfo = pImpl->m_xPathSettings->getPropertySetInfo(); Property aProp = xInfo->getPropertyByName( sProp ); _rReadOnly = ( ( aProp.Attributes & PropertyAttribute::READONLY ) == PropertyAttribute::READONLY ); } } catch( const Exception& ) { OSL_ENSURE( sal_False, "SvxPathTabPage::GetPathList(): caught an exception!" ); } } // ----------------------------------------------------------------------- void SvxPathTabPage::SetPathList( sal_uInt16 _nPathHandle, const String& _rUserPath, const String& _rWritablePath ) { String sCfgName = getCfgName_Impl( _nPathHandle ); // load PathSettings service if necessary if ( !pImpl->m_xPathSettings.is() ) { Reference< XMultiServiceFactory > xSMgr = comphelper::getProcessServiceFactory(); pImpl->m_xPathSettings = Reference< XPropertySet >( xSMgr->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.util.PathSettings") ) ), UNO_QUERY ); } try { if ( pImpl->m_xPathSettings.is() ) { // save user paths char cDelim = MULTIPATH_DELIMITER; sal_uInt16 nCount = _rUserPath.GetTokenCount( cDelim ); Sequence< ::rtl::OUString > aPathSeq( nCount ); ::rtl::OUString* pArray = aPathSeq.getArray(); for ( sal_uInt16 i = 0; i < nCount; ++i ) pArray[i] = ::rtl::OUString( _rUserPath.GetToken( i, cDelim ) ); String sProp( sCfgName ); sProp += POSTFIX_USER; Any aValue = makeAny( aPathSeq ); pImpl->m_xPathSettings->setPropertyValue( sProp, aValue ); // then the writable path aValue = makeAny( ::rtl::OUString( _rWritablePath ) ); sProp = sCfgName; sProp += POSTFIX_WRITABLE; pImpl->m_xPathSettings->setPropertyValue( sProp, aValue ); } } catch( const Exception& ) { OSL_ENSURE( sal_False, "SvxPathTabPage::SetPathList(): caught an exception!" ); } }