622 lines
21 KiB
C++
Executable File
622 lines
21 KiB
C++
Executable File
/**
|
|
**
|
|
** @RDE_HEADER@
|
|
** plan_overlay_view.h
|
|
** $Id$
|
|
** $HeadURL$
|
|
** $Author$
|
|
**
|
|
** -----------------------------------------------------------------------------------------------
|
|
**
|
|
** Hardware-Environment: Intel-PC
|
|
** Software-Environment: Windows 7, Qt 5.7. ArcGIS 100
|
|
**
|
|
** Language ........: C++ 11
|
|
**
|
|
** -----------------------------------------------------------------------------------------------
|
|
**
|
|
** Author ...........: Jörg Turla, SPD G, Tel. 3132
|
|
**
|
|
** -----------------------------------------------------------------------------------------------
|
|
**
|
|
** Notes .........:
|
|
**
|
|
** 11.07.2017, JT : First edition for use with Qt5
|
|
**
|
|
** -----------------------------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "plan_overlay_view.h"
|
|
#include "plan_overlay_model.h"
|
|
|
|
#include <LtsWidgets/lts_drag_icon.h>
|
|
|
|
#include <QtCore/QByteArray>
|
|
|
|
#include <QtGui/QGuiApplication>
|
|
#include <QtGui/QPainter>
|
|
#include <QtGui/QTransform>
|
|
|
|
#include <QtWidgets/QHeaderView>
|
|
#include <QtWidgets/QLabel>
|
|
#include <QtWidgets/QPushButton>
|
|
#include <QtWidgets/QSlider>
|
|
#include <QtWidgets/QStyledItemDelegate>
|
|
#include <QtWidgets/QVBoxLayout>
|
|
#include <QtWidgets/QWidget>
|
|
|
|
|
|
namespace PlanOverlaysPlugin
|
|
{
|
|
|
|
class WidgetItemDelegate : public QStyledItemDelegate
|
|
{
|
|
Q_OBJECT
|
|
|
|
private:
|
|
|
|
PlanOverlayView *m_planOverlayView;
|
|
|
|
mutable QMap<QByteArray, QWidget *> m_widgetMap;
|
|
mutable QMap<QByteArray, QSize> m_sizeHints;
|
|
|
|
QByteArray buildKey(const QModelIndex &index) const
|
|
{
|
|
return QByteArray::number(index.row()) + ',' + QByteArray::number(index.column());
|
|
} // QByteArray buildKey(const QModelIndex & index) const
|
|
|
|
|
|
void removeKey(const QByteArray &indexKey, QObject *qobj) const
|
|
{
|
|
QWidget *widget = qobject_cast<QWidget *>(qobj);
|
|
|
|
if (nullptr == widget) return;
|
|
if (!m_widgetMap.contains(indexKey)) return;
|
|
if (widget != m_widgetMap[indexKey]) return;
|
|
|
|
// qCritical() << "remove key " << indexKey << " --> " << widget;
|
|
|
|
m_sizeHints.remove(indexKey);
|
|
m_widgetMap.remove(indexKey);
|
|
} // removeKey
|
|
|
|
public:
|
|
|
|
explicit WidgetItemDelegate(PlanOverlayView *planOverlayView) : QStyledItemDelegate(planOverlayView), m_planOverlayView(planOverlayView) {;}
|
|
~WidgetItemDelegate() = default;
|
|
|
|
|
|
void destroyEditor(QWidget *editor, const QModelIndex &index) const override
|
|
{
|
|
if (!index.isValid()) return;
|
|
if (m_planOverlayView->model()->rowCount() <= index.row()) return; // do not destroy will be needed again
|
|
|
|
const QByteArray &indexKey = buildKey(index);
|
|
removeKey(indexKey, editor);
|
|
if (editor) editor-> deleteLater();
|
|
|
|
// qCritical() << "Destroy widget " << indexKey << " --> " << editor;
|
|
} // void destroyEditor(QWidget* editor, const QModelIndex & index) const
|
|
|
|
|
|
QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override
|
|
{
|
|
const QByteArray &indexKey = buildKey(index);
|
|
|
|
const QVariant &modelData = index.model()->data(index, Qt::DisplayRole);
|
|
|
|
if (m_widgetMap.contains(indexKey))
|
|
{
|
|
QWidget *w = m_widgetMap[indexKey];
|
|
removeKey(indexKey, w);
|
|
if (w) w->deleteLater();
|
|
}
|
|
|
|
const QString &backgroundStyle = QStringLiteral("background-color: %1; color: %2; border:none;").arg(QGuiApplication::palette().color(QPalette::ColorRole::Base).name(),
|
|
m_planOverlayView->palette().text().color().name());
|
|
const QString &backgroundDisabledStyle = QStringLiteral("background-color: %1; color: %2; border:none;").arg(QGuiApplication::palette().color(QPalette::ColorGroup::Disabled, QPalette::ColorRole::Base).name(),
|
|
m_planOverlayView->palette().text().color().name());
|
|
const QString &buttonStyleSheet = QStringLiteral("QPushButton:!disabled {%1}\nQPushButton:disabled {%2}").arg(backgroundStyle, backgroundDisabledStyle);
|
|
|
|
switch (static_cast<PlanOverlayModel::ColumnSection>(index.column()))
|
|
{
|
|
case PlanOverlayModel::ColumnSection::OrderButtons:
|
|
{
|
|
if (index.model()->rowCount() > 1)
|
|
{
|
|
QWidget *orderButtons = new QWidget(parent);
|
|
QVBoxLayout *orderLayout = new QVBoxLayout(orderButtons);
|
|
|
|
QPixmap icon(QStringLiteral("icon:media-vcr-normal.svg")); // better use up and down buttons
|
|
|
|
LtsWidgets::LtsDragIcon *up = nullptr;
|
|
|
|
if (index.row() > 0)
|
|
{
|
|
up = new LtsWidgets::LtsDragIcon(orderButtons);
|
|
|
|
//up->setIcon(QIcon(QStringLiteral("icon:overlay_up.svg"))); // looks not very nice --> use simple arrow
|
|
up->setIcon(QIcon(icon.transformed(QTransform().rotate(-90).scale(0.5, 0.5))));
|
|
up->setText(QString());
|
|
up->setIconSize(LtsWidgets::ButtonSize::eDefault);
|
|
up->setButtonStyle(LtsWidgets::ButtonStyle::eIconOnly);
|
|
up->setProperty("row", index.row());
|
|
up->setToolTip(tr("Move layer up in display order"));
|
|
|
|
connect(up, &LtsWidgets::LtsDragIcon::clicked, m_planOverlayView, &PlanOverlayView::onChangeLayerOrderUp);
|
|
}
|
|
|
|
LtsWidgets::LtsDragIcon *down = nullptr;
|
|
|
|
if ((index.row() + 1) < index.model()->rowCount())
|
|
{
|
|
down = new LtsWidgets::LtsDragIcon(orderButtons);
|
|
|
|
//down->setIcon(QIcon(QStringLiteral("icon:overlay_down.svg"))); // looks not very nice --> use simple arrow
|
|
down->setIcon(QIcon(icon.transformed(QTransform().rotate(90).scale(0.5, 0.5))));
|
|
down->setText(QString());
|
|
down->setIconSize(LtsWidgets::ButtonSize::eDefault);
|
|
down->setButtonStyle(LtsWidgets::ButtonStyle::eIconOnly);
|
|
down->setProperty("row", index.row());
|
|
down->setToolTip(tr("Move layer down in display order"));
|
|
connect(down, &LtsWidgets::LtsDragIcon::clicked, m_planOverlayView, &PlanOverlayView::onChangeLayerOrderDown);
|
|
}
|
|
|
|
orderLayout->addStretch();
|
|
orderLayout->addSpacing(5);
|
|
if (up) orderLayout->addWidget(up);
|
|
if (down) orderLayout->addWidget(down);
|
|
orderLayout->addSpacing(5);
|
|
orderLayout->addStretch();
|
|
|
|
orderButtons->setAutoFillBackground(true);
|
|
|
|
connect(orderButtons, &QObject::destroyed, orderButtons, [this, indexKey](QObject * qobj) { removeKey(indexKey, qobj); });
|
|
|
|
m_sizeHints[indexKey] = orderButtons->sizeHint();
|
|
m_widgetMap[indexKey] = orderButtons;
|
|
|
|
// qCritical() << "setup " << indexKey << " --> " << orderButtons;
|
|
|
|
return orderButtons;
|
|
}
|
|
break;
|
|
};
|
|
|
|
case PlanOverlayModel::ColumnSection::PlanName:
|
|
{
|
|
QLabel *laName = new QLabel(modelData.toString(), parent);
|
|
|
|
laName->setAlignment(Qt::AlignCenter);
|
|
laName->setStyleSheet(QStringLiteral("QLabel:!disabled {%1}\nQLabel:disabled {%2}").arg(backgroundStyle, backgroundDisabledStyle));
|
|
|
|
m_sizeHints[indexKey] = laName->sizeHint();
|
|
m_widgetMap[indexKey] = laName;
|
|
|
|
return laName;
|
|
|
|
};
|
|
|
|
case PlanOverlayModel::ColumnSection::MinScale:
|
|
{
|
|
QPushButton *pbScaleMin = new QPushButton(parent);
|
|
pbScaleMin->setStyleSheet(buttonStyleSheet);
|
|
pbScaleMin->setPalette(m_planOverlayView->palette());
|
|
pbScaleMin->setAutoFillBackground(true);
|
|
pbScaleMin->setProperty("row", index.row());
|
|
pbScaleMin->setText(modelData.toString());
|
|
pbScaleMin->setToolTip(tr("Get minimum scale from current map settings to limit zoom out"));
|
|
|
|
connect(pbScaleMin, &QPushButton::clicked, m_planOverlayView, &PlanOverlayView::onSetMinScale);
|
|
connect(pbScaleMin, &QObject::destroyed, pbScaleMin, [this, indexKey](QObject * qobj) { removeKey(indexKey, qobj); });
|
|
|
|
m_sizeHints[indexKey] = pbScaleMin->sizeHint();
|
|
m_widgetMap[indexKey] = pbScaleMin;
|
|
|
|
// qCritical() << "setup " << indexKey << " --> " << pbScaleMin;
|
|
|
|
return pbScaleMin;
|
|
};
|
|
|
|
case PlanOverlayModel::ColumnSection::MaxScale:
|
|
{
|
|
QPushButton *pbScaleMax = new QPushButton(parent);
|
|
pbScaleMax->setStyleSheet(buttonStyleSheet);
|
|
pbScaleMax->setAutoFillBackground(true);
|
|
pbScaleMax->setProperty("row", index.row());
|
|
pbScaleMax->setText(modelData.toString());
|
|
pbScaleMax->setToolTip(tr("Get maximum scale from current map settings to limit zoom in"));
|
|
|
|
connect(pbScaleMax, &QPushButton::clicked, m_planOverlayView, &PlanOverlayView::onSetMaxScale);
|
|
connect(pbScaleMax, &QObject::destroyed, pbScaleMax, [this, indexKey](QObject * qobj) { removeKey(indexKey, qobj); });
|
|
|
|
m_sizeHints[indexKey] = pbScaleMax->sizeHint();
|
|
m_widgetMap[indexKey] = pbScaleMax;
|
|
|
|
// qCritical() << "setup " << indexKey << " --> " << pbScaleMax;
|
|
|
|
return pbScaleMax;
|
|
};
|
|
|
|
case PlanOverlayModel::ColumnSection::Opacity:
|
|
{
|
|
QSlider *slOpacity = new QSlider(parent);
|
|
|
|
slOpacity->setAutoFillBackground(true);
|
|
slOpacity->setOrientation(Qt::Horizontal);
|
|
slOpacity->setRange(0, 100);
|
|
slOpacity->setValue(int(modelData.toDouble() * 100));
|
|
slOpacity->setProperty("row", index.row());
|
|
slOpacity->setToolTip(tr("Adjust overlays opacity"));
|
|
|
|
connect(slOpacity, &QSlider::sliderMoved, m_planOverlayView, &PlanOverlayView::onChangeLayerOpacity);
|
|
connect(slOpacity, &QObject::destroyed, slOpacity, [this, indexKey](QObject * qobj) { removeKey(indexKey, qobj); });
|
|
|
|
m_sizeHints[indexKey] = slOpacity->sizeHint();
|
|
m_widgetMap[indexKey] = slOpacity;
|
|
|
|
return slOpacity;
|
|
};
|
|
|
|
case PlanOverlayModel::ColumnSection::CustomSection:
|
|
{
|
|
QWidget *containerWidget = new QWidget(parent);
|
|
QVBoxLayout *layout = new QVBoxLayout(containerWidget);
|
|
QHBoxLayout *layoutBtnRow = new QHBoxLayout();
|
|
|
|
LtsWidgets::LtsDragIcon *pbReload = new LtsWidgets::LtsDragIcon(containerWidget);
|
|
|
|
pbReload->setIcon(QPixmap(QStringLiteral("icon:overlay_reload_plan.svg")));
|
|
pbReload->setText(QString());
|
|
pbReload->setIconSize(LtsWidgets::ButtonSize::eDefault);
|
|
pbReload->setButtonStyle(LtsWidgets::ButtonStyle::eIconOnly);
|
|
pbReload->setProperty("row", index.row());
|
|
pbReload->setAutoFillBackground(true);
|
|
pbReload->setToolTip(tr("Reload plan"));
|
|
|
|
LtsWidgets::LtsDragIcon *pbUnload = new LtsWidgets::LtsDragIcon(containerWidget);
|
|
|
|
pbUnload->setIcon(QPixmap(QStringLiteral("icon:overlay_unload_plan.svg")));
|
|
pbUnload->setText(QString());
|
|
pbUnload->setIconSize(LtsWidgets::ButtonSize::eDefault);
|
|
pbUnload->setButtonStyle(LtsWidgets::ButtonStyle::eIconOnly);
|
|
pbUnload->setProperty("row", index.row());
|
|
pbUnload->setAutoFillBackground(true);
|
|
pbUnload->setToolTip(tr("Unload plan and remove overlayer"));
|
|
|
|
layoutBtnRow->addWidget(pbReload);
|
|
layoutBtnRow->addWidget(pbUnload);
|
|
|
|
layout->addStretch(2);
|
|
layout->addLayout(layoutBtnRow);
|
|
layout->addStretch(2);
|
|
|
|
containerWidget->setAutoFillBackground(true);
|
|
|
|
connect(pbReload, &LtsWidgets::LtsDragIcon::clicked, m_planOverlayView, &PlanOverlayView::onReloadOverlayById);
|
|
connect(pbUnload, &LtsWidgets::LtsDragIcon::clicked, m_planOverlayView, &PlanOverlayView::onUnloadOverlay);
|
|
|
|
m_sizeHints[indexKey] = containerWidget->sizeHint();
|
|
m_widgetMap[indexKey] = containerWidget;
|
|
|
|
return containerWidget;
|
|
};
|
|
case PlanOverlayModel::ColumnSection::ExerciseId:
|
|
case PlanOverlayModel::ColumnSection::PhaseId:
|
|
break;
|
|
|
|
} // switch
|
|
|
|
const QString &labelText = m_planOverlayView->model()->data(index, Qt::ItemDataRole::DisplayRole).toString();
|
|
#if QT_VERSION < QT_VERSION_CHECK(5, 11, 0)
|
|
int labelWidth = option.fontMetrics.width(labelText);
|
|
#else
|
|
int labelWidth = option.fontMetrics.horizontalAdvance(labelText);
|
|
#endif
|
|
labelWidth = (option.rect.width() > labelWidth) ? option.rect.width() : labelWidth + labelWidth / 5;
|
|
|
|
m_sizeHints[indexKey] = QSize(labelWidth, option.rect.height());
|
|
|
|
return nullptr;
|
|
} // QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const
|
|
|
|
|
|
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
|
|
{
|
|
const QByteArray &indexKey = buildKey(index);
|
|
|
|
if (m_widgetMap.contains(indexKey))
|
|
{
|
|
QWidget *w = m_widgetMap[indexKey];
|
|
if (w)
|
|
{
|
|
w->setGeometry(option.rect);
|
|
painter->drawPixmap(option.rect.x(), option.rect.y(), w->grab());
|
|
return;
|
|
}
|
|
}
|
|
QStyledItemDelegate::paint(painter, option, index);
|
|
} // void paint( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const
|
|
|
|
|
|
QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override
|
|
{
|
|
Q_UNUSED(option);
|
|
const QByteArray &indexKey = buildKey(index);
|
|
return (m_sizeHints.contains(indexKey)) ? m_sizeHints[indexKey] : QSize();
|
|
} // QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const
|
|
|
|
|
|
void setEditorData(QWidget *editor, const QModelIndex &index) const override
|
|
{
|
|
const QVariant &modelData = index.model()->data(index, Qt::ItemDataRole::DisplayRole);
|
|
switch (static_cast<PlanOverlayModel::ColumnSection>(index.column()))
|
|
{
|
|
case PlanOverlayModel::ColumnSection::PlanName:
|
|
{
|
|
QLabel *laName = qobject_cast<QLabel *>(editor);
|
|
if (laName) laName->setText(modelData.toString());
|
|
break;
|
|
}
|
|
|
|
case PlanOverlayModel::ColumnSection::MinScale:
|
|
{
|
|
QPushButton *pbMinScale = qobject_cast<QPushButton *>(editor);
|
|
if (pbMinScale) pbMinScale->setText(modelData.toString());
|
|
break;
|
|
}
|
|
|
|
case PlanOverlayModel::ColumnSection::MaxScale:
|
|
{
|
|
QPushButton *pbMaxScale = qobject_cast<QPushButton *>(editor);
|
|
if (pbMaxScale) pbMaxScale->setText(modelData.toString());
|
|
break;
|
|
}
|
|
|
|
case PlanOverlayModel::ColumnSection::Opacity:
|
|
{
|
|
QSlider *slOpacity = qobject_cast<QSlider *>(editor);
|
|
if (slOpacity) slOpacity->setValue(int(modelData.toDouble() * 100));
|
|
break;
|
|
}
|
|
case PlanOverlayModel::ColumnSection::ExerciseId:
|
|
case PlanOverlayModel::ColumnSection::PhaseId:
|
|
case PlanOverlayModel::ColumnSection::OrderButtons:
|
|
case PlanOverlayModel::ColumnSection::CustomSection:
|
|
break;
|
|
}
|
|
} // void setEditorData(QWidget * editor, const QModelIndex & index) const
|
|
|
|
|
|
void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const override
|
|
{
|
|
Q_UNUSED(editor);
|
|
Q_UNUSED(model);
|
|
Q_UNUSED(index);
|
|
} // void setModelData(QWidget * editor, QAbstractItemModel * model; const QModelIndex & index) const
|
|
|
|
|
|
}; // WidgetItemDelegate
|
|
|
|
|
|
PlanOverlayView::PlanOverlayView(PlanOverlayModel *model, QWidget *parent)
|
|
: QTableView(parent)
|
|
{
|
|
setModel(model);
|
|
connect(model, &PlanOverlayModel::dropPlanAccepted, this, [this]()
|
|
{
|
|
setCurrentIndex(QModelIndex());
|
|
PlanOverlayView::clearSelection();
|
|
});
|
|
connect (model, &PlanOverlayModel::layoutChanged, this, &PlanOverlayView::onLayoutChanged);
|
|
|
|
setSelectionMode(SelectionMode::SingleSelection); // selection have to be enabled to get drag working
|
|
setSelectionBehavior(SelectionBehavior::SelectRows);
|
|
|
|
setItemDelegate(new WidgetItemDelegate(this));
|
|
setEditTriggers(QAbstractItemView::AllEditTriggers);
|
|
|
|
setDragEnabled(true);
|
|
setAcceptDrops(true);
|
|
setDragDropMode(QAbstractItemView::DragDrop);
|
|
setDragDropOverwriteMode(false);
|
|
setDropIndicatorShown(true);
|
|
setSortingEnabled(false);
|
|
setShowGrid(false);
|
|
|
|
horizontalHeader()->setSectionResizeMode(int(PlanOverlayModel::ColumnSection::PlanName), QHeaderView::ResizeMode::Stretch);
|
|
resizeColumnsToContents();
|
|
resizeRowsToContents();
|
|
horizontalHeader()->reset();
|
|
//allways persistent editor
|
|
onLayoutChanged();
|
|
} // PlanOverlayView::PlanOverlayView()
|
|
|
|
|
|
PlanOverlayView::~PlanOverlayView()
|
|
{
|
|
} // PlanOverlayView::~PlanOverlayView()
|
|
|
|
|
|
void PlanOverlayView::onLayoutChanged()
|
|
{
|
|
clearSelection();
|
|
if (model() != nullptr)
|
|
{
|
|
for (int row = 0; row < model()->rowCount(); ++row)
|
|
{
|
|
for (int col = 0; col < model()->columnCount(); ++col)
|
|
openPersistentEditor(model()->index(row, col, QModelIndex()));
|
|
}
|
|
}
|
|
|
|
resizeRowsToContents();
|
|
resizeColumnsToContents();
|
|
horizontalHeader()->setSectionResizeMode(int(PlanOverlayModel::ColumnSection::PlanName), QHeaderView::ResizeMode::Stretch);
|
|
} // void PlanOverlayView::updateGeometries()
|
|
|
|
|
|
int PlanOverlayView::getPlanKeyIdOfRow(int row) const
|
|
{
|
|
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
|
|
|
if (nullptr == poModel) return -1;
|
|
|
|
if (row < 0) return -1;
|
|
if (row >= poModel->rowCount(QModelIndex())) return -1;
|
|
|
|
const PlanOverlayModel::PlanItem &planItem = poModel->planItemAtRow(row);
|
|
|
|
return (planItem.isValid()) ? planItem.m_keyId : -1;
|
|
|
|
} // int PlanOverlayView::getPlanKeyIdOfRow(int row) const
|
|
|
|
|
|
QString PlanOverlayView::getPlanNameOfRow(int row) const
|
|
{
|
|
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
|
|
|
if (nullptr == poModel) return QString();
|
|
|
|
if (row < 0) return QString();
|
|
if (row >= poModel->rowCount(QModelIndex())) return QString();
|
|
|
|
const PlanOverlayModel::PlanItem &planItem = poModel->planItemAtRow(row);
|
|
|
|
return (planItem.isValid()) ? planItem.m_fileName : QString();
|
|
|
|
} // int PlanOverlayView::getPlanNameOfRow(int row) const
|
|
|
|
|
|
void PlanOverlayView::onSetMinScale()
|
|
{
|
|
QPushButton *senderButton = qobject_cast<QPushButton *>(sender());
|
|
if (nullptr == senderButton) return;
|
|
|
|
int row = senderButton->property("row").toInt();
|
|
int keyId = getPlanKeyIdOfRow(row);
|
|
|
|
if (keyId < 0) return;
|
|
|
|
emit requestMinScale(keyId, model()->data(model()->index(row, int(PlanOverlayModel::ColumnSection::PlanName), QModelIndex()), Qt::ItemDataRole::DisplayRole).toString());
|
|
|
|
} // void PlanOverlayView::onSetMinScale()
|
|
|
|
|
|
void PlanOverlayView::onSetMaxScale()
|
|
{
|
|
QPushButton *senderButton = qobject_cast<QPushButton *>(sender());
|
|
if (nullptr == senderButton) return;
|
|
|
|
int row = senderButton->property("row").toInt();
|
|
int keyId = getPlanKeyIdOfRow(row);
|
|
|
|
if (keyId < 0) return;
|
|
|
|
emit requestMaxScale(keyId, model()->data(model()->index(row, int(PlanOverlayModel::ColumnSection::PlanName), QModelIndex()), Qt::ItemDataRole::DisplayRole).toString());
|
|
|
|
} // void PlanOverlayView::onSetMaxScale()
|
|
|
|
|
|
void PlanOverlayView::onReloadOverlayById()
|
|
{
|
|
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
|
if (nullptr == senderButton) return;
|
|
|
|
int row = senderButton->property("row").toInt();
|
|
int keyId = getPlanKeyIdOfRow(row);
|
|
|
|
if (keyId < 0) return;
|
|
|
|
emit requestReloadPlanById(keyId);
|
|
|
|
} // void PlanOverlayView::onReloadOverlayById()
|
|
|
|
|
|
void PlanOverlayView::onReloadOverlayByName()
|
|
{
|
|
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
|
if (nullptr == senderButton) return;
|
|
|
|
int row = senderButton->property("row").toInt();
|
|
QString planName = getPlanNameOfRow(row);
|
|
|
|
if (planName.isEmpty()) return;
|
|
|
|
emit requestReloadPlanByName(planName);
|
|
|
|
} // void PlanOverlayView::onReloadOverlayById()
|
|
|
|
|
|
|
|
void PlanOverlayView::onUnloadOverlay()
|
|
{
|
|
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
|
if (nullptr == senderButton) return;
|
|
|
|
int keyId = getPlanKeyIdOfRow(senderButton->property("row").toInt());
|
|
|
|
if (keyId >= 0)
|
|
emit requestUnloadPlan(keyId);
|
|
} // void PlanOverlayView::onUnloadOverlay()
|
|
|
|
|
|
void PlanOverlayView::onChangeLayerOpacity(int sliderValue)
|
|
{
|
|
QSlider *senderSlider = qobject_cast<QSlider *>(sender());
|
|
if (nullptr == senderSlider) return;
|
|
|
|
int row = senderSlider->property("row").toInt();
|
|
|
|
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
|
|
|
if (nullptr == poModel) return;
|
|
if (row < 0) return;
|
|
if (row >= poModel->rowCount(QModelIndex())) return;
|
|
|
|
poModel->setOpacity(row, double(sliderValue) / 100.0);
|
|
|
|
} // void PlanOverlayView::onChangeLayerOpacity(int sliderValue)
|
|
|
|
|
|
void PlanOverlayView::onChangeLayerOrderUp()
|
|
{
|
|
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
|
if (nullptr == senderButton) return;
|
|
|
|
int row = senderButton->property("row").toInt();
|
|
|
|
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
|
|
|
if (nullptr == poModel) return;
|
|
if (row < 1) return;
|
|
if (row >= poModel->rowCount(QModelIndex())) return;
|
|
|
|
poModel->swapRow(row, row - 1);
|
|
|
|
} // void PlanOverlayView::onChangeLayerOrderUp()
|
|
|
|
|
|
void PlanOverlayView::onChangeLayerOrderDown()
|
|
{
|
|
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
|
if (nullptr == senderButton) return;
|
|
|
|
int row = senderButton->property("row").toInt();
|
|
|
|
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
|
|
|
if (nullptr == poModel) return;
|
|
if (row < 0) return;
|
|
if (row + 1 >= poModel->rowCount(QModelIndex())) return;
|
|
|
|
poModel->swapRow(row, row + 1);
|
|
|
|
} // void PlanOverlayView::onChangeLayerOrderDown()
|
|
|
|
|
|
} // namespace PlanOverlaysPlugin
|
|
|
|
|
|
#include <plan_overlay_view.moc>
|