alecs/plasma-framework
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Apply the astyle-kdelibs script

Browse Source
This commit is contained in:
Kevin Ottens 2014-04-26 01:45:47 +02:00
parent c2aa81e2d4
commit 72ba7b4146
210 changed files with 4821 additions and 4923 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
autotests/configloadertest.cpp
View File

@ -54,70 +54,70 @@ void ConfigLoaderTest::cleanup()
void ConfigLoaderTest::boolDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemBool*, "DefaultBoolItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemBool *, "DefaultBoolItem");
QVERIFY(typeItem->isEqual(true));
}
void ConfigLoaderTest::colorDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemColor*, "DefaultColorItem");
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemColor *, "DefaultColorItem");
QVERIFY(typeItem->isEqual(QColor("#00FF00")));
}
void ConfigLoaderTest::dateTimeDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemDateTime*, "DefaultDateTimeItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemDateTime *, "DefaultDateTimeItem");
QVERIFY(typeItem->isEqual(QDateTime::fromString("Thu Sep 09 2010")));
}
void ConfigLoaderTest::enumDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemEnum*, "DefaultEnumItem");
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemEnum *, "DefaultEnumItem");
QVERIFY(typeItem->isEqual(3));
}
void ConfigLoaderTest::fontDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemFont*, "DefaultFontItem");
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemFont *, "DefaultFontItem");
QVERIFY(typeItem->isEqual(QFont("DejaVu Sans")));
}
void ConfigLoaderTest::intDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemInt*, "DefaultIntItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemInt *, "DefaultIntItem");
QVERIFY(typeItem->isEqual(27));
}
void ConfigLoaderTest::passwordDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemPassword*, "DefaultPasswordItem");
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemPassword *, "DefaultPasswordItem");
QVERIFY(typeItem->isEqual(QString::fromLatin1("h4x.")));
}
void ConfigLoaderTest::pathDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemPath*, "DefaultPathItem");
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemPath *, "DefaultPathItem");
QVERIFY(typeItem->isEqual(QString::fromLatin1("/dev/null")));
}
void ConfigLoaderTest::stringDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemString*, "DefaultStringItem");
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemString *, "DefaultStringItem");
QVERIFY(typeItem->isEqual(QString::fromLatin1("TestString")));
}
void ConfigLoaderTest::stringListDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemStringList*, "DefaultStringListItem");
GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemStringList *, "DefaultStringListItem");
// Create a string list with the expected values.
QStringList expected;
@ -132,28 +132,28 @@ void ConfigLoaderTest::stringListDefaultValue()
void ConfigLoaderTest::uintDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemUInt*, "DefaultUIntItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemUInt *, "DefaultUIntItem");
QVERIFY(typeItem->isEqual(7U));
}
void ConfigLoaderTest::urlDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemUrl*, "DefaultUrlItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemUrl *, "DefaultUrlItem");
QVERIFY(typeItem->isEqual(QUrl("http://kde.org")));
}
void ConfigLoaderTest::doubleDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemDouble*, "DefaultDoubleItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemDouble *, "DefaultDoubleItem");
QVERIFY(typeItem->isEqual(13.37));
}
void ConfigLoaderTest::intListDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemIntList*, "DefaultIntListItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemIntList *, "DefaultIntListItem");
// Create a int list with the expected values.
QList<int> expected;
@ -169,21 +169,21 @@ void ConfigLoaderTest::intListDefaultValue()
void ConfigLoaderTest::longLongDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemLongLong*, "DefaultLongLongItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemLongLong *, "DefaultLongLongItem");
QVERIFY(typeItem->isEqual(Q_INT64_C(-9211372036854775808)));
}
void ConfigLoaderTest::pointDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemPoint*, "DefaultPointItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemPoint *, "DefaultPointItem");
QVERIFY(typeItem->isEqual(QPoint(185, 857)));
}
void ConfigLoaderTest::rectDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemRect*, "DefaultRectItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemRect *, "DefaultRectItem");
// Create a new QRect with the expected value.
QRect expected;
@ -194,19 +194,17 @@ void ConfigLoaderTest::rectDefaultValue()
void ConfigLoaderTest::sizeDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemSize*, "DefaultSizeItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemSize *, "DefaultSizeItem");
QVERIFY(typeItem->isEqual(QSize(640, 480)));
}
void ConfigLoaderTest::ulongLongDefaultValue()
{
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemULongLong*, "DefaultULongLongItem");
GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemULongLong *, "DefaultULongLongItem");
QVERIFY(typeItem->isEqual(Q_UINT64_C(9223372036854775806)));
}
QTEST_MAIN(ConfigLoaderTest)

6
autotests/configloadertest.h
View File

@ -24,7 +24,7 @@
namespace Plasma
{
class ConfigLoader;
class ConfigLoader;
}
class QFile;
@ -59,8 +59,8 @@ private Q_SLOTS:
void ulongLongDefaultValue();
private:
Plasma::ConfigLoader* cl;
QFile* configFile;
Plasma::ConfigLoader *cl;
QFile *configFile;
};
#endif

245
autotests/dynamictreemodel.cpp
View File

