bool KviKvsTreeNodeHashElement::evaluateReadOnlyInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c,KviKvsVariant * pBuffer)
{
KviKvsVariant key;
if(!m_pKey->evaluateReadOnly(c,&key))return false;
QString szKey;
key.asString(szKey);
if(szKey.isEmpty())
{
c->warning(this,__tr2qs_ctx("Hash key evaluated to empty string: fix the script","kvs"));
pBuffer->setNothing();
return true;
}
KviKvsVariant val;
if(o)
{
if(!m_pSource->evaluateReadOnlyInObjectScope(o,c,&val))return false;
} else {
if(!m_pSource->evaluateReadOnly(c,&val))return false;
}
if(!val.isHash())
{
if(!val.isNothing())
{
QString szType;
val.getTypeName(szType);
c->warning(this,__tr2qs_ctx("The argument of the {} subscript didn't evaluate to a hash: automatic conversion from type '%Q' supplied","kvs"),&szType);
}
pBuffer->setNothing();
return true;
}
KviKvsVariant * v = val.hash()->find(szKey);
if(!v)
{
pBuffer->setNothing();
return true;
}
pBuffer->copyFrom(v);
return true;
}
bool KviKvsTreeNodeSpecialCommandForeach::execute(KviKvsRunTimeContext * c)
{
KviKvsVariantList l;
l.setAutoDelete(true);
if(!m_pIterationData->evaluate(c,&l))
return false;
KviKvsSwitchList swl;
if(m_pSwitches)
{
if(!(m_pSwitches->evaluate(c,&swl)))
return false;
}
bool bIncludeEmptyScalars = swl.find('a',"all") != 0;
for(KviKvsVariant * pArg = l.first(); pArg; pArg = l.next())
{
switch(pArg->type())
{
case KviKvsVariantData::Array:
{
unsigned int uCnt = pArg->array()->size();
unsigned int idx = 0;
while(idx < uCnt)
{
// we evaluate this each time (as it may actually be killed at each iteration)
// FIXME: maybe some kind of reference counting or a observer pattern might be a bit more efficient here
// (but might be far less efficient everywhere else...)
KviKvsRWEvaluationResult * v = m_pIterationVariable->evaluateReadWrite(c);
if(!v)
return false;
KviKvsVariant * pOne = pArg->array()->at(idx);
if(pOne)
{
if(bIncludeEmptyScalars || (!pOne->isEmpty()))
{
v->result()->copyFrom(*pOne);
} else {
delete v; // we're done with it for this iteration
idx++;
continue;
}
} else {
if(bIncludeEmptyScalars)
{
v->result()->setNothing();
} else {
delete v; // we're done with it for this iteration
idx++;
continue;
}
}
delete v; // we're done with it for this iteration
if(!m_pLoop->execute(c))
{
if(c->error())
return false;
// break allowed!
if(c->breakPending())
{
c->handleBreak();
return true;
}
if(c->continuePending())
{
c->handleContinue();
idx++;
continue;
}
return false; // propagate the false return value
}
idx++;
}
}
break;
case KviKvsVariantData::Hash:
{
KviKvsHashIterator it(*(pArg->hash()->dict()));
while(KviKvsVariant * pOne = it.current())
{
// we evaluate this each time (as it may actually be killed at each iteration)
// FIXME: maybe some kind of reference counting or a observer pattern might be a bit more efficient here
// (but might be far less efficient everywhere else...)
KviKvsRWEvaluationResult * v = m_pIterationVariable->evaluateReadWrite(c);
if(!v)
return false;
if(bIncludeEmptyScalars || (!pOne->isEmpty()))
{
v->result()->copyFrom(*pOne);
} else {
delete v; // we're done with it for this iteration
++it;
continue;
}
delete v; // we're done with it for this iteration
if(!m_pLoop->execute(c))
{
if(c->error())
return false;
// break allowed!
if(c->breakPending())
{
c->handleBreak();
return true;
}
if(c->continuePending())
{
c->handleContinue();
++it;
continue;
}
return false; // propagate the false return value
}
++it;
}
}
break;
default:
if(bIncludeEmptyScalars || (!pArg->isEqualToNothing()))
{
// we evaluate this each time (as it may actually be killed at each iteration)
// FIXME: maybe some kind of reference counting or a observer pattern might be a bit more efficient here
// (but might be far less efficient everywhere else...)
KviKvsRWEvaluationResult * v = m_pIterationVariable->evaluateReadWrite(c);
if(!v)
return false;
v->result()->copyFrom(*pArg);
delete v; // we're done with it for this iteration
if(!m_pLoop->execute(c))
{
if(c->error())
return false;
// break allowed!
if(c->breakPending())
{
c->handleBreak();
return true;
}
if(c->continuePending())
{
c->handleContinue();
continue;
}
return false; // propagate the false return value
}
}
break;
}
}
return true;
}
OptionsWidget_textEncoding::OptionsWidget_textEncoding(QWidget * parent)
: KviOptionsWidget(parent)
{
setObjectName("textencoding_options_widget");
createLayout();
KviTalGroupBox* gbox = addGroupBox(0,0,0,0,Qt::Horizontal,__tr2qs_ctx("Encoding","options"));
QGridLayout* grid = new QGridLayout;
gbox->setLayout(grid);
//server encoding
grid->addWidget(addLabel(gbox,__tr2qs_ctx("Default server encoding:","options")),0,0);
m_pSrvEncodingCombo = new QComboBox(gbox);
grid->addWidget(m_pSrvEncodingCombo,0,1);
m_pSrvEncodingCombo->addItem(__tr2qs_ctx("Use Language Encoding","options"));
//text encoding
grid->addWidget(addLabel(gbox,__tr2qs_ctx("Default text encoding:","options")),1,0);
m_pTextEncodingCombo = new QComboBox(gbox);
grid->addWidget(m_pTextEncodingCombo,1,1);
m_pTextEncodingCombo->addItem(__tr2qs_ctx("Use Language Encoding","options"));
//common between text and server encoding
int i = 0;
int iTextMatch = 0, iSrvMatch=0;
KviLocale::EncodingDescription * d = KviLocale::instance()->encodingDescription(i);
while(d->pcName)
{
if(KviQString::equalCI(d->pcName,KVI_OPTION_STRING(KviOption_stringDefaultTextEncoding)))
iTextMatch = i + 1;
if(KviQString::equalCI(d->pcName,KVI_OPTION_STRING(KviOption_stringDefaultSrvEncoding)))
iSrvMatch = i + 1;
m_pTextEncodingCombo->insertItem(m_pTextEncodingCombo->count(),d->pcName);
m_pSrvEncodingCombo->insertItem(m_pSrvEncodingCombo->count(),d->pcName);
i++;
d = KviLocale::instance()->encodingDescription(i);
}
m_pTextEncodingCombo->setCurrentIndex(iTextMatch);
m_pSrvEncodingCombo->setCurrentIndex(iSrvMatch);
gbox = addGroupBox(0,1,0,1,Qt::Horizontal,__tr2qs_ctx("Language","options"));
grid = new QGridLayout;
gbox->setLayout(grid);
grid->addWidget(addLabel(gbox,__tr2qs_ctx("Force language:","options")),0,0);
m_pForcedLocaleCombo = new QComboBox(gbox);
grid->addWidget(m_pForcedLocaleCombo,0,1);
grid->addWidget(addLabel(gbox,__tr2qs_ctx("<b>Note:</b> You must restart KVIrc to apply any language changes","options")),1,0,1,2);
m_pForcedLocaleCombo->addItem(__tr2qs_ctx("Automatic detection","options"));
m_pForcedLocaleCombo->addItem(__tr2qs_ctx("en","options"));
QString szLangFile;
g_pApp->getLocalKvircDirectory(szLangFile,KviApplication::None,KVI_FORCE_LOCALE_FILE_NAME);
bool bIsDefaultLocale = !KviFileUtils::fileExists(szLangFile);
//We Have setted locale, but not restarted kvirc
if(!g_szPrevSettedLocale.isEmpty())
m_szLanguage = g_szPrevSettedLocale;
else
m_szLanguage = KviLocale::instance()->localeName();
QString szLocaleDir;
g_pApp->getGlobalKvircDirectory(szLocaleDir,KviApplication::Locale);
QStringList list=QDir(szLocaleDir).entryList(QStringList("kvirc_*.mo"),QDir::Files);
i = 0;
int iMatch = 0;
for(QStringList::Iterator it = list.begin(); it != list.end(); ++it)
{
QString szTmp=*it;
szTmp.replace("kvirc_","");
szTmp.replace(".mo","");
m_pForcedLocaleCombo->insertItem(m_pForcedLocaleCombo->count(),szTmp);
if(KviQString::equalCI(szTmp,m_szLanguage))
iMatch = i + 2;
i++;
}
if(bIsDefaultLocale)
m_pForcedLocaleCombo->setCurrentIndex(0);
else if(KviQString::equalCI(m_szLanguage,"en"))
m_pForcedLocaleCombo->setCurrentIndex(1);
else
m_pForcedLocaleCombo->setCurrentIndex(iMatch);
#ifdef COMPILE_ENCHANT_SUPPORT
{
gbox = addGroupBox(0,2,0,2,Qt::Horizontal,__tr2qs_ctx("Spell Checker Dictionaries","options"));
KviKvsVariant availableDictionaries;
KviKvsScript::evaluate("$spellchecker.availableDictionaries", NULL, NULL, &availableDictionaries);
const KviPointerHashTable<QString, KviKvsVariant>* hashTable = availableDictionaries.hash()->dict();
KviPointerHashTableIterator<QString, KviKvsVariant> iter(*hashTable);
QMap<QString, QString> dictMap;
for (bool b = iter.moveFirst(); b; b = iter.moveNext()) {
QString szDescription;
iter.current()->asString(szDescription);
dictMap[iter.currentKey()] = szDescription;
}
m_pSpellCheckerDictionaries = new QTableWidget(gbox);
m_pSpellCheckerDictionaries->setRowCount(dictMap.size());
m_pSpellCheckerDictionaries->setColumnCount(2);
QStringList header;
header << __tr2qs_ctx("Language code", "options");
header << __tr2qs_ctx("Provided by", "options");
m_pSpellCheckerDictionaries->setHorizontalHeaderLabels(header);
#if (QT_VERSION >= 0x050000)
m_pSpellCheckerDictionaries->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
#else
m_pSpellCheckerDictionaries->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
#endif
m_pSpellCheckerDictionaries->setSelectionBehavior(QAbstractItemView::SelectRows);
m_pSpellCheckerDictionaries->setSelectionMode(QAbstractItemView::SingleSelection);
m_pSpellCheckerDictionaries->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
int row = 0;
for (QMap<QString, QString>::iterator it = dictMap.begin(); it != dictMap.end(); ++it, ++row) {
QTableWidgetItem* itemLang = new QTableWidgetItem(it.key());
itemLang->setCheckState(KVI_OPTION_STRINGLIST(KviOption_stringlistSpellCheckerDictionaries).contains(it.key()) ? Qt::Checked : Qt::Unchecked);
itemLang->setFlags(itemLang->flags() & ~Qt::ItemIsEditable);
m_pSpellCheckerDictionaries->setItem(row,0,itemLang);
QTableWidgetItem* itemDesc = new QTableWidgetItem(it.value());
itemDesc->setFlags(itemDesc->flags() & ~Qt::ItemIsEditable);
m_pSpellCheckerDictionaries->setItem(row,1,itemDesc);
}
m_pSpellCheckerDictionaries->resizeColumnsToContents();
m_pSpellCheckerDictionaries->resizeRowsToContents();
}
#else
addRowSpacer(0,2,0,2);
#endif
}
bool process(KviKvsVariantList * pVariantList, KviKvsRunTimeContext * pContext, KviKvsParameterProcessor::ParameterFormat * pFmtArray)
{
KviKvsVariant * v = pVariantList->first();
while(pFmtArray->szName)
{
if(!v)
{
// parameter not present
// it MUST be optional
if(!(pFmtArray->uFlags & KVS_PF_OPTIONAL))
{
// bad luck
QString szError = QString(__tr2qs_ctx("Missing non-optional parameter \"%1\"", "kvs")).arg(pFmtArray->szName);
pContext->error(szError);
return false;
}
// ok, missing but optional (all the following are implicitly optional too)
// set to default values
do
{
setDefaultValue(pFmtArray);
pFmtArray++;
} while(pFmtArray->szName);
return true;
}
// here we do only "light" casts: hard ones must be done explicitly by the user
switch(pFmtArray->uType)
{
case KVS_PT_STRING:
v->asString(*((QString *)(pFmtArray->pContainer)));
if(pFmtArray->uFlags & KVS_PF_APPENDREMAINING)
{
v = pVariantList->next();
while(v)
{
*((QString *)(pFmtArray->pContainer)) += QChar(' ');
v->appendAsString(*((QString *)(pFmtArray->pContainer)));
v = pVariantList->next();
}
return true;
}
break;
case KVS_PT_STRINGLIST:
{
((QStringList *)(pFmtArray->pContainer))->clear();
QString pSz;
v->asString(pSz);
((QStringList *)(pFmtArray->pContainer))->append(pSz);
v = pVariantList->next();
while(v)
{
v->asString(pSz);
((QStringList *)(pFmtArray->pContainer))->append(pSz);
v = pVariantList->next();
}
return true;
}
break;
case KVS_PT_VARIANTLIST:
{
((KviKvsVariantList *)(pFmtArray->pContainer))->clear();
((KviKvsVariantList *)(pFmtArray->pContainer))->setAutoDelete(false);
((KviKvsVariantList *)(pFmtArray->pContainer))->append(v);
v = pVariantList->next();
while(v)
{
((KviKvsVariantList *)(pFmtArray->pContainer))->append(v);
v = pVariantList->next();
}
return true;
}
break;
case KVS_PT_NONEMPTYSTRING:
{
v->asString(*((QString *)(pFmtArray->pContainer)));
bool bDoReturn = false;
if(pFmtArray->uFlags & KVS_PF_APPENDREMAINING)
{
v = pVariantList->next();
while(v)
{
*((QString *)(pFmtArray->pContainer)) += QChar(' ');
v->appendAsString(*((QString *)(pFmtArray->pContainer)));
v = pVariantList->next();
}
bDoReturn = true;
}
if(((QString *)(pFmtArray->pContainer))->isEmpty())
{
QString szError = QString(__tr2qs_ctx("Invalid data type for parameter \"%1\": found empty string while a non empty one was expected", "kvs")).arg(pFmtArray->szName);
pContext->error(szError);
return false;
}
if(bDoReturn)
return true;
}
break;
case KVS_PT_CSTRING:
{
QString tmp;
v->asString(tmp);
if(pFmtArray->uFlags & KVS_PF_APPENDREMAINING)
{
v = pVariantList->next();
while(v)
{
*((QByteArray *)(pFmtArray->pContainer)) += ' ';
v->appendAsString(tmp);
v = pVariantList->next();
}
*((QByteArray *)(pFmtArray->pContainer)) = tmp.toUtf8();
return true;
}
*((QByteArray *)(pFmtArray->pContainer)) = tmp.toUtf8();
}
break;
case KVS_PT_NONEMPTYCSTRING:
{
QString tmp;
v->asString(tmp);
bool bDoReturn = false;
if(pFmtArray->uFlags & KVS_PF_APPENDREMAINING)
{
v = pVariantList->next();
while(v)
{
*((QByteArray *)(pFmtArray->pContainer)) += ' ';
v->appendAsString(tmp);
v = pVariantList->next();
}
*((QByteArray *)(pFmtArray->pContainer)) = tmp.toUtf8();
bDoReturn = true;
}
*((QByteArray *)(pFmtArray->pContainer)) = tmp.toUtf8();
if(((QByteArray *)(pFmtArray->pContainer))->isEmpty())
{
QString szError = QString(__tr2qs_ctx("Invalid data type for parameter \"%1\": found empty string while a non empty one was expected", "kvs")).arg(pFmtArray->szName);
pContext->error(szError);
return false;
}
if(bDoReturn)
return true;
}
break;
case KVS_PT_INT:
if(!v->asInteger(*((kvs_int_t *)(pFmtArray->pContainer))))
{
if(!handleParameterTypeError(pContext, pFmtArray, v, "integer"))
return false;
}
break;
case KVS_PT_UINT:
{
kvs_int_t iTmp;
if(!v->asInteger(iTmp))
{
if(!handleParameterTypeError(pContext, pFmtArray, v, "unsigned integer"))
return false;
}
if(iTmp < 0)
{
QString szError = QString(__tr2qs_ctx("Invalid data type for parameter \"%1\": found signed integer \"%2\" where type 'unsigned integer' was expected", "kvs")).arg(pFmtArray->szName).arg(iTmp);
pContext->error(szError);
return false;
}
*((kvs_uint_t *)(pFmtArray->pContainer)) = (kvs_uint_t)iTmp;
}
break;
case KVS_PT_DOUBLE:
if(!v->asReal(*((kvs_real_t *)(pFmtArray->pContainer))))
{
if(!handleParameterTypeError(pContext, pFmtArray, v, "real"))
return false;
}
break;
case KVS_PT_HASH:
if(!v->isHash())
{
if(!handleParameterTypeError(pContext, pFmtArray, v, "hash"))
return false;
}
else
{
*((KviKvsHash **)(pFmtArray->pContainer)) = v->hash();
}
break;
case KVS_PT_ARRAYCAST:
v->castToArray((KviKvsArrayCast *)(pFmtArray->pContainer));
break;
case KVS_PT_ARRAY:
if(!v->isArray())
{
if(!handleParameterTypeError(pContext, pFmtArray, v, "array"))
return false;
}
else
{
*((KviKvsArray **)(pFmtArray->pContainer)) = v->array();
}
break;
case KVS_PT_BOOL:
// this never fails: anything is converted to a boolean
*((bool *)(pFmtArray->pContainer)) = v->asBoolean();
break;
case KVS_PT_VARIANT:
*((KviKvsVariant **)(pFmtArray->pContainer)) = v;
break;
case KVS_PT_HOBJECT:
if(!v->asHObject(*((kvs_hobject_t *)(pFmtArray->pContainer))))
{
if(!handleParameterTypeError(pContext, pFmtArray, v, "hobject"))
return false;
}
break;
case KVS_PT_IGNORE:
// ignore
break;
default:
qDebug("Internal error in KviKvsParameterProcessor::processAsParameters(): unknown parameter type %d", pFmtArray->uType);
return false;
break;
}
pFmtArray++;
v = pVariantList->next();
}
return true;
}