/**************************************************************
 * 
 * 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 <stdlib.h>
#include <time.h>

#ifndef _HELP_HXX //autogen
#include <vcl/help.hxx>
#endif
#ifndef _MSGBOX_HXX //autogen
#include <vcl/msgbox.hxx>
#endif
#include <vcl/decoview.hxx>
#include <vcl/toolbox.hxx>
#include <vcl/scrbar.hxx>

//added for issue73355
//#ifndef _SV_SVDATA_HXX
//#include <vcl/svdata.hxx>
//#endif
//issue73355 ends

#include <sfx2/app.hxx>
#include <sfx2/sfxdlg.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/viewsh.hxx>
#include <sfx2/msg.hxx>
#include <sfx2/msgpool.hxx>
#include <sfx2/mnumgr.hxx>
#include <sfx2/minfitem.hxx>
#include <sfx2/objsh.hxx>
#include <sfx2/request.hxx>
#include <sfx2/filedlghelper.hxx>
#include <svl/stritem.hxx>
#include <svtools/miscopt.hxx>
#include <tools/diagnose_ex.h>
#include <toolkit/unohlp.hxx>

#include <algorithm>
//add
#include <cuires.hrc>
#include "cfg.hrc"
#include "helpid.hrc"

#include "acccfg.hxx"
#include "cfg.hxx"
#include "eventdlg.hxx"
#include <dialmgr.hxx>

#include <comphelper/documentinfo.hxx>
#include <comphelper/processfactory.hxx>
#ifndef _UNOTOOLS_CONFIGMGR_HXX_
#include <unotools/configmgr.hxx>
#endif
#include <com/sun/star/ui/ItemType.hpp>
#include <com/sun/star/ui/ItemStyle.hpp>
#include <com/sun/star/ui/XModuleUIConfigurationManagerSupplier.hpp>
#include <com/sun/star/frame/XController.hpp>
#include <com/sun/star/frame/XDesktop.hpp>
#include <com/sun/star/ui/XUIConfiguration.hpp>
#include <com/sun/star/ui/XUIConfigurationListener.hpp>
#include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
#include <com/sun/star/ui/XUIConfigurationPersistence.hpp>
#include <com/sun/star/ui/XUIConfigurationStorage.hpp>
#include <com/sun/star/ui/XModuleUIConfigurationManager.hpp>
#include <com/sun/star/ui/XUIElement.hpp>
#ifndef _COM_SUN_STAR_UI_UIElementType_HPP_
#include <com/sun/star/ui/UIElementType.hpp>
#endif
#include <com/sun/star/ui/ImageType.hpp>
#include <com/sun/star/frame/XLayoutManager.hpp>
#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
#include "com/sun/star/ui/dialogs/TemplateDescription.hpp"
#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
#include <com/sun/star/frame/XFramesSupplier.hpp>
#include <com/sun/star/frame/XFrames.hpp>
#include <com/sun/star/frame/FrameSearchFlag.hpp>
#include <com/sun/star/embed/ElementModes.hpp>

#include "dlgname.hxx"

#define PRTSTR(x) rtl::OUStringToOString(x, RTL_TEXTENCODING_ASCII_US).pData->buffer

#define ENTRY_HEIGHT 16

static const char ITEM_DESCRIPTOR_COMMANDURL[]  = "CommandURL";
static const char ITEM_DESCRIPTOR_CONTAINER[]   = "ItemDescriptorContainer";
static const char ITEM_DESCRIPTOR_LABEL[]       = "Label";
static const char ITEM_DESCRIPTOR_TYPE[]        = "Type";
static const char ITEM_DESCRIPTOR_STYLE[]       = "Style";
static const char ITEM_DESCRIPTOR_ISVISIBLE[]   = "IsVisible";
static const char ITEM_DESCRIPTOR_RESOURCEURL[] = "ResourceURL";
static const char ITEM_DESCRIPTOR_UINAME[]		= "UIName";

static const char ITEM_MENUBAR_URL[] = "private:resource/menubar/menubar";
static const char ITEM_TOOLBAR_URL[] = "private:resource/toolbar/";

static const char CUSTOM_TOOLBAR_STR[] = "custom_toolbar_";
static const char CUSTOM_MENU_STR[] = "vnd.openoffice.org:CustomMenu";

static const char __FAR_DATA pSeparatorStr[] =
	"----------------------------------";
static const char __FAR_DATA pMenuSeparatorStr[]	= " | ";

#ifdef _MSC_VER
#pragma warning (disable:4355)
#endif

using rtl::OUString;
namespace css = com::sun::star;
namespace uno = com::sun::star::uno;
namespace frame = com::sun::star::frame;
namespace lang = com::sun::star::lang;
namespace container = com::sun::star::container;
namespace beans = com::sun::star::beans;
namespace graphic = com::sun::star::graphic;

#if OSL_DEBUG_LEVEL > 1

void printPropertySet(
	const OUString& prefix,
	const uno::Reference< beans::XPropertySet >& xPropSet )
{
	uno::Reference< beans::XPropertySetInfo > xPropSetInfo =
		xPropSet->getPropertySetInfo();

	uno::Sequence< beans::Property > aPropDetails =
		xPropSetInfo->getProperties();

	OSL_TRACE("printPropertySet: %d properties", aPropDetails.getLength());

	for ( sal_Int32 i = 0; i < aPropDetails.getLength(); i++ )
	{
		OUString tmp;
		sal_Int32 ival;

		uno::Any a = xPropSet->getPropertyValue( aPropDetails[i].Name );

		if ( ( a >>= tmp ) /* && tmp.getLength() != 0 */ )
		{
			OSL_TRACE("%s: Got property: %s = %s",
				PRTSTR(prefix), PRTSTR(aPropDetails[i].Name), PRTSTR(tmp));
		}
		else if ( ( a >>= ival ) )
		{
			OSL_TRACE("%s: Got property: %s = %d",
				PRTSTR(prefix), PRTSTR(aPropDetails[i].Name), PRTSTR(tmp));
		}
		else
		{
			OSL_TRACE("%s: Got property: %s of type %s",
				PRTSTR(prefix), PRTSTR(aPropDetails[i].Name), PRTSTR(a.getValueTypeName()));
		}
	}
}

void printProperties(
	const OUString& prefix,
	const uno::Sequence< beans::PropertyValue >& aProp )
{
	for ( sal_Int32 i = 0; i < aProp.getLength(); i++ )
	{
		OUString tmp;

		aProp[i].Value >>= tmp;

		OSL_TRACE("%s: Got property: %s = %s",
			PRTSTR(prefix), PRTSTR(aProp[i].Name), PRTSTR(tmp));
	}
}

void printEntries(SvxEntries* entries)
{
	SvxEntries::const_iterator iter = entries->begin();

	for ( ; iter != entries->end(); iter++ )
	{
		SvxConfigEntry* entry = *iter;

        OSL_TRACE("printEntries: %s", PRTSTR(entry->GetName()));
	}
}

#endif

OUString
stripHotKey( const OUString& str )
{
	sal_Int32 index = str.indexOf( '~' );
	if ( index == -1 )
	{
		return str;
	}
	else
	{
		return str.replaceAt( index, 1, OUString() );
	}
}

OUString replaceSaveInName(
	const OUString& rMessage,
	const OUString& rSaveInName )
{
	OUString name;
	OUString placeholder = OUString::createFromAscii( "%SAVE IN SELECTION%" );

	sal_Int32 pos = rMessage.indexOf( placeholder );

	if ( pos != -1 )
	{
		name = rMessage.replaceAt(
			pos, placeholder.getLength(), rSaveInName );
	}
	else
	{
		// don't change the message
	}

	return name;
}

OUString
replaceSixteen( const OUString& str, sal_Int32 nReplacement )
{
	OUString result( str );
	OUString sixteen = OUString::valueOf( (sal_Int32)16 );
	OUString expected = OUString::valueOf( nReplacement );

	sal_Int32 len = sixteen.getLength();
	sal_Int32 index = result.indexOf( sixteen );

	while ( index != -1 )
	{
		result = result.replaceAt( index, len, expected );
		index = result.indexOf( sixteen, index );
	}

	return result;
}

OUString
generateCustomName(
	const OUString& prefix,
	SvxEntries* entries,
	sal_Int32 suffix = 1 )
{
	// find and replace the %n placeholder in the prefix string
	OUString name;
	OUString placeholder = OUString::createFromAscii( "%n" );

	sal_Int32 pos = prefix.indexOf(
		OUString::createFromAscii( "%n" ) );

	if ( pos != -1 )
	{
		name = prefix.replaceAt(
			pos, placeholder.getLength(), OUString::valueOf( suffix ) );
	}
	else
	{
		// no placeholder found so just append the suffix
		name = prefix + OUString::valueOf( suffix );
	}

	// now check is there is an already existing entry with this name
	SvxEntries::const_iterator iter = entries->begin();

	SvxConfigEntry* pEntry;
	while ( iter != entries->end() )
	{
		pEntry = *iter;

		if ( name.equals( pEntry->GetName() ) )
		{
			break;
		}
		iter++;
	}

	if ( iter != entries->end() )
	{
		// name already exists so try the next number up
		return generateCustomName( prefix, entries, ++suffix );
	}

	return name;
}

sal_uInt32 generateRandomValue()
{
    srand( unsigned( time( NULL ) ));
    return sal_uInt32( rand() );
}

OUString
generateCustomURL(
	SvxEntries* entries )
{
	OUString url = OUString::createFromAscii( ITEM_TOOLBAR_URL );
	url += OUString::createFromAscii( CUSTOM_TOOLBAR_STR );

    // use a random number to minimize possible clash with existing custom toolbars
    url += OUString::valueOf( sal_Int64( generateRandomValue() ), 16 );

	// now check is there is an already existing entry with this url
	SvxEntries::const_iterator iter = entries->begin();

	SvxConfigEntry* pEntry;
	while ( iter != entries->end() )
	{
		pEntry = *iter;

		if ( url.equals( pEntry->GetCommand() ) )
		{
			break;
		}
		iter++;
	}

	if ( iter != entries->end() )
	{
		// url already exists so try the next number up
		return generateCustomURL( entries );
	}

	return url;
}

OUString
generateCustomMenuURL(
	SvxEntries* entries,
	sal_Int32 suffix = 1 )
{
	OUString url = OUString::createFromAscii( CUSTOM_MENU_STR );
	url += OUString::valueOf( suffix );

	// now check is there is an already existing entry with this url
	SvxEntries::const_iterator iter = entries->begin();

	SvxConfigEntry* pEntry;
	while ( iter != entries->end() )
	{
		pEntry = *iter;

		if ( url.equals( pEntry->GetCommand() ) )
		{
			break;
		}
		iter++;
	}

	if ( iter != entries->end() )
	{
		// url already exists so try the next number up
		return generateCustomMenuURL( entries, ++suffix );
	}

	return url;
}

static sal_Int16 theImageType =
	css::ui::ImageType::COLOR_NORMAL |
	css::ui::ImageType::SIZE_DEFAULT;

void InitImageType()
{
	theImageType =
		css::ui::ImageType::COLOR_NORMAL |
		css::ui::ImageType::SIZE_DEFAULT;

    if ( SvtMiscOptions().AreCurrentSymbolsLarge() )
	{
        theImageType |= css::ui::ImageType::SIZE_LARGE;
	}

	Window* topwin = Application::GetActiveTopWindow();
	if ( topwin != NULL &&
		 topwin->GetSettings().GetStyleSettings().GetHighContrastMode() )
	{
        theImageType |= css::ui::ImageType::COLOR_HIGHCONTRAST;
	}
}

sal_Int16 GetImageType()
{
	return theImageType;
}

void RemoveEntry( SvxEntries* pEntries, SvxConfigEntry* pChildEntry )
{
	SvxEntries::iterator iter = pEntries->begin();

	while ( iter != pEntries->end() )
	{
		if ( pChildEntry == *iter )
		{
			pEntries->erase( iter );
			break;
		}
		iter++;
	}
}

bool
SvxConfigPage::CanConfig( const OUString& aModuleId )
{
	OSL_TRACE("SupportsDocumentConfig: %s", PRTSTR(aModuleId));

	if  (  aModuleId.equalsAscii( "com.sun.star.script.BasicIDE" )
        || aModuleId.equalsAscii( "com.sun.star.frame.Bibliography" )
        )
    {
		return sal_False;
	}
	return sal_True;
}

OUString GetModuleName( const OUString& aModuleId )
{
    if ( aModuleId.equalsAscii( "com.sun.star.text.TextDocument" ) ||
		 aModuleId.equalsAscii( "com.sun.star.text.GlobalDocument" ) )
		return OUString::createFromAscii("Writer");
	else if ( aModuleId.equalsAscii( "com.sun.star.text.WebDocument" ) )
		return OUString::createFromAscii("Writer/Web");
	else if ( aModuleId.equalsAscii( "com.sun.star.drawing.DrawingDocument" ) )
		return OUString::createFromAscii("Draw");
	else if ( aModuleId.equalsAscii( "com.sun.star.presentation.PresentationDocument" ) )
		return OUString::createFromAscii("Impress");
	else if ( aModuleId.equalsAscii( "com.sun.star.sheet.SpreadsheetDocument" ) )
		return OUString::createFromAscii("Calc");
	else if ( aModuleId.equalsAscii( "com.sun.star.script.BasicIDE" ) )
		return OUString::createFromAscii("Basic");
	else if ( aModuleId.equalsAscii( "com.sun.star.formula.FormulaProperties" ) )
		return OUString::createFromAscii("Math");
    else if ( aModuleId.equalsAscii( "com.sun.star.sdb.RelationDesign" ) )
        return OUString::createFromAscii("Relation Design");
    else if ( aModuleId.equalsAscii( "com.sun.star.sdb.QueryDesign" ) )
        return OUString::createFromAscii("Query Design");
    else if ( aModuleId.equalsAscii( "com.sun.star.sdb.TableDesign" ) )
        return OUString::createFromAscii("Table Design");
    else if ( aModuleId.equalsAscii( "com.sun.star.sdb.DataSourceBrowser" ) )
        return OUString::createFromAscii("Data Source Browser" );
    else if ( aModuleId.equalsAscii( "com.sun.star.sdb.DatabaseDocument" ) )
        return OUString::createFromAscii("Database" );

    return ::rtl::OUString();
}

OUString GetUIModuleName( const OUString& aModuleId, const uno::Reference< css::frame::XModuleManager >& rModuleManager )
{
    OUString aModuleUIName;

    if ( rModuleManager.is() )
    {
        uno::Reference< css::container::XNameAccess > xNameAccess( rModuleManager, uno::UNO_QUERY );
        if ( xNameAccess.is() )
        {
            try
            {
                uno::Any a = xNameAccess->getByName( aModuleId );
                uno::Sequence< beans::PropertyValue > aSeq;

                if ( a >>= aSeq )
                {
                    OUString aUIName;
                    for ( sal_Int32 i = 0; i < aSeq.getLength(); i++ )
                    {
                        if ( aSeq[i].Name.equalsAscii( "ooSetupFactoryUIName" ))
                        {
                            aSeq[i].Value >>= aModuleUIName;
                            break;
                        }
                    }
                }
            }
            catch ( uno::RuntimeException& e )
            {
                throw e;
            }
            catch ( uno::Exception& )
            {
            }
        }
    }

    if ( aModuleUIName.getLength() == 0 )
        aModuleUIName = GetModuleName( aModuleId );

    return aModuleUIName;
}

bool GetMenuItemData(
	const uno::Reference< container::XIndexAccess >& rItemContainer,
	sal_Int32 nIndex,
	OUString& rCommandURL,
	OUString& rLabel,
	sal_uInt16& rType,
	uno::Reference< container::XIndexAccess >& rSubMenu )
{
    try
    {
        uno::Sequence< beans::PropertyValue > aProp;
        if ( rItemContainer->getByIndex( nIndex ) >>= aProp )
        {
            for ( sal_Int32 i = 0; i < aProp.getLength(); i++ )
            {
                if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_COMMANDURL ))
                {
                    aProp[i].Value >>= rCommandURL;
                }
                else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_CONTAINER ))
                {
                    aProp[i].Value >>= rSubMenu;
                }
                else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL ))
                {
                    aProp[i].Value >>= rLabel;
                }
                else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_TYPE ))
                {
                    aProp[i].Value >>= rType;
                }
            }

            return sal_True;
        }
    }
    catch ( ::com::sun::star::lang::IndexOutOfBoundsException& )
    {
    }

    return sal_False;
}

bool GetToolbarItemData(
	const uno::Reference< container::XIndexAccess >& rItemContainer,
	sal_Int32 nIndex,
	OUString& rCommandURL,
	OUString& rLabel,
	sal_uInt16& rType,
	sal_Bool& rIsVisible,
	sal_Int32& rStyle,
	uno::Reference< container::XIndexAccess >& rSubMenu )
{
    try
    {
        uno::Sequence< beans::PropertyValue > aProp;
        if ( rItemContainer->getByIndex( nIndex ) >>= aProp )
        {
            for ( sal_Int32 i = 0; i < aProp.getLength(); i++ )
            {
                if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_COMMANDURL ))
                {
                    aProp[i].Value >>= rCommandURL;
                }
                if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_STYLE ))
                {
                    aProp[i].Value >>= rStyle;
                }
                else if (aProp[i].Name.equalsAscii(ITEM_DESCRIPTOR_CONTAINER))
                {
                    aProp[i].Value >>= rSubMenu;
                }
                else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL ))
                {
                    aProp[i].Value >>= rLabel;
                }
                else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_TYPE ))
                {
                    aProp[i].Value >>= rType;
                }
                else if (aProp[i].Name.equalsAscii(ITEM_DESCRIPTOR_ISVISIBLE))
                {
                    aProp[i].Value >>= rIsVisible;
                }
            }

            return sal_True;
        }
    }
    catch ( ::com::sun::star::lang::IndexOutOfBoundsException& )
    {
    }

    return sal_False;
}

uno::Sequence< beans::PropertyValue >
ConvertSvxConfigEntry(
	const uno::Reference< container::XNameAccess >& xCommandToLabelMap,
	const SvxConfigEntry* pEntry )
{
	static const OUString aDescriptorCommandURL (
		RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_COMMANDURL ) );

	static const OUString aDescriptorType(
			RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_TYPE ) );

	static const OUString aDescriptorLabel(
			RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_LABEL ) );

	static const OUString aDescriptorContainer(
			RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_CONTAINER ) );

    uno::Sequence< beans::PropertyValue > aPropSeq( 3 );

    aPropSeq[0].Name = aDescriptorCommandURL;
    aPropSeq[0].Value <<= rtl::OUString( pEntry->GetCommand() );

    aPropSeq[1].Name = aDescriptorType;
    aPropSeq[1].Value <<= css::ui::ItemType::DEFAULT;

    // If the name has not been changed and the name is the same as
    // in the default command to label map then the label can be stored
    // as an empty string.
    // It will be initialised again later using the command to label map.
    aPropSeq[2].Name = aDescriptorLabel;
    if ( pEntry->HasChangedName() == sal_False && pEntry->GetCommand().getLength() )
    {
        sal_Bool isDefaultName = sal_False;
        try
        {
            uno::Any a( xCommandToLabelMap->getByName( pEntry->GetCommand() ) );
            uno::Sequence< beans::PropertyValue > tmpPropSeq;
            if ( a >>= tmpPropSeq )
            {
                for ( sal_Int32 i = 0; i < tmpPropSeq.getLength(); i++ )
                {
                    if ( tmpPropSeq[i].Name.equals( aDescriptorLabel ) )
                    {
                        OUString tmpLabel;
                        tmpPropSeq[i].Value >>= tmpLabel;

                        if ( tmpLabel.equals( pEntry->GetName() ) )
                        {
                            isDefaultName = sal_True;
                        }

                        break;
                    }
                }
            }
        }
        catch ( container::NoSuchElementException& )
        {
            // isDefaultName is left as FALSE
        }

        if ( isDefaultName )
        {
            aPropSeq[2].Value <<= rtl::OUString();
        }
        else
        {
            aPropSeq[2].Value <<= rtl::OUString( pEntry->GetName() );
        }
    }
    else
    {
        aPropSeq[2].Value <<= rtl::OUString( pEntry->GetName() );
    }

    return aPropSeq;
}

uno::Sequence< beans::PropertyValue >
ConvertToolbarEntry(
	const uno::Reference< container::XNameAccess >& xCommandToLabelMap,
	const SvxConfigEntry* pEntry )
{
	static const OUString aDescriptorCommandURL (
		RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_COMMANDURL ) );

	static const OUString aDescriptorType(
			RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_TYPE ) );

	static const OUString aDescriptorLabel(
			RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_LABEL ) );

	static const OUString aDescriptorContainer(
			RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_CONTAINER ) );

	static const OUString aIsVisible(
			RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_ISVISIBLE ) );

    uno::Sequence< beans::PropertyValue > aPropSeq( 4 );

    aPropSeq[0].Name = aDescriptorCommandURL;
    aPropSeq[0].Value <<= rtl::OUString( pEntry->GetCommand() );

    aPropSeq[1].Name = aDescriptorType;
    aPropSeq[1].Value <<= css::ui::ItemType::DEFAULT;

    // If the name has not been changed and the name is the same as
    // in the default command to label map then the label can be stored
    // as an empty string.
    // It will be initialised again later using the command to label map.
    aPropSeq[2].Name = aDescriptorLabel;
    if ( pEntry->HasChangedName() == sal_False && pEntry->GetCommand().getLength() )
    {
        sal_Bool isDefaultName = sal_False;
        try
        {
            uno::Any a( xCommandToLabelMap->getByName( pEntry->GetCommand() ) );
            uno::Sequence< beans::PropertyValue > tmpPropSeq;
            if ( a >>= tmpPropSeq )
            {
                for ( sal_Int32 i = 0; i < tmpPropSeq.getLength(); i++ )
                {
                    if ( tmpPropSeq[i].Name.equals( aDescriptorLabel ) )
                    {
                        OUString tmpLabel;
                        tmpPropSeq[i].Value >>= tmpLabel;

                        if ( tmpLabel.equals( pEntry->GetName() ) )
                        {
                            isDefaultName = sal_True;
                        }

                        break;
                    }
                }
            }
        }
        catch ( container::NoSuchElementException& )
        {
            // isDefaultName is left as FALSE
        }

        if ( isDefaultName )
        {
            aPropSeq[2].Value <<= rtl::OUString();
        }
        else
        {
            aPropSeq[2].Value <<= rtl::OUString( pEntry->GetName() );
        }
    }
    else
    {
        aPropSeq[2].Value <<= rtl::OUString( pEntry->GetName() );
    }

    aPropSeq[3].Name = aIsVisible;
    aPropSeq[3].Value <<= pEntry->IsVisible();

    return aPropSeq;
}

SfxTabPage *CreateSvxMenuConfigPage( Window *pParent, const SfxItemSet& rSet )
{
    return new SvxMenuConfigPage( pParent, rSet );
}

SfxTabPage *CreateKeyboardConfigPage( Window *pParent, const SfxItemSet& rSet )
{
   	return new SfxAcceleratorConfigPage( pParent, rSet );
}

SfxTabPage *CreateSvxToolbarConfigPage( Window *pParent, const SfxItemSet& rSet )
{
    return new SvxToolbarConfigPage( pParent, rSet );
}

SfxTabPage *CreateSvxEventConfigPage( Window *pParent, const SfxItemSet& rSet )
{
    return new SvxEventConfigPage( pParent, rSet, SvxEventConfigPage::EarlyInit() );
}

