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

move the core, graphicslayouts and graphicswidgets imports in runtime

Browse Source 
svn path=/trunk/KDE/kdebase/runtime/; revision=1185277
This commit is contained in:
Marco Martin 2010-10-12 19:51:57 +00:00
parent 017f67bc86
commit 2a256d1e74
28 changed files with 2177 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
declarativeimports/core/CMakeLists.txt Normal file
View File

@ -0,0 +1,27 @@
project(corebindings)
include(KDE4Defaults)
set(corebindings_SRCS
corebindingsplugin.cpp
dataengineconsumer.cpp
theme.cpp
datasource.cpp
svgitem.cpp
framesvgitem.cpp
)
INCLUDE_DIRECTORIES(
${CMAKE_SOURCE_DIR}
${CMAKE_BINARY_DIR}
${KDE4_INCLUDES}
)
qt4_automoc(${corebindings_SRCS})
add_library(corebindingsplugin SHARED ${corebindings_SRCS})
target_link_libraries(corebindingsplugin ${KDE4_PLASMA_LIBS} ${QT_QTSCRIPT_LIBRARY} ${QT_QTDECLARATIVE_LIBRARY})
install(TARGETS corebindingsplugin DESTINATION ${QT_IMPORTS_DIR}/org/kde/plasma/core)
install(FILES qmldir DESTINATION ${QT_IMPORTS_DIR}/org/kde/plasma/core)

53
declarativeimports/core/corebindingsplugin.cpp Normal file
View File

@ -0,0 +1,53 @@
/*
* Copyright 2009 by Alan Alpert <alan.alpert@nokia.com>
* Copyright 2010 by Ménard Alexis <menard@kde.org>
* Copyright 2010 by Marco Martin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "corebindingsplugin.h"
#include <QtDeclarative/qdeclarative.h>
#include <Plasma/FrameSvg>
#include <Plasma/Svg>
#include "datasource_p.h"
#include "framesvgitem_p.h"
#include "svgitem_p.h"
#include "theme_p.h"
void CoreBindingsPlugin::registerTypes(const char *uri)
{
Q_ASSERT(uri == QLatin1String("org.kde.plasma.core"));
qmlRegisterType<Plasma::Svg>(uri, 0, 1, "Svg");
qmlRegisterType<Plasma::FrameSvg>(uri, 0, 1, "FrameSvg");
qmlRegisterType<Plasma::SvgItem>(uri, 0, 1, "SvgItem");
qmlRegisterType<Plasma::FrameSvgItem>(uri, 0, 1, "FrameSvgItem");
qmlRegisterType<ThemeProxy>(uri, 0, 1, "Theme");
qmlRegisterType<Plasma::DataSource>(uri, 0, 1, "DataSource");
qmlRegisterInterface<Plasma::Service>("Service");
qRegisterMetaType<Plasma::Service*>("Service");
}
#include "corebindingsplugin.moc"

41
declarativeimports/core/corebindingsplugin.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright 2009 by Alan Alpert <alan.alpert@nokia.com>
* Copyright 2010 by Ménard Alexis <menard@kde.org>
* Copyright 2010 by Marco Martin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef COREBINDINGSPLUGIN_H
#define COREBINDINGSPLUGIN_H
#include <QDeclarativeExtensionPlugin>
#include <Plasma/Service>
Q_DECLARE_METATYPE(Plasma::Service*)
class CoreBindingsPlugin : public QDeclarativeExtensionPlugin
{
Q_OBJECT
public:
void registerTypes(const char *uri);
};
Q_EXPORT_PLUGIN2(corebindingsplugin, CoreBindingsPlugin);
#endif

117
declarativeimports/core/dataengineconsumer.cpp Normal file
View File

@ -0,0 +1,117 @@
/*
* Copyright 2005 by Aaron Seigo <aseigo@kde.org>
* Copyright 2007 by Riccardo Iaconelli <riccardo@kde.org>
* Copyright 2008 by Ménard Alexis <darktears31@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "dataengineconsumer_p.h"
#include <QtCore/QSet>
#include <kdebug.h>
#include <plasma/dataenginemanager.h>
#include <plasma/servicejob.h>
namespace Plasma
{
ServiceMonitor::ServiceMonitor(DataEngineConsumer *consumer)
: m_consumer(consumer)
{
}
ServiceMonitor::~ServiceMonitor()
{
}
void ServiceMonitor::slotJobFinished(Plasma::ServiceJob *job)
{
kDebug() << "engine ready!";
QString engineName = job->parameters()["EngineName"].toString();
QString location = job->destination();
QPair<QString, QString> pair(location, engineName);
kDebug() << "pair = " << pair;
if (!m_consumer->m_remoteEngines.contains(pair)) {
kDebug() << "engine does not exist yet!";
} else {
KUrl engineLocation(location);
engineLocation.setFileName(job->result().toString());
kDebug() << "setting location : "
<< engineLocation.prettyUrl();
// m_consumer->m_remoteEngines[pair]->setLocation(engineLocation);
}
}
void ServiceMonitor::slotServiceReady(Plasma::Service *plasmoidService)
{
kDebug() << "service ready!";
if (!m_consumer->m_engineNameForService.contains(plasmoidService)) {
kDebug() << "no engine name for service!";
kDebug() << "amount of services in map: " << m_consumer->m_engineNameForService.count();
} else {
kDebug() << "value = " << m_consumer->m_engineNameForService.value(plasmoidService);
}
kDebug() << "requesting dataengine!";
KConfigGroup op = plasmoidService->operationDescription("DataEngine");
op.writeEntry("EngineName", m_consumer->m_engineNameForService.value(plasmoidService));
plasmoidService->startOperationCall(op);
connect(plasmoidService, SIGNAL(finished(Plasma::ServiceJob*)),
this, SLOT(slotJobFinished(Plasma::ServiceJob*)));
}
DataEngineConsumer::DataEngineConsumer()
: m_monitor(new ServiceMonitor(this))
{
}
DataEngineConsumer::~DataEngineConsumer()
{
foreach (const QString &engine, m_loadedEngines) {
DataEngineManager::self()->unloadEngine(engine);
}
delete m_monitor;
}
DataEngine *DataEngineConsumer::dataEngine(const QString &name)
{
if (m_loadedEngines.contains(name)) {
return DataEngineManager::self()->engine(name);
}
DataEngine *engine = DataEngineManager::self()->loadEngine(name);
if (engine->isValid()) {
m_loadedEngines.insert(name);
}
return engine;
}
DataEngine *DataEngineConsumer::remoteDataEngine(const KUrl &location, const QString &name)
{
return 0;
}
} // namespace Plasma
#include "dataengineconsumer_p.moc"

74
declarativeimports/core/dataengineconsumer_p.h Normal file
View File

@ -0,0 +1,74 @@
/*
* Copyright 2005 by Aaron Seigo <aseigo@kde.org>
* Copyright 2007 by Riccardo Iaconelli <riccardo@kde.org>
* Copyright 2008 by Ménard Alexis <darktears31@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef PLASMA_DATAENGINECONSUMER_H
#define PLASMA_DATAENGINECONSUMER_H
#include <QtCore/QSet>
#include <kdebug.h>
#include "plasma/dataenginemanager.h"
#include <plasma/servicejob.h>
namespace Plasma
{
class DataEngineConsumer;
class RemoteDataEngine;
class ServiceMonitor : public QObject
{
Q_OBJECT
public:
ServiceMonitor(DataEngineConsumer *consumer);
~ServiceMonitor();
public Q_SLOTS:
void slotJobFinished(Plasma::ServiceJob *job);
void slotServiceReady(Plasma::Service *service);
private:
DataEngineConsumer *m_consumer;
};
class DataEngineConsumer
{
public:
DataEngineConsumer();
~DataEngineConsumer();
DataEngine *dataEngine(const QString &name);
DataEngine *remoteDataEngine(const KUrl &location, const QString &name);
private:
QSet<QString> m_loadedEngines;
QMap<QPair<QString, QString>, RemoteDataEngine*> m_remoteEngines;
QMap<Service*, QString> m_engineNameForService;
ServiceMonitor *m_monitor;
friend class ServiceMonitor;
};
} // namespace Plasma
#endif

127
declarativeimports/core/datasource.cpp Normal file
View File

@ -0,0 +1,127 @@
/*
* Copyright 2009 by Alan Alpert <alan.alpert@nokia.com>
* Copyright 2010 by Ménard Alexis <menard@kde.org>
* Copyright 2010 by Marco MArtin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "datasource_p.h"
#include "qdeclarativeengine.h"
#include "qdeclarativecontext.h"
#include <QDebug>
#include <QTimer>
#include <Plasma/Applet>
namespace Plasma
{
DataSource::DataSource(QObject* parent)
: QObject(parent),
m_interval(1000),
m_dataEngine(0)
{
setObjectName("DataSource");
m_data = new QDeclarativePropertyMap(this);
connect(this, SIGNAL(engineChanged()),
this, SLOT(setupData()));
connect(this, SIGNAL(sourceChanged()),
this, SLOT(setupData()));
connect(this, SIGNAL(intervalChanged()),
this, SLOT(setupData()));
}
void DataSource::setSource(const QString &s)
{
if (s == m_source) {
return;
}
m_source = s;
emit sourceChanged();
}
void DataSource::setupData()
{
if (/*m_source.isEmpty() ||*/ m_engine.isEmpty()) {
return;
}
if (m_dataEngine) {
m_dataEngine->disconnectSource(m_connectedSource, this);
m_dataEngine = 0;
m_keys.clear();
emit keysChanged();
}
Plasma::DataEngine* de = dataEngine(m_engine);
if (!de) {
kWarning() << "DataEngine not found";
return;
}
de->connectSource(m_source, this, m_interval);
m_dataEngine = de;
m_connectedSource = m_source;
connect(de, SIGNAL(sourceAdded(constQString&)), this, SIGNAL(sourcesChanged()));
connect(de, SIGNAL(sourceRemoved(constQString&)), this, SIGNAL(sourcesChanged()));
}
void DataSource::dataUpdated(const QString &sourceName, const Plasma::DataEngine::Data &data)
{
Q_UNUSED(sourceName);//Only one source
QStringList newKeys;
foreach (const QString &key, data.keys()) {
// Properties in QML must start lowercase.
QString ourKey = key.toLower();
m_data->insert(ourKey.toLatin1(), data.value(key));
newKeys << ourKey;
}
if (newKeys != m_keys) {
//FIXME: pretty utterly inefficient
foreach (const QString &key, m_keys) {
if (!newKeys.contains(key)) {
m_data->insert(key.toLatin1(), QVariant());
}
}
emit keysChanged();
m_keys = newKeys;
}
emit dataChanged();
}
Plasma::Service *DataSource::service()
{
if (!m_service) {
m_service = m_dataEngine->serviceForSource(m_source);
}
return m_service;
}
}
#include "datasource_p.moc"

