void QCupsPrintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
{
Q_D(QCupsPrintEngine);
switch (int(key)) {
case PPK_PaperSize:
d->printerPaperSize = QPrinter::PaperSize(value.toInt());
d->setPaperSize();
break;
case PPK_CupsPageRect:
d->cupsPageRect = value.toRect();
break;
case PPK_CupsPaperRect:
d->cupsPaperRect = value.toRect();
break;
case PPK_CupsOptions:
d->cupsOptions = value.toStringList();
break;
case PPK_CupsStringPageSize:
d->cupsStringPageSize = value.toString();
break;
case PPK_PrinterName:
// prevent setting the defaults again for the same printer
if (d->printerName != value.toString()) {
d->printerName = value.toString();
d->setCupsDefaults();
}
break;
default:
QPdfPrintEngine::setProperty(key, value);
break;
}
}
void LabelPrintEngine::setProperty ( PrintEnginePropertyKey key, const QVariant & value )
{
switch(key) {
case QPrintEngine::PPK_PrinterName:
m_printerName = value.toString();
break;
case QPrintEngine::PPK_DocumentName:
m_docName = value.toString();
break;
case QPrintEngine::PPK_CustomPaperSize:
m_paperSize = value.toSizeF();
m_paperRect = QRect(QPoint(0,0),m_paperSize.toSize());
break;
case QPrintEngine::PPK_PaperRect:
case QPrintEngine::PPK_PageRect:
m_paperSize = value.toRect().size();
m_paperRect = value.toRect();
break;
case QPrintEngine::PPK_PageSize:
// not implemented
break;
case QPrintEngine::PPK_Resolution:
m_resolution = value.toInt();
break;
default: break;
}
}
void DummyAnimation::updateCurrentValue(const QVariant &value)
{
if (state() == Stopped)
return;
if (m_dummy)
m_dummy->setRect(value.toRect());
}
void HappyPropertySheetExtension::setProperty(int index, const QVariant &value)
{
if ( index == 0 )
{
m_widget->setObjectName( value.toString() );
}
else if ( index == 1 )
{
m_widget->setGeometry( value.toRect() );
}
else if ( index == 2 )
{
m_widget->setDiameterInPixels( value.toInt() );
}
else if ( index == 3 )
{
m_widget->setColour( value.toString() );
}
else if ( index == 4 )
{
// m_widget->setScalpHair( value.value<ImaginativeThinking::Hair>() );
}
else if ( index == 5 )
{
// m_widget->setScalpHair( value.value<ImaginativeThinking::Hair>() );
}
}
/*!
* Initialisation du module
*
*/
void CRaspiGPIO::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>());
wiringPiSetupGpio(); // Utilise la numérotation de pin BCM
for (unsigned int i=0; i<MAX_GPIO_COUNT; i++) {
// Recherche dans le fichier EEPROM une configuration de type "gpio_<i>=input pull down"
// gpio_17 = input
QString eeprom_config_name = "gpio_" + QString::number(i);
val = m_application->m_eeprom->read(getName(), eeprom_config_name, QVariant());
if (val != QVariant()) { // le paramètre a été trouvé -> le GPIO est utilisé et doit être configuré
configPinMode(i, val.toString());
}
// Initialise la liste des GPIO dans la liste déroulante de configuration
// on part des contrôles affichés sur l'interface et on récupère les numéros
// Rensigne dans la liste déroulante des GPIO tous les numéros possibles de GPIO
QLabel *lbl = m_ihm.findChild<QLabel*>(PREFIX_MODE_GPIO + QString::number(i)); // "mode_GPIO_<i>" c'est le nom de tous les labels des GPIO sur l'IHM pour indiquer si c'est une entrée / sortie / ...
if (lbl) {
m_ihm.ui.configChoixGPIO->addItem("GPIO " + QString::number(i));
}
// connexion signal/slot avec toutes les checkbox qui permettent d'écrire sur le port
// on repert toutes les checkbox par leur nom "write_GPIO_<i>"
QCheckBox *checkbox = m_ihm.findChild<QCheckBox*>(PREFIX_CHECKBOX_WRITE + QString::number(i));
if (checkbox) {
connect(checkbox, SIGNAL(clicked(bool)), this, SLOT(onWritePinChange(bool)));
}
}
// Renseigne dans la liste déroulante des configurations possibles
QStringList list_modes;
list_modes << "" << "Input" << "Input pull down" << "Input pull up" << "Output" << "PWM Output";
m_ihm.ui.configChoixMode->addItems(list_modes);
connect(m_ihm.ui.configChoixGPIO, SIGNAL(activated(int)), this, SLOT(onChoixConfigGPIO()));
connect(m_ihm.ui.configChoixMode, SIGNAL(activated(QString)), this, SLOT(onChoixConfigMode(QString)));
connect(&m_timer_read, SIGNAL(timeout()), this, SLOT(readAllInputs()));
m_timer_read.start(100);
}
/*!
\internal
Reimplemented from QGraphicsItemPrivate. ### Qt 5: Move impl to
reimplementation QGraphicsProxyWidget::inputMethodQuery().
*/
QVariant QGraphicsProxyWidgetPrivate::inputMethodQueryHelper(Qt::InputMethodQuery query) const
{
Q_Q(const QGraphicsProxyWidget);
if (!widget || !q->hasFocus())
return QVariant();
QWidget *focusWidget = widget->focusWidget();
if (!focusWidget)
focusWidget = widget;
QVariant v = focusWidget->inputMethodQuery(query);
QPointF focusWidgetPos = q->subWidgetRect(focusWidget).topLeft();
switch (v.type()) {
case QVariant::RectF:
v = v.toRectF().translated(focusWidgetPos);
break;
case QVariant::PointF:
v = v.toPointF() + focusWidgetPos;
break;
case QVariant::Rect:
v = v.toRect().translated(focusWidgetPos.toPoint());
break;
case QVariant::Point:
v = v.toPoint() + focusWidgetPos.toPoint();
break;
default:
break;
}
return v;
}
void QRectProperty::setValue(const QVariant &value)
{
disconnectUpdateValue();
QRect re = value.toRect();
if(m_x->getVisible())
{
m_x->setValue(re.x());
m_y->setValue(re.y());
}
else
{
m_x->setValue(0);
m_y->setValue(0);
}
m_width->setValue(re.width());
m_height->setValue(re.height());
re.setRect(m_x->getValue().toInt(),m_y->getValue().toInt(),
m_width->getValue().toInt(),m_height->getValue().toInt());
connectUpdateValue();
QAbstractProperty::setValue(re);
}
/**
* Main initialization function
*/
void App::init()
{
QSettings settings;
setWindowIcon(QIcon(":/qlc.png"));
#ifndef __APPLE__
/* MDI Area */
setCentralWidget(new QMdiArea(this));
centralWidget()->setContextMenuPolicy(Qt::CustomContextMenu);
connect(centralWidget(),
SIGNAL(customContextMenuRequested(const QPoint&)),
this,
SLOT(slotCustomContextMenuRequested(const QPoint&)));
/* Workspace background */
setBackgroundImage(settings.value("/workspace/background").toString());
/* Application geometry and window state */
QVariant var;
var = settings.value(KXMLQLCGeometry, QRect(0, 0, 800, 600));
if (var.isValid() == true)
setGeometry(var.toRect());
var = settings.value(KXMLQLCWindowState, Qt::WindowNoState);
if (var.isValid() == true)
setWindowState(Qt::WindowState(var.toInt()));
#else
/* App is just a toolbar, we only need it to be the size of the
toolbar's buttons */
resize(600, 32);
move(0, 22);
#endif
/* Input & output mappers and their plugins */
initOutputMap();
initInputMap();
/* Function running engine/master timer */
m_masterTimer = new MasterTimer(this, m_outputMap);
m_masterTimer->start();
/* Buses */
Bus::init(this);
/* Fixture definitions */
loadFixtureDefinitions();
// The main view
initStatusBar();
initActions();
initMenuBar();
initToolBar();
// Document
initDoc();
// Start up in non-modified state
m_doc->resetModified();
}
/**
* Plot with plotter, using the painter.
* To be called from QML
*/
void Calculator::plot(QVariant painter, const QVariant plotArea)
{
QPainter * thePainter;
uint uintPainter = painter.toUInt();
thePainter = (QPainter *)uintPainter;
QRect thePlotArea = plotArea.toRect();
plotter.plot(thePainter, thePlotArea);
}
QString RectDelegate::displayText( const QVariant& value ) const
{
const QRect r(value.toRect());
return QString::fromLatin1(RECTEDIT_MASK)
.arg(r.x())
.arg(r.y())
.arg(r.width())
.arg(r.height());
}
void RectComposedProperty::setValue(Property *property,
const QVariant &value, bool rememberOldValue)
{
const QRect r( value.toRect() );
property->child("x")->setValue(r.x(), rememberOldValue, false);
property->child("y")->setValue(r.y(), rememberOldValue, false);
property->child("width")->setValue(r.width(), rememberOldValue, false);
property->child("height")->setValue(r.height(), rememberOldValue, false);
}
QString write(const QVariant &variant)
{
if (!variant.isValid()) {
qWarning() << "Trying to serialize invalid QVariant";
return QString();
}
QString value;
switch (variant.type()) {
case QMetaType::QPoint:
{
QPoint p = variant.toPoint();
value = QString("%1,%2").arg(QString::number(p.x()), QString::number(p.y()));
break;
}
case QMetaType::QPointF:
{
QPointF p = variant.toPointF();
value = QString("%1,%2").arg(QString::number(p.x(), 'f'), QString::number(p.y(), 'f'));
break;
}
case QMetaType::QSize:
{
QSize s = variant.toSize();
value = QString("%1x%2").arg(QString::number(s.width()), QString::number(s.height()));
break;
}
case QMetaType::QSizeF:
{
QSizeF s = variant.toSizeF();
value = QString("%1x%2").arg(QString::number(s.width(), 'f'), QString::number(s.height(), 'f'));
break;
}
case QMetaType::QRect:
{
QRect r = variant.toRect();
value = QString("%1,%2,%3x%4").arg(QString::number(r.x()), QString::number(r.y()),
QString::number(r.width()), QString::number(r.height()));
break;
}
case QMetaType::QRectF:
{
QRectF r = variant.toRectF();
value = QString("%1,%2,%3x%4").arg(QString::number(r.x(), 'f'), QString::number(r.y(), 'f'),
QString::number(r.width(), 'f'), QString::number(r.height(), 'f'));
break;
}
default:
QVariant strVariant = variant;
strVariant.convert(QVariant::String);
if (!strVariant.isValid())
qWarning() << Q_FUNC_INFO << "cannot serialize type " << QMetaType::typeName(variant.type());
value = strVariant.toString();
}
return value;
}
void QSvgIOHandler::setOption(ImageOption option, const QVariant & value)
{
switch(option) {
case ClipRect:
d->clipRect = value.toRect();
break;
case ScaledSize:
d->scaledSize = value.toSize();
break;
case ScaledClipRect:
d->scaledClipRect = value.toRect();
break;
case BackgroundColor:
d->backColor = value.value<QColor>();
break;
default:
break;
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
QSettings settings;
QVariant val = settings.value("Geometry",
QRect(50, 50, 200, 200));
setGeometry(val.toRect());
}
QString VariantDelegate::displayText(const QVariant &value)
{
switch (value.type()) {
case QVariant::Bool:
case QVariant::ByteArray:
case QVariant::Char:
case QVariant::Double:
case QVariant::Int:
case QVariant::LongLong:
case QVariant::String:
case QVariant::UInt:
case QVariant::ULongLong:
return value.toString();
case QVariant::Color:
{
QColor color = qvariant_cast<QColor>(value);
return QString("(%1,%2,%3,%4)")
.arg(color.red()).arg(color.green())
.arg(color.blue()).arg(color.alpha());
}
case QVariant::Date:
return value.toDate().toString(Qt::ISODate);
case QVariant::DateTime:
return value.toDateTime().toString(Qt::ISODate);
case QVariant::Invalid:
return "<Invalid>";
case QVariant::Point:
{
QPoint point = value.toPoint();
return QString("(%1,%2)").arg(point.x()).arg(point.y());
}
case QVariant::Rect:
{
QRect rect = value.toRect();
return QString("(%1,%2,%3,%4)")
.arg(rect.x()).arg(rect.y())
.arg(rect.width()).arg(rect.height());
}
case QVariant::Size:
{
QSize size = value.toSize();
return QString("(%1,%2)").arg(size.width()).arg(size.height());
}
case QVariant::StringList:
return value.toStringList().join(',');
case QVariant::Time:
return value.toTime().toString(Qt::ISODate);
default:
break;
}
return QString("<%1>").arg(value.typeName());
}
void PredictiveKeyboard::queryResponse ( int property, const QVariant & result )
{
if(property == Qt::ImMicroFocus) {
QRect r = result.toRect();
QPoint p = r.center();
if(mActive) {
QPoint bp = mActive->requestedRegion().boundingRect().topLeft();
p += bp;
}
mKeyboard->setAcceptDest(p);
}
};
void Keyboard::queryResponse ( int property, const QVariant & result )
{
if(property==Qt::ImMicroFocus){
QRect resultRect = result.toRect();
if(resultRect.isValid()){
microX = resultRect.x();
microY = resultRect.y();
if(keyboardFrame->obscures(QPoint(microX, microY)))
keyboardFrame->swapPosition();
}
//microFocusPending = false;
//if (showPending) show();
}
};
bool QWSInputContext::translateIMQueryEvent(QWidget *w, const QWSIMQueryEvent *e)
{
Qt::InputMethodQuery type = static_cast<Qt::InputMethodQuery>(e->simpleData.property);
QVariant result = w->inputMethodQuery(type);
QWidget *tlw = w->window();
int winId = tlw->winId();
if ( type == Qt::ImMicroFocus ) {
// translate to relative to tlw
QRect mf = result.toRect();
mf.moveTopLeft(w->mapTo(tlw,mf.topLeft()));
result = mf;
}
QPaintDevice::qwsDisplay()->sendIMResponse(winId, e->simpleData.property, result);
return false;
}
void MainWindow::readSettings()
{
mSettings->beginGroup(settingsGroup);
const QVariant geom = mSettings->value(geometryKey);
if(geom.isValid())
setGeometry(geom.toRect());
if (mSettings->value(maximizeKey, false).toBool())
setWindowState(Qt::WindowMaximized);
const QVariant theme = mSettings->value(themeKey);
mSettings->endGroup();
mOptions->readSettings(mSettings);
if(theme.isValid())
setTheme(theme.toString());
else
setTheme("clean");
}
/*!
* Initialisation du module
*
*/
void CXbeeNetworkMessenger::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>());
val = m_application->m_eeprom->read(getName(), "trace_active", QVariant(false));
m_trace_active = val.toBool();
m_ihm.ui.trace_active->setChecked(m_trace_active);
m_xbee_messenger.initApp(m_application);
connect(m_application->m_XBEE, SIGNAL(readyBytes(QByteArray,unsigned short)), this, SLOT(Xbee_readyBytes(QByteArray,unsigned short)));
connect(m_ihm.ui.clear_trace, SIGNAL(released()), this, SLOT(on_clear_trace()));
connect(m_ihm.ui.message_list, SIGNAL(currentIndexChanged(QString)), this, SLOT(on_message_name_changed(QString)));
connect(m_ihm.ui.ID, SIGNAL(editingFinished()), this, SLOT(on_message_id_changed()));
connect(m_ihm.ui.send, SIGNAL(released()), this, SLOT(on_send_message()));
connect(m_ihm.ui.trace_active, SIGNAL(clicked(bool)), this, SLOT(on_trace_active_changed(bool)));
initDiagPresencePage();
initGeneratorPage();
connect(&m_timer, SIGNAL(timeout()), this, SLOT(on_timer_tick()));
m_timer.start(MESSENGER_REFRESH_PERIOD);
}
void DbSettings::setValue(const QString &key, const QVariant &value)
{
QMutexLocker lock(&value_lock);
QSqlDatabase db = QSqlDatabase::database(settings_db);
if (!db.isOpen())
return;
QSqlQuery q(db);
q.prepare("SELECT value FROM settings WHERE key=?");
q.addBindValue(key);
if (q.exec()) {
QString string_value;
if (value.canConvert<QString>()) {
string_value = QLatin1String("@String ") + value.toString();
}
else if (value.canConvert<QRect>()) {
QTextStream out(&string_value, QIODevice::WriteOnly);
const QRect r = value.toRect();
out << rect_key << " "
<< r.left() << ", "
<< r.top() << ", "
<< r.width() << ", "
<< r.height();
}
else
Q_ASSERT(false);
value_map[key] = value;
if (q.next())
// update query
q.prepare("UPDATE settings SET value=? WHERE key=?");
else
// insert query
q.prepare("INSERT INTO settings (value, key) VALUES (?,?)");
q.addBindValue(string_value);
q.addBindValue(key);
q.exec();
}
}
void PoItemDelegate::paint (QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
if (index.column() != ProjectModel::Graph)
return QStyledItemDelegate::paint(painter,option,index);
QVariant graphData = index.data(Qt::DisplayRole);
if (KDE_ISUNLIKELY( !graphData.isValid()))
{
painter->fillRect(option.rect,Qt::transparent);
return;
}
QRect rect = graphData.toRect();
int translated = rect.left();
int untranslated = rect.top();
int fuzzy = rect.width();
int total = translated + untranslated + fuzzy;
if (total > 0)
{
painter->setPen(Qt::white);
QRect myRect(option.rect);
myRect.setWidth(option.rect.width() * translated / total);
painter->fillRect(myRect, m_colorScheme.foreground(KColorScheme::PositiveText));
//painter->drawText(myRect,Qt::AlignRight,QString("%1").arg(data.left()));
myRect.setLeft(myRect.left() + myRect.width());
myRect.setWidth(option.rect.width() * fuzzy / total);
painter->fillRect(myRect, m_colorScheme.foreground(KColorScheme::NeutralText));
// painter->drawText(myRect,Qt::AlignRight,QString("%1").arg(data.width()));
myRect.setLeft(myRect.left() + myRect.width());
myRect.setWidth(option.rect.width() - myRect.left() + option.rect.left());
painter->fillRect(myRect, m_colorScheme.foreground(KColorScheme::NegativeText));
// painter->drawText(myRect,Qt::AlignRight,QString("%1").arg(data.top()));
}
else if (total == -1)
painter->fillRect(option.rect,Qt::transparent);
else if (total == 0)
painter->fillRect(option.rect,QBrush(Qt::gray));
}
void KNMusicHeaderPlayer::onActionMouseInOut(const QVariant &value)
{
//Translate the value to rect.
QRect currentPos=value.toRect();
//Calculate the opacity.
qreal opacity=qAbs(currentPos.height()==0?
1:(qreal)currentPos.y()/(qreal)currentPos.height());
//Make sure the opacity is in the range.
if(opacity>1.0)
{
opacity=1.0;
}
else if(opacity<0.0)
{
opacity=0.0;
}
//Apply the opacity to album art, title and artist-album labels.
m_informationEffect->setOpacity(opacity);
m_title->setOpacity(opacity);
m_artistAlbum->setOpacity(opacity);
//Update the duration label.
updateDurationPalette((1.0-opacity)*255.0);
}
void
RectCustomProperty::setValue(const QVariant &value, bool rememberOldValue)
{
if(!m_property)
return;
if(m_property->parent()) {
QRect r = m_property->parent()->value().toRect();
if(m_property->type() == Rect_X) {
//changing x component of Rect shouldn't change width
const int delta = value.toInt() - r.x();
r.setX(value.toInt());
r.setWidth(r.width()+delta);
}
else if(m_property->type() == Rect_Y) {
//changing y component of Rect shouldn't change height
const int delta = value.toInt() - r.y();
r.setY(value.toInt());
r.setHeight(r.height()+delta);
}
else if(m_property->type() == Rect_Width)
r.setWidth(value.toInt());
else if(m_property->type() == Rect_Height)
r.setHeight(value.toInt());
m_property->parent()->setValue(r, true, false);
}
else {
QRect r = value.toRect();
m_property->child("x")->setValue(r.x(), rememberOldValue, false);
m_property->child("y")->setValue(r.y(), rememberOldValue, false);
m_property->child("width")->setValue(r.width(), rememberOldValue, false);
m_property->child("height")->setValue(r.height(), rememberOldValue, false);
}
}
bool QHangulPlatformInputContext::popupCandidateList() {
const ucschar *text = hangul_ic_get_preedit_string(m_hic);
if (text != NULL && *text != 0) {
QString str;
str += QChar(text[0]);
HanjaList *list = hanja_table_match_suffix(hanjaTable, str.toUtf8());
if (m_candidateList == NULL)
m_candidateList = new CandidateList();
QPoint p(0, 0);
QWidget *focus = qobject_cast<QWidget *>(m_focusObject);
if (focus != NULL) {
QVariant v = focus->inputMethodQuery(Qt::ImMicroFocus);
QRect r = v.toRect();
p = focus->mapToGlobal(QPoint(r.right(), r.bottom()));
}
m_candidateList->open(list, p.x(), p.y());
}
return false;
}
QString PropertyField::valueToString(QVariant val)
{
QString text;
switch (val.type()) {
case QVariant::Double:
text = QString("%1").arg(val.toReal(), 0, 'f', 4);
break;
case QVariant::Size:
text = QString("%1 x %2").arg(val.toSize().width()).arg(val.toSize().height());
break;
case QVariant::SizeF:
text = QString("%1 x %2").arg(val.toSizeF().width()).arg(val.toSizeF().height());
break;
case QVariant::Rect: {
QRect rect = val.toRect();
text = QString("%1 x %2 %3%4 %5%6").arg(rect.width())
.arg(rect.height()).arg(rect.x() < 0 ? "" : "+").arg(rect.x())
.arg(rect.y() < 0 ? "" : "+").arg(rect.y());
} break;
default:
text = val.toString();
}
return text;
}
bool GCF::Message::encodeVariant(QDataStream& ds, const QVariant& value)
{
QString typeName;
if( value.isValid() )
{
typeName = QString(value.typeName());
if( typeName.isEmpty() )
return false;
}
else
typeName = "Invalid";
if( value.type() >= QVariant::UserType )
return false;
// Prepare the typename in-case of bool, char, int, double
switch(value.type())
{
case QVariant::Int:
typeName = is32Bit() ? "qint32" : "qint64";
break;
case QVariant::Char:
typeName = "quint8";
break;
case QVariant::UInt:
typeName = is32Bit() ? "quint32" : "quint64";
break;
default:
break;
}
// Serialize value on to the byte array
switch( value.type() )
{
case QVariant::Invalid:
ds << typeName;
ds << qint32(0);
break;
case QVariant::Bool:
ds << typeName;
ds << value.toBool();
break;
case QVariant::Char:
ds << typeName;
ds << value.toChar();
break;
case QVariant::Color:
ds << typeName;
ds << value.value<QColor>();
break;
case QVariant::Date:
ds << typeName;
ds << value.toDate();
break;
case QVariant::DateTime:
ds << typeName;
ds << value.toDateTime();
break;
case QVariant::Double:
ds << typeName;
ds << value.toDouble();
break;
case QVariant::Int:
ds << typeName;
if( is32Bit() )
ds << (qint32)value.toInt();
else
ds << (qint64)value.toInt();
break;
case QVariant::Time:
ds << typeName;
ds << value.toTime();
break;
case QVariant::UInt:
ds << typeName;
if( is32Bit() )
ds << (quint32)value.toUInt();
else
ds << (quint64)value.toUInt();
break;
case QVariant::String:
ds << typeName;
ds << value.toString();
break;
case QVariant::Pixmap:
ds << typeName;
ds << value.value<QPixmap>();
break;
case QVariant::ByteArray:
ds << typeName;
ds << value.toByteArray();
break;
case QVariant::BitArray:
ds << typeName;
ds << value.toBitArray();
break;
case QVariant::Image:
ds << typeName;
ds << value.value<QImage>();
break;
case QVariant::Url:
ds << typeName;
ds << value.toUrl();
break;
case QVariant::StringList:
ds << typeName;
ds << value.toStringList();
break;
case QVariant::SizePolicy:
ds << typeName;
ds << value.value<QSizePolicy>();
break;
case QVariant::SizeF:
ds << typeName;
ds << value.toSizeF();
break;
case QVariant::Size:
ds << typeName;
ds << value.toSize();
break;
case QVariant::RegExp:
ds << typeName;
ds << value.toRegExp();
break;
case QVariant::RectF:
ds << typeName;
ds << value.toRectF();
break;
case QVariant::Rect:
ds << typeName;
ds << value.toRect();
break;
case QVariant::Polygon:
ds << typeName;
ds << value.value<QPolygon>();
break;
case QVariant::PointF:
ds << typeName;
ds << value.toPointF();
break;
case QVariant::Point:
ds << typeName;
ds << value.toPoint();
break;
case QVariant::Matrix:
ds << typeName;
ds << value.value<QMatrix>();
break;
case QVariant::LineF:
ds << typeName;
ds << value.toLineF();
break;
case QVariant::Line:
ds << typeName;
ds << value.toLine();
break;
case QVariant::Brush:
ds << typeName;
ds << value.value<QBrush>();
break;
case QVariant::Bitmap:
ds << typeName;
ds << value.value<QBitmap>();
break;
case QVariant::Transform:
ds << typeName;
ds << value.value<QTransform>();
break;
default:
// Other types will be supported shortly.
// TODO: support user defined types.
return false;
}
return true;
}
QString VariantHandler::displayString(const QVariant& value)
{
switch (value.type()) {
#ifndef QT_NO_CURSOR
case QVariant::Cursor:
{
const QCursor cursor = value.value<QCursor>();
return Util::enumToString(QVariant::fromValue<int>(cursor.shape()), "Qt::CursorShape");
}
#endif
case QVariant::Icon:
{
const QIcon icon = value.value<QIcon>();
if (icon.isNull()) {
return QObject::tr("<no icon>");
}
QStringList l;
foreach (const QSize &size, icon.availableSizes()) {
l.push_back(displayString(size));
}
return l.join(QLatin1String(", "));
}
case QVariant::Line:
return
QString::fromUtf8("%1 x %2 → %3 x %4").
arg(value.toLine().x1()).arg(value.toLine().y1()).
arg(value.toLine().x2()).arg(value.toLine().y2());
case QVariant::LineF:
return
QString::fromUtf8("%1 x %2 → %3 x %4").
arg(value.toLineF().x1()).arg(value.toLineF().y1()).
arg(value.toLineF().x2()).arg(value.toLineF().y2());
case QVariant::Locale:
return value.value<QLocale>().name();
case QVariant::Point:
return
QString::fromLatin1("%1x%2").
arg(value.toPoint().x()).
arg(value.toPoint().y());
case QVariant::PointF:
return
QString::fromLatin1("%1x%2").
arg(value.toPointF().x()).
arg(value.toPointF().y());
case QVariant::Rect:
return
QString::fromLatin1("%1x%2 %3x%4").
arg(value.toRect().x()).
arg(value.toRect().y()).
arg(value.toRect().width()).
arg(value.toRect().height());
case QVariant::RectF:
return
QString::fromLatin1("%1x%2 %3x%4").
arg(value.toRectF().x()).
arg(value.toRectF().y()).
arg(value.toRectF().width()).
arg(value.toRectF().height());
case QVariant::Region:
{
const QRegion region = value.value<QRegion>();
if (region.isEmpty()) {
return QLatin1String("<empty>");
}
if (region.rectCount() == 1) {
return displayString(region.rects().first());
} else {
return QString::fromLatin1("<%1 rects>").arg(region.rectCount());
}
}
case QVariant::Palette:
{
const QPalette pal = value.value<QPalette>();
if (pal == qApp->palette()) {
return QLatin1String("<inherited>");
}
return QLatin1String("<custom>");
}
case QVariant::Size:
return
QString::fromLatin1("%1x%2").
arg(value.toSize().width()).
arg(value.toSize().height());
case QVariant::SizeF:
return
QString::fromLatin1("%1x%2").
arg(value.toSizeF().width()).
arg(value.toSizeF().height());
case QVariant::StringList:
return value.toStringList().join(", ");
case QVariant::Transform:
{
const QTransform t = value.value<QTransform>();
return
QString::fromLatin1("[%1 %2 %3, %4 %5 %6, %7 %8 %9]").
arg(t.m11()).arg(t.m12()).arg(t.m13()).
arg(t.m21()).arg(t.m22()).arg(t.m23()).
arg(t.m31()).arg(t.m32()).arg(t.m33());
}
default:
break;
}
// types with dynamic type ids
if (value.type() == (QVariant::Type)qMetaTypeId<QTextLength>()) {
const QTextLength l = value.value<QTextLength>();
QString typeStr;
switch (l.type()) {
case QTextLength::VariableLength:
typeStr = QObject::tr("variable");
break;
case QTextLength::FixedLength:
typeStr = QObject::tr("fixed");
break;
case QTextLength::PercentageLength:
typeStr = QObject::tr("percentage");
break;
}
return QString::fromLatin1("%1 (%2)").arg(l.rawValue()).arg(typeStr);
}
if (value.userType() == qMetaTypeId<QPainterPath>()) {
const QPainterPath path = value.value<QPainterPath>();
if (path.isEmpty()) {
return QObject::tr("<empty>");
}
return QObject::tr("<%1 elements>").arg(path.elementCount());
}
if (value.userType() == qMetaTypeId<QMargins>()) {
const QMargins margins = value.value<QMargins>();
return QObject::tr("left: %1, top: %2, right: %3, bottom: %4")
.arg(margins.left()).arg(margins.top())
.arg(margins.right()).arg(margins.bottom());
}
if (value.canConvert<QObject*>()) {
return Util::displayString(value.value<QObject*>());
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
if (value.userType() == qMetaTypeId<QSet<QByteArray> >()) {
const QSet<QByteArray> set = value.value<QSet<QByteArray> >();
QStringList l;
foreach (const QByteArray &b, set)
l.push_back(QString::fromUtf8(b));
return l.join(", ");
}
if (value.userType() == qMetaTypeId<QSurfaceFormat>()) {
const QSurfaceFormat format = value.value<QSurfaceFormat>();
QString s;
switch (format.renderableType()) {
case QSurfaceFormat::DefaultRenderableType: s += "Default"; break;
case QSurfaceFormat::OpenGL: s += "OpenGL"; break;
case QSurfaceFormat::OpenGLES: s += "OpenGL ES"; break;
case QSurfaceFormat::OpenVG: s += "OpenVG"; break;
}
s += " (" + QString::number(format.majorVersion()) + "." + QString::number(format.minorVersion());
switch (format.profile()) {
case QSurfaceFormat::CoreProfile: s += " core"; break;
case QSurfaceFormat::CompatibilityProfile: s += " compat"; break;
case QSurfaceFormat::NoProfile: break;
}
s += ")";
s += " RGBA: " + QString::number(format.redBufferSize()) + "/" + QString::number(format.greenBufferSize())
+ "/" + QString::number(format.blueBufferSize()) + "/" + QString::number(format.alphaBufferSize());
s += " Depth: " + QString::number(format.depthBufferSize());
s += " Stencil: " + QString::number(format.stencilBufferSize());
s += " Buffer: ";
switch (format.swapBehavior()) {
case QSurfaceFormat::DefaultSwapBehavior: s += "default"; break;
case QSurfaceFormat::SingleBuffer: s += "single"; break;
case QSurfaceFormat::DoubleBuffer: s += "double"; break;
case QSurfaceFormat::TripleBuffer: s += "triple"; break;
default: s += "unknown";
}
return s;
}
if (value.userType() == qMetaTypeId<QSurface::SurfaceClass>()) {
const QSurface::SurfaceClass sc = value.value<QSurface::SurfaceClass>();
switch (sc) {
case QSurface::Window: return QObject::tr("Window");
#if QT_VERSION > QT_VERSION_CHECK(5, 1, 0)
case QSurface::Offscreen: return QObject::tr("Offscreen");
#endif
default: return QObject::tr("Unknown Surface Class");
}
}
if (value.userType() == qMetaTypeId<QSurface::SurfaceType>()) {
const QSurface::SurfaceType type = value.value<QSurface::SurfaceType>();
switch (type) {
case QSurface::RasterSurface: return QObject::tr("Raster");
case QSurface::OpenGLSurface: return QObject::tr("OpenGL");
default: return QObject::tr("Unknown Surface Type");
}
}
#endif
// enums
const QString enumStr = Util::enumToString(value);
if (!enumStr.isEmpty()) {
return enumStr;
}
// custom converters
const QHash<int, Converter<QString>*>::const_iterator it = s_variantHandlerRepository()->stringConverters.constFind(value.userType());
if (it != s_variantHandlerRepository()->stringConverters.constEnd()) {
return (*it.value())(value);
}
return value.toString();
}
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.
/*qt4 FIXME const QMetaObject* objmeta = obj->metaObject();
int i = objmeta->findProperty(propertyName, true);
if (i == -1)
{
PyErr_SetString(PyExc_ValueError,
QObject::tr("Property not found"));
return NULL;
}
const QMetaProperty* propmeta = objmeta->property(i, true);
assert(propmeta);
*/
// 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 NULL;
}
// Return the resulting Python object
if (resultobj == NULL)
{
// An exception was set while assigning to resultobj
assert(PyErr_Occurred());
return NULL;
}
else
return resultobj;
}
// Apply a simple variant type to a DOM property
static bool applySimpleProperty(const QVariant &v, bool translateString, DomProperty *dom_prop)
{
switch (v.type()) {
case QVariant::String: {
DomString *str = new DomString();
str->setText(v.toString());
if (!translateString)
str->setAttributeNotr(QStringLiteral("true"));
dom_prop->setElementString(str);
}
return true;
case QVariant::ByteArray:
dom_prop->setElementCstring(QString::fromUtf8(v.toByteArray()));
return true;
case QVariant::Int:
dom_prop->setElementNumber(v.toInt());
return true;
case QVariant::UInt:
dom_prop->setElementUInt(v.toUInt());
return true;
case QVariant::LongLong:
dom_prop->setElementLongLong(v.toLongLong());
return true;
case QVariant::ULongLong:
dom_prop->setElementULongLong(v.toULongLong());
return true;
case QVariant::Double:
dom_prop->setElementDouble(v.toDouble());
return true;
case QVariant::Bool:
dom_prop->setElementBool(v.toBool() ? QFormBuilderStrings::instance().trueValue : QFormBuilderStrings::instance().falseValue);
return true;
case QVariant::Char: {
DomChar *ch = new DomChar();
const QChar character = v.toChar();
ch->setElementUnicode(character.unicode());
dom_prop->setElementChar(ch);
}
return true;
case QVariant::Point: {
DomPoint *pt = new DomPoint();
const QPoint point = v.toPoint();
pt->setElementX(point.x());
pt->setElementY(point.y());
dom_prop->setElementPoint(pt);
}
return true;
case QVariant::PointF: {
DomPointF *ptf = new DomPointF();
const QPointF pointf = v.toPointF();
ptf->setElementX(pointf.x());
ptf->setElementY(pointf.y());
dom_prop->setElementPointF(ptf);
}
return true;
case QVariant::Color: {
DomColor *clr = new DomColor();
const QColor color = qvariant_cast<QColor>(v);
clr->setElementRed(color.red());
clr->setElementGreen(color.green());
clr->setElementBlue(color.blue());
const int alphaChannel = color.alpha();
if (alphaChannel != 255)
clr->setAttributeAlpha(alphaChannel);
dom_prop->setElementColor(clr);
}
return true;
case QVariant::Size: {
DomSize *sz = new DomSize();
const QSize size = v.toSize();
sz->setElementWidth(size.width());
sz->setElementHeight(size.height());
dom_prop->setElementSize(sz);
}
return true;
case QVariant::SizeF: {
DomSizeF *szf = new DomSizeF();
const QSizeF sizef = v.toSizeF();
szf->setElementWidth(sizef.width());
szf->setElementHeight(sizef.height());
dom_prop->setElementSizeF(szf);
}
return true;
case QVariant::Rect: {
DomRect *rc = new DomRect();
const QRect rect = v.toRect();
rc->setElementX(rect.x());
rc->setElementY(rect.y());
rc->setElementWidth(rect.width());
rc->setElementHeight(rect.height());
dom_prop->setElementRect(rc);
}
return true;
case QVariant::RectF: {
DomRectF *rcf = new DomRectF();
const QRectF rectf = v.toRectF();
rcf->setElementX(rectf.x());
rcf->setElementY(rectf.y());
rcf->setElementWidth(rectf.width());
rcf->setElementHeight(rectf.height());
dom_prop->setElementRectF(rcf);
}
return true;
case QVariant::Font: {
DomFont *fnt = new DomFont();
const QFont font = qvariant_cast<QFont>(v);
const uint mask = font.resolve();
if (mask & QFont::WeightResolved) {
fnt->setElementBold(font.bold());
fnt->setElementWeight(font.weight());
}
if (mask & QFont::FamilyResolved)
fnt->setElementFamily(font.family());
if (mask & QFont::StyleResolved)
fnt->setElementItalic(font.italic());
if (mask & QFont::SizeResolved)
fnt->setElementPointSize(font.pointSize());
if (mask & QFont::StrikeOutResolved)
fnt->setElementStrikeOut(font.strikeOut());
if (mask & QFont::UnderlineResolved)
fnt->setElementUnderline(font.underline());
if (mask & QFont::KerningResolved)
fnt->setElementKerning(font.kerning());
if (mask & QFont::StyleStrategyResolved) {
const QMetaEnum styleStrategy_enum = metaEnum<QAbstractFormBuilderGadget>("styleStrategy");
fnt->setElementStyleStrategy(QLatin1String(styleStrategy_enum.valueToKey(font.styleStrategy())));
}
dom_prop->setElementFont(fnt);
}
return true;
#ifndef QT_NO_CURSOR
case QVariant::Cursor: {
const QMetaEnum cursorShape_enum = metaEnum<QAbstractFormBuilderGadget>("cursorShape");
dom_prop->setElementCursorShape(QLatin1String(cursorShape_enum.valueToKey(qvariant_cast<QCursor>(v).shape())));
}
return true;
#endif
case QVariant::KeySequence: {
DomString *s = new DomString();
s->setText(qvariant_cast<QKeySequence>(v).toString(QKeySequence::PortableText));
dom_prop->setElementString(s);
}
return true;
case QVariant::Locale: {
DomLocale *dom = new DomLocale();
const QLocale locale = qvariant_cast<QLocale>(v);
const QMetaEnum language_enum = metaEnum<QAbstractFormBuilderGadget>("language");
const QMetaEnum country_enum = metaEnum<QAbstractFormBuilderGadget>("country");
dom->setAttributeLanguage(QLatin1String(language_enum.valueToKey(locale.language())));
dom->setAttributeCountry(QLatin1String(country_enum.valueToKey(locale.country())));
dom_prop->setElementLocale(dom);
}
return true;
case QVariant::SizePolicy: {
DomSizePolicy *dom = new DomSizePolicy();
const QSizePolicy sizePolicy = qvariant_cast<QSizePolicy>(v);
dom->setElementHorStretch(sizePolicy.horizontalStretch());
dom->setElementVerStretch(sizePolicy.verticalStretch());
const QMetaEnum sizeType_enum = metaEnum<QAbstractFormBuilderGadget>("sizeType");
dom->setAttributeHSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.horizontalPolicy())));
dom->setAttributeVSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.verticalPolicy())));
dom_prop->setElementSizePolicy(dom);
}
return true;
case QVariant::Date: {
DomDate *dom = new DomDate();
const QDate date = qvariant_cast<QDate>(v);
dom->setElementYear(date.year());
dom->setElementMonth(date.month());
dom->setElementDay(date.day());
dom_prop->setElementDate(dom);
}
return true;
case QVariant::Time: {
DomTime *dom = new DomTime();
const QTime time = qvariant_cast<QTime>(v);
dom->setElementHour(time.hour());
dom->setElementMinute(time.minute());
dom->setElementSecond(time.second());
dom_prop->setElementTime(dom);
}
return true;
case QVariant::DateTime: {
DomDateTime *dom = new DomDateTime();
const QDateTime dateTime = qvariant_cast<QDateTime>(v);
dom->setElementHour(dateTime.time().hour());
dom->setElementMinute(dateTime.time().minute());
dom->setElementSecond(dateTime.time().second());
dom->setElementYear(dateTime.date().year());
dom->setElementMonth(dateTime.date().month());
dom->setElementDay(dateTime.date().day());
dom_prop->setElementDateTime(dom);
}
return true;
case QVariant::Url: {
DomUrl *dom = new DomUrl();
const QUrl url = v.toUrl();
DomString *str = new DomString();
str->setText(url.toString());
dom->setElementString(str);
dom_prop->setElementUrl(dom);
}
return true;
case QVariant::StringList: {
DomStringList *sl = new DomStringList;
sl->setElementString(qvariant_cast<QStringList>(v));
dom_prop->setElementStringList(sl);
}
return true;
default:
break;
}
return false;
}