sal_Bool impl_showKeyConfigTabPage( const css::uno::Reference< css::frame::XFrame >& xFrame )
{
    static ::rtl::OUString SERVICENAME_MODULEMANAGER = ::rtl::OUString::createFromAscii("com.sun.star.frame.ModuleManager");
    static ::rtl::OUString SERVICENAME_DESKTOP       = ::rtl::OUString::createFromAscii("com.sun.star.frame.Desktop"             );
    static ::rtl::OUString MODULEID_STARTMODULE      = ::rtl::OUString::createFromAscii("com.sun.star.frame.StartModule"         );

    try
    {
        css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR   = ::comphelper::getProcessServiceFactory();
		css::uno::Reference< css::frame::XFramesSupplier >     xDesktop(xSMGR->createInstance(SERVICENAME_DESKTOP), css::uno::UNO_QUERY_THROW);
        css::uno::Reference< css::frame::XModuleManager >     xMM     (xSMGR->createInstance(SERVICENAME_MODULEMANAGER), css::uno::UNO_QUERY_THROW);

        if (xMM.is() && xFrame.is())
        {
            ::rtl::OUString sModuleId = xMM->identify(xFrame);
            if (
                ( sModuleId.getLength()                 ) &&
                (!sModuleId.equals(MODULEID_STARTMODULE))
               )
               return sal_True;
        }
    }
    catch(const css::uno::Exception&)
        {}

    return sal_False;
}

/******************************************************************************
 *
 * SvxConfigDialog is the configuration dialog which is brought up from the
 * Tools menu. It includes tabs for customizing menus, toolbars, events and
 * key bindings.
 *
 *****************************************************************************/
SvxConfigDialog::SvxConfigDialog(
	Window * pParent, const SfxItemSet* pSet_ )
	:
		SfxTabDialog( pParent,
			CUI_RES( RID_SVXDLG_CUSTOMIZE ), pSet_ )
{
	FreeResource();

	InitImageType();

	AddTabPage( RID_SVXPAGE_MENUS, CreateSvxMenuConfigPage, NULL );
	AddTabPage( RID_SVXPAGE_KEYBOARD, CreateKeyboardConfigPage, NULL );
	AddTabPage( RID_SVXPAGE_TOOLBARS, CreateSvxToolbarConfigPage, NULL );
	AddTabPage( RID_SVXPAGE_EVENTS, CreateSvxEventConfigPage, NULL );

	const SfxPoolItem* pItem =
		pSet_->GetItem( pSet_->GetPool()->GetWhich( SID_CONFIG ) );

	if ( pItem )
	{
		OUString text = ((const SfxStringItem*)pItem)->GetValue();

		if (text.indexOf(OUString::createFromAscii(ITEM_TOOLBAR_URL)) == 0)
		{
			SetCurPageId( RID_SVXPAGE_TOOLBARS );
		}
	}
}

void SvxConfigDialog::SetFrame(const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& xFrame)
{
    m_xFrame = xFrame;

    if (!impl_showKeyConfigTabPage( xFrame ))
        RemoveTabPage( RID_SVXPAGE_KEYBOARD );
}

SvxConfigDialog::~SvxConfigDialog()
{
}

short SvxConfigDialog::Ok()
{
	return SfxTabDialog::Ok();
}

void SvxConfigDialog::PageCreated( sal_uInt16 nId, SfxTabPage& rPage )
{
	(void)rPage;

	switch ( nId )
	{
		case RID_SVXPAGE_MENUS:
		case RID_SVXPAGE_TOOLBARS:
        case RID_SVXPAGE_KEYBOARD:
            {
                rPage.SetFrame(m_xFrame);
            }
			break;
        case RID_SVXPAGE_EVENTS:
            {
                dynamic_cast< SvxEventConfigPage& >( rPage ).LateInit( m_xFrame );
            };
            break;
		default:
			break;
	}
}

/******************************************************************************
 *
 * The SaveInData class is used to hold data for entries in the Save In
 * ListBox controls in the menu and toolbar tabs
 *
 ******************************************************************************/

// Initialize static variable which holds default XImageManager
uno::Reference< css::ui::XImageManager>* SaveInData::xDefaultImgMgr = NULL;

SaveInData::SaveInData(
	const uno::Reference< css::ui::XUIConfigurationManager >& xCfgMgr,
    const uno::Reference< css::ui::XUIConfigurationManager >& xParentCfgMgr,
	const OUString& aModuleId,
	bool isDocConfig )
		:
			bModified( sal_False ),
			bDocConfig( isDocConfig ),
			bReadOnly( sal_False ),
			m_xCfgMgr( xCfgMgr ),
            m_xParentCfgMgr( xParentCfgMgr )
{
    uno::Reference< beans::XPropertySet > xProps(
		::comphelper::getProcessServiceFactory(), uno::UNO_QUERY );

    xProps->getPropertyValue(
		OUString::createFromAscii( "DefaultContext" ))
			>>= m_xComponentContext;

    m_aSeparatorSeq.realloc( 1 );
    m_aSeparatorSeq[0].Name  = OUString(
		RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_TYPE ) );
    m_aSeparatorSeq[0].Value <<= css::ui::ItemType::SEPARATOR_LINE;

	if ( bDocConfig )
	{
		uno::Reference< css::ui::XUIConfigurationPersistence >
			xDocPersistence( GetConfigManager(), uno::UNO_QUERY );

		bReadOnly = xDocPersistence->isReadOnly();
	}

	m_xServiceManager = uno::Reference< lang::XMultiServiceFactory >(
		::comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW );

	uno::Reference< container::XNameAccess > xNameAccess(
		m_xServiceManager->createInstance(
			OUString( RTL_CONSTASCII_USTRINGPARAM(
				"com.sun.star.frame.UICommandDescription" ) ) ),
		uno::UNO_QUERY );

	if ( xNameAccess.is() )
		xNameAccess->getByName( aModuleId ) >>= m_xCommandToLabelMap;

	if ( !m_xImgMgr.is() )
	{
		m_xImgMgr = uno::Reference< css::ui::XImageManager >(
			GetConfigManager()->getImageManager(), uno::UNO_QUERY );
	}

	if ( !IsDocConfig() )
	{
	    // If this is not a document configuration then it is the settings
	    // for the module (writer, calc, impress etc.) Use this as the default
	    // XImageManager instance
		xDefaultImgMgr = &m_xImgMgr;
	}
    else
    {
        // If this is a document configuration then use the module image manager
        // as default.
        if ( m_xParentCfgMgr.is() )
        {
            m_xParentImgMgr = uno::Reference< css::ui::XImageManager >(
                m_xParentCfgMgr->getImageManager(), uno::UNO_QUERY );
            xDefaultImgMgr = &m_xParentImgMgr;
        }
    }
}

uno::Reference< graphic::XGraphic > GetGraphic(
	const uno::Reference< css::ui::XImageManager >& xImageManager,
	const OUString& rCommandURL )
{
	uno::Reference< graphic::XGraphic > result;

	if ( xImageManager.is() )
	{
		// TODO handle large and high contrast graphics
		uno::Sequence< uno::Reference< graphic::XGraphic > > aGraphicSeq;

		uno::Sequence< OUString > aImageCmdSeq( 1 );
		aImageCmdSeq[0] = rCommandURL;

		try
		{
			aGraphicSeq =
				xImageManager->getImages( GetImageType(), aImageCmdSeq );

			if ( aGraphicSeq.getLength() > 0 )
			{
				result =  aGraphicSeq[0];
			}
		}
		catch ( uno::Exception& )
		{
			// will return empty XGraphic
		}
	}

	return result;
}

Image SaveInData::GetImage( const OUString& rCommandURL )
{
	Image aImage;

	uno::Reference< graphic::XGraphic > xGraphic =
		GetGraphic( m_xImgMgr, rCommandURL );

	if ( xGraphic.is() )
	{
		aImage = Image( xGraphic );
	}
	else if ( xDefaultImgMgr != NULL && (*xDefaultImgMgr).is() )
	{
		xGraphic = GetGraphic( (*xDefaultImgMgr), rCommandURL );

		if ( xGraphic.is() )
		{
			aImage = Image( xGraphic );
		}
	}

	return aImage;
}

bool SaveInData::PersistChanges(
	const uno::Reference< uno::XInterface >& xManager )
{
	bool result = sal_True;

	try
	{
		if ( xManager.is() && !IsReadOnly() )
		{
			uno::Reference< css::ui::XUIConfigurationPersistence >
				xConfigPersistence( xManager, uno::UNO_QUERY );

			if ( xConfigPersistence->isModified() )
			{
				xConfigPersistence->store();
			}
		}
	}
	catch ( com::sun::star::io::IOException& )
	{
		result = sal_False;
	}

	return result;
}

/******************************************************************************
 *
 * The MenuSaveInData class extends SaveInData and provides menu specific
 * load and store functionality.
 *
 ******************************************************************************/

// Initialize static variable which holds default Menu data
MenuSaveInData* MenuSaveInData::pDefaultData = NULL;

MenuSaveInData::MenuSaveInData(
	const uno::Reference< css::ui::XUIConfigurationManager >& cfgmgr,
    const uno::Reference< css::ui::XUIConfigurationManager >& xParentCfgMgr,
	const OUString& aModuleId,
	bool isDocConfig )
	:
		SaveInData( cfgmgr, xParentCfgMgr, aModuleId, isDocConfig ),
		m_aMenuResourceURL(
			RTL_CONSTASCII_USTRINGPARAM( ITEM_MENUBAR_URL ) ),
		m_aDescriptorContainer(
			RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_CONTAINER ) ),
		pRootEntry( 0 )
{
	try
	{
		OUString url( RTL_CONSTASCII_USTRINGPARAM( ITEM_MENUBAR_URL ) );
		m_xMenuSettings = GetConfigManager()->getSettings( url, sal_False );
	}
	catch ( container::NoSuchElementException& )
	{
		// will use menu settings for the module
	}

	// If this is not a document configuration then it is the settings
	// for the module (writer, calc, impress etc.). These settings should
	// be set as the default to be used for SaveIn locations that do not
	// have custom settings
	if ( !IsDocConfig() )
	{
		SetDefaultData( this );
	}
}

MenuSaveInData::~MenuSaveInData()
{
	if ( pRootEntry != NULL )
	{
		delete pRootEntry;
	}
}

SvxEntries*
MenuSaveInData::GetEntries()
{
	if ( pRootEntry == NULL )
	{
		pRootEntry = new SvxConfigEntry(
			String::CreateFromAscii("MainMenus"), String(), sal_True );

		if ( m_xMenuSettings.is() )
		{
			LoadSubMenus( m_xMenuSettings, String(), pRootEntry );
		}
		else if ( GetDefaultData() != NULL )
		{
			// If the doc has no config settings use module config settings
			LoadSubMenus( GetDefaultData()->m_xMenuSettings, String(), pRootEntry );
		}
	}

	return pRootEntry->GetEntries();
}

void
MenuSaveInData::SetEntries( SvxEntries* pNewEntries )
{
	// delete old menu hierarchy first
	if ( pRootEntry != NULL )
	{
		delete pRootEntry->GetEntries();
	}

	// now set new menu hierarchy
	pRootEntry->SetEntries( pNewEntries );
}

bool MenuSaveInData::LoadSubMenus(
	const uno::Reference< container::XIndexAccess >& xMenuSettings,
	const OUString& rBaseTitle,
	SvxConfigEntry* pParentData )
{
	SvxEntries* pEntries = pParentData->GetEntries();

    // Don't access non existing menu configuration!
    if ( !xMenuSettings.is() )
        return true;
    
    for ( sal_Int32 nIndex = 0; nIndex < xMenuSettings->getCount(); nIndex++ )
    {
        uno::Reference< container::XIndexAccess >	xSubMenu;
        OUString				aCommandURL;
        OUString				aLabel;
		bool					bIsUserDefined = sal_True;

        sal_uInt16 nType( css::ui::ItemType::DEFAULT );

        bool bItem = GetMenuItemData( xMenuSettings, nIndex,
			aCommandURL, aLabel, nType, xSubMenu );

        if ( bItem )
        {
            if ( nType == css::ui::ItemType::DEFAULT )
            {
				uno::Any a;
				try
				{
					a = m_xCommandToLabelMap->getByName( aCommandURL );
					bIsUserDefined = sal_False;
				}
				catch ( container::NoSuchElementException& )
				{
					bIsUserDefined = sal_True;
				}

				// If custom label not set retrieve it from the command
				// to info service
				if ( aLabel.equals( OUString() ) )
				{
					uno::Sequence< beans::PropertyValue > aPropSeq;
					if ( a >>= aPropSeq )
					{
						for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ )
						{
							if ( aPropSeq[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL ) )
							{
								aPropSeq[i].Value >>= aLabel;
								break;
							}
						}
					}
				}

                if ( xSubMenu.is() )
                {
                    // popup menu
					SvxConfigEntry* pEntry = new SvxConfigEntry(
						aLabel, aCommandURL, sal_True );

					pEntry->SetUserDefined( bIsUserDefined );

					pEntries->push_back( pEntry );

					OUString subMenuTitle( rBaseTitle );

					if ( subMenuTitle.getLength() != 0 )
					{
						subMenuTitle +=
							OUString::createFromAscii(pMenuSeparatorStr);
					}
					else
					{
						pEntry->SetMain( sal_True );
					}

					subMenuTitle += stripHotKey( aLabel );

					LoadSubMenus( xSubMenu, subMenuTitle, pEntry );
                }
                else
                {
                    SvxConfigEntry* pEntry = new SvxConfigEntry(
						aLabel, aCommandURL, sal_False );
					pEntry->SetUserDefined( bIsUserDefined );
					pEntries->push_back( pEntry );
                }
            }
            else
            {
				SvxConfigEntry* pEntry = new SvxConfigEntry;
				pEntry->SetUserDefined( bIsUserDefined );
				pEntries->push_back( pEntry );
            }
        }
    }
	return true;
}

bool MenuSaveInData::Apply()
{
	bool result = sal_False;

	if ( IsModified() )
	{
        // Apply new menu bar structure to our settings container
        m_xMenuSettings = uno::Reference< container::XIndexAccess >(
			GetConfigManager()->createSettings(), uno::UNO_QUERY );

        uno::Reference< container::XIndexContainer > xIndexContainer (
			m_xMenuSettings, uno::UNO_QUERY );

        uno::Reference< lang::XSingleComponentFactory > xFactory (
			m_xMenuSettings, uno::UNO_QUERY );

        Apply( pRootEntry, xIndexContainer, xFactory, NULL );

        try
        {
			if ( GetConfigManager()->hasSettings( m_aMenuResourceURL ) )
			{
            	GetConfigManager()->replaceSettings(
					m_aMenuResourceURL, m_xMenuSettings );
			}
			else
			{
            	GetConfigManager()->insertSettings(
					m_aMenuResourceURL, m_xMenuSettings );
			}
        }
        catch ( container::NoSuchElementException& )
        {
			OSL_TRACE("caught container::NoSuchElementException saving settings");
        }
        catch ( com::sun::star::io::IOException& )
        {
			OSL_TRACE("caught IOException saving settings");
        }
        catch ( com::sun::star::uno::Exception& )
		{
			OSL_TRACE("caught some other exception saving settings");
		}

        SetModified( sal_False );

		result = PersistChanges( GetConfigManager() );
	}

	return result;
}

void MenuSaveInData::Apply(
	SvxConfigEntry* pRootEntry_,
	uno::Reference< container::XIndexContainer >& rMenuBar,
	uno::Reference< lang::XSingleComponentFactory >& rFactory,
	SvLBoxEntry *pParentEntry )
{
	(void)pRootEntry_;
	(void)pParentEntry;

	SvxEntries::const_iterator iter = GetEntries()->begin();
	SvxEntries::const_iterator end = GetEntries()->end();

	for ( ; iter != end; iter++ )
	{
		SvxConfigEntry* pEntryData = *iter;

		uno::Sequence< beans::PropertyValue > aPropValueSeq =
			ConvertSvxConfigEntry( m_xCommandToLabelMap, pEntryData );

		uno::Reference< container::XIndexContainer > xSubMenuBar(
			rFactory->createInstanceWithContext( m_xComponentContext ),
			uno::UNO_QUERY );

		sal_Int32 nIndex = aPropValueSeq.getLength();
		aPropValueSeq.realloc( nIndex + 1 );
		aPropValueSeq[nIndex].Name = m_aDescriptorContainer;
		aPropValueSeq[nIndex].Value <<= xSubMenuBar;
		rMenuBar->insertByIndex(
			rMenuBar->getCount(), uno::makeAny( aPropValueSeq ));
		ApplyMenu( xSubMenuBar, rFactory, pEntryData );
	}
}

void MenuSaveInData::ApplyMenu(
	uno::Reference< container::XIndexContainer >& rMenuBar,
	uno::Reference< lang::XSingleComponentFactory >& rFactory,
	SvxConfigEntry* pMenuData )
{
	SvxEntries::const_iterator iter = pMenuData->GetEntries()->begin();
	SvxEntries::const_iterator end = pMenuData->GetEntries()->end();

	for ( ; iter != end; iter++ )
	{
		SvxConfigEntry* pEntry = *iter;

		if ( pEntry->IsPopup() )
		{
			uno::Sequence< beans::PropertyValue > aPropValueSeq =
				ConvertSvxConfigEntry( m_xCommandToLabelMap, pEntry );

			uno::Reference< container::XIndexContainer > xSubMenuBar(
				rFactory->createInstanceWithContext( m_xComponentContext ),
					uno::UNO_QUERY );

			sal_Int32 nIndex = aPropValueSeq.getLength();
			aPropValueSeq.realloc( nIndex + 1 );
			aPropValueSeq[nIndex].Name = m_aDescriptorContainer;
			aPropValueSeq[nIndex].Value <<= xSubMenuBar;

			rMenuBar->insertByIndex(
				rMenuBar->getCount(), uno::makeAny( aPropValueSeq ));

			ApplyMenu( xSubMenuBar, rFactory, pEntry );
		}
		else if ( pEntry->IsSeparator() )
		{
			rMenuBar->insertByIndex(
				rMenuBar->getCount(), uno::makeAny( m_aSeparatorSeq ));
		}
		else
		{
			uno::Sequence< beans::PropertyValue > aPropValueSeq =
				ConvertSvxConfigEntry( m_xCommandToLabelMap, pEntry );
			rMenuBar->insertByIndex(
				rMenuBar->getCount(), uno::makeAny( aPropValueSeq ));
		}
	}
}

void
MenuSaveInData::Reset()
{
	GetConfigManager()->reset();

	delete pRootEntry;
	pRootEntry = NULL;

	try
	{
		m_xMenuSettings = GetConfigManager()->getSettings(
			m_aMenuResourceURL, sal_False );
	}
	catch ( container::NoSuchElementException& )
	{
		// will use default settings
	}
}

class PopupPainter : public SvLBoxString
{
public:
	PopupPainter( SvLBoxEntry* pEntry, const String& rStr )
		: SvLBoxString( pEntry, 0, rStr )
	{ }

	~PopupPainter() { }

	void Paint( const Point& rPos, SvLBox& rOutDev,
		sal_uInt16 nViewDataEntryFlags, SvLBoxEntry* pEntry )
	{
		SvLBoxString::Paint( rPos, rOutDev, nViewDataEntryFlags, pEntry );

		Color aOldFillColor = rOutDev.GetFillColor();

		SvTreeListBox* pTreeBox = static_cast< SvTreeListBox* >( &rOutDev );
		long nX = pTreeBox->GetSizePixel().Width();

		ScrollBar* pVScroll = pTreeBox->GetVScroll();
		if ( pVScroll->IsVisible() )
		{
			nX -= pVScroll->GetSizePixel().Width();
		}

		SvViewDataItem* pItem = rOutDev.GetViewDataItem( pEntry, this );
		nX -= pItem->aSize.Height();

		long nSize = pItem->aSize.Height() / 2;
		long nHalfSize = nSize / 2;
		long nY = rPos.Y() + nHalfSize;

		if ( aOldFillColor == COL_WHITE )
		{
			rOutDev.SetFillColor( Color( COL_BLACK ) );
		}
		else
		{
			rOutDev.SetFillColor( Color( COL_WHITE ) );
		}

		long n = 0;
		while ( n <= nHalfSize )
		{
			rOutDev.DrawRect( Rectangle( nX+n, nY+n, nX+n, nY+nSize-n ) );
			n++;
		}

		rOutDev.SetFillColor( aOldFillColor );
	}
};

/******************************************************************************
 *
 * SvxMenuEntriesListBox is the listbox in which the menu items for a
 * particular menu are shown. We have a custom listbox because we need
 * to add drag'n'drop support from the Macro Selector and within the
 * listbox
 *
 *****************************************************************************/
SvxMenuEntriesListBox::SvxMenuEntriesListBox(
	Window* pParent, const ResId& rResId)
	: SvTreeListBox( pParent, rResId )
	, pPage( (SvxMenuConfigPage*) pParent )
	, m_bIsInternalDrag( sal_False )
{
	SetStyle(
		GetStyle() | WB_CLIPCHILDREN | WB_HSCROLL | WB_HIDESELECTION );

	SetSpaceBetweenEntries( 3 );
	SetEntryHeight( ENTRY_HEIGHT );

	SetHighlightRange();
	SetSelectionMode(SINGLE_SELECTION);

	SetDragDropMode( SV_DRAGDROP_CTRL_MOVE	|
					 SV_DRAGDROP_APP_COPY	|
					 SV_DRAGDROP_ENABLE_TOP |
					 SV_DRAGDROP_APP_DROP);
}

SvxMenuEntriesListBox::~SvxMenuEntriesListBox()
{
	// do nothing
}

// drag and drop support
DragDropMode SvxMenuEntriesListBox::NotifyStartDrag(
	TransferDataContainer& aTransferDataContainer, SvLBoxEntry* pEntry )
{
	(void)aTransferDataContainer;
	(void)pEntry;

	m_bIsInternalDrag = sal_True;
	return GetDragDropMode();
}

void SvxMenuEntriesListBox::DragFinished( sal_Int8 nDropAction )
{
	(void)nDropAction;
	m_bIsInternalDrag = sal_False;
}

sal_Int8 SvxMenuEntriesListBox::AcceptDrop( const AcceptDropEvent& rEvt )
{
	if ( m_bIsInternalDrag )
	{
		// internal copy isn't allowed!
		if ( rEvt.mnAction == DND_ACTION_COPY )
			return DND_ACTION_NONE;
		else
			return SvTreeListBox::AcceptDrop( rEvt );
	}

	// Always do COPY instead of MOVE if D&D comes from outside!
	AcceptDropEvent aNewAcceptDropEvent( rEvt );
	aNewAcceptDropEvent.mnAction = DND_ACTION_COPY;
	return SvTreeListBox::AcceptDrop( aNewAcceptDropEvent );
}

sal_Bool SvxMenuEntriesListBox::NotifyAcceptDrop( SvLBoxEntry* )
{
	return sal_True;
}

sal_Bool SvxMenuEntriesListBox::NotifyMoving(
	SvLBoxEntry* pTarget, SvLBoxEntry* pSource,
	SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos)
{
	// only try to do a move if we are dragging within the list box
	if ( m_bIsInternalDrag )
	{
		if ( pPage->MoveEntryData( pSource, pTarget ) == sal_True )
		{
			SvTreeListBox::NotifyMoving(
				pTarget, pSource, rpNewParent, rNewChildPos );
			return sal_True;
		}
		else
		{
			return sal_False;
		}
	}
	else
	{
		return NotifyCopying( pTarget, pSource, rpNewParent, rNewChildPos );
	}
}