101
declarativeimports/core/datasource_p.h Normal file
View File

@ -0,0 +1,101 @@
/*
* Copyright 2009 by Alan Alpert <alan.alpert@nokia.com>
* Copyright 2010 by Ménard Alexis <menard@kde.org>
* Copyright 2010 by Marco MArtin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef DATASOURCE_H
#define DATASOURCE_H
#include <QObject>
#include <QDeclarativePropertyMap>
#include "dataengineconsumer_p.h"
#include <Plasma/DataEngine>
#include <qdeclarative.h>
class QDeclarativePropertyMap;
namespace Plasma
{
class Applet;
class DataEngine;
class DataSource : public QObject, DataEngineConsumer
{
Q_OBJECT
public:
typedef QHash<QString, QVariant> Data;
DataSource(QObject* parent=0);
Q_PROPERTY(bool valid READ valid);
bool valid() const {return m_dataEngine != 0;}
Q_PROPERTY(int interval READ interval WRITE setInterval NOTIFY intervalChanged);
int interval() const {return m_interval;}
void setInterval(int i) {if(i==m_interval) return; m_interval=i; emit intervalChanged();}
Q_PROPERTY(QString engine READ engine WRITE setEngine NOTIFY engineChanged);
QString engine() const {return m_engine;}
void setEngine(const QString &e) {if(e==m_engine) return; m_engine=e; emit engineChanged();}
Q_PROPERTY(QString source READ source WRITE setSource NOTIFY sourceChanged);
QString source() const {return m_source;}
void setSource(const QString &s);
Q_PROPERTY(QStringList keys READ keys NOTIFY keysChanged);
QStringList keys() const {return m_keys;}
Q_PROPERTY(QStringList allSources READ allSources NOTIFY sourcesChanged);
QStringList allSources() const {if (m_dataEngine) return m_dataEngine->sources(); else return QStringList();}
Q_PROPERTY(QObject *data READ data NOTIFY dataChanged);
QObject *data() const {return m_data;}
Q_PROPERTY(Plasma::Service *service READ service CONSTANT);
Plasma::Service *service();
public Q_SLOTS:
void dataUpdated(const QString &sourceName, const Plasma::DataEngine::Data &data);
void setupData();
Q_SIGNALS:
void intervalChanged();
void engineChanged();
void sourceChanged();
void keysChanged();
void dataChanged();
void sourcesChanged();
private:
QString m_id;
int m_interval;
QString m_source;
QString m_engine;
QStringList m_keys;
QDeclarativePropertyMap *m_data;
Plasma::DataEngine* m_dataEngine;
Plasma::Service *m_service;
QString m_connectedSource;
};
}
#endif

121
declarativeimports/core/framesvgitem.cpp Normal file
View File

@ -0,0 +1,121 @@
/*
* Copyright 2010 Marco Martin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "framesvgitem_p.h"
#include <QtGui/QPainter>
#include "kdebug.h"
#include "plasma/framesvg.h"
namespace Plasma
{
FrameSvgItemMargins::FrameSvgItemMargins(Plasma::FrameSvg *frameSvg, QObject *parent)
: QObject(parent),
m_frameSvg(frameSvg)
{
connect(m_frameSvg, SIGNAL(repaintNeeded()), this, SIGNAL(marginsChanged()));
}
qreal FrameSvgItemMargins::left() const
{
return m_frameSvg->marginSize(LeftMargin);
}
qreal FrameSvgItemMargins::top() const
{
return m_frameSvg->marginSize(TopMargin);
}
qreal FrameSvgItemMargins::right() const
{
return m_frameSvg->marginSize(RightMargin);
}
qreal FrameSvgItemMargins::bottom() const
{
return m_frameSvg->marginSize(BottomMargin);
}
FrameSvgItem::FrameSvgItem(QDeclarativeItem *parent)
: QDeclarativeItem(parent)
{
m_frameSvg = new Plasma::FrameSvg(this);
m_margins = new FrameSvgItemMargins(m_frameSvg, this);
setFlag(QGraphicsItem::ItemHasNoContents, false);
connect(m_frameSvg, SIGNAL(repaintNeeded()), this, SLOT(doUpdate()));
}
FrameSvgItem::~FrameSvgItem()
{
}
void FrameSvgItem::setImagePath(const QString &path)
{
m_frameSvg->setImagePath(path);
update();
}
QString FrameSvgItem::imagePath() const
{
return m_frameSvg->imagePath();
}
void FrameSvgItem::setPrefix(const QString &prefix)
{
m_frameSvg->setElementPrefix(prefix);
update();
}
QString FrameSvgItem::prefix() const
{
return m_frameSvg->prefix();
}
FrameSvgItemMargins *FrameSvgItem::margins() const
{
return m_margins;
}
void FrameSvgItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
m_frameSvg->paintFrame(painter);
}
void FrameSvgItem::geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry)
{
m_frameSvg->resizeFrame(newGeometry.size());
QDeclarativeItem::geometryChanged(newGeometry, oldGeometry);
}
void FrameSvgItem::doUpdate()
{
update();
}
} // Plasma namespace
#include "framesvgitem_p.moc"

87
declarativeimports/core/framesvgitem_p.h Normal file
View File

@ -0,0 +1,87 @@
/***************************************************************************
* Copyright 2010 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#ifndef FRAMESVGITEM_P
#define FRAMESVGITEM_P
#include <QDeclarativeItem>
namespace Plasma {
class FrameSvg;
class FrameSvgItemMargins : public QObject
{
Q_OBJECT
Q_PROPERTY(qreal left READ left NOTIFY marginsChanged)
Q_PROPERTY(qreal top READ top NOTIFY marginsChanged)
Q_PROPERTY(qreal right READ right NOTIFY marginsChanged)
Q_PROPERTY(qreal bottom READ bottom NOTIFY marginsChanged)
public:
FrameSvgItemMargins(Plasma::FrameSvg *frameSvg, QObject *parent = 0);
qreal left() const;
qreal top() const;
qreal right() const;
qreal bottom() const;
Q_SIGNALS:
void marginsChanged();
private:
FrameSvg *m_frameSvg;
};
class FrameSvgItem : public QDeclarativeItem
{
Q_OBJECT
Q_PROPERTY(QString imagePath READ imagePath WRITE setImagePath)
Q_PROPERTY(QString prefix READ prefix WRITE setPrefix)
Q_PROPERTY(QObject *margins READ margins CONSTANT)
public:
FrameSvgItem(QDeclarativeItem *parent=0);
~FrameSvgItem();
void setImagePath(const QString &path);
QString imagePath() const;
void setPrefix(const QString &prefix);
QString prefix() const;
FrameSvgItemMargins *margins() const;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
void geometryChanged(const QRectF &newGeometry,
const QRectF &oldGeometry);
private Q_SLOTS:
void doUpdate();
private:
Plasma::FrameSvg *m_frameSvg;
FrameSvgItemMargins *m_margins;
};
}
#endif

2
declarativeimports/core/qmldir Normal file
View File

@ -0,0 +1,2 @@
plugin corebindingsplugin

78
declarativeimports/core/svgitem.cpp Normal file
View File

@ -0,0 +1,78 @@
/*
* Copyright 2010 Marco Martin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "svgitem_p.h"
#include <QtGui/QPainter>
#include "kdebug.h"
#include "plasma/svg.h"
namespace Plasma
{
SvgItem::SvgItem(QDeclarativeItem *parent)
: QDeclarativeItem(parent)
{
m_svg = new Plasma::Svg(this);
setFlag(QGraphicsItem::ItemHasNoContents, false);
connect(m_svg, SIGNAL(repaintNeeded()), this, SLOT(update()));
}
SvgItem::~SvgItem()
{
}
void SvgItem::setImagePath(const QString &path)
{
m_svg->setImagePath(path);
update();
}
QString SvgItem::imagePath() const
{
return m_svg->imagePath();
}
void SvgItem::setElementId(const QString &elementID)
{
m_svg->setContainsMultipleImages(!elementID.isNull());
m_elementID = elementID;
update();
}
QString SvgItem::elementId() const
{
return m_elementID;
}
void SvgItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
m_svg->paint(painter, boundingRect(), m_elementID);
}
} // Plasma namespace
#include "svgitem_p.moc"

53
declarativeimports/core/svgitem_p.h Normal file
View File

@ -0,0 +1,53 @@
/***************************************************************************
* Copyright 2010 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#ifndef SVGITEM_P
#define SVGITEM_P
#include <QDeclarativeItem>
namespace Plasma {
class Svg;
class SvgItem : public QDeclarativeItem
{
Q_OBJECT
Q_PROPERTY(QString imagePath READ imagePath WRITE setImagePath)
Q_PROPERTY(QString elementId READ elementId WRITE setElementId)
public:
SvgItem(QDeclarativeItem *parent=0);
~SvgItem();
void setImagePath(const QString &path);
QString imagePath() const;
void setElementId(const QString &elementID);
QString elementId() const;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
private:
Plasma::Svg *m_svg;
QString m_elementID;
};
}
#endif

70
declarativeimports/core/theme.cpp Normal file
View File

@ -0,0 +1,70 @@
/***************************************************************************
* Copyright 2010 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#include "theme_p.h"
#include <plasma/theme.h>
ThemeProxy::ThemeProxy(QObject *parent)
: QObject(parent)
{
connect(Plasma::Theme::defaultTheme(), SIGNAL(themeChanged()), this, SIGNAL(themeChanged()));
}
ThemeProxy::~ThemeProxy()
{
}
QColor ThemeProxy::textColor() const
{
return Plasma::Theme::defaultTheme()->color(Plasma::Theme::TextColor);
}
QColor ThemeProxy::highlightColor() const
{
return Plasma::Theme::defaultTheme()->color(Plasma::Theme::HighlightColor);
}
QColor ThemeProxy::backgroundColor() const
{
return Plasma::Theme::defaultTheme()->color(Plasma::Theme::BackgroundColor);
}
QColor ThemeProxy::buttonTextColor() const
{
return Plasma::Theme::defaultTheme()->color(Plasma::Theme::ButtonTextColor);
}
QColor ThemeProxy::buttonBackgroundColor() const
{
return Plasma::Theme::defaultTheme()->color(Plasma::Theme::ButtonBackgroundColor);
}
QColor ThemeProxy::linkColor() const
{
return Plasma::Theme::defaultTheme()->color(Plasma::Theme::LinkColor);
}
QColor ThemeProxy::visitedLinkColor() const
{
return Plasma::Theme::defaultTheme()->color(Plasma::Theme::VisitedLinkColor);
}
#include "theme_p.moc"

54
declarativeimports/core/theme_p.h Normal file
View File

@ -0,0 +1,54 @@
/***************************************************************************
* Copyright 2010 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#ifndef THEME_PROXY_P
#define THEME_PROXY_P
#include <QObject>
#include <QColor>
class ThemeProxy : public QObject
{
Q_OBJECT
Q_PROPERTY(QColor textColor READ textColor NOTIFY themeChanged)
Q_PROPERTY(QColor highlightColor READ highlightColor NOTIFY themeChanged)
Q_PROPERTY(QColor backgroundColor READ backgroundColor NOTIFY themeChanged)
Q_PROPERTY(QColor buttonTextColor READ buttonTextColor NOTIFY themeChanged)
Q_PROPERTY(QColor buttonBackgroundColor READ buttonBackgroundColor NOTIFY themeChanged)
Q_PROPERTY(QColor linkColor READ linkColor NOTIFY themeChanged)
Q_PROPERTY(QColor visitedLinkColor READ visitedLinkColor NOTIFY themeChanged)
public:
ThemeProxy(QObject *parent = 0);
~ThemeProxy();
QColor textColor() const;
QColor highlightColor() const;
QColor backgroundColor() const;
QColor buttonTextColor() const;
QColor buttonBackgroundColor() const;
QColor linkColor() const;
QColor visitedLinkColor() const;
Q_SIGNALS:
void themeChanged();
};
#endif

24
declarativeimports/graphicslayouts/CMakeLists.txt Normal file
View File

@ -0,0 +1,24 @@
project(graphicslayoutsbindings)
include(KDE4Defaults)
set(graphicslayoutsbindings_SRCS
graphicslayoutsbindingsplugin.cpp
gridlayout.cpp
linearlayout.cpp
)
INCLUDE_DIRECTORIES(
${CMAKE_SOURCE_DIR}
${CMAKE_BINARY_DIR}
${KDE4_INCLUDES}
)
qt4_automoc(${graphicslayoutsbindings_SRCS})
add_library(graphicslayoutsbindingsplugin SHARED ${graphicslayoutsbindings_SRCS})
target_link_libraries(graphicslayoutsbindingsplugin ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTSCRIPT_LIBRARY} ${QT_QTDECLARATIVE_LIBRARY})
install(TARGETS graphicslayoutsbindingsplugin DESTINATION ${QT_IMPORTS_DIR}/org/kde/plasma/graphicslayouts)
install(FILES qmldir DESTINATION ${QT_IMPORTS_DIR}/org/kde/plasma/graphicslayouts)

43
declarativeimports/graphicslayouts/graphicslayoutsbindingsplugin.cpp Normal file
View File

@ -0,0 +1,43 @@
/*
* Copyright 2009 by Alan Alpert <alan.alpert@nokia.com>
* Copyright 2010 by Ménard Alexis <menard@kde.org>
* Copyright 2010 by Marco Martin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "graphicslayoutsbindingsplugin.h"
#include <QtDeclarative/qdeclarative.h>
#include "gridlayout.h"
#include "linearlayout.h"
void GraphicsLayoutsBindingsPlugin::registerTypes(const char *uri)
{
Q_ASSERT(uri == QLatin1String("org.kde.plasma.graphicslayouts"));
qmlRegisterInterface<QGraphicsLayoutItem>("QGraphicsLayoutItem");
qmlRegisterInterface<QGraphicsLayout>("QGraphicsLayout");
qmlRegisterType<GraphicsLinearLayoutStretchItemObject>(uri,4,7,"QGraphicsLinearLayoutStretchItem");
qmlRegisterType<GraphicsLinearLayoutObject>(uri,4,7,"QGraphicsLinearLayout");
qmlRegisterType<GraphicsGridLayoutObject>(uri,4,7,"QGraphicsGridLayout");
}
#include "graphicslayoutsbindingsplugin.moc"

38
declarativeimports/graphicslayouts/graphicslayoutsbindingsplugin.h Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright 2009 by Alan Alpert <alan.alpert@nokia.com>
* Copyright 2010 by Ménard Alexis <menard@kde.org>
* Copyright 2010 by Marco Martin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef GRAPHICSLAYOUTSBINDINGSPLUGIN_H
#define GRAPHICSLAYOUTSBINDINGSPLUGIN_H
#include <QDeclarativeExtensionPlugin>
class GraphicsLayoutsBindingsPlugin : public QDeclarativeExtensionPlugin
{
Q_OBJECT
public:
void registerTypes(const char *uri);
};
Q_EXPORT_PLUGIN2(graphicslayoutsbindingsplugin, GraphicsLayoutsBindingsPlugin);
#endif

189
declarativeimports/graphicslayouts/gridlayout.cpp Normal file
View File

@ -0,0 +1,189 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
** the names of its contributors may be used to endorse or promote
** products derived from this software without specific prior written
** permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
** $QT_END_LICENSE$
**
****************************************************************************/
#include "gridlayout.h"
#include <QGraphicsWidget>
#include <QDebug>
GridLayoutAttached::GridLayoutAttached(QObject *parent)
: QObject(parent), m_row(-1), m_column(-1), m_rowspan(1), m_colspan(1), m_alignment(-1), m_rowStretch(-1),
m_colStretch(-1), m_rowSpacing(-1), m_colSpacing(-1), m_rowPrefHeight(-1), m_rowMaxHeight(-1), m_rowMinHeight(-1),
m_rowFixHeight(-1), m_colPrefwidth(-1), m_colMaxwidth(-1), m_colMinwidth(-1), m_colFixwidth(-1)
{
}
void GridLayoutAttached::setAlignment(Qt::Alignment a)
{
if (m_alignment != a) {
m_alignment = a;
emit alignmentChanged(reinterpret_cast<QGraphicsLayoutItem*>(parent()), m_alignment);
}
}
QHash<QGraphicsLayoutItem*, GridLayoutAttached*> GraphicsGridLayoutObject::attachedProperties;
GraphicsGridLayoutObject::GraphicsGridLayoutObject(QObject *parent)
: QObject(parent)
{
}
GraphicsGridLayoutObject::~GraphicsGridLayoutObject()
{
}
void GraphicsGridLayoutObject::addWidget(QGraphicsWidget *widget)
{
//use attached properties
if (QObject *obj = attachedProperties.value(qobject_cast<QGraphicsLayoutItem*>(widget))) {
int row = static_cast<GridLayoutAttached *>(obj)->row();
int column = static_cast<GridLayoutAttached *>(obj)->column();
int rowSpan = static_cast<GridLayoutAttached *>(obj)->rowSpan();
int columnSpan = static_cast<GridLayoutAttached *>(obj)->columnSpan();
if (row == -1 || column == -1) {
qWarning() << "Must set row and column for an item in a grid layout";
return;
}
addItem(widget, row, column, rowSpan, columnSpan);
}
}
void GraphicsGridLayoutObject::addLayoutItem(QGraphicsLayoutItem *item)
{
//use attached properties
if (GridLayoutAttached *obj = attachedProperties.value(item)) {
int row = obj->row();
int column = obj->column();
int rowSpan = obj->rowSpan();
int columnSpan = obj->columnSpan();
Qt::Alignment alignment = obj->alignment();
if (row == -1 || column == -1) {
qWarning() << "Must set row and column for an item in a grid layout";
return;
}
if (obj->rowSpacing() != -1)
setRowSpacing(row, obj->rowSpacing());
if (obj->columnSpacing() != -1)
setColumnSpacing(column, obj->columnSpacing());
if (obj->rowStretchFactor() != -1)
setRowStretchFactor(row, obj->rowStretchFactor());
if (obj->columnStretchFactor() != -1)
setColumnStretchFactor(column, obj->columnStretchFactor());
if (obj->rowPreferredHeight() != -1)
setRowPreferredHeight(row, obj->rowPreferredHeight());
if (obj->rowMaximumHeight() != -1)
setRowMaximumHeight(row, obj->rowMaximumHeight());
if (obj->rowMinimumHeight() != -1)
setRowMinimumHeight(row, obj->rowMinimumHeight());
if (obj->rowFixedHeight() != -1)
setRowFixedHeight(row, obj->rowFixedHeight());
if (obj->columnPreferredWidth() != -1)
setColumnPreferredWidth(row, obj->columnPreferredWidth());
if (obj->columnMaximumWidth() != -1)
setColumnMaximumWidth(row, obj->columnMaximumWidth());
if (obj->columnMinimumWidth() != -1)
setColumnMinimumWidth(row, obj->columnMinimumWidth());
if (obj->columnFixedWidth() != -1)
setColumnFixedWidth(row, obj->columnFixedWidth());
addItem(item, row, column, rowSpan, columnSpan);
if (alignment != -1)
setAlignment(item, alignment);
QObject::connect(obj, SIGNAL(alignmentChanged(QGraphicsLayoutItem*, Qt::Alignment)),
this, SLOT(updateAlignment(QGraphicsLayoutItem*, Qt::Alignment)));
}
}
void GraphicsGridLayoutObject::removeAt(int index)
{
QGraphicsLayoutItem *item = itemAt(index);
if (item) {
GridLayoutAttached *obj = attachedProperties.value(item);
obj->disconnect(this);
attachedProperties.remove(item);
}
QGraphicsGridLayout::removeAt(index);
}
void GraphicsGridLayoutObject::clearChildren()
{
// do not delete the removed items; they will be deleted by the QML engine
while (count() > 0)
removeAt(count()-1);
}
qreal GraphicsGridLayoutObject::spacing() const
{
if (verticalSpacing() == horizontalSpacing())
return verticalSpacing();
return -1;
}
qreal GraphicsGridLayoutObject::contentsMargin() const
{
qreal a, b, c, d;
getContentsMargins(&a, &b, &c, &d);
if (a == b && a == c && a == d)
return a;
return -1;
}
void GraphicsGridLayoutObject::setContentsMargin(qreal m)
{
setContentsMargins(m, m, m, m);
}
void GraphicsGridLayoutObject::updateAlignment(QGraphicsLayoutItem *item, Qt::Alignment alignment)
{
QGraphicsGridLayout::setAlignment(item, alignment);
}
GridLayoutAttached *GraphicsGridLayoutObject::qmlAttachedProperties(QObject *obj)
{
GridLayoutAttached *rv = new GridLayoutAttached(obj);
if (qobject_cast<QGraphicsLayoutItem*>(obj))
attachedProperties.insert(qobject_cast<QGraphicsLayoutItem*>(obj), rv);
return rv;
}
#include "gridlayout.moc"

