AOO410/main/editeng/source/misc/splwrap.cxx

/**************************************************************
 * 
 * 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<rtl/ustring.hxx>
#include <tools/shl.hxx>
#include <vcl/wrkwin.hxx>
#include <vcl/svapp.hxx>
#include <vcl/msgbox.hxx>
#include <tools/debug.hxx>
#include <svtools/langtab.hxx>

#ifndef __RSC
#include <tools/errinf.hxx>
#endif
#include <editeng/unolingu.hxx>
#include <linguistic/lngprops.hxx>
#include <com/sun/star/frame/XStorable.hpp>

#include <map>

#include <editeng/svxenum.hxx>
#include <editeng/splwrap.hxx>      // Der Wrapper
#include <editeng/edtdlg.hxx>      
#include <editeng/eerdll.hxx>
#include <editeng/editrids.hrc>
#include <editeng/editids.hrc>
#include <editeng/editerr.hxx>

#define WAIT_ON() if(pWin != NULL) { pWin->EnterWait(); }

#define WAIT_OFF() if(pWin != NULL) { pWin->LeaveWait(); }

using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::linguistic2;


// misc functions ---------------------------------------------

void SvxPrepareAutoCorrect( String &rOldText, String &rNewText )
{
	// This function should be used to strip (or add) trailing '.' from
	// the strings before passing them on to the autocorrect function in
	// order that the autocorrect function will hopefully
	// works properly with normal words and abbreviations (with trailing '.')
	// independ of if they are at the end of the sentence or not.
	//
	// rOldText: text to be replaced
	// rNewText: replacement text

	xub_StrLen	nOldLen = rOldText.Len(),
				nNewLen = rNewText.Len();
	if (nOldLen && nNewLen)
	{
		sal_Bool bOldHasDot = sal_Unicode( '.' ) == rOldText.GetChar( nOldLen - 1 ),
			 bNewHasDot = sal_Unicode( '.' ) == rNewText.GetChar( nNewLen - 1 );
		if (bOldHasDot && !bNewHasDot
			/*this is: !(bOldHasDot && bNewHasDot) && bOldHasDot*/)
			rOldText.Erase( nOldLen - 1 );
	}
}

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

#define SVX_LANG_NEED_CHECK			0
#define SVX_LANG_OK					1
#define SVX_LANG_MISSING			2
#define SVX_LANG_MISSING_DO_WARN	3

#define SVX_FLAGS_NEW


struct lt_LanguageType
{
    bool operator()( LanguageType n1, LanguageType n2 ) const
    {
        return n1 < n2;
    }
};

typedef std::map< LanguageType, sal_uInt16, lt_LanguageType >   LangCheckState_map_t;

static LangCheckState_map_t & GetLangCheckState()
{
    static LangCheckState_map_t aLangCheckState;
    return aLangCheckState;
}

void SvxSpellWrapper::ShowLanguageErrors()
{
    // display message boxes for languages not available for
    // spellchecking or hyphenation
    LangCheckState_map_t &rLCS = GetLangCheckState();
    LangCheckState_map_t::iterator aIt( rLCS.begin() );
    while (aIt != rLCS.end())
	{
        LanguageType nLang = aIt->first;
        sal_uInt16   nVal  = aIt->second;
		sal_uInt16 nTmpSpell = nVal & 0x00FF;
		sal_uInt16 nTmpHyph  = (nVal >> 8) & 0x00FF;

		if (SVX_LANG_MISSING_DO_WARN == nTmpSpell)
		{
			String aErr( SvtLanguageTable::GetLanguageString( nLang ) );
			ErrorHandler::HandleError(
				*new StringErrorInfo( ERRCODE_SVX_LINGU_LANGUAGENOTEXISTS, aErr ) );
			nTmpSpell = SVX_LANG_MISSING;
		}
		if (SVX_LANG_MISSING_DO_WARN == nTmpHyph)
		{
			String aErr( SvtLanguageTable::GetLanguageString( nLang ) );
			ErrorHandler::HandleError(
				*new StringErrorInfo( ERRCODE_SVX_LINGU_LANGUAGENOTEXISTS, aErr ) );
			nTmpHyph = SVX_LANG_MISSING;
		}

        rLCS[ nLang ] = (nTmpHyph << 8) | nTmpSpell;
        ++aIt;
	}

}

