QString QgsOracleConn::quotedValue( const QVariant &value, QVariant::Type type )
{
if ( value.isNull() )
return "NULL";
if ( type == QVariant::Invalid )
type = value.type();
if ( value.canConvert( type ) )
{
switch ( type )
{
case QVariant::Int:
case QVariant::LongLong:
case QVariant::Double:
return value.toString();
case QVariant::DateTime:
{
QDateTime datetime( value.toDateTime() );
if ( datetime.isValid() )
return QString( "TO_DATE('%1','YYYY-MM-DD HH24:MI:SS')" ).arg( datetime.toString( "yyyy-MM-dd hh:mm:ss" ) );
break;
}
case QVariant::Date:
{
QDate date( value.toDate() );
if ( date.isValid() )
return QString( "TO_DATE('%1','YYYY-MM-DD')" ).arg( date.toString( "yyyy-MM-dd" ) );
break;
}
case QVariant::Time:
{
QDateTime datetime( value.toDateTime() );
if ( datetime.isValid() )
return QString( "TO_DATE('%1','HH24:MI:SS')" ).arg( datetime.toString( "hh:mm:ss" ) );
break;
}
default:
break;
}
}
QString v = value.toString();
v.replace( "'", "''" );
v.replace( "\\\"", "\\\\\"" );
return v.prepend( "'" ).append( "'" );
}
mafMementoObject::mafMementoObject(const mafObject *obj, const QString code_location) : mafMemento(obj, code_location) {
mafMementoPropertyList *list = mementoPropertyList();
int i = 0;
const QMetaObject *meta = obj->metaObject();
int num = meta->propertyCount();
for ( ; i < num; ++i) {
mafMementoPropertyItem item;
const QMetaProperty qmp = meta->property(i);
QString propName = qmp.name();
QVariant value = obj->property(propName.toAscii());
if (value.canConvert(QVariant::List)) {
item.m_Multiplicity = value.toList().count();
} else if(value.canConvert(QVariant::Map)) {
item.m_Multiplicity = value.toMap().count();
} else if(value.canConvert(QVariant::Hash)) {
item.m_Multiplicity = value.toHash().count();
} else {
item.m_Multiplicity = 1;
}
item.m_Name = qmp.name();
item.m_Value = value;
list->append(item);
}
mafMementoPropertyItem itemTagList;
itemTagList.m_Multiplicity = obj->tagList()->count();
itemTagList.m_Name = "TagList";
itemTagList.m_Value = *obj->tagList();
list->append(itemTagList);
mafMementoPropertyItem itemDic;
itemDic.m_Multiplicity = obj->dictionary()->count();
itemDic.m_Name = "dictionary";
itemDic.m_Value = *(obj->dictionary());
list->append(itemDic);
}
DefaultDataForm::DefaultDataForm(const DataItem &item) :
m_widget(0),
m_isChanged(false),
m_incompleteWidgets(0),
m_buttonsBox(0),
m_hasSubitems(item.hasSubitems() || item.isAllowedModifySubitems())
{
DataLayout *dataLayout = 0;
QVBoxLayout *layout = 0;
setObjectName(item.name());
setWindowTitle(item.title());
if (item.isAllowedModifySubitems()) {
layout = new QVBoxLayout(this);
ModifiableWidget *w = new ModifiableWidget(item, this, this);
m_widget = w;
layout->addWidget(w);
if (!w->isExpandable()) {
QSpacerItem *spacer = new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
layout->addItem(spacer);
}
} else {
dataLayout = new DataLayout(item, this, item.property<quint16>("columns", 1), this);
QVariant spacing = item.property("horizontalSpacing");
if (spacing.canConvert(QVariant::Int))
dataLayout->setHorizontalSpacing(spacing.toInt());
spacing = item.property("verticalSpacing");
if (spacing.canConvert(QVariant::Int))
dataLayout->setVerticalSpacing(spacing.toInt());
m_widget = dataLayout;
if (item.hasSubitems())
dataLayout->addDataItems(item.subitems());
else
dataLayout->addDataItem(item);
if (!dataLayout->isExpandable())
dataLayout->addSpacer();
}
}
bool QAbstractDiagramGraphicsItem::changeProperty(const QString & name, const QVariant & value)
{
QDiagramMetaProperty metaProperty = m_metadata->property(m_metadata->indexOfProperty(name));
// Check if property is dynamic
if (!metaProperty.isValid()){
// Check if dynamic property has changed
if (m_dynamicProperties.value(name) != value){
m_dynamicProperties[name] = value;
itemPropertyHasChanged(name, value);
}
return false;
}
// Check if static property is read only
if (metaProperty.isReadOnly()){
// Property is read only
return false;
}
QVariant currentValue = m_properties.value(name);
if (currentValue != value){
if (name == "brush"){
m_brush = brush(value.toString());
} else if (name == "geometry"){
if (value.canConvert(QVariant::RectF)){
prepareGeometryChange();
setPos(value.toRectF().x(), value.toRectF().y());
} else if (value.canConvert(QVariant::Map)){
prepareGeometryChange();
setPos(value.toMap().value("x").toDouble(), value.toMap().value("y").toDouble());
}
m_properties[name] = value;
itemGeometryHasChanged(value);
} else {
m_properties[name] = value;
}
itemPropertyHasChanged(name, value);
}
return true;
}
void DbusAdapter::_phoneState(QDBusMessage msg) {
qDebug() << "Got phone call state dbus message:" << msg;
QList<QVariant> outArgs = msg.arguments();
QVariant state = outArgs.at(0);
if (state.canConvert(QVariant::String) && state.toString() == "State") {
qDebug() <<"Phone Call State";
QVariant argument = outArgs.at(1);
const QVariant v = qvariant_cast<QDBusVariant>(argument).variant();
if (v.canConvert(QVariant::String)) {
if (v.toString() == "active"){
emit phoneCallStart();
qDebug() << v.toString();
}
if (v.toString() == "disconnected"){
emit phoneCallEnd();
qDebug() << v.toString();
}
}
}else{
qDebug() <<"No State ";
}
}
bool TreeModel::isDuplicate(TreeItem *item, QString str)
{
QList<TreeItem*> items = item->childItems;
int count = items.count();
for(int n = 0; n < count; n++)
{
QVariant qv = items.at(n)->data(0);
if(qv.canConvert(QVariant::String)) {
if(qv.toString() == str)
return true;
}
}
return false;
}
void
LineStyleEdit::setValue(const QVariant &value, bool emitChange)
{
if (!value.canConvert(QVariant::Int))
return;
if ((value.toInt() > 5) || (value.toInt() < 0))
return;
m_edit->blockSignals(true);
m_edit->setCurrentIndex(value.toInt());
m_edit->blockSignals(false);
if (emitChange)
emit valueChanged(this);
}
inline KData::ContentType guessType(const QVariant & v) {
KData::ContentType t;
if (!v.isValid())
t = KData::Undefined;
else if (v.type() == QVariant::Bool)
t = KData::Boolean;
else if (v.type() == QVariant::String)
t = KData::Text;
else if (v.canConvert(QVariant::Double))
t = KData::Numeric;
else
t = KData::Object;
return t;
}
QString Hdd::filePath(const Plasma::DataEngine::Data &data)
{
QString label = data["File Path"].toString();
QVariant accessible = data["Accessible"];
if (accessible.isValid()) {
if (accessible.canConvert(QVariant::Bool)) {
if (!accessible.toBool()) {
label = i18nc("hard disk label (not mounted or accessible)",
"%1 (not accessible)", label);
}
}
}
return label;
}
bool JsonRpcServer::convertArgs(const QMetaMethod& meta_method,
const QVariantMap& args,
QVariantList& converted_args)
{
QList<QByteArray> param_types = meta_method.parameterTypes();
if (args.size() != param_types.size()) {
logError(QString("wrong number of arguments to method %1 -- "
"expected %2 arguments, but got %3")
.arg(QString(meta_method.methodSignature()))
.arg(meta_method.parameterCount())
.arg(args.size()));
return false;
}
for (int i = 0; i < param_types.size(); i++) {
QByteArray param_name = meta_method.parameterNames().at(i);
if (args.find(param_name) == args.end()) {
// no arg with param name found
return false;
}
const QVariant& arg = args.value(param_name);
if (!arg.isValid()) {
logError(QString("argument %1 of %2 to method %3 is invalid")
.arg(i + 1)
.arg(param_types.size())
.arg(QString(meta_method.methodSignature())));
return false;
}
QByteArray arg_type_name = arg.typeName();
QByteArray param_type_name = param_types.at(i);
QVariant::Type param_type = QVariant::nameToType(param_type_name);
QVariant copy = QVariant(arg);
if (copy.type() != param_type) {
if (copy.canConvert(param_type)) {
if (!copy.convert(param_type)) {
// qDebug() << "cannot convert" << arg_type_name
// << "to" << param_type_name;
return false;
}
}
}
converted_args << copy;
}
return true;
}
/*
* load board from xbasic config file using xBasicConfig
*/
void Hardware::loadBoards()
{
QSettings settings(publisherKey, xBasicGuiKey, this);
QVariant sv = settings.value(configFileKey);
if(sv.canConvert(QVariant::String))
xBasicCfgFile = sv.toString();
sv = settings.value(separatorKey);
if(sv.canConvert(QVariant::String))
xBasicSeparator = sv.toString();
if(xBasicConfig->loadBoards(xBasicCfgFile) == 0)
return;
/* get board types */
QStringList boards = xBasicConfig->getBoardNames();
ui->comboBoxBoard->clear();
for(int n = 0; n < boards.count(); n++) {
ui->comboBoxBoard->addItem(boards.at(n));
}
/* load first board info */
XBasicBoard *brd = xBasicConfig->getBoardData(ui->comboBoxBoard->itemText(0));
setDialogBoardInfo(brd);
}
void Properties::setupOptions()
{
QFrame *frame = new QFrame(this);
QHBoxLayout *hlayout = new QHBoxLayout();
QFormLayout *edlayout = new QFormLayout(this);
QGroupBox *editor = new QGroupBox(tr("Editor Settings"));
editor->setLayout(edlayout);
QFormLayout *otlayout = new QFormLayout(this);
QGroupBox *other = new QGroupBox(tr("Other Settings"));
other->setLayout(otlayout);
hlayout->addWidget(editor);
hlayout->addWidget(other);
frame->setLayout(hlayout);
tabWidget.addTab(frame,"General");
QSettings settings(publisherKey, PropellerIdeGuiKey,this);
QVariant enac = settings.value(enableAutoComplete,true);
QVariant enss = settings.value(enableSpinSuggest,true);
autoCompleteEnable.setChecked(enac.toBool());
edlayout->addRow(new QLabel(tr("Enable AutoComplete")), &autoCompleteEnable);
spinSuggestEnable.setChecked(enss.toBool());
edlayout->addRow(new QLabel(tr("Enable Code Suggestion")), &spinSuggestEnable);
#if ENABLE_PORT_BOARD_NAMES
portBoardNameEnable.setChecked(false);
portBoardNameEnable.setDisabled(true);
otlayout->addRow(new QLabel(tr("Enable Port Board Names")), &portBoardNameEnable);
#endif
QVariant tabsv = settings.value(tabSpacesKey,"4");
if(tabsv.canConvert(QVariant::String)) {
tabspaceLedit.setText(tabsv.toString());
}
else {
tabspaceLedit.setText("4");
}
edlayout->addRow(new QLabel(tr("Editor Tab Space Count")), &tabspaceLedit);
clearSettingsButton.setText("Clear Settings");
clearSettingsButton.setToolTip(tr("Clear Settings on Exit"));
connect(&clearSettingsButton,SIGNAL(clicked()), this, SLOT(cleanSettings()));
otlayout->addRow(new QLabel(tr("Clear Settings on Exit")), &clearSettingsButton);
fontButton.setText(tr("Set Editor Font"));
connect(&fontButton,SIGNAL(clicked()),this,SLOT(showFontDialog()));
edlayout->addRow(new QLabel(tr("Set Editor Font")), &fontButton);
}
void DropDownModelTest::testMoreIndex_MovieSortModels()
{
//GIVEN
QVariant dataModel;
MovieSortModels movieSortModels;
QString msg;
int countRow = movieSortModels.rowCount();
//WHEN
QModelIndex indx = movieSortModels.index(countRow, 0, QModelIndex());
dataModel = movieSortModels.data(indx, MovieSortModels :: SortingFieldRole);
//EXPECTED
//msg = QString("countRow - %1, indx.row() - %2").arg(countRow).arg(indx.row());
//QWARN (msg.toLocal8Bit().constData());
QCOMPARE(dataModel.canConvert(QVariant::Int), false);
}
void DropDownModelTest::testMoreIndex_TVCategoryModel()
{
//GIVEN
QVariant dataModel;
TVCategoryModel tvCategoryModel;
QString msg;
int countRow = tvCategoryModel.rowCount();
//WHEN
QModelIndex indx = tvCategoryModel.index(countRow, 0, QModelIndex());
dataModel = tvCategoryModel.data(indx, TVCategoryModel :: IdRole);
//EXPECTED
//msg = QString("countRow - %1, indx.row() - %2").arg(countRow).arg(indx.row());
//QWARN (msg.toLocal8Bit().constData());
QCOMPARE(dataModel.canConvert(QVariant::Int), false);
}
inline optional<Value> toValue(const QVariant& value) {
if (value.type() == QVariant::Bool) {
return { value.toBool() };
} else if (value.type() == QVariant::String) {
return { value.toString().toStdString() };
} else if (value.type() == QVariant::Color) {
return { value.value<QColor>().name().toStdString() };
} else if (value.type() == QVariant::Int) {
return { value.toInt() };
} else if (value.canConvert(QVariant::Double)) {
return { value.toFloat() };
} else {
return {};
}
}
void parseToProperties(const QByteArray &json, QObject *obj)
{
QVariantMap map = parse(json).toMap();
const QMetaObject *meta = obj->metaObject();
for (int i = 0, size = meta->propertyCount(); i < size; i++) {
QMetaProperty prop = meta->property(i);
QVariantMap::iterator it = map.find(prop.name());
if (it != map.end()) {
QVariant var = it.value();
if (var.canConvert(prop.type())) {
prop.write(obj, var);
}
}
}
}
bool DeviceListPrivate::parse( const QVariant& data )
{
if( !data.canConvert( QVariant::List ) )
return false;
QVariantList varList = data.toList();
QVariantList devList;
foreach( const QVariant & var, varList )
{
DevicePtr ptr( new Device( var, this ) );
m_devicesList.append( ptr );
QVariant v;
v.setValue<DevicePtr>( ptr );
devList.append( v );
}
void StringFieldDefinition::validate(const QVariant& v, StrictChecking strict) const
{
if (getAllowNull() && v.isValid() == false)
{
// the value is null, no problem.
}
else if (!getAllowNull() && v.isValid() == false)
{
_reportError(getName(), "Nulls are not allowed, but field was set to null.", strict);
}
else if (v.canConvert(QVariant::String) == false)
{
_reportError(getName(), "Could not convert string variant to string.", strict);
}
}
void MainWindow::updateUIFromOptions()
{
QSettings settings;
QVariant sem = settings.value("plugins/sem", false);
if (sem.canConvert(QVariant::Bool) && sem.toBool())
{
ui->tabBar->addTab("SEM");
}
else
{
if (ui->tabBar->count() >= 4)
ui->tabBar->removeTab(2);
}
}
void AddCalendarPage::calendarChanged(QOrganizerManager *manager, QOrganizerCollection& calendar)
{
m_manager = manager;
m_collection = calendar;
window()->setWindowTitle(!calendar.id().isNull() ? "Edit calendar" : "Add calendar");
#if defined(Q_WS_MAEMO_5)
// Maemo5 calendar features
QVariant calendarName = calendar.metaData("Name");
if (calendarName.canConvert(QVariant::String))
m_nameEdit->setText(calendarName.toString());
QVariant colorList = calendar.metaData("Available colors");
QStringList availableColors;
if (colorList.canConvert(QVariant::StringList))
availableColors = colorList.toStringList();
int index = 0;
foreach(QString color, availableColors) {
m_colorComboBox->addItem(color);
if (calendar.metaData("Color").toString() == color)
m_colorComboBox->setCurrentIndex(index);
++index;
}
bool parseObject(const QVariant &source, QObject *target)
{
if (!source.isValid() || !source.canConvert(QVariant::Map)) {
qDebug() << "[ObjectParser] Error: Invalid object... " << source.toByteArray();
return false;
}
const QVariantMap &map = source.toMap();
const QMetaObject *metaobject = target->metaObject();
QVariantMap::const_iterator it;
QVariantMap::const_iterator end = map.constEnd();
for (it = map.constBegin(); it != end; ++it) {
const int index = metaobject->indexOfProperty(it.key().toLatin1());
if (index < 0) {
continue;
}
const QMetaProperty metaproperty = metaobject->property(index);
const QVariant::Type type = metaproperty.type();
QVariant v = it.value();
if (v.canConvert(type)) {
v.convert(type);
metaproperty.write(target, v);
} else if (QString(QLatin1String("QVariant"))
.compare(QLatin1String(metaproperty.typeName())) == 0) {
metaproperty.write(target, v);
} else {
qDebug() << "[ObjectParser] Warning: unable to map variable" << it.key() << "of type"
<< v.type() << "to type" << metaproperty.type() << "!";
metaproperty.write(target, QVariant());
}
}
return true;
}
void TConfig::setValue(const QString & key, const QVariant & value)
{
QDomElement element = find(k->currentGroup, key);
if (!element.isNull()) {
if (value.canConvert(QVariant::StringList)) {
QStringList list = value.toStringList();
element.setAttribute("value", list.join(";"));
} else {
element.setAttribute("value", value.toString());
}
} else {
element = k->document.createElement(key);
if (value.canConvert(QVariant::StringList)) {
QStringList list = value.toStringList();
element.setAttribute("value", list.join(";"));
} else {
element.setAttribute("value", value.toString());
}
k->currentGroup.appendChild(element);
}
}
char AppSettings::getCsvSeparator (void)
{
QVariant var = m_Settings.value(SETTINGNAME_CSV_SEPARATOR);
if (var.canConvert(QVariant::Char))
{
char c = var.toChar().toAscii();
if (ExporterSinkCsv::isAllowedSeparator(c))
return c;
else
this->setCsvSeparator(ExporterSinkCsv::defaultSeparator());
}
return ExporterSinkCsv::defaultSeparator();
}
void setFontFamily(QFontComboBox* combo, const QVariant& value, const QFont& fallback)
{
QString family = ((value.type() == QVariant::Font) && (value.canConvert(QVariant::Font))) ? value.value<QFont>().family() : value.toString();
bool found = false;
if (family != "") {
for (int i = 0, n = combo->count(); i < n; ++i) {
if (combo->itemText(i) == family) {
combo->setCurrentIndex(i);
found = true;
break;
}
}
}
if (!found)
combo->setCurrentFont(fallback);
}
bool OptionsTreeModel::setData ( const QModelIndex & index, const QVariant & value, int role)
{
QString option = indexToOptionName(index);
if ((role != Qt::EditRole) || ((Section) index.column() != Value) || internalNode(option)) {
return false;
}
QVariant current = tree_->getOption(option);
QVariant newval = value;
if (!newval.canConvert(current.type())) {
qWarning() << "Sorry don't know how to do that!";
return false;
}
newval.convert(current.type());
tree_->setOption(option, newval);
return true;
}
int Configuration::getPreviewOption()
{
QVariant var = settings->value(PREVIEW_OPTION);
if (var.isValid() && var.canConvert(QVariant::Int))
{
return var.toInt();
} else {
if(isShowPreview_Old()){
setPreviewOption(MdCharmGlobal::WriteRead);
return MdCharmGlobal::WriteRead;
} else {
setPreviewOption(MdCharmGlobal::WriteMode);
return MdCharmGlobal::WriteMode;
}
}
}
uint AppSettings::getUnitSystem (void)
{
QVariant var = m_Settings.value(SETTINGNAME_UNITSYSTEM);
if (var.canConvert(QVariant::UInt))
{
bool bOk = false;
uint ui = var.toUInt(&bOk);
if (bOk && AppSettings::unitSystemValidate(ui))
return ui;
else
this->setUnitSystem(AppSettings::defaultUnitSystem());
}
return AppSettings::defaultUnitSystem();
}
int AppSettings::getKmlLineWidth (void)
{
QVariant var = m_Settings.value(SETTINGNAME_KML_LINEWIDTH);
if (var.canConvert(QVariant::Int))
{
int nVal = var.toInt();
QPair<int,int> bounds = ExporterSinkKml::lineWidthBounds();
if (nVal >= bounds.first && nVal <= bounds.second)
return nVal;
else
this->setKmlLineWidth(ExporterSinkKml::defaultLineWidth());
}
return ExporterSinkKml::defaultLineWidth();
}
quint8 AppSettings::getLastMeansOfTransport (void)
{
QVariant var = m_Settings.value(SETTINGNAME_LASTMEANSOFTRANSPORT);
if (var.canConvert(QVariant::Int))
{
bool bOk = false;
int i = var.toInt(&bOk);
if (bOk && GPSRFile::isValidMeansOfTransport((quint8)i))
return (quint8)i;
else
this->setLastMeansOfTransport(AppSettings::defaultMeansOfTransport());
}
return AppSettings::defaultMeansOfTransport();
}
uint AppSettings::getHorizSpeedUnit (void)
{
QVariant var = m_Settings.value(SETTINGNAME_HORIZSPEEDUNIT);
if (var.canConvert(QVariant::UInt))
{
bool bOk = false;
uint ui = var.toUInt(&bOk);
if (bOk && AppSettings::horizSpeedUnitValidate(ui))
return ui;
else
this->setHorizSpeedUnit(AppSettings::defaultHorizSpeedUnit());
}
return AppSettings::defaultHorizSpeedUnit();
}
