QGIS API Documentation 3.41.0-Master (3440c17df1d)
Loading...
Searching...
No Matches
qgsprocessingvectortilewriterlayerswidgetwrapper.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsprocessingvectortilewriterlayerswidgetwrapper.cpp
3 ---------------------
4 Date : April 2020
5 Copyright : (C) 2020 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
17#include "moc_qgsprocessingvectortilewriterlayerswidgetwrapper.cpp"
18
19#include <QBoxLayout>
20#include <QLineEdit>
21#include <QMessageBox>
22#include <QPushButton>
23#include <QStandardItemModel>
24#include <QToolButton>
25
26#include "qgspanelwidget.h"
27
28#include "qgsvectortilewriter.h"
29
31
33
34//
35// QgsProcessingVectorTileWriteLayerDetailsWidget
36//
37
38QgsProcessingVectorTileWriteLayerDetailsWidget::QgsProcessingVectorTileWriteLayerDetailsWidget( const QVariant &value, QgsProject *project )
39{
40 setupUi( this );
41
42 mContext.setProject( project );
43
45 mLayer = layer.layer();
46
47 if ( !mLayer )
48 return;
49
50 mSpinMinZoom->setClearValue( -1, tr( "Not set" ) );
51 mSpinMaxZoom->setClearValue( -1, tr( "Not set" ) );
52 mEditFilterExpression->setMultiLine( true );
53 mEditFilterExpression->setLayer( mLayer );
54
55 mSpinMinZoom->setValue( layer.minZoom() );
56 mSpinMaxZoom->setValue( layer.maxZoom() );
57 mEditLayerName->setText( layer.layerName() );
58 mEditLayerName->setPlaceholderText( mLayer->name() );
59 mEditFilterExpression->setExpression( layer.filterExpression() );
60
61 connect( mSpinMinZoom, qOverload<int>( &QSpinBox::valueChanged ), this, &QgsPanelWidget::widgetChanged );
62 connect( mSpinMaxZoom, qOverload<int>( &QSpinBox::valueChanged ), this, &QgsPanelWidget::widgetChanged );
63 connect( mEditLayerName, &QLineEdit::textChanged, this, &QgsPanelWidget::widgetChanged );
64 connect( mEditFilterExpression, &QgsExpressionLineEdit::expressionChanged, this, &QgsPanelWidget::widgetChanged );
65}
66
67QVariant QgsProcessingVectorTileWriteLayerDetailsWidget::value() const
68{
69 QgsVectorTileWriter::Layer layer( mLayer );
70 layer.setMinZoom( mSpinMinZoom->value() );
71 layer.setMaxZoom( mSpinMaxZoom->value() );
72 layer.setLayerName( mEditLayerName->text() );
73 layer.setFilterExpression( mEditFilterExpression->expression() );
75}
76
77//
78// QgsProcessingVectorTileWriterLayersPanelWidget
79//
80
81
82QgsProcessingVectorTileWriterLayersPanelWidget::QgsProcessingVectorTileWriterLayersPanelWidget(
83 const QVariant &value,
84 QgsProject *project,
85 QWidget *parent )
86 : QgsProcessingMultipleSelectionPanelWidget( QVariantList(), QVariantList(), parent )
87 , mProject( project )
88{
89
90 connect( listView(), &QListView::doubleClicked, this, &QgsProcessingVectorTileWriterLayersPanelWidget::configureLayer );
91
92 QPushButton *configureLayerButton = new QPushButton( tr( "Configure Layer…" ) );
93 connect( configureLayerButton, &QPushButton::clicked, this, &QgsProcessingVectorTileWriterLayersPanelWidget::configureLayer );
94 buttonBox()->addButton( configureLayerButton, QDialogButtonBox::ActionRole );
95
96 QPushButton *copyLayerButton = new QPushButton( tr( "Copy Layer" ) );
97 connect( copyLayerButton, &QPushButton::clicked, this, &QgsProcessingVectorTileWriterLayersPanelWidget::copyLayer );
98 buttonBox()->addButton( copyLayerButton, QDialogButtonBox::ActionRole );
99
100 // populate the list: first layers already selected, then layers from project not yet selected
101 mContext.setProject( project );
102
103 QSet<const QgsVectorLayer *> seenVectorLayers;
104 const QVariantList valueList = value.toList();
105 for ( const QVariant &v : valueList )
106 {
108 if ( !layer.layer() )
109 continue; // skip any invalid layers
110
111 addOption( v, titleForLayer( layer ), true );
112
113 seenVectorLayers.insert( layer.layer() );
114 }
115
116 const QList<QgsVectorLayer *> options = QgsProcessingUtils::compatibleVectorLayers( project, QList< int >() );
117 for ( const QgsVectorLayer *layer : options )
118 {
119 if ( seenVectorLayers.contains( layer ) )
120 continue;
121
122 QVariantMap vm;
123 vm["layer"] = layer->id();
124
125 const QString title = layer->name();
126
127 addOption( vm, title, false );
128 }
129}
130
131void QgsProcessingVectorTileWriterLayersPanelWidget::configureLayer()
132{
133 const QModelIndexList selection = listView()->selectionModel()->selectedIndexes();
134 if ( selection.size() != 1 )
135 {
136 QMessageBox::warning( this, tr( "Configure Layer" ), tr( "Please select a single layer." ) );
137 return;
138 }
139
140 QStandardItem *item = mModel->itemFromIndex( selection[0] );
141 const QVariant value = item->data( Qt::UserRole );
142
144 if ( panel && panel->dockMode() )
145 {
146 QgsProcessingVectorTileWriteLayerDetailsWidget *widget = new QgsProcessingVectorTileWriteLayerDetailsWidget( value, mProject );
147 widget->setPanelTitle( tr( "Configure Layer" ) );
148 widget->buttonBox()->hide();
149
150 connect( widget, &QgsProcessingVectorTileWriteLayerDetailsWidget::widgetChanged, this, [ = ]()
151 {
152 setItemValue( item, widget->value() );
153 } );
154 panel->openPanel( widget );
155 }
156 else
157 {
158 QDialog dlg;
159 dlg.setWindowTitle( tr( "Configure Layer" ) );
160 QVBoxLayout *vLayout = new QVBoxLayout();
161 QgsProcessingVectorTileWriteLayerDetailsWidget *widget = new QgsProcessingVectorTileWriteLayerDetailsWidget( value, mProject );
162 vLayout->addWidget( widget );
163 connect( widget->buttonBox(), &QDialogButtonBox::accepted, &dlg, &QDialog::accept );
164 connect( widget->buttonBox(), &QDialogButtonBox::rejected, &dlg, &QDialog::reject );
165 dlg.setLayout( vLayout );
166 if ( dlg.exec() )
167 {
168 setItemValue( item, widget->value() );
169 }
170 }
171}
172
173void QgsProcessingVectorTileWriterLayersPanelWidget::copyLayer()
174{
175 const QModelIndexList selection = listView()->selectionModel()->selectedIndexes();
176 if ( selection.size() != 1 )
177 {
178 QMessageBox::warning( this, tr( "Copy Layer" ), tr( "Please select a single layer." ) );
179 return;
180 }
181
182 QStandardItem *item = mModel->itemFromIndex( selection[0] );
183 mModel->insertRow( selection[0].row() + 1, item->clone() );
184}
185
186void QgsProcessingVectorTileWriterLayersPanelWidget::setItemValue( QStandardItem *item, const QVariant &value )
187{
188 mContext.setProject( mProject );
189
191
192 item->setText( titleForLayer( layer ) );
193 item->setData( value, Qt::UserRole );
194}
195
196QString QgsProcessingVectorTileWriterLayersPanelWidget::titleForLayer( const QgsVectorTileWriter::Layer &layer )
197{
198 QString title = layer.layer()->name();
199
200 // add more details
201 if ( layer.minZoom() >= 0 && layer.maxZoom() >= 0 )
202 title += tr( " [zoom %1...%2]" ).arg( layer.minZoom() ).arg( layer.maxZoom() );
203 else if ( layer.minZoom() >= 0 )
204 title += tr( " [zoom >= %1]" ).arg( layer.minZoom() );
205 else if ( layer.maxZoom() >= 0 )
206 title += tr( " [zoom <= %1]" ).arg( layer.maxZoom() );
207
208 if ( !layer.layerName().isEmpty() )
209 title += tr( " [name: %1]" ).arg( layer.layerName() );
210 if ( !layer.filterExpression().isEmpty() )
211 title += tr( " [with filter]" );
212
213 return title;
214}
215
216
217//
218// QgsProcessingVectorTileWriterLayersWidget
219//
220
221
222QgsProcessingVectorTileWriterLayersWidget::QgsProcessingVectorTileWriterLayersWidget( QWidget *parent )
223 : QWidget( parent )
224{
225 QHBoxLayout *hl = new QHBoxLayout();
226 hl->setContentsMargins( 0, 0, 0, 0 );
227
228 mLineEdit = new QLineEdit();
229 mLineEdit->setEnabled( false );
230 hl->addWidget( mLineEdit, 1 );
231
232 mToolButton = new QToolButton();
233 mToolButton->setText( QString( QChar( 0x2026 ) ) );
234 hl->addWidget( mToolButton );
235
236 setLayout( hl );
237
238 updateSummaryText();
239
240 connect( mToolButton, &QToolButton::clicked, this, &QgsProcessingVectorTileWriterLayersWidget::showDialog );
241}
242
243void QgsProcessingVectorTileWriterLayersWidget::setValue( const QVariant &value )
244{
245 if ( value.isValid() )
246 mValue = value.userType() == QMetaType::Type::QVariantList ? value.toList() : QVariantList() << value;
247 else
248 mValue.clear();
249
250 updateSummaryText();
251 emit changed();
252}
253
254void QgsProcessingVectorTileWriterLayersWidget::setProject( QgsProject *project )
255{
256 mProject = project;
257}
258
259void QgsProcessingVectorTileWriterLayersWidget::showDialog()
260{
262 if ( panel && panel->dockMode() )
263 {
264 QgsProcessingVectorTileWriterLayersPanelWidget *widget = new QgsProcessingVectorTileWriterLayersPanelWidget( mValue, mProject );
265 widget->setPanelTitle( tr( "Input layers" ) );
266 connect( widget, &QgsProcessingMultipleSelectionPanelWidget::selectionChanged, this, [ = ]()
267 {
268 setValue( widget->selectedOptions() );
269 } );
270 connect( widget, &QgsProcessingMultipleSelectionPanelWidget::acceptClicked, widget, &QgsPanelWidget::acceptPanel );
271 panel->openPanel( widget );
272 }
273 else
274 {
275 QDialog dlg;
276 dlg.setWindowTitle( tr( "Input layers" ) );
277 QVBoxLayout *vLayout = new QVBoxLayout();
278 QgsProcessingVectorTileWriterLayersPanelWidget *widget = new QgsProcessingVectorTileWriterLayersPanelWidget( mValue, mProject );
279 vLayout->addWidget( widget );
280 widget->buttonBox()->addButton( QDialogButtonBox::Cancel );
281 connect( widget->buttonBox(), &QDialogButtonBox::accepted, &dlg, &QDialog::accept );
282 connect( widget->buttonBox(), &QDialogButtonBox::rejected, &dlg, &QDialog::reject );
283 dlg.setLayout( vLayout );
284 if ( dlg.exec() )
285 {
286 setValue( widget->selectedOptions() );
287 }
288 }
289}
290
291void QgsProcessingVectorTileWriterLayersWidget::updateSummaryText()
292{
293 mLineEdit->setText( tr( "%n vector layer(s) selected", nullptr, mValue.count() ) );
294}
295
296//
297// QgsProcessingVectorTileWriterLayersWidgetWrapper
298//
299
300QgsProcessingVectorTileWriterLayersWidgetWrapper::QgsProcessingVectorTileWriterLayersWidgetWrapper( const QgsProcessingParameterDefinition *parameter, QgsProcessingGui::WidgetType type, QWidget *parent )
301 : QgsAbstractProcessingParameterWidgetWrapper( parameter, type, parent )
302{
303}
304
305QString QgsProcessingVectorTileWriterLayersWidgetWrapper::parameterType() const
306{
308}
309
310QgsAbstractProcessingParameterWidgetWrapper *QgsProcessingVectorTileWriterLayersWidgetWrapper::createWidgetWrapper( const QgsProcessingParameterDefinition *parameter, QgsProcessingGui::WidgetType type )
311{
312 return new QgsProcessingVectorTileWriterLayersWidgetWrapper( parameter, type );
313}
314
315QWidget *QgsProcessingVectorTileWriterLayersWidgetWrapper::createWidget()
316{
317 mPanel = new QgsProcessingVectorTileWriterLayersWidget( nullptr );
318 mPanel->setProject( widgetContext().project() );
319 connect( mPanel, &QgsProcessingVectorTileWriterLayersWidget::changed, this, [ = ]
320 {
321 emit widgetValueHasChanged( this );
322 } );
323 return mPanel;
324}
325
326void QgsProcessingVectorTileWriterLayersWidgetWrapper::setWidgetContext( const QgsProcessingParameterWidgetContext &context )
327{
329 if ( mPanel )
330 {
331 mPanel->setProject( context.project() );
332 }
333}
334
335void QgsProcessingVectorTileWriterLayersWidgetWrapper::setWidgetValue( const QVariant &value, QgsProcessingContext &context )
336{
337 Q_UNUSED( context )
338 if ( mPanel )
339 {
340 mPanel->setValue( value );
341 }
342}
343
344QVariant QgsProcessingVectorTileWriterLayersWidgetWrapper::widgetValue() const
345{
346 return mPanel ? mPanel->value() : QVariant();
347}
348
349QStringList QgsProcessingVectorTileWriterLayersWidgetWrapper::compatibleParameterTypes() const
350{
351 return QStringList();
352}
353
354QStringList QgsProcessingVectorTileWriterLayersWidgetWrapper::compatibleOutputTypes() const
355{
356 return QStringList();
357}
358
A widget wrapper for Processing parameter value widgets.
virtual void setWidgetContext(const QgsProcessingParameterWidgetContext &context)
Sets the context in which the Processing parameter widget is shown, e.g., the parent model algorithm,...
void expressionChanged(const QString &expression)
Emitted when the expression is changed.
QString name
Definition qgsmaplayer.h:80
Base class for any widget that can be shown as a inline panel.
void openPanel(QgsPanelWidget *panel)
Open a panel or dialog depending on dock mode setting If dock mode is true this method will emit the ...
void widgetChanged()
Emitted when the widget state changes.
void acceptPanel()
Accept the panel.
static QgsPanelWidget * findParentPanel(QWidget *widget)
Traces through the parents of a widget to find if it is contained within a QgsPanelWidget widget.
bool dockMode()
Returns the dock mode state.
Contains information about the context in which a processing algorithm is executed.
WidgetType
Types of dialogs which Processing widgets can be created for.
Base class for the definition of processing parameters.
static QgsVectorTileWriter::Layer variantMapAsLayer(const QVariantMap &layerVariantMap, QgsProcessingContext &context)
Converts a QVariant value (a QVariantMap) to a single input layer.
static QVariantMap layerAsVariantMap(const QgsVectorTileWriter::Layer &layer)
Converts a single input layer to QVariant representation (a QVariantMap)
static QString typeName()
Returns the type name for the parameter class.
Contains settings which reflect the context in which a Processing parameter widget is shown,...
QgsProject * project() const
Returns the project associated with the widget.
static QList< QgsVectorLayer * > compatibleVectorLayers(QgsProject *project, const QList< int > &sourceTypes=QList< int >(), bool sort=true)
Returns a list of vector layers from a project which are compatible with the processing framework.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition qgsproject.h:107
Represents a vector layer which manages a vector based data sets.
Configuration of a single input vector layer to be included in the output.
QString layerName() const
Returns layer name in the output. If not set, layer()->name() will be used.
void setLayerName(const QString &name)
Sets layer name in the output. If not set, layer()->name() will be used.
QgsVectorLayer * layer() const
Returns vector layer of this entry.
void setMaxZoom(int maxzoom)
Sets maximum zoom level at which this layer will be used. Negative value means no max....
void setFilterExpression(const QString &expr)
Sets filter expression. If not empty, only features matching the expression will be used.
void setMinZoom(int minzoom)
Sets minimum zoom level at which this layer will be used. Negative value means no min....
QString filterExpression() const
Returns filter expression. If not empty, only features matching the expression will be used.
int maxZoom() const
Returns maximum zoom level at which this layer will be used. Negative value means no max....
int minZoom() const
Returns minimum zoom level at which this layer will be used. Negative value means no min....