sal_Bool SvxMenuEntriesListBox::NotifyCopying(
    SvLBoxEntry* pTarget, SvLBoxEntry* pSource,
    SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos)
{
	(void)pSource;
	(void)rpNewParent;
	(void)rNewChildPos;

	if ( !m_bIsInternalDrag )
	{
		// if the target is NULL then add function to the start of the list
		pPage->AddFunction( pTarget, pTarget == NULL );

		// AddFunction already adds the listbox entry so return FALSE
		// to stop another listbox entry being added
		return sal_False;
	}

	// Copying is only allowed from external controls, not within the listbox
	return sal_False;
}

void SvxMenuEntriesListBox::KeyInput( const KeyEvent& rKeyEvent )
{
	KeyCode keycode = rKeyEvent.GetKeyCode();

	// support DELETE for removing the current entry
	if ( keycode == KEY_DELETE )
	{
		pPage->DeleteSelectedContent();
	}
	// support CTRL+UP and CTRL+DOWN for moving selected entries
	else if ( keycode.GetCode() == KEY_UP && keycode.IsMod1() )
	{
		pPage->MoveEntry( sal_True );
	}
	else if ( keycode.GetCode() == KEY_DOWN && keycode.IsMod1() )
	{
		pPage->MoveEntry( sal_False );
	}
	else
	{
		// pass on to superclass
		SvTreeListBox::KeyInput( rKeyEvent );
	}
}

// class SvxDescriptionEdit ----------------------------------------------

SvxDescriptionEdit::SvxDescriptionEdit( Window* pParent, const ResId& _rId ) :

    ExtMultiLineEdit( pParent, _rId )

{
    // calculate the available space for help text
    m_aRealRect = Rectangle( Point(), GetSizePixel() );
    if ( GetVScrollBar() )
        m_aRealRect.Right() -= ( GetVScrollBar()->GetSizePixel().Width() + 4 );

    SetLeftMargin(2);
    SetBorderStyle( WINDOW_BORDER_MONO );
}

// -----------------------------------------------------------------------

void SvxDescriptionEdit::SetNewText( const String& _rText )
{
    String sTemp( _rText );
    sal_Bool bShow = sal_False;
    if ( sTemp.Len() > 0 )
    {
        // detect if a scrollbar is necessary
        Rectangle aRect = GetTextRect( m_aRealRect, sTemp, TEXT_DRAW_WORDBREAK | TEXT_DRAW_MULTILINE );
        bShow = ( aRect.Bottom() > m_aRealRect.Bottom() );
    }

    if ( GetVScrollBar() )
        GetVScrollBar()->Show( bShow );

    if ( bShow )
        sTemp += '\n';

    SetText( sTemp );
}

/******************************************************************************
 *
 * SvxConfigPage is the abstract base class on which the Menu and Toolbar
 * configuration tabpages are based. It includes methods which are common to
 * both tabpages to add, delete, move and rename items etc.
 *
 *****************************************************************************/
SvxConfigPage::SvxConfigPage(
    Window *pParent, const SfxItemSet& rSet )
	:
	SfxTabPage( pParent, CUI_RES( RID_SVXPAGE_MENUS ), rSet ),
	bInitialised( sal_False ),
	pCurrentSaveInData( 0 ),
	aTopLevelSeparator( this, CUI_RES( GRP_MENUS ) ),
	aTopLevelLabel( this, CUI_RES( FT_MENUS ) ),
	aTopLevelListBox( this, CUI_RES( LB_MENUS ) ),
	aNewTopLevelButton( this, CUI_RES( BTN_NEW ) ),
	aModifyTopLevelButton( this, CUI_RES( BTN_CHANGE ) ),
	aContentsSeparator( this, CUI_RES( GRP_MENU_SEPARATOR ) ),
	aContentsLabel( this, CUI_RES( GRP_MENU_ENTRIES ) ),
	aContentsListBox( 0 ),
	aAddCommandsButton( this, CUI_RES( BTN_ADD_COMMANDS ) ),
	aModifyCommandButton( this, CUI_RES( BTN_CHANGE_ENTRY ) ),
	aMoveUpButton( this, CUI_RES( BTN_UP ) ),
	aMoveDownButton( this, CUI_RES( BTN_DOWN ) ),
	aSaveInText( this, CUI_RES( TXT_SAVEIN ) ),
	aSaveInListBox( this, CUI_RES( LB_SAVEIN ) ),
    aDescriptionLabel( this, CUI_RES( FT_DESCRIPTION ) ),
    aDescriptionField( this, CUI_RES( ED_DESCRIPTION ) ),
	pSelectorDlg( 0 )
{
    aDescriptionField.SetControlBackground( GetSettings().GetStyleSettings().GetDialogColor() );
    aDescriptionField.SetAutoScroll( sal_True );
    aDescriptionField.EnableCursor( sal_False );

	aMoveUpButton.SetAccessibleName(String(CUI_RES(BUTTON_STR_UP)));
	aMoveDownButton.SetAccessibleName(String(CUI_RES(BUTTON_STR_DOWN)));
	aMoveUpButton.SetAccessibleRelationMemberOf(&aContentsSeparator);
	aMoveDownButton.SetAccessibleRelationMemberOf(&aContentsSeparator);
	aNewTopLevelButton.SetAccessibleRelationMemberOf(&aTopLevelSeparator);
	aModifyTopLevelButton.SetAccessibleRelationMemberOf(&aTopLevelSeparator);
	aAddCommandsButton.SetAccessibleRelationMemberOf(&aContentsSeparator);
	aModifyCommandButton.SetAccessibleRelationMemberOf(&aContentsSeparator);
}

SvxConfigPage::~SvxConfigPage()
{
}

void SvxConfigPage::Reset( const SfxItemSet& )
{
	// If we haven't initialised our XMultiServiceFactory reference
	// then Reset is being called at the opening of the dialog.
	//
	// Load menu configuration data for the module of the currently
	// selected document, for the currently selected document, and for
	// all other open documents of the same module type
	if ( !bInitialised )
	{
		sal_uInt16 nPos = 0;
		uno::Reference < css::ui::XUIConfigurationManager > xCfgMgr;
		uno::Reference < css::ui::XUIConfigurationManager > xDocCfgMgr;

		uno::Reference< lang::XMultiServiceFactory > xServiceManager(
			::comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW );

        m_xFrame = GetFrame();
		OUString aModuleId = GetFrameWithDefaultAndIdentify( m_xFrame );

		// replace %MODULENAME in the label with the correct module name
        uno::Reference< css::frame::XModuleManager > xModuleManager(
			xServiceManager->createInstance(
				OUString( RTL_CONSTASCII_USTRINGPARAM(
					"com.sun.star.frame.ModuleManager" ) ) ),
			uno::UNO_QUERY_THROW );
		OUString aModuleName = GetUIModuleName( aModuleId, xModuleManager );

		OUString title = aTopLevelSeparator.GetText();
		OUString aSearchString = OUString::createFromAscii( "%MODULENAME" );
		sal_Int32 index = title.indexOf( aSearchString );

		if ( index != -1 )
		{
			title = title.replaceAt(
				index, aSearchString.getLength(), aModuleName );
			aTopLevelSeparator.SetText( title );
		}

		uno::Reference< css::ui::XModuleUIConfigurationManagerSupplier >
			xModuleCfgSupplier( xServiceManager->createInstance(
				OUString( RTL_CONSTASCII_USTRINGPARAM(
			"com.sun.star.ui.ModuleUIConfigurationManagerSupplier" ))),
			uno::UNO_QUERY );

		// Set up data for module specific menus
		SaveInData* pModuleData = NULL;

		try
		{
			xCfgMgr =
				xModuleCfgSupplier->getUIConfigurationManager( aModuleId );

            pModuleData = CreateSaveInData( xCfgMgr,
                                            uno::Reference< css::ui::XUIConfigurationManager >(),
                                            aModuleId,
                                            sal_False );
		}
		catch ( container::NoSuchElementException& )
		{
		}

		if ( pModuleData != NULL )
		{
			OUString label;
			utl::ConfigManager::GetDirectConfigProperty(
				utl::ConfigManager::PRODUCTNAME ) >>= label;
			label += OUString::createFromAscii( " " );
			label += aModuleName;

			nPos = aSaveInListBox.InsertEntry( label );
			aSaveInListBox.SetEntryData( nPos, pModuleData );
		}

		// try to retrieve the document based ui configuration manager
		OUString aTitle;
		uno::Reference< frame::XController > xController =
			m_xFrame->getController();
		if ( CanConfig( aModuleId ) && xController.is() )
		{
			uno::Reference< frame::XModel > xModel( xController->getModel() );
			if ( xModel.is() )
			{
				uno::Reference< css::ui::XUIConfigurationManagerSupplier >
					xCfgSupplier( xModel, uno::UNO_QUERY );

				if ( xCfgSupplier.is() )
				{
					xDocCfgMgr = xCfgSupplier->getUIConfigurationManager();
				}
                aTitle = ::comphelper::DocumentInfo::getDocumentTitle( xModel );
			}
		}

		SaveInData* pDocData = NULL;
		if ( xDocCfgMgr.is() )
		{
			pDocData = CreateSaveInData( xDocCfgMgr, xCfgMgr, aModuleId, sal_True );

			if ( !pDocData->IsReadOnly() )
			{
				nPos = aSaveInListBox.InsertEntry( aTitle );
				aSaveInListBox.SetEntryData( nPos, pDocData );
			}
		}

		// if an item to select has been passed in (eg. the ResourceURL for a
		// toolbar) then try to select the SaveInData entry that has that item
		bool bURLToSelectFound = sal_False;
		if ( m_aURLToSelect.getLength() != 0 )
		{
			if ( pDocData != NULL && pDocData->HasURL( m_aURLToSelect ) )
			{
				aSaveInListBox.SelectEntryPos( nPos, sal_True );
				pCurrentSaveInData = pDocData;
				bURLToSelectFound = sal_True;
			}
			else if ( pModuleData->HasURL( m_aURLToSelect ) )
			{
				aSaveInListBox.SelectEntryPos( 0, sal_True );
				pCurrentSaveInData = pModuleData;
				bURLToSelectFound = sal_True;
			}
		}

		if ( bURLToSelectFound == sal_False )
		{
			// if the document has menu configuration settings select it
			// it the SaveIn listbox, otherwise select the module data
			if ( pDocData != NULL && pDocData->HasSettings() )
			{
				aSaveInListBox.SelectEntryPos( nPos, sal_True );
				pCurrentSaveInData = pDocData;
			}
			else
			{
				aSaveInListBox.SelectEntryPos( 0, sal_True );
				pCurrentSaveInData = pModuleData;
			}
		}

#ifdef DBG_UTIL
        DBG_ASSERT( pCurrentSaveInData, "SvxConfigPage::Reset(): no SaveInData" );
#endif

		if ( CanConfig( aModuleId ) )
        {
            // Load configuration for other open documents which have
		    // same module type
		    uno::Sequence< uno::Reference< frame::XFrame > > aFrameList;
            try
            {
		        uno::Reference< frame::XFramesSupplier > xFramesSupplier(
			        xServiceManager->createInstance(
				        OUString( RTL_CONSTASCII_USTRINGPARAM(
					        "com.sun.star.frame.Desktop" ) ) ),
			        uno::UNO_QUERY_THROW );

		        uno::Reference< frame::XFrames > xFrames =
			        xFramesSupplier->getFrames();

			    aFrameList = xFrames->queryFrames(
                    frame::FrameSearchFlag::ALL & ~frame::FrameSearchFlag::SELF );

            }
            catch( const uno::Exception& )
            {
            	DBG_UNHANDLED_EXCEPTION();
            }

		    for ( sal_Int32 i = 0; i < aFrameList.getLength(); i++ )
		    {
			    SaveInData* pData = NULL;
			    uno::Reference < frame::XFrame > xf = aFrameList[i];

			    if ( xf.is() && xf != m_xFrame )
			    {
                    OUString aCheckId;
                    try{
                        aCheckId = xModuleManager->identify( xf );
                    } catch(const uno::Exception&)
                        { aCheckId = ::rtl::OUString(); }

				    if ( aModuleId.equals( aCheckId ) )
				    {
					    // try to get the document based ui configuration manager
					    OUString aTitle2;
					    uno::Reference< frame::XController > xController_ =
						    xf->getController();

					    if ( xController_.is() )
					    {
						    uno::Reference< frame::XModel > xModel(
							    xController_->getModel() );

						    if ( xModel.is() )
						    {
							    uno::Reference<
								    css::ui::XUIConfigurationManagerSupplier >
									    xCfgSupplier( xModel, uno::UNO_QUERY );

							    if ( xCfgSupplier.is() )
							    {
								    xDocCfgMgr =
									    xCfgSupplier->getUIConfigurationManager();
							    }
                                aTitle2 = ::comphelper::DocumentInfo::getDocumentTitle( xModel );
						    }
					    }

					    if ( xDocCfgMgr.is() )
					    {
						    pData = CreateSaveInData( xDocCfgMgr, xCfgMgr, aModuleId, sal_True );

						    if ( pData && !pData->IsReadOnly() )
						    {
							    nPos = aSaveInListBox.InsertEntry( aTitle2 );
							    aSaveInListBox.SetEntryData( nPos, pData );
						    }
					    }
				    }
			    }
		    }
        }

		aSaveInListBox.SetSelectHdl(
			LINK( this, SvxConfigPage, SelectSaveInLocation ) );

		bInitialised = sal_True;

		Init();
	}
	else
	{
		if ( QueryReset() == RET_YES )
		{
			// Reset menu configuration for currently selected SaveInData
			GetSaveInData()->Reset();

			Init();
		}
	}
}

::rtl::OUString SvxConfigPage::GetFrameWithDefaultAndIdentify( uno::Reference< frame::XFrame >& _inout_rxFrame )
{
    ::rtl::OUString sModuleID;
    try
    {
		uno::Reference< lang::XMultiServiceFactory > xServiceManager(
			::comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW );

		uno::Reference< frame::XFramesSupplier > xFramesSupplier(
			xServiceManager->createInstance(
				OUString( RTL_CONSTASCII_USTRINGPARAM(
					"com.sun.star.frame.Desktop" ) ) ),
			uno::UNO_QUERY_THROW );

        if ( !_inout_rxFrame.is() )
    		_inout_rxFrame = xFramesSupplier->getActiveFrame();

        if ( !_inout_rxFrame.is() )
        {
            uno::Reference< frame::XDesktop > xDesktop( xFramesSupplier, uno::UNO_QUERY_THROW );
            _inout_rxFrame = xDesktop->getCurrentFrame();
        }

        if ( !_inout_rxFrame.is() && SfxViewFrame::Current() )
            _inout_rxFrame = SfxViewFrame::Current()->GetFrame().GetFrameInterface();

        if ( !_inout_rxFrame.is() )
        {
            DBG_ERRORFILE( "SvxConfigPage::GetFrameWithDefaultAndIdentify(): no frame found!" );
            return sModuleID;
        }

        uno::Reference< css::frame::XModuleManager > xModuleManager(
			xServiceManager->createInstance(
				OUString( RTL_CONSTASCII_USTRINGPARAM(
					"com.sun.star.frame.ModuleManager" ) ) ),
			uno::UNO_QUERY_THROW );

        try
        {
            sModuleID = xModuleManager->identify( _inout_rxFrame );
        }
        catch ( const frame::UnknownModuleException& )
        {
        }

    }
    catch( const uno::Exception& )
    {
    	DBG_UNHANDLED_EXCEPTION();
    }

    return sModuleID;
}

sal_Bool SvxConfigPage::FillItemSet( SfxItemSet& )
{
	bool result = sal_False;

	for ( sal_uInt16 i = 0 ; i < aSaveInListBox.GetEntryCount(); i++ )
	{
		SaveInData* pData =
			(SaveInData*) aSaveInListBox.GetEntryData( i );

		result = pData->Apply();
	}
	return result;
}

void SvxConfigPage::PositionContentsListBox()
{
	if ( aContentsListBox == NULL )
	{
		return;
	}

	Point p, newp;
	Size s, news;
	long x, y, width, height;

	// x and width is same as aTopLevelListBox
	x = aTopLevelListBox.GetPosPixel().X();
	width = aTopLevelListBox.GetSizePixel().Width();

	// y is same as aAddCommandsButton
	y = aAddCommandsButton.GetPosPixel().Y();

	// get gap between aAddCommandsButton and aContentsSeparator
	p = aContentsSeparator.GetPosPixel();
	s = aContentsSeparator.GetSizePixel();
    long gap = y - ( p.Y() + s.Height() );

	height = aSaveInListBox.GetPosPixel().Y() - y - gap;

	aContentsListBox->SetPosPixel( Point( x, y ) );
	aContentsListBox->SetSizePixel( Size( width, height ) );
}

IMPL_LINK( SvxConfigPage, SelectSaveInLocation, ListBox *, pBox )
{
	(void)pBox;

	pCurrentSaveInData = (SaveInData*) aSaveInListBox.GetEntryData(
			aSaveInListBox.GetSelectEntryPos());

	Init();
	return 1;
}

void SvxConfigPage::ReloadTopLevelListBox( SvxConfigEntry* pToSelect )
{
	sal_uInt16 nSelectionPos = aTopLevelListBox.GetSelectEntryPos();
	aTopLevelListBox.Clear();

    if ( GetSaveInData() && GetSaveInData()->GetEntries() )
    {
        SvxEntries::const_iterator iter = GetSaveInData()->GetEntries()->begin();
        SvxEntries::const_iterator end = GetSaveInData()->GetEntries()->end();

        for ( ; iter != end; iter++ )
        {
            SvxConfigEntry* pEntryData = *iter;
            sal_uInt16 nPos = aTopLevelListBox.InsertEntry( stripHotKey( pEntryData->GetName() ) );
            aTopLevelListBox.SetEntryData( nPos, pEntryData );

            if ( pEntryData == pToSelect )
                nSelectionPos = nPos;

            AddSubMenusToUI( stripHotKey( pEntryData->GetName() ), pEntryData );
        }
    }
#ifdef DBG_UTIL
    else
    {
        DBG_ASSERT( GetSaveInData(), "SvxConfigPage::ReloadTopLevelListBox(): no SaveInData" );
        DBG_ASSERT( GetSaveInData()->GetEntries() ,
            "SvxConfigPage::ReloadTopLevelListBox(): no SaveInData entries" );
    }
#endif

	nSelectionPos = nSelectionPos < aTopLevelListBox.GetEntryCount() ?
		nSelectionPos : aTopLevelListBox.GetEntryCount() - 1;

	aTopLevelListBox.SelectEntryPos( nSelectionPos, sal_True );
	aTopLevelListBox.GetSelectHdl().Call( this );
}

void SvxConfigPage::AddSubMenusToUI(
	const String& rBaseTitle, SvxConfigEntry* pParentData )
{
	SvxEntries::const_iterator iter = pParentData->GetEntries()->begin();
	SvxEntries::const_iterator end = pParentData->GetEntries()->end();

	for ( ; iter != end; iter++ )
	{
		SvxConfigEntry* pEntryData = *iter;

		if ( pEntryData->IsPopup() )
		{
			OUString subMenuTitle( rBaseTitle );
			subMenuTitle += OUString::createFromAscii( pMenuSeparatorStr );
			subMenuTitle += stripHotKey( pEntryData->GetName() );

			sal_uInt16 nPos = aTopLevelListBox.InsertEntry( subMenuTitle );
			aTopLevelListBox.SetEntryData( nPos, pEntryData );

			AddSubMenusToUI( subMenuTitle, pEntryData );
		}
	}
}

SvxEntries* SvxConfigPage::FindParentForChild(
	SvxEntries* pRootEntries, SvxConfigEntry* pChildData )
{
	SvxEntries::const_iterator iter = pRootEntries->begin();
	SvxEntries::const_iterator end = pRootEntries->end();

	for ( ; iter != end; iter++ )
	{
		SvxConfigEntry* pEntryData = *iter;

		if ( pEntryData == pChildData )
		{
			return pRootEntries;
		}
		else if ( pEntryData->IsPopup() )
		{
			SvxEntries* result =
				FindParentForChild( pEntryData->GetEntries(), pChildData );

			if ( result != NULL )
			{
				return result;
			}
		}
	}
	return NULL;
}

SvLBoxEntry* SvxConfigPage::AddFunction(
	SvLBoxEntry* pTarget, bool bFront, bool bAllowDuplicates )
{
	String aDisplayName = pSelectorDlg->GetSelectedDisplayName();
	String aHelpText = pSelectorDlg->GetSelectedHelpText();
	String aURL = pSelectorDlg->GetScriptURL();

	if ( !aURL.Len() )
	{
		return NULL;
	}

	SvxConfigEntry* pNewEntryData =
		new SvxConfigEntry( aDisplayName, aURL, sal_False );
	pNewEntryData->SetUserDefined( sal_True );

	// check that this function is not already in the menu
	SvxConfigEntry* pParent = GetTopLevelSelection();

	SvxEntries::const_iterator iter = pParent->GetEntries()->begin();
	SvxEntries::const_iterator end = pParent->GetEntries()->end();

	if ( !bAllowDuplicates )
	{
		while ( iter != end )
		{
			SvxConfigEntry *pCurEntry = *iter;

			if ( pCurEntry->GetCommand() == pNewEntryData->GetCommand() )
			{
				// asynchronous error message, because of MsgBoxes
				PostUserEvent(
					LINK( this, SvxConfigPage, AsyncInfoMsg ) );
				return NULL;
			}

			iter++;
		}
	}

	return InsertEntry( pNewEntryData, pTarget, bFront );
}

SvLBoxEntry* SvxConfigPage::InsertEntry(
	SvxConfigEntry* pNewEntryData,
	SvLBoxEntry* pTarget,
	bool bFront )
{
	// Grab the entries list for the currently selected menu
	SvxEntries* pEntries = GetTopLevelSelection()->GetEntries();

	SvLBoxEntry* pNewEntry = NULL;
	SvLBoxEntry* pCurEntry =
		pTarget != NULL ? pTarget : aContentsListBox->GetCurEntry();

	if ( bFront )
	{
		pEntries->insert( pEntries->begin(), pNewEntryData );
		pNewEntry = InsertEntryIntoUI( pNewEntryData, 0 );
	}
	else if ( pCurEntry == NULL || pCurEntry == aContentsListBox->Last() )
	{
		pEntries->push_back( pNewEntryData );
		pNewEntry = InsertEntryIntoUI( pNewEntryData );
	}
	else
	{
		SvxConfigEntry* pEntryData =
			(SvxConfigEntry*) pCurEntry->GetUserData();

		SvxEntries::iterator iter = pEntries->begin();
		SvxEntries::const_iterator end = pEntries->end();

		// Advance the iterator to the data for currently selected entry
		sal_uInt16 nPos = 0;
		while (*iter != pEntryData && ++iter != end)
		{
			nPos++;
		}

		// Now step past it to the entry after the currently selected one
		iter++;
		nPos++;

		// Now add the new entry to the UI and to the parent's list
		if ( iter != end )
		{
			pEntries->insert( iter, pNewEntryData );
			pNewEntry = InsertEntryIntoUI( pNewEntryData, nPos );
		}
	}

	if ( pNewEntry != NULL )
	{
		aContentsListBox->Select( pNewEntry );
		aContentsListBox->MakeVisible( pNewEntry );

		GetSaveInData()->SetModified( sal_True );
	}

	return pNewEntry;
}

