Commit 2c66e1f6 authored by Roman Gilg's avatar Roman Gilg Committed by Bhushan Shah

Remove orientation sensor

Summary:
This functionality will instead be implemented in KScreen such that manual and
automatic output rotation can be used and configured through a single UI in
unison together.

Test Plan: Compiles.

Reviewers: #kwin, davidedmundson, zzag

Reviewed By: #kwin, zzag

Subscribers: kwin, bshah, davidedmundson, zzag

Tags: #kwin

Differential Revision: https://phabricator.kde.org/D26036
parent 7706e17d
......@@ -456,7 +456,6 @@ set(kwin_SRCS
netinfo.cpp
onscreennotification.cpp
options.cpp
orientation_sensor.cpp
osd.cpp
outline.cpp
outputscreens.cpp
......@@ -562,7 +561,6 @@ qt5_add_dbus_adaptor(kwin_SRCS org.kde.KWin.xml dbusinterface.h KWin::DBusInterf
qt5_add_dbus_adaptor(kwin_SRCS org.kde.kwin.Compositing.xml dbusinterface.h KWin::CompositorDBusInterface)
qt5_add_dbus_adaptor(kwin_SRCS org.kde.kwin.ColorCorrect.xml colorcorrection/colorcorrectdbusinterface.h KWin::ColorCorrect::ColorCorrectDBusInterface)
qt5_add_dbus_adaptor(kwin_SRCS ${kwin_effects_dbus_xml} effects.h KWin::EffectsHandlerImpl)
qt5_add_dbus_adaptor(kwin_SRCS org.kde.kwin.OrientationSensor.xml orientation_sensor.h KWin::OrientationSensor)
qt5_add_dbus_adaptor(kwin_SRCS org.kde.KWin.VirtualDesktopManager.xml dbusinterface.h KWin::VirtualDesktopManagerDBusInterface)
qt5_add_dbus_adaptor(kwin_SRCS org.kde.KWin.Session.xml sm.h KWin::SessionManager)
......
......@@ -167,7 +167,6 @@ ecm_mark_as_test(testBuiltInEffectLoader)
include_directories(${KWin_SOURCE_DIR})
set(testScriptedEffectLoader_SRCS
../effectloader.cpp
../orientation_sensor.cpp
../screens.cpp
../scripting/scriptedeffect.cpp
../scripting/scripting_logging.cpp
......@@ -179,7 +178,6 @@ set(testScriptedEffectLoader_SRCS
test_scripted_effectloader.cpp
)
kconfig_add_kcfg_files(testScriptedEffectLoader_SRCS ../settings.kcfgc)
qt5_add_dbus_adaptor(testScriptedEffectLoader_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../org.kde.kwin.OrientationSensor.xml ${CMAKE_CURRENT_SOURCE_DIR}/../orientation_sensor.h KWin::OrientationSensor)
add_executable(testScriptedEffectLoader ${testScriptedEffectLoader_SRCS})
target_link_libraries(testScriptedEffectLoader
......@@ -245,7 +243,6 @@ target_link_libraries(effectversionplugin kwineffects)
# Test Screens
########################################################
set(testScreens_SRCS
../orientation_sensor.cpp
../screens.cpp
../x11eventfilter.cpp
mock_abstract_client.cpp
......@@ -255,7 +252,6 @@ set(testScreens_SRCS
test_screens.cpp
)
kconfig_add_kcfg_files(testScreens_SRCS ../settings.kcfgc)
qt5_add_dbus_adaptor(testScreens_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../org.kde.kwin.OrientationSensor.xml ${CMAKE_CURRENT_SOURCE_DIR}/../orientation_sensor.h KWin::OrientationSensor)
add_executable(testScreens ${testScreens_SRCS})
target_include_directories(testScreens BEFORE PRIVATE ./)
......@@ -282,7 +278,6 @@ ecm_mark_as_test(testScreens)
set(testScreenEdges_SRCS
../atoms.cpp
../gestures.cpp
../orientation_sensor.cpp
../plugins/platforms/x11/standalone/edge.cpp
../screenedge.cpp
../screens.cpp
......@@ -296,7 +291,6 @@ set(testScreenEdges_SRCS
)
kconfig_add_kcfg_files(testScreenEdges_SRCS ../settings.kcfgc)
qt5_add_dbus_interface(testScreenEdges_SRCS ${KSCREENLOCKER_DBUS_INTERFACES_DIR}/kf5_org.freedesktop.ScreenSaver.xml screenlocker_interface )
qt5_add_dbus_adaptor(testScreenEdges_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../org.kde.kwin.OrientationSensor.xml ${CMAKE_CURRENT_SOURCE_DIR}/../orientation_sensor.h KWin::OrientationSensor)
add_executable(testScreenEdges ${testScreenEdges_SRCS})
set_target_properties(testScreenEdges PROPERTIES COMPILE_DEFINITIONS "NO_NONE_WINDOW")
......
......@@ -661,6 +661,8 @@ void Connection::applyScreenToDevice(Device *device)
}
}
device->setScreenId(id);
// TODO: this is currently non-functional even on DRM. Needs orientation() override there.
device->setOrientation(screens()->orientation(id));
#else
Q_UNUSED(device)
......
<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node>
<interface name="org.kde.kwin.OrientationSensor">
<property name="userEnabled" type="b" access="readwrite"/>
</interface>
</node>
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2017 Martin Flöser <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/>.
*********************************************************************/
#include "orientation_sensor.h"
#include <orientationsensoradaptor.h>
#include <QOrientationSensor>
#include <QOrientationReading>
#include <KConfigGroup>
#include <KStatusNotifierItem>
#include <KLocalizedString>
namespace KWin
{
OrientationSensor::OrientationSensor(QObject *parent)
: QObject(parent)
, m_sensor(new QOrientationSensor(this))
{
connect(m_sensor, &QOrientationSensor::readingChanged, this, &OrientationSensor::updateState);
connect(m_sensor, &QOrientationSensor::activeChanged, this, &OrientationSensor::refresh);
new OrientationSensorAdaptor(this);
}
void OrientationSensor::updateState()
{
auto toOrientation = [] (auto reading) {
switch (reading->orientation()) {
case QOrientationReading::Undefined:
return OrientationSensor::Orientation::Undefined;
case QOrientationReading::TopUp:
return OrientationSensor::Orientation::TopUp;
case QOrientationReading::TopDown:
return OrientationSensor::Orientation::TopDown;
case QOrientationReading::LeftUp:
return OrientationSensor::Orientation::LeftUp;
case QOrientationReading::RightUp:
return OrientationSensor::Orientation::RightUp;
case QOrientationReading::FaceUp:
return OrientationSensor::Orientation::FaceUp;
case QOrientationReading::FaceDown:
return OrientationSensor::Orientation::FaceDown;
default:
Q_UNREACHABLE();
}
};
const auto orientation = toOrientation(m_sensor->reading());
if (m_orientation != orientation) {
m_orientation = orientation;
emit orientationChanged();
}
}
void OrientationSensor::activate()
{
m_userEnabled = !m_userEnabled;
startStopSensor();
emit userEnabledChanged(m_userEnabled);
}
void OrientationSensor::refresh()
{
if (m_orientation == Orientation::Undefined) {
delete m_sni;
m_sni = nullptr;
return;
}
if (!m_sni) {
m_sni = new KStatusNotifierItem(QStringLiteral("kwin-automatic-rotation"), this);
m_sni->setStandardActionsEnabled(false);
m_sni->setCategory(KStatusNotifierItem::Hardware);
m_sni->setStatus(KStatusNotifierItem::Passive);
// TODO: proper icon with state
m_sni->setIconByName(QStringLiteral("preferences-desktop-display"));
// we start disabled, it gets updated when the sensor becomes active
connect(m_sni, &KStatusNotifierItem::activateRequested, this, &OrientationSensor::activate);
}
if (m_sensor->isActive()) {
m_sni->setTitle(i18n("Allow Rotation"));
m_sni->setToolTipTitle(i18n("Automatic screen rotation is enabled"));
updateState();
} else {
QString text;
switch(m_orientation) {
case Orientation::Undefined:
Q_UNREACHABLE(); //we don't want an sni if it's undefined
break;
case Orientation::FaceUp:
case Orientation::FaceDown:
text = i18n("Undefined");
break;
case Orientation::TopUp:
case Orientation::TopDown:
text = i18nc("Portrait oriented display", "Vertical");
break;
case Orientation::LeftUp:
case Orientation::RightUp:
text = i18nc("Landscape oriented display", "Horizontal");
break;
}
m_sni->setTitle(text);
m_sni->setToolTipTitle(i18n("Automatic screen rotation is disabled"));
}
}
OrientationSensor::~OrientationSensor() = default;
void OrientationSensor::setEnabled(bool enabled)
{
if (m_enabled == enabled) {
return;
}
m_enabled = enabled;
if (m_enabled) {
loadConfig();
refresh();
QDBusConnection::sessionBus().registerObject(QStringLiteral("/Orientation"), this);
} else {
QDBusConnection::sessionBus().unregisterObject(QStringLiteral("/Orientation"));
delete m_sni;
m_sni = nullptr;
}
startStopSensor();
}
void OrientationSensor::loadConfig()
{
if (!m_config) {
return;
}
m_userEnabled = m_config->group("OrientationSensor").readEntry("Enabled", true);
}
void OrientationSensor::startStopSensor()
{
if (m_enabled && m_userEnabled) {
m_sensor->start();
} else {
m_sensor->stop();
}
}
void OrientationSensor::setUserEnabled(bool enabled)
{
if (m_userEnabled == enabled) {
return;
}
m_userEnabled = enabled;
if (m_config) {
m_config->group("OrientationSensor").writeEntry("Enabled", m_userEnabled);
}
emit userEnabledChanged(m_userEnabled);
}
}
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2017 Martin Flöser <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/>.
*********************************************************************/
#pragma once
#include <QObject>
#include <KSharedConfig>
#include <kwin_export.h>
class QOrientationSensor;
class KStatusNotifierItem;
namespace KWin
{
class KWIN_EXPORT OrientationSensor : public QObject
{
Q_OBJECT
Q_PROPERTY(bool userEnabled READ isUserEnabled WRITE setUserEnabled NOTIFY userEnabledChanged)
public:
explicit OrientationSensor(QObject *parent = nullptr);
~OrientationSensor() override;
void setEnabled(bool enabled);
/**
* Just like QOrientationReading::Orientation,
* copied to not leak the QSensors API into internal API.
*/
enum class Orientation {
Undefined,
TopUp,
TopDown,
LeftUp,
RightUp,
FaceUp,
FaceDown
};
Q_ENUM(Orientation)
Orientation orientation() const {
return m_orientation;
}
void setConfig(KSharedConfig::Ptr config) {
m_config = std::move(config);
}
bool isUserEnabled() const {
return m_userEnabled;
}
void setUserEnabled(bool enabled);
Q_SIGNALS:
void orientationChanged();
void userEnabledChanged(bool);
private:
void startStopSensor();
void loadConfig();
void refresh();
void activate();
void updateState();
QOrientationSensor *m_sensor;
bool m_enabled = false;
bool m_userEnabled = true;
Orientation m_orientation = Orientation::Undefined;
KStatusNotifierItem *m_sni = nullptr;
KSharedConfig::Ptr m_config;
};
}
......@@ -27,7 +27,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "logind.h"
#include "logging.h"
#include "main.h"
#include "orientation_sensor.h"
#include "screens_drm.h"
#include "wayland_server.h"
// KWayland
......@@ -270,15 +269,6 @@ bool DrmOutput::init(drmModeConnector *connector)
setInternal(connector->connector_type == DRM_MODE_CONNECTOR_LVDS || connector->connector_type == DRM_MODE_CONNECTOR_eDP
|| connector->connector_type == DRM_MODE_CONNECTOR_DSI);
setDpmsSupported(true);
if (isInternal()) {
connect(kwinApp(), &Application::screensCreated, this,
[this] {
connect(screens()->orientationSensor(), &OrientationSensor::orientationChanged, this, &DrmOutput::automaticRotation);
}
);
}
initOutputDevice(connector);
if (!m_backend->atomicModeSetting() && !m_crtc->blank()) {
......@@ -1087,47 +1077,6 @@ bool DrmOutput::supportsTransformations() const
|| transformations.testFlag(DrmPlane::Transformation::Rotate270);
}
void DrmOutput::automaticRotation()
{
if (!m_primaryPlane) {
return;
}
const auto supportedTransformations = m_primaryPlane->supportedTransformations();
const auto requestedTransformation = screens()->orientationSensor()->orientation();
Transform newTransformation = Transform::Normal;
switch (requestedTransformation) {
case OrientationSensor::Orientation::TopUp:
newTransformation = Transform::Normal;
break;
case OrientationSensor::Orientation::TopDown:
if (!supportedTransformations.testFlag(DrmPlane::Transformation::Rotate180)) {
return;
}
newTransformation = Transform::Rotated180;
break;
case OrientationSensor::Orientation::LeftUp:
if (!supportedTransformations.testFlag(DrmPlane::Transformation::Rotate90)) {
return;
}
newTransformation = Transform::Rotated90;
break;
case OrientationSensor::Orientation::RightUp:
if (!supportedTransformations.testFlag(DrmPlane::Transformation::Rotate270)) {
return;
}
newTransformation = Transform::Rotated270;
break;
case OrientationSensor::Orientation::FaceUp:
case OrientationSensor::Orientation::FaceDown:
case OrientationSensor::Orientation::Undefined:
// unsupported
return;
}
setTransform(newTransformation);
emit screens()->changed();
}
int DrmOutput::gammaRampSize() const
{
return m_crtc->gammaRampSize();
......
......@@ -139,7 +139,6 @@ private:
void setWaylandMode();
void updateTransform(Transform transform) override;
void automaticRotation();
int gammaRampSize() const override;
bool setGammaRamp(const GammaRamp &gamma) override;
......
......@@ -21,7 +21,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <abstract_client.h>
#include <x11client.h>
#include "cursor.h"
#include "orientation_sensor.h"
#include "utils.h"
#include "settings.h"
#include <workspace.h>
......@@ -55,21 +54,8 @@ Screens::Screens(QObject *parent)
, m_current(0)
, m_currentFollowsMouse(false)
, m_changedTimer(new QTimer(this))
, m_orientationSensor(new OrientationSensor(this))
, m_maxScale(1.0)
{
connect(this, &Screens::changed, this,
[this] {
int internalIndex = -1;
for (int i = 0; i < m_count; i++) {
if (isInternal(i)) {
internalIndex = i;
break;
}
}
m_orientationSensor->setEnabled(internalIndex != -1 && supportsTransformations(internalIndex));
}
);
}
Screens::~Screens()
......@@ -241,9 +227,6 @@ Qt::ScreenOrientation Screens::orientation(int screen) const
void Screens::setConfig(KSharedConfig::Ptr config)
{
m_config = config;
if (m_orientationSensor) {
m_orientationSensor->setConfig(config);
}
}
} // namespace
......@@ -35,7 +35,6 @@ namespace KWin
{
class AbstractClient;
class Platform;
class OrientationSensor;
class KWIN_EXPORT Screens : public QObject
{
......@@ -147,16 +146,6 @@ public:
virtual Qt::ScreenOrientation orientation(int screen) const;
/**
* Provides access to the OrientationSensor. The OrientationSensor is controlled by the
* base implementation. The implementing subclass can use this to get notifications about
* changes of the orientation and current orientation. There is no need to enable/disable it,
* that is done by the base implementation
*/
OrientationSensor *orientationSensor() const {
return m_orientationSensor;
}
public Q_SLOTS:
void reconfigure();
......@@ -208,7 +197,6 @@ private:
QTimer *m_changedTimer;
KSharedConfig::Ptr m_config;
QSize m_boundingSize;
OrientationSensor *m_orientationSensor;
qreal m_maxScale;
KWIN_SINGLETON(Screens)
......
......@@ -38,10 +38,3 @@ add_executable(cursorhotspottest cursorhotspottest.cpp)
target_link_libraries(cursorhotspottest Qt5::Widgets)
include_directories(${CMAKE_CURRENT_BINARY_DIR})
set(orientationtest_SRCS
../orientation_sensor.cpp
orientationtest.cpp
)
qt5_add_dbus_adaptor(orientationtest_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../org.kde.kwin.OrientationSensor.xml ${CMAKE_CURRENT_SOURCE_DIR}/../orientation_sensor.h KWin::OrientationSensor)
add_executable(orientationtest ${orientationtest_SRCS})
target_link_libraries(orientationtest Qt5::DBus Qt5::Widgets Qt5::Sensors KF5::ConfigCore KF5::Notifications KF5::I18n)
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2017 Martin Flöser <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/>.
*********************************************************************/
#include "../orientation_sensor.h"
#include <QApplication>
#include <QDebug>
using KWin::OrientationSensor;
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
OrientationSensor sensor;
QObject::connect(&sensor, &OrientationSensor::orientationChanged,
[&sensor] {
const auto orientation = sensor.orientation();
switch (orientation) {
case OrientationSensor::Orientation::Undefined:
qDebug() << "Undefined";
break;
case OrientationSensor::Orientation::TopUp:
qDebug() << "TopUp";
break;
case OrientationSensor::Orientation::TopDown:
qDebug() << "TopDown";
break;
case OrientationSensor::Orientation::LeftUp:
qDebug() << "LeftUp";
break;
case OrientationSensor::Orientation::RightUp:
qDebug() << "RightUp";
break;
case OrientationSensor::Orientation::FaceUp:
qDebug() << "FaceUp";
break;
case OrientationSensor::Orientation::FaceDown:
qDebug() << "FaceDown";
break;
}
}
);
sensor.setEnabled(true);
return app.exec();
}
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment