yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/clients/aurorae/themes/plastik/package/contents/ui/main.qml

429 lines
15 KiB
QML
Raw Normal View History

Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
/********************************************************************
Copyright (C) 2012 Martin Gräßlin <mgraesslin@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, see <http://www.gnu.org/licenses/>.
*********************************************************************/
[aurorae] Plastik theme transits to QtQuick 2
2013-10-01 11:58:01 +00:00
import QtQuick 2.0
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
import org.kde.kwin.decoration 0.1
import org.kde.kwin.decorations.plastik 1.0
Decoration {
[aurorae] Fix BorderSize in Plastik
2014-12-05 16:19:46 +00:00
function readBorderSize() {
switch (borderSize) {
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
case DecorationOptions.BorderTiny:
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
borders.setBorders(3);
extendedBorders.setAllBorders(0);
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
break;
case DecorationOptions.BorderLarge:
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
borders.setBorders(8);
extendedBorders.setAllBorders(0);
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
break;
case DecorationOptions.BorderVeryLarge:
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
borders.setBorders(12);
extendedBorders.setAllBorders(0);
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
break;
case DecorationOptions.BorderHuge:
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
borders.setBorders(18);
extendedBorders.setAllBorders(0);
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
break;
case DecorationOptions.BorderVeryHuge:
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
borders.setBorders(27);
extendedBorders.setAllBorders(0);
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
break;
case DecorationOptions.BorderOversized:
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
borders.setBorders(40);
extendedBorders.setAllBorders(0);
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
break;
Support for new decoration border sizes BorderNoSides and BorderNone BorderNoSides is what is known from Oxygen as "No Side Borders". The name should indicate that there is only a border at the bottom. BorderNone is a mode with no borders at all. The new enums are added to KDecoration and the KCM so that all decos can make use of it. Aurorae is adjusted to support the new sizes for QML themes (it breaks the old svg based themes) and Plastik makes use of it, by rendering a one-pixel border around the window, which illustrates that it's still up to the decoration to decide how to make use of the setting. REVIEW: 108164
2013-01-04 13:02:44 +00:00
case DecorationOptions.BorderNoSides:
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
borders.setBorders(4);
borders.setSideBorders(1);
Fix typo in Plastik QML
2013-02-18 08:47:11 +00:00
extendedBorders.setSideBorders(3);
Support for new decoration border sizes BorderNoSides and BorderNone BorderNoSides is what is known from Oxygen as "No Side Borders". The name should indicate that there is only a border at the bottom. BorderNone is a mode with no borders at all. The new enums are added to KDecoration and the KCM so that all decos can make use of it. Aurorae is adjusted to support the new sizes for QML themes (it breaks the old svg based themes) and Plastik makes use of it, by rendering a one-pixel border around the window, which illustrates that it's still up to the decoration to decide how to make use of the setting. REVIEW: 108164
2013-01-04 13:02:44 +00:00
break;
case DecorationOptions.BorderNone:
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
borders.setBorders(1);
extendedBorders.setBorders(3);
Support for new decoration border sizes BorderNoSides and BorderNone BorderNoSides is what is known from Oxygen as "No Side Borders". The name should indicate that there is only a border at the bottom. BorderNone is a mode with no borders at all. The new enums are added to KDecoration and the KCM so that all decos can make use of it. Aurorae is adjusted to support the new sizes for QML themes (it breaks the old svg based themes) and Plastik makes use of it, by rendering a one-pixel border around the window, which illustrates that it's still up to the decoration to decide how to make use of the setting. REVIEW: 108164
2013-01-04 13:02:44 +00:00
break;
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
case DecorationOptions.BorderNormal: // fall through to default
default:
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
borders.setBorders(4);
extendedBorders.setAllBorders(0);
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
break;
}
[aurorae] Fix BorderSize in Plastik
2014-12-05 16:19:46 +00:00
}
function readConfig() {
Support for Plastik's configuration options Adding a KConfigXT xml file and an ui file to configure the QML variant of Plastik. Currently supported options: * title alignment * title shadow * animation of buttons Missing option: * colored borders
2012-08-25 09:09:57 +00:00
var titleAlignLeft = decoration.readConfig("titleAlignLeft", true);
var titleAlignCenter = decoration.readConfig("titleAlignCenter", false);
var titleAlignRight = decoration.readConfig("titleAlignRight", false);
if (titleAlignRight) {
root.titleAlignment = Text.AlignRight;
} else if (titleAlignCenter) {
root.titleAlignment = Text.AlignHCenter;
} else {
if (!titleAlignLeft) {
console.log("Error reading title alignment: all alignment options are false");
}
root.titleAlignment = Text.AlignLeft;
}
root.animateButtons = decoration.readConfig("animateButtons", true);
root.titleShadow = decoration.readConfig("titleShadow", true);
Disable animations in Plastik for native or non-compositing Adding a new property on whether we want animations based on whether we are on raster or with Compositing. The property is constant as the deco gets recreated on compositing change state anyway. REVIEW: 109456 BUG: 314532 FIXED-IN: 4.10.2
2013-03-12 17:36:21 +00:00
if (decoration.animationsSupported) {
root.animationDuration = 150;
root.animateButtons = false;
}
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
ColorHelper {
id: colorHelper
}
DecorationOptions {
id: options
deco: decoration
}
[aurorae] Fix BorderSize in Plastik
2014-12-05 16:19:46 +00:00
property int borderSize: decorationSettings.borderSize
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
property alias buttonSize: titleRow.captionHeight
Support for Plastik's configuration options Adding a KConfigXT xml file and an ui file to configure the QML variant of Plastik. Currently supported options: * title alignment * title shadow * animation of buttons Missing option: * colored borders
2012-08-25 09:09:57 +00:00
property alias titleAlignment: caption.horizontalAlignment
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
property color titleBarColor: options.titleBarColor
Fix initial button flickering in Plastik QML Disable animations till the decoration is completel loaded. This ensures that the buttons do not flicker because of the animation from black to their respective color.
2012-09-27 15:12:31 +00:00
// set by readConfig after Component completed, ensures that buttons do not flicker
property int animationDuration: 0
Support for Plastik's configuration options Adding a KConfigXT xml file and an ui file to configure the QML variant of Plastik. Currently supported options: * title alignment * title shadow * animation of buttons Missing option: * colored borders
2012-08-25 09:09:57 +00:00
property bool animateButtons: true
property bool titleShadow: true
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
Behavior on titleBarColor {
ColorAnimation {
duration: root.animationDuration
}
}
id: root
Decoration can announce whether it currently requires an alpha channel A decoration can provide the AbilityAnnounceAlphaChannel in addition to AbilityUsesAlphaChannel. If this ability is provided the decoration can enable/disable the use of the alpha channel through setAlphaEnabled(). The base idea behind this mechanism is to be able to tell the compositor that currently alpha is not needed. An example is the maximized state in which the decoration is fully opaque so that there is no need to use the translucency code path which would render all windows behind the deco. In addition also the blur effect honors this setting so that behind a known opaque decoration no blurring is performed. Oxygen is adjusted to disable translucency in maximized state and Aurorae is adjusted to allow themes to enable/disable translucency. For Plastik translucency and with that also blurring is disabled. REVIEW: 106810
2012-10-12 09:34:05 +00:00
alpha: false
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
Rectangle {
color: root.titleBarColor
anchors {
fill: parent
}
border {
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
width: decoration.client.maximized ? 0 : 2
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
color: colorHelper.shade(root.titleBarColor, ColorHelper.DarkShade)
}
Rectangle {
id: borderLeft
anchors {
left: parent.left
top: parent.top
bottom: parent.bottom
leftMargin: 1
bottomMargin: 1
topMargin: 1
}
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
visible: !decoration.client.maximized
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
width: root.borders.left
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
color: root.titleBarColor
Rectangle {
width: 1
anchors {
left: parent.left
top: parent.top
bottom: parent.bottom
}
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
color: colorHelper.shade(root.titleBarColor, ColorHelper.LightShade, colorHelper.contrast - (decoration.client.active ? 0.4 : 0.8))
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
}
Rectangle {
id: borderRight
anchors {
right: parent.right
top: parent.top
bottom: parent.bottom
rightMargin: 1
bottomMargin: 1
topMargin: 1
}
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
visible: !decoration.client.maximzied
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
width: root.borders.right -1
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
color: root.titleBarColor
Rectangle {
width: 1
anchors {
bottom: parent.bottom
top: parent.top
}
x: parent.x + parent.width - 1
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
color: colorHelper.shade(root.titleBarColor, ColorHelper.DarkShade, colorHelper.contrast - (decoration.client.active ? 0.4 : 0.8))
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
}
Rectangle {
id: borderBottom
anchors {
left: parent.right
right: parent.left
bottom: parent.bottom
leftMargin: 1
rightMargin: 1
}
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
height: root.borders.bottom
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
visible: !decoration.client.maximzied
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
color: root.titleBarColor
Rectangle {
height: 1
anchors {
left: parent.left
right: parent.right
}
y: parent.y + parent.height - 1
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
color: colorHelper.shade(root.titleBarColor, ColorHelper.DarkShade, colorHelper.contrast - (decoration.client.active ? 0.4 : 0.8))
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
}
Rectangle {
id: top
property int topMargin: 1
property real normalHeight: titleRow.normalHeight + topMargin + 1
Polish Plastik theme. Fixed caption and left buttons positions. Added enphasizing line under titleRow. (like in 4.9.x version). REVIEW: 109992 BUG: 317220 FIXED-IN: 4.11
2013-04-25 18:17:13 +00:00
property real maximizedHeight: titleRow.maximizedHeight + 1
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
height: decoration.client.maximized ? maximizedHeight : normalHeight
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
anchors {
left: parent.left
right: parent.right
top: parent.top
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
topMargin: decoration.client.maximized ? 0 : top.topMargin
leftMargin: decoration.client.maximized ? 0 : 2
rightMargin: decoration.client.maximized ? 0 : 2
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
gradient: Gradient {
id: topGradient
GradientStop {
position: 0.0
color: colorHelper.shade(root.titleBarColor, ColorHelper.MidlightShade, colorHelper.contrast - 0.4)
}
GradientStop {
id: middleGradientStop
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
position: 4.0/(decoration.client.maximized ? top.maximizedHeight : top.normalHeight)
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
color: colorHelper.shade(root.titleBarColor, ColorHelper.MidShade, colorHelper.contrast - 0.4)
}
GradientStop {
position: 1.0
color: root.titleBarColor
}
}
Rectangle {
height: 1
anchors {
top: top.top
left: top.left
right: top.right
}
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
visible: !decoration.client.maximized
color: colorHelper.shade(root.titleBarColor, ColorHelper.LightShade, colorHelper.contrast - (decoration.client.active ? 0.4 : 0.8))
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
Item {
id: titleRow
property real captionHeight: caption.implicitHeight + 4
Polish Plastik theme. Fixed caption and left buttons positions. Added enphasizing line under titleRow. (like in 4.9.x version). REVIEW: 109992 BUG: 317220 FIXED-IN: 4.11
2013-04-25 18:17:13 +00:00
property int topMargin: 3
property int bottomMargin: 1
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
property real normalHeight: captionHeight + bottomMargin + topMargin
property real maximizedHeight: captionHeight + bottomMargin
anchors {
left: parent.left
right: parent.right
top: parent.top
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
topMargin: decoration.client.maximized ? 0 : titleRow.topMargin
leftMargin: decoration.client.maximized ? 0 : 3
rightMargin: decoration.client.maximized ? 0 : 3
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
bottomMargin: titleRow.bottomMargin
}
ButtonGroup {
id: leftButtonGroup
spacing: 1
explicitSpacer: root.buttonSize
menuButton: menuButtonComponent
Application Menu button support for Plastik New icon with three lines similar to the one used in Oxygen is added for application menu support. REVIEW: 107937
2012-12-27 09:53:56 +00:00
appMenuButton: appMenuButtonComponent
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
minimizeButton: minimizeButtonComponent
maximizeButton: maximizeButtonComponent
keepBelowButton: keepBelowButtonComponent
keepAboveButton: keepAboveButtonComponent
helpButton: helpButtonComponent
shadeButton: shadeButtonComponent
allDesktopsButton: stickyButtonComponent
closeButton: closeButtonComponent
buttons: options.titleButtonsLeft
anchors {
top: parent.top
left: parent.left
}
}
Text {
id: caption
make plastik use PlainText captions BUG: 323798 FIXED-IN: 4.11 REVIEW: 112180
2013-08-20 19:54:05 +00:00
textFormat: Text.PlainText
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
anchors {
top: parent.top
left: leftButtonGroup.right
right: rightButtonGroup.left
rightMargin: 5
leftMargin: 5
Polish Plastik theme. Fixed caption and left buttons positions. Added enphasizing line under titleRow. (like in 4.9.x version). REVIEW: 109992 BUG: 317220 FIXED-IN: 4.11
2013-04-25 18:17:13 +00:00
topMargin: 3
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
color: options.fontColor
Behavior on color {
ColorAnimation { duration: root.animationDuration }
}
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
text: decoration.client.caption
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
font: options.titleFont
Support for Plastik's configuration options Adding a KConfigXT xml file and an ui file to configure the QML variant of Plastik. Currently supported options: * title alignment * title shadow * animation of buttons Missing option: * colored borders
2012-08-25 09:09:57 +00:00
style: root.titleShadow ? Text.Raised : Text.Normal
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
styleColor: colorHelper.shade(color, ColorHelper.ShadowShade)
elide: Text.ElideMiddle
[aurorae] Use NativeRendering for decoration title
2014-06-30 12:33:09 +00:00
renderType: Text.NativeRendering
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
ButtonGroup {
id: rightButtonGroup
spacing: 1
explicitSpacer: root.buttonSize
menuButton: menuButtonComponent
Application Menu button support for Plastik New icon with three lines similar to the one used in Oxygen is added for application menu support. REVIEW: 107937
2012-12-27 09:53:56 +00:00
appMenuButton: appMenuButtonComponent
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
minimizeButton: minimizeButtonComponent
maximizeButton: maximizeButtonComponent
keepBelowButton: keepBelowButtonComponent
keepAboveButton: keepAboveButtonComponent
helpButton: helpButtonComponent
shadeButton: shadeButtonComponent
allDesktopsButton: stickyButtonComponent
closeButton: closeButtonComponent
buttons: options.titleButtonsRight
anchors {
top: parent.top
right: parent.right
}
}
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
Component.onCompleted: {
decoration.installTitleItem(titleRow);
}
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
}
Polish Plastik theme. Fixed caption and left buttons positions. Added enphasizing line under titleRow. (like in 4.9.x version). REVIEW: 109992 BUG: 317220 FIXED-IN: 4.11
2013-04-25 18:17:13 +00:00
Item {
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
id: innerBorder
Polish Plastik theme. Fixed caption and left buttons positions. Added enphasizing line under titleRow. (like in 4.9.x version). REVIEW: 109992 BUG: 317220 FIXED-IN: 4.11
2013-04-25 18:17:13 +00:00
anchors.fill: parent
Rectangle {
anchors {
left: parent.left
right: parent.right
}
height: 1
y: top.height - 1
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
visible: decoration.client.maximized
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
color: colorHelper.shade(root.titleBarColor, ColorHelper.MidShade)
}
Polish Plastik theme. Fixed caption and left buttons positions. Added enphasizing line under titleRow. (like in 4.9.x version). REVIEW: 109992 BUG: 317220 FIXED-IN: 4.11
2013-04-25 18:17:13 +00:00
Rectangle {
anchors {
fill: parent
leftMargin: root.borders.left - 1
rightMargin: root.borders.right
topMargin: root.borders.top - 1
bottomMargin: root.borders.bottom
}
border {
width: 1
color: colorHelper.shade(root.titleBarColor, ColorHelper.MidShade)
}
Initial port of Aurorae to KDecoration2 The port to KDecoration2 means quite some changes in the way how Aurorae works. First of all: the theme to load is passed to the Deocoration ctor and not searched for by Aurorae itself. The rendering mechanismn didn't change significantly yet. It's still rendering to an FBO and passing the image on. This needs some further work as KDecoration2 does not support the padding any more. So all themes using shadow are currently broken. Another big change is the way how the rendering scene is constructed and used. KDecoration2 doesn't want the the Decoration to be a native window. But for being able to render a QtQuick scene at all we need a QQuickWindow. Thus it creates a window parented to the decoration id, but not accepting any input event. Input is nowadays controlled from the outside: events are passed into the Decoration, so we don't want the QtQuick window intercepting events. In case of non-composited the normal FBO mechanism doesn't work and Aurorae just renders to the QQuickWindow directly. This could use some optimization in the decoration renderer in KWin core to not even try to perform the normal rendering. On the other hand it's probably too much a hassle for the use case. The rendering architecture might hopefully be improved with Qt 5.4 and the new QQuickRenderControl class. The QQuickWindow also exposes a problem for preview in the kdecoration-viewer and the future KCM: we don't want a different window, but best would be to get to the QML scene directly. A small hack is added to have the previewers set a "visualParent" which Aurorae uses to parent the QML scene to without the need to create a QQuickWindow.
2014-10-24 11:48:31 +00:00
visible: !decoration.client.maximized
Polish Plastik theme. Fixed caption and left buttons positions. Added enphasizing line under titleRow. (like in 4.9.x version). REVIEW: 109992 BUG: 317220 FIXED-IN: 4.11
2013-04-25 18:17:13 +00:00
color: root.titleBarColor
}
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
}
Component {
id: maximizeButtonComponent
PlastikButton {
[aurorae] Use enum type for Decoration Buttons Defines the DecorationButton type in DecorationOptions (needs to be re-defined due to QML limitations) and exports the buttons as a QList<int> property (again QML limitations). All QML files are switched from string to the new enum type.
2013-10-10 13:40:25 +00:00
buttonType: DecorationOptions.DecorationButtonMaximizeRestore
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
size: root.buttonSize
}
}
Component {
id: keepBelowButtonComponent
PlastikButton {
[aurorae] Use enum type for Decoration Buttons Defines the DecorationButton type in DecorationOptions (needs to be re-defined due to QML limitations) and exports the buttons as a QList<int> property (again QML limitations). All QML files are switched from string to the new enum type.
2013-10-10 13:40:25 +00:00
buttonType: DecorationOptions.DecorationButtonKeepBelow
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
size: root.buttonSize
}
}
Component {
id: keepAboveButtonComponent
PlastikButton {
[aurorae] Use enum type for Decoration Buttons Defines the DecorationButton type in DecorationOptions (needs to be re-defined due to QML limitations) and exports the buttons as a QList<int> property (again QML limitations). All QML files are switched from string to the new enum type.
2013-10-10 13:40:25 +00:00
buttonType: DecorationOptions.DecorationButtonKeepAbove
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
size: root.buttonSize
}
}
Component {
id: helpButtonComponent
PlastikButton {
[aurorae] Use enum type for Decoration Buttons Defines the DecorationButton type in DecorationOptions (needs to be re-defined due to QML limitations) and exports the buttons as a QList<int> property (again QML limitations). All QML files are switched from string to the new enum type.
2013-10-10 13:40:25 +00:00
buttonType: DecorationOptions.DecorationButtonQuickHelp
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
size: root.buttonSize
}
}
Component {
id: minimizeButtonComponent
PlastikButton {
[aurorae] Use enum type for Decoration Buttons Defines the DecorationButton type in DecorationOptions (needs to be re-defined due to QML limitations) and exports the buttons as a QList<int> property (again QML limitations). All QML files are switched from string to the new enum type.
2013-10-10 13:40:25 +00:00
buttonType: DecorationOptions.DecorationButtonMinimize
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
size: root.buttonSize
}
}
Component {
id: shadeButtonComponent
PlastikButton {
[aurorae] Use enum type for Decoration Buttons Defines the DecorationButton type in DecorationOptions (needs to be re-defined due to QML limitations) and exports the buttons as a QList<int> property (again QML limitations). All QML files are switched from string to the new enum type.
2013-10-10 13:40:25 +00:00
buttonType: DecorationOptions.DecorationButtonShade
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
size: root.buttonSize
}
}
Component {
id: stickyButtonComponent
PlastikButton {
[aurorae] Use enum type for Decoration Buttons Defines the DecorationButton type in DecorationOptions (needs to be re-defined due to QML limitations) and exports the buttons as a QList<int> property (again QML limitations). All QML files are switched from string to the new enum type.
2013-10-10 13:40:25 +00:00
buttonType: DecorationOptions.DecorationButtonOnAllDesktops
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
size: root.buttonSize
}
}
Component {
id: closeButtonComponent
PlastikButton {
[aurorae] Use enum type for Decoration Buttons Defines the DecorationButton type in DecorationOptions (needs to be re-defined due to QML limitations) and exports the buttons as a QList<int> property (again QML limitations). All QML files are switched from string to the new enum type.
2013-10-10 13:40:25 +00:00
buttonType: DecorationOptions.DecorationButtonClose
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
size: root.buttonSize
}
}
Component {
id: menuButtonComponent
MenuButton {
width: root.buttonSize
height: root.buttonSize
}
}
Application Menu button support for Plastik New icon with three lines similar to the one used in Oxygen is added for application menu support. REVIEW: 107937
2012-12-27 09:53:56 +00:00
Component {
id: appMenuButtonComponent
PlastikButton {
[aurorae] Use enum type for Decoration Buttons Defines the DecorationButton type in DecorationOptions (needs to be re-defined due to QML limitations) and exports the buttons as a QList<int> property (again QML limitations). All QML files are switched from string to the new enum type.
2013-10-10 13:40:25 +00:00
buttonType: DecorationOptions.DecorationButtonApplicationMenu
Application Menu button support for Plastik New icon with three lines similar to the one used in Oxygen is added for application menu support. REVIEW: 107937
2012-12-27 09:53:56 +00:00
size: root.buttonSize
}
}
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
Component.onCompleted: {
borders.setBorders(4);
borders.setTitle(top.normalHeight);
maximizedBorders.setTitle(top.maximizedHeight);
[aurorae] Fix BorderSize in Plastik
2014-12-05 16:19:46 +00:00
readBorderSize();
Introduce a dedicated borders element in Aurorae The Borders element provides the four properties: * left * right * top * bottom And is used directly in Decoration for all the different kind of settings following this pattern: * normal borders * maximized borders * padding * extended borders These properties replace the existing used borderLeft & co. This makes the code in the C++ side easier as the various border elements can now be read with a shared implementation. The Borders provide some convenient methods to set the sizes of the borders. E.g. it's possible to just set the side borders to a specific value. This should simplify the implementation of the no-side-borders feature in new decoration. The aurorae qml and plastik are adjusted to use the new way. Existing 3rd party decorations would break, but there's a good reason why there's no documentation for QML based decorations ;-) REVIEW: 108436
2013-01-16 07:43:53 +00:00
readConfig();
}
[kcmkwin/deco] Reconfigure deco after applying changes Required hooks also added to KWin core and Aurorae.
2014-12-05 14:58:05 +00:00
Connections {
target: decoration
onConfigChanged: root.readConfig()
}
[aurorae] Fix BorderSize in Plastik
2014-12-05 16:19:46 +00:00
Connections {
target: decorationSettings
onBorderSizeChanged: root.readBorderSize();
}
Port of Plastik decoration to QML The Plastik decoration buttons are provided by a declarative extension plugin as the canvas drawing API would be needed to draw these buttons. This should be changed with Qt 5. But it's also a nice example to show how a QML based decoration can have an extension in C++.
2012-07-28 12:39:40 +00:00
}
Reference in a new issue Copy permalink