coronabase, a pure qobject corona
This commit is contained in:
Marco Martin
parent
570585f666
commit
dba549382b
|
|
@ -97,6 +97,7 @@ set(plasma_LIB_SRCS
|
|||
configloader.cpp
|
||||
containmentactions.cpp
|
||||
containmentactionspluginsconfig.cpp
|
||||
coronabase.cpp
|
||||
datacontainer.cpp
|
||||
dataengine.cpp
|
||||
dataenginemanager.cpp
|
||||
|
|
|
|||
2
applet.h
2
applet.h
|
|
@ -1014,6 +1014,8 @@ class PLASMA_EXPORT Applet : public QGraphicsWidget
|
|||
//Corona needs to access setFailedToLaunch and init
|
||||
friend class Corona;
|
||||
friend class CoronaPrivate;
|
||||
friend class CoronaBase;
|
||||
friend class CoronaBasePrivate;
|
||||
friend class Containment;
|
||||
friend class ContainmentPrivate;
|
||||
friend class AppletScript;
|
||||
|
|
|
|||
|
|
@ -624,6 +624,7 @@ Q_SIGNALS:
|
|||
friend class Applet;
|
||||
friend class AppletPrivate;
|
||||
friend class CoronaPrivate;
|
||||
friend class CoronaBasePrivate;
|
||||
friend class ContainmentPrivate;
|
||||
friend class ContainmentActions;
|
||||
friend class PopupApplet;
|
||||
|
|
|
|||
805
coronabase.cpp
Normal file
805
coronabase.cpp
Normal file
|
|
@ -0,0 +1,805 @@
|
|||
/*
|
||||
* Copyright 2007 Matt Broadstone <mbroadst@gmail.com>
|
||||
* Copyright 2007-2011 Aaron Seigo <aseigo@kde.org>
|
||||
* Copyright 2007 Riccardo Iaconelli <riccardo@kde.org>
|
||||
* Copyright (c) 2009 Chani Armitage <chani@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 "coronabase.h"
|
||||
#include "private/coronabase_p.h"
|
||||
|
||||
#include <QApplication>
|
||||
#include <QDesktopWidget>
|
||||
#include <QGraphicsView>
|
||||
#include <QGraphicsGridLayout>
|
||||
#include <QMimeData>
|
||||
#include <QPainter>
|
||||
#include <QTimer>
|
||||
|
||||
#include <cmath>
|
||||
|
||||
#include <kaction.h>
|
||||
#include <kdebug.h>
|
||||
#include <kglobal.h>
|
||||
#include <klocale.h>
|
||||
#include <kmimetype.h>
|
||||
#include <kshortcutsdialog.h>
|
||||
#include <kwindowsystem.h>
|
||||
#include <kicon.h>
|
||||
|
||||
#include "abstractdialogmanager.h"
|
||||
#include "abstracttoolbox.h"
|
||||
#include "containment.h"
|
||||
#include "containmentactionspluginsconfig.h"
|
||||
#include "pluginloader.h"
|
||||
#include "private/applet_p.h"
|
||||
#include "private/containment_p.h"
|
||||
#include "tooltipmanager.h"
|
||||
#include "view.h"
|
||||
|
||||
using namespace Plasma;
|
||||
|
||||
namespace Plasma
|
||||
{
|
||||
|
||||
bool CoronaBasePrivate::s_positioningContainments = false;
|
||||
|
||||
CoronaBase::CoronaBase(QObject *parent)
|
||||
: QObject(parent),
|
||||
d(new CoronaBasePrivate(this))
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
kDebug() << "!!{} STARTUP TIME" << QTime().msecsTo(QTime::currentTime()) << "Corona ctor start";
|
||||
#endif
|
||||
d->init();
|
||||
//setViewport(new QGLWidget(QGLFormat(QGL::StencilBuffer | QGL::AlphaChannel)));
|
||||
}
|
||||
|
||||
CoronaBase::~CoronaBase()
|
||||
{
|
||||
KConfigGroup trans(KGlobal::config(), "PlasmaTransientsConfig");
|
||||
trans.deleteGroup();
|
||||
|
||||
delete d;
|
||||
}
|
||||
|
||||
void CoronaBase::setAppletMimeType(const QString &type)
|
||||
{
|
||||
d->mimetype = type;
|
||||
}
|
||||
|
||||
QString CoronaBase::appletMimeType()
|
||||
{
|
||||
return d->mimetype;
|
||||
}
|
||||
|
||||
void CoronaBase::setDefaultContainmentPlugin(const QString &name)
|
||||
{
|
||||
// we could check if it is in:
|
||||
// Containment::listContainments().contains(name) ||
|
||||
// Containment::listContainments(QString(), KGlobal::mainComponent().componentName()).contains(name)
|
||||
// but that seems like overkill
|
||||
d->defaultContainmentPlugin = name;
|
||||
}
|
||||
|
||||
QString CoronaBase::defaultContainmentPlugin() const
|
||||
{
|
||||
return d->defaultContainmentPlugin;
|
||||
}
|
||||
|
||||
void CoronaBase::saveLayout(const QString &configName) const
|
||||
{
|
||||
KSharedConfigPtr c;
|
||||
|
||||
if (configName.isEmpty() || configName == d->configName) {
|
||||
c = config();
|
||||
} else {
|
||||
c = KSharedConfig::openConfig(configName, KConfig::SimpleConfig);
|
||||
}
|
||||
|
||||
d->saveLayout(c);
|
||||
}
|
||||
|
||||
void CoronaBase::exportLayout(KConfigGroup &config, QList<Containment*> containments)
|
||||
{
|
||||
foreach (const QString &group, config.groupList()) {
|
||||
KConfigGroup cg(&config, group);
|
||||
cg.deleteGroup();
|
||||
}
|
||||
|
||||
//temporarily unlock so that removal works
|
||||
ImmutabilityType oldImm = immutability();
|
||||
d->immutability = Mutable;
|
||||
|
||||
KConfigGroup dest(&config, "Containments");
|
||||
KConfigGroup dummy;
|
||||
foreach (Plasma::Containment *c, containments) {
|
||||
c->save(dummy);
|
||||
c->config().reparent(&dest);
|
||||
|
||||
//ensure the containment is unlocked
|
||||
//this is done directly because we have to bypass any SystemImmutable checks
|
||||
c->Applet::d->immutability = Mutable;
|
||||
foreach (Applet *a, c->applets()) {
|
||||
a->d->immutability = Mutable;
|
||||
}
|
||||
|
||||
c->destroy(false);
|
||||
}
|
||||
|
||||
//restore immutability
|
||||
d->immutability = oldImm;
|
||||
|
||||
config.sync();
|
||||
}
|
||||
|
||||
void CoronaBase::requestConfigSync()
|
||||
{
|
||||
// constant controlling how long between requesting a configuration sync
|
||||
// and one happening should occur. currently 10 seconds
|
||||
static const int CONFIG_SYNC_TIMEOUT = 10000;
|
||||
|
||||
// TODO: should we check into our immutability before doing this?
|
||||
|
||||
//NOTE: this is a pretty simplistic model: we simply save no more than CONFIG_SYNC_TIMEOUT
|
||||
// after the first time this is called. not much of a heuristic for save points, but
|
||||
// it should at least compress these activities a bit and provide a way for applet
|
||||
// authors to ween themselves from the sync() disease. A more interesting/dynamic
|
||||
// algorithm for determining when to actually sync() to disk might be better, though.
|
||||
if (!d->configSyncTimer.isActive()) {
|
||||
d->configSyncTimer.start(CONFIG_SYNC_TIMEOUT);
|
||||
}
|
||||
}
|
||||
|
||||
void CoronaBase::requireConfigSync()
|
||||
{
|
||||
d->syncConfig();
|
||||
}
|
||||
|
||||
void CoronaBase::initializeLayout(const QString &configName)
|
||||
{
|
||||
clearContainments();
|
||||
loadLayout(configName);
|
||||
|
||||
if (d->containments.isEmpty()) {
|
||||
loadDefaultLayout();
|
||||
if (!d->containments.isEmpty()) {
|
||||
requestConfigSync();
|
||||
}
|
||||
}
|
||||
|
||||
if (config()->isImmutable()) {
|
||||
setImmutability(SystemImmutable);
|
||||
} else {
|
||||
KConfigGroup coronaConfig(config(), "General");
|
||||
setImmutability((ImmutabilityType)coronaConfig.readEntry("immutability", (int)Mutable));
|
||||
}
|
||||
}
|
||||
|
||||
void CoronaBase::layoutContainments()
|
||||
{
|
||||
if (CoronaBasePrivate::s_positioningContainments) {
|
||||
return;
|
||||
}
|
||||
|
||||
CoronaBasePrivate::s_positioningContainments = true;
|
||||
|
||||
//TODO: we should avoid running this too often; consider compressing requests
|
||||
// with a timer.
|
||||
QList<Containment*> c = containments();
|
||||
QMutableListIterator<Containment*> it(c);
|
||||
|
||||
while (it.hasNext()) {
|
||||
Containment *containment = it.next();
|
||||
if (containment->containmentType() == Containment::PanelContainment ||
|
||||
containment->containmentType() == Containment::CustomPanelContainment) {
|
||||
// weed out all containments we don't care about at all
|
||||
// e.g. Panels and ourself
|
||||
it.remove();
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (c.isEmpty()) {
|
||||
CoronaBasePrivate::s_positioningContainments = false;
|
||||
return;
|
||||
}
|
||||
|
||||
int column = 0;
|
||||
int x = 0;
|
||||
int y = 0;
|
||||
int rowHeight = 0;
|
||||
|
||||
it.toFront();
|
||||
while (it.hasNext()) {
|
||||
Containment *containment = it.next();
|
||||
containment->setPos(x, y);
|
||||
//kDebug() << ++count << "setting to" << x << y;
|
||||
|
||||
int height = containment->size().height();
|
||||
if (height > rowHeight) {
|
||||
rowHeight = height;
|
||||
}
|
||||
|
||||
++column;
|
||||
|
||||
if (column == CONTAINMENT_COLUMNS) {
|
||||
column = 0;
|
||||
x = 0;
|
||||
y += rowHeight + INTER_CONTAINMENT_MARGIN + TOOLBOX_MARGIN;
|
||||
rowHeight = 0;
|
||||
} else {
|
||||
x += containment->size().width() + INTER_CONTAINMENT_MARGIN;
|
||||
}
|
||||
//kDebug() << "column: " << column << "; x " << x << "; y" << y << "; width was"
|
||||
// << containment->size().width();
|
||||
}
|
||||
|
||||
CoronaBasePrivate::s_positioningContainments = false;
|
||||
}
|
||||
|
||||
|
||||
void CoronaBase::loadLayout(const QString &configName)
|
||||
{
|
||||
if (!configName.isEmpty() && configName != d->configName) {
|
||||
// if we have a new config name passed in, then use that as the config file for this Corona
|
||||
d->config = 0;
|
||||
d->configName = configName;
|
||||
}
|
||||
|
||||
KConfigGroup conf(config(), QString());
|
||||
d->importLayout(conf, false);
|
||||
}
|
||||
|
||||
QList<Plasma::Containment *> CoronaBase::importLayout(const KConfigGroup &conf)
|
||||
{
|
||||
return d->importLayout(conf, true);
|
||||
}
|
||||
|
||||
Containment *CoronaBase::containmentForScreen(int screen, int desktop) const
|
||||
{
|
||||
foreach (Containment *containment, d->containments) {
|
||||
if (containment->screen() == screen &&
|
||||
(desktop < 0 || containment->desktop() == desktop) &&
|
||||
(containment->containmentType() == Containment::DesktopContainment ||
|
||||
containment->containmentType() == Containment::CustomContainment)) {
|
||||
return containment;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Containment *CoronaBase::containmentForScreen(int screen, int desktop,
|
||||
const QString &defaultPluginIfNonExistent, const QVariantList &defaultArgs)
|
||||
{
|
||||
Containment *containment = containmentForScreen(screen, desktop);
|
||||
if (!containment && !defaultPluginIfNonExistent.isEmpty()) {
|
||||
// screen requests are allowed to bypass immutability
|
||||
if (screen >= 0 && screen < numScreens() &&
|
||||
desktop >= -1 && desktop < KWindowSystem::numberOfDesktops()) {
|
||||
containment = d->addContainment(defaultPluginIfNonExistent, defaultArgs, 0, false);
|
||||
if (containment) {
|
||||
containment->setScreen(screen, desktop);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return containment;
|
||||
}
|
||||
|
||||
QList<Containment*> CoronaBase::containments() const
|
||||
{
|
||||
return d->containments;
|
||||
}
|
||||
|
||||
void CoronaBase::clearContainments()
|
||||
{
|
||||
foreach (Containment *containment, d->containments) {
|
||||
containment->clearApplets();
|
||||
}
|
||||
}
|
||||
|
||||
KSharedConfigPtr CoronaBase::config() const
|
||||
{
|
||||
if (!d->config) {
|
||||
d->config = KSharedConfig::openConfig(d->configName, KConfig::SimpleConfig);
|
||||
}
|
||||
|
||||
return d->config;
|
||||
}
|
||||
|
||||
Containment *CoronaBase::addContainment(const QString &name, const QVariantList &args)
|
||||
{
|
||||
if (d->immutability == Mutable) {
|
||||
return d->addContainment(name, args, 0, false);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Containment *CoronaBase::addContainmentDelayed(const QString &name, const QVariantList &args)
|
||||
{
|
||||
if (d->immutability == Mutable) {
|
||||
return d->addContainment(name, args, 0, true);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CoronaBase::numScreens() const
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
QRect CoronaBase::screenGeometry(int id) const
|
||||
{
|
||||
//This is unreliable, give better implementations in subclasses
|
||||
return qApp->desktop()->screenGeometry(id);
|
||||
}
|
||||
|
||||
QRegion CoronaBase::availableScreenRegion(int id) const
|
||||
{
|
||||
return QRegion(screenGeometry(id));
|
||||
}
|
||||
|
||||
void CoronaBase::loadDefaultLayout()
|
||||
{
|
||||
}
|
||||
|
||||
void CoronaBase::setPreferredToolBoxPlugin(const Containment::Type type, const QString &plugin)
|
||||
{
|
||||
d->toolBoxPlugins[type] = plugin;
|
||||
//TODO: react to plugin changes on the fly? still don't see the use case (maybe for laptops that become tablets?)
|
||||
}
|
||||
|
||||
QString CoronaBase::preferredToolBoxPlugin(const Containment::Type type) const
|
||||
{
|
||||
return d->toolBoxPlugins.value(type);
|
||||
}
|
||||
|
||||
ImmutabilityType CoronaBase::immutability() const
|
||||
{
|
||||
return d->immutability;
|
||||
}
|
||||
|
||||
void CoronaBase::setImmutability(const ImmutabilityType immutable)
|
||||
{
|
||||
if (d->immutability == immutable || d->immutability == SystemImmutable) {
|
||||
return;
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
kDebug() << "setting immutability to" << immutable;
|
||||
#endif
|
||||
d->immutability = immutable;
|
||||
d->updateContainmentImmutability();
|
||||
//tell non-containments that might care (like plasmaapp or a custom corona)
|
||||
emit immutabilityChanged(immutable);
|
||||
|
||||
//update our actions
|
||||
QAction *action = d->actions.action("lock widgets");
|
||||
if (action) {
|
||||
if (d->immutability == SystemImmutable) {
|
||||
action->setEnabled(false);
|
||||
action->setVisible(false);
|
||||
} else {
|
||||
bool unlocked = d->immutability == Mutable;
|
||||
action->setText(unlocked ? i18n("Lock Widgets") : i18n("Unlock Widgets"));
|
||||
action->setIcon(KIcon(unlocked ? "object-locked" : "object-unlocked"));
|
||||
action->setEnabled(true);
|
||||
action->setVisible(true);
|
||||
}
|
||||
}
|
||||
|
||||
if (d->immutability != SystemImmutable) {
|
||||
KConfigGroup cg(config(), "General");
|
||||
|
||||
// we call the dptr member directly for locked since isImmutable()
|
||||
// also checks kiosk and parent containers
|
||||
cg.writeEntry("immutability", (int)d->immutability);
|
||||
requestConfigSync();
|
||||
}
|
||||
}
|
||||
|
||||
QList<Plasma::Location> CoronaBase::freeEdges(int screen) const
|
||||
{
|
||||
QList<Plasma::Location> freeEdges;
|
||||
freeEdges << Plasma::TopEdge << Plasma::BottomEdge
|
||||
<< Plasma::LeftEdge << Plasma::RightEdge;
|
||||
|
||||
foreach (Containment *containment, containments()) {
|
||||
if (containment->screen() == screen &&
|
||||
freeEdges.contains(containment->location())) {
|
||||
freeEdges.removeAll(containment->location());
|
||||
}
|
||||
}
|
||||
|
||||
return freeEdges;
|
||||
}
|
||||
|
||||
QAction *CoronaBase::action(QString name) const
|
||||
{
|
||||
return d->actions.action(name);
|
||||
}
|
||||
|
||||
void CoronaBase::addAction(QString name, QAction *action)
|
||||
{
|
||||
d->actions.addAction(name, action);
|
||||
}
|
||||
|
||||
KAction* CoronaBase::addAction(QString name)
|
||||
{
|
||||
return d->actions.addAction(name);
|
||||
}
|
||||
|
||||
QList<QAction*> CoronaBase::actions() const
|
||||
{
|
||||
return d->actions.actions();
|
||||
}
|
||||
|
||||
void CoronaBase::enableAction(const QString &name, bool enable)
|
||||
{
|
||||
QAction *action = d->actions.action(name);
|
||||
if (action) {
|
||||
action->setEnabled(enable);
|
||||
action->setVisible(enable);
|
||||
}
|
||||
}
|
||||
|
||||
void CoronaBase::updateShortcuts()
|
||||
{
|
||||
QMutableListIterator<QWeakPointer<KActionCollection> > it(d->actionCollections);
|
||||
while (it.hasNext()) {
|
||||
it.next();
|
||||
KActionCollection *collection = it.value().data();
|
||||
if (!collection) {
|
||||
// get rid of KActionCollections that have been deleted behind our backs
|
||||
it.remove();
|
||||
continue;
|
||||
}
|
||||
|
||||
collection->readSettings();
|
||||
if (d->shortcutsDlg) {
|
||||
d->shortcutsDlg.data()->addCollection(collection);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CoronaBase::addShortcuts(KActionCollection *newShortcuts)
|
||||
{
|
||||
d->actionCollections << newShortcuts;
|
||||
if (d->shortcutsDlg) {
|
||||
d->shortcutsDlg.data()->addCollection(newShortcuts);
|
||||
}
|
||||
}
|
||||
|
||||
void CoronaBase::setContainmentActionsDefaults(Containment::Type containmentType, const ContainmentActionsPluginsConfig &config)
|
||||
{
|
||||
d->containmentActionsDefaults.insert(containmentType, config);
|
||||
}
|
||||
|
||||
ContainmentActionsPluginsConfig CoronaBase::containmentActionsDefaults(Containment::Type containmentType)
|
||||
{
|
||||
return d->containmentActionsDefaults.value(containmentType);
|
||||
}
|
||||
|
||||
void CoronaBase::setDialogManager(AbstractDialogManager *dialogManager)
|
||||
{
|
||||
d->dialogManager = dialogManager;
|
||||
}
|
||||
|
||||
AbstractDialogManager *CoronaBase::dialogManager()
|
||||
{
|
||||
return d->dialogManager.data();
|
||||
}
|
||||
|
||||
CoronaBasePrivate::CoronaBasePrivate(CoronaBase *corona)
|
||||
: q(corona),
|
||||
immutability(Mutable),
|
||||
mimetype("text/x-plasmoidservicename"),
|
||||
defaultContainmentPlugin("desktop"),
|
||||
config(0),
|
||||
actions(corona)
|
||||
{
|
||||
if (KGlobal::hasMainComponent()) {
|
||||
configName = KGlobal::mainComponent().componentName() + "-appletsrc";
|
||||
} else {
|
||||
configName = "plasma-appletsrc";
|
||||
}
|
||||
}
|
||||
|
||||
CoronaBasePrivate::~CoronaBasePrivate()
|
||||
{
|
||||
qDeleteAll(containments);
|
||||
}
|
||||
|
||||
void CoronaBasePrivate::init()
|
||||
{
|
||||
configSyncTimer.setSingleShot(true);
|
||||
QObject::connect(&configSyncTimer, SIGNAL(timeout()), q, SLOT(syncConfig()));
|
||||
|
||||
//some common actions
|
||||
actions.setConfigGroup("Shortcuts");
|
||||
|
||||
KAction *lockAction = actions.addAction("lock widgets");
|
||||
QObject::connect(lockAction, SIGNAL(triggered(bool)), q, SLOT(toggleImmutability()));
|
||||
lockAction->setText(i18n("Lock Widgets"));
|
||||
lockAction->setAutoRepeat(true);
|
||||
lockAction->setIcon(KIcon("object-locked"));
|
||||
lockAction->setData(AbstractToolBox::ControlTool);
|
||||
lockAction->setShortcut(KShortcut("alt+d, l"));
|
||||
lockAction->setShortcutContext(Qt::ApplicationShortcut);
|
||||
|
||||
//FIXME this doesn't really belong here. desktop KCM maybe?
|
||||
//but should the shortcuts be per-app or really-global?
|
||||
//I don't know how to make kactioncollections use plasmarc
|
||||
KAction *action = actions.addAction("configure shortcuts");
|
||||
QObject::connect(action, SIGNAL(triggered()), q, SLOT(showShortcutConfig()));
|
||||
action->setText(i18n("Shortcut Settings"));
|
||||
action->setIcon(KIcon("configure-shortcuts"));
|
||||
action->setAutoRepeat(false);
|
||||
action->setData(AbstractToolBox::ConfigureTool);
|
||||
//action->setShortcut(KShortcut("ctrl+h"));
|
||||
action->setShortcutContext(Qt::ApplicationShortcut);
|
||||
|
||||
//fake containment/applet actions
|
||||
KActionCollection *containmentActions = AppletPrivate::defaultActions(q); //containment has to start with applet stuff
|
||||
ContainmentPrivate::addDefaultActions(containmentActions); //now it's really containment
|
||||
actionCollections << &actions << AppletPrivate::defaultActions(q) << containmentActions;
|
||||
q->updateShortcuts();
|
||||
}
|
||||
|
||||
void CoronaBasePrivate::showShortcutConfig()
|
||||
{
|
||||
//show a kshortcutsdialog with the actions
|
||||
KShortcutsDialog *dlg = shortcutsDlg.data();
|
||||
if (!dlg) {
|
||||
dlg = new KShortcutsDialog();
|
||||
dlg->setModal(false);
|
||||
dlg->setAttribute(Qt::WA_DeleteOnClose, true);
|
||||
QObject::connect(dlg, SIGNAL(saved()), q, SIGNAL(shortcutsChanged()));
|
||||
|
||||
dlg->addCollection(&actions);
|
||||
QMutableListIterator<QWeakPointer<KActionCollection> > it(actionCollections);
|
||||
while (it.hasNext()) {
|
||||
it.next();
|
||||
KActionCollection *collection = it.value().data();
|
||||
if (!collection) {
|
||||
// get rid of KActionCollections that have been deleted behind our backs
|
||||
it.remove();
|
||||
continue;
|
||||
}
|
||||
|
||||
dlg->addCollection(collection);
|
||||
}
|
||||
}
|
||||
|
||||
KWindowSystem::setOnDesktop(dlg->winId(), KWindowSystem::currentDesktop());
|
||||
dlg->configure();
|
||||
dlg->raise();
|
||||
}
|
||||
|
||||
void CoronaBasePrivate::toggleImmutability()
|
||||
{
|
||||
if (immutability == Mutable) {
|
||||
q->setImmutability(UserImmutable);
|
||||
} else {
|
||||
q->setImmutability(Mutable);
|
||||
}
|
||||
}
|
||||
|
||||
void CoronaBasePrivate::saveLayout(KSharedConfigPtr cg) const
|
||||
{
|
||||
KConfigGroup containmentsGroup(cg, "Containments");
|
||||
foreach (const Containment *containment, containments) {
|
||||
QString cid = QString::number(containment->id());
|
||||
KConfigGroup containmentConfig(&containmentsGroup, cid);
|
||||
containment->save(containmentConfig);
|
||||
}
|
||||
}
|
||||
|
||||
void CoronaBasePrivate::updateContainmentImmutability()
|
||||
{
|
||||
foreach (Containment *c, containments) {
|
||||
// we need to tell each containment that immutability has been altered
|
||||
c->updateConstraints(ImmutableConstraint);
|
||||
}
|
||||
}
|
||||
|
||||
void CoronaBasePrivate::containmentDestroyed(QObject *obj)
|
||||
{
|
||||
// we do a static_cast here since it really isn't an Containment by this
|
||||
// point anymore since we are in the qobject dtor. we don't actually
|
||||
// try and do anything with it, we just need the value of the pointer
|
||||
// so this unsafe looking code is actually just fine.
|
||||
Containment* containment = static_cast<Plasma::Containment*>(obj);
|
||||
int index = containments.indexOf(containment);
|
||||
|
||||
if (index > -1) {
|
||||
containments.removeAt(index);
|
||||
q->requestConfigSync();
|
||||
}
|
||||
}
|
||||
|
||||
void CoronaBasePrivate::syncConfig()
|
||||
{
|
||||
q->config()->sync();
|
||||
emit q->configSynced();
|
||||
}
|
||||
|
||||
Containment *CoronaBasePrivate::addContainment(const QString &name, const QVariantList &args, uint id, bool delayedInit)
|
||||
{
|
||||
QString pluginName = name;
|
||||
Containment *containment = 0;
|
||||
Applet *applet = 0;
|
||||
|
||||
//kDebug() << "Loading" << name << args << id;
|
||||
|
||||
if (pluginName.isEmpty() || pluginName == "default") {
|
||||
// default to the desktop containment
|
||||
pluginName = defaultContainmentPlugin;
|
||||
}
|
||||
|
||||
bool loadingNull = pluginName == "null";
|
||||
if (!loadingNull) {
|
||||
applet = PluginLoader::self()->loadApplet(pluginName, id, args);
|
||||
containment = dynamic_cast<Containment*>(applet);
|
||||
}
|
||||
|
||||
if (!containment) {
|
||||
if (!loadingNull) {
|
||||
#ifndef NDEBUG
|
||||
kDebug() << "loading of containment" << name << "failed.";
|
||||
#endif
|
||||
}
|
||||
|
||||
// in case we got a non-Containment from Applet::loadApplet or
|
||||
// a null containment was requested
|
||||
if (applet) {
|
||||
// the applet probably doesn't know what's hit it, so let's pretend it can be
|
||||
// initialized to make assumptions in the applet's dtor safer
|
||||
applet->init();
|
||||
delete applet;
|
||||
}
|
||||
applet = containment = new Containment(0, 0, id);
|
||||
|
||||
if (loadingNull) {
|
||||
containment->setDrawWallpaper(false);
|
||||
} else {
|
||||
containment->setFailedToLaunch(false);
|
||||
}
|
||||
|
||||
// we want to provide something and don't care about the failure to launch
|
||||
containment->setFormFactor(Plasma::Planar);
|
||||
}
|
||||
|
||||
// if this is a new containment, we need to ensure that there are no stale
|
||||
// configuration data around
|
||||
if (id == 0) {
|
||||
KConfigGroup conf(q->config(), "Containments");
|
||||
conf = KConfigGroup(&conf, QString::number(containment->id()));
|
||||
conf.deleteGroup();
|
||||
}
|
||||
|
||||
applet->d->isContainment = true;
|
||||
applet->d->setIsContainment(true, true);
|
||||
containments.append(containment);
|
||||
|
||||
if (!delayedInit) {
|
||||
containment->init();
|
||||
KConfigGroup cg = containment->config();
|
||||
containment->restore(cg);
|
||||
containment->updateConstraints(Plasma::StartupCompletedConstraint);
|
||||
containment->save(cg);
|
||||
q->requestConfigSync();
|
||||
containment->flushPendingConstraintsEvents();
|
||||
}
|
||||
|
||||
QObject::connect(containment, SIGNAL(destroyed(QObject*)),
|
||||
q, SLOT(containmentDestroyed(QObject*)));
|
||||
QObject::connect(containment, SIGNAL(configNeedsSaving()),
|
||||
q, SLOT(requestConfigSync()));
|
||||
QObject::connect(containment, SIGNAL(releaseVisualFocus()),
|
||||
q, SIGNAL(releaseVisualFocus()));
|
||||
QObject::connect(containment, SIGNAL(screenChanged(int,int,Plasma::Containment*)),
|
||||
q, SIGNAL(screenOwnerChanged(int,int,Plasma::Containment*)));
|
||||
|
||||
if (!delayedInit) {
|
||||
emit q->containmentAdded(containment);
|
||||
}
|
||||
|
||||
return containment;
|
||||
}
|
||||
|
||||
QList<Plasma::Containment *> CoronaBasePrivate::importLayout(const KConfigGroup &conf, bool mergeConfig)
|
||||
{
|
||||
if (!conf.isValid()) {
|
||||
return QList<Containment *>();
|
||||
}
|
||||
|
||||
QList<Plasma::Containment *> newContainments;
|
||||
QSet<uint> containmentsIds;
|
||||
|
||||
foreach (Containment *containment, containments) {
|
||||
containmentsIds.insert(containment->id());
|
||||
}
|
||||
|
||||
KConfigGroup containmentsGroup(&conf, "Containments");
|
||||
|
||||
foreach (const QString &group, containmentsGroup.groupList()) {
|
||||
KConfigGroup containmentConfig(&containmentsGroup, group);
|
||||
|
||||
if (containmentConfig.entryMap().isEmpty()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
uint cid = group.toUInt();
|
||||
if (containmentsIds.contains(cid)) {
|
||||
cid = ++AppletPrivate::s_maxAppletId;
|
||||
} else if (cid > AppletPrivate::s_maxAppletId) {
|
||||
AppletPrivate::s_maxAppletId = cid;
|
||||
}
|
||||
|
||||
if (mergeConfig) {
|
||||
KConfigGroup realConf(q->config(), "Containments");
|
||||
realConf = KConfigGroup(&realConf, QString::number(cid));
|
||||
// in case something was there before us
|
||||
realConf.deleteGroup();
|
||||
containmentConfig.copyTo(&realConf);
|
||||
}
|
||||
|
||||
//kDebug() << "got a containment in the config, trying to make a" << containmentConfig.readEntry("plugin", QString()) << "from" << group;
|
||||
#ifndef NDEBUG
|
||||
kDebug() << "!!{} STARTUP TIME" << QTime().msecsTo(QTime::currentTime()) << "Adding Containment" << containmentConfig.readEntry("plugin", QString());
|
||||
#endif
|
||||
Containment *c = addContainment(containmentConfig.readEntry("plugin", QString()), QVariantList(), cid, true);
|
||||
if (!c) {
|
||||
continue;
|
||||
}
|
||||
|
||||
newContainments.append(c);
|
||||
containmentsIds.insert(c->id());
|
||||
|
||||
c->init();
|
||||
#ifndef NDEBUG
|
||||
kDebug() << "!!{} STARTUP TIME" << QTime().msecsTo(QTime::currentTime()) << "Init Containment" << c->pluginName();
|
||||
#endif
|
||||
c->restore(containmentConfig);
|
||||
#ifndef NDEBUG
|
||||
kDebug() << "!!{} STARTUP TIME" << QTime().msecsTo(QTime::currentTime()) << "Restored Containment" << c->pluginName();
|
||||
#endif
|
||||
}
|
||||
|
||||
foreach (Containment *containment, newContainments) {
|
||||
containment->updateConstraints(Plasma::StartupCompletedConstraint);
|
||||
containment->d->initApplets();
|
||||
emit q->containmentAdded(containment);
|
||||
#ifndef NDEBUG
|
||||
kDebug() << "!!{} STARTUP TIME" << QTime().msecsTo(QTime::currentTime()) << "Containment" << containment->name();
|
||||
#endif
|
||||
}
|
||||
|
||||
return newContainments;
|
||||
}
|
||||
|
||||
} // namespace Plasma
|
||||
|
||||
|
||||
|
||||
#include "moc_coronabase.cpp"
|
||||
438
coronabase.h
Normal file
438
coronabase.h
Normal file
|
|
@ -0,0 +1,438 @@
|
|||
/*
|
||||
* Copyright 2007 Aaron Seigo <aseigo@kde.org>
|
||||
* Copyright 2007 Matt Broadstone <mbroadst@gmail.com>
|
||||
* Copyright 2012 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 PLASMA_CORONABASE_H
|
||||
#define PLASMA_CORONABASE_H
|
||||
|
||||
#include <QGraphicsScene>
|
||||
|
||||
#include <plasma/containment.h>
|
||||
#include <plasma/plasma.h>
|
||||
#include <plasma/plasma_export.h>
|
||||
|
||||
class QGraphicsGridLayout;
|
||||
class QAction;
|
||||
|
||||
class KAction;
|
||||
|
||||
namespace Plasma
|
||||
{
|
||||
|
||||
class CoronaBasePrivate;
|
||||
class ContainmentActionsPluginsConfig;
|
||||
class AbstractDialogManager;
|
||||
|
||||
/**
|
||||
* @class CoronaBase plasma/CoronaBase.h <Plasma/CoronaBase>
|
||||
*
|
||||
* @short A QGraphicsScene for Plasma::Applets
|
||||
*/
|
||||
class PLASMA_EXPORT CoronaBase : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
//typedef QHash<QString, QList<Plasma::Applet*> > layouts;
|
||||
|
||||
public:
|
||||
explicit CoronaBase(QObject * parent = 0);
|
||||
~CoronaBase();
|
||||
|
||||
/**
|
||||
* Sets the mimetype of Drag/Drop items. Default is
|
||||
* text/x-plasmoidservicename
|
||||
*/
|
||||
void setAppletMimeType(const QString &mimetype);
|
||||
|
||||
/**
|
||||
* The current mime type of Drag/Drop items.
|
||||
*/
|
||||
QString appletMimeType();
|
||||
|
||||
/**
|
||||
* @return the default containment plugin type
|
||||
* @since 4.7
|
||||
*/
|
||||
QString defaultContainmentPlugin() const;
|
||||
|
||||
/**
|
||||
* @return all containments on this CoronaBase
|
||||
*/
|
||||
QList<Containment*> containments() const;
|
||||
|
||||
/**
|
||||
* Clear the CoronaBase from all applets.
|
||||
*/
|
||||
void clearContainments();
|
||||
|
||||
/**
|
||||
* Returns the config file used to store the configuration for this CoronaBase
|
||||
*/
|
||||
KSharedConfig::Ptr config() const;
|
||||
|
||||
/**
|
||||
* Adds a Containment to the CoronaBase
|
||||
*
|
||||
* @param name the plugin name for the containment, as given by
|
||||
* KPluginInfo::pluginName(). If an empty string is passed in, the default
|
||||
* containment plugin will be used (usually DesktopContainment). If the
|
||||
* string literal "null" is passed in, then no plugin will be loaded and
|
||||
* a simple Containment object will be created instead.
|
||||
* @param args argument list to pass to the containment
|
||||
*
|
||||
* @return a pointer to the containment on success, or 0 on failure. Failure can be
|
||||
* caused by too restrictive of an Immutability type, as containments cannot be added
|
||||
* when widgets are locked, or if the requested containment plugin can not be located
|
||||
* or successfully loaded.
|
||||
*/
|
||||
Containment *addContainment(const QString &name, const QVariantList &args = QVariantList());
|
||||
|
||||
/**
|
||||
* Loads a containment with delayed initialization, primarily useful
|
||||
* for implementations of loadDefaultLayout. The caller is responsible
|
||||
* for all initializating, saving and notification of a new containment.
|
||||
*
|
||||
* @param name the plugin name for the containment, as given by
|
||||
* KPluginInfo::pluginName(). If an empty string is passed in, the defalt
|
||||
* containment plugin will be used (usually DesktopContainment). If the
|
||||
* string literal "null" is passed in, then no plugin will be loaded and
|
||||
* a simple Containment object will be created instead.
|
||||
* @param args argument list to pass to the containment
|
||||
*
|
||||
* @return a pointer to the containment on success, or 0 on failure. Failure can
|
||||
* be caused by the Immutability type being too restrictive, as containments can't be added
|
||||
* when widgets are locked, or if the requested containment plugin can not be located
|
||||
* or successfully loaded.
|
||||
* @see addContainment
|
||||
**/
|
||||
Containment *addContainmentDelayed(const QString &name,
|
||||
const QVariantList &args = QVariantList());
|
||||
|
||||
/**
|
||||
* Returns the Containment, if any, for a given physical screen and desktop
|
||||
*
|
||||
* @param screen number of the physical screen to locate
|
||||
* @param desktop the virtual desktop) to locate; if < 0 then it will
|
||||
* simply return the first Containment associated with screen
|
||||
*/
|
||||
Containment *containmentForScreen(int screen, int desktop = -1) const;
|
||||
|
||||
/**
|
||||
* Returns the Containment for a given physical screen and desktop, creating one
|
||||
* if none exists
|
||||
*
|
||||
* @param screen number of the physical screen to locate
|
||||
* @param desktop the virtual desktop) to locate; if < 0 then it will
|
||||
* simply return the first Containment associated with screen
|
||||
* @param defaultPluginIfNonExistent the plugin to load by default; "null" is an empty
|
||||
* Containment and "default" creates the default plugin
|
||||
* @param defaultArgs optional arguments to pass in when creating a Containment if needed
|
||||
* @since 4.6
|
||||
*/
|
||||
Containment *containmentForScreen(int screen, int desktop,
|
||||
const QString &defaultPluginIfNonExistent,
|
||||
const QVariantList &defaultArgs = QVariantList());
|
||||
|
||||
/**
|
||||
* Returns the number of screens available to plasma.
|
||||
* Subclasses should override this method as the default
|
||||
* implementation returns a meaningless value.
|
||||
*/
|
||||
virtual int numScreens() const;
|
||||
|
||||
/**
|
||||
* Returns the geometry of a given screen.
|
||||
* Valid screen ids are 0 to numScreen()-1, or -1 for the full desktop geometry.
|
||||
* Subclasses should override this method as the default
|
||||
* implementation returns a meaningless value.
|
||||
*/
|
||||
virtual QRect screenGeometry(int id) const;
|
||||
|
||||
/**
|
||||
* Returns the available region for a given screen.
|
||||
* The available region excludes panels and similar windows.
|
||||
* Valid screen ids are 0 to numScreens()-1.
|
||||
* By default this method returns a rectangular region
|
||||
* equal to screenGeometry(id); subclasses that need another
|
||||
* behavior should override this method.
|
||||
*/
|
||||
virtual QRegion availableScreenRegion(int id) const;
|
||||
|
||||
/**
|
||||
* This method is useful in order to retrieve the list of available
|
||||
* screen edges for panel type containments.
|
||||
* @param screen the id of the screen to look for free edges.
|
||||
* @returns a list of free edges not filled with panel type containments.
|
||||
*/
|
||||
QList<Plasma::Location> freeEdges(int screen) const;
|
||||
|
||||
/**
|
||||
* Returns the QAction with the given name from our collection
|
||||
*/
|
||||
QAction *action(QString name) const;
|
||||
|
||||
/**
|
||||
* Adds the action to our collection under the given name
|
||||
*/
|
||||
void addAction(QString name, QAction *action);
|
||||
|
||||
/**
|
||||
* Returns all the actions in our collection
|
||||
*/
|
||||
QList<QAction*> actions() const;
|
||||
|
||||
/**
|
||||
* convenience function - enables or disables an action by name
|
||||
*
|
||||
* @param name the name of the action in our collection
|
||||
* @param enable true to enable, false to disable
|
||||
*/
|
||||
void enableAction(const QString &name, bool enable);
|
||||
|
||||
/**
|
||||
* @since 4.3
|
||||
* Updates keyboard shortcuts for all the CoronaBase's actions.
|
||||
* If you've added actions to the CoronaBase you'll need to
|
||||
* call this for them to be configurable.
|
||||
*/
|
||||
void updateShortcuts();
|
||||
|
||||
/**
|
||||
* @since 4.3
|
||||
* Adds a set of actions to the shortcut config dialog.
|
||||
* don't use this on actions in the CoronaBase's own actioncollection,
|
||||
* those are handled automatically. this is for stuff outside of that.
|
||||
*/
|
||||
void addShortcuts(KActionCollection *newShortcuts);
|
||||
|
||||
/**
|
||||
* @since 4.3
|
||||
* Creates an action in our collection under the given name
|
||||
* @return the new action
|
||||
* FIXME I'm wrapping so much of kactioncollection API now, maybe I should just expose the
|
||||
* collection itself :P
|
||||
*/
|
||||
KAction* addAction(QString name);
|
||||
|
||||
/**
|
||||
* @since 4.4
|
||||
* Sets the default containmentactions plugins for the given containment type
|
||||
*/
|
||||
void setContainmentActionsDefaults(Containment::Type containmentType, const ContainmentActionsPluginsConfig &config);
|
||||
|
||||
/**
|
||||
* @since 4.4
|
||||
* Returns the default containmentactions plugins for the given containment type
|
||||
*/
|
||||
ContainmentActionsPluginsConfig containmentActionsDefaults(Containment::Type containmentType);
|
||||
|
||||
/**
|
||||
* @param the AbstractDialogManager implementaion
|
||||
*
|
||||
* @since 4.5
|
||||
*/
|
||||
void setDialogManager(AbstractDialogManager *manager);
|
||||
|
||||
/**
|
||||
* @return the AbstractDialogManager that will show dialogs used by applets, like configuration dialogs
|
||||
*
|
||||
* @since 4.5
|
||||
*/
|
||||
AbstractDialogManager *dialogManager();
|
||||
|
||||
/**
|
||||
* Returns the name of the preferred plugin to be used as containment toolboxes.
|
||||
* CustomContainments and CustomPanelContainments can still override it as their liking. It's also not guaranteed that the plugin will actually exist.
|
||||
*
|
||||
* @param type the containment type of which we want to know the associated toolbox plugin
|
||||
* @since 4.6
|
||||
*/
|
||||
QString preferredToolBoxPlugin(const Containment::Type type) const;
|
||||
|
||||
/**
|
||||
* Imports an applet layout from a config file. The results will be added to the
|
||||
* current set of Containments.
|
||||
*
|
||||
* @param config the name of the config file to load from,
|
||||
* or the default config file if QString()
|
||||
* @return the list of containments that were loaded
|
||||
* @since 4.6
|
||||
*/
|
||||
QList<Plasma::Containment *> importLayout(const KConfigGroup &config);
|
||||
|
||||
/**
|
||||
* Exports a set of containments to a config file.
|
||||
*
|
||||
* @param config the config group to save to
|
||||
* @param containments the list of containments to save
|
||||
* @since 4.6
|
||||
*/
|
||||
void exportLayout(KConfigGroup &config, QList<Containment*> containments);
|
||||
|
||||
public Q_SLOTS:
|
||||
/**
|
||||
* Initializes the layout from a config file. This will first clear any existing
|
||||
* Containments, load a layout from the requested configuration file, request the
|
||||
* default layout if needed and update immutability.
|
||||
*
|
||||
* @param config the name of the config file to load from,
|
||||
* or the default config file if QString()
|
||||
*/
|
||||
void initializeLayout(const QString &config = QString());
|
||||
|
||||
/**
|
||||
* Load applet layout from a config file. The results will be added to the
|
||||
* current set of Containments.
|
||||
*
|
||||
* @param config the name of the config file to load from,
|
||||
* or the default config file if QString()
|
||||
*/
|
||||
void loadLayout(const QString &config = QString());
|
||||
|
||||
/**
|
||||
* Save applets layout to file
|
||||
* @param config the file to save to, or the default config file if QString()
|
||||
*/
|
||||
void saveLayout(const QString &config = QString()) const;
|
||||
|
||||
/**
|
||||
* @return The type of immutability of this CoronaBase
|
||||
*/
|
||||
ImmutabilityType immutability() const;
|
||||
|
||||
/**
|
||||
* Sets the immutability type for this CoronaBase (not immutable,
|
||||
* user immutable or system immutable)
|
||||
* @param immutable the new immutability type of this applet
|
||||
*/
|
||||
void setImmutability(const ImmutabilityType immutable);
|
||||
|
||||
/**
|
||||
* Schedules a flush-to-disk synchronization of the configuration state
|
||||
* at the next convenient moment.
|
||||
*/
|
||||
void requestConfigSync();
|
||||
|
||||
/**
|
||||
* Schedules a time sensitive flush-to-disk synchronization of the
|
||||
* configuration state. Since this method does not provide any sort of
|
||||
* event compression, it should only be used when an *immediate* disk
|
||||
* sync is *absolutely* required. Otherwise, use @see requestConfigSync()
|
||||
* which does do event compression.
|
||||
*/
|
||||
void requireConfigSync();
|
||||
|
||||
/**
|
||||
* @since 4.5
|
||||
* Layout the containments on this CoronaBase. The default implementation
|
||||
* organizes them in a grid-like view, but subclasses can reimplement
|
||||
* this slot to provide their own layout.
|
||||
*/
|
||||
virtual void layoutContainments();
|
||||
|
||||
Q_SIGNALS:
|
||||
/**
|
||||
* This signal indicates a new containment has been added to
|
||||
* the CoronaBase
|
||||
*/
|
||||
void containmentAdded(Plasma::Containment *containment);
|
||||
|
||||
/**
|
||||
* This signal indicates that a containment has been newly
|
||||
* associated (or dissociated) with a physical screen.
|
||||
*
|
||||
* @param wasScreen the screen it was associated with
|
||||
* @param isScreen the screen it is now associated with
|
||||
* @param containment the containment switching screens
|
||||
*/
|
||||
void screenOwnerChanged(int wasScreen, int isScreen, Plasma::Containment *containment);
|
||||
|
||||
/**
|
||||
* This signal indicates that an application launch, window
|
||||
* creation or window focus event was triggered. This is used, for instance,
|
||||
* to ensure that the Dashboard view in Plasma hides when such an event is
|
||||
* triggered by an item it is displaying.
|
||||
*/
|
||||
void releaseVisualFocus();
|
||||
|
||||
/**
|
||||
* This signal indicates that the configuration file was flushed to disc.
|
||||
*/
|
||||
void configSynced();
|
||||
|
||||
/**
|
||||
* This signal inicates that a change in available screen goemetry occurred.
|
||||
*/
|
||||
void availableScreenRegionChanged();
|
||||
|
||||
/**
|
||||
* emitted when immutability changes.
|
||||
* this is for use by things that don't get contraints events, like plasmaapp.
|
||||
* it's NOT for containments or applets or any of the other stuff on the scene.
|
||||
* if your code's not in shells/ it probably shouldn't be using it.
|
||||
*/
|
||||
void immutabilityChanged(Plasma::ImmutabilityType immutability);
|
||||
|
||||
/**
|
||||
* @since 4.3
|
||||
* emitted when the user changes keyboard shortcut settings
|
||||
* connect to this if you've put some extra shortcuts in your app
|
||||
* that are NOT in CoronaBase's actioncollection.
|
||||
* if your code's not in shells/ it probably shouldn't be using this function.
|
||||
* @see addShortcuts
|
||||
*/
|
||||
void shortcutsChanged();
|
||||
|
||||
protected:
|
||||
/**
|
||||
* Loads the default (system wide) layout for this user
|
||||
**/
|
||||
virtual void loadDefaultLayout();
|
||||
|
||||
/**
|
||||
* @return The preferred toolbox plugin name for a given containment type.
|
||||
* @param type the containment type of which we want to know the preferred toolbox plugin.
|
||||
* @param plugin the toolbox plugin name
|
||||
* @since 4.6
|
||||
*/
|
||||
void setPreferredToolBoxPlugin(const Containment::Type type, const QString &plugin);
|
||||
|
||||
/**
|
||||
* Sets the default containment plugin to try and load
|
||||
* @since 4.7
|
||||
*/
|
||||
void setDefaultContainmentPlugin(const QString &name);
|
||||
|
||||
private:
|
||||
CoronaBasePrivate *const d;
|
||||
|
||||
Q_PRIVATE_SLOT(d, void containmentDestroyed(QObject*))
|
||||
Q_PRIVATE_SLOT(d, void syncConfig())
|
||||
Q_PRIVATE_SLOT(d, void toggleImmutability())
|
||||
Q_PRIVATE_SLOT(d, void showShortcutConfig())
|
||||
|
||||
friend class CoronaBasePrivate;
|
||||
friend class View;
|
||||
};
|
||||
|
||||
} // namespace Plasma
|
||||
|
||||
#endif
|
||||
|
||||
72
private/coronabase_p.h
Normal file
72
private/coronabase_p.h
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
/*
|
||||
* Copyright 2007-2011 Aaron Seigo <aseigo@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 PLASMA_CORONA_P_H
|
||||
#define PLASMA_CORONA_P_H
|
||||
|
||||
#include <QTimer>
|
||||
|
||||
#include <kactioncollection.h>
|
||||
|
||||
class KShortcutsDialog;
|
||||
|
||||
namespace Plasma
|
||||
{
|
||||
|
||||
class Containment;
|
||||
|
||||
class CoronaBasePrivate
|
||||
{
|
||||
public:
|
||||
CoronaBasePrivate(CoronaBase *corona);
|
||||
~CoronaBasePrivate();
|
||||
|
||||
void init();
|
||||
void showShortcutConfig();
|
||||
void toggleImmutability();
|
||||
void saveLayout(KSharedConfigPtr cg) const;
|
||||
void updateContainmentImmutability();
|
||||
void containmentDestroyed(QObject *obj);
|
||||
void syncConfig();
|
||||
Containment *addContainment(const QString &name, const QVariantList &args, uint id, bool delayedInit);
|
||||
void offscreenWidgetDestroyed(QObject *);
|
||||
QList<Plasma::Containment *> importLayout(const KConfigGroup &conf, bool mergeConfig);
|
||||
|
||||
static bool s_positioningContainments;
|
||||
|
||||
CoronaBase *q;
|
||||
ImmutabilityType immutability;
|
||||
QString mimetype;
|
||||
QString configName;
|
||||
QString defaultContainmentPlugin;
|
||||
KSharedConfigPtr config;
|
||||
QTimer configSyncTimer;
|
||||
QList<Containment*> containments;
|
||||
QHash<uint, QGraphicsWidget*> offscreenWidgets;
|
||||
KActionCollection actions;
|
||||
QMap<Containment::Type, ContainmentActionsPluginsConfig> containmentActionsDefaults;
|
||||
QWeakPointer<KShortcutsDialog> shortcutsDlg;
|
||||
QWeakPointer<AbstractDialogManager> dialogManager;
|
||||
QHash<Containment::Type, QString> toolBoxPlugins;
|
||||
QList<QWeakPointer<KActionCollection> > actionCollections;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue
Block a user