217
declarativeimports/graphicslayouts/gridlayout.h Normal file
View File

@ -0,0 +1,217 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
** the names of its contributors may be used to endorse or promote
** products derived from this software without specific prior written
** permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef GRIDLAYOUT_H
#define GRIDLAYOUT_H
#include <QtDeclarative/qdeclarative.h>
#include <QGraphicsGridLayout>
#include <QGraphicsLayoutItem>
#include <QDeclarativeListProperty>
class GridLayoutAttached;
class GraphicsGridLayoutObject : public QObject, public QGraphicsGridLayout
{
Q_OBJECT
Q_INTERFACES(QGraphicsLayout QGraphicsLayoutItem)
Q_PROPERTY(QDeclarativeListProperty<QGraphicsLayoutItem> children READ children)
Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing)
Q_PROPERTY(qreal contentsMargin READ contentsMargin WRITE setContentsMargin)
Q_PROPERTY(qreal verticalSpacing READ verticalSpacing WRITE setVerticalSpacing)
Q_PROPERTY(qreal horizontalSpacing READ horizontalSpacing WRITE setHorizontalSpacing)
Q_CLASSINFO("DefaultProperty", "children")
public:
GraphicsGridLayoutObject(QObject * = 0);
~GraphicsGridLayoutObject();
QDeclarativeListProperty<QGraphicsLayoutItem> children() { return QDeclarativeListProperty<QGraphicsLayoutItem>(this, 0, children_append, children_count, children_at, children_clear); }
qreal spacing() const;
qreal contentsMargin() const;
void setContentsMargin(qreal);
void removeAt(int index);
static GridLayoutAttached *qmlAttachedProperties(QObject *);
private slots:
void updateAlignment(QGraphicsLayoutItem*,Qt::Alignment);
private:
friend class GraphicsLayoutAttached;
void addWidget(QGraphicsWidget *);
void clearChildren();
void addLayoutItem(QGraphicsLayoutItem *);
static void children_append(QDeclarativeListProperty<QGraphicsLayoutItem> *prop, QGraphicsLayoutItem *item) {
static_cast<GraphicsGridLayoutObject*>(prop->object)->addLayoutItem(item);
}
static void children_clear(QDeclarativeListProperty<QGraphicsLayoutItem> *prop) {
static_cast<GraphicsGridLayoutObject*>(prop->object)->clearChildren();
}
static int children_count(QDeclarativeListProperty<QGraphicsLayoutItem> *prop) {
return static_cast<GraphicsGridLayoutObject*>(prop->object)->count();
}
static QGraphicsLayoutItem *children_at(QDeclarativeListProperty<QGraphicsLayoutItem> *prop, int index) {
return static_cast<GraphicsGridLayoutObject*>(prop->object)->itemAt(index);
}
static QHash<QGraphicsLayoutItem*, GridLayoutAttached*> attachedProperties;
};
class GridLayoutAttached : public QObject
{
Q_OBJECT
Q_PROPERTY(int row READ row WRITE setRow)
Q_PROPERTY(int column READ column WRITE setColumn)
Q_PROPERTY(int rowSpan READ rowSpan WRITE setRowSpan)
Q_PROPERTY(int columnSpan READ columnSpan WRITE setColumnSpan)
Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment)
Q_PROPERTY(int rowStretchFactor READ rowStretchFactor WRITE setRowStretchFactor)
Q_PROPERTY(int columnStretchFactor READ columnStretchFactor WRITE setColumnStretchFactor)
Q_PROPERTY(int rowSpacing READ rowSpacing WRITE setRowSpacing)
Q_PROPERTY(int columnSpacing READ columnSpacing WRITE setColumnSpacing)
Q_PROPERTY(int rowPreferredHeight READ rowPreferredHeight WRITE setRowPreferredHeight)
Q_PROPERTY(int rowMinimumHeight READ rowMinimumHeight WRITE setRowMinimumHeight)
Q_PROPERTY(int rowMaximumHeight READ rowMaximumHeight WRITE setRowMaximumHeight)
Q_PROPERTY(int rowFixedHeight READ rowFixedHeight WRITE setRowFixedHeight)
Q_PROPERTY(int columnPreferredWidth READ columnPreferredWidth WRITE setColumnPreferredWidth)
Q_PROPERTY(int columnMaximumWidth READ columnMaximumWidth WRITE setColumnMaximumWidth)
Q_PROPERTY(int columnMinimumWidth READ columnMinimumWidth WRITE setColumnMinimumWidth)
Q_PROPERTY(int columnFixedWidth READ columnFixedWidth WRITE setColumnFixedWidth)
public:
GridLayoutAttached(QObject *parent);
int row() const { return m_row; }
void setRow(int r) { m_row = r; }
int column() const { return m_column; }
void setColumn(int c) { m_column = c; }
int rowSpan() const { return m_rowspan; }
void setRowSpan(int rs) { m_rowspan = rs; }
int columnSpan() const { return m_colspan; }
void setColumnSpan(int cs) { m_colspan = cs; }
Qt::Alignment alignment() const { return m_alignment; }
void setAlignment(Qt::Alignment a);
int rowStretchFactor() const { return m_rowStretch; }
void setRowStretchFactor(int f) { m_rowStretch = f; }
int columnStretchFactor() const { return m_colStretch; }
void setColumnStretchFactor(int f) { m_colStretch = f; }
int rowSpacing() const { return m_rowSpacing; }
void setRowSpacing(int s) { m_rowSpacing = s; }
int columnSpacing() const { return m_colSpacing; }
void setColumnSpacing(int s) { m_colSpacing = s; }
int rowPreferredHeight() const { return m_rowPrefHeight; }
void setRowPreferredHeight(int s) { m_rowPrefHeight = s; }
int rowMaximumHeight() const { return m_rowMaxHeight; }
void setRowMaximumHeight(int s) { m_rowMaxHeight = s; }
int rowMinimumHeight() const { return m_rowMinHeight; }
void setRowMinimumHeight(int s) { m_rowMinHeight = s; }
int rowFixedHeight() const { return m_rowFixHeight; }
void setRowFixedHeight(int s) { m_rowFixHeight = s; }
int columnPreferredWidth() const { return m_colPrefwidth; }
void setColumnPreferredWidth(int s) { m_colPrefwidth = s; }
int columnMaximumWidth() const { return m_colMaxwidth; }
void setColumnMaximumWidth(int s) { m_colMaxwidth = s; }
int columnMinimumWidth() const { return m_colMinwidth; }
void setColumnMinimumWidth(int s) { m_colMinwidth = s; }
int columnFixedWidth() const { return m_colFixwidth; }
void setColumnFixedWidth(int s) { m_colFixwidth = s; }
signals:
void alignmentChanged(QGraphicsLayoutItem*, Qt::Alignment);
private:
int m_row;
int m_column;
int m_rowspan;
int m_colspan;
Qt::Alignment m_alignment;
int m_rowStretch;
int m_colStretch;
int m_rowSpacing;
int m_colSpacing;
int m_rowPrefHeight;
int m_rowMaxHeight;
int m_rowMinHeight;
int m_rowFixHeight;
int m_colPrefwidth;
int m_colMaxwidth;
int m_colMinwidth;
int m_colFixwidth;
};
QML_DECLARE_TYPE(GraphicsGridLayoutObject)
QML_DECLARE_TYPEINFO(GraphicsGridLayoutObject, QML_HAS_ATTACHED_PROPERTIES)
#endif

