wilderjds
/
plasma-workspace
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Don't rely graphic objects in panel script engine

Browse Source 
The basic design of Plasma is that scripts and and the shell (in theory)
manipulate a tree of basic applet geometry and configs.

Plasmashell then reacts to those changes and displays them visually with
a distinct separation between the layout and UI.

Panel's scriptengine seemed to do away with all, and try and manipulate
the graphic object directly..which might not exist and that leads to
complex code.

This changes it to read/write from the same config object as
PanelView will use. More akin to how the script engine for applet and
contiainment works.

If there's a view for this panel, we update immediately, otherwise it'll
just get loaded when it's needed. PanelView::reload() has the error
checking/bounds management so no point duplicating that.

BUG: 355918
REVIEW: 125921
wilder-5.14
David Edmundson 10 years ago committed by David Edmundson
parent 3ff5cdd3cf
commit 0dc7f6c3e5
4 changed files with 105 additions and 312 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 47
      shell/panelview.cpp
  2. 3
      shell/panelview.h
  3. 366
      shell/scripting/panel.cpp
  4. 1
      shell/scripting/panel.h

47
shell/panelview.cpp
Unescape View File

@ -123,22 +123,27 @@ PanelView::~PanelView()
PanelShadows::self()->removeWindow(this);
}
KConfigGroup PanelView::config() const
KConfigGroup PanelView::panelConfig(ShellCorona *corona, Plasma::Containment *containment, QScreen *screen)
{
if (!containment()) {
if (!containment || !screen) {
return KConfigGroup();
}
KConfigGroup views(m_corona->applicationConfig(), "PlasmaViews");
views = KConfigGroup(&views, QStringLiteral("Panel %1").arg(containment()->id()));
KConfigGroup views(corona->applicationConfig(), "PlasmaViews");
views = KConfigGroup(&views, QStringLiteral("Panel %1").arg(containment->id()));
if (formFactor() == Plasma::Types::Vertical) {
return KConfigGroup(&views, "Vertical" + QString::number(screen()->size().height()));
if (containment->formFactor() == Plasma::Types::Vertical) {
return KConfigGroup(&views, "Vertical" + QString::number(screen->size().height()));
//treat everything else as horizontal
} else {
return KConfigGroup(&views, "Horizontal" + QString::number(screen()->size().width()));
return KConfigGroup(&views, "Horizontal" + QString::number(screen->size().width()));
}
}
KConfigGroup PanelView::config() const
{
return panelConfig(m_corona, containment(), screen());
}
void PanelView::maximize()
{
int length;
@ -491,26 +496,12 @@ void PanelView::restore()
int defaultMaxLength = 0;
int defaultMinLength = 0;
int defaultAlignment = Qt::AlignLeft;
QQuickItem *containmentItem = containment()->property("_plasma_graphicObject").value<QQuickItem *>();
if (containmentItem && containmentItem->property("_plasma_desktopscripting_alignment").canConvert<int>()) {
defaultAlignment = containmentItem->property("_plasma_desktopscripting_alignment").toInt();
}
setAlignment((Qt::Alignment)config().readEntry<int>("alignment", defaultAlignment));
if (containmentItem && containmentItem->property("_plasma_desktopscripting_offset").canConvert<int>()) {
defaultOffset = containmentItem->property("_plasma_desktopscripting_offset").toInt();
}
m_offset = config().readEntry<int>("offset", defaultOffset);
if (m_alignment != Qt::AlignCenter) {
m_offset = qMax(0, m_offset);
}
if (containmentItem && containmentItem->property("_plasma_desktopscripting_thickness").canConvert<int>()) {
defaultThickness = qMax(16, containmentItem->property("_plasma_desktopscripting_thickness").toInt());
}
setThickness(config().readEntry<int>("thickness", defaultThickness));
setMinimumSize(QSize(-1, -1));
@ -521,13 +512,6 @@ void PanelView::restore()
defaultMaxLength = screen()->size().height();
defaultMinLength = screen()->size().height();
if (containmentItem && containmentItem->property("_plasma_desktopscripting_maxLength").canConvert<int>()) {
defaultMaxLength = containmentItem->property("_plasma_desktopscripting_maxLength").toInt();
}
if (containmentItem && containmentItem->property("_plasma_desktopscripting_minLength").canConvert<int>()) {
defaultMinLength = containmentItem->property("_plasma_desktopscripting_minLength").toInt();
}
m_maxLength = config().readEntry<int>("maxLength", defaultMaxLength);
m_minLength = config().readEntry<int>("minLength", defaultMinLength);
@ -545,13 +529,6 @@ void PanelView::restore()
defaultMaxLength = screen()->size().width();
defaultMinLength = screen()->size().width();
if (containmentItem && containmentItem->property("_plasma_desktopscripting_maxLength").canConvert<int>()) {
defaultMaxLength = containmentItem->property("_plasma_desktopscripting_maxLength").toInt();
}
if (containmentItem && containmentItem->property("_plasma_desktopscripting_minLength").canConvert<int>()) {
defaultMinLength = containmentItem->property("_plasma_desktopscripting_minLength").toInt();
}
m_maxLength = config().readEntry<int>("maxLength", defaultMaxLength);
m_minLength = config().readEntry<int>("minLength", defaultMinLength);

3
shell/panelview.h
Unescape View File

@ -133,6 +133,9 @@ public:
*/
QRect geometryByDistance(int distance) const;
/* Shared with script/panel.cpp */
static KConfigGroup panelConfig(ShellCorona *corona, Plasma::Containment *containment, QScreen *screen);
protected:
void resizeEvent(QResizeEvent *ev);
void showEvent(QShowEvent *event);

366
shell/scripting/panel.cpp
Unescape View File

@ -48,34 +48,34 @@ QString Panel::location() const
{
Plasma::Containment *c = containment();
if (!c) {
return QStringLiteral("floating");
return "floating";
}
switch (c->location()) {
case Plasma::Types::Floating:
return QStringLiteral("floating");
return "floating";
break;
case Plasma::Types::Desktop:
return QStringLiteral("desktop");
return "desktop";
break;
case Plasma::Types::FullScreen:
return QStringLiteral("fullscreen");
return "fullscreen";
break;
case Plasma::Types::TopEdge:
return QStringLiteral("top");
return "top";
break;
case Plasma::Types::BottomEdge:
return QStringLiteral("bottom");
return "bottom";
break;
case Plasma::Types::LeftEdge:
return QStringLiteral("left");
return "left";
break;
case Plasma::Types::RightEdge:
return QStringLiteral("right");
return "right";
break;
}
return QStringLiteral("floating");
return "floating";
}
void Panel::setLocation(const QString &locationString)
@ -88,20 +88,20 @@ void Panel::setLocation(const QString &locationString)
const QString lower = locationString.toLower();
Plasma::Types::Location loc = Plasma::Types::Floating;
Plasma::Types::FormFactor ff = Plasma::Types::Planar;
if (lower == QLatin1String("desktop")) {
if (lower == "desktop") {
loc = Plasma::Types::Desktop;
} else if (lower == QLatin1String("fullscreen")) {
} else if (lower == "fullscreen") {
loc = Plasma::Types::FullScreen;
} else if (lower == QLatin1String("top")) {
} else if (lower == "top") {
loc = Plasma::Types::TopEdge;
ff = Plasma::Types::Horizontal;
} else if (lower == QLatin1String("bottom")) {
} else if (lower == "bottom") {
loc = Plasma::Types::BottomEdge;
ff = Plasma::Types::Horizontal;
} else if (lower == QLatin1String("left")) {
} else if (lower == "left") {
loc = Plasma::Types::LeftEdge;
ff = Plasma::Types::Vertical;
} else if (lower == QLatin1String("right")) {
} else if (lower == "right") {
loc = Plasma::Types::RightEdge;
ff = Plasma::Types::Vertical;
}
@ -120,336 +120,148 @@ PanelView *Panel::panel() const
return m_corona->panelView(c);
}
QString Panel::alignment() const
KConfigGroup Panel::panelConfig() const
{
PanelView *v = panel();
if (!v) {
return QStringLiteral("left");
int screenNum = qMax(screen(), 0); //if we don't have a screen (-1) we'll be put on screen 0
if (QGuiApplication::screens().size() < screenNum) {
return KConfigGroup();
}
QScreen *s = QGuiApplication::screens().at(screenNum);
return PanelView::panelConfig(m_corona, containment(), s);
}
switch (v->alignment()) {
QString Panel::alignment() const
{
switch (panelConfig().readEntry("alignment", 0)) {
case Qt::AlignRight:
return QStringLiteral("right");
return "right";
break;
case Qt::AlignCenter:
return QStringLiteral("center");
return "center";
break;
default:
return QStringLiteral("left");
return "left";
break;
}
return QStringLiteral("left");
return "left";
}
void Panel::setAlignment(const QString &alignment)
{
Qt::Alignment alignmentValue = Qt::AlignLeft;
bool success = false;
if (alignment.compare(QLatin1String("left"), Qt::CaseInsensitive) == 0) {
success = true;
alignmentValue = Qt::AlignLeft;
} else if (alignment.compare(QLatin1String("right"), Qt::CaseInsensitive) == 0) {
success = true;
alignmentValue = Qt::AlignRight;
} else if (alignment.compare(QLatin1String("center"), Qt::CaseInsensitive) == 0) {
success = true;
alignmentValue = Qt::AlignCenter;
int a = Qt::AlignLeft;
if (alignment.compare("right", Qt::CaseInsensitive) == 0) {
a = Qt::AlignRight;
} else if (alignment.compare("center", Qt::CaseInsensitive) == 0) {
a = Qt::AlignCenter;
}
if (!success) {
return;
}
PanelView *v = panel();
if (v) {
v->setOffset(0);
v->setAlignment(alignmentValue);
} else {
QQuickItem *graphicObject = qobject_cast<QQuickItem *>(containment()->property("_plasma_graphicObject").value<QObject *>());
if (!graphicObject) {
return;
}
graphicObject->setProperty("_plasma_desktopscripting_alignment", (int)alignmentValue);
panelConfig().writeEntry("alignment", a);
if (panel()) {
QMetaObject::invokeMethod(panel(), "restore");
}
}
int Panel::offset() const
{
PanelView *v = panel();
if (v) {
return v->offset();
}
return 0;
return panelConfig().readEntry("offset", 0);
}
void Panel::setOffset(int pixels)
{
Plasma::Containment *c = containment();
if (pixels < 0 || !c) {
return;
}
QQuickItem *graphicObject = qobject_cast<QQuickItem *>(c->property("_plasma_graphicObject").value<QObject *>());
if (!graphicObject) {
return;
}
PanelView *v = panel();
if (v) {
QRectF screen = v->screen()->geometry();
QSizeF size(graphicObject->width(), graphicObject->height());
if (c->formFactor() == Plasma::Types::Vertical) {
if (pixels > screen.height()) {
return;
}
if (size.height() + pixels > screen.height()) {
graphicObject->setWidth(size.width());
graphicObject->setHeight(screen.height() - pixels);
}
} else if (pixels > screen.width()) {
return;
} else if (size.width() + pixels > screen.width()) {
size.setWidth(screen.width() - pixels);
graphicObject->setWidth(size.width());
graphicObject->setHeight(size.height());
v->setMinimumSize(size.toSize());
v->setMaximumSize(size.toSize());
}
v->setOffset(pixels);
}
panelConfig().writeEntry("offset", pixels);
if (panel()) {
QMetaObject::invokeMethod(panel(), "restore");
}
}
int Panel::length() const
{
Plasma::Containment *c = containment();
if (!c) {
return 0;
}
QQuickItem *graphicObject = qobject_cast<QQuickItem *>(c->property("_plasma_graphicObject").value<QObject *>());
if (!graphicObject) {
return 0;
}
if (c->formFactor() == Plasma::Types::Vertical) {
return graphicObject->height();
} else {
return graphicObject->width();
}
return panelConfig().readEntry("length", 0);
}
void Panel::setLength(int pixels)
{
PanelView *v = panel();
Plasma::Containment *c = containment();
if (!v || !c || pixels < 0 || pixels > v->maximumLength() || pixels < v->minimumLength()) {
return;
}
QRectF screen = v->screen()->geometry();
if (c->formFactor() == Plasma::Types::Vertical
&& pixels > screen.height() - v->offset()) {
return;
} else if (pixels > screen.width() - v->offset()) {
return;
}
v->setLength(pixels);
panelConfig().writeEntry("length", pixels);
if (panel()) {
QMetaObject::invokeMethod(panel(), "restore");
}
}
int Panel::minimumLength() const
{
PanelView *v = panel();
if (v) {
return v->minimumLength();
}
return 0;
return panelConfig().readEntry("minLength", 0);
}
void Panel::setMinimumLength(int pixels)
{
PanelView *v = panel();
Plasma::Containment *c = containment();
if (!c || pixels < 0) {
return;
}
//NOTE: due to dependency of class creation at startup, we can't in any way have
//the panel views already instantiated, so put the property in a placeholder dynamic property
if (!v) {
QQuickItem *graphicObject = qobject_cast<QQuickItem *>(c->property("_plasma_graphicObject").value<QObject *>());
if (!graphicObject) {
return;
}
graphicObject->setProperty("_plasma_desktopscripting_minLength", pixels);
return;
}
QRectF screen = v->screen()->geometry();
if (c->formFactor() == Plasma::Types::Vertical
&& pixels > screen.height() - v->offset()) {
return;
} else if (pixels > screen.width() - v->offset()) {
return;
}
v->setMinimumLength(pixels);
if (v->maximumLength() < pixels) {
v->setMaximumLength(pixels);
}
panelConfig().writeEntry("minLength", pixels);
if (panel()) {
QMetaObject::invokeMethod(panel(), "restore");
}
}
int Panel::maximumLength() const
{
PanelView *v = panel();
if (v) {
return v->maximumLength();
}
return 0;
return panelConfig().readEntry("maxLength", 0);
}
void Panel::setMaximumLength(int pixels)
{
PanelView *v = panel();
Plasma::Containment *c = containment();
if (!c || pixels < 0) {
return;
}
//NOTE: due to dependency of class creation at startup, we can't in any way have
//the panel views already instantiated, so put the property in a placeholder dynamic property
if (!v) {
QQuickItem *graphicObject = qobject_cast<QQuickItem *>(c->property("_plasma_graphicObject").value<QObject *>());
if (!graphicObject) {
return;
}
graphicObject->setProperty("_plasma_desktopscripting_maxLength", pixels);
return;
}
QRectF screen = v->screen()->geometry();
if (c->formFactor() == Plasma::Types::Vertical
&& pixels > screen.height() - v->offset()) {
return;
} else if (pixels > screen.width() - v->offset()) {
return;
}
v->setMaximumLength(pixels);
if (v->minimumLength() > pixels) {
v->setMinimumLength(pixels);
}
panelConfig().writeEntry("maxLength", pixels);
if (panel()) {
QMetaObject::invokeMethod(panel(), "restore");
}
}
int Panel::height() const
{
Plasma::Containment *c = containment();
if (!c) {
return 0;
}
QQuickItem *graphicObject = qobject_cast<QQuickItem *>(c->property("_plasma_graphicObject").value<QObject *>());
if (!graphicObject) {
return 0;
}
return c->formFactor() == Plasma::Types::Vertical ? graphicObject->width()
: graphicObject->height();
return panelConfig().readEntry("thickness", 0);
}
void Panel::setHeight(int height)
{
Plasma::Containment *c = containment();
if (height < 16 || !c) {
return;
}
QQuickItem *graphicObject = qobject_cast<QQuickItem *>(c->property("_plasma_graphicObject").value<QObject *>());
if (!graphicObject) {
return;
}
PanelView *v = panel();
if (v) {
QRect screen = v->screen()->geometry();
QSizeF size(graphicObject->width(), graphicObject->height());
const int max = (c->formFactor() == Plasma::Types::Vertical ? screen.width() : screen.height()) / 3;
height = qBound(16, height, max);
v->setThickness(height);
} else {
//NOTE: due to dependency of class creation at startup, we can't in any way have
//the panel views already instantiated, so put the property in a placeholder dynamic property
QQuickItem *graphicObject = qobject_cast<QQuickItem *>(c->property("_plasma_graphicObject").value<QObject *>());
if (!graphicObject) {
return;
}
graphicObject->setProperty("_plasma_desktopscripting_thickness", height);
panelConfig().writeEntry("thickness", height);
if (panel()) {
QMetaObject::invokeMethod(panel(), "restore");
}
}
QString Panel::hiding() const
{
PanelView *v = panel();
if (v) {
switch (v->visibilityMode()) {
case PanelView::NormalPanel:
return QStringLiteral("none");
break;
case PanelView::AutoHide:
return QStringLiteral("autohide");
break;
case PanelView::LetWindowsCover:
return QStringLiteral("windowscover");
break;
case PanelView::WindowsGoBelow:
return QStringLiteral("windowsbelow");
break;
}
switch (panelConfig().readEntry("panelVisibility", 0)) {
case PanelView::NormalPanel:
return "none";
break;
case PanelView::AutoHide:
return "autohide";
break;
case PanelView::LetWindowsCover:
return "windowscover";
break;
case PanelView::WindowsGoBelow:
return "windowsbelow";
break;
}
return QStringLiteral("none");
return "none";
}
void Panel::setHiding(const QString &mode)
{
PanelView *v = panel();
if (v) {
if (mode.compare(QLatin1String("autohide"), Qt::CaseInsensitive) == 0) {
v->setVisibilityMode(PanelView::AutoHide);
} else if (mode.compare(QLatin1String("windowscover"), Qt::CaseInsensitive) == 0) {
v->setVisibilityMode(PanelView::LetWindowsCover);
} else if (mode.compare(QLatin1String("windowsbelow"), Qt::CaseInsensitive) == 0) {
v->setVisibilityMode(PanelView::WindowsGoBelow);
} else {
v->setVisibilityMode(PanelView::NormalPanel);
}
PanelView::VisibilityMode visibilityMode = PanelView::NormalPanel;
if (mode.compare("autohide", Qt::CaseInsensitive) == 0) {
visibilityMode = PanelView::AutoHide;
} else if (mode.compare("windowscover", Qt::CaseInsensitive) == 0) {
visibilityMode = PanelView::LetWindowsCover;
} else if (mode.compare("windowsbelow", Qt::CaseInsensitive) == 0) {
visibilityMode = PanelView::WindowsGoBelow;
}
panelConfig().writeEntry("panelVisibility", (int)visibilityMode);
if (panel()) {
QMetaObject::invokeMethod(panel(), "restore");
}
}

1
shell/scripting/panel.h
Unescape View File

@ -100,6 +100,7 @@ public Q_SLOTS:
private:
PanelView *panel() const;
KConfigGroup panelConfig() const;
ShellCorona *m_corona;
};

Write Preview
Loading…
Cancel
Save