SvLBoxEntry* SvxConfigPage::InsertEntryIntoUI(
	SvxConfigEntry* pNewEntryData, sal_uLong nPos )
{
	SvLBoxEntry* pNewEntry = NULL;

	if (pNewEntryData->IsSeparator())
	{
		pNewEntry = aContentsListBox->InsertEntry(
			String::CreateFromAscii( pSeparatorStr ),
				0, sal_False, nPos, pNewEntryData );
	}
	else
	{
		OUString aName = stripHotKey( pNewEntryData->GetName() );

		Image aImage = GetSaveInData()->GetImage(
			pNewEntryData->GetCommand());

		if ( !!aImage )
		{
			pNewEntry = aContentsListBox->InsertEntry(
				aName, aImage, aImage, 0, sal_False, nPos, pNewEntryData );
		}
		else
		{
			pNewEntry = aContentsListBox->InsertEntry(
				aName, 0, sal_False, nPos, pNewEntryData );
		}

		if ( pNewEntryData->IsPopup() ||
			 pNewEntryData->GetStyle() & css::ui::ItemStyle::DROP_DOWN )
		{
			// add new popup painter, it gets destructed by the entry
			pNewEntry->ReplaceItem(
				new PopupPainter( pNewEntry, aName ),
				pNewEntry->ItemCount() - 1 );
		}
	}

	return pNewEntry;
}

IMPL_LINK( SvxConfigPage, AsyncInfoMsg, String*, pMsg )
{
	(void)pMsg;

	// Asynchronous msg because of D&D
	InfoBox( this, CUI_RES(
		IBX_MNUCFG_ALREADY_INCLUDED ) ).Execute();

	return 0;
}

IMPL_LINK( SvxConfigPage, MoveHdl, Button *, pButton )
{
	MoveEntry( pButton == &aMoveUpButton );
	return 0;
}

void SvxConfigPage::MoveEntry( bool bMoveUp )
{
	SvLBoxEntry *pSourceEntry = aContentsListBox->FirstSelected();
	SvLBoxEntry *pTargetEntry = NULL;
	SvLBoxEntry *pToSelect = NULL;

	if ( !pSourceEntry )
	{
		return;
	}

	if ( bMoveUp )
	{
		// Move Up is just a Move Down with the source and target reversed
		pTargetEntry = pSourceEntry;
		pSourceEntry = aContentsListBox->PrevSibling( pTargetEntry );
		pToSelect = pTargetEntry;
	}
	else
	{
		pTargetEntry = aContentsListBox->NextSibling( pSourceEntry );
		pToSelect = pSourceEntry;
	}

	if ( MoveEntryData( pSourceEntry, pTargetEntry ) )
	{
		aContentsListBox->GetModel()->Move( pSourceEntry, pTargetEntry );
		aContentsListBox->Select( pToSelect );
		aContentsListBox->MakeVisible( pToSelect );

		UpdateButtonStates();
	}
}

bool SvxConfigPage::MoveEntryData(
	SvLBoxEntry* pSourceEntry, SvLBoxEntry* pTargetEntry )
{
	//modified by shizhoubo for issue53677
	if ( NULL == pSourceEntry || NULL == pTargetEntry )
 	{
 		return sal_False;
 	}

	// Grab the entries list for the currently selected menu
	SvxEntries* pEntries = GetTopLevelSelection()->GetEntries();

	SvxConfigEntry* pSourceData =
		(SvxConfigEntry*) pSourceEntry->GetUserData();

	if ( pTargetEntry == NULL )
	{
		RemoveEntry( pEntries, pSourceData );
		pEntries->insert(
			pEntries->begin(), pSourceData );

		GetSaveInData()->SetModified( sal_True );

		return sal_True;
	}
	else
	{
		SvxConfigEntry* pTargetData =
			(SvxConfigEntry*) pTargetEntry->GetUserData();

		if ( pSourceData != NULL && pTargetData != NULL )
		{
			// remove the source entry from our list
			RemoveEntry( pEntries, pSourceData );

			SvxEntries::iterator iter = pEntries->begin();
			SvxEntries::const_iterator end = pEntries->end();

			// advance the iterator to the position of the target entry
			while (*iter != pTargetData && ++iter != end) ;

			// insert the source entry at the position after the target
			pEntries->insert( ++iter, pSourceData );

			GetSaveInData()->SetModified( sal_True );

			return sal_True;
		}
	}

	return sal_False;
}

SvxMenuConfigPage::SvxMenuConfigPage(
    Window *pParent, const SfxItemSet& rSet )
	:
	SvxConfigPage( pParent, rSet )
{
	aContentsListBox = new SvxMenuEntriesListBox( this, CUI_RES( BOX_ENTRIES ) );
    FreeResource();

	PositionContentsListBox();
	aContentsListBox->SetZOrder( &aAddCommandsButton, WINDOW_ZORDER_BEFOR );

	aTopLevelListBox.SetSelectHdl(
		LINK( this, SvxMenuConfigPage, SelectMenu ) );

	aContentsListBox->SetSelectHdl(
		LINK( this, SvxMenuConfigPage, SelectMenuEntry ) );

	aMoveUpButton.SetClickHdl ( LINK( this, SvxConfigPage, MoveHdl) );
	aMoveDownButton.SetClickHdl	( LINK( this, SvxConfigPage, MoveHdl) );

	aNewTopLevelButton.SetClickHdl	(
		LINK( this, SvxMenuConfigPage, NewMenuHdl ) );

	aAddCommandsButton.SetClickHdl	(
		LINK( this, SvxMenuConfigPage, AddCommandsHdl ) );

	PopupMenu* pMenu = new PopupMenu( CUI_RES( MODIFY_MENU ) );
	pMenu->SetMenuFlags(
		pMenu->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES );

	aModifyTopLevelButton.SetPopupMenu( pMenu );
	aModifyTopLevelButton.SetSelectHdl(
		LINK( this, SvxMenuConfigPage, MenuSelectHdl ) );

	PopupMenu* pEntry = new PopupMenu( CUI_RES( MODIFY_ENTRY ) );
	pEntry->SetMenuFlags(
		pEntry->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES );

	aModifyCommandButton.SetPopupMenu( pEntry );
	aModifyCommandButton.SetSelectHdl(
		LINK( this, SvxMenuConfigPage, EntrySelectHdl ) );
}

// Populates the Menu combo box
void SvxMenuConfigPage::Init()
{
	// ensure that the UI is cleared before populating it
	aTopLevelListBox.Clear();
	aContentsListBox->Clear();

	ReloadTopLevelListBox();

	aTopLevelListBox.SelectEntryPos(0, sal_True);
	aTopLevelListBox.GetSelectHdl().Call(this);
}

SvxMenuConfigPage::~SvxMenuConfigPage()
{
	for ( sal_uInt16 i = 0 ; i < aSaveInListBox.GetEntryCount(); i++ )
	{
		MenuSaveInData* pData =
			(MenuSaveInData*) aSaveInListBox.GetEntryData( i );

		delete pData;
	}

	if ( pSelectorDlg != NULL )
	{
		delete pSelectorDlg;
	}

	delete aContentsListBox;
}

IMPL_LINK( SvxMenuConfigPage, SelectMenuEntry, Control *, pBox )
{
	(void)pBox;

	UpdateButtonStates();

	return 1;
}

void SvxMenuConfigPage::UpdateButtonStates()
{
	PopupMenu* pPopup = aModifyCommandButton.GetPopupMenu();

	// Disable Up and Down buttons depending on current selection
	SvLBoxEntry* selection = aContentsListBox->GetCurEntry();

	if ( aContentsListBox->GetEntryCount() == 0 || selection == NULL )
	{
		aMoveUpButton.Enable( sal_False );
		aMoveDownButton.Enable( sal_False );

		pPopup->EnableItem( ID_BEGIN_GROUP, sal_True );
		pPopup->EnableItem( ID_RENAME, sal_False );
		pPopup->EnableItem( ID_DELETE, sal_False );

        aDescriptionField.Clear();

		return;
	}

	SvLBoxEntry* first = aContentsListBox->First();
	SvLBoxEntry* last = aContentsListBox->Last();

	aMoveUpButton.Enable( selection != first );
	aMoveDownButton.Enable( selection != last );

	SvxConfigEntry* pEntryData =
		(SvxConfigEntry*) selection->GetUserData();

	if ( pEntryData->IsSeparator() )
	{
		pPopup->EnableItem( ID_DELETE, sal_True );
		pPopup->EnableItem( ID_BEGIN_GROUP, sal_False );
		pPopup->EnableItem( ID_RENAME, sal_False );

        aDescriptionField.Clear();
	}
	else
	{
		pPopup->EnableItem( ID_BEGIN_GROUP, sal_True );
		pPopup->EnableItem( ID_DELETE, sal_True );
		pPopup->EnableItem( ID_RENAME, sal_True );

        aDescriptionField.SetNewText( pEntryData->GetHelpText() );
	}
}

void SvxMenuConfigPage::DeleteSelectedTopLevel()
{
	SvxConfigEntry* pMenuData = GetTopLevelSelection();

	SvxEntries* pParentEntries =
		FindParentForChild( GetSaveInData()->GetEntries(), pMenuData );

	RemoveEntry( pParentEntries, pMenuData );
	delete pMenuData;

	ReloadTopLevelListBox();

	GetSaveInData()->SetModified( sal_True );
}

bool SvxMenuConfigPage::DeleteSelectedContent()
{
	SvLBoxEntry *pActEntry = aContentsListBox->FirstSelected();

	if ( pActEntry != NULL )
	{
		// get currently selected menu entry
		SvxConfigEntry* pMenuEntry =
			(SvxConfigEntry*) pActEntry->GetUserData();

		// get currently selected menu
		SvxConfigEntry* pMenu = GetTopLevelSelection();

		// remove menu entry from the list for this menu
		RemoveEntry( pMenu->GetEntries(), pMenuEntry );

		// remove menu entry from UI
		aContentsListBox->GetModel()->Remove( pActEntry );

		// if this is a submenu entry, redraw the menus list box
		if ( pMenuEntry->IsPopup() )
		{
			ReloadTopLevelListBox();
		}

		// delete data for menu entry
		delete pMenuEntry;

		GetSaveInData()->SetModified( sal_True );

		return sal_True;
	}
	return sal_False;
}

short SvxMenuConfigPage::QueryReset()
{
	String msg =
		String( CUI_RES( RID_SVXSTR_CONFIRM_MENU_RESET ) );

	String saveInName = aSaveInListBox.GetEntry(
		aSaveInListBox.GetSelectEntryPos() );

	OUString label = replaceSaveInName( msg, saveInName );

	QueryBox qbox( this, WB_YES_NO, label );

	return qbox.Execute();
}

IMPL_LINK( SvxMenuConfigPage, SelectMenu, ListBox *, pBox )
{
	(void)pBox;

	aContentsListBox->Clear();

	SvxConfigEntry* pMenuData = GetTopLevelSelection();

	PopupMenu* pPopup = aModifyTopLevelButton.GetPopupMenu();
    if ( pMenuData )
    {
	    pPopup->EnableItem( ID_DELETE, pMenuData->IsDeletable() );
	    pPopup->EnableItem( ID_RENAME, pMenuData->IsRenamable() );
	    pPopup->EnableItem( ID_MOVE, pMenuData->IsMovable() );

	    SvxEntries* pEntries = pMenuData->GetEntries();
	    SvxEntries::const_iterator iter = pEntries->begin();

	    for ( ; iter != pEntries->end(); iter++ )
	    {
		    SvxConfigEntry* pEntry = *iter;
		    InsertEntryIntoUI( pEntry );
	    }
    }

	UpdateButtonStates();

	return 0;
}

IMPL_LINK( SvxMenuConfigPage, MenuSelectHdl, MenuButton *, pButton )
{
	switch( pButton->GetCurItemId() )
	{
		case ID_DELETE:
		{
			DeleteSelectedTopLevel();
			break;
		}
		case ID_RENAME:
		{
			SvxConfigEntry* pMenuData = GetTopLevelSelection();

			String aNewName( stripHotKey( pMenuData->GetName() ) );
            String aDesc = CUI_RESSSTR( RID_SVXSTR_LABEL_NEW_NAME );

			SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc );
			pNameDialog->SetHelpId( HID_SVX_CONFIG_RENAME_MENU );
            pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_RENAME_MENU ) );

			bool ret = pNameDialog->Execute();

			if ( ret == RET_OK ) {
				pNameDialog->GetName( aNewName );
				pMenuData->SetName( aNewName );

				ReloadTopLevelListBox();

				GetSaveInData()->SetModified( sal_True );
			}

			// #i68101# Moemory leak (!)
			delete pNameDialog;

			break;
		}
		case ID_MOVE:
		{
			SvxConfigEntry* pMenuData = GetTopLevelSelection();

			SvxMainMenuOrganizerDialog* pDialog =
				new SvxMainMenuOrganizerDialog( this,
					GetSaveInData()->GetEntries(), pMenuData );

			bool ret = pDialog->Execute();

			if ( ret == RET_OK )
			{
				GetSaveInData()->SetEntries( pDialog->GetEntries() );

				ReloadTopLevelListBox( pDialog->GetSelectedEntry() );

				GetSaveInData()->SetModified( sal_True );
			}

			delete pDialog;

			break;
		}
		default:
			return sal_False;
	}
	return sal_True;
}

IMPL_LINK( SvxMenuConfigPage, EntrySelectHdl, MenuButton *, pButton )
{
	switch( pButton->GetCurItemId() )
	{
		case ID_ADD_SUBMENU:
		{
            String aNewName;
            String aDesc = CUI_RESSSTR( RID_SVXSTR_SUBMENU_NAME );

			SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc );
			pNameDialog->SetHelpId( HID_SVX_CONFIG_NAME_SUBMENU );
            pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_ADD_SUBMENU ) );

			bool ret = pNameDialog->Execute();

			if ( ret == RET_OK ) {
				pNameDialog->GetName(aNewName);

				SvxConfigEntry* pNewEntryData =
					new SvxConfigEntry( aNewName, aNewName, sal_True );
				pNewEntryData->SetUserDefined( sal_True );

				InsertEntry( pNewEntryData );

				ReloadTopLevelListBox();

				GetSaveInData()->SetModified( sal_True );
			}

			delete pNameDialog;

			break;
		}
		case ID_BEGIN_GROUP:
		{
			SvxConfigEntry* pNewEntryData = new SvxConfigEntry;
			pNewEntryData->SetUserDefined( sal_True );
			InsertEntry( pNewEntryData );

			break;
		}
		case ID_DELETE:
		{
			DeleteSelectedContent();
			break;
		}
		case ID_RENAME:
		{
			SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry();
			SvxConfigEntry* pEntry =
				(SvxConfigEntry*) pActEntry->GetUserData();

			String aNewName( stripHotKey( pEntry->GetName() ) );
            String aDesc = CUI_RESSSTR( RID_SVXSTR_LABEL_NEW_NAME );

			SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc );
			pNameDialog->SetHelpId( HID_SVX_CONFIG_RENAME_MENU_ITEM );
            pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_RENAME_MENU ) );

			bool ret = pNameDialog->Execute();

			if ( ret == RET_OK ) {
				pNameDialog->GetName(aNewName);

				pEntry->SetName( aNewName );
				aContentsListBox->SetEntryText( pActEntry, aNewName );

				GetSaveInData()->SetModified( sal_True );
			}

			delete pNameDialog;

			break;
		}
		default:
		{
			return sal_False;
		}
	}

	if ( GetSaveInData()->IsModified() )
	{
		UpdateButtonStates();
	}

	return sal_True;
}

IMPL_LINK( SvxMenuConfigPage, AddFunctionHdl,
	SvxScriptSelectorDialog *, pDialog )
{
	(void)pDialog;

	AddFunction();

	return 0;
}

IMPL_LINK( SvxMenuConfigPage, NewMenuHdl, Button *, pButton )
{
	(void)pButton;

	SvxMainMenuOrganizerDialog* pDialog =
		new SvxMainMenuOrganizerDialog( 0,
			GetSaveInData()->GetEntries(), NULL, sal_True );

	bool ret = pDialog->Execute();

	if ( ret == RET_OK )
	{
		GetSaveInData()->SetEntries( pDialog->GetEntries() );
		ReloadTopLevelListBox( pDialog->GetSelectedEntry() );
		GetSaveInData()->SetModified( sal_True );
	}

	delete pDialog;

	return 0;
}

IMPL_LINK( SvxMenuConfigPage, AddCommandsHdl, Button *, pButton )
{
	(void)pButton;

	if ( pSelectorDlg == NULL )
	{
		// Create Script Selector which also shows builtin commands
		pSelectorDlg = new SvxScriptSelectorDialog( this, sal_True, m_xFrame );

		pSelectorDlg->SetAddHdl(
			LINK( this, SvxMenuConfigPage, AddFunctionHdl ) );

		pSelectorDlg->SetDialogDescription( String(
			CUI_RES( RID_SVXSTR_MENU_ADDCOMMANDS_DESCRIPTION ) ) );
	}

	// Position the Script Selector over the Add button so it is
	// beside the menu contents list and does not obscure it
	pSelectorDlg->SetPosPixel( aAddCommandsButton.GetPosPixel() );

	pSelectorDlg->SetImageProvider(
		static_cast< ImageProvider* >( GetSaveInData() ) );

	pSelectorDlg->Show();
	return 1;
}

SaveInData* SvxMenuConfigPage::CreateSaveInData(
	const uno::Reference< css::ui::XUIConfigurationManager >& xCfgMgr,
    const uno::Reference< css::ui::XUIConfigurationManager >& xParentCfgMgr,
	const OUString& aModuleId,
	bool bDocConfig )
{
	return static_cast< SaveInData* >(
		new MenuSaveInData( xCfgMgr, xParentCfgMgr, aModuleId, bDocConfig ));
}

SvxMainMenuOrganizerDialog::SvxMainMenuOrganizerDialog(
	Window* pParent, SvxEntries* entries,
	SvxConfigEntry* selection, bool bCreateMenu )
	:
	ModalDialog( pParent, CUI_RES( MD_MENU_ORGANISER ) ),
	aMenuNameText( this, CUI_RES( TXT_MENU_NAME ) ),
	aMenuNameEdit( this, CUI_RES( EDIT_MENU_NAME ) ),
	aMenuListText( this, CUI_RES( TXT_MENU ) ),
	aMenuListBox( this, CUI_RES( BOX_MAIN_MENUS ) ),
	aMoveUpButton( this, CUI_RES( BTN_MENU_UP ) ),
	aMoveDownButton( this, CUI_RES( BTN_MENU_DOWN ) ),
	aOKButton( this, CUI_RES( BTN_MENU_ADD ) ),
	aCloseButton( this, CUI_RES( BTN_MENU_CLOSE ) ),
	aHelpButton( this, CUI_RES( BTN_MENU_HELP ) ),
	bModified( sal_False )
{
	FreeResource();

	// Copy the entries list passed in
	if ( entries != NULL )
	{
		SvxConfigEntry* pEntry;
		SvLBoxEntry* pLBEntry;

		pEntries = new SvxEntries();
		SvxEntries::const_iterator iter = entries->begin();

		while ( iter != entries->end() )
		{
			pEntry = *iter;
			pLBEntry =
				aMenuListBox.InsertEntry( stripHotKey( pEntry->GetName() ) );
			pLBEntry->SetUserData( pEntry );
			pEntries->push_back( pEntry );

			if ( pEntry == selection )
			{
				aMenuListBox.Select( pLBEntry );
			}
			iter++;
		}
	}

	if ( bCreateMenu )
	{
		// Generate custom name for new menu
		String prefix =
			String( CUI_RES( RID_SVXSTR_NEW_MENU ) );

		OUString newname = generateCustomName( prefix, entries );
		OUString newurl = generateCustomMenuURL( pEntries );

		SvxConfigEntry* pNewEntryData =
			new SvxConfigEntry( newname, newurl, sal_True );
		pNewEntryData->SetUserDefined( sal_True );
		pNewEntryData->SetMain( sal_True );

		pNewMenuEntry =
			aMenuListBox.InsertEntry( stripHotKey( pNewEntryData->GetName() ) );
		aMenuListBox.Select( pNewMenuEntry );

		pNewMenuEntry->SetUserData( pNewEntryData );

		pEntries->push_back( pNewEntryData );

		aMenuNameEdit.SetText( newname );
    	aMenuNameEdit.SetModifyHdl(
			LINK( this, SvxMainMenuOrganizerDialog, ModifyHdl ) );
	}
	else
	{
		Point p, newp;
		Size s, news;

		// get offset to bottom of name textfield from top of dialog
		p = aMenuNameEdit.GetPosPixel();
		s = aMenuNameEdit.GetSizePixel();
		long offset = p.Y() + s.Height();

		// reposition menu list and label
		aMenuListText.SetPosPixel( aMenuNameText.GetPosPixel() );
		aMenuListBox.SetPosPixel( aMenuNameEdit.GetPosPixel() );

		// reposition up and down buttons
        p = aMoveUpButton.GetPosPixel();
        newp = Point( p.X(), p.Y() - offset );
		aMoveUpButton.SetPosPixel( newp );

        p = aMoveDownButton.GetPosPixel();
        newp = Point( p.X(), p.Y() - offset );
		aMoveDownButton.SetPosPixel( newp );

		// change size of dialog
		s = GetSizePixel();
		news = Size( s.Width(), s.Height() - offset );
		SetSizePixel( news );

		// hide name label and textfield
		aMenuNameText.Hide();
		aMenuNameEdit.Hide();

		// change the title
		SetText( CUI_RES( RID_SVXSTR_MOVE_MENU ) );
	}

	aMenuListBox.SetSelectHdl(
		LINK( this, SvxMainMenuOrganizerDialog, SelectHdl ) );

	aMoveUpButton.SetClickHdl (
		LINK( this, SvxMainMenuOrganizerDialog, MoveHdl) );
	aMoveDownButton.SetClickHdl	(
		LINK( this, SvxMainMenuOrganizerDialog, MoveHdl) );

	aMoveUpButton.SetAccessibleName(String(CUI_RES(BUTTON_STR_UP)));
	aMoveDownButton.SetAccessibleName(String(CUI_RES(BUTTON_STR_DOWN)));
}

IMPL_LINK(SvxMainMenuOrganizerDialog, ModifyHdl, Edit*, pEdit)
{
	(void)pEdit;

	// if the Edit control is empty do not change the name
	if ( aMenuNameEdit.GetText().Equals( String() ) )
	{
		return 0;
	}

	SvxConfigEntry* pNewEntryData =
		(SvxConfigEntry*) pNewMenuEntry->GetUserData();

	pNewEntryData->SetName( aMenuNameEdit.GetText() );

	aMenuListBox.SetEntryText( pNewMenuEntry, pNewEntryData->GetName() );

    return 0;
}

SvxMainMenuOrganizerDialog::~SvxMainMenuOrganizerDialog()
{
}

IMPL_LINK( SvxMainMenuOrganizerDialog, SelectHdl, Control*, pCtrl )
{
	(void)pCtrl;
	UpdateButtonStates();
	return 1;
}

void SvxMainMenuOrganizerDialog::UpdateButtonStates()
{
	// Disable Up and Down buttons depending on current selection
	SvLBoxEntry* selection = aMenuListBox.GetCurEntry();
	SvLBoxEntry* first = aMenuListBox.First();
	SvLBoxEntry* last = aMenuListBox.Last();

	aMoveUpButton.Enable( selection != first );
	aMoveDownButton.Enable( selection != last );
}

