688 lines
22 KiB
QML
688 lines
22 KiB
QML
/*
|
|
Copyright (C) 2011 Martin Gräßlin <mgraesslin@kde.org>
|
|
Copyright (C) 2012 Gregor Taetzner <gregor@freenet.de>
|
|
Copyright (C) 2012 Marco Martin <mart@kde.org>
|
|
Copyright (C) 2013 2014 David Edmundson <davidedmundson@kde.org>
|
|
Copyright 2014 Sebastian Kügler <sebas@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.3
|
|
import org.kde.plasma.plasmoid 2.0
|
|
import QtQuick.Layouts 1.1
|
|
import org.kde.plasma.plasmoid as PlasmaCore
|
|
import org.kde.ksvg as KSvg
|
|
import org.kde.plasma.plasma5support as Plasma5Support
|
|
import org.kde.kirigami 2.20 as Kirigami
|
|
import org.kde.plasma.components 3.0 as PlasmaComponents
|
|
import org.kde.plasma.extras 2.0 as PlasmaExtras
|
|
import org.kde.kquickcontrolsaddons 2.0
|
|
|
|
import org.kde.plasma.private.kicker 0.1 as Kicker
|
|
|
|
Item {
|
|
id: root
|
|
Layout.minimumWidth: Kirigami.Units.gridUnit * 26
|
|
Layout.maximumWidth: Layout.minimumWidth
|
|
|
|
Layout.minimumHeight: Kirigami.Units.gridUnit * 34
|
|
Layout.maximumHeight: Layout.minimumHeight
|
|
|
|
property string previousState
|
|
property bool switchTabsOnHover: plasmoid.configuration.switchTabsOnHover
|
|
property Item currentView: mainTabGroup.currentTab.decrementCurrentIndex ? mainTabGroup.currentTab : mainTabGroup.currentTab.item
|
|
property KickoffButton firstButton: null
|
|
property var configMenuItems
|
|
|
|
property QtObject globalFavorites: rootModelFavorites
|
|
|
|
state: "Normal"
|
|
|
|
onFocusChanged: {
|
|
header.input.forceActiveFocus();
|
|
}
|
|
|
|
function switchToInitial() {
|
|
if (firstButton != null) {
|
|
root.state = "Normal";
|
|
mainTabGroup.currentTab = firstButton.tab;
|
|
tabBar.currentTab = firstButton;
|
|
header.query = ""
|
|
}
|
|
}
|
|
|
|
Kicker.DragHelper {
|
|
id: dragHelper
|
|
|
|
dragIconSize: Kirigami.Units.iconSizes.medium
|
|
onDropped: kickoff.dragSource = null
|
|
}
|
|
|
|
Kicker.AppsModel {
|
|
id: rootModel
|
|
|
|
autoPopulate: false
|
|
|
|
appletInterface: plasmoid
|
|
|
|
appNameFormat: plasmoid.configuration.showAppsByName ? 0 : 1
|
|
flat: false
|
|
sorted: plasmoid.configuration.alphaSort
|
|
showSeparators: false
|
|
showTopLevelItems: true
|
|
|
|
favoritesModel: Kicker.KAStatsFavoritesModel {
|
|
id: rootModelFavorites
|
|
favorites: plasmoid.configuration.favorites
|
|
|
|
onFavoritesChanged: {
|
|
plasmoid.configuration.favorites = favorites;
|
|
}
|
|
}
|
|
|
|
Component.onCompleted: {
|
|
favoritesModel.initForClient("org.kde.plasma.kickoff.favorites.instance-" + plasmoid.id)
|
|
|
|
if (!plasmoid.configuration.favoritesPortedToKAstats) {
|
|
favoritesModel.portOldFavorites(plasmoid.configuration.favorites);
|
|
plasmoid.configuration.favoritesPortedToKAstats = true;
|
|
}
|
|
|
|
rootModel.refresh();
|
|
}
|
|
}
|
|
|
|
Plasma5Support.DataSource {
|
|
id: pmSource
|
|
engine: "powermanagement"
|
|
connectedSources: ["PowerDevil"]
|
|
}
|
|
|
|
KSvg.Svg {
|
|
id: arrowsSvg
|
|
|
|
imagePath: "widgets/arrows"
|
|
size: "16x16"
|
|
}
|
|
|
|
Header {
|
|
id: header
|
|
}
|
|
|
|
Item {
|
|
id: mainArea
|
|
anchors.topMargin: mainTabGroup.state == "top" ? Kirigami.Units.smallSpacing : 0
|
|
|
|
Kirigami.Page {
|
|
id: mainPage
|
|
|
|
// Set anchors
|
|
anchors.fill: parent
|
|
|
|
// Create a row for the tab buttons
|
|
Kirigami.PageRow {
|
|
id: tabRow
|
|
|
|
// Set row orientation based on plasmoid location
|
|
orientation: {
|
|
switch (plasmoid.location) {
|
|
case PlasmaCore.Types.LeftEdge:
|
|
case PlasmaCore.Types.RightEdge:
|
|
return Qt.Horizontal
|
|
default:
|
|
return Qt.Vertical
|
|
}
|
|
}
|
|
|
|
// Add tab buttons
|
|
PlasmaComponents.Button {
|
|
text: i18n("Favorites")
|
|
onClicked: mainPage.currentIndex = 0
|
|
}
|
|
PlasmaComponents.Button {
|
|
text: i18n("Applications")
|
|
onClicked: mainPage.currentIndex = 1
|
|
}
|
|
PlasmaComponents.Button {
|
|
text: i18n("Computer")
|
|
onClicked: mainPage.currentIndex = 2
|
|
}
|
|
PlasmaComponents.Button {
|
|
text: i18n("Recently Used")
|
|
onClicked: mainPage.currentIndex = 3
|
|
}
|
|
PlasmaComponents.Button {
|
|
text: i18n("Often Used")
|
|
onClicked: mainPage.currentIndex = 4
|
|
}
|
|
PlasmaComponents.Button {
|
|
text: i18n("Leave")
|
|
onClicked: mainPage.currentIndex = 5
|
|
}
|
|
PlasmaComponents.Button {
|
|
text: i18n("Search")
|
|
onClicked: root.state = "Search"
|
|
}
|
|
}
|
|
|
|
// Add pages
|
|
Kirigami.Page {
|
|
id: favoritesPage
|
|
anchors.fill: parent
|
|
visible: mainPage.currentIndex === 0
|
|
// Add contents of the Favorites view here
|
|
}
|
|
Kirigami.Page {
|
|
id: applicationsPage
|
|
anchors.fill: parent
|
|
visible: mainPage.currentIndex === 1
|
|
// Add contents of the Applications view here
|
|
}
|
|
Kirigami.Page {
|
|
id: computerPage
|
|
anchors.fill: parent
|
|
visible: mainPage.currentIndex === 2
|
|
// Add contents of the Computer view here
|
|
}
|
|
Kirigami.Page {
|
|
id: recentlyUsedPage
|
|
anchors.fill: parent
|
|
visible: mainPage.currentIndex === 3
|
|
// Add contents of the Recently Used view here
|
|
}
|
|
Kirigami.Page {
|
|
id: oftenUsedPage
|
|
anchors.fill: parent
|
|
visible: mainPage.currentIndex === 4
|
|
// Add contents of the Often Used view here
|
|
}
|
|
Kirigami.Page {
|
|
id: leavePage
|
|
anchors.fill: parent
|
|
visible: mainPage.currentIndex === 5
|
|
// Add contents of the Leave view here
|
|
}
|
|
Kirigami.Page {
|
|
id: searchPage
|
|
anchors.fill: parent
|
|
visible: root.state === "Search"
|
|
// Add contents of the Search view here
|
|
}
|
|
|
|
// Handle the plasmoid location states
|
|
states: [
|
|
State {
|
|
name: "left"
|
|
PropertyChanges {
|
|
target: tabRow
|
|
rotation: 0
|
|
}
|
|
PropertyChanges {
|
|
target: tabRow
|
|
anchors {
|
|
left: parent.left
|
|
top: parent.top
|
|
bottom: parent.bottom
|
|
}
|
|
}
|
|
},
|
|
State {
|
|
name: "top"
|
|
PropertyChanges {
|
|
target: tabRow
|
|
rotation: -90
|
|
}
|
|
PropertyChanges {
|
|
target: tabRow
|
|
anchors {
|
|
top: parent.top
|
|
left: parent.left
|
|
right: parent.right
|
|
}
|
|
}
|
|
},
|
|
State {
|
|
name: "right"
|
|
PropertyChanges {
|
|
target: tabRow
|
|
rotation: 180
|
|
}
|
|
PropertyChanges {
|
|
target: tabRow
|
|
anchors {
|
|
right: parent.right
|
|
top: parent.top
|
|
bottom: parent.bottom
|
|
}
|
|
}
|
|
},
|
|
State {
|
|
name: "bottom"
|
|
PropertyChanges {
|
|
target: tabRow
|
|
rotation: 90
|
|
}
|
|
PropertyChanges {
|
|
target: tabRow
|
|
anchors {
|
|
bottom: parent.bottom
|
|
left: parent.left
|
|
right: parent.right
|
|
}
|
|
}
|
|
}
|
|
]
|
|
|
|
// Set initial plasmoid state
|
|
state: {
|
|
switch (plasmoid.location) {
|
|
case PlasmaCore.Types.LeftEdge:
|
|
return "left"
|
|
case PlasmaCore.Types.TopEdge:
|
|
return "top"
|
|
case PlasmaCore.Types.RightEdge:
|
|
return "right"
|
|
case PlasmaCore.Types.BottomEdge:
|
|
default:
|
|
return "bottom"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
PlasmaComponents.TabBar {
|
|
id: tabBar
|
|
count: 5 // updated in createButtons()
|
|
|
|
Behavior on width {
|
|
NumberAnimation { duration: Kirigami.Units.longDuration; easing.type: Easing.InQuad; }
|
|
enabled: plasmoid.expanded
|
|
}
|
|
Behavior on height {
|
|
NumberAnimation { duration: Kirigami.Units.longDuration; easing.type: Easing.InQuad; }
|
|
enabled: plasmoid.expanded
|
|
}
|
|
|
|
tabPosition: {
|
|
switch (plasmoid.location) {
|
|
case PlasmaCore.Types.TopEdge:
|
|
return Qt.TopEdge;
|
|
case PlasmaCore.Types.LeftEdge:
|
|
return Qt.LeftEdge;
|
|
case PlasmaCore.Types.RightEdge:
|
|
return Qt.RightEdge;
|
|
default:
|
|
return Qt.BottomEdge;
|
|
}
|
|
}
|
|
|
|
onCurrentTabChanged: header.input.forceActiveFocus();
|
|
|
|
Connections {
|
|
target: plasmoid
|
|
function onExpandedChanged() {
|
|
if(menuItemsChanged()) {
|
|
createButtons();
|
|
}
|
|
if (!plasmoid.expanded) {
|
|
switchToInitial();
|
|
}
|
|
}
|
|
}
|
|
} // tabBar
|
|
|
|
KSvg.SvgItem {
|
|
id: tabBarSeparator
|
|
svg: KSvg.Svg {
|
|
id: tabBarSeparatorLine
|
|
imagePath: "widgets/line"
|
|
}
|
|
}
|
|
|
|
MouseArea {
|
|
anchors.fill: tabBar
|
|
|
|
property var oldPos: null
|
|
|
|
enabled: root.state !== "Search"
|
|
hoverEnabled: root.switchTabsOnHover
|
|
|
|
onExited: {
|
|
// Reset so we switch immediately when MouseArea is entered
|
|
// freshly, e.g. from the panel.
|
|
oldPos = null;
|
|
|
|
clickTimer.stop();
|
|
}
|
|
|
|
onPositionChanged: {
|
|
// Reject multiple events with the same coordinates that QQuickWindow
|
|
// synthesizes.
|
|
if (oldPos === Qt.point(mouse.x, mouse.y)) {
|
|
return;
|
|
}
|
|
|
|
var button = tabBar.layout.childAt(mouse.x, mouse.y);
|
|
|
|
if (!button || button.objectName !== "KickoffButton") {
|
|
clickTimer.stop();
|
|
|
|
return;
|
|
}
|
|
|
|
// Switch immediately when MouseArea was freshly entered, e.g.
|
|
// from the panel.
|
|
if (oldPos === null) {
|
|
oldPos = Qt.point(mouse.x, mouse.y);
|
|
|
|
clickTimer.stop();
|
|
button.clicked();
|
|
|
|
return;
|
|
}
|
|
|
|
var dx = (mouse.x - oldPos.x);
|
|
var dy = (mouse.y - oldPos.y);
|
|
|
|
// Check Manhattan length against drag distance to get a decent
|
|
// pointer motion vector.
|
|
if ((Math.abs(dx) + Math.abs(dy)) > Qt.styleHints.startDragDistance) {
|
|
if (tabBar.currentTab !== button) {
|
|
var tabBarPos = mapToItem(tabBar, oldPos.x, oldPos.y);
|
|
oldPos = Qt.point(mouse.x, mouse.y);
|
|
|
|
var angleMouseMove = Math.atan2(dy, dx) * 180 / Math.PI;
|
|
var angleToCornerA = 0;
|
|
var angleToCornerB = 0;
|
|
|
|
switch (plasmoid.location) {
|
|
case PlasmaCore.Types.TopEdge: {
|
|
angleToCornerA = Math.atan2(tabBar.height - tabBarPos.y, 0 - tabBarPos.x);
|
|
angleToCornerB = Math.atan2(tabBar.height - tabBarPos.y, tabBar.width - tabBarPos.x);
|
|
|
|
break;
|
|
}
|
|
case PlasmaCore.Types.LeftEdge: {
|
|
angleToCornerA = Math.atan2(0 - tabBarPos.y, tabBar.width - tabBarPos.x);
|
|
angleToCornerB = Math.atan2(tabBar.height - tabBarPos.y, tabBar.width - tabBarPos.x);
|
|
|
|
break;
|
|
}
|
|
case PlasmaCore.Types.RightEdge: {
|
|
angleToCornerA = Math.atan2(0 - tabBarPos.y, 0 - tabBarPos.x);
|
|
angleToCornerB = Math.atan2(tabBar.height - tabBarPos.y, 0 - tabBarPos.x);
|
|
|
|
break;
|
|
}
|
|
// PlasmaCore.Types.BottomEdge
|
|
default: {
|
|
angleToCornerA = Math.atan2(0 - tabBarPos.y, 0 - tabBarPos.x);
|
|
angleToCornerB = Math.atan2(0 - tabBarPos.y, tabBar.width - tabBarPos.x);
|
|
}
|
|
}
|
|
|
|
// Degrees are nicer to debug than radians.
|
|
angleToCornerA = angleToCornerA * 180 / Math.PI;
|
|
angleToCornerB = angleToCornerB * 180 / Math.PI;
|
|
|
|
var lower = Math.min(angleToCornerA, angleToCornerB);
|
|
var upper = Math.max(angleToCornerA, angleToCornerB);
|
|
|
|
// If the motion vector is outside the angle range from oldPos to the
|
|
// relevant tab bar corners, switch immediately. Otherwise start the
|
|
// timer, which gets aborted should the pointer exit the tab bar
|
|
// early.
|
|
var inRange = (lower < angleMouseMove == angleMouseMove < upper);
|
|
|
|
// Mirror-flip.
|
|
if (plasmoid.location === PlasmaCore.Types.RightEdge ? inRange : !inRange) {
|
|
clickTimer.stop();
|
|
button.clicked();
|
|
|
|
return;
|
|
} else {
|
|
clickTimer.pendingButton = button;
|
|
clickTimer.start();
|
|
}
|
|
} else {
|
|
oldPos = Qt.point(mouse.x, mouse.y);
|
|
}
|
|
}
|
|
}
|
|
|
|
onClicked: {
|
|
clickTimer.stop();
|
|
|
|
var button = tabBar.layout.childAt(mouse.x, mouse.y);
|
|
|
|
if (!button || button.objectName !== "KickoffButton") {
|
|
return;
|
|
}
|
|
|
|
button.clicked();
|
|
}
|
|
|
|
Timer {
|
|
id: clickTimer
|
|
|
|
property Item pendingButton: null
|
|
|
|
interval: 250
|
|
|
|
onTriggered: {
|
|
if (pendingButton) {
|
|
pendingButton.clicked();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Keys.forwardTo: [tabBar.layout]
|
|
|
|
Keys.onPressed: {
|
|
|
|
if (mainTabGroup.currentTab == applicationsPage) {
|
|
if (event.key !== Qt.Key_Tab) {
|
|
root.state = "Applications";
|
|
}
|
|
}
|
|
|
|
switch(event.key) {
|
|
case Qt.Key_Up: {
|
|
currentView.decrementCurrentIndex();
|
|
event.accepted = true;
|
|
break;
|
|
}
|
|
case Qt.Key_Down: {
|
|
currentView.incrementCurrentIndex();
|
|
event.accepted = true;
|
|
break;
|
|
}
|
|
case Qt.Key_Left: {
|
|
if (header.input.focus && header.state == "query") {
|
|
break;
|
|
}
|
|
if (!currentView.deactivateCurrentIndex()) {
|
|
if (root.state == "Applications") {
|
|
mainTabGroup.currentTab = firstButton.tab;
|
|
tabBar.currentTab = firstButton;
|
|
}
|
|
root.state = "Normal"
|
|
}
|
|
event.accepted = true;
|
|
break;
|
|
}
|
|
case Qt.Key_Right: {
|
|
if (header.input.focus && header.state == "query") {
|
|
break;
|
|
}
|
|
currentView.activateCurrentIndex();
|
|
event.accepted = true;
|
|
break;
|
|
}
|
|
case Qt.Key_Tab: {
|
|
root.state == "Applications" ? root.state = "Normal" : root.state = "Applications";
|
|
event.accepted = true;
|
|
break;
|
|
}
|
|
case Qt.Key_Enter:
|
|
case Qt.Key_Return: {
|
|
currentView.activateCurrentIndex(1);
|
|
event.accepted = true;
|
|
break;
|
|
}
|
|
case Qt.Key_Escape: {
|
|
if (header.state != "query") {
|
|
plasmoid.expanded = false;
|
|
} else {
|
|
header.query = "";
|
|
}
|
|
event.accepted = true;
|
|
break;
|
|
}
|
|
case Qt.Key_Menu: {
|
|
currentView.openContextMenu();
|
|
event.accepted = true;
|
|
break;
|
|
}
|
|
default:
|
|
if (!header.input.focus) {
|
|
header.input.forceActiveFocus();
|
|
}
|
|
}
|
|
}
|
|
|
|
states: [
|
|
State {
|
|
name: "Normal"
|
|
PropertyChanges {
|
|
target: root
|
|
Keys.forwardTo: [tabBar.layout]
|
|
}
|
|
PropertyChanges {
|
|
target: tabBar
|
|
//Set the opacity and NOT the visibility, as visibility is recursive
|
|
//and this binding would be executed also on popup show/hide
|
|
//as recommended by the docs: https://doc.qt.io/qt-5/qml-qtquick-item.html#visible-prop
|
|
//plus, it triggers https://bugreports.qt.io/browse/QTBUG-66907
|
|
//in which a mousearea may think it's under the mouse while it isn't
|
|
opacity: tabBar.count > 1 ? 1 : 0
|
|
}
|
|
},
|
|
State {
|
|
name: "Applications"
|
|
PropertyChanges {
|
|
target: root
|
|
Keys.forwardTo: [root]
|
|
}
|
|
PropertyChanges {
|
|
target: tabBar
|
|
opacity: tabBar.count > 1 ? 1 : 0
|
|
}
|
|
},
|
|
State {
|
|
name: "Search"
|
|
PropertyChanges {
|
|
target: tabBar
|
|
opacity: 0
|
|
}
|
|
PropertyChanges {
|
|
target: mainTabGroup
|
|
currentTab: searchPage
|
|
}
|
|
PropertyChanges {
|
|
target: root
|
|
Keys.forwardTo: [root]
|
|
}
|
|
}
|
|
] // states
|
|
|
|
function getButtonDefinition(name) {
|
|
switch(name) {
|
|
case "bookmark":
|
|
return {id: "bookmarkButton", tab: favoritesPage, iconSource: "bookmarks", text: i18n("Favorites")};
|
|
case "application":
|
|
return {id: "applicationButton", tab: applicationsPage, iconSource: "applications-other", text: i18n("Applications")};
|
|
case "computer":
|
|
return {id: "computerButton", tab: systemPage, iconSource: pmSource.data["PowerDevil"] && pmSource.data["PowerDevil"]["Is Lid Present"] ? "computer-laptop" : "computer", text: i18n("Computer")};
|
|
case "used":
|
|
return {id: "usedButton", tab: recentlyUsedPage, iconSource: "view-history", text: i18n("History")};
|
|
case "oftenUsed":
|
|
return {id: "usedButton", tab: oftenUsedPage, iconSource: "office-chart-pie", text: i18n("Often Used")};
|
|
case "leave":
|
|
return {id: "leaveButton", tab: leavePage, iconSource: "system-log-out", text: i18n("Leave")};
|
|
}
|
|
}
|
|
|
|
Component {
|
|
id: kickoffButton
|
|
KickoffButton {}
|
|
}
|
|
|
|
|
|
Component.onCompleted: {
|
|
createButtons();
|
|
}
|
|
|
|
function getEnabled(configuration) {
|
|
var res = [];
|
|
for(var i = 0; i < configuration.length; i++) {
|
|
var confItemName = configuration[i].substring(0, configuration[i].indexOf(":"));
|
|
var confItemEnabled = configuration[i].substring(configuration[i].length-1) === "t";
|
|
if(confItemEnabled) {
|
|
res.push(confItemName);
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
function createButtons() {
|
|
configMenuItems = plasmoid.configuration.menuItems;
|
|
var menuItems = getEnabled(plasmoid.configuration.menuItems);
|
|
tabBar.count = menuItems.length
|
|
|
|
// remove old menu items
|
|
for(var i = tabBar.layout.children.length -1; i >= 0; i--) {
|
|
if(tabBar.layout.children[i].objectName === "KickoffButton") {
|
|
tabBar.layout.children[i].destroy();
|
|
}
|
|
}
|
|
|
|
for (var i = 0; i < menuItems.length; i++) {
|
|
var props = getButtonDefinition(menuItems[i]);
|
|
var button = kickoffButton.createObject(tabBar.layout, props);
|
|
if(i === 0) {
|
|
firstButton = button;
|
|
switchToInitial();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
function menuItemsChanged() {
|
|
if(configMenuItems.length !== plasmoid.configuration.menuItems.length) {
|
|
return true;
|
|
}
|
|
|
|
for(var i = 0; i < configMenuItems.length; i++) {
|
|
if(configMenuItems[i] !== plasmoid.configuration.menuItems[i]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|