SvxSpellWrapper::~SvxSpellWrapper()
{
}

/*--------------------------------------------------------------------
 *	Beschreibung: Ctor, die Pruefreihenfolge wird festgelegt
 *
 *  !bStart && !bOtherCntnt:	BODY_END,	BODY_START,	OTHER
 *  !bStart && bOtherCntnt:		OTHER,		BODY
 *  bStart && !bOtherCntnt:		BODY_END,	OTHER
 *  bStart && bOtherCntnt:		OTHER
 *
 --------------------------------------------------------------------*/

SvxSpellWrapper::SvxSpellWrapper( Window* pWn,
	Reference< XSpellChecker1 >  &xSpellChecker,
	const sal_Bool bStart, const sal_Bool bIsAllRight,
	const sal_Bool bOther, const sal_Bool bRevAllow ) :

	pWin		( pWn ),
	xSpell		( xSpellChecker ),
	mpTextObj( NULL),
	bOtherCntnt	( bOther ),
	bDialog		( sal_False ),
	bHyphen		( sal_False ),
	bAuto		( sal_False ),
	bStartChk	( bOther ),
    bRevAllowed ( bRevAllow ),
    bAllRight   ( bIsAllRight )
{
	Reference< beans::XPropertySet >  xProp( SvxGetLinguPropertySet() );
	sal_Bool bWrapReverse = xProp.is() ?
		*(sal_Bool*)xProp->getPropertyValue(
			::rtl::OUString::createFromAscii(UPN_IS_WRAP_REVERSE) ).getValue()
		: sal_False;
	bReverse = bRevAllow && bWrapReverse;
	bStartDone = bOther || ( !bReverse && bStart );
	bEndDone   = bReverse && bStart && !bOther;
}

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

SvxSpellWrapper::SvxSpellWrapper( Window* pWn,
		Reference< XHyphenator >  &xHyphenator,
		const sal_Bool bStart, const sal_Bool bOther ) :
	pWin		( pWn ),
	xHyph		( xHyphenator ),
	mpTextObj( NULL),
	bOtherCntnt	( bOther ),
	bDialog		( sal_False ),
	bHyphen		( sal_False ),
	bAuto		( sal_False ),
	bReverse	( sal_False ),
	bStartDone	( bOther || ( !bReverse && bStart ) ),
	bEndDone	( bReverse && bStart && !bOther ),
	bStartChk	( bOther ),
    bRevAllowed ( sal_False ),
    bAllRight   ( sal_True )
{
}

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

sal_Int16 SvxSpellWrapper::CheckSpellLang(
		Reference< XSpellChecker1 > xSpell, sal_Int16 nLang)
{
    LangCheckState_map_t &rLCS = GetLangCheckState();

    LangCheckState_map_t::iterator aIt( rLCS.find( nLang ) );
    sal_uInt16 nVal = aIt == rLCS.end() ? SVX_LANG_NEED_CHECK : aIt->second;

    if (aIt == rLCS.end())
        rLCS[ nLang ] = nVal;

	if (SVX_LANG_NEED_CHECK == (nVal & 0x00FF))
	{
		sal_uInt16 nTmpVal = SVX_LANG_MISSING_DO_WARN;
		if (xSpell.is()  &&  xSpell->hasLanguage( nLang ))
			nTmpVal = SVX_LANG_OK;
		nVal &= 0xFF00;
		nVal |= nTmpVal;

        rLCS[ nLang ] = nVal;
	}

    return (sal_Int16) nVal;
}

