void QgsUniqueValueDialog::apply()
{
QgsDebugMsg( "called." );
QgsUniqueValueRenderer *renderer = new QgsUniqueValueRenderer( mVectorLayer->geometryType() );
//go through mValues and add the entries to the renderer
for ( QMap<QString, QgsSymbol*>::iterator it = mValues.begin(); it != mValues.end(); ++it )
{
QgsSymbol* symbol = it.value();
QgsSymbol* newsymbol = new QgsSymbol( mVectorLayer->geometryType(), symbol->lowerValue(), symbol->upperValue(), symbol->label() );
newsymbol->setPen( symbol->pen() );
newsymbol->setCustomTexture( symbol->customTexture() );
newsymbol->setBrush( symbol->brush() );
newsymbol->setNamedPointSymbol( symbol->pointSymbolName() );
newsymbol->setPointSize( symbol->pointSize() );
newsymbol->setPointSizeUnits( symbol->pointSizeUnits() );
newsymbol->setScaleClassificationField( symbol->scaleClassificationField() );
newsymbol->setRotationClassificationField( symbol->rotationClassificationField() );
renderer->insertValue( it.key(), newsymbol );
}
renderer->updateSymbolAttributes();
QgsVectorDataProvider *provider = dynamic_cast<QgsVectorDataProvider *>( mVectorLayer->dataProvider() );
if ( provider )
{
int fieldIndex = mClassificationComboBox->itemData( mClassificationComboBox->currentIndex() ).toInt();
if ( fieldIndex != -1 )
{
renderer->setClassificationField( fieldIndex );
mVectorLayer->setRenderer( renderer );
return;
}
}
delete renderer; //something went wrong
}
QgsUniqueValueDialog::QgsUniqueValueDialog( QgsVectorLayer* vl ): QDialog(), mVectorLayer( vl ), sydialog( vl, true )
{
setupUi( this );
setOrientation( Qt::Vertical );
//find out the fields of mVectorLayer
if ( mVectorLayer )
{
//we cannot use unique values for not-commited fields because QgsVectorLayer has no 'unique values' method...
QgsVectorDataProvider* provider = mVectorLayer->dataProvider();
if ( provider )
{
const QgsFieldMap & fields = provider->fields();
QString str;
for ( QgsFieldMap::const_iterator it = fields.begin(); it != fields.end(); ++it )
{
str = ( *it ).name();
str = mVectorLayer->attributeDisplayName( it.key() );
mClassificationComboBox->addItem( str, it.key() );
}
}
}
mClassListWidget->setSelectionMode( QAbstractItemView::ExtendedSelection );
mClassListWidget->setEditTriggers( QAbstractItemView::DoubleClicked | QAbstractItemView::EditKeyPressed | QAbstractItemView::AnyKeyPressed );
mClassListWidget->setSortingEnabled( true );
if ( mVectorLayer )
{
const QgsUniqueValueRenderer* renderer = dynamic_cast<const QgsUniqueValueRenderer *>( mVectorLayer->renderer() );
if ( renderer )
{
mClassListWidget->clear();
QString field = mVectorLayer->attributeDisplayName( renderer->classificationField() );
mOldClassificationAttribute = field;
mClassificationComboBox->setCurrentIndex( mClassificationComboBox->findText( field ) );
const QList<QgsSymbol*> list = renderer->symbols();
//fill the items of the renderer into mValues
for ( QList<QgsSymbol*>::const_iterator iter = list.begin(); iter != list.end(); ++iter )
{
QgsSymbol* symbol = *iter;
QString symbolvalue = symbol->lowerValue();
QgsSymbol* sym = new QgsSymbol( mVectorLayer->geometryType(), symbol->lowerValue(), symbol->upperValue(), symbol->label() );
sym->setPen( symbol->pen() );
sym->setCustomTexture( symbol->customTexture() );
sym->setBrush( symbol->brush() );
sym->setNamedPointSymbol( symbol->pointSymbolName() );
sym->setPointSize( symbol->pointSize() );
sym->setPointSizeUnits( symbol->pointSizeUnits() );
sym->setScaleClassificationField( symbol->scaleClassificationField() );
sym->setRotationClassificationField( symbol->rotationClassificationField() );
mValues.insert( symbolvalue, sym );
QListWidgetItem *item = new QListWidgetItem( symbolvalue );
mClassListWidget->addItem( item );
updateEntryIcon( symbol, item );
item->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled );
item->setData( Qt::UserRole, symbol->lowerValue() );
item->setToolTip( symbol->label() );
}
}
}
mDeletePushButton->setEnabled( false );
connect( mClassifyButton, SIGNAL( clicked() ), this, SLOT( changeClassificationAttribute() ) );
connect( mAddButton, SIGNAL( clicked() ), this, SLOT( addClass() ) );
connect( mDeletePushButton, SIGNAL( clicked() ), this, SLOT( deleteSelectedClasses() ) );
connect( mRandomizeColors, SIGNAL( clicked() ), this, SLOT( randomizeColors() ) );
connect( mResetColors, SIGNAL( clicked() ), this, SLOT( resetColors() ) );
connect( mClassListWidget, SIGNAL( itemSelectionChanged() ), this, SLOT( selectionChanged() ) );
connect( mCommonPropertyLock, SIGNAL( clicked() ), this, SLOT( selectionChanged() ) );
connect( mClassListWidget, SIGNAL( itemChanged( QListWidgetItem * ) ), this, SLOT( itemChanged( QListWidgetItem * ) ) );
connect( &sydialog, SIGNAL( settingsChanged() ), this, SLOT( applySymbologyChanges() ) );
mSymbolWidgetStack->addWidget( &sydialog );
mSymbolWidgetStack->setCurrentWidget( &sydialog );
}
void QgsQuickPrint::scalePointSymbols( int theScaleFactor, SymbolScalingType theDirection )
{
if ( 0 >= theScaleFactor )
{
QgsDebugMsg( "invalid scale factor" );
return;
}
QStringList myLayerSet = mpMapRenderer->layerSet();
QStringListIterator myLayerIterator( myLayerSet );
while ( myLayerIterator.hasNext() )
{
QString myLayerId = myLayerIterator.next();
QgsDebugMsg( "Scaling point symbols for print for " + myLayerId );
QgsMapLayer * mypLayer =
QgsMapLayerRegistry::instance()->mapLayer( myLayerId );
if ( mypLayer )
{
QgsVectorLayer *mypVectorLayer =
qobject_cast<QgsVectorLayer *>( mypLayer );
if ( mypVectorLayer )
{
const QgsRenderer* mypRenderer = mypVectorLayer->renderer();
const QList<QgsSymbol*> mySymbolList = mypRenderer->symbols();
//
// Single symbol
//
if ( 1 == mySymbolList.size() )
{
QgsSymbol * mypSymbol = mySymbolList.at( 0 );
if ( mypSymbol->type() == QGis::Point )
{
if ( theDirection == ScaleUp )
{
mypSymbol->setPointSize( mypSymbol->pointSize() * theScaleFactor );
}
else //Scale Down
{
mypSymbol->setPointSize( mypSymbol->pointSize() / theScaleFactor );
}
}
}
else //class breaks
{
QListIterator<QgsSymbol *> myIterator( mySymbolList );
while ( myIterator.hasNext() )
{
QgsSymbol * mypSymbol = myIterator.next();
if ( mypSymbol->type() == QGis::Point )
{
if ( theDirection == ScaleUp )
{
mypSymbol->setPointSize( mypSymbol->pointSize() * theScaleFactor );
}
else //Scale Down
{
mypSymbol->setPointSize( mypSymbol->pointSize() / theScaleFactor );
}
}
} //symbol loop
} //class breaks
} //if vectorlayer
} //if maplayer
} //layer iterator
}
QgsSymbol* QgsSymbologyV2Conversion::symbolV2toV1( QgsSymbolV2* s )
{
if ( s == NULL || s->symbolLayerCount() == 0 )
return NULL;
// we will use only the first symbol layer
QgsSymbolLayerV2* sl = s->symbolLayer( 0 );
switch ( sl->type() )
{
case QgsSymbolV2::Marker:
{
QgsMarkerSymbolLayerV2* msl = static_cast<QgsMarkerSymbolLayerV2*>( sl );
QgsSymbol* sOld = new QgsSymbol( QGis::Point );
sOld->setFillColor( sl->color() );
sOld->setFillStyle( Qt::SolidPattern );
sOld->setPointSize( msl->size() );
if ( sl->layerType() == "SimpleMarker" )
{
QgsSimpleMarkerSymbolLayerV2* smsl = static_cast<QgsSimpleMarkerSymbolLayerV2*>( sl );
sOld->setColor( smsl->borderColor() );
sOld->setNamedPointSymbol( "hard:" + smsl->name() );
}
else if ( sl->layerType() == "SvgMarker" )
{
QgsSvgMarkerSymbolLayerV2* smsl = static_cast<QgsSvgMarkerSymbolLayerV2*>( sl );
sOld->setNamedPointSymbol( "svg:" + smsl->path() );
}
return sOld;
}
break;
case QgsSymbolV2::Line:
{
QgsLineSymbolLayerV2* lsl = static_cast<QgsLineSymbolLayerV2*>( sl );
QgsSymbol* sOld = new QgsSymbol( QGis::Line );
sOld->setColor( sl->color() );
sOld->setLineWidth( lsl->width() );
if ( sl->layerType() == "SimpleLine" )
{
// add specific settings
QgsSimpleLineSymbolLayerV2* slsl = static_cast<QgsSimpleLineSymbolLayerV2*>( sl );
sOld->setLineStyle( slsl->penStyle() );
}
return sOld;
}
case QgsSymbolV2::Fill:
{
QgsSymbol* sOld = new QgsSymbol( QGis::Polygon );
sOld->setFillColor( sl->color() );
if ( sl->layerType() == "SimpleFill" )
{
// add specifc settings
QgsSimpleFillSymbolLayerV2* sfsl = static_cast<QgsSimpleFillSymbolLayerV2*>( sl );
sOld->setColor( sfsl->borderColor() );
sOld->setLineWidth( sfsl->borderWidth() );
sOld->setLineStyle( sfsl->borderStyle() );
sOld->setFillStyle( sfsl->brushStyle() );
}
return sOld;
}
}
return NULL; // should never get here
}
