src/shapelib/shapefil.h

   1 #ifndef SHAPEFILE_H_INCLUDED
   2 #define SHAPEFILE_H_INCLUDED
   3
   4 /******************************************************************************
   5  * $Id: shapefil.h,v 1.52 2011-12-11 22:26:46 fwarmerdam Exp $
   6  *
   7  * Project:  Shapelib
   8  * Purpose:  Primary include file for Shapelib.
   9  * Author:   Frank Warmerdam, warmerdam@pobox.com
  10  *
  11  ******************************************************************************
  12  * Copyright (c) 1999, Frank Warmerdam
  13  *
  14  * This software is available under the following "MIT Style" license,
  15  * or at the option of the licensee under the LGPL (see LICENSE.LGPL).  This
  16  * option is discussed in more detail in shapelib.html.
  17  *
  18  * --
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining a
  21  * copy of this software and associated documentation files (the "Software"),
  22  * to deal in the Software without restriction, including without limitation
  23  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  24  * and/or sell copies of the Software, and to permit persons to whom the
  25  * Software is furnished to do so, subject to the following conditions:
  26  *
  27  * The above copyright notice and this permission notice shall be included
  28  * in all copies or substantial portions of the Software.
  29  *
  30  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  31  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  32  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  33  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  34  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  35  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  36  * DEALINGS IN THE SOFTWARE.
  37  ******************************************************************************
  38  *
  39  * $Log: shapefil.h,v $
  40  * Revision 1.52  2011-12-11 22:26:46  fwarmerdam
  41  * upgrade .qix access code to use SAHooks (gdal #3365)
  42  *
  43  * Revision 1.51  2011-07-24 05:59:25  fwarmerdam
  44  * minimize use of CPLError in favor of SAHooks.Error()
  45  *
  46  * Revision 1.50  2011-05-13 17:35:17  fwarmerdam
  47  * added DBFReorderFields() and DBFAlterFields() functions (from Even)
  48  *
  49  * Revision 1.49  2011-04-16 14:38:21  fwarmerdam
  50  * avoid warnings with gcc on SHP_CVSID
  51  *
  52  * Revision 1.48  2010-08-27 23:42:52  fwarmerdam
  53  * add SHPAPI_CALL attribute in code
  54  *
  55  * Revision 1.47  2010-01-28 11:34:34  fwarmerdam
  56  * handle the shape file length limits more gracefully (#3236)
  57  *
  58  * Revision 1.46  2008-11-12 14:28:15  fwarmerdam
  59  * DBFCreateField() now works on files with records
  60  *
  61  * Revision 1.45  2008/11/11 17:47:10  fwarmerdam
  62  * added DBFDeleteField() function
  63  *
  64  * Revision 1.44  2008/01/16 20:05:19  bram
  65  * Add file hooks that accept UTF-8 encoded filenames on some platforms.  Use SASetupUtf8Hooks
  66  *  tosetup the hooks and check SHPAPI_UTF8_HOOKS for its availability.  Currently, this
  67  *  is only available on the Windows platform that decodes the UTF-8 filenames to wide
  68  *  character strings and feeds them to _wfopen and _wremove.
  69  *
  70  * Revision 1.43  2008/01/10 16:35:30  fwarmerdam
  71  * avoid _ prefix on #defined symbols (bug 1840)
  72  *
  73  * Revision 1.42  2007/12/18 18:28:14  bram
  74  * - create hook for client specific atof (bugzilla ticket 1615)
  75  * - check for NULL handle before closing cpCPG file, and close after reading.
  76  *
  77  * Revision 1.41  2007/12/15 20:25:32  bram
  78  * dbfopen.c now reads the Code Page information from the DBF file, and exports
  79  * this information as a string through the DBFGetCodePage function.  This is
  80  * either the number from the LDID header field ("LDID/<number>") or as the
  81  * content of an accompanying .CPG file.  When creating a DBF file, the code can
  82  * be set using DBFCreateEx.
  83  *
  84  * Revision 1.40  2007/12/06 07:00:25  fwarmerdam
  85  * dbfopen now using SAHooks for fileio
  86  *
  87  * Revision 1.39  2007/12/04 20:37:56  fwarmerdam
  88  * preliminary implementation of hooks api for io and errors
  89  *
  90  * Revision 1.38  2007/11/21 22:39:56  fwarmerdam
  91  * close shx file in readonly mode (GDAL #1956)
  92  *
  93  * Revision 1.37  2007/10/27 03:31:14  fwarmerdam
  94  * limit default depth of tree to 12 levels (gdal ticket #1594)
  95  *
  96  * Revision 1.36  2007/09/10 23:33:15  fwarmerdam
  97  * Upstreamed support for visibility flag in SHPAPI_CALL for the needs
  98  * of GDAL (gdal ticket #1810).
  99  *
 100  * Revision 1.35  2007/09/03 19:48:10  fwarmerdam
 101  * move DBFReadAttribute() static dDoubleField into dbfinfo
 102  *
 103  * Revision 1.34  2006/06/17 15:33:32  fwarmerdam
 104  * added pszWorkField - bug 1202 (rso)
 105  *
 106  * Revision 1.33  2006/02/15 01:14:30  fwarmerdam
 107  * added DBFAddNativeFieldType
 108  *
 109  * Revision 1.32  2006/01/26 15:07:32  fwarmerdam
 110  * add bMeasureIsUsed flag from Craig Bruce: Bug 1249
 111  *
 112  * Revision 1.31  2006/01/05 01:27:27  fwarmerdam
 113  * added dbf deletion mark/fetch
 114  *
 115  * Revision 1.30  2005/01/03 22:30:13  fwarmerdam
 116  * added support for saved quadtrees
 117  *
 118  * Revision 1.29  2004/09/26 20:09:35  fwarmerdam
 119  * avoid rcsid warnings
 120  *
 121  * Revision 1.28  2003/12/29 06:02:18  fwarmerdam
 122  * added cpl_error.h option
 123  *
 124  * Revision 1.27  2003/04/21 18:30:37  warmerda
 125  * added header write/update public methods
 126  *
 127  * Revision 1.26  2002/09/29 00:00:08  warmerda
 128  * added FTLogical and logical attribute read/write calls
 129  *
 130  * Revision 1.25  2002/05/07 13:46:30  warmerda
 131  * added DBFWriteAttributeDirectly().
 132  *
 133  * Revision 1.24  2002/04/10 16:59:54  warmerda
 134  * added SHPRewindObject
 135  *
 136  * Revision 1.23  2002/01/15 14:36:07  warmerda
 137  * updated email address
 138  *
 139  * Revision 1.22  2002/01/15 14:32:00  warmerda
 140  * try to improve SHPAPI_CALL docs
 141  */
 142
 143 #include <stdio.h>
 144
 145 #ifdef USE_DBMALLOC
 146 #include <dbmalloc.h>
 147 #endif
 148
 149 #ifdef __cplusplus
 150 extern "C" {
 151 #endif
 152
 153 /************************************************************************/
 154 /*                        Configuration options.                        */
 155 /************************************************************************/
 156
 157 /* -------------------------------------------------------------------- */
 158 /*      Should the DBFReadStringAttribute() strip leading and           */
 159 /*      trailing white space?                                           */
 160 /* -------------------------------------------------------------------- */
 161 #define TRIM_DBF_WHITESPACE
 162
 163 /* -------------------------------------------------------------------- */
 164 /*      Should we write measure values to the Multipatch object?        */
 165 /*      Reportedly ArcView crashes if we do write it, so for now it     */
 166 /*      is disabled.                                                    */
 167 /* -------------------------------------------------------------------- */
 168 #define DISABLE_MULTIPATCH_MEASURE
 169
 170 /* -------------------------------------------------------------------- */
 171 /*      SHPAPI_CALL                                                     */
 172 /*                                                                      */
 173 /*      The following two macros are present to allow forcing           */
 174 /*      various calling conventions on the Shapelib API.                */
 175 /*                                                                      */
 176 /*      To force __stdcall conventions (needed to call Shapelib         */
 177 /*      from Visual Basic and/or Dephi I believe) the makefile could    */
 178 /*      be modified to define:                                          */
 179 /*                                                                      */
 180 /*        /DSHPAPI_CALL=__stdcall                                       */
 181 /*                                                                      */
 182 /*      If it is desired to force export of the Shapelib API without    */
 183 /*      using the shapelib.def file, use the following definition.      */
 184 /*                                                                      */
 185 /*        /DSHAPELIB_DLLEXPORT                                          */
 186 /*                                                                      */
 187 /*      To get both at once it will be necessary to hack this           */
 188 /*      include file to define:                                         */
 189 /*                                                                      */
 190 /*        #define SHPAPI_CALL __declspec(dllexport) __stdcall           */
 191 /*        #define SHPAPI_CALL1 __declspec(dllexport) * __stdcall        */
 192 /*                                                                      */
 193 /*      The complexity of the situtation is partly caused by the        */
 194 /*      peculiar requirement of Visual C++ that __stdcall appear        */
 195 /*      after any "*"'s in the return value of a function while the     */
 196 /*      __declspec(dllexport) must appear before them.                  */
 197 /* -------------------------------------------------------------------- */
 198
 199 #ifdef WIN32
 200   #define SHAPELIB_DLLEXPORT 1
 201 #endif
 202
 203 #ifdef WIN32
 204 #ifdef SHAPELIB_DLLEXPORT
 205 #  define SHPAPI_CALL __declspec(dllexport)
 206 #  define SHPAPI_CALL1(x)  __declspec(dllexport) x
 207 #else
 208 #  define SHPAPI_CALL __declspec(dllimport)
 209 #  define SHPAPI_CALL1(x)  __declspec(dllimport) x
 210 #endif
 211 #endif
 212
 213 #ifndef SHPAPI_CALL
 214 #  if defined(USE_GCC_VISIBILITY_FLAG)
 215 #    define SHPAPI_CALL     __attribute__ ((visibility("default")))
 216 #    define SHPAPI_CALL1(x) __attribute__ ((visibility("default")))     x
 217 #  else
 218 #    define SHPAPI_CALL
 219 #  endif
 220 #endif
 221
 222 #ifndef SHPAPI_CALL1
 223 #  define SHPAPI_CALL1(x)      x SHPAPI_CALL
 224 #endif
 225
 226 /* -------------------------------------------------------------------- */
 227 /*      Macros for controlling CVSID and ensuring they don't appear     */
 228 /*      as unreferenced variables resulting in lots of warnings.        */
 229 /* -------------------------------------------------------------------- */
 230 #ifndef DISABLE_CVSID
 231 #  if defined(__GNUC__) && __GNUC__ >= 4
 232 #    define SHP_CVSID(string)     static char cpl_cvsid[] __attribute__((used)) = string;
 233 #  else
 234 #    define SHP_CVSID(string)     static char cpl_cvsid[] = string; \
 235 static char *cvsid_aw() { return( cvsid_aw() ? ((char *) NULL) : cpl_cvsid ); }
 236 #  endif
 237 #else
 238 #  define SHP_CVSID(string)
 239 #endif
 240
 241 /* -------------------------------------------------------------------- */
 242 /*      On some platforms, additional file IO hooks are defined that    */
 243 /*      UTF-8 encoded filenames Unicode filenames                       */
 244 /* -------------------------------------------------------------------- */
 245 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
 246 #       define SHPAPI_WINDOWS
 247 #       define SHPAPI_UTF8_HOOKS
 248 #endif
 249
 250 /* -------------------------------------------------------------------- */
 251 /*      IO/Error hook functions.                                        */
 252 /* -------------------------------------------------------------------- */
 253 typedef int *SAFile;
 254
 255 #ifndef SAOffset
 256 typedef unsigned long SAOffset;
 257 #endif
 258
 259 typedef struct {
 260     SAFile     (*FOpen) ( const char *filename, const char *access);
 261     SAOffset   (*FRead) ( void *p, SAOffset size, SAOffset nmemb, SAFile file);
 262     SAOffset   (*FWrite)( void *p, SAOffset size, SAOffset nmemb, SAFile file);
 263     SAOffset   (*FSeek) ( SAFile file, SAOffset offset, int whence );
 264     SAOffset   (*FTell) ( SAFile file );
 265     int        (*FFlush)( SAFile file );
 266     int        (*FClose)( SAFile file );
 267     int        (*Remove) ( const char *filename );
 268
 269     void       (*Error) ( const char *message );
 270     double     (*Atof)  ( const char *str );
 271 } SAHooks;
 272
 273 void SHPAPI_CALL SASetupDefaultHooks( SAHooks *psHooks );
 274 #ifdef SHPAPI_UTF8_HOOKS
 275 void SHPAPI_CALL SASetupUtf8Hooks( SAHooks *psHooks );
 276 #endif
 277
 278 /************************************************************************/
 279 /*                             SHP Support.                             */
 280 /************************************************************************/
 281 typedef struct
 282 {
 283     SAHooks sHooks;
 284
 285     SAFile      fpSHP;
 286     SAFile      fpSHX;
 287
 288     int         nShapeType;                             /* SHPT_* */
 289
 290     unsigned int        nFileSize;                              /* SHP file */
 291
 292     int         nRecords;
 293     int         nMaxRecords;
 294     unsigned int                *panRecOffset;
 295     unsigned int                *panRecSize;
 296
 297     double      adBoundsMin[4];
 298     double      adBoundsMax[4];
 299
 300     int         bUpdated;
 301
 302     unsigned char *pabyRec;
 303     int         nBufSize;
 304 } SHPInfo;
 305
 306 typedef SHPInfo * SHPHandle;
 307
 308 /* -------------------------------------------------------------------- */
 309 /*      Shape types (nSHPType)                                          */
 310 /* -------------------------------------------------------------------- */
 311 #define SHPT_NULL       0
 312 #define SHPT_POINT      1
 313 #define SHPT_ARC        3
 314 #define SHPT_POLYGON    5
 315 #define SHPT_MULTIPOINT 8
 316 #define SHPT_POINTZ     11
 317 #define SHPT_ARCZ       13
 318 #define SHPT_POLYGONZ   15
 319 #define SHPT_MULTIPOINTZ 18
 320 #define SHPT_POINTM     21
 321 #define SHPT_ARCM       23
 322 #define SHPT_POLYGONM   25
 323 #define SHPT_MULTIPOINTM 28
 324 #define SHPT_MULTIPATCH 31
 325
 326
 327 /* -------------------------------------------------------------------- */
 328 /*      Part types - everything but SHPT_MULTIPATCH just uses           */
 329 /*      SHPP_RING.                                                      */
 330 /* -------------------------------------------------------------------- */
 331
 332 #define SHPP_TRISTRIP   0
 333 #define SHPP_TRIFAN     1
 334 #define SHPP_OUTERRING  2
 335 #define SHPP_INNERRING  3
 336 #define SHPP_FIRSTRING  4
 337 #define SHPP_RING       5
 338
 339 /* -------------------------------------------------------------------- */
 340 /*      SHPObject - represents on shape (without attributes) read       */
 341 /*      from the .shp file.                                             */
 342 /* -------------------------------------------------------------------- */
 343 typedef struct
 344 {
 345     int         nSHPType;
 346
 347     int         nShapeId; /* -1 is unknown/unassigned */
 348
 349     int         nParts;
 350     int         *panPartStart;
 351     int         *panPartType;
 352
 353     int         nVertices;
 354     double      *padfX;
 355     double      *padfY;
 356     double      *padfZ;
 357     double      *padfM;
 358
 359     double      dfXMin;
 360     double      dfYMin;
 361     double      dfZMin;
 362     double      dfMMin;
 363
 364     double      dfXMax;
 365     double      dfYMax;
 366     double      dfZMax;
 367     double      dfMMax;
 368
 369     int         bMeasureIsUsed;
 370 } SHPObject;
 371
 372 /* -------------------------------------------------------------------- */
 373 /*      SHP API Prototypes                                              */
 374 /* -------------------------------------------------------------------- */
 375
 376 /* If pszAccess is read-only, the fpSHX field of the returned structure */
 377 /* will be NULL as it is not necessary to keep the SHX file open */
 378 SHPHandle SHPAPI_CALL
 379       SHPOpen( const char * pszShapeFile, const char * pszAccess );
 380 SHPHandle SHPAPI_CALL
 381       SHPOpenLL( const char *pszShapeFile, const char *pszAccess,
 382                  SAHooks *psHooks );
 383 SHPHandle SHPAPI_CALL
 384       SHPCreate( const char * pszShapeFile, int nShapeType );
 385 SHPHandle SHPAPI_CALL
 386       SHPCreateLL( const char * pszShapeFile, int nShapeType,
 387                    SAHooks *psHooks );
 388 void SHPAPI_CALL
 389       SHPGetInfo( SHPHandle hSHP, int * pnEntities, int * pnShapeType,
 390                   double * padfMinBound, double * padfMaxBound );
 391
 392 SHPObject SHPAPI_CALL1(*)
 393       SHPReadObject( SHPHandle hSHP, int iShape );
 394 int SHPAPI_CALL
 395       SHPWriteObject( SHPHandle hSHP, int iShape, SHPObject * psObject );
 396
 397 void SHPAPI_CALL
 398       SHPDestroyObject( SHPObject * psObject );
 399 void SHPAPI_CALL
 400       SHPComputeExtents( SHPObject * psObject );
 401 SHPObject SHPAPI_CALL1(*)
 402       SHPCreateObject( int nSHPType, int nShapeId, int nParts,
 403                        const int * panPartStart, const int * panPartType,
 404                        int nVertices,
 405                        const double * padfX, const double * padfY,
 406                        const double * padfZ, const double * padfM );
 407 SHPObject SHPAPI_CALL1(*)
 408       SHPCreateSimpleObject( int nSHPType, int nVertices,
 409                              const double * padfX,
 410                              const double * padfY,
 411                              const double * padfZ );
 412
 413 int SHPAPI_CALL
 414       SHPRewindObject( SHPHandle hSHP, SHPObject * psObject );
 415
 416 void SHPAPI_CALL SHPClose( SHPHandle hSHP );
 417 void SHPAPI_CALL SHPWriteHeader( SHPHandle hSHP );
 418
 419 const char SHPAPI_CALL1(*)
 420       SHPTypeName( int nSHPType );
 421 const char SHPAPI_CALL1(*)
 422       SHPPartTypeName( int nPartType );
 423
 424 /* -------------------------------------------------------------------- */
 425 /*      Shape quadtree indexing API.                                    */
 426 /* -------------------------------------------------------------------- */
 427
 428 /* this can be two or four for binary or quad tree */
 429 #define MAX_SUBNODE     4
 430
 431 /* upper limit of tree levels for automatic estimation */
 432 #define MAX_DEFAULT_TREE_DEPTH 12
 433
 434 typedef struct shape_tree_node
 435 {
 436     /* region covered by this node */
 437     double      adfBoundsMin[4];
 438     double      adfBoundsMax[4];
 439
 440     /* list of shapes stored at this node.  The papsShapeObj pointers
 441        or the whole list can be NULL */
 442     int         nShapeCount;
 443     int         *panShapeIds;
 444     SHPObject   **papsShapeObj;
 445
 446     int         nSubNodes;
 447     struct shape_tree_node *apsSubNode[MAX_SUBNODE];
 448
 449 } SHPTreeNode;
 450
 451 typedef struct
 452 {
 453     SHPHandle   hSHP;
 454
 455     int         nMaxDepth;
 456     int         nDimension;
 457     int         nTotalCount;
 458
 459     SHPTreeNode *psRoot;
 460 } SHPTree;
 461
 462 SHPTree SHPAPI_CALL1(*)
 463       SHPCreateTree( SHPHandle hSHP, int nDimension, int nMaxDepth,
 464                      double *padfBoundsMin, double *padfBoundsMax );
 465 void    SHPAPI_CALL
 466       SHPDestroyTree( SHPTree * hTree );
 467
 468 int     SHPAPI_CALL
 469       SHPWriteTree( SHPTree *hTree, const char * pszFilename );
 470
 471 int     SHPAPI_CALL
 472       SHPTreeAddShapeId( SHPTree * hTree, SHPObject * psObject );
 473 int     SHPAPI_CALL
 474       SHPTreeRemoveShapeId( SHPTree * hTree, int nShapeId );
 475
 476 void    SHPAPI_CALL
 477       SHPTreeTrimExtraNodes( SHPTree * hTree );
 478
 479 int    SHPAPI_CALL1(*)
 480       SHPTreeFindLikelyShapes( SHPTree * hTree,
 481                                double * padfBoundsMin,
 482                                double * padfBoundsMax,
 483                                int * );
 484 int     SHPAPI_CALL
 485       SHPCheckBoundsOverlap( double *, double *, double *, double *, int );
 486
 487 int SHPAPI_CALL1(*)
 488 SHPSearchDiskTree( FILE *fp,
 489                    double *padfBoundsMin, double *padfBoundsMax,
 490                    int *pnShapeCount );
 491
 492
 493 typedef struct SHPDiskTreeInfo* SHPTreeDiskHandle;
 494
 495 SHPTreeDiskHandle SHPAPI_CALL
 496     SHPOpenDiskTree( const char* pszQIXFilename,
 497                      SAHooks *psHooks );
 498
 499 void SHPAPI_CALL
 500     SHPCloseDiskTree( SHPTreeDiskHandle hDiskTree );
 501
 502 int SHPAPI_CALL1(*)
 503 SHPSearchDiskTreeEx( SHPTreeDiskHandle hDiskTree,
 504                    double *padfBoundsMin, double *padfBoundsMax,
 505                    int *pnShapeCount );
 506
 507 int SHPAPI_CALL
 508     SHPWriteTreeLL(SHPTree *hTree, const char *pszFilename, SAHooks *psHooks );
 509
 510 /************************************************************************/
 511 /*                             DBF Support.                             */
 512 /************************************************************************/
 513 typedef struct
 514 {
 515     SAHooks sHooks;
 516
 517     SAFile      fp;
 518
 519     int         nRecords;
 520
 521     int         nRecordLength;
 522     int         nHeaderLength;
 523     int         nFields;
 524     int         *panFieldOffset;
 525     int         *panFieldSize;
 526     int         *panFieldDecimals;
 527     char        *pachFieldType;
 528
 529     char        *pszHeader;
 530
 531     int         nCurrentRecord;
 532     int         bCurrentRecordModified;
 533     char        *pszCurrentRecord;
 534
 535     int         nWorkFieldLength;
 536     char        *pszWorkField;
 537
 538     int         bNoHeader;
 539     int         bUpdated;
 540
 541     double      dfDoubleField;
 542
 543     int         iLanguageDriver;
 544     char        *pszCodePage;
 545 } DBFInfo;
 546
 547 typedef DBFInfo * DBFHandle;
 548
 549 typedef enum {
 550   FTString,
 551   FTInteger,
 552   FTDouble,
 553   FTLogical,
 554   FTInvalid
 555 } DBFFieldType;
 556
 557 #define XBASE_FLDHDR_SZ       32
 558
 559
 560 DBFHandle SHPAPI_CALL
 561       DBFOpen( const char * pszDBFFile, const char * pszAccess );
 562 DBFHandle SHPAPI_CALL
 563       DBFOpenLL( const char * pszDBFFile, const char * pszAccess,
 564                  SAHooks *psHooks );
 565 DBFHandle SHPAPI_CALL
 566       DBFCreate( const char * pszDBFFile );
 567 DBFHandle SHPAPI_CALL
 568       DBFCreateEx( const char * pszDBFFile, const char * pszCodePage );
 569 DBFHandle SHPAPI_CALL
 570       DBFCreateLL( const char * pszDBFFile, const char * pszCodePage, SAHooks *psHooks );
 571
 572 int     SHPAPI_CALL
 573       DBFGetFieldCount( DBFHandle psDBF );
 574 int     SHPAPI_CALL
 575       DBFGetRecordCount( DBFHandle psDBF );
 576 int     SHPAPI_CALL
 577       DBFAddField( DBFHandle hDBF, const char * pszFieldName,
 578                    DBFFieldType eType, int nWidth, int nDecimals );
 579
 580 int     SHPAPI_CALL
 581       DBFAddNativeFieldType( DBFHandle hDBF, const char * pszFieldName,
 582                              char chType, int nWidth, int nDecimals );
 583
 584 int     SHPAPI_CALL
 585       DBFDeleteField( DBFHandle hDBF, int iField );
 586
 587 int SHPAPI_CALL
 588       DBFReorderFields( DBFHandle psDBF, int* panMap );
 589
 590 int SHPAPI_CALL
 591       DBFAlterFieldDefn( DBFHandle psDBF, int iField, const char * pszFieldName,
 592                          char chType, int nWidth, int nDecimals );
 593
 594 DBFFieldType SHPAPI_CALL
 595       DBFGetFieldInfo( DBFHandle psDBF, int iField,
 596                        char * pszFieldName, int * pnWidth, int * pnDecimals );
 597
 598 int SHPAPI_CALL
 599       DBFGetFieldIndex(DBFHandle psDBF, const char *pszFieldName);
 600
 601 int     SHPAPI_CALL
 602       DBFReadIntegerAttribute( DBFHandle hDBF, int iShape, int iField );
 603 double  SHPAPI_CALL
 604       DBFReadDoubleAttribute( DBFHandle hDBF, int iShape, int iField );
 605 const char SHPAPI_CALL1(*)
 606       DBFReadStringAttribute( DBFHandle hDBF, int iShape, int iField );
 607 const char SHPAPI_CALL1(*)
 608       DBFReadLogicalAttribute( DBFHandle hDBF, int iShape, int iField );
 609 int     SHPAPI_CALL
 610       DBFIsAttributeNULL( DBFHandle hDBF, int iShape, int iField );
 611
 612 int SHPAPI_CALL
 613       DBFWriteIntegerAttribute( DBFHandle hDBF, int iShape, int iField,
 614                                 int nFieldValue );
 615 int SHPAPI_CALL
 616       DBFWriteDoubleAttribute( DBFHandle hDBF, int iShape, int iField,
 617                                double dFieldValue );
 618 int SHPAPI_CALL
 619       DBFWriteStringAttribute( DBFHandle hDBF, int iShape, int iField,
 620                                const char * pszFieldValue );
 621 int SHPAPI_CALL
 622      DBFWriteNULLAttribute( DBFHandle hDBF, int iShape, int iField );
 623
 624 int SHPAPI_CALL
 625      DBFWriteLogicalAttribute( DBFHandle hDBF, int iShape, int iField,
 626                                const char lFieldValue);
 627 int SHPAPI_CALL
 628      DBFWriteAttributeDirectly(DBFHandle psDBF, int hEntity, int iField,
 629                                void * pValue );
 630 const char SHPAPI_CALL1(*)
 631       DBFReadTuple(DBFHandle psDBF, int hEntity );
 632 int SHPAPI_CALL
 633       DBFWriteTuple(DBFHandle psDBF, int hEntity, void * pRawTuple );
 634
 635 int SHPAPI_CALL DBFIsRecordDeleted( DBFHandle psDBF, int iShape );
 636 int SHPAPI_CALL DBFMarkRecordDeleted( DBFHandle psDBF, int iShape,
 637                                       int bIsDeleted );
 638
 639 DBFHandle SHPAPI_CALL
 640       DBFCloneEmpty(DBFHandle psDBF, const char * pszFilename );
 641
 642 void    SHPAPI_CALL
 643       DBFClose( DBFHandle hDBF );
 644 void    SHPAPI_CALL
 645       DBFUpdateHeader( DBFHandle hDBF );
 646 char    SHPAPI_CALL
 647       DBFGetNativeFieldType( DBFHandle hDBF, int iField );
 648
 649 const char SHPAPI_CALL1(*)
 650       DBFGetCodePage(DBFHandle psDBF );
 651
 652 #ifdef __cplusplus
 653 }
 654 #endif
 655
 656 #endif /* ndef SHAPEFILE_H_INCLUDED */