LTP GCOV extension - code coverage report
Current view: directory - ogr/ogrsf_frmts/mitab - mitab.h
Test: gdal_filtered.info
Date: 2010-07-12 Instrumented lines: 93
Code covered: 28.0 % Executed lines: 26

       1                 : /**********************************************************************
       2                 :  * $Id: mitab.h,v 1.117 2008/10/29 12:55:10 dmorissette Exp $
       3                 :  *
       4                 :  * Name:     mitab.h
       5                 :  * Project:  MapInfo TAB Read/Write library
       6                 :  * Language: C++
       7                 :  * Purpose:  Header file containing public definitions for the library.
       8                 :  * Author:   Daniel Morissette, dmorissette@dmsolutions.ca
       9                 :  *
      10                 :  **********************************************************************
      11                 :  * Copyright (c) 1999-2005, Daniel Morissette
      12                 :  *
      13                 :  * Permission is hereby granted, free of charge, to any person obtaining a
      14                 :  * copy of this software and associated documentation files (the "Software"),
      15                 :  * to deal in the Software without restriction, including without limitation
      16                 :  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
      17                 :  * and/or sell copies of the Software, and to permit persons to whom the
      18                 :  * Software is furnished to do so, subject to the following conditions:
      19                 :  * 
      20                 :  * The above copyright notice and this permission notice shall be included
      21                 :  * in all copies or substantial portions of the Software.
      22                 :  * 
      23                 :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      24                 :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      25                 :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
      26                 :  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      27                 :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      28                 :  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
      29                 :  * DEALINGS IN THE SOFTWARE.
      30                 :  **********************************************************************
      31                 :  *
      32                 :  * $Log: mitab.h,v $
      33                 :  * Revision 1.117  2008/10/29 12:55:10  dmorissette
      34                 :  * Update version to 2.0.0-dev (2008-10) for GDAL 1.6.0 release
      35                 :  *
      36                 :  * Revision 1.116  2008/08/22 16:14:19  fwarmerdam
      37                 :  * export spatialref/coordsys transformers
      38                 :  *
      39                 :  * Revision 1.115  2008/07/21 14:09:41  aboudreault
      40                 :  * Add font text styles support (bold, italic, etc.) (bug 1922)
      41                 :  *
      42                 :  * Revision 1.114  2008/07/17 14:09:30  aboudreault
      43                 :  * Add text outline color support (halo background in MapInfo)
      44                 :  *
      45                 :  * Revision 1.113  2008/07/01 14:33:17  aboudreault
      46                 :  * * Fixed deprecated warnings generated by mitab.h by moving SetFontName to
      47                 :  *   mitab_feature.cpp.
      48                 :  *
      49                 :  * Revision 1.112  2008/03/05 20:35:39  dmorissette
      50                 :  * Replace MITAB 1.x SetFeature() with a CreateFeature() for V2.x (bug 1859)
      51                 :  *
      52                 :  * Revision 1.111  2008/02/29 21:27:41  dmorissette
      53                 :  * Update to v1.7.0-beta1
      54                 :  *
      55                 :  * Revision 1.110  2008/02/20 21:35:30  dmorissette
      56                 :  * Added support for V800 COLLECTION of large objects (bug 1496)
      57                 :  *
      58                 :  * Revision 1.109  2008/02/13 21:10:43  dmorissette
      59                 :  * Fixed error in TAB_GEOM_GET_VERSION() macro logic
      60                 :  *
      61                 :  * Revision 1.108  2008/02/05 22:21:59  dmorissette
      62                 :  * Added macro TAB_GEOM_GET_VERSION()
      63                 :  *
      64                 :  * Revision 1.107  2008/02/01 19:55:55  dmorissette
      65                 :  * Set version to 1.7.0-dev
      66                 :  *
      67                 :  * Revision 1.106  2008/02/01 19:36:31  dmorissette
      68                 :  * Initial support for V800 REGION and MULTIPLINE (bug 1496)
      69                 :  *
      70                 :  * Revision 1.105  2008/01/29 21:56:39  dmorissette
      71                 :  * Update dataset version properly for Date/Time/DateTime field types (#1754)
      72                 :  *
      73                 :  * Revision 1.104  2007/12/11 04:26:29  dmorissette
      74                 :  * Update for 1.6.4 release
      75                 :  *
      76                 :  * Revision 1.103  2007/10/12 15:47:48  dmorissette
      77                 :  * Updated for 1.6.3 release
      78                 :  *
      79                 :  * Revision 1.102  2007/09/18 18:13:42  dmorissette
      80                 :  * Updated for 1.6.3-beta2
      81                 :  *
      82                 :  * Revision 1.101  2007/09/14 20:03:08  dmorissette
      83                 :  * Removed stray ReadGeometryFromMAPFile() declaration
      84                 :  *
      85                 :  * Revision 1.100  2007/09/14 19:42:39  dmorissette
      86                 :  * Updated for 1.6.3-beta1
      87                 :  *
      88                 :  * Revision 1.99  2007/09/14 18:30:18  dmorissette
      89                 :  * Fixed the splitting of object blocks with the optimized spatial
      90                 :  * index mode that was producing files with misaligned bytes that
      91                 :  * confused MapInfo (bug 1732)
      92                 :  *
      93                 :  * Revision 1.98  2007/09/12 20:22:31  dmorissette
      94                 :  * Added TABFeature::CreateFromMapInfoType()
      95                 :  *
      96                 :  * ...
      97                 :  *
      98                 :  * Revision 1.1  1999/07/12 04:18:23  daniel
      99                 :  * Initial checkin
     100                 :  *
     101                 :  **********************************************************************/
     102                 : 
     103                 : #ifndef _MITAB_H_INCLUDED_
     104                 : #define _MITAB_H_INCLUDED_
     105                 : 
     106                 : #include "mitab_priv.h"
     107                 : #include "ogr_feature.h"
     108                 : #include "ogr_featurestyle.h"
     109                 : #include "ogrsf_frmts.h"
     110                 : 
     111                 : /*---------------------------------------------------------------------
     112                 :  * Current version of the MITAB library... always useful!
     113                 :  *--------------------------------------------------------------------*/
     114                 : #define MITAB_VERSION      "2.0.0-dev (2008-10)"
     115                 : #define MITAB_VERSION_INT  2000000  /* version x.y.z -> xxxyyyzzz */
     116                 : 
     117                 : #ifndef PI
     118                 : #  define PI 3.14159265358979323846
     119                 : #endif
     120                 : 
     121                 : #ifndef ROUND_INT
     122                 : #  define ROUND_INT(dX) ((int)((dX) < 0.0 ? (dX)-0.5 : (dX)+0.5 ))
     123                 : #endif
     124                 : 
     125                 : 
     126                 : #define MITAB_AREA(x1, y1, x2, y2)  ((double)((x2)-(x1))*(double)((y2)-(y1)))
     127                 : 
     128                 : class TABFeature;
     129                 : 
     130                 : /*---------------------------------------------------------------------
     131                 :  * Codes for the GetFileClass() in the IMapInfoFile-derived  classes
     132                 :  *--------------------------------------------------------------------*/
     133                 : typedef enum
     134                 : {
     135                 :     TABFC_IMapInfoFile = 0,
     136                 :     TABFC_TABFile,
     137                 :     TABFC_TABView,
     138                 :     TABFC_TABSeamless,
     139                 :     TABFC_MIFFile
     140                 : } TABFileClass;
     141                 : 
     142                 : 
     143                 : /*---------------------------------------------------------------------
     144                 :  *                      class IMapInfoFile
     145                 :  *
     146                 :  * Virtual base class for the TABFile and MIFFile classes.
     147                 :  *
     148                 :  * This is the definition of the public interface methods that should
     149                 :  * be available for any type of MapInfo dataset.
     150                 :  *--------------------------------------------------------------------*/
     151                 : 
     152                 : class IMapInfoFile : public OGRLayer
     153                 : {
     154                 :   private:
     155                 : 
     156                 :   protected: 
     157                 :     int                 m_nCurFeatureId;
     158                 :     TABFeature         *m_poCurFeature;
     159                 :     GBool               m_bBoundsSet;
     160                 : 
     161                 :     char                *m_pszCharset;
     162                 : 
     163                 :   public:
     164                 :     IMapInfoFile() ;
     165                 :     virtual ~IMapInfoFile();
     166                 : 
     167               0 :     virtual TABFileClass GetFileClass() {return TABFC_IMapInfoFile;}
     168                 : 
     169                 :     virtual int Open(const char *pszFname, const char *pszAccess,
     170                 :                      GBool bTestOpenNoError = FALSE ) = 0;
     171                 :     virtual int Close() = 0;
     172                 : 
     173               0 :     virtual int SetQuickSpatialIndexMode(GBool bQuickSpatialIndexMode=TRUE) {return -1;}
     174                 : 
     175                 :     virtual const char *GetTableName() = 0;
     176                 : 
     177                 :     ///////////////
     178                 :     // Static method to detect file type, create an object to read that
     179                 :     // file and open it.
     180                 :     static IMapInfoFile *SmartOpen(const char *pszFname,
     181                 :                                    GBool bTestOpenNoError = FALSE);
     182                 : 
     183                 :     ///////////////
     184                 :     //  OGR methods for read support
     185                 :     virtual void        ResetReading() = 0;
     186                 :     virtual int         GetFeatureCount (int bForce) = 0;
     187                 :     virtual OGRFeature *GetNextFeature();
     188                 :     virtual OGRFeature *GetFeature(long nFeatureId);
     189                 :     virtual OGRErr      CreateFeature(OGRFeature *poFeature);
     190                 :     virtual int         TestCapability( const char * pszCap ) =0;
     191                 :     virtual int         GetExtent(OGREnvelope *psExtent, int bForce) =0;
     192                 : 
     193                 :     ///////////////
     194                 :     // Read access specific stuff
     195                 :     //
     196                 :     virtual int GetNextFeatureId(int nPrevId) = 0;
     197                 :     virtual TABFeature *GetFeatureRef(int nFeatureId) = 0;
     198                 :     virtual OGRFeatureDefn *GetLayerDefn() = 0;
     199                 : 
     200                 :     virtual TABFieldType GetNativeFieldType(int nFieldId) = 0;
     201                 : 
     202                 :     virtual int GetBounds(double &dXMin, double &dYMin, 
     203                 :                           double &dXMax, double &dYMax,
     204                 :                           GBool bForce = TRUE ) = 0;
     205                 :     
     206                 :     virtual OGRSpatialReference *GetSpatialRef() = 0;
     207                 : 
     208                 :     virtual int GetFeatureCountByType(int &numPoints, int &numLines,
     209                 :                                       int &numRegions, int &numTexts,
     210                 :                                       GBool bForce = TRUE ) = 0;
     211                 : 
     212                 :     virtual GBool IsFieldIndexed(int nFieldId) = 0;
     213                 :     virtual GBool IsFieldUnique(int nFieldId) = 0;
     214                 : 
     215                 :     ///////////////
     216                 :     // Write access specific stuff
     217                 :     //
     218               9 :     GBool       IsBoundsSet()            {return m_bBoundsSet;}
     219                 :     virtual int SetBounds(double dXMin, double dYMin, 
     220                 :                           double dXMax, double dYMax) = 0;
     221                 :     virtual int SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,
     222                 :                             TABFieldType *paeMapInfoNativeFieldTypes = NULL)=0;
     223                 :     virtual int AddFieldNative(const char *pszName, TABFieldType eMapInfoType,
     224                 :                                int nWidth=0, int nPrecision=0,
     225                 :                                GBool bIndexed=FALSE, GBool bUnique=FALSE) = 0;
     226                 :     virtual OGRErr CreateField( OGRFieldDefn *poField, int bApproxOK = TRUE );
     227                 :     
     228                 :     virtual int SetSpatialRef(OGRSpatialReference *poSpatialRef) = 0;
     229                 : 
     230                 :     virtual OGRErr CreateFeature(TABFeature *poFeature) = 0;
     231                 : 
     232                 :     virtual int SetFieldIndexed(int nFieldId) = 0;
     233                 : 
     234                 :     virtual int SetCharset(const char* charset);
     235                 : 
     236                 :     ///////////////
     237                 :     // semi-private.
     238                 :     virtual int  GetProjInfo(TABProjInfo *poPI) = 0;
     239                 :     virtual int  SetProjInfo(TABProjInfo *poPI) = 0;
     240                 :     virtual int  SetMIFCoordSys(const char *pszMIFCoordSys) = 0;
     241                 : 
     242                 : #ifdef DEBUG
     243                 :     virtual void Dump(FILE *fpOut = NULL) = 0;
     244                 : #endif
     245                 : };
     246                 : 
     247                 : /*---------------------------------------------------------------------
     248                 :  *                      class TABFile
     249                 :  *
     250                 :  * The main class for TAB datasets.  External programs should use this
     251                 :  * class to open a TAB dataset and read/write features from/to it.
     252                 :  *
     253                 :  *--------------------------------------------------------------------*/
     254                 : class TABFile: public IMapInfoFile
     255                 : {
     256                 :   private:
     257                 :     char        *m_pszFname;
     258                 :     TABAccess   m_eAccessMode;
     259                 :     char        **m_papszTABFile;
     260                 :     int         m_nVersion;
     261                 :     int         *m_panIndexNo;
     262                 :     TABTableType m_eTableType;  // NATIVE (.DAT) or DBF
     263                 : 
     264                 :     TABDATFile  *m_poDATFile;   // Attributes file
     265                 :     TABMAPFile  *m_poMAPFile;   // Object Geometry file
     266                 :     TABINDFile  *m_poINDFile;   // Attributes index file
     267                 : 
     268                 :     OGRFeatureDefn *m_poDefn;
     269                 :     OGRSpatialReference *m_poSpatialRef;
     270                 :     int         bUseSpatialTraversal;
     271                 : 
     272                 :     int         m_nLastFeatureId;
     273                 : 
     274                 : 
     275                 :     ///////////////
     276                 :     // Private Read access specific stuff
     277                 :     //
     278                 :     int         ParseTABFileFirstPass(GBool bTestOpenNoError);
     279                 :     int         ParseTABFileFields();
     280                 : 
     281                 :      ///////////////
     282                 :     // Private Write access specific stuff
     283                 :     //
     284                 :     int         WriteTABFile();
     285                 : 
     286                 :   public:
     287                 :     TABFile();
     288                 :     virtual ~TABFile();
     289                 : 
     290               0 :     virtual TABFileClass GetFileClass() {return TABFC_TABFile;}
     291                 : 
     292                 :     virtual int Open(const char *pszFname, const char *pszAccess,
     293                 :                      GBool bTestOpenNoError = FALSE );
     294                 :     virtual int Close();
     295                 : 
     296                 :     virtual int SetQuickSpatialIndexMode(GBool bQuickSpatialIndexMode=TRUE);
     297                 : 
     298               0 :     virtual const char *GetTableName()
     299               0 :                             {return m_poDefn?m_poDefn->GetName():"";};
     300                 : 
     301                 :     virtual void        ResetReading();
     302                 :     virtual int         TestCapability( const char * pszCap );
     303                 :     virtual int         GetFeatureCount (int bForce);
     304                 :     virtual int         GetExtent(OGREnvelope *psExtent, int bForce);
     305                 : 
     306                 :     /* Implement OGRLayer's SetFeature() for random write, only with TABFile */
     307                 :     virtual OGRErr      SetFeature( OGRFeature * );
     308                 : 
     309                 :     ///////////////
     310                 :     // Read access specific stuff
     311                 :     //
     312                 : 
     313                 :     int         GetNextFeatureId_Spatial( int nPrevId );
     314                 : 
     315                 :     virtual int GetNextFeatureId(int nPrevId);
     316                 :     virtual TABFeature *GetFeatureRef(int nFeatureId);
     317                 :     virtual OGRFeatureDefn *GetLayerDefn();
     318                 : 
     319                 :     virtual TABFieldType GetNativeFieldType(int nFieldId);
     320                 : 
     321                 :     virtual int GetBounds(double &dXMin, double &dYMin, 
     322                 :                           double &dXMax, double &dYMax,
     323                 :                           GBool bForce = TRUE );
     324                 :     
     325                 :     virtual OGRSpatialReference *GetSpatialRef();
     326                 : 
     327                 :     virtual int GetFeatureCountByType(int &numPoints, int &numLines,
     328                 :                                       int &numRegions, int &numTexts,
     329                 :                                       GBool bForce = TRUE);
     330                 : 
     331                 :     virtual GBool IsFieldIndexed(int nFieldId);
     332               0 :     virtual GBool IsFieldUnique(int /*nFieldId*/)   {return FALSE;};
     333                 : 
     334                 :     ///////////////
     335                 :     // Write access specific stuff
     336                 :     //
     337                 :     virtual int SetBounds(double dXMin, double dYMin, 
     338                 :                           double dXMax, double dYMax);
     339                 :     virtual int SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,
     340                 :                             TABFieldType *paeMapInfoNativeFieldTypes = NULL);
     341                 :     virtual int AddFieldNative(const char *pszName, TABFieldType eMapInfoType,
     342                 :                                int nWidth=0, int nPrecision=0,
     343                 :                                GBool bIndexed=FALSE, GBool bUnique=FALSE);
     344                 :     virtual int SetSpatialRef(OGRSpatialReference *poSpatialRef);
     345                 : 
     346                 :     virtual OGRErr CreateFeature(TABFeature *poFeature);
     347                 : 
     348                 :     virtual int SetFieldIndexed(int nFieldId);
     349                 : 
     350                 :     ///////////////
     351                 :     // semi-private.
     352               0 :     virtual int  GetProjInfo(TABProjInfo *poPI)
     353               0 :             { return m_poMAPFile->GetHeaderBlock()->GetProjInfo( poPI ); }
     354                 :     virtual int  SetProjInfo(TABProjInfo *poPI);
     355                 :     virtual int  SetMIFCoordSys(const char *pszMIFCoordSys);
     356                 : 
     357                 :     int         GetFieldIndexNumber(int nFieldId);
     358                 :     TABINDFile  *GetINDFileRef();
     359                 : 
     360                 :     TABMAPFile  *GetMAPFileRef() { return m_poMAPFile; }
     361                 : 
     362                 :     int         WriteFeature(TABFeature *poFeature, int nFeatureId /*=-1*/);
     363                 : 
     364                 : #ifdef DEBUG
     365                 :     virtual void Dump(FILE *fpOut = NULL);
     366                 : #endif
     367                 : };
     368                 : 
     369                 : 
     370                 : /*---------------------------------------------------------------------
     371                 :  *                      class TABView
     372                 :  *
     373                 :  * TABView is used to handle special type of .TAB files that are
     374                 :  * composed of a number of .TAB datasets linked through some indexed 
     375                 :  * fields.
     376                 :  *
     377                 :  * NOTE: The current implementation supports only TABViews composed
     378                 :  *       of 2 TABFiles linked through an indexed field of integer type.
     379                 :  *       It is unclear if any other type of views could exist anyways.
     380                 :  *--------------------------------------------------------------------*/
     381                 : class TABView: public IMapInfoFile
     382                 : {
     383                 :   private:
     384                 :     char        *m_pszFname;
     385                 :     TABAccess   m_eAccessMode;
     386                 :     char        **m_papszTABFile;
     387                 :     char        *m_pszVersion;
     388                 :     
     389                 :     char        **m_papszTABFnames;
     390                 :     TABFile     **m_papoTABFiles;
     391                 :     int         m_numTABFiles;
     392                 :     int         m_nMainTableIndex; // The main table is the one that also 
     393                 :                                    // contains the geometries
     394                 :     char        **m_papszFieldNames;
     395                 :     char        **m_papszWhereClause;
     396                 : 
     397                 :     TABRelation *m_poRelation;
     398                 :     GBool       m_bRelFieldsCreated;
     399                 : 
     400                 :     ///////////////
     401                 :     // Private Read access specific stuff
     402                 :     //
     403                 :     int         ParseTABFile(const char *pszDatasetPath, 
     404                 :                              GBool bTestOpenNoError = FALSE);
     405                 : 
     406                 :     int         OpenForRead(const char *pszFname, 
     407                 :                             GBool bTestOpenNoError = FALSE );
     408                 : 
     409                 :     ///////////////
     410                 :     // Private Write access specific stuff
     411                 :     //
     412                 :     int         OpenForWrite(const char *pszFname );
     413                 :     int         WriteTABFile();
     414                 : 
     415                 : 
     416                 :   public:
     417                 :     TABView();
     418                 :     virtual ~TABView();
     419                 : 
     420               0 :     virtual TABFileClass GetFileClass() {return TABFC_TABView;}
     421                 : 
     422                 :     virtual int Open(const char *pszFname, const char *pszAccess,
     423                 :                      GBool bTestOpenNoError = FALSE );
     424                 :     virtual int Close();
     425                 : 
     426                 :     virtual int SetQuickSpatialIndexMode(GBool bQuickSpatialIndexMode=TRUE);
     427                 : 
     428               0 :     virtual const char *GetTableName()
     429               0 :            {return m_poRelation?m_poRelation->GetFeatureDefn()->GetName():"";};
     430                 : 
     431                 :     virtual void        ResetReading();
     432                 :     virtual int         TestCapability( const char * pszCap );
     433                 :     virtual int         GetFeatureCount (int bForce);
     434                 :     virtual int         GetExtent(OGREnvelope *psExtent, int bForce);
     435                 :     
     436                 :     ///////////////
     437                 :     // Read access specific stuff
     438                 :     //
     439                 : 
     440                 :     virtual int GetNextFeatureId(int nPrevId);
     441                 :     virtual TABFeature *GetFeatureRef(int nFeatureId);
     442                 :     virtual OGRFeatureDefn *GetLayerDefn();
     443                 : 
     444                 :     virtual TABFieldType GetNativeFieldType(int nFieldId);
     445                 : 
     446                 :     virtual int GetBounds(double &dXMin, double &dYMin, 
     447                 :                           double &dXMax, double &dYMax,
     448                 :                           GBool bForce = TRUE );
     449                 :     
     450                 :     virtual OGRSpatialReference *GetSpatialRef();
     451                 : 
     452                 :     virtual int GetFeatureCountByType(int &numPoints, int &numLines,
     453                 :                                       int &numRegions, int &numTexts,
     454                 :                                       GBool bForce = TRUE);
     455                 : 
     456                 :     virtual GBool IsFieldIndexed(int nFieldId);
     457                 :     virtual GBool IsFieldUnique(int nFieldId);
     458                 : 
     459                 :     ///////////////
     460                 :     // Write access specific stuff
     461                 :     //
     462                 :     virtual int SetBounds(double dXMin, double dYMin, 
     463                 :                           double dXMax, double dYMax);
     464                 :     virtual int SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,
     465                 :                            TABFieldType *paeMapInfoNativeFieldTypes=NULL);
     466                 :     virtual int AddFieldNative(const char *pszName,
     467                 :                                TABFieldType eMapInfoType,
     468                 :                                int nWidth=0, int nPrecision=0,
     469                 :                                GBool bIndexed=FALSE, GBool bUnique=FALSE);
     470                 :     virtual int SetSpatialRef(OGRSpatialReference *poSpatialRef);
     471                 : 
     472                 :     virtual OGRErr CreateFeature(TABFeature *poFeature);
     473                 : 
     474                 :     virtual int SetFieldIndexed(int nFieldId);
     475                 : 
     476                 :     ///////////////
     477                 :     // semi-private.
     478               0 :     virtual int  GetProjInfo(TABProjInfo *poPI)
     479                 :             { return m_nMainTableIndex!=-1?
     480               0 :                      m_papoTABFiles[m_nMainTableIndex]->GetProjInfo(poPI):-1; }
     481               0 :     virtual int  SetProjInfo(TABProjInfo *poPI)
     482                 :             { return m_nMainTableIndex!=-1?
     483               0 :                      m_papoTABFiles[m_nMainTableIndex]->SetProjInfo(poPI):-1; }
     484               0 :     virtual int  SetMIFCoordSys(const char * /*pszMIFCoordSys*/) {return -1;};
     485                 : 
     486                 : #ifdef DEBUG
     487                 :     virtual void Dump(FILE *fpOut = NULL);
     488                 : #endif
     489                 : };
     490                 : 
     491                 : 
     492                 : /*---------------------------------------------------------------------
     493                 :  *                      class TABSeamless
     494                 :  *
     495                 :  * TABSeamless is used to handle seamless .TAB files that are
     496                 :  * composed of a main .TAB file in which each feature is the MBR of
     497                 :  * a base table.
     498                 :  *
     499                 :  * TABSeamless are supported for read access only.
     500                 :  *--------------------------------------------------------------------*/
     501                 : class TABSeamless: public IMapInfoFile
     502                 : {
     503                 :   private:
     504                 :     char        *m_pszFname;
     505                 :     char        *m_pszPath;
     506                 :     TABAccess   m_eAccessMode;
     507                 :     OGRFeatureDefn *m_poFeatureDefnRef;
     508                 : 
     509                 :     TABFile     *m_poIndexTable;
     510                 :     int         m_nTableNameField;
     511                 :     int         m_nCurBaseTableId;
     512                 :     TABFile     *m_poCurBaseTable;
     513                 :     GBool       m_bEOF;
     514                 : 
     515                 :     ///////////////
     516                 :     // Private Read access specific stuff
     517                 :     //
     518                 :     int         OpenForRead(const char *pszFname, 
     519                 :                             GBool bTestOpenNoError = FALSE );
     520                 :     int         OpenBaseTable(TABFeature *poIndexFeature,
     521                 :                               GBool bTestOpenNoError = FALSE);
     522                 :     int         OpenBaseTable(int nTableId, GBool bTestOpenNoError = FALSE);
     523                 :     int         OpenNextBaseTable(GBool bTestOpenNoError =FALSE);
     524                 :     int         EncodeFeatureId(int nTableId, int nBaseFeatureId);
     525                 :     int         ExtractBaseTableId(int nEncodedFeatureId);
     526                 :     int         ExtractBaseFeatureId(int nEncodedFeatureId);
     527                 : 
     528                 :   public:
     529                 :     TABSeamless();
     530                 :     virtual ~TABSeamless();
     531                 : 
     532               0 :     virtual TABFileClass GetFileClass() {return TABFC_TABSeamless;}
     533                 : 
     534                 :     virtual int Open(const char *pszFname, const char *pszAccess,
     535                 :                      GBool bTestOpenNoError = FALSE );
     536                 :     virtual int Close();
     537                 : 
     538               0 :     virtual const char *GetTableName()
     539               0 :            {return m_poFeatureDefnRef?m_poFeatureDefnRef->GetName():"";};
     540                 : 
     541                 :     virtual void        SetSpatialFilter( OGRGeometry * );
     542                 : 
     543                 :     virtual void        ResetReading();
     544                 :     virtual int         TestCapability( const char * pszCap );
     545                 :     virtual int         GetFeatureCount (int bForce);
     546                 :     virtual int         GetExtent(OGREnvelope *psExtent, int bForce);
     547                 :     
     548                 :     ///////////////
     549                 :     // Read access specific stuff
     550                 :     //
     551                 : 
     552                 :     virtual int GetNextFeatureId(int nPrevId);
     553                 :     virtual TABFeature *GetFeatureRef(int nFeatureId);
     554                 :     virtual OGRFeatureDefn *GetLayerDefn();
     555                 : 
     556                 :     virtual TABFieldType GetNativeFieldType(int nFieldId);
     557                 : 
     558                 :     virtual int GetBounds(double &dXMin, double &dYMin, 
     559                 :                           double &dXMax, double &dYMax,
     560                 :                           GBool bForce = TRUE );
     561                 :     
     562                 :     virtual OGRSpatialReference *GetSpatialRef();
     563                 : 
     564                 :     virtual int GetFeatureCountByType(int &numPoints, int &numLines,
     565                 :                                       int &numRegions, int &numTexts,
     566                 :                                       GBool bForce = TRUE);
     567                 : 
     568                 :     virtual GBool IsFieldIndexed(int nFieldId);
     569                 :     virtual GBool IsFieldUnique(int nFieldId);
     570                 : 
     571                 :     ///////////////
     572                 :     // Write access specific stuff
     573                 :     //
     574                 :     virtual int SetBounds(double dXMin, double dYMin, 
     575               0 :                           double dXMax, double dYMax)   {return -1;}
     576                 :     virtual int SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,
     577               0 :                                TABFieldType *paeMapInfoNativeFieldTypes=NULL)
     578               0 :                                                         {return -1;}
     579                 :     virtual int AddFieldNative(const char *pszName,
     580                 :                                TABFieldType eMapInfoType,
     581                 :                                int nWidth=0, int nPrecision=0,
     582                 :                                GBool bIndexed=FALSE, 
     583               0 :                                GBool bUnique=FALSE)     {return -1;}
     584                 : 
     585               0 :     virtual int SetSpatialRef(OGRSpatialReference *poSpatialRef) {return -1;}
     586                 : 
     587               0 :     virtual OGRErr CreateFeature(TABFeature *poFeature) 
     588               0 :                                         {return OGRERR_UNSUPPORTED_OPERATION;}
     589                 : 
     590               0 :     virtual int SetFieldIndexed(int nFieldId)   {return -1;}
     591                 : 
     592                 :     ///////////////
     593                 :     // semi-private.
     594               0 :     virtual int  GetProjInfo(TABProjInfo *poPI)
     595               0 :             { return m_poIndexTable?m_poIndexTable->GetProjInfo(poPI):-1; }
     596               0 :     virtual int  SetProjInfo(TABProjInfo *poPI)         { return -1; }
     597               0 :     virtual int  SetMIFCoordSys(const char * /*pszMIFCoordSys*/) {return -1;};
     598                 : 
     599                 : #ifdef DEBUG
     600                 :     virtual void Dump(FILE *fpOut = NULL);
     601                 : #endif
     602                 : };
     603                 : 
     604                 : 
     605                 : /*---------------------------------------------------------------------
     606                 :  *                      class MIFFile
     607                 :  *
     608                 :  * The main class for (MID/MIF) datasets.  External programs should use this
     609                 :  * class to open a (MID/MIF) dataset and read/write features from/to it.
     610                 :  *
     611                 :  *--------------------------------------------------------------------*/
     612                 : class MIFFile: public IMapInfoFile
     613                 : {
     614                 :   private:
     615                 :     char        *m_pszFname;
     616                 :     TABAccess    m_eAccessMode;
     617                 :     int          m_nVersion;   /* Dataset version: 300, 450, 600, 900, etc. */
     618                 :     char        *m_pszDelimiter;
     619                 :     char        *m_pszUnique;
     620                 :     char        *m_pszIndex;
     621                 :     char        *m_pszCoordSys;
     622                 : 
     623                 :     TABFieldType *m_paeFieldType;
     624                 :     GBool       *m_pabFieldIndexed;
     625                 :     GBool       *m_pabFieldUnique;
     626                 :     
     627                 :     double       m_dfXMultiplier;
     628                 :     double       m_dfYMultiplier;
     629                 :     double       m_dfXDisplacement;
     630                 :     double       m_dfYDisplacement;
     631                 : 
     632                 :     /* these are the projection bounds, possibly much broader than extents */
     633                 :     double      m_dXMin;
     634                 :     double      m_dYMin;
     635                 :     double      m_dXMax;
     636                 :     double      m_dYMax;
     637                 : 
     638                 :     /* extents, as cached by MIFFile::PreParseFile() */
     639                 :     int         m_bExtentsSet;
     640                 :     OGREnvelope m_sExtents;
     641                 : 
     642                 :     int         m_nPoints;
     643                 :     int         m_nLines;
     644                 :     int         m_nRegions;
     645                 :     int         m_nTexts;
     646                 : 
     647                 :     int         m_nPreloadedId;  // preloaded mif line is for this feature id
     648                 :     MIDDATAFile  *m_poMIDFile;   // Mid file
     649                 :     MIDDATAFile  *m_poMIFFile;   // Mif File
     650                 : 
     651                 :     OGRFeatureDefn *m_poDefn;
     652                 :     OGRSpatialReference *m_poSpatialRef;
     653                 : 
     654                 :     int         m_nFeatureCount;
     655                 :     int         m_nWriteFeatureId;
     656                 :     int         m_nAttribut;
     657                 : 
     658                 :     ///////////////
     659                 :     // Private Read access specific stuff
     660                 :     //
     661                 :     int         ReadFeatureDefn();
     662                 :     int         ParseMIFHeader();
     663                 :     void        PreParseFile();
     664                 :     int         AddFields(const char *pszLine);
     665                 :     int         GotoFeature(int nFeatureId);
     666                 :     int         NextFeature();
     667                 : 
     668                 :     ///////////////
     669                 :     // Private Write access specific stuff
     670                 :     //
     671                 :     GBool       m_bPreParsed;
     672                 :     GBool       m_bHeaderWrote;
     673                 :     
     674                 :     int         WriteMIFHeader();
     675                 :     void UpdateExtents(double dfX,double dfY);
     676                 : 
     677                 :   public:
     678                 :     MIFFile();
     679                 :     virtual ~MIFFile();
     680                 : 
     681               0 :     virtual TABFileClass GetFileClass() {return TABFC_MIFFile;}
     682                 : 
     683                 :     virtual int Open(const char *pszFname, const char *pszAccess,
     684                 :                      GBool bTestOpenNoError = FALSE );
     685                 :     virtual int Close();
     686                 : 
     687               0 :     virtual const char *GetTableName()
     688               0 :                            {return m_poDefn?m_poDefn->GetName():"";};
     689                 : 
     690                 :     virtual int         TestCapability( const char * pszCap ) ;
     691                 :     virtual int         GetFeatureCount (int bForce);
     692                 :     virtual void        ResetReading();
     693                 :     virtual int         GetExtent(OGREnvelope *psExtent, int bForce);
     694                 : 
     695                 :     ///////////////
     696                 :     // Read access specific stuff
     697                 :     //
     698                 :     
     699                 :     virtual int GetNextFeatureId(int nPrevId);
     700                 :     virtual TABFeature *GetFeatureRef(int nFeatureId);
     701                 :     virtual OGRFeatureDefn *GetLayerDefn();
     702                 : 
     703                 :     virtual TABFieldType GetNativeFieldType(int nFieldId);
     704                 : 
     705                 :     virtual int GetBounds(double &dXMin, double &dYMin, 
     706                 :                           double &dXMax, double &dYMax,
     707                 :                           GBool bForce = TRUE );
     708                 :     
     709                 :     virtual OGRSpatialReference *GetSpatialRef();
     710                 : 
     711                 :     virtual int GetFeatureCountByType(int &numPoints, int &numLines,
     712                 :                                       int &numRegions, int &numTexts,
     713                 :                                       GBool bForce = TRUE);
     714                 : 
     715                 :     virtual GBool IsFieldIndexed(int nFieldId);
     716                 :     virtual GBool IsFieldUnique(int nFieldId);
     717                 : 
     718                 :     ///////////////
     719                 :     // Write access specific stuff
     720                 :     //
     721                 :     virtual int SetBounds(double dXMin, double dYMin, 
     722                 :                           double dXMax, double dYMax);
     723                 :     virtual int SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,
     724                 :                             TABFieldType *paeMapInfoNativeFieldTypes = NULL);
     725                 :     virtual int AddFieldNative(const char *pszName, TABFieldType eMapInfoType,
     726                 :                                int nWidth=0, int nPrecision=0,
     727                 :                                GBool bIndexed=FALSE, GBool bUnique=FALSE);
     728                 :     /* TODO */
     729                 :     virtual int SetSpatialRef(OGRSpatialReference *poSpatialRef);
     730                 : 
     731                 :     virtual OGRErr CreateFeature(TABFeature *poFeature);
     732                 : 
     733                 :     virtual int SetFieldIndexed(int nFieldId);
     734                 : 
     735                 :     ///////////////
     736                 :     // semi-private.
     737               0 :     virtual int  GetProjInfo(TABProjInfo * /*poPI*/){return -1;}
     738                 :     /*  { return m_poMAPFile->GetHeaderBlock()->GetProjInfo( poPI ); }*/
     739               0 :     virtual int  SetProjInfo(TABProjInfo * /*poPI*/){return -1;}
     740                 :     /*  { return m_poMAPFile->GetHeaderBlock()->SetProjInfo( poPI ); }*/
     741                 :     virtual int  SetMIFCoordSys(const char * pszMIFCoordSys);
     742                 : 
     743                 : #ifdef DEBUG
     744               0 :     virtual void Dump(FILE * /*fpOut*/ = NULL) {};
     745                 : #endif
     746                 : };
     747                 : 
     748                 : /*---------------------------------------------------------------------
     749                 :  * Define some error codes specific to this lib.
     750                 :  *--------------------------------------------------------------------*/
     751                 : #define TAB_WarningFeatureTypeNotSupported     501
     752                 : #define TAB_WarningInvalidFieldName            502
     753                 : #define TAB_WarningBoundsOverflow              503
     754                 : 
     755                 : /*---------------------------------------------------------------------
     756                 :  * Codes for the known MapInfo Geometry types
     757                 :  *--------------------------------------------------------------------*/
     758                 : #define TAB_GEOM_NONE           0
     759                 : #define TAB_GEOM_SYMBOL_C       0x01
     760                 : #define TAB_GEOM_SYMBOL         0x02
     761                 : #define TAB_GEOM_LINE_C         0x04
     762                 : #define TAB_GEOM_LINE           0x05
     763                 : #define TAB_GEOM_PLINE_C        0x07
     764                 : #define TAB_GEOM_PLINE          0x08
     765                 : #define TAB_GEOM_ARC_C          0x0a
     766                 : #define TAB_GEOM_ARC            0x0b
     767                 : #define TAB_GEOM_REGION_C       0x0d
     768                 : #define TAB_GEOM_REGION         0x0e
     769                 : #define TAB_GEOM_TEXT_C         0x10
     770                 : #define TAB_GEOM_TEXT           0x11
     771                 : #define TAB_GEOM_RECT_C         0x13
     772                 : #define TAB_GEOM_RECT           0x14
     773                 : #define TAB_GEOM_ROUNDRECT_C    0x16
     774                 : #define TAB_GEOM_ROUNDRECT      0x17
     775                 : #define TAB_GEOM_ELLIPSE_C      0x19
     776                 : #define TAB_GEOM_ELLIPSE        0x1a
     777                 : #define TAB_GEOM_MULTIPLINE_C   0x25
     778                 : #define TAB_GEOM_MULTIPLINE     0x26
     779                 : #define TAB_GEOM_FONTSYMBOL_C   0x28 
     780                 : #define TAB_GEOM_FONTSYMBOL     0x29
     781                 : #define TAB_GEOM_CUSTOMSYMBOL_C 0x2b
     782                 : #define TAB_GEOM_CUSTOMSYMBOL   0x2c
     783                 : /* Version 450 object types: */
     784                 : #define TAB_GEOM_V450_REGION_C  0x2e
     785                 : #define TAB_GEOM_V450_REGION    0x2f
     786                 : #define TAB_GEOM_V450_MULTIPLINE_C 0x31
     787                 : #define TAB_GEOM_V450_MULTIPLINE   0x32
     788                 : /* Version 650 object types: */
     789                 : #define TAB_GEOM_MULTIPOINT_C   0x34
     790                 : #define TAB_GEOM_MULTIPOINT     0x35
     791                 : #define TAB_GEOM_COLLECTION_C   0x37
     792                 : #define TAB_GEOM_COLLECTION     0x38
     793                 : /* Version 800 object types: */
     794                 : #define TAB_GEOM_UNKNOWN1_C     0x3a    // ???
     795                 : #define TAB_GEOM_UNKNOWN1       0x3b    // ???
     796                 : #define TAB_GEOM_V800_REGION_C  0x3d
     797                 : #define TAB_GEOM_V800_REGION    0x3e
     798                 : #define TAB_GEOM_V800_MULTIPLINE_C 0x40
     799                 : #define TAB_GEOM_V800_MULTIPLINE   0x41
     800                 : #define TAB_GEOM_V800_MULTIPOINT_C 0x43
     801                 : #define TAB_GEOM_V800_MULTIPOINT   0x44
     802                 : #define TAB_GEOM_V800_COLLECTION_C 0x46
     803                 : #define TAB_GEOM_V800_COLLECTION   0x47
     804                 : 
     805                 : #define TAB_GEOM_GET_VERSION(nGeomType)                     \
     806                 :     (((nGeomType) < TAB_GEOM_V450_REGION_C)  ? 300:         \
     807                 :      ((nGeomType) < TAB_GEOM_MULTIPOINT_C)   ? 450:         \
     808                 :      ((nGeomType) < TAB_GEOM_UNKNOWN1_C)     ? 650: 800 )
     809                 : 
     810                 : 
     811                 : /*---------------------------------------------------------------------
     812                 :  * Codes for the feature classes
     813                 :  *--------------------------------------------------------------------*/
     814                 : typedef enum
     815                 : {
     816                 :     TABFCNoGeomFeature = 0,
     817                 :     TABFCPoint = 1,
     818                 :     TABFCFontPoint = 2,
     819                 :     TABFCCustomPoint = 3,
     820                 :     TABFCText = 4,
     821                 :     TABFCPolyline = 5,
     822                 :     TABFCArc = 6,
     823                 :     TABFCRegion = 7,
     824                 :     TABFCRectangle = 8,
     825                 :     TABFCEllipse = 9,
     826                 :     TABFCMultiPoint = 10,
     827                 :     TABFCCollection = 11,
     828                 :     TABFCDebugFeature
     829                 : } TABFeatureClass;
     830                 : 
     831                 : /*---------------------------------------------------------------------
     832                 :  * Definitions for text attributes
     833                 :  *--------------------------------------------------------------------*/
     834                 : typedef enum TABTextJust_t
     835                 : {
     836                 :     TABTJLeft = 0,      // Default: Left Justification
     837                 :     TABTJCenter,
     838                 :     TABTJRight
     839                 : } TABTextJust;
     840                 : 
     841                 : typedef enum TABTextSpacing_t
     842                 : {
     843                 :     TABTSSingle = 0,    // Default: Single spacing
     844                 :     TABTS1_5,           // 1.5
     845                 :     TABTSDouble
     846                 : } TABTextSpacing;
     847                 : 
     848                 : typedef enum TABTextLineType_t
     849                 : {
     850                 :     TABTLNoLine = 0,    // Default: No line
     851                 :     TABTLSimple,
     852                 :     TABTLArrow
     853                 : } TABTextLineType;
     854                 : 
     855                 : typedef enum TABFontStyle_t     // Can be OR'ed
     856                 : {                               // except box and halo are mutually exclusive
     857                 :     TABFSNone       = 0,
     858                 :     TABFSBold       = 0x0001,
     859                 :     TABFSItalic     = 0x0002,
     860                 :     TABFSUnderline  = 0x0004,
     861                 :     TABFSStrikeout  = 0x0008,
     862                 :     TABFSOutline    = 0x0010,
     863                 :     TABFSShadow     = 0x0020,
     864                 :     TABFSInverse    = 0x0040,
     865                 :     TABFSBlink      = 0x0080,
     866                 :     TABFSBox        = 0x0100,   // See note about box vs halo below.
     867                 :     TABFSHalo       = 0x0200,   // MIF uses 256, see MIF docs, App.A
     868                 :     TABFSAllCaps    = 0x0400,   // MIF uses 512
     869                 :     TABFSExpanded   = 0x0800    // MIF uses 1024
     870                 : } TABFontStyle;
     871                 : 
     872                 : /* TABFontStyle enum notes:
     873                 :  *
     874                 :  * The enumeration values above correspond to the values found in a .MAP
     875                 :  * file. However, they differ a little from what is found in a MIF file:
     876                 :  * Values 0x01 to 0x80 are the same in .MIF and .MAP files.
     877                 :  * Values 0x200 to 0x800 in .MAP are 0x100 to 0x400 in .MIF
     878                 :  *
     879                 :  * What about TABFSBox (0x100) ?
     880                 :  * TABFSBox is stored just like the other styles in .MAP files but it is not 
     881                 :  * explicitly stored in a MIF file.
     882                 :  * If a .MIF FONT() clause contains the optional BG color, then this implies
     883                 :  * that either Halo or Box was set.  Thus if TABFSHalo (value 256 in MIF) 
     884                 :  * is not set in the style, then this implies that TABFSBox should be set.
     885                 :  */
     886                 : 
     887                 : typedef enum TABCustSymbStyle_t // Can be OR'ed
     888                 : { 
     889                 :     TABCSNone       = 0,        // Transparent BG, use default colors
     890                 :     TABCSBGOpaque   = 0x01,     // White pixels are opaque
     891                 :     TABCSApplyColor = 0x02      // non-white pixels drawn using symbol color
     892                 : } TABCustSymbStyle;
     893                 : 
     894                 : /*=====================================================================
     895                 :   Base classes to be used to add supported drawing tools to each feature type
     896                 :  =====================================================================*/
     897                 : 
     898                 : class ITABFeaturePen
     899                 : {
     900                 :   protected:
     901                 :     int         m_nPenDefIndex;
     902                 :     TABPenDef   m_sPenDef;
     903                 :   public:
     904                 :     ITABFeaturePen();
     905             102 :     ~ITABFeaturePen() {};
     906                 :     int         GetPenDefIndex() {return m_nPenDefIndex;};
     907               0 :     TABPenDef  *GetPenDefRef() {return &m_sPenDef;};
     908                 : 
     909                 :     GByte       GetPenWidthPixel();
     910                 :     double      GetPenWidthPoint();
     911                 :     int         GetPenWidthMIF();
     912              34 :     GByte       GetPenPattern() {return m_sPenDef.nLinePattern;};
     913              10 :     GInt32      GetPenColor()   {return m_sPenDef.rgbColor;};
     914                 : 
     915                 :     void        SetPenWidthPixel(GByte val);
     916                 :     void        SetPenWidthPoint(double val);
     917                 :     void        SetPenWidthMIF(int val);
     918                 : 
     919              28 :     void        SetPenPattern(GByte val) {m_sPenDef.nLinePattern=val;};
     920              28 :     void        SetPenColor(GInt32 clr)  {m_sPenDef.rgbColor = clr;};
     921                 : 
     922                 :     const char *GetPenStyleString();
     923                 :     void        SetPenFromStyleString(const char *pszStyleString);
     924                 : 
     925                 :     void        DumpPenDef(FILE *fpOut = NULL);
     926                 : };
     927                 : 
     928                 : class ITABFeatureBrush
     929                 : {
     930                 :   protected:
     931                 :     int         m_nBrushDefIndex;
     932                 :     TABBrushDef m_sBrushDef;
     933                 :   public:
     934                 :     ITABFeatureBrush();
     935             100 :     ~ITABFeatureBrush() {};
     936                 :     int         GetBrushDefIndex() {return m_nBrushDefIndex;};
     937               0 :     TABBrushDef *GetBrushDefRef() {return &m_sBrushDef;};
     938                 : 
     939              10 :     GInt32      GetBrushFGColor()     {return m_sBrushDef.rgbFGColor;};
     940              10 :     GInt32      GetBrushBGColor()     {return m_sBrushDef.rgbBGColor;};
     941              20 :     GByte       GetBrushPattern()     {return m_sBrushDef.nFillPattern;};
     942              17 :     GByte       GetBrushTransparent() {return m_sBrushDef.bTransparentFill;};
     943                 : 
     944              28 :     void        SetBrushFGColor(GInt32 clr)  { m_sBrushDef.rgbFGColor = clr;};
     945              28 :     void        SetBrushBGColor(GInt32 clr)  { m_sBrushDef.rgbBGColor = clr;};
     946              28 :     void        SetBrushPattern(GByte val)   { m_sBrushDef.nFillPattern=val;};
     947               0 :     void        SetBrushTransparent(GByte val)
     948               0 :                                           {m_sBrushDef.bTransparentFill=val;};
     949                 : 
     950                 :     const char *GetBrushStyleString();
     951                 :     void        SetBrushFromStyleString(const char *pszStyleString);
     952                 : 
     953                 :     void        DumpBrushDef(FILE *fpOut = NULL);
     954                 : };
     955                 : 
     956                 : class ITABFeatureFont
     957                 : {
     958                 :   protected:
     959                 :     int         m_nFontDefIndex;
     960                 :     TABFontDef  m_sFontDef;
     961                 :   public:
     962                 :     ITABFeatureFont();
     963               0 :     ~ITABFeatureFont() {};
     964                 :     int         GetFontDefIndex() {return m_nFontDefIndex;};
     965               0 :     TABFontDef *GetFontDefRef() {return &m_sFontDef;};
     966                 : 
     967               0 :     const char *GetFontNameRef() {return m_sFontDef.szFontName;};
     968                 : 
     969                 :     void        SetFontName(const char *pszName);
     970                 : 
     971                 :     void        DumpFontDef(FILE *fpOut = NULL);
     972                 : };
     973                 : 
     974                 : class ITABFeatureSymbol
     975                 : {
     976                 :   protected:
     977                 :     int         m_nSymbolDefIndex;
     978                 :     TABSymbolDef m_sSymbolDef;
     979                 :   public:
     980                 :     ITABFeatureSymbol();
     981               8 :     ~ITABFeatureSymbol() {};
     982                 :     int         GetSymbolDefIndex() {return m_nSymbolDefIndex;};
     983               0 :     TABSymbolDef *GetSymbolDefRef() {return &m_sSymbolDef;};
     984                 : 
     985               4 :     GInt16      GetSymbolNo()    {return m_sSymbolDef.nSymbolNo;};
     986               4 :     GInt16      GetSymbolSize()  {return m_sSymbolDef.nPointSize;};
     987               4 :     GInt32      GetSymbolColor() {return m_sSymbolDef.rgbColor;};
     988                 : 
     989               4 :     void        SetSymbolNo(GInt16 val)     { m_sSymbolDef.nSymbolNo = val;};
     990               4 :     void        SetSymbolSize(GInt16 val)   { m_sSymbolDef.nPointSize = val;};
     991               4 :     void        SetSymbolColor(GInt32 clr)  { m_sSymbolDef.rgbColor = clr;};
     992                 : 
     993                 :     const char *GetSymbolStyleString(double dfAngle = 0.0);
     994                 :     void        SetSymbolFromStyleString(const char *pszStyleString);
     995                 : 
     996                 :     void        DumpSymbolDef(FILE *fpOut = NULL);
     997                 : };
     998                 : 
     999                 : 
    1000                 : /*=====================================================================
    1001                 :                         Feature Classes
    1002                 :  =====================================================================*/
    1003                 : 
    1004                 : /*---------------------------------------------------------------------
    1005                 :  *                      class TABFeature
    1006                 :  *
    1007                 :  * Extend the OGRFeature to support MapInfo specific extensions related
    1008                 :  * to geometry types, representation strings, etc.
    1009                 :  *
    1010                 :  * TABFeature will be used as a base class for all the feature classes.
    1011                 :  *
    1012                 :  * This class will also be used to instanciate objects with no Geometry
    1013                 :  * (i.e. type TAB_GEOM_NONE) which is a valid case in MapInfo.
    1014                 :  *
    1015                 :  * The logic to read/write the object from/to the .DAT and .MAP files is also
    1016                 :  * implemented as part of this class and derived classes.
    1017                 :  *--------------------------------------------------------------------*/
    1018                 : class TABFeature: public OGRFeature
    1019                 : {
    1020                 :   protected:
    1021                 :     int         m_nMapInfoType;
    1022                 : 
    1023                 :     double      m_dXMin;
    1024                 :     double      m_dYMin;
    1025                 :     double      m_dXMax;
    1026                 :     double      m_dYMax;
    1027                 : 
    1028                 :     GBool       m_bDeletedFlag;
    1029                 : 
    1030                 :     void        CopyTABFeatureBase(TABFeature *poDestFeature);
    1031                 : 
    1032                 :     // Compr. Origin is set for TAB files by ValidateCoordType()
    1033                 :     GInt32      m_nXMin;
    1034                 :     GInt32      m_nYMin;
    1035                 :     GInt32      m_nXMax;
    1036                 :     GInt32      m_nYMax;
    1037                 :     GInt32      m_nComprOrgX;
    1038                 :     GInt32      m_nComprOrgY;
    1039                 : 
    1040                 :     virtual int UpdateMBR(TABMAPFile *poMapFile = NULL);
    1041                 : 
    1042                 :   public:
    1043                 :              TABFeature(OGRFeatureDefn *poDefnIn );
    1044                 :     virtual ~TABFeature();
    1045                 : 
    1046                 :     static  TABFeature     *CreateFromMapInfoType(int nMapInfoType,
    1047                 :                                                   OGRFeatureDefn *poDefn);
    1048                 : 
    1049                 :     virtual TABFeature     *CloneTABFeature(OGRFeatureDefn *pNewDefn = NULL);
    1050               1 :     virtual TABFeatureClass GetFeatureClass() { return TABFCNoGeomFeature; };
    1051               0 :     virtual int             GetMapInfoType()  { return m_nMapInfoType; };
    1052               1 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL)
    1053               1 :                                                 {m_nMapInfoType=TAB_GEOM_NONE;
    1054               1 :                                                  return m_nMapInfoType;};
    1055                 :     GBool       IsRecordDeleted() { return m_bDeletedFlag; };
    1056              53 :     void        SetRecordDeleted(GBool bDeleted) { m_bDeletedFlag=bDeleted; };
    1057                 : 
    1058                 :     /*-----------------------------------------------------------------
    1059                 :      * TAB Support
    1060                 :      *----------------------------------------------------------------*/
    1061                 : 
    1062                 :     virtual int ReadRecordFromDATFile(TABDATFile *poDATFile);
    1063                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1064                 :                                         GBool bCoordDataOnly=FALSE,
    1065                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1066                 : 
    1067                 :     virtual int WriteRecordToDATFile(TABDATFile *poDATFile,
    1068                 :                                      TABINDFile *poINDFile, int *panIndexNo);
    1069                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1070                 :                                        GBool bCoordDataOnly=FALSE,
    1071                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1072                 :     GBool       ValidateCoordType(TABMAPFile * poMapFile);
    1073                 :     void        ForceCoordTypeAndOrigin(int nMapInfoType, GBool bCompr,
    1074                 :                                         GInt32 nComprOrgX, GInt32 nComprOrgY,
    1075                 :                                         GInt32 nXMin, GInt32 nYMin, 
    1076                 :                                         GInt32 nXMax, GInt32 nYMax);
    1077                 : 
    1078                 :     /*-----------------------------------------------------------------
    1079                 :      * Mid/Mif Support
    1080                 :      *----------------------------------------------------------------*/
    1081                 : 
    1082                 :     virtual int ReadRecordFromMIDFile(MIDDATAFile *fp);
    1083                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1084                 : 
    1085                 :     virtual int WriteRecordToMIDFile(MIDDATAFile *fp);
    1086                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1087                 : 
    1088                 :     void ReadMIFParameters(MIDDATAFile *fp);
    1089                 :     void WriteMIFParameters(MIDDATAFile *fp);
    1090                 : 
    1091                 :     /*-----------------------------------------------------------------
    1092                 :      *----------------------------------------------------------------*/
    1093                 : 
    1094                 :     void        SetMBR(double dXMin, double dYMin, 
    1095                 :                        double dXMax, double dYMax);
    1096                 :     void        GetMBR(double &dXMin, double &dYMin, 
    1097                 :                        double &dXMax, double &dYMax);
    1098                 :     void        SetIntMBR(GInt32 nXMin, GInt32 nYMin, 
    1099                 :                           GInt32 nXMax, GInt32 nYMax);
    1100                 :     void        GetIntMBR(GInt32 &nXMin, GInt32 &nYMin, 
    1101                 :                           GInt32 &nXMax, GInt32 &nYMax);
    1102                 : 
    1103                 :     virtual void DumpMID(FILE *fpOut = NULL);
    1104                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1105                 : 
    1106                 : };
    1107                 : 
    1108                 : 
    1109                 : /*---------------------------------------------------------------------
    1110                 :  *                      class TABPoint
    1111                 :  *
    1112                 :  * Feature class to handle old style MapInfo point symbols:
    1113                 :  *
    1114                 :  *     TAB_GEOM_SYMBOL_C        0x01
    1115                 :  *     TAB_GEOM_SYMBOL          0x02
    1116                 :  *
    1117                 :  * Feature geometry will be a OGRPoint
    1118                 :  *
    1119                 :  * The symbol number is in the range [31..67], with 31=None and corresponds
    1120                 :  * to one of the 35 predefined "Old MapInfo Symbols"
    1121                 :  *
    1122                 :  * NOTE: This class is also used as a base class for the other point
    1123                 :  * symbol types TABFontPoint and TABCustomPoint.
    1124                 :  *--------------------------------------------------------------------*/
    1125                 : class TABPoint: public TABFeature, 
    1126                 :                 public ITABFeatureSymbol
    1127                 : {
    1128                 :   public:
    1129                 :              TABPoint(OGRFeatureDefn *poDefnIn);
    1130                 :     virtual ~TABPoint();
    1131                 : 
    1132               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCPoint; };
    1133                 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL);
    1134                 : 
    1135                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1136                 : 
    1137                 :     double      GetX();
    1138                 :     double      GetY();
    1139                 : 
    1140                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1141                 :                                         GBool bCoordDataOnly=FALSE,
    1142                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1143                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1144                 :                                        GBool bCoordDataOnly=FALSE,
    1145                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1146                 : 
    1147                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1148                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1149                 : 
    1150                 :     virtual const char *GetStyleString();
    1151                 : 
    1152                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1153                 : };
    1154                 : 
    1155                 : 
    1156                 : /*---------------------------------------------------------------------
    1157                 :  *                      class TABFontPoint
    1158                 :  *
    1159                 :  * Feature class to handle MapInfo Font Point Symbol types:
    1160                 :  *
    1161                 :  *     TAB_GEOM_FONTSYMBOL_C    0x28 
    1162                 :  *     TAB_GEOM_FONTSYMBOL      0x29
    1163                 :  *
    1164                 :  * Feature geometry will be a OGRPoint
    1165                 :  *
    1166                 :  * The symbol number refers to a character code in the specified Windows
    1167                 :  * Font (e.g. "Windings").
    1168                 :  *--------------------------------------------------------------------*/
    1169                 : class TABFontPoint: public TABPoint, 
    1170                 :                     public ITABFeatureFont
    1171                 : {
    1172                 :   protected:
    1173                 :     double      m_dAngle;
    1174                 :     GInt16      m_nFontStyle;           // Bold/shadow/halo/etc.
    1175                 : 
    1176                 :   public:
    1177                 :              TABFontPoint(OGRFeatureDefn *poDefnIn);
    1178                 :     virtual ~TABFontPoint();
    1179                 : 
    1180               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCFontPoint; };
    1181                 : 
    1182                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1183                 : 
    1184                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1185                 :                                         GBool bCoordDataOnly=FALSE,
    1186                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1187                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1188                 :                                        GBool bCoordDataOnly=FALSE,
    1189                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1190                 : 
    1191                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1192                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1193                 : 
    1194                 :     virtual const char *GetStyleString();
    1195                 : 
    1196                 :     GBool       QueryFontStyle(TABFontStyle eStyleToQuery);
    1197                 :     void        ToggleFontStyle(TABFontStyle eStyleToToggle, GBool bStatus);
    1198                 : 
    1199                 :     int         GetFontStyleMIFValue();
    1200                 :     void        SetFontStyleMIFValue(int nStyle);
    1201               0 :     int         GetFontStyleTABValue()           {return m_nFontStyle;};
    1202               0 :     void        SetFontStyleTABValue(int nStyle){m_nFontStyle=(GInt16)nStyle;};
    1203                 : 
    1204                 :     // GetSymbolAngle(): Return angle in degrees counterclockwise
    1205               0 :     double      GetSymbolAngle()        {return m_dAngle;};
    1206                 :     void        SetSymbolAngle(double dAngle);
    1207                 : };
    1208                 : 
    1209                 : 
    1210                 : /*---------------------------------------------------------------------
    1211                 :  *                      class TABCustomPoint
    1212                 :  *
    1213                 :  * Feature class to handle MapInfo Custom Point Symbol (Bitmap) types:
    1214                 :  *
    1215                 :  *     TAB_GEOM_CUSTOMSYMBOL_C  0x2b
    1216                 :  *     TAB_GEOM_CUSTOMSYMBOL    0x2c
    1217                 :  *
    1218                 :  * Feature geometry will be a OGRPoint
    1219                 :  *
    1220                 :  * The symbol name is the name of a BMP file stored in the "CustSymb"
    1221                 :  * directory (e.g. "arrow.BMP").  The symbol number has no meaning for 
    1222                 :  * this symbol type.
    1223                 :  *--------------------------------------------------------------------*/
    1224                 : class TABCustomPoint: public TABPoint, 
    1225                 :                       public ITABFeatureFont
    1226                 : {
    1227                 :   protected:
    1228                 :     GByte       m_nCustomStyle;         // Show BG/Apply Color                 
    1229                 : 
    1230                 :   public:
    1231                 :     GByte       m_nUnknown_;
    1232                 : 
    1233                 :   public:
    1234                 :              TABCustomPoint(OGRFeatureDefn *poDefnIn);
    1235                 :     virtual ~TABCustomPoint();
    1236                 : 
    1237               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCCustomPoint; };
    1238                 : 
    1239                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1240                 : 
    1241                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1242                 :                                         GBool bCoordDataOnly=FALSE,
    1243                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1244                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1245                 :                                        GBool bCoordDataOnly=FALSE,
    1246                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1247                 : 
    1248                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1249                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1250                 : 
    1251                 :     virtual const char *GetStyleString();
    1252                 : 
    1253                 :     const char *GetSymbolNameRef()      { return GetFontNameRef(); };
    1254                 :     void        SetSymbolName(const char *pszName) {SetFontName(pszName);};
    1255                 :     
    1256               0 :     GByte       GetCustomSymbolStyle()              {return m_nCustomStyle;}
    1257               0 :     void        SetCustomSymbolStyle(GByte nStyle)  {m_nCustomStyle = nStyle;}
    1258                 : };
    1259                 : 
    1260                 : 
    1261                 : /*---------------------------------------------------------------------
    1262                 :  *                      class TABPolyline
    1263                 :  *
    1264                 :  * Feature class to handle the various MapInfo line types:
    1265                 :  *
    1266                 :  *     TAB_GEOM_LINE_C         0x04
    1267                 :  *     TAB_GEOM_LINE           0x05
    1268                 :  *     TAB_GEOM_PLINE_C        0x07
    1269                 :  *     TAB_GEOM_PLINE          0x08
    1270                 :  *     TAB_GEOM_MULTIPLINE_C   0x25
    1271                 :  *     TAB_GEOM_MULTIPLINE     0x26
    1272                 :  *     TAB_GEOM_V450_MULTIPLINE_C 0x31
    1273                 :  *     TAB_GEOM_V450_MULTIPLINE   0x32
    1274                 :  *
    1275                 :  * Feature geometry can be either a OGRLineString or a OGRMultiLineString
    1276                 :  *--------------------------------------------------------------------*/
    1277                 : class TABPolyline: public TABFeature, 
    1278                 :                    public ITABFeaturePen
    1279                 : {
    1280                 :   private:
    1281                 :     GBool       m_bCenterIsSet;
    1282                 :     double      m_dCenterX, m_dCenterY;
    1283                 :     GBool       m_bWriteTwoPointLineAsPolyline;
    1284                 : 
    1285                 :   public:
    1286                 :              TABPolyline(OGRFeatureDefn *poDefnIn);
    1287                 :     virtual ~TABPolyline();
    1288                 : 
    1289               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCPolyline; };
    1290                 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL);
    1291                 : 
    1292                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1293                 : 
    1294                 :     /* 2 methods to simplify access to rings in a multiple polyline
    1295                 :      */
    1296                 :     int                 GetNumParts();
    1297                 :     OGRLineString      *GetPartRef(int nPartIndex);
    1298                 : 
    1299                 :     GBool       TwoPointLineAsPolyline();
    1300                 :     void        TwoPointLineAsPolyline(GBool bTwoPointLineAsPolyline);
    1301                 : 
    1302                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1303                 :                                         GBool bCoordDataOnly=FALSE,
    1304                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1305                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1306                 :                                        GBool bCoordDataOnly=FALSE,
    1307                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1308                 : 
    1309                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1310                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1311                 : 
    1312                 :     virtual const char *GetStyleString();
    1313                 : 
    1314                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1315                 : 
    1316                 :     int         GetCenter(double &dX, double &dY);
    1317                 :     void        SetCenter(double dX, double dY);
    1318                 : 
    1319                 :     // MapInfo-specific attributes... made available through public vars
    1320                 :     // for now.
    1321                 :     GBool       m_bSmooth;
    1322                 : 
    1323                 : };
    1324                 : 
    1325                 : /*---------------------------------------------------------------------
    1326                 :  *                      class TABRegion
    1327                 :  *
    1328                 :  * Feature class to handle the MapInfo region types:
    1329                 :  *
    1330                 :  *     TAB_GEOM_REGION_C         0x0d
    1331                 :  *     TAB_GEOM_REGION           0x0e
    1332                 :  *     TAB_GEOM_V450_REGION_C    0x2e
    1333                 :  *     TAB_GEOM_V450_REGION      0x2f
    1334                 :  *
    1335                 :  * Feature geometry will be returned as OGRPolygon (with a single ring)
    1336                 :  * or OGRMultiPolygon (for multiple rings).
    1337                 :  *
    1338                 :  * REGIONs with multiple rings are returned as OGRMultiPolygon instead of
    1339                 :  * as OGRPolygons since OGRPolygons require that the first ring be the
    1340                 :  * outer ring, and the other all be inner rings, but this is not guaranteed
    1341                 :  * inside MapInfo files.  However, when writing features, OGRPolygons with
    1342                 :  * multiple rings will be accepted without problem.
    1343                 :  *--------------------------------------------------------------------*/
    1344                 : class TABRegion: public TABFeature, 
    1345                 :                  public ITABFeaturePen, 
    1346                 :                  public ITABFeatureBrush
    1347                 : {
    1348                 :     GBool       m_bSmooth;
    1349                 :   private:
    1350                 :     GBool       m_bCenterIsSet;
    1351                 :     double      m_dCenterX, m_dCenterY;
    1352                 : 
    1353                 :     int     ComputeNumRings(TABMAPCoordSecHdr **ppasSecHdrs, 
    1354                 :                             TABMAPFile *poMAPFile);
    1355                 :     int     AppendSecHdrs(OGRPolygon *poPolygon,
    1356                 :                           TABMAPCoordSecHdr * &pasSecHdrs,
    1357                 :                           TABMAPFile *poMAPFile,
    1358                 :                           int &iLastRing);
    1359                 : 
    1360                 :   public:
    1361                 :              TABRegion(OGRFeatureDefn *poDefnIn);
    1362                 :     virtual ~TABRegion();
    1363                 : 
    1364               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCRegion; };
    1365                 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL);
    1366                 : 
    1367                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1368                 : 
    1369                 :     /* 2 methods to make the REGION's geometry look like a single collection
    1370                 :      * of OGRLinearRings 
    1371                 :      */
    1372                 :     int                 GetNumRings();
    1373                 :     OGRLinearRing      *GetRingRef(int nRequestedRingIndex);
    1374                 :     GBool               IsInteriorRing(int nRequestedRingIndex);
    1375                 : 
    1376                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1377                 :                                         GBool bCoordDataOnly=FALSE,
    1378                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1379                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1380                 :                                        GBool bCoordDataOnly=FALSE,
    1381                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1382                 : 
    1383                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1384                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1385                 : 
    1386                 :     virtual const char *GetStyleString();
    1387                 : 
    1388                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1389                 : 
    1390                 :     int         GetCenter(double &dX, double &dY);
    1391                 :     void        SetCenter(double dX, double dY);
    1392                 : };
    1393                 : 
    1394                 : 
    1395                 : /*---------------------------------------------------------------------
    1396                 :  *                      class TABRectangle
    1397                 :  *
    1398                 :  * Feature class to handle the MapInfo rectangle types:
    1399                 :  *
    1400                 :  *     TAB_GEOM_RECT_C         0x13
    1401                 :  *     TAB_GEOM_RECT           0x14
    1402                 :  *     TAB_GEOM_ROUNDRECT_C    0x16
    1403                 :  *     TAB_GEOM_ROUNDRECT      0x17
    1404                 :  *
    1405                 :  * A rectangle is defined by the coords of its 2 opposite corners (the MBR)
    1406                 :  * Its corners can optionaly be rounded, in which case a X and Y rounding
    1407                 :  * radius will be defined.
    1408                 :  *
    1409                 :  * Feature geometry will be OGRPolygon
    1410                 :  *--------------------------------------------------------------------*/
    1411                 : class TABRectangle: public TABFeature, 
    1412                 :                     public ITABFeaturePen, 
    1413                 :                     public ITABFeatureBrush
    1414                 : {
    1415                 :   private:
    1416                 :     virtual int UpdateMBR(TABMAPFile *poMapFile = NULL);
    1417                 : 
    1418                 :   public:
    1419                 :              TABRectangle(OGRFeatureDefn *poDefnIn);
    1420                 :     virtual ~TABRectangle();
    1421                 : 
    1422               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCRectangle; };
    1423                 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL);
    1424                 : 
    1425                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1426                 : 
    1427                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1428                 :                                         GBool bCoordDataOnly=FALSE,
    1429                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1430                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1431                 :                                        GBool bCoordDataOnly=FALSE,
    1432                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1433                 : 
    1434                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1435                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1436                 : 
    1437                 :     virtual const char *GetStyleString();
    1438                 : 
    1439                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1440                 : 
    1441                 :     // MapInfo-specific attributes... made available through public vars
    1442                 :     // for now.
    1443                 :     GBool       m_bRoundCorners;
    1444                 :     double      m_dRoundXRadius;
    1445                 :     double      m_dRoundYRadius;
    1446                 : 
    1447                 : };
    1448                 : 
    1449                 : 
    1450                 : /*---------------------------------------------------------------------
    1451                 :  *                      class TABEllipse
    1452                 :  *
    1453                 :  * Feature class to handle the MapInfo ellipse types:
    1454                 :  *
    1455                 :  *     TAB_GEOM_ELLIPSE_C      0x19
    1456                 :  *     TAB_GEOM_ELLIPSE        0x1a
    1457                 :  *
    1458                 :  * An ellipse is defined by the coords of its 2 opposite corners (the MBR)
    1459                 :  *
    1460                 :  * Feature geometry can be either an OGRPoint defining the center of the
    1461                 :  * ellipse, or an OGRPolygon defining the ellipse itself.
    1462                 :  *
    1463                 :  * When an ellipse is read, the returned geometry is a OGRPolygon representing
    1464                 :  * the ellipse with 2 degrees line segments.
    1465                 :  *
    1466                 :  * In the case of the OGRPoint, then the X/Y Radius MUST be set, but.  
    1467                 :  * However with an OGRPolygon, if the X/Y radius are not set (== 0) then
    1468                 :  * the MBR of the polygon will be used to define the ellipse parameters 
    1469                 :  * and the center of the MBR is used as the center of the ellipse... 
    1470                 :  * (i.e. the polygon vertices themselves will be ignored).
    1471                 :  *--------------------------------------------------------------------*/
    1472                 : class TABEllipse: public TABFeature, 
    1473                 :                   public ITABFeaturePen, 
    1474                 :                   public ITABFeatureBrush
    1475                 : {
    1476                 :   private:
    1477                 :     virtual int UpdateMBR(TABMAPFile *poMapFile = NULL);
    1478                 : 
    1479                 :   public:
    1480                 :              TABEllipse(OGRFeatureDefn *poDefnIn);
    1481                 :     virtual ~TABEllipse();
    1482                 : 
    1483               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCEllipse; };
    1484                 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL);
    1485                 : 
    1486                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1487                 : 
    1488                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1489                 :                                         GBool bCoordDataOnly=FALSE,
    1490                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1491                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1492                 :                                        GBool bCoordDataOnly=FALSE,
    1493                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1494                 : 
    1495                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1496                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1497                 : 
    1498                 :     virtual const char *GetStyleString();
    1499                 : 
    1500                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1501                 : 
    1502                 :     // MapInfo-specific attributes... made available through public vars
    1503                 :     // for now.
    1504                 :     double      m_dCenterX;
    1505                 :     double      m_dCenterY;
    1506                 :     double      m_dXRadius;
    1507                 :     double      m_dYRadius;
    1508                 : 
    1509                 : };
    1510                 : 
    1511                 : 
    1512                 : /*---------------------------------------------------------------------
    1513                 :  *                      class TABArc
    1514                 :  *
    1515                 :  * Feature class to handle the MapInfo arc types:
    1516                 :  *
    1517                 :  *     TAB_GEOM_ARC_C      0x0a
    1518                 :  *     TAB_GEOM_ARC        0x0b
    1519                 :  *
    1520                 :  * In MapInfo, an arc is defined by the coords of the MBR corners of its 
    1521                 :  * defining ellipse, which in this case is different from the arc's MBR,
    1522                 :  * and a start and end angle in degrees.
    1523                 :  *
    1524                 :  * Feature geometry can be either an OGRLineString or an OGRPoint.
    1525                 :  *
    1526                 :  * In any case, X/Y radius X/Y center, and start/end angle (in degrees 
    1527                 :  * counterclockwise) MUST be set.
    1528                 :  *
    1529                 :  * When an arc is read, the returned geometry is an OGRLineString 
    1530                 :  * representing the arc with 2 degrees line segments.
    1531                 :  *--------------------------------------------------------------------*/
    1532                 : class TABArc: public TABFeature, 
    1533                 :               public ITABFeaturePen
    1534                 : {
    1535                 :   private:
    1536                 :     double      m_dStartAngle;  // In degrees, counterclockwise, 
    1537                 :     double      m_dEndAngle;    // starting at 3 o'clock
    1538                 : 
    1539                 :     virtual int UpdateMBR(TABMAPFile *poMapFile = NULL);
    1540                 : 
    1541                 :   public:
    1542                 :              TABArc(OGRFeatureDefn *poDefnIn);
    1543                 :     virtual ~TABArc();
    1544                 : 
    1545               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCArc; };
    1546                 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL);
    1547                 : 
    1548                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1549                 : 
    1550                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1551                 :                                         GBool bCoordDataOnly=FALSE,
    1552                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1553                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1554                 :                                        GBool bCoordDataOnly=FALSE,
    1555                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1556                 : 
    1557                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1558                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1559                 : 
    1560                 :     virtual const char *GetStyleString();
    1561                 : 
    1562                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1563                 : 
    1564               0 :     double      GetStartAngle() { return m_dStartAngle; };
    1565               0 :     double      GetEndAngle()   { return m_dEndAngle; };
    1566                 :     void        SetStartAngle(double dAngle);
    1567                 :     void        SetEndAngle(double dAngle);
    1568                 : 
    1569                 :     // MapInfo-specific attributes... made available through public vars
    1570                 :     // for now.
    1571                 :     double      m_dCenterX;
    1572                 :     double      m_dCenterY;
    1573                 :     double      m_dXRadius;
    1574                 :     double      m_dYRadius;
    1575                 : };
    1576                 : 
    1577                 : 
    1578                 : /*---------------------------------------------------------------------
    1579                 :  *                      class TABText
    1580                 :  *
    1581                 :  * Feature class to handle the MapInfo text types:
    1582                 :  *
    1583                 :  *     TAB_GEOM_TEXT_C         0x10
    1584                 :  *     TAB_GEOM_TEXT           0x11
    1585                 :  *
    1586                 :  * Feature geometry is an OGRPoint corresponding to the lower-left 
    1587                 :  * corner of the text MBR BEFORE ROTATION.
    1588                 :  * 
    1589                 :  * Text string, and box height/width (box before rotation is applied)
    1590                 :  * are required in a valid text feature and MUST be set.  
    1591                 :  * Text angle and other styles are optional.
    1592                 :  *--------------------------------------------------------------------*/
    1593                 : class TABText: public TABFeature, 
    1594                 :                public ITABFeatureFont,
    1595                 :                public ITABFeaturePen
    1596                 : {
    1597                 :   protected:
    1598                 :     char        *m_pszString;
    1599                 : 
    1600                 :     double      m_dAngle;
    1601                 :     double      m_dHeight;
    1602                 :     double      m_dWidth;
    1603                 :     double      m_dfLineEndX;
    1604                 :     double      m_dfLineEndY;
    1605                 :     GBool       m_bLineEndSet;
    1606                 :     void        UpdateTextMBR();
    1607                 : 
    1608                 :     GInt32      m_rgbForeground;
    1609                 :     GInt32      m_rgbBackground;
    1610                 :     GInt32      m_rgbOutline;
    1611                 :     GInt32      m_rgbShadow;
    1612                 : 
    1613                 :     GInt16      m_nTextAlignment;       // Justification/Vert.Spacing/arrow
    1614                 :     GInt16      m_nFontStyle;           // Bold/italic/underlined/shadow/...
    1615                 : 
    1616                 :     const char *GetLabelStyleString();
    1617                 : 
    1618                 :     virtual int UpdateMBR(TABMAPFile *poMapFile = NULL);
    1619                 : 
    1620                 :   public:
    1621                 :              TABText(OGRFeatureDefn *poDefnIn);
    1622                 :     virtual ~TABText();
    1623                 : 
    1624               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCText; };
    1625                 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL);
    1626                 : 
    1627                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1628                 : 
    1629                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1630                 :                                         GBool bCoordDataOnly=FALSE,
    1631                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1632                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1633                 :                                        GBool bCoordDataOnly=FALSE,
    1634                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1635                 : 
    1636                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1637                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1638                 : 
    1639                 :     virtual const char *GetStyleString();
    1640                 : 
    1641                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1642                 : 
    1643                 :     const char *GetTextString();
    1644                 :     double      GetTextAngle();
    1645                 :     double      GetTextBoxHeight();
    1646                 :     double      GetTextBoxWidth();
    1647                 :     GInt32      GetFontFGColor();
    1648                 :     GInt32      GetFontBGColor();
    1649                 :     GInt32      GetFontOColor();
    1650                 :     GInt32      GetFontSColor();
    1651                 :     void        GetTextLineEndPoint(double &dX, double &dY);
    1652                 : 
    1653                 :     TABTextJust GetTextJustification();
    1654                 :     TABTextSpacing  GetTextSpacing();
    1655                 :     TABTextLineType GetTextLineType();
    1656                 :     GBool       QueryFontStyle(TABFontStyle eStyleToQuery);
    1657                 : 
    1658                 :     void        SetTextString(const char *pszStr);
    1659                 :     void        SetTextAngle(double dAngle);
    1660                 :     void        SetTextBoxHeight(double dHeight);
    1661                 :     void        SetTextBoxWidth(double dWidth);
    1662                 :     void        SetFontFGColor(GInt32 rgbColor);
    1663                 :     void        SetFontBGColor(GInt32 rgbColor);
    1664                 :     void        SetFontOColor(GInt32 rgbColor);
    1665                 :     void        SetFontSColor(GInt32 rgbColor);
    1666                 :     void        SetTextLineEndPoint(double dX, double dY);
    1667                 : 
    1668                 :     void        SetTextJustification(TABTextJust eJust);
    1669                 :     void        SetTextSpacing(TABTextSpacing eSpacing);
    1670                 :     void        SetTextLineType(TABTextLineType eLineType);
    1671                 :     void        ToggleFontStyle(TABFontStyle eStyleToToggle, GBool bStatus);
    1672                 : 
    1673                 :     int         GetFontStyleMIFValue();
    1674                 :     void        SetFontStyleMIFValue(int nStyle, GBool bBGColorSet=FALSE);
    1675                 :     GBool       IsFontBGColorUsed();
    1676                 :     GBool       IsFontOColorUsed();
    1677                 :     GBool       IsFontSColorUsed();
    1678                 :     GBool       IsFontBold();
    1679                 :     GBool       IsFontItalic();
    1680                 :     GBool       IsFontUnderline();
    1681               0 :     int         GetFontStyleTABValue()           {return m_nFontStyle;};
    1682               0 :     void        SetFontStyleTABValue(int nStyle){m_nFontStyle=(GInt16)nStyle;};
    1683                 : 
    1684                 : };
    1685                 : 
    1686                 : 
    1687                 : /*---------------------------------------------------------------------
    1688                 :  *                      class TABMultiPoint
    1689                 :  *
    1690                 :  * Feature class to handle MapInfo Multipoint features:
    1691                 :  *
    1692                 :  *     TAB_GEOM_MULTIPOINT_C        0x34
    1693                 :  *     TAB_GEOM_MULTIPOINT          0x35
    1694                 :  *
    1695                 :  * Feature geometry will be a OGRMultiPoint
    1696                 :  *
    1697                 :  * The symbol number is in the range [31..67], with 31=None and corresponds
    1698                 :  * to one of the 35 predefined "Old MapInfo Symbols"
    1699                 :  *--------------------------------------------------------------------*/
    1700                 : class TABMultiPoint: public TABFeature, 
    1701                 :                      public ITABFeatureSymbol
    1702                 : {
    1703                 :   private:
    1704                 :     // We call it center, but it's more like a label point
    1705                 :     // Its value default to be the location of the first point
    1706                 :     GBool       m_bCenterIsSet;
    1707                 :     double      m_dCenterX, m_dCenterY;
    1708                 : 
    1709                 :   public:
    1710                 :              TABMultiPoint(OGRFeatureDefn *poDefnIn);
    1711                 :     virtual ~TABMultiPoint();
    1712                 : 
    1713               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCMultiPoint; };
    1714                 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL);
    1715                 : 
    1716                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1717                 : 
    1718                 :     int         GetXY(int i, double &dX, double &dY);
    1719                 :     int         GetNumPoints();
    1720                 : 
    1721                 :     int         GetCenter(double &dX, double &dY);
    1722                 :     void        SetCenter(double dX, double dY);
    1723                 : 
    1724                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1725                 :                                         GBool bCoordDataOnly=FALSE,
    1726                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1727                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1728                 :                                        GBool bCoordDataOnly=FALSE,
    1729                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1730                 : 
    1731                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1732                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1733                 : 
    1734                 :     virtual const char *GetStyleString();
    1735                 : 
    1736                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1737                 : };
    1738                 : 
    1739                 : /*---------------------------------------------------------------------
    1740                 :  *
    1741                 :  *                      class TABCollection
    1742                 :  *
    1743                 :  * Feature class to handle MapInfo Collection features:
    1744                 :  *
    1745                 :  *     TAB_GEOM_COLLECTION_C        0x37
    1746                 :  *     TAB_GEOM_COLLECTION          0x38
    1747                 :  *
    1748                 :  * Feature geometry will be a OGRCollection
    1749                 :  *
    1750                 :  * **** IMPORTANT NOTE: ****
    1751                 :  *
    1752                 :  * The current implementation does not allow setting the Geometry via
    1753                 :  * OGRFeature::SetGeometry*(). The geometries must be set via the
    1754                 :  * TABCollection::SetRegion/Pline/MpointDirectly() methods which will take
    1755                 :  * care of keeping the OGRFeature's geometry in sync.
    1756                 :  *
    1757                 :  * If we ever want to support creating collections via the OGR interface then
    1758                 :  * something should be added in TABCollection::WriteGeometryToMapFile(), or
    1759                 :  * perhaps in ValidateMapInfoType(), or even better in a custom
    1760                 :  * TABCollection::SetGeometry*()... but then this last option may not work
    1761                 :  * unless OGRFeature::SetGeometry*() are made virtual in OGR.
    1762                 :  *
    1763                 :  *--------------------------------------------------------------------*/
    1764                 : class TABCollection: public TABFeature, 
    1765                 :                      public ITABFeatureSymbol
    1766                 : {
    1767                 :   private:
    1768                 :     TABRegion       *m_poRegion;
    1769                 :     TABPolyline     *m_poPline;
    1770                 :     TABMultiPoint   *m_poMpoint;
    1771                 : 
    1772                 :     void    EmptyCollection();
    1773                 :     int     ReadLabelAndMBR(TABMAPCoordBlock *poCoordBlock, 
    1774                 :                             GBool bComprCoord,
    1775                 :                             GInt32 nComprOrgX, GInt32 nComprOrgY,
    1776                 :                             GInt32 &pnMinX, GInt32 &pnMinY,
    1777                 :                             GInt32 &pnMaxX, GInt32 &pnMaxY,
    1778                 :                             GInt32 &pnLabelX, GInt32 &pnLabelY );
    1779                 :     int     WriteLabelAndMBR(TABMAPCoordBlock *poCoordBlock,
    1780                 :                              GBool bComprCoord,
    1781                 :                              GInt32 nMinX, GInt32 nMinY,
    1782                 :                              GInt32 nMaxX, GInt32 nMaxY,
    1783                 :                              GInt32 nLabelX, GInt32 nLabelY );
    1784                 :     int     SyncOGRGeometryCollection(GBool bSyncRegion,
    1785                 :                                       GBool bSyncPline,
    1786                 :                                       GBool bSyncMpoint);
    1787                 : 
    1788                 :   public:
    1789                 :              TABCollection(OGRFeatureDefn *poDefnIn);
    1790                 :     virtual ~TABCollection();
    1791                 : 
    1792               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCCollection; };
    1793                 :     virtual int             ValidateMapInfoType(TABMAPFile *poMapFile = NULL);
    1794                 : 
    1795                 :     virtual TABFeature *CloneTABFeature(OGRFeatureDefn *poNewDefn = NULL );
    1796                 : 
    1797                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1798                 :                                         GBool bCoordDataOnly=FALSE,
    1799                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1800                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1801                 :                                        GBool bCoordDataOnly=FALSE,
    1802                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1803                 :     
    1804                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1805                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1806                 : 
    1807                 :     virtual const char *GetStyleString();
    1808                 : 
    1809                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1810                 : 
    1811                 :     TABRegion           *GetRegionRef()         {return m_poRegion; };
    1812                 :     TABPolyline         *GetPolylineRef()       {return m_poPline; };
    1813                 :     TABMultiPoint       *GetMultiPointRef()     {return m_poMpoint; };
    1814                 : 
    1815                 :     int                 SetRegionDirectly(TABRegion *poRegion);
    1816                 :     int                 SetPolylineDirectly(TABPolyline *poPline);
    1817                 :     int                 SetMultiPointDirectly(TABMultiPoint *poMpoint);
    1818                 : };
    1819                 : 
    1820                 : 
    1821                 : /*---------------------------------------------------------------------
    1822                 :  *                      class TABDebugFeature
    1823                 :  *
    1824                 :  * Feature class to use for testing purposes... this one does not 
    1825                 :  * correspond to any MapInfo type... it's just used to dump info about
    1826                 :  * feature types that are not implemented yet.
    1827                 :  *--------------------------------------------------------------------*/
    1828                 : class TABDebugFeature: public TABFeature
    1829                 : {
    1830                 :   private:
    1831                 :     GByte       m_abyBuf[512];
    1832                 :     int         m_nSize;
    1833                 :     int         m_nCoordDataPtr;  // -1 if none
    1834                 :     int         m_nCoordDataSize;
    1835                 : 
    1836                 :   public:
    1837                 :              TABDebugFeature(OGRFeatureDefn *poDefnIn);
    1838                 :     virtual ~TABDebugFeature();
    1839                 : 
    1840               0 :     virtual TABFeatureClass GetFeatureClass() { return TABFCDebugFeature; };
    1841                 : 
    1842                 :     virtual int ReadGeometryFromMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1843                 :                                         GBool bCoordDataOnly=FALSE,
    1844                 :                                         TABMAPCoordBlock **ppoCoordBlock=NULL);
    1845                 :     virtual int WriteGeometryToMAPFile(TABMAPFile *poMapFile, TABMAPObjHdr *,
    1846                 :                                        GBool bCoordDataOnly=FALSE,
    1847                 :                                        TABMAPCoordBlock **ppoCoordBlock=NULL);
    1848                 : 
    1849                 :     virtual int ReadGeometryFromMIFFile(MIDDATAFile *fp);
    1850                 :     virtual int WriteGeometryToMIFFile(MIDDATAFile *fp);
    1851                 : 
    1852                 :     virtual void DumpMIF(FILE *fpOut = NULL);
    1853                 : };
    1854                 : 
    1855                 : /* -------------------------------------------------------------------- */
    1856                 : /*      Some stuff related to spatial reference system handling.        */
    1857                 : /*                                                                      */
    1858                 : /*      In GDAL we make use of the coordsys transformation from         */
    1859                 : /*      other places (sometimes even from plugins), so we               */
    1860                 : /*      deliberately export these two functions from the DLL.           */
    1861                 : /* -------------------------------------------------------------------- */
    1862                 : 
    1863                 : char CPL_DLL *MITABSpatialRef2CoordSys( OGRSpatialReference * );
    1864                 : OGRSpatialReference CPL_DLL * MITABCoordSys2SpatialRef( const char * );
    1865                 : 
    1866                 : GBool MITABExtractCoordSysBounds( const char * pszCoordSys,
    1867                 :                                   double &dXMin, double &dYMin,
    1868                 :                                   double &dXMax, double &dYMax );
    1869                 : int MITABCoordSys2TABProjInfo(const char * pszCoordSys, TABProjInfo *psProj);
    1870                 : 
    1871                 : typedef struct {
    1872                 :     int         nMapInfoDatumID;
    1873                 :     const char  *pszOGCDatumName;
    1874                 :     int         nEllipsoid;
    1875                 :     double      dfShiftX;
    1876                 :     double      dfShiftY;
    1877                 :     double      dfShiftZ;
    1878                 :     double      dfDatumParm0; /* RotX */
    1879                 :     double      dfDatumParm1; /* RotY */
    1880                 :     double      dfDatumParm2; /* RotZ */
    1881                 :     double      dfDatumParm3; /* Scale Factor */
    1882                 :     double      dfDatumParm4; /* Prime Meridian */
    1883                 : } MapInfoDatumInfo;
    1884                 : 
    1885                 : typedef struct
    1886                 : {
    1887                 :     int         nMapInfoId;
    1888                 :     const char *pszMapinfoName;
    1889                 :     double      dfA; /* semi major axis in meters */
    1890                 :     double      dfInvFlattening; /* Inverse flattening */
    1891                 : } MapInfoSpheroidInfo;
    1892                 : 
    1893                 : 
    1894                 : /*---------------------------------------------------------------------
    1895                 :  * The following are used for coordsys bounds lookup
    1896                 :  *--------------------------------------------------------------------*/
    1897                 : typedef struct
    1898                 : {
    1899                 :     TABProjInfo sProj;          /* Projection/datum definition */
    1900                 :     double      dXMin;          /* Default bounds for that coordsys */
    1901                 :     double      dYMin;
    1902                 :     double      dXMax;
    1903                 :     double      dYMax;
    1904                 : } MapInfoBoundsInfo;
    1905                 : 
    1906                 : GBool   MITABLookupCoordSysBounds(TABProjInfo *psCS,
    1907                 :                                   double &dXMin, double &dYMin,
    1908                 :                                   double &dXMax, double &dYMax);
    1909                 : int     MITABLoadCoordSysTable(const char *pszFname);
    1910                 : void    MITABFreeCoordSysTable();
    1911                 : GBool   MITABCoordSysTableLoaded();
    1912                 : 
    1913                 : #endif /* _MITAB_H_INCLUDED_ */
    1914                 : 
    1915                 : 

Generated by: LTP GCOV extension version 1.5