| /************************************************************** |
| * |
| * 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 <algorithm> |
| #include <ucbhelper/content.hxx> |
| #include <vos/mutex.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <avmedia/mediawindow.hxx> |
| #include <unotools/pathoptions.hxx> |
| #include <sfx2/opengrf.hxx> |
| #include <svtools/filter.hxx> |
| #include <svx/gallery1.hxx> |
| #include <svx/galtheme.hxx> |
| #include "cuigaldlg.hxx" |
| #include "helpid.hrc" |
| #include <unotools/syslocale.hxx> |
| #include <cppuhelper/implbase1.hxx> |
| #include <com/sun/star/uno/Reference.hxx> |
| #include <com/sun/star/lang/XInitialization.hpp> |
| #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp> |
| #include <comphelper/processfactory.hxx> |
| #include <com/sun/star/sdbc/XResultSet.hpp> |
| #include <com/sun/star/sdbc/XRow.hpp> |
| #include <com/sun/star/ucb/XContentAccess.hpp> |
| #include <com/sun/star/ui/dialogs/XAsynchronousExecutableDialog.hpp> |
| #include <sfx2/sfxuno.hxx> |
| #include "dialmgr.hxx" |
| #include "gallery.hrc" |
| #include <svx/dialogs.hrc> |
| #include <svx/dialmgr.hxx> |
| |
| |
| // -------------- |
| // - Namespaces - |
| // -------------- |
| |
| using namespace ::ucbhelper; |
| using namespace ::rtl; |
| using namespace ::cppu; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::sdbc; |
| using namespace ::com::sun::star::ucb; |
| using namespace ::com::sun::star::ui::dialogs; |
| using namespace ::com::sun::star::uno; |
| |
| |
| // ----------- |
| // - Defines - |
| // ----------- |
| |
| #define MAXPATH 1024 |
| |
| // ---------------- |
| // - SearchThread - |
| // ---------------- |
| |
| SearchThread::SearchThread( SearchProgress* pProgess, |
| TPGalleryThemeProperties* pBrowser, |
| const INetURLObject& rStartURL ) : |
| mpProgress ( pProgess ), |
| mpBrowser ( pBrowser ), |
| maStartURL ( rStartURL ) |
| { |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| SearchThread::~SearchThread() |
| { |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SAL_CALL SearchThread::run() |
| { |
| const String aFileType( mpBrowser->aCbbFileType.GetText() ); |
| |
| if( aFileType.Len() ) |
| { |
| const sal_uInt16 nFileNumber = mpBrowser->aCbbFileType.GetEntryPos( aFileType ); |
| sal_uInt16 nBeginFormat, nEndFormat; |
| ::std::vector< String > aFormats; |
| |
| if( !nFileNumber || ( nFileNumber >= mpBrowser->aCbbFileType.GetEntryCount() ) ) |
| { |
| nBeginFormat = 1; |
| nEndFormat = mpBrowser->aCbbFileType.GetEntryCount() - 1; |
| } |
| else |
| nBeginFormat = nEndFormat = nFileNumber; |
| |
| for( sal_uInt16 i = nBeginFormat; i <= nEndFormat; ++i ) |
| aFormats.push_back( ( (FilterEntry*) mpBrowser->aFilterEntryList.GetObject( i ) )->aFilterName.ToLowerAscii() ); |
| |
| ImplSearch( maStartURL, aFormats, mpBrowser->bSearchRecursive ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SAL_CALL SearchThread::onTerminated() |
| { |
| Application::PostUserEvent( LINK( mpProgress, SearchProgress, CleanUpHdl ) ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SearchThread::ImplSearch( const INetURLObject& rStartURL, |
| const ::std::vector< String >& rFormats, |
| sal_Bool bRecursive ) |
| { |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| |
| mpProgress->SetDirectory( rStartURL ); |
| mpProgress->Sync(); |
| } |
| |
| try |
| { |
| ::com::sun::star::uno::Reference< XCommandEnvironment > xEnv; |
| Content aCnt( rStartURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv ); |
| Sequence< OUString > aProps( 2 ); |
| |
| aProps.getArray()[ 0 ] = OUString::createFromAscii( "IsFolder" ); |
| aProps.getArray()[ 1 ] = OUString::createFromAscii( "IsDocument" ); |
| ::com::sun::star::uno::Reference< XResultSet > xResultSet( |
| aCnt.createCursor( aProps, INCLUDE_FOLDERS_AND_DOCUMENTS ) ); |
| |
| if( xResultSet.is() ) |
| { |
| ::com::sun::star::uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY_THROW ); |
| ::com::sun::star::uno::Reference< XRow > xRow( xResultSet, UNO_QUERY_THROW ); |
| |
| while( xResultSet->next() && schedule() ) |
| { |
| INetURLObject aFoundURL( xContentAccess->queryContentIdentifierString() ); |
| DBG_ASSERT( aFoundURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" ); |
| |
| sal_Bool bFolder = xRow->getBoolean( 1 ); // property "IsFolder" |
| if ( xRow->wasNull() ) |
| bFolder = sal_False; |
| |
| if( bRecursive && bFolder ) |
| ImplSearch( aFoundURL, rFormats, sal_True ); |
| else |
| { |
| sal_Bool bDocument = xRow->getBoolean( 2 ); // property "IsDocument" |
| if ( xRow->wasNull() ) |
| bDocument = sal_False; |
| |
| if( bDocument ) |
| { |
| GraphicDescriptor aDesc( aFoundURL ); |
| String aFileName; |
| |
| if( ( aDesc.Detect() && |
| ::std::find( rFormats.begin(), |
| rFormats.end(), |
| aDesc.GetImportFormatShortName( |
| aDesc.GetFileFormat() ).ToLowerAscii() ) |
| != rFormats.end() ) || |
| ::std::find( rFormats.begin(), |
| rFormats.end(), |
| String(aFoundURL.GetExtension().toAsciiLowerCase()) ) |
| != rFormats.end() ) |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| |
| mpBrowser->aFoundList.Insert( |
| new String( aFoundURL.GetMainURL( INetURLObject::NO_DECODE ) ), |
| LIST_APPEND ); |
| mpBrowser->aLbxFound.InsertEntry( |
| GetReducedString( aFoundURL, 50 ), |
| (sal_uInt16) mpBrowser->aFoundList.Count() - 1 ); |
| } |
| } |
| } |
| } |
| } |
| } |
| catch( const ContentCreationException& ) |
| { |
| } |
| catch( const ::com::sun::star::uno::RuntimeException& ) |
| { |
| } |
| catch( const ::com::sun::star::uno::Exception& ) |
| { |
| } |
| } |
| |
| // ------------------ |
| // - SearchProgress - |
| // ------------------ |
| |
| SearchProgress::SearchProgress( Window* pParent, const INetURLObject& rStartURL ) : |
| ModalDialog ( pParent, CUI_RES(RID_SVXDLG_GALLERY_SEARCH_PROGRESS ) ), |
| aFtSearchDir ( this, CUI_RES( FT_SEARCH_DIR ) ), |
| aFLSearchDir ( this, CUI_RES( FL_SEARCH_DIR ) ), |
| aFtSearchType ( this, CUI_RES( FT_SEARCH_TYPE ) ), |
| aFLSearchType ( this, CUI_RES( FL_SEARCH_TYPE ) ), |
| aBtnCancel ( this, CUI_RES( BTN_CANCEL ) ), |
| maSearchThread ( this, (TPGalleryThemeProperties*) pParent, rStartURL ) |
| { |
| FreeResource(); |
| aBtnCancel.SetClickHdl( LINK( this, SearchProgress, ClickCancelBtn ) ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SearchProgress::Terminate() |
| { |
| maSearchThread.terminate(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( SearchProgress, ClickCancelBtn, void*, EMPTYARG ) |
| { |
| Terminate(); |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( SearchProgress, CleanUpHdl, void*, EMPTYARG ) |
| { |
| EndDialog( RET_OK ); |
| delete this; |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| short SearchProgress::Execute() |
| { |
| DBG_ERROR( "SearchProgress cannot be executed via Dialog::Execute!\n" |
| "It creates a thread that will call back to VCL apartment => deadlock!\n" |
| "Use Dialog::StartExecuteModal to execute the dialog!" ); |
| return RET_CANCEL; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SearchProgress::StartExecuteModal( const Link& rEndDialogHdl ) |
| { |
| maSearchThread.create(); |
| ModalDialog::StartExecuteModal( rEndDialogHdl ); |
| } |
| |
| // -------------- |
| // - TakeThread - |
| // -------------- |
| |
| TakeThread::TakeThread( TakeProgress* pProgess, TPGalleryThemeProperties* pBrowser, List& rTakenList ) : |
| mpProgress ( pProgess ), |
| mpBrowser ( pBrowser ), |
| mrTakenList ( rTakenList ) |
| { |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| TakeThread::~TakeThread() |
| { |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SAL_CALL TakeThread::run() |
| { |
| String aName; |
| INetURLObject aURL; |
| sal_uInt16 nEntries; |
| GalleryTheme* pThm = mpBrowser->GetXChgData()->pTheme; |
| sal_uInt16 nPos; |
| GalleryProgress* pStatusProgress; |
| |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| pStatusProgress = new GalleryProgress; |
| nEntries = mpBrowser->bTakeAll ? mpBrowser->aLbxFound.GetEntryCount() : mpBrowser->aLbxFound.GetSelectEntryCount(); |
| pThm->LockBroadcaster(); |
| } |
| |
| for( sal_uInt16 i = 0; i < nEntries && schedule(); i++ ) |
| { |
| // kompletten Filenamen aus FoundList holen |
| if( mpBrowser->bTakeAll ) |
| aURL = INetURLObject(*mpBrowser->aFoundList.GetObject( nPos = i )); |
| else |
| aURL = INetURLObject(*mpBrowser->aFoundList.GetObject( nPos = mpBrowser->aLbxFound.GetSelectEntryPos( i ) )); |
| |
| // Position in Taken-Liste uebernehmen |
| mrTakenList.Insert( (void*) (sal_uLong)nPos, LIST_APPEND ); |
| |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| |
| mpProgress->SetFile( aURL.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ) ); |
| pStatusProgress->Update( i, nEntries - 1 ); |
| mpProgress->Sync(); |
| pThm->InsertURL( aURL ); |
| } |
| } |
| |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| |
| pThm->UnlockBroadcaster(); |
| delete pStatusProgress; |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SAL_CALL TakeThread::onTerminated() |
| { |
| Application::PostUserEvent( LINK( mpProgress, TakeProgress, CleanUpHdl ) ); |
| } |
| |
| // ---------------- |
| // - TakeProgress - |
| // ---------------- |
| |
| TakeProgress::TakeProgress( Window* pWindow ) : |
| ModalDialog ( pWindow, CUI_RES( RID_SVXDLG_GALLERY_TAKE_PROGRESS ) ), |
| aFtTakeFile ( this, CUI_RES( FT_TAKE_FILE ) ), |
| aFLTakeProgress( this, CUI_RES( FL_TAKE_PROGRESS ) ), |
| aBtnCancel ( this, CUI_RES( BTN_CANCEL ) ), |
| maTakeThread ( this, (TPGalleryThemeProperties*) pWindow, maTakenList ) |
| |
| { |
| FreeResource(); |
| aBtnCancel.SetClickHdl( LINK( this, TakeProgress, ClickCancelBtn ) ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| |
| void TakeProgress::Terminate() |
| { |
| maTakeThread.terminate(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TakeProgress, ClickCancelBtn, void*, EMPTYARG ) |
| { |
| Terminate(); |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TakeProgress, CleanUpHdl, void*, EMPTYARG ) |
| { |
| TPGalleryThemeProperties* mpBrowser = (TPGalleryThemeProperties*) GetParent(); |
| ::std::bit_vector aRemoveEntries( mpBrowser->aFoundList.Count(), false ); |
| ::std::vector< String > aRemainingVector; |
| sal_uInt32 i, nCount; |
| |
| GetParent()->EnterWait(); |
| mpBrowser->aLbxFound.SetUpdateMode( sal_False ); |
| mpBrowser->aLbxFound.SetNoSelection(); |
| |
| // mark all taken positions in aRemoveEntries |
| for( i = 0UL, nCount = maTakenList.Count(); i < nCount; ++i ) |
| aRemoveEntries[ (sal_uLong) maTakenList.GetObject( i ) ] = true; |
| |
| maTakenList.Clear(); |
| |
| // refill found list |
| for( i = 0, nCount = aRemoveEntries.size(); i < nCount; ++i ) |
| if( !aRemoveEntries[ i ] ) |
| aRemainingVector.push_back( *mpBrowser->aFoundList.GetObject( i ) ); |
| |
| for( String* pStr = mpBrowser->aFoundList.First(); pStr; pStr = mpBrowser->aFoundList.Next() ) |
| delete pStr; |
| |
| mpBrowser->aFoundList.Clear(); |
| |
| for( i = 0, nCount = aRemainingVector.size(); i < nCount; ++i ) |
| mpBrowser->aFoundList.Insert( new String( aRemainingVector[ i ] ), LIST_APPEND ); |
| |
| aRemainingVector.clear(); |
| |
| // refill list box |
| for( i = 0, nCount = aRemoveEntries.size(); i < nCount; ++i ) |
| if( !aRemoveEntries[ i ] ) |
| aRemainingVector.push_back( mpBrowser->aLbxFound.GetEntry( (sal_uInt16) i ) ); |
| |
| mpBrowser->aLbxFound.Clear(); |
| |
| for( i = 0, nCount = aRemainingVector.size(); i < nCount; ++i ) |
| mpBrowser->aLbxFound.InsertEntry( aRemainingVector[ i ] ); |
| |
| aRemainingVector.clear(); |
| |
| mpBrowser->aLbxFound.SetUpdateMode( sal_True ); |
| mpBrowser->SelectFoundHdl( NULL ); |
| GetParent()->LeaveWait(); |
| |
| EndDialog( RET_OK ); |
| delete this; |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| short TakeProgress::Execute() |
| { |
| DBG_ERROR( "TakeProgress cannot be executed via Dialog::Execute!\n" |
| "It creates a thread that will call back to VCL apartment => deadlock!\n" |
| "Use Dialog::StartExecuteModal to execute the dialog!" ); |
| return RET_CANCEL; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void TakeProgress::StartExecuteModal( const Link& rEndDialogHdl ) |
| { |
| maTakeThread.create(); |
| ModalDialog::StartExecuteModal( rEndDialogHdl ); |
| } |
| |
| // --------------------- |
| // - ActualizeProgress - |
| // --------------------- |
| |
| ActualizeProgress::ActualizeProgress( Window* pWindow, GalleryTheme* pThm ) : |
| ModalDialog ( pWindow, CUI_RES( RID_SVXDLG_GALLERY_ACTUALIZE_PROGRESS ) ), |
| aFtActualizeFile ( this, CUI_RES( FT_ACTUALIZE_FILE ) ), |
| aFLActualizeProgress ( this, CUI_RES( FL_ACTUALIZE_PROGRESS ) ), |
| aBtnCancel ( this, CUI_RES( BTN_CANCEL ) ), |
| pTheme ( pThm ) |
| { |
| FreeResource(); |
| aBtnCancel.SetClickHdl( LINK( this, ActualizeProgress, ClickCancelBtn ) ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| short ActualizeProgress::Execute() |
| { |
| short nRet; |
| |
| pTimer = new Timer; |
| |
| if ( pTimer ) |
| { |
| pTimer->SetTimeoutHdl( LINK( this, ActualizeProgress, TimeoutHdl ) ); |
| pTimer->SetTimeout( 500 ); |
| pTimer->Start(); |
| } |
| |
| nRet = ModalDialog::Execute(); |
| |
| return nRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( ActualizeProgress, ClickCancelBtn, void*, EMPTYARG ) |
| { |
| pTheme->AbortActualize(); |
| EndDialog( RET_OK ); |
| |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( ActualizeProgress, TimeoutHdl, Timer*, _pTimer ) |
| { |
| if ( _pTimer ) |
| { |
| _pTimer->Stop(); |
| delete _pTimer; |
| } |
| |
| pTheme->Actualize( LINK( this, ActualizeProgress, ActualizeHdl ), &aStatusProgress ); |
| ClickCancelBtn( NULL ); |
| |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( ActualizeProgress, ActualizeHdl, INetURLObject*, pURL ) |
| { |
| for( long i = 0; i < 128; i++ ) |
| Application::Reschedule(); |
| |
| Flush(); |
| Sync(); |
| |
| if( pURL ) |
| { |
| aFtActualizeFile.SetText( GetReducedString( *pURL, 30 ) ); |
| aFtActualizeFile.Flush(); |
| aFtActualizeFile.Sync(); |
| } |
| |
| return 0; |
| } |
| |
| // --------------- |
| // - TitleDialog - |
| // --------------- |
| |
| TitleDialog::TitleDialog( Window* pParent, const String& rOldTitle ) : |
| ModalDialog ( pParent, CUI_RES( RID_SVXDLG_GALLERY_TITLE ) ), |
| maOk ( this, CUI_RES( BTN_OK ) ), |
| maCancel ( this, CUI_RES( BTN_CANCEL ) ), |
| maHelp ( this, CUI_RES( BTN_HELP ) ), |
| maFL ( this, CUI_RES( FL_TITLE ) ), |
| maEdit ( this, CUI_RES( EDT_TITLE ) ) |
| { |
| FreeResource(); |
| maEdit.SetText( rOldTitle ); |
| maEdit.GrabFocus(); |
| } |
| |
| // ------------------- |
| // - GalleryIdDialog - |
| // ------------------- |
| |
| GalleryIdDialog::GalleryIdDialog( Window* pParent, GalleryTheme* _pThm ) : |
| ModalDialog ( pParent, CUI_RES( RID_SVXDLG_GALLERY_THEMEID ) ), |
| aBtnOk ( this, CUI_RES( BTN_OK ) ), |
| aBtnCancel ( this, CUI_RES( BTN_CANCEL ) ), |
| aFLId ( this, CUI_RES( FL_ID ) ), |
| aLbResName ( this, CUI_RES( LB_RESNAME ) ), |
| pThm ( _pThm ) |
| { |
| FreeResource(); |
| |
| aLbResName.InsertEntry( String( RTL_CONSTASCII_USTRINGPARAM( "!!! No Id !!!" ) ) ); |
| |
| GalleryTheme::InsertAllThemes( aLbResName ); |
| |
| aLbResName.SelectEntryPos( (sal_uInt16) pThm->GetId() ); |
| aLbResName.GrabFocus(); |
| |
| aBtnOk.SetClickHdl( LINK( this, GalleryIdDialog, ClickOkHdl ) ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| IMPL_LINK( GalleryIdDialog, ClickOkHdl, void*, EMPTYARG ) |
| { |
| Gallery* pGal = pThm->GetParent(); |
| const sal_uLong nId = GetId(); |
| sal_Bool bDifferentThemeExists = sal_False; |
| |
| for( sal_uLong i = 0, nCount = pGal->GetThemeCount(); i < nCount && !bDifferentThemeExists; i++ ) |
| { |
| const GalleryThemeEntry* pInfo = pGal->GetThemeInfo( i ); |
| |
| if( ( pInfo->GetId() == nId ) && ( pInfo->GetThemeName() != pThm->GetName() ) ) |
| { |
| String aStr( CUI_RES( RID_SVXSTR_GALLERY_ID_EXISTS ) ); |
| |
| aStr += String( RTL_CONSTASCII_USTRINGPARAM( " (" ) ); |
| aStr += pInfo->GetThemeName(); |
| aStr += ')'; |
| |
| InfoBox aBox( this, aStr ); |
| aBox.Execute(); |
| aLbResName.GrabFocus(); |
| bDifferentThemeExists = sal_True; |
| } |
| } |
| |
| if( !bDifferentThemeExists ) |
| EndDialog( RET_OK ); |
| |
| return 0L; |
| } |
| |
| |
| // -------------------------- |
| // - GalleryThemeProperties - |
| // -------------------------- |
| |
| GalleryThemeProperties::GalleryThemeProperties( Window* pParent, ExchangeData* _pData, SfxItemSet* pItemSet ) : |
| SfxTabDialog ( pParent, CUI_RES( RID_SVXTABDLG_GALLERYTHEME ), pItemSet ), |
| pData ( _pData ) |
| { |
| FreeResource(); |
| |
| AddTabPage( RID_SVXTABPAGE_GALLERY_GENERAL, TPGalleryThemeGeneral::Create, 0 ); |
| AddTabPage( RID_SVXTABPAGE_GALLERYTHEME_FILES, TPGalleryThemeProperties::Create, 0 ); |
| |
| if( pData->pTheme->IsReadOnly() ) |
| RemoveTabPage( RID_SVXTABPAGE_GALLERYTHEME_FILES ); |
| |
| String aText( GetText() ); |
| |
| aText += pData->pTheme->GetName(); |
| |
| if( pData->pTheme->IsReadOnly() ) |
| aText += String( CUI_RES( RID_SVXSTR_GALLERY_READONLY ) ); |
| |
| SetText( aText ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void GalleryThemeProperties::PageCreated( sal_uInt16 nId, SfxTabPage &rPage ) |
| { |
| if( RID_SVXTABPAGE_GALLERY_GENERAL == nId ) |
| ( (TPGalleryThemeGeneral&) rPage ).SetXChgData( pData ); |
| else |
| ( (TPGalleryThemeProperties&) rPage ).SetXChgData( pData ); |
| } |
| |
| // ------------------------- |
| // - TPGalleryThemeGeneral - |
| // ------------------------- |
| |
| TPGalleryThemeGeneral::TPGalleryThemeGeneral( Window* pParent, const SfxItemSet& rSet ) : |
| SfxTabPage ( pParent, CUI_RES( RID_SVXTABPAGE_GALLERY_GENERAL ), rSet ), |
| aFiMSImage ( this, CUI_RES( FI_MS_IMAGE ) ), |
| aEdtMSName ( this, CUI_RES( EDT_MS_NAME ) ), |
| aFlMSGeneralFirst ( this, CUI_RES( FL_MS_GENERAL_FIRST ) ), |
| aFtMSType ( this, CUI_RES( FT_MS_TYPE ) ), |
| aFtMSShowType ( this, CUI_RES( FT_MS_SHOW_TYPE ) ), |
| aFtMSPath ( this, CUI_RES( FT_MS_PATH ) ), |
| aFtMSShowPath ( this, CUI_RES( FT_MS_SHOW_PATH ) ), |
| aFtMSContent ( this, CUI_RES( FT_MS_CONTENT ) ), |
| aFtMSShowContent ( this, CUI_RES( FT_MS_SHOW_CONTENT ) ), |
| aFlMSGeneralSecond ( this, CUI_RES( FL_MS_GENERAL_SECOND ) ), |
| aFtMSChangeDate ( this, CUI_RES( FT_MS_CHANGEDATE ) ), |
| aFtMSShowChangeDate ( this, CUI_RES( FT_MS_SHOW_CHANGEDATE ) ) |
| { |
| FreeResource(); |
| |
| String aAccName(SVX_RES(RID_SVXSTR_GALLERY_THEMENAME)); |
| aEdtMSName.SetAccessibleName(aAccName); |
| aFiMSImage.SetAccessibleName(aAccName); |
| aEdtMSName.SetAccessibleRelationLabeledBy( &aFiMSImage ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void TPGalleryThemeGeneral::SetXChgData( ExchangeData* _pData ) |
| { |
| pData = _pData; |
| |
| GalleryTheme* pThm = pData->pTheme; |
| String aOutStr( String::CreateFromInt32( pThm->GetObjectCount() ) ); |
| String aObjStr( CUI_RES( RID_SVXSTR_GALLERYPROPS_OBJECT ) ); |
| String aAccess; |
| String aType( SVX_RES( RID_SVXSTR_GALLERYPROPS_GALTHEME ) ); |
| sal_Bool bReadOnly = pThm->IsReadOnly() && !pThm->IsImported(); |
| |
| aEdtMSName.SetHelpId( HID_GALLERY_EDIT_MSNAME ); |
| aEdtMSName.SetText( pThm->GetName() ); |
| aEdtMSName.SetReadOnly( bReadOnly ); |
| |
| if( bReadOnly ) |
| aEdtMSName.Disable(); |
| else |
| aEdtMSName.Enable(); |
| |
| if( pThm->IsReadOnly() ) |
| aType += String( CUI_RES( RID_SVXSTR_GALLERY_READONLY ) ); |
| |
| aFtMSShowType.SetText( aType ); |
| aFtMSShowPath.SetText( pThm->GetSdgURL().GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ) ); |
| |
| // Ein- oder Mehrzahl? |
| if ( 1 == pThm->GetObjectCount() ) |
| aObjStr = aObjStr.GetToken( 0 ); |
| else |
| aObjStr = aObjStr.GetToken( 1 ); |
| |
| aOutStr += ' '; |
| aOutStr += aObjStr; |
| |
| aFtMSShowContent.SetText( aOutStr ); |
| |
| // get locale wrapper (singleton) |
| const LocaleDataWrapper& aLocaleData = SvtSysLocale().GetLocaleData(); |
| |
| // ChangeDate/Time |
| aAccess = aLocaleData.getDate( pData->aThemeChangeDate ); |
| aAccess += String( RTL_CONSTASCII_USTRINGPARAM( ", " ) ); |
| aAccess += aLocaleData.getTime( pData->aThemeChangeTime ); |
| aFtMSShowChangeDate.SetText( aAccess ); |
| |
| // Image setzen |
| sal_uInt16 nId; |
| |
| if( pThm->IsImported() ) |
| nId = RID_SVXBMP_THEME_IMPORTED_BIG; |
| else if( pThm->IsReadOnly() ) |
| nId = RID_SVXBMP_THEME_READONLY_BIG; |
| else if( pThm->IsDefault() ) |
| nId = RID_SVXBMP_THEME_DEFAULT_BIG; |
| else |
| nId = RID_SVXBMP_THEME_NORMAL_BIG; |
| |
| aFiMSImage.SetImage( Image( Bitmap( CUI_RES( nId ) ), COL_LIGHTMAGENTA ) ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool TPGalleryThemeGeneral::FillItemSet( SfxItemSet& /*rSet*/ ) |
| { |
| pData->aEditedTitle = aEdtMSName.GetText(); |
| return sal_True; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| SfxTabPage* TPGalleryThemeGeneral::Create( Window* pParent, const SfxItemSet& rSet ) |
| { |
| return new TPGalleryThemeGeneral( pParent, rSet ); |
| } |
| |
| // ---------------------------- |
| // - TPGalleryThemeProperties - |
| // ---------------------------- |
| |
| TPGalleryThemeProperties::TPGalleryThemeProperties( Window* pWindow, const SfxItemSet& rSet ) : |
| SfxTabPage ( pWindow, CUI_RES( RID_SVXTABPAGE_GALLERYTHEME_FILES ), rSet ), |
| aFtFileType ( this, CUI_RES(FT_FILETYPE ) ), |
| aCbbFileType ( this, CUI_RES(CBB_FILETYPE ) ), |
| aLbxFound ( this, CUI_RES(LBX_FOUND ) ), |
| aBtnSearch ( this, CUI_RES(BTN_SEARCH ) ), |
| aBtnTake ( this, CUI_RES(BTN_TAKE ) ), |
| aBtnTakeAll ( this, CUI_RES(BTN_TAKEALL ) ), |
| aCbxPreview ( this, CUI_RES(CBX_PREVIEW ) ), |
| aWndPreview ( this, CUI_RES( WND_BRSPRV ) ), |
| nCurFilterPos (0), |
| nFirstExtFilterPos (0), |
| bEntriesFound (sal_False), |
| bInputAllowed (sal_True), |
| bSearchRecursive (sal_False), |
| xDialogListener ( new ::svt::DialogClosedListener() ) |
| { |
| FreeResource(); |
| |
| xDialogListener->SetDialogClosedLink( LINK( this, TPGalleryThemeProperties, DialogClosedHdl ) ); |
| aLbxFound.SetAccessibleName(String(SVX_RES(RID_SVXSTR_GALLERY_FILESFOUND))); |
| aWndPreview.SetAccessibleName(aCbxPreview.GetText()); |
| aLbxFound.SetAccessibleRelationLabeledBy(&aLbxFound); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void TPGalleryThemeProperties::SetXChgData( ExchangeData* _pData ) |
| { |
| pData = _pData; |
| |
| aPreviewTimer.SetTimeoutHdl( LINK( this, TPGalleryThemeProperties, PreviewTimerHdl ) ); |
| aPreviewTimer.SetTimeout( 500 ); |
| aBtnSearch.SetClickHdl(LINK(this, TPGalleryThemeProperties, ClickSearchHdl)); |
| aBtnTake.SetClickHdl(LINK(this, TPGalleryThemeProperties, ClickTakeHdl)); |
| aBtnTakeAll.SetClickHdl(LINK(this, TPGalleryThemeProperties, ClickTakeAllHdl)); |
| aCbxPreview.SetClickHdl(LINK(this, TPGalleryThemeProperties, ClickPreviewHdl)); |
| aCbbFileType.SetSelectHdl(LINK(this, TPGalleryThemeProperties, SelectFileTypeHdl)); |
| aCbbFileType.EnableDDAutoWidth( sal_False ); |
| aLbxFound.SetDoubleClickHdl(LINK(this, TPGalleryThemeProperties, DClickFoundHdl)); |
| aLbxFound.SetSelectHdl(LINK(this, TPGalleryThemeProperties, SelectFoundHdl)); |
| aLbxFound.InsertEntry(String(CUI_RES(RID_SVXSTR_GALLERY_NOFILES))); |
| aLbxFound.Show(); |
| |
| FillFilterList(); |
| |
| aBtnTake.Enable(); |
| aBtnTakeAll.Disable(); |
| aCbxPreview.Disable(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void TPGalleryThemeProperties::StartSearchFiles( const String& _rFolderURL, short _nDlgResult ) |
| { |
| if ( RET_OK == _nDlgResult ) |
| { |
| aURL = INetURLObject( _rFolderURL ); |
| bSearchRecursive = sal_True; // UI choice no longer possible, windows file picker allows no user controls |
| SearchFiles(); |
| } |
| |
| nCurFilterPos = aCbbFileType.GetEntryPos( aCbbFileType.GetText() ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| TPGalleryThemeProperties::~TPGalleryThemeProperties() |
| { |
| xMediaPlayer.clear(); |
| xDialogListener.clear(); |
| |
| for( String* pStr = aFoundList.First(); pStr; pStr = aFoundList.Next() ) |
| delete pStr; |
| |
| for( void* pEntry = aFilterEntryList.First(); pEntry; pEntry = aFilterEntryList.Next() ) |
| delete (FilterEntry*) pEntry; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| SfxTabPage* TPGalleryThemeProperties::Create( Window* pParent, const SfxItemSet& rSet ) |
| { |
| return new TPGalleryThemeProperties( pParent, rSet ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| ::rtl::OUString TPGalleryThemeProperties::addExtension( const ::rtl::OUString& _rDisplayText, const ::rtl::OUString& _rExtension ) |
| { |
| ::rtl::OUString sAllFilter( RTL_CONSTASCII_USTRINGPARAM( "(*.*)" ) ); |
| ::rtl::OUString sOpenBracket( RTL_CONSTASCII_USTRINGPARAM( " (" ) ); |
| ::rtl::OUString sCloseBracket( RTL_CONSTASCII_USTRINGPARAM( ")" ) ); |
| ::rtl::OUString sRet = _rDisplayText; |
| |
| if ( sRet.indexOf( sAllFilter ) == -1 ) |
| { |
| String sExt = _rExtension; |
| sRet += sOpenBracket; |
| sRet += sExt; |
| sRet += sCloseBracket; |
| } |
| return sRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void TPGalleryThemeProperties::FillFilterList() |
| { |
| GraphicFilter* pFilter = GraphicFilter::GetGraphicFilter(); |
| String aExt; |
| String aName; |
| FilterEntry* pFilterEntry; |
| FilterEntry* pTestEntry; |
| sal_uInt16 i, nKeyCount; |
| sal_Bool bInList; |
| |
| // graphic filters |
| for( i = 0, nKeyCount = pFilter->GetImportFormatCount(); i < nKeyCount; i++ ) |
| { |
| aExt = pFilter->GetImportFormatShortName( i ); |
| aName = pFilter->GetImportFormatName( i ); |
| pTestEntry = (FilterEntry*) aFilterEntryList.First(); |
| bInList = sal_False; |
| |
| String aExtensions; |
| int j = 0; |
| String sWildcard; |
| while( sal_True ) |
| { |
| sWildcard = pFilter->GetImportWildcard( i, j++ ); |
| if ( !sWildcard.Len() ) |
| break; |
| if ( aExtensions.Search( sWildcard ) == STRING_NOTFOUND ) |
| { |
| if ( aExtensions.Len() ) |
| aExtensions += sal_Unicode(';'); |
| aExtensions += sWildcard; |
| } |
| } |
| aName = addExtension( aName, aExtensions ); |
| |
| while( pTestEntry ) |
| { |
| if ( pTestEntry->aFilterName == aExt ) |
| { |
| bInList = sal_True; |
| break; |
| } |
| pTestEntry = (FilterEntry*) aFilterEntryList.Next(); |
| } |
| if ( !bInList ) |
| { |
| pFilterEntry = new FilterEntry; |
| pFilterEntry->aFilterName = aExt; |
| aFilterEntryList.Insert( pFilterEntry, aCbbFileType.InsertEntry( aName ) ); |
| } |
| } |
| |
| // media filters |
| static const ::rtl::OUString aWildcard( RTL_CONSTASCII_USTRINGPARAM( "*." ) ); |
| ::avmedia::FilterNameVector aFilters; |
| const ::rtl::OUString aSeparator( RTL_CONSTASCII_USTRINGPARAM( ";" ) ); |
| ::rtl::OUString aAllTypes; |
| |
| ::avmedia::MediaWindow::getMediaFilters( aFilters ); |
| |
| for( unsigned long l = 0; l < aFilters.size(); ++l ) |
| { |
| for( sal_Int32 nIndex = 0; nIndex >= 0; ) |
| { |
| ::rtl::OUString aFilterWildcard( aWildcard ); |
| |
| pFilterEntry = new FilterEntry; |
| pFilterEntry->aFilterName = aFilters[ l ].second.getToken( 0, ';', nIndex ); |
| nFirstExtFilterPos = aCbbFileType.InsertEntry( addExtension( aFilters[ l ].first, |
| aFilterWildcard += pFilterEntry->aFilterName ) ); |
| aFilterEntryList.Insert( pFilterEntry, nFirstExtFilterPos ); |
| } |
| } |
| |
| // 'All' filters |
| String aExtensions; |
| |
| // graphic filters |
| for ( i = 0; i < nKeyCount; ++i ) |
| { |
| int j = 0; |
| String sWildcard; |
| while( sal_True ) |
| { |
| sWildcard = pFilter->GetImportWildcard( i, j++ ); |
| if ( !sWildcard.Len() ) |
| break; |
| if ( aExtensions.Search( sWildcard ) == STRING_NOTFOUND ) |
| { |
| if ( aExtensions.Len() ) |
| aExtensions += sal_Unicode( ';' ); |
| |
| aExtensions += sWildcard; |
| } |
| } |
| } |
| |
| // media filters |
| for( unsigned long k = 0; k < aFilters.size(); ++k ) |
| { |
| for( sal_Int32 nIndex = 0; nIndex >= 0; ) |
| { |
| if ( aExtensions.Len() ) |
| aExtensions += sal_Unicode( ';' ); |
| ( aExtensions += String( aWildcard ) ) += String( aFilters[ k ].second.getToken( 0, ';', nIndex ) ); |
| } |
| } |
| |
| #if defined(WNT) |
| if ( aExtensions.Len() > 240 ) |
| aExtensions = DEFINE_CONST_UNICODE( "*.*" ); |
| #endif |
| |
| pFilterEntry = new FilterEntry; |
| pFilterEntry->aFilterName = String( CUI_RES( RID_SVXSTR_GALLERY_ALLFILES ) ); |
| pFilterEntry->aFilterName = addExtension( pFilterEntry->aFilterName, aExtensions ); |
| aFilterEntryList.Insert(pFilterEntry, aCbbFileType. InsertEntry( pFilterEntry->aFilterName, 0 ) ); |
| |
| aCbbFileType.SetText( pFilterEntry->aFilterName ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, SelectFileTypeHdl, void *, EMPTYARG ) |
| { |
| String aText( aCbbFileType.GetText() ); |
| |
| if( bInputAllowed && ( aLastFilterName != aText ) ) |
| { |
| aLastFilterName = aText; |
| |
| if( QueryBox( this, WB_YES_NO, String( CUI_RES( RID_SVXSTR_GALLERY_SEARCH ) ) ).Execute() == RET_YES ) |
| SearchFiles(); |
| } |
| |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void TPGalleryThemeProperties::SearchFiles() |
| { |
| SearchProgress* pProgress = new SearchProgress( this, aURL ); |
| |
| for( String* pStr = aFoundList.First(); pStr; pStr = aFoundList.Next() ) |
| delete pStr; |
| |
| aFoundList.Clear(); |
| aLbxFound.Clear(); |
| |
| pProgress->SetFileType( aCbbFileType.GetText() ); |
| pProgress->SetDirectory( rtl::OUString() ); |
| pProgress->Update(); |
| |
| pProgress->StartExecuteModal( LINK( this, TPGalleryThemeProperties, EndSearchProgressHdl ) ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, ClickCloseBrowserHdl, void *, EMPTYARG ) |
| { |
| if( bInputAllowed ) |
| aPreviewTimer.Stop(); |
| |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, ClickSearchHdl, void *, EMPTYARG ) |
| { |
| if( bInputAllowed ) |
| { |
| try |
| { |
| // setup folder picker |
| ::com::sun::star::uno::Reference< XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() ); |
| if( xMgr.is() ) |
| { |
| xFolderPicker = ::com::sun::star::uno::Reference< XFolderPicker >( |
| xMgr->createInstance( OUString::createFromAscii( "com.sun.star.ui.dialogs.FolderPicker" )), UNO_QUERY ); |
| |
| if ( xFolderPicker.is() ) |
| { |
| String aDlgPathName( SvtPathOptions().GetGraphicPath() ); |
| xFolderPicker->setDisplayDirectory(aDlgPathName); |
| |
| aPreviewTimer.Stop(); |
| |
| ::com::sun::star::uno::Reference< XAsynchronousExecutableDialog > xAsyncDlg( xFolderPicker, UNO_QUERY ); |
| if ( xAsyncDlg.is() ) |
| xAsyncDlg->startExecuteModal( xDialogListener.get() ); |
| else |
| { |
| if( xFolderPicker->execute() == RET_OK ) |
| { |
| aURL = INetURLObject( xFolderPicker->getDirectory() ); |
| bSearchRecursive = sal_True; // UI choice no longer possible, windows file picker allows no user controls |
| SearchFiles(); |
| } |
| |
| nCurFilterPos = aCbbFileType.GetEntryPos( aCbbFileType.GetText() ); |
| } |
| } |
| } |
| } |
| catch(IllegalArgumentException) |
| { |
| #ifdef DBG_UTIL |
| DBG_ERROR( "Folder picker failed with illegal arguments" ); |
| #endif |
| } |
| } |
| |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void TPGalleryThemeProperties::TakeFiles() |
| { |
| if( aLbxFound.GetSelectEntryCount() || ( bTakeAll && bEntriesFound ) ) |
| { |
| TakeProgress* pTakeProgress = new TakeProgress( this ); |
| pTakeProgress->Update(); |
| |
| pTakeProgress->StartExecuteModal( |
| Link() /* no postprocessing needed, pTakeProgress |
| will be deleted in TakeProgress::CleanupHdl */ ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, ClickPreviewHdl, void *, EMPTYARG ) |
| { |
| if ( bInputAllowed ) |
| { |
| aPreviewTimer.Stop(); |
| aPreviewString.Erase(); |
| |
| if( !aCbxPreview.IsChecked() ) |
| { |
| xMediaPlayer.clear(); |
| aWndPreview.SetGraphic( Graphic() ); |
| aWndPreview.Invalidate(); |
| } |
| else |
| DoPreview(); |
| } |
| |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void TPGalleryThemeProperties::DoPreview() |
| { |
| String aString( aLbxFound.GetSelectEntry() ); |
| |
| if( aString != aPreviewString ) |
| { |
| INetURLObject _aURL( *aFoundList.GetObject( aLbxFound.GetEntryPos( aString ) ) ); |
| bInputAllowed = sal_False; |
| |
| if ( !aWndPreview.SetGraphic( _aURL ) ) |
| { |
| GetParent()->LeaveWait(); |
| ErrorHandler::HandleError( ERRCODE_IO_NOTEXISTSPATH ); |
| GetParent()->EnterWait(); |
| } |
| else if( ::avmedia::MediaWindow::isMediaURL( _aURL.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ) ) ) |
| { |
| xMediaPlayer = ::avmedia::MediaWindow::createPlayer( _aURL.GetMainURL( INetURLObject::NO_DECODE ) ); |
| if( xMediaPlayer.is() ) |
| xMediaPlayer->start(); |
| } |
| |
| bInputAllowed = sal_True; |
| aPreviewString = aString; |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, ClickTakeHdl, void*, EMPTYARG ) |
| { |
| if( bInputAllowed ) |
| { |
| aPreviewTimer.Stop(); |
| |
| if( !aLbxFound.GetSelectEntryCount() || !bEntriesFound ) |
| { |
| SvxOpenGraphicDialog aDlg(String( RTL_CONSTASCII_USTRINGPARAM( "Gallery" ) ) ); |
| aDlg.EnableLink(sal_False); |
| aDlg.AsLink(sal_False); |
| |
| if( !aDlg.Execute() ) |
| pData->pTheme->InsertURL( INetURLObject( aDlg.GetPath() ) ); |
| } |
| else |
| { |
| bTakeAll = sal_False; |
| TakeFiles(); |
| } |
| } |
| |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, ClickTakeAllHdl, void *, EMPTYARG ) |
| { |
| if( bInputAllowed ) |
| { |
| aPreviewTimer.Stop(); |
| bTakeAll = sal_True; |
| TakeFiles(); |
| } |
| |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, SelectFoundHdl, void *, EMPTYARG ) |
| { |
| if( bInputAllowed ) |
| { |
| sal_Bool bPreviewPossible = sal_False; |
| |
| aPreviewTimer.Stop(); |
| |
| if( bEntriesFound ) |
| { |
| if( aLbxFound.GetSelectEntryCount() == 1 ) |
| { |
| aCbxPreview.Enable(); |
| bPreviewPossible = sal_True; |
| } |
| else |
| aCbxPreview.Disable(); |
| |
| if( aFoundList.Count() ) |
| aBtnTakeAll.Enable(); |
| else |
| aBtnTakeAll.Disable(); |
| } |
| |
| if( bPreviewPossible && aCbxPreview.IsChecked() ) |
| aPreviewTimer.Start(); |
| } |
| |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, DClickFoundHdl, void *, EMPTYARG ) |
| { |
| if( bInputAllowed ) |
| { |
| aPreviewTimer.Stop(); |
| |
| return (aLbxFound.GetSelectEntryCount() == 1 && bEntriesFound) ? |
| ClickTakeHdl(NULL) : 0; |
| } |
| else |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, PreviewTimerHdl, void *, EMPTYARG ) |
| { |
| aPreviewTimer.Stop(); |
| DoPreview(); |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, EndSearchProgressHdl, SearchProgress *, EMPTYARG ) |
| { |
| if( aFoundList.Count() ) |
| { |
| aLbxFound.SelectEntryPos( 0 ); |
| aBtnTakeAll.Enable(); |
| aCbxPreview.Enable(); |
| bEntriesFound = sal_True; |
| } |
| else |
| { |
| aLbxFound.InsertEntry( String( CUI_RES( RID_SVXSTR_GALLERY_NOFILES ) ) ); |
| aBtnTakeAll.Disable(); |
| aCbxPreview.Disable(); |
| bEntriesFound = sal_False; |
| } |
| return 0L; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK( TPGalleryThemeProperties, DialogClosedHdl, ::com::sun::star::ui::dialogs::DialogClosedEvent*, pEvt ) |
| { |
| DBG_ASSERT( xFolderPicker.is() == sal_True, "TPGalleryThemeProperties::DialogClosedHdl(): no folder picker" ); |
| |
| String sURL = String( xFolderPicker->getDirectory() ); |
| StartSearchFiles( sURL, pEvt->DialogResult ); |
| |
| return 0L; |
| } |
| |