//*******************************************************************
// read_data PRIVATE
//*******************************************************************
void QBtConfig::read_data()
{
QBtSettings stt;
QVariant data;
// filter state
filter_ = DEFAULT_FILTER_STATE;
if( stt.read( MAIN_WINDOW_GROUP + FILTER_KEY, data ) ) {
filter_ = data.toBool();
}
// button mode
btn_mode_ = QBtButtonSpace::FULL_DESC;
if( stt.read( MAIN_WINDOW_GROUP + BTN_MODE_KEY, data ) ) {
btn_mode_ = data.toInt();
}
// button font
btn_font_ = QFont();
if( stt.read( MAIN_WINDOW_GROUP + BTN_FONT_KEY, data ) ) {
btn_font_.fromString( data.toString() );
}
// font
font_ = QFont();
if( stt.read( VIEW_GROUP + FONT_KEY, data ) ) {
font_.fromString( data.toString() );
}
// bkg f nc ns
bkg_f_nc_ns_color_ = DEFAULT_BKG_F_NC_NS_COLOR;
if( stt.read( VIEW_GROUP + BKG_F_NC_NS_COLOR_KEY, data ) ) {
bkg_f_nc_ns_color_.setNamedColor( data.toString() );
}
// txt f nc ns
txt_f_nc_ns_color_ = DEFAULT_TXT_F_NC_NS_COLOR;
if( stt.read( VIEW_GROUP + TXT_F_NC_NS_COLOR_KEY, data ) ) {
txt_f_nc_ns_color_.setNamedColor( data.toString() );
}
// bkg nf nc ns
bkg_nf_nc_ns_color_ = DEFAULT_BKG_NF_NC_NS_COLOR;
if( stt.read( VIEW_GROUP + BKG_NF_NC_NS_COLOR_KEY, data ) ) {
bkg_nf_nc_ns_color_.setNamedColor( data.toString() );
}
// txt nf nc ns
txt_nf_nc_ns_color_ = DEFAULT_TXT_NF_NC_NS_COLOR;
if( stt.read( VIEW_GROUP + TXT_NF_NC_NS_COLOR_KEY, data ) ) {
txt_nf_nc_ns_color_.setNamedColor( data.toString() );
}
// bkg f nc s
bkg_f_nc_s_color_ = DEFAULT_BKG_F_NC_S_COLOR;
if( stt.read( VIEW_GROUP + BKG_F_NC_S_COLOR_KEY, data ) ) {
bkg_f_nc_s_color_.setNamedColor( data.toString() );
}
// txt f nc s
txt_f_nc_s_color_ = DEFAULT_TXT_F_NC_S_COLOR;
if( stt.read( VIEW_GROUP + TXT_F_NC_S_COLOR_KEY, data ) ) {
txt_f_nc_s_color_.setNamedColor( data.toString() );
}
// bkg nf nc s
bkg_nf_nc_s_color_ = DEFAULT_BKG_NF_NC_S_COLOR;
if( stt.read( VIEW_GROUP + BKG_NF_NC_S_COLOR_KEY, data ) ) {
bkg_nf_nc_s_color_.setNamedColor( data.toString() );
}
// txt nf nc s
txt_nf_nc_s_color_ = DEFAULT_TXT_NF_NC_S_COLOR;
if( stt.read( VIEW_GROUP + TXT_NF_NC_S_COLOR_KEY, data ) ) {
txt_nf_nc_s_color_.setNamedColor( data.toString() );
}
// bkg f c s
bkg_f_c_s_color_ = DEFAULT_BKG_F_C_S_COLOR;
if( stt.read( VIEW_GROUP + BKG_F_C_S_COLOR_KEY, data ) ) {
bkg_f_c_s_color_.setNamedColor( data.toString() );
}
// txt f c s
txt_f_c_s_color_ = DEFAULT_TXT_F_C_S_COLOR;
if( stt.read( VIEW_GROUP + TXT_F_C_S_COLOR_KEY, data ) ) {
txt_f_c_s_color_.setNamedColor( data.toString() );
}
// bkg nf c s
bkg_nf_c_s_color_ = DEFAULT_BKG_NF_C_S_COLOR;
if( stt.read( VIEW_GROUP + BKG_NF_C_S_COLOR_KEY, data ) ) {
bkg_nf_c_s_color_.setNamedColor( data.toString() );
}
// txt nf c s
txt_nf_c_s_color_ = DEFAULT_TXT_NF_C_S_COLOR;
if( stt.read( VIEW_GROUP + TXT_NF_C_S_COLOR_KEY, data ) ) {
txt_nf_c_s_color_.setNamedColor( data.toString() );
}
// bkg f c ns
bkg_f_c_ns_color_ = DEFAULT_BKG_F_C_NS_COLOR;
if( stt.read( VIEW_GROUP + BKG_F_C_NS_COLOR_KEY, data ) ) {
bkg_f_c_ns_color_.setNamedColor( data.toString() );
}
// txt f c ns
txt_f_c_ns_color_ = DEFAULT_TXT_F_C_NS_COLOR;
if( stt.read( VIEW_GROUP + TXT_F_C_NS_COLOR_KEY, data ) ) {
txt_f_c_ns_color_.setNamedColor( data.toString() );
}
// bkg nf c ns
bkg_nf_c_ns_color_ = DEFAULT_BKG_NF_C_NS_COLOR;
if( stt.read( VIEW_GROUP + BKG_NF_C_NS_COLOR_KEY, data ) ) {
bkg_nf_c_ns_color_.setNamedColor( data.toString() );
}
// txt nf c ns
txt_nf_c_ns_color_ = DEFAULT_TXT_NF_C_NS_COLOR;
if( stt.read( VIEW_GROUP + TXT_NF_C_NS_COLOR_KEY, data ) ) {
txt_nf_c_ns_color_.setNamedColor( data.toString() );
}
}
void DataWidget::valueChanged(QtProperty *property, const QVariant &value) {
if(ignore_change) return;
map<QtVariantProperty*, paramWrapper>::iterator it;
map<QtVariantProperty*, paramWrapper*>::iterator it3;
double dValue;
float fValue;
long lValue;
int iValue;
bool bValue;
string sValue;
DataItem *item;
//DataItem *item2;
if(property == showAllProperty) {
std::vector<DataInfo> infoList;
std::vector<DataInfo>::iterator it;
bool newShowAll = value.toBool();
assert(newShowAll != showAll);
dataBroker->unregisterAsyncReceiver(this, "*", "*");
dataBroker->unregisterTimedReceiver(this, "*", "*", "_REALTIME_");
changeMutex.lock();
addMutex.lock();
listMutex.lock();
changeList.clear();
addList.clear();
//map<unsigned long, paramWrapper>::iterator foo;
map<QtVariantProperty*, paramWrapper*>::iterator bar;
for(bar = guiToWrapper.begin(); bar != guiToWrapper.end(); ++bar) {
pDialog->removeGenericProperty(bar->first);
}
paramList.clear();
guiToWrapper.clear();
listMutex.unlock();
addMutex.unlock();
changeMutex.unlock();
showAll = newShowAll;
infoList = dataBroker->getDataList();
for(it=infoList.begin(); it!=infoList.end(); ++it) {
if(newShowAll || it->flags & data_broker::DATA_PACKAGE_WRITE_FLAG) {
addParam(*it);
dataBroker->registerTimedReceiver(this, it->groupName, it->dataName,
"_REALTIME_", 250);
//dataBroker->registerAsyncReceiver(this, it->groupName, it->dataName);
}
}
return;
}
it3 = guiToWrapper.find((QtVariantProperty*)property);
if(it3 != guiToWrapper.end()) {
int idx = 0;
std::vector<QtVariantProperty*>::iterator it2;
for(it2 = it3->second->guiElements.begin();
it2 != it3->second->guiElements.end() && *it2 != property;
++it2, ++idx) /* do nothing */ ;
item = &it3->second->dataPackage[idx];
//item2 = ¶mList[it->second.info.dataId].dataPackage[idx];
switch(item->type) {
case data_broker::DOUBLE_TYPE:
dValue = value.toDouble();
if(dValue != item->d) {
item->d = dValue;
//item2->d = dValue;
}
break;
case data_broker::FLOAT_TYPE:
fValue = value.toFloat();
if(fValue != item->f) {
item->f = fValue;
//item2->f = fValue;
}
break;
case data_broker::LONG_TYPE:
lValue = value.toLongLong();
if(lValue != item->l) {
item->l = lValue;
//item2->l = lValue;
}
break;
case data_broker::INT_TYPE:
iValue = value.toInt();
if(iValue != item->i) {
item->i = iValue;
//item2->i = iValue;
}
break;
case data_broker::BOOL_TYPE:
bValue = value.toBool();
if(bValue != item->b) {
item->b = bValue;
//item2->b = iValue;
}
break;
case data_broker::STRING_TYPE:
sValue = value.toString().toStdString();
if(sValue != item->s) {
item->s = sValue;
//item2->s = sValue;
}
break;
case data_broker::UNDEFINED_TYPE:
break;
// don't supply a default case so that the compiler might warn
// us if we forget to handle a new enum value.
}
dataBroker->pushData(it3->second->info.dataId,
it3->second->dataPackage);
}
}
bool ParameterEdit::setDocument(const QDomDocument & doc)
{
QDomElement root = doc.documentElement();
if(root.tagName() != "report")
{
QMessageBox::critical(this, tr("Not a Valid Report"),
tr("The report definition does not appear to be a valid report."
"\n\nThe root node is not 'report'."));
return false;
}
_list->show();
_new->hide();
_delete->hide();
for(QDomNode n = root.firstChild(); !n.isNull(); n = n.nextSibling())
{
if(n.nodeName() == "parameter")
{
QDomElement elemSource = n.toElement();
ORParameter param;
param.name = elemSource.attribute("name");
if(param.name.isEmpty())
continue;
param.type = elemSource.attribute("type");
param.defaultValue = elemSource.attribute("default");
param.active = (elemSource.attribute("active") == "true");
param.listtype = elemSource.attribute("listtype");
QList<QPair<QString,QString> > pairs;
if(param.listtype.isEmpty())
param.description = elemSource.text();
else
{
QDomNodeList section = elemSource.childNodes();
for(int nodeCounter = 0; nodeCounter < section.count(); nodeCounter++)
{
QDomElement elemThis = section.item(nodeCounter).toElement();
if(elemThis.tagName() == "description")
param.description = elemThis.text();
else if(elemThis.tagName() == "query")
param.query = elemThis.text();
else if(elemThis.tagName() == "item")
param.values.append(qMakePair(elemThis.attribute("value"), elemThis.text()));
else
qDebug("While parsing parameter encountered an unknown element: %s",(const char*)elemThis.tagName().toLatin1().data());
}
}
QVariant defaultVar;
if(!param.defaultValue.isEmpty())
defaultVar = QVariant(param.defaultValue);
if("integer" == param.type)
defaultVar = defaultVar.toInt();
else if("double" == param.type)
defaultVar = defaultVar.toDouble();
else if("bool" == param.type)
defaultVar = QVariant(defaultVar.toBool());
else
defaultVar = defaultVar.toString();
updateParam(param.name, defaultVar, param.active);
QList<QPair<QString, QString> > list;
if("static" == param.listtype)
list = param.values;
else if("dynamic" == param.listtype && !param.query.isEmpty())
{
QSqlQuery qry(param.query);
while(qry.next())
list.append(qMakePair(qry.value(0).toString(), qry.value(1).toString()));
}
if(!list.isEmpty())
_lists.insert(param.name, list);
}
}
if(_lists.isEmpty())
return false; // no defined parameters
else
return true;
}
/*!
* Initialisation du module
*
*/
void CSensorView::init(CApplication *application)
{
CModule::init(application);
setGUI(&m_ihm); // indique à la classe de base l'IHM
// Gère les actions sur clic droit sur le panel graphique du module
m_ihm.setContextMenuPolicy(Qt::CustomContextMenu);
connect(&m_ihm, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(onRightClicGUI(QPoint)));
// Restore la taille de la fenêtre
QVariant val;
val = m_application->m_eeprom->read(getName(), "geometry", QRect(50, 50, 150, 150));
m_ihm.setGeometry(val.toRect());
// Restore le fait que la fenêtre est visible ou non
val = m_application->m_eeprom->read(getName(), "visible", QVariant(true));
if (val.toBool()) { m_ihm.show(); }
else { m_ihm.hide(); }
// Restore le niveau d'affichage
val = m_application->m_eeprom->read(getName(), "niveau_trace", QVariant(MSG_TOUS));
setNiveauTrace(val.toUInt());
// Restore la couleur de fond
val = m_application->m_eeprom->read(getName(), "background_color", QVariant(DEFAULT_MODULE_COLOR));
setBackgroundColor(val.value<QColor>());
//récupération des signaux déjà placés sur la vue
val=m_application->m_eeprom->read(getName(),"signalsPlacement",QStringList());
QStringList listePointsWidget_=val.toStringList();
val=m_application->m_eeprom->read(getName(),"signalsAdded",QStringList());
listeStringSignalsAdded=val.toStringList();
int minSize = 0;
minSize=qMin(listePointsWidget_.size(), listeStringSignalsAdded.size());
int ind;
if(minSize>0)
{
QString unStringPoint, temp, xString, yString;
QStringList ListXY;
double xFromString, yFromString;
for(ind=0;ind<minSize;ind++)
{
unStringPoint=listePointsWidget_.at(ind);
ListXY=unStringPoint.split('x');
if (ListXY.size()>=2){
temp=ListXY.at(0);
xString=temp.remove(QChar('('), Qt::CaseInsensitive);
xFromString=xString.toInt();
temp=ListXY.at(1);
yString=temp.remove(QChar(')'), Qt::CaseInsensitive);
yFromString=yString.toInt();
listePointsSignalsAdded << QPoint(xFromString,yFromString);
}
}
}
if (minSize>0)
for(ind=0;ind<minSize;ind++)
{
//listeAddedSignals << new viewWidget(listeStringSignalsAdded.at(ind),listePointsSignalsAdded.at(ind));
addWidget(listeStringSignalsAdded.at(ind),listePointsSignalsAdded.at(ind));
}
m_ihm.ui.listWidget->setAcceptDrops(false);
m_ihm.ui.listWidget->setDragEnabled(false);
m_ihm.ui.viewWidget->setAcceptDrops(false);
m_ihm.ui.viewWidget->setDragEnabled(false);
isLocked=m_ihm.ui.pb_lockGUI->isChecked();
connect(m_ihm.ui.pb_lockGUI,SIGNAL(toggled(bool)),this,SLOT(lock(bool)));
connect(m_ihm.ui.viewWidget,SIGNAL(addWidget(QString,QPoint)),this,SLOT(addWidget(QString,QPoint)));
connect(m_ihm.ui.listWidget,SIGNAL(refreshList(QString)),this,SLOT(removeWidget(QString)));
refreshListeVariables();
connect(&m_timer_lecture_variables, SIGNAL(timeout()), this, SLOT(refreshValeursVariables()));
//m_timer_lecture_variables.start(PERIODE_ECHANTILLONNAGE_VARIABLES);
connect(m_ihm.ui.pb_play,SIGNAL(toggled(bool)),this,SLOT(start(bool)));
connect(m_ihm.ui.pb_filtering_nothing, SIGNAL(clicked()),this,SLOT(uncheckAllSignals()));
connect(m_ihm.ui.pb_filtering_actuator, SIGNAL(clicked()),this,SLOT(refreshListeVariables()));
connect(m_ihm.ui.pb_filtering_ana, SIGNAL(clicked()),this,SLOT(refreshListeVariables()));
connect(m_ihm.ui.pb_filtering_computed, SIGNAL(clicked()),this,SLOT(refreshListeVariables()));
connect(m_ihm.ui.pb_filtering_tor, SIGNAL(clicked()),this,SLOT(refreshListeVariables()));
}
// write QSettings values
bool OptionsModel::setData(const QModelIndex & index, const QVariant & value, int role)
{
bool successful = true; /* set to false on parse error */
if(role == Qt::EditRole)
{
QSettings settings;
switch(index.row())
{
case StartAtStartup:
successful = GUIUtil::SetStartOnSystemStartup(value.toBool());
break;
case MinimizeToTray:
fMinimizeToTray = value.toBool();
settings.setValue("fMinimizeToTray", fMinimizeToTray);
break;
case MapPortUPnP: // core option - can be changed on-the-fly
settings.setValue("fUseUPnP", value.toBool());
MapPort(value.toBool());
break;
case MinimizeOnClose:
fMinimizeOnClose = value.toBool();
settings.setValue("fMinimizeOnClose", fMinimizeOnClose);
break;
// default proxy
case ProxyUse:
if (settings.value("fUseProxy") != value) {
settings.setValue("fUseProxy", value.toBool());
setRestartRequired(true);
}
break;
case ProxyIP: {
// contains current IP at index 0 and current port at index 1
QStringList strlIpPort = settings.value("addrProxy").toString().split(":", QString::SkipEmptyParts);
// if that key doesn't exist or has a changed IP
if (!settings.contains("addrProxy") || strlIpPort.at(0) != value.toString()) {
// construct new value from new IP and current port
QString strNewValue = value.toString() + ":" + strlIpPort.at(1);
settings.setValue("addrProxy", strNewValue);
setRestartRequired(true);
}
}
break;
case ProxyPort: {
// contains current IP at index 0 and current port at index 1
QStringList strlIpPort = settings.value("addrProxy").toString().split(":", QString::SkipEmptyParts);
// if that key doesn't exist or has a changed port
if (!settings.contains("addrProxy") || strlIpPort.at(1) != value.toString()) {
// construct new value from current IP and new port
QString strNewValue = strlIpPort.at(0) + ":" + value.toString();
settings.setValue("addrProxy", strNewValue);
setRestartRequired(true);
}
}
break;
#ifdef ENABLE_WALLET
case SpendZeroConfChange:
if (settings.value("bSpendZeroConfChange") != value) {
settings.setValue("bSpendZeroConfChange", value);
setRestartRequired(true);
}
break;
#endif
case DisplayUnit:
setDisplayUnit(value);
break;
case ThirdPartyTxUrls:
if (strThirdPartyTxUrls != value.toString()) {
strThirdPartyTxUrls = value.toString();
settings.setValue("strThirdPartyTxUrls", strThirdPartyTxUrls);
setRestartRequired(true);
}
break;
case Digits:
if (settings.value("digits") != value) {
settings.setValue("digits", value);
setRestartRequired(true);
}
break;
case Theme:
if (settings.value("theme") != value) {
settings.setValue("theme", value);
setRestartRequired(true);
}
break;
case Language:
if (settings.value("language") != value) {
settings.setValue("language", value);
setRestartRequired(true);
}
break;
case DarksendRounds:
nDarksendRounds = value.toInt();
settings.setValue("nDarksendRounds", nDarksendRounds);
emit darksendRoundsChanged(nDarksendRounds);
break;
case AnonymizeDarkcoinAmount:
nAnonymizeDarkcoinAmount = value.toInt();
settings.setValue("nAnonymizeDarkcoinAmount", nAnonymizeDarkcoinAmount);
emit anonymizeDarkcoinAmountChanged(nAnonymizeDarkcoinAmount);
break;
case CoinControlFeatures:
fCoinControlFeatures = value.toBool();
settings.setValue("fCoinControlFeatures", fCoinControlFeatures);
emit coinControlFeaturesChanged(fCoinControlFeatures);
break;
case DatabaseCache:
if (settings.value("nDatabaseCache") != value) {
settings.setValue("nDatabaseCache", value);
setRestartRequired(true);
}
break;
case ThreadsScriptVerif:
if (settings.value("nThreadsScriptVerif") != value) {
settings.setValue("nThreadsScriptVerif", value);
setRestartRequired(true);
}
break;
case Listen:
if (settings.value("fListen") != value) {
settings.setValue("fListen", value);
setRestartRequired(true);
}
break;
default:
break;
}
}
emit dataChanged(index, index);
return successful;
}
bool QgsComposerAttributeTableV2::getTableContents( QgsComposerTableContents &contents )
{
contents.clear();
if (( mSource == QgsComposerAttributeTableV2::AtlasFeature || mSource == QgsComposerAttributeTableV2::RelationChildren )
&& !mComposition->atlasComposition().enabled() )
{
//source mode requires atlas, but atlas disabled
return false;
}
QgsVectorLayer* layer = sourceLayer();
if ( !layer )
{
//no source layer
return false;
}
//prepare filter expression
QScopedPointer<QgsExpression> filterExpression;
bool activeFilter = false;
if ( mFilterFeatures && !mFeatureFilter.isEmpty() )
{
filterExpression.reset( new QgsExpression( mFeatureFilter ) );
if ( !filterExpression->hasParserError() )
{
activeFilter = true;
}
}
QgsRectangle selectionRect;
if ( mComposerMap && mShowOnlyVisibleFeatures )
{
selectionRect = *mComposerMap->currentMapExtent();
if ( layer && mComposition->mapSettings().hasCrsTransformEnabled() )
{
//transform back to layer CRS
QgsCoordinateTransform coordTransform( layer->crs(), mComposition->mapSettings().destinationCrs() );
try
{
selectionRect = coordTransform.transformBoundingBox( selectionRect, QgsCoordinateTransform::ReverseTransform );
}
catch ( QgsCsException &cse )
{
Q_UNUSED( cse );
return false;
}
}
}
QgsFeatureRequest req;
if ( mSource == QgsComposerAttributeTableV2::RelationChildren )
{
QgsRelation relation = QgsProject::instance()->relationManager()->relation( mRelationId );
QgsFeature* atlasFeature = mComposition->atlasComposition().currentFeature();
if ( atlasFeature )
{
req = relation.getRelatedFeaturesRequest( *atlasFeature );
}
else
{
//no atlas feature, so empty table
return true;
}
}
if ( !selectionRect.isEmpty() )
req.setFilterRect( selectionRect );
req.setFlags( mShowOnlyVisibleFeatures ? QgsFeatureRequest::ExactIntersect : QgsFeatureRequest::NoFlags );
if ( mSource == QgsComposerAttributeTableV2::AtlasFeature
&& mComposition->atlasComposition().enabled() )
{
//source mode is current atlas feature
QgsFeature* atlasFeature = mComposition->atlasComposition().currentFeature();
if ( atlasFeature )
{
req.setFilterFid( atlasFeature->id() );
}
else
{
//no atlas feature, so empty table
return true;
}
}
QgsFeature f;
int counter = 0;
QgsFeatureIterator fit = layer->getFeatures( req );
while ( fit.nextFeature( f ) && counter < mMaximumNumberOfFeatures )
{
//check feature against filter
if ( activeFilter && !filterExpression.isNull() )
{
QVariant result = filterExpression->evaluate( &f, layer->pendingFields() );
// skip this feature if the filter evaluation is false
if ( !result.toBool() )
{
continue;
}
}
//check against atlas feature intersection
if ( mFilterToAtlasIntersection )
{
if ( !f.geometry() || ! mComposition->atlasComposition().enabled() )
{
continue;
}
QgsFeature* atlasFeature = mComposition->atlasComposition().currentFeature();
if ( !atlasFeature || !atlasFeature->geometry() ||
!f.geometry()->intersects( atlasFeature->geometry() ) )
{
//feature falls outside current atlas feature
continue;
}
}
QgsComposerTableRow currentRow;
QList<QgsComposerTableColumn*>::const_iterator columnIt = mColumns.constBegin();
for ( ; columnIt != mColumns.constEnd(); ++columnIt )
{
int idx = layer->fieldNameIndex(( *columnIt )->attribute() );
if ( idx != -1 )
{
currentRow << f.attributes()[idx];
}
else
{
// Lets assume it's an expression
QgsExpression* expression = new QgsExpression(( *columnIt )->attribute() );
expression->setCurrentRowNumber( counter + 1 );
expression->prepare( layer->pendingFields() );
QVariant value = expression->evaluate( f );
currentRow << value;
}
}
if ( !mShowUniqueRowsOnly || !contentsContainsRow( contents, currentRow ) )
{
contents << currentRow;
++counter;
}
}
//sort the list, starting with the last attribute
QgsComposerAttributeTableCompareV2 c;
QList< QPair<int, bool> > sortColumns = sortAttributes();
for ( int i = sortColumns.size() - 1; i >= 0; --i )
{
c.setSortColumn( sortColumns.at( i ).first );
c.setAscending( sortColumns.at( i ).second );
qStableSort( contents.begin(), contents.end(), c );
}
recalculateTableSize();
return true;
}
bool JSON_Model::setData(QModelIndex const& index, QVariant const& value, int role)
{
if (!index.isValid())
{
return false;
}
auto* ti = (Tree_Item*)index.internalPointer();
if (!ti || !ti->m_json)
{
return false;
}
bool modified = false;
auto* json = ti->m_json;
if (role == Qt::DisplayRole || role == Qt::EditRole)
{
if (index.column() == 1)
{
if (json->IsBool())
{
json->SetBool(value.toBool());
modified = true;
}
else if (json->IsInt())
{
json->SetInt(value.toInt());
modified = true;
}
else if (json->IsUint())
{
json->SetUint(value.toUInt());
modified = true;
}
else if (json->IsInt64())
{
json->SetInt64(value.toLongLong());
modified = true;
}
else if (json->IsUint64())
{
json->SetUint64(value.toULongLong());
modified = true;
}
else if (json->IsDouble() || json->IsNumber())
{
json->SetDouble(value.toDouble());
modified = true;
}
else if (json->IsString())
{
json->SetString(value.toString().toLatin1().data(), m_document->GetAllocator());
modified = true;
}
}
}
if (modified)
{
emit dataChanged(createIndex(index.row(), 0, index.internalPointer()), createIndex(index.row(), columnCount(), index.internalPointer()));
}
return modified;
}
void InputWidget::setShowStyleButtons(const QVariant &v)
{
ui.showStyleButton->setVisible(v.toBool());
}
void InputWidget::setEnablePerChatHistory(const QVariant &v)
{
_perChatHistory = v.toBool();
}
void InputWidget::setEnableEmacsMode(const QVariant &v)
{
ui.inputEdit->setEmacsMode(v.toBool());
}
void InputWidget::setShowNickSelector(const QVariant &v)
{
ui.ownNick->setVisible(v.toBool());
}
void InputWidget::setEnableSpellCheck(const QVariant &v)
{
ui.inputEdit->setSpellCheckEnabled(v.toBool());
}
void TestItem::setData(const QVariant & value, int role){
switch(role) {
case DurationRole:
setDuration(value.toDouble());
break;
case ChecksumRole:
setChecksum(value.toString());
break;
case DependsRole:
setDepends(value.toString());
break;
case TestNameRole:
setTestname(value.toString());
break;
case RequiresRole:
setRequires(value.toString());
break;
case DescriptionRole:
setDescription(value.toString());
break;
case CommandRole:
setCommand(value.toString());
break;
case EnvironRole:
setEnviron(value.toString());
break;
case PluginRole:
setPlugin(value.toString());
break;
case TypeRole:
setType(value.toString());
break;
case UserRole:
setUser(value.toString());
break;
case ViaRole:
setVia(value.toString());
break;
case GroupRole:
setGroup(value.toString());
break;
case CheckRole:
setCheck(value.toBool());
break;
case ObjectPathRole:
setObjectpath(value.toString());
break;
case RunstatusRole:
setRunstatus(value.toInt());
break;
case ElapsedtimeRole:
setElapsedtime(value.toInt());
break;
case GroupstatusRole:
setGroupstatus(value.toInt());
break;
case ParentNameRole:
//setGroupstatus(value.toStringList()));
break;
case ParentIdRole:
//setGroupstatus(value.toStringList());
break;
case DepthRole:
setDepth(value.toInt());
break;
case BranchRole:
setBranch(value.toBool());
break;
case IOLogRole:
setIo_log(value.toString());
break;
case CommentsRole:
setComments(value.toString());
break;
case OutcomeRole:
setOutcome(value.toString());
break;
case RerunRole:
setRerun(value.toBool());
break;
}
}
//! [2]
void replyFinished(QNetworkReply *reply) {
QVariant fromCache = reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute);
qDebug() << "page from cache?" << fromCache.toBool();
}
void TestRunner::overridePreference(const QString& name, const QVariant& value)
{
QWebSettings* settings = m_topLoadingFrame->page()->settings();
if (name == "WebKitJavaScriptEnabled")
settings->setAttribute(QWebSettings::JavascriptEnabled, value.toBool());
else if (name == "WebKitTabToLinksPreferenceKey")
settings->setAttribute(QWebSettings::LinksIncludedInFocusChain, value.toBool());
else if (name == "WebKitOfflineWebApplicationCacheEnabled")
settings->setAttribute(QWebSettings::OfflineWebApplicationCacheEnabled, value.toBool());
else if (name == "WebKitDefaultFontSize")
settings->setFontSize(QWebSettings::DefaultFontSize, value.toInt());
else if (name == "WebKitUsesPageCachePreferenceKey")
QWebSettings::setMaximumPagesInCache(value.toInt());
else if (name == "WebKitEnableCaretBrowsing")
setCaretBrowsingEnabled(value.toBool());
else if (name == "WebKitPluginsEnabled")
settings->setAttribute(QWebSettings::PluginsEnabled, value.toBool());
else if (name == "WebKitWebGLEnabled")
settings->setAttribute(QWebSettings::WebGLEnabled, value.toBool());
else if (name == "WebKitCSSRegionsEnabled")
settings->setAttribute(QWebSettings::CSSRegionsEnabled, value.toBool());
else if (name == "WebKitCSSGridLayoutEnabled")
settings->setAttribute(QWebSettings::CSSGridLayoutEnabled, value.toBool());
else if (name == "WebKitHyperlinkAuditingEnabled")
settings->setAttribute(QWebSettings::HyperlinkAuditingEnabled, value.toBool());
else if (name == "WebKitAcceleratedCompositingEnabled")
settings->setAttribute(QWebSettings::AcceleratedCompositingEnabled, value.toBool());
else if (name == "WebKitDisplayImagesKey")
settings->setAttribute(QWebSettings::AutoLoadImages, value.toBool());
else
printf("ERROR: TestRunner::overridePreference() does not support the '%s' preference\n",
name.toLatin1().data());
}
void InputWidget::setScrollBarsEnabled(const QVariant &v)
{
ui.inputEdit->setScrollBarsEnabled(v.toBool());
}
bool DomConvenience::variantToElement(const QVariant& v, QDomElement& e)
{
bool ok = true;
clearAttributes(e);
switch (v.type())
{
case QVariant::String:
e.setTagName("string");
e.setAttribute("value", v.toString().utf8());
break;
case QVariant::CString:
e.setTagName("string");
e.setAttribute("value", v.toCString());
break;
case QVariant::Int:
e.setTagName("int");
e.setAttribute("value", v.toInt());
break;
case QVariant::UInt:
e.setTagName("uint");
e.setAttribute("value", v.toUInt());
break;
case QVariant::Double:
e.setTagName("double");
e.setAttribute("value", v.toDouble());
break;
case QVariant::Bool:
e.setTagName("bool");
e.setAttribute("value", boolString(v.toBool()));
break;
case QVariant::Color:
{
e.setTagName("color");
QColor color = v.toColor();
e.setAttribute("red", color.red());
e.setAttribute("green", color.green());
e.setAttribute("blue", color.blue());
}
break;
case QVariant::Pen:
{
e.setTagName("pen");
QPen pen = v.toPen();
e.setAttribute("red", pen.color().red());
e.setAttribute("green", pen.color().green());
e.setAttribute("blue", pen.color().blue());
e.setAttribute("style", pen.style());
e.setAttribute("cap", pen.capStyle());
e.setAttribute("join", pen.joinStyle());
}
break;
case QVariant::Brush:
{
e.setTagName("brush");
QBrush brush = v.toBrush();
e.setAttribute("red", brush.color().red());
e.setAttribute("green", brush.color().green());
e.setAttribute("blue", brush.color().blue());
e.setAttribute("style", brush.style());
}
break;
case QVariant::Point:
{
e.setTagName("point");
QPoint point = v.toPoint();
e.setAttribute("x", point.x());
e.setAttribute("y", point.y());
}
break;
case QVariant::Rect:
{
e.setTagName("rect");
QRect rect = v.toRect();
e.setAttribute("x", rect.x());
e.setAttribute("y", rect.y());
e.setAttribute("width", rect.width());
e.setAttribute("height", rect.height());
}
break;
case QVariant::Size:
{
e.setTagName("size");
QSize qsize = v.toSize();
e.setAttribute("width", qsize.width());
e.setAttribute("height", qsize.height());
}
break;
case QVariant::Font:
{
e.setTagName("font");
QFont f(v.toFont());
e.setAttribute("family", f.family());
e.setAttribute("pointsize", f.pointSize());
e.setAttribute("bold", boolString(f.bold()));
e.setAttribute("italic", boolString(f.italic()));
e.setAttribute("underline", boolString(f.underline()));
e.setAttribute("strikeout", boolString(f.strikeOut()));
}
break;
case QVariant::SizePolicy:
{
e.setTagName("sizepolicy");
QSizePolicy sp(v.toSizePolicy());
e.setAttribute("hsizetype", sp.horData());
e.setAttribute("vsizetype", sp.verData());
#if (QT_VERSION >= 300)
e.setAttribute("horstretch", sp.horStretch());
e.setAttribute("verstretch", sp.verStretch());
#endif
}
break;
case QVariant::Cursor:
e.setTagName("cursor");
e.setAttribute("shape", v.toCursor().shape());
break;
case QVariant::StringList:
{
e.setTagName("stringlist");
uint j;
QDomNode n;
QDomNodeList stringNodeList = e.elementsByTagName("string");
QDomElement stringElem;
QStringList stringList = v.toStringList();
QStringList::Iterator it = stringList.begin();
for (j = 0;
((j < stringNodeList.length()) && (it != stringList.end()));
j++)
{
// get the current string element
stringElem = stringNodeList.item(j).toElement();
// set it to the current string
variantToElement(QVariant(*it), stringElem);
// iterate to the next string
++it;
}
// more nodes in previous stringlist then current, remove excess nodes
if (stringNodeList.count() > stringList.count())
{
while (j < stringNodeList.count())
e.removeChild(stringNodeList.item(j).toElement());
}
else if (j <stringList.count())
{
while (it != stringList.end())
{
// create a new element
stringElem = m_doc.createElement("string");
// set it to the currentstring
variantToElement(QVariant(*it), stringElem);
// append it to the current element
e.appendChild(stringElem);
// iterate to the next string
++it;
}
}
}
break;
#if QT_VERSION >= 300
case QVariant::KeySequence:
e.setTagName("key");
e.setAttribute("sequence", (QString)v.toKeySequence());
break;
#endif
case QVariant::ByteArray: // this is only for [u]int64_t
{
e.setTagName("uint64");
QByteArray ba = v.toByteArray();
// make sure this only handles [u]int64_t's
if (ba.size() != sizeof(uint64_t))
{
qWarning("Don't know how to persist variant of type: %s (%d) (size=%d)!",
v.typeName(), v.type(), ba.size());
ok = false;
break;
}
// convert the data back into a uint64_t
uint64_t num = *(uint64_t*)ba.data();
QChar buff[33];
QChar* p = &buff[32];
const char* digitSet = "0123456789abcdef";
int len = 0;
// construct the string
do
{
*--p = digitSet[((int)(num%16))];
num = num >> 4; // divide by 16
len++;
} while ( num );
// store it in a QString
QString storage;
storage.setUnicode(p, len);
// set the value
e.setAttribute("value", storage);
}
break;
#if 0
case QVariant::List:
case QVaraint::Map:
#endif
default:
qWarning("Don't know how to persist variant of type: %s (%d)!",
v.typeName(), v.type());
ok = false;
break;
}
return ok;
}
void InputWidget::setLineWrapEnabled(const QVariant &v)
{
ui.inputEdit->setLineWrapEnabled(v.toBool());
}
void CellListAdapter::setData(Record<CSMWorld::Cell>& record,
const QVariant& value, int subRowIndex, int subColIndex) const
{
CSMWorld::Cell cell = record.get();
bool isInterior = (cell.mData.mFlags & ESM::Cell::Interior) != 0;
bool behaveLikeExterior = (cell.mData.mFlags & ESM::Cell::QuasiEx) != 0;
bool interiorWater = (cell.mData.mFlags & ESM::Cell::HasWater) != 0;
switch (subColIndex)
{
case 0:
{
if (value.toBool())
cell.mData.mFlags |= ESM::Cell::Interior;
else
cell.mData.mFlags &= ~ESM::Cell::Interior;
break;
}
case 1:
{
if (isInterior && !behaveLikeExterior)
cell.mAmbi.mAmbient = static_cast<int32_t>(value.toInt());
else
return; // return without saving
break;
}
case 2:
{
if (isInterior && !behaveLikeExterior)
cell.mAmbi.mSunlight = static_cast<int32_t>(value.toInt());
else
return; // return without saving
break;
}
case 3:
{
if (isInterior && !behaveLikeExterior)
cell.mAmbi.mFog = static_cast<int32_t>(value.toInt());
else
return; // return without saving
break;
}
case 4:
{
if (isInterior && !behaveLikeExterior)
cell.mAmbi.mFogDensity = value.toFloat();
else
return; // return without saving
break;
}
case 5:
{
if (isInterior && !behaveLikeExterior && interiorWater)
cell.mWater = value.toFloat();
else
return; // return without saving
break;
}
case 6:
{
if (!isInterior)
cell.mMapColor = value.toInt();
else
return; // return without saving
break;
}
#if 0
// redundant since this flag is shown in the main table as "Interior Sky"
// keep here for documenting the logic based on vanilla
case 7:
{
if (isInterior)
{
if (value.toBool())
cell.mData.mFlags |= ESM::Cell::QuasiEx;
else
cell.mData.mFlags &= ~ESM::Cell::QuasiEx;
}
else
return; // return without saving
break;
}
#endif
default: throw std::runtime_error("Cell subcolumn index out of range");
}
record.setModified (cell);
}
void InputWidget::setMultiLineEnabled(const QVariant &v)
{
ui.inputEdit->setMode(v.toBool() ? MultiLineEdit::MultiLine : MultiLineEdit::SingleLine);
}
void MACDDialog::setGUI (Entity *settings)
{
_settings = settings;
// MACD page
QWidget *w = new QWidget;
QFormLayout *form = new QFormLayout;
w->setLayout(form);
// input
QVariant *set = _settings->get(QString("input"));
BarType bt;
_input = new QComboBox;
_input->addItems(bt.list());
_input->setCurrentIndex(_input->findText(set->toString(), Qt::MatchExactly));
connect(_input, SIGNAL(currentIndexChanged(int)), this, SLOT(modified()));
form->addRow(tr("Input"), _input);
// color
set = _settings->get(QString("macdColor"));
_macdColor = new ColorButton(this, QColor(set->toString()));
connect(_macdColor, SIGNAL(valueChanged(QColor)), this, SLOT(modified()));
form->addRow(tr("Color"), _macdColor);
// fast period
set = _settings->get(QString("fast"));
_fast = new QSpinBox;
_fast->setRange(1, 999999);
_fast->setValue(set->toInt());
connect(_fast, SIGNAL(valueChanged(const QString &)), this, SLOT(modified()));
form->addRow(tr("Fast Period"), _fast);
// slow period
set = _settings->get(QString("slow"));
_slow = new QSpinBox;
_slow->setRange(1, 999999);
_slow->setValue(set->toInt());
connect(_slow, SIGNAL(valueChanged(const QString &)), this, SLOT(modified()));
form->addRow(tr("Slow Period"), _slow);
// ma fast type
set = _settings->get(QString("fastMA"));
MAType mat;
_fastMA = new QComboBox;
_fastMA->addItems(mat.list());
_fastMA->setCurrentIndex(_fastMA->findText(set->toString(), Qt::MatchExactly));
connect(_fastMA, SIGNAL(currentIndexChanged(int)), this, SLOT(modified()));
form->addRow(tr("Fast MA"), _fastMA);
// ma slow type
set = _settings->get(QString("slowMA"));
_slowMA = new QComboBox;
_slowMA->addItems(mat.list());
_slowMA->setCurrentIndex(_slowMA->findText(set->toString(), Qt::MatchExactly));
connect(_slowMA, SIGNAL(currentIndexChanged(int)), this, SLOT(modified()));
form->addRow(tr("Slow MA"), _slowMA);
// line style
set = _settings->get(QString("macdStyle"));
CurveLineType clt;
_macdStyle = new QComboBox;
_macdStyle->addItems(clt.list());
_macdStyle->setCurrentIndex(_macdStyle->findText(set->toString(), Qt::MatchExactly));
connect(_macdStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(modified()));
form->addRow(tr("Style"), _macdStyle);
// width
set = _settings->get(QString("macdWidth"));
_macdWidth = new QSpinBox;
_macdWidth->setRange(1, 99);
_macdWidth->setValue(set->toInt());
connect(_macdWidth, SIGNAL(valueChanged(const QString &)), this, SLOT(modified()));
form->addRow(tr("Width"), _macdWidth);
// show
set = _settings->get(QString("macdShow"));
_macdShow = new QCheckBox;
_macdShow->setChecked(set->toBool());
connect(_macdShow, SIGNAL(toggled(bool)), this, SLOT(modified()));
form->addRow(tr("Show"), _macdShow);
_tabs->addTab(w, QString("MACD"));
// SIGNAL page
w = new QWidget;
form = new QFormLayout;
w->setLayout(form);
// style
set = _settings->get(QString("signalStyle"));
_signalStyle = new QComboBox;
_signalStyle->addItems(clt.list());
_signalStyle->setCurrentIndex(_signalStyle->findText(set->toString(), Qt::MatchExactly));
connect(_signalStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(modified()));
form->addRow(tr("Style"), _signalStyle);
// width
set = _settings->get(QString("signalWidth"));
_signalWidth = new QSpinBox;
_signalWidth->setRange(1, 99);
_signalWidth->setValue(set->toInt());
connect(_signalWidth, SIGNAL(valueChanged(const QString &)), this, SLOT(modified()));
form->addRow(tr("Width"), _signalWidth);
// color
set = _settings->get(QString("signalColor"));
_signalColor = new ColorButton(this, QColor(set->toString()));
connect(_signalColor, SIGNAL(valueChanged(QColor)), this, SLOT(modified()));
form->addRow(tr("Color"), _signalColor);
// ma type
set = _settings->get(QString("signalMA"));
_signalMA = new QComboBox;
_signalMA->addItems(mat.list());
_signalMA->setCurrentIndex(_fastMA->findText(set->toString(), Qt::MatchExactly));
connect(_signalMA, SIGNAL(currentIndexChanged(int)), this, SLOT(modified()));
form->addRow(tr("MA"), _signalMA);
// period
set = _settings->get(QString("signalPeriod"));
_signalPeriod = new QSpinBox;
_signalPeriod->setRange(1, 999999);
_signalPeriod->setValue(set->toInt());
connect(_signalPeriod, SIGNAL(valueChanged(const QString &)), this, SLOT(modified()));
form->addRow(tr("Period"), _signalPeriod);
// show
set = _settings->get(QString("signalShow"));
_signalShow = new QCheckBox;
_signalShow->setChecked(set->toBool());
connect(_signalShow, SIGNAL(toggled(bool)), this, SLOT(modified()));
form->addRow(tr("Show"), _signalShow);
_tabs->addTab(w, tr("Signal"));
// HIST page
w = new QWidget;
form = new QFormLayout;
w->setLayout(form);
// color
set = _settings->get(QString("histColor"));
_histColor = new ColorButton(this, QColor(set->toString()));
connect(_histColor, SIGNAL(valueChanged(QColor)), this, SLOT(modified()));
form->addRow(tr("Color"), _histColor);
// show
set = _settings->get(QString("histShow"));
_histShow = new QCheckBox;
_histShow->setChecked(set->toBool());
connect(_histShow, SIGNAL(toggled(bool)), this, SLOT(modified()));
form->addRow(tr("Show"), _histShow);
_tabs->addTab(w, tr("Histogram"));
}
QDomElement MaiaObject::toXml(QVariant arg)
{
//dummy document
QDomDocument doc;
//value element, we need this in each case
QDomElement tagValue = doc.createElement("value");
switch(arg.type()) {
case QVariant::String: {
QDomElement tagString = doc.createElement("string");
QDomText textString = doc.createTextNode(arg.toString());
tagValue.appendChild(tagString);
tagString.appendChild(textString);
return tagValue;
} case QVariant::Int: {
QDomElement tagInt = doc.createElement("int");
QDomText textInt = doc.createTextNode(QString::number(arg.toInt()));
tagValue.appendChild(tagInt);
tagInt.appendChild(textInt);
return tagValue;
} case QVariant::Double: {
QDomElement tagDouble = doc.createElement("double");
QDomText textDouble = doc.createTextNode(QString::number(arg.toDouble()));
tagValue.appendChild(tagDouble);
tagDouble.appendChild(textDouble);
return tagValue;
} case QVariant::Bool: {
QString textValue = arg.toBool() ? "1" : "0";
QDomElement tag = doc.createElement("boolean");
QDomText text = doc.createTextNode(textValue);
tagValue.appendChild(tag);
tag.appendChild(text);
return tagValue;
} case QVariant::ByteArray: {
QString textValue = arg.toByteArray().toBase64();
QDomElement tag = doc.createElement("base64");
QDomText text = doc.createTextNode(textValue);
tagValue.appendChild(tag);
tag.appendChild(text);
return tagValue;
} case QVariant::DateTime: {
QString textValue = arg.toDateTime().toString("yyyyMMddThh:mm:ss");
QDomElement tag = doc.createElement("datetime.iso8601");
QDomText text = doc.createTextNode(textValue);
tagValue.appendChild(tag);
tag.appendChild(text);
return tagValue;
} case QVariant::List: {
QDomElement tagArray = doc.createElement("array");
QDomElement tagData = doc.createElement("data");
tagArray.appendChild(tagData);
tagValue.appendChild(tagArray);
const QList<QVariant> args = arg.toList();
for(int i = 0; i < args.size(); ++i) {
tagData.appendChild(toXml(args.at(i)));
}
return tagValue;
} case QVariant::Map: {
QDomElement tagStruct = doc.createElement("struct");
QDomElement member;
QDomElement name;
tagValue.appendChild(tagStruct);
QMap<QString, QVariant> map = arg.toMap();
QMapIterator<QString, QVariant> i(map);
while(i.hasNext()) {
i.next();
member = doc.createElement("member");
name = doc.createElement("name");
// (key) -> name -> member -> struct
tagStruct.appendChild(member);
member.appendChild(name);
name.appendChild(doc.createTextNode(i.key()));
// add variables by recursion
member.appendChild(toXml(i.value()));
}
return tagValue;
} default:
qDebug() << "Failed to marshal unknown variant type: " << arg.type() << endl;
}
return QDomElement(); //QString::null;
}
bool OptionsModel::setData(const QModelIndex & index, const QVariant & value, int role)
{
bool successful = true; /* set to false on parse error */
if(role == Qt::EditRole)
{
QSettings settings;
switch(index.row())
{
case StartAtStartup:
successful = GUIUtil::SetStartOnSystemStartup(value.toBool());
break;
case MinimizeToTray:
fMinimizeToTray = value.toBool();
settings.setValue("fMinimizeToTray", fMinimizeToTray);
break;
case MapPortUPnP:
fUseUPnP = value.toBool();
settings.setValue("fUseUPnP", fUseUPnP);
MapPort();
break;
case MinimizeOnClose:
fMinimizeOnClose = value.toBool();
settings.setValue("fMinimizeOnClose", fMinimizeOnClose);
break;
case ProxyUse:
settings.setValue("fUseProxy", value.toBool());
ApplyProxySettings();
break;
case ProxyIP: {
proxyType proxy;
proxy.first = CService("127.0.0.1", 9050);
GetProxy(NET_IPV4, proxy);
CNetAddr addr(value.toString().toStdString());
proxy.first.SetIP(addr);
settings.setValue("addrProxy", proxy.first.ToStringIPPort().c_str());
successful = ApplyProxySettings();
}
break;
case ProxyPort: {
proxyType proxy;
proxy.first = CService("127.0.0.1", 9050);
GetProxy(NET_IPV4, proxy);
proxy.first.SetPort(value.toInt());
settings.setValue("addrProxy", proxy.first.ToStringIPPort().c_str());
successful = ApplyProxySettings();
}
break;
case ProxySocksVersion: {
proxyType proxy;
proxy.second = 5;
GetProxy(NET_IPV4, proxy);
proxy.second = value.toInt();
settings.setValue("nSocksVersion", proxy.second);
successful = ApplyProxySettings();
}
break;
case Fee:
nTransactionFee = value.toLongLong();
settings.setValue("nTransactionFee", (qint64) nTransactionFee);
emit transactionFeeChanged(nTransactionFee);
break;
case ReserveBalance:
nReserveBalance = value.toLongLong();
settings.setValue("nReserveBalance", (qint64) nReserveBalance);
emit reserveBalanceChanged(nReserveBalance);
break;
case DisplayUnit:
nDisplayUnit = value.toInt();
settings.setValue("nDisplayUnit", nDisplayUnit);
emit displayUnitChanged(nDisplayUnit);
break;
case DisplayAddresses:
bDisplayAddresses = value.toBool();
settings.setValue("bDisplayAddresses", bDisplayAddresses);
break;
case DetachDatabases: {
bool fDetachDB = value.toBool();
bitdb.SetDetach(fDetachDB);
settings.setValue("detachDB", fDetachDB);
}
break;
case Language:
settings.setValue("language", value);
break;
case CoinControlFeatures: {
fCoinControlFeatures = value.toBool();
settings.setValue("fCoinControlFeatures", fCoinControlFeatures);
emit coinControlFeaturesChanged(fCoinControlFeatures);
}
break;
default:
break;
}
}
emit dataChanged(index, index);
return successful;
}
void VtkVisTabWidget::buildProportiesDialog(VtkVisPipelineItem* item)
{
auto* layout =
static_cast<QFormLayout*>(this->scrollAreaWidgetContents->layout());
while (layout->count())
delete layout->takeAt(0)->widget();
QMap<QString, QVariant>* propMap = nullptr;
QMap<QString, QList<QVariant>>* propVecMap = nullptr;
VtkAlgorithmProperties* algProps = item->getVtkProperties();
if (algProps == nullptr)
WARN("VtkAlgorithmProperties null!")
// Retrieve algorithm properties
if (item->compositeFilter())
{
propMap = item->compositeFilter()->GetAlgorithmUserProperties();
propVecMap =
item->compositeFilter()->GetAlgorithmUserVectorProperties();
}
else
{
if (algProps)
{
propMap = algProps->GetAlgorithmUserProperties();
propVecMap = algProps->GetAlgorithmUserVectorProperties();
}
}
// Select appropriate GUI element and set connect for each property
if (propMap)
{
QMapIterator<QString, QVariant> i(*propMap);
while (i.hasNext())
{
i.next();
QString key = i.key();
QVariant value = i.value();
VtkAlgorithmPropertyLineEdit* lineEdit;
VtkAlgorithmPropertyCheckbox* checkbox;
switch (value.type())
{
case QVariant::Double:
lineEdit =
new VtkAlgorithmPropertyLineEdit(QString::number(
value.toDouble()),
key, QVariant::Double,
algProps);
connect(lineEdit, SIGNAL(editingFinished()), this,
SIGNAL(requestViewUpdate()));
layout->addRow(key, lineEdit);
break;
case QVariant::Int:
lineEdit =
new VtkAlgorithmPropertyLineEdit(QString::number(
value.toInt()),
key, QVariant::Int,
algProps);
connect(lineEdit, SIGNAL(editingFinished()), this,
SIGNAL(requestViewUpdate()));
layout->addRow(key, lineEdit);
break;
case QVariant::Bool:
checkbox = new VtkAlgorithmPropertyCheckbox(
value.toBool(), key, algProps);
connect(checkbox, SIGNAL(stateChanged(int)), this,
SIGNAL(requestViewUpdate()));
layout->addRow(key, checkbox);
break;
default:
break;
}
}
}
if (propVecMap)
{
QMapIterator<QString, QList<QVariant> > i(*propVecMap);
while (i.hasNext())
{
i.next();
QString key = i.key();
QList<QVariant> values = i.value();
VtkAlgorithmPropertyVectorEdit* vectorEdit;
if (!values.empty())
{
QList<QString> valuesAsString;
foreach (QVariant variant, values)
valuesAsString.push_back(variant.toString());
vectorEdit = new VtkAlgorithmPropertyVectorEdit(valuesAsString, key,
values.front().type(),
algProps);
connect(vectorEdit, SIGNAL(editingFinished()), this,
SIGNAL(requestViewUpdate()));
layout->addRow(key, vectorEdit);
}
}
}
}
// write QSettings values
bool OptionsModel::setData(const QModelIndex & index, const QVariant & value, int role)
{
bool successful = true; /* set to false on parse error */
bool changeSendShaper = false;
bool changeReceiveShaper = false;
if(role == Qt::EditRole)
{
QSettings settings;
switch(index.row())
{
case StartAtStartup:
successful = GUIUtil::SetStartOnSystemStartup(value.toBool());
break;
case MinimizeToTray:
fMinimizeToTray = value.toBool();
settings.setValue("fMinimizeToTray", fMinimizeToTray);
break;
case MapPortUPnP: // core option - can be changed on-the-fly
settings.setValue("fUseUPnP", value.toBool());
MapPort(value.toBool());
break;
case MinimizeOnClose:
fMinimizeOnClose = value.toBool();
settings.setValue("fMinimizeOnClose", fMinimizeOnClose);
break;
// default proxy
case ProxyUse:
if (settings.value("fUseProxy") != value) {
settings.setValue("fUseProxy", value.toBool());
setRestartRequired(true);
}
break;
case ProxyIP: {
// contains current IP at index 0 and current port at index 1
QStringList strlIpPort = settings.value("addrProxy").toString().split(":", QString::SkipEmptyParts);
// if that key doesn't exist or has a changed IP
if (!settings.contains("addrProxy") || strlIpPort.at(0) != value.toString()) {
// construct new value from new IP and current port
QString strNewValue = value.toString() + ":" + strlIpPort.at(1);
settings.setValue("addrProxy", strNewValue);
setRestartRequired(true);
}
}
break;
case ProxyPort: {
// contains current IP at index 0 and current port at index 1
QStringList strlIpPort = settings.value("addrProxy").toString().split(":", QString::SkipEmptyParts);
// if that key doesn't exist or has a changed port
if (!settings.contains("addrProxy") || strlIpPort.at(1) != value.toString()) {
// construct new value from current IP and new port
QString strNewValue = strlIpPort.at(0) + ":" + value.toString();
settings.setValue("addrProxy", strNewValue);
setRestartRequired(true);
}
}
break;
#ifdef ENABLE_WALLET
case SpendZeroConfChange:
if (settings.value("bSpendZeroConfChange") != value) {
settings.setValue("bSpendZeroConfChange", value);
setRestartRequired(true);
}
break;
#endif
case DisplayUnit:
setDisplayUnit(value);
break;
case ThirdPartyTxUrls:
if (strThirdPartyTxUrls != value.toString()) {
strThirdPartyTxUrls = value.toString();
settings.setValue("strThirdPartyTxUrls", strThirdPartyTxUrls);
setRestartRequired(true);
}
break;
case Language:
if (settings.value("language") != value) {
settings.setValue("language", value);
setRestartRequired(true);
}
break;
case CoinControlFeatures:
fCoinControlFeatures = value.toBool();
settings.setValue("fCoinControlFeatures", fCoinControlFeatures);
Q_EMIT coinControlFeaturesChanged(fCoinControlFeatures);
break;
case DatabaseCache:
if (settings.value("nDatabaseCache") != value) {
settings.setValue("nDatabaseCache", value);
setRestartRequired(true);
}
break;
case ThreadsScriptVerif:
if (settings.value("nThreadsScriptVerif") != value) {
settings.setValue("nThreadsScriptVerif", value);
setRestartRequired(true);
}
break;
case Listen:
if (settings.value("fListen") != value) {
settings.setValue("fListen", value);
setRestartRequired(true);
}
break;
case UseReceiveShaping:
if (settings.value("fUseReceiveShaping") != value) {
settings.setValue("fUseReceiveShaping",value);
changeReceiveShaper = true;
}
break;
case UseSendShaping:
if (settings.value("fUseSendShaping") != value) {
settings.setValue("fUseSendShaping",value);
changeSendShaper = true;
}
break;
case ReceiveBurst:
if (settings.value("nReceiveBurst") != value) {
settings.setValue("nReceiveBurst",value);
changeReceiveShaper = true;
}
break;
case ReceiveAve:
if (settings.value("nReceiveAve") != value) {
settings.setValue("nReceiveAve",value);
changeReceiveShaper = true;
}
break;
case SendBurst:
if (settings.value("nSendBurst") != value) {
settings.setValue("nSendBurst",value);
changeSendShaper = true;
}
break;
case SendAve:
if (settings.value("nSendAve") != value) {
settings.setValue("nSendAve",value);
changeSendShaper = true;
}
break;
default:
break;
}
if (changeReceiveShaper) {
extern CLeakyBucket receiveShaper;
if (settings.value("fUseReceiveShaping").toBool()) {
int ave = 1000 * settings.value("nReceiveAve").toInt();
int burst = ave * settings.value("nReceiveBurst").toInt() / 100;
receiveShaper.set(burst, ave);
}
else
{
receiveShaper.disable();
}
}
if (changeSendShaper) {
extern CLeakyBucket sendShaper;
if (settings.value("fUseSendShaping").toBool()) {
int ave = 1000 * settings.value("nSendAve").toInt();
int burst = ave * settings.value("nSendBurst").toInt() / 100;
sendShaper.set(burst, ave);
}
else
{
sendShaper.disable();
}
}
}
Q_EMIT dataChanged(index, index);
return successful;
}
bool OptionsModel::setData(const QModelIndex & index, const QVariant & value, int role)
{
bool successful = true; /* set to false on parse error */
if(role == Qt::EditRole)
{
QSettings settings;
switch(index.row())
{
case StartAtStartup:
successful = GUIUtil::SetStartOnSystemStartup(value.toBool());
break;
case MinimizeToTray:
fMinimizeToTray = value.toBool();
settings.setValue("fMinimizeToTray", fMinimizeToTray);
break;
case MapPortUPnP:
settings.setValue("fUseUPnP", value.toBool());
MapPort(value.toBool());
break;
case MinimizeOnClose:
fMinimizeOnClose = value.toBool();
settings.setValue("fMinimizeOnClose", fMinimizeOnClose);
break;
case ProxyUse:
settings.setValue("fUseProxy", value.toBool());
ApplyProxySettings();
break;
case ProxyIP: {
proxyType proxy;
proxy = CService("127.0.0.1", 9050);
GetProxy(NET_IPV4, proxy);
CNetAddr addr(value.toString().toStdString());
proxy.SetIP(addr);
settings.setValue("addrProxy", proxy.ToStringIPPort().c_str());
successful = ApplyProxySettings();
}
break;
case ProxyPort: {
proxyType proxy;
proxy = CService("127.0.0.1", 9050);
GetProxy(NET_IPV4, proxy);
proxy.SetPort(value.toInt());
settings.setValue("addrProxy", proxy.ToStringIPPort().c_str());
successful = ApplyProxySettings();
}
break;
case Fee:
nTransactionFee = value.toLongLong();
settings.setValue("nTransactionFee", (qint64) nTransactionFee);
emit transactionFeeChanged(nTransactionFee);
break;
case ReserveBalance:
nReserveBalance = value.toLongLong();
settings.setValue("nReserveBalance", (qint64) nReserveBalance);
emit reserveBalanceChanged(nReserveBalance);
break;
case DisplayUnit:
nDisplayUnit = value.toInt();
settings.setValue("nDisplayUnit", nDisplayUnit);
emit displayUnitChanged(nDisplayUnit);
break;
case Language:
settings.setValue("language", value);
break;
case CoinControlFeatures: {
fCoinControlFeatures = value.toBool();
settings.setValue("fCoinControlFeatures", fCoinControlFeatures);
emit coinControlFeaturesChanged(fCoinControlFeatures);
}
break;
case MinimizeCoinAge:
fMinimizeCoinAge = value.toBool();
settings.setValue("fMinimizeCoinAge", fMinimizeCoinAge);
break;
case UseBlackTheme:
fUseBlackTheme = value.toBool();
settings.setValue("fUseBlackTheme", fUseBlackTheme);
break;
case DarksendRounds:
nDarksendRounds = value.toInt();
settings.setValue("nDarksendRounds", nDarksendRounds);
emit darksendRoundsChanged(nDarksendRounds);
break;
case anonymizeSlingAmount:
nAnonymizeSlingAmount = value.toInt();
settings.setValue("nAnonymizeSlingAmount", nAnonymizeSlingAmount);
emit anonymizeSlingAmountChanged(nAnonymizeSlingAmount);
break;
#ifdef USE_NATIVE_I2P
case I2PUseI2POnly:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
settings.setValue("useI2POnly", value.toBool());
break;
}
case I2PSAMHost:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
settings.setValue("samhost", value.toString());
break;
}
case I2PSAMPort:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
settings.setValue("samport", value.toString());
break;
}
case I2PSessionName:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
settings.setValue("sessionName", value.toString());
break;
}
case I2PInboundQuantity:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pInboundQuantity = value.toInt();
settings.setValue(SAM_NAME_INBOUND_QUANTITY, i2pInboundQuantity);
break;
}
case I2PInboundLength:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pInboundLength = value.toInt();
settings.setValue(SAM_NAME_INBOUND_LENGTH, i2pInboundLength);
break;
}
case I2PInboundLengthVariance:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pInboundLengthVariance = value.toInt();
settings.setValue(SAM_NAME_INBOUND_LENGTHVARIANCE, i2pInboundLengthVariance);
break;
}
case I2PInboundBackupQuantity:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pInboundBackupQuantity = value.toInt();
settings.setValue(SAM_NAME_INBOUND_BACKUPQUANTITY, i2pInboundBackupQuantity);
break;
}
case I2PInboundAllowZeroHop:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pInboundAllowZeroHop = value.toBool();
settings.setValue(SAM_NAME_INBOUND_ALLOWZEROHOP, i2pInboundAllowZeroHop);
break;
}
case I2PInboundIPRestriction:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pInboundIPRestriction = value.toInt();
settings.setValue(SAM_NAME_INBOUND_IPRESTRICTION, i2pInboundIPRestriction);
break;
}
case I2POutboundQuantity:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pOutboundQuantity = value.toInt();
settings.setValue(SAM_NAME_OUTBOUND_QUANTITY, i2pOutboundQuantity);
break;
}
case I2POutboundLength:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pOutboundLength = value.toInt();
settings.setValue(SAM_NAME_OUTBOUND_LENGTH, i2pOutboundLength);
break;
}
case I2POutboundLengthVariance:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pOutboundLengthVariance = value.toInt();
settings.setValue(SAM_NAME_OUTBOUND_LENGTHVARIANCE, i2pOutboundLengthVariance);
break;
}
case I2POutboundBackupQuantity:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pOutboundBackupQuantity = value.toInt();
settings.setValue(SAM_NAME_OUTBOUND_BACKUPQUANTITY, i2pOutboundBackupQuantity);
break;
}
case I2POutboundAllowZeroHop:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pOutboundAllowZeroHop = value.toBool();
settings.setValue(SAM_NAME_OUTBOUND_ALLOWZEROHOP, i2pOutboundAllowZeroHop);
break;
}
case I2POutboundIPRestriction:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pOutboundIPRestriction = value.toInt();
settings.setValue(SAM_NAME_OUTBOUND_IPRESTRICTION, i2pOutboundIPRestriction);
break;
}
case I2POutboundPriority:
{
ScopeGroupHelper s(settings, I2P_OPTIONS_SECTION_NAME);
i2pOutboundPriority = value.toInt();
settings.setValue(SAM_NAME_OUTBOUND_PRIORITY, i2pOutboundPriority);
break;
}
#endif
default:
break;
}
}
emit dataChanged(index, index);
return successful;
}
bool OptionsModel::setData(const QModelIndex & index, const QVariant & value, int role)
{
bool successful = true; /* set to false on parse error */
if(role == Qt::EditRole)
{
QSettings settings;
switch(index.row())
{
case StartAtStartup:
successful = GUIUtil::SetStartOnSystemStartup(value.toBool());
break;
case MinimizeToTray:
fMinimizeToTray = value.toBool();
settings.setValue("fMinimizeToTray", fMinimizeToTray);
break;
case MapPortUPnP:
settings.setValue("fUseUPnP", value.toBool());
MapPort(value.toBool());
break;
case MinimizeOnClose:
fMinimizeOnClose = value.toBool();
settings.setValue("fMinimizeOnClose", fMinimizeOnClose);
break;
case ProxyUse:
settings.setValue("fUseProxy", value.toBool());
ApplyProxySettings();
break;
case ProxyIP: {
proxyType proxy;
proxy = CService("127.0.0.1", 9050);
GetProxy(NET_IPV4, proxy);
CNetAddr addr(value.toString().toStdString());
proxy.SetIP(addr);
settings.setValue("addrProxy", proxy.ToStringIPPort().c_str());
successful = ApplyProxySettings();
}
break;
case ProxyPort: {
proxyType proxy;
proxy = CService("127.0.0.1", 9050);
GetProxy(NET_IPV4, proxy);
proxy.SetPort(value.toInt());
settings.setValue("addrProxy", proxy.ToStringIPPort().c_str());
successful = ApplyProxySettings();
}
break;
case Fee:
nTransactionFee = value.toLongLong();
settings.setValue("nTransactionFee", (qint64) nTransactionFee);
emit transactionFeeChanged(nTransactionFee);
break;
case ReserveBalance:
nReserveBalance = value.toLongLong();
settings.setValue("nReserveBalance", (qint64) nReserveBalance);
emit reserveBalanceChanged(nReserveBalance);
break;
case DisplayUnit:
nDisplayUnit = value.toInt();
settings.setValue("nDisplayUnit", nDisplayUnit);
emit displayUnitChanged(nDisplayUnit);
break;
case Language:
settings.setValue("language", value);
break;
case CoinControlFeatures: {
fCoinControlFeatures = value.toBool();
settings.setValue("fCoinControlFeatures", fCoinControlFeatures);
emit coinControlFeaturesChanged(fCoinControlFeatures);
}
break;
case MinimizeCoinAge:
fMinimizeCoinAge = value.toBool();
settings.setValue("fMinimizeCoinAge", fMinimizeCoinAge);
break;
case UseBlackTheme:
fUseBlackTheme = value.toBool();
settings.setValue("fUseBlackTheme", fUseBlackTheme);
break;
case DarksendRounds:
nDarksendRounds = value.toInt();
settings.setValue("nDarksendRounds", nDarksendRounds);
emit darksendRoundsChanged(nDarksendRounds);
break;
case anonymizeDroidzAmount:
nAnonymizeDroidzAmount = value.toInt();
settings.setValue("nAnonymizeDroidzAmount", nAnonymizeDroidzAmount);
emit anonymizeDroidzAmountChanged(nAnonymizeDroidzAmount);
break;
default:
break;
}
}
emit dataChanged(index, index);
return successful;
}
int login2::set(ParameterList &pParams, QSplashScreen *pSplash)
{
_splash = pSplash;
QVariant param;
bool valid;
param = pParams.value("username", &valid);
if (valid)
{
_username->setText(param.toString());
_password->setFocus();
_captive = TRUE;
}
else
{
_username->setFocus();
_captive = FALSE;
}
param = pParams.value("password", &valid);
if (valid)
{
_password->setText(param.toString());
_captive = TRUE;
}
param = pParams.value("copyright", &valid);
if (valid)
_copyrightLit->setText(param.toString());
param = pParams.value("version", &valid);
if (valid)
_versionLit->setText(tr("Version ") + param.toString());
param = pParams.value("build", &valid);
if (valid)
_build->setText(param.toString());
param = pParams.value("evaluation", &valid);
if (valid)
_demoOption->setChecked(TRUE);
param = pParams.value("name", &valid);
if (valid)
_nameLit->setText(param.toString());
param = pParams.value("databaseURL", &valid);
if (valid)
_databaseURL = param.toString();
populateDatabaseInfo();
param = pParams.value("nonxTupleDB", &valid);
if (valid)
_nonxTupleDB = true;
param = pParams.value("multipleConnections", &valid);
if (valid)
_multipleConnections = true;
param = pParams.value("enhancedAuth", &valid);
if (valid)
_enhancedAuth = param.toBool();
param = pParams.value("requireSSL", &valid);
if (valid)
_requireSSL = param.toBool();
if(pParams.inList("login"))
sLogin();
return 0;
}
SetResponse freightBreakdown::set(const ParameterList& pParams)
{
XDialog::set(pParams);
QVariant param;
bool valid;
ParameterList params;
param = pParams.value("order_id", &valid);
if (valid)
{
_orderid = param.toInt();
params.append("order_id", _orderid);
}
param = pParams.value("cust_id", &valid);
if (valid)
params.append("cust_id", param.toInt());
param = pParams.value("shipto_id", &valid);
if (valid)
params.append("shipto_id", param.toInt());
param = pParams.value("orderdate", &valid);
if (valid)
params.append("orderdate", param.toDate());
param = pParams.value("shipvia", &valid);
if (valid)
params.append("shipvia", param.toString());
param = pParams.value("curr_id", &valid);
if (valid)
params.append("curr_id", param.toInt());
param = pParams.value("document_number", &valid);
if (valid)
_document->setText(param.toString());
param = pParams.value("order_type", &valid);
if (valid)
{
_ordertype = param.toString();
params.append("order_type", _ordertype);
if (_ordertype == "SO")
_header->setText(tr("Freight Breakdown for Sales Order:"));
else if (_ordertype == "QU")
_header->setText(tr("Freight Breakdown for Quote:"));
else
_header->setText(tr("Freight Breakdown for Return Auth.:"));
}
param = pParams.value("calcfreight", &valid);
if (valid)
{
_calcfreight = param.toBool();
if (_calcfreight == true)
_calculated->setChecked(true);
else
_manual->setChecked(true);
}
param = pParams.value("mode", &valid);
if (valid)
{
if(param.toString() == "view")
_mode = cView;
else
_mode = cEdit;
}
QString sql = "SELECT *,"
" 'weight' AS freightdata_weight_xtnumericrole,"
" 'salesprice' AS freightdata_price_xtnumericrole,"
" 'curr' AS freightdata_total_xtnumericrole,"
" 0 AS freightdata_total_xttotalrole "
"FROM freightDetail(<? value(\"order_type\") ?>,"
" <? value(\"order_id\") ?>,"
" <? value(\"cust_id\") ?>,"
" <? value(\"shipto_id\") ?>,"
" <? value(\"orderdate\") ?>,"
" <? value(\"shipvia\") ?>,"
" <? value(\"curr_id\") ?>);";
MetaSQLQuery mql(sql);
q = mql.toQuery(params);
_freight->populate(q);
if (q.lastError().type() != QSqlError::NoError)
{
systemError(this, q.lastError().databaseText(), __FILE__, __LINE__);
return UndefinedError;
}
return NoError;
}
static QCFType<CFPropertyListRef> macValue(const QVariant &value)
{
CFPropertyListRef result = 0;
switch (value.type()) {
case QVariant::ByteArray:
{
QByteArray ba = value.toByteArray();
result = CFDataCreate(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(ba.data()),
CFIndex(ba.size()));
}
break;
// should be same as below (look for LIST)
case QVariant::List:
case QVariant::StringList:
case QVariant::Polygon:
result = macList(value.toList());
break;
case QVariant::Map:
{
/*
QMap<QString, QVariant> is potentially a multimap,
whereas CFDictionary is a single-valued map. To allow
for multiple values with the same key, we store
multiple values in a CFArray. To avoid ambiguities,
we also wrap lists in a CFArray singleton.
*/
QMap<QString, QVariant> map = value.toMap();
QMap<QString, QVariant>::const_iterator i = map.constBegin();
int maxUniqueKeys = map.size();
int numUniqueKeys = 0;
QVarLengthArray<QCFType<CFPropertyListRef> > cfkeys(maxUniqueKeys);
QVarLengthArray<QCFType<CFPropertyListRef> > cfvalues(maxUniqueKeys);
while (i != map.constEnd()) {
const QString &key = i.key();
QList<QVariant> values;
do {
values << i.value();
++i;
} while (i != map.constEnd() && i.key() == key);
bool singleton = (values.count() == 1);
if (singleton) {
switch (values.constFirst().type()) {
// should be same as above (look for LIST)
case QVariant::List:
case QVariant::StringList:
case QVariant::Polygon:
singleton = false;
default:
;
}
}
cfkeys[numUniqueKeys] = QCFString::toCFStringRef(key);
cfvalues[numUniqueKeys] = singleton ? macValue(values.constFirst()) : macList(values);
++numUniqueKeys;
}
result = CFDictionaryCreate(kCFAllocatorDefault,
reinterpret_cast<const void **>(cfkeys.data()),
reinterpret_cast<const void **>(cfvalues.data()),
CFIndex(numUniqueKeys),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
break;
case QVariant::DateTime:
{
/*
CFDate, unlike QDateTime, doesn't store timezone information.
*/
QDateTime dt = value.toDateTime();
if (dt.timeSpec() == Qt::LocalTime) {
QDateTime reference;
reference.setTime_t((uint)kCFAbsoluteTimeIntervalSince1970);
result = CFDateCreate(kCFAllocatorDefault, CFAbsoluteTime(reference.secsTo(dt)));
} else {
goto string_case;
}
}
break;
case QVariant::Bool:
result = value.toBool() ? kCFBooleanTrue : kCFBooleanFalse;
break;
case QVariant::Int:
case QVariant::UInt:
{
int n = value.toInt();
result = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &n);
}
break;
case QVariant::Double:
{
double n = value.toDouble();
result = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &n);
}
break;
case QVariant::LongLong:
case QVariant::ULongLong:
{
qint64 n = value.toLongLong();
result = CFNumberCreate(0, kCFNumberLongLongType, &n);
}
break;
case QVariant::String:
string_case:
default:
result = QCFString::toCFStringRef(QSettingsPrivate::variantToString(value));
}
return result;
}
