7f135227a9
and cid#1556135 COPY_INSTEAD_OF_MOVE cid#1556146 COPY_INSTEAD_OF_MOVE cid#1556164 COPY_INSTEAD_OF_MOVE cid#1556171 COPY_INSTEAD_OF_MOVE cid#1556177 COPY_INSTEAD_OF_MOVE cid#1556181 COPY_INSTEAD_OF_MOVE cid#1556182 COPY_INSTEAD_OF_MOVE cid#1556183 COPY_INSTEAD_OF_MOVE cid#1556192 COPY_INSTEAD_OF_MOVE cid#1556201 COPY_INSTEAD_OF_MOVE cid#1556208 COPY_INSTEAD_OF_MOVE cid#1556215 COPY_INSTEAD_OF_MOVE cid#1556224 COPY_INSTEAD_OF_MOVE cid#1556227 COPY_INSTEAD_OF_MOVE cid#1556228 COPY_INSTEAD_OF_MOVE cid#1556238 COPY_INSTEAD_OF_MOVE cid#1556246 COPY_INSTEAD_OF_MOVE cid#1556247 COPY_INSTEAD_OF_MOVE cid#1556288 COPY_INSTEAD_OF_MOVE cid#1556293 COPY_INSTEAD_OF_MOVE cid#1556305 COPY_INSTEAD_OF_MOVE cid#1556310 COPY_INSTEAD_OF_MOVE cid#1556317 COPY_INSTEAD_OF_MOVE cid#1556321 COPY_INSTEAD_OF_MOVE cid#1556322 COPY_INSTEAD_OF_MOVE cid#1556331 COPY_INSTEAD_OF_MOVE cid#1556339 COPY_INSTEAD_OF_MOVE cid#1556342 COPY_INSTEAD_OF_MOVE cid#1556351 COPY_INSTEAD_OF_MOVE cid#1556358 COPY_INSTEAD_OF_MOVE cid#1556370 COPY_INSTEAD_OF_MOVE cid#1556379 COPY_INSTEAD_OF_MOVE cid#1556390 COPY_INSTEAD_OF_MOVE cid#1556423 COPY_INSTEAD_OF_MOVE cid#1556532 COPY_INSTEAD_OF_MOVE cid#1556561 COPY_INSTEAD_OF_MOVE cid#1556662 COPY_INSTEAD_OF_MOVE cid#1556704 COPY_INSTEAD_OF_MOVE cid#1556730 COPY_INSTEAD_OF_MOVE cid#1556988 COPY_INSTEAD_OF_MOVE cid#1557071 COPY_INSTEAD_OF_MOVE cid#1557081 COPY_INSTEAD_OF_MOVE cid#1557177 COPY_INSTEAD_OF_MOVE Change-Id: I2c723f0fe9a4eefa62a68f47049ed690d06eb0ba Reviewed-on: https://gerrit.libreoffice.org/c/core/+/170932 Tested-by: Jenkins Reviewed-by: Caolán McNamara <caolan.mcnamara@collabora.com>
1002 lines
43 KiB
C++
1002 lines
43 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* 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 .
|
|
*/
|
|
|
|
#include <editeng/hangulhanja.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/BreakIterator.hpp>
|
|
#include <com/sun/star/i18n/ScriptType.hpp>
|
|
#include <com/sun/star/i18n/UnicodeScript.hpp>
|
|
#include <com/sun/star/i18n/TextConversion.hpp>
|
|
#include <com/sun/star/i18n/XExtendedTextConversion.hpp>
|
|
#include <com/sun/star/i18n/TextConversionType.hpp>
|
|
#include <com/sun/star/i18n/TextConversionOption.hpp>
|
|
#include <vcl/weld.hxx>
|
|
#include <unotools/charclass.hxx>
|
|
#include <sal/log.hxx>
|
|
#include <osl/diagnose.h>
|
|
#include <tools/debug.hxx>
|
|
#include <comphelper/diagnose_ex.hxx>
|
|
|
|
#include <editeng/edtdlg.hxx>
|
|
|
|
#define HHC HangulHanjaConversion
|
|
|
|
|
|
namespace editeng
|
|
{
|
|
|
|
|
|
using namespace ::com::sun::star;
|
|
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;
|
|
|
|
class HangulHanjaConversion_Impl
|
|
{
|
|
private:
|
|
typedef std::set<OUString> StringBag;
|
|
typedef std::map<OUString, OUString> StringMap;
|
|
|
|
private:
|
|
StringBag m_sIgnoreList;
|
|
StringMap m_aChangeList;
|
|
static StringMap m_aRecentlyUsedList;
|
|
|
|
// general
|
|
VclPtr<AbstractHangulHanjaConversionDialog>
|
|
m_pConversionDialog; // the dialog to display for user interaction
|
|
weld::Widget* m_pUIParent; // the parent window for any UI we raise
|
|
Reference< XComponentContext >
|
|
m_xContext; // the service factory to use
|
|
Reference< XExtendedTextConversion >
|
|
m_xConverter; // the text conversion service
|
|
lang::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 to
|
|
// save the applications from always converting to this
|
|
// type in their implementations
|
|
LanguageType m_nTargetLang; // target language of new replacement text
|
|
const vcl::Font* m_pTargetFont; // target font of new replacement text
|
|
sal_Int32 m_nConvOptions; // text conversion options (as used by 'getConversions')
|
|
bool m_bIsInteractive; // specifies if the conversion requires user interaction
|
|
// (and likely a specialised dialog) or if it is to run
|
|
// automatically without any user interaction.
|
|
// True for Hangul / Hanja conversion
|
|
// False for Chinese simplified / traditional conversion
|
|
|
|
HangulHanjaConversion* m_pAntiImpl; // our "anti-impl" instance
|
|
|
|
// options
|
|
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
|
|
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< OUString >
|
|
m_aCurrentSuggestions; // the suggestions for the current unit
|
|
// (means for the text [m_nCurrentStartIndex, m_nCurrentEndIndex) in m_sCurrentPortion)
|
|
bool m_bTryBothDirections; // specifies if other conversion directions should be tried when looking for convertible characters
|
|
|
|
|
|
public:
|
|
HangulHanjaConversion_Impl(
|
|
weld::Widget* pUIParent,
|
|
const Reference< XComponentContext >& rxContext,
|
|
const lang::Locale& _rSourceLocale,
|
|
const lang::Locale& _rTargetLocale,
|
|
const vcl::Font* _pTargetFont,
|
|
sal_Int32 _nConvOptions,
|
|
bool _bIsInteractive,
|
|
HangulHanjaConversion* _pAntiImpl );
|
|
|
|
public:
|
|
void DoDocumentConversion( );
|
|
|
|
bool IsValid() const { return m_xConverter.is(); }
|
|
|
|
weld::Widget* GetUIParent() const { return m_pUIParent; }
|
|
LanguageType GetSourceLang() const { return m_nSourceLang; }
|
|
LanguageType GetTargetLang() const { return m_nTargetLang; }
|
|
const vcl::Font * GetTargetFont() const { return m_pTargetFont; }
|
|
sal_Int32 GetConvOptions() const { return m_nConvOptions; }
|
|
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
|
|
*/
|
|
bool ContinueConversion( bool _bRepeatCurrentUnit );
|
|
|
|
private:
|
|
DECL_LINK( OnOptionsChanged, LinkParamNone*, void );
|
|
DECL_LINK( OnIgnore, weld::Button&, void );
|
|
DECL_LINK( OnIgnoreAll, weld::Button&, void );
|
|
DECL_LINK( OnChange, weld::Button&, void );
|
|
DECL_LINK( OnChangeAll, weld::Button&, void );
|
|
DECL_LINK( OnByCharClicked, weld::Toggleable&, void );
|
|
DECL_LINK( OnConversionTypeChanged, weld::Toggleable&, void );
|
|
DECL_LINK( OnFind, weld::Button&, 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 OUString& _rChangeInto );
|
|
|
|
/** find the next convertible piece of text, with possibly advancing to the next portion
|
|
|
|
@see HangulHanjaConversion::GetNextPortion
|
|
*/
|
|
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
|
|
*/
|
|
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::StringMap HangulHanjaConversion_Impl::m_aRecentlyUsedList = HangulHanjaConversion_Impl::StringMap();
|
|
|
|
HangulHanjaConversion_Impl::HangulHanjaConversion_Impl( weld::Widget* pUIParent,
|
|
const Reference< XComponentContext >& rxContext,
|
|
const lang::Locale& _rSourceLocale,
|
|
const lang::Locale& _rTargetLocale,
|
|
const vcl::Font* _pTargetFont,
|
|
sal_Int32 _nOptions,
|
|
bool _bIsInteractive,
|
|
HangulHanjaConversion* _pAntiImpl )
|
|
: m_pUIParent( pUIParent )
|
|
, m_xContext( rxContext )
|
|
, m_aSourceLocale( _rSourceLocale )
|
|
, m_nSourceLang( LanguageTag::convertToLanguageType( _rSourceLocale ) )
|
|
, m_nTargetLang( LanguageTag::convertToLanguageType( _rTargetLocale ) )
|
|
, m_pTargetFont( _pTargetFont )
|
|
, m_nConvOptions(_nOptions)
|
|
, m_bIsInteractive( _bIsInteractive )
|
|
, m_pAntiImpl( _pAntiImpl )
|
|
, m_bByCharacter((_nOptions & CHARACTER_BY_CHARACTER) != 0)
|
|
, m_eConversionFormat( HHC::eSimpleConversion)
|
|
, m_ePrimaryConversionDirection( HHC::eHangulToHanja) // used for eConvHangulHanja
|
|
, m_eCurrentConversionDirection( HHC::eHangulToHanja) // used for eConvHangulHanja
|
|
, 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( true )
|
|
{
|
|
implReadOptionsFromConfiguration();
|
|
|
|
DBG_ASSERT( m_xContext.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
|
|
{
|
|
m_eConvType = HHC::eConvHangulHanja;
|
|
OSL_FAIL( "failed to determine conversion type from languages" );
|
|
}
|
|
|
|
m_xConverter = TextConversion::create( m_xContext );
|
|
}
|
|
|
|
void HangulHanjaConversion_Impl::createDialog()
|
|
{
|
|
DBG_ASSERT( m_bIsInteractive, "createDialog when the conversion should not be interactive?" );
|
|
if ( !m_bIsInteractive || m_pConversionDialog )
|
|
return;
|
|
|
|
EditAbstractDialogFactory* pFact = EditAbstractDialogFactory::Create();
|
|
m_pConversionDialog = pFact->CreateHangulHanjaConversionDialog(m_pUIParent);
|
|
|
|
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 = m_bByCharacter ? CHARACTER_BY_CHARACTER : css::i18n::TextConversionOption::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 = false;
|
|
|
|
bool bFoundAny = true;
|
|
try
|
|
{
|
|
TextConversionResult aResult = m_xConverter->getConversions(
|
|
m_sCurrentPortion,
|
|
nStartSearch,
|
|
nLength,
|
|
m_aSourceLocale,
|
|
m_nCurrentConversionType,
|
|
m_nCurrentConversionOption
|
|
);
|
|
const 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 = std::move(aSecondResult);
|
|
|
|
// our current conversion direction changed now
|
|
m_eCurrentConversionDirection = ( HHC::eHangulToHanja == m_eCurrentConversionDirection )
|
|
? HHC::eHanjaToHangul : HHC::eHangulToHanja;
|
|
bFoundAny = 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 )
|
|
{
|
|
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< OUString > aTmp(nCount);
|
|
auto pTmp = aTmp.getArray();
|
|
pTmp[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;
|
|
pTmp[n]=m_aCurrentSuggestions[n-nDiff];
|
|
}
|
|
m_aCurrentSuggestions = aTmp;
|
|
}
|
|
}
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
TOOLS_WARN_EXCEPTION( "editeng", "HangulHanjaConversion_Impl::implNextConvertibleUnit" );
|
|
|
|
//!!! 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 = m_pConversionDialog->GetDirection( HHC::eHangulToHanja );
|
|
|
|
if( !m_bTryBothDirections && eDialogDirection != m_eCurrentConversionDirection )
|
|
{
|
|
m_eCurrentConversionDirection = eDialogDirection;
|
|
}
|
|
|
|
// save currently used value for possible later use
|
|
HangulHanjaConversion::m_bTryBothDirectionsSave = m_bTryBothDirections;
|
|
HangulHanjaConversion::m_ePrimaryConversionDirectionSave = m_eCurrentConversionDirection;
|
|
}
|
|
|
|
bool bFoundAny = implUpdateSuggestions( true, _nStartAt );
|
|
|
|
return bFoundAny &&
|
|
(m_nCurrentStartIndex < m_sCurrentPortion.getLength());
|
|
}
|
|
|
|
bool HangulHanjaConversion_Impl::implRetrieveNextPortion( )
|
|
{
|
|
const bool bAllowImplicitChanges = m_eConvType == HHC::eConvSimplifiedTraditional;
|
|
|
|
m_sCurrentPortion.clear();
|
|
m_nCurrentPortionLang = LANGUAGE_NONE;
|
|
m_pAntiImpl->GetNextPortion( m_sCurrentPortion, m_nCurrentPortionLang, bAllowImplicitChanges );
|
|
m_nReplacementBaseIndex = 0;
|
|
m_nCurrentStartIndex = m_nCurrentEndIndex = 0;
|
|
|
|
bool bRet = !m_sCurrentPortion.isEmpty();
|
|
|
|
if (m_eConvType == HHC::eConvHangulHanja && m_bTryBothDirections)
|
|
implGetConversionDirectionForCurrentPortion( m_eCurrentConversionDirection );
|
|
|
|
return bRet;
|
|
}
|
|
|
|
bool HangulHanjaConversion_Impl::implNextConvertible( bool _bRepeatUnit )
|
|
{
|
|
if ( _bRepeatUnit || ( m_nCurrentEndIndex < m_sCurrentPortion.getLength() ) )
|
|
{
|
|
if ( implNextConvertibleUnit(
|
|
_bRepeatUnit
|
|
? m_nCurrentStartIndex
|
|
: m_nCurrentEndIndex
|
|
) )
|
|
return 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 true;
|
|
}
|
|
}
|
|
while ( !m_sCurrentPortion.isEmpty() );
|
|
|
|
// no more portions
|
|
return false;
|
|
}
|
|
|
|
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!" );
|
|
|
|
OUString sCurrentUnit = m_sCurrentPortion.copy( m_nCurrentStartIndex, m_nCurrentEndIndex - m_nCurrentStartIndex );
|
|
return sCurrentUnit;
|
|
}
|
|
|
|
bool HangulHanjaConversion_Impl::ContinueConversion( bool _bRepeatCurrentUnit )
|
|
{
|
|
while ( implNextConvertible( _bRepeatCurrentUnit ) )
|
|
{
|
|
OUString sCurrentUnit( GetCurrentUnit() );
|
|
|
|
// do we need to ignore it?
|
|
const bool bAlwaysIgnoreThis = m_sIgnoreList.end() != m_sIgnoreList.find( sCurrentUnit );
|
|
|
|
// do we need to change it?
|
|
StringMap::const_iterator aChangeListPos = m_aChangeList.find( sCurrentUnit );
|
|
const bool bAlwaysChangeThis = m_aChangeList.end() != aChangeListPos;
|
|
|
|
// do we automatically change this?
|
|
const bool bAutoChange = m_bAutoReplaceUnique && m_aCurrentSuggestions.getLength() == 1;
|
|
|
|
if (!m_bIsInteractive)
|
|
{
|
|
// silent conversion (e.g. for simplified/traditional Chinese)...
|
|
if(m_aCurrentSuggestions.hasElements())
|
|
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 interactively
|
|
// decide what happens with the current convertible
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
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
|
|
Reference< XBreakIterator > xBreakIter = i18n::BreakIterator::create( m_xContext );
|
|
sal_Int32 nNextAsianScript = xBreakIter->beginOfScript( m_sCurrentPortion, m_nCurrentStartIndex, css::i18n::ScriptType::ASIAN );
|
|
if ( -1 == nNextAsianScript )
|
|
nNextAsianScript = xBreakIter->nextScript( m_sCurrentPortion, m_nCurrentStartIndex, css::i18n::ScriptType::ASIAN );
|
|
if ( ( nNextAsianScript >= m_nCurrentStartIndex ) && ( nNextAsianScript < m_sCurrentPortion.getLength() ) )
|
|
{ // found asian text
|
|
|
|
// determine if it's Hangul
|
|
CharClass aCharClassificaton( m_xContext, LanguageTag( m_aSourceLocale) );
|
|
css::i18n::UnicodeScript 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& )
|
|
{
|
|
TOOLS_WARN_EXCEPTION( "editeng", "HangulHanjaConversion_Impl::implGetConversionDirectionForCurrentPortion" );
|
|
}
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
void HangulHanjaConversion_Impl::DoDocumentConversion( )
|
|
{
|
|
// clear the change-all list - it's to be re-initialized for every single document
|
|
StringMap().swap(m_aChangeList);
|
|
|
|
// 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() )
|
|
{
|
|
SAL_INFO( "editeng", "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 (HangulHanjaConversion::IsUseSavedConversionDirectionState())
|
|
{
|
|
m_ePrimaryConversionDirection = HangulHanjaConversion::m_ePrimaryConversionDirectionSave;
|
|
m_bTryBothDirections = HangulHanjaConversion::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(HangulHanjaConversion::IsUseSavedConversionDirectionState())
|
|
ContinueConversion( false );
|
|
else
|
|
implUpdateData();
|
|
m_pConversionDialog->Execute();
|
|
m_pConversionDialog.disposeAndClear();
|
|
}
|
|
else
|
|
{
|
|
const bool bCompletelyDone = ContinueConversion( 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 OUString& _rChangeInto )
|
|
{
|
|
if( _rChangeInto.isEmpty() )
|
|
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?
|
|
const 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:
|
|
OSL_FAIL( "HangulHanjaConversion_Impl::implChange: invalid/unexpected conversion format!" );
|
|
}
|
|
}
|
|
|
|
// the proper indices (the wrapper implementation needs indices 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 = nullptr;
|
|
LanguageType nNewUnitLang = LANGUAGE_NONE;
|
|
if (m_eConvType == HHC::eConvSimplifiedTraditional)
|
|
{
|
|
// check if language needs to be changed
|
|
if ( m_pAntiImpl->GetTargetLanguage() == LANGUAGE_CHINESE_TRADITIONAL &&
|
|
!HangulHanjaConversion::IsTraditional( m_nCurrentPortionLang ))
|
|
nNewUnitLang = LANGUAGE_CHINESE_TRADITIONAL;
|
|
else if ( m_pAntiImpl->GetTargetLanguage() == LANGUAGE_CHINESE_SIMPLIFIED &&
|
|
!HangulHanjaConversion::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 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;
|
|
if (m_eConvType == HHC::eConvSimplifiedTraditional && m_xConverter.is())
|
|
{
|
|
try
|
|
{
|
|
m_xConverter->getConversionWithOffset(
|
|
m_sCurrentPortion,
|
|
m_nCurrentStartIndex,
|
|
m_nCurrentEndIndex - m_nCurrentStartIndex,
|
|
m_aSourceLocale,
|
|
m_nCurrentConversionType,
|
|
m_nCurrentConversionOption,
|
|
aOffsets
|
|
);
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
TOOLS_WARN_EXCEPTION( "editeng", "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)
|
|
{
|
|
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_NOARG(HangulHanjaConversion_Impl, OnOptionsChanged, LinkParamNone*, void)
|
|
{
|
|
//options and dictionaries might have been changed
|
|
//-> update our internal settings and the dialog
|
|
implUpdateData();
|
|
}
|
|
|
|
IMPL_LINK_NOARG(HangulHanjaConversion_Impl, OnIgnore, weld::Button&, void)
|
|
{
|
|
// simply ignore, and proceed
|
|
implProceed( false );
|
|
}
|
|
|
|
IMPL_LINK_NOARG(HangulHanjaConversion_Impl, OnIgnoreAll, weld::Button&, void)
|
|
{
|
|
DBG_ASSERT( m_pConversionDialog, "HangulHanjaConversion_Impl::OnIgnoreAll: no dialog! How this?" );
|
|
|
|
if ( m_pConversionDialog )
|
|
{
|
|
OUString 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( false );
|
|
}
|
|
}
|
|
|
|
IMPL_LINK_NOARG(HangulHanjaConversion_Impl, OnChange, weld::Button&, void)
|
|
{
|
|
// change
|
|
DBG_ASSERT( m_pConversionDialog, "we should always have a dialog here!" );
|
|
if( m_pConversionDialog )
|
|
implChange( m_pConversionDialog->GetCurrentSuggestion( ) );
|
|
// and proceed
|
|
implProceed( false );
|
|
}
|
|
|
|
IMPL_LINK_NOARG(HangulHanjaConversion_Impl, OnChangeAll, weld::Button&, void)
|
|
{
|
|
DBG_ASSERT( m_pConversionDialog, "HangulHanjaConversion_Impl::OnChangeAll: no dialog! How this?" );
|
|
if ( !m_pConversionDialog )
|
|
return;
|
|
|
|
OUString sCurrentUnit( m_pConversionDialog->GetCurrentString() );
|
|
OUString sChangeInto( m_pConversionDialog->GetCurrentSuggestion( ) );
|
|
|
|
if( !sChangeInto.isEmpty() )
|
|
{
|
|
// change the current occurrence
|
|
implChange( sChangeInto );
|
|
|
|
// put into the "change all" list
|
|
m_aChangeList.emplace( sCurrentUnit, sChangeInto );
|
|
}
|
|
|
|
// and proceed
|
|
implProceed( false );
|
|
}
|
|
|
|
IMPL_LINK(HangulHanjaConversion_Impl, OnByCharClicked, weld::Toggleable&, rBox, void)
|
|
{
|
|
m_bByCharacter = rBox.get_active();
|
|
|
|
// continue conversion, without advancing to the next unit, but instead continuing with the current unit
|
|
implProceed( true );
|
|
}
|
|
|
|
IMPL_LINK_NOARG(HangulHanjaConversion_Impl, OnConversionTypeChanged, weld::Toggleable&, void)
|
|
{
|
|
DBG_ASSERT( m_pConversionDialog, "we should always have a dialog here!" );
|
|
if( m_pConversionDialog )
|
|
m_eConversionFormat = m_pConversionDialog->GetConversionFormat( );
|
|
}
|
|
|
|
IMPL_LINK_NOARG(HangulHanjaConversion_Impl, OnFind, weld::Button&, void)
|
|
{
|
|
DBG_ASSERT( m_pConversionDialog, "HangulHanjaConversion_Impl::OnFind: where did this come from?" );
|
|
if ( !m_pConversionDialog )
|
|
return;
|
|
|
|
try
|
|
{
|
|
OUString sNewOriginal( m_pConversionDialog->GetCurrentSuggestion( ) );
|
|
Sequence< 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 = nullptr;
|
|
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& )
|
|
{
|
|
TOOLS_WARN_EXCEPTION( "editeng", "HangulHanjaConversion_Impl::OnFind" );
|
|
}
|
|
}
|
|
|
|
bool HangulHanjaConversion::m_bUseSavedValues = false;
|
|
bool HangulHanjaConversion::m_bTryBothDirectionsSave = false;
|
|
HHC::ConversionDirection HangulHanjaConversion::m_ePrimaryConversionDirectionSave = HHC::eHangulToHanja;
|
|
|
|
HangulHanjaConversion::HangulHanjaConversion( weld::Widget* pUIParent,
|
|
const Reference< XComponentContext >& rxContext,
|
|
const lang::Locale& _rSourceLocale, const lang::Locale& _rTargetLocale,
|
|
const vcl::Font* _pTargetFont,
|
|
sal_Int32 _nOptions, bool _bIsInteractive)
|
|
:m_pImpl( new HangulHanjaConversion_Impl( pUIParent, rxContext, _rSourceLocale, _rTargetLocale, _pTargetFont, _nOptions, _bIsInteractive, this ) )
|
|
{
|
|
}
|
|
|
|
HangulHanjaConversion::~HangulHanjaConversion() COVERITY_NOEXCEPT_FALSE
|
|
{
|
|
}
|
|
|
|
void HangulHanjaConversion::SetUseSavedConversionDirectionState( bool bVal )
|
|
{
|
|
m_bUseSavedValues = bVal;
|
|
}
|
|
|
|
bool HangulHanjaConversion::IsUseSavedConversionDirectionState()
|
|
{
|
|
return m_bUseSavedValues;
|
|
}
|
|
|
|
weld::Widget* HangulHanjaConversion::GetUIParent() const
|
|
{
|
|
return m_pImpl->GetUIParent();
|
|
}
|
|
|
|
LanguageType HangulHanjaConversion::GetSourceLanguage( ) const
|
|
{
|
|
return m_pImpl->GetSourceLang();
|
|
}
|
|
|
|
LanguageType HangulHanjaConversion::GetTargetLanguage( ) const
|
|
{
|
|
return m_pImpl->GetTargetLang();
|
|
}
|
|
|
|
const vcl::Font * HangulHanjaConversion::GetTargetFont( ) const
|
|
{
|
|
return m_pImpl->GetTargetFont();
|
|
}
|
|
|
|
sal_Int32 HangulHanjaConversion::GetConversionOptions( ) const
|
|
{
|
|
return m_pImpl->GetConvOptions();
|
|
}
|
|
|
|
bool HangulHanjaConversion::IsInteractive( ) const
|
|
{
|
|
return m_pImpl->IsInteractive();
|
|
}
|
|
|
|
void HangulHanjaConversion::ConvertDocument()
|
|
{
|
|
if ( m_pImpl->IsValid() )
|
|
m_pImpl->DoDocumentConversion( );
|
|
}
|
|
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|