IMPL_LINK( SvxMainMenuOrganizerDialog, MoveHdl, Button *, pButton )
{
	SvLBoxEntry *pSourceEntry = aMenuListBox.FirstSelected();
	SvLBoxEntry *pTargetEntry = NULL;

	if ( !pSourceEntry )
	{
		return 0;
	}

	if ( pButton == &aMoveDownButton )
	{
		pTargetEntry = aMenuListBox.NextSibling( pSourceEntry );
	}
	else if ( pButton == &aMoveUpButton )
	{
		// Move Up is just a Move Down with the source and target reversed
		pTargetEntry = pSourceEntry;
		pSourceEntry = aMenuListBox.PrevSibling( pTargetEntry );
	}

	if ( pSourceEntry != NULL && pTargetEntry != NULL )
	{
		SvxConfigEntry* pSourceData =
			(SvxConfigEntry*) pSourceEntry->GetUserData();
		SvxConfigEntry* pTargetData =
			(SvxConfigEntry*) pTargetEntry->GetUserData();

		SvxEntries::iterator iter1 = GetEntries()->begin();
		SvxEntries::iterator iter2 = GetEntries()->begin();
		SvxEntries::const_iterator end = GetEntries()->end();

		// Advance the iterators to the positions of the source and target
		while (*iter1 != pSourceData && ++iter1 != end) ;
		while (*iter2 != pTargetData && ++iter2 != end) ;

		// Now swap the entries in the menu list and in the UI
		if ( iter1 != end && iter2 != end )
		{
			std::swap( *iter1, *iter2 );
			aMenuListBox.GetModel()->Move( pSourceEntry, pTargetEntry );
			aMenuListBox.MakeVisible( pSourceEntry );

			bModified = sal_True;
		}
	}

	if ( bModified )
	{
		UpdateButtonStates();
	}

	return 0;
}

SvxEntries* SvxMainMenuOrganizerDialog::GetEntries()
{
	return pEntries;
}

SvxConfigEntry* SvxMainMenuOrganizerDialog::GetSelectedEntry()
{
	return (SvxConfigEntry*)aMenuListBox.FirstSelected()->GetUserData();
}

const OUString&
SvxConfigEntry::GetHelpText()
{
	if ( aHelpText.getLength() == 0 )
	{
		if ( aCommand.getLength() )
		{
			aHelpText = Application::GetHelp()->GetHelpText( aCommand, NULL );
		}
	}

	return aHelpText;
}

SvxConfigEntry::SvxConfigEntry( const OUString& rDisplayName,
								const OUString& rCommandURL, bool bPopup, bool bParentData )
	: nId( 1 )
	, aLabel(rDisplayName)
	, aCommand(rCommandURL)
	, bPopUp(bPopup)
	, bStrEdited( sal_False )
	, bIsUserDefined( sal_False )
	, bIsMain( sal_False )
    , bIsParentData( bParentData )
	, bIsVisible( sal_True )
	, nStyle( 0 )
	, pEntries( 0 )
{
	if (bPopUp)
	{
		pEntries = new SvxEntries();
	}
}

SvxConfigEntry::~SvxConfigEntry()
{
	if ( pEntries != NULL )
	{
		SvxEntries::const_iterator iter = pEntries->begin();

		for ( ; iter != pEntries->end(); iter++ )
		{
			delete *iter;
		}
		delete pEntries;
	}
}

bool SvxConfigEntry::IsMovable()
{
	if ( IsPopup() && !IsMain() )
	{
		return sal_False;
	}
	return sal_True;
}

bool SvxConfigEntry::IsDeletable()
{
	if ( IsMain() && !IsUserDefined() )
	{
		return sal_False;
	}
	return sal_True;
}

bool SvxConfigEntry::IsRenamable()
{
	if ( IsMain() && !IsUserDefined() )
	{
		return sal_False;
	}
	return sal_True;
}

SvxToolbarConfigPage::SvxToolbarConfigPage(
	Window *pParent, const SfxItemSet& rSet )
	:
	SvxConfigPage( pParent, rSet )
{
	SetHelpId( HID_SVX_CONFIG_TOOLBAR );

	aContentsListBox = new SvxToolbarEntriesListBox(this, CUI_RES(BOX_ENTRIES));
	FreeResource();
	PositionContentsListBox();
	aContentsListBox->SetZOrder( &aAddCommandsButton, WINDOW_ZORDER_BEFOR );

	aContentsListBox->SetHelpId( HID_SVX_CONFIG_TOOLBAR_CONTENTS );
    aNewTopLevelButton.SetHelpId( HID_SVX_NEW_TOOLBAR );
    aModifyTopLevelButton.SetHelpId( HID_SVX_MODIFY_TOOLBAR );
    aAddCommandsButton.SetHelpId( HID_SVX_NEW_TOOLBAR_ITEM );
    aModifyCommandButton.SetHelpId( HID_SVX_MODIFY_TOOLBAR_ITEM );
    aSaveInListBox.SetHelpId( HID_SVX_SAVE_IN );

	aTopLevelSeparator.SetText(
		CUI_RES ( RID_SVXSTR_PRODUCTNAME_TOOLBARS ) );

	aTopLevelLabel.SetText( CUI_RES( RID_SVXSTR_TOOLBAR ) );
	aModifyTopLevelButton.SetText( CUI_RES( RID_SVXSTR_TOOLBAR ) );
	aContentsSeparator.SetText( CUI_RES( RID_SVXSTR_TOOLBAR_CONTENT ) );
	aContentsLabel.SetText( CUI_RES( RID_SVXSTR_COMMANDS ) );

	aTopLevelListBox.SetSelectHdl(
		LINK( this, SvxToolbarConfigPage, SelectToolbar ) );
	aContentsListBox->SetSelectHdl(
		LINK( this, SvxToolbarConfigPage, SelectToolbarEntry ) );

	aNewTopLevelButton.SetClickHdl	(
		LINK( this, SvxToolbarConfigPage, NewToolbarHdl ) );

	aAddCommandsButton.SetClickHdl	(
		LINK( this, SvxToolbarConfigPage, AddCommandsHdl ) );

	aMoveUpButton.SetClickHdl ( LINK( this, SvxToolbarConfigPage, MoveHdl) );
	aMoveDownButton.SetClickHdl	( LINK( this, SvxToolbarConfigPage, MoveHdl) );
    // Always enable Up and Down buttons
    // added for issue i53677 by shizhoubo
    aMoveDownButton.Enable( sal_True );
    aMoveUpButton.Enable( sal_True );

	PopupMenu* pMenu = new PopupMenu( CUI_RES( MODIFY_TOOLBAR ) );
	pMenu->SetMenuFlags(
		pMenu->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES );

	aModifyTopLevelButton.SetPopupMenu( pMenu );
	aModifyTopLevelButton.SetSelectHdl(
		LINK( this, SvxToolbarConfigPage, ToolbarSelectHdl ) );

	PopupMenu* pEntry = new PopupMenu(
		CUI_RES( MODIFY_TOOLBAR_CONTENT ) );
	pEntry->SetMenuFlags(
		pEntry->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES );

	aModifyCommandButton.SetPopupMenu( pEntry );
	aModifyCommandButton.SetSelectHdl(
		LINK( this, SvxToolbarConfigPage, EntrySelectHdl ) );

	// default toolbar to select is standardbar unless a different one
	// has been passed in
	m_aURLToSelect = OUString::createFromAscii( ITEM_TOOLBAR_URL );
	m_aURLToSelect += OUString::createFromAscii( "standardbar" );

	const SfxPoolItem* pItem =
		rSet.GetItem( rSet.GetPool()->GetWhich( SID_CONFIG ) );

	if ( pItem )
	{
		OUString text = ((const SfxStringItem*)pItem)->GetValue();
		if (text.indexOf(OUString::createFromAscii(ITEM_TOOLBAR_URL)) == 0)
		{
			m_aURLToSelect = text.copy( 0 );
		}
	}

    long nTxtW = aTopLevelLabel.GetCtrlTextWidth( aTopLevelLabel.GetText() );
    long nCtrlW = aTopLevelLabel.GetSizePixel().Width();
    if ( nTxtW >= nCtrlW )
    {
        long nDelta = Max( (long)10, nTxtW - nCtrlW );
        Size aNewSz = aTopLevelLabel.GetSizePixel();
        aNewSz.Width() += nDelta;
        aTopLevelLabel.SetSizePixel( aNewSz );
        aNewSz = aTopLevelListBox.GetSizePixel();
        aNewSz.Width() -= nDelta;
        Point aNewPt = aTopLevelListBox.GetPosPixel();
        aNewPt.X() += nDelta;
        aTopLevelListBox.SetPosSizePixel( aNewPt, aNewSz );
    }
}

SvxToolbarConfigPage::~SvxToolbarConfigPage()
{
	for ( sal_uInt16 i = 0 ; i < aSaveInListBox.GetEntryCount(); i++ )
	{
		ToolbarSaveInData* pData =
			(ToolbarSaveInData*) aSaveInListBox.GetEntryData( i );

		delete pData;
	}

	if ( pSelectorDlg != NULL )
	{
		delete pSelectorDlg;
	}


	delete aContentsListBox;
}

void SvxToolbarConfigPage::DeleteSelectedTopLevel()
{
	sal_uInt16 nSelectionPos = aTopLevelListBox.GetSelectEntryPos();
	ToolbarSaveInData* pSaveInData = (ToolbarSaveInData*) GetSaveInData();
	pSaveInData->RemoveToolbar( GetTopLevelSelection() );

	if ( aTopLevelListBox.GetEntryCount() > 1 )
	{
		// select next entry after the one being deleted
		// selection position is indexed from 0 so need to
		// subtract one from the entry count
		if ( nSelectionPos != aTopLevelListBox.GetEntryCount() - 1 )
		{
			aTopLevelListBox.SelectEntryPos( nSelectionPos + 1, sal_True );
		}
		else
		{
			aTopLevelListBox.SelectEntryPos( nSelectionPos - 1, sal_True );
		}
		aTopLevelListBox.GetSelectHdl().Call( this );

		// and now remove the entry
		aTopLevelListBox.RemoveEntry( nSelectionPos );
	}
	else
	{
		ReloadTopLevelListBox();
	}
}

bool SvxToolbarConfigPage::DeleteSelectedContent()
{
	SvLBoxEntry *pActEntry = aContentsListBox->FirstSelected();

	if ( pActEntry != NULL )
	{
		// get currently selected entry
		SvxConfigEntry* pEntry =
			(SvxConfigEntry*) pActEntry->GetUserData();

		SvxConfigEntry* pToolbar = GetTopLevelSelection();

		// remove entry from the list for this toolbar
		RemoveEntry( pToolbar->GetEntries(), pEntry );

		// remove toolbar entry from UI
		aContentsListBox->GetModel()->Remove( pActEntry );

		// delete data for toolbar entry
		delete pEntry;

		(( ToolbarSaveInData* ) GetSaveInData())->ApplyToolbar( pToolbar );
		UpdateButtonStates();

		// if this is the last entry in the toolbar and it is a user
		// defined toolbar pop up a dialog asking the user if they
		// want to delete the toolbar
		if ( aContentsListBox->GetEntryCount() == 0 &&
			 GetTopLevelSelection()->IsDeletable() )
		{
			QueryBox qbox( this,
				CUI_RES( QBX_CONFIRM_DELETE_TOOLBAR ) );

			if ( qbox.Execute() == RET_YES )
			{
				DeleteSelectedTopLevel();
			}
		}

		return sal_True;
	}

	return sal_False;
}

IMPL_LINK( SvxToolbarConfigPage, MoveHdl, Button *, pButton )
{
	MoveEntry( pButton == &aMoveUpButton );
	return 0;
}

void SvxToolbarConfigPage::MoveEntry( bool bMoveUp )
{
	SvxConfigPage::MoveEntry( bMoveUp );

	// Apply change to currently selected toolbar
	SvxConfigEntry* pToolbar = GetTopLevelSelection();
    if ( pToolbar )
        ((ToolbarSaveInData*)GetSaveInData())->ApplyToolbar( pToolbar );
    else
    {
        DBG_ERRORFILE( "SvxToolbarConfigPage::MoveEntry(): no entry" );
        UpdateButtonStates();
    }
}

IMPL_LINK( SvxToolbarConfigPage, ToolbarSelectHdl, MenuButton *, pButton )
{
	sal_uInt16 nSelectionPos = aTopLevelListBox.GetSelectEntryPos();

	SvxConfigEntry* pToolbar =
		(SvxConfigEntry*)aTopLevelListBox.GetEntryData( nSelectionPos );

	ToolbarSaveInData* pSaveInData = (ToolbarSaveInData*) GetSaveInData();

	switch( pButton->GetCurItemId() )
	{
		case ID_DELETE:
		{
			DeleteSelectedTopLevel();
            UpdateButtonStates();
			break;
		}
		case ID_RENAME:
		{
			String aNewName( stripHotKey( pToolbar->GetName() ) );
            String aDesc = CUI_RESSSTR( RID_SVXSTR_LABEL_NEW_NAME );

			SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc );
			pNameDialog->SetHelpId( HID_SVX_CONFIG_RENAME_TOOLBAR );
            pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_RENAME_TOOLBAR ) );

			bool ret = pNameDialog->Execute();

			if ( ret == RET_OK )
			{
				pNameDialog->GetName(aNewName);

				pToolbar->SetName( aNewName );
				pSaveInData->ApplyToolbar( pToolbar );

				// have to use remove and insert to change the name
				aTopLevelListBox.RemoveEntry( nSelectionPos );
				nSelectionPos =
					aTopLevelListBox.InsertEntry( aNewName, nSelectionPos );
				aTopLevelListBox.SetEntryData( nSelectionPos, pToolbar );
				aTopLevelListBox.SelectEntryPos( nSelectionPos );
			}

			delete pNameDialog;

			break;
		}
		case ID_DEFAULT_STYLE:
		{
			QueryBox qbox( this,
				CUI_RES( QBX_CONFIRM_RESTORE_DEFAULT ) );

			if ( qbox.Execute() == RET_YES )
			{
				ToolbarSaveInData* pSaveInData_ =
					(ToolbarSaveInData*) GetSaveInData();

				pSaveInData_->RestoreToolbar( pToolbar );

				aTopLevelListBox.GetSelectHdl().Call( this );
			}

			break;
		}
		case ID_ICONS_ONLY:
		{
			pToolbar->SetStyle( 0 );
			pSaveInData->SetSystemStyle( m_xFrame, pToolbar->GetCommand(), 0 );

			aTopLevelListBox.GetSelectHdl().Call( this );

			break;
		}
		case ID_TEXT_ONLY:
		{
			pToolbar->SetStyle( 1 );
			pSaveInData->SetSystemStyle( m_xFrame, pToolbar->GetCommand(), 1 );

			aTopLevelListBox.GetSelectHdl().Call( this );

			break;
		}
		case ID_ICONS_AND_TEXT:
		{
			pToolbar->SetStyle( 2 );
			pSaveInData->SetSystemStyle( m_xFrame, pToolbar->GetCommand(), 2 );

			aTopLevelListBox.GetSelectHdl().Call( this );

			break;
		}
	}
	return 1;
}

IMPL_LINK( SvxToolbarConfigPage, EntrySelectHdl, MenuButton *, pButton )
{
	bool bNeedsApply = sal_False;

	// get currently selected toolbar
	SvxConfigEntry* pToolbar = GetTopLevelSelection();

	switch( pButton->GetCurItemId() )
	{
		case ID_RENAME:
		{
			SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry();
			SvxConfigEntry* pEntry =
				(SvxConfigEntry*) pActEntry->GetUserData();

			String aNewName( stripHotKey( pEntry->GetName() ) );
            String aDesc = CUI_RESSSTR( RID_SVXSTR_LABEL_NEW_NAME );

			SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc );
			pNameDialog->SetHelpId( HID_SVX_CONFIG_RENAME_TOOLBAR_ITEM );
            pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_RENAME_TOOLBAR ) );

			bool ret = pNameDialog->Execute();

			if ( ret == RET_OK ) {
				pNameDialog->GetName(aNewName);

				pEntry->SetName( aNewName );
				aContentsListBox->SetEntryText( pActEntry, aNewName );

				bNeedsApply = sal_True;
			}

			delete pNameDialog;
			break;
		}
		case ID_DEFAULT_COMMAND:
		{
			SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry();
			SvxConfigEntry* pEntry =
				(SvxConfigEntry*) pActEntry->GetUserData();

			sal_uInt16 nSelectionPos = 0;

			// find position of entry within the list
			for ( sal_uInt16 i = 0; i < aContentsListBox->GetEntryCount(); i++ )
			{
				if ( aContentsListBox->GetEntry( 0, i ) == pActEntry )
				{
					nSelectionPos = i;
					break;
				}
			}

			ToolbarSaveInData* pSaveInData =
				(ToolbarSaveInData*) GetSaveInData();

			OUString aSystemName =
				pSaveInData->GetSystemUIName( pEntry->GetCommand() );

			if ( !pEntry->GetName().equals( aSystemName ) )
			{
				pEntry->SetName( aSystemName );
				aContentsListBox->SetEntryText(
					pActEntry, stripHotKey( aSystemName ) );
				bNeedsApply = sal_True;
			}

			uno::Sequence< OUString > aURLSeq( 1 );
			aURLSeq[ 0 ] = pEntry->GetCommand();

			try
			{
				GetSaveInData()->GetImageManager()->removeImages(
					GetImageType(), aURLSeq );

				// reset backup in entry
				pEntry->SetBackupGraphic(
					uno::Reference< graphic::XGraphic >() );

				GetSaveInData()->PersistChanges(
				    GetSaveInData()->GetImageManager() );

				aContentsListBox->GetModel()->Remove( pActEntry );

				SvLBoxEntry* pNewLBEntry =
					InsertEntryIntoUI( pEntry, nSelectionPos );

				aContentsListBox->SetCheckButtonState( pNewLBEntry,
					pEntry->IsVisible() ?
						SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED );

				aContentsListBox->Select( pNewLBEntry );
				aContentsListBox->MakeVisible( pNewLBEntry );

				bNeedsApply = sal_True;
			}
           	catch ( uno::Exception& )
           	{
				OSL_TRACE("Error restoring image");
           	}
			break;
		}
		case ID_BEGIN_GROUP:
		{
			SvxConfigEntry* pNewEntryData = new SvxConfigEntry;
			pNewEntryData->SetUserDefined( sal_True );

			SvLBoxEntry* pNewLBEntry = InsertEntry( pNewEntryData );

			aContentsListBox->SetCheckButtonState(
				pNewLBEntry, SV_BUTTON_TRISTATE );

			bNeedsApply = sal_True;
			break;
		}
		case ID_DELETE:
		{
			DeleteSelectedContent();
			break;
		}
		case ID_ICON_ONLY:
		{
			break;
		}
		case ID_TEXT_ONLY:
		{
			break;
		}
		case ID_ICON_AND_TEXT:
		{
			break;
		}
		case ID_CHANGE_SYMBOL:
		{
			SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry();
			SvxConfigEntry* pEntry =
				(SvxConfigEntry*) pActEntry->GetUserData();

			sal_uInt16 nSelectionPos = 0;

			// find position of entry within the list
			for ( sal_uInt16 i = 0; i < aContentsListBox->GetEntryCount(); i++ )
			{
				if ( aContentsListBox->GetEntry( 0, i ) == pActEntry )
				{
					nSelectionPos = i;
					break;
				}
			}

			SvxIconSelectorDialog* pIconDialog =
				new SvxIconSelectorDialog( 0,
					GetSaveInData()->GetImageManager(),
                    GetSaveInData()->GetParentImageManager() );

			bool ret = pIconDialog->Execute();

			if ( ret == RET_OK )
			{
				uno::Reference< graphic::XGraphic > newgraphic =
					pIconDialog->GetSelectedIcon();

				if ( newgraphic.is() )
				{
					uno::Sequence< uno::Reference< graphic::XGraphic > >
						aGraphicSeq( 1 );

					uno::Sequence< OUString > aURLSeq( 1 );
					aURLSeq[ 0 ] = pEntry->GetCommand();

					if ( !pEntry->GetBackupGraphic().is() )
					{
						uno::Reference< graphic::XGraphic > backup;
						backup = GetGraphic(
							GetSaveInData()->GetImageManager(), aURLSeq[ 0 ] );

						if ( backup.is() )
						{
							pEntry->SetBackupGraphic( backup );
						}
					}

					aGraphicSeq[ 0 ] = newgraphic;
					try
					{
						GetSaveInData()->GetImageManager()->replaceImages(
							GetImageType(), aURLSeq, aGraphicSeq );

						Image aImage( newgraphic );

						aContentsListBox->GetModel()->Remove( pActEntry );
						SvLBoxEntry* pNewLBEntry =
							InsertEntryIntoUI( pEntry, nSelectionPos );

						aContentsListBox->SetCheckButtonState( pNewLBEntry,
							pEntry->IsVisible() ?
								SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED );

						aContentsListBox->Select( pNewLBEntry );
						aContentsListBox->MakeVisible( pNewLBEntry );

						GetSaveInData()->PersistChanges(
							GetSaveInData()->GetImageManager() );
					}
            		catch ( uno::Exception& )
            		{
						OSL_TRACE("Error replacing image");
            		}
				}
			}

			delete pIconDialog;

			break;
		}
		case ID_RESET_SYMBOL:
		{
			SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry();
			SvxConfigEntry* pEntry =
				(SvxConfigEntry*) pActEntry->GetUserData();

			sal_uInt16 nSelectionPos = 0;

			// find position of entry within the list
			for ( sal_uInt16 i = 0; i < aContentsListBox->GetEntryCount(); i++ )
			{
				if ( aContentsListBox->GetEntry( 0, i ) == pActEntry )
				{
					nSelectionPos = i;
					break;
				}
			}

			uno::Reference< graphic::XGraphic > backup =
				pEntry->GetBackupGraphic();

			uno::Sequence< uno::Reference< graphic::XGraphic > >
				aGraphicSeq( 1 );
			aGraphicSeq[ 0 ] = backup;

			uno::Sequence< OUString > aURLSeq( 1 );
			aURLSeq[ 0 ] = pEntry->GetCommand();

			try
			{
				GetSaveInData()->GetImageManager()->replaceImages(
					GetImageType(), aURLSeq, aGraphicSeq );

				Image aImage( backup );
				aContentsListBox->GetModel()->Remove( pActEntry );

				SvLBoxEntry* pNewLBEntry =
					InsertEntryIntoUI( pEntry, nSelectionPos );

				aContentsListBox->SetCheckButtonState( pNewLBEntry,
					pEntry->IsVisible() ?
						SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED );

				aContentsListBox->Select( pNewLBEntry );
				aContentsListBox->MakeVisible( pNewLBEntry );

				// reset backup in entry
				pEntry->SetBackupGraphic(
					uno::Reference< graphic::XGraphic >() );

				GetSaveInData()->PersistChanges(
					GetSaveInData()->GetImageManager() );
			}
			catch ( uno::Exception& )
			{
				OSL_TRACE("Error resetting image");
			}
			break;
		}
	}

	if ( bNeedsApply == sal_True )
	{
		(( ToolbarSaveInData* ) GetSaveInData())->ApplyToolbar( pToolbar );
		UpdateButtonStates();
	}

	return 1;
}