175
declarativeimports/graphicslayouts/linearlayout.cpp Normal file
View File

@ -0,0 +1,175 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
** the names of its contributors may be used to endorse or promote
** products derived from this software without specific prior written
** permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
** $QT_END_LICENSE$
**
****************************************************************************/
#include "linearlayout.h"
#include <QGraphicsWidget>
#include <QGraphicsLayoutItem>
LinearLayoutAttached::LinearLayoutAttached(QObject *parent)
: QObject(parent), m_stretch(1), m_alignment(Qt::AlignTop), m_spacing(0)
{
}
void LinearLayoutAttached::setStretchFactor(int f)
{
if (m_stretch != f) {
m_stretch = f;
emit stretchChanged(reinterpret_cast<QGraphicsLayoutItem*>(parent()), m_stretch);
}
}
void LinearLayoutAttached::setSpacing(int s)
{
if (m_spacing != s) {
m_spacing = s;
emit spacingChanged(reinterpret_cast<QGraphicsLayoutItem*>(parent()), m_spacing);
}
}
void LinearLayoutAttached::setAlignment(Qt::Alignment a)
{
if (m_alignment != a) {
m_alignment = a;
emit alignmentChanged(reinterpret_cast<QGraphicsLayoutItem*>(parent()), m_alignment);
}
}
GraphicsLinearLayoutStretchItemObject::GraphicsLinearLayoutStretchItemObject(QObject *parent)
: QObject(parent)
{
}
QSizeF GraphicsLinearLayoutStretchItemObject::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
{
Q_UNUSED(which);
Q_UNUSED(constraint);
return QSizeF();
}
GraphicsLinearLayoutObject::GraphicsLinearLayoutObject(QObject *parent)
: QObject(parent)
{
}
GraphicsLinearLayoutObject::~GraphicsLinearLayoutObject()
{
}
void GraphicsLinearLayoutObject::insertLayoutItem(int index, QGraphicsLayoutItem *item)
{
insertItem(index, item);
if (LinearLayoutAttached *obj = attachedProperties.value(item)) {
setStretchFactor(item, obj->stretchFactor());
setAlignment(item, obj->alignment());
updateSpacing(item, obj->spacing());
QObject::connect(obj, SIGNAL(stretchChanged(QGraphicsLayoutItem*,int)),
this, SLOT(updateStretch(QGraphicsLayoutItem*,int)));
QObject::connect(obj, SIGNAL(alignmentChanged(QGraphicsLayoutItem*,Qt::Alignment)),
this, SLOT(updateAlignment(QGraphicsLayoutItem*,Qt::Alignment)));
QObject::connect(obj, SIGNAL(spacingChanged(QGraphicsLayoutItem*,int)),
this, SLOT(updateSpacing(QGraphicsLayoutItem*,int)));
}
}
void GraphicsLinearLayoutObject::removeAt(int index)
{
QGraphicsLayoutItem *item = itemAt(index);
if (item) {
LinearLayoutAttached *obj = attachedProperties.value(item);
obj->disconnect(this);
attachedProperties.remove(item);
}
QGraphicsLinearLayout::removeAt(index);
}
void GraphicsLinearLayoutObject::clearChildren()
{
// do not delete the removed items; they will be deleted by the QML engine
while (count() > 0)
removeAt(count()-1);
}
qreal GraphicsLinearLayoutObject::contentsMargin() const
{
qreal a, b, c, d;
getContentsMargins(&a, &b, &c, &d);
if (a == b && a == c && a == d)
return a;
return -1;
}
void GraphicsLinearLayoutObject::setContentsMargin(qreal m)
{
setContentsMargins(m, m, m, m);
}
void GraphicsLinearLayoutObject::updateStretch(QGraphicsLayoutItem *item, int stretch)
{
QGraphicsLinearLayout::setStretchFactor(item, stretch);
}
void GraphicsLinearLayoutObject::updateSpacing(QGraphicsLayoutItem* item, int spacing)
{
for (int i=0; i < count(); i++){
if (itemAt(i) == item) {
QGraphicsLinearLayout::setItemSpacing(i, spacing);
return;
}
}
}
void GraphicsLinearLayoutObject::updateAlignment(QGraphicsLayoutItem *item, Qt::Alignment alignment)
{
QGraphicsLinearLayout::setAlignment(item, alignment);
}
QHash<QGraphicsLayoutItem*, LinearLayoutAttached*> GraphicsLinearLayoutObject::attachedProperties;
LinearLayoutAttached *GraphicsLinearLayoutObject::qmlAttachedProperties(QObject *obj)
{
LinearLayoutAttached *rv = new LinearLayoutAttached(obj);
if (qobject_cast<QGraphicsLayoutItem*>(obj))
attachedProperties.insert(qobject_cast<QGraphicsLayoutItem*>(obj), rv);
return rv;
}
#include "linearlayout.moc"

