2008-11-04 00:08:39 +01:00
|
|
|
/*
|
|
|
|
* 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>
|
2009-08-18 00:31:18 +02:00
|
|
|
* Copyright (c) 2009 Chani Armitage <chani@kde.org>
|
2008-11-04 00:08:39 +01:00
|
|
|
*
|
|
|
|
* 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 "applet.h"
|
|
|
|
#include "private/applet_p.h"
|
2010-04-29 07:57:34 +02:00
|
|
|
|
|
|
|
#include "config-plasma.h"
|
|
|
|
|
2009-12-11 20:53:55 +01:00
|
|
|
#include <plasma/animations/animation.h>
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
#include <cmath>
|
|
|
|
#include <limits>
|
|
|
|
|
|
|
|
#include <QApplication>
|
|
|
|
#include <QEvent>
|
|
|
|
#include <QFile>
|
|
|
|
#include <QGraphicsGridLayout>
|
|
|
|
#include <QGraphicsSceneMouseEvent>
|
|
|
|
#include <QGraphicsView>
|
2009-09-03 01:49:58 +02:00
|
|
|
#include <QHostInfo>
|
2008-11-04 00:08:39 +01:00
|
|
|
#include <QLabel>
|
|
|
|
#include <QList>
|
|
|
|
#include <QGraphicsLinearLayout>
|
|
|
|
#include <QPainter>
|
2009-10-29 10:09:01 +01:00
|
|
|
#include <QRegExp>
|
2008-11-04 00:08:39 +01:00
|
|
|
#include <QSize>
|
|
|
|
#include <QStyleOptionGraphicsItem>
|
|
|
|
#include <QTextDocument>
|
|
|
|
#include <QUiLoader>
|
2008-11-15 22:23:56 +01:00
|
|
|
#include <QVBoxLayout>
|
2008-11-06 16:52:13 +01:00
|
|
|
#include <QWidget>
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2008-11-04 03:04:34 +01:00
|
|
|
#include <kaction.h>
|
2008-11-15 22:23:56 +01:00
|
|
|
#include <kactioncollection.h>
|
2012-06-15 16:05:18 +02:00
|
|
|
#include <kcoreauthorized.h>
|
2008-11-04 03:04:34 +01:00
|
|
|
#include <kcolorscheme.h>
|
|
|
|
#include <kdialog.h>
|
2011-10-31 17:54:39 +01:00
|
|
|
#include <kdesktopfile.h>
|
2008-11-04 03:04:34 +01:00
|
|
|
#include <kiconloader.h>
|
2008-11-15 22:23:56 +01:00
|
|
|
#include <kkeysequencewidget.h>
|
2008-11-04 03:04:34 +01:00
|
|
|
#include <kplugininfo.h>
|
2012-06-12 12:59:34 +02:00
|
|
|
|
2008-11-04 03:04:34 +01:00
|
|
|
#include <kservice.h>
|
|
|
|
#include <kservicetypetrader.h>
|
|
|
|
#include <kshortcut.h>
|
|
|
|
#include <kwindowsystem.h>
|
2008-11-23 15:09:45 +01:00
|
|
|
#include <kpushbutton.h>
|
2009-09-16 19:08:45 +02:00
|
|
|
|
2012-08-24 03:16:04 +02:00
|
|
|
#if !PLASMA_NO_KUTILS
|
2011-11-02 17:24:25 +01:00
|
|
|
#include <kcmoduleinfo.h>
|
|
|
|
#include <kcmoduleproxy.h>
|
2011-11-03 12:15:52 +01:00
|
|
|
#else
|
|
|
|
#include <kcmodule.h>
|
2011-11-02 17:24:25 +01:00
|
|
|
#endif
|
|
|
|
|
2012-08-24 03:16:04 +02:00
|
|
|
#if !PLASMA_NO_SOLID
|
2008-11-04 03:04:34 +01:00
|
|
|
#include <solid/powermanagement.h>
|
2010-04-29 07:57:34 +02:00
|
|
|
#endif
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2010-01-27 00:35:32 +01:00
|
|
|
#include "abstracttoolbox.h"
|
2009-09-04 02:08:26 +02:00
|
|
|
#include "authorizationrule.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
#include "configloader.h"
|
|
|
|
#include "containment.h"
|
|
|
|
#include "corona.h"
|
2009-09-12 02:19:42 +02:00
|
|
|
#include "dialog.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
#include "package.h"
|
|
|
|
#include "plasma.h"
|
|
|
|
#include "scripting/appletscript.h"
|
|
|
|
#include "svg.h"
|
|
|
|
#include "framesvg.h"
|
|
|
|
#include "popupapplet.h"
|
2009-10-28 19:06:56 +01:00
|
|
|
#include "private/applethandle_p.h"
|
2010-04-07 04:04:52 +02:00
|
|
|
#include "private/framesvg_p.h"
|
2011-04-29 15:18:35 +02:00
|
|
|
#include "remote/authorizationmanager.h"
|
|
|
|
#include "remote/authorizationmanager_p.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
#include "theme.h"
|
|
|
|
#include "view.h"
|
|
|
|
#include "widgets/iconwidget.h"
|
|
|
|
#include "widgets/label.h"
|
|
|
|
#include "tooltipmanager.h"
|
|
|
|
#include "wallpaper.h"
|
2009-02-02 20:39:41 +01:00
|
|
|
#include "paintutils.h"
|
2010-04-03 21:10:32 +02:00
|
|
|
#include "abstractdialogmanager.h"
|
2010-07-15 23:06:21 +02:00
|
|
|
#include "pluginloader.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2009-10-20 21:15:32 +02:00
|
|
|
#include "private/associatedapplicationmanager_p.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
#include "private/containment_p.h"
|
2009-09-02 04:27:16 +02:00
|
|
|
#include "private/package_p.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
#include "private/packages_p.h"
|
2009-11-25 02:09:17 +01:00
|
|
|
#include "private/plasmoidservice_p.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
#include "private/popupapplet_p.h"
|
2009-10-20 21:15:32 +02:00
|
|
|
#include "private/remotedataengine_p.h"
|
2009-09-02 04:27:16 +02:00
|
|
|
#include "private/service_p.h"
|
|
|
|
#include "ui_publish.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2009-09-09 15:40:16 +02:00
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
namespace Plasma
|
|
|
|
{
|
|
|
|
|
2012-09-24 14:30:42 +02:00
|
|
|
Applet::Applet(const KPluginInfo &info, QObject *parent, uint appletId)
|
|
|
|
: QObject(parent),
|
2010-08-03 01:56:02 +02:00
|
|
|
d(new AppletPrivate(KService::Ptr(), &info, appletId, this))
|
|
|
|
{
|
|
|
|
// WARNING: do not access config() OR globalConfig() in this method!
|
|
|
|
// that requires a scene, which is not available at this point
|
|
|
|
d->init();
|
|
|
|
}
|
|
|
|
|
2012-09-24 14:30:42 +02:00
|
|
|
Applet::Applet(QObject *parent, const QString &serviceID, uint appletId)
|
|
|
|
: QObject(parent),
|
2010-08-03 01:56:02 +02:00
|
|
|
d(new AppletPrivate(KService::serviceByStorageId(serviceID), 0, appletId, this))
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
|
|
|
// WARNING: do not access config() OR globalConfig() in this method!
|
|
|
|
// that requires a scene, which is not available at this point
|
|
|
|
d->init();
|
|
|
|
}
|
|
|
|
|
2012-09-24 14:30:42 +02:00
|
|
|
Applet::Applet(QObject *parent, const QString &serviceID, uint appletId, const QVariantList &args)
|
|
|
|
: QObject(parent),
|
2010-08-03 01:56:02 +02:00
|
|
|
d(new AppletPrivate(KService::serviceByStorageId(serviceID), 0, appletId, this))
|
2009-02-08 16:24:56 +01:00
|
|
|
{
|
|
|
|
// WARNING: do not access config() OR globalConfig() in this method!
|
|
|
|
// that requires a scene, which is not available at this point
|
|
|
|
|
|
|
|
QVariantList &mutableArgs = const_cast<QVariantList &>(args);
|
|
|
|
if (!mutableArgs.isEmpty()) {
|
|
|
|
mutableArgs.removeFirst();
|
|
|
|
|
|
|
|
if (!mutableArgs.isEmpty()) {
|
|
|
|
mutableArgs.removeFirst();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
d->args = mutableArgs;
|
|
|
|
|
|
|
|
d->init();
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
Applet::Applet(QObject *parentObject, const QVariantList &args)
|
2012-09-24 14:30:42 +02:00
|
|
|
: QObject(0),
|
2008-11-04 00:08:39 +01:00
|
|
|
d(new AppletPrivate(
|
2010-08-03 01:56:02 +02:00
|
|
|
KService::serviceByStorageId(args.count() > 0 ? args[0].toString() : QString()), 0,
|
2008-11-04 00:08:39 +01:00
|
|
|
args.count() > 1 ? args[1].toInt() : 0, this))
|
|
|
|
{
|
|
|
|
// now remove those first two items since those are managed by Applet and subclasses shouldn't
|
|
|
|
// need to worry about them. yes, it violates the constness of this var, but it lets us add
|
|
|
|
// or remove items later while applets can just pretend that their args always start at 0
|
|
|
|
QVariantList &mutableArgs = const_cast<QVariantList &>(args);
|
|
|
|
if (!mutableArgs.isEmpty()) {
|
|
|
|
mutableArgs.removeFirst();
|
|
|
|
|
|
|
|
if (!mutableArgs.isEmpty()) {
|
|
|
|
mutableArgs.removeFirst();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-08 16:24:56 +01:00
|
|
|
d->args = mutableArgs;
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
setParent(parentObject);
|
2009-01-13 22:46:07 +01:00
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
// WARNING: do not access config() OR globalConfig() in this method!
|
|
|
|
// that requires a scene, which is not available at this point
|
|
|
|
d->init();
|
|
|
|
|
|
|
|
// the brain damage seen in the initialization list is due to the
|
|
|
|
// inflexibility of KService::createInstance
|
|
|
|
}
|
|
|
|
|
2010-03-23 23:41:57 +01:00
|
|
|
Applet::Applet(const QString &packagePath, uint appletId, const QVariantList &args)
|
2012-09-24 14:30:42 +02:00
|
|
|
: QObject(0),
|
2010-08-03 01:56:02 +02:00
|
|
|
d(new AppletPrivate(KService::Ptr(new KService(packagePath + "/metadata.desktop")), 0, appletId, this))
|
2010-03-23 23:41:57 +01:00
|
|
|
{
|
|
|
|
Q_UNUSED(args) // FIXME?
|
|
|
|
d->init(packagePath);
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
Applet::~Applet()
|
|
|
|
{
|
2009-01-28 08:58:17 +01:00
|
|
|
//let people know that i will die
|
2012-09-24 13:58:54 +02:00
|
|
|
emit appletDeleted(this);
|
2009-01-28 08:58:17 +01:00
|
|
|
|
2009-02-24 03:32:48 +01:00
|
|
|
// clean up our config dialog, if any
|
2009-02-24 03:34:57 +01:00
|
|
|
delete KConfigDialog::exists(d->configDialogId());
|
2008-11-04 00:08:39 +01:00
|
|
|
delete d;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::init()
|
|
|
|
{
|
2009-06-12 17:20:54 +02:00
|
|
|
if (d->script) {
|
2009-11-11 20:26:05 +01:00
|
|
|
d->setupScriptSupport();
|
2009-11-11 02:54:00 +01:00
|
|
|
|
|
|
|
if (!d->script->init() && !d->failed) {
|
2009-06-12 17:20:54 +02:00
|
|
|
setFailedToLaunch(true, i18n("Script initialization failed"));
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint Applet::id() const
|
|
|
|
{
|
|
|
|
return d->appletId;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::save(KConfigGroup &g) const
|
|
|
|
{
|
2008-12-18 23:14:06 +01:00
|
|
|
if (d->transient) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
KConfigGroup group = g;
|
|
|
|
if (!group.isValid()) {
|
|
|
|
group = *d->mainConfigGroup();
|
|
|
|
}
|
|
|
|
|
2012-04-30 13:08:55 +02:00
|
|
|
//kDebug() << "saving" << pluginName() << "to" << group.name();
|
2008-11-04 00:08:39 +01:00
|
|
|
// we call the dptr member directly for locked since isImmutable()
|
|
|
|
// also checks kiosk and parent containers
|
|
|
|
group.writeEntry("immutability", (int)d->immutability);
|
|
|
|
group.writeEntry("plugin", pluginName());
|
2008-12-12 02:05:00 +01:00
|
|
|
|
|
|
|
group.writeEntry("geometry", geometry());
|
|
|
|
group.writeEntry("zvalue", zValue());
|
|
|
|
|
|
|
|
if (!d->started) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
//kDebug() << pluginName() << "geometry is" << geometry()
|
|
|
|
// << "pos is" << pos() << "bounding rect is" << boundingRect();
|
|
|
|
if (transform() == QTransform()) {
|
|
|
|
group.deleteEntry("transform");
|
|
|
|
} else {
|
|
|
|
QList<qreal> m;
|
|
|
|
QTransform t = transform();
|
|
|
|
m << t.m11() << t.m12() << t.m13() << t.m21() << t.m22() << t.m23() << t.m31() << t.m32() << t.m33();
|
|
|
|
group.writeEntry("transform", m);
|
|
|
|
//group.writeEntry("transform", transformToString(transform()));
|
|
|
|
}
|
|
|
|
|
|
|
|
KConfigGroup appletConfigGroup(&group, "Configuration");
|
|
|
|
saveState(appletConfigGroup);
|
|
|
|
|
2009-01-07 21:34:34 +01:00
|
|
|
if (d->configLoader) {
|
2009-05-26 19:32:33 +02:00
|
|
|
// we're saving so we know its changed, we don't need or want the configChanged
|
|
|
|
// signal bubbling up at this point due to that
|
2011-04-25 16:43:15 +02:00
|
|
|
disconnect(d->configLoader, SIGNAL(configChanged()), this, SLOT(propagateConfigChanged()));
|
2009-01-07 21:34:34 +01:00
|
|
|
d->configLoader->writeConfig();
|
2011-04-25 16:43:15 +02:00
|
|
|
connect(d->configLoader, SIGNAL(configChanged()), this, SLOT(propagateConfigChanged()));
|
2009-01-07 21:34:34 +01:00
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::restore(KConfigGroup &group)
|
|
|
|
{
|
|
|
|
QList<qreal> m = group.readEntry("transform", QList<qreal>());
|
|
|
|
if (m.count() == 9) {
|
|
|
|
QTransform t(m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]);
|
|
|
|
setTransform(t);
|
|
|
|
}
|
|
|
|
|
|
|
|
qreal z = group.readEntry("zvalue", 0);
|
|
|
|
|
|
|
|
if (z >= AppletPrivate::s_maxZValue) {
|
|
|
|
AppletPrivate::s_maxZValue = z;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (z > 0) {
|
|
|
|
setZValue(z);
|
|
|
|
}
|
|
|
|
|
|
|
|
setImmutability((ImmutabilityType)group.readEntry("immutability", (int)Mutable));
|
|
|
|
|
|
|
|
QRectF geom = group.readEntry("geometry", QRectF());
|
|
|
|
if (geom.isValid()) {
|
|
|
|
setGeometry(geom);
|
|
|
|
}
|
|
|
|
|
|
|
|
KConfigGroup shortcutConfig(&group, "Shortcuts");
|
|
|
|
QString shortcutText = shortcutConfig.readEntryUntranslated("global", QString());
|
|
|
|
if (!shortcutText.isEmpty()) {
|
|
|
|
setGlobalShortcut(KShortcut(shortcutText));
|
2009-03-24 03:07:20 +01:00
|
|
|
/*
|
2011-07-29 15:46:52 +02:00
|
|
|
#ifndef NDEBUG
|
2008-11-04 00:08:39 +01:00
|
|
|
kDebug() << "got global shortcut for" << name() << "of" << QKeySequence(shortcutText);
|
2011-07-29 15:46:52 +02:00
|
|
|
#endif
|
|
|
|
#ifndef NDEBUG
|
2008-11-04 00:08:39 +01:00
|
|
|
kDebug() << "set to" << d->activationAction->objectName()
|
2011-07-29 15:46:52 +02:00
|
|
|
#endif
|
2008-11-04 00:08:39 +01:00
|
|
|
<< d->activationAction->globalShortcut().primary();
|
2009-03-24 03:07:20 +01:00
|
|
|
*/
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// local shortcut, if any
|
|
|
|
//TODO: implement; the shortcut will need to be registered with the containment
|
|
|
|
/*
|
2009-09-02 04:27:16 +02:00
|
|
|
#include "accessmanager.h"
|
2009-11-25 02:09:17 +01:00
|
|
|
#include "private/plasmoidservice_p.h"
|
2009-09-02 04:27:16 +02:00
|
|
|
#include "authorizationmanager.h"
|
|
|
|
#include "authorizationmanager.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
shortcutText = shortcutConfig.readEntryUntranslated("local", QString());
|
|
|
|
if (!shortcutText.isEmpty()) {
|
|
|
|
//TODO: implement; the shortcut
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::setFailedToLaunch(bool failed, const QString &reason)
|
|
|
|
{
|
|
|
|
d->failed = failed;
|
2011-11-17 14:40:53 +01:00
|
|
|
d->updateFailedToLaunch(reason);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::saveState(KConfigGroup &group) const
|
|
|
|
{
|
2009-11-05 19:43:39 +01:00
|
|
|
if (d->script) {
|
|
|
|
emit d->script->saveState(group);
|
|
|
|
}
|
2010-01-27 00:35:32 +01:00
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
if (group.config()->name() != config().config()->name()) {
|
|
|
|
// we're being saved to a different file!
|
|
|
|
// let's just copy the current values in our configuration over
|
|
|
|
KConfigGroup c = config();
|
|
|
|
c.copyTo(&group);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
KConfigGroup Applet::config() const
|
|
|
|
{
|
2009-01-22 01:00:16 +01:00
|
|
|
if (d->transient) {
|
2012-03-24 19:33:54 +01:00
|
|
|
return KConfigGroup(KSharedConfig::openConfig(), "PlasmaTransientsConfig");
|
2009-01-22 01:00:16 +01:00
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
if (d->isContainment) {
|
|
|
|
return *(d->mainConfigGroup());
|
|
|
|
}
|
|
|
|
|
|
|
|
return KConfigGroup(d->mainConfigGroup(), "Configuration");
|
|
|
|
}
|
|
|
|
|
|
|
|
KConfigGroup Applet::globalConfig() const
|
|
|
|
{
|
|
|
|
KConfigGroup globalAppletConfig;
|
|
|
|
QString group = isContainment() ? "ContainmentGlobals" : "AppletGlobals";
|
|
|
|
|
2012-09-24 17:18:55 +02:00
|
|
|
Containment *cont = containment();
|
|
|
|
Corona *corona = 0;
|
|
|
|
if (cont) {
|
|
|
|
corona = cont->corona();
|
|
|
|
}
|
2008-12-18 23:14:06 +01:00
|
|
|
if (corona) {
|
|
|
|
KSharedConfig::Ptr coronaConfig = corona->config();
|
2008-11-04 00:08:39 +01:00
|
|
|
globalAppletConfig = KConfigGroup(coronaConfig, group);
|
|
|
|
} else {
|
2012-03-24 19:33:54 +01:00
|
|
|
globalAppletConfig = KConfigGroup(KSharedConfig::openConfig(), group);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return KConfigGroup(&globalAppletConfig, d->globalName());
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::destroy()
|
|
|
|
{
|
2009-06-20 04:14:43 +02:00
|
|
|
if (immutability() != Mutable || d->transient || !d->started) {
|
2008-11-04 00:08:39 +01:00
|
|
|
return; //don't double delete
|
|
|
|
}
|
|
|
|
|
|
|
|
d->transient = true;
|
2011-11-17 14:40:53 +01:00
|
|
|
//FIXME: an animation on leave if !isContainment() would be good again .. which should be handled by the containment class
|
|
|
|
d->cleanUpAndDelete();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2008-12-01 02:04:58 +01:00
|
|
|
bool Applet::destroyed() const
|
|
|
|
{
|
|
|
|
return d->transient;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
ConfigLoader *Applet::configScheme() const
|
|
|
|
{
|
|
|
|
return d->configLoader;
|
|
|
|
}
|
|
|
|
|
|
|
|
DataEngine *Applet::dataEngine(const QString &name) const
|
|
|
|
{
|
2012-09-24 15:51:14 +02:00
|
|
|
return d->dataEngine(name, d->remoteLocation);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 12:59:51 +02:00
|
|
|
Package Applet::package() const
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
2011-07-15 12:59:51 +02:00
|
|
|
return d->package ? *d->package : Package();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
QRectF Applet::mapFromView(const QGraphicsView *view, const QRect &rect) const
|
|
|
|
{
|
2012-09-24 17:18:55 +02:00
|
|
|
return QRect();
|
|
|
|
/*TODO: port away qgv
|
2008-11-04 00:08:39 +01:00
|
|
|
// Why is this adjustment needed? Qt calculation error?
|
2012-09-24 17:18:55 +02:00
|
|
|
return mapFromScene(view->mapToScene(rect)).boundingRect().adjusted(0, 0, 1, 1);*/
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
QRect Applet::mapToView(const QGraphicsView *view, const QRectF &rect) const
|
|
|
|
{
|
2012-09-24 17:18:55 +02:00
|
|
|
return QRect();
|
|
|
|
/*TODO: port away qgv
|
2008-11-04 00:08:39 +01:00
|
|
|
// Why is this adjustment needed? Qt calculation error?
|
2012-09-24 17:18:55 +02:00
|
|
|
return view->mapFromScene(mapToScene(rect)).boundingRect().adjusted(0, 0, -1, -1);*/
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
QPoint Applet::popupPosition(const QSize &s) const
|
2009-09-28 19:28:17 +02:00
|
|
|
{
|
|
|
|
return popupPosition(s, Qt::AlignLeft);
|
|
|
|
}
|
|
|
|
|
|
|
|
QPoint Applet::popupPosition(const QSize &s, Qt::AlignmentFlag alignment) const
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
2012-09-24 17:18:55 +02:00
|
|
|
Containment *cont = containment();
|
|
|
|
Corona *corona = 0;
|
|
|
|
if (cont) {
|
|
|
|
corona = cont->corona();
|
|
|
|
}
|
2008-12-18 23:14:06 +01:00
|
|
|
Q_ASSERT(corona);
|
2009-09-28 19:28:17 +02:00
|
|
|
|
|
|
|
return corona->popupPosition(this, s, alignment);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::updateConstraints(Plasma::Constraints constraints)
|
|
|
|
{
|
|
|
|
d->scheduleConstraintsUpdate(constraints);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::constraintsEvent(Plasma::Constraints constraints)
|
|
|
|
{
|
|
|
|
//NOTE: do NOT put any code in here that reacts to constraints updates
|
|
|
|
// as it will not get called for any applet that reimplements constraintsEvent
|
|
|
|
// without calling the Applet:: version as well, which it shouldn't need to.
|
|
|
|
// INSTEAD put such code into flushPendingConstraintsEvents
|
|
|
|
Q_UNUSED(constraints)
|
|
|
|
//kDebug() << constraints << "constraints are FormFactor: " << formFactor()
|
|
|
|
// << ", Location: " << location();
|
|
|
|
if (d->script) {
|
|
|
|
d->script->constraintsEvent(constraints);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-04 19:22:55 +01:00
|
|
|
void Applet::setBusy(bool busy)
|
|
|
|
{
|
2011-11-17 14:40:53 +01:00
|
|
|
d->setBusy(busy);
|
2008-11-04 19:22:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Applet::isBusy() const
|
|
|
|
{
|
2011-11-17 14:40:53 +01:00
|
|
|
return d->isBusy();
|
2008-11-04 19:22:55 +01:00
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
QString Applet::name() const
|
|
|
|
{
|
2009-01-22 01:00:16 +01:00
|
|
|
if (d->isContainment) {
|
2008-11-04 00:08:39 +01:00
|
|
|
const Containment *c = qobject_cast<const Containment*>(this);
|
2010-05-21 03:07:31 +02:00
|
|
|
if (c && c->d->isPanelContainment()) {
|
|
|
|
return i18n("Panel");
|
|
|
|
} else if (!d->appletDescription.isValid()) {
|
|
|
|
return i18n("Unknown");
|
2009-10-07 20:31:14 +02:00
|
|
|
} else {
|
2010-05-21 03:07:31 +02:00
|
|
|
return d->appletDescription.name();
|
2009-10-07 20:31:14 +02:00
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
} else if (!d->appletDescription.isValid()) {
|
|
|
|
return i18n("Unknown Widget");
|
|
|
|
}
|
|
|
|
|
|
|
|
return d->appletDescription.name();
|
|
|
|
}
|
|
|
|
|
|
|
|
QFont Applet::font() const
|
|
|
|
{
|
|
|
|
return QApplication::font();
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Applet::icon() const
|
|
|
|
{
|
|
|
|
if (!d->appletDescription.isValid()) {
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
|
|
|
return d->appletDescription.icon();
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Applet::pluginName() const
|
|
|
|
{
|
|
|
|
if (!d->appletDescription.isValid()) {
|
2012-04-30 13:08:55 +02:00
|
|
|
return d->mainConfigGroup()->readEntry("plugin", QString());
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return d->appletDescription.pluginName();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Applet::shouldConserveResources() const
|
|
|
|
{
|
2012-08-24 03:16:04 +02:00
|
|
|
#if !PLASMA_NO_SOLID
|
2008-11-04 00:08:39 +01:00
|
|
|
return Solid::PowerManagement::appShouldConserveResources();
|
2010-04-29 07:57:34 +02:00
|
|
|
#else
|
|
|
|
return true;
|
|
|
|
#endif
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
QString Applet::category() const
|
|
|
|
{
|
|
|
|
if (!d->appletDescription.isValid()) {
|
2008-11-04 13:54:19 +01:00
|
|
|
return i18nc("misc category", "Miscellaneous");
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return d->appletDescription.category();
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Applet::category(const KPluginInfo &applet)
|
|
|
|
{
|
2009-05-01 20:03:13 +02:00
|
|
|
return applet.property("X-KDE-PluginInfo-Category").toString();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
QString Applet::category(const QString &appletName)
|
|
|
|
{
|
|
|
|
if (appletName.isEmpty()) {
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
2009-07-06 13:49:01 +02:00
|
|
|
const QString constraint = QString("[X-KDE-PluginInfo-Name] == '%1'").arg(appletName);
|
2009-07-26 16:20:31 +02:00
|
|
|
KService::List offers = KServiceTypeTrader::self()->query("Plasma/Applet", constraint);
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
if (offers.isEmpty()) {
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
2009-05-01 20:03:13 +02:00
|
|
|
return offers.first()->property("X-KDE-PluginInfo-Category").toString();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ImmutabilityType Applet::immutability() const
|
|
|
|
{
|
2010-11-12 23:48:31 +01:00
|
|
|
// if this object is itself system immutable, then just return that; it's the most
|
|
|
|
// restrictive setting possible and will override anything that might be happening above it
|
|
|
|
// in the Corona->Containment->Applet hierarchy
|
2010-12-26 11:42:57 +01:00
|
|
|
if (d->transient || (d->mainConfig && d->mainConfig->isImmutable())) {
|
2010-11-12 23:48:31 +01:00
|
|
|
return SystemImmutable;
|
2010-09-21 16:21:58 +02:00
|
|
|
}
|
|
|
|
|
2010-11-12 23:48:31 +01:00
|
|
|
//Returning the more strict immutability between the applet immutability, Containment and Corona
|
|
|
|
ImmutabilityType upperImmutability = Mutable;
|
|
|
|
Containment *cont = d->isContainment ? 0 : containment();
|
|
|
|
|
2010-09-21 16:21:58 +02:00
|
|
|
if (cont) {
|
2010-11-12 23:48:31 +01:00
|
|
|
upperImmutability = cont->immutability();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2010-11-12 23:48:31 +01:00
|
|
|
if (upperImmutability != Mutable) {
|
|
|
|
// it's either system or user immutable, and we already check for local system immutability,
|
|
|
|
// so upperImmutability is guaranteed to be as or more severe as this object's immutability
|
|
|
|
return upperImmutability;
|
2008-11-04 00:08:39 +01:00
|
|
|
} else {
|
|
|
|
return d->immutability;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::setImmutability(const ImmutabilityType immutable)
|
|
|
|
{
|
2010-11-12 23:48:31 +01:00
|
|
|
if (d->immutability == immutable || immutable == Plasma::SystemImmutable) {
|
|
|
|
// we do not store system immutability in d->immutability since that gets saved
|
|
|
|
// out to the config file; instead, we check with
|
|
|
|
// the config group itself for this information at all times. this differs from
|
|
|
|
// corona, where SystemImmutability is stored in d->immutability.
|
2008-11-04 00:08:39 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
d->immutability = immutable;
|
|
|
|
updateConstraints(ImmutableConstraint);
|
|
|
|
}
|
|
|
|
|
2011-06-24 16:35:09 +02:00
|
|
|
BackgroundHints Applet::backgroundHints() const
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
|
|
|
return d->backgroundHints;
|
|
|
|
}
|
|
|
|
|
2011-06-24 16:35:09 +02:00
|
|
|
void Applet::setBackgroundHints(const Plasma::BackgroundHints hints)
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
2009-06-15 00:12:40 +02:00
|
|
|
if (d->backgroundHints == hints) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
d->backgroundHints = hints;
|
2009-07-27 22:14:38 +02:00
|
|
|
d->preferredBackgroundHints = hints;
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
//Draw the standard background?
|
|
|
|
if ((hints & StandardBackground) || (hints & TranslucentBackground)) {
|
|
|
|
if (!d->background) {
|
|
|
|
d->background = new Plasma::FrameSvg(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((hints & TranslucentBackground) &&
|
|
|
|
Plasma::Theme::defaultTheme()->currentThemeHasImage("widgets/translucentbackground")) {
|
|
|
|
d->background->setImagePath("widgets/translucentbackground");
|
|
|
|
} else {
|
|
|
|
d->background->setImagePath("widgets/background");
|
|
|
|
}
|
|
|
|
|
|
|
|
d->background->setEnabledBorders(Plasma::FrameSvg::AllBorders);
|
|
|
|
qreal left, top, right, bottom;
|
|
|
|
d->background->getMargins(left, top, right, bottom);
|
|
|
|
QSizeF fitSize(left + right, top + bottom);
|
|
|
|
d->background->resizeFrame(boundingRect().size());
|
2009-01-13 22:46:07 +01:00
|
|
|
|
|
|
|
//if the background has an "overlay" element decide a random position for it and then save it so it's consistent across plasma starts
|
2009-02-18 20:47:32 +01:00
|
|
|
if (d->background->hasElement("overlay")) {
|
2009-01-13 22:46:07 +01:00
|
|
|
QSize overlaySize = d->background->elementSize("overlay");
|
|
|
|
|
2009-02-18 20:47:32 +01:00
|
|
|
//position is in the boundaries overlaySize.width()*2, overlaySize.height()
|
|
|
|
qsrand(id());
|
2009-02-23 23:10:30 +01:00
|
|
|
d->background->d->overlayPos.rx() = - (overlaySize.width() /2) + (overlaySize.width() /4) * (qrand() % (4 + 1));
|
|
|
|
d->background->d->overlayPos.ry() = (- (overlaySize.height() /2) + (overlaySize.height() /4) * (qrand() % (4 + 1)))/2;
|
2009-01-13 22:46:07 +01:00
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
} else if (d->background) {
|
|
|
|
qreal left, top, right, bottom;
|
|
|
|
d->background->getMargins(left, top, right, bottom);
|
|
|
|
|
|
|
|
delete d->background;
|
|
|
|
d->background = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Applet::hasFailedToLaunch() const
|
|
|
|
{
|
|
|
|
return d->failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Applet::configurationRequired() const
|
|
|
|
{
|
2008-11-06 16:52:13 +01:00
|
|
|
return d->needsConfig;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::setConfigurationRequired(bool needsConfig, const QString &reason)
|
|
|
|
{
|
2008-11-06 16:52:13 +01:00
|
|
|
if (d->needsConfig == needsConfig) {
|
2008-11-04 00:08:39 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-06 16:52:13 +01:00
|
|
|
d->needsConfig = needsConfig;
|
2011-11-17 14:40:53 +01:00
|
|
|
d->showConfigurationRequiredMessage(needsConfig, reason);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2009-02-02 20:39:41 +01:00
|
|
|
void Applet::showMessage(const QIcon &icon, const QString &message, const MessageButtons buttons)
|
|
|
|
{
|
2011-11-17 14:40:53 +01:00
|
|
|
d->showMessage(icon, message, buttons);
|
2009-02-02 20:39:41 +01:00
|
|
|
}
|
|
|
|
|
2009-02-08 16:24:56 +01:00
|
|
|
QVariantList Applet::startupArguments() const
|
|
|
|
{
|
|
|
|
return d->args;
|
|
|
|
}
|
|
|
|
|
2009-07-09 19:19:00 +02:00
|
|
|
ItemStatus Applet::status() const
|
|
|
|
{
|
|
|
|
return d->itemStatus;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::setStatus(const ItemStatus status)
|
|
|
|
{
|
|
|
|
d->itemStatus = status;
|
|
|
|
emit newStatus(status);
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
void Applet::flushPendingConstraintsEvents()
|
|
|
|
{
|
|
|
|
if (d->pendingConstraints == NoConstraint) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-11-18 03:21:43 +01:00
|
|
|
if (d->constraintsTimer.isActive()) {
|
|
|
|
d->constraintsTimer.stop();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//kDebug() << "fushing constraints: " << d->pendingConstraints << "!!!!!!!!!!!!!!!!!!!!!!!!!!!";
|
|
|
|
Plasma::Constraints c = d->pendingConstraints;
|
|
|
|
d->pendingConstraints = NoConstraint;
|
|
|
|
|
|
|
|
if (c & Plasma::StartupCompletedConstraint) {
|
|
|
|
//common actions
|
|
|
|
bool unlocked = immutability() == Mutable;
|
2009-05-03 22:22:14 +02:00
|
|
|
QAction *closeApplet = d->actions->action("remove");
|
|
|
|
if (closeApplet) {
|
|
|
|
closeApplet->setEnabled(unlocked);
|
|
|
|
closeApplet->setVisible(unlocked);
|
2010-03-09 06:11:37 +01:00
|
|
|
connect(closeApplet, SIGNAL(triggered(bool)), this, SLOT(selectItemToDestroy()), Qt::UniqueConnection);
|
2009-05-03 22:22:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
QAction *configAction = d->actions->action("configure");
|
2010-03-09 06:15:13 +01:00
|
|
|
if (configAction) {
|
2009-05-03 22:22:14 +02:00
|
|
|
if (d->isContainment) {
|
2010-03-09 06:11:37 +01:00
|
|
|
connect(configAction, SIGNAL(triggered(bool)), this, SLOT(requestConfiguration()), Qt::UniqueConnection);
|
2009-05-03 22:22:14 +02:00
|
|
|
} else {
|
2010-03-09 06:11:37 +01:00
|
|
|
connect(configAction, SIGNAL(triggered(bool)), this, SLOT(showConfigurationInterface()), Qt::UniqueConnection);
|
2009-05-03 22:22:14 +02:00
|
|
|
}
|
2009-07-30 20:13:01 +02:00
|
|
|
|
2010-09-05 10:03:27 +02:00
|
|
|
if (d->hasConfigurationInterface) {
|
2010-03-09 06:15:13 +01:00
|
|
|
bool canConfig = unlocked || KAuthorized::authorize("plasma/allow_configure_when_locked");
|
|
|
|
configAction->setVisible(canConfig);
|
|
|
|
configAction->setEnabled(canConfig);
|
|
|
|
}
|
2009-05-03 22:22:14 +02:00
|
|
|
}
|
|
|
|
|
2009-09-16 19:08:45 +02:00
|
|
|
QAction *runAssociatedApplication = d->actions->action("run associated application");
|
|
|
|
if (runAssociatedApplication) {
|
2010-03-09 06:11:37 +01:00
|
|
|
connect(runAssociatedApplication, SIGNAL(triggered(bool)), this, SLOT(runAssociatedApplication()), Qt::UniqueConnection);
|
2009-09-16 19:08:45 +02:00
|
|
|
}
|
|
|
|
|
2009-05-03 22:22:14 +02:00
|
|
|
d->updateShortcuts();
|
2012-09-24 17:18:55 +02:00
|
|
|
Containment *cont = containment();
|
|
|
|
Corona *corona = 0;
|
|
|
|
if (cont) {
|
|
|
|
corona = cont->corona();
|
|
|
|
}
|
2009-05-03 22:22:14 +02:00
|
|
|
if (corona) {
|
2010-03-09 06:11:37 +01:00
|
|
|
connect(corona, SIGNAL(shortcutsChanged()), this, SLOT(updateShortcuts()), Qt::UniqueConnection);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c & Plasma::ImmutableConstraint) {
|
|
|
|
bool unlocked = immutability() == Mutable;
|
2009-05-03 22:22:14 +02:00
|
|
|
QAction *action = d->actions->action("remove");
|
2008-11-04 00:08:39 +01:00
|
|
|
if (action) {
|
|
|
|
action->setVisible(unlocked);
|
|
|
|
action->setEnabled(unlocked);
|
|
|
|
}
|
2009-01-16 01:39:07 +01:00
|
|
|
|
2009-05-03 22:22:14 +02:00
|
|
|
action = d->actions->action("configure");
|
2010-09-05 10:03:27 +02:00
|
|
|
if (action && d->hasConfigurationInterface) {
|
2010-01-21 07:00:24 +01:00
|
|
|
bool canConfig = unlocked || KAuthorized::authorize("plasma/allow_configure_when_locked");
|
2009-02-08 19:31:43 +01:00
|
|
|
action->setVisible(canConfig);
|
|
|
|
action->setEnabled(canConfig);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
2010-04-07 04:04:52 +02:00
|
|
|
|
2011-05-28 00:22:17 +02:00
|
|
|
if (!unlocked && d->handle) {
|
|
|
|
AppletHandle *h = d->handle.data();
|
|
|
|
disconnect(this);
|
|
|
|
|
|
|
|
h->deleteLater();
|
|
|
|
}
|
|
|
|
|
2009-08-18 00:30:46 +02:00
|
|
|
emit immutabilityChanged(immutability());
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2008-12-15 19:29:45 +01:00
|
|
|
if (c & Plasma::SizeConstraint) {
|
2009-08-24 19:27:24 +02:00
|
|
|
d->positionMessageOverlay();
|
2008-11-04 19:22:55 +01:00
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
if (c & Plasma::FormFactorConstraint) {
|
|
|
|
FormFactor f = formFactor();
|
2009-01-22 01:00:16 +01:00
|
|
|
if (!d->isContainment && f != Vertical && f != Horizontal) {
|
2009-07-27 22:14:38 +02:00
|
|
|
setBackgroundHints(d->preferredBackgroundHints);
|
|
|
|
} else {
|
|
|
|
BackgroundHints hints = d->preferredBackgroundHints;
|
|
|
|
setBackgroundHints(NoBackground);
|
|
|
|
d->preferredBackgroundHints = hints;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2010-05-17 14:40:37 +02:00
|
|
|
// avoid putting rotated applets in panels
|
|
|
|
if (f == Vertical || f == Horizontal) {
|
|
|
|
QTransform at;
|
|
|
|
at.rotateRadians(0);
|
|
|
|
setTransform(at);
|
|
|
|
}
|
2010-06-16 14:26:23 +02:00
|
|
|
|
|
|
|
//was a size saved for a particular form factor?
|
|
|
|
if (d->sizeForFormFactor.contains(f)) {
|
|
|
|
resize(d->sizeForFormFactor.value(f));
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
2010-06-16 14:26:23 +02:00
|
|
|
|
2010-08-27 21:27:19 +02:00
|
|
|
if (!size().isEmpty() &&
|
|
|
|
((c & Plasma::StartupCompletedConstraint) || (c & Plasma::SizeConstraint && !(c & Plasma::FormFactorConstraint)))) {
|
2010-06-16 14:26:23 +02:00
|
|
|
d->sizeForFormFactor[formFactor()] = size();
|
|
|
|
}
|
|
|
|
|
2008-12-15 19:29:45 +01:00
|
|
|
if (c & Plasma::SizeConstraint || c & Plasma::FormFactorConstraint) {
|
2009-01-22 17:49:45 +01:00
|
|
|
if (aspectRatioMode() == Plasma::Square || aspectRatioMode() == Plasma::ConstrainedSquare) {
|
2008-12-15 19:29:45 +01:00
|
|
|
// enforce square size in panels
|
2010-04-21 14:16:06 +02:00
|
|
|
//save the old size policy. since ignored doesn't (yet) have a valid use case in containments, use it as special unset value
|
|
|
|
if (d->preferredSizePolicy == QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored)) {
|
|
|
|
d->preferredSizePolicy = sizePolicy();
|
|
|
|
}
|
2008-12-15 19:29:45 +01:00
|
|
|
if (formFactor() == Horizontal) {
|
|
|
|
setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding));
|
|
|
|
} else if (formFactor() == Vertical) {
|
|
|
|
setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
|
2010-04-21 14:16:06 +02:00
|
|
|
} else if (d->preferredSizePolicy != QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored)) {
|
|
|
|
setSizePolicy(d->preferredSizePolicy);
|
2008-12-15 19:29:45 +01:00
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-15 19:29:45 +01:00
|
|
|
// now take care of constraints in special subclasses: Contaiment and PopupApplet
|
2008-11-04 00:08:39 +01:00
|
|
|
Containment* containment = qobject_cast<Plasma::Containment*>(this);
|
2009-01-22 01:00:16 +01:00
|
|
|
if (d->isContainment && containment) {
|
2008-11-04 00:08:39 +01:00
|
|
|
containment->d->containmentConstraintsEvent(c);
|
|
|
|
}
|
|
|
|
|
|
|
|
PopupApplet* popup = qobject_cast<Plasma::PopupApplet*>(this);
|
|
|
|
if (popup) {
|
|
|
|
popup->d->popupConstraintsEvent(c);
|
|
|
|
}
|
|
|
|
|
2008-12-15 19:29:45 +01:00
|
|
|
// pass the constraint on to the actual subclass
|
2008-11-04 00:08:39 +01:00
|
|
|
constraintsEvent(c);
|
|
|
|
|
2008-12-15 18:41:37 +01:00
|
|
|
if (c & StartupCompletedConstraint) {
|
|
|
|
// start up is done, we can now go do a mod timer
|
2009-11-18 03:21:43 +01:00
|
|
|
if (d->modificationsTimer) {
|
|
|
|
if (d->modificationsTimer->isActive()) {
|
|
|
|
d->modificationsTimer->stop();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
d->modificationsTimer = new QBasicTimer;
|
2008-12-15 18:41:37 +01:00
|
|
|
}
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int Applet::type() const
|
|
|
|
{
|
|
|
|
return Type;
|
|
|
|
}
|
|
|
|
|
|
|
|
QList<QAction*> Applet::contextualActions()
|
|
|
|
{
|
|
|
|
//kDebug() << "empty context actions";
|
|
|
|
return d->script ? d->script->contextualActions() : QList<QAction*>();
|
|
|
|
}
|
|
|
|
|
|
|
|
QAction *Applet::action(QString name) const
|
|
|
|
{
|
2009-05-03 22:22:14 +02:00
|
|
|
return d->actions->action(name);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::addAction(QString name, QAction *action)
|
|
|
|
{
|
2009-05-03 22:22:14 +02:00
|
|
|
d->actions->addAction(name, action);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
|
|
|
|
{
|
2008-11-17 02:27:14 +01:00
|
|
|
if (!d->started) {
|
2009-01-22 01:00:16 +01:00
|
|
|
//kDebug() << "not started";
|
2008-11-17 02:27:14 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
if (transform().isRotating()) {
|
2008-11-28 23:39:29 +01:00
|
|
|
painter->setRenderHint(QPainter::SmoothPixmapTransform);
|
|
|
|
painter->setRenderHint(QPainter::Antialiasing);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (d->background &&
|
|
|
|
formFactor() != Plasma::Vertical &&
|
|
|
|
formFactor() != Plasma::Horizontal) {
|
|
|
|
//kDebug() << "option rect is" << option->rect;
|
2008-11-28 23:39:29 +01:00
|
|
|
d->background->paintFrame(painter);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2008-11-28 23:39:29 +01:00
|
|
|
if (d->failed) {
|
2009-01-22 01:00:16 +01:00
|
|
|
//kDebug() << "failed!";
|
2008-11-28 23:39:29 +01:00
|
|
|
return;
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2009-01-22 01:00:16 +01:00
|
|
|
if (widget && d->isContainment) {
|
2008-11-28 23:39:29 +01:00
|
|
|
// note that the widget we get is actually the viewport of the view, not the view itself
|
|
|
|
View* v = qobject_cast<Plasma::View*>(widget->parent());
|
|
|
|
Containment* c = qobject_cast<Plasma::Containment*>(this);
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2008-11-28 23:39:29 +01:00
|
|
|
if (!v || v->isWallpaperEnabled()) {
|
|
|
|
|
|
|
|
// paint the wallpaper
|
|
|
|
if (c && c->drawWallpaper() && c->wallpaper()) {
|
|
|
|
Wallpaper *w = c->wallpaper();
|
|
|
|
if (!w->isInitialized()) {
|
|
|
|
// delayed paper initialization
|
|
|
|
KConfigGroup wallpaperConfig = c->config();
|
|
|
|
wallpaperConfig = KConfigGroup(&wallpaperConfig, "Wallpaper");
|
|
|
|
wallpaperConfig = KConfigGroup(&wallpaperConfig, w->pluginName());
|
|
|
|
w->restore(wallpaperConfig);
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2008-11-28 23:39:29 +01:00
|
|
|
painter->save();
|
|
|
|
c->wallpaper()->paint(painter, option->exposedRect);
|
|
|
|
painter->restore();
|
|
|
|
}
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
FormFactor Applet::formFactor() const
|
|
|
|
{
|
|
|
|
Containment *c = containment();
|
2012-09-24 14:30:42 +02:00
|
|
|
QObject *pw = qobject_cast<QObject *>(parent());
|
2010-04-14 14:05:15 +02:00
|
|
|
Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(pw);
|
|
|
|
//assumption: this loop is usually is -really- short or doesn't run at all
|
2012-09-24 17:18:55 +02:00
|
|
|
while (!parentApplet && pw && pw->parent()) {
|
|
|
|
pw = pw->parent();
|
2010-04-14 14:05:15 +02:00
|
|
|
parentApplet = qobject_cast<Plasma::Applet *>(pw);
|
|
|
|
}
|
2009-08-08 13:34:49 +02:00
|
|
|
|
|
|
|
|
2010-04-11 23:05:55 +02:00
|
|
|
const PopupApplet *pa = dynamic_cast<const PopupApplet *>(this);
|
|
|
|
|
2009-08-08 13:34:49 +02:00
|
|
|
//if the applet is in a widget that isn't a containment
|
|
|
|
//try to retrieve the formFactor from the parent size
|
2010-04-11 23:05:55 +02:00
|
|
|
//we can't use our own sizeHint here because it needs formFactor, so endless recursion.
|
|
|
|
// a popupapplet can always be constrained.
|
|
|
|
// a normal applet should to but
|
|
|
|
//FIXME: not always constrained to not break systemmonitor
|
2012-09-24 17:18:55 +02:00
|
|
|
if (parentApplet && parentApplet != c && c != this) {
|
|
|
|
if (pa || (parentApplet->size().height() < sizeHint(Qt::MinimumSize).height())) {
|
2009-08-08 13:34:49 +02:00
|
|
|
return Plasma::Horizontal;
|
2012-09-24 17:18:55 +02:00
|
|
|
} else if (pa || (parentApplet->size().width() < sizeHint(Qt::MinimumSize).width())) {
|
2010-04-11 23:05:55 +02:00
|
|
|
return Plasma::Vertical;
|
|
|
|
}
|
2010-04-14 14:05:15 +02:00
|
|
|
return parentApplet->formFactor();
|
2009-08-08 13:34:49 +02:00
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
return c ? c->d->formFactor : Plasma::Planar;
|
|
|
|
}
|
|
|
|
|
|
|
|
Containment *Applet::containment() const
|
|
|
|
{
|
2009-01-22 01:00:16 +01:00
|
|
|
if (d->isContainment) {
|
2008-12-18 23:14:06 +01:00
|
|
|
Containment *c = qobject_cast<Containment*>(const_cast<Applet*>(this));
|
2008-11-04 00:08:39 +01:00
|
|
|
if (c) {
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-24 17:18:55 +02:00
|
|
|
QObject *parent = this->parent();
|
2008-11-04 00:08:39 +01:00
|
|
|
Containment *c = 0;
|
|
|
|
|
|
|
|
while (parent) {
|
|
|
|
Containment *possibleC = dynamic_cast<Containment*>(parent);
|
2009-01-22 01:00:16 +01:00
|
|
|
if (possibleC && possibleC->Applet::d->isContainment) {
|
2008-11-04 00:08:39 +01:00
|
|
|
c = possibleC;
|
|
|
|
break;
|
|
|
|
}
|
2012-09-24 17:18:55 +02:00
|
|
|
parent = parent->parent();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2010-12-16 21:08:16 +01:00
|
|
|
if (!c) {
|
|
|
|
//if the applet is an offscreen widget its parentItem will be 0, while its parent
|
|
|
|
//will be its parentWidget, so here we check the QObject hierarchy.
|
|
|
|
QObject *objParent = this->parent();
|
|
|
|
while (objParent) {
|
|
|
|
Containment *possibleC = qobject_cast<Containment*>(objParent);
|
|
|
|
if (possibleC && possibleC->Applet::d->isContainment) {
|
|
|
|
c = possibleC;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
objParent = objParent->parent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::setGlobalShortcut(const KShortcut &shortcut)
|
|
|
|
{
|
|
|
|
if (!d->activationAction) {
|
|
|
|
d->activationAction = new KAction(this);
|
|
|
|
d->activationAction->setText(i18n("Activate %1 Widget", name()));
|
|
|
|
d->activationAction->setObjectName(QString("activate widget %1").arg(id())); // NO I18N
|
|
|
|
connect(d->activationAction, SIGNAL(triggered()), this, SIGNAL(activate()));
|
2010-05-07 22:57:03 +02:00
|
|
|
connect(d->activationAction, SIGNAL(globalShortcutChanged(QKeySequence)),
|
|
|
|
this, SLOT(globalShortcutChanged()));
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2009-05-03 22:22:14 +02:00
|
|
|
QList<QWidget *> widgets = d->actions->associatedWidgets();
|
2008-11-04 00:08:39 +01:00
|
|
|
foreach (QWidget *w, widgets) {
|
|
|
|
w->addAction(d->activationAction);
|
|
|
|
}
|
2011-12-06 17:37:54 +01:00
|
|
|
} else if (d->activationAction->globalShortcut() == shortcut) {
|
|
|
|
return;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//kDebug() << "before" << shortcut.primary() << d->activationAction->globalShortcut().primary();
|
|
|
|
d->activationAction->setGlobalShortcut(
|
|
|
|
shortcut,
|
|
|
|
KAction::ShortcutTypes(KAction::ActiveShortcut | KAction::DefaultShortcut),
|
|
|
|
KAction::NoAutoloading);
|
2010-05-07 22:57:03 +02:00
|
|
|
d->globalShortcutChanged();
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
KShortcut Applet::globalShortcut() const
|
|
|
|
{
|
|
|
|
if (d->activationAction) {
|
|
|
|
return d->activationAction->globalShortcut();
|
|
|
|
}
|
|
|
|
|
|
|
|
return KShortcut();
|
|
|
|
}
|
|
|
|
|
2008-12-29 07:03:43 +01:00
|
|
|
bool Applet::isPopupShowing() const
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
void Applet::addAssociatedWidget(QWidget *widget)
|
|
|
|
{
|
2009-05-03 22:22:14 +02:00
|
|
|
d->actions->addAssociatedWidget(widget);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::removeAssociatedWidget(QWidget *widget)
|
|
|
|
{
|
2009-05-03 22:22:14 +02:00
|
|
|
d->actions->removeAssociatedWidget(widget);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Location Applet::location() const
|
|
|
|
{
|
|
|
|
Containment *c = containment();
|
|
|
|
return c ? c->d->location : Plasma::Desktop;
|
|
|
|
}
|
|
|
|
|
|
|
|
Plasma::AspectRatioMode Applet::aspectRatioMode() const
|
|
|
|
{
|
|
|
|
return d->aspectRatioMode;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::setAspectRatioMode(Plasma::AspectRatioMode mode)
|
|
|
|
{
|
2009-11-18 21:11:03 +01:00
|
|
|
PopupApplet *popup = qobject_cast<PopupApplet *>(this);
|
|
|
|
if (popup && popup->d->dialogPtr) {
|
|
|
|
popup->d->dialogPtr.data()->setAspectRatioMode(mode);
|
2009-11-18 21:18:32 +01:00
|
|
|
popup->d->savedAspectRatio = mode;
|
2009-11-18 21:11:03 +01:00
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
d->aspectRatioMode = mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Applet::hasConfigurationInterface() const
|
|
|
|
{
|
|
|
|
return d->hasConfigurationInterface;
|
|
|
|
}
|
|
|
|
|
2009-09-04 02:08:26 +02:00
|
|
|
void Applet::publish(AnnouncementMethods methods, const QString &resourceName)
|
2009-09-02 04:27:16 +02:00
|
|
|
{
|
2011-08-17 13:08:56 +02:00
|
|
|
if (!d->remotingService) {
|
|
|
|
d->remotingService = new PlasmoidService(this);
|
2011-07-13 20:04:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const QString resName = resourceName.isEmpty() ? i18nc("%1 is the name of a plasmoid, %2 the name of the machine that plasmoid is published on",
|
|
|
|
"%1 on %2", name(), QHostInfo::localHostName())
|
|
|
|
: resourceName;
|
2011-07-29 15:46:52 +02:00
|
|
|
#ifndef NDEBUG
|
2011-07-13 20:04:13 +02:00
|
|
|
kDebug() << "publishing package under name " << resName;
|
2011-07-29 15:46:52 +02:00
|
|
|
#endif
|
2011-07-13 20:04:13 +02:00
|
|
|
if (d->package && d->package->isValid()) {
|
2011-08-17 13:08:56 +02:00
|
|
|
d->remotingService->d->publish(methods, resName, d->package->metadata());
|
2011-07-13 20:04:13 +02:00
|
|
|
} else if (!d->package && d->appletDescription.isValid()) {
|
2011-08-17 13:08:56 +02:00
|
|
|
d->remotingService->d->publish(methods, resName, d->appletDescription);
|
2010-10-04 23:10:48 +02:00
|
|
|
} else {
|
2011-08-17 13:08:56 +02:00
|
|
|
delete d->remotingService;
|
|
|
|
d->remotingService = 0;
|
2011-07-29 15:46:52 +02:00
|
|
|
#ifndef NDEBUG
|
2010-10-04 23:10:48 +02:00
|
|
|
kDebug() << "Can not publish invalid applets.";
|
2011-07-29 15:46:52 +02:00
|
|
|
#endif
|
2009-09-03 01:49:46 +02:00
|
|
|
}
|
2009-09-02 04:27:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::unpublish()
|
|
|
|
{
|
2011-08-17 13:08:56 +02:00
|
|
|
if (d->remotingService) {
|
|
|
|
d->remotingService->d->unpublish();
|
2009-09-02 04:27:16 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Applet::isPublished() const
|
|
|
|
{
|
2011-08-17 13:08:56 +02:00
|
|
|
return d->remotingService && d->remotingService->d->isPublished();
|
2009-09-02 04:27:16 +02:00
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
void Applet::setHasConfigurationInterface(bool hasInterface)
|
|
|
|
{
|
2010-03-06 02:10:53 +01:00
|
|
|
if (hasInterface == d->hasConfigurationInterface) {
|
2008-11-04 00:08:39 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-03-06 02:10:53 +01:00
|
|
|
QAction *configAction = d->actions->action("configure");
|
|
|
|
if (configAction) {
|
|
|
|
bool enable = hasInterface;
|
|
|
|
if (enable) {
|
|
|
|
const bool unlocked = immutability() == Mutable;
|
|
|
|
enable = unlocked || KAuthorized::authorize("plasma/allow_configure_when_locked");
|
|
|
|
}
|
|
|
|
configAction->setEnabled(enable);
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
d->hasConfigurationInterface = hasInterface;
|
|
|
|
}
|
|
|
|
|
2010-01-29 22:21:16 +01:00
|
|
|
bool Applet::isUserConfiguring() const
|
|
|
|
{
|
|
|
|
return KConfigDialog::exists(d->configDialogId());
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
void Applet::showConfigurationInterface()
|
|
|
|
{
|
|
|
|
if (!hasConfigurationInterface()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-01-21 07:00:24 +01:00
|
|
|
if (immutability() != Mutable && !KAuthorized::authorize("plasma/allow_configure_when_locked")) {
|
2008-11-04 00:08:39 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-01-20 03:11:01 +01:00
|
|
|
KConfigDialog *dlg = KConfigDialog::exists(d->configDialogId());
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
if (dlg) {
|
|
|
|
KWindowSystem::setOnDesktop(dlg->winId(), KWindowSystem::currentDesktop());
|
|
|
|
dlg->show();
|
|
|
|
KWindowSystem::activateWindow(dlg->winId());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-02-16 07:46:39 +01:00
|
|
|
d->publishUI.publishCheckbox = 0;
|
2011-11-02 17:24:25 +01:00
|
|
|
if (d->package) {
|
2010-02-03 18:37:54 +01:00
|
|
|
KConfigDialog *dialog = 0;
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2011-10-31 17:54:39 +01:00
|
|
|
const QString uiFile = d->package->filePath("mainconfigui");
|
2011-11-01 20:33:13 +01:00
|
|
|
KDesktopFile df(d->package->path() + "/metadata.desktop");
|
2011-10-31 17:54:39 +01:00
|
|
|
const QStringList kcmPlugins = df.desktopGroup().readEntry("X-Plasma-ConfigPlugins", QStringList());
|
|
|
|
if (!uiFile.isEmpty() || !kcmPlugins.isEmpty()) {
|
2011-11-02 17:24:25 +01:00
|
|
|
KConfigSkeleton *configLoader = d->configLoader ? d->configLoader : new KConfigSkeleton(0);
|
|
|
|
dialog = new AppletConfigDialog(0, d->configDialogId(), configLoader);
|
|
|
|
|
2011-12-01 17:12:11 +01:00
|
|
|
if (!d->configLoader) {
|
|
|
|
// delete the temporary when this dialog is done
|
|
|
|
configLoader->setParent(dialog);
|
|
|
|
}
|
|
|
|
|
2011-10-31 17:54:39 +01:00
|
|
|
dialog->setWindowTitle(d->configWindowTitle());
|
|
|
|
dialog->setAttribute(Qt::WA_DeleteOnClose, true);
|
|
|
|
bool hasPages = false;
|
|
|
|
|
2009-05-26 20:04:02 +02:00
|
|
|
QFile f(uiFile);
|
2010-02-03 17:18:37 +01:00
|
|
|
QUiLoader loader;
|
|
|
|
QWidget *w = loader.load(&f);
|
2010-02-03 18:37:54 +01:00
|
|
|
if (w) {
|
|
|
|
dialog->addPage(w, i18n("Settings"), icon(), i18n("%1 Settings", name()));
|
2011-10-31 17:54:39 +01:00
|
|
|
hasPages = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (const QString &kcm, kcmPlugins) {
|
2012-08-24 03:16:04 +02:00
|
|
|
#if !PLASMA_NO_KUTILS
|
2011-10-31 17:54:39 +01:00
|
|
|
KCModuleProxy *module = new KCModuleProxy(kcm);
|
|
|
|
if (module->realModule()) {
|
2012-06-19 20:05:06 +02:00
|
|
|
//preemptively load modules to prevent save() crashing on some kcms, like powerdevil ones
|
|
|
|
module->load();
|
2011-12-06 17:36:39 +01:00
|
|
|
connect(module, SIGNAL(changed(bool)), dialog, SLOT(settingsModified(bool)));
|
2012-06-07 12:50:05 +02:00
|
|
|
connect(dialog, SIGNAL(okClicked()),
|
|
|
|
module->realModule(), SLOT(save()));
|
|
|
|
connect(dialog, SIGNAL(applyClicked()),
|
|
|
|
module->realModule(), SLOT(save()));
|
2011-10-31 17:54:39 +01:00
|
|
|
dialog->addPage(module, module->moduleInfo().moduleName(), module->moduleInfo().icon());
|
|
|
|
hasPages = true;
|
|
|
|
} else {
|
|
|
|
delete module;
|
|
|
|
}
|
2011-11-02 17:24:25 +01:00
|
|
|
#else
|
|
|
|
KService::Ptr service = KService::serviceByStorageId(kcm);
|
|
|
|
if (service) {
|
|
|
|
QString error;
|
|
|
|
KCModule *module = service->createInstance<KCModule>(dialog, QVariantList(), &error);
|
|
|
|
if (module) {
|
2012-06-19 20:05:06 +02:00
|
|
|
module->load();
|
2011-11-02 17:24:25 +01:00
|
|
|
connect(module, SIGNAL(changed(bool)), dialog, SLOT(settingsModified(bool)));
|
2012-06-07 12:50:05 +02:00
|
|
|
connect(dialog, SIGNAL(okClicked()),
|
|
|
|
module, SLOT(save()));
|
|
|
|
connect(dialog, SIGNAL(applyClicked()),
|
|
|
|
module, SLOT(save()));
|
2011-11-02 17:24:25 +01:00
|
|
|
dialog->addPage(module, service->name(), service->icon());
|
|
|
|
hasPages = true;
|
|
|
|
} else {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
kDebug() << "failed to load kcm" << kcm << "for" << name();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2011-10-31 17:54:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (hasPages) {
|
2010-02-03 18:37:54 +01:00
|
|
|
d->addGlobalShortcutsPage(dialog);
|
|
|
|
d->addPublishPage(dialog);
|
|
|
|
dialog->show();
|
2011-10-31 17:54:39 +01:00
|
|
|
} else {
|
|
|
|
delete dialog;
|
|
|
|
dialog = 0;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
2009-05-26 20:04:02 +02:00
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2010-02-03 18:37:54 +01:00
|
|
|
if (!dialog && d->script) {
|
|
|
|
d->script->showConfigurationInterface();
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
} else if (d->script) {
|
|
|
|
d->script->showConfigurationInterface();
|
|
|
|
} else {
|
2009-08-20 21:05:14 +02:00
|
|
|
KConfigDialog *dialog = d->generateGenericConfigDialog();
|
2009-10-23 15:48:29 +02:00
|
|
|
d->addStandardConfigurationPages(dialog);
|
2010-04-03 21:10:32 +02:00
|
|
|
showConfigurationInterface(dialog);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
emit releaseVisualFocus();
|
|
|
|
}
|
|
|
|
|
2010-04-03 21:10:32 +02:00
|
|
|
void Applet::showConfigurationInterface(QWidget *widget)
|
|
|
|
{
|
|
|
|
if (!containment() || !containment()->corona() ||
|
|
|
|
!containment()->corona()->dialogManager()) {
|
|
|
|
widget->show();
|
|
|
|
return;
|
|
|
|
}
|
2010-04-03 23:58:35 +02:00
|
|
|
|
|
|
|
QMetaObject::invokeMethod(containment()->corona()->dialogManager(), "showDialog", Q_ARG(QWidget *, widget), Q_ARG(Plasma::Applet *, this));
|
2010-04-03 21:10:32 +02:00
|
|
|
}
|
|
|
|
|
2011-04-25 16:43:15 +02:00
|
|
|
void Applet::configChanged()
|
|
|
|
{
|
2011-12-05 00:16:53 +01:00
|
|
|
if (d->script) {
|
|
|
|
if (d->configLoader) {
|
|
|
|
d->configLoader->readConfig();
|
|
|
|
}
|
|
|
|
d->script->configChanged();
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::createConfigurationInterface(KConfigDialog *parent)
|
|
|
|
{
|
|
|
|
Q_UNUSED(parent)
|
|
|
|
// virtual method reimplemented by subclasses.
|
|
|
|
// do not put anything here ...
|
|
|
|
}
|
|
|
|
|
2009-06-03 03:10:57 +02:00
|
|
|
bool Applet::hasAuthorization(const QString &constraint) const
|
2009-03-04 18:05:51 +01:00
|
|
|
{
|
2012-03-24 19:33:54 +01:00
|
|
|
KConfigGroup constraintGroup(KSharedConfig::openConfig(), "Constraints");
|
2009-03-04 18:05:51 +01:00
|
|
|
return constraintGroup.readEntry(constraint, true);
|
|
|
|
}
|
|
|
|
|
2009-09-16 19:08:45 +02:00
|
|
|
void Applet::setAssociatedApplication(const QString &string)
|
|
|
|
{
|
|
|
|
AssociatedApplicationManager::self()->setApplication(this, string);
|
|
|
|
|
|
|
|
QAction *runAssociatedApplication = d->actions->action("run associated application");
|
|
|
|
if (runAssociatedApplication) {
|
|
|
|
bool valid = AssociatedApplicationManager::self()->appletHasValidAssociatedApplication(this);
|
2010-01-27 21:34:55 +01:00
|
|
|
valid = valid && hasAuthorization("LaunchApp"); //obey security!
|
2009-09-16 19:08:45 +02:00
|
|
|
runAssociatedApplication->setVisible(valid);
|
|
|
|
runAssociatedApplication->setEnabled(valid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-15 22:28:17 +02:00
|
|
|
void Applet::setAssociatedApplicationUrls(const QList<QUrl> &urls)
|
2009-09-16 19:08:45 +02:00
|
|
|
{
|
|
|
|
AssociatedApplicationManager::self()->setUrls(this, urls);
|
|
|
|
|
|
|
|
QAction *runAssociatedApplication = d->actions->action("run associated application");
|
|
|
|
if (runAssociatedApplication) {
|
|
|
|
bool valid = AssociatedApplicationManager::self()->appletHasValidAssociatedApplication(this);
|
2010-01-27 21:34:55 +01:00
|
|
|
valid = valid && hasAuthorization("LaunchApp"); //obey security!
|
2009-09-16 19:08:45 +02:00
|
|
|
runAssociatedApplication->setVisible(valid);
|
|
|
|
runAssociatedApplication->setEnabled(valid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Applet::associatedApplication() const
|
|
|
|
{
|
|
|
|
return AssociatedApplicationManager::self()->application(this);
|
|
|
|
}
|
|
|
|
|
2012-07-15 22:28:17 +02:00
|
|
|
QList<QUrl> Applet::associatedApplicationUrls() const
|
2009-09-16 19:08:45 +02:00
|
|
|
{
|
|
|
|
return AssociatedApplicationManager::self()->urls(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::runAssociatedApplication()
|
|
|
|
{
|
2010-01-27 21:34:55 +01:00
|
|
|
if (hasAuthorization("LaunchApp")) {
|
|
|
|
AssociatedApplicationManager::self()->run(this);
|
|
|
|
}
|
2009-09-16 19:08:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Applet::hasValidAssociatedApplication() const
|
|
|
|
{
|
|
|
|
return AssociatedApplicationManager::self()->appletHasValidAssociatedApplication(this);
|
|
|
|
}
|
|
|
|
|
2010-04-29 01:34:30 +02:00
|
|
|
KPluginInfo::List Applet::listAppletInfo(const QString &category, const QString &parentApp)
|
|
|
|
{
|
2011-07-19 21:53:03 +02:00
|
|
|
return PluginLoader::self()->listAppletInfo(category, parentApp);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2011-05-06 12:12:47 +02:00
|
|
|
KPluginInfo::List Applet::listAppletInfoForMimeType(const QString &mimeType)
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
2010-04-29 01:34:30 +02:00
|
|
|
QString constraint = AppletPrivate::parentAppConstraint();
|
2011-05-06 12:12:47 +02:00
|
|
|
constraint.append(QString(" and '%1' in [X-Plasma-DropMimeTypes]").arg(mimeType));
|
|
|
|
//kDebug() << "listAppletInfoForMimetype with" << mimeType << constraint;
|
2008-11-04 00:08:39 +01:00
|
|
|
KService::List offers = KServiceTypeTrader::self()->query("Plasma/Applet", constraint);
|
2009-11-11 01:24:49 +01:00
|
|
|
AppletPrivate::filterOffers(offers);
|
2008-11-04 00:08:39 +01:00
|
|
|
return KPluginInfo::fromServices(offers);
|
|
|
|
}
|
2009-10-29 10:09:01 +01:00
|
|
|
|
|
|
|
KPluginInfo::List Applet::listAppletInfoForUrl(const QUrl &url)
|
|
|
|
{
|
2010-04-29 01:34:30 +02:00
|
|
|
QString constraint = AppletPrivate::parentAppConstraint();
|
|
|
|
constraint.append(" and exist [X-Plasma-DropUrlPatterns]");
|
2009-10-29 10:09:01 +01:00
|
|
|
KService::List offers = KServiceTypeTrader::self()->query("Plasma/Applet", constraint);
|
2009-11-11 01:24:49 +01:00
|
|
|
AppletPrivate::filterOffers(offers);
|
2009-10-29 10:09:01 +01:00
|
|
|
|
|
|
|
KPluginInfo::List allApplets = KPluginInfo::fromServices(offers);
|
|
|
|
KPluginInfo::List filtered;
|
|
|
|
foreach (const KPluginInfo &info, allApplets) {
|
|
|
|
QStringList urlPatterns = info.property("X-Plasma-DropUrlPatterns").toStringList();
|
|
|
|
foreach (const QString &glob, urlPatterns) {
|
|
|
|
QRegExp rx(glob);
|
|
|
|
rx.setPatternSyntax(QRegExp::Wildcard);
|
|
|
|
if (rx.exactMatch(url.toString())) {
|
2011-07-29 15:46:52 +02:00
|
|
|
#ifndef NDEBUG
|
2009-10-29 10:09:01 +01:00
|
|
|
kDebug() << info.name() << "matches" << glob << url;
|
2011-07-29 15:46:52 +02:00
|
|
|
#endif
|
2009-10-29 10:09:01 +01:00
|
|
|
filtered << info;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-11-11 01:24:49 +01:00
|
|
|
|
2009-10-29 10:09:01 +01:00
|
|
|
return filtered;
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
QStringList Applet::listCategories(const QString &parentApp, bool visibleOnly)
|
|
|
|
{
|
2010-04-29 01:34:30 +02:00
|
|
|
QString constraint = AppletPrivate::parentAppConstraint(parentApp);
|
|
|
|
constraint.append(" and exist [X-KDE-PluginInfo-Category]");
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2012-03-24 19:33:54 +01:00
|
|
|
KConfigGroup group(KSharedConfig::openConfig(), "General");
|
2009-07-06 13:49:01 +02:00
|
|
|
const QStringList excluded = group.readEntry("ExcludeCategories", QStringList());
|
2009-02-14 14:28:25 +01:00
|
|
|
foreach (const QString &category, excluded) {
|
2009-05-01 20:03:13 +02:00
|
|
|
constraint.append(" and [X-KDE-PluginInfo-Category] != '").append(category).append("'");
|
2009-02-14 14:28:25 +01:00
|
|
|
}
|
|
|
|
|
2009-07-26 16:20:31 +02:00
|
|
|
KService::List offers = KServiceTypeTrader::self()->query("Plasma/Applet", constraint);
|
2009-11-11 01:24:49 +01:00
|
|
|
AppletPrivate::filterOffers(offers);
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
QStringList categories;
|
2009-05-01 20:03:13 +02:00
|
|
|
QSet<QString> known = AppletPrivate::knownCategories();
|
2008-11-04 00:08:39 +01:00
|
|
|
foreach (const KService::Ptr &applet, offers) {
|
2009-05-01 20:03:13 +02:00
|
|
|
QString appletCategory = applet->property("X-KDE-PluginInfo-Category").toString();
|
2008-11-04 00:08:39 +01:00
|
|
|
if (visibleOnly && applet->noDisplay()) {
|
|
|
|
// we don't want to show the hidden category
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
//kDebug() << " and we have " << appletCategory;
|
2009-05-01 20:03:13 +02:00
|
|
|
if (!appletCategory.isEmpty() && !known.contains(appletCategory.toLower())) {
|
2011-07-29 15:46:52 +02:00
|
|
|
#ifndef NDEBUG
|
2009-05-01 20:03:13 +02:00
|
|
|
kDebug() << "Unknown category: " << applet->name() << "says it is in the"
|
|
|
|
<< appletCategory << "category which is unknown to us";
|
2011-07-29 15:46:52 +02:00
|
|
|
#endif
|
2009-05-01 20:03:13 +02:00
|
|
|
appletCategory.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (appletCategory.isEmpty()) {
|
2008-11-04 13:54:19 +01:00
|
|
|
if (!categories.contains(i18nc("misc category", "Miscellaneous"))) {
|
|
|
|
categories << i18nc("misc category", "Miscellaneous");
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
2009-05-01 20:03:13 +02:00
|
|
|
} else if (!categories.contains(appletCategory)) {
|
|
|
|
categories << appletCategory;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
categories.sort();
|
|
|
|
return categories;
|
|
|
|
}
|
|
|
|
|
2009-05-18 13:15:00 +02:00
|
|
|
void Applet::setCustomCategories(const QStringList &categories)
|
|
|
|
{
|
|
|
|
AppletPrivate::s_customCategories = QSet<QString>::fromList(categories);
|
|
|
|
}
|
|
|
|
|
|
|
|
QStringList Applet::customCategories()
|
|
|
|
{
|
|
|
|
return AppletPrivate::s_customCategories.toList();
|
|
|
|
}
|
|
|
|
|
2009-04-26 02:43:20 +02:00
|
|
|
Applet *Applet::loadPlasmoid(const QString &path, uint appletId, const QVariantList &args)
|
|
|
|
{
|
|
|
|
if (QFile::exists(path + "/metadata.desktop")) {
|
2009-10-23 15:48:29 +02:00
|
|
|
KService service(path + "/metadata.desktop");
|
2011-05-31 00:04:03 +02:00
|
|
|
const QStringList &types = service.serviceTypes();
|
2009-10-23 15:48:29 +02:00
|
|
|
|
|
|
|
if (types.contains("Plasma/Containment")) {
|
|
|
|
return new Containment(path, appletId, args);
|
|
|
|
} else if (types.contains("Plasma/PopupApplet")) {
|
|
|
|
return new PopupApplet(path, appletId, args);
|
|
|
|
} else {
|
|
|
|
return new Applet(path, appletId, args);
|
|
|
|
}
|
2009-04-26 02:43:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
QSizeF Applet::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
|
|
|
|
{
|
2012-09-24 17:18:55 +02:00
|
|
|
QSizeF hint(-1, -1);
|
2011-03-28 10:05:58 +02:00
|
|
|
const FormFactor ff = formFactor();
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2011-03-28 10:05:58 +02:00
|
|
|
// in panels make sure that the contents won't exit from the panel
|
|
|
|
if (which == Qt::MinimumSize) {
|
|
|
|
if (ff == Horizontal) {
|
|
|
|
hint.setHeight(0);
|
|
|
|
} else if (ff == Vertical) {
|
|
|
|
hint.setWidth(0);
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// enforce a square size in panels
|
|
|
|
if (d->aspectRatioMode == Plasma::Square) {
|
2011-03-28 10:05:58 +02:00
|
|
|
if (ff == Horizontal) {
|
2008-11-04 00:08:39 +01:00
|
|
|
hint.setWidth(size().height());
|
2011-03-28 10:05:58 +02:00
|
|
|
} else if (ff == Vertical) {
|
2008-11-04 00:08:39 +01:00
|
|
|
hint.setHeight(size().width());
|
|
|
|
}
|
|
|
|
} else if (d->aspectRatioMode == Plasma::ConstrainedSquare) {
|
|
|
|
//enforce a size not wider than tall
|
2011-12-02 17:30:59 +01:00
|
|
|
if (ff == Horizontal) {
|
2008-11-04 00:08:39 +01:00
|
|
|
hint.setWidth(size().height());
|
|
|
|
//enforce a size not taller than wide
|
2011-03-28 10:05:58 +02:00
|
|
|
} else if (ff == Vertical && (which == Qt::MaximumSize || size().width() <= KIconLoader::SizeLarge)) {
|
2008-11-04 00:08:39 +01:00
|
|
|
hint.setHeight(size().width());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return hint;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
|
|
|
|
{
|
|
|
|
Q_UNUSED(event)
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
|
|
|
|
{
|
|
|
|
Q_UNUSED(event)
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::timerEvent(QTimerEvent *event)
|
|
|
|
{
|
|
|
|
if (d->transient) {
|
2009-11-18 03:21:43 +01:00
|
|
|
d->constraintsTimer.stop();
|
|
|
|
if (d->modificationsTimer) {
|
|
|
|
d->modificationsTimer->stop();
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-11-18 03:21:43 +01:00
|
|
|
if (event->timerId() == d->constraintsTimer.timerId()) {
|
|
|
|
d->constraintsTimer.stop();
|
2008-11-04 18:51:11 +01:00
|
|
|
|
|
|
|
// Don't flushPendingConstraints if we're just starting up
|
|
|
|
// flushPendingConstraints will be called by Corona
|
|
|
|
if(!(d->pendingConstraints & Plasma::StartupCompletedConstraint)) {
|
|
|
|
flushPendingConstraintsEvents();
|
|
|
|
}
|
2009-11-18 03:21:43 +01:00
|
|
|
} else if (d->modificationsTimer && event->timerId() == d->modificationsTimer->timerId()) {
|
|
|
|
d->modificationsTimer->stop();
|
2008-11-04 00:08:39 +01:00
|
|
|
// invalid group, will result in save using the default group
|
|
|
|
KConfigGroup cg;
|
2009-06-30 15:32:40 +02:00
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
save(cg);
|
|
|
|
emit configNeedsSaving();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QRect Applet::screenRect() const
|
|
|
|
{
|
2012-09-24 17:18:55 +02:00
|
|
|
//TODO: port away QGV
|
|
|
|
/*
|
2008-11-04 00:08:39 +01:00
|
|
|
QGraphicsView *v = view();
|
|
|
|
|
|
|
|
if (v) {
|
|
|
|
QPointF bottomRight = pos();
|
|
|
|
bottomRight.rx() += size().width();
|
|
|
|
bottomRight.ry() += size().height();
|
|
|
|
|
|
|
|
QPoint tL = v->mapToGlobal(v->mapFromScene(pos()));
|
|
|
|
QPoint bR = v->mapToGlobal(v->mapFromScene(bottomRight));
|
|
|
|
return QRect(QPoint(tL.x(), tL.y()), QSize(bR.x() - tL.x(), bR.y() - tL.y()));
|
2012-09-24 17:18:55 +02:00
|
|
|
}*/
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
//The applet doesn't have a view on it.
|
|
|
|
//So a screenRect isn't relevant.
|
|
|
|
return QRect(QPoint(0, 0), QSize(0, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::raise()
|
|
|
|
{
|
|
|
|
setZValue(++AppletPrivate::s_maxZValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Applet::lower()
|
|
|
|
{
|
|
|
|
setZValue(--AppletPrivate::s_minZValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Applet::isContainment() const
|
|
|
|
{
|
|
|
|
return d->isContainment;
|
|
|
|
}
|
|
|
|
|
|
|
|
// PRIVATE CLASS IMPLEMENTATION
|
|
|
|
|
2009-01-22 01:00:16 +01:00
|
|
|
|
2011-05-28 00:22:17 +02:00
|
|
|
|
|
|
|
void ContainmentPrivate::checkRemoveAction()
|
|
|
|
{
|
|
|
|
q->enableAction("remove", q->immutability() == Mutable);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
} // Plasma namespace
|
|
|
|
|
2012-02-08 23:33:03 +01:00
|
|
|
#include "moc_applet.cpp"
|
|
|
|
#include "private/moc_applet_p.cpp"
|