/**************************************************************
 * 
 * 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_editeng.hxx"
#include <editeng/hangulhanja.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/button.hxx>
#include <unotools/lingucfg.hxx>
#include <unotools/linguprops.hxx>

#include <set>
#include <map>
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/i18n/XBreakIterator.hpp>
#include <com/sun/star/i18n/ScriptType.hpp>
#include <com/sun/star/i18n/UnicodeScript.hpp>
#include <com/sun/star/i18n/XTextConversion.hpp>
#include <com/sun/star/i18n/XExtendedTextConversion.hpp>
#include <com/sun/star/i18n/TextConversionType.hpp>
#include <com/sun/star/i18n/TextConversionOption.hpp>
#include <com/sun/star/i18n/WordType.hpp>
#include <vcl/stdtext.hxx>
#include <unotools/charclass.hxx>

#include <editeng/edtdlg.hxx> 
#include <editeng/editrids.hrc>
#include <editeng/unolingu.hxx>

#define HHC HangulHanjaConversion

//.............................................................................
namespace editeng
{
//.............................................................................

	using namespace ::com::sun::star::uno;
	using namespace ::com::sun::star::i18n;
    using namespace ::com::sun::star::i18n::TextConversionOption;
    using namespace ::com::sun::star::i18n::TextConversionType;
	using namespace ::com::sun::star::lang;
/*
	using HangulHanjaConversion::ReplacementAction;
	using HangulHanjaConversion::eExchange;
	using HangulHanjaConversion::eReplacementBracketed;
	using HangulHanjaConversion::eOriginalBracketed;
	using HangulHanjaConversion::eReplacementAbove;
	using HangulHanjaConversion::eOriginalAbove;
	using HangulHanjaConversion::eReplacementBelow;
	using HangulHanjaConversion::eOriginalBelow;

	using HangulHanjaConversion::eHangulToHanja;
	using HangulHanjaConversion::eHanjaToHangul;

	using HangulHanjaConversion::eSimpleConversion;
	using HangulHanjaConversion::eHangulBracketed;
	using HangulHanjaConversion::eHanjaBracketed;
	using HangulHanjaConversion::eRubyHanjaAbove;
	using HangulHanjaConversion::eRubyHanjaBelow;
	using HangulHanjaConversion::eRubyHangulAbove;
	using HangulHanjaConversion::eRubyHangulBelow;

	using ::com::sun::star::i18n::TextConversionType::TO_HANJA;
	using ::com::sun::star::i18n::TextConversionType::TO_HANGUL;
	using ::com::sun::star::i18n::TextConversionOption::CHARACTER_BY_CHARACTER;
	using ::com::sun::star::i18n::TextConversionOption::NONE;
*/
	//=========================================================================
	//= HangulHanjaConversion_Impl
	//=========================================================================
    //using HangulHanjaConversion::ConversionFormat;

	class HangulHanjaConversion_Impl
	{
	private:
		typedef	::std::set< ::rtl::OUString, ::std::less< ::rtl::OUString > >					StringBag;
		typedef ::std::map< ::rtl::OUString, ::rtl::OUString, ::std::less< ::rtl::OUString > >	StringMap;

	private:
        StringBag               m_sIgnoreList;
        StringMap               m_aChangeList;
        static StringMap        m_aRecentlyUsedList;

		// general
		AbstractHangulHanjaConversionDialog* //CHINA001 HangulHanjaConversionDialog*
								m_pConversionDialog;	// the dialog to display for user interaction
		Window*					m_pUIParent;			// the parent window for any UI we raise
		Reference< XMultiServiceFactory >
								m_xORB;					// the service factory to use
		Reference< XTextConversion >
								m_xConverter;			// the text conversion service
        Locale                  m_aSourceLocale;        // the locale we're working with

        // additions for Chinese simplified / traditional conversion
		HHC::ConversionType     m_eConvType;		// conversion type (Hangul/Hanja, simplified/traditional Chinese,...)
		LanguageType            m_nSourceLang;      // just a 'copy' of m_aSourceLocale in order in order to
                                                    // save the applications from always converting to this
                                                    // type in their implementations
        LanguageType            m_nTargetLang;      // target language of new replacement text
        const Font*             m_pTargetFont;      // target font of new replacement text
        sal_Int32               m_nConvOptions;     // text conversion options (as used by 'getConversions')
        sal_Bool                m_bIsInteractive;   // specifies if the conversion requires user interaction
                                                    // (and likeley a specialised dialog) or if it is to run
                                                    // automatically without any user interaction.
                                                    // True for Hangul / Hanja conversion
                                                    // False for Chinese simlified / traditional conversion

		HangulHanjaConversion*	m_pAntiImpl;			// our "anti-impl" instance

		// options
        sal_Bool                    m_bByCharacter;                 // are we in "by character" mode currently?
        HHC::ConversionFormat       m_eConversionFormat;            // the current format for the conversion
        HHC::ConversionDirection    m_ePrimaryConversionDirection;  // the primary conversion direction
        HHC::ConversionDirection    m_eCurrentConversionDirection;  // the primary conversion direction

        //options from Hangul/Hanja Options dialog (also saved to configuration)
        bool                    m_bIgnorePostPositionalWord;
        bool                    m_bShowRecentlyUsedFirst;
        bool                    m_bAutoReplaceUnique;

		// state
        ::rtl::OUString                m_sCurrentPortion;      // the text which we are currently working on
        LanguageType            m_nCurrentPortionLang;  // language of m_sCurrentPortion found
		sal_Int32				m_nCurrentStartIndex;	// the start index within m_sCurrentPortion of the current convertible portion
		sal_Int32				m_nCurrentEndIndex;		// the end index (excluding) within m_sCurrentPortion of the current convertible portion
		sal_Int32				m_nReplacementBaseIndex;// index which ReplaceUnit-calls need to be relative to
        sal_Int32               m_nCurrentConversionOption;
        sal_Int16               m_nCurrentConversionType;
        Sequence< ::rtl::OUString >
								m_aCurrentSuggestions;	// the suggestions for the current unit
														// (means for the text [m_nCurrentStartIndex, m_nCurrentEndIndex) in m_sCurrentPortion)
        sal_Bool                m_bTryBothDirections;   // specifies if other conversion directions should be tried when looking for convertible characters


	public:
		HangulHanjaConversion_Impl(
			Window* _pUIParent,
			const Reference< XMultiServiceFactory >& _rxORB,
            const Locale& _rSourceLocale,
            const Locale& _rTargetLocale,
            const Font* _pTargetFont,
            sal_Int32 _nConvOptions,
            sal_Bool _bIsInteractive,
			HangulHanjaConversion* _pAntiImpl );

	public:

		static void			SetUseSavedConversionDirectionState( sal_Bool bVal );

				void		DoDocumentConversion( );

		inline	sal_Bool	IsByCharacter( ) const { return m_bByCharacter; }

		inline	sal_Bool	IsValid() const { return m_xConverter.is(); }

        inline LanguageType GetSourceLang() const   { return m_nSourceLang; }
        inline LanguageType GetTargetLang() const   { return m_nTargetLang; }
        inline const Font * GetTargetFont() const   { return m_pTargetFont; }
        inline sal_Int32    GetConvOptions() const  { return m_nConvOptions; }
        inline sal_Bool     IsInteractive() const   { return m_bIsInteractive; }

	protected:
		void	createDialog();

		/** continue with the conversion, return <TRUE/> if and only if the complete conversion is done
			@param _bRepeatCurrentUnit
				if <TRUE/>, an implNextConvertible will be called initially to advance to the next convertible.
				if <FALSE/>, the method will initially work with the current convertible unit
		*/
		sal_Bool ContinueConversion( bool _bRepeatCurrentUnit );

	private:
        DECL_LINK( OnOptionsChanged, void* );
		DECL_LINK( OnIgnore, void* );
		DECL_LINK( OnIgnoreAll, void* );
		DECL_LINK( OnChange, void* );
		DECL_LINK( OnChangeAll, void* );
		DECL_LINK( OnByCharClicked, CheckBox* );
		DECL_LINK( OnConversionTypeChanged, void* );
		DECL_LINK( OnFind, void* );

		/** proceed, after the current convertible has been handled

			<p><b>Attention:</b>
				When returning from this method, the dialog may have been deleted!</p>

			@param _bRepeatCurrentUnit
				will be passed to the <member>ContinueConversion</member> call
		*/
		void	implProceed( bool _bRepeatCurrentUnit );

		// change the current convertible, and do _not_ proceed
		void	implChange( const ::rtl::OUString& _rChangeInto );

		/** find the next convertible piece of text, with possibly advancing to the next portion

			@see HangulHanjaConversion::GetNextPortion
		*/
		sal_Bool	implNextConvertible( bool _bRepeatUnit );

		/** find the next convertible unit within the current portion
			@param _bRepeatUnit
				if <TRUE/>, the search will start at the beginning of the current unit,
				if <FALSE/>, it will start at the end of the current unit
		*/
		bool		implNextConvertibleUnit( const sal_Int32 _nStartAt );

		/** retrieves the next portion, with setting the index members properly
			@return
				<TRUE/> if and only if there is a next portion
		*/
		bool		implRetrieveNextPortion( );

		/** determine the ConversionDirection for m_sCurrentPortion
			@return
				<FALSE/> if and only if something went wrong
		*/
		bool		implGetConversionDirectionForCurrentPortion( HHC::ConversionDirection& rDirection );

        /** member m_aCurrentSuggestions and m_nCurrentEndIndex are updated according to the other settings and current dictionaries

            if _bAllowSearchNextConvertibleText is true _nStartAt is used as starting point to search the next
            convertible text portion. This may result in changing of the member m_nCurrentStartIndex additionally.

            @return
				<TRUE/> if Suggestions were found
        */
        bool        implUpdateSuggestions( const bool _bAllowSearchNextConvertibleText=false, const sal_Int32 _nStartAt=-1 );

        /** reads the options from Hangul/Hanja Options dialog that are saved to configuration
        */
        void implReadOptionsFromConfiguration();

        /** get the string currently considered to be replaced or ignored
        */
        ::rtl::OUString GetCurrentUnit() const;

        /** read options from configuration, update suggestion list and dialog content
        */
        void implUpdateData();

        /** get the conversion direction dependent from m_eConvType and m_eCurrentConversionDirection
            in case of switching the direction is allowed this can be triggered with parameter bSwitchDirection
        */
        sal_Int16 implGetConversionType( bool bSwitchDirection=false ) const;
	};

	//=========================================================================
	//= HangulHanjaConversion_Impl
	//=========================================================================
    //-------------------------------------------------------------------------
    // static member initialization
    HangulHanjaConversion_Impl::StringMap HangulHanjaConversion_Impl::m_aRecentlyUsedList = HangulHanjaConversion_Impl::StringMap();

	//-------------------------------------------------------------------------
	HangulHanjaConversion_Impl::HangulHanjaConversion_Impl( Window* _pUIParent,
        const Reference< XMultiServiceFactory >& _rxORB,
        const Locale& _rSourceLocale,
        const Locale& _rTargetLocale,
        const Font* _pTargetFont,
        sal_Int32 _nOptions,
        sal_Bool _bIsInteractive,
        HangulHanjaConversion* _pAntiImpl )