152
declarativeimports/graphicslayouts/linearlayout.h Normal file
View File

@ -0,0 +1,152 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
** the names of its contributors may be used to endorse or promote
** products derived from this software without specific prior written
** permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef LINEARLAYOUT_H
#define LINEARLAYOUT_H
#include <QtDeclarative/qdeclarative.h>
#include <QGraphicsLinearLayout>
#include <QGraphicsLayoutItem>
#include <QDeclarativeListProperty>
class GraphicsLinearLayoutStretchItemObject : public QObject, public QGraphicsLayoutItem
{
Q_OBJECT
Q_INTERFACES(QGraphicsLayoutItem)
public:
GraphicsLinearLayoutStretchItemObject(QObject *parent = 0);
virtual QSizeF sizeHint(Qt::SizeHint, const QSizeF &) const;
};
class LinearLayoutAttached;
class GraphicsLinearLayoutObject : public QObject, public QGraphicsLinearLayout
{
Q_OBJECT
Q_INTERFACES(QGraphicsLayout QGraphicsLayoutItem)
Q_PROPERTY(QDeclarativeListProperty<QGraphicsLayoutItem> children READ children)
Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation)
Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing)
Q_PROPERTY(qreal contentsMargin READ contentsMargin WRITE setContentsMargin)
Q_CLASSINFO("DefaultProperty", "children")
public:
GraphicsLinearLayoutObject(QObject * = 0);
~GraphicsLinearLayoutObject();
QDeclarativeListProperty<QGraphicsLayoutItem> children() { return QDeclarativeListProperty<QGraphicsLayoutItem>(this, 0, children_append, children_count, children_at, children_clear); }
qreal contentsMargin() const;
void setContentsMargin(qreal);
void removeAt(int index);
static LinearLayoutAttached *qmlAttachedProperties(QObject *);
private slots:
void updateStretch(QGraphicsLayoutItem*,int);
void updateSpacing(QGraphicsLayoutItem*,int);
void updateAlignment(QGraphicsLayoutItem*,Qt::Alignment);
private:
friend class LinearLayoutAttached;
void clearChildren();
void insertLayoutItem(int, QGraphicsLayoutItem *);
static void children_append(QDeclarativeListProperty<QGraphicsLayoutItem> *prop, QGraphicsLayoutItem *item) {
static_cast<GraphicsLinearLayoutObject*>(prop->object)->insertLayoutItem(-1, item);
}
static void children_clear(QDeclarativeListProperty<QGraphicsLayoutItem> *prop) {
static_cast<GraphicsLinearLayoutObject*>(prop->object)->clearChildren();
}
static int children_count(QDeclarativeListProperty<QGraphicsLayoutItem> *prop) {
return static_cast<GraphicsLinearLayoutObject*>(prop->object)->count();
}
static QGraphicsLayoutItem *children_at(QDeclarativeListProperty<QGraphicsLayoutItem> *prop, int index) {
return static_cast<GraphicsLinearLayoutObject*>(prop->object)->itemAt(index);
}
static QHash<QGraphicsLayoutItem*, LinearLayoutAttached*> attachedProperties;
};
class LinearLayoutAttached : public QObject
{
Q_OBJECT
Q_PROPERTY(int stretchFactor READ stretchFactor WRITE setStretchFactor NOTIFY stretchChanged)
Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment NOTIFY alignmentChanged)
Q_PROPERTY(int spacing READ spacing WRITE setSpacing NOTIFY spacingChanged)
public:
LinearLayoutAttached(QObject *parent);
int stretchFactor() const { return m_stretch; }
void setStretchFactor(int f);
Qt::Alignment alignment() const { return m_alignment; }
void setAlignment(Qt::Alignment a);
int spacing() const { return m_spacing; }
void setSpacing(int s);
signals:
void stretchChanged(QGraphicsLayoutItem*, int);
void alignmentChanged(QGraphicsLayoutItem*, Qt::Alignment);
void spacingChanged(QGraphicsLayoutItem*, int);
private:
int m_stretch;
Qt::Alignment m_alignment;
int m_spacing;
};
QML_DECLARE_TYPE(GraphicsLinearLayoutStretchItemObject)
QML_DECLARE_TYPE(GraphicsLinearLayoutObject)
QML_DECLARE_TYPEINFO(GraphicsLinearLayoutObject, QML_HAS_ATTACHED_PROPERTIES)
#endif