sal_Int16 SvxSpellWrapper::CheckHyphLang(
		Reference< XHyphenator >  xHyph, sal_Int16 nLang)
{
    LangCheckState_map_t &rLCS = GetLangCheckState();

    LangCheckState_map_t::iterator aIt( rLCS.find( nLang ) );
    sal_uInt16 nVal = aIt == rLCS.end() ? 0 : aIt->second;

    if (aIt == rLCS.end())
        rLCS[ nLang ] = nVal;

	if (SVX_LANG_NEED_CHECK == ((nVal >> 8) & 0x00FF))
	{
		sal_uInt16 nTmpVal = SVX_LANG_MISSING_DO_WARN;
		if (xHyph.is()  &&  xHyph->hasLocale( SvxCreateLocale( nLang ) ))
			nTmpVal = SVX_LANG_OK;
		nVal &= 0x00FF;
		nVal |= nTmpVal << 8;

        rLCS[ nLang ] = nVal;
	}

    return (sal_Int16) nVal;
}

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


void SvxSpellWrapper::SpellStart( SvxSpellArea /*eSpell*/ )
{	// Hier muessen die notwendigen Vorbereitungen fuer SpellContinue
}	// im uebergebenen Bereich getroffen werden.

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


sal_Bool SvxSpellWrapper::HasOtherCnt()
{
	return sal_False; // Gibt es ueberhaupt einen Sonderbereich?
}

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


sal_Bool SvxSpellWrapper::SpellMore()
{
	return sal_False; // Sollen weitere Dokumente geprueft werden?
}

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


void SvxSpellWrapper::SpellEnd()
{	// Bereich ist abgeschlossen, ggf. Aufraeumen

    // display error for last language not found
    ShowLanguageErrors();
}

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


sal_Bool SvxSpellWrapper::SpellContinue()
{
	return sal_False;
}

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

void SvxSpellWrapper::AutoCorrect( const String&, const String& )
{
}

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


void SvxSpellWrapper::ScrollArea()
{	// Scrollarea einstellen
}

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


void SvxSpellWrapper::ChangeWord( const String&, const sal_uInt16 )
{	// Wort ersetzen
}

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


String SvxSpellWrapper::GetThesWord()
{
	// Welches Wort soll nachgeschlagen werden?
	return String();
}

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


void SvxSpellWrapper::ChangeThesWord( const String& )
{
	// Wort wg. Thesaurus ersetzen
}

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

void SvxSpellWrapper::StartThesaurus( const String &rWord, sal_uInt16 nLanguage )
{
	Reference< XThesaurus >  xThes( SvxGetThesaurus() );
	if (!xThes.is())
	{
		InfoBox( pWin, EE_RESSTR( RID_SVXSTR_HMERR_THESAURUS ) ).Execute();
		return;
	}

	WAIT_ON();	// while looking up for initial word
	EditAbstractDialogFactory* pFact = EditAbstractDialogFactory::Create();
	AbstractThesaurusDialog* pDlg = pFact->CreateThesaurusDialog( pWin, xThes, rWord, nLanguage );
	WAIT_OFF();
	if ( pDlg->Execute()== RET_OK )
	{
		ChangeThesWord( pDlg->GetWord() );
	}
	delete pDlg;
}

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

void SvxSpellWrapper::ReplaceAll( const String &, sal_Int16 )
{	// Wort aus der Replace-Liste ersetzen
}

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


void SvxSpellWrapper::SetLanguage( const sal_uInt16 )
{	// Sprache aendern
}

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


void SvxSpellWrapper::InsertHyphen( const sal_uInt16 )
{	// Hyphen einfuegen bzw. loeschen
}

// -----------------------------------------------------------------------
// Pruefung der Dokumentbereiche in der durch die Flags angegebenen Reihenfolge


