474 lines
15 KiB
C++
474 lines
15 KiB
C++
/*************************************************************************
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* $RCSfile: matchlocale.cxx,v $
|
|
*
|
|
* $Revision: 1.10 $
|
|
*
|
|
* last change: $Author: obo $ $Date: 2006-09-16 15:34:29 $
|
|
*
|
|
* The Contents of this file are made available subject to
|
|
* the terms of GNU Lesser General Public License Version 2.1.
|
|
*
|
|
*
|
|
* GNU Lesser General Public License Version 2.1
|
|
* =============================================
|
|
* Copyright 2005 by Sun Microsystems, Inc.
|
|
* 901 San Antonio Road, Palo Alto, CA 94303, USA
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License version 2.1, as published by the Free Software Foundation.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
************************************************************************/
|
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
#include "precompiled_configmgr.hxx"
|
|
#include "matchlocale.hxx"
|
|
|
|
#include <rtl/ustrbuf.hxx>
|
|
|
|
#include <algorithm>
|
|
#include <iterator>
|
|
|
|
namespace configmgr
|
|
{
|
|
// -----------------------------------------------------------------------------
|
|
namespace localehelper
|
|
{
|
|
// -----------------------------------------------------------------------------
|
|
using ::rtl::OUString;
|
|
namespace uno = ::com::sun::star::uno;
|
|
namespace lang = ::com::sun::star::lang;
|
|
|
|
#define ARRAYSIZE( arr ) (sizeof(arr) / sizeof 0[arr] )
|
|
// -----------------------------------------------------------------------------
|
|
struct StaticLocale
|
|
{
|
|
typedef char const * String;
|
|
String aLanguage;
|
|
String aCountry;
|
|
};
|
|
|
|
StaticLocale::String const c_sAnyLanguage = "*"; // exported !
|
|
StaticLocale::String const c_sDefLanguage = "x-default"; // exported !
|
|
|
|
StaticLocale::String const c_sNoCountry = "";
|
|
|
|
StaticLocale::String const c_sLanguageEnglish = "en";
|
|
StaticLocale::String const c_sCountryUS = "US";
|
|
|
|
StaticLocale const c_aFallbackLocales[] =
|
|
{
|
|
{ c_sLanguageEnglish, c_sCountryUS }, // english [cannot make 'en' better than 'en-US' :-(]
|
|
{ c_sAnyLanguage, c_sNoCountry } // just take the first you find
|
|
};
|
|
SequencePos const c_nFallbackLocales = ARRAYSIZE(c_aFallbackLocales);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
bool isAnyLanguage(OUString const & _sLanguage)
|
|
{
|
|
return !!_sLanguage.equalsAscii(c_sAnyLanguage);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
bool isDefaultLanguage(OUString const & _sLanguage)
|
|
{
|
|
return !!_sLanguage.equalsAscii(c_sDefLanguage);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
OUString getAnyLanguage()
|
|
{
|
|
return OUString::createFromAscii( c_sAnyLanguage );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
OUString getDefaultLanguage()
|
|
{
|
|
return OUString::createFromAscii( c_sDefLanguage );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
Locale getAnyLocale()
|
|
{
|
|
return Locale( getAnyLanguage(), OUString(), OUString() );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
Locale getDefaultLocale()
|
|
{
|
|
return Locale( getDefaultLanguage(), OUString(), OUString() );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
static inline sal_Int32 countrySeparatorPos(OUString const& aLocaleName_)
|
|
{
|
|
sal_Int32 pos = aLocaleName_.indexOf('-');
|
|
if (pos == 1) // allow for x-LL or i-LL
|
|
pos = aLocaleName_.indexOf('-',pos+1);
|
|
|
|
if (pos < 0)
|
|
pos = aLocaleName_.indexOf('_');
|
|
|
|
return pos;
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
static inline sal_Int32 countryLength(OUString const& aLocaleName_, sal_Int32 nCountryPos)
|
|
{
|
|
sal_Int32 pos1 = aLocaleName_.indexOf('.',nCountryPos);
|
|
sal_Int32 pos2 = aLocaleName_.indexOf('_',nCountryPos);
|
|
|
|
if (pos1 < 0) pos1 = aLocaleName_.getLength();
|
|
|
|
if (pos2 < 0 || pos1 < pos2)
|
|
return pos1 - nCountryPos;
|
|
|
|
else
|
|
return pos2 - nCountryPos;
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
static inline void splitLocaleString(OUString const& aLocaleName_, OUString& rLanguage_, OUString& rCountry_)
|
|
{
|
|
sal_Int32 nCountryPos = countrySeparatorPos(aLocaleName_);
|
|
if (nCountryPos >= 0)
|
|
{
|
|
rLanguage_ = aLocaleName_.copy(0,nCountryPos).toAsciiLowerCase();
|
|
|
|
++nCountryPos; // advance past separator
|
|
sal_Int32 nCountryLength = countryLength(aLocaleName_, nCountryPos);
|
|
|
|
rCountry_ = aLocaleName_.copy(nCountryPos,nCountryLength).toAsciiUpperCase();
|
|
}
|
|
else
|
|
{
|
|
rLanguage_ = aLocaleName_.toAsciiLowerCase();
|
|
rCountry_ = OUString();
|
|
}
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// conversion helpers
|
|
Locale makeLocale(OUString const& sLocaleName_)
|
|
{
|
|
Locale aResult;
|
|
splitLocaleString(sLocaleName_, aResult.Language, aResult.Country);
|
|
return aResult;
|
|
}
|
|
Locale makeLocale(Locale const& aLocale_) // normalizes the locale
|
|
{
|
|
return Locale( aLocale_.Language.toAsciiLowerCase(),
|
|
aLocale_.Country .toAsciiUpperCase(),
|
|
OUString() );
|
|
}
|
|
OUString makeIsoLocale(Locale const& aUnoLocale_)
|
|
{
|
|
rtl::OUStringBuffer aResult(aUnoLocale_.Language.toAsciiLowerCase());
|
|
if (aUnoLocale_.Country.getLength())
|
|
{
|
|
aResult.append( sal_Unicode('-') ).append(aUnoLocale_.Country.toAsciiUpperCase());
|
|
}
|
|
return aResult.makeStringAndClear();
|
|
}
|
|
static
|
|
Locale makeLocale(StaticLocale const& aConstLocale_)
|
|
{
|
|
Locale aResult;
|
|
aResult.Language = OUString::createFromAscii(aConstLocale_.aLanguage);
|
|
aResult.Country = OUString::createFromAscii(aConstLocale_.aCountry);
|
|
return aResult;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
template <class T>
|
|
inline
|
|
void addLocaleSeq_impl(T const* first, T const* last, LocaleSequence& rSeq)
|
|
{
|
|
typedef Locale (* const XlateFunc)(T const&);
|
|
XlateFunc xlate = &makeLocale;
|
|
|
|
std::transform(first, last, std::back_inserter(rSeq), xlate);
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------------
|
|
template <class T>
|
|
inline
|
|
LocaleSequence makeLocaleSeq_impl(uno::Sequence< T > const& aLocales_)
|
|
{
|
|
sal_Int32 const nLocaleCount = aLocales_.getLength();
|
|
|
|
T const* pLocaleBegin = aLocales_.getConstArray();
|
|
|
|
LocaleSequence aResult;
|
|
aResult.reserve( nLocaleCount + c_nFallbackLocales ); // make room for fallback stuff as well
|
|
|
|
addLocaleSeq_impl(pLocaleBegin, pLocaleBegin + nLocaleCount, aResult);
|
|
|
|
return aResult;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
void addFallbackLocales(LocaleSequence& aTargetList_)
|
|
{
|
|
addLocaleSeq_impl(c_aFallbackLocales, c_aFallbackLocales + c_nFallbackLocales, aTargetList_);
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
LocaleSequence makeLocaleSequence(uno::Sequence<OUString> const& sLocaleNames_)
|
|
{
|
|
return makeLocaleSeq_impl(sLocaleNames_);
|
|
}
|
|
LocaleSequence makeLocaleSequence(uno::Sequence<lang::Locale> const& aUnoLocales_)
|
|
{
|
|
return makeLocaleSeq_impl(aUnoLocales_);
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
uno::Sequence<OUString> makeIsoSequence(LocaleSequence const& aLocales_)
|
|
{
|
|
LocaleSequence::size_type const nLocaleCount = aLocales_.size();
|
|
sal_Int32 const nSeqSize = sal_Int32(nLocaleCount);
|
|
OSL_ASSERT( nSeqSize >= 0 && sal_uInt32(nSeqSize) == nLocaleCount );
|
|
|
|
uno::Sequence<OUString> aResult(nSeqSize);
|
|
std::transform(aLocales_.begin(), aLocales_.end(), aResult.getArray(), &makeIsoLocale);
|
|
|
|
return aResult;
|
|
}
|
|
uno::Sequence<Locale> makeUnoSequence(LocaleSequence const& aLocales_)
|
|
{
|
|
LocaleSequence::size_type const nLocaleCount = aLocales_.size();
|
|
sal_Int32 const nSeqSize = sal_Int32(nLocaleCount);
|
|
OSL_ASSERT( nSeqSize >= 0 && sal_uInt32(nSeqSize) == nLocaleCount );
|
|
|
|
uno::Sequence<Locale> aResult( &aLocales_.front(), nSeqSize );
|
|
return aResult;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
bool designatesAllLocales(Locale const& aLocale_)
|
|
{
|
|
return aLocale_.Language.equalsAscii(c_sAnyLanguage);
|
|
}
|
|
bool designatesAllLocales(LocaleSequence const& aLocales_)
|
|
{
|
|
return aLocales_.size() <= 1 &&
|
|
(aLocales_.size() == 0 || designatesAllLocales(aLocales_));
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
MatchQuality match(Locale const& aLocale_, Locale const& aTarget_)
|
|
{
|
|
// check language
|
|
if (!aLocale_.Language.equals(aTarget_.Language))
|
|
{
|
|
// can we accept any language
|
|
if (aTarget_.Language.equalsAscii(c_sAnyLanguage))
|
|
return MATCH_LANGUAGE;
|
|
|
|
return MISMATCH;
|
|
}
|
|
|
|
// check for exact match
|
|
else if (aLocale_.Country.equals(aTarget_.Country))
|
|
return MATCH_LOCALE;
|
|
|
|
// check for plain language
|
|
else if (aLocale_.Country.getLength() == 0)
|
|
return MATCH_LANGUAGE_PLAIN;
|
|
|
|
// so we are left with the wrong country
|
|
else
|
|
return MATCH_LANGUAGE;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
/// check the given position and quality, if they are an improvement
|
|
bool MatchResult::improve(SequencePos nPos_, MatchQuality eQuality_)
|
|
{
|
|
// is this a match at all ?
|
|
if (eQuality_ == MISMATCH)
|
|
return false;
|
|
|
|
// is the position worse ?
|
|
if (nPos_ > m_nPos )
|
|
return false;
|
|
|
|
// is this just a non-positive quality change ?
|
|
if (nPos_ == m_nPos && eQuality_ <= m_eQuality)
|
|
return false;
|
|
|
|
// Improvement found
|
|
m_nPos = nPos_;
|
|
m_eQuality = eQuality_;
|
|
|
|
return true;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
MatchResult match(Locale const& aLocale_, LocaleSequence const& aTarget_)
|
|
{
|
|
SequencePos const nEnd = aTarget_.size();
|
|
|
|
for (SequencePos nPos = 0; nPos < nEnd; ++nPos)
|
|
{
|
|
if (MatchQuality eQuality = match(aLocale_, aTarget_[nPos]))
|
|
{
|
|
return MatchResult(nPos,eQuality);
|
|
}
|
|
}
|
|
return MatchResult();
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
bool isMatch(Locale const& aLocale_, LocaleSequence const& aTarget_, MatchQuality eRequiredQuality_)
|
|
{
|
|
SequencePos const nEnd = aTarget_.size();
|
|
|
|
for (SequencePos nPos = 0; nPos < nEnd; ++nPos)
|
|
{
|
|
MatchQuality eQuality = match(aLocale_, aTarget_[nPos]);
|
|
if (eQuality >= eRequiredQuality_)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
static
|
|
inline
|
|
SequencePos getSearchLimitPosition(MatchResult const& aPrevMatch_,LocaleSequence const& aTarget_)
|
|
{
|
|
SequencePos nSize = aTarget_.size();
|
|
|
|
if (aPrevMatch_.isMatch())
|
|
{
|
|
SequencePos nMatchPos = aPrevMatch_.position();
|
|
|
|
OSL_ENSURE(nMatchPos < nSize,"localehelper::getSearchLimitPosition: ERROR - previous position is out-of-bounds");
|
|
|
|
if (nMatchPos < nSize)
|
|
{
|
|
return nMatchPos + 1;
|
|
}
|
|
}
|
|
return nSize;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
bool improveMatch(MatchResult& rMatch_, Locale const& aLocale_, LocaleSequence const& aTarget_)
|
|
{
|
|
SequencePos const nEnd = getSearchLimitPosition(rMatch_,aTarget_);
|
|
|
|
for (SequencePos nPos = 0; nPos < nEnd; ++nPos)
|
|
{
|
|
if (rMatch_.improve(nPos, match(aLocale_, aTarget_[nPos])))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// class FindBestLocale
|
|
// -----------------------------------------------------------------------------
|
|
|
|
inline
|
|
void FindBestLocale::implSetTarget(LocaleSequence const& aTarget_)
|
|
{
|
|
m_aTarget = aTarget_;
|
|
addFallbackLocales(m_aTarget);
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
FindBestLocale::FindBestLocale() // use only fallbacks !
|
|
{
|
|
LocaleSequence aSeq;
|
|
implSetTarget( aSeq );
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
FindBestLocale::FindBestLocale(Locale const& aTarget_)
|
|
{
|
|
LocaleSequence aSeq(1,aTarget_);
|
|
implSetTarget( aSeq );
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
|
|
FindBestLocale::FindBestLocale(LocaleSequence const& aTarget_)
|
|
{
|
|
implSetTarget( aTarget_ );
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
Locale FindBestLocale::getBestMatch() const
|
|
{
|
|
OSL_ENSURE(this->isMatch(), "FindBestLocale::getBestMatch(): ERROR - no match found");
|
|
|
|
if (this->isMatch())
|
|
{
|
|
OSL_ENSURE(m_aResult.position() < m_aTarget.size(), "FindBestLocale::getBestMatch(): ERROR - invalid match position");
|
|
return m_aTarget[m_aResult.position()];
|
|
}
|
|
else
|
|
{
|
|
return Locale();
|
|
}
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
bool FindBestLocale::accept(Locale const& aLocale_)
|
|
{
|
|
return improveMatch(m_aResult, aLocale_, m_aTarget);
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
void FindBestLocale::reset(Locale const& aTarget_)
|
|
{
|
|
LocaleSequence aSeq(1,aTarget_);
|
|
|
|
this->reset(aSeq);
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
void FindBestLocale::reset(LocaleSequence const& aTarget_)
|
|
{
|
|
implSetTarget(aTarget_);
|
|
m_aResult.reset();
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
void FindBestLocale::reset(bool bNeedLocale_)
|
|
{
|
|
if (bNeedLocale_)
|
|
m_aResult.reset();
|
|
|
|
else // mark as best match already (no improvement possible)
|
|
m_aResult = m_aResult.best();
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
} // namespace locale helper
|
|
// -----------------------------------------------------------------------------
|
|
|
|
} // namespace
|
|
|
|
|