void QgsMapToolChangeLabelProperties::canvasReleaseEvent( QMouseEvent *e )
{
Q_UNUSED( e );
QgsVectorLayer* vlayer = currentLayer();
if ( mLabelRubberBand && mCanvas && vlayer )
{
QString labeltext = QString(); // NULL QString signifies no expression
bool settingsOk;
QgsPalLayerSettings& labelSettings = currentLabelSettings( &settingsOk );
if ( settingsOk && labelSettings.isExpression )
{
labeltext = mCurrentLabelPos.labelText;
}
QgsLabelPropertyDialog d( mCurrentLabelPos.layerID, mCurrentLabelPos.featureId, mCurrentLabelPos.labelFont, labeltext, 0 );
if ( d.exec() == QDialog::Accepted )
{
const QgsAttributeMap& changes = d.changedProperties();
if ( changes.size() > 0 )
{
vlayer->beginEditCommand( tr( "Changed properties for label" ) + QString( " '%1'" ).arg( currentLabelText( 24 ) ) );
QgsAttributeMap::const_iterator changeIt = changes.constBegin();
for ( ; changeIt != changes.constEnd(); ++changeIt )
{
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, changeIt.key(), changeIt.value() );
}
vlayer->endEditCommand();
mCanvas->refresh();
}
}
deleteRubberBands();
}
}
void QgsMapToolChangeLabelProperties::canvasReleaseEvent( QMouseEvent * e )
{
QgsVectorLayer* vlayer = currentLayer();
if ( mLabelRubberBand && mCanvas && vlayer )
{
QgsLabelPropertyDialog d( mCurrentLabelPos.layerID, mCurrentLabelPos.featureId, mCanvas->mapRenderer() );
if ( d.exec() == QDialog::Accepted )
{
const QgsAttributeMap& changes = d.changedProperties();
if ( changes.size() > 0 )
{
vlayer->beginEditCommand( tr( "Label properties changed" ) );
QgsAttributeMap::const_iterator changeIt = changes.constBegin();
for ( ; changeIt != changes.constEnd(); ++changeIt )
{
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, changeIt.key(), changeIt.value(), false );
}
vlayer->endEditCommand();
mCanvas->refresh();
}
}
deleteRubberBands();
}
}
QString QgsActionManager::expandAction( QString action, const QgsAttributeMap &attributes,
uint clickedOnValue )
{
// This function currently replaces all %% characters in the action
// with the value from values[clickedOnValue].second, and then
// searches for all strings that go %attribute_name, where
// attribute_name is found in values[x].first, and replaces any that
// it finds by values[s].second.
// Additional substitutions could include symbols for $CWD, $HOME,
// etc (and their OSX and Windows equivalents)
// This function will potentially fall apart if any of the
// substitutions produce text that could match another
// substitution. May be better to adopt a two pass approach - identify
// all matches and their substitutions and then do a second pass
// for the actual substitutions.
QString expanded_action;
if ( attributes.contains( clickedOnValue ) )
expanded_action = action.replace( "%%", attributes[clickedOnValue].toString() );
else
expanded_action = action;
const QgsFields &fields = mLayer->fields();
for ( int i = 0; i < 4; i++ )
{
for ( QgsAttributeMap::const_iterator it = attributes.begin(); it != attributes.end(); ++it )
{
int attrIdx = it.key();
if ( attrIdx < 0 || attrIdx >= fields.count() )
continue;
QString to_replace;
switch ( i )
{
case 0:
to_replace = "[%" + fields[attrIdx].name() + ']';
break;
case 1:
to_replace = "[%" + mLayer->attributeDisplayName( attrIdx ) + ']';
break;
case 2:
to_replace = '%' + fields[attrIdx].name();
break;
case 3:
to_replace = '%' + mLayer->attributeDisplayName( attrIdx );
break;
}
expanded_action = expanded_action.replace( to_replace, it.value().toString() );
}
}
return expanded_action;
}
QDomElement QgsWFSServer::createFeatureElem( QgsFeature* feat, QDomDocument& doc, QgsCoordinateReferenceSystem& crs, QMap< int, QgsField > fields, QSet<QString> hiddenAttributes ) /*const*/
{
//gml:FeatureMember
QDomElement featureElement = doc.createElement( "gml:featureMember"/*wfs:FeatureMember*/ );
//qgs:%TYPENAME%
QDomElement typeNameElement = doc.createElement( "qgs:" + mTypeName.replace( QString( " " ), QString( "_" ) )/*qgs:%TYPENAME%*/ );
typeNameElement.setAttribute( "fid", QString::number( feat->id() ) );
featureElement.appendChild( typeNameElement );
if ( mWithGeom )
{
//add geometry column (as gml)
QgsGeometry* geom = feat->geometry();
QDomElement geomElem = doc.createElement( "qgs:geometry" );
QDomElement gmlElem = createGeometryElem( geom, doc );
if ( !gmlElem.isNull() )
{
QgsRectangle box = geom->boundingBox();
QDomElement bbElem = doc.createElement( "gml:boundedBy" );
QDomElement boxElem = createBoxElem( &box, doc );
if ( crs.isValid() )
{
boxElem.setAttribute( "srsName", crs.authid() );
gmlElem.setAttribute( "srsName", crs.authid() );
}
bbElem.appendChild( boxElem );
typeNameElement.appendChild( bbElem );
geomElem.appendChild( gmlElem );
typeNameElement.appendChild( geomElem );
}
}
//read all attribute values from the feature
QgsAttributeMap featureAttributes = feat->attributeMap();
for ( QgsAttributeMap::const_iterator it = featureAttributes.begin(); it != featureAttributes.end(); ++it )
{
QString attributeName = fields[it.key()].name();
//skip attribute if it has edit type 'hidden'
if ( hiddenAttributes.contains( attributeName ) )
{
continue;
}
QDomElement fieldElem = doc.createElement( "qgs:" + attributeName.replace( QString( " " ), QString( "_" ) ) );
QDomText fieldText = doc.createTextNode( it->toString() );
fieldElem.appendChild( fieldText );
typeNameElement.appendChild( fieldElem );
}
return featureElement;
}
QgsSymbolV2* QgsCategorizedSymbolRendererV2::symbolForFeature( QgsFeature& feature )
{
const QgsAttributeMap& attrMap = feature.attributeMap();
QgsAttributeMap::const_iterator ita = attrMap.find( mAttrNum );
if ( ita == attrMap.end() )
{
QgsDebugMsg( "attribute '" + mAttrName + "' (index " + QString::number( mAttrNum ) + ") required by renderer not found" );
return NULL;
}
// find the right symbol for the category
QgsSymbolV2* symbol = symbolForValue( *ita );
if ( symbol == NULL )
{
// if no symbol found use default one
//return symbolForValue( QVariant( "" ) );
// What is default? Empty string may be a legal value, and features not found
// should not be rendered using empty string value category symbology.
// We also need to get NULL in that case so that willRenderFeature()
// may be used to count features.
return 0;
}
if ( mRotationFieldIdx == -1 && mSizeScaleFieldIdx == -1 )
return symbol; // no data-defined rotation/scaling - just return the symbol
// find out rotation, size scale
double rotation = 0;
double sizeScale = 1;
if ( mRotationFieldIdx != -1 )
rotation = attrMap[mRotationFieldIdx].toDouble();
if ( mSizeScaleFieldIdx != -1 )
sizeScale = attrMap[mSizeScaleFieldIdx].toDouble();
// take a temporary symbol (or create it if doesn't exist)
QgsSymbolV2* tempSymbol = mTempSymbols[ita->toString()];
// modify the temporary symbol and return it
if ( tempSymbol->type() == QgsSymbolV2::Marker )
{
QgsMarkerSymbolV2* markerSymbol = static_cast<QgsMarkerSymbolV2*>( tempSymbol );
if ( mRotationFieldIdx != -1 )
markerSymbol->setAngle( rotation );
if ( mSizeScaleFieldIdx != -1 )
markerSymbol->setSize( sizeScale * static_cast<QgsMarkerSymbolV2*>( symbol )->size() );
markerSymbol->setScaleMethod( mScaleMethod );
}
else if ( tempSymbol->type() == QgsSymbolV2::Line )
{
QgsLineSymbolV2* lineSymbol = static_cast<QgsLineSymbolV2*>( tempSymbol );
if ( mSizeScaleFieldIdx != -1 )
lineSymbol->setWidth( sizeScale * static_cast<QgsLineSymbolV2*>( symbol )->width() );
}
return tempSymbol;
}
void QgsVectorLayerEditBuffer::updateAttributeMapIndex( QgsAttributeMap& map, int index, int offset ) const
{
QgsAttributeMap updatedMap;
for ( QgsAttributeMap::const_iterator it = map.begin(); it != map.end(); ++it )
{
int attrIndex = it.key();
updatedMap.insert( attrIndex < index ? attrIndex : attrIndex + offset, it.value() );
}
map = updatedMap;
}
void QgsGPXProvider::changeAttributeValues( QgsGPSObject& obj, const QgsAttributeMap& attrs )
{
QgsWaypoint* wpt = dynamic_cast<QgsWaypoint*>( &obj );
QgsGPSExtended* ext = dynamic_cast<QgsGPSExtended*>( &obj );
QgsAttributeMap::const_iterator aIter = attrs.begin();
for ( ; aIter != attrs.end(); ++aIter )
{
int i = aIter.key();
QVariant v = aIter.value();
// common attributes
switch ( indexToAttr[i] )
{
case NameAttr: obj.name = v.toString(); break;
case CmtAttr: obj.cmt = v.toString(); break;
case DscAttr: obj.desc = v.toString(); break;
case SrcAttr: obj.src = v.toString(); break;
case URLAttr: obj.url = v.toString(); break;
case URLNameAttr: obj.urlname = v.toString(); break;
}
// waypoint-specific attributes
if ( wpt != NULL )
{
if ( indexToAttr[i] == SymAttr )
wpt->sym = v.toString();
else if ( indexToAttr[i] == EleAttr )
{
bool eleIsOK;
double ele = v.toDouble( &eleIsOK );
if ( eleIsOK )
wpt->ele = ele;
}
}
// route- and track-specific attributes
if ( ext != NULL )
{
if ( indexToAttr[i] == NumAttr )
{
bool numIsOK;
int num = v.toInt( &numIsOK );
if ( numIsOK )
ext->number = num;
}
}
}
}
QString QgsPointDisplacementRenderer::getLabel( const QgsFeature& f )
{
QString attribute;
QgsAttributeMap attMap = f.attributeMap();
if ( attMap.size() > 0 )
{
QgsAttributeMap::const_iterator valIt = attMap.find( mLabelIndex );
if ( valIt != attMap.constEnd() )
{
attribute = valIt->toString();
}
}
return attribute;
}
QSizeF QgsLinearlyInterpolatedDiagramRenderer::diagramSize( const QgsAttributeMap& attributes, const QgsRenderContext& c )
{
Q_UNUSED( c );
QgsAttributeMap::const_iterator attIt = attributes.find( mClassificationAttribute );
if ( attIt == attributes.constEnd() )
{
return QSizeF(); //zero size if attribute is missing
}
double value = attIt.value().toDouble();
//interpolate size
double ratio = ( value - mLowerValue ) / ( mUpperValue - mLowerValue );
return QSizeF( mUpperSize.width() * ratio + mLowerSize.width() * ( 1 - ratio ),
mUpperSize.height() * ratio + mLowerSize.height() * ( 1 - ratio ) );
}
QgsSymbolV2* QgsCategorizedSymbolRendererV2::symbolForFeature( QgsFeature& feature )
{
const QgsAttributeMap& attrMap = feature.attributeMap();
QgsAttributeMap::const_iterator ita = attrMap.find( mAttrNum );
if ( ita == attrMap.end() )
{
QgsDebugMsg( "attribute '" + mAttrName + "' (index " + QString::number( mAttrNum ) + ") required by renderer not found" );
return NULL;
}
// find the right symbol for the category
QgsSymbolV2* symbol = symbolForValue( *ita );
if ( symbol == NULL )
return NULL;
if ( mRotationFieldIdx == -1 && mSizeScaleFieldIdx == -1 )
return symbol; // no data-defined rotation/scaling - just return the symbol
// find out rotation, size scale
double rotation = 0;
double sizeScale = 1;
if ( mRotationFieldIdx != -1 )
rotation = attrMap[mRotationFieldIdx].toDouble();
if ( mSizeScaleFieldIdx != -1 )
sizeScale = attrMap[mSizeScaleFieldIdx].toDouble();
// take a temporary symbol (or create it if doesn't exist)
QgsSymbolV2* tempSymbol = mTempSymbols[ita->toString()];
// modify the temporary symbol and return it
if ( tempSymbol->type() == QgsSymbolV2::Marker )
{
QgsMarkerSymbolV2* markerSymbol = static_cast<QgsMarkerSymbolV2*>( tempSymbol );
if ( mRotationFieldIdx != -1 )
markerSymbol->setAngle( rotation );
if ( mSizeScaleFieldIdx != -1 )
markerSymbol->setSize( sizeScale * static_cast<QgsMarkerSymbolV2*>( symbol )->size() );
}
else if ( tempSymbol->type() == QgsSymbolV2::Line )
{
QgsLineSymbolV2* lineSymbol = static_cast<QgsLineSymbolV2*>( tempSymbol );
if ( mSizeScaleFieldIdx != -1 )
lineSymbol->setWidth( sizeScale * static_cast<QgsLineSymbolV2*>( symbol )->width() );
}
return tempSymbol;
}
QSizeF QgsPieDiagram::diagramSize( const QgsAttributeMap& attributes, const QgsRenderContext& c, const QgsDiagramSettings& s, const QgsDiagramInterpolationSettings& is )
{
Q_UNUSED( c );
QgsAttributeMap::const_iterator attIt = attributes.find( is.classificationAttribute );
if ( attIt == attributes.constEnd() )
{
return QSizeF(); //zero size if attribute is missing
}
double scaledValue = attIt.value().toDouble();
double scaledLowerValue = is.lowerValue;
double scaledUpperValue = is.upperValue;
double scaledLowerSizeWidth = is.lowerSize.width();
double scaledLowerSizeHeight = is.lowerSize.height();
double scaledUpperSizeWidth = is.upperSize.width();
double scaledUpperSizeHeight = is.upperSize.height();
// interpolate the squared value if scale by area
if ( s.scaleByArea )
{
scaledValue = sqrt( scaledValue );
scaledLowerValue = sqrt( scaledLowerValue );
scaledUpperValue = sqrt( scaledUpperValue );
scaledLowerSizeWidth = sqrt( scaledLowerSizeWidth );
scaledLowerSizeHeight = sqrt( scaledLowerSizeHeight );
scaledUpperSizeWidth = sqrt( scaledUpperSizeWidth );
scaledUpperSizeHeight = sqrt( scaledUpperSizeHeight );
}
//interpolate size
double scaledRatio = ( scaledValue - scaledLowerValue ) / ( scaledUpperValue - scaledLowerValue );
QSizeF size = QSizeF( is.upperSize.width() * scaledRatio + is.lowerSize.width() * ( 1 - scaledRatio ),
is.upperSize.height() * scaledRatio + is.lowerSize.height() * ( 1 - scaledRatio ) );
// Scale, if extension is smaller than the specified minimum
if ( size.width() <= s.minimumSize && size.height() <= s.minimumSize )
{
size.scale( s.minimumSize, s.minimumSize, Qt::KeepAspectRatio );
}
return size;
}
QString QgsLabel::fieldValue( int attr, QgsFeature &feature )
{
if ( mLabelFieldIdx[attr] == -1 )
{
return QString();
}
const QgsAttributeMap& attrs = feature.attributeMap();
QgsAttributeMap::const_iterator it = attrs.find( mLabelFieldIdx[attr] );
if ( it != attrs.end() )
{
return it->toString();
}
else
{
return QString();
}
}
int QgsDiagramRenderer::classificationValue( const QgsFeature& f, QVariant& value ) const
{
//find out attribute value of the feature
QgsAttributeMap featureAttributes = f.attributeMap();
QgsAttributeMap::const_iterator iter;
if ( value.type() == QVariant::String ) //string type
{
//we can only handle one classification field for strings
if ( mClassificationAttributes.size() > 1 )
{
return 1;
}
iter = featureAttributes.find( mClassificationAttributes.first() );
if ( iter == featureAttributes.constEnd() )
{
return 2;
}
value = iter.value();
}
else //numeric type
{
double currentValue;
double totalValue = 0;
QList<int>::const_iterator list_it = mClassificationAttributes.constBegin();
for ( ; list_it != mClassificationAttributes.constEnd(); ++list_it )
{
QgsAttributeMap::const_iterator iter = featureAttributes.find( *list_it );
if ( iter == featureAttributes.constEnd() )
{
continue;
}
currentValue = iter.value().toDouble();
totalValue += currentValue;
}
value = QVariant( totalValue );
}
return 0;
}
void QgsMapToolChangeLabelProperties::applyChanges( const QgsAttributeMap& changes )
{
QgsVectorLayer* vlayer = mCurrentLabel.layer;
if ( !vlayer )
return;
if ( !changes.isEmpty() )
{
vlayer->beginEditCommand( tr( "Changed properties for label" ) + QStringLiteral( " '%1'" ).arg( currentLabelText( 24 ) ) );
QgsAttributeMap::const_iterator changeIt = changes.constBegin();
for ( ; changeIt != changes.constEnd(); ++changeIt )
{
vlayer->changeAttributeValue( mCurrentLabel.pos.featureId, changeIt.key(), changeIt.value() );
}
vlayer->endEditCommand();
vlayer->triggerRepaint();
}
}
void QgsVectorLayerFeatureIterator::updateChangedAttributes( QgsFeature &f )
{
QgsAttributes& attrs = f.attributes();
// remove all attributes that will disappear - from higher indices to lower
for ( int idx = mDeletedAttributeIds.count() - 1; idx >= 0; --idx )
{
attrs.remove( mDeletedAttributeIds[idx] );
}
// adjust size to accommodate added attributes
attrs.resize( attrs.count() + mAddedAttributes.count() );
// update changed attributes
if ( mChangedAttributeValues.contains( f.id() ) )
{
const QgsAttributeMap &map = mChangedAttributeValues[f.id()];
for ( QgsAttributeMap::const_iterator it = map.begin(); it != map.end(); it++ )
attrs[it.key()] = it.value();
}
}
void QgsOfflineEditing::applyFeaturesAdded( QgsVectorLayer* offlineLayer, QgsVectorLayer* remoteLayer, sqlite3* db, int layerId )
{
QString sql = QString( "SELECT \"fid\" FROM 'log_added_features' WHERE \"layer_id\" = %1" ).arg( layerId );
QList<int> newFeatureIds = sqlQueryInts( db, sql );
// get new features from offline layer
QgsFeatureList features;
for ( int i = 0; i < newFeatureIds.size(); i++ )
{
QgsFeature feature;
if ( offlineLayer->featureAtId( newFeatureIds.at( i ), feature, true, true ) )
{
features << feature;
}
}
// copy features to remote layer
mProgressDialog->setupProgressBar( tr( "%v / %m features added" ), features.size() );
int i = 1;
for ( QgsFeatureList::iterator it = features.begin(); it != features.end(); ++it )
{
QgsFeature f = *it;
// NOTE: Spatialite provider ignores position of geometry column
// restore gap in QgsAttributeMap if geometry column is not last (WORKAROUND)
QMap<int, int> attrLookup = attributeLookup( offlineLayer, remoteLayer );
QgsAttributeMap newAttrMap;
QgsAttributeMap attrMap = f.attributeMap();
for ( QgsAttributeMap::const_iterator it = attrMap.begin(); it != attrMap.end(); ++it )
{
newAttrMap.insert( attrLookup[ it.key()], it.value() );
}
f.setAttributeMap( newAttrMap );
remoteLayer->addFeature( f, false );
mProgressDialog->setProgressValue( i++ );
}
}
QString QgsWFSServer::createFeatureGeoJSON( QgsFeature* feat, QgsCoordinateReferenceSystem &, QMap< int, QgsField > fields, QSet<QString> hiddenAttributes ) /*const*/
{
QString fStr = "{\"type\": \"Feature\",\n";
fStr += " \"id\": ";
fStr += QString::number( feat->id() );
fStr += ",\n";
QgsGeometry* geom = feat->geometry();
if ( geom && mWithGeom )
{
QgsRectangle box = geom->boundingBox();
fStr += " \"bbox\": [ " + QString::number( box.xMinimum(), 'f', 6 ).remove( QRegExp( "[0]{1,5}$" ) ) + ", " + QString::number( box.yMinimum(), 'f', 6 ).remove( QRegExp( "[0]{1,5}$" ) ) + ", " + QString::number( box.xMaximum(), 'f', 6 ).remove( QRegExp( "[0]{1,5}$" ) ) + ", " + QString::number( box.yMaximum(), 'f', 6 ).remove( QRegExp( "[0]{1,5}$" ) ) + "],\n";
fStr += " \"geometry\": ";
fStr += geom->exportToGeoJSON();
fStr += ",\n";
}
//read all attribute values from the feature
fStr += " \"properties\": {\n";
QgsAttributeMap featureAttributes = feat->attributeMap();
int attributeCounter = 0;
for ( QgsAttributeMap::const_iterator it = featureAttributes.begin(); it != featureAttributes.end(); ++it )
{
QString attributeName = fields[it.key()].name();
//skip attribute if it has edit type 'hidden'
if ( hiddenAttributes.contains( attributeName ) )
{
continue;
}
if ( attributeCounter == 0 )
fStr += " \"";
else
fStr += " ,\"";
fStr += attributeName;
fStr += "\": ";
if ( it->type() == 6 || it->type() == 2 )
{
fStr += it->toString();
}
else
{
fStr += "\"";
fStr += it->toString().replace( QString( "\"" ), QString( "\\\"" ) );
fStr += "\"";
}
fStr += "\n";
++attributeCounter;
}
fStr += " }\n";
fStr += " }";
return fStr;
}
void QgsOfflineEditing::committedAttributeValuesChanges( const QString& qgisLayerId, const QgsChangedAttributesMap& changedAttrsMap )
{
sqlite3* db = openLoggingDb();
if ( db == NULL )
{
return;
}
// insert log
int layerId = getOrCreateLayerId( db, qgisLayerId );
int commitNo = getCommitNo( db );
for ( QgsChangedAttributesMap::const_iterator cit = changedAttrsMap.begin(); cit != changedAttrsMap.end(); ++cit )
{
QgsFeatureId fid = cit.key();
if ( isAddedFeature( db, layerId, fid ) )
{
// skip added features
continue;
}
QgsAttributeMap attrMap = cit.value();
for ( QgsAttributeMap::const_iterator it = attrMap.begin(); it != attrMap.end(); ++it )
{
QString sql = QString( "INSERT INTO 'log_feature_updates' VALUES ( %1, %2, %3, %4, '%5' )" )
.arg( layerId )
.arg( commitNo )
.arg( fid )
.arg( it.key() ) // attr
.arg( it.value().toString() ); // value
sqlExec( db, sql );
}
}
increaseCommitNo( db );
sqlite3_close( db );
}
bool QgsFeatureAction::editFeature()
{
bool res = false;
if ( !mLayer )
return res;
QgsAttributeDialog *dialog = newDialog( false );
if ( !mLayer->isEditable() )
{
res = dialog->exec();
}
else
{
QgsAttributeMap src = mFeature.attributeMap();
if ( dialog->exec() )
{
mLayer->beginEditCommand( text() );
const QgsAttributeMap &dst = mFeature.attributeMap();
for ( QgsAttributeMap::const_iterator it = dst.begin(); it != dst.end(); it++ )
{
if ( !src.contains( it.key() ) || it.value() != src[it.key()] )
{
mLayer->changeAttributeValue( mFeature.id(), it.key(), it.value() );
}
}
mLayer->endEditCommand();
res = true;
}
else
{
res = false;
}
}
delete dialog;
return res;
}
bool QgsWFSProvider::changeAttributeValues( const QgsChangedAttributesMap &attr_map )
{
//find out typename from uri and strip namespace prefix
QString tname = mShared->mURI.typeName();
if ( tname.isNull() )
{
return false;
}
//create <Transaction> xml
QDomDocument transactionDoc;
QDomElement transactionElem = createTransactionElement( transactionDoc );
transactionDoc.appendChild( transactionElem );
QgsChangedAttributesMap::const_iterator attIt = attr_map.constBegin();
for ( ; attIt != attr_map.constEnd(); ++attIt )
{
QString gmlid = mShared->findGmlId( attIt.key() );
if ( gmlid.isEmpty() )
{
QgsDebugMsg( QString( "Cannot identify feature of id %1" ).arg( attIt.key() ) );
continue;
}
QDomElement updateElem = transactionDoc.createElementNS( QgsWFSConstants::WFS_NAMESPACE, "Update" );
updateElem.setAttribute( "typeName", tname );
QgsAttributeMap::const_iterator attMapIt = attIt.value().constBegin();
for ( ; attMapIt != attIt.value().constEnd(); ++attMapIt )
{
QString fieldName = mShared->mFields.at( attMapIt.key() ).name();
QDomElement propertyElem = transactionDoc.createElementNS( QgsWFSConstants::WFS_NAMESPACE, "Property" );
QDomElement nameElem = transactionDoc.createElementNS( QgsWFSConstants::WFS_NAMESPACE, "Name" );
QDomText nameText = transactionDoc.createTextNode( fieldName );
nameElem.appendChild( nameText );
propertyElem.appendChild( nameElem );
QDomElement valueElem = transactionDoc.createElementNS( QgsWFSConstants::WFS_NAMESPACE, "Value" );
QDomText valueText = transactionDoc.createTextNode( attMapIt.value().toString() );
valueElem.appendChild( valueText );
propertyElem.appendChild( valueElem );
updateElem.appendChild( propertyElem );
}
//Filter
QDomElement filterElem = transactionDoc.createElementNS( QgsWFSConstants::OGC_NAMESPACE, "Filter" );
QDomElement featureIdElem = transactionDoc.createElementNS( QgsWFSConstants::OGC_NAMESPACE, "FeatureId" );
featureIdElem.setAttribute( "fid", gmlid );
filterElem.appendChild( featureIdElem );
updateElem.appendChild( filterElem );
transactionElem.appendChild( updateElem );
}
QDomDocument serverResponse;
bool success = sendTransactionDocument( transactionDoc, serverResponse );
if ( !success )
{
return false;
}
if ( transactionSuccess( serverResponse ) )
{
mShared->changeAttributeValues( attr_map );
return true;
}
else
{
handleException( serverResponse );
return false;
}
}
void QgsOfflineEditing::copyVectorLayer( QgsVectorLayer* layer, sqlite3* db, const QString& offlineDbPath )
{
if ( layer == NULL )
{
return;
}
QString tableName = layer->name();
// create table
QString sql = QString( "CREATE TABLE '%1' (" ).arg( tableName );
QString delim = "";
const QgsFieldMap& fields = layer->dataProvider()->fields();
for ( QgsFieldMap::const_iterator it = fields.begin(); it != fields.end() ; ++it )
{
QString dataType = "";
QVariant::Type type = it.value().type();
if ( type == QVariant::Int )
{
dataType = "INTEGER";
}
else if ( type == QVariant::Double )
{
dataType = "REAL";
}
else if ( type == QVariant::String )
{
dataType = "TEXT";
}
else
{
showWarning( tr( "Unknown data type %1" ).arg( type ) );
}
sql += delim + QString( "'%1' %2" ).arg( it.value().name() ).arg( dataType );
delim = ",";
}
sql += ")";
// add geometry column
QString geomType = "";
switch ( layer->wkbType() )
{
case QGis::WKBPoint:
geomType = "POINT";
break;
case QGis::WKBMultiPoint:
geomType = "MULTIPOINT";
break;
case QGis::WKBLineString:
geomType = "LINESTRING";
break;
case QGis::WKBMultiLineString:
geomType = "MULTILINESTRING";
break;
case QGis::WKBPolygon:
geomType = "POLYGON";
break;
case QGis::WKBMultiPolygon:
geomType = "MULTIPOLYGON";
break;
default:
showWarning( tr( "QGIS wkbType %1 not supported" ).arg( layer->wkbType() ) );
break;
};
QString sqlAddGeom = QString( "SELECT AddGeometryColumn('%1', 'Geometry', %2, '%3', 2)" )
.arg( tableName )
.arg( layer->crs().authid().startsWith( "EPSG:", Qt::CaseInsensitive ) ? layer->crs().authid().mid( 5 ).toLong() : 0 )
.arg( geomType );
// create spatial index
QString sqlCreateIndex = QString( "SELECT CreateSpatialIndex('%1', 'Geometry')" ).arg( tableName );
int rc = sqlExec( db, sql );
if ( rc == SQLITE_OK )
{
rc = sqlExec( db, sqlAddGeom );
if ( rc == SQLITE_OK )
{
rc = sqlExec( db, sqlCreateIndex );
}
}
if ( rc == SQLITE_OK )
{
// add new layer
QgsVectorLayer* newLayer = new QgsVectorLayer( QString( "dbname='%1' table='%2'(Geometry) sql=" )
.arg( offlineDbPath ).arg( tableName ), tableName + " (offline)", "spatialite" );
if ( newLayer->isValid() )
{
// mark as offline layer
newLayer->setCustomProperty( CUSTOM_PROPERTY_IS_OFFLINE_EDITABLE, true );
// store original layer source
newLayer->setCustomProperty( CUSTOM_PROPERTY_REMOTE_SOURCE, layer->source() );
newLayer->setCustomProperty( CUSTOM_PROPERTY_REMOTE_PROVIDER, layer->providerType() );
// copy style
bool hasLabels = layer->hasLabelsEnabled();
if ( !hasLabels )
{
// NOTE: copy symbology before adding the layer so it is displayed correctly
copySymbology( layer, newLayer );
}
// register this layer with the central layers registry
QgsMapLayerRegistry::instance()->addMapLayer( newLayer );
if ( hasLabels )
{
// NOTE: copy symbology of layers with labels enabled after adding to project, as it will crash otherwise (WORKAROUND)
copySymbology( layer, newLayer );
}
// TODO: layer order
// copy features
newLayer->startEditing();
QgsFeature f;
// NOTE: force feature recount for PostGIS layer, else only visible features are counted, before iterating over all features (WORKAROUND)
layer->setSubsetString( "" );
layer->select( layer->pendingAllAttributesList(), QgsRectangle(), true, false );
mProgressDialog->setupProgressBar( tr( "%v / %m features copied" ), layer->featureCount() );
int featureCount = 1;
QList<int> remoteFeatureIds;
while ( layer->nextFeature( f ) )
{
remoteFeatureIds << f.id();
// NOTE: Spatialite provider ignores position of geometry column
// fill gap in QgsAttributeMap if geometry column is not last (WORKAROUND)
int column = 0;
QgsAttributeMap newAttrMap;
QgsAttributeMap attrMap = f.attributeMap();
for ( QgsAttributeMap::const_iterator it = attrMap.begin(); it != attrMap.end(); ++it )
{
newAttrMap.insert( column++, it.value() );
}
f.setAttributeMap( newAttrMap );
newLayer->addFeature( f, false );
mProgressDialog->setProgressValue( featureCount++ );
}
if ( newLayer->commitChanges() )
{
mProgressDialog->setupProgressBar( tr( "%v / %m features processed" ), layer->featureCount() );
featureCount = 1;
// update feature id lookup
int layerId = getOrCreateLayerId( db, newLayer->id() );
QList<int> offlineFeatureIds;
newLayer->select( QgsAttributeList(), QgsRectangle(), false, false );
while ( newLayer->nextFeature( f ) )
{
offlineFeatureIds << f.id();
}
// NOTE: insert fids in this loop, as the db is locked during newLayer->nextFeature()
sqlExec( db, "BEGIN" );
for ( int i = 0; i < remoteFeatureIds.size(); i++ )
{
addFidLookup( db, layerId, offlineFeatureIds.at( i ), remoteFeatureIds.at( i ) );
mProgressDialog->setProgressValue( featureCount++ );
}
sqlExec( db, "COMMIT" );
}
else
{
showWarning( newLayer->commitErrors().join( "\n" ) );
}
// remove remote layer
QgsMapLayerRegistry::instance()->removeMapLayer( layer->id() );
}
}
}
void RgLineVectorLayerDirector::makeGraph( RgGraphBuilder *builder, const QVector< QgsPoint >& additionalPoints,
QVector< QgsPoint >& tiedPoint ) const
{
QgsVectorLayer *vl = myLayer();
if ( vl == NULL )
return;
int featureCount = ( int ) vl->featureCount() * 2;
int step = 0;
QgsCoordinateTransform ct;
QgsDistanceArea da;
ct.setSourceCrs( vl->crs() );
if ( builder->coordinateTransformEnabled() )
{
ct.setDestCRS( builder->destinationCrs() );
da.setProjectionsEnabled( true );
//
//da.setSourceCrs( builder->destinationCrs().srsid() );
//
}
else
{
ct.setDestCRS( vl->crs() );
da.setProjectionsEnabled( false );
}
tiedPoint = QVector< QgsPoint >( additionalPoints.size(), QgsPoint( 0.0, 0.0 ) );
TiePointInfo tmpInfo;
tmpInfo.mLength = infinity();
QVector< TiePointInfo > pointLengthMap( additionalPoints.size(), tmpInfo );
QVector< TiePointInfo >::iterator pointLengthIt;
// begin: tie points to the graph
QgsAttributeList la;
vl->select( la );
QgsFeature feature;
while ( vl->nextFeature( feature ) )
{
QgsMultiPolyline mpl;
if ( feature.geometry()->wkbType() == QGis::WKBLineString )
{
mpl.push_back( feature.geometry()->asPolyline() );
}else if ( feature.geometry()->wkbType() == QGis::WKBMultiLineString )
{
mpl = feature.geometry()->asMultiPolyline();
}
QgsMultiPolyline::iterator mplIt;
for ( mplIt = mpl.begin(); mplIt != mpl.end(); ++mplIt )
{
QgsPoint pt1, pt2;
bool isFirstPoint = true;
QgsPolyline::iterator pointIt;
for ( pointIt = mplIt->begin(); pointIt != mplIt->end(); ++pointIt )
{
pt2 = builder->addVertex( ct.transform( *pointIt ) );
if ( !isFirstPoint )
{
int i = 0;
for ( i = 0; i != additionalPoints.size(); ++i )
{
TiePointInfo info;
if ( pt1 == pt2 )
{
info.mLength = additionalPoints[ i ].sqrDist( pt1 );
info.mTiedPoint = pt1;
}
else
{
info.mLength = additionalPoints[ i ].sqrDistToSegment( pt1.x(), pt1.y(), pt2.x(), pt2.y(), info.mTiedPoint );
}
if ( pointLengthMap[ i ].mLength > info.mLength )
{
info.mTiedPoint = builder->addVertex( info.mTiedPoint );
info.mFirstPoint = pt1;
info.mLastPoint = pt2;
pointLengthMap[ i ] = info;
tiedPoint[ i ] = info.mTiedPoint;
}
}
}
pt1 = pt2;
isFirstPoint = false;
}
}
emit buildProgress( ++step, featureCount );
}
// end: tie points to graph
if ( mDirectionFieldId != -1 )
{
la.push_back( mDirectionFieldId );
}
if ( mSpeedFieldId != -1 )
{
la.push_back( mSpeedFieldId );
}
SpeedUnit su = SpeedUnit::byName( mSpeedUnitName );
// begin graph construction
vl->select( la );
while ( vl->nextFeature( feature ) )
{
QgsAttributeMap attr = feature.attributeMap();
int directionType = mDefaultDirection;
QgsAttributeMap::const_iterator it;
// What direction have feature?
for ( it = attr.constBegin(); it != attr.constEnd(); ++it )
{
if ( it.key() != mDirectionFieldId )
{
continue;
}
QString str = it.value().toString();
if ( str == mBothDirectionValue )
{
directionType = 3;
}
else if ( str == mDirectDirectionValue )
{
directionType = 1;
}
else if ( str == mReverseDirectionValue )
{
directionType = 2;
}
}
// What speed have feature?
double speed = 0.0;
for ( it = attr.constBegin(); it != attr.constEnd(); ++it )
{
if ( it.key() != mSpeedFieldId )
{
continue;
}
speed = it.value().toDouble();
}
if ( speed <= 0.0 )
{
speed = mDefaultSpeed;
}
// begin features segments and add arc to the Graph;
QgsMultiPolyline mpl;
if ( feature.geometry()->wkbType() == QGis::WKBLineString )
{
mpl.push_back( feature.geometry()->asPolyline() );
}else if ( feature.geometry()->wkbType() == QGis::WKBMultiLineString )
{
mpl = feature.geometry()->asMultiPolyline();
}
QgsMultiPolyline::iterator mplIt;
for ( mplIt = mpl.begin(); mplIt != mpl.end(); ++mplIt )
{
QgsPoint pt1, pt2;
bool isFirstPoint = true;
QgsPolyline::iterator pointIt;
for ( pointIt = mplIt->begin(); pointIt != mplIt->end(); ++pointIt )
{
pt2 = builder->addVertex( ct.transform( *pointIt ) );
std::map< double, QgsPoint > pointsOnArc;
pointsOnArc[ 0.0 ] = pt1;
pointsOnArc[ pt1.sqrDist( pt2 )] = pt2;
for ( pointLengthIt = pointLengthMap.begin(); pointLengthIt != pointLengthMap.end(); ++pointLengthIt )
{
if ( pointLengthIt->mFirstPoint == pt1 && pointLengthIt->mLastPoint == pt2 )
{
QgsPoint tiedPoint = pointLengthIt->mTiedPoint;
pointsOnArc[ pt1.sqrDist( tiedPoint )] = tiedPoint;
}
}
if ( !isFirstPoint )
{
std::map< double, QgsPoint >::iterator pointsIt;
QgsPoint pt1;
QgsPoint pt2;
bool isFirstPoint = true;
for ( pointsIt = pointsOnArc.begin(); pointsIt != pointsOnArc.end(); ++pointsIt )
{
pt2 = pointsIt->second;
if ( !isFirstPoint )
{
double cost = da.measureLine( pt1, pt2 );
if ( directionType == 1 ||
directionType == 3 )
{
builder->addArc( pt1, pt2, cost, speed*su.multipler(), feature.id() );
}
if ( directionType == 2 ||
directionType == 3 )
{
builder->addArc( pt2, pt1, cost, speed*su.multipler(), feature.id() );
}
}
pt1 = pt2;
isFirstPoint = false;
}
} // if ( !isFirstPoint )
pt1 = pt2;
isFirstPoint = false;
}
} // for (it = pl.begin(); it != pl.end(); ++it)
emit buildProgress( ++step, featureCount );
} // while( vl->nextFeature(feature) )
} // makeGraph( RgGraphBuilder *builder, const QgsRectangle& rt )
bool QgsGPXProvider::addFeature( QgsFeature& f )
{
unsigned char* geo = f.geometry()->asWkb();
QGis::WkbType wkbType = f.geometry()->wkbType();
bool success = false;
QgsGPSObject* obj = NULL;
const QgsAttributeMap& attrs( f.attributeMap() );
QgsAttributeMap::const_iterator it;
// is it a waypoint?
if ( mFeatureType == WaypointType && geo != NULL && wkbType == QGis::WKBPoint )
{
// add geometry
QgsWaypoint wpt;
std::memcpy( &wpt.lon, geo + 5, sizeof( double ) );
std::memcpy( &wpt.lat, geo + 13, sizeof( double ) );
// add waypoint-specific attributes
for ( it = attrs.begin(); it != attrs.end(); ++it )
{
if ( it.key() == EleAttr )
{
bool eleIsOK;
double ele = it->toDouble( &eleIsOK );
if ( eleIsOK )
wpt.ele = ele;
}
else if ( it.key() == SymAttr )
{
wpt.sym = it->toString();
}
}
QgsGPSData::WaypointIterator iter = data->addWaypoint( wpt );
success = true;
obj = &( *iter );
}
// is it a route?
if ( mFeatureType == RouteType && geo != NULL && wkbType == QGis::WKBLineString )
{
QgsRoute rte;
// reset bounds
rte.xMin = std::numeric_limits<double>::max();
rte.xMax = -std::numeric_limits<double>::max();
rte.yMin = std::numeric_limits<double>::max();
rte.yMax = -std::numeric_limits<double>::max();
// add geometry
int nPoints;
std::memcpy( &nPoints, geo + 5, 4 );
for ( int i = 0; i < nPoints; ++i )
{
double lat, lon;
std::memcpy( &lon, geo + 9 + 16 * i, sizeof( double ) );
std::memcpy( &lat, geo + 9 + 16 * i + 8, sizeof( double ) );
QgsRoutepoint rtept;
rtept.lat = lat;
rtept.lon = lon;
rte.points.push_back( rtept );
rte.xMin = rte.xMin < lon ? rte.xMin : lon;
rte.xMax = rte.xMax > lon ? rte.xMax : lon;
rte.yMin = rte.yMin < lat ? rte.yMin : lat;
rte.yMax = rte.yMax > lat ? rte.yMax : lat;
}
// add route-specific attributes
for ( it = attrs.begin(); it != attrs.end(); ++it )
{
if ( it.key() == NumAttr )
{
bool numIsOK;
long num = it->toInt( &numIsOK );
if ( numIsOK )
rte.number = num;
}
}
QgsGPSData::RouteIterator iter = data->addRoute( rte );
success = true;
obj = &( *iter );
}
// is it a track?
if ( mFeatureType == TrackType && geo != NULL && wkbType == QGis::WKBLineString )
{
QgsTrack trk;
QgsTrackSegment trkseg;
// reset bounds
trk.xMin = std::numeric_limits<double>::max();
trk.xMax = -std::numeric_limits<double>::max();
trk.yMin = std::numeric_limits<double>::max();
trk.yMax = -std::numeric_limits<double>::max();
// add geometry
int nPoints;
std::memcpy( &nPoints, geo + 5, 4 );
for ( int i = 0; i < nPoints; ++i )
{
double lat, lon;
std::memcpy( &lon, geo + 9 + 16 * i, sizeof( double ) );
std::memcpy( &lat, geo + 9 + 16 * i + 8, sizeof( double ) );
QgsTrackpoint trkpt;
trkpt.lat = lat;
trkpt.lon = lon;
trkseg.points.push_back( trkpt );
trk.xMin = trk.xMin < lon ? trk.xMin : lon;
trk.xMax = trk.xMax > lon ? trk.xMax : lon;
trk.yMin = trk.yMin < lat ? trk.yMin : lat;
trk.yMax = trk.yMax > lat ? trk.yMax : lat;
}
// add track-specific attributes
for ( it = attrs.begin(); it != attrs.end(); ++it )
{
if ( it.key() == NumAttr )
{
bool numIsOK;
long num = it->toInt( &numIsOK );
if ( numIsOK )
trk.number = num;
}
}
trk.segments.push_back( trkseg );
QgsGPSData::TrackIterator iter = data->addTrack( trk );
success = true;
obj = &( *iter );
}
// add common attributes
if ( obj )
{
for ( it = attrs.begin(); it != attrs.end(); ++it )
{
if ( it.key() == NameAttr )
{
obj->name = it->toString();
}
else if ( it.key() == CmtAttr )
{
obj->cmt = it->toString();
}
else if ( it.key() == DscAttr )
{
obj->desc = it->toString();
}
else if ( it.key() == SrcAttr )
{
obj->src = it->toString();
}
else if ( it.key() == URLAttr )
{
obj->url = it->toString();
}
else if ( it.key() == URLNameAttr )
{
obj->urlname = it->toString();
}
}
}
return success;
}
void QgsMapToolRotatePointSymbols::canvasPressEvent( QMouseEvent *e )
{
if ( !mCanvas )
{
return;
}
mActiveLayer = currentVectorLayer();
if ( !mActiveLayer )
{
notifyNotVectorLayer();
return;
}
if ( !mActiveLayer->isEditable() )
{
notifyNotEditableLayer();
return;
}
if ( mActiveLayer->geometryType() != QGis::Point )
{
return;
}
//find the closest feature to the pressed position
QgsMapCanvasSnapper canvasSnapper( mCanvas );
QList<QgsSnappingResult> snapResults;
if ( canvasSnapper.snapToCurrentLayer( e->pos(), snapResults, QgsSnapper::SnapToVertex, -1 ) != 0 || snapResults.size() < 1 )
{
QMessageBox::critical( 0, tr( "No point feature" ), tr( "No point feature was detected at the clicked position. Please click closer to the feature or enhance the search tolerance under Settings->Options->Digitizing->Serch radius for vertex edits" ) );
return; //error during snapping
}
mFeatureNumber = snapResults.at( 0 ).snappedAtGeometry;
//get list with renderer rotation attributes
if ( layerRotationAttributes( mActiveLayer, mCurrentRotationAttributes ) != 0 )
{
return;
}
if ( mCurrentRotationAttributes.size() < 1 )
{
QMessageBox::critical( 0, tr( "No rotation Attributes" ), tr( "The active point layer does not have a rotation attribute" ) );
return;
}
mSnappedPoint = toCanvasCoordinates( snapResults.at( 0 ).snappedVertex );
//find out initial arrow direction
QgsFeature pointFeature;
if ( !mActiveLayer->featureAtId( mFeatureNumber, pointFeature, false, true ) )
{
return;
}
const QgsAttributeMap pointFeatureAttributes = pointFeature.attributeMap();
const QgsAttributeMap::const_iterator attIt = pointFeatureAttributes.find( mCurrentRotationAttributes.at( 0 ) );
if ( attIt == pointFeatureAttributes.constEnd() )
{
return;
}
mCurrentRotationFeature = attIt.value().toDouble();
createPixmapItem( pointFeature );
if ( mRotationItem )
{
mRotationItem->setPointLocation( snapResults.at( 0 ).snappedVertex );
}
mCurrentMouseAzimut = calculateAzimut( e->pos() );
setPixmapItemRotation(( int )( mCurrentMouseAzimut ) );
mRotating = true;
}