@ -45,10 +45,9 @@
#include <QtCore/QList>
#include <QtCore/QTimer>
DynamicTreeModel::DynamicTreeModel(QObject *parent)
: QAbstractItemModel(parent),
nextId(1)
: QAbstractItemModel(parent),
nextId(1)
{
}
@ -57,125 +56,130 @@ QModelIndex DynamicTreeModel::index(int row, int column, const QModelIndex &pare
// if (column != 0)
// return QModelIndex();
if (column < 0 || row < 0) {
return QModelIndex();
}
if ( column < 0 || row < 0 )
return QModelIndex();
QList<QList<qint64> > childIdColumns = m_childItems.value(parent.internalId());
QList<QList<qint64> > childIdColumns = m_childItems.value(parent.internalId());
const qint64 grandParent = findParentId(parent.internalId());
if (grandParent >= 0) {
QList<QList<qint64> > parentTable = m_childItems.value(grandParent);
Q_ASSERT(parent.column() < parentTable.size());
QList<qint64> parentSiblings = parentTable.at(parent.column());
Q_ASSERT(parent.row() < parentSiblings.size());
}
const qint64 grandParent = findParentId(parent.internalId());
if (grandParent >= 0) {
QList<QList<qint64> > parentTable = m_childItems.value(grandParent);
Q_ASSERT(parent.column() < parentTable.size());
QList<qint64> parentSiblings = parentTable.at(parent.column());
Q_ASSERT(parent.row() < parentSiblings.size());
}
if (childIdColumns.size() == 0) {
return QModelIndex();
}
if (childIdColumns.size() == 0)
return QModelIndex();
if (column >= childIdColumns.size()) {
return QModelIndex();
}
if (column >= childIdColumns.size())
return QModelIndex();
QList<qint64> rowIds = childIdColumns.at(column);
QList<qint64> rowIds = childIdColumns.at(column);
if (row >= rowIds.size()) {
return QModelIndex();
}
if ( row >= rowIds.size())
return QModelIndex();
qint64 id = rowIds.at(row);
qint64 id = rowIds.at(row);
return createIndex(row, column, reinterpret_cast<void *>(id));
return createIndex(row, column, reinterpret_cast<void *>(id));
}
qint64 DynamicTreeModel::findParentId(qint64 searchId) const
{
if (searchId <= 0)
return -1;
QHashIterator<qint64, QList<QList<qint64> > > i(m_childItems);
while (i.hasNext())
{
i.next();
QListIterator<QList<qint64> > j(i.value());
while (j.hasNext())
{
QList<qint64> l = j.next();
if (l.contains(searchId))
{
return i.key();
}
if (searchId <= 0) {
return -1;
}
}
return -1;
QHashIterator<qint64, QList<QList<qint64> > > i(m_childItems);
while (i.hasNext()) {
i.next();
QListIterator<QList<qint64> > j(i.value());
while (j.hasNext()) {
QList<qint64> l = j.next();
if (l.contains(searchId)) {
return i.key();
}
}
}
return -1;
}
QModelIndex DynamicTreeModel::parent(const QModelIndex &index) const
{
if (!index.isValid())
return QModelIndex();
if (!index.isValid()) {
return QModelIndex();
}
qint64 searchId = index.internalId();
qint64 parentId = findParentId(searchId);
// Will never happen for valid index, but what the hey...
if (parentId <= 0)
return QModelIndex();
qint64 searchId = index.internalId();
qint64 parentId = findParentId(searchId);
// Will never happen for valid index, but what the hey...
if (parentId <= 0) {
return QModelIndex();
}
qint64 grandParentId = findParentId(parentId);
if (grandParentId < 0)
grandParentId = 0;
qint64 grandParentId = findParentId(parentId);
if (grandParentId < 0) {
grandParentId = 0;
}
int column = 0;
QList<qint64> childList = m_childItems.value(grandParentId).at(column);
int column = 0;
QList<qint64> childList = m_childItems.value(grandParentId).at(column);
int row = childList.indexOf(parentId);
int row = childList.indexOf(parentId);
return createIndex(row, column, reinterpret_cast<void *>(parentId));
return createIndex(row, column, reinterpret_cast<void *>(parentId));
}
int DynamicTreeModel::rowCount(const QModelIndex &index ) const
int DynamicTreeModel::rowCount(const QModelIndex &index) const
{
QList<QList<qint64> > cols = m_childItems.value(index.internalId());
QList<QList<qint64> > cols = m_childItems.value(index.internalId());
if (cols.size() == 0 )
return 0;
if (cols.size() == 0) {
return 0;
}
if (index.column() > 0)
return 0;
if (index.column() > 0) {
return 0;
}
return cols.at(0).size();
return cols.at(0).size();
}
int DynamicTreeModel::columnCount(const QModelIndex &index ) const
int DynamicTreeModel::columnCount(const QModelIndex &index) const
{
// Q_UNUSED(index);
return m_childItems.value(index.internalId()).size();
return m_childItems.value(index.internalId()).size();
}
QVariant DynamicTreeModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
if (!index.isValid()) {
return QVariant();
}
if (Qt::DisplayRole == role)
{
return m_items.value(index.internalId());
}
return QVariant();
if (Qt::DisplayRole == role) {
return m_items.value(index.internalId());
}
return QVariant();
}
void DynamicTreeModel::clear()
{
beginResetModel();
m_items.clear();
m_childItems.clear();
nextId = 1;
endResetModel();
beginResetModel();
m_items.clear();
m_childItems.clear();
nextId = 1;
endResetModel();
}
ModelChangeCommand::ModelChangeCommand( DynamicTreeModel *model, QObject *parent )
ModelChangeCommand::ModelChangeCommand(DynamicTreeModel *model, QObject *parent)
: QObject(parent), m_model(model), m_numCols(1), m_startRow(-1), m_endRow(-1)
{
@ -183,18 +187,17 @@ ModelChangeCommand::ModelChangeCommand( DynamicTreeModel *model, QObject *parent
QModelIndex ModelChangeCommand::findIndex(QList<int> rows)
{
const int col = 0;
QModelIndex parent = QModelIndex();
QListIterator<int> i(rows);
while (i.hasNext())
{
parent = m_model->index(i.next(), col, parent);
Q_ASSERT(parent.isValid());
}
return parent;
const int col = 0;
QModelIndex parent = QModelIndex();
QListIterator<int> i(rows);
while (i.hasNext()) {
parent = m_model->index(i.next(), col, parent);
Q_ASSERT(parent.isValid());
}
return parent;
}
ModelInsertCommand::ModelInsertCommand(DynamicTreeModel *model, QObject *parent )
ModelInsertCommand::ModelInsertCommand(DynamicTreeModel *model, QObject *parent)
: ModelChangeCommand(model, parent)
{
@ -202,38 +205,34 @@ ModelInsertCommand::ModelInsertCommand(DynamicTreeModel *model, QObject *parent
void ModelInsertCommand::doCommand()
{
QModelIndex parent = findIndex(m_rowNumbers);
m_model->beginInsertRows(parent, m_startRow, m_endRow);
qint64 parentId = parent.internalId();
for (int row = m_startRow; row <= m_endRow; row++)
{
for(int col = 0; col < m_numCols; col++ )
{
if (m_model->m_childItems[parentId].size() <= col)
{
m_model->m_childItems[parentId].append(QList<qint64>());
}
QModelIndex parent = findIndex(m_rowNumbers);
m_model->beginInsertRows(parent, m_startRow, m_endRow);
qint64 parentId = parent.internalId();
for (int row = m_startRow; row <= m_endRow; row++) {
for (int col = 0; col < m_numCols; col++) {
if (m_model->m_childItems[parentId].size() <= col) {
m_model->m_childItems[parentId].append(QList<qint64>());
}
// QString name = QUuid::createUuid().toString();
qint64 id = m_model->newId();
QString name = QString::number(id);
qint64 id = m_model->newId();
QString name = QString::number(id);
m_model->m_items.insert(id, name);
m_model->m_childItems[parentId][col].insert(row, id);
m_model->m_items.insert(id, name);
m_model->m_childItems[parentId][col].insert(row, id);
}
}
}
m_model->endInsertRows();
m_model->endInsertRows();
}
ModelMoveCommand::ModelMoveCommand(DynamicTreeModel *model, QObject *parent)
: ModelChangeCommand(model, parent)
: ModelChangeCommand(model, parent)
{
}
bool ModelMoveCommand::emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow)
{
return m_model->beginMoveRows(srcParent, srcStart, srcEnd, destParent, destRow);
return m_model->beginMoveRows(srcParent, srcStart, srcEnd, destParent, destRow);
}
void ModelMoveCommand::doCommand()
@ -241,32 +240,28 @@ void ModelMoveCommand::doCommand()
QModelIndex srcParent = findIndex(m_rowNumbers);
QModelIndex destParent = findIndex(m_destRowNumbers);
if (!emitPreSignal(srcParent, m_startRow, m_endRow, destParent, m_destRow))
{
if (!emitPreSignal(srcParent, m_startRow, m_endRow, destParent, m_destRow)) {
return;
}
for (int column = 0; column < m_numCols; ++column)
{
QList<qint64> l = m_model->m_childItems.value(srcParent.internalId())[column].mid(m_startRow, m_endRow - m_startRow + 1 );
for (int column = 0; column < m_numCols; ++column) {
QList<qint64> l = m_model->m_childItems.value(srcParent.internalId())[column].mid(m_startRow, m_endRow - m_startRow + 1);
for (int i = m_startRow; i <= m_endRow ; i++)
{
for (int i = m_startRow; i <= m_endRow; i++) {
m_model->m_childItems[srcParent.internalId()][column].removeAt(m_startRow);
}
int d;
if (m_destRow < m_startRow)
if (m_destRow < m_startRow) {
d = m_destRow;
else
{
if (srcParent == destParent)
} else {
if (srcParent == destParent) {
d = m_destRow - (m_endRow - m_startRow + 1);
else
} else {
d = m_destRow - (m_endRow - m_startRow) + 1;
}
}
foreach(const qint64 id, l)
{
foreach (const qint64 id, l) {
m_model->m_childItems[destParent.internalId()][column].insert(d++, id);
}
}
@ -279,8 +274,8 @@ void ModelMoveCommand::emitPostSignal()
m_model->endMoveRows();
}
ModelResetCommand::ModelResetCommand(DynamicTreeModel* model, QObject* parent)
: ModelMoveCommand(model, parent)
ModelResetCommand::ModelResetCommand(DynamicTreeModel *model, QObject *parent)
: ModelMoveCommand(model, parent)
{
}
@ -306,8 +301,8 @@ void ModelResetCommand::emitPostSignal()
m_model->reset();
}
ModelResetCommandFixed::ModelResetCommandFixed(DynamicTreeModel* model, QObject* parent)
: ModelMoveCommand(model, parent)
ModelResetCommandFixed::ModelResetCommandFixed(DynamicTreeModel *model, QObject *parent)
: ModelMoveCommand(model, parent)
{
}

153
autotests/dynamictreemodel.h
View File

@ -47,118 +47,136 @@
#include <QtCore/QHash>
#include <QtCore/QList>
class DynamicTreeModel : public QAbstractItemModel
{
Q_OBJECT
Q_OBJECT
public:
DynamicTreeModel(QObject *parent = 0);
DynamicTreeModel(QObject *parent = 0);
QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
QModelIndex parent(const QModelIndex &index) const;
int rowCount(const QModelIndex &index = QModelIndex()) const;
int columnCount(const QModelIndex &index = QModelIndex()) const;
QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
QModelIndex parent(const QModelIndex &index) const;
int rowCount(const QModelIndex &index = QModelIndex()) const;
int columnCount(const QModelIndex &index = QModelIndex()) const;
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
void clear();
void clear();
protected Q_SLOTS:
/**
Finds the parent id of the string with id @p searchId.
/**
Finds the parent id of the string with id @p searchId.
Returns -1 if not found.
*/
qint64 findParentId(qint64 searchId) const;
Returns -1 if not found.
*/
qint64 findParentId(qint64 searchId) const;
private:
QHash<qint64, QString> m_items;
QHash<qint64, QList<QList<qint64> > > m_childItems;
qint64 nextId;
qint64 newId() { return nextId++; };
QHash<qint64, QString> m_items;
QHash<qint64, QList<QList<qint64> > > m_childItems;
qint64 nextId;
qint64 newId()
{
return nextId++;
};
QModelIndex m_nextParentIndex;
int m_nextRow;
QModelIndex m_nextParentIndex;
int m_nextRow;
int m_depth;
int maxDepth;
int m_depth;
int maxDepth;
friend class ModelInsertCommand;
friend class ModelMoveCommand;
friend class ModelResetCommand;
friend class ModelResetCommandFixed;
friend class ModelInsertCommand;
friend class ModelMoveCommand;
friend class ModelResetCommand;
friend class ModelResetCommandFixed;
};
class ModelChangeCommand : public QObject
{
Q_OBJECT
Q_OBJECT
public:
explicit ModelChangeCommand( DynamicTreeModel *model, QObject *parent = 0 );
explicit ModelChangeCommand(DynamicTreeModel *model, QObject *parent = 0);
virtual ~ModelChangeCommand() {}
virtual ~ModelChangeCommand() {}
void setAncestorRowNumbers(QList<int> rowNumbers) { m_rowNumbers = rowNumbers; }
void setAncestorRowNumbers(QList<int> rowNumbers)
{
m_rowNumbers = rowNumbers;
}
QModelIndex findIndex(QList<int> rows);
QModelIndex findIndex(QList<int> rows);
void setStartRow(int row) { m_startRow = row; }
void setStartRow(int row)
{
m_startRow = row;
}
void setEndRow(int row) { m_endRow = row; }
void setEndRow(int row)
{
m_endRow = row;
}
void setNumCols(int cols) { m_numCols = cols; }
void setNumCols(int cols)
{
m_numCols = cols;
}
virtual void doCommand() = 0;
virtual void doCommand() = 0;
protected:
DynamicTreeModel* m_model;
QList<int> m_rowNumbers;
int m_numCols;
int m_startRow;
int m_endRow;
DynamicTreeModel *m_model;
QList<int> m_rowNumbers;
int m_numCols;
int m_startRow;
int m_endRow;
};
typedef QList<ModelChangeCommand*> ModelChangeCommandList;
typedef QList<ModelChangeCommand *> ModelChangeCommandList;
class ModelInsertCommand : public ModelChangeCommand
{
Q_OBJECT
Q_OBJECT
public:
explicit ModelInsertCommand(DynamicTreeModel *model, QObject *parent = 0 );
virtual ~ModelInsertCommand() {}
explicit ModelInsertCommand(DynamicTreeModel *model, QObject *parent = 0);
virtual ~ModelInsertCommand() {}
virtual void doCommand();
virtual void doCommand();
};
class ModelMoveCommand : public ModelChangeCommand
{
Q_OBJECT
Q_OBJECT
public:
ModelMoveCommand(DynamicTreeModel *model, QObject *parent);
ModelMoveCommand(DynamicTreeModel *model, QObject *parent);
virtual ~ModelMoveCommand() {}
virtual ~ModelMoveCommand() {}
virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
virtual void doCommand();
virtual void doCommand();
virtual void emitPostSignal();
virtual void emitPostSignal();
void setDestAncestors( QList<int> rows ) { m_destRowNumbers = rows; }
void setDestAncestors(QList<int> rows)
{
m_destRowNumbers = rows;
}
void setDestRow(int row) { m_destRow = row; }
void setDestRow(int row)
{
m_destRow = row;
}
protected:
QList<int> m_destRowNumbers;
int m_destRow;
QList<int> m_destRowNumbers;
int m_destRow;
};
/**
@ -166,14 +184,14 @@ protected:
*/
class ModelResetCommand : public ModelMoveCommand
{
Q_OBJECT
Q_OBJECT
public:
explicit ModelResetCommand(DynamicTreeModel* model, QObject* parent = 0);
explicit ModelResetCommand(DynamicTreeModel *model, QObject *parent = 0);
virtual ~ModelResetCommand();
virtual ~ModelResetCommand();
virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
virtual void emitPostSignal();
virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
virtual void emitPostSignal();
};
@ -182,16 +200,15 @@ public:
*/
class ModelResetCommandFixed : public ModelMoveCommand
{
Q_OBJECT
Q_OBJECT
public:
explicit ModelResetCommandFixed(DynamicTreeModel* model, QObject* parent = 0);
explicit ModelResetCommandFixed(DynamicTreeModel *model, QObject *parent = 0);
virtual ~ModelResetCommandFixed();
virtual ~ModelResetCommandFixed();
virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
virtual void emitPostSignal();
virtual bool emitPreSignal(const QModelIndex &srcParent, int srcStart, int srcEnd, const QModelIndex &destParent, int destRow);
virtual void emitPostSignal();
};
#endif

411
autotests/modeltest.cpp
View File

@ -39,7 +39,6 @@
**
****************************************************************************/
#include <QtGui/QtGui>
#include "modeltest.h"
@ -48,61 +47,62 @@
//#undef Q_ASSERT
//#define Q_ASSERT QVERIFY
Q_DECLARE_METATYPE ( QModelIndex )
Q_DECLARE_METATYPE(QModelIndex)
/*!
Connect to all of the models signals. Whenever anything happens recheck everything.
*/
ModelTest::ModelTest ( QAbstractItemModel *_model, QObject *parent ) : QObject ( parent ), model ( _model ), fetchingMore ( false )
ModelTest::ModelTest(QAbstractItemModel *_model, QObject *parent) : QObject(parent), model(_model), fetchingMore(false)
{
Q_ASSERT ( model );
Q_ASSERT(model);
connect ( model, SIGNAL (columnsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT (runAllTests()) );
connect ( model, SIGNAL (columnsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT (runAllTests()) );
connect ( model, SIGNAL (columnsInserted(QModelIndex,int,int)),
this, SLOT (runAllTests()) );
connect ( model, SIGNAL (columnsRemoved(QModelIndex,int,int)),
this, SLOT (runAllTests()) );
connect ( model, SIGNAL (dataChanged(QModelIndex,QModelIndex)),
this, SLOT (runAllTests()) );
connect ( model, SIGNAL (headerDataChanged(Qt::Orientation,int,int)),
this, SLOT (runAllTests()) );
connect ( model, SIGNAL (layoutAboutToBeChanged()), this, SLOT (runAllTests()) );
connect ( model, SIGNAL (layoutChanged()), this, SLOT (runAllTests()) );
connect ( model, SIGNAL (modelReset()), this, SLOT (runAllTests()) );
connect ( model, SIGNAL (rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT (runAllTests()) );
connect ( model, SIGNAL (rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT (runAllTests()) );
connect ( model, SIGNAL (rowsInserted(QModelIndex,int,int)),
this, SLOT (runAllTests()) );
connect ( model, SIGNAL (rowsRemoved(QModelIndex,int,int)),
this, SLOT (runAllTests()) );
connect(model, SIGNAL(columnsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(runAllTests()));
connect(model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(runAllTests()));
connect(model, SIGNAL(columnsInserted(QModelIndex,int,int)),
this, SLOT(runAllTests()));
connect(model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
this, SLOT(runAllTests()));
connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT(runAllTests()));
connect(model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
this, SLOT(runAllTests()));
connect(model, SIGNAL(layoutAboutToBeChanged()), this, SLOT(runAllTests()));
connect(model, SIGNAL(layoutChanged()), this, SLOT(runAllTests()));
connect(model, SIGNAL(modelReset()), this, SLOT(runAllTests()));
connect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(runAllTests()));
connect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(runAllTests()));
connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(runAllTests()));
connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(runAllTests()));
// Special checks for inserting/removing
connect ( model, SIGNAL (layoutAboutToBeChanged()),
this, SLOT (layoutAboutToBeChanged()) );
connect ( model, SIGNAL (layoutChanged()),
this, SLOT (layoutChanged()) );
connect(model, SIGNAL(layoutAboutToBeChanged()),
this, SLOT(layoutAboutToBeChanged()));
connect(model, SIGNAL(layoutChanged()),
this, SLOT(layoutChanged()));
connect ( model, SIGNAL (rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT (rowsAboutToBeInserted(QModelIndex,int,int)) );
connect ( model, SIGNAL (rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT (rowsAboutToBeRemoved(QModelIndex,int,int)) );
connect ( model, SIGNAL (rowsInserted(QModelIndex,int,int)),
this, SLOT (rowsInserted(QModelIndex,int,int)) );
connect ( model, SIGNAL (rowsRemoved(QModelIndex,int,int)),
this, SLOT (rowsRemoved(QModelIndex,int,int)) );
connect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(rowsAboutToBeInserted(QModelIndex,int,int)));
connect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)));
connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(rowsInserted(QModelIndex,int,int)));
connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(rowsRemoved(QModelIndex,int,int)));
runAllTests();
}
void ModelTest::runAllTests()
{
if ( fetchingMore )
if (fetchingMore) {
return;
}
nonDestructiveBasicTest();
rowCount();
columnCount();
@ -118,32 +118,32 @@ void ModelTest::runAllTests()
*/
void ModelTest::nonDestructiveBasicTest()
{
Q_ASSERT ( model->buddy ( QModelIndex() ) == QModelIndex() );
model->canFetchMore ( QModelIndex() );
Q_ASSERT ( model->columnCount ( QModelIndex() ) >= 0 );
Q_ASSERT ( model->data ( QModelIndex() ) == QVariant() );
Q_ASSERT(model->buddy(QModelIndex()) == QModelIndex());
model->canFetchMore(QModelIndex());
Q_ASSERT(model->columnCount(QModelIndex()) >= 0);
Q_ASSERT(model->data(QModelIndex()) == QVariant());
fetchingMore = true;
model->fetchMore ( QModelIndex() );
model->fetchMore(QModelIndex());
fetchingMore = false;
Qt::ItemFlags flags = model->flags ( QModelIndex() );
Q_ASSERT ( flags == Qt::ItemIsDropEnabled || flags == 0 );
model->hasChildren ( QModelIndex() );
model->hasIndex ( 0, 0 );
model->headerData ( 0, Qt::Horizontal );
model->index ( 0, 0 );
model->itemData ( QModelIndex() );
Qt::ItemFlags flags = model->flags(QModelIndex());
Q_ASSERT(flags == Qt::ItemIsDropEnabled || flags == 0);
model->hasChildren(QModelIndex());
model->hasIndex(0, 0);
model->headerData(0, Qt::Horizontal);
model->index(0, 0);
model->itemData(QModelIndex());
QVariant cache;
model->match ( QModelIndex(), -1, cache );
model->match(QModelIndex(), -1, cache);
model->mimeTypes();
Q_ASSERT ( model->parent ( QModelIndex() ) == QModelIndex() );
Q_ASSERT ( model->rowCount() >= 0 );
Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());
Q_ASSERT(model->rowCount() >= 0);
QVariant variant;
model->setData ( QModelIndex(), variant, -1 );
model->setHeaderData ( -1, Qt::Horizontal, QVariant() );
model->setHeaderData ( 999999, Qt::Horizontal, QVariant() );
model->setData(QModelIndex(), variant, -1);
model->setHeaderData(-1, Qt::Horizontal, QVariant());
model->setHeaderData(999999, Qt::Horizontal, QVariant());
QMap<int, QVariant> roles;
model->sibling ( 0, 0, QModelIndex() );
model->span ( QModelIndex() );
model->sibling(0, 0, QModelIndex());
model->span(QModelIndex());
model->supportedDropActions();
}
@ -156,19 +156,21 @@ void ModelTest::rowCount()
{
// qDebug() << "rc";
// check top row
QModelIndex topIndex = model->index ( 0, 0, QModelIndex() );
int rows = model->rowCount ( topIndex );
Q_ASSERT ( rows >= 0 );
if ( rows > 0 )
Q_ASSERT ( model->hasChildren ( topIndex ) == true );
QModelIndex topIndex = model->index(0, 0, QModelIndex());
int rows = model->rowCount(topIndex);
Q_ASSERT(rows >= 0);
if (rows > 0) {
Q_ASSERT(model->hasChildren(topIndex) == true);
}
QModelIndex secondLevelIndex = model->index ( 0, 0, topIndex );
if ( secondLevelIndex.isValid() ) { // not the top level
QModelIndex secondLevelIndex = model->index(0, 0, topIndex);
if (secondLevelIndex.isValid()) { // not the top level
// check a row count where parent is valid
rows = model->rowCount ( secondLevelIndex );
Q_ASSERT ( rows >= 0 );
if ( rows > 0 )
Q_ASSERT ( model->hasChildren ( secondLevelIndex ) == true );
rows = model->rowCount(secondLevelIndex);
Q_ASSERT(rows >= 0);
if (rows > 0) {
Q_ASSERT(model->hasChildren(secondLevelIndex) == true);
}
}
// The models rowCount() is tested more extensively in checkChildren(),
@ -181,13 +183,14 @@ void ModelTest::rowCount()
void ModelTest::columnCount()
{
// check top row
QModelIndex topIndex = model->index ( 0, 0, QModelIndex() );
Q_ASSERT ( model->columnCount ( topIndex ) >= 0 );
QModelIndex topIndex = model->index(0, 0, QModelIndex());
Q_ASSERT(model->columnCount(topIndex) >= 0);
// check a column count where parent is valid
QModelIndex childIndex = model->index ( 0, 0, topIndex );
if ( childIndex.isValid() )
Q_ASSERT ( model->columnCount ( childIndex ) >= 0 );
QModelIndex childIndex = model->index(0, 0, topIndex);
if (childIndex.isValid()) {
Q_ASSERT(model->columnCount(childIndex) >= 0);
}
// columnCount() is tested more extensively in checkChildren(),
// but this catches the big mistakes
@ -200,19 +203,20 @@ void ModelTest::hasIndex()
{
// qDebug() << "hi";
// Make sure that invalid values returns an invalid index
Q_ASSERT ( model->hasIndex ( -2, -2 ) == false );
Q_ASSERT ( model->hasIndex ( -2, 0 ) == false );
Q_ASSERT ( model->hasIndex ( 0, -2 ) == false );
Q_ASSERT(model->hasIndex(-2, -2) == false);
Q_ASSERT(model->hasIndex(-2, 0) == false);
Q_ASSERT(model->hasIndex(0, -2) == false);
int rows = model->rowCount();
int columns = model->columnCount();
// check out of bounds
Q_ASSERT ( model->hasIndex ( rows, columns ) == false );
Q_ASSERT ( model->hasIndex ( rows + 1, columns + 1 ) == false );
Q_ASSERT(model->hasIndex(rows, columns) == false);
Q_ASSERT(model->hasIndex(rows + 1, columns + 1) == false);
if ( rows > 0 )
Q_ASSERT ( model->hasIndex ( 0, 0 ) == true );
if (rows > 0) {
Q_ASSERT(model->hasIndex(0, 0) == true);
}
// hasIndex() is tested more extensively in checkChildren(),
// but this catches the big mistakes
@ -225,24 +229,25 @@ void ModelTest::index()
{
// qDebug() << "i";
// Make sure that invalid values returns an invalid index
Q_ASSERT ( model->index ( -2, -2 ) == QModelIndex() );
Q_ASSERT ( model->index ( -2, 0 ) == QModelIndex() );
Q_ASSERT ( model->index ( 0, -2 ) == QModelIndex() );
Q_ASSERT(model->index(-2, -2) == QModelIndex());
Q_ASSERT(model->index(-2, 0) == QModelIndex());
Q_ASSERT(model->index(0, -2) == QModelIndex());
int rows = model->rowCount();
int columns = model->columnCount();
if ( rows == 0 )
if (rows == 0) {
return;
}
// Catch off by one errors
Q_ASSERT ( model->index ( rows, columns ) == QModelIndex() );
Q_ASSERT ( model->index ( 0, 0 ).isValid() == true );
Q_ASSERT(model->index(rows, columns) == QModelIndex());
Q_ASSERT(model->index(0, 0).isValid() == true);
// Make sure that the same index is *always* returned
QModelIndex a = model->index ( 0, 0 );
QModelIndex b = model->index ( 0, 0 );
Q_ASSERT ( a == b );
QModelIndex a = model->index(0, 0);
QModelIndex b = model->index(0, 0);
Q_ASSERT(a == b);
// index() is tested more extensively in checkChildren(),
// but this catches the big mistakes
@ -256,10 +261,11 @@ void ModelTest::parent()
// qDebug() << "p";
// Make sure the model wont crash and will return an invalid QModelIndex
// when asked for the parent of an invalid index.
Q_ASSERT ( model->parent ( QModelIndex() ) == QModelIndex() );
Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());
if ( model->rowCount() == 0 )
if (model->rowCount() == 0) {
return;
}
// Column 0 | Column 1 |
// QModelIndex() | |
@ -268,29 +274,29 @@ void ModelTest::parent()
// Common error test #1, make sure that a top level index has a parent
// that is a invalid QModelIndex.
QModelIndex topIndex = model->index ( 0, 0, QModelIndex() );
Q_ASSERT ( model->parent ( topIndex ) == QModelIndex() );
QModelIndex topIndex = model->index(0, 0, QModelIndex());
Q_ASSERT(model->parent(topIndex) == QModelIndex());
// Common error test #2, make sure that a second level index has a parent
// that is the first level index.
if ( model->rowCount ( topIndex ) > 0 ) {
QModelIndex childIndex = model->index ( 0, 0, topIndex );
Q_ASSERT ( model->parent ( childIndex ) == topIndex );
if (model->rowCount(topIndex) > 0) {
QModelIndex childIndex = model->index(0, 0, topIndex);
Q_ASSERT(model->parent(childIndex) == topIndex);
}
// Common error test #3, the second column should NOT have the same children
// as the first column in a row.
// Usually the second column shouldn't have children.
QModelIndex topIndex1 = model->index ( 0, 1, QModelIndex() );
if ( model->rowCount ( topIndex1 ) > 0 ) {
QModelIndex childIndex = model->index ( 0, 0, topIndex );
QModelIndex childIndex1 = model->index ( 0, 0, topIndex1 );
Q_ASSERT ( childIndex != childIndex1 );
QModelIndex topIndex1 = model->index(0, 1, QModelIndex());
if (model->rowCount(topIndex1) > 0) {
QModelIndex childIndex = model->index(0, 0, topIndex);
QModelIndex childIndex1 = model->index(0, 0, topIndex1);
Q_ASSERT(childIndex != childIndex1);
}
// Full test, walk n levels deep through the model making sure that all
// parent's children correctly specify their parent.
checkChildren ( QModelIndex() );
checkChildren(QModelIndex());
}
/*!
@ -307,62 +313,65 @@ void ModelTest::parent()
found the basic bugs because it is easier to figure out the problem in
those tests then this one.
*/
void ModelTest::checkChildren ( const QModelIndex &parent, int currentDepth )
void ModelTest::checkChildren(const QModelIndex &parent, int currentDepth)
{
// First just try walking back up the tree.
QModelIndex p = parent;
while ( p.isValid() )
while (p.isValid()) {
p = p.parent();
}
// For models that are dynamically populated
if ( model->canFetchMore ( parent ) ) {
if (model->canFetchMore(parent)) {
fetchingMore = true;
model->fetchMore ( parent );
model->fetchMore(parent);
fetchingMore = false;
}
int rows = model->rowCount ( parent );
int columns = model->columnCount ( parent );
int rows = model->rowCount(parent);
int columns = model->columnCount(parent);
if ( rows > 0 )
Q_ASSERT ( model->hasChildren ( parent ) );
if (rows > 0) {
Q_ASSERT(model->hasChildren(parent));
}
// Some further testing against rows(), columns(), and hasChildren()
Q_ASSERT ( rows >= 0 );
Q_ASSERT ( columns >= 0 );
if ( rows > 0 )
Q_ASSERT ( model->hasChildren ( parent ) == true );
Q_ASSERT(rows >= 0);
Q_ASSERT(columns >= 0);
if (rows > 0) {
Q_ASSERT(model->hasChildren(parent) == true);
}
//qDebug() << "parent:" << model->data(parent).toString() << "rows:" << rows
// << "columns:" << columns << "parent column:" << parent.column();
Q_ASSERT ( model->hasIndex ( rows + 1, 0, parent ) == false );
for ( int r = 0; r < rows; ++r ) {
if ( model->canFetchMore ( parent ) ) {
Q_ASSERT(model->hasIndex(rows + 1, 0, parent) == false);
for (int r = 0; r < rows; ++r) {
if (model->canFetchMore(parent)) {
fetchingMore = true;
model->fetchMore ( parent );
model->fetchMore(parent);
fetchingMore = false;
}
Q_ASSERT ( model->hasIndex ( r, columns + 1, parent ) == false );
for ( int c = 0; c < columns; ++c ) {
Q_ASSERT ( model->hasIndex ( r, c, parent ) == true );
QModelIndex index = model->index ( r, c, parent );
Q_ASSERT(model->hasIndex(r, columns + 1, parent) == false);
for (int c = 0; c < columns; ++c) {
Q_ASSERT(model->hasIndex(r, c, parent) == true);
QModelIndex index = model->index(r, c, parent);
// rowCount() and columnCount() said that it existed...
Q_ASSERT ( index.isValid() == true );
Q_ASSERT(index.isValid() == true);
// index() should always return the same index when called twice in a row
QModelIndex modifiedIndex = model->index ( r, c, parent );
Q_ASSERT ( index == modifiedIndex );
QModelIndex modifiedIndex = model->index(r, c, parent);
Q_ASSERT(index == modifiedIndex);
// Make sure we get the same index if we request it twice in a row
QModelIndex a = model->index ( r, c, parent );
QModelIndex b = model->index ( r, c, parent );
Q_ASSERT ( a == b );
QModelIndex a = model->index(r, c, parent);
QModelIndex b = model->index(r, c, parent);
Q_ASSERT(a == b);
// Some basic checking on the index that is returned
Q_ASSERT ( index.model() == model );
Q_ASSERT ( index.row() == r );
Q_ASSERT ( index.column() == c );
Q_ASSERT(index.model() == model);
Q_ASSERT(index.row() == r);
Q_ASSERT(index.column() == c);
// While you can technically return a QVariant usually this is a sign
// of an bug in data() Disable if this really is ok in your model.
// Q_ASSERT ( model->data ( index, Qt::DisplayRole ).isValid() == true );
@ -381,17 +390,17 @@ void ModelTest::checkChildren ( const QModelIndex &parent, int currentDepth )
// Check that we can get back our real parent.
// qDebug() << model->parent ( index ) << parent ;
Q_ASSERT ( model->parent ( index ) == parent );
Q_ASSERT(model->parent(index) == parent);
// recursively go down the children
if ( model->hasChildren ( index ) && currentDepth < 10 ) {
if (model->hasChildren(index) && currentDepth < 10) {
//qDebug() << r << c << "has children" << model->rowCount(index);
checkChildren ( index, ++currentDepth );
checkChildren(index, ++currentDepth);
}/* else { if (currentDepth >= 10) qDebug() << "checked 10 deep"; };*/
// make sure that after testing the children that the index doesn't change.
QModelIndex newerIndex = model->index ( r, c, parent );
Q_ASSERT ( index == newerIndex );
QModelIndex newerIndex = model->index(r, c, parent);
Q_ASSERT(index == newerIndex);
}
}
}
@ -402,68 +411,69 @@ void ModelTest::checkChildren ( const QModelIndex &parent, int currentDepth )
void ModelTest::data()
{
// Invalid index should return an invalid qvariant
Q_ASSERT ( !model->data ( QModelIndex() ).isValid() );
Q_ASSERT(!model->data(QModelIndex()).isValid());
if ( model->rowCount() == 0 )
if (model->rowCount() == 0) {
return;
}
// A valid index should have a valid QVariant data
Q_ASSERT ( model->index ( 0, 0 ).isValid() );
Q_ASSERT(model->index(0, 0).isValid());
// shouldn't be able to set data on an invalid index
Q_ASSERT ( model->setData ( QModelIndex(), QLatin1String ( "foo" ), Qt::DisplayRole ) == false );
Q_ASSERT(model->setData(QModelIndex(), QLatin1String("foo"), Qt::DisplayRole) == false);
// General Purpose roles that should return a QString
QVariant variant = model->data ( model->index ( 0, 0 ), Qt::ToolTipRole );
if ( variant.isValid() ) {
Q_ASSERT ( qVariantCanConvert<QString> ( variant ) );
QVariant variant = model->data(model->index(0, 0), Qt::ToolTipRole);
if (variant.isValid()) {
Q_ASSERT(qVariantCanConvert<QString> (variant));
}
variant = model->data ( model->index ( 0, 0 ), Qt::StatusTipRole );
if ( variant.isValid() ) {
Q_ASSERT ( qVariantCanConvert<QString> ( variant ) );
variant = model->data(model->index(0, 0), Qt::StatusTipRole);
if (variant.isValid()) {
Q_ASSERT(qVariantCanConvert<QString> (variant));
}
variant = model->data ( model->index ( 0, 0 ), Qt::WhatsThisRole );
if ( variant.isValid() ) {
Q_ASSERT ( qVariantCanConvert<QString> ( variant ) );
variant = model->data(model->index(0, 0), Qt::WhatsThisRole);
if (variant.isValid()) {
Q_ASSERT(qVariantCanConvert<QString> (variant));
}
// General Purpose roles that should return a QSize
variant = model->data ( model->index ( 0, 0 ), Qt::SizeHintRole );
if ( variant.isValid() ) {
Q_ASSERT ( qVariantCanConvert<QSize> ( variant ) );
variant = model->data(model->index(0, 0), Qt::SizeHintRole);
if (variant.isValid()) {
Q_ASSERT(qVariantCanConvert<QSize> (variant));
}
// General Purpose roles that should return a QFont
QVariant fontVariant = model->data ( model->index ( 0, 0 ), Qt::FontRole );
if ( fontVariant.isValid() ) {
Q_ASSERT ( qVariantCanConvert<QFont> ( fontVariant ) );
QVariant fontVariant = model->data(model->index(0, 0), Qt::FontRole);
if (fontVariant.isValid()) {
Q_ASSERT(qVariantCanConvert<QFont> (fontVariant));
}
// Check that the alignment is one we know about
QVariant textAlignmentVariant = model->data ( model->index ( 0, 0 ), Qt::TextAlignmentRole );
if ( textAlignmentVariant.isValid() ) {
QVariant textAlignmentVariant = model->data(model->index(0, 0), Qt::TextAlignmentRole);
if (textAlignmentVariant.isValid()) {
int alignment = textAlignmentVariant.toInt();
Q_ASSERT ( alignment == ( alignment & ( Qt::AlignHorizontal_Mask | Qt::AlignVertical_Mask ) ) );
Q_ASSERT(alignment == (alignment & (Qt::AlignHorizontal_Mask | Qt::AlignVertical_Mask)));
}
// General Purpose roles that should return a QColor
QVariant colorVariant = model->data ( model->index ( 0, 0 ), Qt::BackgroundColorRole );
if ( colorVariant.isValid() ) {
Q_ASSERT ( qVariantCanConvert<QColor> ( colorVariant ) );
QVariant colorVariant = model->data(model->index(0, 0), Qt::BackgroundColorRole);
if (colorVariant.isValid()) {
Q_ASSERT(qVariantCanConvert<QColor> (colorVariant));
}
colorVariant = model->data ( model->index ( 0, 0 ), Qt::TextColorRole );
if ( colorVariant.isValid() ) {
Q_ASSERT ( qVariantCanConvert<QColor> ( colorVariant ) );
colorVariant = model->data(model->index(0, 0), Qt::TextColorRole);
if (colorVariant.isValid()) {
Q_ASSERT(qVariantCanConvert<QColor> (colorVariant));
}
// Check that the "check state" is one we know about.
QVariant checkStateVariant = model->data ( model->index ( 0, 0 ), Qt::CheckStateRole );
if ( checkStateVariant.isValid() ) {
QVariant checkStateVariant = model->data(model->index(0, 0), Qt::CheckStateRole);
if (checkStateVariant.isValid()) {
int state = checkStateVariant.toInt();
Q_ASSERT ( state == Qt::Unchecked ||
state == Qt::PartiallyChecked ||
state == Qt::Checked );
Q_ASSERT(state == Qt::Unchecked ||
state == Qt::PartiallyChecked ||
state == Qt::Checked);
}
}
@ -472,7 +482,7 @@ void ModelTest::data()
\sa rowsInserted()
*/
void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, int end )
void ModelTest::rowsAboutToBeInserted(const QModelIndex &parent, int start, int end)
{
// Q_UNUSED(end);
// qDebug() << "rowsAboutToBeInserted" << "start=" << start << "end=" << end << "parent=" << model->data ( parent ).toString()
@ -480,10 +490,10 @@ void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, in
// qDebug() << model->index(start-1, 0, parent) << model->data( model->index(start-1, 0, parent) );
Changing c;
c.parent = parent;
c.oldSize = model->rowCount ( parent );
c.last = model->data ( model->index ( start - 1, 0, parent ) );
c.next = model->data ( model->index ( start, 0, parent ) );
insert.push ( c );
c.oldSize = model->rowCount(parent);
c.last = model->data(model->index(start - 1, 0, parent));
c.next = model->data(model->index(start, 0, parent));
insert.push(c);
}
/*!
@ -491,10 +501,10 @@ void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, in
\sa rowsAboutToBeInserted()
*/
void ModelTest::rowsInserted ( const QModelIndex & parent, int start, int end )
void ModelTest::rowsInserted(const QModelIndex &parent, int start, int end)
{
Changing c = insert.pop();
Q_ASSERT ( c.parent == parent );
Q_ASSERT(c.parent == parent);
// qDebug() << "rowsInserted" << "start=" << start << "end=" << end << "oldsize=" << c.oldSize
// << "parent=" << model->data ( parent ).toString() << "current rowcount of parent=" << model->rowCount ( parent );
@ -504,30 +514,32 @@ void ModelTest::rowsInserted ( const QModelIndex & parent, int start, int end )
// }
// qDebug();
Q_ASSERT ( c.oldSize + ( end - start + 1 ) == model->rowCount ( parent ) );
Q_ASSERT ( c.last == model->data ( model->index ( start - 1, 0, c.parent ) ) );
Q_ASSERT(c.oldSize + (end - start + 1) == model->rowCount(parent));
Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
if (c.next != model->data(model->index(end + 1, 0, c.parent))) {
qDebug() << start << end;
for (int i=0; i < model->rowCount(); ++i)
for (int i = 0; i < model->rowCount(); ++i) {
qDebug() << model->index(i, 0).data().toString();
}
qDebug() << c.next << model->data(model->index(end + 1, 0, c.parent));
}
Q_ASSERT ( c.next == model->data ( model->index ( end + 1, 0, c.parent ) ) );
Q_ASSERT(c.next == model->data(model->index(end + 1, 0, c.parent)));
}
void ModelTest::layoutAboutToBeChanged()
{
for ( int i = 0; i < qBound ( 0, model->rowCount(), 100 ); ++i )
changing.append ( QPersistentModelIndex ( model->index ( i, 0 ) ) );
for (int i = 0; i < qBound(0, model->rowCount(), 100); ++i) {
changing.append(QPersistentModelIndex(model->index(i, 0)));
}
}
void ModelTest::layoutChanged()
{
for ( int i = 0; i < changing.count(); ++i ) {
for (int i = 0; i < changing.count(); ++i) {
QPersistentModelIndex p = changing[i];
Q_ASSERT ( p == model->index ( p.row(), p.column(), p.parent() ) );
Q_ASSERT(p == model->index(p.row(), p.column(), p.parent()));
}
changing.clear();
}
@ -537,15 +549,15 @@ void ModelTest::layoutChanged()
\sa rowsRemoved()
*/
void ModelTest::rowsAboutToBeRemoved ( const QModelIndex &parent, int start, int end )
void ModelTest::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
{
qDebug() << "ratbr" << parent << start << end;
qDebug() << "ratbr" << parent << start << end;
Changing c;
c.parent = parent;
c.oldSize = model->rowCount ( parent );
c.last = model->data ( model->index ( start - 1, 0, parent ) );
c.next = model->data ( model->index ( end + 1, 0, parent ) );
remove.push ( c );
c.oldSize = model->rowCount(parent);
c.last = model->data(model->index(start - 1, 0, parent));
c.next = model->data(model->index(end + 1, 0, parent));
remove.push(c);
}
/*!
@ -553,14 +565,13 @@ qDebug() << "ratbr" << parent << start << end;
\sa rowsAboutToBeRemoved()
*/
void ModelTest::rowsRemoved ( const QModelIndex & parent, int start, int end )
void ModelTest::rowsRemoved(const QModelIndex &parent, int start, int end)
{
qDebug() << "rr" << parent << start << end;
qDebug() << "rr" << parent << start << end;
Changing c = remove.pop();
Q_ASSERT ( c.parent == parent );
Q_ASSERT ( c.oldSize - ( end - start + 1 ) == model->rowCount ( parent ) );
Q_ASSERT ( c.last == model->data ( model->index ( start - 1, 0, c.parent ) ) );
Q_ASSERT ( c.next == model->data ( model->index ( start, 0, c.parent ) ) );
Q_ASSERT(c.parent == parent);
Q_ASSERT(c.oldSize - (end - start + 1) == model->rowCount(parent));
Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
Q_ASSERT(c.next == model->data(model->index(start, 0, c.parent)));
}

57
autotests/modeltest.h
View File

@ -39,7 +39,6 @@
**
****************************************************************************/
#ifndef MODELTEST_H
#define MODELTEST_H
@ -49,46 +48,46 @@
class ModelTest : public QObject
{
Q_OBJECT
Q_OBJECT
public:
explicit ModelTest( QAbstractItemModel *model, QObject *parent = 0 );
explicit ModelTest(QAbstractItemModel *model, QObject *parent = 0);
private Q_SLOTS:
void nonDestructiveBasicTest();
void rowCount();
void columnCount();
void hasIndex();
void index();
void parent();
void data();
void nonDestructiveBasicTest();
void rowCount();
void columnCount();
void hasIndex();
void index();
void parent();
void data();
protected Q_SLOTS:
void runAllTests();
void layoutAboutToBeChanged();
void layoutChanged();
void rowsAboutToBeInserted( const QModelIndex &parent, int start, int end );
void rowsInserted( const QModelIndex & parent, int start, int end );
void rowsAboutToBeRemoved( const QModelIndex &parent, int start, int end );
void rowsRemoved( const QModelIndex & parent, int start, int end );
void runAllTests();
void layoutAboutToBeChanged();
void layoutChanged();
void rowsAboutToBeInserted(const QModelIndex &parent, int start, int end);
void rowsInserted(const QModelIndex &parent, int start, int end);
void rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end);
void rowsRemoved(const QModelIndex &parent, int start, int end);
private:
void checkChildren( const QModelIndex &parent, int currentDepth = 0 );
void checkChildren(const QModelIndex &parent, int currentDepth = 0);
QAbstractItemModel *model;
QAbstractItemModel *model;
struct Changing {
QModelIndex parent;
int oldSize;
QVariant last;
QVariant next;
};
QStack<Changing> insert;
QStack<Changing> remove;
struct Changing {
QModelIndex parent;
int oldSize;
QVariant last;
QVariant next;
};
QStack<Changing> insert;
QStack<Changing> remove;
bool fetchingMore;
bool fetchingMore;
QList<QPersistentModelIndex> changing;
QList<QPersistentModelIndex> changing;
};
#endif

16
autotests/packagestructuretest.cpp
View File

@ -42,7 +42,6 @@ public:
}
};
void PackageStructureTest::initTestCase()
{
m_packagePath = QFINDTESTDATA("data/testpackage");
@ -82,10 +81,10 @@ void PackageStructureTest::multiplePaths()
void PackageStructureTest::directories()
{
QList<const char*> dirs;
QList<const char *> dirs;
dirs << "config" << "data" << "images" << "theme" << "scripts" << "translations" << "ui";
QList<const char*> psDirs = ps.directories();
QList<const char *> psDirs = ps.directories();
QCOMPARE(dirs.count(), psDirs.count());
@ -114,16 +113,16 @@ void PackageStructureTest::directories()
void PackageStructureTest::requiredDirectories()
{
QList<const char*> dirs;
QList<const char *> dirs;
QCOMPARE(ps.requiredDirectories(), dirs);
}
void PackageStructureTest::files()
{
QList<const char*> files;
QList<const char *> files;
files << "mainconfigui" << "mainconfigxml" << "mainscript";
QList<const char*> psFiles = ps.files();
QList<const char *> psFiles = ps.files();
//for (int i = 0; i < psFiles.count(); ++i) {
// qDebug() << psFiles[i];
@ -142,10 +141,10 @@ void PackageStructureTest::files()
void PackageStructureTest::requiredFiles()
{
QList<const char*> files;
QList<const char *> files;
files << "mainscript";
QList<const char*> psFiles = ps.requiredFiles();
QList<const char *> psFiles = ps.requiredFiles();
QCOMPARE(files.count(), psFiles.count());
for (int i = 0; i < files.count(); ++i) {
@ -181,4 +180,3 @@ void PackageStructureTest::mimeTypes()
QTEST_MAIN(PackageStructureTest)

8
autotests/packageurlinterceptortest.h
View File

@ -25,11 +25,11 @@
class PackageUrlInterceptorTest : public QObject
{
Q_OBJECT
public:
PackageUrlInterceptorTest() {}
public:
PackageUrlInterceptorTest() {}
private Q_SLOTS:
void loadAccessManager();
private Q_SLOTS:
void loadAccessManager();
};
#endif

11
autotests/plasmoidpackagetest.cpp
View File

@ -90,7 +90,6 @@ void PlasmoidPackageTest::createTestPackage(const QString &packageName)
file.flush();
file.close();
qDebug() << "THIS IS A PLASMOID SCRIPT THING";
// Now we have a minimal plasmoid package which is valid. Let's add some
// files to it for test purposes.
@ -274,31 +273,29 @@ void PlasmoidPackageTest::createAndInstallPackage()
qDebug() << "Installing " << archivePath;
//const QString packageRoot = "plasma/plasmoids/";
//const QString servicePrefix = "plasma-applet-";
KJob* job = p->install(archivePath, m_packageRoot);
KJob *job = p->install(archivePath, m_packageRoot);
connect(job, SIGNAL(finished(KJob*)), SLOT(packageInstalled(KJob*)));
//QVERIFY(p->isValid());
delete p;
}
void PlasmoidPackageTest::packageInstalled(KJob* j)
void PlasmoidPackageTest::packageInstalled(KJob *j)
{
qDebug() << "!!!!!!!!!!!!!!!!!!!! package installed" << (j->error() == KJob::NoError);
QVERIFY(j->error() == KJob::NoError);
//QVERIFY(p->path());
Plasma::Package *p = new Plasma::Package(m_defaultPackageStructure);
KJob* jj = p->uninstall("org.kde.microblog-qml", m_packageRoot);
KJob *jj = p->uninstall("org.kde.microblog-qml", m_packageRoot);
//QObject::disconnect(j, SIGNAL(finished(KJob*)), this, SLOT(packageInstalled(KJob*)));
connect(jj, SIGNAL(finished(KJob*)), SLOT(packageInstalled(KJob*)));
}
void PlasmoidPackageTest::packageUninstalled(KJob* j)
void PlasmoidPackageTest::packageUninstalled(KJob *j)
{
qDebug() << "!!!!!!!!!!!!!!!!!!!!! package uninstalled";
QVERIFY(j->error() == KJob::NoError);
}
QTEST_MAIN(PlasmoidPackageTest)

8
autotests/plasmoidpackagetest.h
View File

@ -39,17 +39,17 @@ private Q_SLOTS:
void filePath();
void entryList();
void packageInstalled(KJob* j);
void packageUninstalled(KJob* j);
void packageInstalled(KJob *j);
void packageUninstalled(KJob *j);
private:
void createTestPackage(const QString &packageName);
QString m_packageRoot;
QString m_package;
KJob* m_packageJob;
KJob *m_packageJob;
Plasma::Package m_defaultPackage;
Plasma::PackageStructure* m_defaultPackageStructure;
Plasma::PackageStructure *m_defaultPackageStructure;
};
#endif

1
autotests/pluginloadertest.cpp
View File

@ -75,6 +75,5 @@ void PluginTest::loadDataEngine()
}
#include "moc_pluginloadertest.cpp"

18
autotests/pluginloadertest.h
View File

@ -25,18 +25,18 @@
class PluginTest : public QObject
{
Q_OBJECT
public:
PluginTest() {}
public:
PluginTest() {}
private Q_SLOTS:
void listEngines();
void listAppletCategories();
void listContainmentActions();
void listContainmentsOfType();
private Q_SLOTS:
void listEngines();
void listAppletCategories();
void listContainmentActions();
void listContainmentsOfType();
void loadDataEngine();
void loadDataEngine();
private:
private:
};
#endif

6
autotests/sortfiltermodeltest.cpp
View File

@ -43,7 +43,7 @@ void SortFilterModelTest::setModel()
filterModel.setModel(&model);
QCOMPARE(spy.count(), 1);
QList<QVariant> arguments = spy.takeFirst();
QCOMPARE(arguments.at(0).value<QObject*>(), static_cast<QObject*>(&model));
QCOMPARE(arguments.at(0).value<QObject *>(), static_cast<QObject *>(&model));
filterModel.setModel(&model);
QCOMPARE(spy.count(), 0);
@ -54,9 +54,9 @@ void SortFilterModelTest::setEmptyModel()
SortFilterModel filterModel;
QStandardItemModel model;
filterModel.setModel(&model);
QCOMPARE(filterModel.sourceModel(), static_cast<QAbstractItemModel*>(&model));
QCOMPARE(filterModel.sourceModel(), static_cast<QAbstractItemModel *>(&model));
filterModel.setModel(0);
QCOMPARE(filterModel.sourceModel(), static_cast<QAbstractItemModel*>(0));
QCOMPARE(filterModel.sourceModel(), static_cast<QAbstractItemModel *>(0));
}
void SortFilterModelTest::setFilterRegExp()

1
autotests/storagetest.h
View File

@ -34,7 +34,6 @@ private Q_SLOTS:
void retrieve();
void deleteEntry();
private:
QVariantMap m_data;
};

2
examples/dataengines/customDataContainers/customDataContainersEngine.cpp
View File

@ -31,7 +31,7 @@
#include "httpContainer.h"
/*
This DataEngine shows how to use a subclass of DataContainer to create and
This DataEngine shows how to use a subclass of DataContainer to create and
manage sources. This is particularly useful when managing asynchronous requests,
such as sources that reflect network, D-Bus, etc. results.
*/

2
examples/dataengines/customDataContainers/httpContainer.h
View File

@ -32,7 +32,7 @@
namespace KIO
{
class Job;
class Job;
};
class HttpContainer : public Plasma::DataContainer

20
examples/kpart/appletselector.cpp
View File

@ -1,4 +1,4 @@
/*
/*
* Copyright 2010 Aleix Pol Gonzalez <aleixpol@kde.org>
*
* This library is free software; you can redistribute it and/or
@ -23,13 +23,13 @@
#include <plasma/applet.h>
#include <QStandardItemModel>
AppletSelector::AppletSelector(QObject* parent, const QVariantList& args)
AppletSelector::AppletSelector(QObject *parent, const QVariantList &args)
: KDialog()
{
Q_UNUSED(args);
setButtons(Close);
QWidget* w = new QWidget(this);
QWidget *w = new QWidget(this);
m_ui = new Ui::AppletSelector;
m_ui->setupUi(w);
@ -38,13 +38,13 @@ AppletSelector::AppletSelector(QObject* parent, const QVariantList& args)
setMainWidget(w);
QStandardItemModel* model = new QStandardItemModel(this);
const KPluginInfo::List list= Plasma::Applet::listAppletInfo();
foreach(const KPluginInfo& info, list) {
QStandardItem* item = new QStandardItem(KIcon(info.icon()), info.name());
QStandardItemModel *model = new QStandardItemModel(this);
const KPluginInfo::List list = Plasma::Applet::listAppletInfo();
foreach (const KPluginInfo &info, list) {
QStandardItem *item = new QStandardItem(KIcon(info.icon()), info.name());
item->setEditable(false);
item->setToolTip(info.comment());
item->setData(info.pluginName(), Qt::UserRole+1);
item->setData(info.pluginName(), Qt::UserRole + 1);
model->appendRow(item);
}
@ -59,9 +59,9 @@ AppletSelector::~AppletSelector()
delete m_ui;
}
void AppletSelector::selected(const QModelIndex& idx)
void AppletSelector::selected(const QModelIndex &idx)
{
emit addApplet(idx.data(Qt::UserRole+1).toString());
emit addApplet(idx.data(Qt::UserRole + 1).toString());
}
#include "appletselector.moc"

15
examples/kpart/appletselector.h
View File

@ -23,22 +23,25 @@
#include <KDE/KDialog>
class QModelIndex;
namespace Ui { class AppletSelector; }
namespace Ui
{
class AppletSelector;
}
class AppletSelector : public KDialog
{
Q_OBJECT
Q_OBJECT
public:
explicit AppletSelector(QObject* parent = 0, const QVariantList& args = QVariantList());
explicit AppletSelector(QObject *parent = 0, const QVariantList &args = QVariantList());
~AppletSelector();
public slots:
void selected(const QModelIndex& idx);
void selected(const QModelIndex &idx);
signals:
void addApplet(const QString& name);
void addApplet(const QString &name);
private:
Ui::AppletSelector* m_ui;
Ui::AppletSelector *m_ui;
};
#endif // APPLETSELECTOR_H

9
examples/kpart/containmentshell.cpp
View File

@ -27,13 +27,12 @@
#include <KStandardAction>
#include <KActionCollection>
#include <Plasma/Containment>
#include <QApplication>
ContainmentShell::ContainmentShell()
: KParts::MainWindow( ),
: KParts::MainWindow(),
m_dialog(0)
{
setXMLFile("plasma-kpart-shellui.rc");
@ -46,7 +45,7 @@ ContainmentShell::ContainmentShell()
// this routine will find and load our Part. it finds the Part by
// name which is a bad idea usually.. but it's alright in this
// case since our Part is made for this Shell
KService::Ptr service = KService::serviceByDesktopPath( "plasma-kpart.desktop" );
KService::Ptr service = KService::serviceByDesktopPath("plasma-kpart.desktop");
if (service) {
Plasma::PluginLoader *loader = new TestShellPluginLoader();
@ -86,8 +85,8 @@ ContainmentShell::~ContainmentShell()
void ContainmentShell::optionsPreferences()
{
if (!m_dialog) {
m_dialog = new AppletSelector( m_part );
connect( m_dialog, SIGNAL(addApplet(QString)), m_part, SLOT(addApplet(QString)) );
m_dialog = new AppletSelector(m_part);
connect(m_dialog, SIGNAL(addApplet(QString)), m_part, SLOT(addApplet(QString)));
}
m_dialog->show();
}

6
examples/kpart/containmentshell.h
View File

@ -33,7 +33,7 @@
*/
class ContainmentShell : public KParts::MainWindow
{
Q_OBJECT
Q_OBJECT
public:
ContainmentShell();
virtual ~ContainmentShell();
@ -42,8 +42,8 @@ public Q_SLOTS:
void optionsPreferences();
private:
KParts::Part* m_part;
KDialog* m_dialog;
KParts::Part *m_part;
KDialog *m_dialog;
};
#endif // CONTAINMENTSHELL_H

4
examples/kpart/main.cpp
View File

@ -23,10 +23,10 @@
static const char version[] = "0.1";
int main(int argc, char** argv)
int main(int argc, char **argv)
{
KAboutData about("plasma-kpart-shell", 0, ki18n("Plasma KPart Shell"), version, ki18n("A KDE KPart Application"), KAboutData::License_GPL, ki18n("(C) 2010 Ryan Rix"), KLocalizedString(), 0, "ry@n.rix.si");
about.addAuthor( ki18n("Ryan Rix"), KLocalizedString(), "ry@n.rix.si" );
about.addAuthor(ki18n("Ryan Rix"), KLocalizedString(), "ry@n.rix.si");
KCmdLineArgs::init(argc, argv, &about);
KApplication app;

6
examples/kpart/testshellpluginloader.cpp
View File

@ -29,19 +29,19 @@ TestShellPluginLoader::~TestShellPluginLoader()
{
}
Plasma::Applet* TestShellPluginLoader::internalLoadApplet (const QString &name, uint appletId, const QVariantList &args)
Plasma::Applet *TestShellPluginLoader::internalLoadApplet(const QString &name, uint appletId, const QVariantList &args)
{
kDebug() << "loadApplet called with" << name << appletId << args;
return 0;
}
Plasma::DataEngine* TestShellPluginLoader::internalLoadDataEngine(const QString &name)
Plasma::DataEngine *TestShellPluginLoader::internalLoadDataEngine(const QString &name)
{
kDebug() << "loadEngine called with" << name;
return 0;
}
Plasma::Service* TestShellPluginLoader::internalLoadService(const QString &name, const QVariantList &args, QObject *parent)
Plasma::Service *TestShellPluginLoader::internalLoadService(const QString &name, const QVariantList &args, QObject *parent)
{
kDebug() << "loadService called with" << name << args << parent;
return 0;

8
examples/kpart/testshellpluginloader.h
View File

@ -26,10 +26,10 @@ class TestShellPluginLoader : public Plasma::PluginLoader
public:
~TestShellPluginLoader();
Plasma::Applet* internalLoadApplet (const QString &name, uint appletId = 0,
const QVariantList &args = QVariantList());
Plasma::DataEngine* internalLoadDataEngine(const QString &name);
Plasma::Service* internalLoadService(const QString &name, const QVariantList &args, QObject *parent = 0);
Plasma::Applet *internalLoadApplet(const QString &name, uint appletId = 0,
const QVariantList &args = QVariantList());
Plasma::DataEngine *internalLoadDataEngine(const QString &name);
Plasma::Service *internalLoadService(const QString &name, const QVariantList &args, QObject *parent = 0);
};
#endif

50
src/declarativeimports/calendar/calendar.cpp
View File

@ -19,7 +19,6 @@
#include <QDebug>
#include "calendar.h"
Calendar::Calendar(QObject *parent)
@ -35,8 +34,8 @@ Calendar::Calendar(QObject *parent)
m_daysModel = new DaysModel(this);
m_daysModel->setSourceData(&m_dayList);
// m_dayHelper = new CalendarDayHelper(this);
// connect(m_dayHelper, SIGNAL(calendarChanged()), this, SLOT(updateData()));
// m_dayHelper = new CalendarDayHelper(this);
// connect(m_dayHelper, SIGNAL(calendarChanged()), this, SLOT(updateData()));
}
QDate Calendar::startDate() const
@ -46,11 +45,11 @@ QDate Calendar::startDate() const
void Calendar::setStartDate(const QDate &dateTime)
{
if(m_startDate == dateTime) {
if (m_startDate == dateTime) {
return;
}
m_startDate = dateTime;
// m_dayHelper->setDate(m_startDate.year(), m_startDate.month());
// m_dayHelper->setDate(m_startDate.year(), m_startDate.month());
updateData();
emit startDateChanged();
}
@ -62,8 +61,9 @@ int Calendar::types() const
void Calendar::setTypes(int types)
{
if (m_types == types)
if (m_types == types) {
return;
}
// m_types = static_cast<Types>(types);
// updateTypes();
@ -78,7 +78,7 @@ int Calendar::days()
void Calendar::setDays(int days)
{
if(m_days != days) {
if (m_days != days) {
m_days = days;
updateData();
emit daysChanged();
@ -92,7 +92,7 @@ int Calendar::weeks()
void Calendar::setWeeks(int weeks)
{
if(m_weeks != weeks) {
if (m_weeks != weeks) {
m_weeks = weeks;
updateData();
emit weeksChanged();
@ -168,7 +168,7 @@ QList<int> Calendar::weeksModel() const
void Calendar::updateData()
{
if(m_days == 0 || m_weeks == 0) {
if (m_days == 0 || m_weeks == 0) {
return;
}
@ -182,7 +182,6 @@ void Calendar::updateData()
QDate firstDay(m_startDate.year(), m_startDate.month(), 1);
// If the first day is the same as the starting day then we add a complete row before it.
if (m_firstDayOfWeek < firstDay.dayOfWeek()) {
daysBeforeCurrentMonth = firstDay.dayOfWeek() - m_firstDayOfWeek;
@ -191,48 +190,48 @@ void Calendar::updateData()
}
int daysThusFar = daysBeforeCurrentMonth + m_startDate.daysInMonth();
if(daysThusFar < totalDays) {
if (daysThusFar < totalDays) {
daysAfterCurrentMonth = totalDays - daysThusFar;
}
if(daysBeforeCurrentMonth > 0) {
if (daysBeforeCurrentMonth > 0) {
QDate previousMonth = m_startDate.addMonths(-1);
//QDate previousMonth(m_startDate.year(), m_startDate.month() - 1, 1);
for(int i = 0; i < daysBeforeCurrentMonth; i++) {
for (int i = 0; i < daysBeforeCurrentMonth; i++) {
DayData day;
day.isCurrentMonth = false;
day.isNextMonth = false;
day.isPreviousMonth = true;
day.dayNumber = previousMonth.daysInMonth() - (daysBeforeCurrentMonth - (i + 1));
day.monthNumber =previousMonth.month();
day.yearNumber =previousMonth.year();
// day.containsEventItems = false;
day.monthNumber = previousMonth.month();
day.yearNumber = previousMonth.year();
// day.containsEventItems = false;
m_dayList << day;
}
}
for(int i = 0; i < m_startDate.daysInMonth(); i++) {
for (int i = 0; i < m_startDate.daysInMonth(); i++) {
DayData day;
day.isCurrentMonth = true;
day.isNextMonth = false;
day.isPreviousMonth = false;
day.dayNumber = i + 1; // +1 to go form 0 based index to 1 based calendar dates
// day.containsEventItems = m_dayHelper->containsEventItems(i + 1);
// day.containsEventItems = m_dayHelper->containsEventItems(i + 1);
day.monthNumber = m_startDate.month();
day.yearNumber = m_startDate.year();
m_dayList << day;
}
if(daysAfterCurrentMonth > 0) {
for(int i = 0; i < daysAfterCurrentMonth; i++) {
if (daysAfterCurrentMonth > 0) {
for (int i = 0; i < daysAfterCurrentMonth; i++) {
DayData day;
day.isCurrentMonth = false;
day.isNextMonth = true;
day.isPreviousMonth = false;
day.dayNumber = i + 1; // +1 to go form 0 based index to 1 based calendar dates
// day.containsEventItems = false;
day.monthNumber = m_startDate.addMonths(1).month();
// day.containsEventItems = false;
day.monthNumber = m_startDate.addMonths(1).month();
day.yearNumber = m_startDate.addMonths(1).year();
m_dayList << day;
}
@ -240,12 +239,11 @@ void Calendar::updateData()
const int numOfDaysInCalendar = m_dayList.count();
// Fill weeksModel (just a QList<int>) with the week numbers. This needs some tweaking!
for(int i = 0; i < numOfDaysInCalendar; i += 7) {
const DayData& data = m_dayList.at(i);
for (int i = 0; i < numOfDaysInCalendar; i += 7) {
const DayData &data = m_dayList.at(i);
m_weekList << QDate(data.yearNumber, data.monthNumber, data.dayNumber).weekNumber();
}
m_daysModel->update();
// qDebug() << "---------------------------------------------------------------";

17
src/declarativeimports/calendar/calendar.h
View File

@ -27,7 +27,6 @@
#include "daydata.h"
#include "daysmodel.h"
class Calendar : public QObject
{
Q_OBJECT
@ -111,7 +110,7 @@ class Calendar : public QObject
* metadata about the current day. The exact metadata can be found in "daysmodel.cpp"
* where the exact names usable in QML are being set.
*/
Q_PROPERTY(QAbstractListModel* daysModel READ daysModel CONSTANT)
Q_PROPERTY(QAbstractListModel *daysModel READ daysModel CONSTANT)
Q_ENUMS(Type)
@ -124,7 +123,6 @@ public:
};
Q_DECLARE_FLAGS(Types, Type)
explicit Calendar(QObject *parent = 0);
// Start date
@ -155,18 +153,17 @@ public:
int year() const;
// Models
QAbstractListModel* daysModel() const;
QList<int> weeksModel() const;
QAbstractListModel *daysModel() const;
QList<int> weeksModel() const;
// QML invokables
Q_INVOKABLE void nextMonth();
Q_INVOKABLE void previousMonth();
Q_INVOKABLE void nextYear();
Q_INVOKABLE void previousYear();
Q_INVOKABLE QString dayName(int weekday) const ;
Q_INVOKABLE QString dayName(int weekday) const;
Q_INVOKABLE int currentWeek() const;
Q_SIGNALS:
void startDateChanged();
void typesChanged();
@ -179,12 +176,12 @@ Q_SIGNALS:
public Q_SLOTS:
void updateData();
private:
QDate m_startDate;
Types m_types;
QList<DayData> m_dayList;
DaysModel* m_daysModel;
DaysModel *m_daysModel;
QList<int> m_weekList;
int m_days;

36
src/declarativeimports/calendar/calendardata.cpp
View File

@ -19,32 +19,28 @@
#include "calendardata.h"
CalendarData::CalendarData(QObject *parent)
: QObject(parent)
, m_types(Holiday | Event | Todo | Journal)
{
// m_etmCalendar = new ETMCalendar();
// m_etmCalendar->setParent(this); //TODO: hit sergio
// m_etmCalendar = new ETMCalendar();
// m_etmCalendar->setParent(this); //TODO: hit sergio
// EntityTreeModel *model = m_etmCalendar->entityTreeModel();
// model->setCollectionFetchStrategy(EntityTreeModel::InvisibleCollectionFetch);
// EntityTreeModel *model = m_etmCalendar->entityTreeModel();
// model->setCollectionFetchStrategy(EntityTreeModel::InvisibleCollectionFetch);
// m_itemList = new EntityMimeTypeFilterModel(this);
// m_itemList->setSourceModel(model);
// m_itemList = new EntityMimeTypeFilterModel(this);
// m_itemList->setSourceModel(model);
// CalendarRoleProxyModel *roleModel = new CalendarRoleProxyModel(this);
// roleModel->setSourceModel(m_itemList);
// CalendarRoleProxyModel *roleModel = new CalendarRoleProxyModel(this);
// roleModel->setSourceModel(m_itemList);
// m_filteredList = new DateTimeRangeFilterModel(this);
// m_filteredList->setSourceModel(roleModel);
// m_filteredList = new DateTimeRangeFilterModel(this);
// m_filteredList->setSourceModel(roleModel);
// updateTypes();
// updateTypes();
}
QDate CalendarData::startDate() const
{
return m_startDate;
@ -52,11 +48,12 @@ QDate CalendarData::startDate() const
void CalendarData::setStartDate(const QDate &dateTime)
{
if (m_startDate == dateTime)
if (m_startDate == dateTime) {
return;
}
m_startDate = dateTime;
// m_filteredList->setStartDate(m_startDate);
// m_filteredList->setStartDate(m_startDate);
emit startDateChanged();
}
@ -67,11 +64,12 @@ QDate CalendarData::endDate() const
void CalendarData::setEndDate(const QDate &dateTime)
{
if (m_endDate == dateTime)
if (m_endDate == dateTime) {
return;
}
m_endDate = dateTime;
// m_filteredList->setEndDate(m_endDate);
// m_filteredList->setEndDate(m_endDate);
emit endDateChanged();
}

19
src/declarativeimports/calendar/calendardata.h
View File

@ -24,9 +24,6 @@
#include <QFlags>
#include <QDate>
class QAbstractItemModel;
class CalendarData : public QObject
@ -35,10 +32,10 @@ class CalendarData : public QObject
Q_PROPERTY(QDate startDate READ startDate WRITE setStartDate NOTIFY startDateChanged)
Q_PROPERTY(QDate endDate READ endDate WRITE setEndDate NOTIFY endDateChanged)
// Q_PROPERTY(int types READ types WRITE setTypes NOTIFY typesChanged)
// Q_PROPERTY(int types READ types WRITE setTypes NOTIFY typesChanged)
Q_PROPERTY(QString errorMessage READ errorMessage NOTIFY errorMessageChanged)
Q_PROPERTY(bool loading READ loading NOTIFY loadingChanged)
// Q_PROPERTY(QAbstractItemModel* model READ model CONSTANT)
// Q_PROPERTY(QAbstractItemModel* model READ model CONSTANT)
Q_ENUMS(Type)
@ -66,20 +63,20 @@ private:
QDate endDate() const;
void setEndDate(const QDate &dateTime);
int types() const;
// void setTypes(int types);
// void setTypes(int types);
QString errorMessage() const;
bool loading() const;
// QAbstractItemModel* model() const;
// QAbstractItemModel* model() const;
// void updateTypes();
// void updateTypes();
QDate m_startDate;
QDate m_endDate;
Types m_types;
// Akonadi::ETMCalendar *m_etmCalendar;
// Akonadi::EntityMimeTypeFilterModel *m_itemList;
// DateTimeRangeFilterModel *m_filteredList;
// Akonadi::ETMCalendar *m_etmCalendar;
// Akonadi::EntityMimeTypeFilterModel *m_itemList;
// DateTimeRangeFilterModel *m_filteredList;
};
#endif // CALENDARDATA_H

7
src/declarativeimports/calendar/calendarplugin.cpp
View File

@ -24,15 +24,12 @@
#include <QAbstractItemModel>
#include <QAbstractListModel>
void CalendarPlugin::registerTypes(const char *uri)
{
Q_ASSERT(uri == QLatin1String("org.kde.plasma.calendar"));
qmlRegisterType<CalendarData>(uri, 2, 0, "CalendarData");
qmlRegisterType<CalendarData>(uri, 2, 0, "CalendarData");
qmlRegisterType<Calendar>(uri, 2, 0, "Calendar");
// qmlRegisterType<CalendarData>(uri, 1, 0, "CalendarData");
// qmlRegisterType<CalendarData>(uri, 1, 0, "CalendarData");
// qmlRegisterType<CalendarData>(uri, 1, 0, "Calendar");
qmlRegisterType<QAbstractItemModel>();
qmlRegisterType<QAbstractListModel>();

4
src/declarativeimports/calendar/calendarplugin.h
View File

@ -20,8 +20,6 @@
#ifndef CALENDARPLUGIN_H
#define CALENDARPLUGIN_H
#include <QQmlExtensionPlugin>
class QQmlEngine;
@ -29,7 +27,7 @@ class QQmlEngine;
class CalendarPlugin : public QQmlExtensionPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
public:
void registerTypes(const char *uri);

9
src/declarativeimports/calendar/daydata.h
View File

@ -7,14 +7,13 @@ public:
bool isPreviousMonth;
bool isCurrentMonth;
bool isNextMonth;
// bool containsHolidayItems;
// bool containsEventItems;
// bool containsTodoItems;
// bool containsJournalItems;
// bool containsHolidayItems;
// bool containsEventItems;
// bool containsTodoItems;
// bool containsJournalItems;
int dayNumber;
int monthNumber;
int yearNumber;
};
#endif // DAYDATA_H

28
src/declarativeimports/calendar/daysmodel.cpp
View File

@ -31,8 +31,8 @@ DaysModel::DaysModel(QObject *parent) :
roleNames.insert(isNextMonth, "isNextMonth");
//roleNames.insert(containsHolidayItems, "containsHolidayItems");
//roleNames.insert(containsEventItems, "containsEventItems");
// roleNames.insert(containsTodoItems, "containsTodoItems");
// roleNames.insert(containsJournalItems, "containsJournalItems");
// roleNames.insert(containsTodoItems, "containsTodoItems");
// roleNames.insert(containsJournalItems, "containsJournalItems");
roleNames.insert(dayNumber, "dayNumber");
roleNames.insert(monthNumber, "monthNumber");
roleNames.insert(yearNumber, "yearNumber");
@ -43,7 +43,7 @@ DaysModel::DaysModel(QObject *parent) :
void DaysModel::setSourceData(QList<DayData> *data)
{
if(m_data != data) {
if (m_data != data) {
m_data = data;
reset();
}
@ -52,7 +52,7 @@ void DaysModel::setSourceData(QList<DayData> *data)
int DaysModel::rowCount(const QModelIndex &parent) const
{
Q_UNUSED(parent)
if(m_data->size() <= 0) {
if (m_data->size() <= 0) {
return 0;
} else {
return m_data->size();
@ -65,19 +65,19 @@ QVariant DaysModel::data(const QModelIndex &index, int role) const
DayData currentData = m_data->at(index.row());
switch(role) {
switch (role) {
case isPreviousMonth:
return currentData.isPreviousMonth;
case isNextMonth:
return currentData.isNextMonth;
// case containsHolidayItems:
// return currentData.containsHolidayItems;
/* case containsEventItems:
return currentData.containsEventItems;
case containsTodoItems:
return currentData.containsTodoItems;
case containsJournalItems:
return currentData.containsJournalItems;*/
// case containsHolidayItems:
// return currentData.containsHolidayItems;
/* case containsEventItems:
return currentData.containsEventItems;
case containsTodoItems:
return currentData.containsTodoItems;
case containsJournalItems:
return currentData.containsJournalItems;*/
case dayNumber:
return currentData.dayNumber;
case monthNumber:
@ -91,7 +91,7 @@ QVariant DaysModel::data(const QModelIndex &index, int role) const
void DaysModel::update()
{
if(m_data->size() <= 0) {
if (m_data->size() <= 0) {
return;
}

2
src/declarativeimports/calendar/daysmodel.h
View File

@ -41,7 +41,7 @@ public:
};
explicit DaysModel(QObject *parent = 0);
void setSourceData(QList<DayData>* data);
void setSourceData(QList<DayData> *data);
virtual int rowCount(const QModelIndex &parent) const;
virtual QVariant data(const QModelIndex &index, int role) const;
void update();

9
src/declarativeimports/core/corebindingsplugin.cpp
View File

@ -46,7 +46,6 @@
// #include "dataenginebindings_p.h"
#include <QDebug>
void CoreBindingsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
@ -61,7 +60,6 @@ void CoreBindingsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
Units *units = new Units(context);
context->setContextProperty("units", units);
if (!engine->rootContext()->contextObject()) {
KDeclarative::KDeclarative kdeclarative;
kdeclarative.setDeclarativeEngine(engine);
@ -92,9 +90,9 @@ void CoreBindingsPlugin::registerTypes(const char *uri)
qmlRegisterType<ToolTip>(uri, 2, 0, "ToolTipArea");
qmlRegisterInterface<Plasma::Service>("Service");
qRegisterMetaType<Plasma::Service*>("Service");
qRegisterMetaType<Plasma::Service *>("Service");
qmlRegisterInterface<Plasma::ServiceJob>("ServiceJob");
qRegisterMetaType<Plasma::ServiceJob*>("ServiceJob");
qRegisterMetaType<Plasma::ServiceJob *>("ServiceJob");
qmlRegisterType<ServiceOperationStatus>(uri, 2, 0, "ServiceOperationStatus");
qmlRegisterType<QAbstractItemModel>();
@ -102,11 +100,10 @@ void CoreBindingsPlugin::registerTypes(const char *uri)
qmlRegisterType<IconItem>(uri, 2, 0, "IconItem");
qmlRegisterInterface<Plasma::DataSource>("DataSource");
qRegisterMetaType<Plasma::DataSource*>("DataSource");
qRegisterMetaType<Plasma::DataSource *>("DataSource");
qmlRegisterType<Plasma::WindowThumbnail>(uri, 2, 0, "WindowThumbnail");
}
#include "corebindingsplugin.moc"

1
src/declarativeimports/core/corebindingsplugin.h
View File

@ -38,5 +38,4 @@ public:
void registerTypes(const char *uri);
};
#endif

2
src/declarativeimports/core/dataenginebindings_p.h
View File

@ -67,7 +67,7 @@ int qScriptRegisterMapMetaType(
QScriptEngine *engine,
const QScriptValue &prototype = QScriptValue()
#ifndef qdoc
, T * /* dummy */ = 0
, T * /* dummy */ = 0
#endif
)
{

24
src/declarativeimports/core/datamodel.cpp
View File

@ -27,14 +27,14 @@
namespace Plasma
{
SortFilterModel::SortFilterModel(QObject* parent)
SortFilterModel::SortFilterModel(QObject *parent)
: QSortFilterProxyModel(parent)
{
setObjectName("SortFilterModel");
setDynamicSortFilter(true);
connect(this, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SIGNAL(countChanged()));
connect(this, SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
connect(this, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SIGNAL(countChanged()));
connect(this, SIGNAL(modelReset()),
this, SIGNAL(countChanged()));
@ -70,7 +70,7 @@ int SortFilterModel::roleNameToId(const QString &name)
return m_roleIds.value(name);
}
void SortFilterModel::setModel(QAbstractItemModel* model)
void SortFilterModel::setModel(QAbstractItemModel *model)
{
if (model == sourceModel()) {
return;
@ -165,10 +165,10 @@ int SortFilterModel::mapRowFromSource(int row) const
return mapFromSource(idx).row();
}
DataModel::DataModel(QObject* parent)
DataModel::DataModel(QObject *parent)
: QAbstractItemModel(parent),
m_dataSource(0),
m_maxRoleId(Qt::UserRole+1)
m_maxRoleId(Qt::UserRole + 1)
{
//There is one reserved role name: DataEngineSource
m_roleNames[m_maxRoleId] = "DataEngineSource";
@ -176,9 +176,9 @@ DataModel::DataModel(QObject* parent)
++m_maxRoleId;
setObjectName("DataModel");
connect(this, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SIGNAL(countChanged()));
connect(this, SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
connect(this, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SIGNAL(countChanged()));
connect(this, SIGNAL(modelReset()),
this, SIGNAL(countChanged()));
@ -215,7 +215,7 @@ void DataModel::dataUpdated(const QString &sourceName, const QVariantMap &data)
} else {
//a key that matches the one we want exists and is a list of DataEngine::Data
if (data.contains(m_keyRoleFilter) &&
data.value(m_keyRoleFilter).canConvert<QVariantList>()) {
data.value(m_keyRoleFilter).canConvert<QVariantList>()) {
setItems(sourceName, data.value(m_keyRoleFilter).value<QVariantList>());
} else if (m_keyRoleFilterRE.isValid()) {
//try to match the key we want with a regular expression if set
@ -265,7 +265,7 @@ QObject *DataModel::dataSource() const
return m_dataSource;
}
void DataModel::setKeyRoleFilter(const QString& key)
void DataModel::setKeyRoleFilter(const QString &key)
{
// the "key role filter" can be used in one of three ways:
//
@ -287,7 +287,7 @@ QString DataModel::keyRoleFilter() const
return m_keyRoleFilter;
}
void DataModel::setSourceFilter(const QString& key)
void DataModel::setSourceFilter(const QString &key)
{
if (m_sourceFilter == key) {
return;
@ -410,7 +410,7 @@ void DataModel::removeSource(const QString &sourceName)
QVariant DataModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || index.column() > 0 ||
index.row() < 0 || index.row() >= countItems()){
index.row() < 0 || index.row() >= countItems()) {
return QVariant();
}

19
src/declarativeimports/core/datamodel.h
View File

@ -34,7 +34,6 @@ namespace Plasma
class DataSource;
class DataModel;
class SortFilterModel : public QSortFilterProxyModel
{
Q_OBJECT
@ -71,7 +70,7 @@ class SortFilterModel : public QSortFilterProxyModel
friend class DataModel;
public:
SortFilterModel(QObject* parent=0);
SortFilterModel(QObject *parent = 0);
~SortFilterModel();
void setModel(QAbstractItemModel *source);
@ -87,7 +86,10 @@ public:
void setSortOrder(const Qt::SortOrder order);
int count() const {return QSortFilterProxyModel::rowCount();}
int count() const
{
return QSortFilterProxyModel::rowCount();
}
/**
* Returns the item at index in the list model.
@ -145,7 +147,7 @@ class DataModel : public QAbstractItemModel
Q_PROPERTY(int count READ count NOTIFY countChanged)
public:
DataModel(QObject* parent=0);
DataModel(QObject *parent = 0);
~DataModel();
void setDataSource(QObject *source);
@ -154,13 +156,13 @@ public:
/**
* Include only items with a key that matches this regexp in the model
*/
void setKeyRoleFilter(const QString& key);
void setKeyRoleFilter(const QString &key);
QString keyRoleFilter() const;
/**
* Include only sources that matches this regexp in the model
*/
void setSourceFilter(const QString& key);
void setSourceFilter(const QString &key);
QString sourceFilter() const;
int roleNameToId(const QString &name);
@ -175,7 +177,10 @@ public:
int rowCount(const QModelIndex &parent = QModelIndex()) const;
int columnCount(const QModelIndex &parent = QModelIndex()) const;
int count() const {return countItems();}
int count() const
{
return countItems();
}
/**
* Returns the item at index in the list model.

18
src/declarativeimports/core/datasource.cpp
View File

@ -24,7 +24,7 @@
namespace Plasma
{
DataSource::DataSource(QObject* parent)
DataSource::DataSource(QObject *parent)
: QObject(parent),
m_interval(0),
m_dataEngine(0),
@ -120,7 +120,7 @@ void DataSource::setupData()
* It is due little explanation why this is a queued connection:
* If sourceAdded arrives immediately, in the case we have a datamodel
* with items at source level we connect too soon (before setData for
* all roles is done), having a dataupdated in the datamodel with only
* all roles is done), having a dataupdated in the datamodel with only
* the first role, killing off the other roles.
* Besides causing a model reset more, unfortunately setRoleNames can be done a single time, so is not possible adding new roles after the
* first setRoleNames() is called.
@ -128,12 +128,12 @@ void DataSource::setupData()
* recommendations engine.
*/
m_dataEngine = engine;
connect(m_dataEngine, SIGNAL(sourceAdded(const QString&)), this, SIGNAL(sourcesChanged()), Qt::QueuedConnection);
connect(m_dataEngine, SIGNAL(sourceRemoved(const QString&)), this, SIGNAL(sourcesChanged()));
connect(m_dataEngine, SIGNAL(sourceAdded(QString)), this, SIGNAL(sourcesChanged()), Qt::QueuedConnection);
connect(m_dataEngine, SIGNAL(sourceRemoved(QString)), this, SIGNAL(sourcesChanged()));
connect(m_dataEngine, SIGNAL(sourceAdded(const QString&)), this, SIGNAL(sourceAdded(const QString&)), Qt::QueuedConnection);
connect(m_dataEngine, SIGNAL(sourceRemoved(const QString&)), this, SLOT(removeSource(const QString&)));
connect(m_dataEngine, SIGNAL(sourceRemoved(const QString&)), this, SIGNAL(sourceRemoved(const QString&)));
connect(m_dataEngine, SIGNAL(sourceAdded(QString)), this, SIGNAL(sourceAdded(QString)), Qt::QueuedConnection);
connect(m_dataEngine, SIGNAL(sourceRemoved(QString)), this, SLOT(removeSource(QString)));
connect(m_dataEngine, SIGNAL(sourceRemoved(QString)), this, SIGNAL(sourceRemoved(QString)));
}
foreach (const QString &source, m_connectedSources) {
@ -163,7 +163,7 @@ void DataSource::modelChanged(const QString &sourceName, QAbstractItemModel *mod
m_models->insert(sourceName, QVariant::fromValue(model));
//FIXME: this will break in the case a second model is set
connect(model, &QObject::destroyed, [=]() {
connect(model, &QObject::destroyed, [ = ]() {
m_models->clear(sourceName);
});
}
@ -189,7 +189,7 @@ void DataSource::removeSource(const QString &source)
}
}
QObject* DataSource::serviceForSource(const QString &source)
QObject *DataSource::serviceForSource(const QString &source)
{
if (!m_services.contains(source)) {
Plasma::Service *service = m_dataEngine->serviceForSource(source);

49
src/declarativeimports/core/datasource.h
View File

@ -30,10 +30,8 @@
#include <Plasma/DataEngineConsumer>
#include <Plasma/DataEngine>
class QQmlPropertyMap;
namespace Plasma
{
class DataEngine;
@ -51,19 +49,25 @@ public:
typedef QMap<QString, QVariant> Data;
DataSource(QObject* parent=0);
DataSource(QObject *parent = 0);
/**
* true if the connection to the Plasma DataEngine is valid
*/
Q_PROPERTY(bool valid READ valid)
bool valid() const {return m_dataEngine && m_dataEngine->isValid();}
bool valid() const
{
return m_dataEngine && m_dataEngine->isValid();
}
/**
* Polling interval in milliseconds when the data will be fetched again. If 0 no polling will be done.
*/
Q_PROPERTY(int interval READ interval WRITE setInterval NOTIFY intervalChanged)
int interval() const {return m_interval;}
int interval() const
{
return m_interval;
}
void setInterval(const int interval);
/**
@ -71,28 +75,44 @@ public:
*/
Q_PROPERTY(QString dataEngine READ engine WRITE setEngine NOTIFY engineChanged)
Q_PROPERTY(QString engine READ engine WRITE setEngine NOTIFY engineChanged)
QString engine() const {return m_engine;}
QString engine() const
{
return m_engine;
}
void setEngine(const QString &e);
/**
* String array of all the source names connected to the DataEngine
*/
Q_PROPERTY(QStringList connectedSources READ connectedSources WRITE setConnectedSources NOTIFY connectedSourcesChanged)
QStringList connectedSources() const {return m_connectedSources;}
QStringList connectedSources() const
{
return m_connectedSources;
}
void setConnectedSources(const QStringList &s);
/**
* Read only string array of all the sources available from the DataEngine (connected or not)
*/
Q_PROPERTY(QStringList sources READ sources NOTIFY sourcesChanged)
QStringList sources() const {if (m_dataEngine) return m_dataEngine->sources(); else return QStringList();}
QStringList sources() const
{
if (m_dataEngine) {
return m_dataEngine->sources();
} else {
return QStringList();
}
}
/**
* All the data fetched by this dataengine.
* This is a map of maps. At the first level, there are the source names, at the second, they keys set by the DataEngine
*/
Q_PROPERTY(QQmlPropertyMap *data READ data CONSTANT);
QQmlPropertyMap *data() const {return m_data;}
QQmlPropertyMap *data() const
{
return m_data;
}
/**
* All the models associated to this DataEngine, indexed by source.
@ -100,13 +120,16 @@ public:
* The user has to be connected to its source, so the source name has to be present in the connectedSources property.
*/
Q_PROPERTY(QQmlPropertyMap *models READ models CONSTANT);
QQmlPropertyMap *models() const {return m_models;}
QQmlPropertyMap *models() const
{
return m_models;
}
/**
* @returns a Plasma::Service given a source name
* @arg QString source source name we want a service of
*/
Q_INVOKABLE QObject* serviceForSource(const QString &source);
Q_INVOKABLE QObject *serviceForSource(const QString &source);
/**
* Connect a new source. It adds it to connectedSources
@ -142,8 +165,8 @@ private:
QString m_engine;
QQmlPropertyMap *m_data;
QQmlPropertyMap *m_models;
Plasma::DataEngine* m_dataEngine;
Plasma::DataEngineConsumer* m_dataEngineConsumer;
Plasma::DataEngine *m_dataEngine;
Plasma::DataEngineConsumer *m_dataEngineConsumer;
QStringList m_connectedSources;
QStringList m_oldSources;
QStringList m_newSources;

12
src/declarativeimports/core/framesvgitem.cpp
View File

@ -96,7 +96,7 @@ bool FrameSvgItemMargins::isFixed() const
FrameSvgItem::FrameSvgItem(QQuickItem *parent)
: QQuickItem(parent),
m_textureChanged(false)
m_textureChanged(false)
{
m_frameSvg = new Plasma::FrameSvg(this);
m_margins = new FrameSvgItemMargins(m_frameSvg, this);
@ -107,7 +107,6 @@ FrameSvgItem::FrameSvgItem(QQuickItem *parent)
connect(&m_units, &Units::devicePixelRatioChanged, this, &FrameSvgItem::updateDevicePixelRatio);
}
FrameSvgItem::~FrameSvgItem()
{
}
@ -145,7 +144,6 @@ QString FrameSvgItem::imagePath() const
return m_frameSvg->imagePath();
}
void FrameSvgItem::setPrefix(const QString &prefix)
{
if (m_prefix == prefix) {
@ -190,8 +188,9 @@ FrameSvgItemMargins *FrameSvgItem::fixedMargins() const
void FrameSvgItem::setEnabledBorders(const Plasma::FrameSvg::EnabledBorders borders)
{
if (m_frameSvg->enabledBorders() == borders)
if (m_frameSvg->enabledBorders() == borders) {
return;
}
m_frameSvg->setEnabledBorders(borders);
emit enabledBordersChanged();
@ -210,7 +209,7 @@ bool FrameSvgItem::hasElementPrefix(const QString &prefix) const
}
void FrameSvgItem::geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry)
const QRectF &oldGeometry)
{
if (isComponentComplete()) {
m_frameSvg->resizeFrame(newGeometry.size());
@ -270,7 +269,7 @@ Plasma::FrameSvg *FrameSvgItem::frameSvg() const
return m_frameSvg;
}
QSGNode* FrameSvgItem::updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData*)
QSGNode *FrameSvgItem::updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *)
{
if (!window() || !m_frameSvg || !m_frameSvg->hasElementPrefix(m_prefix)) {
delete oldNode;
@ -303,7 +302,6 @@ void FrameSvgItem::componentComplete()
m_textureChanged = true;
}
void FrameSvgItem::updateDevicePixelRatio()
{
//devicepixelratio is always set integer in the svg, so needs at least 192dpi to double up.

13
src/declarativeimports/core/framesvgitem.h
View File

@ -27,9 +27,10 @@
#include "units.h"
namespace Plasma {
namespace Plasma
{
class FrameSvg;
class FrameSvg;
class FrameSvgItemMargins : public QObject
{
@ -128,7 +129,7 @@ class FrameSvgItem : public QQuickItem
Q_PROPERTY(qreal implicitHeight READ implicitHeight WRITE setImplicitHeight NOTIFY implicitHeightChanged)
public:
FrameSvgItem(QQuickItem *parent=0);
FrameSvgItem(QQuickItem *parent = 0);
~FrameSvgItem();
void setImagePath(const QString &path);
@ -144,7 +145,7 @@ public:
FrameSvgItemMargins *fixedMargins() const;
void geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry);
const QRectF &oldGeometry);
void setImplicitWidth(qreal width);
qreal implicitWidth() const;
@ -162,9 +163,9 @@ public:
* to draw a frame
* @param prefix the given prefix we want to check if drawable
*/
Q_INVOKABLE bool hasElementPrefix(const QString & prefix) const;
Q_INVOKABLE bool hasElementPrefix(const QString &prefix) const;
virtual QSGNode* updatePaintNode(QSGNode*, UpdatePaintNodeData*);
virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
protected:
virtual void componentComplete();

29
src/declarativeimports/core/iconitem.cpp
View File

@ -29,7 +29,6 @@
#include <plasma/svg.h>
QPixmap transition(const QPixmap &from, const QPixmap &to, qreal amount)
{
if (from.isNull() && to.isNull()) {
@ -43,7 +42,7 @@ QPixmap transition(const QPixmap &from, const QPixmap &to, qreal amount)
QRect startRect(from.rect());
QRect targetRect(to.rect());
QSize pixmapSize = startRect.size().expandedTo(targetRect.size());
QRect toRect = QRect(QPoint(0,0), pixmapSize);
QRect toRect = QRect(QPoint(0, 0), pixmapSize);
targetRect.moveCenter(toRect.center());
startRect.moveCenter(toRect.center());
@ -54,8 +53,8 @@ QPixmap transition(const QPixmap &from, const QPixmap &to, qreal amount)
// If the native paint engine supports Porter/Duff compositing and CompositionMode_Plus
QPaintEngine *paintEngine = from.paintEngine();
if (paintEngine &&
paintEngine->hasFeature(QPaintEngine::PorterDuff) &&
paintEngine->hasFeature(QPaintEngine::BlendModes)) {
paintEngine->hasFeature(QPaintEngine::PorterDuff) &&
paintEngine->hasFeature(QPaintEngine::BlendModes)) {
QPixmap startPixmap(pixmapSize);
startPixmap.fill(Qt::transparent);
@ -163,7 +162,7 @@ IconItem::IconItem(QQuickItem *parent)
{
m_loadPixmapTimer.setSingleShot(true);
m_loadPixmapTimer.setInterval(150);
connect(&m_loadPixmapTimer, &QTimer::timeout, [=] () {
connect(&m_loadPixmapTimer, &QTimer::timeout, [ = ]() {
loadPixmap();
});
@ -183,7 +182,6 @@ IconItem::IconItem(QQuickItem *parent)
connect(KIconLoader::global(), SIGNAL(iconLoaderSettingsChanged()),
this, SIGNAL(implicitHeightChanged()));
connect(this, SIGNAL(enabledChanged()),
&m_loadPixmapTimer, SLOT(start()));
@ -192,7 +190,6 @@ IconItem::IconItem(QQuickItem *parent)
setImplicitHeight(KIconLoader::global()->currentSize(KIconLoader::Dialog));
}
IconItem::~IconItem()
{
}
@ -226,7 +223,7 @@ void IconItem::setSource(const QVariant &source)
m_icon = QIcon();
connect(m_svgIcon, SIGNAL(repaintNeeded()), this, SLOT(loadPixmap()));
//ok, svg not available
//ok, svg not available
} else {
m_icon = QIcon::fromTheme(source.toString());
delete m_svgIcon;
@ -318,7 +315,7 @@ void IconItem::paint(QPainter *painter)
const int iconSize = adjustedSize(qMin(boundingRect().size().width(), boundingRect().size().height()));
const QRect destRect(QPointF(boundingRect().center() - QPointF(iconSize/2, iconSize/2)).toPoint(),
const QRect destRect(QPointF(boundingRect().center() - QPointF(iconSize / 2, iconSize / 2)).toPoint(),
QSize(iconSize, iconSize));
if (m_animation->state() == QAbstractAnimation::Running) {
@ -326,7 +323,7 @@ void IconItem::paint(QPainter *painter)
result = transition(result,
m_iconPixmaps.last(), m_animValue);
painter->drawPixmap(destRect, result);
//simpler logic for just paint
//simpler logic for just paint
} else {
painter->drawPixmap(destRect, m_iconPixmaps.first());
}
@ -349,13 +346,13 @@ void IconItem::valueChanged(const QVariant &value)
int IconItem::adjustedSize(int size)
{
//FIXME: Heuristic: allow 24x24 for icons/ that are in the systray(ugly)
//FIXME: Heuristic: allow 24x24 for icons/ that are in the systray(ugly)
if (m_svgIcon && m_svgIcon->imagePath().contains("icons/") &&
size > KIconLoader::SizeSmallMedium &&
size < KIconLoader::SizeMedium) {
size > KIconLoader::SizeSmallMedium &&
size < KIconLoader::SizeMedium) {
return 24;
//if size is less than 16, leave as is
//if size is less than 16, leave as is
} else if (size < KIconLoader::SizeSmall) {
//do nothing
} else if (size < KIconLoader::SizeSmallMedium) {
@ -366,7 +363,7 @@ int IconItem::adjustedSize(int size)
return KIconLoader::SizeMedium;
} else if (size < KIconLoader::SizeHuge) {
return KIconLoader::SizeLarge;
//if size is more than 64, leave as is
//if size is more than 64, leave as is
}
return size;
@ -378,7 +375,7 @@ void IconItem::loadPixmap()
//final pixmap to paint
QPixmap result;
if (size<=0) {
if (size <= 0) {
//m_iconPixmaps.clear();
m_animation->stop();
update();

7
src/declarativeimports/core/iconitem.h
View File

@ -28,8 +28,9 @@
class QPropertyAnimation;
namespace Plasma {
class Svg;
namespace Plasma
{
class Svg;
}
class IconItem : public QQuickPaintedItem
@ -43,7 +44,7 @@ class IconItem : public QQuickPaintedItem
public:
IconItem(QQuickItem *parent=0);
IconItem(QQuickItem *parent = 0);
~IconItem();
void setSource(const QVariant &source);

2
src/declarativeimports/core/serviceoperationstatus.cpp
View File

@ -19,8 +19,6 @@
#include "serviceoperationstatus.h"
ServiceOperationStatus::ServiceOperationStatus(QObject *parent)
: QObject(parent),
m_enabled(false)

8
src/declarativeimports/core/serviceoperationstatus.h
View File

@ -23,8 +23,9 @@
#include "plasma/service.h"
namespace Plasma {
class Service;
namespace Plasma
{
class Service;
}
class ServiceOperationStatus : public QObject
@ -47,7 +48,7 @@ class ServiceOperationStatus : public QObject
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
public:
ServiceOperationStatus(QObject *parent=0);
ServiceOperationStatus(QObject *parent = 0);
~ServiceOperationStatus();
void setService(Plasma::Service *service);
@ -73,5 +74,4 @@ private:
bool m_enabled;
};
#endif

3
src/declarativeimports/core/svgitem.cpp
View File

@ -43,7 +43,6 @@ SvgItem::SvgItem(QQuickItem *parent)
connect(&m_units, &Units::devicePixelRatioChanged, this, &SvgItem::updateDevicePixelRatio);
}
SvgItem::~SvgItem()
{
}
@ -85,7 +84,6 @@ QSizeF SvgItem::naturalSize() const
return m_svg.data()->size();
}
void SvgItem::setSvg(Plasma::Svg *svg)
{
if (m_svg) {
@ -100,7 +98,6 @@ void SvgItem::setSvg(Plasma::Svg *svg)
connect(svg, SIGNAL(sizeChanged()), this, SIGNAL(naturalSizeChanged()));
}
if (implicitWidth() <= 0) {
setImplicitWidth(naturalSize().width());
}

11
src/declarativeimports/core/svgitem.h
View File

@ -24,9 +24,10 @@
#include "units.h"
namespace Plasma {
namespace Plasma
{
class Svg;
class Svg;
class SvgItem : public QQuickItem
{
@ -47,7 +48,7 @@ class SvgItem : public QQuickItem
* </code>
* Instead of a Svg declaration it can also be the id of a Svg declared elsewhere, useful to share Svg instances.
*/
Q_PROPERTY(Plasma::Svg * svg READ svg WRITE setSvg NOTIFY svgChanged)
Q_PROPERTY(Plasma::Svg *svg READ svg WRITE setSvg NOTIFY svgChanged)
/**
* The natural, unscaled size of the svg document or the element. useful if a pixel perfect rendering of outlines is needed.
@ -70,7 +71,7 @@ class SvgItem : public QQuickItem
Q_PROPERTY(qreal implicitHeight READ implicitHeight WRITE setImplicitHeight NOTIFY implicitHeightChanged)
public:
SvgItem(QQuickItem *parent=0);
SvgItem(QQuickItem *parent = 0);
~SvgItem();
void setElementId(const QString &elementID);
@ -90,7 +91,7 @@ public:
void setImplicitHeight(qreal height);
qreal implicitHeight() const;
QSGNode* updatePaintNode(QSGNode * oldNode, UpdatePaintNodeData * updatePaintNodeData);
QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData);
Q_SIGNALS:
void elementIdChanged();

28
src/declarativeimports/core/svgtexturenode.h
View File

@ -22,7 +22,8 @@
#include <QSGSimpleTextureNode>
namespace Plasma {
namespace Plasma
{
/**
* This class wraps QSGSimpleTextureNode
@ -31,18 +32,19 @@ namespace Plasma {
class SVGTextureNode : public QSGSimpleTextureNode
{
public:
SVGTextureNode() {}
/**
* Set the current texture
* the object takes ownership of the texture
*/
void setTexture(QSGTexture *texture) {
m_texture.reset(texture);
QSGSimpleTextureNode::setTexture(texture);
}
private:
QScopedPointer<QSGTexture> m_texture;
public:
SVGTextureNode() {}
/**
* Set the current texture
* the object takes ownership of the texture
*/
void setTexture(QSGTexture *texture)
{
m_texture.reset(texture);
QSGSimpleTextureNode::setTexture(texture);
}
private:
QScopedPointer<QSGTexture> m_texture;
};
}

2
src/declarativeimports/core/tooltip.cpp
View File

@ -316,7 +316,7 @@ void ToolTip::hoverEnterEvent(QHoverEvent *event)
//FIXME: showToolTip needs to be renamed in sync or something like that
showToolTip();
} else if (m_mainItem ||
(!mainText().isEmpty() && !subText().isEmpty())) {
(!mainText().isEmpty() && !subText().isEmpty())) {
m_showTimer->start(m_interval);
}
}

2
src/declarativeimports/core/tooltip.h
View File

@ -109,7 +109,7 @@ class ToolTip : public QQuickItem
Q_PROPERTY(bool active MEMBER m_active WRITE setActive NOTIFY activeChanged)
/**
* if interactive is false (default), the tooltip will automatically hide
* if interactive is false (default), the tooltip will automatically hide
* itself as soon as the mouse leaves the tooltiparea, if is true, if the mouse leaves tooltiparea and goes over the tooltip itself, the tooltip won't hide, so it will be possible to interact with tooltip contents
*/
Q_PROPERTY(bool interactive MEMBER m_interactive WRITE setInteractive NOTIFY interactiveChanged)

2
src/declarativeimports/core/tooltipdialog.cpp
View File

@ -47,7 +47,7 @@ ToolTipDialog::ToolTipDialog(QQuickItem *parent)
m_showTimer = new QTimer(this);
m_showTimer->setSingleShot(true);
connect(m_showTimer, &QTimer::timeout, [=]() {
connect(m_showTimer, &QTimer::timeout, [ = ]() {
setVisible(false);
});
}

2
src/declarativeimports/core/tooltipdialog.h
View File

@ -33,7 +33,7 @@ class QPropertyAnimation;
namespace KDeclarative
{
class QmlObject;
class QmlObject;
}
/**

3
src/declarativeimports/core/units.cpp
View File

@ -36,7 +36,7 @@ const QString plasmarc = QStringLiteral("plasmarc");
const QString groupName = QStringLiteral("Units");
const int defaultLongDuration = 250;
Units::Units (QObject *parent)
Units::Units(QObject *parent)
: QObject(parent),
m_gridUnit(-1),
m_devicePixelRatio(-1),
@ -194,7 +194,6 @@ void Units::updateSpacing()
}
}
int Units::longDuration() const
{
return m_longDuration;

38
src/declarativeimports/core/windowthumbnail.cpp
View File

@ -30,18 +30,19 @@
#include <xcb/composite.h>
#if HAVE_GLX
#include <GL/glx.h>
typedef void (*glXBindTexImageEXT_func)(Display* dpy, GLXDrawable drawable,
int buffer, const int* attrib_list);
typedef void (*glXReleaseTexImageEXT_func)(Display* dpy, GLXDrawable drawable, int buffer);
typedef void (*glXBindTexImageEXT_func)(Display *dpy, GLXDrawable drawable,
int buffer, const int *attrib_list);
typedef void (*glXReleaseTexImageEXT_func)(Display *dpy, GLXDrawable drawable, int buffer);
#endif
#if HAVE_EGL
typedef EGLImageKHR(*eglCreateImageKHR_func)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint*);
typedef EGLImageKHR(*eglCreateImageKHR_func)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint *);
typedef EGLBoolean(*eglDestroyImageKHR_func)(EGLDisplay, EGLImageKHR);
typedef GLvoid(*glEGLImageTargetTexture2DOES_func)(GLenum, GLeglImageOES);
#endif // HAVE_EGL
#endif
namespace Plasma {
namespace Plasma
{
WindowTextureNode::WindowTextureNode()
: QSGSimpleTextureNode()
@ -58,7 +59,7 @@ void WindowTextureNode::reset(QSGTexture *texture)
m_texture.reset(texture);
}
WindowThumbnail::WindowThumbnail(QQuickItem* parent)
WindowThumbnail::WindowThumbnail(QQuickItem *parent)
: QQuickItem(parent)
, QAbstractNativeEventFilter()
, m_xcb(false)
@ -80,7 +81,7 @@ WindowThumbnail::WindowThumbnail(QQuickItem* parent)
#endif
{
setFlag(ItemHasContents);
connect(this, &QQuickItem::windowChanged, [this](QQuickWindow *window) {
connect(this, &QQuickItem::windowChanged, [this](QQuickWindow * window) {
if (!window) {
return;
}
@ -88,7 +89,7 @@ WindowThumbnail::WindowThumbnail(QQuickItem* parent)
stopRedirecting();
startRedirecting();
});
if (QGuiApplication *gui = dynamic_cast<QGuiApplication*>(QCoreApplication::instance())) {
if (QGuiApplication *gui = dynamic_cast<QGuiApplication *>(QCoreApplication::instance())) {
m_xcb = (gui->platformName() == QStringLiteral("xcb"));
if (m_xcb) {
gui->installNativeEventFilter(this);
@ -141,7 +142,7 @@ void WindowThumbnail::setWinId(uint32_t winId)
QSGNode *WindowThumbnail::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData)
{
Q_UNUSED(updatePaintNodeData)
auto *node = static_cast<WindowTextureNode*>(oldNode);
auto *node = static_cast<WindowTextureNode *>(oldNode);
if (!node) {
node = new WindowTextureNode();
node->setFiltering(QSGTexture::Linear);
@ -153,8 +154,8 @@ QSGNode *WindowThumbnail::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData
}
node->setRect(boundingRect());
const QSize size(node->texture()->textureSize().scaled(boundingRect().size().toSize(), Qt::KeepAspectRatio));
const qreal x = boundingRect().x() + (boundingRect().width() - size.width())/2;
const qreal y = boundingRect().y() + (boundingRect().height() - size.height())/2;
const qreal x = boundingRect().x() + (boundingRect().width() - size.width()) / 2;
const qreal y = boundingRect().y() + (boundingRect().height() - size.height()) / 2;
node->setRect(QRectF(QPointF(x, y), size));
return node;
}
@ -167,15 +168,15 @@ bool WindowThumbnail::nativeEventFilter(const QByteArray &eventType, void *messa
return false;
}
#if HAVE_XCB_COMPOSITE
xcb_generic_event_t *event = static_cast<xcb_generic_event_t*>(message);
xcb_generic_event_t *event = static_cast<xcb_generic_event_t *>(message);
const uint8_t responseType = event->response_type & ~0x80;
if (responseType == m_damageEventBase + XCB_DAMAGE_NOTIFY) {
if (reinterpret_cast<xcb_damage_notify_event_t*>(event)->drawable == m_winId) {
if (reinterpret_cast<xcb_damage_notify_event_t *>(event)->drawable == m_winId) {
m_damaged = true;
update();
}
} else if (responseType == XCB_CONFIGURE_NOTIFY) {
if (reinterpret_cast<xcb_configure_notify_event_t*>(event)->window == m_winId) {
if (reinterpret_cast<xcb_configure_notify_event_t *>(event)->window == m_winId) {
// TODO: only discard if size changes
discardPixmap();
}
@ -253,8 +254,8 @@ bool WindowThumbnail::xcbWindowToTextureEGL(WindowTextureNode *textureNode)
EGL_NONE
};
m_image = ((eglCreateImageKHR_func)(m_eglCreateImageKHR))(eglGetCurrentDisplay(), EGL_NO_CONTEXT,
EGL_NATIVE_PIXMAP_KHR,
(EGLClientBuffer)m_pixmap, attribs);
EGL_NATIVE_PIXMAP_KHR,
(EGLClientBuffer)m_pixmap, attribs);
if (m_image == EGL_NO_IMAGE_KHR) {
qDebug() << "failed to create egl image";
@ -402,10 +403,11 @@ bool WindowThumbnail::loadGLXTexture()
XVisualInfo *vi = glXGetVisualFromFBConfig(d, fbConfigs[0]);
int textureFormat;
if (window()->openglContext()->format().hasAlpha())
if (window()->openglContext()->format().hasAlpha()) {
textureFormat = bindRgba ? GLX_TEXTURE_FORMAT_RGBA_EXT : GLX_TEXTURE_FORMAT_RGB_EXT;
else
} else {
textureFormat = bindRgb ? GLX_TEXTURE_FORMAT_RGB_EXT : GLX_TEXTURE_FORMAT_RGBA_EXT;
}
XFree(vi);
// we assume that Texture_2D is supported as we have a QtQuick OpenGL context

3
src/declarativeimports/core/windowthumbnail.h
View File

@ -37,7 +37,8 @@
#endif // HAVE_XCB_COMPOSITE
class KWindowInfo;
namespace Plasma {
namespace Plasma
{
class WindowTextureNode;

2
src/declarativeimports/plasmacomponents/enums.cpp
View File

@ -19,6 +19,4 @@
#include "enums.h"
#include "moc_enums.cpp"

2
src/declarativeimports/plasmacomponents/enums.h
View File

@ -22,7 +22,6 @@
#include <QObject>
class DialogStatus : public QObject
{
Q_OBJECT
@ -66,5 +65,4 @@ public:
};
};
#endif // ENUMS_H

1
src/declarativeimports/plasmacomponents/fullscreensheet.cpp
View File

@ -138,6 +138,5 @@ void FullScreenSheet::open()
}
}
#include "fullscreensheet.moc"

35
src/declarativeimports/plasmacomponents/fullscreenwindow.cpp
View File

@ -41,18 +41,17 @@
#include <Plasma/Corona>
#include <Plasma/WindowEffects>
uint FullScreenWindow::s_numItems = 0;
class Background : public QWidget
{
public:
Background(FullScreenWindow *dialog)
: QWidget( 0L ),
: QWidget(0L),
m_dialog(dialog)
{
setAttribute( Qt::WA_NoSystemBackground );
setAttribute( Qt::WA_TranslucentBackground );
setAttribute(Qt::WA_NoSystemBackground);
setAttribute(Qt::WA_TranslucentBackground);
setWindowFlags(Qt::FramelessWindowHint | Qt::CustomizeWindowHint);
KWindowSystem::setOnAllDesktops(winId(), true);
@ -63,9 +62,9 @@ public:
~Background()
{}
void paintEvent( QPaintEvent *e )
void paintEvent(QPaintEvent *e)
{
QPainter painter( this );
QPainter painter(this);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.fillRect(e->rect(), QColor(0, 0, 0, 80));
}
@ -151,7 +150,7 @@ void FullScreenWindow::init(const QString &componentName)
QDeclarativeContext *creationContext = component->creationContext();
m_rootObject = component->create(creationContext);
if (component->status() == QDeclarativeComponent::Error) {
qWarning()<<component->errors();
qWarning() << component->errors();
}
if (m_rootObject) {
@ -220,8 +219,8 @@ void FullScreenWindow::syncViewToMainItem()
}
m_declarativeItemContainer->setDeclarativeItem(di);
} else {
m_mainItem.data()->setY(-10000*s_numItems);
m_mainItem.data()->setY(10000*s_numItems);
m_mainItem.data()->setY(-10000 * s_numItems);
m_mainItem.data()->setY(10000 * s_numItems);
}
break;
}
@ -235,7 +234,6 @@ void FullScreenWindow::syncViewToMainItem()
m_view->setScene(scene);
QRectF itemGeometry(QPointF(m_mainItem.data()->x(), m_mainItem.data()->y()),
QSizeF(m_mainItem.data()->boundingRect().size()));
if (m_declarativeItemContainer) {
@ -244,12 +242,12 @@ void FullScreenWindow::syncViewToMainItem()
} else {
QRectF itemGeometry(QPointF(m_mainItem.data()->x(), m_mainItem.data()->y()),
QSizeF(m_mainItem.data()->boundingRect().size()));
QSizeF(m_mainItem.data()->boundingRect().size()));
m_view->resize(itemGeometry.size().toSize());
m_view->setSceneRect(itemGeometry);
}
m_view->move(QApplication::desktop()->availableGeometry().center() - QPoint(m_view->width()/2, m_view->height()/2));
m_view->move(QApplication::desktop()->availableGeometry().center() - QPoint(m_view->width() / 2, m_view->height() / 2));
}
void FullScreenWindow::syncMainItemToView()
@ -266,7 +264,7 @@ void FullScreenWindow::syncMainItemToView()
m_view->setSceneRect(m_declarativeItemContainer->geometry());
} else {
QRectF itemGeometry(QPointF(m_mainItem.data()->x(), m_mainItem.data()->y()),
QSizeF(m_mainItem.data()->boundingRect().size()));
QSizeF(m_mainItem.data()->boundingRect().size()));
m_view->setSceneRect(itemGeometry);
}
}
@ -297,7 +295,6 @@ QGraphicsView *FullScreenWindow::view() const
return m_view;
}
QDeclarativeListProperty<QGraphicsObject> FullScreenWindow::title()
{
if (m_rootObject) {
@ -334,7 +331,6 @@ DialogStatus::Status FullScreenWindow::status() const
}
}
void FullScreenWindow::statusHasChanged()
{
if (status() == DialogStatus::Closed) {
@ -373,22 +369,17 @@ void FullScreenWindow::close()
}
}
bool FullScreenWindow::eventFilter(QObject *watched, QEvent *event)
{
if (watched == m_mainItem.data() &&
(event->type() == QEvent::GraphicsSceneResize)) {
(event->type() == QEvent::GraphicsSceneResize)) {
syncViewToMainItem();
} else if (watched == m_view &&
(event->type() == QEvent::Resize)) {
(event->type() == QEvent::Resize)) {
syncMainItemToView();
}
return false;
}
#include "fullscreenwindow.moc"

2
src/declarativeimports/plasmacomponents/fullscreenwindow.h
View File

@ -43,7 +43,6 @@ class FullScreenWindow : public QDeclarativeItem
Q_PROPERTY(QDeclarativeListProperty<QGraphicsObject> buttons READ buttons DESIGNABLE false)
Q_PROPERTY(DialogStatus::Status status READ status NOTIFY statusChanged)
public:
FullScreenWindow(QDeclarativeItem *parent = 0);
~FullScreenWindow();
@ -73,7 +72,6 @@ Q_SIGNALS:
void clickedOutside();
void statusChanged();
private Q_SLOTS:
void syncViewToMainItem();
void syncMainItemToView();

11
src/declarativeimports/plasmacomponents/plasmacomponentsplugin.cpp
View File

@ -37,7 +37,7 @@
class BKSingleton
{
public:
EngineBookKeeping self;
EngineBookKeeping self;
};
Q_GLOBAL_STATIC(BKSingleton, privateBKSelf)
@ -63,8 +63,8 @@ QQmlEngine *EngineBookKeeping::engine() const
void EngineBookKeeping::insertEngine(QQmlEngine *engine)
{
connect(engine, SIGNAL(destroyed(QObject *)),
this, SLOT(engineDestroyed(QObject *)));
connect(engine, SIGNAL(destroyed(QObject*)),
this, SLOT(engineDestroyed(QObject*)));
m_engines.insert(engine);
}
@ -73,8 +73,6 @@ void EngineBookKeeping::engineDestroyed(QObject *deleted)
m_engines.remove(static_cast<QQmlEngine *>(deleted));
}
void PlasmaComponentsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
{
QQmlExtensionPlugin::initializeEngine(engine, uri);
@ -91,7 +89,7 @@ void PlasmaComponentsPlugin::registerTypes(const char *uri)
qmlRegisterType<QMenuProxy>(uri, 2, 0, "Menu");
qmlRegisterType<QMenuItem>(uri, 2, 0, "MenuItem");
} else {
// qmlRegisterType<FullScreenSheet>(uri, 2, 0, "Sheet");
// qmlRegisterType<FullScreenSheet>(uri, 2, 0, "Sheet");
}
qmlRegisterType<Plasma::QRangeModel>(uri, 2, 0, "RangeModel");
@ -101,6 +99,5 @@ void PlasmaComponentsPlugin::registerTypes(const char *uri)
qmlRegisterUncreatableType<PageStatus>(uri, 2, 0, "PageStatus", "");
}
#include "moc_plasmacomponentsplugin.cpp"

2
src/declarativeimports/plasmacomponents/plasmacomponentsplugin.h
View File

@ -42,7 +42,7 @@ private Q_SLOTS:
void engineDestroyed(QObject *deleted);
private:
QSet <QQmlEngine*> m_engines;
QSet <QQmlEngine *> m_engines;
};
class PlasmaComponentsPlugin : public QQmlExtensionPlugin

11
src/declarativeimports/plasmacomponents/qmenu.cpp
View File

@ -26,13 +26,13 @@
#include <QQuickItem>
#include "plasmacomponentsplugin.h"
QMenuProxy::QMenuProxy (QObject *parent)
QMenuProxy::QMenuProxy(QObject *parent)
: QObject(parent),
m_status(DialogStatus::Closed)
{
m_menu = new QMenu(0);
connect(m_menu, &QMenu::triggered, this, &QMenuProxy::itemTriggered);
connect(m_menu, &QMenu::aboutToHide, [=]() {
connect(m_menu, &QMenu::aboutToHide, [ = ]() {
m_status = DialogStatus::Closed;
emit statusChanged();
});
@ -85,7 +85,7 @@ void QMenuProxy::setVisualParent(QObject *parent)
if (action) {
action->setMenu(m_menu);
m_menu->clear();
foreach(QMenuItem* item, m_items) {
foreach (QMenuItem *item, m_items) {
m_menu->addAction(item->action());
}
m_menu->updateGeometry();
@ -179,8 +179,8 @@ void QMenuProxy::open(int x, int y)
{
qDebug() << "opening menu at " << x << y;
m_menu->clear();
foreach(QMenuItem* item, m_items) {
qDebug() <<"Adding action: " << item->text();
foreach (QMenuItem *item, m_items) {
qDebug() << "Adding action: " << item->text();
m_menu->addAction(item->action());
}
@ -200,7 +200,6 @@ void QMenuProxy::open(int x, int y)
emit statusChanged();
}
void QMenuProxy::close()
{
m_menu->hide();

2
src/declarativeimports/plasmacomponents/qmenu.h
View File

@ -82,7 +82,7 @@ private Q_SLOTS:
void itemTriggered(QAction *item);
private:
QList<QMenuItem*> m_items;
QList<QMenuItem *> m_items;
QMenu *m_menu;
DialogStatus::Status m_status;
QWeakPointer<QObject> m_visualParent;

11
src/declarativeimports/plasmacomponents/qmenuitem.cpp
View File

@ -20,22 +20,21 @@
#include "qmenuitem.h"
QMenuItem::QMenuItem(QQuickItem *parent)
: QQuickItem(parent),
m_action(0)
m_action(0)
{
setAction(new QAction(this));
connect(m_action, &QAction::triggered, this, &QMenuItem::clicked);
}
QAction* QMenuItem::action() const
QAction *QMenuItem::action() const
{
return m_action;
}
void QMenuItem::setAction(QAction* a)
void QMenuItem::setAction(QAction *a)
{
if (m_action != a) {
if (m_action) {
@ -54,7 +53,7 @@ QVariant QMenuItem::icon() const
return m_icon;
}
void QMenuItem::setIcon(const QVariant& i)
void QMenuItem::setIcon(const QVariant &i)
{
m_icon = i;
if (i.canConvert<QIcon>()) {
@ -80,7 +79,7 @@ QString QMenuItem::text() const
return m_action->text();
}
void QMenuItem::setText(const QString& t)
void QMenuItem::setText(const QString &t)
{
if (m_action->text() != t) {
m_action->setText(t);

10
src/declarativeimports/plasmacomponents/qmenuitem.h
View File

@ -39,17 +39,17 @@ class QMenuItem : public QQuickItem
Q_PROPERTY(bool separator READ separator WRITE setSeparator NOTIFY separatorChanged)
Q_PROPERTY(QString text READ text WRITE setText NOTIFY textChanged)
Q_PROPERTY(QVariant icon READ icon WRITE setIcon NOTIFY iconChanged)
Q_PROPERTY(QAction* action READ action WRITE setAction NOTIFY actionChanged)
Q_PROPERTY(QAction *action READ action WRITE setAction NOTIFY actionChanged)
Q_PROPERTY(bool checkable READ checkable WRITE setCheckable NOTIFY checkableChanged)
Q_PROPERTY(bool checked READ checked WRITE setChecked NOTIFY toggled)
public:
QMenuItem(QQuickItem *parent = 0);
QAction* action() const;
void setAction(QAction* a);
QAction *action() const;
void setAction(QAction *a);
QVariant icon() const;
void setIcon(const QVariant& i);
void setIcon(const QVariant &i);
bool separator() const;
void setSeparator(bool s);
QString text() const;
@ -72,7 +72,7 @@ Q_SIGNALS:
void checkableChanged();
private:
QAction* m_action;
QAction *m_action;
QVariant m_icon;
};

51
src/declarativeimports/plasmacomponents/qrangemodel.cpp
View File

@ -104,14 +104,16 @@ qreal QRangeModelPrivate::publicPosition(qreal position) const
const qreal positionValueRatio = valueRange ? (max - min) / valueRange : 0;
const qreal positionStep = stepSize * positionValueRatio;
if (positionStep == 0)
if (positionStep == 0) {
return (min < max) ? qBound(min, position, max) : qBound(max, position, min);
}
const int stepSizeMultiplier = (position - min) / positionStep;
// Test whether value is below minimum range
if (stepSizeMultiplier < 0)
if (stepSizeMultiplier < 0) {
return min;
}
qreal leftEdge = (stepSizeMultiplier * positionStep) + min;
qreal rightEdge = ((stepSizeMultiplier + 1) * positionStep) + min;
@ -124,8 +126,9 @@ qreal QRangeModelPrivate::publicPosition(qreal position) const
rightEdge = qMax(rightEdge, max);
}
if (qAbs(leftEdge - position) <= qAbs(rightEdge - position))
if (qAbs(leftEdge - position) <= qAbs(rightEdge - position)) {
return leftEdge;
}
return rightEdge;
}
@ -143,14 +146,16 @@ qreal QRangeModelPrivate::publicValue(qreal value) const
// QML bindings; a position that is initially invalid because it lays
// outside the range, might become valid later if the range changes.
if (stepSize == 0)
if (stepSize == 0) {
return qBound(minimum, value, maximum);
}
const int stepSizeMultiplier = (value - minimum) / stepSize;
// Test whether value is below minimum range
if (stepSizeMultiplier < 0)
if (stepSizeMultiplier < 0) {
return minimum;
}
const qreal leftEdge = qMin(maximum, (stepSizeMultiplier * stepSize) + minimum);
const qreal rightEdge = qMin(maximum, ((stepSizeMultiplier + 1) * stepSize) + minimum);
@ -172,10 +177,12 @@ void QRangeModelPrivate::emitValueAndPositionIfChanged(const qreal oldValue, con
// unchanged. This will be the case when operating with values outside range:
const qreal newValue = q->value();
const qreal newPosition = q->position();
if (!qFuzzyCompare(newValue, oldValue))
if (!qFuzzyCompare(newValue, oldValue)) {
emit q->valueChanged(newValue);
if (!qFuzzyCompare(newPosition, oldPosition))
}
if (!qFuzzyCompare(newPosition, oldPosition)) {
emit q->positionChanged(newPosition);
}
}
/*!
@ -224,8 +231,9 @@ void QRangeModel::setPositionRange(qreal min, qreal max)
bool emitPosAtMinChanged = !qFuzzyCompare(min, d->posatmin);
bool emitPosAtMaxChanged = !qFuzzyCompare(max, d->posatmax);
if (!(emitPosAtMinChanged || emitPosAtMaxChanged))
if (!(emitPosAtMinChanged || emitPosAtMaxChanged)) {
return;
}
const qreal oldPosition = position();
d->posatmin = min;
@ -239,10 +247,12 @@ void QRangeModel::setPositionRange(qreal min, qreal max)
// the positionChanged signal.
d->pos = d->equivalentPosition(d->value);
if (emitPosAtMinChanged)
if (emitPosAtMinChanged) {
emit positionAtMinimumChanged(d->posatmin);
if (emitPosAtMaxChanged)
}
if (emitPosAtMaxChanged) {
emit positionAtMaximumChanged(d->posatmax);
}
d->emitValueAndPositionIfChanged(value(), oldPosition);
}
@ -259,8 +269,9 @@ void QRangeModel::setRange(qreal min, qreal max)
bool emitMinimumChanged = !qFuzzyCompare(min, d->minimum);
bool emitMaximumChanged = !qFuzzyCompare(max, d->maximum);
if (!(emitMinimumChanged || emitMaximumChanged))
if (!(emitMinimumChanged || emitMaximumChanged)) {
return;
}
const qreal oldValue = value();
const qreal oldPosition = position();
@ -271,10 +282,12 @@ void QRangeModel::setRange(qreal min, qreal max)
// Update internal position if it was changed. It can occurs if internal value changes, due to range update
d->pos = d->equivalentPosition(d->value);
if (emitMinimumChanged)
if (emitMinimumChanged) {
emit minimumChanged(d->minimum);
if (emitMaximumChanged)
}
if (emitMaximumChanged) {
emit maximumChanged(d->maximum);
}
d->emitValueAndPositionIfChanged(oldValue, oldPosition);
}
@ -332,8 +345,9 @@ void QRangeModel::setStepSize(qreal stepSize)
Q_D(QRangeModel);
stepSize = qMax(qreal(0.0), stepSize);
if (qFuzzyCompare(stepSize, d->stepSize))
if (qFuzzyCompare(stepSize, d->stepSize)) {
return;
}
const qreal oldValue = value();
const qreal oldPosition = position();
@ -386,8 +400,9 @@ void QRangeModel::setPosition(qreal newPosition)
{
Q_D(QRangeModel);
if (qFuzzyCompare(newPosition, d->pos))
if (qFuzzyCompare(newPosition, d->pos)) {
return;
}
const qreal oldPosition = position();
const qreal oldValue = value();
@ -473,8 +488,9 @@ void QRangeModel::setValue(qreal newValue)
{
Q_D(QRangeModel);
if (qFuzzyCompare(newValue, d->value))
if (qFuzzyCompare(newValue, d->value)) {
return;
}
const qreal oldValue = value();
const qreal oldPosition = position();
@ -497,8 +513,9 @@ void QRangeModel::setValue(qreal newValue)
void QRangeModel::setInverted(bool inverted)
{
Q_D(QRangeModel);
if (inverted == d->inverted)
if (inverted == d->inverted) {
return;
}
d->inverted = inverted;
emit invertedChanged(d->inverted);

2
src/declarativeimports/plasmacomponents/qrangemodel.h
View File

@ -113,7 +113,7 @@ Q_SIGNALS:
protected:
QRangeModel(QRangeModelPrivate &dd, QObject *parent);
QRangeModelPrivate* d_ptr;
QRangeModelPrivate *d_ptr;
private:
Q_DISABLE_COPY(QRangeModel)

18
src/declarativeimports/plasmacomponents/qrangemodel_p.h
View File

@ -59,29 +59,35 @@ public:
QRangeModel *q_ptr;
inline qreal effectivePosAtMin() const {
inline qreal effectivePosAtMin() const
{
return inverted ? posatmax : posatmin;
}
inline qreal effectivePosAtMax() const {
inline qreal effectivePosAtMax() const
{
return inverted ? posatmin : posatmax;
}
inline qreal equivalentPosition(qreal value) const {
inline qreal equivalentPosition(qreal value) const
{
// Return absolute position from absolute value
const qreal valueRange = maximum - minimum;
if (valueRange == 0)
if (valueRange == 0) {
return effectivePosAtMin();
}
const qreal scale = (effectivePosAtMax() - effectivePosAtMin()) / valueRange;
return (value - minimum) * scale + effectivePosAtMin();
}
inline qreal equivalentValue(qreal pos) const {
inline qreal equivalentValue(qreal pos) const
{
// Return absolute value from absolute position
const qreal posRange = effectivePosAtMax() - effectivePosAtMin();
if (posRange == 0)
if (posRange == 0) {
return minimum;
}
const qreal scale = (maximum - minimum) / posRange;
return (pos - effectivePosAtMin()) * scale + minimum;

2
src/declarativeimports/plasmaextracomponents/appbackgroundprovider.cpp
View File

@ -27,7 +27,7 @@
#include <Plasma/Theme>
AppBackgroundProvider::AppBackgroundProvider()
: QQuickImageProvider(QQuickImageProvider::Image)
: QQuickImageProvider(QQuickImageProvider::Image)
{
m_theme = new Plasma::Theme();
}

2
src/declarativeimports/plasmaextracomponents/appbackgroundprovider_p.h
View File

@ -24,7 +24,7 @@
namespace Plasma
{
class Theme;
class Theme;
}
class AppBackgroundProvider : public QQuickImageProvider

1
src/declarativeimports/plasmaextracomponents/fallbackcomponent.cpp
View File

@ -25,7 +25,6 @@
#include <QDebug>
FallbackComponent::FallbackComponent(QObject *parent)
: QObject(parent)
{

5
src/declarativeimports/plasmaextracomponents/fallbackcomponent.h
View File

@ -20,7 +20,6 @@
#ifndef FALLBACKCOMPONENT_H
#define FALLBACKCOMPONENT_H
#include <QObject>
#include <QCache>
#include <QStringList>
@ -55,16 +54,14 @@ public:
*
* @param key the name of the file to search for
**/
Q_INVOKABLE QString filePath(const QString& key = QString());
Q_INVOKABLE QString filePath(const QString &key = QString());
QString basePath() const;
void setBasePath(const QString &basePath);
QStringList candidates() const;
void setCandidates(const QStringList &candidates);
Q_SIGNALS:
void basePathChanged();
void candidatesChanged();

4
src/declarativeimports/plasmaextracomponents/plasmaextracomponentsplugin.cpp
View File

@ -1,6 +1,6 @@
/*
* Copyright 2012 by Sebastian Kügler <sebas@kde.org>
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2, or
@ -26,7 +26,6 @@
#include <QtQml>
#include <QQmlEngine>
// #include <KSharedConfig>
// #include <KConfigGroup>
@ -43,6 +42,5 @@ void PlasmaExtraComponentsPlugin::registerTypes(const char *uri)
qmlRegisterType<FallbackComponent>(uri, 2, 0, "FallbackComponent");
}
#include "plasmaextracomponentsplugin.moc"

4
src/declarativeimports/plasmaextracomponents/resourceinstance.cpp
View File

@ -26,7 +26,6 @@
#include <KActivities/ResourceInstance>
#include <QDebug>
ResourceInstance::ResourceInstance(QQuickItem *parent)
: QQuickItem(parent)
{
@ -56,7 +55,7 @@ void ResourceInstance::syncWid()
} else {
if (m_uri.scheme().startsWith(QLatin1String("http")) && !m_uri.hasQuery() && m_uri.path().endsWith('/')) {
const QString & oldPath = m_uri.path();
const QString &oldPath = m_uri.path();
m_uri.setPath(oldPath.left(oldPath.length() - 1));
// qDebug() << "Old and new path" << oldPath << m_uri;
@ -129,7 +128,6 @@ void ResourceInstance::notifyFocusedIn()
m_resourceInstance->notifyFocusedIn();
}
void ResourceInstance::notifyFocusedOut()
{
//ensure the resource instance exists

5
src/declarativeimports/plasmaextracomponents/resourceinstance.h
View File

@ -22,8 +22,9 @@
#include <QQuickItem>
#include <QUrl>
namespace KActivities {
class ResourceInstance;
namespace KActivities
{
class ResourceInstance;
}
class QTimer;

15
src/declarativeimports/platformcomponents/application.cpp
View File

@ -24,13 +24,13 @@
#include <QDebug>
Application::Private::Private(Application * parent)
Application::Private::Private(Application *parent)
: q(parent)
{
connect(
&process, SIGNAL(stateChanged(QProcess::ProcessState)),
this, SLOT(stateChanged(QProcess::ProcessState))
);
);
process.setProcessChannelMode(QProcess::MergedChannels);
}
@ -40,7 +40,7 @@ void Application::Private::stateChanged(QProcess::ProcessState newState)
//q->runningChanged(running);
}
Application::Application(QObject * parent)
Application::Application(QObject *parent)
: QObject(parent), d(this)
{
}
@ -60,7 +60,7 @@ QString Application::application() const
return d->application;
}
void Application::setApplication(const QString & application)
void Application::setApplication(const QString &application)
{
qDebug() << "setting the application to" << application;
@ -87,10 +87,11 @@ void Application::setRunning(bool run)
qDebug() << "running?" << run;
d->running = run;
if (run)
if (run) {
start();
else
} else {
terminate();
}
}
void Application::start()
@ -107,7 +108,7 @@ void Application::start()
qDebug() << "Starting" << d->application;
d->process.start(d->application);
if(!d->process.waitForStarted()) {
if (!d->process.waitForStarted()) {
qWarning() << "Error" << d->process.error() << "while starting" << d->application;
}

9
src/declarativeimports/platformcomponents/application.h
View File

@ -36,7 +36,8 @@
* }
* </code>
*/
class Application: public QObject {
class Application: public QObject
{
Q_OBJECT
/**
@ -51,14 +52,14 @@ class Application: public QObject {
Q_PROPERTY(bool running READ running WRITE setRunning NOTIFY runningChanged);
public:
Application(QObject * parent = Q_NULLPTR);
Application(QObject *parent = Q_NULLPTR);
~Application();
QString application() const;
bool running() const;
public:
void setApplication(const QString & application);
void setApplication(const QString &application);
void setRunning(bool run);
public Q_SLOTS:
@ -66,7 +67,7 @@ public Q_SLOTS:
void terminate();
Q_SIGNALS:
void applicationChanged(const QString & application);
void applicationChanged(const QString &application);
void runningChanged(bool running);
private:

5
src/declarativeimports/platformcomponents/application_p.h
View File

@ -24,7 +24,8 @@
#include <QProcess>
class Application::Private: public QObject {
class Application::Private: public QObject
{
Q_OBJECT
public:
Private(Application *);
@ -37,7 +38,7 @@ private Q_SLOTS:
void stateChanged(QProcess::ProcessState newState);
private:
Application * const q;
Application *const q;
};
#endif /* APPLICATION_P_H */

5
src/declarativeimports/platformcomponents/icondialog.cpp
View File

@ -31,13 +31,14 @@
/**
*
*/
class IconDialog::Private {
class IconDialog::Private
{
public:
utils::SharedSingleton<KIconDialog> dialog;
};
IconDialog::IconDialog(QObject * parent)
IconDialog::IconDialog(QObject *parent)
: QObject(parent)
{
}

5
src/declarativeimports/platformcomponents/icondialog.h
View File

@ -39,11 +39,12 @@
* icon = iconDialog.openDialog()
* </code>
*/
class IconDialog: public QObject {
class IconDialog: public QObject
{
Q_OBJECT
public:
IconDialog(QObject * parent = Q_NULLPTR);
IconDialog(QObject *parent = Q_NULLPTR);
~IconDialog();
Q_INVOKABLE QString openDialog();

10
src/declarativeimports/platformcomponents/platformextensionplugin.cpp
View File

@ -24,25 +24,25 @@
#include "application.h"
#include "icondialog.h"
class PlatformComponentsPlugin: public QQmlExtensionPlugin {
class PlatformComponentsPlugin: public QQmlExtensionPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID "org.kde.plasma.platformcomponents")
public:
PlatformComponentsPlugin(QObject * parent = Q_NULLPTR)
PlatformComponentsPlugin(QObject *parent = Q_NULLPTR)
: QQmlExtensionPlugin(parent)
{
qDebug() << "instantiated plugin object";
}
void registerTypes(const char * uri) Q_DECL_OVERRIDE
{
void registerTypes(const char *uri) Q_DECL_OVERRIDE {
qDebug() << "plugin loaded, registering types " << uri;
Q_ASSERT(QLatin1String(uri) == QLatin1String("org.kde.plasma.platformcomponents"));
qmlRegisterType<Application> (uri, 2, 0, "Application");
qmlRegisterType<IconDialog> (uri, 2, 0, "IconDialog");
qmlRegisterType<IconDialog> (uri, 2, 0, "IconDialog");
}
};

12
src/declarativeimports/platformcomponents/utils/d_ptr.h
View File

@ -22,10 +22,12 @@
#include <memory>
namespace utils {
namespace utils
{
template <typename T>
class d_ptr {
class d_ptr
{
private:
std::unique_ptr<T> d;
@ -33,18 +35,18 @@ public:
d_ptr();
template <typename ...Args>
d_ptr(Args && ...);
d_ptr(Args &&...);
~d_ptr();
T * operator->() const;
T *operator->() const;
};
#define D_PTR \
class Private; \
friend class Private; \
const ::utils::d_ptr<Private> d \
} // namespace utils
#endif

9
src/declarativeimports/platformcomponents/utils/d_ptr_implementation.h
View File

@ -22,7 +22,8 @@
#include <utility>
namespace utils {
namespace utils
{
template <typename T>
d_ptr<T>::d_ptr() : d(new T())
@ -31,8 +32,8 @@ d_ptr<T>::d_ptr() : d(new T())
template <typename T>
template <typename ...Args>
d_ptr<T>::d_ptr(Args && ... args)
: d(new T(std::forward<Args>(args)... ))
d_ptr<T>::d_ptr(Args &&... args)
: d(new T(std::forward<Args>(args)...))
{
}
@ -42,7 +43,7 @@ d_ptr<T>::~d_ptr()
}
template<typename T>
T * d_ptr<T>::operator->() const
T *d_ptr<T>::operator->() const
{
return d.get();
}

6
src/declarativeimports/platformcomponents/utils/sharedsingleton.h
View File

@ -22,10 +22,12 @@
#include <memory>
namespace utils {
namespace utils
{
template <typename Target>
class SharedSingleton {
class SharedSingleton
{
public:
static std::shared_ptr<Target> instance()
{

10
src/kpart/plasmakpart.cpp
View File

@ -88,14 +88,14 @@ PlasmaKPart::~PlasmaKPart()
void PlasmaKPart::setThemeDefaults()
{
KConfigGroup cg(KSharedConfig::openConfig("plasmarc"), "Theme-plasma-kpart" );
KConfigGroup cg(KSharedConfig::openConfig("plasmarc"), "Theme-plasma-kpart");
const QString themeName = cg.readEntry("name", "appdashboard");
Plasma::Theme::defaultTheme()->setUseGlobalSettings(false);
Plasma::Theme::defaultTheme()->setThemeName(themeName);
cg = KConfigGroup(KSharedConfig::openConfig(), "General");
Plasma::Theme::defaultTheme()->setFont(cg.readEntry("desktopFont", QFont("Sans") ));
Plasma::Theme::defaultTheme()->setFont(cg.readEntry("desktopFont", QFont("Sans")));
}
void PlasmaKPart::syncConfig()
@ -119,7 +119,7 @@ void PlasmaKPart::initCorona()
m_view->show();
}
PlasmaKPartCorona* PlasmaKPart::corona() const
PlasmaKPartCorona *PlasmaKPart::corona() const
{
Q_ASSERT(m_corona);
return m_corona;
@ -131,7 +131,7 @@ void PlasmaKPart::createView(Plasma::Containment *containment)
m_view->setContainment(containment);
}
void PlasmaKPart::addApplet(const QString& name, const QVariantList& args, const QRectF& geometry )
void PlasmaKPart::addApplet(const QString &name, const QVariantList &args, const QRectF &geometry)
{
Q_ASSERT(containment());
containment()->createApplet(name, args, geometry);
@ -155,7 +155,7 @@ void PlasmaKPart::setConfigFile(const QString &file)
}
}
Plasma::Containment* PlasmaKPart::containment() const
Plasma::Containment *PlasmaKPart::containment() const
{
Q_ASSERT(corona());
Q_ASSERT(!corona()->containments().isEmpty());

14
src/kpart/plasmakpart.h
View File

@ -30,8 +30,8 @@ class PlasmaKPartCorona;
Q_DECLARE_METATYPE(Plasma::Containment *)
namespace Plasma
{
class Applet;
class PluginLoader;
class Applet;
class PluginLoader;
}
#include <KDE/KParts/Part>
@ -85,14 +85,14 @@ public Q_SLOTS:
private Q_SLOTS:
void initCorona();
void syncConfig();
void createView(Plasma::Containment* containment);
void createView(Plasma::Containment *containment);
void setThemeDefaults();
private:
PlasmaKPartCorona* m_corona;
PlasmaKPartView* m_view;
QHash<QString,Plasma::Applet*>* m_appletList;
QVBoxLayout* m_configLayout;
PlasmaKPartCorona *m_corona;
PlasmaKPartView *m_view;
QHash<QString, Plasma::Applet *> *m_appletList;
QVBoxLayout *m_configLayout;
QString m_configFile;
};

4
src/kpart/plasmakpartcorona.cpp
View File

@ -2,7 +2,7 @@
* Copyright 2008 Aaron Seigo <aseigo@kde.org>
* Copyright 2010 Ryan Rix <ry@n.rix.si>
* Copyright 2010 Siddharth Sharma <siddharth.kde@gmail.com>
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2, or
@ -61,7 +61,7 @@ void PlasmaKPartCorona::evaluateScripts(const QStringList &scripts)
connect(&scriptEngine, SIGNAL(print(QString)), this, SLOT(printScriptMessage(QString)));
QFile file(script);
if (file.open(QIODevice::ReadOnly | QIODevice::Text) ) {
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
QString code = file.readAll();
// qDebug() << "evaluating startup script:" << script;
scriptEngine.evaluateScript(code);

6
src/kpart/plasmakpartcorona.h
View File

@ -26,7 +26,7 @@
namespace Plasma
{
class Applet;
class Applet;
} // namespace Plasma
/**
@ -34,9 +34,9 @@ namespace Plasma
*/
class PlasmaKPartCorona : public Plasma::Corona
{
Q_OBJECT
Q_OBJECT
public:
PlasmaKPartCorona(QObject* parent);
PlasmaKPartCorona(QObject *parent);
protected:
void loadDefaultLayout();

9
src/kpart/plasmakpartview.cpp
View File

@ -26,7 +26,7 @@
#include <Plasma/Applet>
#include <Plasma/Containment>
PlasmaKPartView::PlasmaKPartView(Plasma::Containment* containment, int uid, QWidget* parent)
PlasmaKPartView::PlasmaKPartView(Plasma::Containment *containment, int uid, QWidget *parent)
: Plasma::View(containment, uid, parent),
m_configurationMode(false)
{
@ -41,7 +41,7 @@ PlasmaKPartView::~PlasmaKPartView()
{
}
void PlasmaKPartView::connectContainment(Plasma::Containment* containment)
void PlasmaKPartView::connectContainment(Plasma::Containment *containment)
{
if (!containment) {
return;
@ -51,7 +51,7 @@ void PlasmaKPartView::connectContainment(Plasma::Containment* containment)
connect(containment, SIGNAL(toolBoxVisibilityChanged(bool)), this, SLOT(updateConfigurationMode(bool)));
}
void PlasmaKPartView::setContainment(Plasma::Containment* c)
void PlasmaKPartView::setContainment(Plasma::Containment *c)
{
if (containment()) {
disconnect(containment(), 0, this, 0);
@ -71,7 +71,7 @@ void PlasmaKPartView::resizeEvent(QResizeEvent *event)
void PlasmaKPartView::updateGeometry()
{
Plasma::Containment* c = containment();
Plasma::Containment *c = containment();
if (!c) {
return;
}
@ -85,5 +85,4 @@ void PlasmaKPartView::updateGeometry()
}
}
#include "plasmakpartview.moc"

6
src/kpart/plasmakpartview.h
View File

@ -27,12 +27,12 @@
namespace Plasma
{
class Containment;
class Containment;
} // namespace Plasma
class PlasmaKPartView : public Plasma::View
{
Q_OBJECT
Q_OBJECT
public:
typedef Plasma::Types::ImmutabilityType ImmutabilityType;
PlasmaKPartView(Plasma::Containment *containment, int uid, QWidget *parent = 0);
@ -55,7 +55,7 @@ Q_SIGNALS:
void geometryChanged();
protected:
void resizeEvent( QResizeEvent* event );
void resizeEvent(QResizeEvent *event);
private:
bool m_configurationMode;

185
src/kpart/scripting/backportglobal.h
View File

@ -28,7 +28,7 @@
** functionality provided by Qt Designer and its related libraries.
**
** Trolltech reserves all rights not expressly granted herein.
**
**
** Trolltech ASA (c) 2007
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
@ -45,21 +45,19 @@
Class* self = qscriptvalue_cast<Class*>(ctx->thisObject()); \
if (!self) { \
return ctx->throwError(QScriptContext::TypeError, \
QString::fromLatin1("%0.prototype.%1: this object is not a %0") \
.arg(#Class).arg(#__fn__)); \
QString::fromLatin1("%0.prototype.%1: this object is not a %0") \
.arg(#Class).arg(#__fn__)); \
}
#define DECLARE_SELF2(Class, __fn__, __ret__) \
Class* self = qscriptvalue_cast<Class*>(thisObject()); \
if (!self) { \
context()->throwError(QScriptContext::TypeError, \
QString::fromLatin1("%0.prototype.%1: this object is not a %0") \
.arg(#Class).arg(#__fn__)); \
QString::fromLatin1("%0.prototype.%1: this object is not a %0") \
.arg(#Class).arg(#__fn__)); \
return __ret__; \
}
#define ADD_METHOD(__p__, __f__) \
__p__.setProperty(#__f__, __p__.engine()->newFunction(__f__))
@ -67,53 +65,49 @@
ADD_METHOD(__p__, __get__)
#define ADD_GET_SET_METHODS(__p__, __get__, __set__) \
do { \
ADD_METHOD(__p__, __get__); \
ADD_METHOD(__p__, __set__); \
} while (0);
do { \
ADD_METHOD(__p__, __get__); \
ADD_METHOD(__p__, __set__); \
} while (0);
#define ADD_CTOR_FUNCTION(__c__, __f__) ADD_METHOD(__c__, __f__)
#define ADD_ENUM_VALUE(__c__, __ns__, __v__) \
__c__.setProperty(#__v__, QScriptValue(__c__.engine(), __ns__::__v__))
#define BEGIN_DECLARE_METHOD(Class, __mtd__) \
static QScriptValue __mtd__(QScriptContext *ctx, QScriptEngine *eng) \
{ \
DECLARE_SELF(Class, __mtd__);
static QScriptValue __mtd__(QScriptContext *ctx, QScriptEngine *eng) \
{ \
DECLARE_SELF(Class, __mtd__);
#define END_DECLARE_METHOD \
}
}
#define DECLARE_GET_METHOD(Class, __get__) \
BEGIN_DECLARE_METHOD(Class, __get__) { \
return qScriptValueFromValue(eng, self->__get__()); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __get__) { \
return qScriptValueFromValue(eng, self->__get__()); \
} END_DECLARE_METHOD
#define DECLARE_SET_METHOD(Class, T, __set__) \
BEGIN_DECLARE_METHOD(Class, __set__) { \
self->__set__(qscriptvalue_cast<T>(ctx->argument(0))); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __set__) { \
self->__set__(qscriptvalue_cast<T>(ctx->argument(0))); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
#define DECLARE_GET_SET_METHODS(Class, T, __get__, __set__) \
DECLARE_GET_METHOD(Class, /*T,*/ __get__) \
DECLARE_SET_METHOD(Class, T, __set__)
DECLARE_GET_METHOD(Class, /*T,*/ __get__) \
DECLARE_SET_METHOD(Class, T, __set__)
#define DECLARE_SIMPLE_GET_METHOD(Class, __get__) \
BEGIN_DECLARE_METHOD(Class, __get__) { \
return QScriptValue(eng, self->__get__()); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __get__) { \
return QScriptValue(eng, self->__get__()); \
} END_DECLARE_METHOD
#define DECLARE_SIMPLE_SET_METHOD(Class, ToType, __set__) \
BEGIN_DECLARE_METHOD(Class, __set__) { \
self->__set__(ctx->argument(0).ToType()); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __set__) { \
self->__set__(ctx->argument(0).ToType()); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
#define DECLARE_BOOLEAN_GET_METHOD(Class, __set__) \
DECLARE_SIMPLE_GET_METHOD(Class, __set__)
@ -136,9 +130,9 @@ BEGIN_DECLARE_METHOD(Class, __set__) { \
DECLARE_SIMPLE_SET_METHOD(Class, toString, __set__)
#define DECLARE_QOBJECT_GET_METHOD(Class, __get__) \
BEGIN_DECLARE_METHOD(Class, __get__) { \
return eng->newQObject(self->__get__()); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __get__) { \
return eng->newQObject(self->__get__()); \
} END_DECLARE_METHOD
#define DECLARE_QOBJECT_SET_METHOD(Class, __set__) \
DECLARE_SIMPLE_SET_METHOD(Class, toQObject, __set__)
@ -162,42 +156,40 @@ BEGIN_DECLARE_METHOD(Class, __get__) { \
DECLARE_QOBJECT_GET_METHOD(Class, __get__) \
DECLARE_QOBJECT_SET_METHOD(Class, __set__)
#define DECLARE_VOID_METHOD(Class, __fun__) \
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
#define DECLARE_VOID_NUMBER_METHOD(Class, __fun__) \
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(ctx->argument(0).toNumber()); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(ctx->argument(0).toNumber()); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
#define DECLARE_VOID_NUMBER_NUMBER_METHOD(Class, __fun__) \
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(ctx->argument(0).toNumber(), ctx->argument(1).toNumber()); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(ctx->argument(0).toNumber(), ctx->argument(1).toNumber()); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
#define DECLARE_VOID_QUAD_NUMBER_METHOD(Class, __fun__) \
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(ctx->argument(0).toNumber(), ctx->argument(1).toNumber(), ctx->argument(2).toNumber(), ctx->argument(3).toNumber()); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(ctx->argument(0).toNumber(), ctx->argument(1).toNumber(), ctx->argument(2).toNumber(), ctx->argument(3).toNumber()); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
#define DECLARE_VOID_1ARG_METHOD(Class, ArgType, __fun__) \
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(qscriptvalue_cast<ArgType>(ctx->argument(0))); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __fun__) { \
self->__fun__(qscriptvalue_cast<ArgType>(ctx->argument(0))); \
return eng->undefinedValue(); \
} END_DECLARE_METHOD
#define DECLARE_BOOLEAN_1ARG_METHOD(Class, ArgType, __fun__) \
BEGIN_DECLARE_METHOD(Class, __fun__) { \
return QScriptValue(eng, self->__fun__(qscriptvalue_cast<ArgType>(ctx->argument(0)))); \
} END_DECLARE_METHOD
BEGIN_DECLARE_METHOD(Class, __fun__) { \
return QScriptValue(eng, self->__fun__(qscriptvalue_cast<ArgType>(ctx->argument(0)))); \
} END_DECLARE_METHOD
#define DECLARE_POINTER_METATYPE(T) \
Q_DECLARE_METATYPE(T*) \
@ -214,21 +206,22 @@ template <typename T>
class Pointer : public QSharedData
{
public:
typedef T* pointer_type;
typedef T *pointer_type;
typedef QExplicitlySharedDataPointer<Pointer<T> > wrapped_pointer_type;
~Pointer()
{
if (!(m_flags & UserOwnership))
if (!(m_flags & UserOwnership)) {
delete m_value;
}
}
operator T*()
operator T *()
{
return m_value;
}
operator const T*() const
operator const T *() const
{
return m_value;
}
@ -238,25 +231,26 @@ public:
return wrapped_pointer_type(new Pointer(value, flags));
}
static QScriptValue toScriptValue(QScriptEngine *engine, T* const &source)
static QScriptValue toScriptValue(QScriptEngine *engine, T *const &source)
{
if (!source)
if (!source) {
return engine->nullValue();
}
return engine->newVariant(qVariantFromValue(source));
}
static void fromScriptValue(const QScriptValue &value, T* &target)
static void fromScriptValue(const QScriptValue &value, T *&target)
{
if (value.isVariant()) {
QVariant var = value.toVariant();
if (qVariantCanConvert<T*>(var)) {
target = qvariant_cast<T*>(var);
if (qVariantCanConvert<T *>(var)) {
target = qvariant_cast<T *>(var);
} else if (qVariantCanConvert<wrapped_pointer_type>(var)) {
target = qvariant_cast<wrapped_pointer_type>(var)->operator T*();
target = qvariant_cast<wrapped_pointer_type>(var)->operator T * ();
} else {
// look in prototype chain
target = 0;
int type = qMetaTypeId<T*>();
int type = qMetaTypeId<T *>();
int pointerType = qMetaTypeId<wrapped_pointer_type>();
QScriptValue proto = value.prototype();
while (proto.isObject() && proto.isVariant()) {
@ -264,10 +258,10 @@ public:
if ((type == protoType) || (pointerType == protoType)) {
QByteArray name = QMetaType::typeName(var.userType());
if (name.startsWith("QScript::Pointer<")) {
target = (*reinterpret_cast<wrapped_pointer_type*>(var.data()))->operator T*();
target = (*reinterpret_cast<wrapped_pointer_type *>(var.data()))->operator T * ();
break;
} else {
target = static_cast<T*>(var.data());
target = static_cast<T *>(var.data());
break;
}
}
@ -276,28 +270,34 @@ public:
}
} else if (value.isQObject()) {
QObject *qobj = value.toQObject();
QByteArray typeName = QMetaType::typeName(qMetaTypeId<T*>());
target = reinterpret_cast<T*>(qobj->qt_metacast(typeName.left(typeName.size()-1)));
QByteArray typeName = QMetaType::typeName(qMetaTypeId<T *>());
target = reinterpret_cast<T *>(qobj->qt_metacast(typeName.left(typeName.size() - 1)));
} else {
target = 0;
}
}
uint flags() const
{ return m_flags; }
{
return m_flags;
}
void setFlags(uint flags)
{ m_flags = flags; }
{
m_flags = flags;
}
void unsetFlags(uint flags)
{ m_flags &= ~flags; }
{
m_flags &= ~flags;
}
protected:
Pointer(T* value, uint flags)
Pointer(T *value, uint flags)
: m_flags(flags), m_value(value)
{}
private:
uint m_flags;
T* m_value;
T *m_value;
};
template <typename T>
@ -307,9 +307,9 @@ int registerPointerMetaType(
T * /* dummy */ = 0
)
{
QScriptValue (*mf)(QScriptEngine *, T* const &) = Pointer<T>::toScriptValue;
void (*df)(const QScriptValue &, T* &) = Pointer<T>::fromScriptValue;
const int id = qMetaTypeId<T*>();
QScriptValue(*mf)(QScriptEngine *, T * const &) = Pointer<T>::toScriptValue;
void (*df)(const QScriptValue &, T *&) = Pointer<T>::fromScriptValue;
const int id = qMetaTypeId<T *>();
qScriptRegisterMetaType_helper(
eng, id, reinterpret_cast<QScriptEngine::MarshalFunction>(mf),
reinterpret_cast<QScriptEngine::DemarshalFunction>(df),
@ -323,8 +323,9 @@ inline void maybeReleaseOwnership(const QScriptValue &value)
if (value.isVariant()) {
QVariant var = value.toVariant();
QByteArray name = QMetaType::typeName(var.userType());
if (name.startsWith("QScript::Pointer<"))
(*reinterpret_cast<Pointer<void*>::wrapped_pointer_type *>(var.data()))->setFlags(UserOwnership);
if (name.startsWith("QScript::Pointer<")) {
(*reinterpret_cast<Pointer<void *>::wrapped_pointer_type *>(var.data()))->setFlags(UserOwnership);
}
}
}
@ -333,8 +334,9 @@ inline void maybeTakeOwnership(const QScriptValue &value)
if (value.isVariant()) {
QVariant var = value.toVariant();
QByteArray name = QMetaType::typeName(var.userType());
if (name.startsWith("QScript::Pointer<"))
(*reinterpret_cast<Pointer<void*>::wrapped_pointer_type *>(var.data()))->unsetFlags(UserOwnership);
if (name.startsWith("QScript::Pointer<")) {
(*reinterpret_cast<Pointer<void *>::wrapped_pointer_type *>(var.data()))->unsetFlags(UserOwnership);
}
}
}
@ -348,7 +350,8 @@ inline QScriptValue wrapPointer(QScriptEngine *eng, T *ptr, uint flags = 0)
#ifdef QGRAPHICSITEM_H
namespace QScript {
namespace QScript
{
template <class T>
inline QScriptValue wrapGVPointer(QScriptEngine *eng, T *item)

8
src/kpart/scripting/rect.cpp
View File

@ -19,13 +19,12 @@
#include <QtCore/QRectF>
#include "backportglobal.h"
Q_DECLARE_METATYPE(QRectF*)
Q_DECLARE_METATYPE(QRectF *)
Q_DECLARE_METATYPE(QRectF)
static QScriptValue ctor(QScriptContext *ctx, QScriptEngine *eng)
{
if (ctx->argumentCount() == 4)
{
if (ctx->argumentCount() == 4) {
qreal x = ctx->argument(0).toNumber();
qreal y = ctx->argument(1).toNumber();
qreal width = ctx->argument(2).toNumber();
@ -158,7 +157,6 @@ static QScriptValue moveRight(QScriptContext *ctx, QScriptEngine *)
return QScriptValue();
}
static QScriptValue moveTo(QScriptContext *ctx, QScriptEngine *)
{
DECLARE_SELF(QRectF, moveTo);
@ -321,7 +319,7 @@ QScriptValue constructQRectFClass(QScriptEngine *eng)
proto.setProperty("y", eng->newFunction(y), getter | setter);
eng->setDefaultPrototype(qMetaTypeId<QRectF>(), proto);
eng->setDefaultPrototype(qMetaTypeId<QRectF*>(), proto);
eng->setDefaultPrototype(qMetaTypeId<QRectF *>(), proto);
return eng->newFunction(ctor, proto);
}

36
src/kpart/scripting/scriptengine.cpp
View File

@ -134,7 +134,7 @@ QScriptValue ScriptEngine::loadTemplate(QScriptContext *context, QScriptEngine *
}
const QString constraint = QString("[X-Plasma-Shell] == '%1' and [X-KDE-PluginInfo-Name] == '%2'")
.arg(KGlobal::mainComponent().componentName(),layout);
.arg(KGlobal::mainComponent().componentName(), layout);
KService::List offers = KServiceTypeTrader::self()->query("Plasma/LayoutTemplate", constraint);
if (offers.isEmpty()) {
@ -145,8 +145,8 @@ QScriptValue ScriptEngine::loadTemplate(QScriptContext *context, QScriptEngine *
Plasma::PackageStructure::Ptr structure(new LayoutTemplatePackageStructure);
KPluginInfo info(offers.first());
const QString path = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
structure->defaultPackageRoot() + '/' + info.pluginName() + '/',
QStandardPaths::LocateDirectory);
structure->defaultPackageRoot() + '/' + info.pluginName() + '/',
QStandardPaths::LocateDirectory);
if (path.isEmpty()) {
// qDebug() << "script path is empty";
return false;
@ -189,11 +189,11 @@ void ScriptEngine::setupEngine()
v.setProperty("widgets", newFunction(ScriptEngine::widgets));
v.setProperty("addWidget", newFunction(ScriptEngine::addWidget));
v.setProperty("applicationVersion", KGlobal::mainComponent().aboutData()->version(),
QScriptValue::PropertyGetter | QScriptValue::ReadOnly | QScriptValue::Undeletable);
QScriptValue::PropertyGetter | QScriptValue::ReadOnly | QScriptValue::Undeletable);
v.setProperty("scriptingVersion", newVariant(PLASMA_KPART_SCRIPTING_VERSION),
QScriptValue::PropertyGetter | QScriptValue::ReadOnly | QScriptValue::Undeletable);
QScriptValue::PropertyGetter | QScriptValue::ReadOnly | QScriptValue::Undeletable);
v.setProperty("platformVersion", KDE::versionString(),
QScriptValue::PropertyGetter | QScriptValue::ReadOnly | QScriptValue::Undeletable);
QScriptValue::PropertyGetter | QScriptValue::ReadOnly | QScriptValue::Undeletable);
setGlobalObject(v);
}
@ -205,9 +205,9 @@ bool ScriptEngine::evaluateScript(const QString &script, const QString &path)
if (hasUncaughtException()) {
//qDebug() << "catch the exception!";
QString error = QString("Error: %1 at line %2\n\nBacktrace:\n%3").arg(
uncaughtException().toString(),
QString::number(uncaughtExceptionLineNumber()),
uncaughtExceptionBacktrace().join("\n "));
uncaughtException().toString(),
QString::number(uncaughtExceptionLineNumber()),
uncaughtExceptionBacktrace().join("\n "));
emit printError(error);
return false;
}
@ -334,24 +334,24 @@ QScriptValue ScriptEngine::addWidget(QScriptContext *context, QScriptEngine *eng
if (v.isString()) {
// FIXME: Using QMetaObject::invokeMethod until the newspaper's API is exported... Fuuuu
// applet = env->m_containment->addApplet(v.toString(), row, column);
QMetaObject::invokeMethod(env->m_containment, "addApplet",
Qt::DirectConnection,
Q_RETURN_ARG(Plasma::Applet*, applet),
Q_ARG(QString, v.toString()),
QMetaObject::invokeMethod(env->m_containment, "addApplet",
Qt::DirectConnection,
Q_RETURN_ARG(Plasma::Applet *, applet),
Q_ARG(QString, v.toString()),
Q_ARG(int, row), Q_ARG(int, column));
if (applet) {
ScriptEngine *env = ScriptEngine::envFor(engine);
return env->wrap(applet);
}
} else if (Widget *widget = qobject_cast<Widget*>(v.toQObject())) {
} else if (Widget *widget = qobject_cast<Widget *>(v.toQObject())) {
applet = widget->applet();
// FIXME: Using QMetaObject::invokeMethod until the newspaper's API is exported... Fuuuu
// env->m_containment->addApplet(applet, row, column);
QMetaObject::invokeMethod(env->m_containment, "addApplet",
Qt::DirectConnection,
Q_RETURN_ARG(Plasma::Applet*, applet),
Q_ARG(QString, v.toString()),
QMetaObject::invokeMethod(env->m_containment, "addApplet",
Qt::DirectConnection,
Q_RETURN_ARG(Plasma::Applet *, applet),
Q_ARG(QString, v.toString()),
Q_ARG(int, row), Q_ARG(int, column));
return v;
}

6
src/kpart/scripting/scriptengine.h
View File

@ -25,9 +25,9 @@
namespace Plasma
{
class Applet;
class Containment;
class Corona;
class Applet;
class Containment;
class Corona;
} // namespace Plasma
namespace PlasmaKPartScripting

6
src/kpart/scripting/widget.h
View File

@ -26,7 +26,7 @@
namespace Plasma
{
class Applet;
class Applet;
} // namespace Plasma
namespace PlasmaKPartScripting
@ -71,7 +71,7 @@ public:
QString type() const;
/**
FIXME: what should the index(es?) be given that we're in the newspaper containment
FIXME: what should the index(es?) be given that we're in the newspaper containment
int index() const;
void setIndex(int index);
*/
@ -89,7 +89,7 @@ public Q_SLOTS:
private:
class Private;
Private * const d;
Private *const d;
};
}

36
src/plasma/applet.cpp
View File

@ -56,7 +56,6 @@
#include "private/associatedapplicationmanager_p.h"
#include "private/containment_p.h"
namespace Plasma
{
@ -168,12 +167,12 @@ void Applet::restore(KConfigGroup &group)
if (!shortcutText.isEmpty()) {
setGlobalShortcut(QKeySequence(shortcutText));
/*
#ifndef NDEBUG
#ifndef NDEBUG
// qDebug() << "got global shortcut for" << name() << "of" << QKeySequence(shortcutText);
#endif
#ifndef NDEBUG
#endif
#ifndef NDEBUG
// qDebug() << "set to" << d->activationAction->objectName()
#endif
#endif
<< d->activationAction->globalShortcut().primary();
*/
}
@ -181,10 +180,10 @@ void Applet::restore(KConfigGroup &group)
// local shortcut, if any
//TODO: implement; the shortcut will need to be registered with the containment
/*
#include "accessmanager.h"
#include "private/plasmoidservice_p.h"
#include "authorizationmanager.h"
#include "authorizationmanager.h"
#include "accessmanager.h"
#include "private/plasmoidservice_p.h"
#include "authorizationmanager.h"
#include "authorizationmanager.h"
shortcutText = shortcutConfig.readEntryUntranslated("local", QString());
if (!shortcutText.isEmpty()) {
//TODO: implement; the shortcut
@ -268,7 +267,7 @@ bool Applet::destroyed() const
ConfigLoader *Applet::configScheme() const
{
if (!d->configLoader) {
const QString xmlPath = d->package? d->package->filePath("mainconfigxml") : QString();
const QString xmlPath = d->package ? d->package->filePath("mainconfigxml") : QString();
KConfigGroup cfg = config();
if (xmlPath.isEmpty()) {
d->configLoader = new ConfigLoader(&cfg, 0);
@ -352,7 +351,7 @@ Types::Types::ImmutabilityType Applet::immutability() const
Types::ImmutabilityType upperImmutability = Types::Mutable;
if (isContainment()) {
Corona *cor = static_cast<Containment*>(const_cast<Applet*>(this))->corona();
Corona *cor = static_cast<Containment *>(const_cast<Applet *>(this))->corona();
if (cor) {
upperImmutability = cor->immutability();
}
@ -506,7 +505,7 @@ void Applet::flushPendingConstraintsEvents()
}
// now take care of constraints in special subclass: Contaiment
Containment* containment = qobject_cast<Plasma::Containment*>(this);
Containment *containment = qobject_cast<Plasma::Containment *>(this);
if (containment) {
containment->d->containmentConstraintsEvent(c);
}
@ -534,10 +533,10 @@ void Applet::flushPendingConstraintsEvents()
}
}
QList<QAction*> Applet::contextualActions()
QList<QAction *> Applet::contextualActions()
{
//qDebug() << "empty context actions";
return d->script ? d->script->contextualActions() : QList<QAction*>();
return d->script ? d->script->contextualActions() : QList<QAction *>();
}
KActionCollection *Applet::actions() const
@ -561,7 +560,7 @@ Types::FormFactor Applet::formFactor() const
Containment *Applet::containment() const
{
Containment *c = qobject_cast<Containment*>(const_cast<Applet*>(this));
Containment *c = qobject_cast<Containment *>(const_cast<Applet *>(this));
if (c && c->isContainment()) {
return c;
} else {
@ -571,7 +570,7 @@ Containment *Applet::containment() const
QObject *parent = this->parent();
while (parent) {
Containment *possibleC = qobject_cast<Containment*>(parent);
Containment *possibleC = qobject_cast<Containment *>(parent);
if (possibleC && possibleC->isContainment()) {
c = possibleC;
@ -612,7 +611,6 @@ QKeySequence Applet::globalShortcut() const
}
}
return QKeySequence();
}
@ -731,7 +729,7 @@ void Applet::timerEvent(QTimerEvent *event)
// Don't flushPendingConstraints if we're just starting up
// flushPendingConstraints will be called by Corona
if(!(d->pendingConstraints & Plasma::Types::StartupCompletedConstraint)) {
if (!(d->pendingConstraints & Plasma::Types::StartupCompletedConstraint)) {
flushPendingConstraintsEvents();
}
} else if (d->modificationsTimer && event->timerId() == d->modificationsTimer->timerId()) {
@ -753,7 +751,7 @@ bool Applet::isContainment() const
return true;
}
//normal "acting as a containment" condition
return qobject_cast<const Containment*>(this) && qobject_cast<Corona *>(parent());
return qobject_cast<const Containment *>(this) && qobject_cast<Corona *>(parent());
}
} // Plasma namespace

906
src/plasma/applet.h
View File

File diff suppressed because it is too large Load Diff

34
src/plasma/configloader.cpp
View File

@ -155,7 +155,7 @@ QString ConfigLoaderHandler::defaultValue() const
}
bool ConfigLoaderHandler::endElement(const QString &namespaceURI,
const QString &localName, const QString &qName)
const QString &localName, const QString &qName)
{
Q_UNUSED(namespaceURI)
Q_UNUSED(qName)
@ -247,7 +247,7 @@ void ConfigLoaderHandler::addItem()
item = m_config->addItemFont(m_name, *d->newFont(), QFont(m_default), m_key);
} else if (m_type == "int") {
KConfigSkeleton::ItemInt *intItem = m_config->addItemInt(m_name, *d->newInt(),
m_default.toInt(), m_key);
m_default.toInt(), m_key);
if (m_haveMin) {
intItem->setMinValue(m_min);
@ -313,11 +313,11 @@ void ConfigLoaderHandler::addItem()
longlongItem->setMaxValue(m_max);
}
item = longlongItem;
/* No addItemPathList in KConfigSkeleton ?
} else if (m_type == "PathList") {
//FIXME: the split() is naive and will break on lists with ,'s in them
item = m_config->addItemPathList(m_name, *d->newStringList(), m_default.split(","), m_key);
*/
/* No addItemPathList in KConfigSkeleton ?
} else if (m_type == "PathList") {
//FIXME: the split() is naive and will break on lists with ,'s in them
item = m_config->addItemPathList(m_name, *d->newStringList(), m_default.split(","), m_key);
*/
} else if (m_type == "point") {
QPoint defaultPoint;
QStringList tmpList = m_default.split(',');
@ -352,15 +352,15 @@ void ConfigLoaderHandler::addItem()
ulonglongItem->setMaxValue(m_max);
}
item = ulonglongItem;
/* No addItemUrlList in KConfigSkeleton ?
} else if (m_type == "urllist") {
//FIXME: the split() is naive and will break on lists with ,'s in them
QStringList tmpList = m_default.split(",");
QList<QUrl> defaultList;
foreach (const QString& tmp, tmpList) {
defaultList.append(QUrl(tmp));
}
item = m_config->addItemUrlList(m_name, *d->newUrlList(), defaultList, m_key);*/
/* No addItemUrlList in KConfigSkeleton ?
} else if (m_type == "urllist") {
//FIXME: the split() is naive and will break on lists with ,'s in them
QStringList tmpList = m_default.split(",");
QList<QUrl> defaultList;
foreach (const QString& tmp, tmpList) {
defaultList.append(QUrl(tmp));
}
item = m_config->addItemUrlList(m_name, *d->newUrlList(), defaultList, m_key);*/
}
if (item) {
@ -456,7 +456,7 @@ bool ConfigLoader::usrWriteConfig()
{
if (d->saveDefaults) {
KConfigSkeletonItem::List itemList = items();
for(int i = 0; i < itemList.size(); i++) {
for (int i = 0; i < itemList.size(); i++) {
KConfigGroup cg(config(), itemList.at(i)->group());
cg.writeEntry(itemList.at(i)->key(), "");
}

2
src/plasma/configloader.h
View File

@ -146,7 +146,7 @@ protected:
private:
friend class Service;
ConfigLoaderPrivate * const d;
ConfigLoaderPrivate *const d;
};
} // Plasma namespace

Some files were not shown because too many files have changed in this diff Show More