xref: /aoo41x/main/cui/source/dialogs/cuigaldlg.cxx (revision cdf0e10c)

/*************************************************************************
 *
 * 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.
 *
 ************************************************************************/

// 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;
}