mirror of
https://bitbucket.org/smil3y/kde-workspace.git
synced 2025-02-24 19:02:51 +00:00
546 lines
14 KiB
C++
546 lines
14 KiB
C++
/***************************************************************************
|
|
* Copyright (C) 2010 - 2011 by Ingomar Wesp <ingomar@wesp.name> *
|
|
* *
|
|
* 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 "launchergrid.h"
|
|
|
|
// Qt
|
|
#include <QtCore/qnamespace.h>
|
|
#include <QtGlobal>
|
|
#include <QtCore/QEvent>
|
|
#include <QtCore/QMimeData>
|
|
#include <QtCore/QPointer>
|
|
#include <QtCore/qpoint.h>
|
|
#include <QtCore/qrect.h>
|
|
#include <QtCore/QUrl>
|
|
#include <QtGui/QApplication>
|
|
#include <QtGui/QBrush>
|
|
#include <QtGui/QDrag>
|
|
#include <QtGui/QGraphicsGridLayout>
|
|
#include <QtGui/QGraphicsItem>
|
|
#include <QtGui/QGraphicsLinearLayout>
|
|
#include <QtGui/qgraphicssceneevent.h>
|
|
#include <QtGui/qgraphicssceneevent.h>
|
|
#include <QtGui/qgraphicssceneevent.h>
|
|
#include <QtGui/QGraphicsWidget>
|
|
#include <QtGui/QIcon>
|
|
#include <QtGui/QPainter>
|
|
#include <QtGui/QSizePolicy>
|
|
#include <QtGui/qstyleoption.h>
|
|
#include <QtGui/QWidget>
|
|
|
|
// KDE
|
|
#include <KIcon>
|
|
#include <KIconLoader>
|
|
#include <KUrl>
|
|
|
|
// Plasma
|
|
#include <Plasma/Plasma>
|
|
#include <Plasma/IconWidget>
|
|
#include <Plasma/Theme>
|
|
#include <Plasma/ToolTipContent>
|
|
#include <Plasma/ToolTipManager>
|
|
|
|
// stdlib
|
|
#include <math.h>
|
|
|
|
// Own
|
|
#include "icongridlayout.h"
|
|
#include "launcherdata.h"
|
|
#include "launcher.h"
|
|
|
|
using Plasma::Theme;
|
|
|
|
namespace Quicklaunch {
|
|
|
|
class DropMarker : public Launcher {
|
|
|
|
public:
|
|
DropMarker(LauncherGrid *parent)
|
|
: Launcher(LauncherData(), parent)
|
|
{
|
|
hide();
|
|
}
|
|
|
|
protected:
|
|
void paint(
|
|
QPainter *painter,
|
|
const QStyleOptionGraphicsItem *option,
|
|
QWidget *widget)
|
|
{
|
|
// This mirrors the behavior of the panel spacer committed by mart
|
|
// workspace/plasma/desktop/containments/panel/panel.cpp R875513)
|
|
QColor brushColor(Theme::defaultTheme()->color(Theme::TextColor));
|
|
brushColor.setAlphaF(0.3);
|
|
|
|
painter->setRenderHint(QPainter::Antialiasing);
|
|
painter->setPen(Qt::NoPen);
|
|
painter->setBrush(QBrush(brushColor));
|
|
|
|
painter->drawRoundedRect(contentsRect(), 4, 4);
|
|
Launcher::paint(painter, option, widget);
|
|
}
|
|
};
|
|
|
|
LauncherGrid::LauncherGrid(QGraphicsItem *parent)
|
|
:
|
|
QGraphicsWidget(parent),
|
|
m_launchers(),
|
|
m_launcherNamesVisible(false),
|
|
m_preferredIconSize(),
|
|
m_locked(false),
|
|
m_layout(new IconGridLayout()),
|
|
m_mousePressedPos(),
|
|
m_dropMarker(new DropMarker(this)),
|
|
m_dropMarkerIndex(-1),
|
|
m_placeHolder(0)
|
|
{
|
|
m_dropMarker->setOrientation(Qt::Vertical);
|
|
|
|
setLayout(m_layout);
|
|
initPlaceHolder();
|
|
|
|
setLocked(false);
|
|
}
|
|
|
|
bool LauncherGrid::launcherNamesVisible() const
|
|
{
|
|
return m_launcherNamesVisible;
|
|
}
|
|
|
|
void LauncherGrid::setLauncherNamesVisible(bool enable)
|
|
{
|
|
if (enable == m_launcherNamesVisible) {
|
|
return;
|
|
}
|
|
|
|
Q_FOREACH (Launcher *launcher, m_launchers) {
|
|
launcher->setNameVisible(enable);
|
|
}
|
|
m_dropMarker->setNameVisible(enable);
|
|
m_launcherNamesVisible = enable;
|
|
}
|
|
|
|
void LauncherGrid::setPreferredIconSize(int size)
|
|
{
|
|
QSizeF newSize(size, size);
|
|
|
|
if (newSize == m_preferredIconSize) {
|
|
return;
|
|
}
|
|
|
|
m_preferredIconSize = newSize;
|
|
m_dropMarker->setPreferredIconSize(newSize);
|
|
|
|
Q_FOREACH (Launcher *launcher, m_launchers) {
|
|
launcher->setPreferredIconSize(newSize);
|
|
}
|
|
|
|
if (m_placeHolder) {
|
|
m_placeHolder->setPreferredIconSize(newSize);
|
|
}
|
|
}
|
|
|
|
LauncherGrid::LayoutMode LauncherGrid::layoutMode() const
|
|
{
|
|
IconGridLayout::Mode mode = m_layout->mode();
|
|
|
|
if (mode == IconGridLayout::PreferColumns) {
|
|
return PreferColumns;
|
|
} else {
|
|
return PreferRows;
|
|
}
|
|
}
|
|
|
|
void LauncherGrid::setLayoutMode(LauncherGrid::LayoutMode mode)
|
|
{
|
|
if (mode == PreferColumns) {
|
|
m_layout->setMode(IconGridLayout::PreferColumns);
|
|
} else {
|
|
m_layout->setMode(IconGridLayout::PreferRows);
|
|
}
|
|
}
|
|
|
|
int LauncherGrid::maxSectionCount() const
|
|
{
|
|
return m_layout->maxSectionCount();
|
|
}
|
|
|
|
void LauncherGrid::setMaxSectionCount(int maxSectionCount)
|
|
{
|
|
m_layout->setMaxSectionCount(maxSectionCount);
|
|
}
|
|
|
|
bool LauncherGrid::maxSectionCountForced() const
|
|
{
|
|
return m_layout->maxSectionCountForced();
|
|
}
|
|
|
|
void LauncherGrid::setMaxSectionCountForced(bool enable)
|
|
{
|
|
m_layout->setMaxSectionCountForced(enable);
|
|
}
|
|
|
|
bool LauncherGrid::locked() const
|
|
{
|
|
return m_locked;
|
|
}
|
|
|
|
void LauncherGrid::setLocked(bool enable)
|
|
{
|
|
m_locked = enable;
|
|
setAcceptDrops(!enable);
|
|
}
|
|
|
|
IconGridLayout *LauncherGrid::layout() const
|
|
{
|
|
return m_layout;
|
|
}
|
|
|
|
int LauncherGrid::launcherCount() const
|
|
{
|
|
return m_launchers.size();
|
|
}
|
|
|
|
void LauncherGrid::clear()
|
|
{
|
|
while(launcherCount() > 0) {
|
|
removeAt(0);
|
|
}
|
|
}
|
|
|
|
void LauncherGrid::insert(int index, const LauncherData &launcherData)
|
|
{
|
|
QList<LauncherData> launcherDataList;
|
|
launcherDataList.append(launcherData);
|
|
insert(index, launcherDataList);
|
|
}
|
|
|
|
void LauncherGrid::insert(int index, const QList<LauncherData> &launcherDataList)
|
|
{
|
|
if (launcherDataList.size() == 0) {
|
|
return;
|
|
}
|
|
|
|
if (m_launchers.size() == 0 && m_placeHolder) {
|
|
deletePlaceHolder();
|
|
index = 0;
|
|
}
|
|
else if (index < 0 || index > m_launchers.size()) {
|
|
index = m_launchers.size();
|
|
}
|
|
|
|
Q_FOREACH(const LauncherData &launcherData, launcherDataList) {
|
|
|
|
Launcher *launcher = new Launcher(launcherData);
|
|
|
|
launcher->setNameVisible(m_launcherNamesVisible);
|
|
launcher->setOrientation(Qt::Vertical);
|
|
|
|
if (m_preferredIconSize.isValid()) {
|
|
launcher->setPreferredIconSize(m_preferredIconSize);
|
|
}
|
|
|
|
launcher->installEventFilter(this);
|
|
connect(launcher, SIGNAL(clicked()), this, SIGNAL(launcherClicked()));
|
|
|
|
m_launchers.insert(index, launcher);
|
|
|
|
int layoutIndex = index;
|
|
|
|
if (m_dropMarkerIndex != -1) {
|
|
if (m_dropMarkerIndex <= index) {
|
|
layoutIndex++;
|
|
} else {
|
|
m_dropMarkerIndex++;
|
|
}
|
|
}
|
|
|
|
m_layout->insertItem(layoutIndex, launcher);
|
|
index++;
|
|
}
|
|
|
|
Q_EMIT launchersChanged();
|
|
}
|
|
|
|
void LauncherGrid::removeAt(int index)
|
|
{
|
|
int layoutIndex = index;
|
|
|
|
if (m_dropMarkerIndex != -1) {
|
|
if (m_dropMarkerIndex <= index) {
|
|
layoutIndex++;
|
|
} else {
|
|
m_dropMarkerIndex--;
|
|
}
|
|
}
|
|
|
|
m_layout->removeAt(layoutIndex);
|
|
delete m_launchers.takeAt(index);
|
|
|
|
if (m_launchers.size() == 0 && m_dropMarkerIndex == -1) {
|
|
initPlaceHolder();
|
|
}
|
|
|
|
Q_EMIT launchersChanged();
|
|
}
|
|
|
|
LauncherData LauncherGrid::launcherAt(int index) const
|
|
{
|
|
return m_launchers.at(index)->launcherData();
|
|
}
|
|
|
|
int LauncherGrid::launcherIndexAtPosition(const QPointF& pos) const
|
|
{
|
|
for (int i = 0; i < m_launchers.size(); i++) {
|
|
if (m_launchers.at(i)->geometry().contains(pos)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool LauncherGrid::eventFilter(QObject *watched, QEvent *event)
|
|
{
|
|
Launcher *sourceLauncher =
|
|
qobject_cast<Launcher*>(watched);
|
|
|
|
// Start of Drag & Drop operations
|
|
if (sourceLauncher && !m_locked) {
|
|
|
|
if (event->type() == QEvent::GraphicsSceneMousePress) {
|
|
m_mousePressedPos =
|
|
static_cast<QGraphicsSceneMouseEvent*>(event)->pos();
|
|
|
|
return false;
|
|
}
|
|
else if (event->type() == QEvent::GraphicsSceneMouseMove) {
|
|
|
|
QGraphicsSceneMouseEvent *mouseEvent =
|
|
static_cast<QGraphicsSceneMouseEvent*>(event);
|
|
|
|
if ((m_mousePressedPos - mouseEvent->pos()).manhattanLength() >=
|
|
QApplication::startDragDistance()) {
|
|
|
|
LauncherData sourceData = sourceLauncher->launcherData();
|
|
|
|
QMimeData *mimeData = new QMimeData();
|
|
sourceData.populateMimeData(mimeData);
|
|
|
|
QPointer<QDrag> drag = new QDrag(mouseEvent->widget());
|
|
drag->setMimeData(mimeData);
|
|
drag->setPixmap(sourceLauncher->icon().pixmap(16, 16));
|
|
|
|
int launcherIndex = m_launchers.indexOf(sourceLauncher);
|
|
|
|
removeAt(launcherIndex);
|
|
|
|
Qt::DropAction dropAction = drag->exec();
|
|
|
|
if (dropAction != Qt::MoveAction) {
|
|
// Restore the icon.
|
|
insert(launcherIndex, sourceData);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void LauncherGrid::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
|
|
{
|
|
Q_ASSERT(!m_locked);
|
|
|
|
Qt::DropAction proposedAction = event->proposedAction();
|
|
|
|
if (proposedAction != Qt::CopyAction && proposedAction != Qt::MoveAction) {
|
|
|
|
Qt::DropActions possibleActions = event->possibleActions();
|
|
|
|
if (possibleActions & Qt::CopyAction) {
|
|
event->setProposedAction(Qt::CopyAction);
|
|
}
|
|
else if (possibleActions & Qt::MoveAction) {
|
|
event->setProposedAction(Qt::MoveAction);
|
|
} else {
|
|
event->setAccepted(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Initialize drop marker
|
|
const QMimeData *mimeData = event->mimeData();
|
|
|
|
if (LauncherData::canDecode(mimeData)) {
|
|
QList<LauncherData> data = LauncherData::fromMimeData(mimeData);
|
|
|
|
if (data.size() > 0) {
|
|
|
|
if (data.size() == 1) {
|
|
m_dropMarker->setLauncherData(data.at(0));
|
|
} else {
|
|
m_dropMarker->setLauncherData(LauncherData());
|
|
m_dropMarker->setIcon("document-multiple");
|
|
|
|
if (m_launcherNamesVisible) {
|
|
m_dropMarker->setText(i18n("Multiple items"));
|
|
} else {
|
|
m_dropMarker->setText(QString());
|
|
}
|
|
}
|
|
|
|
if (m_launchers.size() != 0) {
|
|
m_dropMarkerIndex = determineDropMarkerIndex(
|
|
mapFromScene(event->scenePos()));
|
|
|
|
} else {
|
|
deletePlaceHolder();
|
|
m_dropMarkerIndex = 0;
|
|
}
|
|
|
|
m_layout->insertItem(m_dropMarkerIndex, m_dropMarker);
|
|
m_dropMarker->show();
|
|
|
|
event->accept();
|
|
} else {
|
|
event->setAccepted(false);
|
|
return;
|
|
}
|
|
} else {
|
|
event->setAccepted(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void LauncherGrid::dragMoveEvent(QGraphicsSceneDragDropEvent *event)
|
|
{
|
|
// DragMoveEvents are always preceded by DragEnterEvents
|
|
Q_ASSERT(m_dropMarkerIndex != -1);
|
|
|
|
int newDropMarkerIndex =
|
|
determineDropMarkerIndex(mapFromScene(event->scenePos()));
|
|
|
|
if (newDropMarkerIndex != m_dropMarkerIndex) {
|
|
m_layout->moveItem(m_dropMarkerIndex, newDropMarkerIndex);
|
|
m_dropMarkerIndex = newDropMarkerIndex;
|
|
}
|
|
}
|
|
|
|
void LauncherGrid::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
|
|
{
|
|
Q_UNUSED(event);
|
|
|
|
if (m_dropMarkerIndex != -1) {
|
|
|
|
m_dropMarker->hide();
|
|
m_layout->removeAt(m_dropMarkerIndex);
|
|
m_dropMarker->setLauncherData(LauncherData());
|
|
m_dropMarkerIndex = -1;
|
|
|
|
if (m_launchers.size() == 0) {
|
|
initPlaceHolder();
|
|
}
|
|
}
|
|
}
|
|
|
|
void LauncherGrid::dropEvent(QGraphicsSceneDragDropEvent *event)
|
|
{
|
|
int dropIndex = m_dropMarkerIndex;
|
|
|
|
if (dropIndex != -1) {
|
|
m_dropMarker->hide();
|
|
m_layout->removeAt(m_dropMarkerIndex);
|
|
m_dropMarker->setLauncherData(LauncherData());
|
|
m_dropMarkerIndex = -1;
|
|
}
|
|
|
|
const QMimeData *mimeData = event->mimeData();
|
|
|
|
if (LauncherData::canDecode(mimeData)) {
|
|
|
|
QList<LauncherData> data = LauncherData::fromMimeData(mimeData);
|
|
insert(dropIndex, data);
|
|
}
|
|
|
|
event->accept();
|
|
}
|
|
|
|
void LauncherGrid::onPlaceHolderActivated()
|
|
{
|
|
Q_ASSERT(m_placeHolder);
|
|
Plasma::ToolTipManager::self()->show(m_placeHolder);
|
|
}
|
|
|
|
void LauncherGrid::initPlaceHolder()
|
|
{
|
|
Q_ASSERT(!m_placeHolder);
|
|
|
|
m_placeHolder = new Plasma::IconWidget(KIcon("fork"), QString(), this);
|
|
m_placeHolder->setPreferredIconSize(m_dropMarker->preferredIconSize());
|
|
|
|
Plasma::ToolTipContent tcp(
|
|
i18n("Quicklaunch"),
|
|
i18n("Add launchers by Drag and Drop or by using the context menu."),
|
|
m_placeHolder->icon());
|
|
Plasma::ToolTipManager::self()->setContent(m_placeHolder, tcp);
|
|
|
|
connect(m_placeHolder, SIGNAL(activated()), SLOT(onPlaceHolderActivated()));
|
|
|
|
m_layout->addItem(m_placeHolder);
|
|
}
|
|
|
|
void LauncherGrid::deletePlaceHolder()
|
|
{
|
|
Q_ASSERT(m_placeHolder);
|
|
|
|
m_layout->removeAt(0);
|
|
|
|
delete m_placeHolder;
|
|
m_placeHolder = 0;
|
|
}
|
|
|
|
int LauncherGrid::determineDropMarkerIndex(const QPointF &localPos) const
|
|
{
|
|
if (m_placeHolder) {
|
|
return 0;
|
|
}
|
|
|
|
// Determine the new index of the drop marker.
|
|
const int rowCount = m_layout->rowCount();
|
|
const int columnCount = m_layout->columnCount();
|
|
|
|
int row = 0;
|
|
while (row + 1 < rowCount && localPos.y() > m_layout->itemAt(row + 1, 0)->geometry().top()) {
|
|
row++;
|
|
}
|
|
|
|
int col = 0;
|
|
while (col + 1 < columnCount && localPos.x() > m_layout->itemAt(0, col + 1)->geometry().left()) {
|
|
col++;
|
|
}
|
|
|
|
int newDropMarkerIndex = row * columnCount + col;
|
|
|
|
if (newDropMarkerIndex > m_launchers.size())
|
|
newDropMarkerIndex = m_launchers.size();
|
|
|
|
return newDropMarkerIndex;
|
|
}
|
|
}
|
|
|
|
#include "moc_launchergrid.cpp"
|