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.first().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.first()) : 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;
}
/*!
Sets the \a newValue for \a option and returns \c true on success; \c false
otherwise.
\note If the option's associated type is \c quint8 or \c quint16 and the
type of \a newValue is larger, the data will be truncated or conversation
will fail.
\table
\header
\li Key
\li Description
\row
\li \l QModbusServer::DiagnosticRegister
\li Sets the diagnostic register of the server in a device specific
encoding to \a newValue. The default value preset is \c 0x0000.
The bit values of the register need device specific documentation.
\row
\li \l QModbusServer::ExceptionStatusOffset
\li Sets the exception status byte offset of the server to
\a newValue which is the absolute offset address in the coils
(0x register). Modbus register table starting with \c 0x0000h.
The default value preset is \c 0x0000, using the exception
status coils similar to Modicon 984 CPUs (coils 1-8).
The function returns \c true if the coils register contains the
8 bits required for storing and retrieving the status coils,
otherwise \c false.
\row
\li \l QModbusServer::DeviceBusy
\li Sets a flag that signals that the server is engaged in
processing a long-duration program command. Valid values are
\c 0x0000 (not busy) and \c 0xffff (busy).
The default value preset is \c 0x0000.
\row
\li \l QModbusServer::AsciiInputDelimiter
\li The \a newValue becomes the end of message delimiter for future
Modbus ASCII messages. The default value preset is \c {\n}.
\row
\li \l QModbusServer::ListenOnlyMode
\li Ss the server's listen only state to \a newValue. If listen only
mode is set to \c true, messages are monitored but no response
will be sent. The default value preset is \c false.
\row
\li \l QModbusServer::ServerIdentifier
\li Sets the server's manufacturer identifier to \a newValue.
Possible values are in the range of \c 0x00 to 0xff.
The default value preset is \c 0x0a.
\row
\li \l QModbusServer::RunIndicatorStatus
\li Sets the servers' run indicator status to \a newValue. This
data is used as addendum by the \l QModbusPdu::ReportServerId
function code. Valid values are \c 0x00 (OFF) and \c 0xff (ON).
The default value preset is \c 0xff (ON).
\row
\li \l QModbusServer::AdditionalData
\li Sets the server's additional data to \a newValue. This data is
used as addendum by the \l QModbusPdu::ReportServerId function
code. The maximum data size cannot exceed 249 bytes to match
response message size restrictions.
The default value preset is \c {Qt Modbus Server}.
\row
\li \l QModbusServer::UserOption
\li Sets the value of a user option to \a newValue.
\note For user options, it is up to the developer to decide
which types to use and ensure that components use the correct
types when accessing and setting values.
\endtable
*/
bool QModbusServer::setValue(int option, const QVariant &newValue)
{
#define CHECK_INT_OR_UINT(val) \
do { \
if ((val.type() != QVariant::Int) && (val.type() != QVariant::UInt)) \
return false; \
} while (0)
Q_D(QModbusServer);
switch (option) {
case DiagnosticRegister:
CHECK_INT_OR_UINT(newValue);
d->m_serverOptions.insert(option, newValue);
return true;
case ExceptionStatusOffset: {
CHECK_INT_OR_UINT(newValue);
const quint16 tmp = newValue.value<quint16>();
QModbusDataUnit coils(QModbusDataUnit::Coils, tmp, 8);
if (!data(&coils))
return false;
d->m_serverOptions.insert(option, tmp);
return true;
}
case DeviceBusy: {
CHECK_INT_OR_UINT(newValue);
const quint16 tmp = newValue.value<quint16>();
if ((tmp != 0x0000) && (tmp != 0xffff))
return false;
d->m_serverOptions.insert(option, tmp);
return true;
}
case AsciiInputDelimiter: {
CHECK_INT_OR_UINT(newValue);
bool ok = false;
if (newValue.toUInt(&ok) > 0xff || !ok)
return false;
d->m_serverOptions.insert(option, newValue);
return true;
}
case ListenOnlyMode: {
if (newValue.type() != QVariant::Bool)
return false;
d->m_serverOptions.insert(option, newValue);
return true;
}
case ServerIdentifier:
CHECK_INT_OR_UINT(newValue);
d->m_serverOptions.insert(option, newValue);
return true;
case RunIndicatorStatus: {
CHECK_INT_OR_UINT(newValue);
const quint8 tmp = newValue.value<quint8>();
if ((tmp != 0x00) && (tmp != 0xff))
return false;
d->m_serverOptions.insert(option, tmp);
return true;
}
case AdditionalData: {
if (newValue.type() != QVariant::ByteArray)
return false;
const QByteArray additionalData = newValue.toByteArray();
if (additionalData.size() > 249)
return false;
d->m_serverOptions.insert(option, additionalData);
return true;
}
default:
break;
};
if (option < UserOption)
return false;
d->m_serverOptions.insert(option, newValue);
return true;
#undef CHECK_INT_OR_UINT
}
ExternalHelpWindow::ExternalHelpWindow(QWidget *parent)
: QMainWindow(parent)
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Help::Constants::ID_MODE_HELP);
const QVariant geometry = settings->value(QLatin1String("geometry"));
if (geometry.isValid())
restoreGeometry(geometry.toByteArray());
else
resize(640, 480);
settings->endGroup();
QAction *action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_I));
connect(action, SIGNAL(triggered()), this, SIGNAL(activateIndex()));
addAction(action);
action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_C));
connect(action, SIGNAL(triggered()), this, SIGNAL(activateContents()));
addAction(action);
action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Slash));
connect(action, SIGNAL(triggered()), this, SIGNAL(activateSearch()));
addAction(action);
action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_B));
connect(action, SIGNAL(triggered()), this, SIGNAL(activateBookmarks()));
addAction(action);
action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_O));
connect(action, SIGNAL(triggered()), this, SIGNAL(activateOpenPages()));
addAction(action);
CentralWidget *centralWidget = CentralWidget::instance();
action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Plus));
connect(action, SIGNAL(triggered()), centralWidget, SLOT(zoomIn()));
addAction(action);
action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Minus));
connect(action, SIGNAL(triggered()), centralWidget, SLOT(zoomOut()));
addAction(action);
action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
connect(action, SIGNAL(triggered()), this, SIGNAL(addBookmark()));
addAction(action);
action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_C));
connect(action, SIGNAL(triggered()), centralWidget, SLOT(copy()));
addAction(action);
action = new QAction(this);
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_P));
connect(action, SIGNAL(triggered()), centralWidget, SLOT(print()));
addAction(action);
action = new QAction(this);
action->setShortcut(QKeySequence::Back);
action->setEnabled(centralWidget->isBackwardAvailable());
connect(action, SIGNAL(triggered()), centralWidget, SLOT(backward()));
connect(centralWidget, SIGNAL(backwardAvailable(bool)), action,
SLOT(setEnabled(bool)));
action = new QAction(this);
action->setShortcut(QKeySequence::Forward);
action->setEnabled(centralWidget->isForwardAvailable());
connect(action, SIGNAL(triggered()), centralWidget, SLOT(forward()));
connect(centralWidget, SIGNAL(forwardAvailable(bool)), action,
SLOT(setEnabled(bool)));
QAction *reset = new QAction(this);
connect(reset, SIGNAL(triggered()), centralWidget, SLOT(resetZoom()));
addAction(reset);
QAction *ctrlTab = new QAction(this);
connect(ctrlTab, SIGNAL(triggered()), &OpenPagesManager::instance(),
SLOT(gotoPreviousPage()));
addAction(ctrlTab);
QAction *ctrlShiftTab = new QAction(this);
connect(ctrlShiftTab, SIGNAL(triggered()), &OpenPagesManager::instance(),
SLOT(gotoNextPage()));
addAction(ctrlShiftTab);
action = new QAction(QIcon(Core::Constants::ICON_TOGGLE_SIDEBAR),
tr("Show Sidebar"), this);
connect(action, SIGNAL(triggered()), this, SIGNAL(showHideSidebar()));
#ifdef Q_WS_MAC
reset->setShortcut(QKeySequence(Qt::ALT + Qt::Key_0));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_0));
ctrlTab->setShortcut(QKeySequence(Qt::ALT + Qt::Key_Tab));
ctrlShiftTab->setShortcut(QKeySequence(Qt::ALT + Qt::SHIFT + Qt::Key_Tab));
#else
reset->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_0));
action->setShortcut(QKeySequence(Qt::ALT + Qt::Key_0));
ctrlTab->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Tab));
ctrlShiftTab->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Tab));
#endif
QToolButton *button = new QToolButton;
button->setDefaultAction(action);
QStatusBar *statusbar = statusBar();
statusbar->show();
statusbar->setProperty("p_styled", true);
statusbar->addPermanentWidget(button);
QWidget *w = new QWidget;
QHBoxLayout *layout = new QHBoxLayout(w);
layout->addStretch(1);
statusbar->insertWidget(1, w, 1);
installEventFilter(this);
setWindowTitle(tr("Qt Creator Offline Help"));
}
PyObject* scribus_getproperty(PyObject* /*self*/, PyObject* args, PyObject* kw)
{
PyObject* objArg = NULL;
char* propertyName = NULL;
char* kwargs[] = {const_cast<char*>("object"),
const_cast<char*>("property"),
NULL};
if (!PyArg_ParseTupleAndKeywords(args, kw, "Oes", kwargs,
&objArg, "ascii", &propertyName))
return NULL;
// Get the QObject* the object argument refers to
QObject* obj = getQObjectFromPyArg(objArg);
if (!obj)
return NULL;
objArg = NULL; // no need to decref, it's borrowed
// Get the QMetaProperty for the property, so we can check
// if it's a set/enum and do name/value translation.
const QMetaObject* objmeta = obj->metaObject();
int i = objmeta->indexOfProperty(propertyName);
if (i == -1)
{
PyErr_SetString(PyExc_ValueError,
QObject::tr("Property not found").toLocal8Bit().data());
return NULL;
}
QMetaProperty propmeta = objmeta->property(i);
if (!propmeta.isValid())
{
PyErr_SetString(PyExc_ValueError,
QObject::tr("Invalid property").toLocal8Bit().data());
return NULL;
}
// Get the property value as a variant type
QVariant prop = obj->property(propertyName);
// Convert the property to an instance of the closest matching Python type.
PyObject* resultobj = NULL;
// NUMERIC TYPES
if (prop.type() == QVariant::Int)
resultobj = PyLong_FromLong(prop.toInt());
else if (prop.type() == QVariant::Double)
resultobj = PyFloat_FromDouble(prop.toDouble());
// BOOLEAN
else if (prop.type() == QVariant::Bool)
resultobj = PyBool_FromLong(prop.toBool());
// STRING TYPES
else if (prop.type() == QVariant::ByteArray)
resultobj = PyString_FromString(prop.toByteArray().data());
else if (prop.type() == QVariant::String)
resultobj = PyString_FromString(prop.toString().toUtf8().data());
// HIGHER ORDER TYPES
else if (prop.type() == QVariant::Point)
{
// Return a QPoint as an (x,y) tuple.
QPoint pt = prop.toPoint();
return Py_BuildValue("(ii)", pt.x(), pt.y());
}
else if (prop.type() == QVariant::Rect)
{
// Return a QRect as an (x,y,width,height) tuple.
// FIXME: We should really construct and return an object that
// matches the API of QRect and has properties to keep
// left/top/right/bottom and x/y/width/height in sync.
QRect r = prop.toRect();
return Py_BuildValue("(iiii)", r.x(), r.y(), r.width(), r.height());
}
else if (prop.type() == QVariant::StringList)
{
QStringList tmp = prop.toStringList();
return convert_QStringList_to_PyListObject(tmp);
}
// UNHANDLED TYPE
else
{
PyErr_SetString(PyExc_TypeError, QObject::tr("Couldn't convert result type '%1'.").arg(prop.typeName()).toLocal8Bit().constData() );
return resultobj;
}
// Return the resulting Python object
if (resultobj == NULL)
{
// An exception was set while assigning to resultobj
assert(PyErr_Occurred());
return NULL;
}
else
return resultobj;
}
QList<QByteArray> convertFromMime(const QString & /* mime */, QVariant data, QString /* flav */) {
QByteArray a = data.toByteArray();
QList<QByteArray> l;
l.append(a);
return l;
}
void App::init()
{
QSettings settings;
setWindowIcon(QIcon(":/qlcplus.png"));
m_tab = new QTabWidget(this);
m_tab->setTabPosition(QTabWidget::South);
setCentralWidget(m_tab);
QVariant var = settings.value(SETTINGS_GEOMETRY);
if (var.isValid() == true)
{
this->restoreGeometry(var.toByteArray());
}
else
{
/* Application geometry and window state */
QSize size = settings.value("/workspace/size").toSize();
if (size.isValid() == true)
resize(size);
else
{
if (QLCFile::isRaspberry())
{
QRect geometry = qApp->desktop()->availableGeometry();
int w = geometry.width();
int h = geometry.height();
if (m_overscan == true)
{
// if we're on a Raspberry Pi, introduce a 5% margin
w = (float)geometry.width() * 0.95;
h = (float)geometry.height() * 0.95;
}
setGeometry((geometry.width() - w) / 2, (geometry.height() - h) / 2,
w, h);
}
else
resize(800, 600);
}
QVariant state = settings.value("/workspace/state", Qt::WindowNoState);
if (state.isValid() == true)
setWindowState(Qt::WindowState(state.toInt()));
}
QVariant dir = settings.value(SETTINGS_WORKINGPATH);
if (dir.isValid() == true)
m_workingDirectory = QDir(dir.toString());
// The engine object
initDoc();
// Main view actions
initActions();
// Main tool bar
initToolBar();
m_dumpProperties = new DmxDumpFactoryProperties(KUniverseCount);
// Create primary views.
m_tab->setIconSize(QSize(24, 24));
QWidget* w = new FixtureManager(m_tab, m_doc);
m_tab->addTab(w, QIcon(":/fixture.png"), tr("Fixtures"));
w = new FunctionManager(m_tab, m_doc);
m_tab->addTab(w, QIcon(":/function.png"), tr("Functions"));
w = new ShowManager(m_tab, m_doc);
m_tab->addTab(w, QIcon(":/show.png"), tr("Shows"));
w = new VirtualConsole(m_tab, m_doc);
m_tab->addTab(w, QIcon(":/virtualconsole.png"), tr("Virtual Console"));
w = new SimpleDesk(m_tab, m_doc);
m_tab->addTab(w, QIcon(":/slidermatrix.png"), tr("Simple Desk"));
w = new InputOutputManager(m_tab, m_doc);
m_tab->addTab(w, QIcon(":/input_output.png"), tr("Inputs/Outputs"));
// Listen to blackout changes and toggle m_controlBlackoutAction
connect(m_doc->inputOutputMap(), SIGNAL(blackoutChanged(bool)), this, SLOT(slotBlackoutChanged(bool)));
// Enable/Disable panic button
connect(m_doc->masterTimer(), SIGNAL(functionListChanged()), this, SLOT(slotRunningFunctionsChanged()));
slotRunningFunctionsChanged();
// Start up in non-modified state
m_doc->resetModified();
QString ssDir;
#if defined(WIN32) || defined(Q_OS_WIN)
/* User's input profile directory on Windows */
LPTSTR home = (LPTSTR) malloc(256 * sizeof(TCHAR));
GetEnvironmentVariable(TEXT("UserProfile"), home, 256);
ssDir = QString("%1/%2").arg(QString::fromUtf16(reinterpret_cast<ushort*> (home)))
.arg(USERQLCPLUSDIR);
free(home);
#else
/* User's input profile directory on *NIX systems */
ssDir = QString("%1/%2").arg(getenv("HOME")).arg(USERQLCPLUSDIR);
#endif
QFile ssFile(ssDir + QDir::separator() + "qlcplusStyle.qss");
if (ssFile.exists() == true)
{
ssFile.open(QFile::ReadOnly);
QString styleSheet = QLatin1String(ssFile.readAll());
this->setStyleSheet(styleSheet);
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
m_videoProvider = new VideoProvider(m_doc, this);
#endif
}
AddFixture::AddFixture(QWidget* parent, const Doc* doc, const Fixture* fxi)
: QDialog(parent)
, m_doc(doc)
{
m_addressValue = 0;
m_universeValue = 0;
m_amountValue = 1;
m_gapValue = 0;
m_channelsValue = 1;
m_fixtureDef = NULL;
m_mode = NULL;
m_fxiCount = 0;
m_fixtureID = Fixture::invalidId();
m_invalidAddressFlag = false;
setupUi(this);
m_addrErrorLabel->hide();
QAction* action = new QAction(this);
action->setShortcut(QKeySequence(QKeySequence::Close));
connect(action, SIGNAL(triggered(bool)), this, SLOT(reject()));
addAction(action);
connect(m_tree, SIGNAL(itemSelectionChanged()),
this, SLOT(slotSelectionChanged()));
connect(m_tree, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),
this, SLOT(slotTreeDoubleClicked(QTreeWidgetItem*)));
connect(m_modeCombo, SIGNAL(activated(const QString&)),
this, SLOT(slotModeActivated(const QString&)));
connect(m_universeCombo, SIGNAL(activated(int)),
this, SLOT(slotUniverseActivated(int)));
connect(m_addressSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotAddressChanged(int)));
connect(m_channelsSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotChannelsChanged(int)));
connect(m_nameEdit, SIGNAL(textEdited(const QString&)),
this, SLOT(slotNameEdited(const QString&)));
connect(m_gapSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotGapSpinChanged(int)));
connect(m_amountSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotAmountSpinChanged(int)));
connect(m_searchEdit, SIGNAL(textChanged(QString)),
this, SLOT(slotSearchFilterChanged(QString)));
connect(m_diptoolButton, SIGNAL(clicked()),
this, SLOT(slotDiptoolButtonClicked()));
/* Fill fixture definition tree (and select a fixture def) */
if (fxi != NULL)
{
fillTree(fxi->fixtureDef()->manufacturer(), fxi->fixtureDef()->model());
m_fixtureID = fxi->id();
}
else
fillTree(KXMLFixtureGeneric, KXMLFixtureGeneric);
m_fixturesCount->setText(tr("Fixtures found: %1").arg(m_fxiCount));
/* Fill universe combo with available universes */
m_universeCombo->addItems(m_doc->inputOutputMap()->universeNames());
/* Simulate first selection and find the next free address */
slotSelectionChanged();
if (fxi != NULL)
{
// Universe
m_universeCombo->setCurrentIndex(fxi->universe());
slotUniverseActivated(fxi->universe());
m_addressSpin->setValue(fxi->address() + 1);
m_addressValue = fxi->address();
m_multipleGroup->setEnabled(false);
// Name
m_nameEdit->setText(fxi->name());
slotNameEdited(fxi->name());
m_nameEdit->setModified(true); // Prevent auto-naming
// Mode
int index = m_modeCombo->findText(fxi->fixtureMode()->name());
if (index != -1)
{
m_channelsSpin->setValue(fxi->channels());
m_modeCombo->setCurrentIndex(index);
slotModeActivated(m_modeCombo->itemText(index));
}
}
else
{
slotUniverseActivated(0);
findAddress();
m_channelsSpin->setValue(1);
}
QSettings settings;
QVariant var = settings.value(SETTINGS_GEOMETRY);
if (var.isValid() == true)
restoreGeometry(var.toByteArray());
AppUtil::ensureWidgetIsVisible(this);
}
uint qHash( const QVariant &variant )
{
if ( !variant.isValid() || variant.isNull() )
return std::numeric_limits<uint>::max();
switch ( variant.type() )
{
case QVariant::Int:
return qHash( variant.toInt() );
case QVariant::UInt:
return qHash( variant.toUInt() );
case QVariant::Bool:
return qHash( variant.toBool() );
case QVariant::Double:
return qHash( variant.toDouble() );
case QVariant::LongLong:
return qHash( variant.toLongLong() );
case QVariant::ULongLong:
return qHash( variant.toULongLong() );
case QVariant::String:
return qHash( variant.toString() );
case QVariant::Char:
return qHash( variant.toChar() );
case QVariant::List:
#if QT_VERSION >= 0x050600
return qHash( variant.toList() );
#else
{
QVariantList list = variant.toList();
if ( list.isEmpty() )
return -1;
else
return qHash( list.at( 0 ) );
}
#endif
case QVariant::StringList:
#if QT_VERSION >= 0x050600
return qHash( variant.toStringList() );
#else
{
QStringList list = variant.toStringList();
if ( list.isEmpty() )
return -1;
else
return qHash( list.at( 0 ) );
}
#endif
case QVariant::ByteArray:
return qHash( variant.toByteArray() );
case QVariant::Date:
return qHash( variant.toDate() );
case QVariant::Time:
return qHash( variant.toTime() );
case QVariant::DateTime:
return qHash( variant.toDateTime() );
case QVariant::Url:
case QVariant::Locale:
case QVariant::RegExp:
return qHash( variant.toString() );
default:
break;
}
return std::numeric_limits<uint>::max();
}
void QPpmHandler::setOption(ImageOption option, const QVariant &value)
{
if (option == SubType)
subType = value.toByteArray().toLower();
}
QDomElement MaiaObject::toXml(QVariant arg) {
//dummy document
QDomDocument doc;
//value element, we need this in each case
QDomElement tagValue = doc.createElement("value");
/* qDebug("type: %d (%s)", arg.type(), arg.typeName()); */
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;
}
/*!
Client side method call that directly accesses the object through the DBus interface.
All arguments and return types are processed and converted accordingly so that all functions
satisfy the QtDBus type system.
*/
QVariant ObjectEndPoint::invokeRemote(int metaIndex, const QVariantList& args, int returnType)
{
QMetaMethod method = service->metaObject()->method(metaIndex);
Q_ASSERT(d->endPointType == ObjectEndPoint::Client);
// Check is this is a signal relay
if (method.methodType() == QMetaMethod::Signal) {
// Convert custom arguments
QVariantList convertedList;
QList<QByteArray> params = method.parameterTypes();
for (int i = 0; i < params.size(); i++) {
const QByteArray& type = params[i];
int variantType = QVariant::nameToType(type);
if (variantType == QVariant::UserType) {
variantType = QMetaType::type(type);
QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(args[i]);
QVariant variant = dbusVariant.variant();
if (type == "QVariant") {
convertedList << variant;
} else {
QByteArray buffer = variant.toByteArray();
QDataStream stream(&buffer, QIODevice::ReadWrite);
QVariant *customType = new QVariant(variantType, (const void*)0);
QMetaType::load(stream, QMetaType::type("QVariant"), customType);
convertedList << *customType;
}
} else {
convertedList << args[i];
}
}
// Signal relay
const int numArgs = convertedList.size();
QVarLengthArray<void *, 32> a( numArgs+1 );
a[0] = 0;
const QList<QByteArray> pTypes = method.parameterTypes();
for ( int arg = 0; arg < numArgs; ++arg ) {
if (pTypes.at(arg) == "QVariant") {
a[arg+1] = (void *)&( convertedList[arg] );
} else {
a[arg+1] = (void *)( convertedList[arg].data() );
}
}
// Activate the service proxy signal call
QMetaObject::activate(service, metaIndex, a.data());
return QVariant();
}
// Method call so process arguments and convert if not a supported DBus type
QVariantList convertedList;
QList<QByteArray> params = method.parameterTypes();
for (int i = 0; i < params.size(); i++) {
QVariant converted = toDBusVariant(params[i], args[i]);
convertedList << converted;
}
bool validDBus = false;
QDBusMessage msg;
// Find the method name and try a direct DBus call
QString methodName(method.signature());
methodName.truncate(methodName.indexOf("("));
if (method.methodType() == QMetaMethod::Slot || method.methodType() == QMetaMethod::Method) {
// Slot or Invokable method
msg = iface->callWithArgumentList(QDBus::Block, methodName, convertedList);
if (msg.type() == QDBusMessage::ReplyMessage) {
validDBus = true;
}
}
// DBus call should only fail for methods with invalid type definitions
if (validDBus) {
if (returnType == QMetaType::Void) {
// Void method call
return QVariant();
}
else {
// Use DBus message return value
QVariantList retList = msg.arguments();
// Process return
const QByteArray& retType = QByteArray(method.typeName());
int variantType = QVariant::nameToType(retType);
if (variantType == QVariant::UserType) {
variantType = QMetaType::type(retType);
if (retType == "QVariant") {
// QVariant return from QDBusVariant wrapper
QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(retList[0]);
return dbusVariant.variant();
} else {
// Custom return type
QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(retList[0]);
QVariant convert = dbusVariant.variant();
QServiceUserTypeDBus customType = qdbus_cast<QServiceUserTypeDBus>(convert);
QByteArray buffer = customType.variantBuffer;
QDataStream stream(&buffer, QIODevice::ReadWrite);
// Load our buffered variant-wrapped custom return
QVariant *customReturn = new QVariant(variantType, (const void*)0);
QMetaType::load(stream, QMetaType::type("QVariant"), customReturn);
return QVariant(variantType, customReturn->data());
}
} else {
// Standard return type
return retList[0];
}
}
} else {
qWarning( "%s::%s cannot be called.", service->metaObject()->className(), method.signature());
}
return QVariant();
}
static QString variantToTextValue(const QVariant& value, const QString& typeNs, const QString& type)
{
switch (value.userType())
{
case QVariant::Char:
// fall-through
case QVariant::String:
return value.toString();
case QVariant::Url:
// xmlpatterns/data/qatomicvalue.cpp says to do this:
return value.toUrl().toString();
case QVariant::ByteArray:
{
const QByteArray data = value.toByteArray();
if (typeNs == KDSoapNamespaceManager::xmlSchema1999() || typeNs == KDSoapNamespaceManager::xmlSchema2001()) {
if (type == QLatin1String("hexBinary")) {
const QByteArray hb = data.toHex();
return QString::fromLatin1(hb.constData(), hb.size());
}
}
// default to base64Binary, like variantToXMLType() does.
const QByteArray b64 = value.toByteArray().toBase64();
return QString::fromLatin1(b64.constData(), b64.size());
}
case QVariant::Int:
// fall-through
case QVariant::LongLong:
// fall-through
case QVariant::UInt:
return QString::number(value.toLongLong());
case QVariant::ULongLong:
return QString::number(value.toULongLong());
case QVariant::Bool:
case QMetaType::Float:
case QVariant::Double:
return value.toString();
case QVariant::Time:
{
const QTime time = value.toTime();
if (time.msec()) {
// include milli-seconds
return time.toString(QLatin1String("hh:mm:ss.zzz"));
} else {
return time.toString(Qt::ISODate);
}
}
case QVariant::Date:
return value.toDate().toString(Qt::ISODate);
case QVariant::DateTime: // http://www.w3.org/TR/xmlschema-2/#dateTime
return KDDateTime(value.toDateTime()).toDateString();
case QVariant::Invalid:
qDebug() << "ERROR: Got invalid QVariant in a KDSoapValue";
return QString();
default:
if (value.canConvert<KDDateTime>()) {
return value.value<KDDateTime>().toDateString();
}
if (value.userType() == qMetaTypeId<float>())
return QString::number(value.value<float>());
qDebug() << QString::fromLatin1("QVariants of type %1 are not supported in "
"KDSoap, see the documentation").arg(QLatin1String(value.typeName()));
return value.toString();
}
}
QString App::convertToUtf8String(const QVariant &pushContent)
{
return QString::fromUtf8(pushContent.toByteArray().data());
}
bool QDBusMarshaller::appendVariantInternal(const QVariant &arg)
{
int id = arg.userType();
if (id == QVariant::Invalid) {
qWarning("QDBusMarshaller: cannot add an invalid QVariant");
error(QLatin1String("Variant containing QVariant::Invalid passed in arguments"));
return false;
}
// intercept QDBusArgument parameters here
if (id == QDBusMetaTypeId::argument()) {
QDBusArgument dbusargument = qvariant_cast<QDBusArgument>(arg);
QDBusArgumentPrivate *d = QDBusArgumentPrivate::d(dbusargument);
if (!d->message)
return false; // can't append this one...
QDBusDemarshaller demarshaller(capabilities);
demarshaller.message = q_dbus_message_ref(d->message);
if (d->direction == Demarshalling) {
// it's demarshalling; just copy
demarshaller.iterator = static_cast<QDBusDemarshaller *>(d)->iterator;
} else {
// it's marshalling; start over
if (!q_dbus_message_iter_init(demarshaller.message, &demarshaller.iterator))
return false; // error!
}
return appendCrossMarshalling(&demarshaller);
}
const char *signature = QDBusMetaType::typeToSignature( QVariant::Type(id) );
if (!signature) {
qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "
"Use qDBusRegisterMetaType to register it",
QMetaType::typeName(id), id);
error(QString::fromLatin1("Unregistered type %1 passed in arguments")
.arg(QLatin1String(QMetaType::typeName(id))));
return false;
}
switch (*signature) {
#ifdef __OPTIMIZE__
case DBUS_TYPE_BYTE:
case DBUS_TYPE_INT16:
case DBUS_TYPE_UINT16:
case DBUS_TYPE_INT32:
case DBUS_TYPE_UINT32:
case DBUS_TYPE_INT64:
case DBUS_TYPE_UINT64:
case DBUS_TYPE_DOUBLE:
qIterAppend(&iterator, ba, *signature, arg.constData());
return true;
case DBUS_TYPE_BOOLEAN:
append( arg.toBool() );
return true;
#else
case DBUS_TYPE_BYTE:
append( qvariant_cast<uchar>(arg) );
return true;
case DBUS_TYPE_BOOLEAN:
append( arg.toBool() );
return true;
case DBUS_TYPE_INT16:
append( qvariant_cast<short>(arg) );
return true;
case DBUS_TYPE_UINT16:
append( qvariant_cast<ushort>(arg) );
return true;
case DBUS_TYPE_INT32:
append( static_cast<dbus_int32_t>(arg.toInt()) );
return true;
case DBUS_TYPE_UINT32:
append( static_cast<dbus_uint32_t>(arg.toUInt()) );
return true;
case DBUS_TYPE_INT64:
append( arg.toLongLong() );
return true;
case DBUS_TYPE_UINT64:
append( arg.toULongLong() );
return true;
case DBUS_TYPE_DOUBLE:
append( arg.toDouble() );
return true;
#endif
case DBUS_TYPE_STRING:
append( arg.toString() );
return true;
case DBUS_TYPE_OBJECT_PATH:
append( qvariant_cast<QDBusObjectPath>(arg) );
return true;
case DBUS_TYPE_SIGNATURE:
append( qvariant_cast<QDBusSignature>(arg) );
return true;
// compound types:
case DBUS_TYPE_VARIANT:
// nested QVariant
return append( qvariant_cast<QDBusVariant>(arg) );
case DBUS_TYPE_ARRAY:
// could be many things
// find out what kind of array it is
switch (arg.type()) {
case QVariant::StringList:
append( arg.toStringList() );
return true;
case QVariant::ByteArray:
append( arg.toByteArray() );
return true;
default:
; // fall through
}
// fall through
case DBUS_TYPE_STRUCT:
case DBUS_STRUCT_BEGIN_CHAR:
return appendRegisteredType( arg );
case DBUS_TYPE_DICT_ENTRY:
case DBUS_DICT_ENTRY_BEGIN_CHAR:
qFatal("QDBusMarshaller::appendVariantInternal got a DICT_ENTRY!");
return false;
case DBUS_TYPE_UNIX_FD:
if (capabilities & QDBusConnection::UnixFileDescriptorPassing || ba) {
append(qvariant_cast<QDBusUnixFileDescriptor>(arg));
return true;
}
// fall through
default:
qWarning("QDBusMarshaller::appendVariantInternal: Found unknown D-BUS type '%s'",
signature);
return false;
}
return true;
}
bool RawData::startsWith(const QVariant &data)
{
return mByteArray.startsWith(data.toByteArray());
}
bool RawData::contains(const QVariant &data)
{
return mByteArray.contains(data.toByteArray());
}
void MVariant::tostring(QVariant params )
{
// qDebug()<<"\n"<<params.type()<<"\n"<<params;
switch ( params.type() ) {
case QVariant::Int:
case QVariant::UInt:
this->items << QString::number( params.toInt() );
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::String:
this->items <<params.toString();
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::Double:
this->items << QString::number( params.toDouble() );
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::DateTime:
this->items << params.toDateTime().toString();
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::Bool:
this->items << ( params.toBool() ? "true" : "false" );
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::ByteArray:
{
QString data = params.toByteArray().toBase64();
if ( data.length() > 128 ) {
data = data.left(64)+"...";
}
this->items << data;
this->ret<<this->items;
// this->items.clear();
break;
}
case QVariant::StringList:
case QVariant::List:
{ //this->items.clear();
QListIterator<QVariant> it( params.toList() );
while( it.hasNext() ) {
//it.next();
this->tostring(it.next());
}
break;
}
case QVariant::Map:
{
//QStringList item;
QMapIterator<QString,QVariant> it( params.toMap());
while( it.hasNext() ) {
it.next();
//this->items.clear();
this->items<<it.key();
this->tostring(it.value());
//this->ret<<this->items;
this->items.clear();
}
break;
}
default:
break;
}
}
int RawData::count(const QVariant &data) const
{
return mByteArray.count(data.toByteArray());
}
QVariant QDbfSqlModel::data(const QModelIndex &index, int role) const
{
QVariant value = QSqlQueryModel::data(index, role);
int i,j,k;
QByteArray tempDateArray;
QDate tempDate;
QTime tempTime;
quint32 l;
qint32 l1;
qint64 l2;
double db;
bool ok;
QString currency;
//QLocale clocale(QLocale::German);
QLocale clocale(QLocale::C);
quint8 r,g,b;
QByteArray tempByteArray;
//QList<int> charFields;
for (i=0;i<charFields.count();i++)
{
if (index.column() == charFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignLeft | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(charFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> currencyFields;
for (i=0;i<currencyFields.count();i++)
{
if (index.column() == currencyFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
tempDateArray = value.toByteArray();
tempDateArray = QByteArray::fromHex(tempDateArray);
l2 = *(qint64 *)tempDateArray.data();
db = l2;
currency.setNum(db/10000,'f',4);
value = clocale.toString(db/10000,'f',4);
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(currencyFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> numericFields;
for (i=0;i<numericFields.count();i++)
{
if (index.column() == numericFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
currency=value.toString().simplified();
k=currency.count()-1;
j=0;
ok=false;
while (k>0)
{
if (currency.at(k) == '.')
{
ok = true;
break;
}
k--;
j++;
}
if (!ok) j=0;
value = clocale.toString(currency.toDouble(&ok),'f',j);
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(numericFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> dateFields;
for (i=0;i<dateFields.count();i++)
{
if (index.column() == dateFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
value = value.toDate().toString("dd.MM.yyyy");
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(dateFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> timeFields;
for (i=0;i<timeFields.count();i++)
{
if (index.column() == timeFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
tempDateArray = value.toByteArray();
tempDateArray = QByteArray::fromHex(tempDateArray);
l = *(quint32 *)tempDateArray.data();
tempDate = QDate::fromJulianDay(l);
l = *(quint32 *)(tempDateArray.data()+4);
tempTime.setHMS(0,0,0);
tempTime = tempTime.addMSecs(l);
value = tempDate.toString("dd.MM.yyyy")+" "+tempTime.toString("hh:mm:ss.zzz");
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(timeFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> doubleFields;
for (i=0;i<doubleFields.count();i++)
{
if (index.column() == doubleFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
tempDateArray = value.toByteArray();
tempDateArray = QByteArray::fromHex(tempDateArray);
db = *(double *)tempDateArray.data();
value = db;
//value = clocale.toString(db,'f',4);
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(doubleFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> intFields;
for (i=0;i<intFields.count();i++)
{
if (index.column() == intFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
tempDateArray = value.toByteArray();
tempDateArray = QByteArray::fromHex(tempDateArray);
l1 = *(quint32 *)tempDateArray.data();
value = l1;
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(intFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> logicalFields;
for (i=0;i<logicalFields.count();i++)
{
if (index.column() == logicalFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(logicalFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> memoFields;
for (i=0;i<memoFields.count();i++)
{
if (index.column() == memoFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(memoFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> memo4Fields;
for (i=0;i<memo4Fields.count();i++)
{
if (index.column() == memo4Fields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
tempDateArray = value.toByteArray();
tempDateArray = QByteArray::fromHex(tempDateArray);
l = *(quint32 *)tempDateArray.data();
value = l;
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(memo4FieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
//QList<int> generalFields;
for (i=0;i<generalFields.count();i++)
{
if (index.column() == generalFields.at(i))
{
switch (role)
{
case Qt::DisplayRole:
break;
case Qt::TextAlignmentRole:
value = QVariant(Qt::AlignRight | Qt::AlignVCenter);
break;
case Qt::TextColorRole:
tempByteArray.append(generalFieldColorString);
tempByteArray = QByteArray::fromHex(tempByteArray);
r = tempByteArray.at(0);
g = tempByteArray.at(1);
b = tempByteArray.at(2);
QColor tempColor(r,g,b);
value = qVariantFromValue(tempColor);
break;
}
}
}
return value;
}
bool RawData::endsWith(const QVariant &data) const
{
return mByteArray.endsWith(data.toByteArray());
}
static bool variantToString(const QVariant &arg, QString &out)
{
int argType = arg.userType();
if (argType == QVariant::StringList) {
out += QLatin1Char('{');
const QStringList list = arg.toStringList();
for (const QString &item : list)
out += QLatin1Char('\"') + item + QLatin1String("\", ");
if (!list.isEmpty())
out.chop(2);
out += QLatin1Char('}');
} else if (argType == QVariant::ByteArray) {
out += QLatin1Char('{');
QByteArray list = arg.toByteArray();
for (int i = 0; i < list.count(); ++i) {
out += QString::number(list.at(i));
out += QLatin1String(", ");
}
if (!list.isEmpty())
out.chop(2);
out += QLatin1Char('}');
} else if (argType == QVariant::List) {
out += QLatin1Char('{');
const QList<QVariant> list = arg.toList();
for (const QVariant &item : list) {
if (!variantToString(item, out))
return false;
out += QLatin1String(", ");
}
if (!list.isEmpty())
out.chop(2);
out += QLatin1Char('}');
} else if (argType == QMetaType::Char || argType == QMetaType::Short || argType == QMetaType::Int
|| argType == QMetaType::Long || argType == QMetaType::LongLong) {
out += QString::number(arg.toLongLong());
} else if (argType == QMetaType::UChar || argType == QMetaType::UShort || argType == QMetaType::UInt
|| argType == QMetaType::ULong || argType == QMetaType::ULongLong) {
out += QString::number(arg.toULongLong());
} else if (argType == QMetaType::Double) {
out += QString::number(arg.toDouble());
} else if (argType == QMetaType::Bool) {
out += QLatin1String(arg.toBool() ? "true" : "false");
} else if (argType == qMetaTypeId<QDBusArgument>()) {
argToString(qvariant_cast<QDBusArgument>(arg), out);
} else if (argType == qMetaTypeId<QDBusObjectPath>()) {
const QString path = qvariant_cast<QDBusObjectPath>(arg).path();
out += QLatin1String("[ObjectPath: ");
out += path;
out += QLatin1Char(']');
} else if (argType == qMetaTypeId<QDBusSignature>()) {
out += QLatin1String("[Signature: ") + qvariant_cast<QDBusSignature>(arg).signature();
out += QLatin1Char(']');
} else if (argType == qMetaTypeId<QDBusUnixFileDescriptor>()) {
out += QLatin1String("[Unix FD: ");
out += QLatin1String(qvariant_cast<QDBusUnixFileDescriptor>(arg).isValid() ? "valid" : "not valid");
out += QLatin1Char(']');
} else if (argType == qMetaTypeId<QDBusVariant>()) {
const QVariant v = qvariant_cast<QDBusVariant>(arg).variant();
out += QLatin1String("[Variant");
int vUserType = v.userType();
if (vUserType != qMetaTypeId<QDBusVariant>()
&& vUserType != qMetaTypeId<QDBusSignature>()
&& vUserType != qMetaTypeId<QDBusObjectPath>()
&& vUserType != qMetaTypeId<QDBusArgument>())
out += QLatin1Char('(') + QLatin1String(v.typeName()) + QLatin1Char(')');
out += QLatin1String(": ");
if (!variantToString(v, out))
return false;
out += QLatin1Char(']');
} else if (arg.canConvert(QVariant::String)) {
out += QLatin1Char('\"') + arg.toString() + QLatin1Char('\"');
} else {
out += QLatin1Char('[');
out += QLatin1String(arg.typeName());
out += QLatin1Char(']');
}
return true;
}
int RawData::indexOf(const QVariant &data, int from) const
{
return mByteArray.indexOf(data.toByteArray(), from);
}
QT_BEGIN_NAMESPACE
static void copyArgument(void *to, int id, const QVariant &arg)
{
if (id == arg.userType()) {
switch (id) {
case QVariant::Bool:
*reinterpret_cast<bool *>(to) = arg.toBool();
return;
case QMetaType::UChar:
*reinterpret_cast<uchar *>(to) = arg.value<uchar>();
return;
case QMetaType::Short:
*reinterpret_cast<short *>(to) = arg.value<short>();
return;
case QMetaType::UShort:
*reinterpret_cast<ushort *>(to) = arg.value<ushort>();
return;
case QVariant::Int:
*reinterpret_cast<int *>(to) = arg.toInt();
return;
case QVariant::UInt:
*reinterpret_cast<uint *>(to) = arg.toUInt();
return;
case QVariant::LongLong:
*reinterpret_cast<qlonglong *>(to) = arg.toLongLong();
return;
case QVariant::ULongLong:
*reinterpret_cast<qulonglong *>(to) = arg.toULongLong();
return;
case QVariant::Double:
*reinterpret_cast<double *>(to) = arg.toDouble();
return;
case QVariant::String:
*reinterpret_cast<QString *>(to) = arg.toString();
return;
case QVariant::ByteArray:
*reinterpret_cast<QByteArray *>(to) = arg.toByteArray();
return;
case QVariant::StringList:
*reinterpret_cast<QStringList *>(to) = arg.toStringList();
return;
}
if (id == QDBusMetaTypeId::variant) {
*reinterpret_cast<QDBusVariant *>(to) = arg.value<QDBusVariant>();
return;
} else if (id == QDBusMetaTypeId::objectpath) {
*reinterpret_cast<QDBusObjectPath *>(to) = arg.value<QDBusObjectPath>();
return;
} else if (id == QDBusMetaTypeId::signature) {
*reinterpret_cast<QDBusSignature *>(to) = arg.value<QDBusSignature>();
return;
}
// those above are the only types possible
// the demarshaller code doesn't demarshall anything else
qFatal("Found a decoded basic type in a D-Bus reply that shouldn't be there");
}
// if we got here, it's either an un-dermarshalled type or a mismatch
if (arg.userType() != QDBusMetaTypeId::argument) {
// it's a mismatch
//qWarning?
return;
}
// is this type registered?
const char *userSignature = QDBusMetaType::typeToSignature(id);
if (!userSignature || !*userSignature) {
// type not registered
//qWarning?
return;
}
// is it the same signature?
QDBusArgument dbarg = arg.value<QDBusArgument>();
if (dbarg.currentSignature() != QLatin1String(userSignature)) {
// not the same signature, another mismatch
//qWarning?
return;
}
// we can demarshall
QDBusMetaType::demarshall(dbarg, id, to);
}
int RawData::lastIndexOf(const QVariant &data) const
{
return mByteArray.lastIndexOf(data.toByteArray());
}
void KexiBlobTableEdit::handleCopyAction(const QVariant& value, const QVariant& visibleValue)
{
Q_UNUSED(visibleValue);
executeCopyAction(value.toByteArray());
}
QScriptValue RawData::prepend(const QVariant &data)
{
mByteArray.prepend(data.toByteArray());
return thisObject();
}
void DXAudioInputRegistrar::setDeviceChoice(const QVariant &choice, Settings &s) {
s.qbaDXInput = choice.toByteArray();
}
QScriptValue RawData::setData(const QVariant &data)
{
mByteArray = data.toByteArray();
return thisObject();
}
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());
break;
#if 0
case QVariant::CString:
e.setTagName("string");
e.setAttribute("value", v.toString());
break;
#endif
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.value<QColor>();
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.value<QPen>();
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.value<QBrush>();
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.value<QFont>());
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.value<QSizePolicy>());
e.setAttribute("hsizetype", sp.horData());
e.setAttribute("vsizetype", sp.verData());
e.setAttribute("horstretch", sp.horStretch());
e.setAttribute("verstretch", sp.verStretch());
}
break;
case QVariant::Cursor:
e.setTagName("cursor");
e.setAttribute("shape", v.value<QCursor>().shape());
break;
case QVariant::StringList:
{
e.setTagName("stringlist");
int32_t j;
QDomNode n;
QDomNodeList stringNodeList = e.elementsByTagName("string");
QDomElement stringElem;
QStringList stringList = v.toStringList();
QStringList::Iterator it = stringList.begin();
for (j = 0;
((j < (int32_t)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 < (int32_t)stringNodeList.count())
e.removeChild(stringNodeList.item(j).toElement());
}
else if (j < (int32_t)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;
case QVariant::KeySequence:
e.setTagName("key");
e.setAttribute("sequence", (QString)v.value<QKeySequence>().toString());
break;
case QVariant::ByteArray: // this is only for [u]int64_t
{
e.setTagName("data");
// set the value
e.setAttribute("value", getStringFromByteArray(v.toByteArray()));
}
break;
default:
qWarning("Don't know how to persist variant of type: %s (%d)!",
v.typeName(), v.type());
ok = false;
break;
}
return ok;
}
bool XQCentralRepositoryUtilsPrivate::createKey(const XQCentralRepositorySettingsKey& key, const QVariant& value)
{
CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(key.uid());
if (handler)
{
switch (value.type())
{
case QVariant::Int:
{
m_settingsManagerPrivate.iError = handler->createKey(key.key(), value.toInt());
break;
}
case QVariant::Double:
{
m_settingsManagerPrivate.iError = handler->createKey(key.key(), value.toDouble());
break;
}
case QVariant::String:
{
m_settingsManagerPrivate.iError = handler->createKey(key.key(), TPtrC16(reinterpret_cast<const TUint16*>(value.toString().utf16())));
break;
}
case QVariant::ByteArray:
{
m_settingsManagerPrivate.iError = handler->createKey(key.key(), TPtrC8((TUint8*)(value.toByteArray().constData())));
break;
}
default:
{
m_settingsManagerPrivate.iError = KErrArgument;
break;
}
}
}
else
{
m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;
}
return m_settingsManagerPrivate.iError == KErrNone;
}