void SvxToolbarConfigPage::Init()
{
	// ensure that the UI is cleared before populating it
	aTopLevelListBox.Clear();
	aContentsListBox->Clear();

	ReloadTopLevelListBox();

	sal_uInt16 nPos = 0;
	if ( m_aURLToSelect.getLength() != 0 )
	{
		for ( sal_uInt16 i = 0 ; i < aTopLevelListBox.GetEntryCount(); i++ )
		{
			SvxConfigEntry* pData =
				(SvxConfigEntry*) aTopLevelListBox.GetEntryData( i );

			if ( pData->GetCommand().equals( m_aURLToSelect ) )
			{
				nPos = i;
				break;
			}
		}

		// in future select the default toolbar: Standard
		m_aURLToSelect = OUString::createFromAscii( ITEM_TOOLBAR_URL );
		m_aURLToSelect += OUString::createFromAscii( "standardbar" );
	}

	aTopLevelListBox.SelectEntryPos(nPos, sal_True);
	aTopLevelListBox.GetSelectHdl().Call(this);
}

SaveInData* SvxToolbarConfigPage::CreateSaveInData(
	const uno::Reference< css::ui::XUIConfigurationManager >& xCfgMgr,
    const uno::Reference< css::ui::XUIConfigurationManager >& xParentCfgMgr,
	const OUString& aModuleId,
	bool bDocConfig )
{
	return static_cast< SaveInData* >(
		new ToolbarSaveInData( xCfgMgr, xParentCfgMgr, aModuleId, bDocConfig ));
}

ToolbarSaveInData::ToolbarSaveInData(
    const uno::Reference < css::ui::XUIConfigurationManager >& xCfgMgr,
    const uno::Reference < css::ui::XUIConfigurationManager >& xParentCfgMgr,
	const OUString& aModuleId,
    bool docConfig ) :

    SaveInData              ( xCfgMgr, xParentCfgMgr, aModuleId, docConfig ),
    pRootEntry              ( NULL ),
    m_aDescriptorContainer  ( RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_CONTAINER ) )

{
	// Initialize the m_xPersistentWindowState variable which is used
	// to get the default properties of system toolbars such as name
	uno::Reference< container::XNameAccess > xPWSS(
		m_xServiceManager->createInstance(
			OUString( RTL_CONSTASCII_USTRINGPARAM(
				"com.sun.star.ui.WindowStateConfiguration" ) ) ),
		uno::UNO_QUERY );

	if ( xPWSS.is() )
		xPWSS->getByName( aModuleId ) >>= m_xPersistentWindowState;
}

ToolbarSaveInData::~ToolbarSaveInData()
{
    delete pRootEntry;
}

void ToolbarSaveInData::SetSystemStyle(
	uno::Reference< frame::XFrame > xFrame,
	const OUString& rResourceURL,
	sal_Int32 nStyle )
{
	// change the style using the API
	SetSystemStyle( rResourceURL, nStyle );

	// this code is a temporary hack as the UI is not updating after
	// changing the toolbar style via the API
	uno::Reference< css::frame::XLayoutManager > xLayoutManager;
	Window *window = NULL;

	uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY );
	if ( xPropSet.is() )
	{
		uno::Any a = xPropSet->getPropertyValue(
			OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ) ) );
		a >>= xLayoutManager;
	}

	if ( xLayoutManager.is() )
	{
		uno::Reference< css::ui::XUIElement > xUIElement =
			xLayoutManager->getElement( rResourceURL );

        // check reference before we call getRealInterface. The layout manager
        // can only provide references for elements that have been created
        // before. It's possible that the current element is not available.
        uno::Reference< com::sun::star::awt::XWindow > xWindow;
        if ( xUIElement.is() )
            xWindow = uno::Reference< com::sun::star::awt::XWindow >(
                        xUIElement->getRealInterface(), uno::UNO_QUERY );

		window = VCLUnoHelper::GetWindow( xWindow );
	}

	if ( window != NULL && window->GetType() == WINDOW_TOOLBOX )
	{
		ToolBox* toolbox = (ToolBox*)window;

		if ( nStyle == 0 )
		{
			toolbox->SetButtonType( BUTTON_SYMBOL );
		}
		else if ( nStyle == 1 )
		{
			toolbox->SetButtonType( BUTTON_TEXT );
		}
		if ( nStyle == 2 )
		{
			toolbox->SetButtonType( BUTTON_SYMBOLTEXT );
		}
	}
}

void ToolbarSaveInData::SetSystemStyle(
	const OUString& rResourceURL,
	sal_Int32 nStyle )
{
	if ( rResourceURL.indexOf( OUString::createFromAscii( "private" ) ) == 0 &&
		 m_xPersistentWindowState.is() &&
		 m_xPersistentWindowState->hasByName( rResourceURL ) )
	{
		try
		{
			uno::Sequence< beans::PropertyValue > aProps;

			uno::Any a( m_xPersistentWindowState->getByName( rResourceURL ) );

			if ( a >>= aProps )
			{
				for ( sal_Int32 i = 0; i < aProps.getLength(); i++ )
				{
					if ( aProps[ i ].Name.equalsAscii( ITEM_DESCRIPTOR_STYLE) )
					{
						aProps[ i ].Value = uno::makeAny( nStyle );
						break;
					}
				}
			}

			uno::Reference< container::XNameReplace >
				xNameReplace( m_xPersistentWindowState, uno::UNO_QUERY );

			xNameReplace->replaceByName( rResourceURL, uno::makeAny( aProps ) );
		}
		catch ( uno::Exception& )
		{
			// do nothing, a default value is returned
			OSL_TRACE("Exception setting toolbar style");
		}
	}
}

sal_Int32 ToolbarSaveInData::GetSystemStyle( const OUString& rResourceURL )
{
	sal_Int32 result = 0;

	if ( rResourceURL.indexOf( OUString::createFromAscii( "private" ) ) == 0 &&
		 m_xPersistentWindowState.is() &&
		 m_xPersistentWindowState->hasByName( rResourceURL ) )
	{
		try
		{
			uno::Sequence< beans::PropertyValue > aProps;
			uno::Any a( m_xPersistentWindowState->getByName( rResourceURL ) );

			if ( a >>= aProps )
			{
				for ( sal_Int32 i = 0; i < aProps.getLength(); i++ )
				{
					if ( aProps[ i ].Name.equalsAscii( ITEM_DESCRIPTOR_STYLE) )
					{
						aProps[i].Value >>= result;
						break;
					}
				}
			}
		}
		catch ( uno::Exception& )
		{
			// do nothing, a default value is returned
		}
	}

	return result;
}

OUString ToolbarSaveInData::GetSystemUIName( const OUString& rResourceURL )
{
	OUString result;

	if ( rResourceURL.indexOf( OUString::createFromAscii( "private" ) ) == 0 &&
		 m_xPersistentWindowState.is() &&
		 m_xPersistentWindowState->hasByName( rResourceURL ) )
	{
		try
		{
			uno::Sequence< beans::PropertyValue > aProps;
			uno::Any a( m_xPersistentWindowState->getByName( rResourceURL ) );

			if ( a >>= aProps )
			{
				for ( sal_Int32 i = 0; i < aProps.getLength(); i++ )
				{
					if ( aProps[ i ].Name.equalsAscii( ITEM_DESCRIPTOR_UINAME) )
					{
						aProps[ i ].Value >>= result;
					}
				}
			}
		}
		catch ( uno::Exception& )
		{
			// do nothing, an empty UIName will be returned
		}
	}

	if ( rResourceURL.indexOf( OUString::createFromAscii( ".uno" ) ) == 0 &&
		 m_xCommandToLabelMap.is() &&
		 m_xCommandToLabelMap->hasByName( rResourceURL ) )
	{
		uno::Any a;
		try
		{
			a = m_xCommandToLabelMap->getByName( rResourceURL );

			uno::Sequence< beans::PropertyValue > aPropSeq;
			if ( a >>= aPropSeq )
			{
				for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ )
				{
					if ( aPropSeq[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL ) )
					{
						aPropSeq[i].Value >>= result;
					}
				}
			}
		}
		catch ( uno::Exception& )
		{
			// not a system command name
		}
	}

	return result;
}

bool EntrySort( SvxConfigEntry* a, SvxConfigEntry* b )
{
    return a->GetName().compareTo( b->GetName() ) < 0;
}

SvxEntries*	ToolbarSaveInData::GetEntries()
{
    typedef ::std::hash_map< ::rtl::OUString,
                             bool,
                             ::rtl::OUStringHash,
                             ::std::equal_to< ::rtl::OUString > > ToolbarInfo;

    ToolbarInfo aToolbarInfo;

    if ( pRootEntry == NULL )
	{

        pRootEntry = new SvxConfigEntry(
			String::CreateFromAscii("MainToolbars"), String(), sal_True );

		uno::Sequence< uno::Sequence < beans::PropertyValue > > info =
			GetConfigManager()->getUIElementsInfo(
				css::ui::UIElementType::TOOLBAR );

		for ( sal_Int32 i = 0; i < info.getLength(); i++ )
		{
			uno::Sequence< beans::PropertyValue > props = info[ i ];

			OUString url;
			OUString systemname;
			OUString uiname;

			for ( sal_Int32 j = 0; j < props.getLength(); j++ )
			{
				if ( props[ j ].Name.equalsAscii( ITEM_DESCRIPTOR_RESOURCEURL) )
				{
					props[ j ].Value >>= url;
					systemname = url.copy( url.lastIndexOf( '/' ) + 1 );
				}
				else if ( props[ j ].Name.equalsAscii( ITEM_DESCRIPTOR_UINAME) )
				{
					props[ j ].Value >>= uiname;
				}
			}

			try
			{
				uno::Reference< container::XIndexAccess > xToolbarSettings =
					GetConfigManager()->getSettings( url, sal_False );

				if ( uiname.getLength() == 0 )
				{
					// try to get the name from m_xPersistentWindowState
					uiname = GetSystemUIName( url );

					if ( uiname.getLength() == 0 )
					{
						uiname = systemname;
					}
				}

				SvxConfigEntry* pEntry = new SvxConfigEntry(
					uiname, url, sal_True );

				pEntry->SetMain( sal_True );
				pEntry->SetStyle( GetSystemStyle( url ) );


                // insert into hash_map to filter duplicates from the parent
                aToolbarInfo.insert( ToolbarInfo::value_type( systemname, true ));

				OUString custom = OUString::createFromAscii(CUSTOM_TOOLBAR_STR);
				if ( systemname.indexOf( custom ) == 0 )
				{
					pEntry->SetUserDefined( sal_True );
				}
				else
				{
					pEntry->SetUserDefined( sal_False );
				}

				pRootEntry->GetEntries()->push_back( pEntry );

				LoadToolbar( xToolbarSettings, pEntry );
			}
			catch ( container::NoSuchElementException& )
			{
				// TODO, handle resourceURL with no settings
			}
		}

        uno::Reference< css::ui::XUIConfigurationManager > xParentCfgMgr = GetParentConfigManager();
        if ( xParentCfgMgr.is() )
        {
            // Retrieve also the parent toolbars to make it possible
            // to configure module toolbars and save them into the document
            // config manager.
		    uno::Sequence< uno::Sequence < beans::PropertyValue > > info_ =
			    xParentCfgMgr->getUIElementsInfo(
				    css::ui::UIElementType::TOOLBAR );

		    for ( sal_Int32 i = 0; i < info_.getLength(); i++ )
		    {
			    uno::Sequence< beans::PropertyValue > props = info_[ i ];

			    OUString url;
			    OUString systemname;
			    OUString uiname;

			    for ( sal_Int32 j = 0; j < props.getLength(); j++ )
			    {
				    if ( props[ j ].Name.equalsAscii( ITEM_DESCRIPTOR_RESOURCEURL) )
				    {
					    props[ j ].Value >>= url;
					    systemname = url.copy( url.lastIndexOf( '/' ) + 1 );
				    }
				    else if ( props[ j ].Name.equalsAscii( ITEM_DESCRIPTOR_UINAME) )
				    {
					    props[ j ].Value >>= uiname;
				    }
			    }

                // custom toolbars of the parent are not visible in the document layer
				OUString custom = OUString::createFromAscii(CUSTOM_TOOLBAR_STR);
				if ( systemname.indexOf( custom ) == 0 )
                    continue;

                // check if toolbar is already in the document layer
                ToolbarInfo::const_iterator pIter = aToolbarInfo.find( systemname );
                if ( pIter == aToolbarInfo.end() )
                {
                    aToolbarInfo.insert( ToolbarInfo::value_type( systemname, true ));

                    try
			        {
				        uno::Reference< container::XIndexAccess > xToolbarSettings =
					        xParentCfgMgr->getSettings( url, sal_False );

				        if ( uiname.getLength() == 0 )
				        {
					        // try to get the name from m_xPersistentWindowState
					        uiname = GetSystemUIName( url );

					        if ( uiname.getLength() == 0 )
					        {
						        uiname = systemname;
					        }
				        }

				        SvxConfigEntry* pEntry = new SvxConfigEntry(
					        uiname, url, sal_True, sal_True );

				        pEntry->SetMain( sal_True );
				        pEntry->SetStyle( GetSystemStyle( url ) );

				        if ( systemname.indexOf( custom ) == 0 )
				        {
					        pEntry->SetUserDefined( sal_True );
				        }
				        else
				        {
					        pEntry->SetUserDefined( sal_False );
				        }

				        pRootEntry->GetEntries()->push_back( pEntry );

				        LoadToolbar( xToolbarSettings, pEntry );
			        }
			        catch ( container::NoSuchElementException& )
			        {
				        // TODO, handle resourceURL with no settings
			        }
                }
            }
        }

		std::sort( GetEntries()->begin(), GetEntries()->end(), EntrySort );
	}

	return pRootEntry->GetEntries();
}

void
ToolbarSaveInData::SetEntries( SvxEntries* pNewEntries )
{
	// delete old menu hierarchy first
	if ( pRootEntry != NULL && pRootEntry->GetEntries() != NULL )
	{
		delete pRootEntry->GetEntries();
	}

	// now set new menu hierarchy
	pRootEntry->SetEntries( pNewEntries );
}

bool
ToolbarSaveInData::HasURL( const OUString& rURL )
{
	SvxEntries::const_iterator iter = GetEntries()->begin();
	SvxEntries::const_iterator end = GetEntries()->end();

	while ( iter != end )
	{
		SvxConfigEntry* pEntry = *iter;

		if ( pEntry->GetCommand().equals( rURL ) )
		{
			if ( pEntry->IsParentData() )
                return sal_False;
            else
                return sal_True;
		}

		iter++;
	}
	return sal_False;
}

bool ToolbarSaveInData::HasSettings()
{
	// return true if there is at least one toolbar entry
	if ( GetEntries()->size() > 0 )
	{
		return sal_True;
	}
	return sal_False;
}

void ToolbarSaveInData::Reset()
{
	SvxEntries::const_iterator toolbars = GetEntries()->begin();
	SvxEntries::const_iterator end = GetEntries()->end();

	// reset each toolbar by calling removeSettings for it's toolbar URL
	for ( ; toolbars != end; toolbars++ )
	{
		SvxConfigEntry* pToolbar = *toolbars;

		try
		{
			OUString url = pToolbar->GetCommand();
			GetConfigManager()->removeSettings( url );
		}
		catch ( uno::Exception& )
		{
			// error occured removing the settings
			// TODO - add error dialog in future?
		}
	}

	// persist changes to toolbar storage
	PersistChanges( GetConfigManager() );

	// now delete the root SvxConfigEntry the next call to GetEntries()
	// causes it to be reinitialised
	delete pRootEntry;
	pRootEntry = NULL;

	// reset all icons to default
	try
	{
		GetImageManager()->reset();
		PersistChanges( GetImageManager() );
	}
	catch ( uno::Exception& )
	{
		OSL_TRACE("Error resetting all icons when resetting toolbars");
	}
}

bool ToolbarSaveInData::Apply()
{
	// toolbar changes are instantly applied
	return sal_False;
}

void ToolbarSaveInData::ApplyToolbar(
	uno::Reference< container::XIndexContainer >& rToolbarBar,
	uno::Reference< lang::XSingleComponentFactory >& rFactory,
	SvxConfigEntry* pToolbarData )
{
	SvxEntries::const_iterator iter = pToolbarData->GetEntries()->begin();
	SvxEntries::const_iterator end = pToolbarData->GetEntries()->end();

	for ( ; iter != end; iter++ )
	{
		SvxConfigEntry* pEntry = *iter;

		if ( pEntry->IsPopup() )
		{
			uno::Sequence< beans::PropertyValue > aPropValueSeq =
				ConvertToolbarEntry( m_xCommandToLabelMap, pEntry );

			uno::Reference< container::XIndexContainer > xSubMenuBar(
				rFactory->createInstanceWithContext( m_xComponentContext ),
					uno::UNO_QUERY );

			sal_Int32 nIndex = aPropValueSeq.getLength();
			aPropValueSeq.realloc( nIndex + 1 );
			aPropValueSeq[nIndex].Name = m_aDescriptorContainer;
			aPropValueSeq[nIndex].Value <<= xSubMenuBar;
			rToolbarBar->insertByIndex(
				rToolbarBar->getCount(), uno::makeAny( aPropValueSeq ));

			ApplyToolbar( xSubMenuBar, rFactory, pEntry );
		}
		else if ( pEntry->IsSeparator() )
		{
			rToolbarBar->insertByIndex(
				rToolbarBar->getCount(), uno::makeAny( m_aSeparatorSeq ));
		}
		else
		{
			uno::Sequence< beans::PropertyValue > aPropValueSeq =
				ConvertToolbarEntry( m_xCommandToLabelMap, pEntry );

			rToolbarBar->insertByIndex(
				rToolbarBar->getCount(), uno::makeAny( aPropValueSeq ));
		}
	}
}

void ToolbarSaveInData::ApplyToolbar( SvxConfigEntry* pToolbar )
{
	// Apply new toolbar structure to our settings container
	uno::Reference< container::XIndexAccess > xSettings(
		GetConfigManager()->createSettings(), uno::UNO_QUERY );

	uno::Reference< container::XIndexContainer > xIndexContainer (
		xSettings, uno::UNO_QUERY );

	uno::Reference< lang::XSingleComponentFactory > xFactory (
		xSettings, uno::UNO_QUERY );

	ApplyToolbar( xIndexContainer, xFactory, pToolbar );

	uno::Reference< beans::XPropertySet > xProps(
		xSettings, uno::UNO_QUERY );

	if ( pToolbar->IsUserDefined() )
	{
		xProps->setPropertyValue(
			OUString::createFromAscii( ITEM_DESCRIPTOR_UINAME ),
			uno::makeAny( OUString( pToolbar->GetName() ) ) );
	}

    try
	{
		if ( GetConfigManager()->hasSettings( pToolbar->GetCommand() ) )
		{
			GetConfigManager()->replaceSettings(
				pToolbar->GetCommand(), xSettings );
		}
		else
		{
			GetConfigManager()->insertSettings(
				pToolbar->GetCommand(), xSettings );
            if ( pToolbar->IsParentData() )
                pToolbar->SetParentData( false );
		}
	}
	catch ( container::NoSuchElementException& )
	{
		OSL_TRACE("caught container::NoSuchElementException saving settings");
	}
	catch ( com::sun::star::io::IOException& )
	{
		OSL_TRACE("caught IOException saving settings");
	}
	catch ( com::sun::star::uno::Exception& )
	{
		OSL_TRACE("caught some other exception saving settings");
	}

	PersistChanges( GetConfigManager() );
}

void ToolbarSaveInData::CreateToolbar( SvxConfigEntry* pToolbar )
{
	// show the new toolbar in the UI also
	uno::Reference< container::XIndexAccess >
		xSettings( GetConfigManager()->createSettings(), uno::UNO_QUERY );

	uno::Reference< container::XIndexContainer >
		xIndexContainer ( xSettings, uno::UNO_QUERY );

	uno::Reference< beans::XPropertySet >
		xPropertySet( xSettings, uno::UNO_QUERY );

	xPropertySet->setPropertyValue(
		OUString::createFromAscii( ITEM_DESCRIPTOR_UINAME ),
			uno::makeAny( pToolbar->GetName() ) );

	try
	{
		GetConfigManager()->insertSettings( pToolbar->GetCommand(), xSettings );
	}
	catch ( container::ElementExistException& )
	{
		OSL_TRACE("caught ElementExistsException saving settings");
	}
	catch ( com::sun::star::lang::IllegalArgumentException& )
	{
		OSL_TRACE("caught IOException saving settings");
	}
	catch ( com::sun::star::lang::IllegalAccessException& )
	{
		OSL_TRACE("caught IOException saving settings");
	}
	catch ( com::sun::star::uno::Exception& )
	{
		OSL_TRACE("caught some other exception saving settings");
	}

	GetEntries()->push_back( pToolbar );

	PersistChanges( GetConfigManager() );
}

void ToolbarSaveInData::RemoveToolbar( SvxConfigEntry* pToolbar )
{
	try
	{
        OUString url = pToolbar->GetCommand();
		GetConfigManager()->removeSettings( url );
		RemoveEntry( GetEntries(), pToolbar );
		delete pToolbar;

		PersistChanges( GetConfigManager() );

        // remove the persistent window state data
        css::uno::Reference< css::container::XNameContainer > xNameContainer(
            m_xPersistentWindowState, css::uno::UNO_QUERY_THROW );

        xNameContainer->removeByName( url );
	}
	catch ( uno::Exception& )
	{
		// error occured removing the settings
	}
}

void ToolbarSaveInData::RestoreToolbar( SvxConfigEntry* pToolbar )
{
	OUString url = pToolbar->GetCommand();

	// Restore of toolbar is done by removing it from
	// it's configuration manager and then getting it again
    bool bParentToolbar = pToolbar->IsParentData();

    // Cannot restore parent toolbar
    if ( bParentToolbar )
        return;

	try
	{
        GetConfigManager()->removeSettings( url );
		pToolbar->GetEntries()->clear();
		PersistChanges( GetConfigManager() );
	}
	catch ( uno::Exception& )
	{
		// if an error occurs removing the settings then just return
		return;
	}

	// Now reload the toolbar settings
	try
	{
        uno::Reference< container::XIndexAccess > xToolbarSettings;
        if ( IsDocConfig() )
        {
            xToolbarSettings = GetParentConfigManager()->getSettings( url, sal_False );
            pToolbar->SetParentData( true );
        }
        else
            xToolbarSettings = GetConfigManager()->getSettings( url, sal_False );

		LoadToolbar( xToolbarSettings, pToolbar );

		// After reloading, ensure that the icon is reset of each entry
		// in the toolbar
		SvxEntries::const_iterator iter = pToolbar->GetEntries()->begin();
		uno::Sequence< OUString > aURLSeq( 1 );
		for ( ; iter != pToolbar->GetEntries()->end(); iter++ )
		{
			SvxConfigEntry* pEntry = *iter;
			aURLSeq[ 0 ] = pEntry->GetCommand();

			try
			{
				GetImageManager()->removeImages( GetImageType(), aURLSeq );
			}
           	catch ( uno::Exception& )
           	{
				OSL_TRACE("Error restoring icon when resetting toolbar");
           	}
		}
		PersistChanges( GetImageManager() );
	}
	catch ( container::NoSuchElementException& )
	{
		// cannot find the resource URL after removing it
		// so no entry will appear in the toolbar list
	}
}

