mirror of
https://gitgud.io/wackyideas/aerothemeplasma.git
synced 2026-06-19 03:45:50 +00:00
259 lines
9.5 KiB
QML
Executable file
259 lines
9.5 KiB
QML
Executable file
/***************************************************************************
|
|
* Copyright (C) 2013-2014 by Eike Hein <hein@kde.org> *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
|
|
***************************************************************************/
|
|
|
|
import QtQuick 2.0
|
|
import QtQuick.Layouts 1.1
|
|
|
|
import org.kde.plasma.plasmoid 2.0
|
|
import org.kde.plasma.core 2.0 as PlasmaCore
|
|
import org.kde.kwindowsystem 1.0
|
|
|
|
import org.kde.kirigami as Kirigami
|
|
|
|
Item {
|
|
id: root
|
|
|
|
Layout.minimumHeight: floatingOrbPanel.scaledHeight / 3;
|
|
Layout.maximumHeight: floatingOrbPanel.scaledHeight / 3;
|
|
Layout.minimumWidth: floatingOrbPanel.scaledWidth;
|
|
Layout.maximumWidth: floatingOrbPanel.scaledWidth;
|
|
//Layout.preferredWidth: 56;
|
|
//Layout.preferredHeight: floatingOrbPanel.scaledHeight / 3;
|
|
width: Layout.maximumWidth
|
|
height: Layout.maximumHeight
|
|
property bool compositing: false
|
|
|
|
Binding {
|
|
target: kicker
|
|
property: "Layout.minimumHeight"
|
|
value: root.Layout.minimumHeight
|
|
}
|
|
|
|
Binding {
|
|
target: kicker
|
|
property: "Layout.maximumHeight"
|
|
value: root.Layout.maximumHeight
|
|
}
|
|
|
|
Binding {
|
|
target: kicker
|
|
property: "Layout.minimumWidth"
|
|
value: root.Layout.minimumWidth
|
|
}
|
|
Binding {
|
|
target: kicker
|
|
property: "Layout.maximumWidth"
|
|
value: root.Layout.maximumWidth
|
|
}
|
|
|
|
property QtObject contextMenu: null
|
|
property QtObject dashWindow: null
|
|
readonly property bool editMode: Plasmoid.containment.corona.editMode
|
|
readonly property bool inPanel: (Plasmoid.location == PlasmaCore.Types.TopEdge || Plasmoid.location == PlasmaCore.Types.RightEdge || Plasmoid.location == PlasmaCore.Types.BottomEdge || Plasmoid.location == PlasmaCore.Types.LeftEdge)
|
|
property bool menuShown: dashWindow.visible
|
|
property QtObject orb: null
|
|
property alias orbTimer: orbTimer
|
|
readonly property var screenGeometry: Plasmoid.screenGeometry
|
|
|
|
// Should the orb be rendered in its own dialog window so that it can stick out of the panel?
|
|
readonly property bool stickOutOrb: (Plasmoid.location == PlasmaCore.Types.TopEdge || Plasmoid.location == PlasmaCore.Types.BottomEdge) && Plasmoid.configuration.stickOutOrb && kicker.height <= 30 && !editMode
|
|
readonly property bool useCustomButtonImage: (Plasmoid.configuration.useCustomButtonImage)
|
|
readonly property bool vertical: (Plasmoid.formFactor == PlasmaCore.Types.Vertical)
|
|
|
|
// If the url is empty (default value), then use the fallback url. Otherwise, return the url path relative to
|
|
// the location of the source code.
|
|
function getResolvedUrl(url, fallback) {
|
|
|
|
if (url.toString() === "" || !Plasmoid.fileExists(url)) {
|
|
return Qt.resolvedUrl(fallback);
|
|
}
|
|
return url;
|
|
}
|
|
function positionOrb() {
|
|
var pos = kicker.mapToGlobal(floatingOrbPanel.x, floatingOrbPanel.y);
|
|
pos.y -= 5;
|
|
if(Plasmoid.configuration.offsetFloatingOrb) {
|
|
pos.y += 3;
|
|
}
|
|
orb.width = floatingOrbPanel.scaledWidth
|
|
orb.height = floatingOrbPanel.scaledHeight / 3;
|
|
if(orb.height === 30) {
|
|
pos.y += 2;
|
|
}
|
|
|
|
orb.x = pos.x;
|
|
orb.y = pos.y;
|
|
}
|
|
function showMenu() {
|
|
dashWindow.visible = !dashWindow.visible;
|
|
dashWindow.showingAllPrograms = false;
|
|
if(KWindowSystem.isPlatformX11) Plasmoid.setActiveWin(dashWindow);
|
|
dashWindow.m_searchField.focus = true;
|
|
orb.raise();
|
|
}
|
|
function updateSizeHints() {
|
|
return;
|
|
/*if (useCustomButtonImage) {
|
|
if (vertical) {
|
|
var scaledHeight = Math.floor(parent.width * (floatingOrbPanel.buttonIcon.height / floatingOrbPanel.buttonIcon.width));
|
|
root.Layout.minimumHeight = scaledHeight;
|
|
root.Layout.maximumHeight = scaledHeight;
|
|
root.Layout.minimumWidth = Kirigami.Units.iconSizes.small;
|
|
root.Layout.maximumWidth = inPanel ? Kirigami.Units.iconSizes.medium : -1;
|
|
} else {
|
|
var scaledWidth = Math.floor(parent.height * (floatingOrbPanel.buttonIcon.width / floatingOrbPanel.buttonIcon.height));
|
|
root.Layout.minimumWidth = scaledWidth;
|
|
root.Layout.maximumWidth = scaledWidth;
|
|
root.Layout.minimumHeight = Kirigami.Units.iconSizes.small;
|
|
root.Layout.maximumHeight = inPanel ? Kirigami.Units.iconSizes.medium : -1;
|
|
}
|
|
} else {
|
|
root.Layout.minimumWidth = Kirigami.Units.iconSizes.small;
|
|
root.Layout.maximumWidth = inPanel ? Kirigami.Units.iconSizes.medium : -1;
|
|
root.Layout.minimumHeight = Kirigami.Units.iconSizes.small;
|
|
root.Layout.maximumHeight = inPanel ? Kirigami.Units.iconSizes.medium : -1;
|
|
}
|
|
if (stickOutOrb && orb) {
|
|
root.Layout.minimumWidth = orb.width + panelSvg.margins.right * (compositing ? 0 : 1);
|
|
root.Layout.maximumWidth = orb.width + panelSvg.margins.right * (compositing ? 0 : 1);
|
|
root.Layout.minimumHeight = orb.height;
|
|
root.Layout.maximumHeight = orb.height;
|
|
}*/
|
|
}
|
|
|
|
//kicker.status: PlasmaCore.Types.PassiveStatus
|
|
//Plasmoid.status: dashWindow && dashWindow.visible ? PlasmaCore.Types.RequiresAttentionStatus : PlasmaCore.Types.PassiveStatus
|
|
//clip: true
|
|
|
|
Component.onCompleted: {
|
|
dashWindow = Qt.createQmlObject("MenuRepresentation {}", kicker);
|
|
orb = Qt.createQmlObject("StartOrb {}", kicker);
|
|
|
|
orbTimer.start();
|
|
Plasmoid.activated.connect(function () {
|
|
showMenu();
|
|
});
|
|
}
|
|
onCompositingChanged: {
|
|
updateSizeHints();
|
|
positionOrb();
|
|
compositingFix.start();
|
|
}
|
|
onHeightChanged: updateSizeHints()
|
|
|
|
onStickOutOrbChanged: {
|
|
updateSizeHints();
|
|
positionOrb();
|
|
}
|
|
onWidthChanged: updateSizeHints()
|
|
|
|
Connections {
|
|
target: Plasmoid.configuration
|
|
function onCustomButtonImageChanged() {
|
|
positionOrb();
|
|
}
|
|
function onOrbWidthChanged() {
|
|
positionOrb();
|
|
}
|
|
}
|
|
Connections {
|
|
function onScreenChanged() {
|
|
orbTimer.start();
|
|
}
|
|
function onScreenGeometryChanged() {
|
|
orbTimer.start();
|
|
}
|
|
|
|
target: kicker
|
|
}
|
|
|
|
/*
|
|
* Three IconItems are used in order to achieve the same look and feel as Windows 7's
|
|
* orbs. When the menu is closed, hovering over the orb results in the hovered icon
|
|
* gradually appearing into view, and clicking on the orb causes an instant change in
|
|
* visibility, where the normal and hovered icons are invisible, and the pressed icon
|
|
* is visible.
|
|
*
|
|
* When they're bounded by the panel, these icons will by default try to fill up as
|
|
* much space as they can in the compact representation while preserving their aspect
|
|
* ratio.
|
|
*/
|
|
|
|
|
|
FloatingOrb {
|
|
id: floatingOrbPanel
|
|
anchors.left: parent.left
|
|
anchors.right: parent.right
|
|
anchors.verticalCenter: parent.verticalCenter
|
|
objectName: "innerorb"
|
|
opacity: (!stickOutOrb)
|
|
|
|
}
|
|
|
|
// Handles all mouse events for the popup orb
|
|
MouseArea {
|
|
id: mouseAreaCompositingOff
|
|
|
|
acceptedButtons: Qt.LeftButton | Qt.RightButton
|
|
anchors.fill: parent
|
|
hoverEnabled: true
|
|
propagateComposedEvents: true
|
|
|
|
onPressed: mouse => {
|
|
if(mouse.button === Qt.LeftButton)
|
|
showMenu();
|
|
else
|
|
mouse.accepted = false;
|
|
}
|
|
z: 99
|
|
}
|
|
|
|
// I hate this
|
|
|
|
// So the only way I could reasonably think of to make this work is running the function
|
|
// with a delay.
|
|
Timer {
|
|
id: compositingFix
|
|
|
|
interval: 150
|
|
|
|
onTriggered: {
|
|
if (!compositing) {
|
|
Plasmoid.setTransparentWindow();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Even worse, this just makes things even more unsophisticated. If someone has a better
|
|
// way of solving this, I would love to know.
|
|
Timer {
|
|
id: orbTimer
|
|
|
|
interval: 15
|
|
|
|
onTriggered: {
|
|
|
|
Plasmoid.setOrb(orb);
|
|
// Currently hardcoded, will make it configurable soon, when it's been properly tested and hopefully slightly refactored.
|
|
Plasmoid.setMask(Qt.resolvedUrl("./orbs/mask.png"), false);
|
|
updateSizeHints();
|
|
positionOrb();
|
|
}
|
|
}
|
|
}
|