2
declarativeimports/graphicslayouts/qmldir Normal file
View File

@ -0,0 +1,2 @@
plugin graphicslayoutsbindingsplugin

23
declarativeimports/graphicswidgets/CMakeLists.txt Normal file
View File

@ -0,0 +1,23 @@
project(graphicswidgetsbindings)
include(KDE4Defaults)
set(graphicswidgetsbindings_SRCS
graphicswidgetsbindingsplugin.cpp
declarativetabbar.cpp
)
INCLUDE_DIRECTORIES(
${CMAKE_SOURCE_DIR}
${CMAKE_BINARY_DIR}
${KDE4_INCLUDES}
)
qt4_automoc(${graphicswidgetsbindings_SRCS})
add_library(graphicswidgetsbindingsplugin SHARED ${graphicswidgetsbindings_SRCS})
target_link_libraries(graphicswidgetsbindingsplugin ${KDE4_PLASMA_LIBS} ${QT_QTSCRIPT_LIBRARY} ${QT_QTDECLARATIVE_LIBRARY})
install(TARGETS graphicswidgetsbindingsplugin DESTINATION ${QT_IMPORTS_DIR}/org/kde/plasma/graphicswidgets)
install(FILES qmldir DESTINATION ${QT_IMPORTS_DIR}/org/kde/plasma/graphicswidgets)

