QGIS API Documentation  2.10.1-Pisa
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
qgsvectorfilewriter.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsvectorfilewriter.cpp
3  generic vector file writer
4  -------------------
5  begin : Sat Jun 16 2004
6  copyright : (C) 2004 by Tim Sutton
7  email : tim at linfiniti.com
8  ***************************************************************************/
9 
10 /***************************************************************************
11  * *
12  * This program is free software; you can redistribute it and/or modify *
13  * it under the terms of the GNU General Public License as published by *
14  * the Free Software Foundation; either version 2 of the License, or *
15  * (at your option) any later version. *
16  * *
17  ***************************************************************************/
18 
19 #include "qgsapplication.h"
20 #include "qgsfield.h"
21 #include "qgsfeature.h"
22 #include "qgsgeometry.h"
23 #include "qgslogger.h"
24 #include "qgsmessagelog.h"
25 #include "qgscoordinatereferencesystem.h"
26 #include "qgsvectorfilewriter.h"
27 #include "qgsrendererv2.h"
28 #include "qgssymbollayerv2.h"
29 #include "qgsvectordataprovider.h"
30 #include "qgslocalec.h"
31 
32 #include <QFile>
33 #include <QSettings>
34 #include <QFileInfo>
35 #include <QDir>
36 #include <QTextCodec>
37 #include <QTextStream>
38 #include <QSet>
39 #include <QMetaType>
40 
41 #include <cassert>
42 #include <cstdlib> // size_t
43 #include <limits> // std::numeric_limits
44 
45 #include <ogr_srs_api.h>
46 #include <cpl_error.h>
47 #include <cpl_conv.h>
48 
49 #if defined(GDAL_VERSION_NUM) && GDAL_VERSION_NUM >= 1800
50 #define TO8(x) (x).toUtf8().constData()
51 #define TO8F(x) (x).toUtf8().constData()
52 #else
53 #define TO8(x) (x).toLocal8Bit().constData()
54 #define TO8F(x) QFile::encodeName( x ).constData()
55 #endif
56 
57 
58 QgsVectorFileWriter::QgsVectorFileWriter(
59  const QString &theVectorFileName,
60  const QString &theFileEncoding,
61  const QgsFields& fields,
62  QGis::WkbType geometryType,
63  const QgsCoordinateReferenceSystem* srs,
64  const QString& driverName,
65  const QStringList &datasourceOptions,
66  const QStringList &layerOptions,
67  QString *newFilename,
68  SymbologyExport symbologyExport
69 )
70  : mDS( NULL )
71  , mLayer( NULL )
72  , mGeom( NULL )
73  , mError( NoError )
74  , mCodec( 0 )
75  , mWkbType( geometryType )
76  , mSymbologyExport( symbologyExport )
77  , mSymbologyScaleDenominator( 1.0 )
78 {
79  QString vectorFileName = theVectorFileName;
80  QString fileEncoding = theFileEncoding;
81  QStringList layOptions = layerOptions;
82  QStringList dsOptions = datasourceOptions;
83 
84  if ( theVectorFileName.isEmpty() )
85  {
86  mErrorMessage = QObject::tr( "Empty filename given" );
87  mError = ErrCreateDataSource;
88  return;
89  }
90 
91  QString ogrDriverName;
92  if ( driverName == "MapInfo MIF" )
93  {
94  ogrDriverName = "MapInfo File";
95  }
96  else if ( driverName == "SpatiaLite" )
97  {
98  ogrDriverName = "SQLite";
99  if ( !dsOptions.contains( "SPATIALITE=YES" ) )
100  {
101  dsOptions.append( "SPATIALITE=YES" );
102  }
103  }
104  else if ( driverName == "DBF file" )
105  {
106  ogrDriverName = "ESRI Shapefile";
107  if ( !layOptions.contains( "SHPT=NULL" ) )
108  {
109  layOptions.append( "SHPT=NULL" );
110  }
111  srs = 0;
112  }
113  else
114  {
115  ogrDriverName = driverName;
116  }
117 
118  // find driver in OGR
119  OGRSFDriverH poDriver;
120  QgsApplication::registerOgrDrivers();
121 
122  poDriver = OGRGetDriverByName( ogrDriverName.toLocal8Bit().data() );
123 
124  if ( !poDriver )
125  {
126  mErrorMessage = QObject::tr( "OGR driver for '%1' not found (OGR error: %2)" )
127  .arg( driverName )
128  .arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
129  mError = ErrDriverNotFound;
130  return;
131  }
132 
133  if ( ogrDriverName == "ESRI Shapefile" )
134  {
135  if ( layOptions.join( "" ).toUpper().indexOf( "ENCODING=" ) == -1 )
136  {
137  layOptions.append( "ENCODING=" + convertCodecNameForEncodingOption( fileEncoding ) );
138  }
139 
140  if ( driverName == "ESRI Shapefile" && !vectorFileName.endsWith( ".shp", Qt::CaseInsensitive ) )
141  {
142  vectorFileName += ".shp";
143  }
144  else if ( driverName == "DBF file" && !vectorFileName.endsWith( ".dbf", Qt::CaseInsensitive ) )
145  {
146  vectorFileName += ".dbf";
147  }
148 
149 #if defined(GDAL_VERSION_NUM) && GDAL_VERSION_NUM < 1700
150  // check for unique fieldnames
151  QSet<QString> fieldNames;
152  for ( int i = 0; i < fields.count(); ++i )
153  {
154  QString name = fields[i].name().left( 10 );
155  if ( fieldNames.contains( name ) )
156  {
157  mErrorMessage = QObject::tr( "trimming attribute name '%1' to ten significant characters produces duplicate column name." )
158  .arg( fields[i].name() );
159  mError = ErrAttributeCreationFailed;
160  return;
161  }
162  fieldNames << name;
163  }
164 #endif
165 
166  deleteShapeFile( vectorFileName );
167  }
168  else if ( driverName == "KML" )
169  {
170  if ( !vectorFileName.endsWith( ".kml", Qt::CaseInsensitive ) )
171  {
172  vectorFileName += ".kml";
173  }
174 
175  if ( fileEncoding.compare( "UTF-8", Qt::CaseInsensitive ) != 0 )
176  {
177  QgsDebugMsg( "forced UTF-8 encoding for KML" );
178  fileEncoding = "UTF-8";
179  }
180 
181  QFile::remove( vectorFileName );
182  }
183  else
184  {
185  QString longName;
186  QString trLongName;
187  QString glob;
188  QString exts;
189  if ( QgsVectorFileWriter::driverMetadata( driverName, longName, trLongName, glob, exts ) )
190  {
191  QStringList allExts = exts.split( " ", QString::SkipEmptyParts );
192  bool found = false;
193  foreach ( QString ext, allExts )
194  {
195  if ( vectorFileName.endsWith( "." + ext, Qt::CaseInsensitive ) )
196  {
197  found = true;
198  break;
199  }
200  }
201 
202  if ( !found )
203  {
204  vectorFileName += "." + allExts[0];
205  }
206  }
207 
208  QFile::remove( vectorFileName );
209  }
210 
211  char **options = NULL;
212  if ( !dsOptions.isEmpty() )
213  {
214  options = new char *[ dsOptions.size()+1 ];
215  for ( int i = 0; i < dsOptions.size(); i++ )
216  {
217  options[i] = CPLStrdup( dsOptions[i].toLocal8Bit().data() );
218  }
219  options[ dsOptions.size()] = NULL;
220  }
221 
222  // create the data source
223  mDS = OGR_Dr_CreateDataSource( poDriver, TO8F( vectorFileName ), options );
224 
225  if ( options )
226  {
227  for ( int i = 0; i < dsOptions.size(); i++ )
228  CPLFree( options[i] );
229  delete [] options;
230  options = NULL;
231  }
232 
233  if ( mDS == NULL )
234  {
235  mError = ErrCreateDataSource;
236  mErrorMessage = QObject::tr( "creation of data source failed (OGR error:%1)" )
237  .arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
238  return;
239  }
240 
241  QgsDebugMsg( "Created data source" );
242 
243  // use appropriate codec
244  mCodec = QTextCodec::codecForName( fileEncoding.toLocal8Bit().constData() );
245  if ( !mCodec )
246  {
247  QgsDebugMsg( "error finding QTextCodec for " + fileEncoding );
248 
249  QSettings settings;
250  QString enc = settings.value( "/UI/encoding", "System" ).toString();
251  mCodec = QTextCodec::codecForName( enc.toLocal8Bit().constData() );
252  if ( !mCodec )
253  {
254  QgsDebugMsg( "error finding QTextCodec for " + enc );
255  mCodec = QTextCodec::codecForLocale();
256  Q_ASSERT( mCodec );
257  }
258  }
259 
260  // consider spatial reference system of the layer
261  OGRSpatialReferenceH ogrRef = NULL;
262  if ( srs )
263  {
264  QString srsWkt = srs->toWkt();
265  QgsDebugMsg( "WKT to save as is " + srsWkt );
266  ogrRef = OSRNewSpatialReference( srsWkt.toLocal8Bit().data() );
267  }
268 
269  // datasource created, now create the output layer
270  QString layerName = QFileInfo( vectorFileName ).baseName();
271  OGRwkbGeometryType wkbType = static_cast<OGRwkbGeometryType>( geometryType );
272 
273  if ( !layOptions.isEmpty() )
274  {
275  options = new char *[ layOptions.size()+1 ];
276  for ( int i = 0; i < layOptions.size(); i++ )
277  {
278  options[i] = CPLStrdup( layOptions[i].toLocal8Bit().data() );
279  }
280  options[ layOptions.size()] = NULL;
281  }
282 
283  // disable encoding conversion of OGR Shapefile layer
284  CPLSetConfigOption( "SHAPE_ENCODING", "" );
285 
286  mLayer = OGR_DS_CreateLayer( mDS, TO8F( layerName ), ogrRef, wkbType, options );
287 
288  if ( options )
289  {
290  for ( int i = 0; i < layOptions.size(); i++ )
291  CPLFree( options[i] );
292  delete [] options;
293  options = NULL;
294  }
295 
296  QSettings settings;
297  if ( !settings.value( "/qgis/ignoreShapeEncoding", true ).toBool() )
298  {
299  CPLSetConfigOption( "SHAPE_ENCODING", 0 );
300  }
301 
302  if ( srs )
303  {
304  if ( ogrDriverName == "ESRI Shapefile" )
305  {
306  QString layerName = vectorFileName.left( vectorFileName.indexOf( ".shp", Qt::CaseInsensitive ) );
307  QFile prjFile( layerName + ".qpj" );
308  if ( prjFile.open( QIODevice::WriteOnly ) )
309  {
310  QTextStream prjStream( &prjFile );
311  prjStream << srs->toWkt().toLocal8Bit().data() << endl;
312  prjFile.close();
313  }
314  else
315  {
316  QgsDebugMsg( "Couldn't open file " + layerName + ".qpj" );
317  }
318  }
319 
320  OSRDestroySpatialReference( ogrRef );
321  }
322 
323  if ( mLayer == NULL )
324  {
325  mErrorMessage = QObject::tr( "creation of layer failed (OGR error:%1)" )
326  .arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
327  mError = ErrCreateLayer;
328  return;
329  }
330 
331  OGRFeatureDefnH defn = OGR_L_GetLayerDefn( mLayer );
332 
333  QgsDebugMsg( "created layer" );
334 
335  // create the fields
336  QgsDebugMsg( "creating " + QString::number( fields.size() ) + " fields" );
337 
338  mFields = fields;
339  mAttrIdxToOgrIdx.clear();
340 
341  for ( int fldIdx = 0; fldIdx < fields.count(); ++fldIdx )
342  {
343  const QgsField& attrField = fields[fldIdx];
344 
345  OGRFieldType ogrType = OFTString; //default to string
346  int ogrWidth = attrField.length();
347  int ogrPrecision = attrField.precision();
348  if ( ogrPrecision > 0 )
349  ++ogrWidth;
350 
351  switch ( attrField.type() )
352  {
353  case QVariant::LongLong:
354  ogrType = OFTString;
355  ogrWidth = ogrWidth > 0 && ogrWidth <= 21 ? ogrWidth : 21;
356  ogrPrecision = -1;
357  break;
358 
359  case QVariant::String:
360  ogrType = OFTString;
361  if ( ogrWidth <= 0 || ogrWidth > 255 )
362  ogrWidth = 255;
363  break;
364 
365  case QVariant::Int:
366  ogrType = OFTInteger;
367  ogrWidth = ogrWidth > 0 && ogrWidth <= 10 ? ogrWidth : 10;
368  ogrPrecision = 0;
369  break;
370 
371  case QVariant::Double:
372  ogrType = OFTReal;
373  break;
374 
375  case QVariant::Date:
376  ogrType = OFTDate;
377  break;
378 
379  case QVariant::DateTime:
380  ogrType = OFTDateTime;
381  break;
382 
383  default:
384  //assert(0 && "invalid variant type!");
385  mErrorMessage = QObject::tr( "unsupported type for field %1" )
386  .arg( attrField.name() );
387  mError = ErrAttributeTypeUnsupported;
388  return;
389  }
390 
391  QString name( attrField.name() );
392 
393  if ( ogrDriverName == "SQLite" && name.compare( "ogc_fid", Qt::CaseInsensitive ) == 0 )
394  {
395  int i;
396  for ( i = 0; i < 10; i++ )
397  {
398  name = QString( "ogc_fid%1" ).arg( i );
399 
400  int j;
401  for ( j = 0; j < fields.size() && name.compare( fields[j].name(), Qt::CaseInsensitive ) != 0; j++ )
402  ;
403 
404  if ( j == fields.size() )
405  break;
406  }
407 
408  if ( i == 10 )
409  {
410  mErrorMessage = QObject::tr( "no available replacement for internal fieldname ogc_fid found" ).arg( attrField.name() );
411  mError = ErrAttributeCreationFailed;
412  return;
413  }
414 
415  QgsMessageLog::logMessage( QObject::tr( "Reserved attribute name ogc_fid replaced with %1" ).arg( name ), QObject::tr( "OGR" ) );
416  }
417 
418  // create field definition
419  OGRFieldDefnH fld = OGR_Fld_Create( mCodec->fromUnicode( name ), ogrType );
420  if ( ogrWidth > 0 )
421  {
422  OGR_Fld_SetWidth( fld, ogrWidth );
423  }
424 
425  if ( ogrPrecision >= 0 )
426  {
427  OGR_Fld_SetPrecision( fld, ogrPrecision );
428  }
429 
430  // create the field
431  QgsDebugMsg( "creating field " + attrField.name() +
432  " type " + QString( QVariant::typeToName( attrField.type() ) ) +
433  " width " + QString::number( ogrWidth ) +
434  " precision " + QString::number( ogrPrecision ) );
435  if ( OGR_L_CreateField( mLayer, fld, true ) != OGRERR_NONE )
436  {
437  QgsDebugMsg( "error creating field " + attrField.name() );
438  mErrorMessage = QObject::tr( "creation of field %1 failed (OGR error: %2)" )
439  .arg( attrField.name() )
440  .arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
441  mError = ErrAttributeCreationFailed;
442  OGR_Fld_Destroy( fld );
443  return;
444  }
445  OGR_Fld_Destroy( fld );
446 
447  int ogrIdx = OGR_FD_GetFieldIndex( defn, mCodec->fromUnicode( name ) );
448  if ( ogrIdx < 0 )
449  {
450 #if defined(GDAL_VERSION_NUM) && GDAL_VERSION_NUM < 1700
451  // if we didn't find our new column, assume it's name was truncated and
452  // it was the last one added (like for shape files)
453  int fieldCount = OGR_FD_GetFieldCount( defn );
454 
455  OGRFieldDefnH fdefn = OGR_FD_GetFieldDefn( defn, fieldCount - 1 );
456  if ( fdefn )
457  {
458  const char *fieldName = OGR_Fld_GetNameRef( fdefn );
459 
460  if ( attrField.name().left( strlen( fieldName ) ) == fieldName )
461  {
462  ogrIdx = fieldCount - 1;
463  }
464  }
465 #else
466  // GDAL 1.7 not just truncates, but launders more aggressivly.
467  ogrIdx = OGR_FD_GetFieldCount( defn ) - 1;
468 #endif
469 
470  if ( ogrIdx < 0 )
471  {
472  QgsDebugMsg( "error creating field " + attrField.name() );
473  mErrorMessage = QObject::tr( "created field %1 not found (OGR error: %2)" )
474  .arg( attrField.name() )
475  .arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
476  mError = ErrAttributeCreationFailed;
477  return;
478  }
479  }
480 
481  mAttrIdxToOgrIdx.insert( fldIdx, ogrIdx );
482  }
483 
484  QgsDebugMsg( "Done creating fields" );
485 
486  mWkbType = geometryType;
487  if ( mWkbType != QGis::WKBNoGeometry )
488  {
489  // create geometry which will be used for import
490  mGeom = createEmptyGeometry( mWkbType );
491  }
492 
493  if ( newFilename )
494  *newFilename = vectorFileName;
495 }
496 
497 OGRGeometryH QgsVectorFileWriter::createEmptyGeometry( QGis::WkbType wkbType )
498 {
499  return OGR_G_CreateGeometry(( OGRwkbGeometryType ) wkbType );
500 }
501 
502 QMap<QString, QgsVectorFileWriter::MetaData> QgsVectorFileWriter::initMetaData()
503 {
504  QMap<QString, MetaData> driverMetadata;
505 
506  QMap<QString, Option*> datasetOptions;
507  QMap<QString, Option*> layerOptions;
508 
509  // Arc/Info ASCII Coverage
510  datasetOptions.clear();
511  layerOptions.clear();
512 
513  driverMetadata.insert( "AVCE00",
514  MetaData(
515  "Arc/Info ASCII Coverage",
516  QObject::tr( "Arc/Info ASCII Coverage" ),
517  "*.e00",
518  "e00",
519  datasetOptions,
520  layerOptions
521  )
522  );
523 
524  // Atlas BNA
525  datasetOptions.clear();
526  layerOptions.clear();
527 
528  datasetOptions.insert( "LINEFORMAT", new SetOption(
529  QObject::tr( "New BNA files are created by the "
530  "systems default line termination conventions. "
531  "This may be overridden here." ),
532  QStringList()
533  << "CRLF"
534  << "LF",
535  "", // Default value
536  true // Allow None
537  ) );
538 
539  datasetOptions.insert( "MULTILINE", new BoolOption(
540  QObject::tr( "By default, BNA files are created in multi-line format. "
541  "For each record, the first line contains the identifiers and the "
542  "type/number of coordinates to follow. Each following line contains "
543  "a pair of coordinates." ),
544  true // Default value
545  ) );
546 
547  datasetOptions.insert( "NB_IDS", new SetOption(
548  QObject::tr( "BNA records may contain from 2 to 4 identifiers per record. "
549  "Some software packages only support a precise number of identifiers. "
550  "You can override the default value (2) by a precise value" ),
551  QStringList()
552  << "2"
553  << "3"
554  << "4"
555  << "NB_SOURCE_FIELDS",
556  "2" // Default value
557  ) );
558 
559  datasetOptions.insert( "ELLIPSES_AS_ELLIPSES", new BoolOption(
560  QObject::tr( "The BNA writer will try to recognize ellipses and circles when writing a polygon. "
561  "This will only work if the feature has previously been read from a BNA file. "
562  "As some software packages do not support ellipses/circles in BNA data file, "
563  "it may be useful to tell the writer by specifying ELLIPSES_AS_ELLIPSES=NO not "
564  "to export them as such, but keep them as polygons." ),
565  true // Default value
566  ) );
567 
568  datasetOptions.insert( "NB_PAIRS_PER_LINE", new IntOption(
569  QObject::tr( "Limit the number of coordinate pairs per line in multiline format." ),
570  2 // Default value
571  ) );
572 
573  datasetOptions.insert( "COORDINATE_PRECISION", new IntOption(
574  QObject::tr( "Set the number of decimal for coordinates. Default value is 10." ),
575  10 // Default value
576  ) );
577 
578  driverMetadata.insert( "BNA",
579  MetaData(
580  "Atlas BNA",
581  QObject::tr( "Atlas BNA" ),
582  "*.bna",
583  "bna",
584  datasetOptions,
585  layerOptions
586  )
587  );
588 
589  // Comma Separated Value
590  datasetOptions.clear();
591  layerOptions.clear();
592 
593  layerOptions.insert( "LINEFORMAT", new SetOption(
594  QObject::tr( "By default when creating new .csv files they "
595  "are created with the line termination conventions "
596  "of the local platform (CR/LF on Win32 or LF on all other systems). "
597  "This may be overridden through the use of the LINEFORMAT option." ),
598  QStringList()
599  << "CRLF"
600  << "LF",
601  "", // Default value
602  true // Allow None
603  ) );
604 
605  layerOptions.insert( "GEOMETRY", new SetOption(
606  QObject::tr( "By default, the geometry of a feature written to a .csv file is discarded. "
607  "It is possible to export the geometry in its WKT representation by "
608  "specifying GEOMETRY=AS_WKT. It is also possible to export point geometries "
609  "into their X,Y,Z components by specifying GEOMETRY=AS_XYZ, GEOMETRY=AS_XY "
610  "or GEOMETRY=AS_YX." ),
611  QStringList()
612  << "AS_WKT"
613  << "AS_XYZ"
614  << "AS_XY"
615  << "AS_YX",
616  "AS_XY", // Default value
617  true // Allow None
618  ) );
619 
620  layerOptions.insert( "CREATE_CSVT", new BoolOption(
621  QObject::tr( "Create the associated .csvt file to describe the type of each "
622  "column of the layer and its optional width and precision." ),
623  false // Default value
624  ) );
625 
626  layerOptions.insert( "SEPARATOR", new SetOption(
627  QObject::tr( "Field separator character." ),
628  QStringList()
629  << "COMMA"
630  << "SEMICOLON"
631  << "TAB",
632  "COMMA" // Default value
633  ) );
634 
635  layerOptions.insert( "WRITE_BOM", new BoolOption(
636  QObject::tr( "Write a UTF-8 Byte Order Mark (BOM) at the start of the file." ),
637  false // Default value
638  ) );
639 
640  driverMetadata.insert( "CSV",
641  MetaData(
642  "Comma Separated Value [CSV]",
643  QObject::tr( "Comma Separated Value [CSV]" ),
644  "*.csv",
645  "csv",
646  datasetOptions,
647  layerOptions
648  )
649  );
650 
651  // ESRI Shapefile
652  datasetOptions.clear();
653  layerOptions.clear();
654 
655  layerOptions.insert( "SHPT", new SetOption(
656  QObject::tr( "Override the type of shapefile created. "
657  "Can be one of NULL for a simple .dbf file with no .shp file, POINT, "
658  "ARC, POLYGON or MULTIPOINT for 2D, or POINTZ, ARCZ, POLYGONZ or "
659  "MULTIPOINTZ for 3D. Shapefiles with measure values are not supported, "
660  "nor are MULTIPATCH files." ),
661  QStringList()
662  << "NULL"
663  << "POINT"
664  << "ARC"
665  << "POLYGON"
666  << "MULTIPOINT"
667  << "POINTZ"
668  << "ARCZ"
669  << "POLYGONZ"
670  << "MULTIPOINTZ",
671  "NULL" // Default value
672  ) );
673 
674  layerOptions.insert( "ENCODING", new SetOption(
675  QObject::tr( "set the encoding value in the DBF file. "
676  "The default value is LDID/87. It is not clear "
677  "what other values may be appropriate." ),
678  QStringList()
679  << "LDID/87",
680  "LDID/87" // Default value
681  ) );
682 
683  layerOptions.insert( "RESIZE", new BoolOption(
684  QObject::tr( "Set to YES to resize fields to their optimal size." ),
685  false // Default value
686  ) );
687 
688  driverMetadata.insert( "ESRI",
689  MetaData(
690  "ESRI Shapefile",
691  QObject::tr( "ESRI Shapefile" ),
692  "*.shp",
693  "shp",
694  datasetOptions,
695  layerOptions
696  )
697  );
698 
699  // DBF File
700  datasetOptions.clear();
701  layerOptions.clear();
702 
703  driverMetadata.insert( "DBF File",
704  MetaData(
705  "DBF File",
706  QObject::tr( "DBF File" ),
707  "*.dbf",
708  "dbf",
709  datasetOptions,
710  layerOptions
711  )
712  );
713 
714  // FMEObjects Gateway
715  datasetOptions.clear();
716  layerOptions.clear();
717 
718  driverMetadata.insert( "FMEObjects Gateway",
719  MetaData(
720  "FMEObjects Gateway",
721  QObject::tr( "FMEObjects Gateway" ),
722  "*.fdd",
723  "fdd",
724  datasetOptions,
725  layerOptions
726  )
727  );
728 
729  // GeoJSON
730  datasetOptions.clear();
731  layerOptions.clear();
732 
733  layerOptions.insert( "WRITE_BBOX", new BoolOption(
734  QObject::tr( "Set to YES to write a bbox property with the bounding box "
735  "of the geometries at the feature and feature collection level." ),
736  false // Default value
737  ) );
738 
739  layerOptions.insert( "COORDINATE_PRECISION", new IntOption(
740  QObject::tr( "Maximum number of figures after decimal separator to write in coordinates. "
741  "Default to 15. Truncation will occur to remove trailing zeros." ),
742  15 // Default value
743  ) );
744 
745  driverMetadata.insert( "GeoJSON",
746  MetaData(
747  "GeoJSON",
748  QObject::tr( "GeoJSON" ),
749  "*.geojson",
750  "geojson",
751  datasetOptions,
752  layerOptions
753  )
754  );
755 
756  // GeoRSS
757  datasetOptions.clear();
758  layerOptions.clear();
759 
760  datasetOptions.insert( "FORMAT", new SetOption(
761  QObject::tr( "whether the document must be in RSS 2.0 or Atom 1.0 format. "
762  "Default value : RSS" ),
763  QStringList()
764  << "RSS"
765  << "ATOM",
766  "RSS" // Default value
767  ) );
768 
769  datasetOptions.insert( "GEOM_DIALECT", new SetOption(
770  QObject::tr( "The encoding of location information. Default value : SIMPLE. "
771  "W3C_GEO only supports point geometries. "
772  "SIMPLE or W3C_GEO only support geometries in geographic WGS84 coordinates." ),
773  QStringList()
774  << "SIMPLE"
775  << "GML"
776  << "W3C_GEO",
777  "SIMPLE" // Default value
778  ) );
779 
780  datasetOptions.insert( "USE_EXTENSIONS", new BoolOption(
781  QObject::tr( "If defined to YES, extension fields will be written. "
782  "If the field name not found in the base schema matches "
783  "the foo_bar pattern, foo will be considered as the namespace "
784  "of the element, and a <foo:bar> element will be written. "
785  "Otherwise, elements will be written in the <ogr:> namespace." ),
786  true // Default value
787  ) );
788 
789  datasetOptions.insert( "WRITE_HEADER_AND_FOOTER", new BoolOption(
790  QObject::tr( "If defined to NO, only <entry> or <item> elements will be written. "
791  "The user will have to provide the appropriate header and footer of the document." ),
792  true // Default value
793  ) );
794 
795  datasetOptions.insert( "HEADER", new StringOption(
796  QObject::tr( "XML content that will be put between the <channel> element and the "
797  "first <item> element for a RSS document, or between the xml tag and "
798  "the first <entry> element for an Atom document. " ),
799  "" // Default value
800  ) );
801 
802  datasetOptions.insert( "TITLE", new StringOption(
803  QObject::tr( "Value put inside the <title> element in the header. "
804  "If not provided, a dummy value will be used as that element is compulsory." ),
805  "" // Default value
806  ) );
807 
808  datasetOptions.insert( "DESCRIPTION", new StringOption(
809  QObject::tr( "Value put inside the <description> element in the header. "
810  "If not provided, a dummy value will be used as that element is compulsory." ),
811  "" // Default value
812  ) );
813 
814  datasetOptions.insert( "LINK", new StringOption(
815  QObject::tr( "Value put inside the <link> element in the header. "
816  "If not provided, a dummy value will be used as that element is compulsory." ),
817  "" // Default value
818  ) );
819 
820  datasetOptions.insert( "UPDATED", new StringOption(
821  QObject::tr( "Value put inside the <updated> element in the header. "
822  "Should be formatted as a XML datetime. "
823  "If not provided, a dummy value will be used as that element is compulsory." ),
824  "" // Default value
825  ) );
826 
827  datasetOptions.insert( "AUTHOR_NAME", new StringOption(
828  QObject::tr( "Value put inside the <author><name> element in the header. "
829  "If not provided, a dummy value will be used as that element is compulsory." ),
830  "" // Default value
831  ) );
832 
833  datasetOptions.insert( "ID", new StringOption(
834  QObject::tr( "Value put inside the <id> element in the header. "
835  "If not provided, a dummy value will be used as that element is compulsory." ),
836  "" // Default value
837  ) );
838 
839  driverMetadata.insert( "GeoRSS",
840  MetaData(
841  "GeoRSS",
842  QObject::tr( "GeoRSS" ),
843  "*.xml",
844  "xml",
845  datasetOptions,
846  layerOptions
847  )
848  );
849 
850  // Geography Markup Language [GML]
851  datasetOptions.clear();
852  layerOptions.clear();
853 
854  datasetOptions.insert( "XSISCHEMAURI", new StringOption(
855  QObject::tr( "If provided, this URI will be inserted as the schema location. "
856  "Note that the schema file isn't actually accessed by OGR, so it "
857  "is up to the user to ensure it will match the schema of the OGR "
858  "produced GML data file." ),
859  "" // Default value
860  ) );
861 
862  datasetOptions.insert( "XSISCHEMA", new SetOption(
863  QObject::tr( "This writes a GML application schema file to a corresponding "
864  ".xsd file (with the same basename). If INTERNAL is used the "
865  "schema is written within the GML file, but this is experimental "
866  "and almost certainly not valid XML. "
867  "OFF disables schema generation (and is implicit if XSISCHEMAURI is used)." ),
868  QStringList()
869  << "EXTERNAL"
870  << "INTERNAL"
871  << "OFF",
872  "EXTERNAL" // Default value
873  ) );
874 
875  datasetOptions.insert( "PREFIX", new StringOption(
876  QObject::tr( "This is the prefix for the application target namespace." ),
877  "ogr" // Default value
878  ) );
879 
880  datasetOptions.insert( "STRIP_PREFIX", new BoolOption(
881  QObject::tr( "Can be set to TRUE to avoid writing the prefix of the "
882  "application target namespace in the GML file." ),
883  false // Default value
884  ) );
885 
886  datasetOptions.insert( "TARGET_NAMESPACE", new StringOption(
887  QObject::tr( "Defaults to 'http://ogr.maptools.org/'. "
888  "This is the application target namespace." ),
889  "http://ogr.maptools.org/" // Default value
890  ) );
891 
892  datasetOptions.insert( "FORMAT", new SetOption(
893  QObject::tr( "If not specified, GML2 will be used." ),
894  QStringList()
895  << "GML3"
896  << "GML3Deegree"
897  << "GML3.2",
898  "", // Default value
899  true // Allow None
900  ) );
901 
902  datasetOptions.insert( "GML3_LONGSRS", new BoolOption(
903  QObject::tr( "only valid when FORMAT=GML3/GML3Degree/GML3.2) Default to YES. "
904  "If YES, SRS with EPSG authority will be written with the "
905  "'urn:ogc:def:crs:EPSG::' prefix. In the case, if the SRS is a "
906  "geographic SRS without explicit AXIS order, but that the same "
907  "SRS authority code imported with ImportFromEPSGA() should be "
908  "treated as lat/long, then the function will take care of coordinate "
909  "order swapping. If set to NO, SRS with EPSG authority will be "
910  "written with the 'EPSG:' prefix, even if they are in lat/long order." ),
911  true // Default value
912  ) );
913 
914  datasetOptions.insert( "WRITE_FEATURE_BOUNDED_BY", new BoolOption(
915  QObject::tr( "only valid when FORMAT=GML3/GML3Degree/GML3.2) Default to YES. "
916  "If set to NO, the <gml:boundedBy> element will not be written for "
917  "each feature." ),
918  true // Default value
919  ) );
920 
921  datasetOptions.insert( "SPACE_INDENTATION", new BoolOption(
922  QObject::tr( "Default to YES. If YES, the output will be indented with spaces "
923  "for more readability, but at the expense of file size." ),
924  true // Default value
925  ) );
926 
927 
928  driverMetadata.insert( "GML",
929  MetaData(
930  "Geography Markup Language [GML]",
931  QObject::tr( "Geography Markup Language [GML]" ),
932  "*.gml",
933  "gml",
934  datasetOptions,
935  layerOptions
936  )
937  );
938 
939  // Generic Mapping Tools [GMT]
940  datasetOptions.clear();
941  layerOptions.clear();
942 
943  driverMetadata.insert( "GMT",
944  MetaData(
945  "Generic Mapping Tools [GMT]",
946  QObject::tr( "Generic Mapping Tools [GMT]" ),
947  "*.gmt",
948  "gmt",
949  datasetOptions,
950  layerOptions
951  )
952  );
953 
954  // GPS eXchange Format [GPX]
955  datasetOptions.clear();
956  layerOptions.clear();
957 
958  layerOptions.insert( "FORCE_GPX_TRACK", new BoolOption(
959  QObject::tr( "By default when writing a layer whose features are of "
960  "type wkbLineString, the GPX driver chooses to write "
961  "them as routes. If FORCE_GPX_TRACK=YES is specified, "
962  "they will be written as tracks." ),
963  false // Default value
964  ) );
965 
966  layerOptions.insert( "FORCE_GPX_ROUTE", new BoolOption(
967  QObject::tr( "By default when writing a layer whose features are of "
968  "type wkbMultiLineString, the GPX driver chooses to write "
969  "them as tracks. If FORCE_GPX_ROUTE=YES is specified, "
970  "they will be written as routes, provided that the multilines "
971  "are composed of only one single line." ),
972  false // Default value
973  ) );
974 
975  datasetOptions.insert( "GPX_USE_EXTENSIONS", new BoolOption(
976  QObject::tr( "If GPX_USE_EXTENSIONS=YES is specified, "
977  "extra fields will be written inside the <extensions> tag." ),
978  true // Default value
979  ) );
980 
981  datasetOptions.insert( "GPX_EXTENSIONS_NS", new StringOption(
982  QObject::tr( "Only used if GPX_USE_EXTENSIONS=YES and GPX_EXTENSIONS_NS_URL "
983  "is set. The namespace value used for extension tags. By default, 'ogr'." ),
984  "ogr" // Default value
985  ) );
986 
987  datasetOptions.insert( "GPX_EXTENSIONS_NS_URL", new StringOption(
988  QObject::tr( "Only used if GPX_USE_EXTENSIONS=YES and GPX_EXTENSIONS_NS "
989  "is set. The namespace URI. By default, 'http://osgeo.org/gdal'." ),
990  "http://osgeo.org/gdal" // Default value
991  ) );
992 
993  datasetOptions.insert( "LINEFORMAT", new SetOption(
994  QObject::tr( "By default files are created with the line termination "
995  "conventions of the local platform (CR/LF on win32 or LF "
996  "on all other systems). This may be overridden through use "
997  "of the LINEFORMAT layer creation option which may have a value "
998  "of CRLF (DOS format) or LF (Unix format)." ),
999  QStringList()
1000  << "CRLF"
1001  << "LF",
1002  "", // Default value
1003  true // Allow None
1004  ) );
1005 
1006  driverMetadata.insert( "GPX",
1007  MetaData(
1008  "GPS eXchange Format [GPX]",
1009  QObject::tr( "GPS eXchange Format [GPX]" ),
1010  "*.gpx",
1011  "gpx",
1012  datasetOptions,
1013  layerOptions
1014  )
1015  );
1016 
1017  // INTERLIS 1
1018  datasetOptions.clear();
1019  layerOptions.clear();
1020 
1021  driverMetadata.insert( "Interlis 1",
1022  MetaData(
1023  "INTERLIS 1",
1024  QObject::tr( "INTERLIS 1" ),
1025  "*.itf *.xml *.ili",
1026  "ili",
1027  datasetOptions,
1028  layerOptions
1029  )
1030  );
1031 
1032  // INTERLIS 2
1033  datasetOptions.clear();
1034  layerOptions.clear();
1035 
1036  driverMetadata.insert( "Interlis 2",
1037  MetaData(
1038  "INTERLIS 2",
1039  QObject::tr( "INTERLIS 2" ),
1040  "*.itf *.xml *.ili",
1041  "ili",
1042  datasetOptions,
1043  layerOptions
1044  )
1045  );
1046 
1047  // Keyhole Markup Language [KML]
1048  datasetOptions.clear();
1049  layerOptions.clear();
1050 
1051  datasetOptions.insert( "NameField", new StringOption(
1052  QObject::tr( "Allows you to specify the field to use for the KML <name> element. " ),
1053  "Name" // Default value
1054  ) );
1055 
1056  datasetOptions.insert( "DescriptionField", new StringOption(
1057  QObject::tr( "Allows you to specify the field to use for the KML <description> element." ),
1058  "Description" // Default value
1059  ) );
1060 
1061  datasetOptions.insert( "AltitudeMode", new SetOption(
1062  QObject::tr( "Allows you to specify the AltitudeMode to use for KML geometries. "
1063  "This will only affect 3D geometries and must be one of the valid KML options." ),
1064  QStringList()
1065  << "relativeToGround"
1066  << "clampToGround"
1067  << "absolute",
1068  "relativeToGround" // Default value
1069  ) );
1070 
1071  driverMetadata.insert( "KML",
1072  MetaData(
1073  "Keyhole Markup Language [KML]",
1074  QObject::tr( "Keyhole Markup Language [KML]" ),
1075  "*.kml",
1076  "kml",
1077  datasetOptions,
1078  layerOptions
1079  )
1080  );
1081 
1082  // Mapinfo
1083  datasetOptions.clear();
1084  layerOptions.clear();
1085 
1086  layerOptions.insert( "SPATIAL_INDEX_MODE", new SetOption(
1087  QObject::tr( "Use this to turn on 'quick spatial index mode'. "
1088  "In this mode writing files can be about 5 times faster, "
1089  "but spatial queries can be up to 30 times slower." ),
1090  QStringList()
1091  << "QUICK",
1092  "", // Default value
1093  true // Allow None
1094  ) );
1095 
1096  driverMetadata.insert( "MapInfo File",
1097  MetaData(
1098  "Mapinfo",
1099  QObject::tr( "Mapinfo TAB" ),
1100  "*.tab",
1101  "tab",
1102  datasetOptions,
1103  layerOptions
1104  )
1105  );
1106 
1107  // QGIS internal alias for MIF files
1108  driverMetadata.insert( "MapInfo MIF",
1109  MetaData(
1110  "Mapinfo",
1111  QObject::tr( "Mapinfo MIF" ),
1112  "*.mif",
1113  "mif",
1114  datasetOptions,
1115  layerOptions
1116  )
1117  );
1118 
1119  // Microstation DGN
1120  datasetOptions.clear();
1121  layerOptions.clear();
1122 
1123  datasetOptions.insert( "3D", new BoolOption(
1124  QObject::tr( "Determine whether 2D (seed_2d.dgn) or 3D (seed_3d.dgn) "
1125  "seed file should be used. This option is ignored if the SEED option is provided." ),
1126  false // Default value
1127  ) );
1128 
1129  datasetOptions.insert( "SEED", new StringOption(
1130  QObject::tr( "Override the seed file to use." ),
1131  "" // Default value
1132  ) );
1133 
1134  datasetOptions.insert( "COPY_WHOLE_SEED_FILE", new BoolOption(
1135  QObject::tr( "Indicate whether the whole seed file should be copied. "
1136  "If not, only the first three elements will be copied." ),
1137  false // Default value
1138  ) );
1139 
1140  datasetOptions.insert( "COPY_SEED_FILE_COLOR_TABLEE", new BoolOption(
1141  QObject::tr( "Indicates whether the color table should be copied from the seed file." ),
1142  false // Default value
1143  ) );
1144 
1145  datasetOptions.insert( "MASTER_UNIT_NAME", new StringOption(
1146  QObject::tr( "Override the master unit name from the seed file with "
1147  "the provided one or two character unit name." ),
1148  "" // Default value
1149  ) );
1150 
1151  datasetOptions.insert( "SUB_UNIT_NAME", new StringOption(
1152  QObject::tr( "Override the sub unit name from the seed file with the provided "
1153  "one or two character unit name." ),
1154  "" // Default value
1155  ) );
1156 
1157  datasetOptions.insert( "SUB_UNITS_PER_MASTER_UNIT", new IntOption(
1158  QObject::tr( "Override the number of subunits per master unit. "
1159  "By default the seed file value is used." ),
1160  0 // Default value
1161  ) );
1162 
1163  datasetOptions.insert( "UOR_PER_SUB_UNIT", new IntOption(
1164  QObject::tr( "Override the number of UORs (Units of Resolution) "
1165  "per sub unit. By default the seed file value is used." ),
1166  0 // Default value
1167  ) );
1168 
1169  datasetOptions.insert( "ORIGIN", new StringOption(
1170  QObject::tr( "ORIGIN=x,y,z: Override the origin of the design plane. "
1171  "By default the origin from the seed file is used." ),
1172  "" // Default value
1173  ) );
1174 
1175  driverMetadata.insert( "DGN",
1176  MetaData(
1177  "Microstation DGN",
1178  QObject::tr( "Microstation DGN" ),
1179  "*.dgn",
1180  "dgn",
1181  datasetOptions,
1182  layerOptions
1183  )
1184  );
1185 
1186  // Microstation DGN
1187  datasetOptions.clear();
1188  layerOptions.clear();
1189 
1190  driverMetadata.insert( "DGN",
1191  MetaData(
1192  "Microstation DGN",
1193  QObject::tr( "Microstation DGN" ),
1194  "*.dgn",
1195  "dgn",
1196  datasetOptions,
1197  layerOptions
1198  )
1199  );
1200 
1201  // S-57 Base file
1202  datasetOptions.clear();
1203  layerOptions.clear();
1204 
1205  datasetOptions.insert( "UPDATES", new SetOption(
1206  QObject::tr( "Should update files be incorporated into the base data on the fly. " ),
1207  QStringList()
1208  << "APPLY"
1209  << "IGNORE",
1210  "APPLY" // Default value
1211  ) );
1212 
1213  datasetOptions.insert( "SPLIT_MULTIPOINT", new BoolOption(
1214  QObject::tr( "Should multipoint soundings be split into many single point sounding features. "
1215  "Multipoint geometries are not well handled by many formats, "
1216  "so it can be convenient to split single sounding features with many points "
1217  "into many single point features." ),
1218  false // Default value
1219  ) );
1220 
1221  datasetOptions.insert( "ADD_SOUNDG_DEPTH", new BoolOption(
1222  QObject::tr( "Should a DEPTH attribute be added on SOUNDG features and assign the depth "
1223  "of the sounding. This should only be enabled with SPLIT_MULTIPOINT is "
1224  "also enabled." ),
1225  false // Default value
1226  ) );
1227 
1228  datasetOptions.insert( "RETURN_PRIMITIVES", new BoolOption(
1229  QObject::tr( "Should all the low level geometry primitives be returned as special "
1230  "IsolatedNode, ConnectedNode, Edge and Face layers." ),
1231  true // Default value
1232  ) );
1233 
1234  datasetOptions.insert( "PRESERVE_EMPTY_NUMBERS", new BoolOption(
1235  QObject::tr( "If enabled, numeric attributes assigned an empty string as a value will "
1236  "be preserved as a special numeric value. This option should not generally "
1237  "be needed, but may be useful when translated S-57 to S-57 losslessly." ),
1238  false // Default value
1239  ) );
1240 
1241  datasetOptions.insert( "LNAM_REFS", new BoolOption(
1242  QObject::tr( "Should LNAM and LNAM_REFS fields be attached to features capturing "
1243  "the feature to feature relationships in the FFPT group of the S-57 file." ),
1244  true // Default value
1245  ) );
1246 
1247  datasetOptions.insert( "RETURN_LINKAGES", new BoolOption(
1248  QObject::tr( "Should additional attributes relating features to their underlying "
1249  "geometric primitives be attached. These are the values of the FSPT group, "
1250  "and are primarily needed when doing S-57 to S-57 translations." ),
1251  true // Default value
1252  ) );
1253 
1254  datasetOptions.insert( "RECODE_BY_DSSI", new BoolOption(
1255  QObject::tr( "Should attribute values be recoded to UTF-8 from the character encoding "
1256  "specified in the S57 DSSI record." ),
1257  false // Default value
1258  ) );
1259 
1260  // set OGR_S57_OPTIONS = "RETURN_PRIMITIVES=ON,RETURN_LINKAGES=ON,LNAM_REFS=ON"
1261 
1262  driverMetadata.insert( "S57",
1263  MetaData(
1264  "S-57 Base file",
1265  QObject::tr( "S-57 Base file" ),
1266  "*.000",
1267  "000",
1268  datasetOptions,
1269  layerOptions
1270  )
1271  );
1272 
1273  // Spatial Data Transfer Standard [SDTS]
1274  datasetOptions.clear();
1275  layerOptions.clear();
1276 
1277  driverMetadata.insert( "SDTS",
1278  MetaData(
1279  "Spatial Data Transfer Standard [SDTS]",
1280  QObject::tr( "Spatial Data Transfer Standard [SDTS]" ),
1281  "*catd.ddf",
1282  "ddf",
1283  datasetOptions,
1284  layerOptions
1285  )
1286  );
1287 
1288  // SQLite
1289  datasetOptions.clear();
1290  layerOptions.clear();
1291 
1292  datasetOptions.insert( "METADATA", new BoolOption(
1293  QObject::tr( "Can be used to avoid creating the geometry_columns and spatial_ref_sys "
1294  "tables in a new database. By default these metadata tables are created "
1295  "when a new database is created." ),
1296  true // Default value
1297  ) );
1298 
1299  // Will handle the spatialite alias
1300  datasetOptions.insert( "SPATIALITE", new HiddenOption(
1301  "NO"
1302  ) );
1303 
1304 
1305  datasetOptions.insert( "INIT_WITH_EPSG", new HiddenOption(
1306  "NO"
1307  ) );
1308 
1309  layerOptions.insert( "FORMAT", new SetOption(
1310  QObject::tr( "Controls the format used for the geometry column. Defaults to WKB."
1311  "This is generally more space and processing efficient, but harder "
1312  "to inspect or use in simple applications than WKT (Well Known Text)." ),
1313  QStringList()
1314  << "WKB"
1315  << "WKT",
1316  "WKB" // Default value
1317  ) );
1318 
1319  layerOptions.insert( "LAUNDER", new BoolOption(
1320  QObject::tr( "Controls whether layer and field names will be laundered for easier use "
1321  "in SQLite. Laundered names will be converted to lower case and some special "
1322  "characters(' - #) will be changed to underscores." ),
1323  true // Default value
1324  ) );
1325 
1326  layerOptions.insert( "SPATIAL_INDEX", new HiddenOption(
1327  "NO"
1328  ) );
1329 
1330  layerOptions.insert( "COMPRESS_GEOM", new HiddenOption(
1331  "NO"
1332  ) );
1333 
1334  layerOptions.insert( "SRID", new HiddenOption(
1335  ""
1336  ) );
1337 
1338  layerOptions.insert( "COMPRESS_COLUMNS", new StringOption(
1339  QObject::tr( "column_name1[,column_name2, ...] A list of (String) columns that "
1340  "must be compressed with ZLib DEFLATE algorithm. This might be beneficial "
1341  "for databases that have big string blobs. However, use with care, since "
1342  "the value of such columns will be seen as compressed binary content with "
1343  "other SQLite utilities (or previous OGR versions). With OGR, when inserting, "
1344  "modifying or queryings compressed columns, compression/decompression is "
1345  "done transparently. However, such columns cannot be (easily) queried with "
1346  "an attribute filter or WHERE clause. Note: in table definition, such columns "
1347  "have the 'VARCHAR_deflate' declaration type." ),
1348  "" // Default value
1349  ) );
1350 
1351  driverMetadata.insert( "SQLite",
1352  MetaData(
1353  "SQLite",
1354  QObject::tr( "SQLite" ),
1355  "*.sqlite",
1356  "sqlite",
1357  datasetOptions,
1358  layerOptions
1359  )
1360  );
1361 
1362  // SpatiaLite
1363  datasetOptions.clear();
1364  layerOptions.clear();
1365 
1366  datasetOptions.insert( "METADATA", new BoolOption(
1367  QObject::tr( "Can be used to avoid creating the geometry_columns and spatial_ref_sys "
1368  "tables in a new database. By default these metadata tables are created "
1369  "when a new database is created." ),
1370  true // Default value
1371  ) );
1372 
1373  datasetOptions.insert( "SPATIALITE", new HiddenOption(
1374  "YES"
1375  ) );
1376 
1377  datasetOptions.insert( "INIT_WITH_EPSG", new BoolOption(
1378  QObject::tr( "Insert the content of the EPSG CSV files into the spatial_ref_sys table. "
1379  "Set to NO for regular SQLite databases." ),
1380  true // Default value
1381  ) );
1382 
1383  layerOptions.insert( "FORMAT", new HiddenOption(
1384  "SPATIALITE"
1385  ) );
1386 
1387  layerOptions.insert( "LAUNDER", new BoolOption(
1388  QObject::tr( "Controls whether layer and field names will be laundered for easier use "
1389  "in SQLite. Laundered names will be convered to lower case and some special "
1390  "characters(' - #) will be changed to underscores." ),
1391  true // Default value
1392  ) );
1393 
1394  layerOptions.insert( "SPATIAL_INDEX", new BoolOption(
1395  QObject::tr( "If the database is of the SpatiaLite flavour, and if OGR is linked "
1396  "against libspatialite, this option can be used to control if a spatial "
1397  "index must be created." ),
1398  true // Default value
1399  ) );
1400 
1401  layerOptions.insert( "COMPRESS_GEOM", new BoolOption(
1402  QObject::tr( "If the format of the geometry BLOB is of the SpatiaLite flavour, "
1403  "this option can be used to control if the compressed format for "
1404  "geometries (LINESTRINGs, POLYGONs) must be used" ),
1405  false // Default value
1406  ) );
1407 
1408  layerOptions.insert( "SRID", new StringOption(
1409  QObject::tr( "Used to force the SRID number of the SRS associated with the layer. "
1410  "When this option isn't specified and that a SRS is associated with the "
1411  "layer, a search is made in the spatial_ref_sys to find a match for the "
1412  "SRS, and, if there is no match, a new entry is inserted for the SRS in "
1413  "the spatial_ref_sys table. When the SRID option is specified, this "
1414  "search (and the eventual insertion of a new entry) will not be done: "
1415  "the specified SRID is used as such." ),
1416  "" // Default value
1417  ) );
1418 
1419  layerOptions.insert( "COMPRESS_COLUMNS", new StringOption(
1420  QObject::tr( "column_name1[,column_name2, ...] A list of (String) columns that "
1421  "must be compressed with ZLib DEFLATE algorithm. This might be beneficial "
1422  "for databases that have big string blobs. However, use with care, since "
1423  "the value of such columns will be seen as compressed binary content with "
1424  "other SQLite utilities (or previous OGR versions). With OGR, when inserting, "
1425  "modifying or queryings compressed columns, compression/decompression is "
1426  "done transparently. However, such columns cannot be (easily) queried with "
1427  "an attribute filter or WHERE clause. Note: in table definition, such columns "
1428  "have the 'VARCHAR_deflate' declaration type." ),
1429  "" // Default value
1430  ) );
1431 
1432  driverMetadata.insert( "SpatiaLite",
1433  MetaData(
1434  "SpatiaLite",
1435  QObject::tr( "SpatiaLite" ),
1436  "*.sqlite",
1437  "sqlite",
1438  datasetOptions,
1439  layerOptions
1440  )
1441  );
1442  // AutoCAD DXF
1443  datasetOptions.clear();
1444  layerOptions.clear();
1445 
1446 #if 0
1447 // datasetOptions.insert( "HEADER", new StringOption(
1448  QObject::tr( "Override the header file used - in place of header.dxf." ),
1449  "" // Default value
1450  ) );
1451 
1452  datasetOptions.insert( "TRAILER", new StringOption(
1453  QObject::tr( "Override the trailer file used - in place of trailer.dxf." ),
1454  "" // Default value
1455  ) );
1456 #endif
1457 
1458  driverMetadata.insert( "DXF",
1459  MetaData(
1460  "AutoCAD DXF",
1461  QObject::tr( "AutoCAD DXF" ),
1462  "*.dxf",
1463  "dxf",
1464  datasetOptions,
1465  layerOptions
1466  )
1467  );
1468 
1469  // Geoconcept
1470  datasetOptions.clear();
1471  layerOptions.clear();
1472 
1473  datasetOptions.insert( "EXTENSION", new SetOption(
1474  QObject::tr( "Indicates the GeoConcept export file extension. "
1475  "TXT was used by earlier releases of GeoConcept. GXT is currently used." ),
1476  QStringList()
1477  << "GXT"
1478  << "TXT",
1479  "GXT" // Default value
1480  ) );
1481 
1482 #if 0
1483  datasetOptions.insert( "CONFIG", new StringOption(
1484  QObject::tr( "path to the GCT : the GCT file describe the GeoConcept types definitions: "
1485  "In this file, every line must start with //# followed by a keyword. "
1486  "Lines starting with // are comments." ),
1487  "" // Default value
1488  ) );
1489 #endif
1490 
1491  driverMetadata.insert( "Geoconcept",
1492  MetaData(
1493  "Geoconcept",
1494  QObject::tr( "Geoconcept" ),
1495  "*.gxt *.txt",
1496  "gxt",
1497  datasetOptions,
1498  layerOptions
1499  )
1500  );
1501 
1502  // ESRI FileGDB
1503  datasetOptions.clear();
1504  layerOptions.clear();
1505 
1506  layerOptions.insert( "FEATURE_DATASET", new StringOption(
1507  QObject::tr( "When this option is set, the new layer will be created inside the named "
1508  "FeatureDataset folder. If the folder does not already exist, it will be created." ),
1509  "" // Default value
1510  ) );
1511 
1512  layerOptions.insert( "GEOMETRY_NAME", new StringOption(
1513  QObject::tr( "Set name of geometry column in new layer. Defaults to 'SHAPE'." ),
1514  "SHAPE" // Default value
1515  ) );
1516 
1517  layerOptions.insert( "OID_NAME", new StringOption(
1518  QObject::tr( "Name of the OID column to create. Defaults to 'OBJECTID'." ),
1519  "OBJECTID" // Default value
1520  ) );
1521 
1522  driverMetadata.insert( "FileGDB",
1523  MetaData(
1524  "ESRI FileGDB",
1525  QObject::tr( "ESRI FileGDB" ),
1526  "*.gdb",
1527  "gdb",
1528  datasetOptions,
1529  layerOptions
1530  )
1531  );
1532  return driverMetadata;
1533  }
1534 
1535  bool QgsVectorFileWriter::driverMetadata( const QString& driverName, QgsVectorFileWriter::MetaData& driverMetadata )
1536 {
1537  static const QMap<QString, MetaData> sDriverMetadata = initMetaData();
1538 
1539  QMap<QString, MetaData>::ConstIterator it = sDriverMetadata.constBegin();
1540 
1541  for ( ; it != sDriverMetadata.constEnd(); ++it )
1542  {
1543  if ( it.key().startsWith( driverName ) )
1544  {
1545  driverMetadata = it.value();
1546  return true;
1547  }
1548  }
1549 
1550  return false;
1551 }
1552 
1553 
1554 QgsVectorFileWriter::WriterError QgsVectorFileWriter::hasError()
1555 {
1556  return mError;
1557 }
1558 
1559 QString QgsVectorFileWriter::errorMessage()
1560 {
1561  return mErrorMessage;
1562 }
1563 
1564 bool QgsVectorFileWriter::addFeature( QgsFeature& feature, QgsFeatureRendererV2* renderer, QGis::UnitType outputUnit )
1565 {
1566  // create the feature
1567  OGRFeatureH poFeature = createFeature( feature );
1568  if ( !poFeature )
1569  return false;
1570 
1571  //add OGR feature style type
1572  if ( mSymbologyExport != NoSymbology && renderer )
1573  {
1574  //SymbolLayerSymbology: concatenate ogr styles of all symbollayers
1575  QgsSymbolV2List symbols = renderer->symbolsForFeature( feature );
1576  QString styleString;
1577  QString currentStyle;
1578 
1579  QgsSymbolV2List::const_iterator symbolIt = symbols.constBegin();
1580  for ( ; symbolIt != symbols.constEnd(); ++symbolIt )
1581  {
1582  int nSymbolLayers = ( *symbolIt )->symbolLayerCount();
1583  for ( int i = 0; i < nSymbolLayers; ++i )
1584  {
1585 #if 0
1586  QMap< QgsSymbolLayerV2*, QString >::const_iterator it = mSymbolLayerTable.find(( *symbolIt )->symbolLayer( i ) );
1587  if ( it == mSymbolLayerTable.constEnd() )
1588  {
1589  continue;
1590  }
1591 #endif
1592  double mmsf = mmScaleFactor( mSymbologyScaleDenominator, ( *symbolIt )->outputUnit(), outputUnit );
1593  double musf = mapUnitScaleFactor( mSymbologyScaleDenominator, ( *symbolIt )->outputUnit(), outputUnit );
1594 
1595  currentStyle = ( *symbolIt )->symbolLayer( i )->ogrFeatureStyle( mmsf, musf );//"@" + it.value();
1596 
1597  if ( mSymbologyExport == FeatureSymbology )
1598  {
1599  if ( symbolIt != symbols.constBegin() || i != 0 )
1600  {
1601  styleString.append( ";" );
1602  }
1603  styleString.append( currentStyle );
1604  }
1605  else if ( mSymbologyExport == SymbolLayerSymbology )
1606  {
1607  OGR_F_SetStyleString( poFeature, currentStyle.toLocal8Bit().data() );
1608  if ( !writeFeature( mLayer, poFeature ) )
1609  {
1610  return false;
1611  }
1612  }
1613  }
1614  }
1615  OGR_F_SetStyleString( poFeature, styleString.toLocal8Bit().data() );
1616  }
1617 
1618  if ( mSymbologyExport == NoSymbology || mSymbologyExport == FeatureSymbology )
1619  {
1620  if ( !writeFeature( mLayer, poFeature ) )
1621  {
1622  return false;
1623  }
1624  }
1625 
1626  OGR_F_Destroy( poFeature );
1627  return true;
1628 }
1629 
1630 OGRFeatureH QgsVectorFileWriter::createFeature( QgsFeature& feature )
1631 {
1632  QgsLocaleNumC l;
1633 
1634  OGRFeatureH poFeature = OGR_F_Create( OGR_L_GetLayerDefn( mLayer ) );
1635 
1636  qint64 fid = FID_TO_NUMBER( feature.id() );
1637  if ( fid > std::numeric_limits<int>::max() )
1638  {
1639  QgsDebugMsg( QString( "feature id %1 too large." ).arg( fid ) );
1640  OGRErr err = OGR_F_SetFID( poFeature, static_cast<long>( fid ) );
1641  if ( err != OGRERR_NONE )
1642  {
1643  QgsDebugMsg( QString( "Failed to set feature id to %1: %2 (OGR error: %3)" )
1644  .arg( feature.id() )
1645  .arg( err ).arg( CPLGetLastErrorMsg() )
1646  );
1647  }
1648  }
1649 
1650  // attribute handling
1651  for ( int fldIdx = 0; fldIdx < mFields.count(); ++fldIdx )
1652  {
1653  if ( !mAttrIdxToOgrIdx.contains( fldIdx ) )
1654  {
1655  QgsDebugMsg( QString( "no ogr field for field %1" ).arg( fldIdx ) );
1656  continue;
1657  }
1658 
1659  const QVariant& attrValue = feature.attribute( fldIdx );
1660  int ogrField = mAttrIdxToOgrIdx[ fldIdx ];
1661 
1662  if ( !attrValue.isValid() || attrValue.isNull() )
1663  continue;
1664 
1665  switch ( attrValue.type() )
1666  {
1667  case QVariant::Int:
1668  OGR_F_SetFieldInteger( poFeature, ogrField, attrValue.toInt() );
1669  break;
1670  case QVariant::Double:
1671  OGR_F_SetFieldDouble( poFeature, ogrField, attrValue.toDouble() );
1672  break;
1673  case QVariant::LongLong:
1674  case QVariant::UInt:
1675  case QVariant::ULongLong:
1676  case QVariant::String:
1677  OGR_F_SetFieldString( poFeature, ogrField, mCodec->fromUnicode( attrValue.toString() ).data() );
1678  break;
1679  case QVariant::Date:
1680  OGR_F_SetFieldDateTime( poFeature, ogrField,
1681  attrValue.toDate().year(),
1682  attrValue.toDate().month(),
1683  attrValue.toDate().day(),
1684  0, 0, 0, 0 );
1685  break;
1686  case QVariant::DateTime:
1687  OGR_F_SetFieldDateTime( poFeature, ogrField,
1688  attrValue.toDateTime().date().year(),
1689  attrValue.toDateTime().date().month(),
1690  attrValue.toDateTime().date().day(),
1691  attrValue.toDateTime().time().hour(),
1692  attrValue.toDateTime().time().minute(),
1693  attrValue.toDateTime().time().second(),
1694  0 );
1695  break;
1696  case QVariant::Time:
1697  OGR_F_SetFieldDateTime( poFeature, ogrField,
1698  0, 0, 0,
1699  attrValue.toDateTime().time().hour(),
1700  attrValue.toDateTime().time().minute(),
1701  attrValue.toDateTime().time().second(),
1702  0 );
1703  break;
1704  case QVariant::Invalid:
1705  break;
1706  default:
1707  mErrorMessage = QObject::tr( "Invalid variant type for field %1[%2]: received %3 with type %4" )
1708  .arg( mFields[fldIdx].name() )
1709  .arg( ogrField )
1710  .arg( attrValue.typeName() )
1711  .arg( attrValue.toString() );
1712  QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
1713  mError = ErrFeatureWriteFailed;
1714  return 0;
1715  }
1716  }
1717 
1718  if ( mWkbType != QGis::WKBNoGeometry )
1719  {
1720  // build geometry from WKB
1721  QgsGeometry *geom = feature.geometry();
1722 
1723  // turn single geoemetry to multi geometry if needed
1724  if ( geom && geom->wkbType() != mWkbType && geom->wkbType() == QGis::singleType( mWkbType ) )
1725  {
1726  geom->convertToMultiType();
1727  }
1728 
1729  if ( geom && geom->wkbType() != mWkbType )
1730  {
1731  // there's a problem when layer type is set as wkbtype Polygon
1732  // although there are also features of type MultiPolygon
1733  // (at least in OGR provider)
1734  // If the feature's wkbtype is different from the layer's wkbtype,
1735  // try to export it too.
1736  //
1737  // Btw. OGRGeometry must be exactly of the type of the geometry which it will receive
1738  // i.e. Polygons can't be imported to OGRMultiPolygon
1739 
1740  OGRGeometryH mGeom2 = createEmptyGeometry( geom->wkbType() );
1741 
1742  if ( !mGeom2 )
1743  {
1744  mErrorMessage = QObject::tr( "Feature geometry not imported (OGR error: %1)" )
1745  .arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
1746  mError = ErrFeatureWriteFailed;
1747  QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
1748  OGR_F_Destroy( poFeature );
1749  return 0;
1750  }
1751 
1752  OGRErr err = OGR_G_ImportFromWkb( mGeom2, const_cast<unsigned char *>( geom->asWkb() ), ( int ) geom->wkbSize() );
1753  if ( err != OGRERR_NONE )
1754  {
1755  mErrorMessage = QObject::tr( "Feature geometry not imported (OGR error: %1)" )
1756  .arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
1757  mError = ErrFeatureWriteFailed;
1758  QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
1759  OGR_F_Destroy( poFeature );
1760  return 0;
1761  }
1762 
1763  // pass ownership to geometry
1764  OGR_F_SetGeometryDirectly( poFeature, mGeom2 );
1765  }
1766  else if ( geom )
1767  {
1768  OGRErr err = OGR_G_ImportFromWkb( mGeom, const_cast<unsigned char *>( geom->asWkb() ), ( int ) geom->wkbSize() );
1769  if ( err != OGRERR_NONE )
1770  {
1771  mErrorMessage = QObject::tr( "Feature geometry not imported (OGR error: %1)" )
1772  .arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
1773  mError = ErrFeatureWriteFailed;
1774  QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
1775  OGR_F_Destroy( poFeature );
1776  return 0;
1777  }
1778 
1779  // set geometry (ownership is not passed to OGR)
1780  OGR_F_SetGeometry( poFeature, mGeom );
1781  }
1782  }
1783  return poFeature;
1784 }
1785 
1786 bool QgsVectorFileWriter::writeFeature( OGRLayerH layer, OGRFeatureH feature )
1787 {
1788  if ( OGR_L_CreateFeature( layer, feature ) != OGRERR_NONE )
1789  {
1790  mErrorMessage = QObject::tr( "Feature creation error (OGR error: %1)" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) );
1791  mError = ErrFeatureWriteFailed;
1792  QgsMessageLog::logMessage( mErrorMessage, QObject::tr( "OGR" ) );
1793  OGR_F_Destroy( feature );
1794  return false;
1795  }
1796  return true;
1797 }
1798 
1799 QgsVectorFileWriter::~QgsVectorFileWriter()
1800 {
1801  if ( mGeom )
1802  {
1803  OGR_G_DestroyGeometry( mGeom );
1804  }
1805 
1806  if ( mDS )
1807  {
1808  OGR_DS_Destroy( mDS );
1809  }
1810 }
1811 
1812 QgsVectorFileWriter::WriterError
1813 QgsVectorFileWriter::writeAsVectorFormat( QgsVectorLayer* layer,
1814  const QString& fileName,
1815  const QString& fileEncoding,
1816  const QgsCoordinateReferenceSystem *destCRS,
1817  const QString& driverName,
1818  bool onlySelected,
1819  QString *errorMessage,
1820  const QStringList &datasourceOptions,
1821  const QStringList &layerOptions,
1822  bool skipAttributeCreation,
1823  QString *newFilename,
1824  SymbologyExport symbologyExport,
1825  double symbologyScale,
1826  const QgsRectangle* filterExtent )
1827 {
1828  QgsCoordinateTransform* ct = 0;
1829  if ( destCRS && layer )
1830  {
1831  ct = new QgsCoordinateTransform( layer->crs(), *destCRS );
1832  }
1833 
1834  QgsVectorFileWriter::WriterError error = writeAsVectorFormat( layer, fileName, fileEncoding, ct, driverName, onlySelected,
1835  errorMessage, datasourceOptions, layerOptions, skipAttributeCreation, newFilename, symbologyExport, symbologyScale, filterExtent );
1836  delete ct;
1837  return error;
1838 }
1839 
1840 QgsVectorFileWriter::WriterError QgsVectorFileWriter::writeAsVectorFormat( QgsVectorLayer* layer,
1841  const QString& fileName,
1842  const QString& fileEncoding,
1843  const QgsCoordinateTransform* ct,
1844  const QString& driverName,
1845  bool onlySelected,
1846  QString *errorMessage,
1847  const QStringList &datasourceOptions,
1848  const QStringList &layerOptions,
1849  bool skipAttributeCreation,
1850  QString *newFilename,
1851  SymbologyExport symbologyExport,
1852  double symbologyScale,
1853  const QgsRectangle* filterExtent )
1854 {
1855  if ( !layer )
1856  {
1857  return ErrInvalidLayer;
1858  }
1859 
1860  bool shallTransform = false;
1861  const QgsCoordinateReferenceSystem* outputCRS = 0;
1862  if ( ct )
1863  {
1864  // This means we should transform
1865  outputCRS = &( ct->destCRS() );
1866  shallTransform = true;
1867  }
1868  else
1869  {
1870  // This means we shouldn't transform, use source CRS as output (if defined)
1871  outputCRS = &layer->crs();
1872  }
1873 
1874  QGis::WkbType wkbType = layer->wkbType();
1875  QgsFields fields = skipAttributeCreation ? QgsFields() : layer->pendingFields();
1876 
1877  if ( layer->providerType() == "ogr" && layer->dataProvider() )
1878  {
1879  QStringList theURIParts = layer->dataProvider()->dataSourceUri().split( "|" );
1880  QString srcFileName = theURIParts[0];
1881 
1882  if ( QFile::exists( srcFileName ) && QFileInfo( fileName ).canonicalFilePath() == QFileInfo( srcFileName ).canonicalFilePath() )
1883  {
1884  if ( errorMessage )
1885  *errorMessage = QObject::tr( "Cannot overwrite a OGR layer in place" );
1886  return ErrCreateDataSource;
1887  }
1888 
1889  // Shapefiles might contain multi types although wkbType() only reports singles
1890  if ( layer->storageType() == "ESRI Shapefile" )
1891  {
1892  const QgsFeatureIds &ids = layer->selectedFeaturesIds();
1893  QgsFeatureIterator fit = layer->getFeatures();
1894  QgsFeature fet;
1895  while ( fit.nextFeature( fet ) )
1896  {
1897  if ( onlySelected && !ids.contains( fet.id() ) )
1898  continue;
1899 
1900  if ( fet.constGeometry() && fet.constGeometry()->wkbType() == QGis::multiType( wkbType ) )
1901  {
1902  wkbType = QGis::multiType( wkbType );
1903  break;
1904  }
1905  }
1906  }
1907  }
1908  else if ( layer->providerType() == "spatialite" )
1909  {
1910  for ( int i = 0; i < fields.size(); i++ )
1911  {
1912  if ( fields[i].type() == QVariant::LongLong )
1913  {
1914  QVariant min = layer->minimumValue( i );
1915  QVariant max = layer->maximumValue( i );
1916  if ( qMax( qAbs( min.toLongLong() ), qAbs( max.toLongLong() ) ) < INT_MAX )
1917  {
1918  fields[i].setType( QVariant::Int );
1919  }
1920  }
1921  }
1922  }
1923 
1924  QgsVectorFileWriter* writer =
1925  new QgsVectorFileWriter( fileName, fileEncoding, fields, wkbType, outputCRS, driverName, datasourceOptions, layerOptions, newFilename, symbologyExport );
1926  writer->setSymbologyScaleDenominator( symbologyScale );
1927 
1928  if ( newFilename )
1929  {
1930  QgsDebugMsg( "newFilename = " + *newFilename );
1931  }
1932 
1933  // check whether file creation was successful
1934  WriterError err = writer->hasError();
1935  if ( err != NoError )
1936  {
1937  if ( errorMessage )
1938  *errorMessage = writer->errorMessage();
1939  delete writer;
1940  return err;
1941  }
1942 
1943  if ( errorMessage )
1944  {
1945  errorMessage->clear();
1946  }
1947 
1948  QgsAttributeList allAttr = skipAttributeCreation ? QgsAttributeList() : layer->pendingAllAttributesList();
1949  QgsFeature fet;
1950 
1951  //add possible attributes needed by renderer
1952  writer->addRendererAttributes( layer, allAttr );
1953 
1954  QgsFeatureRequest req;
1955  if ( layer->wkbType() == QGis::WKBNoGeometry )
1956  {
1957  req.setFlags( QgsFeatureRequest::NoGeometry );
1958  }
1959  req.setSubsetOfAttributes( allAttr );
1960  QgsFeatureIterator fit = layer->getFeatures( req );
1961 
1962  const QgsFeatureIds& ids = layer->selectedFeaturesIds();
1963 
1964  //create symbol table if needed
1965  if ( writer->symbologyExport() != NoSymbology )
1966  {
1967  //writer->createSymbolLayerTable( layer, writer->mDS );
1968  }
1969 
1970  if ( writer->symbologyExport() == SymbolLayerSymbology )
1971  {
1972  QgsFeatureRendererV2* r = layer->rendererV2();
1973  if ( r->capabilities() & QgsFeatureRendererV2::SymbolLevels
1974  && r->usingSymbolLevels() )
1975  {
1976  QgsVectorFileWriter::WriterError error = writer->exportFeaturesSymbolLevels( layer, fit, ct, errorMessage );
1977  delete writer;
1978  return ( error == NoError ) ? NoError : ErrFeatureWriteFailed;
1979  }
1980  }
1981 
1982  int n = 0, errors = 0;
1983 
1984  //unit type
1985  QGis::UnitType mapUnits = layer->crs().mapUnits();
1986  if ( ct )
1987  {
1988  mapUnits = ct->destCRS().mapUnits();
1989  }
1990 
1991  writer->startRender( layer );
1992 
1993  // enabling transaction on databases that support it
1994  bool transactionsEnabled = true;
1995 
1996  if ( OGRERR_NONE != OGR_L_StartTransaction( writer->mLayer ) )
1997  {
1998  QgsDebugMsg( "Error when trying to enable transactions on OGRLayer." );
1999  transactionsEnabled = false;
2000  }
2001 
2002  // write all features
2003  while ( fit.nextFeature( fet ) )
2004  {
2005  if ( onlySelected && !ids.contains( fet.id() ) )
2006  continue;
2007 
2008  if ( shallTransform )
2009  {
2010  try
2011  {
2012  if ( fet.geometry() )
2013  {
2014  fet.geometry()->transform( *ct );
2015  }
2016  }
2017  catch ( QgsCsException &e )
2018  {
2019  delete writer;
2020 
2021  QString msg = QObject::tr( "Failed to transform a point while drawing a feature with ID '%1'. Writing stopped. (Exception: %2)" )
2022  .arg( fet.id() ).arg( e.what() );
2023  QgsLogger::warning( msg );
2024  if ( errorMessage )
2025  *errorMessage = msg;
2026 
2027  return ErrProjection;
2028  }
2029  }
2030 
2031  if ( fet.constGeometry() && filterExtent && !fet.constGeometry()->intersects( *filterExtent ) )
2032  continue;
2033 
2034  if ( allAttr.size() < 1 && skipAttributeCreation )
2035  {
2036  fet.initAttributes( 0 );
2037  }
2038 
2039  if ( !writer->addFeature( fet, layer->rendererV2(), mapUnits ) )
2040  {
2041  WriterError err = writer->hasError();
2042  if ( err != NoError && errorMessage )
2043  {
2044  if ( errorMessage->isEmpty() )
2045  {
2046  *errorMessage = QObject::tr( "Feature write errors:" );
2047  }
2048  *errorMessage += "\n" + writer->errorMessage();
2049  }
2050  errors++;
2051 
2052  if ( errors > 1000 )
2053  {
2054  if ( errorMessage )
2055  {
2056  *errorMessage += QObject::tr( "Stopping after %1 errors" ).arg( errors );
2057  }
2058 
2059  n = -1;
2060  break;
2061  }
2062  }
2063  n++;
2064  }
2065 
2066  if ( transactionsEnabled )
2067  {
2068  if ( OGRERR_NONE != OGR_L_CommitTransaction( writer->mLayer ) )
2069  {
2070  QgsDebugMsg( "Error while committing transaction on OGRLayer." );
2071  }
2072  }
2073 
2074  writer->stopRender( layer );
2075  delete writer;
2076 
2077  if ( errors > 0 && errorMessage && n > 0 )
2078  {
2079  *errorMessage += QObject::tr( "\nOnly %1 of %2 features written." ).arg( n - errors ).arg( n );
2080  }
2081 
2082  return errors == 0 ? NoError : ErrFeatureWriteFailed;
2083 }
2084 
2085 
2086 bool QgsVectorFileWriter::deleteShapeFile( QString theFileName )
2087 {
2088  QFileInfo fi( theFileName );
2089  QDir dir = fi.dir();
2090 
2091  QStringList filter;
2092  const char *suffixes[] = { ".shp", ".shx", ".dbf", ".prj", ".qix", ".qpj" };
2093  for ( std::size_t i = 0; i < sizeof( suffixes ) / sizeof( *suffixes ); i++ )
2094  {
2095  filter << fi.completeBaseName() + suffixes[i];
2096  }
2097 
2098  bool ok = true;
2099  foreach ( QString file, dir.entryList( filter ) )
2100  {
2101  QFile f( dir.canonicalPath() + "/" + file );
2102  if ( !f.remove( ) )
2103  {
2104  QgsDebugMsg( QString( "Removing file %1 failed: %2" ).arg( file ).arg( f.errorString() ) );
2105  ok = false;
2106  }
2107  }
2108 
2109  return ok;
2110 }
2111 
2112 QMap< QString, QString> QgsVectorFileWriter::supportedFiltersAndFormats()
2113 {
2114  QMap<QString, QString> resultMap;
2115 
2116  QgsApplication::registerOgrDrivers();
2117  int const drvCount = OGRGetDriverCount();
2118 
2119  for ( int i = 0; i < drvCount; ++i )
2120  {
2121  OGRSFDriverH drv = OGRGetDriver( i );
2122  if ( drv )
2123  {
2124  QString drvName = OGR_Dr_GetName( drv );
2125  if ( OGR_Dr_TestCapability( drv, "CreateDataSource" ) != 0 )
2126  {
2127  QString filterString = filterForDriver( drvName );
2128  if ( filterString.isEmpty() )
2129  continue;
2130 
2131  resultMap.insert( filterString, drvName );
2132  }
2133  }
2134  }
2135 
2136  return resultMap;
2137 }
2138 
2139 QMap<QString, QString> QgsVectorFileWriter::ogrDriverList()
2140 {
2141  QMap<QString, QString> resultMap;
2142 
2143  QgsApplication::registerOgrDrivers();
2144  int const drvCount = OGRGetDriverCount();
2145 
2146  QStringList writableDrivers;
2147  for ( int i = 0; i < drvCount; ++i )
2148  {
2149  OGRSFDriverH drv = OGRGetDriver( i );
2150  if ( drv )
2151  {
2152  QString drvName = OGR_Dr_GetName( drv );
2153  if ( OGR_Dr_TestCapability( drv, "CreateDataSource" ) != 0 )
2154  {
2155  // Add separate format for Mapinfo MIF (MITAB is OGR default)
2156  if ( drvName == "MapInfo File" )
2157  {
2158  writableDrivers << "MapInfo MIF";
2159  }
2160  else if ( drvName == "SQLite" )
2161  {
2162  // Unfortunately it seems that there is no simple way to detect if
2163  // OGR SQLite driver is compiled with SpatiaLite support.
2164  // We have HAVE_SPATIALITE in QGIS, but that may differ from OGR
2165  // http://lists.osgeo.org/pipermail/gdal-dev/2012-November/034580.html
2166  // -> test if creation failes
2167  QString option = "SPATIALITE=YES";
2168  char **options = new char *[2];
2169  options[0] = CPLStrdup( option.toLocal8Bit().data() );
2170  options[1] = NULL;
2171  OGRSFDriverH poDriver;
2172  QgsApplication::registerOgrDrivers();
2173  poDriver = OGRGetDriverByName( drvName.toLocal8Bit().data() );
2174  if ( poDriver )
2175  {
2176  OGRDataSourceH ds = OGR_Dr_CreateDataSource( poDriver, TO8F( QString( "/vsimem/spatialitetest.sqlite" ) ), options );
2177  if ( ds )
2178  {
2179  writableDrivers << "SpatiaLite";
2180  OGR_Dr_DeleteDataSource( poDriver, TO8F( QString( "/vsimem/spatialitetest.sqlite" ) ) );
2181  OGR_DS_Destroy( ds );
2182  }
2183  }
2184  CPLFree( options[0] );
2185  delete [] options;
2186  }
2187  else if ( drvName == "ESRI Shapefile" )
2188  {
2189  writableDrivers << "DBF file";
2190  }
2191  writableDrivers << drvName;
2192  }
2193  }
2194  }
2195 
2196  foreach ( QString drvName, writableDrivers )
2197  {
2198  QString longName;
2199  QString trLongName;
2200  QString glob;
2201  QString exts;
2202  if ( QgsVectorFileWriter::driverMetadata( drvName, longName, trLongName, glob, exts ) && !trLongName.isEmpty() )
2203  {
2204  resultMap.insert( trLongName, drvName );
2205  }
2206  }
2207 
2208  return resultMap;
2209 }
2210 
2211 QString QgsVectorFileWriter::fileFilterString()
2212 {
2213  QString filterString;
2214  QMap< QString, QString> driverFormatMap = supportedFiltersAndFormats();
2215  QMap< QString, QString>::const_iterator it = driverFormatMap.constBegin();
2216  for ( ; it != driverFormatMap.constEnd(); ++it )
2217  {
2218  if ( !filterString.isEmpty() )
2219  filterString += ";;";
2220 
2221  filterString += it.key();
2222  }
2223  return filterString;
2224 }
2225 
2226 QString QgsVectorFileWriter::filterForDriver( const QString& driverName )
2227 {
2228  QString longName;
2229  QString trLongName;
2230  QString glob;
2231  QString exts;
2232  if ( !driverMetadata( driverName, longName, trLongName, glob, exts ) || trLongName.isEmpty() || glob.isEmpty() )
2233  return "";
2234 
2235  return trLongName + " [OGR] (" + glob.toLower() + " " + glob.toUpper() + ")";
2236 }
2237 
2238 QString QgsVectorFileWriter::convertCodecNameForEncodingOption( const QString &codecName )
2239 {
2240  if ( codecName == "System" )
2241  return QString( "LDID/0" );
2242 
2243  QRegExp re = QRegExp( QString( "(CP|windows-|ISO[ -])(.+)" ), Qt::CaseInsensitive );
2244  if ( re.exactMatch( codecName ) )
2245  {
2246  QString c = re.cap( 2 ).replace( "-", "" );
2247  bool isNumber;
2248  c.toInt( &isNumber );
2249  if ( isNumber )
2250  return c;
2251  }
2252  return codecName;
2253 }
2254 
2255 bool QgsVectorFileWriter::driverMetadata( QString driverName, QString &longName, QString &trLongName, QString &glob, QString &ext )
2256 {
2257  if ( driverName.startsWith( "AVCE00" ) )
2258  {
2259  longName = "Arc/Info ASCII Coverage";
2260  trLongName = QObject::tr( "Arc/Info ASCII Coverage" );
2261  glob = "*.e00";
2262  ext = "e00";
2263  }
2264  else if ( driverName.startsWith( "BNA" ) )
2265  {
2266  longName = "Atlas BNA";
2267  trLongName = QObject::tr( "Atlas BNA" );
2268  glob = "*.bna";
2269  ext = "bna";
2270  }
2271  else if ( driverName.startsWith( "CSV" ) )
2272  {
2273  longName = "Comma Separated Value [CSV]";
2274  trLongName = QObject::tr( "Comma Separated Value [CSV]" );
2275  glob = "*.csv";
2276  ext = "csv";
2277  }
2278  else if ( driverName.startsWith( "ESRI" ) )
2279  {
2280  longName = "ESRI Shapefile";
2281  trLongName = QObject::tr( "ESRI Shapefile" );
2282  glob = "*.shp";
2283  ext = "shp";
2284  }
2285  else if ( driverName.startsWith( "DBF file" ) )
2286  {
2287  longName = "DBF File";
2288  trLongName = QObject::tr( "DBF file" );
2289  glob = "*.dbf";
2290  ext = "dbf";
2291  }
2292  else if ( driverName.startsWith( "FMEObjects Gateway" ) )
2293  {
2294  longName = "FMEObjects Gateway";
2295  trLongName = QObject::tr( "FMEObjects Gateway" );
2296  glob = "*.fdd";
2297  ext = "fdd";
2298  }
2299  else if ( driverName.startsWith( "GeoJSON" ) )
2300  {
2301  longName = "GeoJSON";
2302  trLongName = QObject::tr( "GeoJSON" );
2303  glob = "*.geojson";
2304  ext = "geojson";
2305  }
2306  else if ( driverName.startsWith( "GPKG" ) )
2307  {
2308  longName = "GeoPackage";
2309  trLongName = QObject::tr( "GeoPackage" );
2310  glob = "*.gpkg";
2311  ext = "gpkg";
2312  }
2313  else if ( driverName.startsWith( "GeoRSS" ) )
2314  {
2315  longName = "GeoRSS";
2316  trLongName = QObject::tr( "GeoRSS" );
2317  glob = "*.xml";
2318  ext = "xml";
2319  }
2320  else if ( driverName.startsWith( "GML" ) )
2321  {
2322  longName = "Geography Markup Language [GML]";
2323  trLongName = QObject::tr( "Geography Markup Language [GML]" );
2324  glob = "*.gml";
2325  ext = "gml";
2326  }
2327  else if ( driverName.startsWith( "GMT" ) )
2328  {
2329  longName = "Generic Mapping Tools [GMT]";
2330  trLongName = QObject::tr( "Generic Mapping Tools [GMT]" );
2331  glob = "*.gmt";
2332  ext = "gmt";
2333  }
2334  else if ( driverName.startsWith( "GPX" ) )
2335  {
2336  longName = "GPS eXchange Format [GPX]";
2337  trLongName = QObject::tr( "GPS eXchange Format [GPX]" );
2338  glob = "*.gpx";
2339  ext = "gpx";
2340  }
2341  else if ( driverName.startsWith( "Interlis 1" ) )
2342  {
2343  longName = "INTERLIS 1";
2344  trLongName = QObject::tr( "INTERLIS 1" );
2345  glob = "*.itf *.xml *.ili";
2346  ext = "ili";
2347  }
2348  else if ( driverName.startsWith( "Interlis 2" ) )
2349  {
2350  longName = "INTERLIS 2";
2351  trLongName = QObject::tr( "INTERLIS 2" );
2352  glob = "*.itf *.xml *.ili";
2353  ext = "ili";
2354  }
2355  else if ( driverName.startsWith( "KML" ) )
2356  {
2357  longName = "Keyhole Markup Language [KML]";
2358  trLongName = QObject::tr( "Keyhole Markup Language [KML]" );
2359  glob = "*.kml";
2360  ext = "kml";
2361  }
2362  else if ( driverName.startsWith( "MapInfo File" ) )
2363  {
2364  longName = "Mapinfo TAB";
2365  trLongName = QObject::tr( "Mapinfo TAB" );
2366  glob = "*.tab";
2367  ext = "tab";
2368  }
2369  // 'MapInfo MIF' is internal QGIS addition to distinguish between MITAB and MIF
2370  else if ( driverName.startsWith( "MapInfo MIF" ) )
2371  {
2372  longName = "Mapinfo MIF";
2373  trLongName = QObject::tr( "Mapinfo MIF" );
2374  glob = "*.mif";
2375  ext = "mif";
2376  }
2377  else if ( driverName.startsWith( "DGN" ) )
2378  {
2379  longName = "Microstation DGN";
2380  trLongName = QObject::tr( "Microstation DGN" );
2381  glob = "*.dgn";
2382  ext = "dgn";
2383  }
2384  else if ( driverName.startsWith( "S57" ) )
2385  {
2386  longName = "S-57 Base file";
2387  trLongName = QObject::tr( "S-57 Base file" );
2388  glob = "*.000";
2389  ext = "000";
2390  }
2391  else if ( driverName.startsWith( "SDTS" ) )
2392  {
2393  longName = "Spatial Data Transfer Standard [SDTS]";
2394  trLongName = QObject::tr( "Spatial Data Transfer Standard [SDTS]" );
2395  glob = "*catd.ddf";
2396  ext = "ddf";
2397  }
2398  else if ( driverName.startsWith( "SQLite" ) )
2399  {
2400  longName = "SQLite";
2401  trLongName = QObject::tr( "SQLite" );
2402  glob = "*.sqlite";
2403  ext = "sqlite";
2404  }
2405  // QGIS internal addition for SpatialLite
2406  else if ( driverName.startsWith( "SpatiaLite" ) )
2407  {
2408  longName = "SpatiaLite";
2409  trLongName = QObject::tr( "SpatiaLite" );
2410  glob = "*.sqlite";
2411  ext = "sqlite";
2412  }
2413  else if ( driverName.startsWith( "DXF" ) )
2414  {
2415  longName = "AutoCAD DXF";
2416  trLongName = QObject::tr( "AutoCAD DXF" );
2417  glob = "*.dxf";
2418  ext = "dxf";
2419  }
2420  else if ( driverName.startsWith( "Geoconcept" ) )
2421  {
2422  longName = "Geoconcept";
2423  trLongName = QObject::tr( "Geoconcept" );
2424  glob = "*.gxt *.txt";
2425  ext = "gxt";
2426  }
2427  else if ( driverName.startsWith( "FileGDB" ) )
2428  {
2429  longName = "ESRI FileGDB";
2430  trLongName = QObject::tr( "ESRI FileGDB" );
2431  glob = "*.gdb";
2432  ext = "gdb";
2433  }
2434  else
2435  {
2436  return false;
2437  }
2438 
2439  return true;
2440 }
2441 
2442 void QgsVectorFileWriter::createSymbolLayerTable( QgsVectorLayer* vl, const QgsCoordinateTransform* ct, OGRDataSourceH ds )
2443 {
2444  if ( !vl || !ds )
2445  {
2446  return;
2447  }
2448 
2449  QgsFeatureRendererV2* renderer = vl->rendererV2();
2450  if ( !renderer )
2451  {
2452  return;
2453  }
2454 
2455  //unit type
2456  QGis::UnitType mapUnits = vl->crs().mapUnits();
2457  if ( ct )
2458  {
2459  mapUnits = ct->destCRS().mapUnits();
2460  }
2461 
2462 #if defined(GDAL_VERSION_NUM) && GDAL_VERSION_NUM >= 1700
2463  mSymbolLayerTable.clear();
2464  OGRStyleTableH ogrStyleTable = OGR_STBL_Create();
2465  OGRStyleMgrH styleManager = OGR_SM_Create( ogrStyleTable );
2466 
2467  //get symbols
2468  int nTotalLevels = 0;
2469  QgsSymbolV2List symbolList = renderer->symbols();
2470  QgsSymbolV2List::iterator symbolIt = symbolList.begin();
2471  for ( ; symbolIt != symbolList.end(); ++symbolIt )
2472  {
2473  double mmsf = mmScaleFactor( mSymbologyScaleDenominator, ( *symbolIt )->outputUnit(), mapUnits );
2474  double musf = mapUnitScaleFactor( mSymbologyScaleDenominator, ( *symbolIt )->outputUnit(), mapUnits );
2475 
2476  int nLevels = ( *symbolIt )->symbolLayerCount();
2477  for ( int i = 0; i < nLevels; ++i )
2478  {
2479  mSymbolLayerTable.insert(( *symbolIt )->symbolLayer( i ), QString::number( nTotalLevels ) );
2480  OGR_SM_AddStyle( styleManager, QString::number( nTotalLevels ).toLocal8Bit(),
2481  ( *symbolIt )->symbolLayer( i )->ogrFeatureStyle( mmsf, musf ).toLocal8Bit() );
2482  ++nTotalLevels;
2483  }
2484  }
2485  OGR_DS_SetStyleTableDirectly( ds, ogrStyleTable );
2486 #endif
2487 }
2488 
2489 QgsVectorFileWriter::WriterError QgsVectorFileWriter::exportFeaturesSymbolLevels( QgsVectorLayer* layer, QgsFeatureIterator& fit,
2490  const QgsCoordinateTransform* ct, QString* errorMessage )
2491 {
2492  if ( !layer )
2493  return ErrInvalidLayer;
2494 
2495  QgsFeatureRendererV2 *renderer = layer->rendererV2();
2496  if ( !renderer )
2497  return ErrInvalidLayer;
2498 
2499  QHash< QgsSymbolV2*, QList<QgsFeature> > features;
2500 
2501  //unit type
2502  QGis::UnitType mapUnits = layer->crs().mapUnits();
2503  if ( ct )
2504  {
2505  mapUnits = ct->destCRS().mapUnits();
2506  }
2507 
2508  startRender( layer );
2509 
2510  //fetch features
2511  QgsFeature fet;
2512  QgsSymbolV2* featureSymbol = 0;
2513  while ( fit.nextFeature( fet ) )
2514  {
2515  if ( ct )
2516  {
2517  try
2518  {
2519  if ( fet.geometry() )
2520  {
2521  fet.geometry()->transform( *ct );
2522  }
2523  }
2524  catch ( QgsCsException &e )
2525  {
2526  QString msg = QObject::tr( "Failed to transform, writing stopped. (Exception: %1)" )
2527  .arg( e.what() );
2528  QgsLogger::warning( msg );
2529  if ( errorMessage )
2530  *errorMessage = msg;
2531 
2532  return ErrProjection;
2533  }
2534  }
2535 
2536  featureSymbol = renderer->symbolForFeature( fet );
2537  if ( !featureSymbol )
2538  {
2539  continue;
2540  }
2541 
2542  QHash< QgsSymbolV2*, QList<QgsFeature> >::iterator it = features.find( featureSymbol );
2543  if ( it == features.end() )
2544  {
2545  it = features.insert( featureSymbol, QList<QgsFeature>() );
2546  }
2547  it.value().append( fet );
2548  }
2549 
2550  //find out order
2551  QgsSymbolV2LevelOrder levels;
2552  QgsSymbolV2List symbols = renderer->symbols();
2553  for ( int i = 0; i < symbols.count(); i++ )
2554  {
2555  QgsSymbolV2* sym = symbols[i];
2556  for ( int j = 0; j < sym->symbolLayerCount(); j++ )
2557  {
2558  int level = sym->symbolLayer( j )->renderingPass();
2559  if ( level < 0 || level >= 1000 ) // ignore invalid levels
2560  continue;
2561  QgsSymbolV2LevelItem item( sym, j );
2562  while ( level >= levels.count() ) // append new empty levels
2563  levels.append( QgsSymbolV2Level() );
2564  levels[level].append( item );
2565  }
2566  }
2567 
2568  int nErrors = 0;
2569  int nTotalFeatures = 0;
2570 
2571  //export symbol layers and symbology
2572  for ( int l = 0; l < levels.count(); l++ )
2573  {
2574  QgsSymbolV2Level& level = levels[l];
2575  for ( int i = 0; i < level.count(); i++ )
2576  {
2577  QgsSymbolV2LevelItem& item = level[i];
2578  QHash< QgsSymbolV2*, QList<QgsFeature> >::iterator levelIt = features.find( item.symbol() );
2579  if ( levelIt == features.end() )
2580  {
2581  ++nErrors;
2582  continue;
2583  }
2584 
2585  double mmsf = mmScaleFactor( mSymbologyScaleDenominator, levelIt.key()->outputUnit(), mapUnits );
2586  double musf = mapUnitScaleFactor( mSymbologyScaleDenominator, levelIt.key()->outputUnit(), mapUnits );
2587 
2588  int llayer = item.layer();
2589  QList<QgsFeature>& featureList = levelIt.value();
2590  QList<QgsFeature>::iterator featureIt = featureList.begin();
2591  for ( ; featureIt != featureList.end(); ++featureIt )
2592  {
2593  ++nTotalFeatures;
2594  OGRFeatureH ogrFeature = createFeature( *featureIt );
2595  if ( !ogrFeature )
2596  {
2597  ++nErrors;
2598  continue;
2599  }
2600 
2601  QString styleString = levelIt.key()->symbolLayer( llayer )->ogrFeatureStyle( mmsf, musf );
2602  if ( !styleString.isEmpty() )
2603  {
2604  OGR_F_SetStyleString( ogrFeature, styleString.toLocal8Bit().data() );
2605  if ( ! writeFeature( mLayer, ogrFeature ) )
2606  {
2607  ++nErrors;
2608  }
2609  }
2610  OGR_F_Destroy( ogrFeature );
2611  }
2612  }
2613  }
2614 
2615  stopRender( layer );
2616 
2617  if ( nErrors > 0 && errorMessage )
2618  {
2619  *errorMessage += QObject::tr( "\nOnly %1 of %2 features written." ).arg( nTotalFeatures - nErrors ).arg( nTotalFeatures );
2620  }
2621 
2622  return ( nErrors > 0 ) ? QgsVectorFileWriter::ErrFeatureWriteFailed : QgsVectorFileWriter::NoError;
2623 }
2624 
2625 double QgsVectorFileWriter::mmScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, QGis::UnitType mapUnits )
2626 {
2627  if ( symbolUnits == QgsSymbolV2::MM )
2628  {
2629  return 1.0;
2630  }
2631  else
2632  {
2633  //conversion factor map units -> mm
2634  if ( mapUnits == QGis::Meters )
2635  {
2636  return 1000 / scaleDenominator;
2637  }
2638 
2639  }
2640  return 1.0; //todo: map units
2641 }
2642 
2643 double QgsVectorFileWriter::mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, QGis::UnitType mapUnits )
2644 {
2645  if ( symbolUnits == QgsSymbolV2::MapUnit )
2646  {
2647  return 1.0;
2648  }
2649  else
2650  {
2651  if ( symbolUnits == QgsSymbolV2::MM && mapUnits == QGis::Meters )
2652  {
2653  return scaleDenominator / 1000;
2654  }
2655  }
2656  return 1.0;
2657 }
2658 
2659 QgsRenderContext QgsVectorFileWriter::renderContext() const
2660 {
2661  QgsRenderContext context;
2662  context.setRendererScale( mSymbologyScaleDenominator );
2663  return context;
2664 }
2665 
2666 void QgsVectorFileWriter::startRender( QgsVectorLayer* vl ) const
2667 {
2668  QgsFeatureRendererV2* renderer = symbologyRenderer( vl );
2669  if ( !renderer )
2670  {
2671  return;
2672  }
2673 
2674  QgsRenderContext ctx = renderContext();
2675  renderer->startRender( ctx, vl->pendingFields() );
2676 }
2677 
2678 void QgsVectorFileWriter::stopRender( QgsVectorLayer* vl ) const
2679 {
2680  QgsFeatureRendererV2* renderer = symbologyRenderer( vl );
2681  if ( !renderer )
2682  {
2683  return;
2684  }
2685 
2686  QgsRenderContext ctx = renderContext();
2687  renderer->stopRender( ctx );
2688 }
2689 
2690 QgsFeatureRendererV2* QgsVectorFileWriter::symbologyRenderer( QgsVectorLayer* vl ) const
2691 {
2692  if ( mSymbologyExport == NoSymbology )
2693  {
2694  return 0;
2695  }
2696  if ( !vl )
2697  {
2698  return 0;
2699  }
2700 
2701  return vl->rendererV2();
2702 }
2703 
2704 void QgsVectorFileWriter::addRendererAttributes( QgsVectorLayer* vl, QgsAttributeList& attList )
2705 {
2706  QgsFeatureRendererV2* renderer = symbologyRenderer( vl );
2707  if ( renderer )
2708  {
2709  QList<QString> rendererAttributes = renderer->usedAttributes();
2710  for ( int i = 0; i < rendererAttributes.size(); ++i )
2711  {
2712  int index = vl->fieldNameIndex( rendererAttributes.at( i ) );
2713  if ( index != -1 )
2714  {
2715  attList.push_back( vl->fieldNameIndex( rendererAttributes.at( i ) ) );
2716  }
2717  }
2718  }
2719 }
QgsFeature::id
QgsFeatureId id() const
Get the feature ID for this feature.
Definition: qgsfeature.cpp:51
QGis::singleType
static WkbType singleType(WkbType type)
Definition: qgis.h:71
QVariant::toLongLong
qlonglong toLongLong(bool *ok) const
QgsField::name
const QString & name() const
Gets the name of the field.
Definition: qgsfield.cpp:69
QgsFeatureIterator
Wrapper for iterator of features from vector data provider or vector layer.
Definition: qgsfeatureiterator.h:139
QTextCodec::fromUnicode
QByteArray fromUnicode(const QString &str) const
QTime::minute
int minute() const
QgsVectorLayer::rendererV2
QgsFeatureRendererV2 * rendererV2()
Return renderer V2.
Definition: qgsvectorlayer.cpp:2777
QString::indexOf
int indexOf(QChar ch, int from, Qt::CaseSensitivity cs) const
index
static unsigned index
Definition: mersenne-twister.cpp:36
QgsRectangle
A rectangle specified with double values.
Definition: qgsrectangle.h:35
QgsVectorFileWriter::supportedFiltersAndFormats
static QMap< QString, QString > supportedFiltersAndFormats()
Returns map with format filter string as key and OGR format key as value.
Definition: qgsvectorfilewriter.cpp:2112
QgsVectorFileWriter::symbologyExport
SymbologyExport symbologyExport() const
Definition: qgsvectorfilewriter.h:264
QRegExp::cap
QString cap(int nth) const
QString::append
QString & append(QChar ch)
QHash::insert
iterator insert(const Key &key, const T &value)
QString::toUpper
QString toUpper() const
QMap::contains
bool contains(const Key &key) const
QHash::key
const Key key(const T &value) const
QgsVectorFileWriter::mError
WriterError mError
contains error value if construction was not successful
Definition: qgsvectorfilewriter.h:283
QList::push_back
void push_back(const T &value)
QgsVectorLayer::maximumValue
QVariant maximumValue(int index)
Returns maximum value for an attribute column or invalid variant in case of error.
Definition: qgsvectorlayer.cpp:3110
QgsVectorFileWriter::fileFilterString
static QString fileFilterString()
Returns filter string that can be used for dialogs.
Definition: qgsvectorfilewriter.cpp:2211
QFile::remove
bool remove()
QgsDebugMsg
#define QgsDebugMsg(str)
Definition: qgslogger.h:33
QString::split
QStringList split(const QString &sep, SplitBehavior behavior, Qt::CaseSensitivity cs) const
QVariant::toDateTime
QDateTime toDateTime() const
QgsVectorFileWriter::mSymbologyExport
SymbologyExport mSymbologyExport
Definition: qgsvectorfilewriter.h:294
QgsVectorFileWriter::mSymbologyScaleDenominator
double mSymbologyScaleDenominator
Scale for symbology export (e.g.
Definition: qgsvectorfilewriter.h:301
QgsLogger::warning
static void warning(const QString &msg)
Goes to qWarning.
Definition: qgslogger.cpp:124
QgsVectorLayer::getFeatures
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest())
Query the provider for features specified in request.
Definition: qgsvectorlayer.cpp:907
QMap::constBegin
const_iterator constBegin() const
QgsRenderContext::setRendererScale
void setRendererScale(double scale)
Definition: qgsrendercontext.h:99
QList::at
const T & at(int i) const
QgsField::precision
int precision() const
Gets the precision of the field.
Definition: qgsfield.cpp:89
QStringList::contains
bool contains(const QString &str, Qt::CaseSensitivity cs) const
QgsFeatureRequest::setSubsetOfAttributes
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
Definition: qgsfeaturerequest.cpp:123
QgsApplication::registerOgrDrivers
static void registerOgrDrivers()
Register OGR drivers ensuring this only happens once.
Definition: qgsapplication.cpp:763
QgsVectorFileWriter::deleteShapeFile
static bool deleteShapeFile(QString theFileName)
Delete a shapefile (and its accompanying shx / dbf / prf)
Definition: qgsvectorfilewriter.cpp:2086
QgsFields
Container of fields for a vector layer.
Definition: qgsfield.h:173
QDateTime::time
QTime time() const
QgsGeometry
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:75
QGis::WkbType
WkbType
Used for symbology operations.
Definition: qgis.h:53
QgsFeatureRendererV2::usedAttributes
virtual QList< QString > usedAttributes()=0
QStringList::join
QString join(const QString &separator) const
QFile::exists
bool exists() const
QgsVectorFileWriter
A convenience class for writing vector files to disk.
Definition: qgsvectorfilewriter.h:42
QgsFeature
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:162
QDate::month
int month() const
QMap::clear
void clear()
QgsVectorLayer::minimumValue
QVariant minimumValue(int index)
Returns minimum value for an attribute column or invalid variant in case of error.
Definition: qgsvectorlayer.cpp:3044
QObject::tr
QString tr(const char *sourceText, const char *disambiguation, int n)
QTextCodec::codecForLocale
QTextCodec * codecForLocale()
QTime::second
int second() const
QList::size
int size() const
QgsFeatureRendererV2::startRender
virtual void startRender(QgsRenderContext &context, const QgsFields &fields)=0
QgsMessageLog::logMessage
static void logMessage(QString message, QString tag=QString::null, MessageLevel level=WARNING)
add a message to the instance (and create it if necessary)
Definition: qgsmessagelog.cpp:43
QgsVectorLayer::wkbType
QGis::WkbType wkbType() const
Returns the WKBType or WKBUnknown in case of error.
Definition: qgsvectorlayer.cpp:598
QgsFeatureRendererV2::stopRender
virtual void stopRender(QgsRenderContext &context)=0
QString::clear
void clear()
QgsFeatureRendererV2::symbols
virtual QgsSymbolV2List symbols()=0
for symbol levels
TO8F
#define TO8F(x)
Definition: qgsvectorfilewriter.cpp:54
QString::number
QString number(int n, int base)
QList::count
int count(const T &value) const
QList::append
void append(const T &value)
QString::fromUtf8
QString fromUtf8(const char *str, int size)
QVariant::toInt
int toInt(bool *ok) const
QVariant::isNull
bool isNull() const
QgsVectorLayer::selectedFeaturesIds
const QgsFeatureIds & selectedFeaturesIds() const
Return reference to identifiers of selected features.
Definition: qgsvectorlayer.cpp:2349
FID_TO_NUMBER
#define FID_TO_NUMBER(fid)
Definition: qgsfeature.h:88
QgsFeature::initAttributes
void initAttributes(int fieldCount)
Initialize this feature with the given number of fields.
Definition: qgsfeature.cpp:182
QString::toInt
int toInt(bool *ok, int base) const
QList::isEmpty
bool isEmpty() const
QString::isEmpty
bool isEmpty() const
QMap::constEnd
const_iterator constEnd() const
QDate::day
int day() const
QByteArray::constData
const char * constData() const
QString::startsWith
bool startsWith(const QString &s, Qt::CaseSensitivity cs) const
QgsFeatureRequest
This class wraps a request for features to a vector layer (or directly its vector data provider)...
Definition: qgsfeaturerequest.h:58
QgsVectorFileWriter::~QgsVectorFileWriter
~QgsVectorFileWriter()
close opened shapefile for writing
Definition: qgsvectorfilewriter.cpp:1799
QgsAttributeList
QList< int > QgsAttributeList
Definition: qgsfeaturerequest.h:26
QgsSymbolV2::symbolLayerCount
int symbolLayerCount()
Returns total number of symbol layers contained in the symbol.
Definition: qgssymbolv2.h:113
QgsVectorFileWriter::addFeature
bool addFeature(QgsFeature &feature, QgsFeatureRendererV2 *renderer=0, QGis::UnitType outputUnit=QGis::Meters)
add feature to the currently opened shapefile
Definition: qgsvectorfilewriter.cpp:1564
QString::endsWith
bool endsWith(const QString &s, Qt::CaseSensitivity cs) const
QgsFields::count
int count() const
Return number of items.
Definition: qgsfield.cpp:283
QgsGeometry::wkbType
QGis::WkbType wkbType() const
Returns type of the geometry as a WKB type (point / linestring / polygon etc.)
Definition: qgsgeometry.cpp:305
QgsVectorFileWriter::mWkbType
QGis::WkbType mWkbType
geometry type which is being used
Definition: qgsvectorfilewriter.h:289
QDate::year
int year() const
QFileInfo::dir
QDir dir() const
QgsField
Encapsulate a field in an attribute table or data source.
Definition: qgsfield.h:38
QFile::open
virtual bool open(QFlags< QIODevice::OpenModeFlag > mode)
QgsVectorFileWriter::mAttrIdxToOgrIdx
QMap< int, int > mAttrIdxToOgrIdx
map attribute indizes to OGR field indexes
Definition: qgsvectorfilewriter.h:292
QTime::hour
int hour() const
QList::end
iterator end()
QString::toLower
QString toLower() const
QHash::value
const T value(const Key &key) const
QString::toLocal8Bit
QByteArray toLocal8Bit() const
QHash::find
iterator find(const Key &key)
pal::min
int min(int a, int b)
Definition: util.h:93
QgsSymbolLayerV2::renderingPass
int renderingPass() const
Definition: qgssymbollayerv2.h:112
QgsFeature::geometry
QgsGeometry * geometry()
Get the geometry object associated with this feature.
Definition: qgsfeature.cpp:62
QFile::close
virtual void close()
QgsVectorFileWriter::ogrDriverList
static QMap< QString, QString > ogrDriverList()
Returns driver list that can be used for dialogs.
Definition: qgsvectorfilewriter.cpp:2139
QSet::contains
bool contains(const T &value) const
QVariant::typeToName
const char * typeToName(Type typ)
QgsVectorFileWriter::errorMessage
QString errorMessage()
retrieves error message
Definition: qgsvectorfilewriter.cpp:1559
QMap::key
const Key key(const T &value) const
QVariant::toDate
QDate toDate() const
QgsVectorLayer::providerType
QString providerType() const
Return the provider type for this layer.
Definition: qgsvectorlayer.cpp:222
QString::replace
QString & replace(int position, int n, QChar after)
QgsException::what
QString what() const
Definition: qgsexception.h:35
QSettings::value
QVariant value(const QString &key, const QVariant &defaultValue) const
QgsRenderContext
Contains information about the context of a rendering operation.
Definition: qgsrendercontext.h:39
QgsVectorFileWriter::convertCodecNameForEncodingOption
static QString convertCodecNameForEncodingOption(const QString &codecName)
Converts codec name to string passed to ENCODING layer creation option of OGR Shapefile.
Definition: qgsvectorfilewriter.cpp:2238
QgsGeometry::convertToMultiType
bool convertToMultiType()
Converts single type geometry into multitype geometry e.g.
Definition: qgsgeometry.cpp:898
QgsVectorFileWriter::hasError
WriterError hasError()
checks whether there were any errors in constructor
Definition: qgsvectorfilewriter.cpp:1554
QgsFeature::attribute
QVariant attribute(const QString &name) const
Lookup attribute value from attribute name.
Definition: qgsfeature.cpp:236
QgsVectorLayer::pendingAllAttributesList
QgsAttributeList pendingAllAttributesList()
returns list of attributes
Definition: qgsvectorlayer.cpp:2222
QDateTime::date
QDate date() const
QgsVectorFileWriter::QgsVectorFileWriter
QgsVectorFileWriter(const QString &vectorFileName, const QString &fileEncoding, const QgsFields &fields, QGis::WkbType geometryType, const QgsCoordinateReferenceSystem *srs, const QString &driverName="ESRI Shapefile", const QStringList &datasourceOptions=QStringList(), const QStringList &layerOptions=QStringList(), QString *newFilename=0, SymbologyExport symbologyExport=NoSymbology)
create shapefile and initialize it
Definition: qgsvectorfilewriter.cpp:58
QgsFeatureRendererV2::symbolsForFeature
virtual QgsSymbolV2List symbolsForFeature(QgsFeature &feat)
return list of symbols used for rendering the feature.
Definition: qgsrendererv2.cpp:634
QgsVectorFileWriter::setSymbologyScaleDenominator
void setSymbologyScaleDenominator(double d)
Definition: qgsvectorfilewriter.h:268
QDir::entryList
QStringList entryList(QFlags< QDir::Filter > filters, QFlags< QDir::SortFlag > sort) const
QgsSymbolV2LevelItem::symbol
QgsSymbolV2 * symbol()
Definition: qgsrendererv2.h:57
QTextCodec::codecForName
QTextCodec * codecForName(const QByteArray &name)
QgsFeatureRendererV2::usingSymbolLevels
bool usingSymbolLevels() const
Definition: qgsrendererv2.h:131
QVariant::typeName
const char * typeName() const
QgsCoordinateReferenceSystem
Class for storing a coordinate reference system (CRS)
Definition: qgscoordinatereferencesystem.h:50
QgsField::length
int length() const
Gets the length of the field.
Definition: qgsfield.cpp:84
QgsFields::size
int size() const
Return number of items.
Definition: qgsfield.cpp:288
QgsFeature::constGeometry
const QgsGeometry * constGeometry() const
Gets a const pointer to the geometry object associated with this feature.
Definition: qgsfeature.cpp:68
QgsCoordinateTransform
Class for doing transforms between two map coordinate systems.
Definition: qgscoordinatetransform.h:52
QVariant::toBool
bool toBool() const
QGis::UnitType
UnitType
Map units that qgis supports.
Definition: qgis.h:229
QByteArray::data
char * data()
QgsGeometry::transform
int transform(const QgsCoordinateTransform &ct)
Transform this geometry as described by CoordinateTransform ct.
Definition: qgsgeometry.cpp:1557
QString::left
QString left(int n) const
QFileInfo::completeBaseName
QString completeBaseName() const
QgsMapLayer::crs
const QgsCoordinateReferenceSystem & crs() const
Returns layer's spatial reference system.
Definition: qgsmaplayer.cpp:946
QVariant::isValid
bool isValid() const
QDir::canonicalPath
QString canonicalPath() const
QVariant::toDouble
double toDouble(bool *ok) const
QMap::insert
iterator insert(const Key &key, const T &value)
QgsCsException
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgscsexception.h:24
QgsVectorLayer::pendingFields
const QgsFields & pendingFields() const
returns field list in the to-be-committed state
Definition: qgsvectorlayer.cpp:2217
QgsSymbolV2::symbolLayer
QgsSymbolLayerV2 * symbolLayer(int layer)
Returns a specific symbol layers contained in the symbol.
Definition: qgssymbolv2.cpp:217
QgsVectorLayer::dataProvider
QgsVectorDataProvider * dataProvider()
Returns the data provider.
Definition: qgsvectorlayer.cpp:544
QHash::end
iterator end()
QList::constEnd
const_iterator constEnd() const
QgsFeatureRendererV2::capabilities
virtual int capabilities()
returns bitwise OR-ed capabilities of the renderer
Definition: qgsrendererv2.h:126
QgsFeatureIterator::nextFeature
bool nextFeature(QgsFeature &f)
Definition: qgsfeatureiterator.h:194
QList::constBegin
const_iterator constBegin() const
QVariant::type
Type type() const
QgsFeatureRequest::NoGeometry
Geometry is not required. It may still be returned if e.g. required for a filter condition.
Definition: qgsfeaturerequest.h:64
QgsCoordinateTransform::destCRS
const QgsCoordinateReferenceSystem & destCRS() const
Definition: qgscoordinatetransform.h:122
QgsGeometry::intersects
bool intersects(const QgsRectangle &r) const
Test for intersection with a rectangle (uses GEOS)
Definition: qgsgeometry.cpp:754
QgsVectorLayer
Represents a vector layer which manages a vector based data sets.
Definition: qgsvectorlayer.h:620
QgsVectorLayer::fieldNameIndex
int fieldNameIndex(const QString &fieldName) const
Returns the index of a field name or -1 if the field does not exist.
Definition: qgsvectorlayer.cpp:2858
QString::compare
int compare(const QString &other) const
QgsFeatureRendererV2::symbolForFeature
virtual QgsSymbolV2 * symbolForFeature(QgsFeature &feature)=0
to be overridden
QgsFeatureRequest::setFlags
QgsFeatureRequest & setFlags(Flags flags)
Set flags that affect how features will be fetched.
Definition: qgsfeaturerequest.cpp:117
QRegExp::exactMatch
bool exactMatch(const QString &str) const
QString::arg
QString arg(qlonglong a, int fieldWidth, int base, const QChar &fillChar) const
QgsGeometry::asWkb
const unsigned char * asWkb() const
Returns the buffer containing this geometry in WKB format.
Definition: qgsgeometry.cpp:262
QVariant::toString
QString toString() const
QgsVectorFileWriter::createEmptyGeometry
OGRGeometryH createEmptyGeometry(QGis::WkbType wkbType)
Definition: qgsvectorfilewriter.cpp:497
pal::max
int max(int a, int b)
Definition: util.h:87
QFileInfo::baseName
QString baseName() const
QList::begin
iterator begin()
QgsVectorFileWriter::writeAsVectorFormat
static WriterError writeAsVectorFormat(QgsVectorLayer *layer, const QString &fileName, const QString &fileEncoding, const QgsCoordinateReferenceSystem *destCRS, const QString &driverName="ESRI Shapefile", bool onlySelected=false, QString *errorMessage=0, const QStringList &datasourceOptions=QStringList(), const QStringList &layerOptions=QStringList(), bool skipAttributeCreation=false, QString *newFilename=0, SymbologyExport symbologyExport=NoSymbology, double symbologyScale=1.0, const QgsRectangle *filterExtent=0)
Write contents of vector layer to an (OGR supported) vector formt.
Definition: qgsvectorfilewriter.cpp:1813
QgsVectorFileWriter::filterForDriver
static QString filterForDriver(const QString &driverName)
Creates a filter for an OGR driver key.
Definition: qgsvectorfilewriter.cpp:2226
QgsDataProvider::dataSourceUri
virtual QString dataSourceUri() const
Get the data source specification.
Definition: qgsdataprovider.h:96
QGis::multiType
static WkbType multiType(WkbType type)
Definition: qgis.h:85
OGRSpatialReferenceH
void * OGRSpatialReferenceH
Definition: qgscoordinatereferencesystem.h:41
QgsField::type
QVariant::Type type() const
Gets variant type of the field as it will be retrieved from data source.
Definition: qgsfield.cpp:74
QMap::value
const T value(const Key &key) const
QgsVectorFileWriter::driverMetadata
static bool driverMetadata(const QString &driverName, MetaData &driverMetadata)
Definition: qgsvectorfilewriter.cpp:1535
QgsVectorLayer::storageType
QString storageType() const
Returns the permanent storage type for this layer as a friendly name.
Definition: qgsvectorlayer.cpp:193
Generated on Sat Aug 22 2015 02:53:40 for QGIS API Documentation by   doxygen 1.8.6