: m_pConversionDialog( NULL )
, m_pUIParent( _pUIParent )
, m_xORB( _rxORB )
, m_aSourceLocale( _rSourceLocale )
, m_nSourceLang( SvxLocaleToLanguage( _rSourceLocale ) )
, m_nTargetLang( SvxLocaleToLanguage( _rTargetLocale ) )
, m_pTargetFont( _pTargetFont )
, m_bIsInteractive( _bIsInteractive )
, m_pAntiImpl( _pAntiImpl )
, m_nCurrentPortionLang( LANGUAGE_NONE )
, m_nCurrentStartIndex( 0 )
, m_nCurrentEndIndex( 0 )
, m_nReplacementBaseIndex( 0 )
, m_nCurrentConversionOption( TextConversionOption::NONE )
, m_nCurrentConversionType( -1 ) // not yet known
, m_bTryBothDirections( sal_True )
	{
        implReadOptionsFromConfiguration();

		DBG_ASSERT( m_xORB.is(), "HangulHanjaConversion_Impl::HangulHanjaConversion_Impl: no ORB!" );

		// determine conversion type
		if (m_nSourceLang == LANGUAGE_KOREAN && m_nTargetLang == LANGUAGE_KOREAN)
            m_eConvType = HHC::eConvHangulHanja;
		else if ( (m_nSourceLang == LANGUAGE_CHINESE_TRADITIONAL && m_nTargetLang == LANGUAGE_CHINESE_SIMPLIFIED)  ||
				 (m_nSourceLang == LANGUAGE_CHINESE_SIMPLIFIED  && m_nTargetLang == LANGUAGE_CHINESE_TRADITIONAL) )
            m_eConvType = HHC::eConvSimplifiedTraditional;
		else
		{
			DBG_ERROR( "failed to determine conversion type from languages" );
		}

		// set remaining conversion parameters to their default values
		m_nConvOptions		= _nOptions;
		m_bByCharacter		= 0 != (_nOptions & CHARACTER_BY_CHARACTER);
        m_eConversionFormat = HHC::eSimpleConversion;
        m_ePrimaryConversionDirection = HHC::eHangulToHanja;	// used for eConvHangulHanja
        m_eCurrentConversionDirection = HHC::eHangulToHanja;	// used for eConvHangulHanja

		if ( m_xORB.is() )
		{
			::rtl::OUString sTextConversionService( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.i18n.TextConversion" ) );
			m_xConverter = m_xConverter.query( m_xORB->createInstance( sTextConversionService ) );
			if ( !m_xConverter.is() )
				ShowServiceNotAvailableError( m_pUIParent, sTextConversionService, sal_True );
		}

	}

	//-------------------------------------------------------------------------
	void HangulHanjaConversion_Impl::createDialog()
	{
		DBG_ASSERT( m_bIsInteractive, "createDialog when the conversion should not be interactive?" );
		if ( m_bIsInteractive && !m_pConversionDialog )
		{
			EditAbstractDialogFactory* pFact = EditAbstractDialogFactory::Create();
			if(pFact)
			{
				m_pConversionDialog = pFact->CreateHangulHanjaConversionDialog(m_pUIParent, m_ePrimaryConversionDirection );
				DBG_ASSERT(m_pConversionDialog, "Dialogdiet fail!");//CHINA001

                m_pConversionDialog->EnableRubySupport( m_pAntiImpl->HasRubySupport() );

				m_pConversionDialog->SetByCharacter( m_bByCharacter );
				m_pConversionDialog->SetConversionFormat( m_eConversionFormat );
                m_pConversionDialog->SetConversionDirectionState( m_bTryBothDirections, m_ePrimaryConversionDirection );

				// the handlers
                m_pConversionDialog->SetOptionsChangedHdl( LINK( this, HangulHanjaConversion_Impl, OnOptionsChanged ) );
				m_pConversionDialog->SetIgnoreHdl( LINK( this, HangulHanjaConversion_Impl, OnIgnore ) );
				m_pConversionDialog->SetIgnoreAllHdl( LINK( this, HangulHanjaConversion_Impl, OnIgnoreAll ) );
				m_pConversionDialog->SetChangeHdl( LINK( this, HangulHanjaConversion_Impl, OnChange ) );
				m_pConversionDialog->SetChangeAllHdl( LINK( this, HangulHanjaConversion_Impl, OnChangeAll ) );
				m_pConversionDialog->SetClickByCharacterHdl( LINK( this, HangulHanjaConversion_Impl, OnByCharClicked ) );
				m_pConversionDialog->SetConversionFormatChangedHdl( LINK( this, HangulHanjaConversion_Impl, OnConversionTypeChanged ) );
				m_pConversionDialog->SetFindHdl( LINK( this, HangulHanjaConversion_Impl, OnFind ) );
			}
		}
	}

    //-------------------------------------------------------------------------
    sal_Int16 HangulHanjaConversion_Impl::implGetConversionType( bool bSwitchDirection ) const
    {
        sal_Int16 nConversionType = -1;
        if (m_eConvType == HHC::eConvHangulHanja)
            nConversionType = HHC::eHangulToHanja == ( m_eCurrentConversionDirection && !bSwitchDirection ) ? TO_HANJA : TO_HANGUL;
        else if (m_eConvType == HHC::eConvSimplifiedTraditional)
            nConversionType = LANGUAGE_CHINESE_SIMPLIFIED == m_nTargetLang ? TO_SCHINESE : TO_TCHINESE;
        DBG_ASSERT( nConversionType != -1, "unexpected conversion type" );
        return nConversionType;
    }

    //-------------------------------------------------------------------------
    bool HangulHanjaConversion_Impl::implUpdateSuggestions( bool _bAllowSearchNextConvertibleText, const sal_Int32 _nStartAt )
    {
        // parameters for the converter
        sal_Int32 nStartSearch = m_nCurrentStartIndex;
        if( _bAllowSearchNextConvertibleText )
            nStartSearch = _nStartAt;

        sal_Int32 nLength = m_sCurrentPortion.getLength() - nStartSearch;
        m_nCurrentConversionType = implGetConversionType();
        m_nCurrentConversionOption = IsByCharacter() ? CHARACTER_BY_CHARACTER : NONE;
        if( m_bIgnorePostPositionalWord )
            m_nCurrentConversionOption = m_nCurrentConversionOption | IGNORE_POST_POSITIONAL_WORD;

		// no need to check both directions for chinese conversion (saves time)
		if (m_eConvType == HHC::eConvSimplifiedTraditional)
			m_bTryBothDirections = sal_False;

        sal_Bool bFoundAny = sal_True;
		try
		{
			TextConversionResult aResult = m_xConverter->getConversions(
				m_sCurrentPortion,
				nStartSearch,
				nLength,
                m_aSourceLocale,
                m_nCurrentConversionType,
                m_nCurrentConversionOption
			);
            sal_Bool bFoundPrimary = aResult.Boundary.startPos < aResult.Boundary.endPos;
			bFoundAny = bFoundPrimary;

			if ( m_bTryBothDirections )
			{	// see if we find another convertible when assuming the other direction
				TextConversionResult aSecondResult = m_xConverter->getConversions(
					m_sCurrentPortion,
					nStartSearch,
					nLength,
                    m_aSourceLocale,
                    implGetConversionType( true ), // switched!
                    m_nCurrentConversionOption
				);
				if ( aSecondResult.Boundary.startPos < aSecondResult.Boundary.endPos )
				{	// we indeed found such a convertible

					// in case the first attempt (with the original conversion direction)
					// didn't find anything
					if	(	!bFoundPrimary
						// or if the second location is _before_ the first one
						||	( aSecondResult.Boundary.startPos < aResult.Boundary.startPos )
						)
					{
						// then use the second finding
						aResult = aSecondResult;

						// our current conversion direction changed now
                        m_eCurrentConversionDirection = ( HHC::eHangulToHanja == m_eCurrentConversionDirection )
                            ? HHC::eHanjaToHangul : HHC::eHangulToHanja;
						bFoundAny = sal_True;
					}
				}
			}

            if( _bAllowSearchNextConvertibleText )
            {
                //this might change the current position
			    m_aCurrentSuggestions = aResult.Candidates;
			    m_nCurrentStartIndex = aResult.Boundary.startPos;
			    m_nCurrentEndIndex = aResult.Boundary.endPos;
            }
            else
            {
                //the change of starting position is not allowed
                if( m_nCurrentStartIndex == aResult.Boundary.startPos
                    && aResult.Boundary.endPos != aResult.Boundary.startPos )
                {
                    m_aCurrentSuggestions = aResult.Candidates;
                    m_nCurrentEndIndex = aResult.Boundary.endPos;
                }
                else
                {
                    m_aCurrentSuggestions.realloc( 0 );
                    if( m_sCurrentPortion.getLength() >= m_nCurrentStartIndex+1 )
                        m_nCurrentEndIndex = m_nCurrentStartIndex+1;
                }
            }

            //put recently used string to front:
            if( m_bShowRecentlyUsedFirst && m_aCurrentSuggestions.getLength()>1 )
            {
                ::rtl::OUString sCurrentUnit( GetCurrentUnit() );
                StringMap::const_iterator aRecentlyUsed = m_aRecentlyUsedList.find( sCurrentUnit );
                bool bUsedBefore = aRecentlyUsed != m_aRecentlyUsedList.end();
                if( bUsedBefore && m_aCurrentSuggestions[0] != aRecentlyUsed->second )
                {
                    sal_Int32 nCount = m_aCurrentSuggestions.getLength();
                    Sequence< ::rtl::OUString > aTmp(nCount);
                    aTmp[0]=aRecentlyUsed->second;
                    sal_Int32 nDiff = 1;
                    for( sal_Int32 n=1; n<nCount; n++)//we had 0 already
                    {
                        if( nDiff && m_aCurrentSuggestions[n-nDiff]==aRecentlyUsed->second )
                            nDiff=0;
                        aTmp[n]=m_aCurrentSuggestions[n-nDiff];
                    }
                    m_aCurrentSuggestions = aTmp;
                }
            }
		}
		catch( const Exception& )
		{
			DBG_ERROR( "HangulHanjaConversion_Impl::implNextConvertibleUnit: caught an exception!" );

			//!!! at least we want to move on in the text in order
			//!!! to avoid an endless loop...
			return false;
		}
        return bFoundAny;
    }

	//-------------------------------------------------------------------------
	bool HangulHanjaConversion_Impl::implNextConvertibleUnit( const sal_Int32 _nStartAt )
	{
		m_aCurrentSuggestions.realloc( 0 );

		// ask the TextConversion service for the next convertible piece of text

		// get current values from dialog
		if( m_eConvType == HHC::eConvHangulHanja && m_pConversionDialog )
		{
			m_bTryBothDirections = m_pConversionDialog->GetUseBothDirections();
			HHC::ConversionDirection eDialogDirection = HHC::eHangulToHanja;
			eDialogDirection = m_pConversionDialog->GetDirection( eDialogDirection );

			if( !m_bTryBothDirections && eDialogDirection != m_eCurrentConversionDirection )
			{
				m_eCurrentConversionDirection = eDialogDirection;
			}

			// save curently used value for possible later use
			m_pAntiImpl->m_bTryBothDirectionsSave = m_bTryBothDirections;
			m_pAntiImpl->m_ePrimaryConversionDirectionSave = m_eCurrentConversionDirection;
		}

		bool bFoundAny = implUpdateSuggestions( true, _nStartAt );

        return  bFoundAny &&
                (m_nCurrentStartIndex < m_sCurrentPortion.getLength());
	}

	//-------------------------------------------------------------------------
	bool HangulHanjaConversion_Impl::implRetrieveNextPortion( )
	{
        sal_Bool bAllowImplicitChanges = m_eConvType == HHC::eConvSimplifiedTraditional;

		m_sCurrentPortion = ::rtl::OUString();
        m_nCurrentPortionLang = LANGUAGE_NONE;
        m_pAntiImpl->GetNextPortion( m_sCurrentPortion, m_nCurrentPortionLang, bAllowImplicitChanges );
		m_nReplacementBaseIndex = 0;
		m_nCurrentStartIndex = m_nCurrentEndIndex = 0;

		bool bRet = 0 != m_sCurrentPortion.getLength();

		if (m_eConvType == HHC::eConvHangulHanja && m_bTryBothDirections)
			implGetConversionDirectionForCurrentPortion( m_eCurrentConversionDirection );

		return bRet;
	}

	//-------------------------------------------------------------------------
	sal_Bool HangulHanjaConversion_Impl::implNextConvertible( bool _bRepeatUnit )
	{
		if ( _bRepeatUnit || ( m_nCurrentEndIndex < m_sCurrentPortion.getLength() ) )
		{
			if ( implNextConvertibleUnit(
						_bRepeatUnit
					?	( IsByCharacter() ? m_nCurrentStartIndex : m_nCurrentStartIndex )
					:	m_nCurrentEndIndex
				) )
				return sal_True;
		}

		// no convertible text in the current portion anymore
		// -> advance to the next portion
		do
		{
			// next portion
			if ( implRetrieveNextPortion( ) )
			{	// there is a next portion
				// -> find the next convertible unit in the current portion
				if ( implNextConvertibleUnit( 0 ) )
					return sal_True;
			}
		}
		while ( m_sCurrentPortion.getLength() );

		// no more portions
		return sal_False;
	}

	//-------------------------------------------------------------------------
    ::rtl::OUString HangulHanjaConversion_Impl::GetCurrentUnit() const
    {
        DBG_ASSERT( m_nCurrentStartIndex < m_sCurrentPortion.getLength(),
			"HangulHanjaConversion_Impl::GetCurrentUnit: invalid index into current portion!" );
        DBG_ASSERT( m_nCurrentEndIndex <= m_sCurrentPortion.getLength(),
			"HangulHanjaConversion_Impl::GetCurrentUnit: invalid index into current portion!" );
		DBG_ASSERT( m_nCurrentStartIndex <= m_nCurrentEndIndex,
			"HangulHanjaConversion_Impl::GetCurrentUnit: invalid interval!" );

        ::rtl::OUString sCurrentUnit = m_sCurrentPortion.copy( m_nCurrentStartIndex, m_nCurrentEndIndex - m_nCurrentStartIndex );
        return sCurrentUnit;
    }

    //-------------------------------------------------------------------------
	sal_Bool HangulHanjaConversion_Impl::ContinueConversion( bool _bRepeatCurrentUnit )
	{
		sal_Bool bNeedUserInteraction = sal_False;	// when we leave here, do we need user interaction?
		sal_Bool bDocumentDone = sal_False;			// did we already check the whole document?

		while ( !bDocumentDone && !bNeedUserInteraction && implNextConvertible( _bRepeatCurrentUnit ) )
		{
			::rtl::OUString sCurrentUnit( GetCurrentUnit() );

			// do we need to ignore it?
			sal_Bool bAlwaysIgnoreThis = m_sIgnoreList.end() != m_sIgnoreList.find( sCurrentUnit );

			// do we need to change it?
			StringMap::const_iterator aChangeListPos = m_aChangeList.find( sCurrentUnit );
			sal_Bool bAlwaysChangeThis = m_aChangeList.end() != aChangeListPos;

			// do we automatically change this?
			sal_Bool bAutoChange = m_bAutoReplaceUnique && m_aCurrentSuggestions.getLength() == 1;

            if (!m_bIsInteractive)
			{
                // silent conversion (e.g. for simplified/traditional Chinese)...
                if(m_aCurrentSuggestions.getLength()>0)
				    implChange( m_aCurrentSuggestions.getConstArray()[0] );
			}
			else if (bAutoChange)
			{
				implChange( m_aCurrentSuggestions.getConstArray()[0] );
			}
			else if ( bAlwaysChangeThis )
			{
				implChange( aChangeListPos->second );
			}
			else if ( !bAlwaysIgnoreThis )
			{
				// here we need to ask the user for what to do with the text
				// for this, allow derivees to highlight the current text unit in a possible document view
				m_pAntiImpl->HandleNewUnit( m_nCurrentStartIndex - m_nReplacementBaseIndex, m_nCurrentEndIndex - m_nReplacementBaseIndex );

                DBG_ASSERT( m_pConversionDialog, "we should always have a dialog here!" );
                if( m_pConversionDialog )
				    m_pConversionDialog->SetCurrentString( sCurrentUnit, m_aCurrentSuggestions );

				// do not look for the next convertible: We have to wait for the user to interactivly
				// decide what happens with the current convertible
				bNeedUserInteraction = sal_True;
			}
		}

		/*
		if ( bDocumentDone )
			return sal_True;			// we explicitly know that the complete document is done
		else if ( bNeedUserInteraction )
			return sal_False;			// the doc is not done, we found a convertible, but need the user to decide
		else
			return sal_True;			// we did not find a next convertible, so the document is implicitly done
		*/

		return	bDocumentDone || !bNeedUserInteraction;
	}

	//-------------------------------------------------------------------------
	bool HangulHanjaConversion_Impl::implGetConversionDirectionForCurrentPortion( HHC::ConversionDirection& rDirection )
	{
		// - For eConvHangulHanja the direction is determined by
		// the first encountered Korean character.
		// - For eConvSimplifiedTraditional the conversion direction
		// is already specified by the source language.

		bool bSuccess = true;

        if (m_eConvType == HHC::eConvHangulHanja)
		{
			bSuccess = false;
			try
			{
				// get the break iterator service
				::rtl::OUString sBreakIteratorService( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.i18n.BreakIterator" ) );
				Reference< XInterface > xBI( m_xORB->createInstance( ::rtl::OUString( sBreakIteratorService ) ) );
				Reference< XBreakIterator > xBreakIter( xBI, UNO_QUERY );
				if ( !xBreakIter.is() )
				{
					ShowServiceNotAvailableError( m_pUIParent, sBreakIteratorService, sal_True );
				}
				else
				{
					sal_Int32 nNextAsianScript = xBreakIter->beginOfScript( m_sCurrentPortion, m_nCurrentStartIndex, com::sun::star::i18n::ScriptType::ASIAN );
					if ( -1 == nNextAsianScript )
						nNextAsianScript = xBreakIter->nextScript( m_sCurrentPortion, m_nCurrentStartIndex, com::sun::star::i18n::ScriptType::ASIAN );
					if ( ( nNextAsianScript >= m_nCurrentStartIndex ) && ( nNextAsianScript < m_sCurrentPortion.getLength() ) )
					{	// found asian text

						// determine if it's Hangul
						CharClass aCharClassificaton( m_xORB, m_aSourceLocale );
						sal_Int16 nScript = aCharClassificaton.getScript( m_sCurrentPortion, sal::static_int_cast< sal_uInt16 >(nNextAsianScript) );
						if	(	( UnicodeScript_kHangulJamo == nScript )
							||	( UnicodeScript_kHangulCompatibilityJamo == nScript )
							||	( UnicodeScript_kHangulSyllable == nScript )
							)
						{
							rDirection = HHC::eHangulToHanja;
						}
						else
						{
							rDirection = HHC::eHanjaToHangul;
						}

						bSuccess = true;
					}
				}
			}
			catch( const Exception& )
			{
				DBG_ERROR( "HangulHanjaConversion_Impl::implGetConversionDirectionForCurrentPortion: caught an exception!" );
			}
		}

		return bSuccess;
	}

	//-------------------------------------------------------------------------
	void HangulHanjaConversion_Impl::DoDocumentConversion( )
	{
		// clear the change-all list - it's to be re-initialized for every single document
        {
            StringMap aEmpty;
            m_aChangeList.swap( aEmpty );
        }

		// first of all, we need to guess the direction of our conversion - it is determined by the first
		// hangul or hanja character in the first text
		if ( !implRetrieveNextPortion() )
		{
            DBG_WARNING( "HangulHanjaConversion_Impl::DoDocumentConversion: why did you call me if you do have nothing to convert?" );
			// nothing to do
			return;
		}
		if( m_eConvType == HHC::eConvHangulHanja )
		{
			//init conversion direction from saved value
			HHC::ConversionDirection eDirection = HHC::eHangulToHanja;
			if(!implGetConversionDirectionForCurrentPortion( eDirection ))
				// something went wrong, has already been asserted
				return;

			if (m_pAntiImpl->IsUseSavedConversionDirectionState())
			{
				m_ePrimaryConversionDirection = m_pAntiImpl->m_ePrimaryConversionDirectionSave;
				m_bTryBothDirections = m_pAntiImpl->m_bTryBothDirectionsSave;
				if( m_bTryBothDirections )
					m_eCurrentConversionDirection = eDirection;
				else
					m_eCurrentConversionDirection = m_ePrimaryConversionDirection;
			}
			else
			{
				m_ePrimaryConversionDirection = eDirection;
				m_eCurrentConversionDirection = eDirection;
			}
		}

		if (m_bIsInteractive  &&  m_eConvType == HHC::eConvHangulHanja)
		{
			//always open dialog if at least having a hangul or hanja text portion
			createDialog();
			if(m_pAntiImpl->IsUseSavedConversionDirectionState())
				ContinueConversion( sal_False );
			else
				implUpdateData();
			m_pConversionDialog->Execute();
			DELETEZ( m_pConversionDialog );
		}
		else
		{
#ifdef DBG_UTIL
			sal_Bool bCompletelyDone =
#endif
			ContinueConversion( sal_False );
			DBG_ASSERT( bCompletelyDone, "HangulHanjaConversion_Impl::DoDocumentConversion: ContinueConversion should have returned true here!" );
		}
	}

	//-------------------------------------------------------------------------
	void HangulHanjaConversion_Impl::implProceed( bool _bRepeatCurrentUnit )
	{
		if ( ContinueConversion( _bRepeatCurrentUnit ) )
		{	// we're done with the whole document
            DBG_ASSERT( !m_bIsInteractive || m_pConversionDialog, "HangulHanjaConversion_Impl::implProceed: we should not reach this here without dialog!" );
			if ( m_pConversionDialog )
				m_pConversionDialog->EndDialog( RET_OK );
		}
	}

	//-------------------------------------------------------------------------
	void HangulHanjaConversion_Impl::implChange( const ::rtl::OUString& _rChangeInto )
	{
        if( !_rChangeInto.getLength() )
            return;

		// translate the conversion format into a replacement action
		// this translation depends on whether we have a Hangul original, or a Hanja original

        HHC::ReplacementAction eAction( HHC::eExchange );

		if (m_eConvType == HHC::eConvHangulHanja)
		{
			// is the original we're about to change in Hangul?
			sal_Bool bOriginalIsHangul = HHC::eHangulToHanja == m_eCurrentConversionDirection;

			switch ( m_eConversionFormat )
			{
				case HHC::eSimpleConversion: eAction = HHC::eExchange; break;
				case HHC::eHangulBracketed:  eAction = bOriginalIsHangul ? HHC::eOriginalBracketed : HHC::eReplacementBracketed; break;
				case HHC::eHanjaBracketed:   eAction = bOriginalIsHangul ? HHC::eReplacementBracketed : HHC::eOriginalBracketed; break;
				case HHC::eRubyHanjaAbove:   eAction = bOriginalIsHangul ? HHC::eReplacementAbove : HHC::eOriginalAbove; break;
				case HHC::eRubyHanjaBelow:   eAction = bOriginalIsHangul ? HHC::eReplacementBelow : HHC::eOriginalBelow; break;
				case HHC::eRubyHangulAbove:  eAction = bOriginalIsHangul ? HHC::eOriginalAbove : HHC::eReplacementAbove; break;
				case HHC::eRubyHangulBelow:  eAction = bOriginalIsHangul ? HHC::eOriginalBelow : HHC::eReplacementBelow; break;
				default:
					DBG_ERROR( "HangulHanjaConversion_Impl::implChange: invalid/unexpected conversion format!" );
			}
		}

		// the proper indicies (the wrapper implementation needs indicies relative to the
		// previous replacement)
		DBG_ASSERT( ( m_nReplacementBaseIndex <= m_nCurrentStartIndex ) && ( m_nReplacementBaseIndex <= m_nCurrentEndIndex ),
			"HangulHanjaConversion_Impl::implChange: invalid replacement base!" );

		sal_Int32 nStartIndex = m_nCurrentStartIndex - m_nReplacementBaseIndex;
		sal_Int32 nEndIndex = m_nCurrentEndIndex - m_nReplacementBaseIndex;

        //remind this decision
        m_aRecentlyUsedList[ GetCurrentUnit() ] = _rChangeInto;

        LanguageType *pNewUnitLang = 0;
        LanguageType  nNewUnitLang = LANGUAGE_NONE;
        if (m_eConvType == HHC::eConvSimplifiedTraditional)
        {
            // check if language needs to be changed
            if ( m_pAntiImpl->GetTargetLanguage() == LANGUAGE_CHINESE_TRADITIONAL &&
                !m_pAntiImpl->IsTraditional( m_nCurrentPortionLang ))
                nNewUnitLang = LANGUAGE_CHINESE_TRADITIONAL;
            else if ( m_pAntiImpl->GetTargetLanguage() == LANGUAGE_CHINESE_SIMPLIFIED &&
                     !m_pAntiImpl->IsSimplified( m_nCurrentPortionLang ))
                nNewUnitLang = LANGUAGE_CHINESE_SIMPLIFIED;
            if (nNewUnitLang != LANGUAGE_NONE)
                pNewUnitLang = &nNewUnitLang;
        }

        // according to FT we should not (yet) bother about Hangul/Hanja conversion here
        //
        // aOffsets is needed in ReplaceUnit below in order to to find out
        // exactly which characters are really changed in order to keep as much
        // from attributation for the text as possible.
        Sequence< sal_Int32 > aOffsets;
        Reference< XExtendedTextConversion > xExtConverter( m_xConverter, UNO_QUERY );
        if (m_eConvType == HHC::eConvSimplifiedTraditional && xExtConverter.is())
		{
            try
            {
                ::rtl::OUString aConvText = xExtConverter->getConversionWithOffset(
                    m_sCurrentPortion,
                    m_nCurrentStartIndex,
                    m_nCurrentEndIndex - m_nCurrentStartIndex,
                    m_aSourceLocale,
                    m_nCurrentConversionType,
                    m_nCurrentConversionOption,
                    aOffsets
                );
            }
            catch( const Exception& )
            {
                DBG_ERROR( "HangulHanjaConversion_Impl::implChange: caught unexpected exception!" );
                aOffsets.realloc(0);
            }
		}

        // do the replacement
        m_pAntiImpl->ReplaceUnit( nStartIndex, nEndIndex, m_sCurrentPortion,
                _rChangeInto, aOffsets, eAction, pNewUnitLang );


		// adjust the replacement base
		m_nReplacementBaseIndex = m_nCurrentEndIndex;
	}

    //-------------------------------------------------------------------------
    void HangulHanjaConversion_Impl::implReadOptionsFromConfiguration()
    {
        SvtLinguConfig	aLngCfg;
        aLngCfg.GetProperty( UPH_IS_IGNORE_POST_POSITIONAL_WORD ) >>= m_bIgnorePostPositionalWord;
        aLngCfg.GetProperty( UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST ) >>= m_bShowRecentlyUsedFirst;
        aLngCfg.GetProperty( UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES ) >>= m_bAutoReplaceUnique;
    }

    //-------------------------------------------------------------------------
    void HangulHanjaConversion_Impl::implUpdateData()
    {
        implReadOptionsFromConfiguration();
        implUpdateSuggestions();

        if(m_pConversionDialog)
        {
            ::rtl::OUString sCurrentUnit( GetCurrentUnit() );

            m_pConversionDialog->SetCurrentString( sCurrentUnit, m_aCurrentSuggestions );
            m_pConversionDialog->FocusSuggestion();
        }

        m_pAntiImpl->HandleNewUnit( m_nCurrentStartIndex - m_nReplacementBaseIndex, m_nCurrentEndIndex - m_nReplacementBaseIndex );
    }

    //-------------------------------------------------------------------------
	IMPL_LINK( HangulHanjaConversion_Impl, OnOptionsChanged, void*, EMPTYARG )
	{
        //options and dictionaries might have been changed
        //-> update our internal settings and the dialog
        implUpdateData();

        return 0L;
	}

	//-------------------------------------------------------------------------
	IMPL_LINK( HangulHanjaConversion_Impl, OnIgnore, void*, EMPTYARG )
	{
		// simply ignore, and proceed
		implProceed( sal_False );
		return 0L;
	}

	//-------------------------------------------------------------------------
	IMPL_LINK( HangulHanjaConversion_Impl, OnIgnoreAll, void*, EMPTYARG )
	{
		DBG_ASSERT( m_pConversionDialog, "HangulHanjaConversion_Impl::OnIgnoreAll: no dialog! How this?" );

		if ( m_pConversionDialog )
		{
			String sCurrentUnit = m_pConversionDialog->GetCurrentString();
			DBG_ASSERT( m_sIgnoreList.end() == m_sIgnoreList.find( sCurrentUnit ),
				"HangulHanjaConversion_Impl, OnIgnoreAll: shouldn't this have been ignored before" );

			// put into the "ignore all" list
			m_sIgnoreList.insert( sCurrentUnit );

			// and proceed
			implProceed( sal_False );
		}

		return 0L;
	}

	//-------------------------------------------------------------------------
	IMPL_LINK( HangulHanjaConversion_Impl, OnChange, void*, EMPTYARG )
	{
		// change
        DBG_ASSERT( m_pConversionDialog, "we should always have a dialog here!" );
        if( m_pConversionDialog )
		    implChange( m_pConversionDialog->GetCurrentSuggestion( ) );
		// and proceed
		implProceed( sal_False );

		return 0L;
	}

	//-------------------------------------------------------------------------
	IMPL_LINK( HangulHanjaConversion_Impl, OnChangeAll, void*, EMPTYARG )
	{
		DBG_ASSERT( m_pConversionDialog, "HangulHanjaConversion_Impl::OnChangeAll: no dialog! How this?" );
		if ( m_pConversionDialog )
		{
			::rtl::OUString sCurrentUnit( m_pConversionDialog->GetCurrentString() );
			::rtl::OUString sChangeInto( m_pConversionDialog->GetCurrentSuggestion( ) );

            if( sChangeInto.getLength() )
            {
			    // change the current occurence
			    implChange( sChangeInto );

			    // put into the "change all" list
			    m_aChangeList.insert( StringMap::value_type( sCurrentUnit, sChangeInto ) );
            }

			// and proceed
			implProceed( sal_False );
		}

		return 0L;
	}

	//-------------------------------------------------------------------------
	IMPL_LINK( HangulHanjaConversion_Impl, OnByCharClicked, CheckBox*, _pBox )
	{
		m_bByCharacter = _pBox->IsChecked();

		// continue conversion, without advancing to the next unit, but instead continuing with the current unit
		implProceed( sal_True );
		return 0L;
	}

	//-------------------------------------------------------------------------
	IMPL_LINK( HangulHanjaConversion_Impl, OnConversionTypeChanged, void*, EMPTYARG )
	{
        DBG_ASSERT( m_pConversionDialog, "we should always have a dialog here!" );
        if( m_pConversionDialog )
		    m_eConversionFormat = m_pConversionDialog->GetConversionFormat( );
		return 0L;
	}

	//-------------------------------------------------------------------------
	IMPL_LINK( HangulHanjaConversion_Impl, OnFind, void*, EMPTYARG )
	{
		DBG_ASSERT( m_pConversionDialog, "HangulHanjaConversion_Impl::OnFind: where did this come from?" );
		if ( m_pConversionDialog )
		{
			try
			{
				::rtl::OUString sNewOriginal( m_pConversionDialog->GetCurrentSuggestion( ) );
				Sequence< ::rtl::OUString > aSuggestions;

				DBG_ASSERT( m_xConverter.is(), "HangulHanjaConversion_Impl::OnFind: no converter!" );
				TextConversionResult aToHanja = m_xConverter->getConversions(
					sNewOriginal,
					0, sNewOriginal.getLength(),
                    m_aSourceLocale,
					TextConversionType::TO_HANJA,
					TextConversionOption::NONE
				);
				TextConversionResult aToHangul = m_xConverter->getConversions(
					sNewOriginal,
					0, sNewOriginal.getLength(),
                    m_aSourceLocale,
					TextConversionType::TO_HANGUL,
					TextConversionOption::NONE
				);

				bool bHaveToHanja = ( aToHanja.Boundary.startPos < aToHanja.Boundary.endPos );
				bool bHaveToHangul = ( aToHangul.Boundary.startPos < aToHangul.Boundary.endPos );

				TextConversionResult* pResult = NULL;
				if ( bHaveToHanja && bHaveToHangul )
				{	// it found convertibles in both directions -> use the first
					if ( aToHangul.Boundary.startPos < aToHanja.Boundary.startPos )
						pResult = &aToHangul;
					else
						pResult = &aToHanja;
				}
				else if ( bHaveToHanja )
				{	// only found toHanja
					pResult = &aToHanja;
				}
				else
				{	// only found toHangul
					pResult = &aToHangul;
				}
				if ( pResult )
					aSuggestions = pResult->Candidates;

				m_pConversionDialog->SetCurrentString( sNewOriginal, aSuggestions, false );
				m_pConversionDialog->FocusSuggestion();
			}
			catch( const Exception& )
			{
				DBG_ERROR( "HangulHanjaConversion_Impl::OnFind: caught an exception!" );
			}
		}
		return 0L;
	}

	//=========================================================================
	//= HangulHanjaConversion
	//=========================================================================
	//-------------------------------------------------------------------------

	// static member initialization
	sal_Bool	HangulHanjaConversion::m_bUseSavedValues		= sal_False;
	sal_Bool	HangulHanjaConversion::m_bTryBothDirectionsSave	= sal_False;
    HHC::ConversionDirection HangulHanjaConversion::m_ePrimaryConversionDirectionSave	= HHC::eHangulToHanja;

	//-------------------------------------------------------------------------
    HangulHanjaConversion::HangulHanjaConversion( Window* _pUIParent,
        const Reference< XMultiServiceFactory >& _rxORB,
        const Locale& _rSourceLocale, const Locale& _rTargetLocale,
        const Font* _pTargetFont,
        sal_Int32 _nOptions, sal_Bool _bIsInteractive)
        :m_pImpl( new HangulHanjaConversion_Impl( _pUIParent, _rxORB, _rSourceLocale, _rTargetLocale, _pTargetFont, _nOptions, _bIsInteractive, this ) )
	{
	}

	//-------------------------------------------------------------------------
	HangulHanjaConversion::~HangulHanjaConversion( )
	{
	}

	//-------------------------------------------------------------------------
	void HangulHanjaConversion::SetUseSavedConversionDirectionState( sal_Bool bVal )
	{
		m_bUseSavedValues = bVal;
	}

	//-------------------------------------------------------------------------
	sal_Bool HangulHanjaConversion::IsUseSavedConversionDirectionState()
	{
		return m_bUseSavedValues;
	}

    //-------------------------------------------------------------------------
    LanguageType HangulHanjaConversion::GetSourceLanguage( ) const
    {
        return m_pImpl->GetSourceLang();
    }

    //-------------------------------------------------------------------------
    LanguageType HangulHanjaConversion::GetTargetLanguage( ) const
    {
        return m_pImpl->GetTargetLang();
    }

    //-------------------------------------------------------------------------
    const Font * HangulHanjaConversion::GetTargetFont( ) const
    {
        return m_pImpl->GetTargetFont();
    }

    //-------------------------------------------------------------------------
    sal_Int32 HangulHanjaConversion::GetConversionOptions( ) const
    {
        return m_pImpl->GetConvOptions();
    }

    //-------------------------------------------------------------------------
    sal_Bool HangulHanjaConversion::IsInteractive( ) const
    {
        return m_pImpl->IsInteractive();
    }

    //-------------------------------------------------------------------------
	void HangulHanjaConversion::HandleNewUnit( const sal_Int32, const sal_Int32 )
	{
		// nothing to do, only derived classes need this.
	}

	//-------------------------------------------------------------------------
    void HangulHanjaConversion::GetNextPortion( ::rtl::OUString&, LanguageType&, sal_Bool )
	{
		DBG_ERROR( "HangulHanjaConversion::GetNextPortion: to be overridden!" );
	}

	//-------------------------------------------------------------------------
    void HangulHanjaConversion::ReplaceUnit(
            const sal_Int32, const sal_Int32,
            const ::rtl::OUString&,
            const ::rtl::OUString&,
            const ::com::sun::star::uno::Sequence< sal_Int32 > &,
            ReplacementAction,
            LanguageType * )
	{
		DBG_ERROR( "HangulHanjaConversion::ReplaceUnit: to be overridden!" );
	}

    //-------------------------------------------------------------------------
    sal_Bool HangulHanjaConversion::HasRubySupport() const
    {
        DBG_ERROR( "HangulHanjaConversion::HasRubySupport: to be overridden!" );
        return sal_False;
    }

	//-------------------------------------------------------------------------
	void HangulHanjaConversion::ConvertDocument()
	{
		if ( m_pImpl->IsValid() )
			m_pImpl->DoDocumentConversion( );
	}

//.............................................................................
}	// namespace svx
//.............................................................................