617 lines
22 KiB
C++
617 lines
22 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 <sal/config.h>
|
|
|
|
#include <map>
|
|
#include <unordered_map>
|
|
|
|
#include <com/sun/star/linguistic2/XAvailableLocales.hpp>
|
|
#include <com/sun/star/linguistic2/XLinguServiceManager2.hpp>
|
|
#include <com/sun/star/linguistic2/XSpellChecker1.hpp>
|
|
#include <linguistic/misc.hxx>
|
|
#include <rtl/ustring.hxx>
|
|
#include <sal/log.hxx>
|
|
#include <unotools/localedatawrapper.hxx>
|
|
#include <tools/urlobj.hxx>
|
|
#include <svtools/langtab.hxx>
|
|
#include <i18nlangtag/mslangid.hxx>
|
|
#include <i18nlangtag/lang.h>
|
|
#include <i18nlangtag/languagetagicu.hxx>
|
|
#include <editeng/unolingu.hxx>
|
|
#include <svl/languageoptions.hxx>
|
|
#include <svx/langbox.hxx>
|
|
#include <svx/dialmgr.hxx>
|
|
#include <svx/strings.hrc>
|
|
#include <bitmaps.hlst>
|
|
#include <o3tl/sorted_vector.hxx>
|
|
|
|
#include <comphelper/string.hxx>
|
|
#include <comphelper/processfactory.hxx>
|
|
#include <comphelper/scopeguard.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <vcl/settings.hxx>
|
|
|
|
using namespace ::com::sun::star::util;
|
|
using namespace ::com::sun::star::linguistic2;
|
|
using namespace ::com::sun::star::uno;
|
|
|
|
OUString GetDicInfoStr( std::u16string_view rName, const LanguageType nLang, bool bNeg )
|
|
{
|
|
INetURLObject aURLObj;
|
|
aURLObj.SetSmartProtocol( INetProtocol::File );
|
|
aURLObj.SetSmartURL( rName, INetURLObject::EncodeMechanism::All );
|
|
OUString aTmp( aURLObj.GetBase() + " " );
|
|
|
|
if ( bNeg )
|
|
{
|
|
aTmp += " (-) ";
|
|
}
|
|
|
|
if ( LANGUAGE_NONE == nLang )
|
|
aTmp += SvxResId(RID_SVXSTR_LANGUAGE_ALL);
|
|
else
|
|
{
|
|
aTmp += "[" + SvtLanguageTable::GetLanguageString( nLang ) + "]";
|
|
}
|
|
|
|
return aTmp;
|
|
}
|
|
|
|
// misc local helper functions
|
|
static void appendLocaleSeqToLangs(Sequence<css::lang::Locale> const& rSeq,
|
|
std::vector<LanguageType>& aLangs)
|
|
{
|
|
sal_Int32 nCount = rSeq.getLength();
|
|
|
|
aLangs.reserve(aLangs.size() + nCount);
|
|
|
|
std::transform(rSeq.begin(), rSeq.end(), std::back_inserter(aLangs),
|
|
[](const css::lang::Locale& rLocale) -> LanguageType {
|
|
return LanguageTag::convertToLanguageType(rLocale); });
|
|
}
|
|
|
|
static bool lcl_SeqHasLang( const Sequence< sal_Int16 > & rLangSeq, sal_Int16 nLang )
|
|
{
|
|
return rLangSeq.hasElements()
|
|
&& std::find(rLangSeq.begin(), rLangSeq.end(), nLang) != rLangSeq.end();
|
|
}
|
|
|
|
namespace {
|
|
|
|
bool lcl_isPrerequisite(LanguageType nLangType, bool requireSublang)
|
|
{
|
|
return
|
|
nLangType != LANGUAGE_DONTKNOW &&
|
|
nLangType != LANGUAGE_SYSTEM &&
|
|
nLangType != LANGUAGE_NONE &&
|
|
nLangType != LANGUAGE_MULTIPLE &&
|
|
nLangType != LANGUAGE_UNDETERMINED &&
|
|
nLangType != LANGUAGE_USER_KEYID &&
|
|
!MsLangId::isLegacy( nLangType) &&
|
|
(!requireSublang || MsLangId::getSubLanguage( nLangType));
|
|
}
|
|
|
|
bool lcl_isScriptTypeRequested( LanguageType nLangType, SvxLanguageListFlags nLangList )
|
|
{
|
|
return
|
|
bool(nLangList & SvxLanguageListFlags::ALL) ||
|
|
(bool(nLangList & SvxLanguageListFlags::WESTERN) &&
|
|
(SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType) == SvtScriptType::LATIN)) ||
|
|
(bool(nLangList & SvxLanguageListFlags::CTL) &&
|
|
(SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType) == SvtScriptType::COMPLEX)) ||
|
|
(bool(nLangList & SvxLanguageListFlags::CJK) &&
|
|
(SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType) == SvtScriptType::ASIAN));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
LanguageType SvxLanguageBox::get_active_id() const
|
|
{
|
|
OUString sLang = m_xControl->get_active_id();
|
|
if (!sLang.isEmpty())
|
|
return LanguageType(sLang.toInt32());
|
|
else
|
|
return LANGUAGE_DONTKNOW;
|
|
}
|
|
|
|
int SvxLanguageBox::find_id(const LanguageType eLangType) const
|
|
{
|
|
return m_xControl->find_id(OUString::number(static_cast<sal_uInt16>(eLangType)));
|
|
}
|
|
|
|
void SvxLanguageBox::set_id(int pos, const LanguageType eLangType)
|
|
{
|
|
m_xControl->set_id(pos, OUString::number(static_cast<sal_uInt16>(eLangType)));
|
|
}
|
|
|
|
LanguageType SvxLanguageBox::get_id(int pos) const
|
|
{
|
|
return LanguageType(m_xControl->get_id(pos).toInt32());
|
|
}
|
|
|
|
void SvxLanguageBox::remove_id(const LanguageType eLangType)
|
|
{
|
|
m_xControl->remove_id(OUString::number(static_cast<sal_uInt16>(eLangType)));
|
|
}
|
|
|
|
void SvxLanguageBox::append(const LanguageType eLangType, const OUString& rStr)
|
|
{
|
|
m_xControl->append(OUString::number(static_cast<sal_uInt16>(eLangType)), rStr);
|
|
}
|
|
|
|
void SvxLanguageBox::set_active_id(const LanguageType eLangType)
|
|
{
|
|
// If the core uses a LangID of an imported MS document and wants to select
|
|
// a language that is replaced, we need to select the replacement instead.
|
|
LanguageType nLang = MsLangId::getReplacementForObsoleteLanguage( eLangType);
|
|
|
|
sal_Int32 nAt = find_id( nLang );
|
|
|
|
if (nAt == -1)
|
|
{
|
|
InsertLanguage( nLang ); // on-the-fly-ID
|
|
nAt = find_id( nLang );
|
|
}
|
|
|
|
if (nAt != -1)
|
|
m_xControl->set_active(nAt);
|
|
}
|
|
|
|
void SvxLanguageBox::AddLanguages(const std::vector< LanguageType >& rLanguageTypes,
|
|
SvxLanguageListFlags nLangList, std::vector<weld::ComboBoxEntry>& rEntries, bool requireSublang)
|
|
{
|
|
for ( auto const & nLangType : rLanguageTypes )
|
|
{
|
|
if (lcl_isPrerequisite(nLangType, requireSublang))
|
|
{
|
|
LanguageType nLang = MsLangId::getReplacementForObsoleteLanguage( nLangType );
|
|
if (lcl_isScriptTypeRequested( nLang, nLangList))
|
|
{
|
|
int nAt = find_id(nLang);
|
|
if (nAt != -1)
|
|
continue;
|
|
weld::ComboBoxEntry aNewEntry(BuildEntry(nLang));
|
|
if (aNewEntry.sString.isEmpty())
|
|
continue;
|
|
rEntries.push_back(aNewEntry);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void SortLanguages(std::vector<weld::ComboBoxEntry>& rEntries)
|
|
{
|
|
struct NaturalStringSorterCompare
|
|
{
|
|
bool operator()(const OUString& rLHS, const OUString& rRHS) const
|
|
{
|
|
static const auto aSorter = comphelper::string::NaturalStringSorter(
|
|
comphelper::getProcessComponentContext(),
|
|
Application::GetSettings().GetUILanguageTag().getLocale());
|
|
return aSorter.compare(rLHS, rRHS) < 0;
|
|
}
|
|
};
|
|
|
|
struct EntryData
|
|
{
|
|
LanguageTag tag;
|
|
weld::ComboBoxEntry entry;
|
|
};
|
|
|
|
struct GenericFirst
|
|
{
|
|
bool operator()(const EntryData& e1, const EntryData& e2) const
|
|
{
|
|
assert(e1.tag.getLanguage() == e2.tag.getLanguage());
|
|
if (e1.entry.sId == e2.entry.sId)
|
|
return false; // shortcut
|
|
|
|
// Make sure that e.g. generic 'Spanish {es}' goes before 'Spanish (Argentina)'.
|
|
// We can't depend on MsLangId::getPrimaryLanguage/getSubLanguage, because e.g.
|
|
// for generic Bosnian {bs}, the MS-LCID is 0x781A, and getSubLanguage is not 0.
|
|
// So we have to do the expensive LanguageTag construction in EntryData.
|
|
|
|
const bool isLangOnly1 = e1.tag.isIsoLocale() && e1.tag.getCountry().isEmpty();
|
|
const bool isLangOnly2 = e2.tag.isIsoLocale() && e2.tag.getCountry().isEmpty();
|
|
assert(!(isLangOnly1 && isLangOnly2));
|
|
|
|
if (isLangOnly1)
|
|
{
|
|
// e1.tag is a generic language-only tag, e2.tag is not
|
|
return true;
|
|
}
|
|
else if (isLangOnly2)
|
|
{
|
|
// e2.tag is a generic language-only tag, e1.tag is not
|
|
return false;
|
|
}
|
|
|
|
// Do a normal string comparison for other cases
|
|
return NaturalStringSorterCompare()(e1.entry.sString, e2.entry.sString);
|
|
}
|
|
};
|
|
using SortedLangEntries = o3tl::sorted_vector<EntryData, GenericFirst>;
|
|
|
|
// It is impossible to sort using only GenericFirst comparison: it would fail the strict weak
|
|
// ordering requirement, where the following simplified example would fail the last assertion:
|
|
//
|
|
// weld::ComboBoxEntry nn{ u"노르웨이어(니노르스크) {nn}"_ustr, "30740", "" }
|
|
// weld::ComboBoxEntry nn_NO{ u"노르웨이어 뉘노르스크>"_ustr, "2068", "" };
|
|
// weld::ComboBoxEntry nb_NO{ u"노르웨이어 부크몰"_ustr, "1044", "" };
|
|
//
|
|
// assert(GenericFirst(nn, nn_NO));
|
|
// assert(GenericFirst(nn_NO, nb_NO));
|
|
// assert(GenericFirst(nn, nb_NO));
|
|
//
|
|
// So only sort this way inside language groups, where the data set itself guarantees the
|
|
// comparison's strict weak ordering.
|
|
|
|
// 1. Create lang-to-set-of-ComboBoxEntry map
|
|
std::unordered_map<OUString, SortedLangEntries> langToEntriesMap;
|
|
|
|
for (const auto& entry : rEntries)
|
|
{
|
|
LanguageType languageType(entry.sId.toInt32());
|
|
// Remove LANGUAGE_USER_SYSTEM_CONFIG special entry and friends from the list
|
|
if (languageType >= LanguageType(0xFFE0))
|
|
continue;
|
|
LanguageTag tag(languageType);
|
|
langToEntriesMap[tag.getLanguage()].insert({ tag, entry }); // also makes unique
|
|
}
|
|
|
|
// 2. Sort using generic language's translated name, plus ISO language tag appended just in case
|
|
std::map<OUString, const SortedLangEntries&, NaturalStringSorterCompare> finalSort;
|
|
const LanguageTag& uiLang = Application::GetSettings().GetUILanguageTag();
|
|
for (const auto& [lang, lang_entries] : langToEntriesMap)
|
|
{
|
|
OUString translatedLangName = LanguageTagIcu::getDisplayName(LanguageTag(lang), uiLang);
|
|
finalSort.emplace(translatedLangName + "_" + lang, lang_entries);
|
|
}
|
|
|
|
rEntries.clear();
|
|
for ([[maybe_unused]] const auto& [lang, lang_entries] : finalSort)
|
|
for (auto& entryData : lang_entries)
|
|
rEntries.push_back(entryData.entry);
|
|
}
|
|
|
|
void SvxLanguageBox::SetLanguageList(SvxLanguageListFlags nLangList, bool bHasLangNone,
|
|
bool bLangNoneIsLangAll, bool bCheckSpellAvail,
|
|
bool bDefaultLangExist, LanguageType eDefaultLangType,
|
|
sal_Int16 nDefaultType)
|
|
{
|
|
m_bHasLangNone = bHasLangNone;
|
|
m_bLangNoneIsLangAll = bLangNoneIsLangAll;
|
|
m_bWithCheckmark = bCheckSpellAvail;
|
|
|
|
m_xControl->freeze();
|
|
comphelper::ScopeGuard aThawGuard([this]() { m_xControl->thaw(); });
|
|
m_xControl->clear();
|
|
|
|
if (SvxLanguageListFlags::EMPTY == nLangList)
|
|
return;
|
|
|
|
bool bAddSeparator = false;
|
|
|
|
if (bHasLangNone)
|
|
{
|
|
m_xControl->append(BuildEntry(LANGUAGE_NONE));
|
|
m_xControl->append(BuildEntry(LANGUAGE_MULTIPLE));
|
|
m_xControl->append(BuildEntry(LANGUAGE_UNDETERMINED));
|
|
bAddSeparator = true;
|
|
}
|
|
|
|
if (bDefaultLangExist)
|
|
{
|
|
m_xControl->append(BuildEntry(eDefaultLangType, nDefaultType));
|
|
bAddSeparator = true;
|
|
}
|
|
|
|
if (bAddSeparator)
|
|
m_xControl->append_separator(u""_ustr);
|
|
|
|
bool bAddAvailable = (!(nLangList & SvxLanguageListFlags::ONLY_KNOWN) &&
|
|
((nLangList & SvxLanguageListFlags::ALL) ||
|
|
(nLangList & SvxLanguageListFlags::WESTERN) ||
|
|
(nLangList & SvxLanguageListFlags::CTL) ||
|
|
(nLangList & SvxLanguageListFlags::CJK)));
|
|
std::vector< LanguageType > aAvailLang;
|
|
Sequence< sal_Int16 > aSpellUsedLang;
|
|
if (bAddAvailable)
|
|
{
|
|
if (auto xAvail = LinguMgr::GetLngSvcMgr())
|
|
{
|
|
appendLocaleSeqToLangs(xAvail->getAvailableLocales(SN_SPELLCHECKER), aAvailLang);
|
|
appendLocaleSeqToLangs(xAvail->getAvailableLocales(SN_HYPHENATOR), aAvailLang);
|
|
appendLocaleSeqToLangs(xAvail->getAvailableLocales(SN_THESAURUS), aAvailLang);
|
|
}
|
|
}
|
|
if (SvxLanguageListFlags::SPELL_USED & nLangList)
|
|
{
|
|
Reference< XSpellChecker1 > xTmp1 = LinguMgr::GetSpellChecker();
|
|
if (xTmp1.is())
|
|
aSpellUsedLang = xTmp1->getLanguages();
|
|
}
|
|
|
|
std::vector<LanguageType> aKnown;
|
|
sal_uInt32 nCount;
|
|
if ( nLangList & SvxLanguageListFlags::ONLY_KNOWN )
|
|
{
|
|
aKnown = LocaleDataWrapper::getInstalledLanguageTypes();
|
|
nCount = aKnown.size();
|
|
}
|
|
else
|
|
{
|
|
nCount = SvtLanguageTable::GetLanguageEntryCount();
|
|
}
|
|
|
|
std::vector<weld::ComboBoxEntry> aEntries;
|
|
for ( sal_uInt32 i = 0; i < nCount; i++ )
|
|
{
|
|
LanguageType nLangType;
|
|
if ( nLangList & SvxLanguageListFlags::ONLY_KNOWN )
|
|
nLangType = aKnown[i];
|
|
else
|
|
nLangType = SvtLanguageTable::GetLanguageTypeAtIndex( i );
|
|
if ( lcl_isPrerequisite( nLangType, true ) &&
|
|
(lcl_isScriptTypeRequested( nLangType, nLangList) ||
|
|
(bool(nLangList & SvxLanguageListFlags::FBD_CHARS) &&
|
|
MsLangId::hasForbiddenCharacters(nLangType)) ||
|
|
(bool(nLangList & SvxLanguageListFlags::SPELL_USED) &&
|
|
lcl_SeqHasLang(aSpellUsedLang, static_cast<sal_uInt16>(nLangType)))
|
|
) )
|
|
{
|
|
aEntries.push_back(BuildEntry(nLangType));
|
|
if (aEntries.back().sString.isEmpty())
|
|
aEntries.pop_back();
|
|
}
|
|
}
|
|
|
|
if (bAddAvailable)
|
|
{
|
|
// Spell checkers, hyphenators and thesauri may add language tags
|
|
// unknown so far.
|
|
AddLanguages(aAvailLang, nLangList, aEntries, true);
|
|
}
|
|
|
|
SortLanguages(aEntries);
|
|
m_xControl->insert_vector(aEntries, true);
|
|
}
|
|
|
|
void SvxLanguageBox::InsertLanguage(const LanguageType nLangType)
|
|
{
|
|
if (find_id(nLangType) != -1)
|
|
return;
|
|
weld::ComboBoxEntry aEntry = BuildEntry(nLangType);
|
|
if (aEntry.sString.isEmpty())
|
|
return;
|
|
m_xControl->append(aEntry);
|
|
}
|
|
|
|
void SvxLanguageBox::InsertLanguages(const std::vector<LanguageType>& rLanguageTypes)
|
|
{
|
|
std::vector<weld::ComboBoxEntry> entries;
|
|
AddLanguages(rLanguageTypes, SvxLanguageListFlags::ALL, entries, false);
|
|
SortLanguages(entries);
|
|
m_xControl->insert_vector(entries, true);
|
|
}
|
|
|
|
weld::ComboBoxEntry SvxLanguageBox::BuildEntry(const LanguageType nLangType, sal_Int16 nType)
|
|
{
|
|
LanguageType nLang = MsLangId::getReplacementForObsoleteLanguage(nLangType);
|
|
// For obsolete and to be replaced languages check whether an entry of the
|
|
// replacement already exists and if so don't add an entry with identical
|
|
// string as would be returned by SvtLanguageTable::GetString().
|
|
if (nLang != nLangType)
|
|
{
|
|
int nAt = find_id( nLang );
|
|
if (nAt != -1)
|
|
return weld::ComboBoxEntry(u""_ustr);
|
|
}
|
|
|
|
OUString aStrEntry = (LANGUAGE_NONE == nLang && m_bHasLangNone && m_bLangNoneIsLangAll)
|
|
? SvxResId(RID_SVXSTR_LANGUAGE_ALL)
|
|
: SvtLanguageTable::GetLanguageString(nLang);
|
|
|
|
LanguageType nRealLang = nLang;
|
|
if (nRealLang == LANGUAGE_SYSTEM)
|
|
{
|
|
nRealLang = MsLangId::resolveSystemLanguageByScriptType(nRealLang, nType);
|
|
aStrEntry += " - " + SvtLanguageTable::GetLanguageString( nRealLang );
|
|
}
|
|
else if (nRealLang == LANGUAGE_USER_SYSTEM_CONFIG)
|
|
{
|
|
nRealLang = MsLangId::getSystemLanguage();
|
|
// Whatever we obtained, ensure a known supported locale.
|
|
nRealLang = LanguageTag(nRealLang).makeFallback().getLanguageType();
|
|
aStrEntry += " - " + SvtLanguageTable::GetLanguageString( nRealLang );
|
|
}
|
|
|
|
if (m_bWithCheckmark)
|
|
{
|
|
if (!m_xSpellUsedLang)
|
|
{
|
|
Reference<XSpellChecker1> xSpell = LinguMgr::GetSpellChecker();
|
|
if (xSpell.is())
|
|
m_xSpellUsedLang.reset(new Sequence<sal_Int16>(xSpell->getLanguages()));
|
|
}
|
|
|
|
bool bFound = m_xSpellUsedLang && lcl_SeqHasLang(*m_xSpellUsedLang, static_cast<sal_uInt16>(nRealLang));
|
|
|
|
return weld::ComboBoxEntry(aStrEntry, OUString::number(static_cast<sal_uInt16>(nLang)), bFound ? RID_SVXBMP_CHECKED : RID_SVXBMP_NOTCHECKED);
|
|
}
|
|
else
|
|
return weld::ComboBoxEntry(aStrEntry, OUString::number(static_cast<sal_uInt16>(nLang)));
|
|
}
|
|
|
|
IMPL_LINK(SvxLanguageBox, ChangeHdl, weld::ComboBox&, rControl, void)
|
|
{
|
|
if (rControl.has_entry())
|
|
{
|
|
EditedAndValid eOldState = m_eEditedAndValid;
|
|
OUString aStr(rControl.get_active_text());
|
|
if (aStr.isEmpty())
|
|
m_eEditedAndValid = EditedAndValid::Invalid;
|
|
else
|
|
{
|
|
const int nPos = rControl.find_text(aStr);
|
|
if (nPos != -1)
|
|
{
|
|
int nStartSelectPos, nEndSelectPos;
|
|
rControl.get_entry_selection_bounds(nStartSelectPos, nEndSelectPos);
|
|
|
|
// Select the corresponding listbox entry if not current. This
|
|
// invalidates the Edit Selection thus has to happen between
|
|
// obtaining the Selection and setting the new Selection.
|
|
int nSelPos = m_xControl->get_active();
|
|
bool bSetEditSelection;
|
|
if (nSelPos == nPos)
|
|
bSetEditSelection = false;
|
|
else
|
|
{
|
|
m_xControl->set_active(nPos);
|
|
bSetEditSelection = true;
|
|
}
|
|
|
|
// If typing into the Edit control led us here, advance start of a
|
|
// full selection by one so the next character will already
|
|
// continue the string instead of having to type the same character
|
|
// again to start a new string. The selection is in reverse
|
|
// when obtained from the Edit control.
|
|
if (nEndSelectPos == 0)
|
|
{
|
|
OUString aText(m_xControl->get_active_text());
|
|
if (nStartSelectPos == aText.getLength())
|
|
{
|
|
++nEndSelectPos;
|
|
bSetEditSelection = true;
|
|
}
|
|
}
|
|
|
|
if (bSetEditSelection)
|
|
rControl.select_entry_region(nStartSelectPos, nEndSelectPos);
|
|
|
|
m_eEditedAndValid = EditedAndValid::No;
|
|
}
|
|
else
|
|
{
|
|
OUString aCanonicalized;
|
|
bool bValid = LanguageTag::isValidBcp47( aStr, &aCanonicalized, LanguageTag::PrivateUse::ALLOW_ART_X);
|
|
m_eEditedAndValid = (bValid ? EditedAndValid::Valid : EditedAndValid::Invalid);
|
|
if (bValid && aCanonicalized != aStr)
|
|
{
|
|
m_xControl->set_entry_text(aCanonicalized);
|
|
const auto nCursorPos = aCanonicalized.getLength();
|
|
m_xControl->select_entry_region(nCursorPos, nCursorPos);
|
|
}
|
|
}
|
|
}
|
|
if (eOldState != m_eEditedAndValid)
|
|
{
|
|
if (m_eEditedAndValid == EditedAndValid::Invalid)
|
|
rControl.set_entry_message_type(weld::EntryMessageType::Error);
|
|
else
|
|
rControl.set_entry_message_type(weld::EntryMessageType::Normal);
|
|
}
|
|
}
|
|
m_aChangeHdl.Call(rControl);
|
|
}
|
|
|
|
SvxLanguageBox::SvxLanguageBox(std::unique_ptr<weld::ComboBox> pControl)
|
|
: m_xControl(std::move(pControl))
|
|
, m_eSavedLanguage(LANGUAGE_DONTKNOW)
|
|
, m_eEditedAndValid(EditedAndValid::No)
|
|
, m_bHasLangNone(false)
|
|
, m_bLangNoneIsLangAll(false)
|
|
, m_bWithCheckmark(false)
|
|
{
|
|
m_xControl->connect_changed(LINK(this, SvxLanguageBox, ChangeHdl));
|
|
}
|
|
|
|
SvxLanguageBox* SvxLanguageBox::SaveEditedAsEntry(SvxLanguageBox* ppBoxes[3])
|
|
{
|
|
if (m_eEditedAndValid != EditedAndValid::Valid)
|
|
return this;
|
|
|
|
LanguageTag aLanguageTag(m_xControl->get_active_text());
|
|
LanguageType nLang = aLanguageTag.getLanguageType();
|
|
if (nLang == LANGUAGE_DONTKNOW)
|
|
{
|
|
SAL_WARN( "svx.dialog", "SvxLanguageBox::SaveEditedAsEntry: unknown tag");
|
|
return this;
|
|
}
|
|
|
|
for (size_t i = 0; i < 3; ++i)
|
|
{
|
|
SvxLanguageBox* pBox = ppBoxes[i];
|
|
if (!pBox)
|
|
continue;
|
|
|
|
const int nPos = pBox->find_id( nLang);
|
|
if (nPos != -1)
|
|
{
|
|
// Already present but with a different string or in another list.
|
|
pBox->m_xControl->set_active(nPos);
|
|
return pBox;
|
|
}
|
|
}
|
|
|
|
if (SvtLanguageTable::HasLanguageType( nLang))
|
|
{
|
|
// In SvtLanguageTable but not in SvxLanguageBox. On purpose? This
|
|
// may be an entry with different settings.
|
|
SAL_WARN( "svx.dialog", "SvxLanguageBox::SaveEditedAsEntry: already in SvtLanguageTable: " <<
|
|
SvtLanguageTable::GetLanguageString( nLang) << ", " << nLang);
|
|
}
|
|
else
|
|
{
|
|
// Add to SvtLanguageTable first. This at an on-the-fly LanguageTag
|
|
// also sets the ScriptType needed below.
|
|
SvtLanguageTable::AddLanguageTag( aLanguageTag );
|
|
}
|
|
|
|
// Add to the proper list.
|
|
SvxLanguageBox* pBox = nullptr;
|
|
switch (MsLangId::getScriptType(nLang))
|
|
{
|
|
default:
|
|
case css::i18n::ScriptType::LATIN:
|
|
pBox = ppBoxes[0];
|
|
break;
|
|
case css::i18n::ScriptType::ASIAN:
|
|
pBox = ppBoxes[1];
|
|
break;
|
|
case css::i18n::ScriptType::COMPLEX:
|
|
pBox = ppBoxes[2];
|
|
break;
|
|
}
|
|
if (!pBox)
|
|
pBox = this;
|
|
pBox->InsertLanguage(nLang);
|
|
|
|
// Select it.
|
|
const int nPos = pBox->find_id(nLang);
|
|
if (nPos != -1)
|
|
pBox->m_xControl->set_active(nPos);
|
|
|
|
return pBox;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|