00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include <cfloat>
00026 #include <cstring>
00027 #include <climits>
00028 #include <cmath>
00029 #include <iosfwd>
00030 #include <limits>
00031 #include <memory>
00032 #include <set>
00033 #include <sstream>
00034 #include <utility>
00035
00036 #include <QImage>
00037 #include <QPainter>
00038 #include <QPainterPath>
00039 #include <QPolygonF>
00040 #include <QSettings>
00041 #include <QString>
00042 #include <QDomNode>
00043
00044 #include "qgsvectorlayer.h"
00045
00046
00047 #include "qgscontinuouscolorrenderer.h"
00048 #include "qgsgraduatedsymbolrenderer.h"
00049 #include "qgsrenderer.h"
00050 #include "qgssinglesymbolrenderer.h"
00051 #include "qgsuniquevaluerenderer.h"
00052
00053 #include "qgsattributeaction.h"
00054
00055 #include "qgis.h"
00056 #include "qgsapplication.h"
00057 #include "qgscoordinatetransform.h"
00058 #include "qgsfeature.h"
00059 #include "qgsfield.h"
00060 #include "qgsgeometry.h"
00061 #include "qgslabel.h"
00062 #include "qgslogger.h"
00063 #include "qgsmaptopixel.h"
00064 #include "qgspoint.h"
00065 #include "qgsproviderregistry.h"
00066 #include "qgsrectangle.h"
00067 #include "qgsrendercontext.h"
00068 #include "qgssinglesymbolrenderer.h"
00069 #include "qgscoordinatereferencesystem.h"
00070 #include "qgsvectordataprovider.h"
00071 #include "qgsvectorlayerundocommand.h"
00072 #include "qgsvectoroverlay.h"
00073 #include "qgsmaplayerregistry.h"
00074 #include "qgsclipper.h"
00075 #include "qgsproject.h"
00076
00077 #include "qgsrendererv2.h"
00078 #include "qgssymbolv2.h"
00079 #include "qgssymbollayerv2.h"
00080 #include "qgssinglesymbolrendererv2.h"
00081
00082 #ifdef TESTPROVIDERLIB
00083 #include <dlfcn.h>
00084 #endif
00085
00086
00087 static const char * const ident_ = "$Id$";
00088
00089
00090 typedef QgsDataProvider * create_it( const QString* uri );
00091
00092
00093
00094 QgsVectorLayer::QgsVectorLayer( QString vectorLayerPath,
00095 QString baseName,
00096 QString providerKey,
00097 bool loadDefaultStyleFlag )
00098 : QgsMapLayer( VectorLayer, baseName, vectorLayerPath ),
00099 mUpdateThreshold( 0 ),
00100 mDataProvider( NULL ),
00101 mProviderKey( providerKey ),
00102 mEditable( false ),
00103 mReadOnly( false ),
00104 mModified( false ),
00105 mMaxUpdatedIndex( -1 ),
00106 mActiveCommand( NULL ),
00107 mRenderer( 0 ),
00108 mRendererV2( NULL ),
00109 mUsingRendererV2( false ),
00110 mLabel( 0 ),
00111 mLabelOn( false ),
00112 mVertexMarkerOnlyForSelection( false ),
00113 mFetching( false )
00114 {
00115 mActions = new QgsAttributeAction( this );
00116
00117
00118 if ( ! mProviderKey.isEmpty() )
00119 {
00120 setDataProvider( mProviderKey );
00121 }
00122 if ( mValid )
00123 {
00124
00125 setCoordinateSystem();
00126
00127 QSettings settings;
00128 if ( settings.value( "/qgis/use_symbology_ng", false ).toBool() && geometryType() != QGis::NoGeometry )
00129 {
00130
00131 setUsingRendererV2( true );
00132 }
00133
00134
00135
00136 bool defaultLoadedFlag = false;
00137 if ( loadDefaultStyleFlag )
00138 {
00139 loadDefaultStyle( defaultLoadedFlag );
00140 }
00141
00142
00143 if ( !defaultLoadedFlag && geometryType() != QGis::NoGeometry )
00144 {
00145
00146 if ( mUsingRendererV2 )
00147 {
00148 setRendererV2( QgsFeatureRendererV2::defaultRenderer( geometryType() ) );
00149 }
00150 else
00151 {
00152 QgsSingleSymbolRenderer *renderer = new QgsSingleSymbolRenderer( geometryType() );
00153 setRenderer( renderer );
00154 }
00155 }
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165 }
00166 }
00167
00168
00169
00170 QgsVectorLayer::~QgsVectorLayer()
00171 {
00172 QgsDebugMsg( "In QgsVectorLayer destructor" );
00173
00174 emit layerDeleted();
00175
00176 mValid = false;
00177
00178 if ( mRenderer )
00179 {
00180 delete mRenderer;
00181 }
00182
00183 delete mDataProvider;
00184
00185 delete mLabel;
00186
00187
00188 deleteCachedGeometries();
00189
00190 delete mActions;
00191
00192
00193
00194 QList<QgsVectorOverlay*>::iterator overlayIt = mOverlays.begin();
00195 for ( ; overlayIt != mOverlays.end(); ++overlayIt )
00196 {
00197 delete *overlayIt;
00198 }
00199 }
00200
00201 QString QgsVectorLayer::storageType() const
00202 {
00203 if ( mDataProvider )
00204 {
00205 return mDataProvider->storageType();
00206 }
00207 return 0;
00208 }
00209
00210
00211 QString QgsVectorLayer::capabilitiesString() const
00212 {
00213 if ( mDataProvider )
00214 {
00215 return mDataProvider->capabilitiesString();
00216 }
00217 return 0;
00218 }
00219
00220 QString QgsVectorLayer::dataComment() const
00221 {
00222 if ( mDataProvider )
00223 {
00224 return mDataProvider->dataComment();
00225 }
00226 return QString();
00227 }
00228
00229
00230 QString QgsVectorLayer::providerType() const
00231 {
00232 return mProviderKey;
00233 }
00234
00238 void QgsVectorLayer::setDisplayField( QString fldName )
00239 {
00240 if ( geometryType() == QGis::NoGeometry )
00241 return;
00242
00243
00244
00245
00246
00247
00248 QString idxName = "";
00249 QString idxId = "";
00250
00251 if ( !fldName.isEmpty() )
00252 {
00253 mDisplayField = fldName;
00254 }
00255 else
00256 {
00257 const QgsFieldMap &fields = pendingFields();
00258 int fieldsSize = fields.size();
00259
00260 for ( QgsFieldMap::const_iterator it = fields.begin(); it != fields.end(); ++it )
00261 {
00262 QString fldName = it.value().name();
00263 QgsDebugMsg( "Checking field " + fldName + " of " + QString::number( fieldsSize ) + " total" );
00264
00265
00266
00267
00268
00269 if ( fldName.indexOf( "name", false ) > -1 )
00270 {
00271 if ( idxName.isEmpty() )
00272 {
00273 idxName = fldName;
00274 }
00275 }
00276 if ( fldName.indexOf( "descrip", false ) > -1 )
00277 {
00278 if ( idxName.isEmpty() )
00279 {
00280 idxName = fldName;
00281 }
00282 }
00283 if ( fldName.indexOf( "id", false ) > -1 )
00284 {
00285 if ( idxId.isEmpty() )
00286 {
00287 idxId = fldName;
00288 }
00289 }
00290 }
00291
00292
00293 if ( fieldsSize == 0 )
00294 return;
00295
00296 if ( idxName.length() > 0 )
00297 {
00298 mDisplayField = idxName;
00299 }
00300 else
00301 {
00302 if ( idxId.length() > 0 )
00303 {
00304 mDisplayField = idxId;
00305 }
00306 else
00307 {
00308 mDisplayField = fields[0].name();
00309 }
00310 }
00311
00312 }
00313 }
00314
00315
00316
00317
00318 void QgsVectorLayer::drawLabels( QgsRenderContext& rendererContext )
00319 {
00320 if ( geometryType() == QGis::NoGeometry )
00321 return;
00322
00323 QgsDebugMsg( "Starting draw of labels" );
00324
00325 if (( mRenderer || mRendererV2 ) && mLabelOn &&
00326 ( !mLabel->scaleBasedVisibility() ||
00327 ( mLabel->minScale() <= rendererContext.rendererScale() &&
00328 rendererContext.rendererScale() <= mLabel->maxScale() ) ) )
00329 {
00330 QgsAttributeList attributes;
00331 if ( mRenderer )
00332 {
00333 attributes = mRenderer->classificationAttributes();
00334 }
00335 else if ( mRendererV2 )
00336 {
00337 foreach( QString attrName, mRendererV2->usedAttributes() )
00338 {
00339 int attrNum = fieldNameIndex( attrName );
00340 attributes.append( attrNum );
00341 }
00342
00343 mRendererV2->startRender( rendererContext, this );
00344 }
00345
00346
00347 mLabel->addRequiredFields( attributes );
00348
00349 QgsDebugMsg( "Selecting features based on view extent" );
00350
00351 int featureCount = 0;
00352
00353 try
00354 {
00355
00356
00357 select( attributes, rendererContext.extent() );
00358
00359 QgsFeature fet;
00360 while ( nextFeature( fet ) )
00361 {
00362 if (( mRenderer && mRenderer->willRenderFeature( &fet ) )
00363 || ( mRendererV2 && mRendererV2->symbolForFeature( fet ) != NULL ) )
00364 {
00365 bool sel = mSelectedFeatureIds.contains( fet.id() );
00366 mLabel->renderLabel( rendererContext, fet, sel, 0 );
00367 }
00368 featureCount++;
00369 }
00370 }
00371 catch ( QgsCsException &e )
00372 {
00373 Q_UNUSED( e );
00374 QgsDebugMsg( "Error projecting label locations" );
00375 }
00376
00377 if ( mRendererV2 )
00378 {
00379 mRendererV2->stopRender( rendererContext );
00380 }
00381
00382 QgsDebugMsg( QString( "Total features processed %1" ).arg( featureCount ) );
00383
00384
00385
00386
00387
00388 }
00389 }
00390
00391
00392 unsigned char *QgsVectorLayer::drawLineString( unsigned char *feature, QgsRenderContext &renderContext )
00393 {
00394 QPainter *p = renderContext.painter();
00395 unsigned char *ptr = feature + 5;
00396 unsigned int wkbType = *(( int* )( feature + 1 ) );
00397 unsigned int nPoints = *(( int* )ptr );
00398 ptr = feature + 9;
00399
00400 bool hasZValue = ( wkbType == QGis::WKBLineString25D );
00401
00402 std::vector<double> x( nPoints );
00403 std::vector<double> y( nPoints );
00404 std::vector<double> z( nPoints, 0.0 );
00405
00406
00407 for ( register unsigned int i = 0; i < nPoints; ++i )
00408 {
00409 x[i] = *(( double * ) ptr );
00410 ptr += sizeof( double );
00411 y[i] = *(( double * ) ptr );
00412 ptr += sizeof( double );
00413
00414 if ( hasZValue )
00415 ptr += sizeof( double );
00416 }
00417
00418
00419
00420
00421 transformPoints( x, y, z, renderContext );
00422
00423
00424
00425
00426
00427 for ( register unsigned int i = 0; i < nPoints; ++i )
00428 {
00429 if ( std::abs( x[i] ) > QgsClipper::MAX_X ||
00430 std::abs( y[i] ) > QgsClipper::MAX_Y )
00431 {
00432 QgsClipper::trimFeature( x, y, true );
00433 nPoints = x.size();
00434 break;
00435 }
00436 }
00437
00438
00439 QPolygonF pa( nPoints );
00440 for ( register unsigned int i = 0; i < nPoints; ++i )
00441 {
00442 pa[i].setX( x[i] );
00443 pa[i].setY( y[i] );
00444 }
00445
00446
00447
00448
00449 QPen pen = p->pen();
00450
00451
00452
00453
00454
00455 QPen myTransparentPen = p->pen();
00456 QColor myColor = myTransparentPen.color();
00457
00458
00459 if ( !mRenderer->usesTransparency() )
00460 {
00461 myColor.setAlpha( mTransparencyLevel );
00462 }
00463 myTransparentPen.setColor( myColor );
00464 p->setPen( myTransparentPen );
00465 p->drawPolyline( pa );
00466
00467
00468 if ( mEditable && renderContext.drawEditingInformation() )
00469 {
00470
00471 std::vector<double>::const_iterator xIt;
00472 std::vector<double>::const_iterator yIt;
00473 for ( xIt = x.begin(), yIt = y.begin(); xIt != x.end(); ++xIt, ++yIt )
00474 {
00475 drawVertexMarker( *xIt, *yIt, *p, mCurrentVertexMarkerType, mCurrentVertexMarkerSize );
00476 }
00477 }
00478
00479
00480 p->setPen( pen );
00481
00482 return ptr;
00483 }
00484
00485 unsigned char *QgsVectorLayer::drawPolygon( unsigned char *feature, QgsRenderContext &renderContext )
00486 {
00487 QPainter *p = renderContext.painter();
00488 typedef std::pair<std::vector<double>, std::vector<double> > ringType;
00489 typedef ringType* ringTypePtr;
00490 typedef std::vector<ringTypePtr> ringsType;
00491
00492
00493 unsigned int numRings = *(( int* )( feature + 1 + sizeof( int ) ) );
00494
00495 if ( numRings == 0 )
00496 return feature + 9;
00497
00498 unsigned int wkbType = *(( int* )( feature + 1 ) );
00499
00500 bool hasZValue = ( wkbType == QGis::WKBPolygon25D );
00501
00502 int total_points = 0;
00503
00504
00505
00506
00507 ringsType rings;
00508
00509
00510 unsigned char* ptr = feature + 1 + 2 * sizeof( int );
00511
00512 for ( register unsigned int idx = 0; idx < numRings; idx++ )
00513 {
00514 unsigned int nPoints = *(( int* )ptr );
00515
00516 ringTypePtr ring = new ringType( std::vector<double>( nPoints ), std::vector<double>( nPoints ) );
00517 ptr += 4;
00518
00519
00520 std::vector<double> zVector( nPoints, 0.0 );
00521
00522
00523 for ( register unsigned int jdx = 0; jdx < nPoints; jdx++ )
00524 {
00525 ring->first[jdx] = *(( double * ) ptr );
00526 ptr += sizeof( double );
00527 ring->second[jdx] = *(( double * ) ptr );
00528 ptr += sizeof( double );
00529
00530 if ( hasZValue )
00531 ptr += sizeof( double );
00532 }
00533
00534
00535 if ( nPoints < 1 )
00536 {
00537 QgsDebugMsg( "Ring has only " + QString::number( nPoints ) + " points! Skipping this ring." );
00538 continue;
00539 }
00540
00541 transformPoints( ring->first, ring->second, zVector, renderContext );
00542
00543
00544
00545
00546
00547 for ( register unsigned int i = 0; i < nPoints; ++i )
00548 {
00549 if ( std::abs( ring->first[i] ) > QgsClipper::MAX_X ||
00550 std::abs( ring->second[i] ) > QgsClipper::MAX_Y )
00551 {
00552 QgsClipper::trimFeature( ring->first, ring->second, false );
00553 break;
00554 }
00555 }
00556
00557
00558
00559 if ( ring->first.size() == 0 )
00560 delete ring;
00561 else
00562 {
00563 rings.push_back( ring );
00564 total_points += ring->first.size();
00565 }
00566 }
00567
00568
00569
00570
00571
00572
00573
00574 QPainterPath path;
00575
00576
00577 if ( total_points > 0 )
00578 {
00579
00580 QBrush brush = p->brush();
00581 QPen pen = p->pen();
00582
00583
00584
00585
00586 QBrush myTransparentBrush = p->brush();
00587 QColor myColor = brush.color();
00588
00589
00590
00591 if ( !mRenderer->usesTransparency() )
00592 {
00593 myColor.setAlpha( mTransparencyLevel );
00594 }
00595 myTransparentBrush.setColor( myColor );
00596 QPen myTransparentPen = p->pen();
00597 myColor = myTransparentPen.color();
00598
00599
00600
00601 if ( !mRenderer->usesTransparency() )
00602 {
00603 myColor.setAlpha( mTransparencyLevel );
00604 }
00605 myTransparentPen.setColor( myColor );
00606
00607 p->setBrush( myTransparentBrush );
00608 p->setPen( myTransparentPen );
00609
00610 if ( numRings == 1 )
00611 {
00612 ringTypePtr r = rings[0];
00613 unsigned ringSize = r->first.size();
00614
00615 QPolygonF pa( ringSize );
00616 for ( register unsigned int j = 0; j != ringSize; ++j )
00617 {
00618 pa[j].setX( r->first[j] );
00619 pa[j].setY( r->second[j] );
00620 }
00621 p->drawPolygon( pa );
00622
00623
00624 if ( mEditable && renderContext.drawEditingInformation() )
00625 {
00626 for ( register unsigned int j = 0; j != ringSize; ++j )
00627 {
00628 drawVertexMarker( r->first[j], r->second[j], *p, mCurrentVertexMarkerType, mCurrentVertexMarkerSize );
00629 }
00630 }
00631
00632 delete rings[0];
00633 }
00634 else
00635 {
00636
00637
00638 int numRings = rings.size();
00639 for ( register int i = 0; i < numRings; ++i )
00640 {
00641
00642
00643 ringTypePtr r = rings[i];
00644
00645 unsigned ringSize = r->first.size();
00646
00647
00648 QPolygonF pa( ringSize );
00649 for ( register unsigned int j = 0; j != ringSize; ++j )
00650 {
00651 pa[j].setX( r->first[j] );
00652 pa[j].setY( r->second[j] );
00653 }
00654
00655 path.addPolygon( pa );
00656
00657
00658 delete rings[i];
00659 }
00660
00661 #if 0
00662
00663
00664 int largestX = -std::numeric_limits<int>::max();
00665 int smallestX = std::numeric_limits<int>::max();
00666 int largestY = -std::numeric_limits<int>::max();
00667 int smallestY = std::numeric_limits<int>::max();
00668
00669 for ( int i = 0; i < pa.size(); ++i )
00670 {
00671 largestX = std::max( largestX, pa.point( i ).x() );
00672 smallestX = std::min( smallestX, pa.point( i ).x() );
00673 largestY = std::max( largestY, pa.point( i ).y() );
00674 smallestY = std::min( smallestY, pa.point( i ).y() );
00675 }
00676 QgsDebugMsg( QString( "Largest X coordinate was %1" ).arg( largestX ) );
00677 QgsDebugMsg( QString( "Smallest X coordinate was %1" ).arg( smallestX ) );
00678 QgsDebugMsg( QString( "Largest Y coordinate was %1" ).arg( largestY ) );
00679 QgsDebugMsg( QString( "Smallest Y coordinate was %1" ).arg( smallestY ) );
00680 #endif
00681
00682
00683
00684
00685 p->drawPath( path );
00686
00687
00688 if ( mEditable && renderContext.drawEditingInformation() )
00689 {
00690 for ( int i = 0; i < path.elementCount(); ++i )
00691 {
00692 const QPainterPath::Element & e = path.elementAt( i );
00693 drawVertexMarker( e.x, e.y, *p, mCurrentVertexMarkerType, mCurrentVertexMarkerSize );
00694 }
00695 }
00696 }
00697
00698
00699
00700
00701 p->setBrush( brush );
00702 p->setPen( pen );
00703
00704 }
00705
00706 return ptr;
00707 }
00708
00709 void QgsVectorLayer::drawRendererV2( QgsRenderContext& rendererContext, bool labeling )
00710 {
00711 if ( geometryType() == QGis::NoGeometry )
00712 return;
00713
00714 QSettings settings;
00715 bool vertexMarkerOnlyForSelection = settings.value( "/qgis/digitizing/marker_only_for_selected", false ).toBool();
00716
00717 mRendererV2->startRender( rendererContext, this );
00718
00719 #ifndef Q_WS_MAC
00720 int featureCount = 0;
00721 #endif //Q_WS_MAC
00722
00723 QgsFeature fet;
00724 while ( nextFeature( fet ) )
00725 {
00726 try
00727 {
00728 if ( rendererContext.renderingStopped() )
00729 {
00730 break;
00731 }
00732
00733 #ifndef Q_WS_MAC //MH: disable this on Mac for now to avoid problems with resizing
00734 if ( mUpdateThreshold > 0 && 0 == featureCount % mUpdateThreshold )
00735 {
00736 emit screenUpdateRequested();
00737
00738 qApp->processEvents();
00739 }
00740 else if ( featureCount % 1000 == 0 )
00741 {
00742
00743 qApp->processEvents();
00744 }
00745 #endif //Q_WS_MAC
00746
00747 bool sel = mSelectedFeatureIds.contains( fet.id() );
00748 bool drawMarker = ( mEditable && ( !vertexMarkerOnlyForSelection || sel ) );
00749
00750
00751 mRendererV2->renderFeature( fet, rendererContext, -1, sel, drawMarker );
00752
00753
00754 if ( labeling && mRendererV2->symbolForFeature( fet ) != NULL )
00755 rendererContext.labelingEngine()->registerFeature( this, fet, rendererContext );
00756
00757 if ( mEditable )
00758 {
00759
00760 mCachedGeometries[fet.id()] = *fet.geometry();
00761 }
00762 }
00763 catch ( const QgsCsException &cse )
00764 {
00765 QgsDebugMsg( QString( "Failed to transform a point while drawing a feature of type '%1'. Ignoring this feature. %2" )
00766 .arg( fet.typeName() ).arg( cse.what() ) );
00767 }
00768 #ifndef Q_WS_MAC
00769 ++featureCount;
00770 #endif //Q_WS_MAC
00771 }
00772 }
00773
00774 void QgsVectorLayer::drawRendererV2Levels( QgsRenderContext& rendererContext, bool labeling )
00775 {
00776 if ( geometryType() == QGis::NoGeometry )
00777 return;
00778
00779 QHash< QgsSymbolV2*, QList<QgsFeature> > features;
00780
00781 QSettings settings;
00782 bool vertexMarkerOnlyForSelection = settings.value( "/qgis/digitizing/marker_only_for_selected", false ).toBool();
00783
00784
00785 mRendererV2->startRender( rendererContext, this );
00786
00787 QgsSingleSymbolRendererV2* selRenderer = NULL;
00788 if ( !mSelectedFeatureIds.isEmpty() )
00789 {
00790 selRenderer = new QgsSingleSymbolRendererV2( QgsSymbolV2::defaultSymbol( geometryType() ) );
00791 selRenderer->symbol()->setColor( QgsRenderer::selectionColor() );
00792 selRenderer->setVertexMarkerAppearance( currentVertexMarkerType(), currentVertexMarkerSize() );
00793 selRenderer->startRender( rendererContext, this );
00794 }
00795
00796
00797 QgsFeature fet;
00798 #ifndef Q_WS_MAC
00799 int featureCount = 0;
00800 #endif //Q_WS_MAC
00801 while ( nextFeature( fet ) )
00802 {
00803 if ( rendererContext.renderingStopped() )
00804 {
00805 stopRendererV2( rendererContext, selRenderer );
00806 return;
00807 }
00808 #ifndef Q_WS_MAC
00809 if ( featureCount % 1000 == 0 )
00810 {
00811 qApp->processEvents();
00812 }
00813 #endif //Q_WS_MAC
00814 QgsSymbolV2* sym = mRendererV2->symbolForFeature( fet );
00815 if ( !features.contains( sym ) )
00816 {
00817 features.insert( sym, QList<QgsFeature>() );
00818 }
00819 features[sym].append( fet );
00820
00821 if ( labeling && mRendererV2->symbolForFeature( fet ) != NULL )
00822 rendererContext.labelingEngine()->registerFeature( this, fet, rendererContext );
00823
00824 if ( mEditable )
00825 {
00826
00827 mCachedGeometries[fet.id()] = *fet.geometry();
00828 }
00829 #ifndef Q_WS_MAC
00830 ++featureCount;
00831 #endif //Q_WS_MAC
00832 }
00833
00834
00835 QgsSymbolV2LevelOrder levels;
00836 QgsSymbolV2List symbols = mRendererV2->symbols();
00837 for ( int i = 0; i < symbols.count(); i++ )
00838 {
00839 QgsSymbolV2* sym = symbols[i];
00840 for ( int j = 0; j < sym->symbolLayerCount(); j++ )
00841 {
00842 int level = sym->symbolLayer( j )->renderingPass();
00843 if ( level < 0 || level >= 1000 )
00844 continue;
00845 QgsSymbolV2LevelItem item( sym, j );
00846 while ( level >= levels.count() )
00847 levels.append( QgsSymbolV2Level() );
00848 levels[level].append( item );
00849 }
00850 }
00851
00852
00853 for ( int l = 0; l < levels.count(); l++ )
00854 {
00855 QgsSymbolV2Level& level = levels[l];
00856 for ( int i = 0; i < level.count(); i++ )
00857 {
00858 QgsSymbolV2LevelItem& item = level[i];
00859 if ( !features.contains( item.symbol() ) )
00860 {
00861 QgsDebugMsg( "level item's symbol not found!" );
00862 continue;
00863 }
00864 int layer = item.layer();
00865 QList<QgsFeature>& lst = features[item.symbol()];
00866 QList<QgsFeature>::iterator fit;
00867 #ifndef Q_WS_MAC
00868 featureCount = 0;
00869 #endif //Q_WS_MAC
00870 for ( fit = lst.begin(); fit != lst.end(); ++fit )
00871 {
00872 if ( rendererContext.renderingStopped() )
00873 {
00874 stopRendererV2( rendererContext, selRenderer );
00875 return;
00876 }
00877 #ifndef Q_WS_MAC
00878 if ( featureCount % 1000 == 0 )
00879 {
00880 qApp->processEvents();
00881 }
00882 #endif //Q_WS_MAC
00883 bool sel = mSelectedFeatureIds.contains( fit->id() );
00884
00885 bool drawMarker = ( mEditable && ( !vertexMarkerOnlyForSelection || sel ) );
00886
00887 try
00888 {
00889 mRendererV2->renderFeature( *fit, rendererContext, layer, sel, drawMarker );
00890 }
00891 catch ( const QgsCsException &cse )
00892 {
00893 QgsDebugMsg( QString( "Failed to transform a point while drawing a feature of type '%1'. Ignoring this feature. %2" )
00894 .arg( fet.typeName() ).arg( cse.what() ) );
00895 }
00896 #ifndef Q_WS_MAC
00897 ++featureCount;
00898 #endif //Q_WS_MAC
00899 }
00900 }
00901 }
00902
00903 stopRendererV2( rendererContext, selRenderer );
00904 }
00905
00906 void QgsVectorLayer::reload()
00907 {
00908 if ( mDataProvider )
00909 {
00910 mDataProvider->reloadData();
00911 }
00912 }
00913
00914 bool QgsVectorLayer::draw( QgsRenderContext& rendererContext )
00915 {
00916 if ( geometryType() == QGis::NoGeometry )
00917 return true;
00918
00919
00920 QSettings settings;
00921 mUpdateThreshold = settings.value( "Map/updateThreshold", 0 ).toInt();
00922
00923 if ( mUsingRendererV2 )
00924 {
00925 if ( mRendererV2 == NULL )
00926 return false;
00927
00928 QgsDebugMsg( "rendering v2:\n" + mRendererV2->dump() );
00929
00930 if ( mEditable )
00931 {
00932
00933 deleteCachedGeometries();
00934 mCachedGeometriesRect = rendererContext.extent();
00935
00936
00937 mRendererV2->setVertexMarkerAppearance( currentVertexMarkerType(), currentVertexMarkerSize() );
00938 }
00939
00940 QgsAttributeList attributes;
00941 foreach( QString attrName, mRendererV2->usedAttributes() )
00942 {
00943 int attrNum = fieldNameIndex( attrName );
00944 attributes.append( attrNum );
00945 QgsDebugMsg( "attrs: " + attrName + " - " + QString::number( attrNum ) );
00946 }
00947
00948 bool labeling = false;
00949 if ( rendererContext.labelingEngine() )
00950 {
00951 QSet<int> attrIndex;
00952 if ( rendererContext.labelingEngine()->prepareLayer( this, attrIndex, rendererContext ) )
00953 {
00954 QSet<int>::const_iterator attIt = attrIndex.constBegin();
00955 for ( ; attIt != attrIndex.constEnd(); ++attIt )
00956 {
00957 if ( !attributes.contains( *attIt ) )
00958 {
00959 attributes << *attIt;
00960 }
00961 }
00962 labeling = true;
00963 }
00964 }
00965
00966 select( attributes, rendererContext.extent() );
00967
00968 if ( mRendererV2->usingSymbolLevels() )
00969 drawRendererV2Levels( rendererContext, labeling );
00970 else
00971 drawRendererV2( rendererContext, labeling );
00972
00973 return true;
00974 }
00975
00976
00977
00978 if ( mRenderer )
00979 {
00980
00981
00982
00983
00984
00985
00986
00987
00988 QPen pen;
00989
00990 QImage marker;
00991
00992 QgsVectorLayer::VertexMarkerType vertexMarker = QgsVectorLayer::NoMarker;
00993 int vertexMarkerSize = 7;
00994
00995 if ( mEditable )
00996 {
00997
00998 deleteCachedGeometries();
00999 mCachedGeometriesRect = rendererContext.extent();
01000 vertexMarker = currentVertexMarkerType();
01001 vertexMarkerSize = currentVertexMarkerSize();
01002 mVertexMarkerOnlyForSelection = settings.value( "/qgis/digitizing/marker_only_for_selected", false ).toBool();
01003 }
01004
01005
01006 int featureCount = 0;
01007 QgsFeature fet;
01008 QgsAttributeList attributes = mRenderer->classificationAttributes();
01009
01010 bool labeling = false;
01011 if ( rendererContext.labelingEngine() )
01012 {
01013 QSet<int> attrIndex;
01014 if ( rendererContext.labelingEngine()->prepareLayer( this, attrIndex, rendererContext ) )
01015 {
01016 QSet<int>::const_iterator attIt = attrIndex.constBegin();
01017 for ( ; attIt != attrIndex.constEnd(); ++attIt )
01018 {
01019 if ( !attributes.contains( *attIt ) )
01020 {
01021 attributes << *attIt;
01022 }
01023 }
01024 labeling = true;
01025 }
01026 }
01027
01028 select( attributes, rendererContext.extent() );
01029
01030 try
01031 {
01032 while ( nextFeature( fet ) )
01033 {
01034
01035 if ( rendererContext.renderingStopped() )
01036 {
01037 break;
01038 }
01039
01040 #ifndef Q_WS_MAC //MH: disable this on Mac for now to avoid problems with resizing
01041 if ( mUpdateThreshold > 0 && 0 == featureCount % mUpdateThreshold )
01042 {
01043 emit screenUpdateRequested();
01044
01045 qApp->processEvents();
01046 }
01047 else if ( featureCount % 1000 == 0 )
01048 {
01049
01050 qApp->processEvents();
01051 }
01052
01053
01054 #endif //Q_WS_MAC
01055
01056
01057
01058
01059 bool sel = mSelectedFeatureIds.contains( fet.id() );
01060
01061 mCurrentVertexMarkerType = QgsVectorLayer::NoMarker;
01062 mCurrentVertexMarkerSize = 7;
01063
01064 if ( mEditable )
01065 {
01066
01067 mCachedGeometries[fet.id()] = *fet.geometry();
01068
01069 if ( !mVertexMarkerOnlyForSelection || sel )
01070 {
01071 mCurrentVertexMarkerType = vertexMarker;
01072 mCurrentVertexMarkerSize = vertexMarkerSize;
01073 }
01074 }
01075
01076
01077
01078
01079 double opacity = 1.0;
01080 if ( !mRenderer->usesTransparency() )
01081 {
01082 opacity = ( mTransparencyLevel * 1.0 ) / 255.0;
01083 }
01084 mRenderer->renderFeature( rendererContext, fet, &marker, sel, opacity );
01085
01086
01087
01088
01089
01090 drawFeature( rendererContext, fet, &marker );
01091
01092 if ( labeling && mRenderer->willRenderFeature( &fet ) )
01093 {
01094 rendererContext.labelingEngine()->registerFeature( this, fet, rendererContext );
01095 }
01096
01097 ++featureCount;
01098 }
01099 }
01100 catch ( QgsCsException &cse )
01101 {
01102 QgsDebugMsg( QString( "Failed to transform a point while drawing a feature of type '%1'. Rendering stopped. %2" )
01103 .arg( fet.typeName() ).arg( cse.what() ) );
01104 return false;
01105 }
01106 }
01107 else
01108 {
01109 QgsDebugMsg( "QgsRenderer is null" );
01110 }
01111
01112 if ( mEditable )
01113 {
01114 QgsDebugMsg( QString( "Cached %1 geometries." ).arg( mCachedGeometries.count() ) );
01115 }
01116
01117 return true;
01118 }
01119
01120 void QgsVectorLayer::deleteCachedGeometries()
01121 {
01122
01123 mCachedGeometries.clear();
01124 mCachedGeometriesRect = QgsRectangle();
01125 }
01126
01127 void QgsVectorLayer::drawVertexMarker( double x, double y, QPainter& p, QgsVectorLayer::VertexMarkerType type, int m )
01128 {
01129 if ( type == QgsVectorLayer::SemiTransparentCircle )
01130 {
01131 p.setPen( QColor( 50, 100, 120, 200 ) );
01132 p.setBrush( QColor( 200, 200, 210, 120 ) );
01133 p.drawEllipse( x - m, y - m, m*2 + 1, m*2 + 1 );
01134 }
01135 else if ( type == QgsVectorLayer::Cross )
01136 {
01137 p.setPen( QColor( 255, 0, 0 ) );
01138 p.drawLine( x - m, y + m, x + m, y - m );
01139 p.drawLine( x - m, y - m, x + m, y + m );
01140 }
01141 }
01142
01143 void QgsVectorLayer::select( int number, bool emitSignal )
01144 {
01145 mSelectedFeatureIds.insert( number );
01146
01147 if ( emitSignal )
01148 {
01149
01150 setCacheImage( 0 );
01151
01152 emit selectionChanged();
01153 }
01154 }
01155
01156 void QgsVectorLayer::deselect( int number, bool emitSignal )
01157 {
01158 mSelectedFeatureIds.remove( number );
01159
01160 if ( emitSignal )
01161 {
01162
01163 setCacheImage( 0 );
01164
01165 emit selectionChanged();
01166 }
01167 }
01168
01169 void QgsVectorLayer::select( QgsRectangle & rect, bool lock )
01170 {
01171
01172 rect.normalize();
01173
01174 if ( !lock )
01175 {
01176 removeSelection( false );
01177 }
01178
01179
01180 select( QgsAttributeList(), rect, false, true );
01181
01182 QgsFeature f;
01183 while ( nextFeature( f ) )
01184 {
01185 select( f.id(), false );
01186 }
01187
01188
01189 setCacheImage( 0 );
01190
01191 emit selectionChanged();
01192 }
01193
01194 void QgsVectorLayer::invertSelection()
01195 {
01196
01197 QgsFeatureIds tmp = mSelectedFeatureIds;
01198
01199 removeSelection( false );
01200
01201 select( QgsAttributeList(), QgsRectangle(), false );
01202
01203 QgsFeature fet;
01204 while ( nextFeature( fet ) )
01205 {
01206 select( fet.id(), false );
01207 }
01208
01209 for ( QgsFeatureIds::iterator iter = tmp.begin(); iter != tmp.end(); ++iter )
01210 {
01211 mSelectedFeatureIds.remove( *iter );
01212 }
01213
01214
01215 setCacheImage( 0 );
01216
01217 emit selectionChanged();
01218 }
01219
01220 void QgsVectorLayer::invertSelectionInRectangle( QgsRectangle & rect )
01221 {
01222
01223 rect.normalize();
01224
01225 select( QgsAttributeList(), rect, false, true );
01226
01227 QgsFeature fet;
01228 while ( nextFeature( fet ) )
01229 {
01230 if ( mSelectedFeatureIds.contains( fet.id() ) )
01231 {
01232 deselect( fet.id(), false );
01233 }
01234 else
01235 {
01236 select( fet.id(), false );
01237 }
01238 }
01239
01240
01241 setCacheImage( 0 );
01242
01243 emit selectionChanged();
01244 }
01245
01246 void QgsVectorLayer::removeSelection( bool emitSignal )
01247 {
01248 if ( mSelectedFeatureIds.size() == 0 )
01249 return;
01250
01251 mSelectedFeatureIds.clear();
01252
01253 if ( emitSignal )
01254 {
01255
01256 setCacheImage( 0 );
01257
01258 emit selectionChanged();
01259 }
01260 }
01261
01262 void QgsVectorLayer::triggerRepaint()
01263 {
01264 emit repaintRequested();
01265 }
01266
01267 QgsVectorDataProvider* QgsVectorLayer::dataProvider()
01268 {
01269 return mDataProvider;
01270 }
01271
01272 const QgsVectorDataProvider* QgsVectorLayer::dataProvider() const
01273 {
01274 return mDataProvider;
01275 }
01276
01277 void QgsVectorLayer::setProviderEncoding( const QString& encoding )
01278 {
01279 if ( mDataProvider )
01280 {
01281 mDataProvider->setEncoding( encoding );
01282 }
01283 }
01284
01285
01286 const QgsRenderer* QgsVectorLayer::renderer() const
01287 {
01288 return mRenderer;
01289 }
01290
01291 void QgsVectorLayer::setRenderer( QgsRenderer * r )
01292 {
01293 if ( geometryType() == QGis::NoGeometry )
01294 return;
01295
01296 if ( r != mRenderer )
01297 {
01298 delete mRenderer;
01299 mRenderer = r;
01300 }
01301 }
01302
01303 QGis::GeometryType QgsVectorLayer::geometryType() const
01304 {
01305 if ( mDataProvider )
01306 {
01307 int type = mDataProvider->geometryType();
01308 switch ( type )
01309 {
01310 case QGis::WKBPoint:
01311 case QGis::WKBPoint25D:
01312 return QGis::Point;
01313
01314 case QGis::WKBLineString:
01315 case QGis::WKBLineString25D:
01316 return QGis::Line;
01317
01318 case QGis::WKBPolygon:
01319 case QGis::WKBPolygon25D:
01320 return QGis::Polygon;
01321
01322 case QGis::WKBMultiPoint:
01323 case QGis::WKBMultiPoint25D:
01324 return QGis::Point;
01325
01326 case QGis::WKBMultiLineString:
01327 case QGis::WKBMultiLineString25D:
01328 return QGis::Line;
01329
01330 case QGis::WKBMultiPolygon:
01331 case QGis::WKBMultiPolygon25D:
01332 return QGis::Polygon;
01333
01334 case QGis::WKBNoGeometry:
01335 return QGis::NoGeometry;
01336 }
01337 QgsDebugMsg( QString( "Data Provider Geometry type is not recognised, is %1" ).arg( type ) );
01338 }
01339 else
01340 {
01341 QgsDebugMsg( "pointer to mDataProvider is null" );
01342 }
01343
01344
01345
01346
01347
01348
01349 QgsDebugMsg( "WARNING: This code should never be reached. Problems may occur..." );
01350
01351 return QGis::UnknownGeometry;
01352 }
01353
01354 QGis::WkbType QgsVectorLayer::wkbType() const
01355 {
01356 return ( QGis::WkbType )( mWkbType );
01357 }
01358
01359 QgsRectangle QgsVectorLayer::boundingBoxOfSelected()
01360 {
01361 if ( mSelectedFeatureIds.size() == 0 )
01362 {
01363 return QgsRectangle( 0, 0, 0, 0 );
01364 }
01365
01366 QgsRectangle r, retval;
01367
01368
01369 select( QgsAttributeList(), QgsRectangle(), true );
01370
01371 retval.setMinimal();
01372
01373 QgsFeature fet;
01374 while ( nextFeature( fet ) )
01375 {
01376 if ( mSelectedFeatureIds.contains( fet.id() ) )
01377 {
01378 if ( fet.geometry() )
01379 {
01380 r = fet.geometry()->boundingBox();
01381 retval.combineExtentWith( &r );
01382 }
01383 }
01384 }
01385
01386 if ( retval.width() == 0.0 || retval.height() == 0.0 )
01387 {
01388
01389
01390
01391
01392 if ( retval.xMinimum() == 0.0 && retval.xMaximum() == 0.0 &&
01393 retval.yMinimum() == 0.0 && retval.yMaximum() == 0.0 )
01394 {
01395 retval.set( -1.0, -1.0, 1.0, 1.0 );
01396 }
01397 }
01398
01399 return retval;
01400 }
01401
01402
01403
01404 long QgsVectorLayer::featureCount() const
01405 {
01406 if ( !mDataProvider )
01407 {
01408 QgsDebugMsg( "invoked with null mDataProvider" );
01409 return 0;
01410 }
01411
01412 return mDataProvider->featureCount();
01413 }
01414
01415 long QgsVectorLayer::updateFeatureCount() const
01416 {
01417 return -1;
01418 }
01419
01420 void QgsVectorLayer::updateExtents()
01421 {
01422 if ( geometryType() == QGis::NoGeometry )
01423 return;
01424
01425 mLayerExtent.setMinimal();
01426
01427 if ( !mDataProvider )
01428 QgsDebugMsg( "invoked with null mDataProvider" );
01429
01430 if ( mDeletedFeatureIds.isEmpty() && mChangedGeometries.isEmpty() )
01431 {
01432
01433
01434 if ( mDataProvider->featureCount() != 0 )
01435 {
01436 QgsRectangle r = mDataProvider->extent();
01437 mLayerExtent.combineExtentWith( &r );
01438 }
01439
01440 for ( QgsFeatureList::iterator it = mAddedFeatures.begin(); it != mAddedFeatures.end(); it++ )
01441 {
01442 QgsRectangle r = it->geometry()->boundingBox();
01443 mLayerExtent.combineExtentWith( &r );
01444 }
01445 }
01446 else
01447 {
01448 select( QgsAttributeList(), QgsRectangle(), true );
01449
01450 QgsFeature fet;
01451 while ( nextFeature( fet ) )
01452 {
01453 if ( fet.geometry() )
01454 {
01455 QgsRectangle bb = fet.geometry()->boundingBox();
01456 mLayerExtent.combineExtentWith( &bb );
01457 }
01458 }
01459 }
01460
01461 if ( mLayerExtent.xMinimum() > mLayerExtent.xMaximum() && mLayerExtent.yMinimum() > mLayerExtent.yMaximum() )
01462 {
01463
01464 mLayerExtent = QgsRectangle();
01465 }
01466
01467
01468 emit recalculateExtents();
01469 }
01470
01471 QString QgsVectorLayer::subsetString()
01472 {
01473 if ( ! mDataProvider )
01474 {
01475 QgsDebugMsg( "invoked with null mDataProvider" );
01476 return 0;
01477 }
01478 return mDataProvider->subsetString();
01479 }
01480
01481 bool QgsVectorLayer::setSubsetString( QString subset )
01482 {
01483 if ( ! mDataProvider )
01484 {
01485 QgsDebugMsg( "invoked with null mDataProvider" );
01486 return false;
01487 }
01488
01489 bool res = mDataProvider->setSubsetString( subset );
01490
01491
01492 mDataSource = mDataProvider->dataSourceUri();
01493 updateExtents();
01494
01495 if ( res )
01496 setCacheImage( 0 );
01497
01498 return res;
01499 }
01500
01501 void QgsVectorLayer::updateFeatureAttributes( QgsFeature &f, bool all )
01502 {
01503
01504 if ( !mEditable )
01505 return;
01506
01507 if ( mChangedAttributeValues.contains( f.id() ) )
01508 {
01509 const QgsAttributeMap &map = mChangedAttributeValues[f.id()];
01510 for ( QgsAttributeMap::const_iterator it = map.begin(); it != map.end(); it++ )
01511 f.changeAttribute( it.key(), it.value() );
01512 }
01513
01514
01515 QgsAttributeMap map = f.attributeMap();
01516 for ( QgsAttributeMap::const_iterator it = map.begin(); it != map.end(); it++ )
01517 if ( !mUpdatedFields.contains( it.key() ) )
01518 f.deleteAttribute( it.key() );
01519
01520
01521 for ( QgsFieldMap::const_iterator it = mUpdatedFields.begin(); it != mUpdatedFields.end(); it++ )
01522 if ( !map.contains( it.key() ) && ( all || mFetchAttributes.contains( it.key() ) ) )
01523 f.changeAttribute( it.key(), QVariant( QString::null ) );
01524 }
01525
01526 void QgsVectorLayer::updateFeatureGeometry( QgsFeature &f )
01527 {
01528 if ( mChangedGeometries.contains( f.id() ) )
01529 f.setGeometry( mChangedGeometries[f.id()] );
01530 }
01531
01532
01533 void QgsVectorLayer::select( QgsAttributeList attributes, QgsRectangle rect, bool fetchGeometries, bool useIntersect )
01534 {
01535 if ( !mDataProvider )
01536 return;
01537
01538 mFetching = true;
01539 mFetchRect = rect;
01540 mFetchAttributes = attributes;
01541 mFetchGeometry = fetchGeometries;
01542
01543 mFetchConsidered = mDeletedFeatureIds;
01544
01545 if ( mEditable )
01546 {
01547 mFetchAddedFeaturesIt = mAddedFeatures.begin();
01548 mFetchChangedGeomIt = mChangedGeometries.begin();
01549 }
01550
01551
01552 if ( mFetchAttributes.size() > 0 )
01553 {
01554 if ( mEditable )
01555 {
01556
01557 mFetchProvAttributes.clear();
01558 for ( QgsAttributeList::iterator it = mFetchAttributes.begin(); it != mFetchAttributes.end(); it++ )
01559 {
01560 if ( !mUpdatedFields.contains( *it ) || mAddedAttributeIds.contains( *it ) )
01561 continue;
01562
01563 mFetchProvAttributes << *it;
01564 }
01565
01566 mDataProvider->select( mFetchProvAttributes, rect, fetchGeometries, useIntersect );
01567 }
01568 else
01569 mDataProvider->select( mFetchAttributes, rect, fetchGeometries, useIntersect );
01570 }
01571 else
01572 {
01573 mDataProvider->select( QgsAttributeList(), rect, fetchGeometries, useIntersect );
01574 }
01575 }
01576
01577 bool QgsVectorLayer::nextFeature( QgsFeature &f )
01578 {
01579 if ( !mFetching )
01580 return false;
01581
01582 if ( mEditable )
01583 {
01584 if ( !mFetchRect.isEmpty() )
01585 {
01586
01587 for ( ; mFetchChangedGeomIt != mChangedGeometries.end(); mFetchChangedGeomIt++ )
01588 {
01589 int fid = mFetchChangedGeomIt.key();
01590
01591 if ( mFetchConsidered.contains( fid ) )
01592
01593 continue;
01594
01595 mFetchConsidered << fid;
01596
01597 if ( !mFetchChangedGeomIt->intersects( mFetchRect ) )
01598
01599 continue;
01600
01601 f.setFeatureId( fid );
01602 f.setValid( true );
01603
01604 if ( mFetchGeometry )
01605 f.setGeometry( mFetchChangedGeomIt.value() );
01606
01607 if ( mFetchAttributes.size() > 0 )
01608 {
01609 if ( fid < 0 )
01610 {
01611
01612 bool found = false;
01613
01614 for ( QgsFeatureList::iterator it = mAddedFeatures.begin(); it != mAddedFeatures.end(); it++ )
01615 {
01616 if ( fid == it->id() )
01617 {
01618 found = true;
01619 f.setAttributeMap( it->attributeMap() );
01620 break;
01621 }
01622 }
01623
01624 if ( !found )
01625 QgsDebugMsg( QString( "No attributes for the added feature %1 found" ).arg( f.id() ) );
01626 }
01627 else
01628 {
01629
01630 QgsFeature tmp;
01631 mDataProvider->featureAtId( fid, tmp, false, mFetchProvAttributes );
01632 updateFeatureAttributes( tmp );
01633 f.setAttributeMap( tmp.attributeMap() );
01634 }
01635 }
01636
01637
01638 mFetchChangedGeomIt++;
01639 return true;
01640 }
01641
01642
01643 }
01644
01645 for ( ; mFetchAddedFeaturesIt != mAddedFeatures.end(); mFetchAddedFeaturesIt++ )
01646 {
01647 int fid = mFetchAddedFeaturesIt->id();
01648
01649 if ( mFetchConsidered.contains( fid ) )
01650
01651 continue;
01652
01653 if ( !mFetchRect.isEmpty() &&
01654 mFetchAddedFeaturesIt->geometry() &&
01655 !mFetchAddedFeaturesIt->geometry()->intersects( mFetchRect ) )
01656
01657 continue;
01658
01659 f.setFeatureId( fid );
01660 f.setValid( true );
01661
01662 if ( mFetchGeometry )
01663 f.setGeometry( *mFetchAddedFeaturesIt->geometry() );
01664
01665 if ( mFetchAttributes.size() > 0 )
01666 {
01667 f.setAttributeMap( mFetchAddedFeaturesIt->attributeMap() );
01668 updateFeatureAttributes( f );
01669 }
01670
01671 mFetchAddedFeaturesIt++;
01672 return true;
01673 }
01674
01675
01676 }
01677
01678 while ( dataProvider()->nextFeature( f ) )
01679 {
01680 if ( mFetchConsidered.contains( f.id() ) )
01681 continue;
01682
01683 if ( mEditable )
01684 updateFeatureAttributes( f );
01685
01686
01687 return true;
01688 }
01689
01690 mFetching = false;
01691 return false;
01692 }
01693
01694 bool QgsVectorLayer::featureAtId( int featureId, QgsFeature& f, bool fetchGeometries, bool fetchAttributes )
01695 {
01696 if ( !mDataProvider )
01697 return false;
01698
01699 if ( mDeletedFeatureIds.contains( featureId ) )
01700 return false;
01701
01702 if ( fetchGeometries && mChangedGeometries.contains( featureId ) )
01703 {
01704 f.setFeatureId( featureId );
01705 f.setValid( true );
01706 f.setGeometry( mChangedGeometries[featureId] );
01707
01708 if ( fetchAttributes )
01709 {
01710 if ( featureId < 0 )
01711 {
01712
01713 bool found = false;
01714
01715 for ( QgsFeatureList::iterator it = mAddedFeatures.begin(); it != mAddedFeatures.end(); it++ )
01716 {
01717 if ( featureId != it->id() )
01718 {
01719 found = true;
01720 f.setAttributeMap( it->attributeMap() );
01721 break;
01722 }
01723 }
01724
01725 if ( !found )
01726 QgsDebugMsg( QString( "No attributes for the added feature %1 found" ).arg( f.id() ) );
01727 }
01728 else
01729 {
01730
01731 QgsFeature tmp;
01732 mDataProvider->featureAtId( featureId, tmp, false, mDataProvider->attributeIndexes() );
01733 f.setAttributeMap( tmp.attributeMap() );
01734 }
01735 updateFeatureAttributes( f, true );
01736 }
01737 return true;
01738 }
01739
01740
01741 for ( QgsFeatureList::iterator iter = mAddedFeatures.begin(); iter != mAddedFeatures.end(); ++iter )
01742 {
01743 if ( iter->id() == featureId )
01744 {
01745 f.setFeatureId( iter->id() );
01746 f.setValid( true );
01747 if ( fetchGeometries )
01748 f.setGeometry( *iter->geometry() );
01749
01750 if ( fetchAttributes )
01751 f.setAttributeMap( iter->attributeMap() );
01752
01753 return true;
01754 }
01755 }
01756
01757
01758 if ( fetchAttributes )
01759 {
01760 if ( mDataProvider->featureAtId( featureId, f, fetchGeometries, mDataProvider->attributeIndexes() ) )
01761 {
01762 updateFeatureAttributes( f, true );
01763 return true;
01764 }
01765 }
01766 else
01767 {
01768 if ( mDataProvider->featureAtId( featureId, f, fetchGeometries, QgsAttributeList() ) )
01769 {
01770 return true;
01771 }
01772 }
01773 return false;
01774 }
01775
01776 bool QgsVectorLayer::addFeature( QgsFeature& f, bool alsoUpdateExtent )
01777 {
01778 static int addedIdLowWaterMark = -1;
01779
01780 if ( !mDataProvider )
01781 {
01782 return false;
01783 }
01784
01785 if ( !( mDataProvider->capabilities() & QgsVectorDataProvider::AddFeatures ) )
01786 {
01787 return false;
01788 }
01789
01790 if ( !isEditable() )
01791 {
01792 return false;
01793 }
01794
01795
01796 addedIdLowWaterMark--;
01797
01798 QgsDebugMsg( "Assigned feature id " + QString::number( addedIdLowWaterMark ) );
01799
01800
01801
01802
01803 f.setFeatureId( addedIdLowWaterMark );
01804 editFeatureAdd( f );
01805
01806 if ( f.geometry() )
01807 mCachedGeometries[f.id()] = *f.geometry();
01808
01809 setModified( true );
01810
01811 if ( alsoUpdateExtent )
01812 {
01813 updateExtents();
01814 }
01815
01816 return true;
01817 }
01818
01819
01820 bool QgsVectorLayer::insertVertex( double x, double y, int atFeatureId, int beforeVertex )
01821 {
01822 if ( geometryType() == QGis::NoGeometry )
01823 return false;
01824
01825 if ( !mEditable )
01826 {
01827 return false;
01828 }
01829
01830 if ( mDataProvider )
01831 {
01832 QgsGeometry geometry;
01833 if ( !mChangedGeometries.contains( atFeatureId ) )
01834 {
01835
01836 if ( !mCachedGeometries.contains( atFeatureId ) )
01837 {
01838 return false;
01839 }
01840 geometry = mCachedGeometries[atFeatureId];
01841
01842 }
01843 else
01844 {
01845 geometry = mChangedGeometries[atFeatureId];
01846 }
01847 geometry.insertVertex( x, y, beforeVertex );
01848 mCachedGeometries[atFeatureId] = geometry;
01849 editGeometryChange( atFeatureId, geometry );
01850
01851 setModified( true, true );
01852
01853 return true;
01854 }
01855 return false;
01856 }
01857
01858
01859 bool QgsVectorLayer::moveVertex( double x, double y, int atFeatureId, int atVertex )
01860 {
01861 if ( geometryType() == QGis::NoGeometry )
01862 return false;
01863
01864 if ( !mEditable )
01865 {
01866 return false;
01867 }
01868
01869 if ( mDataProvider )
01870 {
01871 QgsGeometry geometry;
01872 if ( !mChangedGeometries.contains( atFeatureId ) )
01873 {
01874
01875 if ( !mCachedGeometries.contains( atFeatureId ) )
01876 {
01877 return false;
01878 }
01879 geometry = mCachedGeometries[atFeatureId];
01880
01881 }
01882 else
01883 {
01884 geometry = mChangedGeometries[atFeatureId];
01885 }
01886
01887 geometry.moveVertex( x, y, atVertex );
01888 mCachedGeometries[atFeatureId] = geometry;
01889 editGeometryChange( atFeatureId, geometry );
01890
01891 setModified( true, true );
01892
01893 return true;
01894 }
01895 return false;
01896 }
01897
01898
01899 bool QgsVectorLayer::deleteVertex( int atFeatureId, int atVertex )
01900 {
01901 if ( geometryType() == QGis::NoGeometry )
01902 return false;
01903
01904 if ( !mEditable )
01905 {
01906 return false;
01907 }
01908
01909 if ( mDataProvider )
01910 {
01911 QgsGeometry geometry;
01912 if ( !mChangedGeometries.contains( atFeatureId ) )
01913 {
01914
01915 if ( !mCachedGeometries.contains( atFeatureId ) )
01916 {
01917 return false;
01918 }
01919 geometry = mCachedGeometries[atFeatureId];
01920 }
01921 else
01922 {
01923 geometry = mChangedGeometries[atFeatureId];
01924 }
01925
01926 if ( !geometry.deleteVertex( atVertex ) )
01927 {
01928 return false;
01929 }
01930 mCachedGeometries[atFeatureId] = geometry;
01931 editGeometryChange( atFeatureId, geometry );
01932
01933 setModified( true, true );
01934
01935 return true;
01936 }
01937 return false;
01938 }
01939
01940
01941 bool QgsVectorLayer::deleteSelectedFeatures()
01942 {
01943 if ( !( mDataProvider->capabilities() & QgsVectorDataProvider::DeleteFeatures ) )
01944 {
01945 return false;
01946 }
01947
01948 if ( !isEditable() )
01949 {
01950 return false;
01951 }
01952
01953 if ( mSelectedFeatureIds.size() == 0 )
01954 return true;
01955
01956 while ( mSelectedFeatureIds.size() > 0 )
01957 {
01958 int fid = *mSelectedFeatureIds.begin();
01959 deleteFeature( fid );
01960 }
01961
01962
01963 setCacheImage( 0 );
01964
01965 emit selectionChanged();
01966
01967 triggerRepaint();
01968 updateExtents();
01969
01970 return true;
01971 }
01972
01973 int QgsVectorLayer::addRing( const QList<QgsPoint>& ring )
01974 {
01975 if ( geometryType() == QGis::NoGeometry )
01976 return 5;
01977
01978 int addRingReturnCode = 5;
01979 double xMin, yMin, xMax, yMax;
01980 QgsRectangle bBox;
01981
01982 if ( boundingBoxFromPointList( ring, xMin, yMin, xMax, yMax ) == 0 )
01983 {
01984 bBox.setXMinimum( xMin ); bBox.setYMinimum( yMin );
01985 bBox.setXMaximum( xMax ); bBox.setYMaximum( yMax );
01986 }
01987 else
01988 {
01989 return 3;
01990 }
01991
01992 select( QgsAttributeList(), bBox, true, true );
01993
01994 QgsFeature f;
01995 while ( nextFeature( f ) )
01996 {
01997 addRingReturnCode = f.geometry()->addRing( ring );
01998 if ( addRingReturnCode == 0 )
01999 {
02000 editGeometryChange( f.id(), *f.geometry() );
02001
02002 setModified( true, true );
02003 break;
02004 }
02005 }
02006
02007 return addRingReturnCode;
02008 }
02009
02010 int QgsVectorLayer::addIsland( const QList<QgsPoint>& ring )
02011 {
02012 if ( geometryType() == QGis::NoGeometry )
02013 return 6;
02014
02015
02016
02017 if ( mSelectedFeatureIds.size() < 1 )
02018 {
02019 QgsDebugMsg( "Number of selected features <1" );
02020 return 4;
02021 }
02022 else if ( mSelectedFeatureIds.size() > 1 )
02023 {
02024 QgsDebugMsg( "Number of selected features >1" );
02025 return 5;
02026 }
02027
02028 int selectedFeatureId = *mSelectedFeatureIds.constBegin();
02029
02030
02031 QgsGeometryMap::iterator changedIt = mChangedGeometries.find( selectedFeatureId );
02032 if ( changedIt != mChangedGeometries.end() )
02033 {
02034 QgsGeometry geom = *changedIt;
02035 int returnValue = geom.addIsland( ring );
02036 editGeometryChange( selectedFeatureId, geom );
02037 mCachedGeometries[selectedFeatureId] = geom;
02038 return returnValue;
02039 }
02040
02041
02042 #if 0
02043 for ( QgsFeatureList::iterator addedIt = mAddedFeatures.begin(); addedIt != mAddedFeatures.end(); ++addedIt )
02044 {
02045 if ( addedIt->id() == selectedFeatureId )
02046 {
02047 return addedIt->geometry()->addIsland( ring );
02048 mCachedGeometries[selectedFeatureId] = *addedIt->geometry();
02049 }
02050 }
02051 #endif
02052
02053
02054 QgsGeometryMap::iterator cachedIt = mCachedGeometries.find( selectedFeatureId );
02055 if ( cachedIt != mCachedGeometries.end() )
02056 {
02057 int errorCode = cachedIt->addIsland( ring );
02058 if ( errorCode == 0 )
02059 {
02060 editGeometryChange( selectedFeatureId, *cachedIt );
02061 mCachedGeometries[selectedFeatureId] = *cachedIt;
02062 setModified( true, true );
02063 }
02064 return errorCode;
02065 }
02066 else
02067 {
02068 QgsFeature f;
02069 QgsGeometry* fGeom = 0;
02070 if ( featureAtId( selectedFeatureId, f, true, false ) )
02071 {
02072 fGeom = f.geometryAndOwnership();
02073 if ( fGeom )
02074 {
02075 int errorCode = fGeom->addIsland( ring );
02076 editGeometryChange( selectedFeatureId, *fGeom );
02077 setModified( true, true );
02078 delete fGeom;
02079 return errorCode;
02080 }
02081 }
02082 }
02083
02084 return 6;
02085 }
02086
02087 int QgsVectorLayer::translateFeature( int featureId, double dx, double dy )
02088 {
02089 if ( geometryType() == QGis::NoGeometry )
02090 return 1;
02091
02092
02093 QgsGeometryMap::iterator changedIt = mChangedGeometries.find( featureId );
02094 if ( changedIt != mChangedGeometries.end() )
02095 {
02096 QgsGeometry geom = *changedIt;
02097 int errorCode = geom.translate( dx, dy );
02098 editGeometryChange( featureId, geom );
02099 return errorCode;
02100 }
02101
02102
02103 #if 0
02104 for ( QgsFeatureList::iterator addedIt = mAddedFeatures.begin(); addedIt != mAddedFeatures.end(); ++addedIt )
02105 {
02106 if ( addedIt->id() == featureId )
02107 {
02108 return addedIt->geometry()->translate( dx, dy );
02109 }
02110 }
02111 #endif
02112
02113
02114 QgsGeometryMap::iterator cachedIt = mCachedGeometries.find( featureId );
02115 if ( cachedIt != mCachedGeometries.end() )
02116 {
02117 int errorCode = cachedIt->translate( dx, dy );
02118 if ( errorCode == 0 )
02119 {
02120 editGeometryChange( featureId, *cachedIt );
02121 setModified( true, true );
02122 }
02123 return errorCode;
02124 }
02125
02126
02127 QgsFeature f;
02128 if ( mDataProvider && mDataProvider->featureAtId( featureId, f, true ) )
02129 {
02130 if ( f.geometry() )
02131 {
02132 QgsGeometry translateGeom( *( f.geometry() ) );
02133 int errorCode = translateGeom.translate( dx, dy );
02134 if ( errorCode == 0 )
02135 {
02136 editGeometryChange( featureId, translateGeom );
02137 setModified( true, true );
02138 }
02139 return errorCode;
02140 }
02141 }
02142 return 1;
02143 }
02144
02145 int QgsVectorLayer::splitFeatures( const QList<QgsPoint>& splitLine, bool topologicalEditing )
02146 {
02147 if ( geometryType() == QGis::NoGeometry )
02148 return 4;
02149
02150 QgsFeatureList newFeatures;
02151 double xMin, yMin, xMax, yMax;
02152 QgsRectangle bBox;
02153 int returnCode = 0;
02154 int splitFunctionReturn;
02155 int numberOfSplitedFeatures = 0;
02156
02157 QgsFeatureList featureList;
02158 const QgsFeatureIds selectedIds = selectedFeaturesIds();
02159
02160 if ( selectedIds.size() > 0 )
02161 {
02162 featureList = selectedFeatures();
02163 }
02164 else
02165 {
02166 if ( boundingBoxFromPointList( splitLine, xMin, yMin, xMax, yMax ) == 0 )
02167 {
02168 bBox.setXMinimum( xMin ); bBox.setYMinimum( yMin );
02169 bBox.setXMaximum( xMax ); bBox.setYMaximum( yMax );
02170 }
02171 else
02172 {
02173 return 1;
02174 }
02175
02176 if ( bBox.isEmpty() )
02177 {
02178
02179 if ( bBox.width() == 0.0 && bBox.height() > 0 )
02180 {
02181 bBox.setXMinimum( bBox.xMinimum() - bBox.height() / 2 );
02182 bBox.setXMaximum( bBox.xMaximum() + bBox.height() / 2 );
02183 }
02184 else if ( bBox.height() == 0.0 && bBox.width() > 0 )
02185 {
02186 bBox.setYMinimum( bBox.yMinimum() - bBox.width() / 2 );
02187 bBox.setYMaximum( bBox.yMaximum() + bBox.width() / 2 );
02188 }
02189 else
02190 {
02191 return 2;
02192 }
02193 }
02194
02195 select( pendingAllAttributesList(), bBox, true, true );
02196
02197 QgsFeature f;
02198 while ( nextFeature( f ) )
02199 featureList << QgsFeature( f );
02200 }
02201
02202 QgsFeatureList::iterator select_it = featureList.begin();
02203 for ( ; select_it != featureList.end(); ++select_it )
02204 {
02205 QList<QgsGeometry*> newGeometries;
02206 QList<QgsPoint> topologyTestPoints;
02207 QgsGeometry* newGeometry = 0;
02208 splitFunctionReturn = select_it->geometry()->splitGeometry( splitLine, newGeometries, topologicalEditing, topologyTestPoints );
02209 if ( splitFunctionReturn == 0 )
02210 {
02211
02212 editGeometryChange( select_it->id(), *( select_it->geometry() ) );
02213
02214 mCachedGeometries[select_it->id()] = *( select_it->geometry() );
02215
02216
02217 for ( int i = 0; i < newGeometries.size(); ++i )
02218 {
02219 newGeometry = newGeometries.at( i );
02220 QgsFeature newFeature;
02221 newFeature.setGeometry( newGeometry );
02222 newFeature.setAttributeMap( select_it->attributeMap() );
02223 newFeatures.append( newFeature );
02224 }
02225
02226 setModified( true, true );
02227 if ( topologicalEditing )
02228 {
02229 QList<QgsPoint>::const_iterator topol_it = topologyTestPoints.constBegin();
02230 for ( ; topol_it != topologyTestPoints.constEnd(); ++topol_it )
02231 {
02232 addTopologicalPoints( *topol_it );
02233 }
02234 }
02235 ++numberOfSplitedFeatures;
02236 }
02237 else if ( splitFunctionReturn > 1 )
02238 {
02239 returnCode = 3;
02240 }
02241 }
02242
02243 if ( numberOfSplitedFeatures == 0 && selectedIds.size() > 0 )
02244 {
02245
02246
02247 returnCode = 4;
02248 }
02249
02250
02251
02252 addFeatures( newFeatures, false );
02253
02254 return returnCode;
02255 }
02256
02257 int QgsVectorLayer::removePolygonIntersections( QgsGeometry* geom )
02258 {
02259 if ( geometryType() == QGis::NoGeometry )
02260 return 1;
02261
02262 int returnValue = 0;
02263
02264
02265 if ( geom->type() != QGis::Polygon )
02266 {
02267 return 1;
02268 }
02269
02270
02271 QgsRectangle geomBBox = geom->boundingBox();
02272
02273
02274 select( QgsAttributeList(), geomBBox, true, true );
02275
02276 QgsFeature f;
02277 while ( nextFeature( f ) )
02278 {
02279
02280 QgsGeometry *currentGeom = f.geometry();
02281 if ( currentGeom )
02282 {
02283 if ( geom->makeDifference( currentGeom ) != 0 )
02284 {
02285 returnValue = 2;
02286 }
02287 }
02288 }
02289 return returnValue;
02290 }
02291
02292 int QgsVectorLayer::addTopologicalPoints( QgsGeometry* geom )
02293 {
02294 if ( geometryType() == QGis::NoGeometry )
02295 return 1;
02296
02297 if ( !geom )
02298 {
02299 return 1;
02300 }
02301
02302 int returnVal = 0;
02303
02304 QGis::WkbType wkbType = geom->wkbType();
02305
02306 switch ( wkbType )
02307 {
02308
02309 case QGis::WKBLineString25D:
02310 case QGis::WKBLineString:
02311 {
02312 QgsPolyline theLine = geom->asPolyline();
02313 QgsPolyline::const_iterator line_it = theLine.constBegin();
02314 for ( ; line_it != theLine.constEnd(); ++line_it )
02315 {
02316 if ( addTopologicalPoints( *line_it ) != 0 )
02317 {
02318 returnVal = 2;
02319 }
02320 }
02321 break;
02322 }
02323
02324
02325 case QGis::WKBMultiLineString25D:
02326 case QGis::WKBMultiLineString:
02327 {
02328 QgsMultiPolyline theMultiLine = geom->asMultiPolyline();
02329 QgsPolyline currentPolyline;
02330
02331 for ( int i = 0; i < theMultiLine.size(); ++i )
02332 {
02333 QgsPolyline::const_iterator line_it = currentPolyline.constBegin();
02334 for ( ; line_it != currentPolyline.constEnd(); ++line_it )
02335 {
02336 if ( addTopologicalPoints( *line_it ) != 0 )
02337 {
02338 returnVal = 2;
02339 }
02340 }
02341 }
02342 break;
02343 }
02344
02345
02346 case QGis::WKBPolygon25D:
02347 case QGis::WKBPolygon:
02348 {
02349 QgsPolygon thePolygon = geom->asPolygon();
02350 QgsPolyline currentRing;
02351
02352 for ( int i = 0; i < thePolygon.size(); ++i )
02353 {
02354 currentRing = thePolygon.at( i );
02355 QgsPolyline::const_iterator line_it = currentRing.constBegin();
02356 for ( ; line_it != currentRing.constEnd(); ++line_it )
02357 {
02358 if ( addTopologicalPoints( *line_it ) != 0 )
02359 {
02360 returnVal = 2;
02361 }
02362 }
02363 }
02364 break;
02365 }
02366
02367
02368 case QGis::WKBMultiPolygon25D:
02369 case QGis::WKBMultiPolygon:
02370 {
02371 QgsMultiPolygon theMultiPolygon = geom->asMultiPolygon();
02372 QgsPolygon currentPolygon;
02373 QgsPolyline currentRing;
02374
02375 for ( int i = 0; i < theMultiPolygon.size(); ++i )
02376 {
02377 currentPolygon = theMultiPolygon.at( i );
02378 for ( int j = 0; j < currentPolygon.size(); ++j )
02379 {
02380 currentRing = currentPolygon.at( j );
02381 QgsPolyline::const_iterator line_it = currentRing.constBegin();
02382 for ( ; line_it != currentRing.constEnd(); ++line_it )
02383 {
02384 if ( addTopologicalPoints( *line_it ) != 0 )
02385 {
02386 returnVal = 2;
02387 }
02388 }
02389 }
02390 }
02391 break;
02392 }
02393 default:
02394 break;
02395 }
02396 return returnVal;
02397 }
02398
02399 int QgsVectorLayer::addTopologicalPoints( const QgsPoint& p )
02400 {
02401 if ( geometryType() == QGis::NoGeometry )
02402 return 1;
02403
02404 QMultiMap<double, QgsSnappingResult> snapResults;
02405
02406 QMultiMap<double, QgsSnappingResult> vertexSnapResults;
02407
02408 QList<QgsSnappingResult> filteredSnapResults;
02409
02410
02411 double threshold = 0.0000001;
02412 if ( mCRS && mCRS->mapUnits() == QGis::Meters )
02413 {
02414 threshold = 0.001;
02415 }
02416 else if ( mCRS && mCRS->mapUnits() == QGis::Feet )
02417 {
02418 threshold = 0.0001;
02419 }
02420
02421
02422 if ( snapWithContext( p, threshold, snapResults, QgsSnapper::SnapToSegment ) != 0 )
02423 {
02424 return 2;
02425 }
02426
02427 QMultiMap<double, QgsSnappingResult>::const_iterator snap_it = snapResults.constBegin();
02428 QMultiMap<double, QgsSnappingResult>::const_iterator vertex_snap_it;
02429 for ( ; snap_it != snapResults.constEnd(); ++snap_it )
02430 {
02431
02432 bool vertexAlreadyExists = false;
02433 if ( snapWithContext( p, threshold, vertexSnapResults, QgsSnapper::SnapToVertex ) != 0 )
02434 {
02435 continue;
02436 }
02437
02438 vertex_snap_it = vertexSnapResults.constBegin();
02439 for ( ; vertex_snap_it != vertexSnapResults.constEnd(); ++vertex_snap_it )
02440 {
02441 if ( snap_it.value().snappedAtGeometry == vertex_snap_it.value().snappedAtGeometry )
02442 {
02443 vertexAlreadyExists = true;
02444 }
02445 }
02446
02447 if ( !vertexAlreadyExists )
02448 {
02449 filteredSnapResults.push_back( *snap_it );
02450 }
02451 }
02452 insertSegmentVerticesForSnap( filteredSnapResults );
02453 return 0;
02454 }
02455
02456 QgsLabel *QgsVectorLayer::label()
02457 {
02458 return mLabel;
02459 }
02460
02461 const QgsLabel *QgsVectorLayer::label() const
02462 {
02463 return mLabel;
02464 }
02465
02466 void QgsVectorLayer::enableLabels( bool on )
02467 {
02468 mLabelOn = on;
02469 }
02470
02471 bool QgsVectorLayer::hasLabelsEnabled( void ) const
02472 {
02473 return mLabelOn;
02474 }
02475
02476 bool QgsVectorLayer::startEditing()
02477 {
02478 if ( !mDataProvider )
02479 {
02480 return false;
02481 }
02482
02483
02484 if ( !( mDataProvider->capabilities() & QgsVectorDataProvider::EditingCapabilities ) )
02485 {
02486 return false;
02487 }
02488
02489 if ( mReadOnly )
02490 {
02491 return false;
02492 }
02493
02494 if ( mEditable )
02495 {
02496
02497 return false;
02498 }
02499
02500 mEditable = true;
02501
02502 mUpdatedFields = mDataProvider->fields();
02503
02504 mMaxUpdatedIndex = -1;
02505
02506 for ( QgsFieldMap::const_iterator it = mUpdatedFields.begin(); it != mUpdatedFields.end(); it++ )
02507 if ( it.key() > mMaxUpdatedIndex )
02508 mMaxUpdatedIndex = it.key();
02509
02510 emit editingStarted();
02511
02512 return true;
02513 }
02514
02515 bool QgsVectorLayer::readXml( QDomNode & layer_node )
02516 {
02517 QgsDebugMsg( QString( "Datasource in QgsVectorLayer::readXml: " ) + mDataSource.toLocal8Bit().data() );
02518
02519
02520 QDomNode pkeyNode = layer_node.namedItem( "provider" );
02521
02522 if ( pkeyNode.isNull() )
02523 {
02524 mProviderKey = "";
02525 }
02526 else
02527 {
02528 QDomElement pkeyElt = pkeyNode.toElement();
02529 mProviderKey = pkeyElt.text();
02530 }
02531
02532
02533 if ( ! mProviderKey.isNull() )
02534 {
02535
02536
02537 }
02538 else if ( mDataSource.contains( "dbname=" ) )
02539 {
02540 mProviderKey = "postgres";
02541 }
02542 else
02543 {
02544 mProviderKey = "ogr";
02545 }
02546
02547 if ( ! setDataProvider( mProviderKey ) )
02548 {
02549 return false;
02550 }
02551
02552 QDomElement pkeyElem = pkeyNode.toElement();
02553 if ( !pkeyElem.isNull() )
02554 {
02555 QString encodingString = pkeyElem.attribute( "encoding" );
02556 if ( !encodingString.isEmpty() )
02557 {
02558 mDataProvider->setEncoding( encodingString );
02559 }
02560 }
02561
02562 QString errorMsg;
02563 if ( geometryType() != QGis::NoGeometry )
02564 {
02565 if ( !readSymbology( layer_node, errorMsg ) )
02566 {
02567 return false;
02568 }
02569 }
02570
02571 return mValid;
02572
02573 }
02574
02575
02576
02577 bool QgsVectorLayer::setDataProvider( QString const & provider )
02578 {
02579
02580
02581
02582 mProviderKey = provider;
02583
02584
02585
02586
02587 mDataProvider =
02588 ( QgsVectorDataProvider* )( QgsProviderRegistry::instance()->getProvider( provider, mDataSource ) );
02589
02590 if ( mDataProvider )
02591 {
02592 QgsDebugMsg( "Instantiated the data provider plugin" );
02593
02594 mValid = mDataProvider->isValid();
02595 if ( mValid )
02596 {
02597
02598
02599 connect( mDataProvider, SIGNAL( fullExtentCalculated() ), this, SLOT( updateExtents() ) );
02600
02601
02602 QgsRectangle mbr = mDataProvider->extent();
02603
02604
02605 QString s = mbr.toString();
02606 QgsDebugMsg( "Extent of layer: " + s );
02607
02608 mLayerExtent.setXMaximum( mbr.xMaximum() );
02609 mLayerExtent.setXMinimum( mbr.xMinimum() );
02610 mLayerExtent.setYMaximum( mbr.yMaximum() );
02611 mLayerExtent.setYMinimum( mbr.yMinimum() );
02612
02613
02614 mWkbType = mDataProvider->geometryType();
02615
02616
02617
02618 setDisplayField();
02619
02620 if ( mProviderKey == "postgres" )
02621 {
02622 QgsDebugMsg( "Beautifying layer name " + name() );
02623
02624
02625 QRegExp reg( "\"[^\"]+\"\\.\"([^\"]+)\"( \\([^)]+\\))?" );
02626 if ( reg.indexIn( name() ) >= 0 )
02627 {
02628 QStringList stuff = reg.capturedTexts();
02629 QString lName = stuff[1];
02630
02631 const QMap<QString, QgsMapLayer*> &layers = QgsMapLayerRegistry::instance()->mapLayers();
02632
02633 QMap<QString, QgsMapLayer*>::const_iterator it;
02634 for ( it = layers.constBegin(); it != layers.constEnd() && ( *it )->name() != lName; it++ )
02635 ;
02636
02637 if ( it != layers.constEnd() && stuff.size() > 2 )
02638 {
02639 lName += "." + stuff[2].mid( 2, stuff[2].length() - 3 );
02640 }
02641
02642 if ( !lName.isEmpty() )
02643 setLayerName( lName );
02644 }
02645
02646 QgsDebugMsg( "Beautified layer name " + name() );
02647
02648
02649 mDataSource = mDataProvider->dataSourceUri();
02650 }
02651 else if ( mProviderKey == "osm" )
02652 {
02653
02654 mDataSource = mDataProvider->dataSourceUri();
02655 }
02656
02657
02658 mLabel = new QgsLabel( mDataProvider->fields() );
02659 mLabelOn = false;
02660 }
02661 else
02662 {
02663 QgsDebugMsg( "Invalid provider plugin " + QString( mDataSource.toUtf8() ) );
02664 return false;
02665 }
02666 }
02667 else
02668 {
02669 QgsDebugMsg( " unable to get data provider" );
02670
02671 return false;
02672 }
02673
02674 return true;
02675
02676 }
02677
02678
02679
02680
02681
02682 bool QgsVectorLayer::writeXml( QDomNode & layer_node,
02683 QDomDocument & document )
02684 {
02685
02686
02687 QDomElement mapLayerNode = layer_node.toElement();
02688
02689 if ( mapLayerNode.isNull() || ( "maplayer" != mapLayerNode.nodeName() ) )
02690 {
02691 QgsDebugMsg( "can't find <maplayer>" );
02692 return false;
02693 }
02694
02695 mapLayerNode.setAttribute( "type", "vector" );
02696
02697
02698 mapLayerNode.setAttribute( "geometry", QGis::qgisVectorGeometryType[geometryType()] );
02699
02700
02701 if ( mDataProvider )
02702 {
02703 QDomElement provider = document.createElement( "provider" );
02704 provider.setAttribute( "encoding", mDataProvider->encoding() );
02705 QDomText providerText = document.createTextNode( providerType() );
02706 provider.appendChild( providerText );
02707 layer_node.appendChild( provider );
02708 }
02709
02710
02711 QString errorMsg;
02712 return writeSymbology( layer_node, document, errorMsg );
02713 }
02714
02715 bool QgsVectorLayer::readSymbology( const QDomNode& node, QString& errorMessage )
02716 {
02717 if ( geometryType() != QGis::NoGeometry )
02718 {
02719
02720 QDomElement rendererElement = node.firstChildElement( RENDERER_TAG_NAME );
02721 if ( !rendererElement.isNull() )
02722 {
02723
02724 setUsingRendererV2( true );
02725
02726 QgsFeatureRendererV2* r = QgsFeatureRendererV2::load( rendererElement );
02727 if ( r == NULL )
02728 return false;
02729
02730 setRendererV2( r );
02731 }
02732 else
02733 {
02734
02735 setUsingRendererV2( false );
02736
02737
02738
02739 QDomNode singlenode = node.namedItem( "singlesymbol" );
02740 QDomNode graduatednode = node.namedItem( "graduatedsymbol" );
02741 QDomNode continuousnode = node.namedItem( "continuoussymbol" );
02742 QDomNode uniquevaluenode = node.namedItem( "uniquevalue" );
02743
02744 QgsRenderer * renderer = 0;
02745 int returnCode = 1;
02746
02747 if ( !singlenode.isNull() )
02748 {
02749 renderer = new QgsSingleSymbolRenderer( geometryType() );
02750 returnCode = renderer->readXML( singlenode, *this );
02751 }
02752 else if ( !graduatednode.isNull() )
02753 {
02754 renderer = new QgsGraduatedSymbolRenderer( geometryType() );
02755 returnCode = renderer->readXML( graduatednode, *this );
02756 }
02757 else if ( !continuousnode.isNull() )
02758 {
02759 renderer = new QgsContinuousColorRenderer( geometryType() );
02760 returnCode = renderer->readXML( continuousnode, *this );
02761 }
02762 else if ( !uniquevaluenode.isNull() )
02763 {
02764 renderer = new QgsUniqueValueRenderer( geometryType() );
02765 returnCode = renderer->readXML( uniquevaluenode, *this );
02766 }
02767
02768 if ( !renderer )
02769 {
02770 errorMessage = tr( "Unknown renderer" );
02771 return false;
02772 }
02773
02774 if ( returnCode == 1 )
02775 {
02776 errorMessage = tr( "No renderer object" ); delete renderer; return false;
02777 }
02778 else if ( returnCode == 2 )
02779 {
02780 errorMessage = tr( "Classification field not found" ); delete renderer; return false;
02781 }
02782
02783 mRenderer = renderer;
02784 }
02785
02786
02787 QDomNode displayFieldNode = node.namedItem( "displayfield" );
02788 if ( !displayFieldNode.isNull() )
02789 {
02790 QDomElement e = displayFieldNode.toElement();
02791 setDisplayField( e.text() );
02792 }
02793
02794
02795 QDomElement e = node.toElement();
02796 mLabel->setScaleBasedVisibility( e.attribute( "scaleBasedLabelVisibilityFlag", "0" ) == "1" );
02797 mLabel->setMinScale( e.attribute( "minLabelScale", "1" ).toFloat() );
02798 mLabel->setMaxScale( e.attribute( "maxLabelScale", "100000000" ).toFloat() );
02799
02800
02801 QDomNode labelnode = node.namedItem( "label" );
02802 QDomElement element = labelnode.toElement();
02803 int hasLabelsEnabled = element.text().toInt();
02804 if ( hasLabelsEnabled < 1 )
02805 {
02806 enableLabels( false );
02807 }
02808 else
02809 {
02810 enableLabels( true );
02811 }
02812
02813 QDomNode labelattributesnode = node.namedItem( "labelattributes" );
02814
02815 if ( !labelattributesnode.isNull() )
02816 {
02817 QgsDebugMsg( "calling readXML" );
02818 mLabel->readXML( labelattributesnode );
02819 }
02820 }
02821
02822
02823 mActions->readXML( node );
02824
02825 mEditTypes.clear();
02826 QDomNode editTypesNode = node.namedItem( "edittypes" );
02827 if ( !editTypesNode.isNull() )
02828 {
02829 QDomNodeList editTypeNodes = editTypesNode.childNodes();
02830
02831 for ( int i = 0; i < editTypeNodes.size(); i++ )
02832 {
02833 QDomNode editTypeNode = editTypeNodes.at( i );
02834 QDomElement editTypeElement = editTypeNode.toElement();
02835
02836 QString name = editTypeElement.attribute( "name" );
02837
02838 EditType editType = ( EditType ) editTypeElement.attribute( "type" ).toInt();
02839 mEditTypes.insert( name, editType );
02840
02841 if ( editType == ValueMap && editTypeNode.hasChildNodes() )
02842 {
02843 mValueMaps.insert( name, QMap<QString, QVariant>() );
02844
02845 QDomNodeList valueMapNodes = editTypeNode.childNodes();
02846 for ( int j = 0; j < valueMapNodes.size(); j++ )
02847 {
02848 QDomElement value = valueMapNodes.at( j ).toElement();
02849 mValueMaps[ name ].insert( value.attribute( "key" ), value.attribute( "value" ) );
02850 }
02851 }
02852 else if ( editType == EditRange || editType == SliderRange )
02853 {
02854 QVariant min = editTypeElement.attribute( "min" );
02855 QVariant max = editTypeElement.attribute( "max" );
02856 QVariant step = editTypeElement.attribute( "step" );
02857
02858 mRanges[ name ] = RangeData( min, max, step );
02859 }
02860 else if ( editType == CheckBox )
02861 {
02862 mCheckedStates[ name ] = QPair<QString, QString>( editTypeElement.attribute( "checked" ), editTypeElement.attribute( "unchecked" ) );
02863 }
02864 }
02865 }
02866
02867 QDomNode editFormNode = node.namedItem( "editform" );
02868 if ( !editFormNode.isNull() )
02869 {
02870 QDomElement e = editFormNode.toElement();
02871 mEditForm = QgsProject::instance()->readPath( e.text() );
02872 }
02873
02874 QDomNode editFormInitNode = node.namedItem( "editforminit" );
02875 if ( !editFormInitNode.isNull() )
02876 {
02877 mEditFormInit = editFormInitNode.toElement().text();
02878 }
02879
02880 QDomNode annotationFormNode = node.namedItem( "annotationform" );
02881 if ( !annotationFormNode.isNull() )
02882 {
02883 QDomElement e = annotationFormNode.toElement();
02884 mAnnotationForm = QgsProject::instance()->readPath( e.text() );
02885 }
02886
02887 mAttributeAliasMap.clear();
02888 QDomNode aliasesNode = node.namedItem( "aliases" );
02889 if ( !aliasesNode.isNull() )
02890 {
02891 QDomElement aliasElem;
02892 int index;
02893 QString name;
02894
02895 QDomNodeList aliasNodeList = aliasesNode.toElement().elementsByTagName( "alias" );
02896 for ( int i = 0; i < aliasNodeList.size(); ++i )
02897 {
02898 aliasElem = aliasNodeList.at( i ).toElement();
02899 index = aliasElem.attribute( "index" ).toInt();
02900 name = aliasElem.attribute( "name" );
02901 mAttributeAliasMap.insert( index, name );
02902 }
02903 }
02904
02905 return true;
02906 }
02907
02908 bool QgsVectorLayer::writeSymbology( QDomNode& node, QDomDocument& doc, QString& errorMessage ) const
02909 {
02910 QDomElement mapLayerNode = node.toElement();
02911
02912 if ( geometryType() != QGis::NoGeometry )
02913 {
02914 if ( mUsingRendererV2 )
02915 {
02916 QDomElement rendererElement = mRendererV2->save( doc );
02917 node.appendChild( rendererElement );
02918 }
02919 else
02920 {
02921
02922 mapLayerNode.setAttribute( "scaleBasedLabelVisibilityFlag", mLabel->scaleBasedVisibility() ? 1 : 0 );
02923 mapLayerNode.setAttribute( "minLabelScale", mLabel->minScale() );
02924 mapLayerNode.setAttribute( "maxLabelScale", mLabel->maxScale() );
02925
02926
02927 QgsAttributeList attributes = mRenderer->classificationAttributes();
02928 const QgsFieldMap providerFields = mDataProvider->fields();
02929 for ( QgsAttributeList::const_iterator it = attributes.begin(); it != attributes.end(); ++it )
02930 {
02931 QDomElement classificationElement = doc.createElement( "classificationattribute" );
02932 QDomText classificationText = doc.createTextNode( providerFields[*it].name() );
02933 classificationElement.appendChild( classificationText );
02934 node.appendChild( classificationElement );
02935 }
02936
02937
02938 const QgsRenderer * myRenderer = renderer();
02939 if ( myRenderer )
02940 {
02941 if ( !myRenderer->writeXML( node, doc, *this ) )
02942 {
02943 errorMessage = tr( "renderer failed to save" );
02944 return false;
02945 }
02946 }
02947 else
02948 {
02949 QgsDebugMsg( "no renderer" );
02950 errorMessage = tr( "no renderer" );
02951 return false;
02952 }
02953 }
02954
02955
02956 QDomElement dField = doc.createElement( "displayfield" );
02957 QDomText dFieldText = doc.createTextNode( displayField() );
02958 dField.appendChild( dFieldText );
02959 node.appendChild( dField );
02960
02961
02962 QDomElement labelElem = doc.createElement( "label" );
02963 QDomText labelText = doc.createTextNode( "" );
02964
02965 if ( hasLabelsEnabled() )
02966 {
02967 labelText.setData( "1" );
02968 }
02969 else
02970 {
02971 labelText.setData( "0" );
02972 }
02973 labelElem.appendChild( labelText );
02974
02975 node.appendChild( labelElem );
02976
02977
02978
02979 QString fieldname = mLabel->labelField( QgsLabel::Text );
02980 if ( fieldname != "" )
02981 {
02982 dField = doc.createElement( "labelfield" );
02983 dFieldText = doc.createTextNode( fieldname );
02984 dField.appendChild( dFieldText );
02985 node.appendChild( dField );
02986 }
02987
02988 mLabel->writeXML( node, doc );
02989 }
02990
02991
02992 if ( mEditTypes.size() > 0 )
02993 {
02994 QDomElement editTypesElement = doc.createElement( "edittypes" );
02995
02996 for ( QMap<QString, EditType>::const_iterator it = mEditTypes.begin(); it != mEditTypes.end(); ++it )
02997 {
02998 QDomElement editTypeElement = doc.createElement( "edittype" );
02999 editTypeElement.setAttribute( "name", it.key() );
03000 editTypeElement.setAttribute( "type", it.value() );
03001
03002 if ( it.value() == ValueMap )
03003 {
03004 if ( mValueMaps.contains( it.key() ) )
03005 {
03006 const QMap<QString, QVariant> &map = mValueMaps[ it.key()];
03007
03008 for ( QMap<QString, QVariant>::const_iterator vmit = map.begin(); vmit != map.end(); vmit++ )
03009 {
03010 QDomElement value = doc.createElement( "valuepair" );
03011 value.setAttribute( "key", vmit.key() );
03012 value.setAttribute( "value", vmit.value().toString() );
03013 editTypeElement.appendChild( value );
03014 }
03015 }
03016 }
03017 else if ( it.value() == EditRange || it.value() == SliderRange )
03018 {
03019 if ( mRanges.contains( it.key() ) )
03020 {
03021 editTypeElement.setAttribute( "min", mRanges[ it.key()].mMin.toString() );
03022 editTypeElement.setAttribute( "max", mRanges[ it.key()].mMax.toString() );
03023 editTypeElement.setAttribute( "step", mRanges[ it.key()].mStep.toString() );
03024 }
03025 }
03026 else if ( it.value() == CheckBox )
03027 {
03028 if ( mCheckedStates.contains( it.key() ) )
03029 {
03030 editTypeElement.setAttribute( "checked", mCheckedStates[ it.key()].first );
03031 editTypeElement.setAttribute( "unchecked", mCheckedStates[ it.key()].second );
03032 }
03033 }
03034
03035 editTypesElement.appendChild( editTypeElement );
03036 }
03037
03038 node.appendChild( editTypesElement );
03039 }
03040
03041 QDomElement efField = doc.createElement( "editform" );
03042 QDomText efText = doc.createTextNode( QgsProject::instance()->writePath( mEditForm ) );
03043 efField.appendChild( efText );
03044 node.appendChild( efField );
03045
03046 QDomElement efiField = doc.createElement( "editforminit" );
03047 QDomText efiText = doc.createTextNode( mEditFormInit );
03048 efiField.appendChild( efiText );
03049 node.appendChild( efiField );
03050
03051 QDomElement afField = doc.createElement( "annotationform" );
03052 QDomText afText = doc.createTextNode( QgsProject::instance()->writePath( mAnnotationForm ) );
03053 afField.appendChild( afText );
03054 node.appendChild( afField );
03055
03056
03057 if ( mAttributeAliasMap.size() > 0 )
03058 {
03059 QDomElement aliasElem = doc.createElement( "aliases" );
03060 QMap<int, QString>::const_iterator a_it = mAttributeAliasMap.constBegin();
03061 for ( ; a_it != mAttributeAliasMap.constEnd(); ++a_it )
03062 {
03063 QDomElement aliasEntryElem = doc.createElement( "alias" );
03064 aliasEntryElem.setAttribute( "index", QString::number( a_it.key() ) );
03065 aliasEntryElem.setAttribute( "name", a_it.value() );
03066 aliasElem.appendChild( aliasEntryElem );
03067 }
03068 node.appendChild( aliasElem );
03069 }
03070
03071
03072 mActions->writeXML( node, doc );
03073
03074
03075 QList<QgsVectorOverlay*>::const_iterator overlay_it = mOverlays.constBegin();
03076 for ( ; overlay_it != mOverlays.constEnd(); ++overlay_it )
03077 {
03078 if ( *overlay_it )
03079 {
03080 ( *overlay_it )->writeXML( mapLayerNode, doc );
03081 }
03082 }
03083
03084 return true;
03085 }
03086
03087
03088 bool QgsVectorLayer::changeGeometry( int fid, QgsGeometry* geom )
03089 {
03090 if ( !mEditable || !mDataProvider || geometryType() == QGis::NoGeometry )
03091 {
03092 return false;
03093 }
03094
03095 editGeometryChange( fid, *geom );
03096 mCachedGeometries[fid] = *geom;
03097 setModified( true, true );
03098 return true;
03099 }
03100
03101
03102 bool QgsVectorLayer::changeAttributeValue( int fid, int field, QVariant value, bool emitSignal )
03103 {
03104 if ( !isEditable() )
03105 return false;
03106
03107 editAttributeChange( fid, field, value );
03108 setModified( true, false );
03109
03110 if ( emitSignal )
03111 emit attributeValueChanged( fid, field, value );
03112
03113 return true;
03114 }
03115
03116 bool QgsVectorLayer::addAttribute( const QgsField &field )
03117 {
03118 if ( !isEditable() )
03119 return false;
03120
03121 for ( QgsFieldMap::const_iterator it = mUpdatedFields.begin(); it != mUpdatedFields.end(); it++ )
03122 {
03123 if ( it.value().name() == field.name() )
03124 return false;
03125 }
03126
03127 if ( !mDataProvider->supportedType( field ) )
03128 return false;
03129
03130 mMaxUpdatedIndex++;
03131
03132 if ( mActiveCommand != NULL )
03133 {
03134 mActiveCommand->storeAttributeAdd( mMaxUpdatedIndex, field );
03135 }
03136
03137 mUpdatedFields.insert( mMaxUpdatedIndex, field );
03138 mAddedAttributeIds.insert( mMaxUpdatedIndex );
03139
03140 setModified( true, false );
03141
03142 emit attributeAdded( mMaxUpdatedIndex );
03143
03144 return true;
03145 }
03146
03147 bool QgsVectorLayer::addAttribute( QString name, QString type )
03148 {
03149 const QMap<QString, QVariant::Type> &map = mDataProvider->supportedNativeTypes();
03150
03151 if ( !map.contains( type ) )
03152 return false;
03153
03154 return addAttribute( QgsField( name, map[ type ], type ) );
03155 }
03156
03157 void QgsVectorLayer::addAttributeAlias( int attIndex, QString aliasString )
03158 {
03159 mAttributeAliasMap.insert( attIndex, aliasString );
03160 emit layerModified( false );
03161 }
03162
03163 QString QgsVectorLayer::attributeAlias( int attributeIndex ) const
03164 {
03165 QMap<int, QString>::const_iterator alias_it = mAttributeAliasMap.find( attributeIndex );
03166 if ( alias_it != mAttributeAliasMap.constEnd() )
03167 {
03168 return alias_it.value();
03169 }
03170 else
03171 {
03172 return QString();
03173 }
03174 }
03175
03176 QString QgsVectorLayer::attributeDisplayName( int attributeIndex ) const
03177 {
03178 QString displayName = attributeAlias( attributeIndex );
03179 if ( displayName.isEmpty() )
03180 {
03181 const QgsFieldMap& fields = pendingFields();
03182 QgsFieldMap::const_iterator fieldIt = fields.find( attributeIndex );
03183 if ( fieldIt != fields.constEnd() )
03184 {
03185 displayName = fieldIt->name();
03186 }
03187 }
03188 return displayName;
03189 }
03190
03191 bool QgsVectorLayer::deleteAttribute( int index )
03192 {
03193 if ( !isEditable() )
03194 return false;
03195
03196 if ( mDeletedAttributeIds.contains( index ) )
03197 return false;
03198
03199 if ( !mAddedAttributeIds.contains( index ) &&
03200 !mDataProvider->fields().contains( index ) )
03201 return false;
03202
03203 if ( mActiveCommand != NULL )
03204 {
03205 mActiveCommand->storeAttributeDelete( index, mUpdatedFields[index] );
03206 }
03207
03208 mDeletedAttributeIds.insert( index );
03209 mAddedAttributeIds.remove( index );
03210 mUpdatedFields.remove( index );
03211 mAttributeAliasMap.remove( index );
03212
03213 setModified( true, false );
03214
03215 emit attributeDeleted( index );
03216
03217 return true;
03218 }
03219
03220 bool QgsVectorLayer::deleteFeature( int fid )
03221 {
03222 if ( !isEditable() )
03223 return false;
03224
03225 if ( mDeletedFeatureIds.contains( fid ) )
03226 return true;
03227
03228 mSelectedFeatureIds.remove( fid );
03229 editFeatureDelete( fid );
03230
03231 setModified( true, false );
03232
03233 emit featureDeleted( fid );
03234
03235 return true;
03236 }
03237
03238 const QgsFieldMap &QgsVectorLayer::pendingFields() const
03239 {
03240 return isEditable() ? mUpdatedFields : mDataProvider->fields();
03241 }
03242
03243 QgsAttributeList QgsVectorLayer::pendingAllAttributesList()
03244 {
03245 return isEditable() ? mUpdatedFields.keys() : mDataProvider->attributeIndexes();
03246 }
03247
03248 int QgsVectorLayer::pendingFeatureCount()
03249 {
03250 return mDataProvider->featureCount()
03251 + mAddedFeatures.size()
03252 - mDeletedFeatureIds.size();
03253 }
03254
03255 bool QgsVectorLayer::commitChanges()
03256 {
03257 bool success = true;
03258
03259
03260 setCacheImage( 0 );
03261
03262 mCommitErrors.clear();
03263
03264 if ( !mDataProvider )
03265 {
03266 mCommitErrors << tr( "ERROR: no provider" );
03267 return false;
03268 }
03269
03270 if ( !isEditable() )
03271 {
03272 mCommitErrors << tr( "ERROR: layer not editable" );
03273 return false;
03274 }
03275
03276 int cap = mDataProvider->capabilities();
03277
03278
03279
03280
03281 bool attributesChanged = false;
03282 if ( mDeletedAttributeIds.size() > 0 )
03283 {
03284 if (( cap & QgsVectorDataProvider::DeleteAttributes ) && mDataProvider->deleteAttributes( mDeletedAttributeIds ) )
03285 {
03286 mCommitErrors << tr( "SUCCESS: %n attribute(s) deleted.", "deleted attributes count", mDeletedAttributeIds.size() );
03287
03288 emit committedAttributesDeleted( getLayerID(), mDeletedAttributeIds );
03289
03290 mDeletedAttributeIds.clear();
03291 attributesChanged = true;
03292 }
03293 else
03294 {
03295 mCommitErrors << tr( "ERROR: %n attribute(s) not deleted.", "not deleted attributes count", mDeletedAttributeIds.size() );
03296 success = false;
03297 }
03298 }
03299
03300
03301
03302
03303 if ( mAddedAttributeIds.size() > 0 )
03304 {
03305 QList<QgsField> addedAttributes;
03306 for ( QgsAttributeIds::const_iterator it = mAddedAttributeIds.begin(); it != mAddedAttributeIds.end(); it++ )
03307 addedAttributes << mUpdatedFields[ *it ];
03308
03309 if (( cap & QgsVectorDataProvider::AddAttributes ) && mDataProvider->addAttributes( addedAttributes ) )
03310 {
03311 mCommitErrors << tr( "SUCCESS: %n attribute(s) added.", "added attributes count", mAddedAttributeIds.size() );
03312
03313 emit committedAttributesAdded( getLayerID(), addedAttributes );
03314
03315 mAddedAttributeIds.clear();
03316 attributesChanged = true;
03317 }
03318 else
03319 {
03320 mCommitErrors << tr( "ERROR: %n new attribute(s) not added", "not added attributes count", mAddedAttributeIds.size() );
03321 success = false;
03322 }
03323 }
03324
03325
03326
03327
03328 bool attributeChangesOk = true;
03329 if ( attributesChanged )
03330 {
03331
03332 QMap<int, QString> src;
03333 for ( QgsFieldMap::const_iterator it = mUpdatedFields.begin(); it != mUpdatedFields.end(); it++ )
03334 {
03335 src[ it.key()] = it.value().name();
03336 }
03337
03338 int maxAttrIdx = -1;
03339 const QgsFieldMap &pFields = mDataProvider->fields();
03340
03341
03342 QMap<QString, int> dst;
03343 for ( QgsFieldMap::const_iterator it = pFields.begin(); it != pFields.end(); it++ )
03344 {
03345 dst[ it.value().name()] = it.key();
03346 if ( it.key() > maxAttrIdx )
03347 maxAttrIdx = it.key();
03348 }
03349
03350
03351
03352 if ( mAddedAttributeIds.size() > 0 )
03353 {
03354 for ( QgsAttributeIds::const_iterator it = mAddedAttributeIds.begin(); it != mAddedAttributeIds.end(); it++ )
03355 {
03356 QString name = mUpdatedFields[ *it ].name();
03357 if ( dst.contains( name ) )
03358 {
03359
03360 mAddedAttributeIds.remove( *it );
03361 mCommitErrors << tr( "SUCCESS: attribute %1 was added." ).arg( name );
03362 }
03363 else
03364 {
03365
03366 dst[ name ] = ++maxAttrIdx;
03367 attributeChangesOk = false;
03368 mCommitErrors << tr( "ERROR: attribute %1 not added" ).arg( name );
03369 }
03370 }
03371 }
03372
03373
03374 QMap<int, int> remap;
03375 for ( QMap<int, QString>::const_iterator it = src.begin(); it != src.end(); it++ )
03376 {
03377 if ( dst.contains( it.value() ) )
03378 {
03379 remap[ it.key()] = dst[ it.value()];
03380 }
03381 }
03382
03383
03384 for ( QgsChangedAttributesMap::iterator fit = mChangedAttributeValues.begin(); fit != mChangedAttributeValues.end(); fit++ )
03385 {
03386 QgsAttributeMap &src = fit.value();
03387 QgsAttributeMap dst;
03388
03389 for ( QgsAttributeMap::const_iterator it = src.begin(); it != src.end(); it++ )
03390 {
03391 if ( remap.contains( it.key() ) )
03392 {
03393 dst[ remap[it.key()] ] = it.value();
03394 }
03395 }
03396 src = dst;
03397 }
03398
03399
03400 for ( QgsFeatureList::iterator fit = mAddedFeatures.begin(); fit != mAddedFeatures.end(); fit++ )
03401 {
03402 const QgsAttributeMap &src = fit->attributeMap();
03403 QgsAttributeMap dst;
03404
03405 for ( QgsAttributeMap::const_iterator it = src.begin(); it != src.end(); it++ )
03406 if ( remap.contains( it.key() ) )
03407 dst[ remap[it.key()] ] = it.value();
03408
03409 fit->setAttributeMap( dst );
03410 }
03411
03412 QgsFieldMap attributes;
03413
03414
03415 for ( QMap<int, int>::iterator it = remap.begin(); it != remap.end(); it++ )
03416 attributes[ it.value()] = mUpdatedFields[ it.key()];
03417
03418 mUpdatedFields = attributes;
03419 }
03420
03421 if ( attributeChangesOk )
03422 {
03423
03424
03425
03426 if ( mChangedAttributeValues.size() > 0 )
03427 {
03428 if (( cap & QgsVectorDataProvider::ChangeAttributeValues ) && mDataProvider->changeAttributeValues( mChangedAttributeValues ) )
03429 {
03430 mCommitErrors << tr( "SUCCESS: %n attribute value(s) changed.", "changed attribute values count", mChangedAttributeValues.size() );
03431
03432 emit committedAttributeValuesChanges( getLayerID(), mChangedAttributeValues );
03433
03434 mChangedAttributeValues.clear();
03435 }
03436 else
03437 {
03438 mCommitErrors << tr( "ERROR: %n attribute value change(s) not applied.", "not changed attribute values count", mChangedAttributeValues.size() );
03439 success = false;
03440 }
03441 }
03442
03443
03444
03445
03446 if ( mAddedFeatures.size() > 0 )
03447 {
03448 for ( int i = 0; i < mAddedFeatures.size(); i++ )
03449 {
03450 QgsFeature &f = mAddedFeatures[i];
03451
03452 if ( mDeletedFeatureIds.contains( f.id() ) )
03453 {
03454 mDeletedFeatureIds.remove( f.id() );
03455
03456 if ( mChangedGeometries.contains( f.id() ) )
03457 mChangedGeometries.remove( f.id() );
03458
03459 mAddedFeatures.removeAt( i-- );
03460 continue;
03461 }
03462
03463 if ( mChangedGeometries.contains( f.id() ) )
03464 {
03465 f.setGeometry( mChangedGeometries.take( f.id() ) );
03466 }
03467 }
03468
03469 if (( cap & QgsVectorDataProvider::AddFeatures ) && mDataProvider->addFeatures( mAddedFeatures ) )
03470 {
03471 mCommitErrors << tr( "SUCCESS: %n feature(s) added.", "added features count", mAddedFeatures.size() );
03472
03473 emit committedFeaturesAdded( getLayerID(), mAddedFeatures );
03474
03475 mAddedFeatures.clear();
03476 }
03477 else
03478 {
03479 mCommitErrors << tr( "ERROR: %n feature(s) not added.", "not added features count", mAddedFeatures.size() );
03480 success = false;
03481 }
03482 }
03483 }
03484
03485
03486
03487
03488 if ( mChangedGeometries.size() > 0 )
03489 {
03490 if (( cap & QgsVectorDataProvider::ChangeGeometries ) && mDataProvider->changeGeometryValues( mChangedGeometries ) )
03491 {
03492 mCommitErrors << tr( "SUCCESS: %n geometries were changed.", "changed geometries count", mChangedGeometries.size() );
03493
03494 emit committedGeometriesChanges( getLayerID(), mChangedGeometries );
03495
03496 mChangedGeometries.clear();
03497 }
03498 else
03499 {
03500 mCommitErrors << tr( "ERROR: %n geometries not changed.", "not changed geometries count", mChangedGeometries.size() );
03501 success = false;
03502 }
03503 }
03504
03505
03506
03507
03508 if ( mDeletedFeatureIds.size() > 0 )
03509 {
03510 if (( cap & QgsVectorDataProvider::DeleteFeatures ) && mDataProvider->deleteFeatures( mDeletedFeatureIds ) )
03511 {
03512 mCommitErrors << tr( "SUCCESS: %n feature(s) deleted.", "deleted features count", mDeletedFeatureIds.size() );
03513 for ( QgsFeatureIds::const_iterator it = mDeletedFeatureIds.begin(); it != mDeletedFeatureIds.end(); it++ )
03514 {
03515 mChangedAttributeValues.remove( *it );
03516 mChangedGeometries.remove( *it );
03517 }
03518
03519 emit committedFeaturesRemoved( getLayerID(), mDeletedFeatureIds );
03520
03521 mDeletedFeatureIds.clear();
03522 }
03523 else
03524 {
03525 mCommitErrors << tr( "ERROR: %n feature(s) not deleted.", "not deleted features count", mDeletedFeatureIds.size() );
03526 success = false;
03527 }
03528 }
03529
03530 deleteCachedGeometries();
03531
03532 if ( success )
03533 {
03534 mEditable = false;
03535 setModified( false );
03536
03537 mUpdatedFields.clear();
03538 mMaxUpdatedIndex = -1;
03539 undoStack()->clear();
03540 emit editingStopped();
03541 }
03542
03543 mDataProvider->updateExtents();
03544
03545 triggerRepaint();
03546
03547 QgsDebugMsg( "result:\n " + mCommitErrors.join( "\n " ) );
03548
03549 return success;
03550 }
03551
03552 const QStringList &QgsVectorLayer::commitErrors()
03553 {
03554 return mCommitErrors;
03555 }
03556
03557 bool QgsVectorLayer::rollBack()
03558 {
03559 if ( !isEditable() )
03560 {
03561 return false;
03562 }
03563
03564 if ( isModified() )
03565 {
03566 while ( mAddedAttributeIds.size() > 0 )
03567 {
03568 int idx = *mAddedAttributeIds.begin();
03569 mAddedAttributeIds.remove( idx );
03570 mUpdatedFields.remove( idx );
03571 emit attributeDeleted( idx );
03572 }
03573
03574 while ( mDeletedAttributeIds.size() > 0 )
03575 {
03576 int idx = *mDeletedAttributeIds.begin();
03577 mDeletedAttributeIds.remove( idx );
03578 emit attributeAdded( idx );
03579 }
03580
03581
03582 mChangedAttributeValues.clear();
03583
03584
03585 mChangedGeometries.clear();
03586
03587
03588
03589 mAddedFeatures.clear();
03590
03591
03592 mDeletedFeatureIds.clear();
03593
03594
03595 mUpdatedFields.clear();
03596 mMaxUpdatedIndex = -1;
03597 }
03598
03599 deleteCachedGeometries();
03600
03601 undoStack()->clear();
03602
03603 mEditable = false;
03604 emit editingStopped();
03605
03606 setModified( false );
03607
03608
03609 setCacheImage( 0 );
03610 triggerRepaint();
03611
03612 return true;
03613 }
03614
03615 void QgsVectorLayer::setSelectedFeatures( const QgsFeatureIds& ids )
03616 {
03617
03618 mSelectedFeatureIds = ids;
03619
03620
03621 setCacheImage( 0 );
03622
03623 emit selectionChanged();
03624 }
03625
03626 int QgsVectorLayer::selectedFeatureCount()
03627 {
03628 return mSelectedFeatureIds.size();
03629 }
03630
03631 const QgsFeatureIds& QgsVectorLayer::selectedFeaturesIds() const
03632 {
03633 return mSelectedFeatureIds;
03634 }
03635
03636
03637 QgsFeatureList QgsVectorLayer::selectedFeatures()
03638 {
03639 if ( !mDataProvider )
03640 {
03641 return QgsFeatureList();
03642 }
03643
03644 QgsFeatureList features;
03645
03646 QgsAttributeList allAttrs = mDataProvider->attributeIndexes();
03647
03648 for ( QgsFeatureIds::iterator it = mSelectedFeatureIds.begin(); it != mSelectedFeatureIds.end(); ++it )
03649 {
03650 QgsFeature feat;
03651
03652 bool selectionIsAddedFeature = false;
03653
03654
03655 for ( QgsFeatureList::iterator iter = mAddedFeatures.begin(); iter != mAddedFeatures.end(); ++iter )
03656 {
03657 if ( *it == iter->id() )
03658 {
03659 feat = QgsFeature( *iter );
03660 selectionIsAddedFeature = true;
03661 break;
03662 }
03663 }
03664
03665
03666 if ( !selectionIsAddedFeature )
03667 {
03668 mDataProvider->featureAtId( *it, feat, true, allAttrs );
03669 }
03670
03671 updateFeatureAttributes( feat );
03672 updateFeatureGeometry( feat );
03673
03674 features << feat;
03675 }
03676
03677 return features;
03678 }
03679
03680 bool QgsVectorLayer::addFeatures( QgsFeatureList features, bool makeSelected )
03681 {
03682 if ( !mDataProvider )
03683 {
03684 return false;
03685 }
03686
03687 if ( !( mDataProvider->capabilities() & QgsVectorDataProvider::AddFeatures ) )
03688 {
03689 return false;
03690 }
03691
03692 if ( !isEditable() )
03693 {
03694 return false;
03695 }
03696
03697 if ( makeSelected )
03698 {
03699 mSelectedFeatureIds.clear();
03700 }
03701
03702 for ( QgsFeatureList::iterator iter = features.begin(); iter != features.end(); ++iter )
03703 {
03704 addFeature( *iter );
03705
03706 if ( makeSelected )
03707 {
03708 mSelectedFeatureIds.insert( iter->id() );
03709 }
03710 }
03711
03712 updateExtents();
03713
03714 if ( makeSelected )
03715 {
03716
03717 setCacheImage( 0 );
03718
03719 emit selectionChanged();
03720 }
03721
03722 return true;
03723 }
03724
03725
03726 bool QgsVectorLayer::copySymbologySettings( const QgsMapLayer& other )
03727 {
03728 if ( geometryType() == QGis::NoGeometry )
03729 return false;
03730
03731 const QgsVectorLayer* vl = qobject_cast<const QgsVectorLayer *>( &other );
03732
03733
03734 if ( this == vl )
03735 {
03736 return false;
03737 }
03738
03739 if ( !vl )
03740 {
03741 return false;
03742 }
03743 delete mRenderer;
03744
03745 QgsRenderer* r = vl->mRenderer;
03746 if ( r )
03747 {
03748 mRenderer = r->clone();
03749 return true;
03750 }
03751 else
03752 {
03753 return false;
03754 }
03755 }
03756
03757 bool QgsVectorLayer::hasCompatibleSymbology( const QgsMapLayer& other ) const
03758 {
03759
03760
03761 const QgsVectorLayer* otherVectorLayer = qobject_cast<const QgsVectorLayer *>( &other );
03762 if ( otherVectorLayer )
03763 {
03764 if ( otherVectorLayer->type() != type() )
03765 {
03766 return false;
03767 }
03768
03769 const QgsFieldMap& fieldsThis = mDataProvider->fields();
03770 const QgsFieldMap& fieldsOther = otherVectorLayer ->mDataProvider->fields();
03771
03772 if ( fieldsThis.size() != fieldsOther.size() )
03773 {
03774 return false;
03775 }
03776
03777
03778
03779 uint fieldsThisSize = fieldsThis.size();
03780
03781 for ( uint i = 0; i < fieldsThisSize; ++i )
03782 {
03783 if ( fieldsThis[i].name() != fieldsOther[i].name() )
03784 {
03785 return false;
03786 }
03787
03788 }
03789 return true;
03790 }
03791 return false;
03792 }
03793
03794 bool QgsVectorLayer::snapPoint( QgsPoint& point, double tolerance )
03795 {
03796 if ( geometryType() == QGis::NoGeometry )
03797 return false;
03798
03799 QMultiMap<double, QgsSnappingResult> snapResults;
03800 int result = snapWithContext( point, tolerance, snapResults, QgsSnapper::SnapToVertex );
03801
03802 if ( result != 0 )
03803 {
03804 return false;
03805 }
03806
03807 if ( snapResults.size() < 1 )
03808 {
03809 return false;
03810 }
03811
03812 QMultiMap<double, QgsSnappingResult>::const_iterator snap_it = snapResults.constBegin();
03813 point.setX( snap_it.value().snappedVertex.x() );
03814 point.setY( snap_it.value().snappedVertex.y() );
03815 return true;
03816 }
03817
03818
03819 int QgsVectorLayer::snapWithContext( const QgsPoint& startPoint, double snappingTolerance,
03820 QMultiMap<double, QgsSnappingResult>& snappingResults,
03821 QgsSnapper::SnappingType snap_to )
03822 {
03823 if ( geometryType() == QGis::NoGeometry )
03824 return 1;
03825
03826 if ( snappingTolerance <= 0 || !mDataProvider )
03827 {
03828 return 1;
03829 }
03830
03831 QList<QgsFeature> featureList;
03832 QgsRectangle searchRect( startPoint.x() - snappingTolerance, startPoint.y() - snappingTolerance,
03833 startPoint.x() + snappingTolerance, startPoint.y() + snappingTolerance );
03834 double sqrSnappingTolerance = snappingTolerance * snappingTolerance;
03835
03836 int n = 0;
03837 QgsFeature f;
03838
03839 if ( mCachedGeometriesRect.contains( searchRect ) )
03840 {
03841 QgsDebugMsg( "Using cached geometries for snapping." );
03842
03843 QgsGeometryMap::iterator it = mCachedGeometries.begin();
03844 for ( ; it != mCachedGeometries.end() ; ++it )
03845 {
03846 QgsGeometry* g = &( it.value() );
03847 if ( g->boundingBox().intersects( searchRect ) )
03848 {
03849 snapToGeometry( startPoint, it.key(), g, sqrSnappingTolerance, snappingResults, snap_to );
03850 ++n;
03851 }
03852 }
03853 }
03854 else
03855 {
03856
03857
03858 select( QgsAttributeList(), searchRect, true, true );
03859
03860 while ( nextFeature( f ) )
03861 {
03862 snapToGeometry( startPoint, f.id(), f.geometry(), sqrSnappingTolerance, snappingResults, snap_to );
03863 ++n;
03864 }
03865 }
03866
03867 return n == 0 ? 2 : 0;
03868 }
03869
03870 void QgsVectorLayer::snapToGeometry( const QgsPoint& startPoint, int featureId, QgsGeometry* geom, double sqrSnappingTolerance,
03871 QMultiMap<double, QgsSnappingResult>& snappingResults, QgsSnapper::SnappingType snap_to ) const
03872 {
03873 if ( !geom )
03874 {
03875 return;
03876 }
03877
03878 int atVertex, beforeVertex, afterVertex;
03879 double sqrDistVertexSnap, sqrDistSegmentSnap;
03880 QgsPoint snappedPoint;
03881 QgsSnappingResult snappingResultVertex;
03882 QgsSnappingResult snappingResultSegment;
03883
03884 if ( snap_to == QgsSnapper::SnapToVertex || snap_to == QgsSnapper::SnapToVertexAndSegment )
03885 {
03886 snappedPoint = geom->closestVertex( startPoint, atVertex, beforeVertex, afterVertex, sqrDistVertexSnap );
03887 if ( sqrDistVertexSnap < sqrSnappingTolerance )
03888 {
03889 snappingResultVertex.snappedVertex = snappedPoint;
03890 snappingResultVertex.snappedVertexNr = atVertex;
03891 snappingResultVertex.beforeVertexNr = beforeVertex;
03892 if ( beforeVertex != -1 )
03893 {
03894 snappingResultVertex.beforeVertex = geom->vertexAt( beforeVertex );
03895 }
03896 snappingResultVertex.afterVertexNr = afterVertex;
03897 if ( afterVertex != -1 )
03898 {
03899 snappingResultVertex.afterVertex = geom->vertexAt( afterVertex );
03900 }
03901 snappingResultVertex.snappedAtGeometry = featureId;
03902 snappingResultVertex.layer = this;
03903 snappingResults.insert( sqrt( sqrDistVertexSnap ), snappingResultVertex );
03904 return;
03905 }
03906 }
03907 if ( snap_to == QgsSnapper::SnapToSegment || snap_to == QgsSnapper::SnapToVertexAndSegment )
03908 {
03909 if ( geometryType() != QGis::Point )
03910 {
03911 sqrDistSegmentSnap = geom->closestSegmentWithContext( startPoint, snappedPoint, afterVertex );
03912
03913 if ( sqrDistSegmentSnap < sqrSnappingTolerance )
03914 {
03915 snappingResultSegment.snappedVertex = snappedPoint;
03916 snappingResultSegment.snappedVertexNr = -1;
03917 snappingResultSegment.beforeVertexNr = afterVertex - 1;
03918 snappingResultSegment.afterVertexNr = afterVertex;
03919 snappingResultSegment.snappedAtGeometry = featureId;
03920 snappingResultSegment.beforeVertex = geom->vertexAt( afterVertex - 1 );
03921 snappingResultSegment.afterVertex = geom->vertexAt( afterVertex );
03922 snappingResultSegment.layer = this;
03923 snappingResults.insert( sqrt( sqrDistSegmentSnap ), snappingResultSegment );
03924 }
03925 }
03926 }
03927
03928 }
03929
03930 int QgsVectorLayer::insertSegmentVerticesForSnap( const QList<QgsSnappingResult>& snapResults )
03931 {
03932 if ( geometryType() == QGis::NoGeometry )
03933 return 1;
03934
03935 int returnval = 0;
03936 QgsPoint layerPoint;
03937
03938 QList<QgsSnappingResult>::const_iterator it = snapResults.constBegin();
03939 for ( ; it != snapResults.constEnd(); ++it )
03940 {
03941 if ( it->snappedVertexNr == -1 )
03942 {
03943 layerPoint = it->snappedVertex;
03944 if ( !insertVertex( layerPoint.x(), layerPoint.y(), it->snappedAtGeometry, it->afterVertexNr ) )
03945 {
03946 returnval = 3;
03947 }
03948 }
03949 }
03950 return returnval;
03951 }
03952
03953 int QgsVectorLayer::boundingBoxFromPointList( const QList<QgsPoint>& list, double& xmin, double& ymin, double& xmax, double& ymax ) const
03954 {
03955 if ( list.size() < 1 )
03956 {
03957 return 1;
03958 }
03959
03960 xmin = std::numeric_limits<double>::max();
03961 xmax = -std::numeric_limits<double>::max();
03962 ymin = std::numeric_limits<double>::max();
03963 ymax = -std::numeric_limits<double>::max();
03964
03965 for ( QList<QgsPoint>::const_iterator it = list.constBegin(); it != list.constEnd(); ++it )
03966 {
03967 if ( it->x() < xmin )
03968 {
03969 xmin = it->x();
03970 }
03971 if ( it->x() > xmax )
03972 {
03973 xmax = it->x();
03974 }
03975 if ( it->y() < ymin )
03976 {
03977 ymin = it->y();
03978 }
03979 if ( it->y() > ymax )
03980 {
03981 ymax = it->y();
03982 }
03983 }
03984
03985 return 0;
03986 }
03987
03988 QgsVectorLayer::VertexMarkerType QgsVectorLayer::currentVertexMarkerType()
03989 {
03990 QSettings settings;
03991 QString markerTypeString = settings.value( "/qgis/digitizing/marker_style", "Cross" ).toString();
03992 if ( markerTypeString == "Cross" )
03993 {
03994 return QgsVectorLayer::Cross;
03995 }
03996 else if ( markerTypeString == "SemiTransparentCircle" )
03997 {
03998 return QgsVectorLayer::SemiTransparentCircle;
03999 }
04000 else
04001 {
04002 return QgsVectorLayer::NoMarker;
04003 }
04004 }
04005
04006 int QgsVectorLayer::currentVertexMarkerSize()
04007 {
04008 QSettings settings;
04009 return settings.value( "/qgis/digitizing/marker_size", 3 ).toInt();
04010 }
04011
04012 void QgsVectorLayer::drawFeature( QgsRenderContext &renderContext,
04013 QgsFeature& fet,
04014 QImage * marker )
04015 {
04016 QPainter *p = renderContext.painter();
04017
04018
04019
04020
04021 if ( ! fet.isValid() ) { return; }
04022 bool needToTrim = false;
04023
04024 QgsGeometry* geom = fet.geometry();
04025 if ( !geom )
04026 {
04027 return;
04028 }
04029 unsigned char* feature = geom->asWkb();
04030
04031 QGis::WkbType wkbType = geom->wkbType();
04032
04033 switch ( wkbType )
04034 {
04035 case QGis::WKBPoint:
04036 case QGis::WKBPoint25D:
04037 {
04038 double x = *(( double * )( feature + 5 ) );
04039 double y = *(( double * )( feature + 5 + sizeof( double ) ) );
04040
04041 transformPoint( x, y, &renderContext.mapToPixel(), renderContext.coordinateTransform() );
04042 if ( std::abs( x ) > QgsClipper::MAX_X ||
04043 std::abs( y ) > QgsClipper::MAX_Y )
04044 {
04045 break;
04046 }
04047
04048
04049 QPointF pt( x*renderContext.rasterScaleFactor() - ( marker->width() / 2 ),
04050 y*renderContext.rasterScaleFactor() - ( marker->height() / 2 ) );
04051
04052 p->save();
04053
04054 p->scale( 1.0 / renderContext.rasterScaleFactor(), 1.0 / renderContext.rasterScaleFactor() );
04055 p->drawImage( pt, *marker );
04056 p->restore();
04057
04058 break;
04059 }
04060 case QGis::WKBMultiPoint:
04061 case QGis::WKBMultiPoint25D:
04062 {
04063 unsigned char *ptr = feature + 5;
04064 unsigned int nPoints = *(( int* )ptr );
04065 ptr += 4;
04066
04067 p->save();
04068
04069 p->scale( 1.0 / renderContext.rasterScaleFactor(), 1.0 / renderContext.rasterScaleFactor() );
04070
04071 for ( register unsigned int i = 0; i < nPoints; ++i )
04072 {
04073 ptr += 5;
04074 double x = *(( double * ) ptr );
04075 ptr += sizeof( double );
04076 double y = *(( double * ) ptr );
04077 ptr += sizeof( double );
04078
04079 if ( wkbType == QGis::WKBMultiPoint25D )
04080 ptr += sizeof( double );
04081
04082 transformPoint( x, y, &renderContext.mapToPixel(), renderContext.coordinateTransform() );
04083
04084
04085 QPointF pt( x*renderContext.rasterScaleFactor() - ( marker->width() / 2 ),
04086 y*renderContext.rasterScaleFactor() - ( marker->height() / 2 ) );
04087
04088
04089
04090 if ( std::abs( x ) > QgsClipper::MAX_X ||
04091 std::abs( y ) > QgsClipper::MAX_Y )
04092 needToTrim = true;
04093 else
04094 p->drawImage( pt, *marker );
04095 }
04096 p->restore();
04097
04098 break;
04099 }
04100 case QGis::WKBLineString:
04101 case QGis::WKBLineString25D:
04102 {
04103 drawLineString( feature, renderContext );
04104 break;
04105 }
04106 case QGis::WKBMultiLineString:
04107 case QGis::WKBMultiLineString25D:
04108 {
04109 unsigned char* ptr = feature + 5;
04110 unsigned int numLineStrings = *(( int* )ptr );
04111 ptr = feature + 9;
04112
04113 for ( register unsigned int jdx = 0; jdx < numLineStrings; jdx++ )
04114 {
04115 ptr = drawLineString( ptr, renderContext );
04116 }
04117 break;
04118 }
04119 case QGis::WKBPolygon:
04120 case QGis::WKBPolygon25D:
04121 {
04122 drawPolygon( feature, renderContext );
04123 break;
04124 }
04125 case QGis::WKBMultiPolygon:
04126 case QGis::WKBMultiPolygon25D:
04127 {
04128 unsigned char *ptr = feature + 5;
04129 unsigned int numPolygons = *(( int* )ptr );
04130 ptr = feature + 9;
04131 for ( register unsigned int kdx = 0; kdx < numPolygons; kdx++ )
04132 ptr = drawPolygon( ptr, renderContext );
04133 break;
04134 }
04135 default:
04136 QgsDebugMsg( "Unknown WkbType ENCOUNTERED" );
04137 break;
04138 }
04139 }
04140
04141
04142
04143 void QgsVectorLayer::setCoordinateSystem()
04144 {
04145 QgsDebugMsg( "----- Computing Coordinate System" );
04146
04147
04148
04149
04150
04151
04152
04153 *mCRS = mDataProvider->crs();
04154
04155
04156
04157
04158
04159 if ( !mCRS->isValid() )
04160 {
04161 if ( geometryType() != QGis::NoGeometry )
04162 {
04163 mCRS->setValidationHint( tr( "Specify CRS for layer %1" ).arg( name() ) );
04164 mCRS->validate();
04165 }
04166 else
04167 {
04168 mCRS->createFromProj4( GEOPROJ4 );
04169 }
04170 }
04171 }
04172
04173
04174 inline void QgsVectorLayer::transformPoint(
04175 double& x, double& y,
04176 const QgsMapToPixel* mtp,
04177 const QgsCoordinateTransform* ct )
04178 {
04179
04180 if ( ct )
04181 {
04182 double z = 0;
04183 ct->transformInPlace( x, y, z );
04184 }
04185
04186
04187
04188 mtp->transformInPlace( x, y );
04189 }
04190
04191 inline void QgsVectorLayer::transformPoints(
04192 std::vector<double>& x, std::vector<double>& y, std::vector<double>& z,
04193 QgsRenderContext &renderContext )
04194 {
04195
04196 if ( renderContext.coordinateTransform() )
04197 renderContext.coordinateTransform()->transformInPlace( x, y, z );
04198
04199
04200
04201 renderContext.mapToPixel().transformInPlace( x, y );
04202 }
04203
04204
04205 const QString QgsVectorLayer::displayField() const
04206 {
04207 return mDisplayField;
04208 }
04209
04210 bool QgsVectorLayer::isEditable() const
04211 {
04212 return ( mEditable && mDataProvider );
04213 }
04214
04215 bool QgsVectorLayer::isReadOnly() const
04216 {
04217 return mReadOnly;
04218 }
04219
04220 bool QgsVectorLayer::setReadOnly( bool readonly )
04221 {
04222
04223 if ( readonly && mEditable )
04224 return false;
04225
04226 mReadOnly = readonly;
04227 return true;
04228 }
04229
04230 bool QgsVectorLayer::isModified() const
04231 {
04232 return mModified;
04233 }
04234
04235 void QgsVectorLayer::setModified( bool modified, bool onlyGeometry )
04236 {
04237 mModified = modified;
04238 emit layerModified( onlyGeometry );
04239 }
04240
04241 QgsVectorLayer::EditType QgsVectorLayer::editType( int idx )
04242 {
04243 const QgsFieldMap &fields = pendingFields();
04244 if ( fields.contains( idx ) && mEditTypes.contains( fields[idx].name() ) )
04245 return mEditTypes[ fields[idx].name()];
04246 else
04247 return LineEdit;
04248 }
04249
04250 void QgsVectorLayer::setEditType( int idx, EditType type )
04251 {
04252 const QgsFieldMap &fields = pendingFields();
04253 if ( fields.contains( idx ) )
04254 mEditTypes[ fields[idx].name()] = type;
04255 }
04256
04257 QString QgsVectorLayer::editForm()
04258 {
04259 return mEditForm;
04260 }
04261
04262 void QgsVectorLayer::setEditForm( QString ui )
04263 {
04264 mEditForm = ui;
04265 }
04266
04267 void QgsVectorLayer::setAnnotationForm( const QString& ui )
04268 {
04269 mAnnotationForm = ui;
04270 }
04271
04272 QString QgsVectorLayer::editFormInit()
04273 {
04274 return mEditFormInit;
04275 }
04276
04277 void QgsVectorLayer::setEditFormInit( QString function )
04278 {
04279 mEditFormInit = function;
04280 }
04281
04282 QMap< QString, QVariant > &QgsVectorLayer::valueMap( int idx )
04283 {
04284 const QgsFieldMap &fields = pendingFields();
04285
04286
04287 if ( !fields.contains( idx ) )
04288 {
04289 QgsDebugMsg( QString( "field %1 not found" ).arg( idx ) );
04290 }
04291
04292 if ( !mValueMaps.contains( fields[idx].name() ) )
04293 mValueMaps[ fields[idx].name()] = QMap<QString, QVariant>();
04294
04295 return mValueMaps[ fields[idx].name()];
04296 }
04297
04298 QgsVectorLayer::RangeData &QgsVectorLayer::range( int idx )
04299 {
04300 const QgsFieldMap &fields = pendingFields();
04301
04302
04303 if ( fields.contains( idx ) )
04304 {
04305 QgsDebugMsg( QString( "field %1 not found" ).arg( idx ) );
04306 }
04307
04308 if ( !mRanges.contains( fields[idx].name() ) )
04309 mRanges[ fields[idx].name()] = RangeData();
04310
04311 return mRanges[ fields[idx].name()];
04312 }
04313
04314 void QgsVectorLayer::addOverlay( QgsVectorOverlay* overlay )
04315 {
04316 mOverlays.push_back( overlay );
04317 }
04318
04319 void QgsVectorLayer::removeOverlay( const QString& typeName )
04320 {
04321 for ( int i = mOverlays.size() - 1; i >= 0; --i )
04322 {
04323 if ( mOverlays.at( i )->typeName() == typeName )
04324 {
04325 mOverlays.removeAt( i );
04326 }
04327 }
04328 }
04329
04330 void QgsVectorLayer::vectorOverlays( QList<QgsVectorOverlay*>& overlayList )
04331 {
04332 overlayList = mOverlays;
04333 }
04334
04335 QgsVectorOverlay* QgsVectorLayer::findOverlayByType( const QString& typeName )
04336 {
04337 QList<QgsVectorOverlay*>::iterator it = mOverlays.begin();
04338 for ( ; it != mOverlays.end(); ++it )
04339 {
04340 if (( *it )->typeName() == typeName )
04341 {
04342 return *it;
04343 }
04344 }
04345 return 0;
04346 }
04347
04348
04349 QgsFeatureRendererV2* QgsVectorLayer::rendererV2()
04350 {
04351 return mRendererV2;
04352 }
04353 void QgsVectorLayer::setRendererV2( QgsFeatureRendererV2* r )
04354 {
04355 if ( geometryType() == QGis::NoGeometry )
04356 return;
04357
04358 delete mRendererV2;
04359 mRendererV2 = r;
04360 }
04361 bool QgsVectorLayer::isUsingRendererV2()
04362 {
04363 return mUsingRendererV2;
04364 }
04365 void QgsVectorLayer::setUsingRendererV2( bool usingRendererV2 )
04366 {
04367 if ( geometryType() == QGis::NoGeometry )
04368 return;
04369
04370 mUsingRendererV2 = usingRendererV2;
04371 }
04372
04373
04374 void QgsVectorLayer::editGeometryChange( int featureId, QgsGeometry& geometry )
04375 {
04376 if ( mActiveCommand != NULL )
04377 {
04378 mActiveCommand->storeGeometryChange( featureId, mChangedGeometries[ featureId ], geometry );
04379 }
04380 mChangedGeometries[ featureId ] = geometry;
04381 }
04382
04383
04384 void QgsVectorLayer::editFeatureAdd( QgsFeature& feature )
04385 {
04386 if ( mActiveCommand != NULL )
04387 {
04388 mActiveCommand->storeFeatureAdd( feature );
04389 }
04390 mAddedFeatures.append( feature );
04391 }
04392
04393 void QgsVectorLayer::editFeatureDelete( int featureId )
04394 {
04395 if ( mActiveCommand != NULL )
04396 {
04397 mActiveCommand->storeFeatureDelete( featureId );
04398 }
04399 mDeletedFeatureIds.insert( featureId );
04400 }
04401
04402 void QgsVectorLayer::editAttributeChange( int featureId, int field, QVariant value )
04403 {
04404 if ( mActiveCommand != NULL )
04405 {
04406 QVariant original;
04407 bool isFirstChange = true;
04408 if ( featureId < 0 )
04409 {
04410
04411 for ( int i = 0; i < mAddedFeatures.size(); i++ )
04412 {
04413 if ( mAddedFeatures[i].id() == featureId && mAddedFeatures[i].attributeMap().contains( field ) )
04414 {
04415 original = mAddedFeatures[i].attributeMap()[field];
04416 isFirstChange = false;
04417 break;
04418 }
04419 }
04420 }
04421 else
04422 {
04423 if ( mChangedAttributeValues.contains( featureId ) && mChangedAttributeValues[featureId].contains( field ) )
04424 {
04425 original = mChangedAttributeValues[featureId][field];
04426 isFirstChange = false;
04427 }
04428 }
04429 mActiveCommand->storeAttributeChange( featureId, field, original, value, isFirstChange );
04430 }
04431
04432 if ( featureId >= 0 )
04433 {
04434
04435 if ( !mChangedAttributeValues.contains( featureId ) )
04436 {
04437 mChangedAttributeValues.insert( featureId, QgsAttributeMap() );
04438 }
04439
04440 mChangedAttributeValues[featureId].insert( field, value );
04441 }
04442 else
04443 {
04444
04445 for ( int i = 0; i < mAddedFeatures.size(); i++ )
04446 {
04447 if ( mAddedFeatures[i].id() == featureId )
04448 {
04449 mAddedFeatures[i].changeAttribute( field, value );
04450 break;
04451 }
04452 }
04453 }
04454 }
04455
04456 void QgsVectorLayer::beginEditCommand( QString text )
04457 {
04458 if ( mActiveCommand == NULL )
04459 {
04460 mActiveCommand = new QgsUndoCommand( this, text );
04461 }
04462 }
04463
04464 void QgsVectorLayer::endEditCommand()
04465 {
04466 if ( mActiveCommand != NULL )
04467 {
04468 undoStack()->push( mActiveCommand );
04469 mActiveCommand = NULL;
04470 }
04471
04472 }
04473
04474 void QgsVectorLayer::destroyEditCommand()
04475 {
04476 if ( mActiveCommand != NULL )
04477 {
04478 undoEditCommand( mActiveCommand );
04479 delete mActiveCommand;
04480 mActiveCommand = NULL;
04481 }
04482
04483 }
04484
04485 void QgsVectorLayer::redoEditCommand( QgsUndoCommand* cmd )
04486 {
04487 QMap<int, QgsUndoCommand::GeometryChangeEntry>& geometryChange = cmd->mGeometryChange;
04488 QgsFeatureIds& deletedFeatureIdChange = cmd->mDeletedFeatureIdChange;
04489 QgsFeatureList& addedFeatures = cmd->mAddedFeatures;
04490 QMap<int, QgsUndoCommand::AttributeChanges>& attributeChange = cmd->mAttributeChange;
04491 QgsFieldMap& addedAttributes = cmd->mAddedAttributes;
04492 QgsFieldMap& deletedAttributes = cmd->mDeletedAttributes;
04493
04494
04495
04496 QMap<int, QgsUndoCommand::GeometryChangeEntry>::iterator it = geometryChange.begin();
04497 for ( ; it != geometryChange.end(); ++it )
04498 {
04499 if ( it.value().target == NULL )
04500 {
04501 mChangedGeometries.remove( it.key() );
04502 }
04503 else
04504 {
04505 mChangedGeometries[it.key()] = *( it.value().target );
04506 }
04507 }
04508
04509
04510 QgsFeatureIds::iterator delIt = deletedFeatureIdChange.begin();
04511 for ( ; delIt != deletedFeatureIdChange.end(); ++delIt )
04512 {
04513 mDeletedFeatureIds.insert( *delIt );
04514 }
04515
04516
04517 QgsFeatureList::iterator addIt = addedFeatures.begin();
04518 for ( ; addIt != addedFeatures.end(); ++addIt )
04519 {
04520 mAddedFeatures.append( *addIt );
04521 }
04522
04523
04524 QMap<int, QgsUndoCommand::AttributeChanges>::iterator attrFeatIt = attributeChange.begin();
04525 for ( ; attrFeatIt != attributeChange.end(); ++attrFeatIt )
04526 {
04527 int fid = attrFeatIt.key();
04528
04529 QMap<int, QgsUndoCommand::AttributeChangeEntry>::iterator attrChIt = attrFeatIt.value().begin();
04530 for ( ; attrChIt != attrFeatIt.value().end(); ++attrChIt )
04531 {
04532 if ( fid >= 0 )
04533 {
04534
04535 if ( attrChIt.value().target.isNull() )
04536 {
04537 mChangedAttributeValues[fid].remove( attrChIt.key() );
04538 }
04539 else
04540 {
04541 mChangedAttributeValues[fid][attrChIt.key()] = attrChIt.value().target;
04542 QgsFeature f;
04543 featureAtId( fid, f, false, true );
04544 f.changeAttribute( attrChIt.key(), attrChIt.value().target );
04545 }
04546 }
04547 else
04548 {
04549
04550 for ( int i = 0; i < mAddedFeatures.size(); i++ )
04551 {
04552 if ( mAddedFeatures[i].id() == fid )
04553 {
04554 mAddedFeatures[i].changeAttribute( attrChIt.key(), attrChIt.value().target );
04555 break;
04556 }
04557 }
04558
04559 }
04560
04561 }
04562 }
04563
04564
04565 QgsFieldMap::iterator attrIt = addedAttributes.begin();
04566 for ( ; attrIt != addedAttributes.end(); ++attrIt )
04567 {
04568 int attrIndex = attrIt.key();
04569 mAddedAttributeIds.insert( attrIndex );
04570 mUpdatedFields.insert( attrIndex, attrIt.value() );
04571 }
04572
04573
04574 QgsFieldMap::iterator dAttrIt = deletedAttributes.begin();
04575 for ( ; dAttrIt != deletedAttributes.end(); ++dAttrIt )
04576 {
04577 int attrIndex = dAttrIt.key();
04578 mDeletedAttributeIds.insert( attrIndex );
04579 mUpdatedFields.remove( attrIndex );
04580 }
04581 setModified( true );
04582
04583
04584 triggerRepaint();
04585 }
04586
04587 void QgsVectorLayer::undoEditCommand( QgsUndoCommand* cmd )
04588 {
04589 QMap<int, QgsUndoCommand::GeometryChangeEntry>& geometryChange = cmd->mGeometryChange;
04590 QgsFeatureIds& deletedFeatureIdChange = cmd->mDeletedFeatureIdChange;
04591 QgsFeatureList& addedFeatures = cmd->mAddedFeatures;
04592 QMap<int, QgsUndoCommand::AttributeChanges>& attributeChange = cmd->mAttributeChange;
04593 QgsFieldMap& addedAttributes = cmd->mAddedAttributes;
04594 QgsFieldMap& deletedAttributes = cmd->mDeletedAttributes;
04595
04596
04597 QgsFieldMap::iterator dAttrIt = deletedAttributes.begin();
04598 for ( ; dAttrIt != deletedAttributes.end(); ++dAttrIt )
04599 {
04600 int attrIndex = dAttrIt.key();
04601 mDeletedAttributeIds.remove( attrIndex );
04602 mUpdatedFields.insert( attrIndex, dAttrIt.value() );
04603 }
04604
04605
04606 QgsFieldMap::iterator attrIt = addedAttributes.begin();
04607 for ( ; attrIt != addedAttributes.end(); ++attrIt )
04608 {
04609 int attrIndex = attrIt.key();
04610 mAddedAttributeIds.remove( attrIndex );
04611 mUpdatedFields.remove( attrIndex );
04612 }
04613
04614
04615 QMap<int, QgsUndoCommand::GeometryChangeEntry>::iterator it = geometryChange.begin();
04616 for ( ; it != geometryChange.end(); ++it )
04617 {
04618 if ( it.value().original == NULL )
04619 {
04620 mChangedGeometries.remove( it.key() );
04621 }
04622 else
04623 {
04624 mChangedGeometries[it.key()] = *( it.value().original );
04625 }
04626 }
04627
04628
04629 QgsFeatureIds::iterator delIt = deletedFeatureIdChange.begin();
04630 for ( ; delIt != deletedFeatureIdChange.end(); ++delIt )
04631 {
04632 mDeletedFeatureIds.remove( *delIt );
04633 }
04634
04635
04636 QgsFeatureList::iterator addIt = addedFeatures.begin();
04637 for ( ; addIt != addedFeatures.end(); ++addIt )
04638 {
04639 QgsFeatureList::iterator addedIt = mAddedFeatures.begin();
04640 for ( ; addedIt != mAddedFeatures.end(); ++addedIt )
04641 {
04642 if ( addedIt->id() == addIt->id() )
04643 {
04644 mAddedFeatures.erase( addedIt );
04645 break;
04646 }
04647 }
04648 }
04649
04650
04651 QMap<int, QgsUndoCommand::AttributeChanges>::iterator attrFeatIt = attributeChange.begin();
04652 for ( ; attrFeatIt != attributeChange.end(); ++attrFeatIt )
04653 {
04654 int fid = attrFeatIt.key();
04655 QMap<int, QgsUndoCommand::AttributeChangeEntry>::iterator attrChIt = attrFeatIt.value().begin();
04656 for ( ; attrChIt != attrFeatIt.value().end(); ++attrChIt )
04657 {
04658 if ( fid >= 0 )
04659 {
04660 if ( attrChIt.value().isFirstChange )
04661 {
04662 mChangedAttributeValues[fid].remove( attrChIt.key() );
04663 }
04664 else
04665 {
04666 mChangedAttributeValues[fid][attrChIt.key()] = attrChIt.value().original;
04667 }
04668 }
04669 else
04670 {
04671
04672 for ( int i = 0; i < mAddedFeatures.size(); i++ )
04673 {
04674 if ( mAddedFeatures[i].id() == fid )
04675 {
04676 mAddedFeatures[i].changeAttribute( attrChIt.key(), attrChIt.value().original );
04677 break;
04678 }
04679 }
04680
04681 }
04682 emit attributeValueChanged( fid, attrChIt.key(), attrChIt.value().original );
04683 }
04684 }
04685 setModified( true );
04686
04687
04688 triggerRepaint();
04689 }
04690
04691 void QgsVectorLayer::setCheckedState( int idx, QString checked, QString unchecked )
04692 {
04693 const QgsFieldMap &fields = pendingFields();
04694 if ( fields.contains( idx ) )
04695 mCheckedStates[ fields[idx].name()] = QPair<QString, QString>( checked, unchecked );
04696 }
04697
04698 QPair<QString, QString> QgsVectorLayer::checkedState( int idx )
04699 {
04700 const QgsFieldMap &fields = pendingFields();
04701 if ( fields.contains( idx ) && mCheckedStates.contains( fields[idx].name() ) )
04702 return mCheckedStates[ fields[idx].name()];
04703 else
04704 return QPair<QString, QString>( "1", "0" );
04705 }
04706
04707 int QgsVectorLayer::fieldNameIndex( const QString& fieldName ) const
04708 {
04709 const QgsFieldMap &theFields = pendingFields();
04710
04711 for ( QgsFieldMap::const_iterator it = theFields.constBegin(); it != theFields.constEnd(); ++it )
04712 {
04713 if ( it->name() == fieldName )
04714 {
04715 return it.key();
04716 }
04717 }
04718 return -1;
04719 }
04720
04721 void QgsVectorLayer::stopRendererV2( QgsRenderContext& rendererContext, QgsSingleSymbolRendererV2* selRenderer )
04722 {
04723 mRendererV2->stopRender( rendererContext );
04724 if ( selRenderer )
04725 {
04726 selRenderer->stopRender( rendererContext );
04727 delete selRenderer;
04728 }
04729 }