alecs/plasma-framework
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

remove dead files

Browse Source 
fullscreensheet and fullscreenwindow were leftovers from porting to kf5
and have not been built since years, remove them
This commit is contained in:
Marco Martin 2019-11-22 16:13:06 +01:00
parent 6de88ef932
commit 4089bba04a
4 changed files with 0 additions and 689 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
src/declarativeimports/plasmacomponents/fullscreensheet.cpp
View File

@ -1,141 +0,0 @@
/***************************************************************************
* Copyright 2012 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#include "fullscreensheet.h"
#include <QApplication>
#include <QDesktopWidget>
#include <QGraphicsView>
#include <QDebug>
FullScreenSheet::FullScreenSheet(QDeclarativeItem *parent)
: FullScreenWindow(parent)
{
init("Sheet");
view()->setGeometry(QApplication::desktop()->availableGeometry());
if (mainItem()) {
connect(mainItem(), SIGNAL(titleChanged()),
this, SIGNAL(titleChanged()));
connect(mainItem(), SIGNAL(acceptButtonChanged()),
this, SIGNAL(acceptButtonChanged()));
connect(mainItem(), SIGNAL(rejectButtonChanged()),
this, SIGNAL(rejectButtonChanged()));
connect(mainItem(), SIGNAL(acceptButtonTextChanged()),
this, SIGNAL(acceptButtonTextChanged()));
connect(mainItem(), SIGNAL(rejectButtonTextChanged()),
this, SIGNAL(rejectButtonTextChanged()));
}
}
FullScreenSheet::~FullScreenSheet()
{
}
QString FullScreenSheet::title() const
{
if (mainItem()) {
return mainItem()->property("title").toString();
} else {
return 0;
}
}
void FullScreenSheet::setTitle(const QString &text)
{
if (mainItem()) {
mainItem()->setProperty("title", QVariant::fromValue(text));
}
}
QDeclarativeItem *FullScreenSheet::acceptButton() const
{
if (mainItem()) {
return mainItem()->property("acceptButton").value<QDeclarativeItem *>();
} else {
return 0;
}
}
void FullScreenSheet::setAcceptButton(QDeclarativeItem *button)
{
if (mainItem()) {
mainItem()->setProperty("acceptButton", QVariant::fromValue(button));
}
}
QDeclarativeItem *FullScreenSheet::rejectButton() const
{
if (mainItem()) {
return mainItem()->property("rejectButton").value<QDeclarativeItem *>();
} else {
return 0;
}
}
void FullScreenSheet::setRejectButton(QDeclarativeItem *button)
{
if (mainItem()) {
mainItem()->setProperty("rejectButton", QVariant::fromValue(button));
}
}
QString FullScreenSheet::acceptButtonText() const
{
if (mainItem()) {
return mainItem()->property("acceptButtonText").toString();
} else {
return 0;
}
}
void FullScreenSheet::setAcceptButtonText(const QString &text)
{
if (mainItem()) {
mainItem()->setProperty("acceptButtonText", QVariant::fromValue(text));
}
}
QString FullScreenSheet::rejectButtonText() const
{
if (mainItem()) {
return mainItem()->property("rejectButtonText").toString();
} else {
return 0;
}
}
void FullScreenSheet::setRejectButtonText(const QString &text)
{
if (mainItem()) {
mainItem()->setProperty("rejectButtonText", QVariant::fromValue(text));
}
}
void FullScreenSheet::open()
{
if (mainItem()) {
view()->setGeometry(QApplication::desktop()->availableGeometry());
QMetaObject::invokeMethod(mainItem(), "open");
}
}

64
src/declarativeimports/plasmacomponents/fullscreensheet.h
View File

@ -1,64 +0,0 @@
/***************************************************************************
* Copyright 2012 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#ifndef FULLSCREENSHEET_P
#define FULLSCREENSHEET_P
#include "fullscreenwindow.h"
class FullScreenSheet : public FullScreenWindow
{
Q_OBJECT
Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged)
Q_PROPERTY(QDeclarativeItem *acceptButton READ acceptButton WRITE setAcceptButton NOTIFY acceptButtonChanged)
Q_PROPERTY(QDeclarativeItem *rejectButton READ rejectButton WRITE setRejectButton NOTIFY rejectButtonChanged)
Q_PROPERTY(QString acceptButtonText READ acceptButtonText WRITE setAcceptButtonText NOTIFY acceptButtonTextChanged)
Q_PROPERTY(QString rejectButtonText READ rejectButtonText WRITE setRejectButtonText NOTIFY rejectButtonTextChanged)
public:
explicit FullScreenSheet(QDeclarativeItem *parent = nullptr);
~FullScreenSheet() override;
QString title() const;
void setTitle(const QString &text);
QDeclarativeItem *acceptButton() const;
void setAcceptButton(QDeclarativeItem *button);
QDeclarativeItem *rejectButton() const;
void setRejectButton(QDeclarativeItem *button);
QString acceptButtonText() const;
void setAcceptButtonText(const QString &text);
QString rejectButtonText() const;
void setRejectButtonText(const QString &text);
Q_INVOKABLE void open();
Q_SIGNALS:
void titleChanged();
void acceptButtonChanged();
void rejectButtonChanged();
void acceptButtonTextChanged();
void rejectButtonTextChanged();
};
#endif

384
src/declarativeimports/plasmacomponents/fullscreenwindow.cpp
View File

@ -1,384 +0,0 @@
/***************************************************************************
* Copyright 2012 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#include "fullscreenwindow.h"
#include "../core/declarativeitemcontainer_p.h"
#include "plasmacomponentsplugin.h"
#include <QApplication>
#include <QDeclarativeItem>
#include <QDeclarativeContext>
#include <QGraphicsObject>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsWidget>
#include <QLayout>
#include <QTimer>
#include <QDesktopWidget>
#include <QFile>
#include <kwindowsystem.h>
#include <KStandardDirs>
#include <kdeclarative/kdeclarative.h>
#include <Plasma/Corona>
#include <Plasma/WindowEffects>
uint FullScreenWindow::s_numItems = 0;
class Background : public QWidget
{
public:
Background(FullScreenWindow *dialog)
: QWidget(0L),
m_dialog(dialog)
{
setAttribute(Qt::WA_NoSystemBackground);
setAttribute(Qt::WA_TranslucentBackground);
setWindowFlags(Qt::FramelessWindowHint | Qt::CustomizeWindowHint);
KWindowSystem::setOnAllDesktops(winId(), true);
unsigned long state = NET::Sticky | NET::StaysOnTop | NET::KeepAbove | NET::SkipTaskbar | NET::SkipPager | NET::MaxVert | NET::MaxHoriz;
KWindowSystem::setState(effectiveWinId(), state);
}
~Background()
{}
void paintEvent(QPaintEvent *e)
{
QPainter painter(this);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.fillRect(e->rect(), QColor(0, 0, 0, 80));
}
void mousePressEvent(QMouseEvent *event)
{
event->accept();
m_dialog->view()->winId();
KWindowSystem::forceActiveWindow(m_dialog->view()->winId());
}
void mouseReleaseEvent(QMouseEvent *event)
{
if (!m_dialog->view()->geometry().contains(event->globalPos())) {
emit m_dialog->clickedOutside();
m_dialog->close();
}
}
private:
FullScreenWindow *m_dialog;
};
FullScreenWindow::FullScreenWindow(QDeclarativeItem *parent)
: QDeclarativeItem(parent),
m_declarativeItemContainer(0)
{
m_view = new QGraphicsView();
m_view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_view->installEventFilter(this);
m_view->setAutoFillBackground(false);
m_view->viewport()->setAutoFillBackground(false);
m_view->setAttribute(Qt::WA_TranslucentBackground);
m_view->setAttribute(Qt::WA_NoSystemBackground);
m_view->viewport()->setAttribute(Qt::WA_NoSystemBackground);
m_view->setCacheMode(QGraphicsView::CacheNone);
m_view->setWindowFlags(Qt::FramelessWindowHint | Qt::CustomizeWindowHint);
m_view->setFrameShape(QFrame::NoFrame);
KWindowSystem::setOnAllDesktops(m_view->winId(), true);
unsigned long state = NET::Sticky | NET::StaysOnTop | NET::KeepAbove | NET::SkipTaskbar | NET::SkipPager;
KWindowSystem::setState(m_view->effectiveWinId(), state);
m_background = new Background(this);
}
FullScreenWindow::~FullScreenWindow()
{
delete m_view;
}
void FullScreenWindow::init(const QString &componentName)
{
if (m_rootObject) {
return;
}
//Try to figure out the path of the dialog component
const QString target = KDeclarative::componentsTarget();
QString filePath;
if (target != KDeclarative::defaultComponentsTarget()) {
const QString file = "platformimports/" % target % "/org/kde/plasma/components/" % componentName % ".qml";
filePath = KStandardDirs::locate("module", file);
}
if (filePath.isEmpty()) {
const QString file = "imports/org/kde/plasma/components/" % componentName % ".qml";
filePath = KStandardDirs::locate("module", file);
}
if (filePath.isEmpty()) {
qWarning() << "Component not found:" << componentName;
return;
}
QDeclarativeEngine *engine = EngineBookKeeping::self()->engine();
if (!engine) {
qWarning() << "Warning, no QDeclarativeEngines available anymore, should never happen";
Q_ASSERT(0);
}
QDeclarativeComponent *component = new QDeclarativeComponent(engine, filePath, this);
QDeclarativeContext *creationContext = component->creationContext();
m_rootObject = component->create(creationContext);
if (component->status() == QDeclarativeComponent::Error) {
qWarning() << component->errors();
}
if (m_rootObject) {
setMainItem(qobject_cast<QGraphicsObject *>(m_rootObject.data()));
connect(m_rootObject.data(), SIGNAL(statusChanged()), this, SLOT(statusHasChanged()));
connect(m_rootObject.data(), SIGNAL(accepted()), this, SIGNAL(accepted()));
connect(m_rootObject.data(), SIGNAL(rejected()), this, SIGNAL(rejected()));
connect(m_rootObject.data(), SIGNAL(clickedOutside()), this, SIGNAL(clickedOutside()));
}
}
QGraphicsObject *FullScreenWindow::mainItem() const
{
return m_mainItem.data();
}
void FullScreenWindow::setMainItem(QGraphicsObject *mainItem)
{
if (m_mainItem.data() != mainItem) {
if (m_mainItem) {
m_mainItem.data()->setParent(mainItem->parent());
m_mainItem.data()->removeEventFilter(this);
m_mainItem.data()->setY(0);
m_scene = 0;
}
m_mainItem = mainItem;
if (mainItem) {
mainItem->setParentItem(0);
mainItem->setParent(this);
m_scene = mainItem->scene();
m_view->resize(mainItem->boundingRect().size().toSize());
mainItem->installEventFilter(this);
}
//if this is called in Component.onCompleted we have to wait a loop the item is added to a scene
QTimer::singleShot(0, this, SLOT(syncViewToMainItem()));
}
}
void FullScreenWindow::syncViewToMainItem()
{
if (!m_mainItem) {
return;
}
//not have a scene? go up in the hierarchy until we find something with a scene
QGraphicsScene *scene = m_mainItem.data()->scene();
if (!scene) {
QObject *parent = m_mainItem.data();
while ((parent = parent->parent())) {
QGraphicsObject *qo = qobject_cast<QGraphicsObject *>(parent);
if (qo) {
scene = qo->scene();
if (scene) {
scene->addItem(m_mainItem.data());
++s_numItems;
Plasma::Corona *corona = qobject_cast<Plasma::Corona *>(scene);
QDeclarativeItem *di = qobject_cast<QDeclarativeItem *>(m_mainItem.data());
if (corona && di) {
if (!m_declarativeItemContainer) {
m_declarativeItemContainer = new DeclarativeItemContainer();
scene->addItem(m_declarativeItemContainer);
corona->addOffscreenWidget(m_declarativeItemContainer);
}
m_declarativeItemContainer->setDeclarativeItem(di);
} else {
m_mainItem.data()->setY(-10000 * s_numItems);
m_mainItem.data()->setY(10000 * s_numItems);
}
break;
}
}
}
}
if (!scene) {
return;
}
m_view->setScene(scene);
QRectF itemGeometry(QPointF(m_mainItem.data()->x(), m_mainItem.data()->y()),
QSizeF(m_mainItem.data()->boundingRect().size()));
if (m_declarativeItemContainer) {
m_view->resize(itemGeometry.size().toSize());
m_view->setSceneRect(m_declarativeItemContainer->geometry());
} else {
QRectF itemGeometry(QPointF(m_mainItem.data()->x(), m_mainItem.data()->y()),
QSizeF(m_mainItem.data()->boundingRect().size()));
m_view->resize(itemGeometry.size().toSize());
m_view->setSceneRect(itemGeometry);
}
m_view->move(QApplication::desktop()->availableGeometry().center() - QPoint(m_view->width() / 2, m_view->height() / 2));
}
void FullScreenWindow::syncMainItemToView()
{
if (!m_mainItem) {
return;
}
m_mainItem.data()->setProperty("width", m_view->width());
m_mainItem.data()->setProperty("height", m_view->height());
if (m_declarativeItemContainer) {
m_declarativeItemContainer->resize(m_view->size());
m_view->setSceneRect(m_declarativeItemContainer->geometry());
} else {
QRectF itemGeometry(QPointF(m_mainItem.data()->x(), m_mainItem.data()->y()),
QSizeF(m_mainItem.data()->boundingRect().size()));
m_view->setSceneRect(itemGeometry);
}
}
bool FullScreenWindow::isVisible() const
{
return m_view->isVisible();
}
void FullScreenWindow::setVisible(const bool visible)
{
if (m_view->isVisible() != visible) {
m_background->setVisible(visible);
Plasma::WindowEffects::slideWindow(m_view->winId(), Plasma::BottomEdge, 0);
m_view->setVisible(visible);
unsigned long state = NET::Sticky | NET::StaysOnTop | NET::KeepAbove | NET::SkipTaskbar | NET::SkipPager;
KWindowSystem::setState(m_view->effectiveWinId(), state);
KWindowSystem::setState(m_background->effectiveWinId(), state);
if (visible) {
m_view->raise();
KWindowSystem::forceActiveWindow(m_view->effectiveWinId());
}
}
}
QGraphicsView *FullScreenWindow::view() const
{
return m_view;
}
QDeclarativeListProperty<QGraphicsObject> FullScreenWindow::title()
{
if (m_rootObject) {
return m_rootObject.data()->property("title").value<QDeclarativeListProperty<QGraphicsObject> >();
} else {
return QDeclarativeListProperty<QGraphicsObject>(this, m_dummyTitleElements);
}
}
QDeclarativeListProperty<QGraphicsObject> FullScreenWindow::content()
{
if (m_rootObject) {
return m_rootObject.data()->property("content").value<QDeclarativeListProperty<QGraphicsObject> >();
} else {
return QDeclarativeListProperty<QGraphicsObject>(this, m_dummyContentElements);
}
}
QDeclarativeListProperty<QGraphicsObject> FullScreenWindow::buttons()
{
if (m_rootObject) {
return m_rootObject.data()->property("buttons").value<QDeclarativeListProperty<QGraphicsObject> >();
} else {
return QDeclarativeListProperty<QGraphicsObject>(this, m_dummyButtonsElements);
}
}
DialogStatus::Status FullScreenWindow::status() const
{
if (m_rootObject) {
return (DialogStatus::Status)m_rootObject.data()->property("status").toInt();
} else {
return DialogStatus::Closed;
}
}
void FullScreenWindow::statusHasChanged()
{
if (status() == DialogStatus::Closed) {
setVisible(false);
} else {
setVisible(true);
}
emit statusChanged();
}
void FullScreenWindow::open()
{
if (m_rootObject) {
QMetaObject::invokeMethod(m_rootObject.data(), "open");
}
}
void FullScreenWindow::accept()
{
if (m_rootObject) {
QMetaObject::invokeMethod(m_rootObject.data(), "accept");
}
}
void FullScreenWindow::reject()
{
if (m_rootObject) {
QMetaObject::invokeMethod(m_rootObject.data(), "reject");
}
}
void FullScreenWindow::close()
{
if (m_rootObject) {
QMetaObject::invokeMethod(m_rootObject.data(), "close");
}
}
bool FullScreenWindow::eventFilter(QObject *watched, QEvent *event)
{
if (watched == m_mainItem.data() &&
(event->type() == QEvent::GraphicsSceneResize)) {
syncViewToMainItem();
} else if (watched == m_view &&
(event->type() == QEvent::Resize)) {
syncMainItemToView();
}
return false;
}

100
src/declarativeimports/plasmacomponents/fullscreenwindow.h
View File

@ -1,100 +0,0 @@
/***************************************************************************
* Copyright 2012 Marco Martin <mart@kde.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#ifndef FULLSCREENWINDOW_P
#define FULLSCREENWINDOW_P
#include <QObject>
#include <QPoint>
#include <QRect>
#include <QPointer>
#include <QDeclarativeListProperty>
#include <QDeclarativeItem>
#include "enums.h"
class QGraphicsObject;
class QGraphicsView;
class QGraphicsScene;
class DeclarativeItemContainer;
class Background;
class FullScreenWindow : public QDeclarativeItem
{
Q_OBJECT
Q_PROPERTY(QDeclarativeListProperty<QGraphicsObject> title READ title DESIGNABLE false)
Q_PROPERTY(QDeclarativeListProperty<QGraphicsObject> content READ content DESIGNABLE false)
Q_PROPERTY(QDeclarativeListProperty<QGraphicsObject> buttons READ buttons DESIGNABLE false)
Q_PROPERTY(DialogStatus::Status status READ status NOTIFY statusChanged)
public:
explicit FullScreenWindow(QDeclarativeItem *parent = nullptr);
~FullScreenWindow() override;
QGraphicsObject *mainItem() const;
void setMainItem(QGraphicsObject *mainItem);
bool isVisible() const;
void setVisible(const bool visible);
QGraphicsView *view() const;
//QML properties
QDeclarativeListProperty<QGraphicsObject> title();
QDeclarativeListProperty<QGraphicsObject> content();
QDeclarativeListProperty<QGraphicsObject> buttons();
DialogStatus::Status status() const;
Q_INVOKABLE void open();
Q_INVOKABLE void accept();
Q_INVOKABLE void reject();
Q_INVOKABLE void close();
Q_SIGNALS:
void accepted();
void rejected();
void clickedOutside();
void statusChanged();
private Q_SLOTS:
void syncViewToMainItem();
void syncMainItemToView();
void statusHasChanged();
protected:
bool eventFilter(QObject *watched, QEvent *event);
void init(const QString &componentName);
private:
QGraphicsView *m_view;
QPointer<QGraphicsObject> m_mainItem;
DeclarativeItemContainer *m_declarativeItemContainer;
QGraphicsScene *m_scene;
QPointer<QObject> m_rootObject;
static uint s_numItems;
Background *m_background;
//those only used in case of error, to not make plasma crash
QList<QGraphicsObject *> m_dummyTitleElements;
QList<QGraphicsObject *> m_dummyContentElements;
QList<QGraphicsObject *> m_dummyButtonsElements;
friend class Background;
};
#endif