bool ToolbarSaveInData::LoadToolbar(
	const uno::Reference< container::XIndexAccess >& xToolbarSettings,
	SvxConfigEntry* pParentData )
{
	SvxEntries*			pEntries			= pParentData->GetEntries();

    for ( sal_Int32 nIndex = 0; nIndex < xToolbarSettings->getCount(); nIndex++ )
    {
        uno::Reference< container::XIndexAccess >	xSubMenu;
        OUString				aCommandURL;
        OUString				aLabel;
		bool					bIsUserDefined = sal_True;
		sal_Bool				bIsVisible;
		sal_Int32				nStyle;

        sal_uInt16 nType( css::ui::ItemType::DEFAULT );

        bool bItem = GetToolbarItemData( xToolbarSettings, nIndex, aCommandURL,
			aLabel, nType, bIsVisible, nStyle, xSubMenu );

        if ( bItem )
        {
            if ( nType == css::ui::ItemType::DEFAULT )
            {
				uno::Any a;
				try
				{
					a = m_xCommandToLabelMap->getByName( aCommandURL );
					bIsUserDefined = sal_False;
				}
				catch ( container::NoSuchElementException& )
				{
					bIsUserDefined = sal_True;
				}

				// If custom label not set retrieve it from the command
				// to info service
				if ( aLabel.equals( OUString() ) )
				{
					uno::Sequence< beans::PropertyValue > aPropSeq;
					if ( a >>= aPropSeq )
					{
						for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ )
						{
							if ( aPropSeq[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL ) )
							{
								aPropSeq[i].Value >>= aLabel;
								break;
							}
						}
					}
				}

                if ( xSubMenu.is() )
                {
					SvxConfigEntry* pEntry = new SvxConfigEntry(
						aLabel, aCommandURL, sal_True );

					pEntry->SetUserDefined( bIsUserDefined );
                    pEntry->SetVisible( bIsVisible );

					pEntries->push_back( pEntry );

					LoadToolbar( xSubMenu, pEntry );
                }
                else
                {
                    SvxConfigEntry* pEntry = new SvxConfigEntry(
						aLabel, aCommandURL, sal_False );
					pEntry->SetUserDefined( bIsUserDefined );
                    pEntry->SetVisible( bIsVisible );
					pEntry->SetStyle( nStyle );
					pEntries->push_back( pEntry );
                }
            }
            else
            {
				SvxConfigEntry* pEntry = new SvxConfigEntry;
				pEntry->SetUserDefined( bIsUserDefined );
				pEntries->push_back( pEntry );
            }
        }
    }

	return true;
}

IMPL_LINK( SvxToolbarConfigPage, SelectToolbarEntry, Control *, pBox )
{
	(void)pBox;
	UpdateButtonStates();
	return 1;
}

void SvxToolbarConfigPage::UpdateButtonStates()
{
	PopupMenu* pPopup = aModifyCommandButton.GetPopupMenu();
    pPopup->EnableItem( ID_RENAME, sal_False );
	pPopup->EnableItem( ID_DELETE, sal_False );
	pPopup->EnableItem( ID_BEGIN_GROUP, sal_False );
	pPopup->EnableItem( ID_DEFAULT_COMMAND, sal_False );
	pPopup->EnableItem( ID_ICON_ONLY, sal_False );
	pPopup->EnableItem( ID_ICON_AND_TEXT, sal_False );
	pPopup->EnableItem( ID_TEXT_ONLY, sal_False );
	pPopup->EnableItem( ID_CHANGE_SYMBOL, sal_False );
	pPopup->EnableItem( ID_RESET_SYMBOL, sal_False );

    aDescriptionField.Clear();

    SvLBoxEntry* selection = aContentsListBox->GetCurEntry();
	if ( aContentsListBox->GetEntryCount() == 0 || selection == NULL )
	{
		return;
	}

    SvxConfigEntry* pEntryData = (SvxConfigEntry*) selection->GetUserData();
	if ( pEntryData->IsSeparator() )
		pPopup->EnableItem( ID_DELETE, sal_True );
	else
	{
		pPopup->EnableItem( ID_BEGIN_GROUP, sal_True );
		pPopup->EnableItem( ID_DELETE, sal_True );
		pPopup->EnableItem( ID_RENAME, sal_True );
		pPopup->EnableItem( ID_ICON_ONLY, sal_True );
		pPopup->EnableItem( ID_ICON_AND_TEXT, sal_True );
		pPopup->EnableItem( ID_TEXT_ONLY, sal_True );
		pPopup->EnableItem( ID_CHANGE_SYMBOL, sal_True );

		if ( !pEntryData->IsUserDefined() )
			pPopup->EnableItem( ID_DEFAULT_COMMAND, sal_True );

		if ( pEntryData->IsIconModified() )
			pPopup->EnableItem( ID_RESET_SYMBOL, sal_True );

        aDescriptionField.SetNewText( pEntryData->GetHelpText() );
	}
}

short SvxToolbarConfigPage::QueryReset()
{
	String msg =
		String( CUI_RES( RID_SVXSTR_CONFIRM_TOOLBAR_RESET ) );

	String saveInName = aSaveInListBox.GetEntry(
		aSaveInListBox.GetSelectEntryPos() );

	OUString label = replaceSaveInName( msg, saveInName );

	QueryBox qbox( this, WB_YES_NO, label );

	return qbox.Execute();
}

IMPL_LINK( SvxToolbarConfigPage, SelectToolbar, ListBox *, pBox )
{
	(void)pBox;

	aContentsListBox->Clear();

	SvxConfigEntry* pToolbar = GetTopLevelSelection();
	if ( pToolbar == NULL )
	{
		aModifyTopLevelButton.Enable( sal_False );
		aModifyCommandButton.Enable( sal_False );
		aAddCommandsButton.Enable( sal_False );

		return 0;
	}

	aModifyTopLevelButton.Enable( sal_True );
	aModifyCommandButton.Enable( sal_True );
	aAddCommandsButton.Enable( sal_True );

	PopupMenu* pPopup = aModifyTopLevelButton.GetPopupMenu();

	pPopup->EnableItem( ID_DELETE, pToolbar->IsDeletable() );
	pPopup->EnableItem( ID_RENAME, pToolbar->IsRenamable() );
	pPopup->EnableItem( ID_DEFAULT_STYLE, !pToolbar->IsRenamable() );

	switch( pToolbar->GetStyle() )
	{
		case 0:
		{
			pPopup->CheckItem( ID_ICONS_ONLY );
			break;
		}
		case 1:
		{
			pPopup->CheckItem( ID_TEXT_ONLY );
			break;
		}
		case 2:
		{
			pPopup->CheckItem( ID_ICONS_AND_TEXT );
			break;
		}
	}

	SvxEntries* pEntries = pToolbar->GetEntries();
	SvxEntries::const_iterator iter = pEntries->begin();

	for ( ; iter != pEntries->end(); iter++ )
	{
		SvxConfigEntry* pEntry = *iter;

		SvLBoxEntry* pNewLBEntry = InsertEntryIntoUI( pEntry );

		if (pEntry->IsBinding())
		{
			aContentsListBox->SetCheckButtonState( pNewLBEntry,
				pEntry->IsVisible() ? SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED );
		}
		else
		{
			aContentsListBox->SetCheckButtonState(
				pNewLBEntry, SV_BUTTON_TRISTATE );
		}
	}

	UpdateButtonStates();

	return 0;
}

IMPL_LINK( SvxToolbarConfigPage, NewToolbarHdl, Button *, pButton )
{
	(void)pButton;

	String prefix =
		String( CUI_RES( RID_SVXSTR_NEW_TOOLBAR ) );

	OUString aNewName =
		generateCustomName( prefix, GetSaveInData()->GetEntries() );

	OUString aNewURL =
		generateCustomURL( GetSaveInData()->GetEntries() );

	SvxNewToolbarDialog* pNameDialog = new SvxNewToolbarDialog( 0, aNewName );

	sal_uInt16 nInsertPos;
	for ( sal_uInt16 i = 0 ; i < aSaveInListBox.GetEntryCount(); i++ )
	{
		SaveInData* pData =
			(SaveInData*) aSaveInListBox.GetEntryData( i );

		nInsertPos = pNameDialog->aSaveInListBox.InsertEntry(
			aSaveInListBox.GetEntry( i ) );

		pNameDialog->aSaveInListBox.SetEntryData( nInsertPos, pData );
	}

	pNameDialog->aSaveInListBox.SelectEntryPos(
		aSaveInListBox.GetSelectEntryPos(), sal_True );

	bool ret = pNameDialog->Execute();
	if ( ret == RET_OK )
	{
		pNameDialog->GetName( aNewName );

		nInsertPos = pNameDialog->aSaveInListBox.GetSelectEntryPos();

		ToolbarSaveInData* pData = (ToolbarSaveInData*)
			pNameDialog->aSaveInListBox.GetEntryData( nInsertPos );

		if ( GetSaveInData() != pData )
		{
			aSaveInListBox.SelectEntryPos( nInsertPos, sal_True );
			aSaveInListBox.GetSelectHdl().Call(this);
		}

		SvxConfigEntry* pToolbar =
			new SvxConfigEntry( aNewName, aNewURL, sal_True );

		pToolbar->SetUserDefined( sal_True );
		pToolbar->SetMain( sal_True );

		pData->CreateToolbar( pToolbar );

        nInsertPos = aTopLevelListBox.InsertEntry( pToolbar->GetName() );
	    aTopLevelListBox.SetEntryData( nInsertPos, pToolbar );
	    aTopLevelListBox.SelectEntryPos( nInsertPos, sal_True );
	    aTopLevelListBox.GetSelectHdl().Call(this);

		pData->SetModified( sal_True );
	}

	delete pNameDialog;

	return 0;
}

IMPL_LINK( SvxToolbarConfigPage, AddCommandsHdl, Button *, pButton )
{
	(void)pButton;

	if ( pSelectorDlg == NULL )
	{
		// Create Script Selector which shows slot commands
		pSelectorDlg = new SvxScriptSelectorDialog( this, sal_True, m_xFrame );

		// Position the Script Selector over the Add button so it is
		// beside the menu contents list and does not obscure it
		pSelectorDlg->SetPosPixel( aAddCommandsButton.GetPosPixel() );

		pSelectorDlg->SetAddHdl(
			LINK( this, SvxToolbarConfigPage, AddFunctionHdl ) );
	}

	pSelectorDlg->SetImageProvider(
		static_cast< ImageProvider* >( GetSaveInData() ) );

	pSelectorDlg->Show();
	return 1;
}

IMPL_LINK( SvxToolbarConfigPage, AddFunctionHdl,
	SvxScriptSelectorDialog *, pDialog )
{
	(void)pDialog;

	AddFunction();

	return 0;
}

SvLBoxEntry* SvxToolbarConfigPage::AddFunction(
	SvLBoxEntry* pTarget, bool bFront, bool bAllowDuplicates )
{
	SvLBoxEntry* pNewLBEntry =
		SvxConfigPage::AddFunction( pTarget, bFront, bAllowDuplicates );

	SvxConfigEntry* pEntry = (SvxConfigEntry*) pNewLBEntry->GetUserData();

	if ( pEntry->IsBinding() )
	{
		pEntry->SetVisible( sal_True );
		aContentsListBox->SetCheckButtonState(
			pNewLBEntry, SV_BUTTON_CHECKED );
	}
	else
	{
		aContentsListBox->SetCheckButtonState(
			pNewLBEntry, SV_BUTTON_TRISTATE );
	}

	// get currently selected toolbar and apply change
	SvxConfigEntry* pToolbar = GetTopLevelSelection();

	if ( pToolbar != NULL )
	{
		( ( ToolbarSaveInData* ) GetSaveInData() )->ApplyToolbar( pToolbar );
	}

	return pNewLBEntry;
}

// -----------------------------------------------------------------------

SvxToolbarEntriesListBox::SvxToolbarEntriesListBox(
	Window* pParent, const ResId& aResId )
	:
		SvxMenuEntriesListBox( pParent, aResId ),
		pPage( ( SvxToolbarConfigPage* ) pParent )
{
	m_pButtonData = new SvLBoxButtonData( this );
	BuildCheckBoxButtonImages( m_pButtonData );
	EnableCheckButton( m_pButtonData );

	m_bHiContrastMode = GetSettings().GetStyleSettings().GetHighContrastMode();
}

// --------------------------------------------------------

SvxToolbarEntriesListBox::~SvxToolbarEntriesListBox()
{
	delete m_pButtonData;
}

// --------------------------------------------------------

void SvxToolbarEntriesListBox::BuildCheckBoxButtonImages( SvLBoxButtonData* pData )
{
	// Build checkbox images according to the current application
	// settings. This is necessary to be able to have correct colors
	// in all color modes, like high contrast.
	const AllSettings& rSettings = Application::GetSettings();

	VirtualDevice	aDev;
	Size			aSize( 26, 20 );

	aDev.SetOutputSizePixel( aSize );

	Image aImage = GetSizedImage( aDev, aSize,
		CheckBox::GetCheckImage( rSettings, BUTTON_DRAW_DEFAULT ));

	// Fill button data struct with new images
	pData->aBmps[SV_BMP_UNCHECKED]		= aImage;
	pData->aBmps[SV_BMP_CHECKED]		= GetSizedImage( aDev, aSize, CheckBox::GetCheckImage( rSettings, BUTTON_DRAW_CHECKED ));
	pData->aBmps[SV_BMP_HICHECKED]		= GetSizedImage( aDev, aSize, CheckBox::GetCheckImage( rSettings, BUTTON_DRAW_CHECKED | BUTTON_DRAW_PRESSED ));
	pData->aBmps[SV_BMP_HIUNCHECKED]	= GetSizedImage( aDev, aSize, CheckBox::GetCheckImage( rSettings, BUTTON_DRAW_DEFAULT | BUTTON_DRAW_PRESSED));
	pData->aBmps[SV_BMP_TRISTATE]		= GetSizedImage( aDev, aSize, Image() ); // Use tristate bitmaps to have no checkbox for separator entries
	pData->aBmps[SV_BMP_HITRISTATE]		= GetSizedImage( aDev, aSize, Image() );

	// Get image size
	m_aCheckBoxImageSizePixel = aImage.GetSizePixel();
}

Image SvxToolbarEntriesListBox::GetSizedImage(
	VirtualDevice& aDev, const Size& aNewSize, const Image& aImage )
{
	// Create new checkbox images for treelistbox. They must have a
	// decent width to have a clear column for the visibility checkbox.

	// Standard transparent color is light magenta as is won't be
	// used for other things
	Color	aFillColor( COL_LIGHTMAGENTA );

	// Position image at the center of (width-2),(height) rectangle.
	// We need 2 pixels to have a bigger border to the next button image
	sal_uInt16	nPosX = std::max( (sal_uInt16) (((( aNewSize.Width() - 2 ) - aImage.GetSizePixel().Width() ) / 2 ) - 1), (sal_uInt16) 0 );
	sal_uInt16	nPosY = std::max( (sal_uInt16) (((( aNewSize.Height() - 2 ) - aImage.GetSizePixel().Height() ) / 2 ) + 1), (sal_uInt16) 0 );
	Point	aPos( nPosX > 0 ? nPosX : 0, nPosY > 0 ? nPosY : 0 );
	aDev.SetFillColor( aFillColor );
	aDev.SetLineColor( aFillColor );
	aDev.DrawRect( Rectangle( Point(), aNewSize ));
	aDev.DrawImage( aPos, aImage );

	// Draw separator line 2 pixels left from the right border
	Color aLineColor = GetDisplayBackground().GetColor().IsDark() ? Color( COL_WHITE ) : Color( COL_BLACK );
	aDev.SetLineColor( aLineColor );
	aDev.DrawLine( Point( aNewSize.Width()-3, 0 ), Point( aNewSize.Width()-3, aNewSize.Height()-1 ));

	// Create new image that uses the fillcolor as transparent
	return Image( aDev.GetBitmap( Point(), aNewSize ), aFillColor );
}

void SvxToolbarEntriesListBox::DataChanged( const DataChangedEvent& rDCEvt )
{
	SvTreeListBox::DataChanged( rDCEvt );

	if (( rDCEvt.GetType() == DATACHANGED_SETTINGS ) &&
        ( rDCEvt.GetFlags() & SETTINGS_STYLE ))
    {
        // We have to reset all images because we change to/from high contrast mode
        m_bHiContrastMode = GetSettings().GetStyleSettings().GetHighContrastMode();

		BuildCheckBoxButtonImages( m_pButtonData );
        Invalidate();
    }
}

// --------------------------------------------------------

void SvxToolbarEntriesListBox::ChangeVisibility( SvLBoxEntry* pEntry )
{
	if ( pEntry != NULL )
	{
		SvxConfigEntry* pEntryData =
			(SvxConfigEntry*) pEntry->GetUserData();

		if ( pEntryData->IsBinding() )
		{
			pEntryData->SetVisible( !pEntryData->IsVisible() );

			SvxConfigEntry* pToolbar = pPage->GetTopLevelSelection();

			ToolbarSaveInData* pToolbarSaveInData = ( ToolbarSaveInData* )
				pPage->GetSaveInData();

   			pToolbarSaveInData->ApplyToolbar( pToolbar );

			SetCheckButtonState( pEntry, pEntryData->IsVisible() ?
				SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED );
		}
	}
}

void SvxToolbarEntriesListBox::CheckButtonHdl()
{
	ChangeVisibility( GetHdlEntry() );
}

void SvxToolbarEntriesListBox::KeyInput( const KeyEvent& rKeyEvent )
{
	// space key will change visibility of toolbar items
	if ( rKeyEvent.GetKeyCode() == KEY_SPACE )
	{
		ChangeVisibility( GetCurEntry() );
	}
	else
	{
		// pass on to superclass
		SvxMenuEntriesListBox::KeyInput( rKeyEvent );
	}
}

sal_Bool SvxToolbarEntriesListBox::NotifyMoving(
	SvLBoxEntry* pTarget, SvLBoxEntry* pSource,
	SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos)
{
	bool result = SvxMenuEntriesListBox::NotifyMoving(
		pTarget, pSource, rpNewParent, rNewChildPos );

	if ( result == sal_True )
	{
		// Instant Apply changes to UI
		SvxConfigEntry* pToolbar = pPage->GetTopLevelSelection();
		if ( pToolbar != NULL )
		{
			ToolbarSaveInData* pSaveInData =
				( ToolbarSaveInData*) pPage->GetSaveInData();
			pSaveInData->ApplyToolbar( pToolbar );
		}
	}

	return result;
}

sal_Bool SvxToolbarEntriesListBox::NotifyCopying(
    SvLBoxEntry*  pTarget,
    SvLBoxEntry*  pSource,
    SvLBoxEntry*& rpNewParent,
    sal_uLong&      rNewChildPos)
{
	(void)pSource;
	(void)rpNewParent;
	(void)rNewChildPos;

	if ( !m_bIsInternalDrag )
	{
		// if the target is NULL then add function to the start of the list
		((SvxToolbarConfigPage*)pPage)->AddFunction( pTarget, pTarget == NULL );

		// Instant Apply changes to UI
		SvxConfigEntry* pToolbar = pPage->GetTopLevelSelection();
		if ( pToolbar != NULL )
		{
			ToolbarSaveInData* pSaveInData =
				( ToolbarSaveInData*) pPage->GetSaveInData();
			pSaveInData->ApplyToolbar( pToolbar );
		}

		// AddFunction already adds the listbox entry so return FALSE
		// to stop another listbox entry being added
		return sal_False;
	}

	// Copying is only allowed from external controls, not within the listbox
	return sal_False;
}

SvxNewToolbarDialog::SvxNewToolbarDialog(
	Window* pWindow, const String& rName )
	:
	ModalDialog		( pWindow, CUI_RES( MD_NEW_TOOLBAR ) ),
	aFtDescription	( this, CUI_RES( FT_NAME ) ),
	aEdtName		( this, CUI_RES( EDT_STRING ) ),
	aSaveInText		( this, CUI_RES( TXT_SAVEIN ) ),
	aBtnOK			( this, CUI_RES( BTN_OK ) ),
	aBtnCancel		( this, CUI_RES( BTN_CANCEL ) ),
	aBtnHelp		( this, CUI_RES( BTN_HELP ) ),
	aSaveInListBox	( this, CUI_RES( LB_SAVEIN ) )
{
	FreeResource();

	aEdtName.SetText( rName );
    aEdtName.SetSelection(Selection(SELECTION_MIN, SELECTION_MAX));
    ModifyHdl(&aEdtName);
    aEdtName.SetModifyHdl(LINK(this, SvxNewToolbarDialog, ModifyHdl));
}

IMPL_LINK(SvxNewToolbarDialog, ModifyHdl, Edit*, pEdit)
{
	(void)pEdit;

    if(aCheckNameHdl.IsSet())
        aBtnOK.Enable(aCheckNameHdl.Call(this) > 0);

    return 0;
}

