diff --git a/containment/package/contents/config/main.xml b/containment/package/contents/config/main.xml
index 984985b5..5fff8523 100644
--- a/containment/package/contents/config/main.xml
+++ b/containment/package/contents/config/main.xml
@@ -1,337 +1,341 @@
0
10
64
0.2
20
0
false
-1
false
true
6
true
false
100
false
true
true
true
true
false
false
false
0
0
-1
-1
2
0
70
30
080808
false
100
0
+
+ false
+
+
6
2
0
0
0
1
0
false
true
2
true
true
true
true
true
false
false
false
0
false
false
true
false
false
true
true
true
true
true
true
true
true
diff --git a/containment/package/contents/ui/layouts/Container.qml b/containment/package/contents/ui/layouts/Container.qml
index bdc4dfd5..166c6538 100644
--- a/containment/package/contents/ui/layouts/Container.qml
+++ b/containment/package/contents/ui/layouts/Container.qml
@@ -1,711 +1,711 @@
/*
* Copyright 2016 Smith AR
* Michail Vourlakos
*
* This file is part of Latte-Dock
*
* Latte-Dock 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.
*
* Latte-Dock 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, see .
*/
import QtQuick 2.1
import QtQuick.Layouts 1.1
import org.kde.plasma.plasmoid 2.0
import org.kde.plasma.core 2.0 as PlasmaCore
import org.kde.latte 0.2 as Latte
import "../../code/HeuristicTools.js" as HeuristicTools
Item{
id: layoutsContainer
readonly property bool isHidden: root.inStartup || (latteView && latteView.visibility && latteView.visibility.isHidden)
readonly property bool useMaxLength: (plasmoid.configuration.panelPosition === Latte.Types.Justify)
&& ((!root.inConfigureAppletsMode && !root.behaveAsPlasmaPanel )
|| (behaveAsPlasmaPanel && root.inConfigureAppletsMode))
property int allCount: root.latteApplet ? _mainLayout.count-1+latteApplet.tasksCount : _mainLayout.count
property int currentSpot: -1000
property int hoveredIndex: -1
readonly property int fillApplets: _startLayout.fillApplets + _mainLayout.fillApplets + _endLayout.fillApplets
property Item startLayout : _startLayout
property Item mainLayout: _mainLayout
property Item endLayout: _endLayout
Binding {
target: layoutsContainer
property: "x"
value: {
if ( latteView && root.isHorizontal && useMaxLength ){
return ((latteView.width/2) - (root.maxLength/2)); // + root.offset)
} else {
if ((visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) && root.isVertical){
return;
}
if (layoutsContainer.isHidden && root.isVertical) {
if (Latte.WindowSystem.compositingActive) {
return visibilityManager.slidingOutToPos;
} else {
if ((plasmoid.location===PlasmaCore.Types.LeftEdge)||(plasmoid.location===PlasmaCore.Types.TopEdge)) {
return visibilityManager.slidingOutToPos + 1;
} else {
return visibilityManager.slidingOutToPos - 1;
}
}
} else {
return 0;
}
}
}
}
Binding{
target: layoutsContainer
property: "y"
value: {
if ( latteView && root.isVertical && useMaxLength ) {
return ((latteView.height/2) - (root.maxLength/2));// + root.offset);
} else {
if ((visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) && root.isHorizontal){
return;
}
if (layoutsContainer.isHidden && root.isHorizontal) {
if (Latte.WindowSystem.compositingActive) {
return visibilityManager.slidingOutToPos;
} else {
if ((plasmoid.location===PlasmaCore.Types.LeftEdge)||(plasmoid.location===PlasmaCore.Types.TopEdge)) {
return visibilityManager.slidingOutToPos + 1;
} else {
return visibilityManager.slidingOutToPos - 1;
}
}
} else {
return 0;
}
}
}
}
width: root.isHorizontal && useMaxLength ? root.maxLength : parent.width
height: root.isVertical && useMaxLength ? root.maxLength : parent.height
z:10
property bool animationSent: false
property bool shouldCheckHalfs: (plasmoid.configuration.panelPosition === Latte.Types.Justify) && (_mainLayout.children>1)
property int contentsWidth: _startLayout.width + _mainLayout.width + _endLayout.width
property int contentsHeight: _startLayout.height + _mainLayout.height + _endLayout.height
onContentsWidthChanged: {
if (root.isHorizontal){
var firstHalfExited = false;
var secondHalfExited = false;
if (shouldCheckHalfs){
firstHalfExited = ( (_startLayout.width + _mainLayout.width/2) >= root.maxLength/2 );
secondHalfExited = ( (_endLayout.width + _mainLayout.width/2) >= root.maxLength/2 );
}
if (latteView && ((contentsWidth >= root.maxLength) || firstHalfExited || secondHalfExited)) {
updateAutomaticIconSize();
}
if (!animationSent) {
animationSent = true;
slotAnimationsNeedLength(1);
}
layoutsContainer.updateSizeForAppletsInFill();
delayUpdateMaskArea.start();
}
}
onContentsHeightChanged: {
if (root.isVertical){
var firstHalfExited = false;
var secondHalfExited = false;
if (shouldCheckHalfs){
firstHalfExited = ( (_startLayout.height + _mainLayout.height/2) >= root.maxLength/2 );
secondHalfExited = ( (_endLayout.height + _mainLayout.height/2) >= root.maxLength/2 );
}
if (latteView && ((contentsHeight >= root.maxLength) || firstHalfExited || secondHalfExited)) {
updateAutomaticIconSize();
}
if (!animationSent) {
animationSent = true;
slotAnimationsNeedLength(1);
}
layoutsContainer.updateSizeForAppletsInFill();
delayUpdateMaskArea.start();
}
}
onXChanged: root.updateEffectsArea();
onYChanged: root.updateEffectsArea();
EnvironmentActions {
- active: true //root.scrollAction !== Latte.Types.ScrollNone // it should have an option to activate/deactivate the dragging active window etc.
+ active: root.scrollAction !== Latte.Types.ScrollNone || root.dragActiveWindowEnabled
}
Grid{
id:_startLayout
columns: root.isVertical ? 1 : 0
columnSpacing: 0
flow: isHorizontal ? Grid.LeftToRight : Grid.TopToBottom
rows: root.isHorizontal ? 1 : 0
rowSpacing: 0
Layout.preferredWidth: width
Layout.preferredHeight: height
property int beginIndex: 0
property int count: children.length
//it is used in calculations for fillWidth,fillHeight applets
property int sizeWithNoFillApplets: 0
Binding{
target: _startLayout
property:"sizeWithNoFillApplets"
when: _startLayout
value: {
if (!visibilityManager || !visibilityManager.normalState)
return;
var space = 0;
for (var i=0; i<_startLayout.children.length; ++i){
if (_startLayout.children[i] && !_startLayout.children[i].needsFillSpace && !_startLayout.children[i].isHidden) {
space = root.isHorizontal ? space + _startLayout.children[i].width : space + _startLayout.children[i].height;
}
}
return space;
}
}
property int shownApplets: {
var res = 0;
for (var i=0; i
*
* This file is part of Latte-Dock
*
* Latte-Dock 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.
*
* Latte-Dock 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, see .
*/
import QtQuick 2.7
import org.kde.plasma.core 2.0 as PlasmaCore
import org.kde.plasma.plasmoid 2.0
import org.kde.latte 0.2 as Latte
import "loaders" as Loaders
Loader {
id: environmentLoader
sourceComponent: MouseArea{
id: mainArea
width: {
if (root.isHorizontal) {
return useAllLayouts ? root.maxLength : root.realPanelLength;
} else {
return root.isHovered ? (root.iconSize + root.thickMargins)*root.zoomFactor : (root.iconSize + root.thickMargins)
}
}
height: {
if (root.isVertical) {
return useAllLayouts ? root.maxLength : root.realPanelLength;
} else {
return root.isHovered ? (root.iconSize + root.thickMargins)*root.zoomFactor : (root.iconSize + root.thickMargins)
}
}
hoverEnabled: true
readonly property bool useAllLayouts: panelUserSetAlignment === Latte.Types.Justify && !root.inConfigureAppletsMode
property int lastPressX: -1
property int lastPressY: -1
onContainsMouseChanged: {
if (root.mouseInHoverableArea()) {
root.stopCheckRestoreZoomTimer();
} else {
root.initializeHoveredIndexes();
root.startCheckRestoreZoomTimer()
}
}
onPressed: {
+ if (!root.dragActiveWindowEnabled) {
+ return;
+ }
+
if (latteView.windowsTracker.activeWindowCanBeDragged()) {
lastPressX = mouse.x;
lastPressY = mouse.y;
dragWindowTimer.start();
}
}
onReleased: {
lastPressX = -1;
lastPressY = -1;
}
onPositionChanged: {
+ if (!root.dragActiveWindowEnabled) {
+ return;
+ }
+
var stepX = Math.abs(lastPressX-mouse.x);
var stepY = Math.abs(lastPressY-mouse.y);
var threshold = 5;
var tryDrag = mainArea.pressed && (stepX>threshold || stepY>threshold);
if ( tryDrag && latteView.windowsTracker.activeWindowCanBeDragged()) {
dragWindowTimer.stop();
activateDragging();
}
}
onDoubleClicked: {
+ if (!root.dragActiveWindowEnabled) {
+ return;
+ }
+
dragWindowTimer.stop();
restoreGrabberTimer.stop();
latteView.windowsTracker.requestToggleMaximizeForActiveWindow();
//tasksModel.requestToggleMaximized(tasksModel.activeTask);
}
onWheel: {
if (root.scrollAction === Latte.Types.ScrollNone) {
root.emptyAreasWheel(wheel);
return;
}
var delta = 0;
if (wheel.angleDelta.y>=0 && wheel.angleDelta.x>=0) {
delta = Math.max(wheel.angleDelta.y, wheel.angleDelta.x);
} else {
delta = Math.min(wheel.angleDelta.y, wheel.angleDelta.x);
}
var angle = delta / 8;
if (angle>10) {
if (pagerLoader.active) {
var next;
if (pagerLoader.item.model.currentPage === pagerLoader.item.count - 1){
next = 0;
} else {
next = Math.min(pagerLoader.item.model.currentPage + 1, pagerLoader.item.count - 1);
}
if (pagerLoader.item.count > 1){
//console.log("+++ changing from: " + pagerLoader.item.model.currentPage + " to ::: " + next);
pagerLoader.item.model.changePage(next);
}
} else if (tasksLoader.active) {
tasksLoader.item.activateNextPrevTask(true);
}
} else if (angle<-10) {
if (pagerLoader.active) {
var prev;
if (pagerLoader.item.model.currentPage === 0){
prev = pagerLoader.item.count - 1;
} else {
prev = Math.max(pagerLoader.item.model.currentPage - 1, 0);
}
if (pagerLoader.item.count > 1){
//console.log("--- changing from: " + pagerLoader.item.model.currentPage + " to ::: " + prev);
pagerLoader.item.model.changePage(prev);
}
} else if (tasksLoader.active) {
tasksLoader.item.activateNextPrevTask(false);
}
}
}
Loaders.Pager{
id: pagerLoader
}
Loaders.Tasks{
id: tasksLoader
}
function activateDragging(){
latteView.disableGrabItemBehavior();
latteView.windowsTracker.requestMoveActiveWindow(mainArea.mouseX, mainArea.mouseY);
restoreGrabberTimer.start();
}
//! Timers
Timer {
id: dragWindowTimer
interval: 500
onTriggered: {
if (mainArea.pressed && latteView.windowsTracker.activeWindowCanBeDragged()) {
mainArea.activateDragging();
}
}
}
Timer {
id: restoreGrabberTimer
interval: 50
onTriggered: {
latteView.restoreGrabItemBehavior();
mainArea.lastPressX = -1;
mainArea.lastPressY = -1;
}
}
states:[
State {
name: "bottom"
when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
AnchorChanges {
target: mainArea
anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined;
horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
}
},
State {
name: "top"
when: (plasmoid.location === PlasmaCore.Types.TopEdge)
AnchorChanges {
target: mainArea
anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined;
horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
}
},
State {
name: "left"
when: (plasmoid.location === PlasmaCore.Types.LeftEdge)
AnchorChanges {
target: mainArea
anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined;
horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
}
},
State {
name: "right"
when: (plasmoid.location === PlasmaCore.Types.RightEdge)
AnchorChanges {
target: mainArea
anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right;
horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
}
}
]
}
states:[
State {
name: "bottom"
when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
AnchorChanges {
target: environmentLoader
anchors{ top:undefined; bottom: _mainLayout.bottom; left:undefined; right:undefined;
horizontalCenter: _mainLayout.horizontalCenter; verticalCenter:undefined}
}
},
State {
name: "top"
when: (plasmoid.location === PlasmaCore.Types.TopEdge)
AnchorChanges {
target: environmentLoader
anchors{ top: _mainLayout.top; bottom:undefined; left:undefined; right:undefined;
horizontalCenter: _mainLayout.horizontalCenter; verticalCenter:undefined}
}
},
State {
name: "left"
when: (plasmoid.location === PlasmaCore.Types.LeftEdge)
AnchorChanges {
target: environmentLoader
anchors{ top:undefined; bottom:undefined; left: _mainLayout.left; right:undefined;
horizontalCenter:undefined; verticalCenter: _mainLayout.verticalCenter}
}
},
State {
name: "right"
when: (plasmoid.location === PlasmaCore.Types.RightEdge)
AnchorChanges {
target: environmentLoader
anchors{ top:undefined; bottom:undefined; left:undefined; right: _mainLayout.right;
horizontalCenter:undefined; verticalCenter: _mainLayout.verticalCenter}
}
}
]
}
diff --git a/containment/package/contents/ui/main.qml b/containment/package/contents/ui/main.qml
index a60219d9..e9fdc3f0 100644
--- a/containment/package/contents/ui/main.qml
+++ b/containment/package/contents/ui/main.qml
@@ -1,1918 +1,1919 @@
/*
* Copyright 2016 Smith AR
* Michail Vourlakos
*
* This file is part of Latte-Dock
*
* Latte-Dock 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.
*
* Latte-Dock 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, see .
*/
import QtQuick 2.1
import QtQuick.Layouts 1.1
import QtQuick.Window 2.2
import QtGraphicalEffects 1.0
import org.kde.plasma.core 2.0 as PlasmaCore
import org.kde.plasma.components 2.0 as PlasmaComponents
import org.kde.kquickcontrolsaddons 2.0
import org.kde.draganddrop 2.0 as DragDrop
import org.kde.plasma.plasmoid 2.0
import org.kde.latte 0.2 as Latte
import "applet" as Applet
import "colorizer" as Colorizer
import "editmode" as EditMode
import "indicators" as Indicators
import "layouts" as Layouts
import "../code/LayoutManager.js" as LayoutManager
DragDrop.DropArea {
id: root
objectName: "containmentViewLayout"
LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.isVertical
LayoutMirroring.childrenInherit: true
//// BEGIN SIGNALS
signal clearZoomSignal();
signal destroyInternalViewSplitters();
signal emptyAreasWheel(QtObject wheel);
signal separatorsUpdated();
signal signalActivateEntryAtIndex(int entryIndex);
signal signalNewInstanceForEntryAtIndex(int entryIndex);
signal updateEffectsArea();
signal updateIndexes();
signal updateScale(int delegateIndex, real newScale, real step);
signal broadcastedToApplet(string pluginName, string action, variant value);
//// END SIGNALS
////BEGIN properties
property bool debugMode: Qt.application.arguments.indexOf("--graphics")>=0
property bool debugModeSpacers: Qt.application.arguments.indexOf("--spacers")>=0
property bool debugModeTimers: Qt.application.arguments.indexOf("--timers")>=0
property bool debugModeWindow: Qt.application.arguments.indexOf("--with-window")>=0
property bool debugModeOverloadedIcons: Qt.application.arguments.indexOf("--overloaded-icons")>=0
property bool globalDirectRender: false //it is used as a globalDirectRender for all elements in the dock
property int directRenderAnimationTime: 0
property bool addLaunchersMessage: false
property bool addLaunchersInTaskManager: plasmoid.configuration.addLaunchersInTaskManager
// when there are only plasma style task managers OR any applets that fill width or height
// the automatic icon size algorithm should better be disabled
property bool autoDecreaseIconSize: !containsOnlyPlasmaTasks && layoutsContainer.fillApplets<=0
property bool backgroundOnlyOnMaximized: plasmoid.configuration.backgroundOnlyOnMaximized
property bool behaveAsPlasmaPanel: {
if (!latteView || !latteView.visibility) {
return false;
}
return (visibilityManager.panelIsBiggerFromIconSize && (maxZoomFactor === 1.0)
&& (latteView.visibility.mode === Latte.Types.AlwaysVisible || latteView.visibility.mode === Latte.Types.WindowsGoBelow)
&& (plasmoid.configuration.panelPosition === Latte.Types.Justify));
}
property int viewType: {
if ((plasmoid.configuration.panelPosition === Latte.Types.Justify)
&& (plasmoid.configuration.useThemePanel)
&& (plasmoid.configuration.panelSize === 100)
&& (maxZoomFactor === 1.0)) {
return Latte.Types.PanelView;
}
return Latte.Types.DockView;
}
property bool blurEnabled: plasmoid.configuration.blurEnabled && (!forceTransparentPanel || forcePanelForBusyBackground)
property bool confirmedDragEntered: false
property bool containsOnlyPlasmaTasks: false //this is flag to indicate when from tasks only a plasma based one is found
property bool dockContainsMouse: latteView && latteView.visibility ? latteView.visibility.containsMouse : false
property bool disablePanelShadowMaximized: plasmoid.configuration.disablePanelShadowForMaximized && Latte.WindowSystem.compositingActive
property bool drawShadowsExternal: panelShadowsActive && behaveAsPlasmaPanel && !visibilityManager.inTempHiding
property bool editMode: editModeVisual.inEditMode
property bool windowIsTouching: latteView && latteView.windowsTracker
&& (latteView.windowsTracker.activeWindowTouching || hasExpandedApplet)
property bool forceSolidPanel: (latteView && latteView.visibility
&& Latte.WindowSystem.compositingActive
&& !inConfigureAppletsMode
&& userShowPanelBackground
&& ( (plasmoid.configuration.solidBackgroundForMaximized
&& !(hasExpandedApplet && !plasmaBackgroundForPopups)
&& latteView.windowsTracker.existsWindowTouching)
|| (hasExpandedApplet && plasmaBackgroundForPopups) ))
|| !Latte.WindowSystem.compositingActive
property bool forceTransparentPanel: root.backgroundOnlyOnMaximized
&& latteView && latteView.visibility
&& Latte.WindowSystem.compositingActive
&& !inConfigureAppletsMode
&& !forceSolidPanel
&& !(windowColors === Latte.Types.TouchingWindowColors && latteView.windowsTracker.activeWindowTouching)
&& !(windowColors === Latte.Types.ActiveWindowColors && latteView.windowsTracker.existsWindowActive)
property bool forcePanelForBusyBackground: userShowPanelBackground && root.forceTransparentPanel
&& colorizerManager.mustBeShown && colorizerManager.backgroundIsBusy
property int themeColors: plasmoid.configuration.themeColors
property int windowColors: plasmoid.configuration.windowColors
property bool colorizerEnabled: themeColors !== Latte.Types.PlasmaThemeColors || windowColors !== Latte.Types.NoneWindowColors
property bool plasmaBackgroundForPopups: plasmoid.configuration.plasmaBackgroundForPopups
readonly property bool hasExpandedApplet: plasmoid.applets.some(function (item) {
return (item.status >= PlasmaCore.Types.NeedsAttentionStatus && item.status !== PlasmaCore.Types.HiddenStatus
&& item.pluginName !== root.plasmoidName
&& item.pluginName !== "org.kde.plasma.appmenu"
&& item.pluginName !== "org.kde.windowappmenu"
&& item.pluginName !== "org.kde.activeWindowControl");
})
readonly property bool hasUserSpecifiedBackground: (latteView && latteView.managedLayout && latteView.managedLayout.background.startsWith("/")) ?
true : false
readonly property bool inConfigureAppletsMode: root.editMode && (plasmoid.configuration.inConfigureAppletsMode || !Latte.WindowSystem.compositingActive)
readonly property bool parabolicEffectEnabled: zoomFactor>1 && !inConfigureAppletsMode
property bool dockIsShownCompletely: !(dockIsHidden || inSlidingIn || inSlidingOut) && !root.editMode
+ property bool dragActiveWindowEnabled: plasmoid.configuration.dragActiveWindowEnabled
property bool immutable: plasmoid.immutable
property bool inFullJustify: (plasmoid.configuration.panelPosition === Latte.Types.Justify) && (plasmoid.configuration.maxLength===100)
property bool inSlidingIn: visibilityManager ? visibilityManager.inSlidingIn : false
property bool inSlidingOut: visibilityManager ? visibilityManager.inSlidingOut : false
property bool inStartup: true
property bool isHalfShown: false //is used to disable the zoom hovering effect at sliding in-out the dock
property bool isHorizontal: plasmoid.formFactor === PlasmaCore.Types.Horizontal
property bool isReady: !(dockIsHidden || inSlidingIn || inSlidingOut)
property bool isVertical: !isHorizontal
property bool isHovered: latteApplet ? ((latteAppletHoveredIndex !== -1) || (layoutsContainer.hoveredIndex !== -1)) //|| wholeArea.containsMouse
: (layoutsContainer.hoveredIndex !== -1) //|| wholeArea.containsMouse
property bool mouseWheelActions: plasmoid.configuration.mouseWheelActions
property bool normalState : false
property bool onlyAddingStarup: true //is used for the initialization phase in startup where there aren't removals, this variable provides a way to grow icon size
property bool shrinkThickMargins: plasmoid.configuration.shrinkThickMargins
property bool showLatteShortcutBadges: false
property bool showAppletShortcutBadges: false
property bool showMetaBadge: false
property int applicationLauncherId: -1
//FIXME: possibly this is going to be the default behavior, this user choice
//has been dropped from the Dock Configuration Window
//property bool smallAutomaticIconJumps: plasmoid.configuration.smallAutomaticIconJumps
property bool smallAutomaticIconJumps: true
property bool userShowPanelBackground: Latte.WindowSystem.compositingActive ? plasmoid.configuration.useThemePanel : true
property bool useThemePanel: noApplets === 0 || !Latte.WindowSystem.compositingActive ?
true : (plasmoid.configuration.useThemePanel || plasmoid.configuration.solidBackgroundForMaximized)
property alias hoveredIndex: layoutsContainer.hoveredIndex
property alias directRenderDelayerIsRunning: directRenderDelayerForEnteringTimer.running
property int actionsBlockHiding: 0 //actions that block hiding
property int animationsNeedBothAxis:0 //animations need space in both axes, e.g zooming a task
property int animationsNeedLength: 0 // animations need length, e.g. adding a task
property int animationsNeedThickness: 0 // animations need thickness, e.g. bouncing animation
property int animationTime: durationTime*2.8*units.longDuration
property int automaticIconSizeBasedSize: -1 //it is not set, this is the defautl
//what is the highest icon size based on what icon size is used, screen calculated or user specified
property int maxIconSize: proportionIconSize!==-1 ? proportionIconSize : plasmoid.configuration.iconSize
property int iconSize: automaticIconSizeBasedSize > 0 && autoDecreaseIconSize ?
Math.min(automaticIconSizeBasedSize, root.maxIconSize) :
root.maxIconSize
property int proportionIconSize: { //icon size based on screen height
if ((plasmoid.configuration.proportionIconSize===-1) || !latteView)
return -1;
return Math.max(16,Math.round(latteView.screenGeometry.height * plasmoid.configuration.proportionIconSize/100/8)*8);
}
property int iconStep: 8
property int latteAppletPos: -1
property int maxLength: {
if (root.isHorizontal) {
return behaveAsPlasmaPanel ? width : width * (plasmoid.configuration.maxLength/100)
} else {
return behaveAsPlasmaPanel ? height : height * (plasmoid.configuration.maxLength/100)
}
}
property int leftClickAction: plasmoid.configuration.leftClickAction
property int middleClickAction: plasmoid.configuration.middleClickAction
property int hoverAction: plasmoid.configuration.hoverAction
property int modifier: plasmoid.configuration.modifier
property int modifierClickAction: plasmoid.configuration.modifierClickAction
property int modifierClick: plasmoid.configuration.modifierClick
property int scrollAction: plasmoid.configuration.scrollAction
property bool panelOutline: plasmoid.configuration.panelOutline
property int panelEdgeSpacing: Math.max(panelBoxBackground.lengthMargins, 1.5*appShadowSize)
property int panelTransparency: plasmoid.configuration.panelTransparency //user set
property int currentPanelTransparency: 0 //application override
readonly property real currentPanelOpacity: currentPanelTransparency/100
property bool panelShadowsActive: {
if (!userShowPanelBackground) {
return false;
}
if (inConfigureAppletsMode) {
return plasmoid.configuration.panelShadows;
}
//! Draw shadows for isBusy state only when current panelTransparency is greater than 40%
if (plasmoid.configuration.panelShadows && root.forcePanelForBusyBackground && currentPanelTransparency>40) {
return true;
}
if (( (plasmoid.configuration.panelShadows && !root.backgroundOnlyOnMaximized)
|| (plasmoid.configuration.panelShadows && root.backgroundOnlyOnMaximized && !root.forceTransparentPanel))
&& !(disablePanelShadowMaximized && latteView && latteView.windowsTracker
&& latteView.windowsTracker.activeWindowMaximized)) {
return true;
}
if (hasExpandedApplet && plasmaBackgroundForPopups) {
return true;
}
return false;
}
property int appShadowOpacity: (plasmoid.configuration.shadowOpacity/100) * 255
property int appShadowSize: enableShadows ? (0.5*root.iconSize) * (plasmoid.configuration.shadowSize/100) : 0
property int appShadowSizeOriginal: enableShadows ? (0.5*maxIconSize) * (plasmoid.configuration.shadowSize/100) : 0
property string appChosenShadowColor: {
if (plasmoid.configuration.shadowColorType === Latte.Types.ThemeColorShadow) {
var strC = String(theme.textColor);
return strC.indexOf("#") === 0 ? strC.substr(1) : strC;
} else if (plasmoid.configuration.shadowColorType === Latte.Types.UserColorShadow) {
return plasmoid.configuration.shadowColor;
}
// default shadow color
return "080808";
}
property string appShadowColor: "#" + decimalToHex(appShadowOpacity) + appChosenShadowColor
property string appShadowColorSolid: "#" + appChosenShadowColor
property int totalPanelEdgeSpacing: 0 //this is set by PanelBox
//FIXME: this is not needed any more probably
property int previousAllTasks: -1 //is used to forbid updateAutomaticIconSize when hovering
property int offset: {
/*if (behaveAsPlasmaPanel) {
return 0;
}*/
if (root.isHorizontal) {
return width * (plasmoid.configuration.offset/100);
} else {
height * (plasmoid.configuration.offset/100)
}
}
//center the layout correctly when the user uses an offset
property int offsetFixed: (offset===0 || panelAlignment === Latte.Types.Center || plasmoid.configuration.panelPosition === Latte.Types.Justify)?
offset : offset+panelMarginLength/2+totalPanelEdgeSpacing/2
property int realPanelSize: 0
property int realPanelLength: 0
property int realPanelThickness: 0
//this is set by the PanelBox
property int panelThickMarginBase: 0
property int panelThickMarginHigh: 0
property int panelMarginLength: 0
property int panelShadow: 0 //shadowsSize
property int editShadow: {
if (!Latte.WindowSystem.compositingActive) {
return 0;
} else if (latteView && latteView.screenGeometry) {
return latteView.screenGeometry.height/90;
} else {
return 7;
}
}
property int themePanelThickness: {
var panelBase = root.panelThickMarginHigh;
var margin = shrinkThickMargins ? 0 : thickMargins;
var maxPanelSize = (iconSize + margin) - panelBase;
var percentage = Latte.WindowSystem.compositingActive ? plasmoid.configuration.panelSize/100 : 1;
return Math.max(panelBase, panelBase + percentage*maxPanelSize);
}
property int lengthIntMargin: lengthIntMarginFactor * root.iconSize
property int lengthExtMargin: lengthExtMarginFactor * root.iconSize
property real lengthIntMarginFactor: indicators.isEnabled ? indicators.padding : 0
property real lengthExtMarginFactor: plasmoid.configuration.lengthExtMargin / 100
property real thickMarginFactor: {
if (shrinkThickMargins) {
return indicators.info.minThicknessPadding;
}
//0.075 old statesLineSize and 0.06 old default thickMargin
return Math.max(indicators.info.minThicknessPadding, plasmoid.configuration.thickMargin / 100)
}
property int thickMargin: thickMarginFactor * root.iconSize
//! thickness margins are always two and equal in order for items
//! to be always correctly centered
property int thickMargins: 2 * thickMargin
//it is used in order to not break the calculations for the thickness placement
//especially in automatic icon sizes calculations
property int maxThickMargin: thickMarginFactor * maxIconSize
property int lengthMargin: lengthIntMargin + lengthExtMargin
property int lengthMargins: 2 * lengthMargin
///FIXME: I can't remember why this is needed, maybe for the anchorings!!! In order for the Double Layout to not mess the anchorings...
//property int layoutsContainer.mainLayoutPosition: !plasmoid.immutable ? Latte.Types.Center : (root.isVertical ? Latte.Types.Top : Latte.Types.Left)
//property int panelAlignment: plasmoid.configuration.panelPosition !== Latte.Types.Justify ? plasmoid.configuration.panelPosition : layoutsContainer.mainLayoutPosition
property int panelAlignment: !root.inConfigureAppletsMode ? plasmoid.configuration.panelPosition :
( plasmoid.configuration.panelPosition === Latte.Types.Justify ?
Latte.Types.Center : plasmoid.configuration.panelPosition )
property int panelUserSetAlignment: plasmoid.configuration.panelPosition
property real zoomFactor: Latte.WindowSystem.compositingActive ? ( 1 + (plasmoid.configuration.zoomLevel / 20) ) : 1
readonly property string plasmoidName: "org.kde.latte.plasmoid"
property var badgesForActivate: {
if (!shortcutsEngine) {
return ['1','2','3','4','5','6','7','8','9','0', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.'];
}
return shortcutsEngine.badgesForActivate;
}
property var iconsArray: [16, 22, 32, 48, 64, 96, 128, 256]
property Item dragOverlay
property Item toolBox
property Item latteAppletContainer
property Item latteApplet
readonly property Item indicatorsManager: indicators
readonly property Item parabolicManager: _parabolicManager
property QtObject latteView: null
property QtObject shortcutsEngine: null
property QtObject themeExtended: null
property QtObject universalSettings: null
property QtObject universalLayoutManager: null
property QtObject managedLayout: latteView && latteView.managedLayout ? latteView.managedLayout : null
// TO BE DELETED, if not needed: property int counter:0;
///BEGIN properties provided to Latte Plasmoid
//shadows for applets, it should be removed as the appleitems don't need it any more
property bool enableShadows: plasmoid.configuration.shadows || (root.forceTransparentPanel && plasmoid.configuration.shadows>0)
property bool dockIsHidden: latteView ? latteView.visibility.isHidden : true
property bool groupTasksByDefault: plasmoid.configuration.groupTasksByDefault
property bool showInfoBadge: plasmoid.configuration.showInfoBadge
property bool showProgressBadge: plasmoid.configuration.showProgressBadge
property bool showAudioBadge: plasmoid.configuration.showAudioBadge
property bool audioBadgeActionsEnabled: plasmoid.configuration.audioBadgeActionsEnabled
property bool showWindowActions: plasmoid.configuration.showWindowActions
property bool showWindowsOnlyFromLaunchers: plasmoid.configuration.showWindowsOnlyFromLaunchers
property bool showOnlyCurrentScreen: plasmoid.configuration.showOnlyCurrentScreen
property bool showOnlyCurrentDesktop: plasmoid.configuration.showOnlyCurrentDesktop
property bool showOnlyCurrentActivity: plasmoid.configuration.showOnlyCurrentActivity
property bool titleTooltips: plasmoid.configuration.titleTooltips
property bool unifiedGlobalShortcuts: plasmoid.configuration.unifiedGlobalShortcuts
readonly property bool hasInternalSeparator: latteApplet ? latteApplet.hasInternalSeparator : false
property int animationStep: {
if (!universalSettings || universalSettings.mouseSensitivity === Latte.Types.HighSensitivity) {
return 1;
} else if (universalSettings.mouseSensitivity === Latte.Types.MediumSensitivity) {
return Math.max(3, root.iconSize / 18);
} else if (universalSettings.mouseSensitivity === Latte.Types.LowSensitivity) {
return Math.max(5, root.iconSize / 10);
}
}
property int latteAppletHoveredIndex: latteApplet ? latteApplet.hoveredIndex : -1
property int launchersGroup: plasmoid.configuration.launchersGroup
property int tasksCount: latteApplet ? latteApplet.tasksCount : 0
//! Animations
property bool animationsEnabled: plasmoid.configuration.animationsEnabled && Latte.WindowSystem.compositingActive
property bool animationLauncherBouncing: animationsEnabled && latteApplet && plasmoid.configuration.animationLauncherBouncing
property bool animationWindowInAttention: animationsEnabled && latteApplet && plasmoid.configuration.animationWindowInAttention
property bool animationNewWindowSliding: animationsEnabled && latteApplet && plasmoid.configuration.animationNewWindowSliding
property bool animationWindowAddedInGroup: animationsEnabled && latteApplet && plasmoid.configuration.animationWindowAddedInGroup
property bool animationWindowRemovedFromGroup: animationsEnabled && latteApplet && plasmoid.configuration.animationWindowRemovedFromGroup
property real appliedDurationTime: animationsEnabled ? durationTime : 2
property real durationTime: {
if (!animationsEnabled) {
return 0;
}
/*if ((latteView && latteView.effects && latteView.effects.animationsBlocked)
|| !animationsEnabled) {
return 0;
}*/
if (plasmoid.configuration.durationTime === 0 || plasmoid.configuration.durationTime === 2 )
return plasmoid.configuration.durationTime;
if (plasmoid.configuration.durationTime === 1)
return 1.65;
else if (plasmoid.configuration.durationTime === 3)
return 2.35;
return 2;
}
property real animationsZoomFactor : {
if (!animationsEnabled) {
return 1;
}
if (latteApplet && (animationLauncherBouncing || animationWindowInAttention || animationWindowAddedInGroup)) {
return 1.65;
}
return 1;
}
property real maxZoomFactor: Math.max(zoomFactor, animationsZoomFactor)
property rect screenGeometry: latteView ? latteView.screenGeometry : plasmoid.screenGeometry
readonly property color minimizedDotColor: colorizerManager.minimizedDotColor
///END properties from latteApplet
Plasmoid.backgroundHints: PlasmaCore.Types.NoBackground
//// BEGIN properties in functions
property int noApplets: {
var count1 = 0;
var count2 = 0;
count1 = layoutsContainer.mainLayout.children.length;
var tempLength = layoutsContainer.mainLayout.children.length;
for (var i=tempLength-1; i>=0; --i) {
var applet = layoutsContainer.mainLayout.children[i];
if (applet && (applet === dndSpacer || applet === lastSpacer || applet.isInternalViewSplitter))
count1--;
}
count2 = layoutsContainer.endLayout.children.length;
tempLength = layoutsContainer.endLayout.children.length;
for (var i=tempLength-1; i>=0; --i) {
var applet = layoutsContainer.endLayout.children[i];
if (applet && (applet === dndSpacer || applet === lastSpacer || applet.isInternalViewSplitter))
count2--;
}
return (count1 + count2);
}
///The index of user's current icon size
property int currentIconIndex:{
for(var i=iconsArray.length-1; i>=0; --i){
if(iconsArray[i] === iconSize){
return i;
}
}
return 3;
}
//// END properties in functions
////////////////END properties
//// BEGIN OF Behaviors
Behavior on thickMargin {
NumberAnimation {
duration: 0.8 * root.animationTime
easing.type: Easing.OutCubic
}
}
Behavior on lengthIntMargin {
NumberAnimation {
duration: 0.8 * root.animationTime
easing.type: Easing.OutCubic
}
}
Behavior on lengthExtMargin {
NumberAnimation {
duration: 0.8 * root.animationTime
easing.type: Easing.OutCubic
}
}
Behavior on iconSize {
enabled: !(root.editMode && root.behaveAsPlasmaPanel)
NumberAnimation {
duration: 0.8 * root.animationTime
onRunningChanged: {
if (!running) {
delayUpdateMaskArea.start();
}
}
}
}
Behavior on offset {
enabled: editModeVisual.plasmaEditMode
NumberAnimation {
id: offsetAnimation
duration: 0.8 * root.animationTime
easing.type: Easing.OutCubic
}
}
//// END OF Behaviors
//////////////START OF CONNECTIONS
onContainsOnlyPlasmaTasksChanged: updateAutomaticIconSize();
onEditModeChanged: {
if (editMode) {
visibilityManager.updateMaskArea();
updateAutomaticIconSize();
clearZoom();
} else {
updateAutomaticIconSize();
layoutsContainer.updateSizeForAppletsInFill();
}
//! This is used in case the dndspacer has been left behind
//! e.g. the user drops a folder and a context menu is appearing
//! but the user decides to not make a choice for the applet type
if (dndSpacer.parent !== root) {
dndSpacer.parent = root;
}
}
onInConfigureAppletsModeChanged: {
if (inConfigureAppletsMode && panelUserSetAlignment===Latte.Types.Justify) {
joinLayoutsToMainLayout();
} else if (!inConfigureAppletsMode) {
splitMainLayoutToLayouts();
}
updateIndexes();
}
//! It is used only when the user chooses different alignment types
//! and not during startup
onPanelUserSetAlignmentChanged: {
if (!root.editMode) {
return;
}
if (!inConfigureAppletsMode){
if (panelUserSetAlignment===Latte.Types.Justify) {
addInternalViewSplitters();
splitMainLayoutToLayouts();
} else {
joinLayoutsToMainLayout();
root.destroyInternalViewSplitters();
}
} else {
if (panelUserSetAlignment===Latte.Types.Justify) {
addInternalViewSplitters();
} else {
root.destroyInternalViewSplitters();
}
}
updateIndexes();
}
onLatteViewChanged: {
if (latteView) {
latteView.onXChanged.connect(visibilityManager.updateMaskArea);
latteView.onYChanged.connect(visibilityManager.updateMaskArea);
latteView.onWidthChanged.connect(visibilityManager.updateMaskArea);
latteView.onHeightChanged.connect(visibilityManager.updateMaskArea);
latteView.positioner.hideDockDuringLocationChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
latteView.positioner.showDockAfterLocationChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
latteView.positioner.hideDockDuringScreenChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
latteView.positioner.showDockAfterScreenChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
latteView.positioner.hideDockDuringMovingToLayoutStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
latteView.positioner.showDockAfterMovingToLayoutFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
latteView.visibility.onContainsMouseChanged.connect(visibilityManager.slotContainsMouseChanged);
latteView.visibility.onMustBeHide.connect(visibilityManager.slotMustBeHide);
latteView.visibility.onMustBeShown.connect(visibilityManager.slotMustBeShown);
updateContainsOnlyPlasmaTasks();
}
}
onDockContainsMouseChanged: {
if (!dockContainsMouse) {
initializeHoveredIndexes();
}
}
onDragEnter: {
if (plasmoid.immutable || dockIsHidden || visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) {
event.ignore();
return;
}
if (event.mimeData.formats.indexOf("application/x-orgkdeplasmataskmanager_taskbuttonitem") >= 0) {
return;
}
if (latteApplet) {
if (latteApplet.launchersDrop(event)) {
root.addLaunchersMessage = true;
if (root.addLaunchersInTaskManager) {
return;
}
} else {
var isSeparator = ( latteView.mimeContainsPlasmoid(event.mimeData, "audoban.applet.separator")
|| latteView.mimeContainsPlasmoid(event.mimeData, "org.kde.latte.separator") );
if (isSeparator && root.latteAppletContainer.containsPos(event)) {
confirmedDragEntered = true
dndSpacer.opacity = 0;
dndSpacer.parent = root;
return;
}
}
}
if (!confirmedDragEntered) {
confirmedDragEntered = true;
slotAnimationsNeedLength(1);
}
if (!latteApplet || (latteApplet && !latteView.mimeContainsPlasmoid(event.mimeData, "org.kde.latte.plasmoid"))) {
LayoutManager.insertAtCoordinates2(dndSpacer, event.x, event.y)
dndSpacer.opacity = 1;
}
}
onDragMove: {
if (event.mimeData.formats.indexOf("application/x-orgkdeplasmataskmanager_taskbuttonitem") >= 0
|| dockIsHidden || visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) {
return;
}
if (latteApplet) {
if (latteApplet.launchersDrop(event)) {
root.addLaunchersMessage = true;
if (root.addLaunchersInTaskManager) {
return;
}
} else {
var isSeparator = ( latteView.mimeContainsPlasmoid(event.mimeData, "audoban.applet.separator")
|| latteView.mimeContainsPlasmoid(event.mimeData, "org.kde.latte.separator") );
if (isSeparator && root.latteAppletContainer.containsPos(event)) {
confirmedDragEntered = true
dndSpacer.opacity = 0;
dndSpacer.parent = root;
return;
}
}
}
if (!latteApplet || (latteApplet && !latteView.mimeContainsPlasmoid(event.mimeData, "org.kde.latte.plasmoid"))) {
LayoutManager.insertAtCoordinates2(dndSpacer, event.x, event.y)
dndSpacer.opacity = 1;
}
}
onDragLeave: {
if (confirmedDragEntered) {
slotAnimationsNeedLength(-1);
confirmedDragEntered = false;
}
root.addLaunchersMessage = false;
dndSpacer.opacity = 0;
dndSpacer.parent = root;
}
onDrop: {
if (dockIsHidden || visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) {
return;
}
if (event.mimeData.formats.indexOf("application/x-orgkdeplasmataskmanager_taskbuttonitem") < 0) {
if (latteApplet && latteApplet.launchersDrop(event) && root.addLaunchersInTaskManager) {
latteApplet.launchersDropped(event.mimeData.urls);
} else if (!latteApplet || (latteApplet && !latteView.mimeContainsPlasmoid(event.mimeData, "org.kde.latte.plasmoid"))) {
plasmoid.processMimeData(event.mimeData, event.x, event.y);
event.accept(event.proposedAction);
}
}
if (confirmedDragEntered) {
slotAnimationsNeedLength(-1);
confirmedDragEntered = false;
}
root.addLaunchersMessage = false;
dndSpacer.opacity = 0;
//! this line is very important because it positions correctly the new applets
//dndSpacer.parent = root;
}
onMaxLengthChanged: {
layoutsContainer.updateSizeForAppletsInFill();
if (root.editMode) {
updateAutomaticIconSize();
}
}
onToolBoxChanged: {
if (toolBox) {
toolBox.visible = false;
}
}
property bool automaticSizeAnimation: false;
onAutomaticIconSizeBasedSizeChanged: {
if (!automaticSizeAnimation) {
automaticSizeAnimation = true;
slotAnimationsNeedBothAxis(1);
}
}
onIconSizeChanged: {
if (((iconSize === automaticIconSizeBasedSize) || (iconSize === root.maxIconSize)) && automaticSizeAnimation){
slotAnimationsNeedBothAxis(-1);
automaticSizeAnimation=false;
}
}
onIsReadyChanged: {
if (isReady && !titleTooltipDialog.visible && titleTooltipDialog.activeItemHovered){
titleTooltipDialog.show(titleTooltipDialog.activeItem, titleTooltipDialog.activeItemText);
}
}
onIsVerticalChanged: {
if (isVertical) {
if (plasmoid.configuration.panelPosition === Latte.Types.Left)
plasmoid.configuration.panelPosition = Latte.Types.Top;
else if (plasmoid.configuration.panelPosition === Latte.Types.Right)
plasmoid.configuration.panelPosition = Latte.Types.Bottom;
} else {
if (plasmoid.configuration.panelPosition === Latte.Types.Top)
plasmoid.configuration.panelPosition = Latte.Types.Left;
else if (plasmoid.configuration.panelPosition === Latte.Types.Bottom)
plasmoid.configuration.panelPosition = Latte.Types.Right;
}
}
onProportionIconSizeChanged: {
if (proportionIconSize!==-1)
updateAutomaticIconSize();
}
// onIconSizeChanged: console.log("Icon Size Changed:"+iconSize);
Component.onCompleted: {
// currentLayout.isLayoutHorizontal = isHorizontal
LayoutManager.plasmoid = plasmoid;
LayoutManager.root = root;
LayoutManager.layout = layoutsContainer.mainLayout;
LayoutManager.layoutS = layoutsContainer.startLayout;
LayoutManager.layoutE = layoutsContainer.endLayout;
LayoutManager.lastSpacer = lastSpacer;
LayoutManager.restore();
plasmoid.action("configure").visible = !plasmoid.immutable;
plasmoid.action("configure").enabled = !plasmoid.immutable;
inStartupTimer.start();
}
Component.onDestruction: {
console.debug("Destroying Latte Dock Containment ui...");
if (latteView) {
latteView.onXChanged.disconnect(visibilityManager.updateMaskArea);
latteView.onYChanged.disconnect(visibilityManager.updateMaskArea);
latteView.onWidthChanged.disconnect(visibilityManager.updateMaskArea);
latteView.onHeightChanged.disconnect(visibilityManager.updateMaskArea);
latteView.positioner.hideDockDuringLocationChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
latteView.positioner.showDockAfterLocationChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
latteView.positioner.hideDockDuringScreenChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
latteView.positioner.showDockAfterScreenChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
latteView.positioner.hideDockDuringMovingToLayoutStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
latteView.positioner.showDockAfterMovingToLayoutFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
if (latteView.visibility) {
latteView.visibility.onContainsMouseChanged.disconnect(visibilityManager.slotContainsMouseChanged);
latteView.visibility.onMustBeHide.disconnect(visibilityManager.slotMustBeHide);
latteView.visibility.onMustBeShown.disconnect(visibilityManager.slotMustBeShown);
}
}
}
Containment.onAppletAdded: {
addApplet(applet, x, y);
console.log(applet.pluginName);
LayoutManager.save();
updateIndexes();
}
Containment.onAppletRemoved: {
LayoutManager.removeApplet(applet);
var flexibleFound = false;
for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
var applet = layoutsContainer.mainLayout.children[i].applet;
if (applet && ((root.isHorizontal && applet.Layout.fillWidth) ||
(!root.isHorizontal && applet.Layout.fillHeight)) &&
applet.visible) {
flexibleFound = true;
break
}
}
if (!flexibleFound) {
lastSpacer.parent = layoutsContainer.mainLayout;
}
console.log(applet.pluginName);
LayoutManager.save();
updateIndexes();
updateContainsOnlyPlasmaTasks();
}
Plasmoid.onUserConfiguringChanged: {
if (plasmoid.immutable) {
if (dragOverlay) {
dragOverlay.destroy();
}
return;
}
// console.debug("user configuring", plasmoid.userConfiguring)
if (plasmoid.userConfiguring) {
latteView.setBlockHiding(true);
// console.log("applets------");
for (var i = 0; i < plasmoid.applets.length; ++i) {
// console.log("applet:"+i);
plasmoid.applets[i].expanded = false;
}
if (!dragOverlay) {
var component = Qt.createComponent("editmode/ConfigOverlay.qml");
if (component.status == Component.Ready) {
dragOverlay = component.createObject(root);
} else {
console.log("Could not create ConfigOverlay");
console.log(component.errorString());
}
component.destroy();
} else {
dragOverlay.visible = true;
}
} else {
latteView.setBlockHiding(false);
if (latteView.visibility.isHidden) {
latteView.visibility.mustBeShown();
}
if (dragOverlay) {
dragOverlay.visible = false;
dragOverlay.destroy();
}
}
}
Plasmoid.onImmutableChanged: {
plasmoid.action("configure").visible = !plasmoid.immutable;
plasmoid.action("configure").enabled = !plasmoid.immutable;
///Set Preferred Sizes///
///Notice: they are set here because if they are set with a binding
///they break the !immutable experience, the latteView becomes too small
///to add applets
/* if (plasmoid.immutable) {
if(root.isHorizontal) {
root.Layout.preferredWidth = (plasmoid.configuration.panelPosition === Latte.Types.Justify ?
layoutsContainer.width + 0.5*iconMargin : layoutsContainer.mainLayout.width + iconMargin);
} else {
root.Layout.preferredHeight = (plasmoid.configuration.panelPosition === Latte.Types.Justify ?
layoutsContainer.height + 0.5*iconMargin : layoutsContainer.mainLayout.height + iconMargin);
}
} else {
if (root.isHorizontal) {
root.Layout.preferredWidth = Screen.width;
} else {
root.Layout.preferredHeight = Screen.height;
}
}*/
visibilityManager.updateMaskArea();
}
//////////////END OF CONNECTIONS
//////////////START OF FUNCTIONS
function addApplet(applet, x, y) {
var container = appletContainerComponent.createObject(dndSpacer.parent)
container.applet = applet;
applet.parent = container.appletWrapper;
applet.anchors.fill = container.appletWrapper;
applet.visible = true;
// don't show applet if it chooses to be hidden but still make it
// accessible in the panelcontroller
container.visible = Qt.binding(function() {
return applet.status !== PlasmaCore.Types.HiddenStatus || (!plasmoid.immutable && plasmoid.userConfiguring)
})
addContainerInLayout(container, applet, x, y);
updateContainsOnlyPlasmaTasks();
}
function addContainerInLayout(container, applet, x, y){
// Is there a DND placeholder? Replace it!
if ( (dndSpacer.parent === layoutsContainer.mainLayout)
|| (dndSpacer.parent === layoutsContainer.startLayout)
|| (dndSpacer.parent===layoutsContainer.endLayout)) {
LayoutManager.insertBeforeForLayout(dndSpacer.parent, dndSpacer, container);
dndSpacer.parent = root;
return;
// If the provided position is valid, use it.
} else if (x >= 0 && y >= 0) {
var index = LayoutManager.insertAtCoordinates2(container, x , y);
// Fall through to determining an appropriate insert position.
} else {
var before = null;
container.animationsEnabled = false;
if (lastSpacer.parent === layoutsContainer.mainLayout) {
before = lastSpacer;
}
// Insert icons to the left of whatever is at the center (usually a Task Manager),
// if it exists.
// FIXME TODO: This is a real-world fix to produce a sensible initial position for
// launcher icons added by launcher menu applets. The basic approach has been used
// since Plasma 1. However, "add launcher to X" is a generic-enough concept and
// frequent-enough occurrence that we'd like to abstract it further in the future
// and get rid of the ugliness of parties external to the containment adding applets
// of a specific type, and the containment caring about the applet type. In a better
// system the containment would be informed of requested launchers, and determine by
// itself what it wants to do with that information.
if (applet.pluginName == "org.kde.plasma.icon") {
var middle = layoutsContainer.mainLayout.childAt(root.width / 2, root.height / 2);
if (middle) {
before = middle;
}
// Otherwise if lastSpacer is here, enqueue before it.
}
if (before) {
LayoutManager.insertBefore(before, container);
// Fall through to adding at the end.
} else {
container.parent = layoutsContainer.mainLayout;
}
}
//Important, removes the first children of the layoutsContainer.mainLayout after the first
//applet has been added
lastSpacer.parent = root;
updateIndexes();
}
function addInternalViewSplitters(){
if (internalViewSplittersCount() === 0) {
addInternalViewSplitter(plasmoid.configuration.splitterPosition);
addInternalViewSplitter(plasmoid.configuration.splitterPosition2);
}
}
function addInternalViewSplitter(pos){
var splittersCount = internalViewSplittersCount();
if(splittersCount<2){
var container = appletContainerComponent.createObject(root);
container.internalSplitterId = splittersCount+1;
container.visible = true;
if(pos>=0 ){
LayoutManager.insertAtIndex(container, pos);
} else {
LayoutManager.insertAtIndex(container, Math.floor(layoutsContainer.mainLayout.count / 2));
}
}
}
//! it is used in order to check the right click position
//! the only way to take into account the visual appearance
//! of the applet (including its spacers)
function appletContainsPos(appletId, pos){
for (var i = 0; i < layoutsContainer.startLayout.children.length; ++i) {
var child = layoutsContainer.startLayout.children[i];
if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
return true;
}
for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
var child = layoutsContainer.mainLayout.children[i];
if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
return true;
}
for (var i = 0; i < layoutsContainer.endLayout.children.length; ++i) {
var child = layoutsContainer.endLayout.children[i];
if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
return true;
}
return false;
}
function checkLastSpacer() {
lastSpacer.parent = root
var expands = false;
if (isHorizontal) {
for (var container in layoutsContainer.mainLayout.children) {
var item = layoutsContainer.mainLayout.children[container];
if (item.Layout && item.Layout.fillWidth) {
expands = true;
}
}
} else {
for (var container in layoutsContainer.mainLayout.children) {
var item = layoutsContainer.mainLayout.children[container];
if (item.Layout && item.Layout.fillHeight) {
expands = true;
}
}
}
if (!expands) {
lastSpacer.parent = layoutsContainer.mainLayout
}
}
function clearZoom(){
if (latteApplet){
latteApplet.clearZoom();
}
root.clearZoomSignal();
}
function containmentActions(){
return latteView.containmentActions();
}
function decimalToHex(d, padding) {
var hex = Number(d).toString(16);
padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;
while (hex.length < padding) {
hex = "0" + hex;
}
return hex;
}
function disableDirectRender(){
// root.globalDirectRender = false;
}
function internalViewSplittersCount(){
var splitters = 0;
for (var container in layoutsContainer.startLayout.children) {
var item = layoutsContainer.startLayout.children[container];
if(item && item.isInternalViewSplitter) {
splitters = splitters + 1;
}
}
for (var container in layoutsContainer.mainLayout.children) {
var item = layoutsContainer.mainLayout.children[container];
if(item && item.isInternalViewSplitter) {
splitters = splitters + 1;
}
}
for (var container in layoutsContainer.endLayout.children) {
var item = layoutsContainer.endLayout.children[container];
if(item && item.isInternalViewSplitter) {
splitters = splitters + 1;
}
}
return splitters;
}
function initializeHoveredIndexes() {
layoutsContainer.hoveredIndex = -1;
layoutsContainer.currentSpot = -1000;
if (latteApplet) {
latteApplet.initializeHoveredIndex();
}
}
function layoutManagerInsertBefore(place, item) {
LayoutManager.insertBefore(place, item);
}
function layoutManagerInsertAfter(place, item) {
LayoutManager.insertAfter(place, item);
}
function layoutManagerSave() {
LayoutManager.save();
}
function layoutManagerSaveOptions() {
LayoutManager.saveOptions();
}
function mouseInCanBeHoveredApplet(){
if (latteApplet && latteApplet.containsMouse())
return true;
var applets = layoutsContainer.startLayout.children;
for(var i=0; i=0; --i){
if(iconsArray[i] === size){
return true;
}
}
return false;
}
function slotAnimationsNeedBothAxis(step) {
if (step === 0) {
return;
}
animationsNeedBothAxis = Math.max(animationsNeedBothAxis + step, 0);
visibilityManager.updateMaskArea();
}
function slotAnimationsNeedLength(step) {
if (step === 0) {
return;
}
animationsNeedLength = Math.max(animationsNeedLength + step, 0);
//when need length animations are ended it would be a good idea
//to update the tasks geometries in the plasmoid
if(animationsNeedLength === 0 && latteApplet) {
latteApplet.publishTasksGeometries();
}
visibilityManager.updateMaskArea();
}
function slotAnimationsNeedThickness(step) {
if (step === 0) {
return;
}
animationsNeedThickness = Math.max(animationsNeedThickness + step, 0);
visibilityManager.updateMaskArea();
}
//this is used when dragging a task in order to not hide the dock
//and also by the menu appearing from tasks for the same reason
function slotActionsBlockHiding(step) {
//if (root.editMode) {
// return;
// }
if ((step === 0) || (!latteView)) {
return;
}
actionsBlockHiding = Math.max(actionsBlockHiding + step, 0);
if (actionsBlockHiding > 0){
latteView.setBlockHiding(true);
} else {
if (!root.editMode)
latteView.setBlockHiding(false);
}
}
function slotPreviewsShown(){
if (latteView) {
latteView.deactivateApplets();
}
}
function startCheckRestoreZoomTimer(){
checkRestoreZoom.start();
}
function stopCheckRestoreZoomTimer(){
checkRestoreZoom.stop();
}
function startDirectRenderDelayerDuringEntering(){
directRenderDelayerForEnteringTimer.start();
}
function setGlobalDirectRender(value) {
if (latteApplet && latteApplet.waitingLaunchers.length > 0)
return;
if (value === true) {
if (mouseInCanBeHoveredApplet()) {
root.globalDirectRender = true;
} else {
// console.log("direct render true ignored...");
}
} else {
root.globalDirectRender = false;
}
}
function updateAutomaticIconSize() {
if ( !blockAutomaticUpdateIconSize.running && !visibilityManager.inTempHiding
&& ((visibilityManager.normalState || root.editMode)
&& (root.autoDecreaseIconSize || (!root.autoDecreaseIconSize && root.iconSize!=root.maxIconSize)))
&& (iconSize===root.maxIconSize || iconSize === automaticIconSizeBasedSize) ) {
blockAutomaticUpdateIconSize.start();
var layoutLength;
var maxLength = root.maxLength;
//console.log("------Entered check-----");
//console.log("max length: "+ maxLength);
if (root.isVertical) {
layoutLength = (plasmoid.configuration.panelPosition === Latte.Types.Justify) ?
layoutsContainer.startLayout.height+layoutsContainer.mainLayout.height+layoutsContainer.endLayout.height : layoutsContainer.mainLayout.height
} else {
layoutLength = (plasmoid.configuration.panelPosition === Latte.Types.Justify) ?
layoutsContainer.startLayout.width+layoutsContainer.mainLayout.width+layoutsContainer.endLayout.width : layoutsContainer.mainLayout.width
}
var toShrinkLimit = maxLength-((root.zoomFactor-1)*(iconSize + thickMargins));
var toGrowLimit = maxLength-1.5*((root.zoomFactor-1)*(iconSize + thickMargins));
var newIconSizeFound = false;
if (layoutLength > toShrinkLimit) { //must shrink
// console.log("step3");
var nextIconSize = root.maxIconSize;
do {
nextIconSize = nextIconSize - iconStep;
var factor = nextIconSize / iconSize;
var nextLength = factor * layoutLength;
} while ( (nextLength>toShrinkLimit) && (nextIconSize !== 16));
automaticIconSizeBasedSize = nextIconSize;
newIconSizeFound = true;
console.log("Step 3 - found:"+automaticIconSizeBasedSize);
} else if ((layoutLength 0) {
if (foundGoodSize === root.maxIconSize) {
automaticIconSizeBasedSize = -1;
} else {
automaticIconSizeBasedSize = foundGoodSize;
}
newIconSizeFound = true
// console.log("Step 4 - found:"+automaticIconSizeBasedSize);
} else {
// console.log("Step 4 - did not found...");
}
}
}
}
function updateContainsOnlyPlasmaTasks() {
if (latteView) {
root.containsOnlyPlasmaTasks = (latteView.tasksPresent() && !latteApplet);
} else {
root.containsOnlyPlasmaTasks = false;
}
}
function updateSizeForAppletsInFill() {
layoutsContainer.updateSizeForAppletsInFill();
}
function splitMainLayoutToLayouts() {
if (internalViewSplittersCount() === 2) {
console.log("LAYOUTS: Moving applets from MAIN to THREE Layouts mode...");
var splitter = -1;
var splitter2 = -1;
var totalChildren = layoutsContainer.mainLayout.children.length;
for (var i=0; i=0 && splitter2 === -1) {
splitter2 = i;
}
}
// console.log("update layouts 1:"+splitter + " - "+splitter2);
for (var i=0; i<=splitter; ++i){
var item = layoutsContainer.mainLayout.children[0];
item.parent = layoutsContainer.startLayout;
}
splitter2 = splitter2 - splitter - 1;
// console.log("update layouts 2:"+splitter + " - "+splitter2);
totalChildren = layoutsContainer.mainLayout.children.length;
for (var i=splitter2+1; i=0; --i) {
var item1 = layoutsContainer.mainLayout.children[0];
item1.parent = layoutsContainer.startLayout;
}
var totalChildren2 = layoutsContainer.endLayout.children.length;
for (var i=totalChildren2-1; i>=0; --i) {
var item2 = layoutsContainer.endLayout.children[0];
item2.parent = layoutsContainer.startLayout;
}
var totalChildrenL = layoutsContainer.startLayout.children.length;
for (var i=totalChildrenL-1; i>=0; --i) {
var itemL = layoutsContainer.startLayout.children[0];
itemL.parent = layoutsContainer.mainLayout;
}
}
//END functions
////BEGIN interfaces
Connections {
target: Latte.WindowSystem
onCompositingActiveChanged: {
visibilityManager.updateMaskArea();
}
}
Connections {
target: latteView
onWidthChanged:{
if (root.isHorizontal && proportionIconSize!==-1)
updateAutomaticIconSize();
}
onHeightChanged:{
if (root.isVertical && proportionIconSize!==-1)
updateAutomaticIconSize();
}
onContextMenuIsShownChanged: {
if (!latteView.contextMenuIsShown) {
checkRestoreZoom.start();
} else {
root.setGlobalDirectRender(false);
}
}
}
Connections{
target: latteView && latteView.visibility ? latteView.visibility : root
ignoreUnknownSignals : true
onContainsMouseChanged: {
if (mouseInHoverableArea()) {
stopCheckRestoreZoomTimer();
} else {
startCheckRestoreZoomTimer();
}
}
}
Connections{
target: layoutsContainer
onHoveredIndexChanged: {
if (latteApplet && layoutsContainer.hoveredIndex>-1){
latteApplet.setHoveredIndex(-1);
}
if (latteApplet && latteApplet.windowPreviewIsShown && layoutsContainer.hoveredIndex>-1) {
latteApplet.hidePreview();
}
}
}
////END interfaces
/////BEGIN: Title Tooltip///////////
PlasmaCore.Dialog{
id: titleTooltipDialog
type: PlasmaCore.Dialog.Tooltip
flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
location: plasmoid.location
mainItem: RowLayout{
Layout.fillWidth: true
Layout.fillHeight: true
PlasmaComponents.Label{
id:titleLbl
Layout.leftMargin: 4
Layout.rightMargin: 4
Layout.topMargin: 2
Layout.bottomMargin: 2
text: titleTooltipDialog.title
}
}
visible: false
property string title: ""
property bool activeItemHovered: false
property Item activeItem: null
property Item activeItemTooltipParent: null
property string activeItemText: ""
Component.onCompleted: {
root.clearZoomSignal.connect(titleTooltipDialog.hide);
}
Component.onDestruction: {
root.clearZoomSignal.disconnect(titleTooltipDialog.hide);
}
function hide(debug){
if (!root.titleTooltips)
return;
activeItemHovered = false;
hideTitleTooltipTimer.start();
}
function show(taskItem, text){
if (!root.titleTooltips || (latteApplet && latteApplet.contextMenu)){
return;
}
activeItemHovered = true;
if (activeItem !== taskItem) {
activeItem = taskItem;
activeItemTooltipParent = taskItem.tooltipVisualParent;
activeItemText = text;
}
if (isReady) {
showTitleTooltipTimer.start();
}
}
function update() {
activeItemHovered = true
title = activeItemText;
visualParent = activeItemTooltipParent;
if (latteApplet && latteApplet.windowPreviewIsShown) {
latteApplet.hidePreview();
}
visible = true;
}
}
Timer {
id: showTitleTooltipTimer
interval: 100
onTriggered: {
if (latteView && latteView.visibility && latteView.visibility.containsMouse) {
titleTooltipDialog.update();
}
if (titleTooltipDialog.visible) {
titleTooltipCheckerToNotShowTimer.start();
}
if (root.debugModeTimers) {
console.log("containment timer: showTitleTooltipTimer called...");
}
}
}
Timer {
id: hideTitleTooltipTimer
interval: 200
onTriggered: {
if (!titleTooltipDialog.activeItemHovered) {
titleTooltipDialog.visible = false;
}
if (root.debugModeTimers) {
console.log("containment timer: hideTitleTooltipTimer called...");
}
}
}
//! Timer to fix #811, rare cases that both a window preview and context menu are
//! shown
Timer {
id: titleTooltipCheckerToNotShowTimer
interval: 250
onTriggered: {
if (titleTooltipDialog.visible && latteApplet && (latteApplet.contextMenu || latteApplet.windowPreviewIsShown)) {
titleTooltipDialog.visible = false;
}
}
}
/////END: Title Tooltip///////////
///////////////BEGIN components
Component {
id: appletContainerComponent
Applet.AppletItem{}
}
ParabolicManager{
id: _parabolicManager
}
Indicators.Manager{
id: indicators
}
///////////////END components
PlasmaCore.ColorScope{
id: colorScopePalette
}
///////////////BEGIN UI elements
//it is used to check if the mouse is outside the layoutsContainer borders,
//so in that case the onLeave event behavior should be trigerred
RootMouseArea{
id: rootMouseArea
}
Loader{
active: root.debugModeWindow
sourceComponent: DebugWindow{}
}
//! Load a sepia background in order to avoid black background
Loader{
anchors.fill: parent
active: !Latte.WindowSystem.compositingActive
sourceComponent: Image{
anchors.fill: parent
fillMode: Image.Tile
source: root.hasUserSpecifiedBackground ? latteView.managedLayout.background : "../icons/wheatprint.jpg"
}
}
EditMode.Visual{
id:editModeVisual
// z: root.behaveAsPlasmaPanel ? 1 : 0
}
Item{
id: panelBox
anchors.fill:layoutsContainer
// z: root.behaveAsPlasmaPanel ? 0 : 1
PanelBox{
id: panelBoxBackground
}
}
Item {
id: lastSpacer
parent: layoutsContainer.mainLayout
Layout.fillWidth: true
Layout.fillHeight: true
z:10
Rectangle{
anchors.fill: parent
color: "transparent"
border.color: "yellow"
border.width: 1
}
}
Item {
id: dndSpacer
property int normalSize: root.iconSize + root.thickMargins - 1
width: normalSize
height: normalSize
Layout.preferredWidth: width
Layout.preferredHeight: height
opacity: 0
z:10
AddWidgetVisual{}
}
Loader{
anchors.fill: parent
active: root.debugMode
z:10
sourceComponent: Item{
Rectangle{
anchors.fill: parent
color: "yellow"
opacity: 0.30
}
}
}
VisibilityManager{ id: visibilityManager }
Layouts.Container {
id: layoutsContainer
}
Colorizer.Manager {
id: colorizerManager
}
///////////////END UI elements
///////////////BEGIN TIMER elements
//Timer to check if the mouse is still outside the latteView in order to restore zooms to 1.0
Timer{
id:checkRestoreZoom
interval: 90
onTriggered: {
if (latteApplet && (latteApplet.previewContainsMouse() || latteApplet.contextMenu))
return;
if (latteView.contextMenuIsShown)
return;
if (!mouseInHoverableArea()) {
setGlobalDirectRender(false);
root.initializeHoveredIndexes();
root.clearZoom();
}
if (root.debugModeTimers) {
console.log("containment timer: checkRestoreZoom called...");
}
}
}
//! Delayer in order to not activate directRendering when the mouse
//! enters until the timer has ended. This way we make sure that the
//! zoom-in animations will have ended.
Timer{
id:directRenderDelayerForEnteringTimer
interval: 3.2 * root.durationTime * units.shortDuration
}
//this is a delayer to update mask area, it is used in cases
//that animations can not catch up with animations signals
//e.g. the automaicIconSize case
Timer{
id:delayUpdateMaskArea
repeat:false;
interval:300;
onTriggered: {
if (layoutsContainer.animationSent) {
root.slotAnimationsNeedLength(-1);
layoutsContainer.animationSent = false;
}
visibilityManager.updateMaskArea();
if (root.debugModeTimers) {
console.log("containment timer: delayUpdateMaskArea called...");
}
}
}
// This function is very costly! This timer makes sure that it can be called
// only once every 1sec.
Timer{
id:blockAutomaticUpdateIconSize
interval: 1000
repeat: false
onTriggered: root.updateAutomaticIconSize();
}
//! It is used in order to slide-in the latteView on startup
Timer{
id: inStartupTimer
interval: 1500
repeat: false
onTriggered: {
if (inStartup) {
visibilityManager.slotMustBeShown();
}
}
}
///////////////END TIMER elements
}
diff --git a/shell/package/contents/configuration/pages/BehaviorConfig.qml b/shell/package/contents/configuration/pages/BehaviorConfig.qml
index 75100130..b9f77f21 100644
--- a/shell/package/contents/configuration/pages/BehaviorConfig.qml
+++ b/shell/package/contents/configuration/pages/BehaviorConfig.qml
@@ -1,678 +1,690 @@
/*
* Copyright 2016 Smith AR
* Michail Vourlakos
*
* This file is part of Latte-Dock
*
* Latte-Dock 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.
*
* Latte-Dock 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, see .
*/
import QtQuick 2.0
import QtQuick.Controls 1.4
import QtQuick.Layouts 1.3
import QtGraphicalEffects 1.0
import org.kde.plasma.core 2.0 as PlasmaCore
import org.kde.plasma.components 2.0 as PlasmaComponents
import org.kde.plasma.components 3.0 as PlasmaComponents3
import org.kde.plasma.plasmoid 2.0
import org.kde.latte 0.2 as Latte
import org.kde.latte.components 1.0 as LatteComponents
import "../../controls" as LatteExtraControls
PlasmaComponents.Page {
Layout.maximumWidth: content.width + content.Layout.leftMargin * 2
Layout.maximumHeight: content.height + units.smallSpacing * 2
ColumnLayout {
id: content
width: (dialog.appliedWidth - units.smallSpacing * 2) - Layout.leftMargin * 2
spacing: dialog.subGroupSpacing
anchors.horizontalCenter: parent.horizontalCenter
Layout.leftMargin: units.smallSpacing * 2
//! BEGIN: Inline Dock/Panel Type, it is used only when the secondary window
//! overlaps the main dock config window
ColumnLayout {
Layout.fillWidth: true
spacing: units.smallSpacing
Layout.topMargin: units.smallSpacing
visible: dialog.highLevel && viewConfig.showInlineProperties
LatteComponents.Header {
text: i18n("Type")
}
LatteExtraControls.TypeSelection{
id: viewTypeSelection
horizontal: true
}
}
//! END: Inline Dock/Panel Type
//! BEGIN: Location
ColumnLayout {
Layout.fillWidth: true
spacing: units.smallSpacing
Layout.topMargin: units.smallSpacing
LatteComponents.Header {
text: i18n("Location")
}
RowLayout {
id: screenRow
Layout.fillWidth: true
Layout.leftMargin: units.smallSpacing * 2
Layout.rightMargin: units.smallSpacing * 2
spacing: 2
visible: true
function updateScreens() {
if (universalSettings.screens.length > 1)
screenRow.visible = true;
else
screenRow.visible = false;
var screens = []
var rtlSpace = Qt.application.layoutDirection === Qt.RightToLeft ? " " : "";
screens.push(rtlSpace + i18n("On Primary"));
//check if the screen exists, it is used in cases Latte is moving
//the view automatically to primaryScreen in order for the user
//to has always a view with tasks shown
var screenExists = false
for (var i = 0; i < universalSettings.screens.length; i++) {
if (universalSettings.screens[i].name === latteView.positioner.currentScreenName)
screenExists = true;
}
if (!screenExists && !latteView.onPrimary)
screens.push(rtlSpace + latteView.positioner.currentScreenName);
for (var i = 0; i < universalSettings.screens.length; i++) {
screens.push(rtlSpace + universalSettings.screens[i].name)
}
screenCmb.model = screens;
if (latteView.onPrimary) {
screenCmb.currentIndex = 0;
} else {
screenCmb.currentIndex = screenCmb.find(latteView.positioner.currentScreenName);
}
console.log(latteView.positioner.currentScreenName);
}
Connections{
target: viewConfig
onShowSignal: screenRow.updateScreens();
}
PlasmaComponents.Label {
text: i18n("Screen:")
Layout.alignment: Qt.AlignRight
}
LatteComponents.ComboBox {
id: screenCmb
Layout.fillWidth: true
Component.onCompleted: screenRow.updateScreens();
//they are used to restore the index when the screen edge
//is occupied
property bool acceptedIndex: true
property int previousIndex: -1
onCurrentIndexChanged: {
//it is used to restore the index when the screen edge
//is occupied
if (!acceptedIndex) {
acceptedIndex = true;
currentIndex = previousIndex;
}
}
onActivated: {
previousIndex = currentIndex;
if (index === 0) {
var succeed = latteView.positioner.setCurrentScreen("primary");
latteView.onPrimary = true;
acceptedIndex = true;
} else if (index>0 && (index !== find(latteView.positioner.currentScreenName) || latteView.onPrimary)) {
console.log("current index changed!!! :"+ index);
console.log("screen must be changed...");
var succeed = latteView.positioner.setCurrentScreen(textAt(index));
if(succeed) {
latteView.onPrimary = false;
} else {
console.log("the edge is already occupied!!!");
acceptedIndex = false;
}
}
}
}
}
RowLayout {
id: locationLayout
Layout.fillWidth: true
Layout.leftMargin: units.smallSpacing * 2
Layout.rightMargin: units.smallSpacing * 2
LayoutMirroring.enabled: false
spacing: 2
Connections{
target: latteView
onDockLocationChanged: locationLayout.lockReservedEdges();
}
Connections{
target: latteView.managedLayout
onViewsCountChanged: locationLayout.lockReservedEdges();
}
Connections{
target: latteView.positioner
onCurrentScreenChanged: locationLayout.lockReservedEdges();
}
Component.onCompleted: lockReservedEdges()
ExclusiveGroup {
id: locationGroup
property bool inStartup: true
onCurrentChanged: {
if (current.checked && !inStartup) {
latteView.positioner.hideDockDuringLocationChange(current.edge);
}
inStartup = false;
}
}
function lockReservedEdges() {
var edges = latteView.managedLayout.qmlFreeEdges(latteView.positioner.currentScreenId);
bottomEdgeBtn.edgeIsFree = (edges.indexOf(bottomEdgeBtn.edge)>=0);
topEdgeBtn.edgeIsFree = (edges.indexOf(topEdgeBtn.edge)>=0);
leftEdgeBtn.edgeIsFree = (edges.indexOf(leftEdgeBtn.edge)>=0);
rightEdgeBtn.edgeIsFree = (edges.indexOf(rightEdgeBtn.edge)>=0);
}
PlasmaComponents.Button {
id: bottomEdgeBtn
Layout.fillWidth: true
text: i18nc("bottom location", "Bottom")
iconSource: "arrow-down"
checked: latteView.location === edge
checkable: true
enabled: checked || edgeIsFree
exclusiveGroup: locationGroup
property bool edgeIsFree: true
readonly property int edge: PlasmaCore.Types.BottomEdge
}
PlasmaComponents.Button {
id: leftEdgeBtn
Layout.fillWidth: true
text: i18nc("left location", "Left")
iconSource: "arrow-left"
checked: latteView.location === edge
checkable: true
enabled: checked || edgeIsFree
exclusiveGroup: locationGroup
property bool edgeIsFree: true
readonly property int edge: PlasmaCore.Types.LeftEdge
}
PlasmaComponents.Button {
id: topEdgeBtn
Layout.fillWidth: true
text: i18nc("top location", "Top")
iconSource: "arrow-up"
checked: latteView.location === edge
checkable: true
enabled: checked || edgeIsFree
exclusiveGroup: locationGroup
property bool edgeIsFree: true
readonly property int edge: PlasmaCore.Types.TopEdge
}
PlasmaComponents.Button {
id: rightEdgeBtn
Layout.fillWidth: true
text: i18nc("right location", "Right")
iconSource: "arrow-right"
checked: latteView.location === edge
checkable: true
enabled: checked || edgeIsFree
exclusiveGroup: locationGroup
property bool edgeIsFree: true
readonly property int edge: PlasmaCore.Types.RightEdge
}
}
}
//! END: Location
//! BEGIN: Alignment
ColumnLayout {
Layout.fillWidth: true
spacing: units.smallSpacing
LatteComponents.Header {
text: i18n("Alignment")
}
RowLayout {
id: alignmentRow
Layout.fillWidth: true
Layout.leftMargin: units.smallSpacing * 2
Layout.rightMargin: units.smallSpacing * 2
LayoutMirroring.enabled: false
spacing: 2
readonly property int panelPosition: plasmoid.configuration.panelPosition
ExclusiveGroup {
id: alignmentGroup
onCurrentChanged: {
if (current.checked)
plasmoid.configuration.panelPosition = current.position
}
}
PlasmaComponents.Button {
Layout.fillWidth: true
text: panelIsVertical ? i18nc("top alignment", "Top") : i18nc("left alignment", "Left")
iconSource: panelIsVertical ? "format-align-vertical-top" : "format-justify-left"
checked: parent.panelPosition === position
checkable: true
exclusiveGroup: alignmentGroup
property int position: panelIsVertical ? Latte.Types.Top : Latte.Types.Left
}
PlasmaComponents.Button {
Layout.fillWidth: true
text: i18nc("center alignment", "Center")
iconSource: panelIsVertical ? "format-align-vertical-center" : "format-justify-center"
checked: parent.panelPosition === position
checkable: true
exclusiveGroup: alignmentGroup
property int position: Latte.Types.Center
}
PlasmaComponents.Button {
Layout.fillWidth: true
text: panelIsVertical ? i18nc("bottom alignment", "Bottom") : i18nc("right alignment", "Right")
iconSource: panelIsVertical ? "format-align-vertical-bottom" : "format-justify-right"
checked: parent.panelPosition === position
checkable: true
exclusiveGroup: alignmentGroup
property int position: panelIsVertical ? Latte.Types.Bottom : Latte.Types.Right
}
PlasmaComponents.Button {
Layout.fillWidth: true
text: i18nc("justify alignment", "Justify")
iconSource: "format-justify-fill"
checked: parent.panelPosition === position
checkable: true
exclusiveGroup: alignmentGroup
property int position: Latte.Types.Justify
}
}
}
//! END: Alignment
//! BEGIN: Visibility
ColumnLayout {
Layout.fillWidth: true
spacing: units.smallSpacing
LatteComponents.Header {
text: i18n("Visibility")
}
GridLayout {
width: parent.width
rowSpacing: 1
columnSpacing: 2
Layout.leftMargin: units.smallSpacing * 2
Layout.rightMargin: units.smallSpacing * 2
columns: 2
property int mode: latteView.visibility.mode
ExclusiveGroup {
id: visibilityGroup
onCurrentChanged: {
if (current.checked)
latteView.visibility.mode = current.mode
}
}
PlasmaComponents.Button {
Layout.fillWidth: true
text: i18n("Always Visible")
checked: parent.mode === mode
checkable: true
exclusiveGroup: visibilityGroup
property int mode: Latte.Types.AlwaysVisible
}
PlasmaComponents.Button {
Layout.fillWidth: true
text: i18n("Auto Hide")
checked: parent.mode === mode
checkable: true
exclusiveGroup: visibilityGroup
property int mode: Latte.Types.AutoHide
}
PlasmaComponents.Button {
Layout.fillWidth: true
text: i18n("Dodge Active")
checked: parent.mode === mode
checkable: true
exclusiveGroup: visibilityGroup
property int mode: Latte.Types.DodgeActive
}
PlasmaComponents.Button {
Layout.fillWidth: true
text: i18n("Dodge Maximized")
checked: parent.mode === mode
checkable: true
exclusiveGroup: visibilityGroup
property int mode: Latte.Types.DodgeMaximized
}
PlasmaComponents.Button {
id: dodgeAllWindowsBtn
Layout.fillWidth: true
text: i18n("Dodge All Windows")
checked: parent.mode === mode
checkable: true
exclusiveGroup: visibilityGroup
property int mode: Latte.Types.DodgeAllWindows
}
PlasmaComponents.Button {
id: windowsGoBelowBtn
Layout.fillWidth: true
text: i18n("Windows Go Below")
checked: parent.mode === mode
checkable: true
exclusiveGroup: visibilityGroup
property int mode: Latte.Types.WindowsGoBelow
}
}
}
//! END: Visibility
//! BEGIN: Delay
ColumnLayout {
Layout.fillWidth: true
spacing: units.smallSpacing
enabled: !(latteView.visibility.mode === Latte.Types.AlwaysVisible
|| latteView.visibility.mode === Latte.Types.WindowsGoBelow)
LatteComponents.Header {
text: i18n("Delay")
}
RowLayout {
Layout.fillWidth: true
Layout.leftMargin: units.smallSpacing * 2
Layout.rightMargin: units.smallSpacing * 2
Layout.topMargin: units.smallSpacing
spacing: 2
RowLayout {
Layout.minimumWidth: dodgeAllWindowsBtn.width
Layout.preferredWidth: Layout.minimumWidth
Layout.maximumWidth: Layout.minimumWidth
spacing: 0
RowLayout{
Layout.alignment: Qt.AlignHCenter
PlasmaComponents.Label {
Layout.leftMargin: Qt.application.layoutDirection === Qt.RightToLeft ? units.smallSpacing : 0
Layout.rightMargin: Qt.application.layoutDirection === Qt.RightToLeft ? 0 : units.smallSpacing
text: i18n("Show ")
}
LatteComponents.TextField {
Layout.preferredWidth: width
text: latteView.visibility.timerShow
onValueChanged: {
latteView.visibility.timerShow = value
}
}
}
}
RowLayout {
Layout.minimumWidth: windowsGoBelowBtn.width
Layout.preferredWidth: Layout.minimumWidth
Layout.maximumWidth: Layout.minimumWidth
spacing: 0
RowLayout {
Layout.alignment: Qt.AlignHCenter
PlasmaComponents.Label {
Layout.leftMargin: Qt.application.layoutDirection === Qt.RightToLeft ? units.smallSpacing : 0
Layout.rightMargin: Qt.application.layoutDirection === Qt.RightToLeft ? 0 : units.smallSpacing
text: i18n("Hide")
}
LatteComponents.TextField{
Layout.preferredWidth: width
text: latteView.visibility.timerHide
onValueChanged: {
latteView.visibility.timerHide = value
}
}
}
}
}
}
//! END: Delay
//! BEGIN: Actions
ColumnLayout {
spacing: units.smallSpacing
visible: dialog.expertLevel
LatteComponents.Header {
text: i18n("Actions")
}
ColumnLayout {
Layout.leftMargin: units.smallSpacing * 2
Layout.rightMargin: units.smallSpacing * 2
spacing: 0
LatteComponents.SubHeader {
text: i18n("Empty Area")
}
- RowLayout {
- Layout.topMargin: units.smallSpacing
+ ColumnLayout {
+ RowLayout {
+ Layout.topMargin: units.smallSpacing
- PlasmaComponents.Label {
- text: i18n("Mouse wheel")
- }
+ PlasmaComponents.Label {
+ text: i18n("Mouse wheel")
+ }
- LatteComponents.ComboBox {
- id: scrollAction
- Layout.fillWidth: true
- model: [i18nc("none scroll actions", "None Action"),
- i18n("Cycle Through Desktops"),
- i18n("Cycle Through Activities"),
- i18n("Cycle Through Tasks")]
-
- currentIndex: plasmoid.configuration.scrollAction
-
- onCurrentIndexChanged: {
- switch(currentIndex) {
- case Latte.Types.ScrollNone:
- plasmoid.configuration.scrollAction = Latte.Types.ScrollNone;
- break;
- case Latte.Types.ScrollDesktops:
- plasmoid.configuration.scrollAction = Latte.Types.ScrollDesktops;
- break;
- case Latte.Types.ScrollActivities:
- plasmoid.configuration.scrollAction = Latte.Types.ScrollActivities;
- break;
- case Latte.Types.ScrollTasks:
- plasmoid.configuration.scrollAction = Latte.Types.ScrollTasks;
- break;
+ LatteComponents.ComboBox {
+ id: scrollAction
+ Layout.fillWidth: true
+ model: [i18nc("none scroll actions", "None Action"),
+ i18n("Cycle Through Desktops"),
+ i18n("Cycle Through Activities"),
+ i18n("Cycle Through Tasks")]
+
+ currentIndex: plasmoid.configuration.scrollAction
+
+ onCurrentIndexChanged: {
+ switch(currentIndex) {
+ case Latte.Types.ScrollNone:
+ plasmoid.configuration.scrollAction = Latte.Types.ScrollNone;
+ break;
+ case Latte.Types.ScrollDesktops:
+ plasmoid.configuration.scrollAction = Latte.Types.ScrollDesktops;
+ break;
+ case Latte.Types.ScrollActivities:
+ plasmoid.configuration.scrollAction = Latte.Types.ScrollActivities;
+ break;
+ case Latte.Types.ScrollTasks:
+ plasmoid.configuration.scrollAction = Latte.Types.ScrollTasks;
+ break;
+ }
}
}
}
+
+ PlasmaComponents.CheckBox {
+ text: i18n("Drag and maximize/restore active window")
+ checked: plasmoid.configuration.dragActiveWindowEnabled
+ tooltip: i18n("Drag/Maximize/Restore active window with double-click and dragging actions")
+ visible: dialog.highLevel
+
+ onClicked: {
+ plasmoid.configuration.dragActiveWindowEnabled = !plasmoid.configuration.dragActiveWindowEnabled;
+ }
+ }
}
LatteComponents.SubHeader {
text: i18n("Items")
}
LatteComponents.CheckBoxesColumn {
PlasmaComponents.CheckBox {
id: titleTooltipsChk
text: i18n("Show title tooltips on hovering")
checked: plasmoid.configuration.titleTooltips
onClicked: {
plasmoid.configuration.titleTooltips = checked;
}
}
PlasmaComponents.CheckBox {
id: mouseWheelChk
text: i18n("Activate through mouse wheel")
checked: plasmoid.configuration.mouseWheelActions
tooltip: i18n("Enable/Disable the mouse wheel action")
visible: dialog.highLevel
onClicked: {
plasmoid.configuration.mouseWheelActions = checked
}
}
PlasmaComponents.CheckBox {
Layout.maximumHeight: mouseWheelChk.height
text: i18n("🅰 Activate based on position through global shortcuts")
checked: latteView.isPreferredForShortcuts || (!latteView.managedLayout.preferredForShortcutsTouched && latteView.isHighestPriorityView())
tooltip: i18n("This view is used for based on position global shortcuts. Take note that only one view can have that option enabled for each layout")
onClicked: {
latteView.isPreferredForShortcuts = checked
if (!latteView.managedLayout.preferredForShortcutsTouched) {
latteView.managedLayout.preferredForShortcutsTouched = true
}
}
}
}
}
}
//! END: Actions
//! BEGIN: Adjust
ColumnLayout {
spacing: units.smallSpacing
visible: dialog.expertLevel
enabled: latteView.visibility.mode !== Latte.Types.AlwaysVisible && latteView.visibility.mode !== Latte.Types.WindowsGoBelow
LatteComponents.Header {
text: i18n("Environment")
}
-
LatteComponents.CheckBoxesColumn {
Layout.leftMargin: units.smallSpacing * 2
Layout.rightMargin: units.smallSpacing * 2
PlasmaComponents.CheckBox {
text: i18n("Activate KWin edge after hiding")
checked: latteView.visibility.enableKWinEdges
tooltip: i18n("After the view becomes hidden, KWin is informed to track user feedback. For example an edge visual hint is shown whenever the mouse approaches the hidden view")
onClicked: {
latteView.visibility.enableKWinEdges = checked;
}
}
PlasmaComponents.CheckBox {
text: i18n("Can be above fullscreen windows")
checked: latteView.byPassWM
tooltip: i18n("BypassWindowManagerHint flag for the window. The view will be above all windows even those set as 'Always On Top'")
onCheckedChanged: {
latteView.byPassWM = checked;
}
}
PlasmaComponents.CheckBox {
text: i18n("Raise on desktop change")
checked: latteView.visibility.raiseOnDesktop
onClicked: {
latteView.visibility.raiseOnDesktop = checked
}
}
PlasmaComponents.CheckBox {
text: i18n("Raise on activity change")
checked: latteView.visibility.raiseOnActivity
onClicked: {
latteView.visibility.raiseOnActivity = checked
}
}
}
}
//! END: Adjust
//! Bottom spacer
PlasmaComponents.Label{
id: bottomMarginSpacer
text:" "
}
}
}
diff --git a/shell/package/contents/controls/TypeSelection.qml b/shell/package/contents/controls/TypeSelection.qml
index d1500479..f984fbe2 100644
--- a/shell/package/contents/controls/TypeSelection.qml
+++ b/shell/package/contents/controls/TypeSelection.qml
@@ -1,137 +1,144 @@
/*
* Copyright 2016 Smith AR
* Michail Vourlakos
*
* This file is part of Latte-Dock
*
* Latte-Dock 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.
*
* Latte-Dock 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, see .
*/
import QtQuick 2.7
import QtGraphicalEffects 1.0
import QtQuick.Controls 1.4
import QtQuick.Layouts 1.3
import org.kde.plasma.core 2.0 as PlasmaCore
import org.kde.plasma.components 2.0 as PlasmaComponents
import org.kde.plasma.plasmoid 2.0
import org.kde.latte 0.2 as Latte
Grid {
id: typeRow
width: horizontal ? content.width - 6*units.smallSpacing : maxWidth - 2*units.smallSpacing
anchors.leftMargin: units.smallSpacing
anchors.rightMargin: units.smallSpacing
Layout.minimumWidth: width
Layout.maximumWidth: width
Layout.minimumHeight: height
Layout.maximumHeight: height
Layout.leftMargin: units.smallSpacing * 2
Layout.rightMargin: units.smallSpacing * 2
rows: horizontal ? 1 : 0
columns: horizontal ? 0 : 1
spacing: 1
verticalItemAlignment: Grid.AlignVCenter
property bool horizontal: false
ExclusiveGroup {
id: viewTypeGroup
}
PlasmaComponents.Button {
id: dockTypeButton
width: horizontal ? (parent.width - parent.spacing)/ 2 : parent.width
checkable: true
checked: latteView.type === Latte.Types.DockView
text: i18nc("dock type","Dock")
exclusiveGroup: viewTypeGroup
tooltip: i18n("Change the behavior and appearance to Dock type")
onPressedChanged: {
if (pressed && !checked) {
latteView.visibility.mode = Latte.Types.DodgeActive;
plasmoid.configuration.panelPosition = Latte.Types.Center;
plasmoid.configuration.useThemePanel = true;
plasmoid.configuration.solidPanel = false;
plasmoid.configuration.panelSize = 5;
plasmoid.configuration.shadows = 2;
plasmoid.configuration.zoomLevel = 16;
plasmoid.configuration.activeIndicator = Latte.Types.InternalsIndicator;
//plasmoid.configuration.autoDecreaseIconSize = true;
+ //! Empty Areas
+ plasmoid.configuration.dragActiveWindowEnabled = false;
+ plasmoid.configuration.scrollAction = Latte.Types.ScrollNone;
+
//! Animations
plasmoid.configuration.animationLauncherBouncing = true;
plasmoid.configuration.animationWindowInAttention = true;
plasmoid.configuration.animationWindowAddedInGroup = true;
//! Dynamic Background
plasmoid.configuration.solidBackgroundForMaximized = false;
plasmoid.configuration.colorizeTransparentPanels = false;
plasmoid.configuration.backgroundOnlyOnMaximized = false;
plasmoid.configuration.disablePanelShadowForMaximized = false;
plasmoid.configuration.plasmaBackgroundForPopups = false;
}
}
}
PlasmaComponents.Button {
id: panelTypeButton
width: dockTypeButton.width
checkable: true
checked: latteView.type === Latte.Types.PanelView
text: i18nc("panel type","Panel")
exclusiveGroup: viewTypeGroup
tooltip: i18n("Change the behavior and appearance to Panel type")
onPressedChanged: {
if (pressed && !checked) {
latteView.visibility.mode = Latte.Types.AlwaysVisible;
plasmoid.configuration.panelPosition = Latte.Types.Justify;
plasmoid.configuration.useThemePanel = true;
plasmoid.configuration.solidPanel = false;
plasmoid.configuration.panelSize = 100;
plasmoid.configuration.panelShadows = true;
plasmoid.configuration.shadows = 0;
plasmoid.configuration.zoomLevel = 0;
plasmoid.configuration.titleTooltips = false;
plasmoid.configuration.activeIndicator = Latte.Types.NoneIndicator;
//plasmoid.configuration.autoDecreaseIconSize = false;
+ //! Empty Areas
+ plasmoid.configuration.dragActiveWindowEnabled = true;
+
//! Animations
plasmoid.configuration.animationLauncherBouncing = false;
plasmoid.configuration.animationWindowInAttention = false;
plasmoid.configuration.animationWindowAddedInGroup = false;
//! Dynamic Background
plasmoid.configuration.solidBackgroundForMaximized = (plasmoid.configuration.panelTransparency !== 100 ? true : false);
plasmoid.configuration.colorizeTransparentPanels = false;
plasmoid.configuration.backgroundOnlyOnMaximized = false;
plasmoid.configuration.disablePanelShadowForMaximized = false;
plasmoid.configuration.plasmaBackgroundForPopups = true;
}
}
}
}