/**************************************************************
*
* 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_cui.hxx"
// include ---------------------------------------------------------------
#include <vcl/msgbox.hxx>
#include <vcl/field.hxx>
#include <vcl/fixed.hxx>
#include <tools/shl.hxx>
#include <tools/dynary.hxx>
#include <i18npool/mslangid.hxx>
#include <unotools/lingucfg.hxx>
#include <editeng/unolingu.hxx>
#include <svx/dlgutil.hxx>
#include <linguistic/lngprops.hxx>
#include <linguistic/misc.hxx>
#include <sfx2/sfxuno.hxx>
#include <sfx2/dispatch.hxx>
#include <tools/urlobj.hxx>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/linguistic2/XSpellChecker.hpp>
#include <com/sun/star/linguistic2/XProofreader.hpp>
#include <com/sun/star/linguistic2/XHyphenator.hpp>
#include <com/sun/star/linguistic2/XThesaurus.hpp>
#include <com/sun/star/linguistic2/XAvailableLocales.hpp>
#include <com/sun/star/lang/XServiceDisplayName.hpp>
#include <com/sun/star/linguistic2/DictionaryListEventFlags.hpp>
#include <com/sun/star/linguistic2/DictionaryListEvent.hpp>
#include <com/sun/star/linguistic2/XDictionaryListEventListener.hpp>
#include <com/sun/star/linguistic2/XDictionaryList.hpp>
#include <com/sun/star/frame/XStorable.hpp>
#include <com/sun/star/ucb/CommandAbortedException.hpp>
#include <com/sun/star/system/SystemShellExecute.hpp>
#include <com/sun/star/system/SystemShellExecuteFlags.hpp>
#include <unotools/extendedsecurityoptions.hxx>
#include <svtools/svlbox.hxx>
#include <svl/eitem.hxx>
#include <svl/intitem.hxx>
#include <sfx2/viewfrm.hxx>
#include <vcl/svapp.hxx>
#define _SVX_OPTLINGU_CXX
#include "optlingu.hrc"
#include <svx/svxdlg.hxx>
#include <editeng/optitems.hxx>
#include "optlingu.hxx"
#include <dialmgr.hxx>
#include <cuires.hrc>
#include "helpid.hrc"
#include <ucbhelper/content.hxx>
#include <vector>
#include <map>
using namespace ::ucbhelper;
using namespace ::rtl;
using namespace ::com::sun::star;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::linguistic2;
using namespace ::com::sun::star::beans;
namespace css = com::sun::star;
#define C2U(cChar) OUString::createFromAscii(cChar)
#define SVX_MAX_USERDICTS 20
#define CBCOL_FIRST 0
#define CBCOL_SECOND 1
#define CBCOL_BOTH 2
static const sal_Char cSpell[] = SN_SPELLCHECKER;
static const sal_Char cGrammar[] = SN_GRAMMARCHECKER;
static const sal_Char cHyph[] = SN_HYPHENATOR;
static const sal_Char cThes[] = SN_THESAURUS;
// static ----------------------------------------------------------------
static Sequence< sal_Int16 > lcl_LocaleSeqToLangSeq( const Sequence< Locale > &rSeq )
{
sal_Int32 nLen = rSeq.getLength();
Sequence< sal_Int16 > aRes( nLen );
sal_Int16 *pRes = aRes.getArray();
const Locale *pSeq = rSeq.getConstArray();
for (sal_Int32 i = 0; i < nLen; ++i)
{
pRes[i] = SvxLocaleToLanguage( pSeq[i] );
}
return aRes;
}
static sal_Bool lcl_SeqHasLang( const Sequence< sal_Int16 > &rSeq, sal_Int16 nLang )
{
sal_Int32 nLen = rSeq.getLength();
const sal_Int16 *pLang = rSeq.getConstArray();
sal_Int32 nPos = -1;
for (sal_Int32 i = 0; i < nLen && nPos < 0; ++i)
{
if (nLang == pLang[i])
nPos = i;
}
return nPos < 0 ? sal_False : sal_True;
}
static sal_Int32 lcl_SeqGetEntryPos(
const Sequence< OUString > &rSeq, const OUString &rEntry )
{
sal_Int32 i;
sal_Int32 nLen = rSeq.getLength();
const OUString *pItem = rSeq.getConstArray();
for (i = 0; i < nLen; ++i)
{
if (rEntry == pItem[i])
break;
}
return i < nLen ? i : -1;
}
static void lcl_OpenURL( const ::rtl::OUString& rURL )
{
if ( rURL.getLength() > 0 )
{
try
{
uno::Reference< css::system::XSystemShellExecute > xSystemShell(
css::system::SystemShellExecute::create(
::comphelper::getProcessComponentContext() ) );
if ( xSystemShell.is() )
xSystemShell->execute( rURL, ::rtl::OUString(), css::system::SystemShellExecuteFlags::DEFAULTS );
}
catch( const uno::Exception& e )
{
OSL_TRACE( "Caught exception: %s\n thread terminated.\n",
rtl::OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).getStr());
}
}
}
/*--------------------------------------------------
--------------------------------------------------*/
static const sal_uInt16 nNameLen = 8;
static sal_uInt16 pRanges[] =
{
SID_ATTR_SPELL,
SID_ATTR_SPELL,
0
};
sal_Bool KillFile_Impl( const String& rURL )
{
sal_Bool bRet = sal_True;
try
{
Content aCnt( rURL, uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () );
aCnt.executeCommand( OUString::createFromAscii( "delete" ), makeAny( sal_Bool( sal_True ) ) );
}
catch( ::com::sun::star::ucb::CommandAbortedException& )
{
DBG_ERRORFILE( "KillFile: CommandAbortedException" );
bRet = sal_False;
}
catch( ... )
{
DBG_ERRORFILE( "KillFile: Any other exception" );
bRet = sal_False;
}
return bRet;
}
/* -----------------------------27.11.00 14:07--------------------------------
---------------------------------------------------------------------------*/
// 0x 0p 0t 0c nn
// p: 1 -> parent
// t: 1 -> spell, 2 -> hyph, 3 -> thes, 4 -> grammar
// c: 1 -> checked 0 -> unchecked
// n: index
#define TYPE_SPELL (sal_uInt8)1
#define TYPE_GRAMMAR (sal_uInt8)2
#define TYPE_HYPH (sal_uInt8)3
#define TYPE_THES (sal_uInt8)4
class ModuleUserData_Impl
{
sal_Bool bParent;
sal_Bool bIsChecked;
sal_uInt8 nType;
sal_uInt8 nIndex;
String sImplName;
public:
ModuleUserData_Impl( String sImpName, sal_Bool bIsParent, sal_Bool bChecked, sal_uInt8 nSetType, sal_uInt8 nSetIndex ) :
bParent(bIsParent),
bIsChecked(bChecked),
nType(nSetType),
nIndex(nSetIndex),
sImplName(sImpName)
{
}
sal_Bool IsParent() const {return bParent;}
sal_uInt8 GetType() const {return nType;}
sal_Bool IsChecked() const {return bIsChecked;}
sal_uInt8 GetIndex() const {return nIndex;}
void SetIndex(sal_uInt8 nSet) {nIndex = nSet;}
const String& GetImplName() const {return sImplName;}
};
/*--------------------------------------------------
--------------------------------------------------*/
//
// User for user-dictionaries (XDictionary interface)
//
class DicUserData
{
sal_uLong nVal;
public:
DicUserData( sal_uLong nUserData ) : nVal( nUserData ) {}
DicUserData( sal_uInt16 nEID,
sal_Bool bChecked, sal_Bool bEditable, sal_Bool bDeletable );
sal_uLong GetUserData() const { return nVal; }
sal_uInt16 GetEntryId() const { return (sal_uInt16)(nVal >> 16); }
sal_Bool IsChecked() const { return (sal_Bool)(nVal >> 8) & 0x01; }
sal_Bool IsEditable() const { return (sal_Bool)(nVal >> 9) & 0x01; }
sal_Bool IsDeletable() const { return (sal_Bool)(nVal >> 10) & 0x01; }
void SetChecked( sal_Bool bVal );
};
DicUserData::DicUserData(
sal_uInt16 nEID,
sal_Bool bChecked, sal_Bool bEditable, sal_Bool bDeletable )
{
DBG_ASSERT( nEID < 65000, "Entry Id out of range" );
nVal = ((sal_uLong)(0xFFFF & nEID) << 16) |
((sal_uLong)(bChecked ? 1 : 0) << 8) |
((sal_uLong)(bEditable ? 1 : 0) << 9) |
((sal_uLong)(bDeletable ? 1 : 0) << 10);
}
void DicUserData::SetChecked( sal_Bool bVal )
{
nVal &= ~(1UL << 8);
nVal |= (sal_uLong)(bVal ? 1 : 0) << 8;
}
// class BrwString_Impl -------------------------------------------------
void lcl_SetCheckButton( SvLBoxEntry* pEntry, sal_Bool bCheck )
{
SvLBoxButton* pItem = (SvLBoxButton*)(pEntry->GetFirstItem(SV_ITEM_ID_LBOXBUTTON));
DBG_ASSERT(pItem,"SetCheckButton:Item not found");
if (((SvLBoxItem*)pItem)->IsA() == SV_ITEM_ID_LBOXBUTTON)
{
if (bCheck)
pItem->SetStateChecked();
else
pItem->SetStateUnchecked();
//InvalidateEntry( pEntry );
}
}
class BrwStringDic_Impl : public SvLBoxString
{
public:
BrwStringDic_Impl( SvLBoxEntry* pEntry, sal_uInt16 nFlags,
const String& rStr ) : SvLBoxString( pEntry, nFlags, rStr ) {}
virtual void Paint( const Point& rPos, SvLBox& rDev, sal_uInt16 nFlags,
SvLBoxEntry* pEntry);
};
void BrwStringDic_Impl::Paint( const Point& rPos, SvLBox& rDev, sal_uInt16,
SvLBoxEntry* pEntry )
{
ModuleUserData_Impl* pData = (ModuleUserData_Impl*)pEntry->GetUserData();
Point aPos(rPos);
Font aOldFont( rDev.GetFont());
if(pData->IsParent())
{
Font aFont( aOldFont );
aFont.SetWeight( WEIGHT_BOLD );
rDev.SetFont( aFont );
aPos.X() = 0;
}
else
aPos.X() += 5;
rDev.DrawText( aPos, GetText() );
rDev.SetFont( aOldFont );
}
/*--------------------------------------------------
--------------------------------------------------*/
class OptionsBreakSet : public ModalDialog
{
OKButton aOKPB;
CancelButton aCancelPB;
FixedLine aValFL;
NumericField aValNF;
public:
OptionsBreakSet(Window* pParent, int nRID) :
ModalDialog(pParent, CUI_RES(RID_SVXDLG_LNG_ED_NUM_PREBREAK )),
aOKPB (this, CUI_RES(BT_OK_PREBREAK)),
aCancelPB (this, CUI_RES(BT_CANCEL_PREBREAK)),
aValFL (this, CUI_RES(FL_NUMVAL_PREBREAK)),
aValNF (this, CUI_RES(ED_PREBREAK))
{
DBG_ASSERT( STR_NUM_PRE_BREAK_DLG == nRID ||
STR_NUM_POST_BREAK_DLG == nRID ||
STR_NUM_MIN_WORDLEN_DLG == nRID, "unexpected RID" );
if (nRID != -1)
aValFL.SetText( String( CUI_RES(nRID) ) );
FreeResource();
}
NumericField& GetNumericFld() { return aValNF; }
};
/*--------------------------------------------------
Entry IDs for options listbox of dialog
--------------------------------------------------*/
enum EID_OPTIONS
{
EID_SPELL_AUTO,
EID_GRAMMAR_AUTO,
EID_CAPITAL_WORDS,
EID_WORDS_WITH_DIGITS,
EID_CAPITALIZATION,
EID_SPELL_SPECIAL,
EID_NUM_MIN_WORDLEN,
EID_NUM_PRE_BREAK,
EID_NUM_POST_BREAK,
EID_HYPH_AUTO,
EID_HYPH_SPECIAL
};
//! this array must have an entry for every value of EID_OPTIONS.
// It is used to get the respective property name.
static const char * aEidToPropName[] =
{
UPN_IS_SPELL_AUTO, // EID_SPELL_AUTO
UPN_IS_GRAMMAR_AUTO, // EID_GRAMMAR_AUTO
UPN_IS_SPELL_UPPER_CASE, // EID_CAPITAL_WORDS
UPN_IS_SPELL_WITH_DIGITS, // EID_WORDS_WITH_DIGITS
UPN_IS_SPELL_CAPITALIZATION, // EID_CAPITALIZATION
UPN_IS_SPELL_SPECIAL, // EID_SPELL_SPECIAL
UPN_HYPH_MIN_WORD_LENGTH, // EID_NUM_MIN_WORDLEN,
UPN_HYPH_MIN_LEADING, // EID_NUM_PRE_BREAK
UPN_HYPH_MIN_TRAILING, // EID_NUM_POST_BREAK
UPN_IS_HYPH_AUTO, // EID_HYPH_AUTO
UPN_IS_HYPH_SPECIAL // EID_HYPH_SPECIAL
};
static inline String lcl_GetPropertyName( EID_OPTIONS eEntryId )
{
DBG_ASSERT( (unsigned int) eEntryId < sizeof(aEidToPropName) / sizeof(aEidToPropName[0]), "index out of range" );
return String::CreateFromAscii( aEidToPropName[ (int) eEntryId ] );
}
// class OptionsUserData -------------------------------------------------
class OptionsUserData
{
sal_uLong nVal;
void SetModified();
public:
OptionsUserData( sal_uLong nUserData ) : nVal( nUserData ) {}
OptionsUserData( sal_uInt16 nEID,
sal_Bool bHasNV, sal_uInt16 nNumVal,
sal_Bool bCheckable, sal_Bool bChecked );
sal_uLong GetUserData() const { return nVal; }
sal_uInt16 GetEntryId() const { return (sal_uInt16)(nVal >> 16); }
sal_Bool HasNumericValue() const { return (sal_Bool)(nVal >> 10) & 0x01; }
sal_uInt16 GetNumericValue() const { return (sal_uInt16)(nVal & 0xFF); }
sal_Bool IsChecked() const { return (sal_Bool)(nVal >> 8) & 0x01; }
sal_Bool IsCheckable() const { return (sal_Bool)(nVal >> 9) & 0x01; }
sal_Bool IsModified() const { return (sal_Bool)(nVal >> 11) & 0x01; }
void SetChecked( sal_Bool bVal );
void SetNumericValue( sal_uInt8 nNumVal );
};
OptionsUserData::OptionsUserData( sal_uInt16 nEID,
sal_Bool bHasNV, sal_uInt16 nNumVal,
sal_Bool bCheckable, sal_Bool bChecked )
{
DBG_ASSERT( nEID < 65000, "Entry Id out of range" );
DBG_ASSERT( nNumVal < 256, "value out of range" );
nVal = ((sal_uLong)(0xFFFF & nEID) << 16) |
((sal_uLong)(bHasNV ? 1 : 0) << 10) |
((sal_uLong)(bCheckable ? 1 : 0) << 9) |
((sal_uLong)(bChecked ? 1 : 0) << 8) |
((sal_uLong)(0xFF & nNumVal));
}
void OptionsUserData::SetChecked( sal_Bool bVal )
{
if (IsCheckable() && (IsChecked() != bVal))
{
nVal &= ~(1UL << 8);
nVal |= (sal_uLong)(bVal ? 1 : 0) << 8;
SetModified();
}
}
void OptionsUserData::SetNumericValue( sal_uInt8 nNumVal )
{
// DBG_ASSERT( nNumVal < 256, "value out of range" );
if (HasNumericValue() && (GetNumericValue() != nNumVal))
{
nVal &= 0xffffff00;
nVal |= (nNumVal);
SetModified();
}
}
void OptionsUserData::SetModified()
{
nVal |= (sal_uLong)1 << 11;
}
// class BrwString_Impl -------------------------------------------------
class BrwString_Impl : public SvLBoxString
{
public:
BrwString_Impl( SvLBoxEntry* pEntry, sal_uInt16 nFlags,
const String& rStr ) : SvLBoxString( pEntry, nFlags, rStr ) {}
virtual void Paint( const Point& rPos, SvLBox& rDev, sal_uInt16 nFlags,
SvLBoxEntry* pEntry);
};
void BrwString_Impl::Paint( const Point& rPos, SvLBox& rDev, sal_uInt16,
SvLBoxEntry* pEntry )
{
Point aPos(rPos);
aPos.X() += 20;
rDev.DrawText( aPos, GetText() );
if(pEntry->GetUserData())
{
Point aNewPos(aPos);
aNewPos.X() += rDev.GetTextWidth(GetText());
Font aOldFont( rDev.GetFont());
Font aFont( aOldFont );
aFont.SetWeight( WEIGHT_BOLD );
// sal_Bool bFett = sal_True;
// sal_uInt16 nPos = 0;
//??? das untere byte aus dem user data in string wandeln
OptionsUserData aData( (sal_uLong) pEntry->GetUserData() );
if(aData.HasNumericValue())
{
String sTxt( ' ' );
sTxt += String::CreateFromInt32( aData.GetNumericValue() );
rDev.SetFont( aFont );
rDev.DrawText( aNewPos, sTxt );
}
// if( STRING_NOTFOUND != nPos )
// aNewPos.X() += rDev.GetTextWidth( sTxt );
rDev.SetFont( aOldFont );
}
}
// ServiceInfo_Impl ----------------------------------------------------
struct ServiceInfo_Impl
{
OUString sDisplayName;
OUString sSpellImplName;
OUString sHyphImplName;
OUString sThesImplName;
OUString sGrammarImplName;
uno::Reference< XSpellChecker > xSpell;
uno::Reference< XHyphenator > xHyph;
uno::Reference< XThesaurus > xThes;
uno::Reference< XProofreader > xGrammar;
sal_Bool bConfigured;
ServiceInfo_Impl() : bConfigured(sal_False) {}
};
typedef std::vector< ServiceInfo_Impl > ServiceInfoArr;
typedef std::map< sal_Int16 /*LanguageType*/, Sequence< OUString > > LangImplNameTable;
// SvxLinguData_Impl ----------------------------------------------------
class SvxLinguData_Impl
{
//contains services and implementation names sorted by implementation names
ServiceInfoArr aDisplayServiceArr;
sal_uLong nDisplayServices;
Sequence< Locale > aAllServiceLocales;
LangImplNameTable aCfgSpellTable;
LangImplNameTable aCfgHyphTable;
LangImplNameTable aCfgThesTable;
LangImplNameTable aCfgGrammarTable;
uno::Reference< XMultiServiceFactory > xMSF;
uno::Reference< XLinguServiceManager > xLinguSrvcMgr;
sal_Bool AddRemove( Sequence< OUString > &rConfigured,
const OUString &rImplName, sal_Bool bAdd );
public:
SvxLinguData_Impl();
SvxLinguData_Impl( const SvxLinguData_Impl &rData );
~SvxLinguData_Impl();
SvxLinguData_Impl & operator = (const SvxLinguData_Impl &rData);
uno::Reference<XLinguServiceManager> & GetManager() { return xLinguSrvcMgr; }
void SetChecked( const Sequence< OUString > &rConfiguredServices );
void Reconfigure( const OUString &rDisplayName, sal_Bool bEnable );
const Sequence<Locale> & GetAllSupportedLocales() { return aAllServiceLocales; }
const LangImplNameTable & GetSpellTable() const { return aCfgSpellTable; }
LangImplNameTable & GetSpellTable() { return aCfgSpellTable; }
const LangImplNameTable & GetHyphTable() const { return aCfgHyphTable; }
LangImplNameTable & GetHyphTable() { return aCfgHyphTable; }
const LangImplNameTable & GetThesTable() const { return aCfgThesTable; }
LangImplNameTable & GetThesTable() { return aCfgThesTable; }
const LangImplNameTable & GetGrammarTable() const { return aCfgGrammarTable; }
LangImplNameTable & GetGrammarTable() { return aCfgGrammarTable; }
const ServiceInfoArr & GetDisplayServiceArray() const { return aDisplayServiceArr; }
ServiceInfoArr & GetDisplayServiceArray() { return aDisplayServiceArr; }
const sal_uLong & GetDisplayServiceCount() const { return nDisplayServices; }
void SetDisplayServiceCount( sal_uLong nVal ) { nDisplayServices = nVal; }
// returns the list of service implementation names for the specified
// language and service (TYPE_SPELL, TYPE_HYPH, TYPE_THES) sorted in
// the proper order for the SvxEditModulesDlg (the ones from the
// configuration (keeping that order!) first and then the other ones.
// I.e. the ones available but not configured in arbitrary order).
// The available ones may contain names that do not(!) support that
// language.
Sequence< OUString > GetSortedImplNames( sal_Int16 nLang, sal_uInt8 nType );
ServiceInfo_Impl * GetInfoByImplName( const OUString &rSvcImplName );
};
sal_Int32 lcl_SeqGetIndex( const Sequence< OUString > &rSeq, const OUString &rTxt )
{
sal_Int32 nRes = -1;
sal_Int32 nLen = rSeq.getLength();
const OUString *pString = rSeq.getConstArray();
for (sal_Int32 i = 0; i < nLen && nRes == -1; ++i)
{
if (pString[i] == rTxt)
nRes = i;
}
return nRes;
}
Sequence< OUString > SvxLinguData_Impl::GetSortedImplNames( sal_Int16 nLang, sal_uInt8 nType )
{
LangImplNameTable *pTable = 0;
switch (nType)
{
case TYPE_SPELL : pTable = &aCfgSpellTable; break;
case TYPE_HYPH : pTable = &aCfgHyphTable; break;
case TYPE_THES : pTable = &aCfgThesTable; break;
case TYPE_GRAMMAR : pTable = &aCfgGrammarTable; break;
}
Sequence< OUString > aRes;
if (pTable->count( nLang ))
aRes = (*pTable)[ nLang ]; // add configured services
sal_Int32 nIdx = aRes.getLength();
DBG_ASSERT( (sal_Int32) nDisplayServices >= nIdx, "size mismatch" );
aRes.realloc( nDisplayServices );
OUString *pRes = aRes.getArray();
// add not configured services
for (sal_Int32 i = 0; i < (sal_Int32) nDisplayServices; ++i)
{
const ServiceInfo_Impl &rInfo = aDisplayServiceArr[ i ];
OUString aImplName;
switch (nType)
{
case TYPE_SPELL : aImplName = rInfo.sSpellImplName; break;
case TYPE_HYPH : aImplName = rInfo.sHyphImplName; break;
case TYPE_THES : aImplName = rInfo.sThesImplName; break;
case TYPE_GRAMMAR : aImplName = rInfo.sGrammarImplName; break;
}
if (aImplName.getLength() && (lcl_SeqGetIndex( aRes, aImplName) == -1)) // name not yet added
{
DBG_ASSERT( nIdx < aRes.getLength(), "index out of range" );
if (nIdx < aRes.getLength())
pRes[ nIdx++ ] = aImplName;
}
}
// don't forget to put aRes back to its actual size just in case you allocated too much
// since all of the names may have already been added
// otherwise you get duplicate entries in the edit dialog
aRes.realloc( nIdx );
return aRes;
}
ServiceInfo_Impl * SvxLinguData_Impl::GetInfoByImplName( const OUString &rSvcImplName )
{
ServiceInfo_Impl* pInfo = 0;
for (sal_uLong i = 0; i < nDisplayServices && !pInfo; ++i)
{
ServiceInfo_Impl &rTmp = aDisplayServiceArr[ i ];
if (rTmp.sSpellImplName == rSvcImplName ||
rTmp.sHyphImplName == rSvcImplName ||
rTmp.sThesImplName == rSvcImplName ||
rTmp.sGrammarImplName == rSvcImplName)
pInfo = &rTmp;
}
return pInfo;
}
//-----------------------------------------------------------------------------
void lcl_MergeLocales(Sequence< Locale >& aAllLocales, const Sequence< Locale >& rAdd)
{
const Locale* pAdd = rAdd.getConstArray();
Sequence<Locale> aLocToAdd(rAdd.getLength());
const Locale* pAllLocales = aAllLocales.getConstArray();
Locale* pLocToAdd = aLocToAdd.getArray();
sal_Int32 nFound = 0;
sal_Int32 i;
for(i = 0; i < rAdd.getLength(); i++)
{
sal_Bool bFound = sal_False;
for(sal_Int32 j = 0; j < aAllLocales.getLength() && !bFound; j++)
{
bFound = pAdd[i].Language == pAllLocales[j].Language &&
pAdd[i].Country == pAllLocales[j].Country;
}
if(!bFound)
{
pLocToAdd[nFound++] = pAdd[i];
}
}
sal_Int32 nLength = aAllLocales.getLength();
aAllLocales.realloc( nLength + nFound);
Locale* pAllLocales2 = aAllLocales.getArray();
for(i = 0; i < nFound; i++)
pAllLocales2[nLength++] = pLocToAdd[i];
}
/* -----------------------------27.11.00 16:48--------------------------------
---------------------------------------------------------------------------*/
void lcl_MergeDisplayArray(
SvxLinguData_Impl &rData,
const ServiceInfo_Impl &rToAdd )
{
sal_uLong nCnt = 0;
ServiceInfoArr &rSvcInfoArr = rData.GetDisplayServiceArray();
sal_uLong nEntries = rData.GetDisplayServiceCount();
ServiceInfo_Impl* pEntry;
for (sal_uLong i = 0; i < nEntries; ++i)
{
pEntry = &rSvcInfoArr[i];
if (pEntry && pEntry->sDisplayName == rToAdd.sDisplayName)
{
if(rToAdd.xSpell.is())
{
DBG_ASSERT( !pEntry->xSpell.is() &&
pEntry->sSpellImplName.getLength() == 0,
"merge conflict" );
pEntry->sSpellImplName = rToAdd.sSpellImplName;
pEntry->xSpell = rToAdd.xSpell;
}
if(rToAdd.xGrammar.is())
{
DBG_ASSERT( !pEntry->xGrammar.is() &&
pEntry->sGrammarImplName.getLength() == 0,
"merge conflict" );
pEntry->sGrammarImplName = rToAdd.sGrammarImplName;
pEntry->xGrammar = rToAdd.xGrammar;
}
if(rToAdd.xHyph.is())
{
DBG_ASSERT( !pEntry->xHyph.is() &&
pEntry->sHyphImplName.getLength() == 0,
"merge conflict" );
pEntry->sHyphImplName = rToAdd.sHyphImplName;
pEntry->xHyph = rToAdd.xHyph;
}
if(rToAdd.xThes.is())
{
DBG_ASSERT( !pEntry->xThes.is() &&
pEntry->sThesImplName.getLength() == 0,
"merge conflict" );
pEntry->sThesImplName = rToAdd.sThesImplName;
pEntry->xThes = rToAdd.xThes;
}
return ;
}
++nCnt;
}
rData.GetDisplayServiceArray().push_back( rToAdd );
rData.SetDisplayServiceCount( nCnt + 1 );
}
/* -----------------------------26.11.00 18:07--------------------------------
---------------------------------------------------------------------------*/
SvxLinguData_Impl::SvxLinguData_Impl() :
nDisplayServices (0)
{
xMSF = ::comphelper::getProcessServiceFactory();
uno::Reference < XInterface > xI = xMSF->createInstance(
C2U( "com.sun.star.linguistic2.LinguServiceManager" ) );
xLinguSrvcMgr = uno::Reference<XLinguServiceManager>(xI, UNO_QUERY);
DBG_ASSERT(xLinguSrvcMgr.is(), "No linguistic service available!");
if(xLinguSrvcMgr.is())
{
Locale aCurrentLocale;
LanguageType eLang = Application::GetSettings().GetLanguage();
SvxLanguageToLocale(aCurrentLocale, eLang);
Sequence<Any> aArgs(2);//second arguments has to be empty!
aArgs.getArray()[0] <<= SvxGetLinguPropertySet();
//read spell checker
Sequence< OUString > aSpellNames = xLinguSrvcMgr->getAvailableServices(
C2U(cSpell), Locale() );
const OUString* pSpellNames = aSpellNames.getConstArray();
sal_Int32 nIdx;
for(nIdx = 0; nIdx < aSpellNames.getLength(); nIdx++)
{
ServiceInfo_Impl aInfo;
aInfo.sSpellImplName = pSpellNames[nIdx];
aInfo.xSpell = uno::Reference<XSpellChecker>(
xMSF->createInstanceWithArguments(aInfo.sSpellImplName, aArgs), UNO_QUERY);
uno::Reference<XServiceDisplayName> xDispName(aInfo.xSpell, UNO_QUERY);
if(xDispName.is())
aInfo.sDisplayName = xDispName->getServiceDisplayName( aCurrentLocale );
const Sequence< Locale > aLocales( aInfo.xSpell->getLocales() );
//! suppress display of entries with no supported languages (see feature 110994)
if (aLocales.getLength())
{
lcl_MergeLocales( aAllServiceLocales, aLocales );
lcl_MergeDisplayArray( *this, aInfo );
}
}
//read grammar checker
Sequence< OUString > aGrammarNames = xLinguSrvcMgr->getAvailableServices(
C2U(cGrammar), Locale() );
const OUString* pGrammarNames = aGrammarNames.getConstArray();
for(nIdx = 0; nIdx < aGrammarNames.getLength(); nIdx++)
{
ServiceInfo_Impl aInfo;
aInfo.sGrammarImplName = pGrammarNames[nIdx];
aInfo.xGrammar = uno::Reference<XProofreader>(
xMSF->createInstanceWithArguments(aInfo.sGrammarImplName, aArgs), UNO_QUERY);
uno::Reference<XServiceDisplayName> xDispName(aInfo.xGrammar, UNO_QUERY);
if(xDispName.is())
aInfo.sDisplayName = xDispName->getServiceDisplayName( aCurrentLocale );
const Sequence< Locale > aLocales( aInfo.xGrammar->getLocales() );
//! suppress display of entries with no supported languages (see feature 110994)
if (aLocales.getLength())
{
lcl_MergeLocales( aAllServiceLocales, aLocales );
lcl_MergeDisplayArray( *this, aInfo );
}
}
//read hyphenator
Sequence< OUString > aHyphNames = xLinguSrvcMgr->getAvailableServices(
C2U(cHyph), Locale() );
const OUString* pHyphNames = aHyphNames.getConstArray();
for(nIdx = 0; nIdx < aHyphNames.getLength(); nIdx++)
{
ServiceInfo_Impl aInfo;
aInfo.sHyphImplName = pHyphNames[nIdx];
aInfo.xHyph = uno::Reference<XHyphenator>(
xMSF->createInstanceWithArguments(aInfo.sHyphImplName, aArgs), UNO_QUERY);
uno::Reference<XServiceDisplayName> xDispName(aInfo.xHyph, UNO_QUERY);
if(xDispName.is())
aInfo.sDisplayName = xDispName->getServiceDisplayName( aCurrentLocale );
const Sequence< Locale > aLocales( aInfo.xHyph->getLocales() );
//! suppress display of entries with no supported languages (see feature 110994)
if (aLocales.getLength())
{
lcl_MergeLocales( aAllServiceLocales, aLocales );
lcl_MergeDisplayArray( *this, aInfo );
}
}
//read thesauri
Sequence< OUString > aThesNames = xLinguSrvcMgr->getAvailableServices(
C2U(cThes), Locale() );
const OUString* pThesNames = aThesNames.getConstArray();
for(nIdx = 0; nIdx < aThesNames.getLength(); nIdx++)
{
ServiceInfo_Impl aInfo;
aInfo.sThesImplName = pThesNames[nIdx];
aInfo.xThes = uno::Reference<XThesaurus>(
xMSF->createInstanceWithArguments(aInfo.sThesImplName, aArgs), UNO_QUERY);
uno::Reference<XServiceDisplayName> xDispName(aInfo.xThes, UNO_QUERY);
if(xDispName.is())
aInfo.sDisplayName = xDispName->getServiceDisplayName( aCurrentLocale );
const Sequence< Locale > aLocales( aInfo.xThes->getLocales() );
//! suppress display of entries with no supported languages (see feature 110994)
if (aLocales.getLength())
{
lcl_MergeLocales( aAllServiceLocales, aLocales );
lcl_MergeDisplayArray( *this, aInfo );
}
}
Sequence< OUString > aCfgSvcs;
const Locale* pAllLocales = aAllServiceLocales.getConstArray();
for(sal_Int32 nLocale = 0; nLocale < aAllServiceLocales.getLength(); nLocale++)
{
sal_Int16 nLang = SvxLocaleToLanguage( pAllLocales[nLocale] );
aCfgSvcs = xLinguSrvcMgr->getConfiguredServices(C2U(cSpell), pAllLocales[nLocale]);
SetChecked( aCfgSvcs );
if (aCfgSvcs.getLength())
aCfgSpellTable[ nLang ] = aCfgSvcs;
aCfgSvcs = xLinguSrvcMgr->getConfiguredServices(C2U(cGrammar), pAllLocales[nLocale]);
SetChecked( aCfgSvcs );
if (aCfgSvcs.getLength())
aCfgGrammarTable[ nLang ] = aCfgSvcs;
aCfgSvcs = xLinguSrvcMgr->getConfiguredServices(C2U(cHyph), pAllLocales[nLocale]);
SetChecked( aCfgSvcs );
if (aCfgSvcs.getLength())
aCfgHyphTable[ nLang ] = aCfgSvcs;
aCfgSvcs = xLinguSrvcMgr->getConfiguredServices(C2U(cThes), pAllLocales[nLocale]);
SetChecked( aCfgSvcs );
if (aCfgSvcs.getLength())
aCfgThesTable[ nLang ] = aCfgSvcs;
}
}
}
/* -----------------------------22.05.01 10:43--------------------------------
---------------------------------------------------------------------------*/
SvxLinguData_Impl::SvxLinguData_Impl( const SvxLinguData_Impl &rData ) :
aDisplayServiceArr (rData.aDisplayServiceArr),
nDisplayServices (rData.nDisplayServices),
aAllServiceLocales (rData.aAllServiceLocales),
aCfgSpellTable (rData.aCfgSpellTable),
aCfgHyphTable (rData.aCfgHyphTable),
aCfgThesTable (rData.aCfgThesTable),
aCfgGrammarTable (rData.aCfgGrammarTable),
xMSF (rData.xMSF),
xLinguSrvcMgr (rData.xLinguSrvcMgr)
{
}
/* -----------------------------22.05.01 10:43--------------------------------
---------------------------------------------------------------------------*/
SvxLinguData_Impl & SvxLinguData_Impl::operator = (const SvxLinguData_Impl &rData)
{
xMSF = rData.xMSF;
xLinguSrvcMgr = rData.xLinguSrvcMgr;
aAllServiceLocales = rData.aAllServiceLocales;
aCfgSpellTable = rData.aCfgSpellTable;
aCfgHyphTable = rData.aCfgHyphTable;
aCfgThesTable = rData.aCfgThesTable;
aCfgGrammarTable = rData.aCfgGrammarTable;
aDisplayServiceArr = rData.aDisplayServiceArr;
nDisplayServices = rData.nDisplayServices;
return *this;
}
/* -----------------------------26.11.00 18:08--------------------------------
---------------------------------------------------------------------------*/
SvxLinguData_Impl::~SvxLinguData_Impl()
{
}
/* -----------------------------26.11.00 19:42--------------------------------
---------------------------------------------------------------------------*/
void SvxLinguData_Impl::SetChecked(const Sequence<OUString>& rConfiguredServices)
{
const OUString* pConfiguredServices = rConfiguredServices.getConstArray();
for(sal_Int32 n = 0; n < rConfiguredServices.getLength(); n++)
{
ServiceInfo_Impl* pEntry;
for (sal_uLong i = 0; i < nDisplayServices; ++i)
{
pEntry = &aDisplayServiceArr[i];
if (pEntry && !pEntry->bConfigured)
{
const OUString &rSrvcImplName = pConfiguredServices[n];
if (rSrvcImplName.getLength() &&
(pEntry->sSpellImplName == rSrvcImplName ||
pEntry->sGrammarImplName == rSrvcImplName ||
pEntry->sHyphImplName == rSrvcImplName ||
pEntry->sThesImplName == rSrvcImplName))
{
pEntry->bConfigured = sal_True;
break;
}
}
}
}
}
/* -----------------------------26.11.00 20:43--------------------------------
---------------------------------------------------------------------------*/
sal_Bool SvxLinguData_Impl::AddRemove(
Sequence< OUString > &rConfigured,
const OUString &rImplName, sal_Bool bAdd )
{
sal_Bool bRet = sal_False; // modified?
sal_Int32 nEntries = rConfigured.getLength();
sal_Int32 nPos = lcl_SeqGetEntryPos(rConfigured, rImplName);
if (bAdd && nPos < 0) // add new entry
{
rConfigured.realloc( ++nEntries );
OUString *pConfigured = rConfigured.getArray();
pConfigured = rConfigured.getArray();
pConfigured[nEntries - 1] = rImplName;
bRet = sal_True;
}
else if (!bAdd && nPos >= 0) // remove existing entry
{
OUString *pConfigured = rConfigured.getArray();
for (sal_Int32 i = nPos; i < nEntries - 1; ++i)
pConfigured[i] = pConfigured[i + 1];
rConfigured.realloc(--nEntries);
bRet = sal_True;
}
return bRet;
}
void SvxLinguData_Impl::Reconfigure( const OUString &rDisplayName, sal_Bool bEnable )
{
DBG_ASSERT( rDisplayName.getLength(), "empty DisplayName" );
ServiceInfo_Impl *pInfo = 0;
ServiceInfo_Impl *pTmp = 0;
for (sal_uLong i = 0; i < nDisplayServices; ++i)
{
pTmp = &aDisplayServiceArr[i];
if (pTmp && pTmp->sDisplayName == rDisplayName)
{
pInfo = pTmp;
break;
}
}
DBG_ASSERT( pInfo, "DisplayName entry not found" );
if (pInfo)
{
pInfo->bConfigured = bEnable;
Sequence< Locale > aLocales;
const Locale *pLocale = 0;
sal_Int32 nLocales = 0;
sal_Int32 i;
// update configured spellchecker entries
if (pInfo->xSpell.is())
{
aLocales = pInfo->xSpell->getLocales();
pLocale = aLocales.getConstArray();
nLocales = aLocales.getLength();
for (i = 0; i < nLocales; ++i)
{
sal_Int16 nLang = SvxLocaleToLanguage( pLocale[i] );
if (!aCfgSpellTable.count( nLang ) && bEnable)
aCfgSpellTable[ nLang ] = Sequence< OUString >();
if (aCfgSpellTable.count( nLang ))
AddRemove( aCfgSpellTable[ nLang ], pInfo->sSpellImplName, bEnable );
}
}
// update configured grammar checker entries
if (pInfo->xGrammar.is())
{
aLocales = pInfo->xGrammar->getLocales();
pLocale = aLocales.getConstArray();
nLocales = aLocales.getLength();
for (i = 0; i < nLocales; ++i)
{
sal_Int16 nLang = SvxLocaleToLanguage( pLocale[i] );
if (!aCfgGrammarTable.count( nLang ) && bEnable)
aCfgGrammarTable[ nLang ] = Sequence< OUString >();
if (aCfgGrammarTable.count( nLang ))
AddRemove( aCfgGrammarTable[ nLang ], pInfo->sGrammarImplName, bEnable );
}
}
// update configured hyphenator entries
if (pInfo->xHyph.is())
{
aLocales = pInfo->xHyph->getLocales();
pLocale = aLocales.getConstArray();
nLocales = aLocales.getLength();
for (i = 0; i < nLocales; ++i)
{
sal_Int16 nLang = SvxLocaleToLanguage( pLocale[i] );
if (!aCfgHyphTable.count( nLang ) && bEnable)
aCfgHyphTable[ nLang ] = Sequence< OUString >();
if (aCfgHyphTable.count( nLang ))
AddRemove( aCfgHyphTable[ nLang ], pInfo->sHyphImplName, bEnable );
}
}
// update configured spellchecker entries
if (pInfo->xThes.is())
{
aLocales = pInfo->xThes->getLocales();
pLocale = aLocales.getConstArray();
nLocales = aLocales.getLength();
for (i = 0; i < nLocales; ++i)
{
sal_Int16 nLang = SvxLocaleToLanguage( pLocale[i] );
if (!aCfgThesTable.count( nLang ) && bEnable)
aCfgThesTable[ nLang ] = Sequence< OUString >();
if (aCfgThesTable.count( nLang ))
AddRemove( aCfgThesTable[ nLang ], pInfo->sThesImplName, bEnable );
}
}
}
}
// class SvxLinguTabPage -------------------------------------------------
#define CBCOL_FIRST 0
#define CBCOL_SECOND 1
#define CBCOL_BOTH 2
SvxLinguTabPage::SvxLinguTabPage( Window* pParent,
const SfxItemSet& rSet ):
SfxTabPage( pParent, CUI_RES( RID_SFXPAGE_LINGU ), rSet ),
aLinguisticFL ( this, CUI_RES( FL_LINGUISTIC ) ),
aLinguModulesFT ( this, CUI_RES( FT_LINGU_MODULES ) ),
aLinguModulesCLB ( this, CUI_RES( CLB_LINGU_MODULES ) ),
aLinguModulesEditPB ( this, CUI_RES( PB_LINGU_MODULES_EDIT ) ),
aLinguDicsFT ( this, CUI_RES( FT_LINGU_DICS ) ),
aLinguDicsCLB ( this, CUI_RES( CLB_LINGU_DICS ) ),
aLinguDicsNewPB ( this, CUI_RES( PB_LINGU_DICS_NEW_DIC ) ),
aLinguDicsEditPB ( this, CUI_RES( PB_LINGU_DICS_EDIT_DIC ) ),
aLinguDicsDelPB ( this, CUI_RES( PB_LINGU_DICS_DEL_DIC ) ),
aLinguOptionsFT ( this, CUI_RES( FT_LINGU_OPTIONS ) ),
aLinguOptionsCLB ( this, CUI_RES( CLB_LINGU_OPTIONS ) ),
aLinguOptionsEditPB ( this, CUI_RES( PB_LINGU_OPTIONS_EDIT ) ),
aMoreDictsLink ( this, CUI_RES( FT_LINGU_OPTIONS_MOREDICTS ) ),
sCapitalWords ( CUI_RES( STR_CAPITAL_WORDS ) ),
sWordsWithDigits ( CUI_RES( STR_WORDS_WITH_DIGITS ) ),
sCapitalization ( CUI_RES( STR_CAPITALIZATION ) ),
sSpellSpecial ( CUI_RES( STR_SPELL_SPECIAL ) ),
sSpellAuto ( CUI_RES( STR_SPELL_AUTO ) ),
sGrammarAuto ( CUI_RES( STR_GRAMMAR_AUTO ) ),
sNumMinWordlen ( CUI_RES( STR_NUM_MIN_WORDLEN ) ),
sNumPreBreak ( CUI_RES( STR_NUM_PRE_BREAK ) ),
sNumPostBreak ( CUI_RES( STR_NUM_POST_BREAK ) ),
sHyphAuto ( CUI_RES( STR_HYPH_AUTO ) ),
sHyphSpecial ( CUI_RES( STR_HYPH_SPECIAL ) ),
pLinguData ( NULL )
{
pCheckButtonData = NULL;
aLinguModulesCLB.SetStyle( aLinguModulesCLB.GetStyle()|WB_CLIPCHILDREN|WB_HSCROLL|WB_FORCE_MAKEVISIBLE );
aLinguModulesCLB.SetHelpId(HID_CLB_LINGU_MODULES );
aLinguModulesCLB.SetHighlightRange();
aLinguModulesCLB.SetSelectHdl( LINK( this, SvxLinguTabPage, SelectHdl_Impl ));
aLinguModulesCLB.SetDoubleClickHdl(LINK(this, SvxLinguTabPage, BoxDoubleClickHdl_Impl));
aLinguModulesCLB.SetCheckButtonHdl(LINK(this, SvxLinguTabPage, BoxCheckButtonHdl_Impl));
aLinguModulesEditPB.SetClickHdl( LINK( this, SvxLinguTabPage, ClickHdl_Impl ));
aLinguOptionsEditPB.SetClickHdl( LINK( this, SvxLinguTabPage, ClickHdl_Impl ));
aLinguDicsCLB.SetStyle( aLinguDicsCLB.GetStyle()|WB_CLIPCHILDREN|WB_HSCROLL|WB_FORCE_MAKEVISIBLE );
aLinguDicsCLB.SetHelpId(HID_CLB_EDIT_MODULES_DICS );
aLinguDicsCLB.SetHighlightRange();
aLinguDicsCLB.SetSelectHdl( LINK( this, SvxLinguTabPage, SelectHdl_Impl ));
aLinguDicsCLB.SetCheckButtonHdl(LINK(this, SvxLinguTabPage, BoxCheckButtonHdl_Impl));
aLinguDicsNewPB.SetClickHdl( LINK( this, SvxLinguTabPage, ClickHdl_Impl ));
aLinguDicsEditPB.SetClickHdl( LINK( this, SvxLinguTabPage, ClickHdl_Impl ));
aLinguDicsDelPB.SetClickHdl( LINK( this, SvxLinguTabPage, ClickHdl_Impl ));
aLinguOptionsCLB.SetStyle( aLinguOptionsCLB.GetStyle()|WB_CLIPCHILDREN|WB_HSCROLL|WB_FORCE_MAKEVISIBLE );
aLinguOptionsCLB.SetHelpId(HID_CLB_LINGU_OPTIONS );
aLinguOptionsCLB.SetHighlightRange();
aLinguOptionsCLB.SetSelectHdl( LINK( this, SvxLinguTabPage, SelectHdl_Impl ));
aLinguOptionsCLB.SetDoubleClickHdl(LINK(this, SvxLinguTabPage, BoxDoubleClickHdl_Impl));
if ( SvtExtendedSecurityOptions().GetOpenHyperlinkMode()
!= SvtExtendedSecurityOptions::OPEN_NEVER )
{
aMoreDictsLink.SetURL( String(
RTL_CONSTASCII_STRINGPARAM( "https://extensions.openoffice.org/dictionaries" ) ) );
aMoreDictsLink.SetClickHdl( LINK( this, SvxLinguTabPage, OpenURLHdl_Impl ) );
}
else
aMoreDictsLink.Hide();
String sAccessibleNameModuleEdit( CUI_RES( STR_LINGU_MODULES_EDIT ) );
String sAccessibleNameDicsEdit ( CUI_RES( STR_LINGU_DICS_EDIT_DIC ) );
String sAccessibleNameOptionEdit( CUI_RES( STR_LINGU_OPTIONS_EDIT ) );
aLinguModulesEditPB.SetAccessibleName(sAccessibleNameModuleEdit);
aLinguDicsEditPB.SetAccessibleName(sAccessibleNameDicsEdit);
aLinguOptionsEditPB.SetAccessibleName(sAccessibleNameOptionEdit);
// force recalculation of hash value used for checking the need of updating
// because new dictionaries might be installed / downloaded.
//! Thus it needs to be called now since it may influence the supported languages
//! to be reported AND the found user-dictionaries(!) as well.
SvxLinguConfigUpdate::UpdateAll( sal_True );
xProp = uno::Reference< XPropertySet >( SvxGetLinguPropertySet(), UNO_QUERY );
xDicList = uno::Reference< XDictionaryList >( SvxGetDictionaryList(), UNO_QUERY );
if (xDicList.is())
{
// keep references to all **currently** available dictionaries,
// since the diclist may get changed meanwhile (e.g. through the API).
// We want the dialog to operate on the same set of dictionaries it
// was started with.
// Also we have to take care to not loose the last reference when
// someone else removes a dictionary from the list.
// Removed dics will be replaced by NULL new entries be added to the end.
// Thus we may use indizes as consistent references.
aDics = xDicList->getDictionaries();
UpdateDicBox_Impl();
}
else
{
aLinguDicsFT.Disable();
aLinguDicsCLB.Disable();
aLinguDicsNewPB.Disable();
aLinguDicsEditPB.Disable();
aLinguDicsDelPB.Disable();
}
const SfxSpellCheckItem* pItem = 0;
SfxItemState eItemState = SFX_ITEM_UNKNOWN;
eItemState = rSet.GetItemState( GetWhich( SID_ATTR_SPELL ),
sal_False, (const SfxPoolItem**)&pItem );
// handelt es sich um ein Default-Item?
if ( eItemState == SFX_ITEM_DEFAULT )
pItem = (const SfxSpellCheckItem*)&(rSet.Get( GetWhich( SID_ATTR_SPELL ) ) );
else if ( eItemState == SFX_ITEM_DONTCARE )
pItem = NULL;
FreeResource();
}
// -----------------------------------------------------------------------
SvxLinguTabPage::~SvxLinguTabPage()
{
if (pLinguData)
delete pLinguData;
}
//------------------------------------------------------------------------
//nicht überladen wegschmeissen
sal_uInt16* SvxLinguTabPage::GetRanges()
{
//TL???
return pRanges;
}
//------------------------------------------------------------------------
SfxTabPage* SvxLinguTabPage::Create( Window* pParent,
const SfxItemSet& rAttrSet )
{
return ( new SvxLinguTabPage( pParent, rAttrSet ) );
}
//------------------------------------------------------------------------
Any lcl_Bool2Any(sal_Bool bVal)
{
Any aRet(&bVal, ::getBooleanCppuType());
return aRet;
}
sal_Bool lcl_Bool2Any(Any& rVal)
{
return *(sal_Bool*)rVal.getValue();
}
sal_Bool SvxLinguTabPage::FillItemSet( SfxItemSet& rCoreSet )
{
sal_Bool bModified = sal_True; // !!!!
// if not HideGroups was called with GROUP_MODULES...
if (aLinguModulesCLB.IsVisible())
{
DBG_ASSERT( pLinguData, "pLinguData not yet initialized" );
if (!pLinguData)
pLinguData = new SvxLinguData_Impl;
LangImplNameTable::const_iterator aIt;
// update spellchecker configuration entries
const LangImplNameTable *pTable = &pLinguData->GetSpellTable();
for (aIt = pTable->begin(); aIt != pTable->end(); ++aIt)
{
sal_Int16 nLang = aIt->first;
const Sequence< OUString > aImplNames( aIt->second );
#if OSL_DEBUG_LEVEL > 1
const OUString *pTmpStr;
pTmpStr = aImplNames.getConstArray();
#endif
uno::Reference< XLinguServiceManager > xMgr( pLinguData->GetManager() );
Locale aLocale( SvxCreateLocale(nLang) );
if (xMgr.is())
xMgr->setConfiguredServices( C2U(cSpell), aLocale, aImplNames );
}
// update grammar checker configuration entries
pTable = &pLinguData->GetGrammarTable();
for (aIt = pTable->begin(); aIt != pTable->end(); ++aIt)
{
sal_Int16 nLang = aIt->first;
const Sequence< OUString > aImplNames( aIt->second );
#if OSL_DEBUG_LEVEL > 1
const OUString *pTmpStr;
pTmpStr = aImplNames.getConstArray();
#endif
uno::Reference< XLinguServiceManager > xMgr( pLinguData->GetManager() );
Locale aLocale( SvxCreateLocale(nLang) );
if (xMgr.is())
xMgr->setConfiguredServices( C2U(cGrammar), aLocale, aImplNames );
}
// update hyphenator configuration entries
pTable = &pLinguData->GetHyphTable();
for (aIt = pTable->begin(); aIt != pTable->end(); ++aIt)
{
sal_Int16 nLang = aIt->first;
const Sequence< OUString > aImplNames( aIt->second );
#if OSL_DEBUG_LEVEL > 1
const OUString *pTmpStr;
pTmpStr = aImplNames.getConstArray();
#endif
uno::Reference< XLinguServiceManager > xMgr( pLinguData->GetManager() );
Locale aLocale( SvxCreateLocale(nLang) );
if (xMgr.is())
xMgr->setConfiguredServices( C2U(cHyph), aLocale, aImplNames );
}
// update thesaurus configuration entries
pTable = &pLinguData->GetThesTable();
for (aIt = pTable->begin(); aIt != pTable->end(); ++aIt)
{
sal_Int16 nLang = aIt->first;
const Sequence< OUString > aImplNames( aIt->second );
#if OSL_DEBUG_LEVEL > 1
const OUString *pTmpStr;
pTmpStr = aImplNames.getConstArray();
#endif
uno::Reference< XLinguServiceManager > xMgr( pLinguData->GetManager() );
Locale aLocale( SvxCreateLocale(nLang) );
if (xMgr.is())
xMgr->setConfiguredServices( C2U(cThes), aLocale, aImplNames );
}
}
//
// activate dictionaries according to checkbox state
//
Sequence< OUString > aActiveDics;
sal_Int32 nActiveDics = 0;
sal_uLong nEntries = aLinguDicsCLB.GetEntryCount();
for (sal_uLong i = 0; i < nEntries; ++i)
{
sal_Int32 nDics = aDics.getLength();
// const uno::Reference< XDictionary > *pDic = aDics.getConstArray();
aActiveDics.realloc( nDics );
OUString *pActiveDic = aActiveDics.getArray();
SvLBoxEntry *pEntry = aLinguDicsCLB.GetEntry( i );
if (pEntry)
{
DicUserData aData( (sal_uLong)pEntry->GetUserData() );
if (aData.GetEntryId() < nDics)
{
sal_Bool bChecked = aLinguDicsCLB.IsChecked( (sal_uInt16) i );
uno::Reference< XDictionary > xDic( aDics.getConstArray()[ i ] );
if (xDic.is())
{
if (SvxGetIgnoreAllList() == xDic)
bChecked = sal_True;
xDic->setActive( bChecked );
if (bChecked)
{
String aDicName( xDic->getName() );
pActiveDic[ nActiveDics++ ] = aDicName;
}
}
}
}
}
//
aActiveDics.realloc( nActiveDics );
Any aTmp;
aTmp <<= aActiveDics;
SvtLinguConfig aLngCfg;
aLngCfg.SetProperty( UPH_ACTIVE_DICTIONARIES, aTmp );
nEntries = aLinguOptionsCLB.GetEntryCount();
for (sal_uInt16 j = 0; j < nEntries; ++j)
{
SvLBoxEntry *pEntry = aLinguOptionsCLB.GetEntry( j );
OptionsUserData aData( (sal_uLong)pEntry->GetUserData() );
String aPropName( lcl_GetPropertyName( (EID_OPTIONS) aData.GetEntryId() ) );
Any aAny;
if (aData.IsCheckable())
{
sal_Bool bChecked = aLinguOptionsCLB.IsChecked( j );
aAny <<= bChecked;
}
else if (aData.HasNumericValue())
{
sal_Int16 nVal = aData.GetNumericValue();
aAny <<= nVal;
}
if (xProp.is())
xProp->setPropertyValue( aPropName, aAny );
aLngCfg.SetProperty( aPropName, aAny );
}
SvLBoxEntry *pPreBreakEntry = aLinguOptionsCLB.GetEntry( (sal_uInt16) EID_NUM_PRE_BREAK );
SvLBoxEntry *pPostBreakEntry = aLinguOptionsCLB.GetEntry( (sal_uInt16) EID_NUM_POST_BREAK );
DBG_ASSERT( pPreBreakEntry, "NULL Pointer" );
DBG_ASSERT( pPostBreakEntry, "NULL Pointer" );
if (pPreBreakEntry && pPostBreakEntry)
{
OptionsUserData aPreBreakData( (sal_uLong)pPreBreakEntry->GetUserData() );
OptionsUserData aPostBreakData( (sal_uLong)pPostBreakEntry->GetUserData() );
if ( aPreBreakData.IsModified() || aPostBreakData.IsModified() )
{
SfxHyphenRegionItem aHyp( GetWhich( SID_ATTR_HYPHENREGION ) );
aHyp.GetMinLead() = (sal_uInt8) aPreBreakData.GetNumericValue();
aHyp.GetMinTrail() = (sal_uInt8) aPostBreakData.GetNumericValue();
rCoreSet.Put( aHyp );
}
}
// automatic spell checking
sal_Bool bNewAutoCheck = aLinguOptionsCLB.IsChecked( (sal_uInt16) EID_SPELL_AUTO );
const SfxPoolItem* pOld = GetOldItem( rCoreSet, SID_AUTOSPELL_CHECK );
if ( !pOld || ( (SfxBoolItem*)pOld )->GetValue() != bNewAutoCheck )
{
rCoreSet.Put( SfxBoolItem( GetWhich( SID_AUTOSPELL_CHECK ),
bNewAutoCheck ) );
bModified |= sal_True;
}
return bModified;
}
// ----------------------------------------------------------------------
sal_uLong SvxLinguTabPage::GetDicUserData( const uno::Reference< XDictionary > &rxDic, sal_uInt16 nIdx )
{
sal_uLong nRes = 0;
DBG_ASSERT( rxDic.is(), "dictionary not supplied" );
if (rxDic.is())
{
uno::Reference< frame::XStorable > xStor( rxDic, UNO_QUERY );
// sal_uLong nUserData = 0;
sal_Bool bChecked = rxDic->isActive();
sal_Bool bEditable = !xStor.is() || !xStor->isReadonly();
sal_Bool bDeletable = bEditable;
// sal_Bool bNegativ = rxDic->getDictionaryType() == DictionaryType_NEGATIVE;
nRes = DicUserData( nIdx,
bChecked, bEditable, bDeletable ).GetUserData();
}
return nRes;
}
void SvxLinguTabPage::AddDicBoxEntry(
const uno::Reference< XDictionary > &rxDic,
sal_uInt16 nIdx )
{
aLinguDicsCLB.SetUpdateMode(sal_False);
String aTxt( ::GetDicInfoStr( rxDic->getName(),
SvxLocaleToLanguage( rxDic->getLocale() ),
DictionaryType_NEGATIVE == rxDic->getDictionaryType() ) );
aLinguDicsCLB.InsertEntry( aTxt, (sal_uInt16)LISTBOX_APPEND ); // append at end
SvLBoxEntry* pEntry = aLinguDicsCLB.GetEntry( aLinguDicsCLB.GetEntryCount() - 1 );
DBG_ASSERT( pEntry, "failed to add entry" );
if (pEntry)
{
DicUserData aData( GetDicUserData( rxDic, nIdx ) );
pEntry->SetUserData( (void *) aData.GetUserData() );
lcl_SetCheckButton( pEntry, aData.IsChecked() );
}
aLinguDicsCLB.SetUpdateMode(sal_True);
}
// ----------------------------------------------------------------------
void SvxLinguTabPage::UpdateDicBox_Impl()
{
aLinguDicsCLB.SetUpdateMode(sal_False);
aLinguDicsCLB.Clear();
sal_Int32 nDics = aDics.getLength();
const uno::Reference< XDictionary > *pDic = aDics.getConstArray();
for (sal_Int32 i = 0; i < nDics; ++i)
{
const uno::Reference< XDictionary > &rDic = pDic[i];
if (rDic.is())
AddDicBoxEntry( rDic, (sal_uInt16)i );
}
aLinguDicsCLB.SetUpdateMode(sal_True);
}
// ----------------------------------------------------------------------
void SvxLinguTabPage::UpdateModulesBox_Impl()
{
if (pLinguData)
{
const ServiceInfoArr &rAllDispSrvcArr = pLinguData->GetDisplayServiceArray();
const sal_uLong nDispSrvcCount = pLinguData->GetDisplayServiceCount();
aLinguModulesCLB.Clear();
for (sal_uInt16 i = 0; i < nDispSrvcCount; ++i)
{
const ServiceInfo_Impl &rInfo = rAllDispSrvcArr[i];
aLinguModulesCLB.InsertEntry( rInfo.sDisplayName, (sal_uInt16)LISTBOX_APPEND );
SvLBoxEntry* pEntry = aLinguModulesCLB.GetEntry(i);
pEntry->SetUserData( (void *) &rInfo );
aLinguModulesCLB.CheckEntryPos( i, rInfo.bConfigured );
}
aLinguModulesEditPB.Enable( nDispSrvcCount > 0 );
}
}
//------------------------------------------------------------------------
void SvxLinguTabPage::Reset( const SfxItemSet& rSet )
{
// if not HideGroups was called with GROUP_MODULES...
if (aLinguModulesCLB.IsVisible())
{
if (!pLinguData)
pLinguData = new SvxLinguData_Impl;
UpdateModulesBox_Impl();
}
//
// get data from configuration
//
SvtLinguConfig aLngCfg;
aLinguOptionsCLB.SetUpdateMode(sal_False);
aLinguOptionsCLB.Clear();
SvLBoxTreeList *pModel = aLinguOptionsCLB.GetModel();
SvLBoxEntry* pEntry = NULL;
sal_Int16 nVal = 0;
sal_Bool bVal = sal_False;
sal_uLong nUserData = 0;
pEntry = CreateEntry( sSpellAuto, CBCOL_FIRST );
aLngCfg.GetProperty( C2U(UPN_IS_SPELL_AUTO) ) >>= bVal;
const SfxPoolItem* pItem = GetItem( rSet, SID_AUTOSPELL_CHECK );
if (pItem)
bVal = ((SfxBoolItem *) pItem)->GetValue();
nUserData = OptionsUserData( EID_SPELL_AUTO, sal_False, 0, sal_True, bVal).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
lcl_SetCheckButton( pEntry, bVal );
pEntry = CreateEntry( sGrammarAuto, CBCOL_FIRST );
aLngCfg.GetProperty( C2U(UPN_IS_GRAMMAR_AUTO) ) >>= bVal;
// const SfxPoolItem* pItem = GetItem( rSet, SID_AUTOSPELL_CHECK );
// if (pItem)
// bVal = ((SfxBoolItem *) pItem)->GetValue();
nUserData = OptionsUserData( EID_GRAMMAR_AUTO, sal_False, 0, sal_True, bVal).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
lcl_SetCheckButton( pEntry, bVal );
pEntry = CreateEntry( sCapitalWords, CBCOL_FIRST );
aLngCfg.GetProperty( C2U(UPN_IS_SPELL_UPPER_CASE) ) >>= bVal;
nUserData = OptionsUserData( EID_CAPITAL_WORDS, sal_False, 0, sal_True, bVal).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
lcl_SetCheckButton( pEntry, bVal );
pEntry = CreateEntry( sWordsWithDigits, CBCOL_FIRST );
aLngCfg.GetProperty( C2U(UPN_IS_SPELL_WITH_DIGITS) ) >>= bVal;
nUserData = OptionsUserData( EID_WORDS_WITH_DIGITS, sal_False, 0, sal_True, bVal).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
lcl_SetCheckButton( pEntry, bVal );
pEntry = CreateEntry( sCapitalization, CBCOL_FIRST );
aLngCfg.GetProperty( C2U(UPN_IS_SPELL_CAPITALIZATION) ) >>= bVal;
nUserData = OptionsUserData( EID_CAPITALIZATION, sal_False, 0, sal_True, bVal).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
lcl_SetCheckButton( pEntry, bVal );
pEntry = CreateEntry( sSpellSpecial, CBCOL_FIRST );
aLngCfg.GetProperty( C2U(UPN_IS_SPELL_SPECIAL) ) >>= bVal;
nUserData = OptionsUserData( EID_SPELL_SPECIAL, sal_False, 0, sal_True, bVal).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
lcl_SetCheckButton( pEntry, bVal );
pEntry = CreateEntry( sNumMinWordlen, CBCOL_SECOND );
aLngCfg.GetProperty( C2U(UPN_HYPH_MIN_WORD_LENGTH) ) >>= nVal;
nUserData = OptionsUserData( EID_NUM_MIN_WORDLEN, sal_True, (sal_uInt16)nVal, sal_False, sal_False).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
const SfxHyphenRegionItem *pHyp = NULL;
sal_uInt16 nWhich = GetWhich( SID_ATTR_HYPHENREGION );
if ( rSet.GetItemState( nWhich, sal_False ) == SFX_ITEM_SET )
pHyp = &( (const SfxHyphenRegionItem &) rSet.Get( nWhich ) );
pEntry = CreateEntry( sNumPreBreak, CBCOL_SECOND );
aLngCfg.GetProperty( C2U(UPN_HYPH_MIN_LEADING) ) >>= nVal;
if (pHyp)
nVal = (sal_Int16) pHyp->GetMinLead();
nUserData = OptionsUserData( EID_NUM_PRE_BREAK, sal_True, (sal_uInt16)nVal, sal_False, sal_False).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
pEntry = CreateEntry( sNumPostBreak, CBCOL_SECOND );
aLngCfg.GetProperty( C2U(UPN_HYPH_MIN_TRAILING) ) >>= nVal;
if (pHyp)
nVal = (sal_Int16) pHyp->GetMinTrail();
nUserData = OptionsUserData( EID_NUM_POST_BREAK, sal_True, (sal_uInt16)nVal, sal_False, sal_False).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
pEntry = CreateEntry( sHyphAuto, CBCOL_FIRST );
aLngCfg.GetProperty( C2U(UPN_IS_HYPH_AUTO) ) >>= bVal;
nUserData = OptionsUserData( EID_HYPH_AUTO, sal_False, 0, sal_True, bVal).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
lcl_SetCheckButton( pEntry, bVal );
pEntry = CreateEntry( sHyphSpecial, CBCOL_FIRST );
aLngCfg.GetProperty( C2U(UPN_IS_HYPH_SPECIAL) ) >>= bVal;
nUserData = OptionsUserData( EID_HYPH_SPECIAL, sal_False, 0, sal_True, bVal).GetUserData();
pEntry->SetUserData( (void *)nUserData );
pModel->Insert( pEntry );
lcl_SetCheckButton( pEntry, bVal );
aLinguOptionsCLB.SetUpdateMode(sal_True);
}
// -----------------------------------------------------------------------
IMPL_LINK( SvxLinguTabPage, BoxDoubleClickHdl_Impl, SvTreeListBox *, pBox )
{
if (pBox == &aLinguModulesCLB)
{
//! in order to avoid a bug causing a GPF when double clicking
//! on a module entry and exiting the "Edit Modules" dialog
//! after that.
Application::PostUserEvent( LINK(
this, SvxLinguTabPage, PostDblClickHdl_Impl ) );
}
else if (pBox == &aLinguOptionsCLB)
{
ClickHdl_Impl(&aLinguOptionsEditPB);
}
return 0;
}
// -----------------------------------------------------------------------
IMPL_LINK( SvxLinguTabPage, PostDblClickHdl_Impl, SvTreeListBox *, EMPTYARG )
{
ClickHdl_Impl(&aLinguModulesEditPB);
return 0;
}
// -----------------------------------------------------------------------
IMPL_LINK( SvxLinguTabPage, OpenURLHdl_Impl, svt::FixedHyperlink *, EMPTYARG )
{
::rtl::OUString sURL( aMoreDictsLink.GetURL() );
lcl_OpenURL( sURL );
return 0;
}
// -----------------------------------------------------------------------
IMPL_LINK( SvxLinguTabPage, BoxCheckButtonHdl_Impl, SvTreeListBox *, pBox )
{
if (pBox == &aLinguModulesCLB)
{
DBG_ASSERT( pLinguData, "NULL pointer, LinguData missing" );
sal_uInt16 nPos = aLinguModulesCLB.GetSelectEntryPos();
if (nPos != LISTBOX_ENTRY_NOTFOUND && pLinguData)
{
pLinguData->Reconfigure( aLinguModulesCLB.GetText( nPos ),
aLinguModulesCLB.IsChecked( nPos ) );
}
}
else if (pBox == &aLinguDicsCLB)
{
sal_uInt16 nPos = aLinguDicsCLB.GetSelectEntryPos();
if (nPos != LISTBOX_ENTRY_NOTFOUND)
{
const uno::Reference< XDictionary > &rDic = aDics.getConstArray()[ nPos ];
if (SvxGetIgnoreAllList() == rDic)
{
SvLBoxEntry* pEntry = aLinguDicsCLB.GetEntry( nPos );
if (pEntry)
lcl_SetCheckButton( pEntry, sal_True );
}
}
}
return 0;
}
// -----------------------------------------------------------------------
IMPL_LINK( SvxLinguTabPage, ClickHdl_Impl, PushButton *, pBtn )
{
if (&aLinguModulesEditPB == pBtn)
{
if (!pLinguData)
pLinguData = new SvxLinguData_Impl;
SvxLinguData_Impl aOldLinguData( *pLinguData );
SvxEditModulesDlg aDlg( this, *pLinguData );
if (aDlg.Execute() != RET_OK)
*pLinguData = aOldLinguData;
// evaluate new status of 'bConfigured' flag
sal_uLong nLen = pLinguData->GetDisplayServiceCount();
for (sal_uLong i = 0; i < nLen; ++i)
pLinguData->GetDisplayServiceArray()[i].bConfigured = sal_False;
const Locale* pAllLocales = pLinguData->GetAllSupportedLocales().getConstArray();
sal_Int32 nLocales = pLinguData->GetAllSupportedLocales().getLength();
for (sal_Int32 k = 0; k < nLocales; ++k)
{
sal_Int16 nLang = SvxLocaleToLanguage( pAllLocales[k] );
if (pLinguData->GetSpellTable().count( nLang ))
pLinguData->SetChecked( pLinguData->GetSpellTable()[ nLang ] );
if (pLinguData->GetGrammarTable().count( nLang ))
pLinguData->SetChecked( pLinguData->GetGrammarTable()[ nLang ] );
if (pLinguData->GetHyphTable().count( nLang ))
pLinguData->SetChecked( pLinguData->GetHyphTable()[ nLang ] );
if (pLinguData->GetThesTable().count( nLang ))
pLinguData->SetChecked( pLinguData->GetThesTable()[ nLang ] );
}
// show new status of modules
UpdateModulesBox_Impl();
}
else if (&aLinguDicsNewPB == pBtn)
{
uno::Reference< XSpellChecker1 > xSpellChecker1;
SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
if(pFact)
{
AbstractSvxNewDictionaryDialog* aDlg = pFact->CreateSvxNewDictionaryDialog( this, xSpellChecker1, RID_SFXDLG_NEWDICT );
DBG_ASSERT(aDlg, "Dialogdiet fail!");
uno::Reference< XDictionary > xNewDic;
if ( aDlg->Execute() == RET_OK )
xNewDic = uno::Reference< XDictionary >( aDlg->GetNewDictionary(), UNO_QUERY );
if ( xNewDic.is() )
{
// add new dics to the end
sal_Int32 nLen = aDics.getLength();
aDics.realloc( nLen + 1 );
aDics.getArray()[ nLen ] = xNewDic;
AddDicBoxEntry( xNewDic, (sal_uInt16) nLen );
}
delete aDlg; //add by CHINA001
}
}
else if (&aLinguDicsEditPB == pBtn)
{
SvLBoxEntry *pEntry = aLinguDicsCLB.GetCurEntry();
if (pEntry)
{
DicUserData aData( (sal_uLong) pEntry->GetUserData() );
sal_uInt16 nDicPos = aData.GetEntryId();
sal_Int32 nDics = aDics.getLength();
if (nDicPos < nDics)
{
uno::Reference< XDictionary > xDic;
xDic = aDics.getConstArray()[ nDicPos ];
if (xDic.is())
{
uno::Reference< XSpellChecker1 > xSpellChecker1;
SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
if(pFact)
{
VclAbstractDialog* aDlg = pFact->CreateSvxEditDictionaryDialog( this, xDic->getName(), xSpellChecker1, RID_SFXDLG_EDITDICT );
DBG_ASSERT(aDlg, "Dialogdiet fail!");
aDlg->Execute();
delete aDlg;
}
}
}
}
}
else if (&aLinguDicsDelPB == pBtn)
{
if ( RET_NO ==
QueryBox( this, CUI_RES( RID_SFXQB_DELDICT ) ).Execute() )
return 0;
SvLBoxEntry *pEntry = aLinguDicsCLB.GetCurEntry();
if (pEntry)
{
DicUserData aData( (sal_uLong) pEntry->GetUserData() );
sal_uInt16 nDicPos = aData.GetEntryId();
sal_Int32 nDics = aDics.getLength();
if (nDicPos < nDics)
{
uno::Reference< XDictionary > xDic;
xDic = aDics.getConstArray()[ nDicPos ];
if (xDic.is())
{
if (SvxGetIgnoreAllList() == xDic)
xDic->clear();
else
{
if (xDicList.is())
xDicList->removeDictionary( xDic );
uno::Reference< frame::XStorable > xStor( xDic, UNO_QUERY );
if ( xStor->hasLocation() && !xStor->isReadonly() )
{
String sURL = xStor->getLocation();
INetURLObject aObj(sURL);
DBG_ASSERT( aObj.GetProtocol() == INET_PROT_FILE,
"non-file URLs cannot be deleted" );
if ( aObj.GetProtocol() == INET_PROT_FILE )
{
KillFile_Impl( aObj.GetMainURL( INetURLObject::NO_DECODE ) );
}
}
aDics.getArray()[ nDicPos ] = 0;
// remove entry from checklistbox
sal_uLong nCnt = aLinguDicsCLB.GetEntryCount();
for (sal_uLong i = 0; i < nCnt; ++i)
{
SvLBoxEntry *pDicEntry = aLinguDicsCLB.GetEntry( i );
DBG_ASSERT( pDicEntry, "missing entry" );
if (pDicEntry)
{
DicUserData aDicData( (sal_uLong) pDicEntry->GetUserData() );
if (aDicData.GetEntryId() == nDicPos )
{
aLinguDicsCLB.RemoveEntry( (sal_uInt16) i );
break;
}
}
}
DBG_ASSERT( nCnt > aLinguDicsCLB.GetEntryCount(),
"remove failed ?");
}
}
}
}
}
else if (&aLinguOptionsEditPB == pBtn)
{
SvLBoxEntry *pEntry = aLinguOptionsCLB.GetCurEntry();
DBG_ASSERT( pEntry, "no entry selected" );
if (pEntry)
{
long nVal = -1;
OptionsUserData aData( (sal_uLong)pEntry->GetUserData() );
if(aData.HasNumericValue())
{
int nRID = -1;
switch (aData.GetEntryId())
{
case EID_NUM_PRE_BREAK : nRID = STR_NUM_PRE_BREAK_DLG; break;
case EID_NUM_POST_BREAK : nRID = STR_NUM_POST_BREAK_DLG; break;
case EID_NUM_MIN_WORDLEN: nRID = STR_NUM_MIN_WORDLEN_DLG; break;
default:
DBG_ERROR( "unexpected case" );
}
OptionsBreakSet aDlg( this, nRID );
aDlg.GetNumericFld().SetValue( aData.GetNumericValue() );
if (RET_OK == aDlg.Execute() )
{
nVal = static_cast<long>(aDlg.GetNumericFld().GetValue());
if (-1 != nVal && aData.GetNumericValue() != nVal)
{
aData.SetNumericValue( (sal_uInt8)nVal ); //! sets IsModified !
pEntry->SetUserData( (void *) aData.GetUserData() );
aLinguOptionsCLB.Invalidate();
}
}
}
}
}
else
{
DBG_ERROR( "pBtn unexpected value" );
}
return 0;
}
// -----------------------------------------------------------------------
IMPL_LINK( SvxLinguTabPage, SelectHdl_Impl, SvxCheckListBox *, pBox )
{
if (&aLinguModulesCLB == pBox)
{
}
else if (&aLinguDicsCLB == pBox)
{
SvLBoxEntry *pEntry = pBox->GetCurEntry();
if (pEntry)
{
DicUserData aData( (sal_uLong) pEntry->GetUserData() );
// always allow to edit (i.e. at least view the content of the dictionary)
aLinguDicsEditPB.Enable( true/*aData.IsEditable()*/ );
aLinguDicsDelPB .Enable( aData.IsDeletable() );
}
}
else if (&aLinguOptionsCLB == pBox)
{
SvLBoxEntry *pEntry = pBox->GetCurEntry();
if (pEntry)
{
OptionsUserData aData( (sal_uLong) pEntry->GetUserData() );
aLinguOptionsEditPB.Enable( aData.HasNumericValue() );
}
}
else
{
DBG_ERROR( "pBox unexpected value" );
}
return 0;
}
// -----------------------------------------------------------------------
SvLBoxEntry* SvxLinguTabPage::CreateEntry( String& rTxt, sal_uInt16 nCol )
{
SvLBoxEntry* pEntry = new SvLBoxEntry;
if( !pCheckButtonData )
pCheckButtonData = new SvLBoxButtonData( &aLinguOptionsCLB );
String sEmpty;
if (CBCOL_FIRST == nCol)
pEntry->AddItem( new SvLBoxButton( pEntry, SvLBoxButtonKind_enabledCheckbox, 0, pCheckButtonData ) );
if (CBCOL_SECOND == nCol)
pEntry->AddItem( new SvLBoxString( pEntry, 0, sEmpty) ); // Leerspalte
pEntry->AddItem( new SvLBoxContextBmp( pEntry, 0, Image(), Image(), 0)); // Sonst Puff!
pEntry->AddItem( new BrwString_Impl( pEntry, 0, rTxt ) );
return pEntry;
}
// -----------------------------------------------------------------------
void SvxLinguTabPage::HideGroups( sal_uInt16 nGrp )
{
if ( 0 != ( GROUP_MODULES & nGrp ) )
{
aLinguModulesFT.Hide();
aLinguModulesCLB.Hide();
aLinguModulesEditPB.Hide();
// reposition / resize remaining controls
long nDeltaY = aLinguDicsFT.GetPosPixel().Y() -
aLinguModulesFT.GetPosPixel().Y();
DBG_ASSERT( nDeltaY >= 0, "move/resize value is negative" );
Point aPos;
//
aPos = aLinguDicsFT.GetPosPixel();
aPos.Y() -= nDeltaY;
aLinguDicsFT.SetPosPixel( aPos );
aPos = aLinguDicsCLB.GetPosPixel();
aPos.Y() -= nDeltaY;
aLinguDicsCLB.SetPosPixel( aPos );
aPos = aLinguDicsNewPB.GetPosPixel();
aPos.Y() -= nDeltaY;
aLinguDicsNewPB.SetPosPixel( aPos );
aPos = aLinguDicsEditPB.GetPosPixel();
aPos.Y() -= nDeltaY;
aLinguDicsEditPB.SetPosPixel( aPos );
aPos = aLinguDicsDelPB.GetPosPixel();
aPos.Y() -= nDeltaY;
aLinguDicsDelPB.SetPosPixel( aPos );
//
aPos = aLinguOptionsFT.GetPosPixel();
aPos.Y() -= nDeltaY;
aLinguOptionsFT.SetPosPixel( aPos );
aPos = aLinguOptionsCLB.GetPosPixel();
aPos.Y() -= nDeltaY;
aLinguOptionsCLB.SetPosPixel( aPos );
aPos = aLinguOptionsEditPB.GetPosPixel();
aPos.Y() -= nDeltaY;
aLinguOptionsEditPB.SetPosPixel( aPos );
//
Size aSize( aLinguOptionsCLB.GetSizePixel() );
aSize.Height() += nDeltaY;
aLinguOptionsCLB.SetSizePixel( aSize );
if ( SvtExtendedSecurityOptions().GetOpenHyperlinkMode()
!= SvtExtendedSecurityOptions::OPEN_NEVER )
{
aSize = GetOutputSizePixel();
aSize.Height() += ( aMoreDictsLink.GetSizePixel().Height() * 11 / 8 );
SetSizePixel( aSize );
aMoreDictsLink.Show();
}
}
}
/*--------------------------------------------------
--------------------------------------------------*/
SvxEditModulesDlg::SvxEditModulesDlg(Window* pParent, SvxLinguData_Impl& rData) :
ModalDialog( pParent, CUI_RES(RID_SVXDLG_EDIT_MODULES ) ),
aModulesFL ( this, CUI_RES( FL_EDIT_MODULES_OPTIONS ) ),
aLanguageFT ( this, CUI_RES( FT_EDIT_MODULES_LANGUAGE ) ),
aLanguageLB ( this, CUI_RES( LB_EDIT_MODULES_LANGUAGE ), sal_False ),
aModulesCLB ( this, CUI_RES( CLB_EDIT_MODULES_MODULES ) ),
aPrioUpPB ( this, CUI_RES( PB_EDIT_MODULES_PRIO_UP ) ),
aPrioDownPB ( this, CUI_RES( PB_EDIT_MODULES_PRIO_DOWN ) ),
aBackPB ( this, CUI_RES( PB_EDIT_MODULES_PRIO_BACK ) ),
aMoreDictsLink ( this, CUI_RES( FT_EDIT_MODULES_NEWDICTSLINK ) ),
aButtonsFL ( this, CUI_RES( FL_EDIT_MODULES_BUTTONS ) ),
aHelpPB ( this, CUI_RES( PB_HELP ) ),
aClosePB ( this, CUI_RES( PB_OK ) ),
sSpell ( CUI_RES( ST_SPELL ) ),
sHyph ( CUI_RES( ST_HYPH ) ),
sThes ( CUI_RES( ST_THES ) ),
sGrammar ( CUI_RES( ST_GRAMMAR ) ),
rLinguData ( rData )
{
pCheckButtonData = NULL;
FreeResource();
pDefaultLinguData = new SvxLinguData_Impl( rLinguData );
aModulesCLB.SetStyle( aModulesCLB.GetStyle()|WB_CLIPCHILDREN|WB_HSCROLL|WB_FORCE_MAKEVISIBLE );
aModulesCLB.SetHighlightRange();
aModulesCLB.SetHelpId(HID_CLB_EDIT_MODULES_MODULES );
aModulesCLB.SetSelectHdl( LINK( this, SvxEditModulesDlg, SelectHdl_Impl ));
aModulesCLB.SetCheckButtonHdl( LINK( this, SvxEditModulesDlg, BoxCheckButtonHdl_Impl) );
aClosePB .SetClickHdl( LINK( this, SvxEditModulesDlg, ClickHdl_Impl ));
aPrioUpPB .SetClickHdl( LINK( this, SvxEditModulesDlg, UpDownHdl_Impl ));
aPrioDownPB.SetClickHdl( LINK( this, SvxEditModulesDlg, UpDownHdl_Impl ));
aBackPB .SetClickHdl( LINK( this, SvxEditModulesDlg, BackHdl_Impl ));
// in case of not installed language modules
aPrioUpPB .Enable( sal_False );
aPrioDownPB.Enable( sal_False );
if ( SvtExtendedSecurityOptions().GetOpenHyperlinkMode()
!= SvtExtendedSecurityOptions::OPEN_NEVER )
{
aMoreDictsLink.SetURL( String(
RTL_CONSTASCII_STRINGPARAM( "https://extensions.openoffice.org/dictionaries" ) ) );
aMoreDictsLink.SetClickHdl( LINK( this, SvxEditModulesDlg, OpenURLHdl_Impl ) );
}
else
{
aMoreDictsLink.Hide();
long nPos = aMoreDictsLink.GetPosPixel().Y() + aMoreDictsLink.GetSizePixel().Height();
Size aSize = aModulesCLB.GetSizePixel();
aSize.Height() += ( nPos - ( aModulesCLB.GetPosPixel().Y() + aSize.Height() ) );
aModulesCLB.SetSizePixel( aSize );
}
//
//fill language box
//
Sequence< sal_Int16 > aAvailLang;
uno::Reference< XAvailableLocales > xAvail( rLinguData.GetManager(), UNO_QUERY );
if (xAvail.is())
{
aAvailLang = lcl_LocaleSeqToLangSeq(
xAvail->getAvailableLocales( C2U(cSpell) ) );
}
const Sequence< Locale >& rLoc = rLinguData.GetAllSupportedLocales();
const Locale* pLocales = rLoc.getConstArray();
aLanguageLB.Clear();
for(long i = 0; i < rLoc.getLength(); i++)
{
sal_Int16 nLang = SvxLocaleToLanguage( pLocales[i] );
aLanguageLB.InsertLanguage( nLang, lcl_SeqHasLang( aAvailLang, nLang ) );
}
LanguageType eSysLang = MsLangId::getSystemLanguage();
aLanguageLB.SelectLanguage( eSysLang );
if(!aLanguageLB.IsLanguageSelected( eSysLang ) )
aLanguageLB.SelectEntryPos(0);
aLanguageLB.SetSelectHdl( LINK( this, SvxEditModulesDlg, LangSelectHdl_Impl ));
LangSelectHdl_Impl(&aLanguageLB);
}
SvxEditModulesDlg::~SvxEditModulesDlg()
{
delete pDefaultLinguData;
}
SvLBoxEntry* SvxEditModulesDlg::CreateEntry( String& rTxt, sal_uInt16 nCol )
{
SvLBoxEntry* pEntry = new SvLBoxEntry;
if( !pCheckButtonData )
{
pCheckButtonData = new SvLBoxButtonData( &aModulesCLB );
pCheckButtonData->SetLink( aModulesCLB.GetCheckButtonHdl() );
}
String sEmpty;
if (CBCOL_FIRST == nCol)
pEntry->AddItem( new SvLBoxButton( pEntry, SvLBoxButtonKind_enabledCheckbox, 0, pCheckButtonData ) );
if (CBCOL_SECOND == nCol)
pEntry->AddItem( new SvLBoxString( pEntry, 0, sEmpty) ); // Leerspalte
pEntry->AddItem( new SvLBoxContextBmp( pEntry, 0, Image(), Image(), 0)); // Sonst Puff!
pEntry->AddItem( new BrwStringDic_Impl( pEntry, 0, rTxt ) );
return pEntry;
}
/* ---------------------------------------------------------------------------
---------------------------------------------------------------------------*/
IMPL_LINK( SvxEditModulesDlg, SelectHdl_Impl, SvxCheckListBox *, pBox )
{
if (&aModulesCLB == pBox)
{
sal_Bool bDisableUp = sal_True;
sal_Bool bDisableDown = sal_True;
SvLBoxEntry *pEntry = pBox->GetCurEntry();
if (pEntry)
{
ModuleUserData_Impl* pData = (ModuleUserData_Impl*)pEntry->GetUserData();
if(!pData->IsParent() && pData->GetType() != TYPE_HYPH)
{
sal_uInt16 nCurPos = pBox->GetSelectEntryPos();
if(nCurPos < pBox->GetEntryCount() - 1)
{
bDisableDown = ((ModuleUserData_Impl*)pBox->
GetEntry(nCurPos + 1)->GetUserData())->IsParent();
}
if(nCurPos > 1)
{
bDisableUp = ((ModuleUserData_Impl*)pBox->
GetEntry(nCurPos - 1)->GetUserData())->IsParent();
}
}
aPrioUpPB.Enable(!bDisableUp);
aPrioDownPB.Enable(!bDisableDown);
}
}
else
{
DBG_ERROR( "pBox unexpected value" );
}
return 0;
}
/* -----------------------------28.05.01 11:00--------------------------------
---------------------------------------------------------------------------*/
IMPL_LINK( SvxEditModulesDlg, BoxCheckButtonHdl_Impl, SvTreeListBox *, pBox )
{
// if (pBox == (SvTreeListBox *) &aModulesCLB)
// {
pBox = &aModulesCLB;
SvLBoxEntry *pCurEntry = pBox->GetCurEntry();
if (pCurEntry)
{
ModuleUserData_Impl* pData = (ModuleUserData_Impl *)
pCurEntry->GetUserData();
if (!pData->IsParent() && pData->GetType() == TYPE_HYPH)
{
// make hyphenator checkboxes function as radio-buttons
// (at most one box may be checked)
SvLBoxEntry *pEntry = pBox->First();
while (pEntry)
{
pData = (ModuleUserData_Impl *) pEntry->GetUserData();
if (!pData->IsParent() &&
pData->GetType() == TYPE_HYPH &&
pEntry != pCurEntry)
{
lcl_SetCheckButton( pEntry, sal_False );
pBox->InvalidateEntry( pEntry );
}
pEntry = pBox->Next( pEntry );
}
}
}
// }
return 0;
}
/* -----------------------------27.11.00 14:00--------------------------------
---------------------------------------------------------------------------*/
OUString lcl_GetServiceName(sal_uInt8 nType)
{
switch(nType)
{
case TYPE_SPELL : return C2U(cSpell);
case TYPE_GRAMMAR : return C2U(cGrammar);
case TYPE_HYPH : return C2U(cHyph);
case TYPE_THES : return C2U(cThes);
}
return OUString();
}
IMPL_LINK( SvxEditModulesDlg, LangSelectHdl_Impl, ListBox *, pBox )
{
LanguageType eCurLanguage = aLanguageLB.GetSelectLanguage();
static Locale aLastLocale;
Locale aCurLocale;
SvxLanguageToLocale(aCurLocale, eCurLanguage);
SvLBoxTreeList *pModel = aModulesCLB.GetModel();
// uno::Reference<XLinguServiceManager>& xMgr = rLinguData.GetManager();
if (pBox)
{
// save old probably changed settings
// before switching to new language entries
sal_Int16 nLang = SvxLocaleToLanguage( aLastLocale );
sal_Int32 nStart = 0, nLocalIndex = 0;
Sequence< OUString > aChange;
sal_Bool bChanged = sal_False;
for(sal_uInt16 i = 0; i < aModulesCLB.GetEntryCount(); i++)
{
SvLBoxEntry *pEntry = aModulesCLB.GetEntry(i);
ModuleUserData_Impl* pData = (ModuleUserData_Impl*)pEntry->GetUserData();
if(pData->IsParent())
{
if(bChanged)
{
LangImplNameTable *pTable = 0;
sal_uInt8 nType = pData->GetType();
switch (nType - 1)
{
case TYPE_SPELL : pTable = &rLinguData.GetSpellTable(); break;
case TYPE_GRAMMAR : pTable = &rLinguData.GetGrammarTable(); break;
case TYPE_HYPH : pTable = &rLinguData.GetHyphTable(); break;
case TYPE_THES : pTable = &rLinguData.GetThesTable(); break;
}
if (pTable)
{
aChange.realloc(nStart);
(*pTable)[ nLang ] = aChange;
}
}
nLocalIndex = nStart = 0;
aChange.realloc(aModulesCLB.GetEntryCount());
bChanged = sal_False;
}
else
{
OUString* pChange = aChange.getArray();
pChange[nStart] = pData->GetImplName();
bChanged |= pData->GetIndex() != nLocalIndex ||
pData->IsChecked() != aModulesCLB.IsChecked(i);
if(aModulesCLB.IsChecked(i))
nStart++;
++nLocalIndex;
}
}
if(bChanged)
{
aChange.realloc(nStart);
rLinguData.GetThesTable()[ nLang ] = aChange;
}
}
for(sal_uLong i = 0; i < aModulesCLB.GetEntryCount(); i++)
delete (ModuleUserData_Impl*)aModulesCLB.GetEntry(i)->GetUserData();
//
// display entries for new selected language
//
aModulesCLB.Clear();
if(LANGUAGE_DONTKNOW != eCurLanguage)
{
// sal_Int32 nEntryPos = 1;
sal_uLong n;
ServiceInfo_Impl* pInfo;
//
// spellchecker entries
//
SvLBoxEntry* pEntry = CreateEntry( sSpell, CBCOL_SECOND );
ModuleUserData_Impl* pUserData = new ModuleUserData_Impl(
String(), sal_True, sal_False, TYPE_SPELL, 0 );
pEntry->SetUserData( (void *)pUserData );
pModel->Insert( pEntry );
//
Sequence< OUString > aNames( rLinguData.GetSortedImplNames( eCurLanguage, TYPE_SPELL ) );
const OUString *pName = aNames.getConstArray();
sal_uLong nNames = (sal_uLong) aNames.getLength();
sal_Int32 nLocalIndex = 0; // index relative to parent
for (n = 0; n < nNames; ++n)
{
OUString aImplName;
sal_Bool bIsSuppLang = sal_False;
pInfo = rLinguData.GetInfoByImplName( pName[n] );
if (pInfo)
{
bIsSuppLang = pInfo->xSpell.is() &&
pInfo->xSpell->hasLocale( aCurLocale );
aImplName = pInfo->sSpellImplName;
}
if (aImplName.getLength() && bIsSuppLang)
{
String aTxt( pInfo->sDisplayName );
SvLBoxEntry* pNewEntry = CreateEntry( aTxt, CBCOL_FIRST );
LangImplNameTable &rTable = rLinguData.GetSpellTable();
const bool bHasLang = rTable.count( eCurLanguage );
if (!bHasLang)
{
DBG_WARNING( "language entry missing" ); // only relevant if all languages found should be supported
}
const bool bCheck = bHasLang && lcl_SeqGetEntryPos( rTable[ eCurLanguage ], aImplName ) >= 0;
lcl_SetCheckButton( pNewEntry, bCheck );
pUserData = new ModuleUserData_Impl( aImplName, sal_False,
bCheck, TYPE_SPELL, (sal_uInt8)nLocalIndex++ );
pNewEntry->SetUserData( (void *)pUserData );
pModel->Insert( pNewEntry );
}
}
//
// grammar checker entries
//
pEntry = CreateEntry( sGrammar, CBCOL_SECOND );
pUserData = new ModuleUserData_Impl( String(), sal_True, sal_False, TYPE_GRAMMAR, 0 );
pEntry->SetUserData( (void *)pUserData );
pModel->Insert( pEntry );
//
aNames = rLinguData.GetSortedImplNames( eCurLanguage, TYPE_GRAMMAR );
pName = aNames.getConstArray();
nNames = (sal_uLong) aNames.getLength();
nLocalIndex = 0;
for (n = 0; n < nNames; ++n)
{
OUString aImplName;
sal_Bool bIsSuppLang = sal_False;
pInfo = rLinguData.GetInfoByImplName( pName[n] );
if (pInfo)
{
bIsSuppLang = pInfo->xGrammar.is() &&
pInfo->xGrammar->hasLocale( aCurLocale );
aImplName = pInfo->sGrammarImplName;
}
if (aImplName.getLength() && bIsSuppLang)
{
String aTxt( pInfo->sDisplayName );
SvLBoxEntry* pNewEntry = CreateEntry( aTxt, CBCOL_FIRST );
LangImplNameTable &rTable = rLinguData.GetGrammarTable();
const bool bHasLang = rTable.count( eCurLanguage );
if (!bHasLang)
{
DBG_WARNING( "language entry missing" ); // only relevant if all languages found should be supported
}
const bool bCheck = bHasLang && lcl_SeqGetEntryPos( rTable[ eCurLanguage ], aImplName ) >= 0;
lcl_SetCheckButton( pNewEntry, bCheck );
pUserData = new ModuleUserData_Impl( aImplName, sal_False,
bCheck, TYPE_GRAMMAR, (sal_uInt8)nLocalIndex++ );
pNewEntry->SetUserData( (void *)pUserData );
pModel->Insert( pNewEntry );
}
}
//
// hyphenator entries
//
pEntry = CreateEntry( sHyph, CBCOL_SECOND );
pUserData = new ModuleUserData_Impl( String(), sal_True, sal_False, TYPE_HYPH, 0 );
pEntry->SetUserData( (void *)pUserData );
pModel->Insert( pEntry );
//
aNames = rLinguData.GetSortedImplNames( eCurLanguage, TYPE_HYPH );
pName = aNames.getConstArray();
nNames = (sal_uLong) aNames.getLength();
nLocalIndex = 0;
for (n = 0; n < nNames; ++n)
{
OUString aImplName;
sal_Bool bIsSuppLang = sal_False;
pInfo = rLinguData.GetInfoByImplName( pName[n] );
if (pInfo)
{
bIsSuppLang = pInfo->xHyph.is() &&
pInfo->xHyph->hasLocale( aCurLocale );
aImplName = pInfo->sHyphImplName;
}
if (aImplName.getLength() && bIsSuppLang)
{
String aTxt( pInfo->sDisplayName );
SvLBoxEntry* pNewEntry = CreateEntry( aTxt, CBCOL_FIRST );
LangImplNameTable &rTable = rLinguData.GetHyphTable();
const bool bHasLang = rTable.count( eCurLanguage );
if (!bHasLang)
{
DBG_WARNING( "language entry missing" ); // only relevant if all languages found should be supported
}
const bool bCheck = bHasLang && lcl_SeqGetEntryPos( rTable[ eCurLanguage ], aImplName ) >= 0;
lcl_SetCheckButton( pNewEntry, bCheck );
pUserData = new ModuleUserData_Impl( aImplName, sal_False,
bCheck, TYPE_HYPH, (sal_uInt8)nLocalIndex++ );
pNewEntry->SetUserData( (void *)pUserData );
pModel->Insert( pNewEntry );
}
}
//
// thesaurus entries
//
pEntry = CreateEntry( sThes, CBCOL_SECOND );
pUserData = new ModuleUserData_Impl( String(), sal_True, sal_False, TYPE_THES, 0 );
pEntry->SetUserData( (void *)pUserData );
pModel->Insert( pEntry );
//
aNames = rLinguData.GetSortedImplNames( eCurLanguage, TYPE_THES );
pName = aNames.getConstArray();
nNames = (sal_uLong) aNames.getLength();
nLocalIndex = 0;
for (n = 0; n < nNames; ++n)
{
OUString aImplName;
sal_Bool bIsSuppLang = sal_False;
pInfo = rLinguData.GetInfoByImplName( pName[n] );
if (pInfo)
{
bIsSuppLang = pInfo->xThes.is() &&
pInfo->xThes->hasLocale( aCurLocale );
aImplName = pInfo->sThesImplName;
}
if (aImplName.getLength() && bIsSuppLang)
{
String aTxt( pInfo->sDisplayName );
SvLBoxEntry* pNewEntry = CreateEntry( aTxt, CBCOL_FIRST );
LangImplNameTable &rTable = rLinguData.GetThesTable();
const bool bHasLang = rTable.count( eCurLanguage );
if (!bHasLang)
{
DBG_WARNING( "language entry missing" ); // only relevant if all languages found should be supported
}
const bool bCheck = bHasLang && lcl_SeqGetEntryPos( rTable[ eCurLanguage ], aImplName ) >= 0;
lcl_SetCheckButton( pNewEntry, bCheck );
pUserData = new ModuleUserData_Impl( aImplName, sal_False,
bCheck, TYPE_THES, (sal_uInt8)nLocalIndex++ );
pNewEntry->SetUserData( (void *)pUserData );
pModel->Insert( pNewEntry );
}
}
}
aLastLocale.Language = aCurLocale.Language;
aLastLocale.Country = aCurLocale.Country;
return 0;
}
/* -----------------------------27.11.00 19:50--------------------------------
---------------------------------------------------------------------------*/
IMPL_LINK( SvxEditModulesDlg, UpDownHdl_Impl, PushButton *, pBtn )
{
sal_Bool bUp = &aPrioUpPB == pBtn;
sal_uInt16 nCurPos = aModulesCLB.GetSelectEntryPos();
SvLBoxEntry* pEntry;
if (nCurPos != LISTBOX_ENTRY_NOTFOUND &&
0 != (pEntry = aModulesCLB.GetEntry(nCurPos)))
{
aModulesCLB.SetUpdateMode(sal_False);
SvLBoxTreeList *pModel = aModulesCLB.GetModel();
ModuleUserData_Impl* pData = (ModuleUserData_Impl*)pEntry->GetUserData();
String aStr(aModulesCLB.GetEntryText(pEntry));
SvLBoxEntry* pToInsert = CreateEntry( aStr, CBCOL_FIRST );
pToInsert->SetUserData( (void *)pData);
sal_Bool bIsChecked = aModulesCLB.IsChecked(nCurPos);
pModel->Remove(pEntry);
sal_uInt16 nDestPos = bUp ? nCurPos - 1 : nCurPos + 1;
pModel->Insert(pToInsert, nDestPos);
aModulesCLB.CheckEntryPos(nDestPos, bIsChecked );
aModulesCLB.SelectEntryPos(nDestPos );
SelectHdl_Impl(&aModulesCLB);
aModulesCLB.SetUpdateMode(sal_True);
}
return 0;
}
/* ---------------------------------------------------------------------------
---------------------------------------------------------------------------*/
IMPL_LINK( SvxEditModulesDlg, ClickHdl_Impl, PushButton *, pBtn )
{
if (&aClosePB == pBtn)
{
// store language config
LangSelectHdl_Impl(&aLanguageLB);
EndDialog( RET_OK );
}
else
{
DBG_ERROR( "pBtn unexpected value" );
}
return 0;
}
/* -----------------------------27.11.00 20:31--------------------------------
---------------------------------------------------------------------------*/
IMPL_LINK( SvxEditModulesDlg, BackHdl_Impl, PushButton *, EMPTYARG )
{
rLinguData = *pDefaultLinguData;
LangSelectHdl_Impl(0);
return 0;
}
// -----------------------------------------------------------------------
IMPL_LINK( SvxEditModulesDlg, OpenURLHdl_Impl, svt::FixedHyperlink *, EMPTYARG )
{
::rtl::OUString sURL( aMoreDictsLink.GetURL() );
lcl_OpenURL( sURL );
return 0;
}