73
declarativeimports/graphicswidgets/declarativetabbar.cpp Normal file
View File

@ -0,0 +1,73 @@
/***************************************************************************
* Copyright 2010 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#include "declarativetabbar.h"
TabBarAttached::TabBarAttached(QObject *parent)
: QObject(parent)
{
}
void TabBarAttached::setTabText(const QString &text)
{
if (text == m_tabText)
return;
m_tabText = text;
emit tabTextChanged(reinterpret_cast<DeclarativeTabBar*>(parent()), m_tabText);
}
QString TabBarAttached::tabText()const
{
return m_tabText;
}
DeclarativeTabBar::DeclarativeTabBar(QObject *parent)
: Plasma::TabBar(qobject_cast<QGraphicsWidget *>(parent))
{}
DeclarativeTabBar::~DeclarativeTabBar()
{}
void DeclarativeTabBar::updateTabText(QGraphicsLayoutItem *item, const QString &text)
{
for (int i=0; i < count(); ++i) {
if (item == tabAt(i)) {
setTabText(i, text);
break;
}
}
}
QHash<QGraphicsLayoutItem*, TabBarAttached*> DeclarativeTabBar::m_attachedProperties;
TabBarAttached *DeclarativeTabBar::qmlAttachedProperties(QObject *obj)
{
// ### This is not allowed - you must attach to any object
if (!qobject_cast<QGraphicsLayoutItem*>(obj)) {
return 0;
}
TabBarAttached *attached = new TabBarAttached(obj);
m_attachedProperties.insert(qobject_cast<QGraphicsLayoutItem*>(obj), attached);
return attached;
}
#include "declarativetabbar.moc"

105
declarativeimports/graphicswidgets/declarativetabbar.h Normal file
View File

@ -0,0 +1,105 @@
/***************************************************************************
* Copyright 2010 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#ifndef DECLARATIVETABBAR
#define DECLARATIVETABBAR
#include <QtDeclarative/qdeclarative.h>
#include <QDeclarativeListProperty>
#include "plasma/widgets/tabbar.h"
class TabBarAttached : public QObject
{
Q_OBJECT
Q_PROPERTY(QString tabText READ tabText WRITE setTabText NOTIFY tabTextChanged)
public:
TabBarAttached(QObject *parent);
void setTabText(const QString& text);
QString tabText() const;
Q_SIGNALS:
void tabTextChanged(QGraphicsLayoutItem*, const QString&);
private:
QString m_tabText;
};
class DeclarativeTabBar : public Plasma::TabBar
{
Q_OBJECT
Q_PROPERTY(KTabBar *nativeWidget READ nativeWidget)
Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex)
Q_PROPERTY(int count READ count)
Q_PROPERTY(QString styleSheet READ styleSheet WRITE setStyleSheet)
Q_PROPERTY(bool tabBarShown READ isTabBarShown WRITE setTabBarShown)
Q_PROPERTY(QDeclarativeListProperty<QGraphicsLayoutItem> children READ children)
Q_CLASSINFO("DefaultProperty", "children")
public:
DeclarativeTabBar(QObject *parent = 0);
~DeclarativeTabBar();
QDeclarativeListProperty<QGraphicsLayoutItem> children() { return QDeclarativeListProperty<QGraphicsLayoutItem>(this, 0, children_append, children_count, children_at, children_clear); }
static TabBarAttached *qmlAttachedProperties(QObject *);
private Q_SLOTS:
void updateTabText(QGraphicsLayoutItem *, const QString&);
private:
static QHash<QGraphicsLayoutItem*, TabBarAttached*> m_attachedProperties;
static void children_append(QDeclarativeListProperty<QGraphicsLayoutItem> *prop, QGraphicsLayoutItem *item) {
QString text;
DeclarativeTabBar *tabBar = static_cast<DeclarativeTabBar*>(prop->object);
if (TabBarAttached *obj = m_attachedProperties.value(item)) {
text = obj->tabText();
QObject::connect(obj, SIGNAL(tabTextChanged(QGraphicsLayoutItem*,int)),
tabBar, SLOT(updateTabText(QGraphicsLayoutItem*,int)));
}
tabBar->addTab(text, item);
}
static void children_clear(QDeclarativeListProperty<QGraphicsLayoutItem> *prop) {
DeclarativeTabBar *tabBar = static_cast<DeclarativeTabBar*>(prop->object);
for (int i=0; i < tabBar->count(); ++i) {
tabBar->removeTab(0);
}
}
static int children_count(QDeclarativeListProperty<QGraphicsLayoutItem> *prop) {
return static_cast<DeclarativeTabBar*>(prop->object)->count();
}
static QGraphicsLayoutItem *children_at(QDeclarativeListProperty<QGraphicsLayoutItem> *prop, int index) {
return static_cast<DeclarativeTabBar*>(prop->object)->tabAt(index);
}
};
QML_DECLARE_TYPE(DeclarativeTabBar)
QML_DECLARE_TYPEINFO(DeclarativeTabBar, QML_HAS_ATTACHED_PROPERTIES)
#endif

91
declarativeimports/graphicswidgets/graphicswidgetsbindingsplugin.cpp Normal file
View File

@ -0,0 +1,91 @@
/*
* Copyright 2009 by Alan Alpert <alan.alpert@nokia.com>
* Copyright 2010 by Ménard Alexis <menard@kde.org>
* Copyright 2010 by Marco Martin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "graphicswidgetsbindingsplugin.h"
#include <QtDeclarative/qdeclarative.h>
#include <Plasma/BusyWidget>
#include <Plasma/CheckBox>
#include <Plasma/ComboBox>
#include <Plasma/FlashingLabel>
#include <Plasma/Frame>
#include <Plasma/GroupBox>
#include <Plasma/IconWidget>
#include <Plasma/ItemBackground>
#include <Plasma/Label>
#include <Plasma/LineEdit>
#include <Plasma/Meter>
#include <Plasma/PushButton>
#include <Plasma/RadioButton>
#include <Plasma/ScrollBar>
#include <Plasma/ScrollWidget>
#include <Plasma/Separator>
#include <Plasma/SignalPlotter>
#include <Plasma/Slider>
#include <Plasma/SpinBox>
#include <Plasma/SvgWidget>
#include <Plasma/TextBrowser>
#include <Plasma/TextEdit>
#include <Plasma/ToolButton>
#include <Plasma/TreeView>
#include <Plasma/VideoWidget>
#include <Plasma/WebView>
#include "declarativetabbar.h"
void GraphicsWidgetsBindingsPlugin::registerTypes(const char *uri)
{
Q_ASSERT(uri == QLatin1String("org.kde.plasma.graphicswidgets"));
qmlRegisterType<DeclarativeTabBar>(uri, 0, 1, "TabBar");
qmlRegisterType<Plasma::BusyWidget>(uri, 0, 1, "BusyWidget");
qmlRegisterType<Plasma::CheckBox>(uri, 0, 1, "CheckBox");
qmlRegisterType<Plasma::ComboBox>(uri, 0, 1, "ComboBox");
qmlRegisterType<Plasma::FlashingLabel>(uri, 0, 1, "FlashingLabel");
qmlRegisterType<Plasma::Frame>(uri, 0, 1, "Frame");
qmlRegisterType<Plasma::GroupBox>(uri, 0, 1, "GroupBox");
qmlRegisterType<Plasma::IconWidget>(uri, 0, 1, "IconWidget");
qmlRegisterType<Plasma::ItemBackground>(uri, 0, 1, "ItemBackground");
qmlRegisterType<Plasma::Label>(uri, 0, 1, "Label");
qmlRegisterType<Plasma::LineEdit>(uri, 0, 1, "LineEdit");
qmlRegisterType<Plasma::Meter>(uri, 0, 1, "Meter");
qmlRegisterType<Plasma::PushButton>(uri, 0, 1, "PushButton");
qmlRegisterType<Plasma::RadioButton>(uri, 0, 1, "RadioButton");
qmlRegisterType<Plasma::ScrollBar>(uri, 0, 1, "ScrollBar");
qmlRegisterType<Plasma::ScrollWidget>(uri, 0, 1, "ScrollWidget");
qmlRegisterType<Plasma::Separator>(uri, 0, 1, "Separator");
qmlRegisterType<Plasma::SignalPlotter>(uri, 0, 1, "SignalPlotter");
qmlRegisterType<Plasma::Slider>(uri, 0, 1, "Slider");
qmlRegisterType<Plasma::SpinBox>(uri, 0, 1, "SpinBox");
qmlRegisterType<Plasma::SvgWidget>(uri, 0, 1, "SvgWidget");
qmlRegisterType<Plasma::TextBrowser>(uri, 0, 1, "TextBrowser");
qmlRegisterType<Plasma::TextEdit>(uri, 0, 1, "TextEdit");
qmlRegisterType<Plasma::ToolButton>(uri, 0, 1, "ToolButton");
qmlRegisterType<Plasma::TreeView>(uri, 0, 1, "TreeView");
qmlRegisterType<Plasma::VideoWidget>(uri, 0, 1, "VideoWidget");
qmlRegisterType<Plasma::WebView>(uri, 0, 1, "WebView");
}
#include "graphicswidgetsbindingsplugin.moc"

38
declarativeimports/graphicswidgets/graphicswidgetsbindingsplugin.h Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright 2009 by Alan Alpert <alan.alpert@nokia.com>
* Copyright 2010 by Ménard Alexis <menard@kde.org>
* Copyright 2010 by Marco Martin <mart@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
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef GRAPHICSWIDGETSBINDINGSPLUGIN_H
#define GRAPHICSWIDGETSBINDINGSPLUGIN_H
#include <QDeclarativeExtensionPlugin>
class GraphicsWidgetsBindingsPlugin : public QDeclarativeExtensionPlugin
{
Q_OBJECT
public:
void registerTypes(const char *uri);
};
Q_EXPORT_PLUGIN2(graphicswidgetsbindingsplugin, GraphicsWidgetsBindingsPlugin);
#endif

2
declarativeimports/graphicswidgets/qmldir Normal file
View File

@ -0,0 +1,2 @@
plugin graphicswidgetsbindingsplugin