void SvxSpellWrapper::SpellDocument( )
{
	if ( bOtherCntnt )
	{
		bReverse = sal_False;
		SpellStart( SVX_SPELL_OTHER );
	}
	else
	{
		bStartChk = bReverse;
		SpellStart( bReverse ? SVX_SPELL_BODY_START : SVX_SPELL_BODY_END );
	}

	if ( FindSpellError() )
	{
		Reference< XSpellAlternatives >  	xAlt( GetLast(), UNO_QUERY );
		Reference< XHyphenatedWord > 		xHyphWord( GetLast(), UNO_QUERY );

		Window *pOld = pWin;
		bDialog = sal_True;
		if (xHyphWord.is())
		{
			EditAbstractDialogFactory* pFact = EditAbstractDialogFactory::Create();
			AbstractHyphenWordDialog* pDlg = pFact->CreateHyphenWordDialog( pWin, 
							xHyphWord->getWord(),
							SvxLocaleToLanguage( xHyphWord->getLocale() ),
							xHyph, this );
			pWin = pDlg->GetWindow();
			pDlg->Execute();
			delete pDlg;
		}
		bDialog = sal_False;
		pWin = pOld;
	};
}

// -----------------------------------------------------------------------
// Naechsten Bereich auswaehlen


sal_Bool SvxSpellWrapper::SpellNext( )
{
	Reference< beans::XPropertySet >  xProp( SvxGetLinguPropertySet() );
	sal_Bool bWrapReverse = xProp.is() ?
			*(sal_Bool*)xProp->getPropertyValue(
				::rtl::OUString::createFromAscii(UPN_IS_WRAP_REVERSE) ).getValue()
			: sal_False;
	sal_Bool bActRev = bRevAllowed && bWrapReverse;

	// bActRev ist die Richtung nach dem Spellen, bReverse die am Anfang.
	if( bActRev == bReverse )
	{   						// Keine Richtungsaenderung, also ist
		if( bStartChk )         // der gewuenschte Bereich ( bStartChk )
			bStartDone = sal_True;  // vollstaendig abgearbeitet.
		else
			bEndDone = sal_True;
	}
	else if( bReverse == bStartChk ) // Bei einer Richtungsaenderung kann
	{ 						   // u.U. auch ein Bereich abgearbeitet sein.
		if( bStartChk )        // Sollte der vordere Teil rueckwaerts gespellt
			bEndDone = sal_True;   // werden und wir kehren unterwegs um, so ist
		else				   // der hintere Teil abgearbeitet (und umgekehrt).
			bStartDone = sal_True;
	}

	bReverse = bActRev;
	if( bOtherCntnt && bStartDone && bEndDone ) // Dokument komplett geprueft?
	{
		if ( SpellMore() )  // ein weiteres Dokument pruefen?
		{
			bOtherCntnt = sal_False;
			bStartDone = !bReverse;
			bEndDone  = bReverse;
			SpellStart( SVX_SPELL_BODY );
			return sal_True;
		}
		return sal_False;
	}

	sal_Bool bGoOn = sal_False;

	if ( bOtherCntnt )
	{
		bStartChk = sal_False;
		SpellStart( SVX_SPELL_BODY );
		bGoOn = sal_True;
	}
	else if ( bStartDone && bEndDone )
	{
		sal_Bool bIsSpellSpecial = xProp.is() ?
			*(sal_Bool*)xProp->getPropertyValue(
				::rtl::OUString::createFromAscii(UPN_IS_SPELL_SPECIAL) ).getValue()
			: sal_False;
		// Bodybereich erledigt, Frage nach Sonderbereich
		if( !IsHyphen() && bIsSpellSpecial && HasOtherCnt() )
		{
			SpellStart( SVX_SPELL_OTHER );
			bOtherCntnt = bGoOn = sal_True;
		}
		else if ( SpellMore() )  // ein weiteres Dokument pruefen?
		{
			bOtherCntnt = sal_False;
			bStartDone = !bReverse;
			bEndDone  = bReverse;
			SpellStart( SVX_SPELL_BODY );
			return sal_True;
		}
	}
	else
	{
		// Ein BODY_Bereich erledigt, Frage nach dem anderen BODY_Bereich
		WAIT_OFF();

// Sobald im Dialog das DontWrapAround gesetzt werden kann, kann der
// folgende #ifdef-Zweig aktiviert werden ...
#ifdef USED
		sal_Bool bDontWrapAround = IsHyphen() ?
			pSpell->GetOptions() & DONT_WRAPAROUND :
			pSpell->GetHyphOptions() & HYPH_DONT_WRAPAROUND;
		if( bDontWrapAround )
#else
		sal_uInt16 nResId = bReverse ? RID_SVXQB_BW_CONTINUE : RID_SVXQB_CONTINUE;
		QueryBox aBox( pWin, EditResId( nResId ) );
		if ( aBox.Execute() != RET_YES )
#endif

		{
			// Verzicht auf den anderen Bereich, ggf. Frage nach Sonderbereich
			WAIT_ON();
			bStartDone = bEndDone = sal_True;
			return SpellNext();
		}
		else
		{
			bStartChk = !bStartDone;
			SpellStart( bStartChk ? SVX_SPELL_BODY_START : SVX_SPELL_BODY_END );
			bGoOn = sal_True;
		}
		WAIT_ON();
	}
	return bGoOn;
}

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