/*******************************************************************************
*
* The SvxIconSelectorDialog class
*
*******************************************************************************/
SvxIconSelectorDialog::SvxIconSelectorDialog( Window *pWindow,
    const uno::Reference< css::ui::XImageManager >& rXImageManager,
	const uno::Reference< css::ui::XImageManager >& rXParentImageManager )
	:
	ModalDialog		     ( pWindow, CUI_RES( MD_ICONSELECTOR ) ),
	aFtDescription	     ( this, CUI_RES( FT_SYMBOLS ) ),
	aTbSymbol		     ( this, CUI_RES( TB_SYMBOLS ) ),
	aFtNote			     ( this, CUI_RES( FT_NOTE ) ),
	aBtnOK			     ( this, CUI_RES( BTN_OK ) ),
	aBtnCancel		     ( this, CUI_RES( BTN_CANCEL ) ),
	aBtnHelp		     ( this, CUI_RES( BTN_HELP ) ),
	aBtnImport		     ( this, CUI_RES( BTN_IMPORT ) ),
	aBtnDelete			 ( this, CUI_RES( BTN_DELETE ) ),
	aFlSeparator		 ( this, CUI_RES( FL_SEPARATOR ) ),
    m_nNextId            ( 0 ),
	m_xImageManager	     ( rXImageManager ),
    m_xParentImageManager( rXParentImageManager )
{
	FreeResource();

    typedef ::std::hash_map< ::rtl::OUString,
                             bool,
                             ::rtl::OUStringHash,
                             ::std::equal_to< ::rtl::OUString > > ImageInfo;

    aTbSymbol.SetPageScroll( sal_True );

	bool bLargeIcons = GetImageType() & css::ui::ImageType::SIZE_LARGE;
	m_nExpectedSize = bLargeIcons ? 26 : 16;

	if ( m_nExpectedSize != 16 )
	{
		aFtNote.SetText( replaceSixteen( aFtNote.GetText(), m_nExpectedSize ) );
	}

	uno::Reference< lang::XMultiServiceFactory > xServiceManager =
		::comphelper::getProcessServiceFactory();

	if ( xServiceManager.is() )
	{
		m_xGraphProvider = uno::Reference< graphic::XGraphicProvider >(
			xServiceManager->createInstance(
				::rtl::OUString::createFromAscii(
					"com.sun.star.graphic.GraphicProvider" ) ),
			uno::UNO_QUERY );
	}

	if ( !m_xGraphProvider.is() )
	{
		aBtnImport.Enable( sal_False );
	}

	uno::Reference< beans::XPropertySet > xPropSet(
		xServiceManager->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.util.PathSettings" ) ),
		uno::UNO_QUERY );

	uno::Any aAny = xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserConfig" ) ) );

	::rtl::OUString aDirectory;

	aAny >>= aDirectory;

	sal_Int32 aCount = aDirectory.getLength();

	if ( aCount > 0 )
	{
		sal_Unicode aChar = aDirectory[ aCount-1 ];
		if ( aChar != '/')
		{
			aDirectory += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) );
		}
	}
	else
	{
		aBtnImport.Enable( sal_False );
	}

	aDirectory += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "soffice.cfg/import" ) );

	uno::Reference< lang::XSingleServiceFactory > xStorageFactory(
		xServiceManager->createInstance(
		::rtl::OUString::createFromAscii( "com.sun.star.embed.FileSystemStorageFactory" )),
		uno::UNO_QUERY );

	uno::Sequence< uno::Any > aArgs( 2 );
	aArgs[ 0 ] <<= aDirectory;
	aArgs[ 1 ] <<= com::sun::star::embed::ElementModes::READWRITE;

	uno::Reference< com::sun::star::embed::XStorage > xStorage(
		xStorageFactory->createInstanceWithArguments( aArgs ), uno::UNO_QUERY );

	uno::Sequence< uno::Any > aProp( 2 );
	beans::PropertyValue aPropValue;

	aPropValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserConfigStorage" ) );
	aPropValue.Value <<= xStorage;
	aProp[ 0 ] <<= aPropValue;

	aPropValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OpenMode" ) );
	aPropValue.Value <<= com::sun::star::embed::ElementModes::READWRITE;
	aProp[ 1 ] <<= aPropValue;

	m_xImportedImageManager = uno::Reference< com::sun::star::ui::XImageManager >(
		xServiceManager->createInstanceWithArguments(
		::rtl::OUString::createFromAscii( "com.sun.star.ui.ImageManager" ), aProp ),
		uno::UNO_QUERY );

	ImageInfo mImageInfo;
	uno::Sequence< OUString > names;
	if ( m_xImportedImageManager.is() )
	{
		names = m_xImportedImageManager->getAllImageNames( GetImageType() );
		for ( sal_Int32 n = 0; n < names.getLength(); n++ )
			mImageInfo.insert( ImageInfo::value_type( names[n], false ));
	}
	sal_uInt16 nId = 1;
	ImageInfo::const_iterator pConstIter = mImageInfo.begin();
	uno::Sequence< OUString > name( 1 );
	while ( pConstIter != mImageInfo.end() )
	{
		name[ 0 ] = pConstIter->first;
		uno::Sequence< uno::Reference< graphic::XGraphic> > graphics = m_xImportedImageManager->getImages( GetImageType(), name );
		if ( graphics.getLength() > 0 )
		{
			Image img = Image( graphics[ 0 ] );
			aTbSymbol.InsertItem( nId, img, pConstIter->first );

			graphics[ 0 ]->acquire();

			aTbSymbol.SetItemData(
				nId, static_cast< void * > ( graphics[ 0 ].get() ) );

			++nId;
		}
		++pConstIter;
	}

    ImageInfo                 aImageInfo;

    if ( m_xParentImageManager.is() )
    {
        names = m_xParentImageManager->getAllImageNames( GetImageType() );
        for ( sal_Int32 n = 0; n < names.getLength(); n++ )
            aImageInfo.insert( ImageInfo::value_type( names[n], false ));
    }

    names = m_xImageManager->getAllImageNames( GetImageType() );
    for ( sal_Int32 n = 0; n < names.getLength(); n++ )
    {
        ImageInfo::iterator pIter = aImageInfo.find( names[n] );
        if ( pIter != aImageInfo.end() )
            pIter->second = true;
        else
            aImageInfo.insert( ImageInfo::value_type( names[n], true ));
    }

	// large growth factor, expecting many entries
	pConstIter = aImageInfo.begin();
    while ( pConstIter != aImageInfo.end() )
    {
		name[ 0 ] = pConstIter->first;

		uno::Sequence< uno::Reference< graphic::XGraphic> > graphics;
		try
		{
            if ( pConstIter->second )
                graphics = m_xImageManager->getImages( GetImageType(), name );
            else
				graphics = m_xParentImageManager->getImages( GetImageType(), name );
		}
		catch ( uno::Exception& )
		{
			// can't get sequence for this name so it will not be
			// added to the list
		}

		if ( graphics.getLength() > 0 )
		{
			Image img = Image( graphics[ 0 ] );
			aTbSymbol.InsertItem( nId, img, pConstIter->first );

            uno::Reference< graphic::XGraphic > xGraphic = graphics[ 0 ];

			if ( xGraphic.is() )
                xGraphic->acquire();

			aTbSymbol.SetItemData(
				nId, static_cast< void * > ( xGraphic.get() ) );

	    	++nId;
		}

        ++pConstIter;
	}

	aBtnDelete.Enable( sal_False );
	aTbSymbol.SetSelectHdl( LINK(this, SvxIconSelectorDialog, SelectHdl) );
	aBtnImport.SetClickHdl( LINK(this, SvxIconSelectorDialog, ImportHdl) );
	aBtnDelete.SetClickHdl( LINK(this, SvxIconSelectorDialog, DeleteHdl) );

    m_nNextId = aTbSymbol.GetItemCount()+1;
}

SvxIconSelectorDialog::~SvxIconSelectorDialog()
{
	sal_uInt16 nCount = aTbSymbol.GetItemCount();

	for (sal_uInt16 n = 0; n < nCount; n++ )
	{
		sal_uInt16 nId = aTbSymbol.GetItemId(n);

		uno::XInterface* xi = static_cast< uno::XInterface* >(
			aTbSymbol.GetItemData( nId ) );

		if ( xi != NULL )
		{
			xi->release();
		}
	}
}

uno::Reference< graphic::XGraphic> SvxIconSelectorDialog::GetSelectedIcon()
{
	uno::Reference< graphic::XGraphic > result;

	sal_uInt16 nId;
	for ( sal_uInt16 n = 0; n < aTbSymbol.GetItemCount(); n++ )
	{
		nId = aTbSymbol.GetItemId( n );
		if ( aTbSymbol.IsItemChecked( nId ) )
		{
			result = uno::Reference< graphic::XGraphic >(
				reinterpret_cast< graphic::XGraphic* >(
					aTbSymbol.GetItemData( nId ) ) );
		}
	}

	return result;
}

IMPL_LINK( SvxIconSelectorDialog, SelectHdl, ToolBox *, pToolBox )
{
	(void)pToolBox;

	sal_uInt16 nCount = aTbSymbol.GetItemCount();

	for (sal_uInt16 n = 0; n < nCount; n++ )
	{
		sal_uInt16 nId = aTbSymbol.GetItemId( n );

		if ( aTbSymbol.IsItemChecked( nId ) )
		{
			aTbSymbol.CheckItem( nId, sal_False );
		}
	}

	sal_uInt16 nId = aTbSymbol.GetCurItemId();
	aTbSymbol.CheckItem( nId );

	::rtl::OUString aSelImageText = aTbSymbol.GetItemText( nId );
	if ( m_xImportedImageManager->hasImage( GetImageType(), aSelImageText ) )
	{
		aBtnDelete.Enable( sal_True );
	}
	else
	{
		aBtnDelete.Enable( sal_False );
	}

	return 0;
}

IMPL_LINK( SvxIconSelectorDialog, ImportHdl, PushButton *, pButton )
{
	(void)pButton;

	sfx2::FileDialogHelper aImportDialog(
		css::ui::dialogs::TemplateDescription::FILEOPEN_LINK_PREVIEW,
        SFXWB_GRAPHIC | SFXWB_MULTISELECTION );

	// disable the link checkbox in the dialog
	uno::Reference< css::ui::dialogs::XFilePickerControlAccess >
		xController( aImportDialog.GetFilePicker(), uno::UNO_QUERY);
	if ( xController.is() )
	{
		xController->enableControl(
			css::ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_LINK,
			sal_False);
	}

	aImportDialog.SetCurrentFilter(
		String::CreateFromAscii( "PNG - Portable Network Graphic" ) );

	if ( ERRCODE_NONE == aImportDialog.Execute() )
	{
		uno::Sequence< OUString > paths = aImportDialog.GetMPath();
		ImportGraphics ( paths );
	}

	return 0;
}

IMPL_LINK( SvxIconSelectorDialog, DeleteHdl, PushButton *, pButton )
{
	(void)pButton;

	OUString message = String( CUI_RES( RID_SVXSTR_DELETE_ICON_CONFIRM ) );
	bool ret = WarningBox( this, WinBits(WB_OK_CANCEL), message ).Execute();

	if ( ret == RET_OK )
	{
		sal_uInt16 nCount = aTbSymbol.GetItemCount();

		for (sal_uInt16 n = 0; n < nCount; n++ )
		{
			sal_uInt16 nId = aTbSymbol.GetItemId( n );

			if ( aTbSymbol.IsItemChecked( nId ) )
			{
				::rtl::OUString aSelImageText = aTbSymbol.GetItemText( nId );
				uno::Sequence< OUString > URLs(1);
				URLs[0] = aSelImageText;
				aTbSymbol.RemoveItem( aTbSymbol.GetItemPos( nId ) );
				m_xImportedImageManager->removeImages( GetImageType(), URLs );
				uno::Reference< css::ui::XUIConfigurationPersistence >
					xConfigPersistence( m_xImportedImageManager, uno::UNO_QUERY );
				if ( xConfigPersistence.is() && xConfigPersistence->isModified() )
				{
					xConfigPersistence->store();
				}
				break;
			}
		}
	}
	return 0;
}

bool SvxIconSelectorDialog::ReplaceGraphicItem(
    const ::rtl::OUString& aURL )
{
	uno::Sequence< OUString > URLs(1);
	uno::Sequence< uno::Reference<graphic::XGraphic > > aImportGraph( 1 );
	uno::Reference< css::ui::XUIConfigurationPersistence >
		xConfigPer( m_xImportedImageManager, uno::UNO_QUERY );

	uno::Reference< graphic::XGraphic > xGraphic;
	uno::Sequence< beans::PropertyValue > aMediaProps( 1 );
	aMediaProps[0].Name = ::rtl::OUString::createFromAscii("URL");
	aMediaProps[0].Value <<= aURL;

    com::sun::star::awt::Size aSize;
    bool bOK = sal_False;
    try
	{
        xGraphic = m_xGraphProvider->queryGraphic( aMediaProps );

		uno::Reference< beans::XPropertySet > props =
			m_xGraphProvider->queryGraphicDescriptor( aMediaProps );
		uno::Any a = props->getPropertyValue(
			OUString::createFromAscii("SizePixel") );
		a >>= aSize;
		if (0 == aSize.Width || 0 == aSize.Height)
			return sal_False;
		else
			bOK = sal_True;
    }
    catch ( uno::Exception& )
    {
        return false;
    }

    bool   bResult( false );
    sal_uInt16 nCount = aTbSymbol.GetItemCount();
	for (sal_uInt16 n = 0; n < nCount; n++ )
	{
		sal_uInt16 nId = aTbSymbol.GetItemId( n );

		if ( OUString( aTbSymbol.GetItemText( nId ) ) == aURL )
		{
            try
            {
                // replace/insert image with provided URL
		        aTbSymbol.RemoveItem( aTbSymbol.GetItemPos( nId ) );
		        aMediaProps[0].Value <<= aURL;

                Image aImage( xGraphic );
				if ( bOK && ((aSize.Width != m_nExpectedSize) || (aSize.Height != m_nExpectedSize)) )
				{
					BitmapEx aBitmap = aImage.GetBitmapEx();
					BitmapEx aBitmapex = AutoScaleBitmap(aBitmap, m_nExpectedSize);
					aImage = Image( aBitmapex);
				}
				aTbSymbol.InsertItem( nId,aImage, aURL, 0, 0 ); //modify

                xGraphic = aImage.GetXGraphic();

                URLs[0] = aURL;
		        aImportGraph[ 0 ] = xGraphic;
                m_xImportedImageManager->replaceImages( GetImageType(), URLs, aImportGraph );
                xConfigPer->store();

                bResult = true;
                break;
            }
            catch ( ::com::sun::star::uno::Exception& )
            {
                break;
            }
		}
	}

    return bResult;
}

void SvxIconSelectorDialog::ImportGraphics(
	const uno::Sequence< OUString >& rPaths )
{
	uno::Sequence< OUString > rejected( rPaths.getLength() );
	sal_Int32 rejectedCount = 0;

	sal_uInt16 ret = 0;
	sal_Int32 aIndex;
	OUString aIconName;
	uno::Sequence< OUString > URLs(1);
	uno::Sequence< uno::Reference<graphic::XGraphic > > aImportGraph( 1 );
	uno::Sequence< beans::PropertyValue > aMediaProps( 1 );
	aMediaProps[0].Name = ::rtl::OUString::createFromAscii("URL");
	uno::Reference< css::ui::XUIConfigurationPersistence >
		xConfigPer( m_xImportedImageManager, uno::UNO_QUERY );

	if ( rPaths.getLength() == 1 )
	{
		if ( m_xImportedImageManager->hasImage( GetImageType(), rPaths[0] ) )
		{
			aIndex = rPaths[0].lastIndexOf( '/' );
			aIconName = rPaths[0].copy( aIndex+1 );
			ret = SvxIconReplacementDialog( this, aIconName ).ShowDialog();
			if ( ret == 2 )
			{
                ReplaceGraphicItem( rPaths[0] );
			}
		}
		else
		{
			if ( ImportGraphic( rPaths[0] ) == sal_False )
			{
				rejected[0] = rPaths[0];
				rejectedCount = 1;
			}
		}
	}
	else
	{
		::rtl::OUString aSourcePath( rPaths[0] );
        if ( rPaths[0].lastIndexOf( '/' ) != rPaths[0].getLength() -1 )
            aSourcePath = rPaths[0] + ::rtl::OUString::createFromAscii( "/" );

		for ( sal_Int32 i = 1; i < rPaths.getLength(); i++ )
		{
            ::rtl::OUString aPath = aSourcePath + rPaths[i];
			if ( m_xImportedImageManager->hasImage( GetImageType(), aPath ) )
			{
				aIndex = rPaths[i].lastIndexOf( '/' );
				aIconName = rPaths[i].copy( aIndex+1 );
				ret = SvxIconReplacementDialog( this, aIconName, sal_True ).ShowDialog();
				if ( ret == 2 )
				{
                    ReplaceGraphicItem( aPath );
				}
				else if ( ret == 5 )
				{
					for ( sal_Int32 k = i; k < rPaths.getLength(); k++ )
					{
						aPath = aSourcePath + rPaths[k];
						bool bHasReplaced = ReplaceGraphicItem( aPath );

                        if ( !bHasReplaced )
						{
							bool result = ImportGraphic( aPath );
							if ( result == sal_False )
							{
								rejected[ rejectedCount ] = rPaths[i];
								rejectedCount++;
							}
						}
					}
					break;
				}
			}
			else
			{
                bool result = ImportGraphic( aSourcePath + rPaths[i] );
				if ( result == sal_False )
				{
					rejected[ rejectedCount ] = rPaths[i];
					rejectedCount++;
				}
			}
		}
	}

	if ( rejectedCount != 0 )
	{
		OUString message =OUString::createFromAscii("");
		OUString newLine = OUString::createFromAscii("\n");
		rtl::OUString fPath = OUString::createFromAscii("");
		if (rejectedCount > 1)
  			fPath = rPaths[0].copy(8) + ::rtl::OUString::createFromAscii( "/" );
		for ( sal_Int32 i = 0; i < rejectedCount; i++ )
		{
			message += fPath + rejected[i];
			message += newLine;
		}

        SvxIconChangeDialog aDialog(this, message);
		aDialog.Execute();
	}
}

bool SvxIconSelectorDialog::ImportGraphic( const OUString& aURL )
{
	bool result = sal_False;

	sal_uInt16 nId = m_nNextId;
	++m_nNextId;

	uno::Sequence< beans::PropertyValue > aMediaProps( 1 );
	aMediaProps[0].Name = ::rtl::OUString::createFromAscii("URL");

	uno::Reference< graphic::XGraphic > xGraphic;
	com::sun::star::awt::Size aSize;
    bool bOK = sal_True;
	aMediaProps[0].Value <<= aURL;
	try
	{
		uno::Reference< beans::XPropertySet > props =
			m_xGraphProvider->queryGraphicDescriptor( aMediaProps );

		uno::Any a = props->getPropertyValue(
			OUString::createFromAscii("SizePixel") );

			xGraphic = m_xGraphProvider->queryGraphic( aMediaProps );
			if ( xGraphic.is() )
			{
				a >>= aSize;
				if ( 0 == aSize.Width || 0 == aSize.Height )
					bOK = sal_False;

				Image aImage( xGraphic );

                if ( bOK && ((aSize.Width != m_nExpectedSize) || (aSize.Height != m_nExpectedSize)) )
				{
					BitmapEx aBitmap = aImage.GetBitmapEx();
					BitmapEx aBitmapex = AutoScaleBitmap(aBitmap, m_nExpectedSize);
					aImage = Image( aBitmapex);
				}
				if ( bOK && !!aImage )
				{
					aTbSymbol.InsertItem( nId, aImage, aURL, 0, 0 );

                    xGraphic = aImage.GetXGraphic();
                    xGraphic->acquire();

					aTbSymbol.SetItemData(
						nId, static_cast< void * > ( xGraphic.get() ) );
					uno::Sequence< OUString > aImportURL( 1 );
					aImportURL[ 0 ] = aURL;
					uno::Sequence< uno::Reference<graphic::XGraphic > > aImportGraph( 1 );
					aImportGraph[ 0 ] = xGraphic;
					m_xImportedImageManager->insertImages( GetImageType(), aImportURL, aImportGraph );
					uno::Reference< css::ui::XUIConfigurationPersistence >
					xConfigPersistence( m_xImportedImageManager, uno::UNO_QUERY );

					if ( xConfigPersistence.is() && xConfigPersistence->isModified() )
					{
						xConfigPersistence->store();
					}

					result = sal_True;
				}
				else
				{
					OSL_TRACE("could not create Image from XGraphic");
				}
			}
			else
			{
				OSL_TRACE("could not get query XGraphic");
			}
	}
	catch( uno::Exception& e )
	{
		OSL_TRACE("Caught exception importing XGraphic: %s", PRTSTR(e.Message));
	}
	return result;
}

/*******************************************************************************
*
* The SvxIconReplacementDialog class
*
*******************************************************************************/
SvxIconReplacementDialog :: SvxIconReplacementDialog(
	Window *pWindow, const rtl::OUString& aMessage, bool /*bYestoAll*/ )
	:
MessBox( pWindow, WB_DEF_YES, String( CUI_RES( RID_SVXSTR_REPLACE_ICON_CONFIRM ) ),  String( CUI_RES( RID_SVXSTR_REPLACE_ICON_WARNING ) ) )

{
    SetImage( WarningBox::GetStandardImage() );
	SetMessText( ReplaceIconName( aMessage ) );
	RemoveButton( 1 );
	AddButton( BUTTON_YES, 2, 0 );
	AddButton( String( CUI_RES( RID_SVXSTR_YESTOALL ) ), 5, 0 );
	AddButton( BUTTON_NO, 3, 0 );
	AddButton( BUTTON_CANCEL, 4, 0 );
}

SvxIconReplacementDialog :: SvxIconReplacementDialog(
	Window *pWindow, const rtl::OUString& aMessage )
	:
MessBox( pWindow, WB_YES_NO_CANCEL, String( CUI_RES( RID_SVXSTR_REPLACE_ICON_CONFIRM ) ),  String( CUI_RES( RID_SVXSTR_REPLACE_ICON_WARNING ) ) )
{
    SetImage( WarningBox::GetStandardImage() );
	SetMessText( ReplaceIconName( aMessage ));
}

rtl::OUString SvxIconReplacementDialog :: ReplaceIconName( const OUString& rMessage )
{
	rtl::OUString name;
	rtl::OUString message = String( CUI_RES( RID_SVXSTR_REPLACE_ICON_WARNING ) );
	rtl::OUString placeholder = OUString::createFromAscii( "%ICONNAME" );
	sal_Int32 pos = message.indexOf( placeholder );
	if ( pos != -1 )
	{
		name = message.replaceAt(
			pos, placeholder.getLength(), rMessage );
	}
	return name;
}

sal_uInt16 SvxIconReplacementDialog :: ShowDialog()
{
	this->Execute();
	return ( this->GetCurButtonId() );
}
/*******************************************************************************
*
* The SvxIconChangeDialog class added for issue83555
*
*******************************************************************************/
SvxIconChangeDialog::SvxIconChangeDialog(
	Window *pWindow, const rtl::OUString& aMessage)
	:
	ModalDialog	           ( pWindow, CUI_RES( MD_ICONCHANGE ) ),
	aFImageInfo            (this, CUI_RES( FI_INFO ) ),
	aBtnOK                 (this, CUI_RES(MD_BTN_OK)),
	aDescriptionLabel      (this, CUI_RES(FTCHGE_DESCRIPTION)),
	aLineEditDescription   (this, CUI_RES(EDT_ADDR))
{
	FreeResource();
	aFImageInfo.SetImage(InfoBox::GetStandardImage());
	aLineEditDescription.SetControlBackground( GetSettings().GetStyleSettings().GetDialogColor() );
	aLineEditDescription.SetAutoScroll( sal_True );
	aLineEditDescription.EnableCursor( sal_False );
	aLineEditDescription.SetText(aMessage);
}

BitmapEx SvxIconSelectorDialog::AutoScaleBitmap(BitmapEx & aBitmap, const long aStandardSize)
{
	Point aEmptyPoint(0,0);
	sal_Int32 imgNewWidth = 0;
	sal_Int32 imgNewHeight = 0;
	double imgposX = 0;
	double imgposY = 0;
    BitmapEx  aRet = aBitmap;
	double imgOldWidth = aRet.GetSizePixel().Width();
	double imgOldHeight =aRet.GetSizePixel().Height();

    Size aScaledSize;
    if (imgOldWidth >= aStandardSize || imgOldHeight >= aStandardSize)
	{
		if (imgOldWidth >= imgOldHeight)
		{
			imgNewWidth = aStandardSize;
			imgNewHeight = sal_Int32(imgOldHeight / (imgOldWidth / aStandardSize) + 0.5);
			imgposX = 0;
			imgposY = (aStandardSize - (imgOldHeight / (imgOldWidth / aStandardSize) + 0.5)) / 2 + 0.5;
		}
		else
		{
			imgNewHeight = aStandardSize;
			imgNewWidth = sal_Int32(imgOldWidth / (imgOldHeight / aStandardSize) + 0.5);
			imgposY = 0;
			imgposX = (aStandardSize - (imgOldWidth / (imgOldHeight / aStandardSize) + 0.5)) / 2 + 0.5;
		}

		aScaledSize = Size( imgNewWidth, imgNewHeight );
        aRet.Scale( aScaledSize, BMP_SCALE_INTERPOLATE );
	}
	else
	{
		imgposX = (aStandardSize - imgOldWidth) / 2 + 0.5;
		imgposY = (aStandardSize - imgOldHeight) / 2 + 0.5;
	}

    Size aBmpSize = aRet.GetSizePixel();
    Size aStdSize( aStandardSize, aStandardSize );
    Rectangle aRect(aEmptyPoint, aStdSize );

    VirtualDevice aVirDevice( *Application::GetDefaultDevice(), 0, 1 );
	aVirDevice.SetOutputSizePixel( aStdSize );
	aVirDevice.SetFillColor( COL_TRANSPARENT );
    aVirDevice.SetLineColor( COL_TRANSPARENT );

    //draw a rect into virDevice
	aVirDevice.DrawRect( aRect );
	Point aPointPixel( (long)imgposX, (long)imgposY );
	aVirDevice.DrawBitmapEx( aPointPixel, aRet );
	aRet = aVirDevice.GetBitmapEx( aEmptyPoint, aStdSize );

	return aRet;
}