Reference< XDictionary >  SvxSpellWrapper::GetAllRightDic() const
{
    Reference< XDictionary >  xDic;

	Reference< XDictionaryList >  xDicList( SvxGetDictionaryList() );
	if (xDicList.is())
	{
		Sequence< Reference< XDictionary >  > aDics( xDicList->getDictionaries() );
		const Reference< XDictionary >  *pDic = aDics.getConstArray();
		sal_Int32 nCount = aDics.getLength();

		sal_Int32 i = 0;
		while (!xDic.is()  &&  i < nCount)
		{
            Reference< XDictionary >  xTmp( pDic[i], UNO_QUERY );
			if (xTmp.is())
			{
				if ( xTmp->isActive() &&
					 xTmp->getDictionaryType() != DictionaryType_NEGATIVE &&
                     SvxLocaleToLanguage( xTmp->getLocale() ) == LANGUAGE_NONE )
				{
					Reference< frame::XStorable >  xStor( xTmp, UNO_QUERY );
					if (xStor.is() && xStor->hasLocation() && !xStor->isReadonly())
					{
						xDic = xTmp;
					}
				}
			}
			++i;
		}

		if (!xDic.is())
		{
			xDic = SvxGetOrCreatePosDic( xDicList );
			if (xDic.is())
				xDic->setActive( sal_True );
		}
	}

	return xDic;
}

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

sal_Bool SvxSpellWrapper::FindSpellError()
{
    ShowLanguageErrors();

 	Reference< XInterface > 	xRef;

	WAIT_ON();
	sal_Bool bSpell = sal_True;

    Reference< XDictionary >  xAllRightDic;
	if (IsAllRight())
		xAllRightDic = GetAllRightDic();

	while ( bSpell )
	{
		SpellContinue();

		Reference< XSpellAlternatives >  	xAlt( GetLast(), UNO_QUERY );
		Reference< XHyphenatedWord > 		xHyphWord( GetLast(), UNO_QUERY );

		if (xAlt.is())
		{
			if (IsAllRight() && xAllRightDic.is())
			{
				xAllRightDic->add( xAlt->getWord(), sal_False, ::rtl::OUString() );
			}
			else
			{
				// look up in ChangeAllList for misspelled word
                Reference< XDictionary >    xChangeAllList(
						SvxGetChangeAllList(), UNO_QUERY );
				Reference< XDictionaryEntry > 	xEntry;
				if (xChangeAllList.is())
					xEntry = xChangeAllList->getEntry( xAlt->getWord() );

				if (xEntry.is())
				{
					// replace word without asking
					ReplaceAll( xEntry->getReplacementText(),
								SvxLocaleToLanguage( xAlt->getLocale() ) );
				}
				else
					bSpell = sal_False;
			}
		}
		else if (xHyphWord.is())
			bSpell = sal_False;
		else
		{
			SpellEnd();
			bSpell = SpellNext();
		}
	}
	WAIT_OFF();
	return GetLast().is();
}