ID_CreateNew,
  ID_Disconnect,
  ID_MemoryDbLoad,
  ID_MemoryDbNew,
  ID_MemoryDbClock,
  ID_MemoryDbSave,
  ID_Vacuum,

  ID_SqlScript,
  ID_QueryViewComposer,
  ID_LoadShp,
  ID_LoadTxt,
  ID_LoadDbf,
  ID_LoadXL,
  ID_VirtualShp,
................................................................................
  ID_Attach,
  ID_SqlLog,
  ID_DbStatus,
  ID_CheckGeom,
  ID_SaneGeom,
  ID_WFS,
  ID_DXF,








  Tree_NewTable,
  Tree_NewView,
  Tree_NewIndex,
  Tree_NewTrigger,
  Tree_NewColumn,
  Tree_NewRasterStyle,
  Tree_ReloadRasterStyle,
................................................................................
  Tree_SldSeRasterStyles,
  Tree_SldSeVectorStyles,
  Tree_ImportRaster,
  Tree_Pyramidize,
  Tree_PyramidizeMonolithic,
  Tree_DePyramidize,
  Tree_RasterDrop,

  Tree_VectorRegister,




  Tree_VectorUnregister,

  Tree_CreateRasterCoverage,
  Tree_UpdateRasterExtent,
  Tree_UpdateRasterExtentAll,
  Tree_UpdateVectorExtent,
  Tree_UpdateVectorExtentAll,
  Tree_Raster_SRIDs,
  Tree_Vector_SRIDs,
................................................................................
  Tree_SimpleLineSymbolizer,
  Tree_SimplePolygonSymbolizer,
  Tree_SimpleTextSymbolizer,
  Tree_CloneTable,
  Tree_RegisterWmsLayer,
  Tree_UnregisterWmsLayer,
  Tree_ConfigureWmsLayer,












  Grid_Clear,
  Grid_All,
  Grid_Column,
  Grid_Row,
  Grid_Copy,
  Grid_Blob,
  Grid_Delete,
................................................................................
  ID_CVG_SAME_RES,
  ID_CVG_VERT_RES,
  ID_CVG_STRICT_RES,
  ID_CVG_MIXED_RES,
  ID_CVG_PATHS,
  ID_CVG_MD5,
  ID_CVG_SUMMARY,

  ID_LOAD_FORCE_SRID,
  ID_LOAD_SRID,
  ID_LOAD_WITH_WORLDFILE,
  ID_LOAD_PYRAMIDIZE,
  ID_LOAD_LIST_DONE,
  ID_LOAD_ABORT,
  ID_LOAD_RASTER_THREAD_FINISHED,
................................................................................
  ID_LOAD_FONT_START,
  ID_LOAD_FONT_STOP,
  ID_LOAD_FONT_SKIP,
  ID_VECTOR_GRID,
  ID_VECTOR_COVERAGE,
  ID_VECTOR_TITLE,
  ID_VECTOR_ABSTRACT,


  ID_VECTOR_SRID_ADD,
  ID_VECTOR_SRID_REMOVE,
  ID_VECTOR_SRID,
  ID_VECTOR_SRID_GRID,
  ID_RASTER_SRID_ADD,
  ID_RASTER_SRID_REMOVE,
  ID_RASTER_SRID,
................................................................................
  ID_WMS_OK,
  ID_WMS_ENABLE_PROXY,
  ID_WMS_PROXY,
  ID_WMS_LIST,
  ID_WMS_LAYER,
  ID_WMS_ENABLE_BGCOLOR,
  ID_WMS_BGCOLOR,







  ID_PANE_MAIN,
  ID_PANE_STROKE1,
  ID_PANE_STROKE2,
  ID_PANE_STROKE3,
  ID_PANE_FILL1,
  ID_PANE_FILL2,
  ID_PANE_POSITION,
  ID_PANE_GRAPHIC,
  ID_PANE_MARK,
  ID_PANE_FONT,
  ID_PANE_PLACEMENT,
  ID_PANE_PREVIEW

};

enum
{
// tree item data types

  MY_TABLE = 0,
  MY_VTABLE,
  MY_VIEW,
  MY_TILE_DATA,
  MY_COLUMN,
  MY_VIEW_COLUMN,
  MY_VIRTUAL_COLUMN,
  MY_GEOMETRY,
................................................................................
  MY_GEOMETRY_INDEX,
  MY_GEOMETRY_CACHED,
  MY_VIEW_GEOMETRY,
  MY_VIEW_GEOMETRY_INDEX,
  MY_VIEW_GEOMETRY_CACHED,
  MY_VIRTUAL_GEOMETRY,
  MY_VIRTUAL_GPKG_GEOMETRY,



  MY_INDEX,
  MY_TRIGGER,
  MY_ATTACHED,
  MY_INT_VARIANT,
  MY_DBL_VARIANT,
  MY_TXT_VARIANT,
  MY_BLOB_VARIANT,
  MY_NULL_VARIANT

};

enum
{
// control IDs for timers
  ID_AUTO_SAVE_TIMER = 20000,
  ID_DB_STATUS_TIMER,
................................................................................
enum
{
// METADATA TYPEs
  METADATA_UNKNOWN = 0,
  METADATA_LEGACY,
  METADATA_CURRENT
};












class RasterCoverageItem
{
//
// a class wrapping a Raster Coverage related Table or View
//
private:
................................................................................

class VectorCoverageSet
{
//
// a class representing a full Vector Coverage Set
//
private:

  wxString Name;
  int Srid;

public:
    VectorCoverageSet(const char *name, int srid);
   ~VectorCoverageSet()
  {;




  }
  wxString & GetName()
  {
    return Name;
  }
  int GetSrid()
  {
    return Srid;
  }




};

class MyObject:public wxTreeItemData
{
//
// a class to store TreeItemData
//
................................................................................
  int Type;                     // the object type
  wxString DbAlias;             // the DB alias [Attached DB] 
  wxString Name;                // the object name
  wxString Column;              // the column name [optional]
  bool Temporary;               // the TMP switch
  bool Coverage;                // TRUE only if Raster Coverage related
  bool Topology;                // TRUE only if TopoGeo or TopoNet related

public:


    MyObject(int type, wxString & name);
    MyObject(int type, wxString & name, bool tmp, bool coverage =
             false, bool topology = false);
    MyObject(int type, wxString & dbAlias, wxString & name, bool tmp);
    MyObject(int type, wxString & name, wxString & column);
    MyObject(int type, bool attached, wxString & dbAlias, wxString & name,
             bool coverage = false, bool topology = false);


    virtual ~ MyObject()
  {;
  }
  int GetType()
  {
    return Type;
  }
................................................................................
  {
    return Column;
  }
  bool IsTemporary()
  {
    return Temporary;
  }




  bool IsAttached()
  {
    if (DbAlias.Len() > 0)
      return true;
    else
      return false;
  }
................................................................................
//
private:
  wxString DbPrefix;
  wxString Name;
  int Srid;
  bool HasZ;
public:

    TopoGeoSet(const char *db_prefix, const char *name, int srid, bool has_z);
   ~TopoGeoSet()
  {;
  }
  wxString & GetDbPrefix()
  {
    return DbPrefix;
................................................................................
private:
  sqlite3 * DbHandle;
  wxString DbPrefix;
  wxString Name;
  wxTreeItemId TopologyNode;
  TopoGeo *Next;
public:


    TopoGeo(class MyTableTree * tree, wxTreeItemId & root,
            wxString & db_prefix, wxString & topology, int srid, bool has_z);
   ~TopoGeo()
  {;
  }
  wxTreeItemId *Check(wxString & table);
  bool CheckTopoFeature(wxString & table);
................................................................................
    Count = 0;
  }
   ~TopoGeoList()
  {
    Flush();
  }
  void Flush();


  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & db_prefix, wxString & topology, int srid, bool has_z);
  wxTreeItemId *FindNode(wxString & table);
  int GetCount()
  {
    return Count;
  }
................................................................................

class TopoNetSet
{
//
// a class representing a full TopoNet Set
//
private:

  wxString Name;
  bool Spatial;
  int Srid;
  bool HasZ;
public:
    TopoNetSet(const char *name, bool spatial, int srid, bool has_z);


   ~TopoNetSet()
  {;




  }
  wxString & GetName()
  {
    return Name;
  }
  bool IsSpatial()
  {
................................................................................

class TopoNet
{
//
// TopoNet container
//
private:

  wxString Name;
  wxTreeItemId NetworkNode;
  TopoNet *Next;
public:
    TopoNet(class MyTableTree * tree, wxTreeItemId & root,
            wxString & network, bool spatial, int srid, bool has_z);



   ~TopoNet()
  {;
  }
  wxTreeItemId *Check(wxString & table);
  TopoNet *GetNext()
  {
    return Next;
................................................................................
   ~TopoNetList()
  {
    Flush();
  }
  void Flush();
  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & network, bool spatial, int srid, bool has_z);



  wxTreeItemId *FindNode(wxString & table);
  int GetCount()
  {
    return Count;
  }
};

class RasterCoverage
{
//
// Raster Coverage container
//
private:

  wxString Name;
  wxTreeItemId CoverageNode;
  RasterCoverage *Next;
public:
    RasterCoverage(class MyTableTree * tree, wxTreeItemId & root,
                   wxString & coverage, int srid);


   ~RasterCoverage()
  {;
  }
  wxTreeItemId *Check(wxString & table, bool * tile_data);
  RasterCoverage *GetNext()
  {
    return Next;
................................................................................
   ~RasterCoverageList()
  {
    Flush();
  }
  void Flush();
  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & coverage, int srid);


  wxTreeItemId *FindNode(wxString & table, bool * tile_data);
  int GetCount()
  {
    return Count;
  }
};

class VectorCoverage
{
//
// Vector Coverage container
//
private:


  wxString Name;
  wxTreeItemId CoverageNode;
  VectorCoverage *Next;
public:
    VectorCoverage(class MyTableTree * tree, wxTreeItemId & root,
                   wxString & coverage, int srid);




   ~VectorCoverage()
  {;
  }
  VectorCoverage *GetNext()
  {
    return Next;
  }
................................................................................
  }
   ~VectorCoverageList()
  {
    Flush();
  }
  void Flush();
  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & coverage, int srid);


  int GetCount()
  {
    return Count;
  }
};

class RootNodes
................................................................................
    CollapseAllChildren(RootIsoMetadata);
    Collapse(RootMetadata);
    Collapse(RootInternal);
    Collapse(RootSpatialIndex);
  }
  void AddTopology(TopoGeoSet * topology)
  {
    Topologies.Add(this, RootTopologies, topology->GetDbPrefix(),
                   topology->GetName(), topology->GetSrid(),
                   topology->GetHasZ());
  }
  void AddAltTopology(wxTreeItemId & rootTopologies, TopoGeoSet * topology)

  {
    AltTopologies.Add(this, rootTopologies, topology->GetDbPrefix(),
                      topology->GetName(), topology->GetSrid(),
                      topology->GetHasZ());
  }
  void DeleteTopologies(wxTreeItemId & root_topologies);
  void DeleteAltTopologies(void)
  {
    AltTopologies.Flush();
  }
  void AddNetwork(TopoNetSet * network)
  {
    Networks.Add(this, RootNetworks, network->GetName(), network->IsSpatial(),
                 network->GetSrid(), network->GetHasZ());
  }
  void AddAltNetwork(wxTreeItemId & rootNetworks, TopoNetSet * network)

  {
    AltNetworks.Add(this, rootNetworks, network->GetName(),
                    network->IsSpatial(), network->GetSrid(),
                    network->GetHasZ());
  }
  void DeleteNetworks(wxTreeItemId & root_networks);
  void DeleteAltNetworks(void)
  {
    AltNetworks.Flush();
................................................................................
  }
  void AddRasterCoverage(RasterCoverageSet * coverage)
  {
    RasterCoverages.Add(this, RootRasterCoverages, coverage->GetName(),
                        coverage->GetSrid());
  }
  void AddAltRasterCoverage(wxTreeItemId & rootRasterCoverages,
                            RasterCoverageSet * coverage)
  {
    AltRasterCoverages.Add(this, rootRasterCoverages, coverage->GetName(),
                           coverage->GetSrid());
  }
  void AddVectorCoverage(VectorCoverageSet * coverage)
  {
    VectorCoverages.Add(this, RootVectorCoverages, coverage->GetName(),
                        coverage->GetSrid());

  }
  void AddAltVectorCoverage(wxTreeItemId & rootVectorCoverages,
                            VectorCoverageSet * coverage)
  {
    AltVectorCoverages.Add(this, rootVectorCoverages, coverage->GetName(),

                           coverage->GetSrid());
  }
  bool GetCurrentlySelectedTable(wxString & table_name);
  void DeleteRasterCoverages(wxTreeItemId & root_coverages);
  void DeleteVectorCoverages(wxTreeItemId & root_coverages);
  void DeleteAltRasterCoverages(void)
  {
    AltRasterCoverages.Flush();
................................................................................
  void OnCmdSimplePointSymbolizer(wxCommandEvent & event);
  void OnCmdSimpleTextSymbolizer(wxCommandEvent & event);
  void OnCmdImportRaster(wxCommandEvent & event);
  void OnCmdPyramidize(wxCommandEvent & event);
  void OnCmdPyramidizeMonolithic(wxCommandEvent & event);
  void OnCmdDePyramidize(wxCommandEvent & event);
  void OnCmdRasterDrop(wxCommandEvent & event);

  void OnCmdRasterSRIDs(wxCommandEvent & event);
  void OnCmdRasterKeywords(wxCommandEvent & event);
  void OnCmdUpdateRasterExtent(wxCommandEvent & event);
  void OnCmdUpdateRasterExtentAll(wxCommandEvent & event);
  void OnCmdVectorUnregister(wxCommandEvent & event);

  void OnCmdVectorSRIDs(wxCommandEvent & event);
  void OnCmdVectorKeywords(wxCommandEvent & event);
  void OnCmdUpdateVectorExtent(wxCommandEvent & event);
  void OnCmdUpdateVectorExtentAll(wxCommandEvent & event);
  void OnCmdRegisterWmsLayer(wxCommandEvent & event);
  void OnCmdUnregisterWmsLayer(wxCommandEvent & event);
  void OnCmdConfigureWmsLayer(wxCommandEvent & event);




  void OnCmdShow(wxCommandEvent & event);
  void OnCmdDrop(wxCommandEvent & event);
  void OnCmdRename(wxCommandEvent & event);
  void OnCmdSelect(wxCommandEvent & event);
  void OnCmdSelectTiles(wxCommandEvent & event);
  void OnCmdRefresh(wxCommandEvent & event);
  void OnRefreshDeferred(wxCommandEvent & event);
................................................................................
  void OnCmdDetachDB(wxCommandEvent & event);
  void OnCmdCheckGeometries(wxCommandEvent & event);
  void OnCmdSanitizeGeometries(wxCommandEvent & event);
  void OnCmdSldSeRasterStyles(wxCommandEvent & event);
  void OnCmdSldSeVectorStyles(wxCommandEvent & event);
  void OnCreateRasterCoverage(wxCommandEvent & event);
  void OnRegisterVectorCoverage(wxCommandEvent & event);




  void OnItemCollapsed(wxTreeEvent & event);
  void OnItemExpanding(wxTreeEvent & event);
};

class SqlThreadParams
{
//
................................................................................
  wxString & GetTmpPrefix()
  {
    return TmpPrefix;
  }
  void OnYes(wxCommandEvent & event);
  void OnNo(wxCommandEvent & event);
};

























































































class WfsParams
{
// parameters for WFS download
private:
  class WfsDialog * Mother;
  wxGauge *ProgressCtrl;
................................................................................
class MyFrame:public wxFrame
{
//
// the main GUI frame
//
private:
  char *Old_SPATIALITE_SECURITY_ENV;

  wxString AutoFDOmsg;
  wxString AutoGPKGmsg;
  bool SpatiaLiteMetadata;
  wxAuiManager Manager;         // the GUI manager
  wxString ConfigLayout;        // PERSISTENCY - the layout configuration
  int ConfigPaneX;              // PERSISTENCY - the main pane screen origin X
  int ConfigPaneY;              // PERSISTENCY - the main pane screen origin Y
................................................................................
  wxBitmap *BtnAttach;          // button icon for ATTACH
  wxBitmap *BtnSqlLog;          // button icon for SQL LOG
  wxBitmap *BtnDbStatus;        // button icon for DB STATUS
  wxBitmap *BtnCheckGeom;       // button icon for CheckGeom
  wxBitmap *BtnSaneGeom;        // button icon for SaneGeom
  wxBitmap *BtnWFS;             // button icon for WFS
  wxBitmap *BtnDXF;             // button icon for DXF

  bool ReadOnlyConnection;
// AutoSave timer
  int AutoSaveInterval;
  int LastTotalChanges;
  wxTimer *TimerAutoSave;
  gaiaGeomCollPtr GeomFromPoint(gaiaPointPtr pt, int srid);
  gaiaGeomCollPtr GeomFromLinestring(gaiaLinestringPtr ln, int srid);
................................................................................
  bool GetTilePreview(wxString & currentTileData, int currentTileId,
                      unsigned char **blob, int *blobSize);
  class RasterCoverageStylesList *FindRasterCoverageStyles(wxString & coverage);
  class RasterCoverageStylesList *FindRasterStyles();
  class VectorCoverageStylesList *FindVectorCoverageStyles(wxString & coverage);
  class VectorCoverageStylesList *FindVectorStyles();
  class CandidateVectorCoveragesList *FindUnregisteredVectorCoverages();






  bool DoRegisterVectorCoverage(wxString & name, wxString & table,
                                wxString & geometry, wxString & title,
                                wxString & abstract);















  bool ValidateRasterStyle(const char *path, void **blob, int *blob_size);
  bool ValidateRasterStyle(void **blob, int *blob_size, const char *xml);
  bool DoInsertRasterSymbolizer(char *xml);
  bool ValidateVectorStyle(const char *path, void **blob, int *blob_size);
  bool ValidateVectorStyle(void **blob, int *blob_size, const char *xml);
  bool DoInsertVectorSymbolizer(char *xml);
  bool ValidateExternalGraphicResource(const char *path, void **blob,
................................................................................
                            int NumBands, int Compression, int Quality,
                            int TileWidth, int TileHeight,
                            bool NotGeoreferenced, int Srid,
                            double HorzResolution, double VertResolution,
                            wxString NoData, bool StrictResolution,
                            bool MixedResolutions, bool InputPaths, bool MD5,
                            bool Summary, int RedBand, int GreenBand,
                            int BlueBand, int NIRband, bool AutoNDVI);

  static void DoubleQuoted(wxString & str);
  bool IsView(wxString & view);
  bool IsWritableView(wxString & view);
  void GetWritableViewPK(wxString & view, wxString & pk_name);

  bool HasFlippedAxes(const char *crs);
  bool BBoxFromLongLat(const char *crs_str, double *minx, double *maxx,
................................................................................
                       double *miny, double *maxy);
  char *GetProjParams(int srid);

  void CreateWmsTables();
  bool IsDefinedWmsGetCapabilities(const char *url);
  bool IsDefinedWmsGetMap(const char *getmap_url, const char *layer_name);
  bool RegisterWmsGetCapabilities(const char *url, const char *title,
                                     const char *abstract);
  bool RegisterWmsGetMap(const char *getcapabilities_url,
                         const char *getmap_url, const char *layer_name,
                         const char *title, const char *abstract,
                         const char *version, const char *ref_sys,
                         const char *image_format, const char *style,
                         int transparent, int flip_axes, int is_queryable,
                         int tiled, int cached, int tile_width, int tile_height,
                         const char *bgcolor);
  bool RegisterWmsSetting(const char *url, const char *layer_name,
                          const char *key, const char *value, int is_default);
  bool RegisterWmsSRS(const char *url, const char *layer_name,
                      const char *ref_sys, double minx, double miny,
                      double maxx, double maxy, int is_default);
  bool TransformWmsBBox(const char *ref_sys, double geoMinX, double geoMinY,
                        double geoMaxX, double geoMaxY, double *minx,
                        double *miny, double *maxx, double *maxy);
  bool UnRegisterWmsGetMap(const char *url, const char *layer);
  void DoRegisterWMS();
  void DoUnRegisterWMS();
  void DoConfigureWMS();





  void OnQuit(wxCommandEvent & event);

  void OnAbout(wxCommandEvent & event);
  void OnConnect(wxCommandEvent & event);
  void OnConnectReadOnly(wxCommandEvent & event);
  void OnCreateNew(wxCommandEvent & event);
  void OnDisconnect(wxCommandEvent & event);
  void OnMemoryDbLoad(wxCommandEvent & event);
  void OnMemoryDbNew(wxCommandEvent & event);
  void OnMemoryDbClock(wxCommandEvent & event);
  void OnMemoryDbSave(wxCommandEvent & event);
  void OnVacuum(wxCommandEvent & event);

  void OnSqlScript(wxCommandEvent & event);
  void OnQueryViewComposer(wxCommandEvent & event);
  void OnCharset(wxCommandEvent & event);
  void OnLoadShp(wxCommandEvent & event);
  void OnLoadTxt(wxCommandEvent & event);
  void OnLoadDbf(wxCommandEvent & event);
  void OnLoadXL(wxCommandEvent & event);
................................................................................
  double VertResolution;
  wxString NoData;
  bool StrictResolution;
  bool MixedResolutions;
  bool InputPaths;
  bool MD5;
  bool Summary;

  bool IsValidNoData(wxString & no_data, int sample, int num_bands);
public:
    CreateRasterCoverageDialog()
  {;
  }
  bool Create(MyFrame * parent);
  virtual ~ CreateRasterCoverageDialog()
................................................................................
  {
    return MD5;
  }
  bool IsSummary()
  {
    return Summary;
  }




  void OnSampleChanged(wxCommandEvent & event);
  void OnPixelChanged(wxCommandEvent & event);
  void OnCompressionChanged(wxCommandEvent & event);
  void OnNumBandsChanged(wxCommandEvent & event);
  void OnRedBandChanged(wxCommandEvent & event);
  void OnGreenBandChanged(wxCommandEvent & event);
  void OnBlueBandChanged(wxCommandEvent & event);
................................................................................
  virtual ~ RasterDropDialog()
  {;
  }
  void CreateControls();
  bool DoDropCoverage(void);
  void OnOk(wxCommandEvent & event);
};



























class RasterCoverageStylesDialog:public wxDialog
{
//
// a dialog for handling SLD/SE Raster Coverage's Styles
//
private:
................................................................................
  int GetSelectedCount();
  int GetSelectedStyleId(int idx);
  void OnOk(wxCommandEvent & event);
};

class CandidateVectorCoverage
{
// an SLD/SE Vector style
private:
  wxString TableName;
  wxString GeometryColumn;
  int Srid;
  wxString GeometryType;
  bool VectorCoverage;
  bool RasterCoverage;


  CandidateVectorCoverage *Next;
public:
    CandidateVectorCoverage(wxString & table, wxString & geometry, int srid,
                            wxString & type)
  {
    TableName = table;
    GeometryColumn = geometry;
    Srid = srid;
    GeometryType = type;
    VectorCoverage = false;
    RasterCoverage = false;


    Next = NULL;
  }
   ~CandidateVectorCoverage()
  {;
  }
  wxString & GetTableName()
  {
................................................................................
  void MarkRasterCoverage()
  {
    RasterCoverage = true;
  }
  bool IsRasterCoverage()
  {
    return RasterCoverage;
















  }
  CandidateVectorCoverage *GetNext()
  {
    return Next;
  }
  void SetNext(CandidateVectorCoverage * next)
  {
    Next = next;
  }
};

class CandidateVectorCoveragesList
{
// a container for candidate Vector Coverages
private:
  CandidateVectorCoverage * First;
  CandidateVectorCoverage *Last;
public:
    CandidateVectorCoveragesList()
  {
    First = NULL;
................................................................................
    Last = NULL;
  }
   ~CandidateVectorCoveragesList();
  void Add(wxString & table_name, wxString & geometry, int srid,
           wxString & type);
  void MarkVectorCoverage(wxString & table, wxString & geometry);
  void MarkRasterCoverage(wxString & table, wxString & geometry);


  CandidateVectorCoverage *GetFirst()
  {
    return First;
  }
};

class VectorRegisterDialog:public wxDialog
{
//
// a dialog for Register Vector Coverage
//
private:
  MyFrame * MainFrame;
  CandidateVectorCoveragesList *List;
  wxGrid *GridCtrl;
  wxString CoverageName;
  wxString TableName;
  wxString GeometryColumn;
  wxString Title;
  wxString Abstract;


public:
    VectorRegisterDialog()
  {
    List = NULL;
  }
  bool Create(MyFrame * parent);
  virtual ~ VectorRegisterDialog()
................................................................................
  {
    return Title;
  }
  wxString & GetAbstract()
  {
    return Abstract;
  }








  void OnOk(wxCommandEvent & event);


















































































































































































































































































































































































































































































































































































};

class VectorCoverageSRID
{
// a Vector Coverage alternative SRID
private:
  int Srid;
................................................................................
    return wxSize(48, 24);
  }
  void SetGraphic(wxImage * graphic)
  {
    Graphic = graphic;
  }
};































class MyFontCellRenderer:public wxGridCellRenderer
{
// a Grid CellRenderer supporting a Text Font
private:
  wxImage * FontExample;
public:
................................................................................
  int Opaque;
  int SwapXY;
  int Tiled;
  int TileWidth;
  int TileHeight;
  int Queryable;
  void GetButtonBitmap(const char *color, wxBitmap & bmp);
  void ParseBgColor(const char *color, unsigned char *red, unsigned char *green, unsigned char *blue);

  unsigned char ParseHex(const char *byte);
public:
    WmsConfigDialog(){;}


    virtual ~ WmsConfigDialog()
    {
		if (Version != NULL) free(Version);

		if (MaxVersion != NULL) free(MaxVersion);

		if (RefSys != NULL) free(RefSys);

		if (Style != NULL) free(Style);

		if (ImageFormat != NULL) free(ImageFormat);

		if (BgColor != NULL) free(BgColor);

	}
  bool Create(MyFrame * parent, wxString url, wxString layer);
  void CreateControls();
  const char *GetVersion()
  {
    return Version;
  }
  const char *GetStyle()
................................................................................
  }
  int GetTileHeight()
  {
    return TileHeight;
  }
  void LoadData();
  void FindMaxVersion();
  void PopulateRefSys(wxComboBox *crsList);
  void PopulateImageFormats(wxComboBox *fmtList);
  void PopulateStyles(wxComboBox *stlList);
  void UpdateSwapXY(void);
  void OnCrsChanged(wxCommandEvent & event);
  void OnVersionChanged(wxCommandEvent & event);
  void OnSwapXYChanged(wxCommandEvent & event);
  void OnTiledChanged(wxCommandEvent & event);
  void OnBgColorEnabledChanged(wxCommandEvent & event);
  void OnBgColorChanged(wxCommandEvent & event);
................................................................................
    DATA_TYPE_MULTIPOINT,
    DATA_TYPE_MULTILINESTRING,
    DATA_TYPE_MULTIPOLYGON,
    DATA_TYPE_GEOMETRYCOLLECTION,
    DATA_TYPE_GEOMETRY
  };
};

  ID_CreateNew,
  ID_Disconnect,
  ID_MemoryDbLoad,
  ID_MemoryDbNew,
  ID_MemoryDbClock,
  ID_MemoryDbSave,
  ID_Vacuum,
  ID_MapPanel,
  ID_SqlScript,
  ID_QueryViewComposer,
  ID_LoadShp,
  ID_LoadTxt,
  ID_LoadDbf,
  ID_LoadXL,
  ID_VirtualShp,
................................................................................
  ID_Attach,
  ID_SqlLog,
  ID_DbStatus,
  ID_CheckGeom,
  ID_SaneGeom,
  ID_WFS,
  ID_DXF,
  ID_AddLayer,
  ID_Center,
  ID_Identify,
  ID_ZoomIn,
  ID_ZoomOut,
  ID_UserScale,
  ID_Pan,
  ID_Printer,
  Tree_NewTable,
  Tree_NewView,
  Tree_NewIndex,
  Tree_NewTrigger,
  Tree_NewColumn,
  Tree_NewRasterStyle,
  Tree_ReloadRasterStyle,
................................................................................
  Tree_SldSeRasterStyles,
  Tree_SldSeVectorStyles,
  Tree_ImportRaster,
  Tree_Pyramidize,
  Tree_PyramidizeMonolithic,
  Tree_DePyramidize,
  Tree_RasterDrop,
  Tree_RasterInfos,
  Tree_VectorRegister,
  Tree_SpatialViewRegister,
  Tree_VirtualShapeRegister,
  Tree_TopoGeoRegister,
  Tree_TopoNetRegister,
  Tree_VectorUnregister,
  Tree_VectorInfos,
  Tree_CreateRasterCoverage,
  Tree_UpdateRasterExtent,
  Tree_UpdateRasterExtentAll,
  Tree_UpdateVectorExtent,
  Tree_UpdateVectorExtentAll,
  Tree_Raster_SRIDs,
  Tree_Vector_SRIDs,
................................................................................
  Tree_SimpleLineSymbolizer,
  Tree_SimplePolygonSymbolizer,
  Tree_SimpleTextSymbolizer,
  Tree_CloneTable,
  Tree_RegisterWmsLayer,
  Tree_UnregisterWmsLayer,
  Tree_ConfigureWmsLayer,
  Tree_CreateTopoGeo,
  Tree_DropTopoGeo,
  Tree_CreateTopoNet,
  Tree_DropTopoNet,
  Tree_MapRemoveAll,
  Tree_MapShowAll,
  Tree_MapHideAll,
  Tree_MapVisible,
  Tree_MapConfigure,
  Tree_MapLayerInfo,
  Tree_MapRemoveLayer,
  Tree_MapDeleteItem,
  Grid_Clear,
  Grid_All,
  Grid_Column,
  Grid_Row,
  Grid_Copy,
  Grid_Blob,
  Grid_Delete,
................................................................................
  ID_CVG_SAME_RES,
  ID_CVG_VERT_RES,
  ID_CVG_STRICT_RES,
  ID_CVG_MIXED_RES,
  ID_CVG_PATHS,
  ID_CVG_MD5,
  ID_CVG_SUMMARY,
  ID_CVG_QUERYABLE,
  ID_LOAD_FORCE_SRID,
  ID_LOAD_SRID,
  ID_LOAD_WITH_WORLDFILE,
  ID_LOAD_PYRAMIDIZE,
  ID_LOAD_LIST_DONE,
  ID_LOAD_ABORT,
  ID_LOAD_RASTER_THREAD_FINISHED,
................................................................................
  ID_LOAD_FONT_START,
  ID_LOAD_FONT_STOP,
  ID_LOAD_FONT_SKIP,
  ID_VECTOR_GRID,
  ID_VECTOR_COVERAGE,
  ID_VECTOR_TITLE,
  ID_VECTOR_ABSTRACT,
  ID_VECTOR_QUERYABLE,
  ID_VECTOR_EDITABLE,
  ID_VECTOR_SRID_ADD,
  ID_VECTOR_SRID_REMOVE,
  ID_VECTOR_SRID,
  ID_VECTOR_SRID_GRID,
  ID_RASTER_SRID_ADD,
  ID_RASTER_SRID_REMOVE,
  ID_RASTER_SRID,
................................................................................
  ID_WMS_OK,
  ID_WMS_ENABLE_PROXY,
  ID_WMS_PROXY,
  ID_WMS_LIST,
  ID_WMS_LAYER,
  ID_WMS_ENABLE_BGCOLOR,
  ID_WMS_BGCOLOR,
  ID_TOPO_NAME,
  ID_TOPO_SRID,
  ID_TOPO_3D,
  ID_TOPO_TOLERANCE,
  ID_TOPO_SPATIAL,
  ID_TOPO_COINCIDENT,
  ID_LAYER_TYPE,
  ID_PANE_MAIN,
  ID_PANE_STROKE1,
  ID_PANE_STROKE2,
  ID_PANE_STROKE3,
  ID_PANE_FILL1,
  ID_PANE_FILL2,
  ID_PANE_POSITION,
  ID_PANE_GRAPHIC,
  ID_PANE_MARK,
  ID_PANE_FONT,
  ID_PANE_PLACEMENT,
  ID_PANE_PREVIEW,
  ID_LAYERS_LIST
};

enum
{
// tree item data types
  MY_ROOT_NODE = 0,
  MY_TABLE,
  MY_VTABLE,
  MY_VIEW,
  MY_TILE_DATA,
  MY_COLUMN,
  MY_VIEW_COLUMN,
  MY_VIRTUAL_COLUMN,
  MY_GEOMETRY,
................................................................................
  MY_GEOMETRY_INDEX,
  MY_GEOMETRY_CACHED,
  MY_VIEW_GEOMETRY,
  MY_VIEW_GEOMETRY_INDEX,
  MY_VIEW_GEOMETRY_CACHED,
  MY_VIRTUAL_GEOMETRY,
  MY_VIRTUAL_GPKG_GEOMETRY,
  MY_TOPO_GEO,
  MY_TOPO_NET,
  MY_COVERAGE,
  MY_INDEX,
  MY_TRIGGER,
  MY_ATTACHED,
  MY_INT_VARIANT,
  MY_DBL_VARIANT,
  MY_TXT_VARIANT,
  MY_BLOB_VARIANT,
  MY_NULL_VARIANT,
  MY_UNDEFINED
};

enum
{
// control IDs for timers
  ID_AUTO_SAVE_TIMER = 20000,
  ID_DB_STATUS_TIMER,
................................................................................
enum
{
// METADATA TYPEs
  METADATA_UNKNOWN = 0,
  METADATA_LEGACY,
  METADATA_CURRENT
};

enum
{
// Map Layer TYPEs
  MAP_LAYER_UNKNOWN = 0,
  MAP_LAYER_WMS,
  MAP_LAYER_VECTOR,
  MAP_LAYER_TOPOLOGY,
  MAP_LAYER_NETWORK,
  MAP_LAYER_RASTER
};

class RasterCoverageItem
{
//
// a class wrapping a Raster Coverage related Table or View
//
private:
................................................................................

class VectorCoverageSet
{
//
// a class representing a full Vector Coverage Set
//
private:
  wxString Prefix;
  wxString Name;
  int Srid;
  int GeometryType;
public:
    VectorCoverageSet(const char *prefix, const char *name, int srid, int type);
   ~VectorCoverageSet()
  {;
  }
  wxString & GetPrefix()
  {
    return Prefix;
  }
  wxString & GetName()
  {
    return Name;
  }
  int GetSrid()
  {
    return Srid;
  }
  int GetGeometryType()
  {
    return GeometryType;
  }
};

class MyObject:public wxTreeItemData
{
//
// a class to store TreeItemData
//
................................................................................
  int Type;                     // the object type
  wxString DbAlias;             // the DB alias [Attached DB] 
  wxString Name;                // the object name
  wxString Column;              // the column name [optional]
  bool Temporary;               // the TMP switch
  bool Coverage;                // TRUE only if Raster Coverage related
  bool Topology;                // TRUE only if TopoGeo or TopoNet related
  bool RootAttached;            // valid only for Type=MY_ROOT_NODE
public:
    MyObject();
    MyObject(bool attached);
    MyObject(int type, wxString & name);
    MyObject(int type, wxString & name, bool tmp, bool coverage =
             false, bool topology = false);
    MyObject(int type, wxString & dbAlias, wxString & name, bool tmp);
    MyObject(int type, wxString & name, wxString & column);
    MyObject(int type, bool attached, wxString & dbAlias, wxString & name,
             bool coverage = false, bool topology = false);
    MyObject(wxString & coverage);
    MyObject(wxString & dbAlias, wxString & coverage);
    virtual ~ MyObject()
  {;
  }
  int GetType()
  {
    return Type;
  }
................................................................................
  {
    return Column;
  }
  bool IsTemporary()
  {
    return Temporary;
  }
  bool IsRootAttached()
  {
    return RootAttached;
  }
  bool IsAttached()
  {
    if (DbAlias.Len() > 0)
      return true;
    else
      return false;
  }
................................................................................
//
private:
  wxString DbPrefix;
  wxString Name;
  int Srid;
  bool HasZ;
public:
    TopoGeoSet(const char *name, int srid, bool has_z);
    TopoGeoSet(const char *db_prefix, const char *name, int srid, bool has_z);
   ~TopoGeoSet()
  {;
  }
  wxString & GetDbPrefix()
  {
    return DbPrefix;
................................................................................
private:
  sqlite3 * DbHandle;
  wxString DbPrefix;
  wxString Name;
  wxTreeItemId TopologyNode;
  TopoGeo *Next;
public:
    TopoGeo(class MyTableTree * tree, wxTreeItemId & root,
            wxString & topology, int srid, bool has_z);
    TopoGeo(class MyTableTree * tree, wxTreeItemId & root,
            wxString & db_prefix, wxString & topology, int srid, bool has_z);
   ~TopoGeo()
  {;
  }
  wxTreeItemId *Check(wxString & table);
  bool CheckTopoFeature(wxString & table);
................................................................................
    Count = 0;
  }
   ~TopoGeoList()
  {
    Flush();
  }
  void Flush();
  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & topology, int srid, bool has_z);
  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & db_prefix, wxString & topology, int srid, bool has_z);
  wxTreeItemId *FindNode(wxString & table);
  int GetCount()
  {
    return Count;
  }
................................................................................

class TopoNetSet
{
//
// a class representing a full TopoNet Set
//
private:
  wxString DbPrefix;
  wxString Name;
  bool Spatial;
  int Srid;
  bool HasZ;
public:
    TopoNetSet(const char *name, bool spatial, int srid, bool has_z);
    TopoNetSet(const char *db_prefix, const char *name, bool spatial, int srid,
               bool has_z);
   ~TopoNetSet()
  {;
  }
  wxString & GetDbPrefix()
  {
    return DbPrefix;
  }
  wxString & GetName()
  {
    return Name;
  }
  bool IsSpatial()
  {
................................................................................

class TopoNet
{
//
// TopoNet container
//
private:
  wxString DbPrefix;
  wxString Name;
  wxTreeItemId NetworkNode;
  TopoNet *Next;
public:
    TopoNet(class MyTableTree * tree, wxTreeItemId & root,
            wxString & network, bool spatial, int srid, bool has_z);
    TopoNet(class MyTableTree * tree, wxTreeItemId & root,
            wxString & dbPrefix, wxString & network, bool spatial, int srid,
            bool has_z);
   ~TopoNet()
  {;
  }
  wxTreeItemId *Check(wxString & table);
  TopoNet *GetNext()
  {
    return Next;
................................................................................
   ~TopoNetList()
  {
    Flush();
  }
  void Flush();
  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & network, bool spatial, int srid, bool has_z);
  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & db_prefix, wxString & network, bool spatial, int srid,
           bool has_z);
  wxTreeItemId *FindNode(wxString & table);
  int GetCount()
  {
    return Count;
  }
};

class RasterCoverage
{
//
// Raster Coverage container
//
private:
  wxString DbPrefix;
  wxString Name;
  wxTreeItemId CoverageNode;
  RasterCoverage *Next;
public:
    RasterCoverage(class MyTableTree * tree, wxTreeItemId & root,
                   wxString & coverage, int srid);
    RasterCoverage(class MyTableTree * tree, wxTreeItemId & root,
                   wxString & dbPrefix, wxString & coverage, int srid);
   ~RasterCoverage()
  {;
  }
  wxTreeItemId *Check(wxString & table, bool * tile_data);
  RasterCoverage *GetNext()
  {
    return Next;
................................................................................
   ~RasterCoverageList()
  {
    Flush();
  }
  void Flush();
  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & coverage, int srid);
  void Add(class MyTableTree * tree, wxTreeItemId & root, wxString & dbPrefix,
           wxString & coverage, int srid);
  wxTreeItemId *FindNode(wxString & table, bool * tile_data);
  int GetCount()
  {
    return Count;
  }
};

class VectorCoverage
{
//
// Vector Coverage container
//
private:
  wxString DbPrefix;
  wxString Prefix;
  wxString Name;
  wxTreeItemId CoverageNode;
  VectorCoverage *Next;
public:
    VectorCoverage(class MyTableTree * tree, wxTreeItemId & root,
                   wxString & prefix, wxString & coverage, int srid,
                   int geometry_type);
    VectorCoverage(class MyTableTree * tree, wxTreeItemId & root,
                   wxString & dbPrefix, wxString & prefix, wxString & coverage,
                   int srid, int geometry_type);
   ~VectorCoverage()
  {;
  }
  VectorCoverage *GetNext()
  {
    return Next;
  }
................................................................................
  }
   ~VectorCoverageList()
  {
    Flush();
  }
  void Flush();
  void Add(class MyTableTree * tree, wxTreeItemId & root,
           wxString & prefix, wxString & coverage, int srid, int geometry_type);
  void Add(class MyTableTree * tree, wxTreeItemId & root, wxString & dbPrefix,
           wxString & prefix, wxString & coverage, int srid, int geometry_type);
  int GetCount()
  {
    return Count;
  }
};

class RootNodes
................................................................................
    CollapseAllChildren(RootIsoMetadata);
    Collapse(RootMetadata);
    Collapse(RootInternal);
    Collapse(RootSpatialIndex);
  }
  void AddTopology(TopoGeoSet * topology)
  {
    Topologies.Add(this, RootTopologies,
                   topology->GetName(), topology->GetSrid(),
                   topology->GetHasZ());
  }
  void AddAltTopology(wxTreeItemId & rootTopologies, wxString & dbAlias,
                      TopoGeoSet * topology)
  {
    AltTopologies.Add(this, rootTopologies, dbAlias,
                      topology->GetName(), topology->GetSrid(),
                      topology->GetHasZ());
  }
  void DeleteTopologies(wxTreeItemId & root_topologies);
  void DeleteAltTopologies(void)
  {
    AltTopologies.Flush();
  }
  void AddNetwork(TopoNetSet * network)
  {
    Networks.Add(this, RootNetworks, network->GetName(), network->IsSpatial(),
                 network->GetSrid(), network->GetHasZ());
  }
  void AddAltNetwork(wxTreeItemId & rootNetworks, wxString & dbAlias,
                     TopoNetSet * network)
  {
    AltNetworks.Add(this, rootNetworks, dbAlias, network->GetName(),
                    network->IsSpatial(), network->GetSrid(),
                    network->GetHasZ());
  }
  void DeleteNetworks(wxTreeItemId & root_networks);
  void DeleteAltNetworks(void)
  {
    AltNetworks.Flush();
................................................................................
  }
  void AddRasterCoverage(RasterCoverageSet * coverage)
  {
    RasterCoverages.Add(this, RootRasterCoverages, coverage->GetName(),
                        coverage->GetSrid());
  }
  void AddAltRasterCoverage(wxTreeItemId & rootRasterCoverages,
                            wxString & dbAlias, RasterCoverageSet * coverage)
  {
    AltRasterCoverages.Add(this, rootRasterCoverages, dbAlias,
                           coverage->GetName(), coverage->GetSrid());
  }
  void AddVectorCoverage(VectorCoverageSet * coverage)
  {
    VectorCoverages.Add(this, RootVectorCoverages, coverage->GetPrefix(),
                        coverage->GetName(), coverage->GetSrid(),
                        coverage->GetGeometryType());
  }
  void AddAltVectorCoverage(wxTreeItemId & rootVectorCoverages,
                            wxString & dbAlias, VectorCoverageSet * coverage)
  {
    AltVectorCoverages.Add(this, rootVectorCoverages, dbAlias,
                           coverage->GetPrefix(), coverage->GetName(),
                           coverage->GetSrid(), coverage->GetGeometryType());
  }
  bool GetCurrentlySelectedTable(wxString & table_name);
  void DeleteRasterCoverages(wxTreeItemId & root_coverages);
  void DeleteVectorCoverages(wxTreeItemId & root_coverages);
  void DeleteAltRasterCoverages(void)
  {
    AltRasterCoverages.Flush();
................................................................................
  void OnCmdSimplePointSymbolizer(wxCommandEvent & event);
  void OnCmdSimpleTextSymbolizer(wxCommandEvent & event);
  void OnCmdImportRaster(wxCommandEvent & event);
  void OnCmdPyramidize(wxCommandEvent & event);
  void OnCmdPyramidizeMonolithic(wxCommandEvent & event);
  void OnCmdDePyramidize(wxCommandEvent & event);
  void OnCmdRasterDrop(wxCommandEvent & event);
  void OnCmdRasterInfos(wxCommandEvent & event);
  void OnCmdRasterSRIDs(wxCommandEvent & event);
  void OnCmdRasterKeywords(wxCommandEvent & event);
  void OnCmdUpdateRasterExtent(wxCommandEvent & event);
  void OnCmdUpdateRasterExtentAll(wxCommandEvent & event);
  void OnCmdVectorUnregister(wxCommandEvent & event);
  void OnCmdVectorInfos(wxCommandEvent & event);
  void OnCmdVectorSRIDs(wxCommandEvent & event);
  void OnCmdVectorKeywords(wxCommandEvent & event);
  void OnCmdUpdateVectorExtent(wxCommandEvent & event);
  void OnCmdUpdateVectorExtentAll(wxCommandEvent & event);
  void OnCmdRegisterWmsLayer(wxCommandEvent & event);
  void OnCmdUnregisterWmsLayer(wxCommandEvent & event);
  void OnCmdConfigureWmsLayer(wxCommandEvent & event);
  void OnCmdCreateTopoGeo(wxCommandEvent & event);
  void OnCmdDropTopoGeo(wxCommandEvent & event);
  void OnCmdCreateTopoNet(wxCommandEvent & event);
  void OnCmdDropTopoNet(wxCommandEvent & event);
  void OnCmdShow(wxCommandEvent & event);
  void OnCmdDrop(wxCommandEvent & event);
  void OnCmdRename(wxCommandEvent & event);
  void OnCmdSelect(wxCommandEvent & event);
  void OnCmdSelectTiles(wxCommandEvent & event);
  void OnCmdRefresh(wxCommandEvent & event);
  void OnRefreshDeferred(wxCommandEvent & event);
................................................................................
  void OnCmdDetachDB(wxCommandEvent & event);
  void OnCmdCheckGeometries(wxCommandEvent & event);
  void OnCmdSanitizeGeometries(wxCommandEvent & event);
  void OnCmdSldSeRasterStyles(wxCommandEvent & event);
  void OnCmdSldSeVectorStyles(wxCommandEvent & event);
  void OnCreateRasterCoverage(wxCommandEvent & event);
  void OnRegisterVectorCoverage(wxCommandEvent & event);
  void OnRegisterSpatialViewCoverage(wxCommandEvent & event);
  void OnRegisterVirtualShapeCoverage(wxCommandEvent & event);
  void OnRegisterTopoGeoCoverage(wxCommandEvent & event);
  void OnRegisterTopoNetCoverage(wxCommandEvent & event);
  void OnItemCollapsed(wxTreeEvent & event);
  void OnItemExpanding(wxTreeEvent & event);
};

class SqlThreadParams
{
//
................................................................................
  wxString & GetTmpPrefix()
  {
    return TmpPrefix;
  }
  void OnYes(wxCommandEvent & event);
  void OnNo(wxCommandEvent & event);
};

class CreateTopoGeoDialog:public wxDialog
{
//
// a Dialog for creating a new Topology-Geometry
//
private:
  MyFrame * MainFrame;
  wxString TopologyName;
  int Srid;
  bool HasZ;
  double Tolerance;
public:
    CreateTopoGeoDialog()
  {;
  }
  bool Create(MyFrame * parent);
  virtual ~ CreateTopoGeoDialog()
  {;
  }
  void CreateControls();

  wxString & GetTopologyName()
  {
    return TopologyName;
  }
  int GetSrid()
  {
    return Srid;
  }
  bool Is3D()
  {
    return HasZ;
  }
  double GetTolerance()
  {
    return Tolerance;
  }
  void OnOk(wxCommandEvent & event);
  void OnCancel(wxCommandEvent & event);
};

class CreateTopoNetDialog:public wxDialog
{
//
// a Dialog for creating a new Topology-Network
//
private:
  MyFrame * MainFrame;
  wxString NetworkName;
  bool Spatial;
  int Srid;
  bool HasZ;
  bool Coincident;
public:
    CreateTopoNetDialog()
  {;
  }
  bool Create(MyFrame * parent);
  virtual ~ CreateTopoNetDialog()
  {;
  }
  void CreateControls();

  wxString & GetNetworkName()
  {
    return NetworkName;
  }
  bool IsSpatial()
  {
    return Spatial;
  }
  int GetSrid()
  {
    return Srid;
  }
  bool Is3D()
  {
    return HasZ;
  }
  bool AllowsCoincident()
  {
    return Coincident;
  }
  void OnSpatialChanged(wxCommandEvent & event);
  void OnOk(wxCommandEvent & event);
  void OnCancel(wxCommandEvent & event);
};

class WfsParams
{
// parameters for WFS download
private:
  class WfsDialog * Mother;
  wxGauge *ProgressCtrl;
................................................................................
class MyFrame:public wxFrame
{
//
// the main GUI frame
//
private:
  char *Old_SPATIALITE_SECURITY_ENV;
  class MyMapPanel *MapPanel;   // the Map Panel
  wxString AutoFDOmsg;
  wxString AutoGPKGmsg;
  bool SpatiaLiteMetadata;
  wxAuiManager Manager;         // the GUI manager
  wxString ConfigLayout;        // PERSISTENCY - the layout configuration
  int ConfigPaneX;              // PERSISTENCY - the main pane screen origin X
  int ConfigPaneY;              // PERSISTENCY - the main pane screen origin Y
................................................................................
  wxBitmap *BtnAttach;          // button icon for ATTACH
  wxBitmap *BtnSqlLog;          // button icon for SQL LOG
  wxBitmap *BtnDbStatus;        // button icon for DB STATUS
  wxBitmap *BtnCheckGeom;       // button icon for CheckGeom
  wxBitmap *BtnSaneGeom;        // button icon for SaneGeom
  wxBitmap *BtnWFS;             // button icon for WFS
  wxBitmap *BtnDXF;             // button icon for DXF
  wxBitmap *BtnMap;             // button icon for Map Panel
  bool ReadOnlyConnection;
// AutoSave timer
  int AutoSaveInterval;
  int LastTotalChanges;
  wxTimer *TimerAutoSave;
  gaiaGeomCollPtr GeomFromPoint(gaiaPointPtr pt, int srid);
  gaiaGeomCollPtr GeomFromLinestring(gaiaLinestringPtr ln, int srid);
................................................................................
  bool GetTilePreview(wxString & currentTileData, int currentTileId,
                      unsigned char **blob, int *blobSize);
  class RasterCoverageStylesList *FindRasterCoverageStyles(wxString & coverage);
  class RasterCoverageStylesList *FindRasterStyles();
  class VectorCoverageStylesList *FindVectorCoverageStyles(wxString & coverage);
  class VectorCoverageStylesList *FindVectorStyles();
  class CandidateVectorCoveragesList *FindUnregisteredVectorCoverages();
  class CandidateSpatialViewCoveragesList
    * FindUnregisteredSpatialViewCoverages();
  class CandidateVirtualShapeCoveragesList
    * FindUnregisteredVirtualShapeCoverages();
  class CandidateTopoGeoCoveragesList *FindUnregisteredTopoGeoCoverages();
  class CandidateTopoNetCoveragesList *FindUnregisteredTopoNetCoverages();
  bool DoRegisterVectorCoverage(wxString & name, wxString & table,
                                wxString & geometry, wxString & title,
                                wxString & abstract, bool isQueryable,
                                bool isEditable);
  bool DoRegisterSpatialViewCoverage(wxString & name, wxString & view,
                                     wxString & geometry, wxString & title,
                                     wxString & abstract, bool isQueryable,
                                     bool isEditable);
  bool DoRegisterVirtualShapeCoverage(wxString & name, wxString & virt_table,
                                      wxString & virt_geometry,
                                      wxString & title, wxString & abstract,
                                      bool isQueryable);
  bool DoRegisterTopoGeoCoverage(wxString & name, wxString & topology,
                                 wxString & title, wxString & abstract,
                                 bool isQueryable, bool isEditable);
  bool DoRegisterTopoNetCoverage(wxString & name, wxString & network,
                                 wxString & title, wxString & abstract,
                                 bool isQueryable, bool isEditable);
  bool ValidateRasterStyle(const char *path, void **blob, int *blob_size);
  bool ValidateRasterStyle(void **blob, int *blob_size, const char *xml);
  bool DoInsertRasterSymbolizer(char *xml);
  bool ValidateVectorStyle(const char *path, void **blob, int *blob_size);
  bool ValidateVectorStyle(void **blob, int *blob_size, const char *xml);
  bool DoInsertVectorSymbolizer(char *xml);
  bool ValidateExternalGraphicResource(const char *path, void **blob,
................................................................................
                            int NumBands, int Compression, int Quality,
                            int TileWidth, int TileHeight,
                            bool NotGeoreferenced, int Srid,
                            double HorzResolution, double VertResolution,
                            wxString NoData, bool StrictResolution,
                            bool MixedResolutions, bool InputPaths, bool MD5,
                            bool Summary, int RedBand, int GreenBand,
                            int BlueBand, int NIRband, bool AutoNDVI,
                            bool isQueryable);
  static void DoubleQuoted(wxString & str);
  bool IsView(wxString & view);
  bool IsWritableView(wxString & view);
  void GetWritableViewPK(wxString & view, wxString & pk_name);

  bool HasFlippedAxes(const char *crs);
  bool BBoxFromLongLat(const char *crs_str, double *minx, double *maxx,
................................................................................
                       double *miny, double *maxy);
  char *GetProjParams(int srid);

  void CreateWmsTables();
  bool IsDefinedWmsGetCapabilities(const char *url);
  bool IsDefinedWmsGetMap(const char *getmap_url, const char *layer_name);
  bool RegisterWmsGetCapabilities(const char *url, const char *title,
                                  const char *abstract);
  bool RegisterWmsGetMap(const char *getcapabilities_url,
                         const char *getmap_url, const char *layer_name,
                         const char *title, const char *abstract,
                         const char *version, const char *ref_sys,
                         const char *image_format, const char *style,
                         int transparent, int flip_axes, int is_queryable,
                         int tiled, int cached, int tile_width, int tile_height,
                         const char *bgcolor, const char *getfeatureinfo);
  bool RegisterWmsSetting(const char *url, const char *layer_name,
                          const char *key, const char *value, int is_default);
  bool RegisterWmsSRS(const char *url, const char *layer_name,
                      const char *ref_sys, double minx, double miny,
                      double maxx, double maxy, int is_default);
  bool TransformWmsBBox(const char *ref_sys, double geoMinX, double geoMinY,
                        double geoMaxX, double geoMaxY, double *minx,
                        double *miny, double *maxx, double *maxy);
  bool UnRegisterWmsGetMap(const char *url, const char *layer);
  void DoRegisterWMS();
  void DoUnRegisterWMS();
  void DoConfigureWMS();
  void DoCreateTopoGeo();
  void DoCreateTopoNet();

  void MapPanelClosing();

  void OnQuit(wxCommandEvent & event);
  void OnClose(wxCloseEvent & event);
  void OnAbout(wxCommandEvent & event);
  void OnConnect(wxCommandEvent & event);
  void OnConnectReadOnly(wxCommandEvent & event);
  void OnCreateNew(wxCommandEvent & event);
  void OnDisconnect(wxCommandEvent & event);
  void OnMemoryDbLoad(wxCommandEvent & event);
  void OnMemoryDbNew(wxCommandEvent & event);
  void OnMemoryDbClock(wxCommandEvent & event);
  void OnMemoryDbSave(wxCommandEvent & event);
  void OnVacuum(wxCommandEvent & event);
  void OnMapPanel(wxCommandEvent & event);
  void OnSqlScript(wxCommandEvent & event);
  void OnQueryViewComposer(wxCommandEvent & event);
  void OnCharset(wxCommandEvent & event);
  void OnLoadShp(wxCommandEvent & event);
  void OnLoadTxt(wxCommandEvent & event);
  void OnLoadDbf(wxCommandEvent & event);
  void OnLoadXL(wxCommandEvent & event);
................................................................................
  double VertResolution;
  wxString NoData;
  bool StrictResolution;
  bool MixedResolutions;
  bool InputPaths;
  bool MD5;
  bool Summary;
  bool Queryable;
  bool IsValidNoData(wxString & no_data, int sample, int num_bands);
public:
    CreateRasterCoverageDialog()
  {;
  }
  bool Create(MyFrame * parent);
  virtual ~ CreateRasterCoverageDialog()
................................................................................
  {
    return MD5;
  }
  bool IsSummary()
  {
    return Summary;
  }
  bool IsQueryable()
  {
    return Queryable;
  }
  void OnSampleChanged(wxCommandEvent & event);
  void OnPixelChanged(wxCommandEvent & event);
  void OnCompressionChanged(wxCommandEvent & event);
  void OnNumBandsChanged(wxCommandEvent & event);
  void OnRedBandChanged(wxCommandEvent & event);
  void OnGreenBandChanged(wxCommandEvent & event);
  void OnBlueBandChanged(wxCommandEvent & event);
................................................................................
  virtual ~ RasterDropDialog()
  {;
  }
  void CreateControls();
  bool DoDropCoverage(void);
  void OnOk(wxCommandEvent & event);
};

class RasterInfosDialog:public wxDialog
{
//
// a dialog for editing Raster Coverage Data
//
private:
  MyFrame * MainFrame;
  wxString CoverageName;
  wxString Title;
  wxString Abstract;
  bool IsQueryable;
  bool DoReadCoverage();
  void DoUpdateCoverage();
public:
    RasterInfosDialog()
  {;
  }
  bool Create(MyFrame * parent, wxString & coverage);
  virtual ~ RasterInfosDialog()
  {;
  }
  void CreateControls();
  void OnOk(wxCommandEvent & event);
  void OnCancel(wxCommandEvent & event);
};

class RasterCoverageStylesDialog:public wxDialog
{
//
// a dialog for handling SLD/SE Raster Coverage's Styles
//
private:
................................................................................
  int GetSelectedCount();
  int GetSelectedStyleId(int idx);
  void OnOk(wxCommandEvent & event);
};

class CandidateVectorCoverage
{
// a candidate Vector Coverage - SpatialTable
private:
  wxString TableName;
  wxString GeometryColumn;
  int Srid;
  wxString GeometryType;
  bool VectorCoverage;
  bool RasterCoverage;
  bool TopoGeo;
  bool TopoNet;
  CandidateVectorCoverage *Next;
public:
    CandidateVectorCoverage(wxString & table, wxString & geometry, int srid,
                            wxString & type)
  {
    TableName = table;
    GeometryColumn = geometry;
    Srid = srid;
    GeometryType = type;
    VectorCoverage = false;
    RasterCoverage = false;
    TopoGeo = false;
    TopoNet = false;
    Next = NULL;
  }
   ~CandidateVectorCoverage()
  {;
  }
  wxString & GetTableName()
  {
................................................................................
  void MarkRasterCoverage()
  {
    RasterCoverage = true;
  }
  bool IsRasterCoverage()
  {
    return RasterCoverage;
  }
  void MarkTopoGeoCoverage()
  {
    TopoGeo = true;
  }
  bool IsTopoGeo()
  {
    return TopoGeo;
  }
  void MarkTopoNetCoverage()
  {
    TopoNet = true;
  }
  bool IsTopoNet()
  {
    return TopoNet;
  }
  CandidateVectorCoverage *GetNext()
  {
    return Next;
  }
  void SetNext(CandidateVectorCoverage * next)
  {
    Next = next;
  }
};

class CandidateVectorCoveragesList
{
// a container for candidate Vector Coverages - SpatialTables
private:
  CandidateVectorCoverage * First;
  CandidateVectorCoverage *Last;
public:
    CandidateVectorCoveragesList()
  {
    First = NULL;
................................................................................
    Last = NULL;
  }
   ~CandidateVectorCoveragesList();
  void Add(wxString & table_name, wxString & geometry, int srid,
           wxString & type);
  void MarkVectorCoverage(wxString & table, wxString & geometry);
  void MarkRasterCoverage(wxString & table, wxString & geometry);
  void MarkTopoGeoCoverage(wxString & table, wxString & geometry);
  void MarkTopoNetCoverage(wxString & table, wxString & geometry);
  CandidateVectorCoverage *GetFirst()
  {
    return First;
  }
};

class VectorRegisterDialog:public wxDialog
{
//
// a dialog for Register Vector Coverage - SpatialTables
//
private:
  MyFrame * MainFrame;
  CandidateVectorCoveragesList *List;
  wxGrid *GridCtrl;
  wxString CoverageName;
  wxString TableName;
  wxString GeometryColumn;
  wxString Title;
  wxString Abstract;
  bool Queryable;
  bool Editable;
public:
    VectorRegisterDialog()
  {
    List = NULL;
  }
  bool Create(MyFrame * parent);
  virtual ~ VectorRegisterDialog()
................................................................................
  {
    return Title;
  }
  wxString & GetAbstract()
  {
    return Abstract;
  }
  bool IsQueryable()
  {
    return Queryable;
  }
  bool IsEditable()
  {
    return Editable;
  }
  void OnOk(wxCommandEvent & event);
};

class CandidateSpatialViewCoverage
{
// a candidate Vector Coverage - SpatialView
private:
  wxString ViewName;
  wxString ViewGeometry;
  int Srid;
  wxString GeometryType;
  bool VectorCoverage;
  CandidateSpatialViewCoverage *Next;
public:
    CandidateSpatialViewCoverage(wxString & view_name, wxString & view_geometry,
                                 int srid, wxString & type)
  {
    ViewName = view_name;
    ViewGeometry = view_geometry;
    Srid = srid;
    GeometryType = type;
    VectorCoverage = false;
    Next = NULL;
  }
   ~CandidateSpatialViewCoverage()
  {;
  }
  wxString & GetViewName()
  {
    return ViewName;
  }
  wxString & GetViewGeometry()
  {
    return ViewGeometry;
  }
  int GetSrid()
  {
    return Srid;
  }
  wxString & GetGeometryType()
  {
    return GeometryType;
  }
  void MarkVectorCoverage()
  {
    VectorCoverage = true;
  }
  bool IsVectorCoverage()
  {
    return VectorCoverage;
  }
  CandidateSpatialViewCoverage *GetNext()
  {
    return Next;
  }
  void SetNext(CandidateSpatialViewCoverage * next)
  {
    Next = next;
  }
};

class CandidateSpatialViewCoveragesList
{
// a container for candidate Vector Coverages - SpatialViews
private:
  CandidateSpatialViewCoverage * First;
  CandidateSpatialViewCoverage *Last;
public:
    CandidateSpatialViewCoveragesList()
  {
    First = NULL;
    Last = NULL;
  }
   ~CandidateSpatialViewCoveragesList();
  void Add(wxString & view_name, wxString & geometry, int srid,
           wxString & type);
  void MarkVectorCoverage(wxString & view, wxString & geometry);
  CandidateSpatialViewCoverage *GetFirst()
  {
    return First;
  }
};

class SpatialViewRegisterDialog:public wxDialog
{
//
// a dialog for Register Vector Coverage - SpatialView
//
private:
  MyFrame * MainFrame;
  CandidateSpatialViewCoveragesList *List;
  wxGrid *GridCtrl;
  wxString CoverageName;
  wxString ViewName;
  wxString ViewGeometry;
  wxString Title;
  wxString Abstract;
  bool Queryable;
  bool Editable;
public:
    SpatialViewRegisterDialog()
  {
    List = NULL;
  }
  bool Create(MyFrame * parent);
  virtual ~ SpatialViewRegisterDialog()
  {
    if (List != NULL)
      delete List;
  }
  void CreateControls();
  wxString & GetCoverageName()
  {
    return CoverageName;
  }
  wxString & GetViewName()
  {
    return ViewName;
  }
  wxString & GetViewGeometry()
  {
    return ViewGeometry;
  }
  wxString & GetTitle()
  {
    return Title;
  }
  wxString & GetAbstract()
  {
    return Abstract;
  }
  bool IsQueryable()
  {
    return Queryable;
  }
  bool IsEditable()
  {
    return Editable;
  }
  void OnOk(wxCommandEvent & event);
};

class CandidateVirtualShapeCoverage
{
// a candidate Vector Coverage - VirtualShape
private:
  wxString VirtName;
  wxString VirtGeometry;
  int Srid;
  wxString GeometryType;
  bool VectorCoverage;
  CandidateVirtualShapeCoverage *Next;
public:
    CandidateVirtualShapeCoverage(wxString & virt_name,
                                  wxString & virt_geometry, int srid,
                                  wxString & type)
  {
    VirtName = virt_name;
    VirtGeometry = virt_geometry;
    Srid = srid;
    GeometryType = type;
    VectorCoverage = false;
    Next = NULL;
  }
   ~CandidateVirtualShapeCoverage()
  {;
  }
  wxString & GetVirtName()
  {
    return VirtName;
  }
  wxString & GetVirtGeometry()
  {
    return VirtGeometry;
  }
  int GetSrid()
  {
    return Srid;
  }
  wxString & GetGeometryType()
  {
    return GeometryType;
  }
  void MarkVectorCoverage()
  {
    VectorCoverage = true;
  }
  bool IsVectorCoverage()
  {
    return VectorCoverage;
  }
  CandidateVirtualShapeCoverage *GetNext()
  {
    return Next;
  }
  void SetNext(CandidateVirtualShapeCoverage * next)
  {
    Next = next;
  }
};

class CandidateVirtualShapeCoveragesList
{
// a container for candidate Vector Coverages - VirtualShape
private:
  CandidateVirtualShapeCoverage * First;
  CandidateVirtualShapeCoverage *Last;
public:
    CandidateVirtualShapeCoveragesList()
  {
    First = NULL;
    Last = NULL;
  }
   ~CandidateVirtualShapeCoveragesList();
  void Add(wxString & view_name, wxString & geometry, int srid,
           wxString & type);
  void MarkVectorCoverage(wxString & view, wxString & geometry);
  CandidateVirtualShapeCoverage *GetFirst()
  {
    return First;
  }
};

class VirtualShapeRegisterDialog:public wxDialog
{
//
// a dialog for Register Vector Coverage - VirtualShape
//
private:
  MyFrame * MainFrame;
  CandidateVirtualShapeCoveragesList *List;
  wxGrid *GridCtrl;
  wxString CoverageName;
  wxString VirtName;
  wxString VirtGeometry;
  wxString Title;
  wxString Abstract;
  bool Queryable;
public:
    VirtualShapeRegisterDialog()
  {
    List = NULL;
  }
  bool Create(MyFrame * parent);
  virtual ~ VirtualShapeRegisterDialog()
  {
    if (List != NULL)
      delete List;
  }
  void CreateControls();
  wxString & GetCoverageName()
  {
    return CoverageName;
  }
  wxString & GetVirtName()
  {
    return VirtName;
  }
  wxString & GetVirtGeometry()
  {
    return VirtGeometry;
  }
  wxString & GetTitle()
  {
    return Title;
  }
  wxString & GetAbstract()
  {
    return Abstract;
  }
  bool IsQueryable()
  {
    return Queryable;
  }
  void OnOk(wxCommandEvent & event);
};

class CandidateTopoGeoCoverage
{
// a candidate TopoGeo Coverage
private:
  wxString TopologyName;
  int Srid;
  wxString Dimensions;
  double Tolerance;
  bool VectorCoverage;
  CandidateTopoGeoCoverage *Next;
public:
    CandidateTopoGeoCoverage(wxString & topology, int srid,
                             wxString & dimensions, double tolerance)
  {
    TopologyName = topology;
    Srid = srid;
    Dimensions = dimensions;
    Tolerance = tolerance;
    VectorCoverage = false;
    Next = NULL;
  }
   ~CandidateTopoGeoCoverage()
  {;
  }
  wxString & GetTopologyName()
  {
    return TopologyName;
  }
  int GetSrid()
  {
    return Srid;
  }
  wxString & GetDimensions()
  {
    return Dimensions;
  }
  double GetTolerance()
  {
    return Tolerance;
  }
  void MarkVectorCoverage()
  {
    VectorCoverage = true;
  }
  bool IsVectorCoverage()
  {
    return VectorCoverage;
  }
  CandidateTopoGeoCoverage *GetNext()
  {
    return Next;
  }
  void SetNext(CandidateTopoGeoCoverage * next)
  {
    Next = next;
  }
};

class CandidateTopoGeoCoveragesList
{
// a container for candidate TopoGeo Coverages
private:
  CandidateTopoGeoCoverage * First;
  CandidateTopoGeoCoverage *Last;
public:
    CandidateTopoGeoCoveragesList()
  {
    First = NULL;
    Last = NULL;
  }
   ~CandidateTopoGeoCoveragesList();
  void Add(wxString & topology, int srid, wxString & dimensions,
           double tolerance);
  void MarkVectorCoverage(wxString & topology);
  CandidateTopoGeoCoverage *GetFirst()
  {
    return First;
  }
};

class TopoGeoRegisterDialog:public wxDialog
{
//
// a dialog for Register TopoGeo Coverage
//
private:
  MyFrame * MainFrame;
  CandidateTopoGeoCoveragesList *List;
  wxGrid *GridCtrl;
  wxString CoverageName;
  wxString TopologyName;
  wxString Title;
  wxString Abstract;
  bool Queryable;
  bool Editable;
public:
    TopoGeoRegisterDialog()
  {
    List = NULL;
  }
  bool Create(MyFrame * parent);
  virtual ~ TopoGeoRegisterDialog()
  {
    if (List != NULL)
      delete List;
  }
  void CreateControls();
  wxString & GetCoverageName()
  {
    return CoverageName;
  }
  wxString & GetTopologyName()
  {
    return TopologyName;
  }
  wxString & GetTitle()
  {
    return Title;
  }
  wxString & GetAbstract()
  {
    return Abstract;
  }
  bool IsQueryable()
  {
    return Queryable;
  }
  bool IsEditable()
  {
    return Editable;
  }
  void OnOk(wxCommandEvent & event);
};

class CandidateTopoNetCoverage
{
// a candidate TopoNet Coverage
private:
  wxString NetworkName;
  int Srid;
  wxString Dimensions;
  bool VectorCoverage;
  CandidateTopoNetCoverage *Next;
public:
    CandidateTopoNetCoverage(wxString & network, int srid,
                             wxString & dimensions)
  {
    NetworkName = network;
    Srid = srid;
    Dimensions = dimensions;
    VectorCoverage = false;
    Next = NULL;
  }
   ~CandidateTopoNetCoverage()
  {;
  }
  wxString & GetNetworkName()
  {
    return NetworkName;
  }
  int GetSrid()
  {
    return Srid;
  }
  wxString & GetDimensions()
  {
    return Dimensions;
  }
  void MarkVectorCoverage()
  {
    VectorCoverage = true;
  }
  bool IsVectorCoverage()
  {
    return VectorCoverage;
  }
  CandidateTopoNetCoverage *GetNext()
  {
    return Next;
  }
  void SetNext(CandidateTopoNetCoverage * next)
  {
    Next = next;
  }
};

class CandidateTopoNetCoveragesList
{
// a container for candidate TopoNet Coverages
private:
  CandidateTopoNetCoverage * First;
  CandidateTopoNetCoverage *Last;
public:
    CandidateTopoNetCoveragesList()
  {
    First = NULL;
    Last = NULL;
  }
   ~CandidateTopoNetCoveragesList();
  void Add(wxString & network, int srid, wxString & dimensions);
  void MarkVectorCoverage(wxString & network);
  CandidateTopoNetCoverage *GetFirst()
  {
    return First;
  }
};

class TopoNetRegisterDialog:public wxDialog
{
//
// a dialog for Register TopoNet Coverage
//
private:
  MyFrame * MainFrame;
  CandidateTopoNetCoveragesList *List;
  wxGrid *GridCtrl;
  wxString CoverageName;
  wxString NetworkName;
  wxString Title;
  wxString Abstract;
  bool Queryable;
  bool Editable;
public:
    TopoNetRegisterDialog()
  {
    List = NULL;
  }
  bool Create(MyFrame * parent);
  virtual ~ TopoNetRegisterDialog()
  {
    if (List != NULL)
      delete List;
  }
  void CreateControls();
  wxString & GetCoverageName()
  {
    return CoverageName;
  }
  wxString & GetNetworkName()
  {
    return NetworkName;
  }
  wxString & GetTitle()
  {
    return Title;
  }
  wxString & GetAbstract()
  {
    return Abstract;
  }
  bool IsQueryable()
  {
    return Queryable;
  }
  bool IsEditable()
  {
    return Editable;
  }
  void OnOk(wxCommandEvent & event);
};

class VectorInfosDialog:public wxDialog
{
//
// a dialog for editing Vector Coverage Data
//
private:
  MyFrame * MainFrame;
  wxString CoverageName;
  wxString Title;
  wxString Abstract;
  bool IsQueryable;
  bool IsEditable;
  bool DoReadCoverage();
  void DoUpdateCoverage();
public:
    VectorInfosDialog()
  {;
  }
  bool Create(MyFrame * parent, wxString & coverage);
  virtual ~ VectorInfosDialog()
  {;
  }
  void CreateControls();
  void OnOk(wxCommandEvent & event);
  void OnCancel(wxCommandEvent & event);
};

class VectorCoverageSRID
{
// a Vector Coverage alternative SRID
private:
  int Srid;
................................................................................
    return wxSize(48, 24);
  }
  void SetGraphic(wxImage * graphic)
  {
    Graphic = graphic;
  }
};

class MyBitmapCellRenderer:public wxGridCellRenderer
{
// a Grid CellRenderer supporting a Bitmap
private:
  wxImage Graphic;
public:
  virtual wxGridCellRenderer * Clone() const
  {
    return new MyBitmapCellRenderer;
  }
  virtual void Draw(wxGrid & grid, wxGridCellAttr & attr, wxDC & dc,
                    const wxRect & rect, int row, int col, bool isSelected);
  virtual wxSize GetBestSize(wxGrid & grid, wxGridCellAttr & attr, wxDC & dc,
                             int row, int col)
  {
    // silencing stupid compiler warnings about unused args
    if (grid.IsEditable() && attr.HasFont() && dc.IsOk())
      {
        if (row == col)
          col = row;
      }

    return wxSize(Graphic.GetWidth(), Graphic.GetHeight());
  }
  void SetGraphic(wxBitmap & graphic)
  {
    Graphic = graphic.ConvertToImage();
  }
};

class MyFontCellRenderer:public wxGridCellRenderer
{
// a Grid CellRenderer supporting a Text Font
private:
  wxImage * FontExample;
public:
................................................................................
  int Opaque;
  int SwapXY;
  int Tiled;
  int TileWidth;
  int TileHeight;
  int Queryable;
  void GetButtonBitmap(const char *color, wxBitmap & bmp);
  void ParseBgColor(const char *color, unsigned char *red, unsigned char *green,
                    unsigned char *blue);
  unsigned char ParseHex(const char *byte);
public:
    WmsConfigDialog()
  {;
  }
  virtual ~ WmsConfigDialog()
  {
    if (Version != NULL)
      free(Version);
    if (MaxVersion != NULL)
      free(MaxVersion);
    if (RefSys != NULL)
      free(RefSys);
    if (Style != NULL)
      free(Style);
    if (ImageFormat != NULL)
      free(ImageFormat);
    if (BgColor != NULL)
      free(BgColor);
  }
  bool Create(MyFrame * parent, wxString url, wxString layer);
  void CreateControls();
  const char *GetVersion()
  {
    return Version;
  }
  const char *GetStyle()
................................................................................
  }
  int GetTileHeight()
  {
    return TileHeight;
  }
  void LoadData();
  void FindMaxVersion();
  void PopulateRefSys(wxComboBox * crsList);
  void PopulateImageFormats(wxComboBox * fmtList);
  void PopulateStyles(wxComboBox * stlList);
  void UpdateSwapXY(void);
  void OnCrsChanged(wxCommandEvent & event);
  void OnVersionChanged(wxCommandEvent & event);
  void OnSwapXYChanged(wxCommandEvent & event);
  void OnTiledChanged(wxCommandEvent & event);
  void OnBgColorEnabledChanged(wxCommandEvent & event);
  void OnBgColorChanged(wxCommandEvent & event);
................................................................................
    DATA_TYPE_MULTIPOINT,
    DATA_TYPE_MULTILINESTRING,
    DATA_TYPE_MULTIPOLYGON,
    DATA_TYPE_GEOMETRYCOLLECTION,
    DATA_TYPE_GEOMETRY
  };
};

class MapLayer
{
//
// a class corresponding to a Map layer 
//
private:
  wxString Name;
  wxString Title;
  wxString Abstract;
  int Type;
  bool Visible;
  MapLayer *Prev;
  MapLayer *Next;
public:
    MapLayer(const char *name, const char *title,
             const char *abstract, int type);
   ~MapLayer()
  {;
  }
  wxString & GetName()
  {
    return Name;
  }
  wxString & GetTitle()
  {
    return Title;
  }
  wxString & GetAbstract()
  {
    return Abstract;
  }
  int GetType()
  {
    return Type;
  }
  bool IsVisible()
  {
    return Visible;
  }
  void Hide()
  {
    Visible = false;
  }
  void Show()
  {
    Visible = true;
  }
  void SetPrev(MapLayer * prev)
  {
    Prev = prev;
  }
  MapLayer *GetPrev()
  {
    return Prev;
  }
  void SetNext(MapLayer * next)
  {
    Next = next;
  }
  MapLayer *GetNext()
  {
    return Next;
  }
};

class MyLayerTree:public wxTreeCtrl
{
//
// a tree-control used for Map Layers
//
private:
  class MyMapPanel * MapPanel;
  bool Changed;
  wxTreeItemId Root;            // the root node
  wxImageList *Images;          // the images list
  wxTreeItemId CurrentItem;     // the tree item holding the current context menu
  wxTreeItemId DraggedItem;     // the tree item to be moved
public:
    MyLayerTree()
  {;
  }
  MyLayerTree(MyMapPanel * parent, wxWindowID id = wxID_ANY);
  virtual ~ MyLayerTree();
  void FlushAll()
  {
    DeleteChildren(Root);
    Changed = true;
  }
  wxTreeItemId & GetRoot()
  {
    return Root;
  }
  void CleanUp();
  void AddLayer(MapLayer * layer);
  void SetLayerIcons();
  void MarkCurrentItem();
  void SelectActiveItem(MapLayer * layer);
  void UpdateDefault(wxTreeItemId item, wxImageList * imageList);
  void OnSelChanged(wxTreeEvent & event);
  void OnItemActivated(wxTreeEvent & event);
  void OnRightClick(wxTreeEvent & event);
  void OnCmdRemoveAll(wxCommandEvent & event);
  void OnCmdShowAll(wxCommandEvent & event);
  void OnCmdHideAll(wxCommandEvent & event);
  void OnCmdVisible(wxCommandEvent & event);
  void OnCmdConfigure(wxCommandEvent & event);
  void OnCmdRemoveLayer(wxCommandEvent & event);
  void OnCmdDeleteItem(wxCommandEvent & event);
  void OnCmdLayerInfo(wxCommandEvent & event);
  void OnDragStart(wxTreeEvent & event);
  void OnDragEnd(wxTreeEvent & event);
};

class MapLayerObject:public wxTreeItemData
{
//
// a class to store TreeItemData - Map Layer wrapper
//
private:
  MapLayer * Layer;
public:
  MapLayerObject(MapLayer * lyr)
  {
    Layer = lyr;
  }
  virtual ~ MapLayerObject()
  {;
  }
  MapLayer *GetLayer()
  {
    return Layer;
  }
};

class MyMapView:public wxPanel
{
//
// a panel used  to show the Map
//
private:
  class MyMapPanel * MapPanel;
  wxBitmap MapBitmap;
  wxBitmap ScreenBitmap;
  int BitmapWidth;
  int BitmapHeight;
  wxCursor CursorCross;
  wxCursor CursorHand;
  bool ValidMap;
  MapLayer *FirstLayer;
  MapLayer *LastLayer;
  MapLayer *ActiveLayer;
public:
    MyMapView()
  {;
  }
  MyMapView(MyMapPanel * parent, wxWindowID id = wxID_ANY);
  virtual ~ MyMapView();
  void Invalidate();
  void PrepareMap();

  void SetActiveMapLayer(MapLayer * layer)
  {
    ActiveLayer = layer;
  }
  bool IsActiveLayer(MapLayer * layer)
  {
    if (ActiveLayer == layer)
      return true;
    return false;
  }
  bool IsValidMap()
  {
    return ValidMap;
  }
  bool CanIdentify();
  void ResetMapLayers();
  void RemoveMapLayer(MapLayer * layer);
  void ReinsertMapLayer(MapLayer * layer);

  void OnEraseBackground(wxEraseEvent & WXUNUSED(event))
  {;
  }
  void OnSize(wxSizeEvent & event);
  void OnPaint(wxPaintEvent & event);
};

class MyMapPanel:public wxFrame
{
//
// the main Map Panel
//
private:
  MyFrame * Parent;
  wxAuiManager Manager;         // the GUI manager
  wxString ConfigLayout;        // PERSISTENCY - the layout configuration
  int ConfigPaneX;              // PERSISTENCY - the map pane screen origin X
  int ConfigPaneY;              // PERSISTENCY - the map pane screen origin Y
  int ConfigPaneWidth;          // PERSISTENCY - the map pane screen width
  int ConfigPaneHeight;         // PERSISTENCY - the map pane screen height
  MyLayerTree *LayerTree;       // the layer tree list
  MyMapView *MapView;           // the map panel
  wxBitmap *BtnAddLayer;        // button icon for adding a Map Layer
  wxBitmap *BtnCenter;          // button icon for Zoom to Full Extent
  wxBitmap *BtnIdentify;        // buttom icon for Identify
  wxBitmap *BtnZoomIn;          // button icon for Zoom In
  wxBitmap *BtnZoomOut;         // buttom icon for Zoom Out
  wxBitmap *BtnUserScale;       // buttom icon for User Scale
  wxBitmap *BtnPan;             // button icon for Pan
  wxBitmap *BtnPrinter;         // button icon for Printer
  wxBitmap *BtnAbout;           // button icon for ABOUT
  wxBitmap *BtnExit;            // button icon for EXIT
  bool IsIdentify;              // current map click is: Identify
  bool IsZoomIn;                // current map click is: ZoomIn
  bool IsZoomOut;               // current map click is: ZoomOut
  bool IsPan;                   // current map click is: Pan
public:
    MyMapPanel(MyFrame * parent, const wxString & title, const wxPoint & pos,
               const wxSize & size);
    virtual ~ MyMapPanel();

  void UpdateTools();
  void ParentQuit();

  void ResetMapLayers()
  {
    MapView->ResetMapLayers();
  }
  void ReinsertMapLayer(MapLayer * layer)
  {
    MapView->ReinsertMapLayer(layer);
  }
  void SetActiveMapLayer(MapLayer * layer)
  {
    MapView->SetActiveMapLayer(layer);
  }
  bool IsActiveLayer(MapLayer * layer)
  {
    return MapView->IsActiveLayer(layer);
  }
  void RemoveMapLayer(MapLayer * layer)
  {
    MapView->RemoveMapLayer(layer);
  }
  void RefreshMap()
  {
    MapView->PrepareMap();
  }
  sqlite3 *GetSqlite()
  {
    return Parent->GetSqlite();
  }

  void OnAddLayer(wxCommandEvent & event);
  void OnCenter(wxCommandEvent & event);
  void OnIdentify(wxCommandEvent & event);
  void OnZoomIn(wxCommandEvent & event);
  void OnZoomOut(wxCommandEvent & event);
  void OnUserScale(wxCommandEvent & event);
  void OnPan(wxCommandEvent & event);
  void OnPrinter(wxCommandEvent & event);
  void OnQuit(wxCommandEvent & event);
  void OnAbout(wxCommandEvent & event);
};

class LayerListItem
{
// a class wrapping a Layer
private:
  wxString DbPrefix;
  wxString LayerPrefix;
  int LayerType;
  wxString LayerName;
  wxString Title;
  wxString Abstract;
  char *f_table_name;
  char *f_geometry_column;
  char *topology_name;
  char *network_name;
  int GeometryType;
  bool HasZ;
  int NativeSrid;
  bool Queryable;
  bool Editable;
  bool SpatialIndex;
  LayerListItem *Next;
public:
    LayerListItem(wxString & db_prefix, int type, wxString & name,
                  wxString & title, wxString & abstract, bool queryable);
    LayerListItem(wxString & db_prefix, wxString & layer_prefix,
                  wxString & name, wxString & title, wxString & abstract,
                  const char *f_table_name, const char *f_geometry_column,
                  int geom_type, int srid, bool queryable, bool editable,
                  bool spatial_index);
    LayerListItem(wxString & db_prefix, int type, wxString & name,
                  wxString & title, wxString & abstract, const char *topo_name,
                  bool has_z, int srid, bool queryable, bool editable);
   ~LayerListItem();
    wxString & GetDbPrefix()
  {
    return DbPrefix;
  }
  wxString & GetLayerPrefix()
  {
    return LayerPrefix;
  }
  int GetLayerType()
  {
    return LayerType;
  }
  wxString & GetLayerName()
  {
    return LayerName;
  }
  wxString & GetTitle()
  {
    return Title;
  }
  wxString & GetAbstract()
  {
    return Abstract;
  }
  const char *GetTableName()
  {
    return f_table_name;
  }
  const char *GetGeometryColumn()
  {
    return f_geometry_column;
  }
  const char *GetTopologyName()
  {
    return topology_name;
  }
  const char *GetNetworkName()
  {
    return network_name;
  }
  int GetGeometryType()
  {
    return GeometryType;
  }
  bool GetHasZ()
  {
    return HasZ;
  }
  int GetSrid()
  {
    return NativeSrid;
  }
  bool IsQueryable()
  {
    return Queryable;
  }
  bool IsEditable()
  {
    return Editable;
  }
  bool HasSpatialIndex()
  {
    return SpatialIndex;
  }
  void SetNext(LayerListItem * next)
  {
    Next = next;
  }
  LayerListItem *GetNext()
  {
    return Next;
  }
};

class AddMapLayerDialog:public wxDialog
{
//
// a Dialog for adding a Map Layer
//
private:
  MyMapPanel * MapPanel;
  LayerListItem *First;
  LayerListItem *Last;
  wxGrid *Layers;
  void FlushList();
  void AddLayer2List(wxString & db_prefix, int layer_type, wxString & name,
                     wxString & title, wxString & abstract, bool queryable);
  void AddLayer2List(wxString & db_prefix, wxString & layer_prefix,
                     wxString & name, wxString & title, wxString & abstract,
                     const char *f_table_name, const char *f_geometry_column,
                     int geom_type, int srid, bool queryable, bool editable,
                     bool spatial_index);
  void AddLayer2List(wxString & db_prefix, int type, wxString & name,
                     wxString & title, wxString & abstract,
                     const char *topo_name, bool has_z, int srid,
                     bool queryable, bool editable);
  void DoLoadVectorCoverages();
  void DoLoadTopoGeoCoverages();
  void DoLoadTopoNetCoverages();
  void DoLoadRasterCoverages();
  void DoLoadWmsCoverages();
  char *QueryVectorCoverages(const char *db_prefix, const char *old_sql);
  char *QuerySpatialViewCoverages(const char *db_prefix, const char *old_sql);
  char *QueryVirtualShapeCoverages(const char *db_prefix, const char *old_sql);
  char *QueryTopoGeoCoverages(const char *db_prefix, const char *old_sql);
  char *QueryTopoNetCoverages(const char *db_prefix, const char *old_sql);
  char *QueryRasterCoverages(const char *db_prefix, const char *old_sql);
  char *QueryWmsCoverages(const char *db_prefix, const char *old_sql);
  bool DoCheckGeometryColumns(const char *db_prefix);
  bool DoCheckViewsGeometryColumns(const char *db_prefix);
  bool DoCheckVirtsGeometryColumns(const char *db_prefix);
  bool DoCheckTopologies(const char *db_prefix);
  bool DoCheckNetworks(const char *db_prefix);
  bool DoCheckVectorCoverages(const char *db_prefix);
  bool DoCheckTopoGeoCoverages(const char *db_prefix);
  bool DoCheckTopoNetCoverages(const char *db_prefix);
  bool DoCheckRasterCoverages(const char *db_prefix);
  bool DoCheckWmsCoverages(const char *db_prefix);
public:
    AddMapLayerDialog()
  {
    MapPanel = NULL;
    First = NULL;
    Last = NULL;
  }
  AddMapLayerDialog(MyMapPanel * parent)
  {
    Create(parent);
  }
  bool Create(MyMapPanel * parent);
  virtual ~ AddMapLayerDialog()
  {
    FlushList();
  }
  void CreateControls();

  void OnOk(wxCommandEvent & event);
  void OnCancel(wxCommandEvent & event);
};

#include "icons/attach.xpm"
#include "icons/sql_log.xpm"
#include "icons/db_status.xpm"
#include "icons/checkgeom.xpm"
#include "icons/sanegeom.xpm"
#include "icons/wfs.xpm"
#include "icons/dxf.xpm"

#include "icons/security_lock.xpm"
#include "icons/security_relaxed.xpm"
#include "icons/security_rdonly.xpm"


#if defined(_WIN32) && !defined(__MINGW32__)
#define unlink	_unlink
................................................................................
//
// main GUI frame constructor
//
  setlocale(LC_ALL, "");
// forcing DECIMAL POINT IS COMMA
  setlocale(LC_NUMERIC, "C");


  Old_SPATIALITE_SECURITY_ENV = NULL;
  RL2MaxThreads = 1;
  wxImage::AddHandler(new wxPNGHandler);
  MemoryDatabase = false;
  AutoSaveInterval = 0;
  LastTotalChanges = 0;
  TimerAutoSave = NULL;
................................................................................
  BtnAttach = new wxBitmap(attach_xpm);
  BtnSqlLog = new wxBitmap(sql_log_xpm);
  BtnDbStatus = new wxBitmap(db_status_xpm);
  BtnCheckGeom = new wxBitmap(checkgeom_xpm);
  BtnSaneGeom = new wxBitmap(sanegeom_xpm);
  BtnWFS = new wxBitmap(wfs_xpm);
  BtnDXF = new wxBitmap(dxf_xpm);


//
// setting up the application icon
//      
  wxIcon MyIcon(icon_xpm);
  SetIcon(MyIcon);

................................................................................
  menuItem->SetBitmap(*BtnDisconnect);
  menuFile->Append(menuItem);
  menuItem =
    new wxMenuItem(menuFile, ID_Vacuum,
                   wxT("&Optimizing current SQLite DB [VACUUM]"));
  menuItem->SetBitmap(*BtnVacuum);
  menuFile->Append(menuItem);








  menuFile->AppendSeparator();
  wxMenu *advancedMenu = new wxMenu();
  menuItem =
    new wxMenuItem(advancedMenu, ID_SqlScript, wxT("&Execute SQL script"));
  menuItem->SetBitmap(*BtnSqlScript);
  advancedMenu->Append(menuItem);
  advancedMenu->AppendSeparator();
................................................................................
  menuItem->SetBitmap(*BtnSrids);
  advancedMenu->Append(menuItem);
  menuItem =
    new wxMenuItem(advancedMenu, ID_Charset, wxT("&Default Output Charset"));
  menuItem->SetBitmap(*BtnCharset);
  advancedMenu->Append(menuItem);
  menuFile->AppendSubMenu(advancedMenu, wxT("&Advanced"));
  menuFile->AppendSeparator();
  menuItem = new wxMenuItem(menuFile, ID_Attach, wxT("&Attach DataBase"));
  menuItem->SetBitmap(*BtnAttach);
  menuFile->Append(menuItem);
  menuFile->AppendSeparator();
  menuItem =
    new wxMenuItem(menuFile, ID_SqlLog, wxT("&SQL Log"), wxT("&SQL Log"),
                   wxITEM_CHECK);
  menuFile->Append(menuItem);
  menuItem = new wxMenuItem(menuFile, ID_DbStatus, wxT("&DB Status"));
  menuFile->Append(menuItem);
................................................................................
  menuItem->SetBitmap(*BtnAbout);
  menuFile->Append(menuItem);
  menuFile->AppendSeparator();
  menuItem = new wxMenuItem(menuFile, wxID_EXIT, wxT("&Quit"));
  menuItem->SetBitmap(*BtnExit);
  menuFile->Append(menuItem);
  wxMenuBar *menuBar = new wxMenuBar;
  menuBar->Append(menuFile, wxT("&Files"));
  SetMenuBar(menuBar);

//
// setting up menu initial state 
//
  menuBar->Enable(ID_Disconnect, false);
  menuBar->Enable(ID_MemoryDbClock, false);
  menuBar->Enable(ID_MemoryDbSave, false);
  menuBar->Enable(ID_Vacuum, false);

  menuBar->Enable(ID_SqlScript, false);
  menuBar->Enable(ID_QueryViewComposer, false);
  menuBar->Enable(ID_LoadShp, false);
  menuBar->Enable(ID_VirtualShp, false);
  menuBar->Enable(ID_LoadTxt, false);
  menuBar->Enable(ID_VirtualTxt, false);
  menuBar->Enable(ID_LoadDbf, false);
................................................................................
                   wxT("Saving the current MEMORY-DB"));
  toolBar->AddTool(ID_Disconnect, wxT("Disconnecting current SQLite DB"),
                   *BtnDisconnect, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Disconnecting current SQLite DB"));
  toolBar->AddTool(ID_Vacuum, wxT("Optimizing current SQLite DB [VACUUM]"),
                   *BtnVacuum, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Optimizing current SQLite DB [VACUUM]"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_Attach, wxT("Attach DataBase"),
                   *BtnAttach, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Attach DataBase"));
  //toolBar->AddSeparator();

  toolBar->AddTool(ID_SqlLog, wxT("SQL Log"),
                   *BtnSqlLog, wxNullBitmap, wxITEM_CHECK, wxT("SQL Log"));
  toolBar->AddTool(ID_DbStatus, wxT("DB Status"),
                   *BtnDbStatus, wxNullBitmap, wxITEM_NORMAL, wxT("DB Status"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_CheckGeom, wxT("Check Geometries"),
                   *BtnCheckGeom, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Check Geometries"));
  toolBar->AddTool(ID_SaneGeom, wxT("Sanitize Geometries"), *BtnSaneGeom,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Sanitize Geometries"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_SqlScript, wxT("Execute SQL script"), *BtnSqlScript,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Execute SQL script"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_QueryViewComposer, wxT("Query/View Composer"),
                   *BtnQueryComposer, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Query/View Composer"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_LoadShp, wxT("Load Shapefile"), *BtnLoadShp, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Load Shapefile"));
  toolBar->AddTool(ID_VirtualShp, wxT("Virtual Shapefile"), *BtnVirtualShp,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Virtual Shapefile"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_LoadTxt, wxT("Load CSV/TXT"), *BtnLoadTxt, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Load CSV/TXT"));
  toolBar->AddTool(ID_VirtualTxt, wxT("Virtual CSV/TXT"), *BtnVirtualTxt,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Virtual CSV/TXT"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_LoadDbf, wxT("Load DBF"), *BtnLoadDbf, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Load DBF"));
  toolBar->AddTool(ID_VirtualDbf, wxT("Virtual DBF"), *BtnVirtualDbf,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Virtual DBF"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_LoadXL, wxT("Load XLS"), *BtnLoadXL, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Load XLS"));
  toolBar->AddTool(ID_VirtualXL, wxT("Virtual XLS"), *BtnVirtualXL,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Virtual XLS"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_Network, wxT("Build Network"), *BtnNetwork, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Build Network"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_Exif, wxT("Import EXIF photos"), *BtnExif, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Import EXIF photos"));
  toolBar->AddTool(ID_GpsPics, wxT("Import GPS photos"), *BtnGpsPics,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Import GPS photos"));
  toolBar->AddTool(ID_LoadXml, wxT("Import XML Documents"), *BtnLoadXml,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Import XML Documents"));
  toolBar->AddTool(ID_WFS, wxT("Import data from WFS datasource"), *BtnWFS,
                   wxNullBitmap, wxITEM_NORMAL,
                   wxT("Import data from WFS datasource"));
  toolBar->AddTool(ID_DXF, wxT("Import DXF drawings"), *BtnDXF, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Import DXF drawings"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_Srids, wxT("Search SRID by name"), *BtnSrids,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Search SRID by name"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_Charset, wxT("Default Output Charset"), *BtnCharset,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Default Output Charset"));
  //toolBar->AddSeparator();
  toolBar->AddTool(ID_Help, wxT("Help"), *BtnHelp, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Help"));
  toolBar->AddTool(wxID_ABOUT, wxT("About ..."), *BtnAbout, wxNullBitmap,
                   wxITEM_NORMAL, wxT("About ..."));
  //toolBar->AddSeparator();
  toolBar->AddTool(wxID_EXIT, wxT("Quit"), *BtnExit, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Quit"));
  toolBar->Realize();
  SetToolBar(toolBar);

//
// setting up the toolbar initial state
//
  toolBar->EnableTool(ID_Disconnect, false);
  toolBar->EnableTool(ID_MemoryDbClock, false);
  toolBar->EnableTool(ID_MemoryDbSave, false);
  toolBar->EnableTool(ID_Vacuum, false);

  toolBar->EnableTool(ID_SqlScript, false);
  toolBar->EnableTool(ID_QueryViewComposer, false);
  toolBar->EnableTool(ID_LoadShp, false);
  toolBar->EnableTool(ID_VirtualShp, false);
  toolBar->EnableTool(ID_LoadTxt, false);
  toolBar->EnableTool(ID_VirtualTxt, false);
  toolBar->EnableTool(ID_LoadDbf, false);
................................................................................
          (wxObjectEventFunction) & MyFrame::OnMemoryDbNew);
  Connect(ID_MemoryDbClock, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnMemoryDbClock);
  Connect(ID_MemoryDbSave, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnMemoryDbSave);
  Connect(ID_Vacuum, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnVacuum);


  Connect(ID_SqlScript, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnSqlScript);
  Connect(ID_QueryViewComposer, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnQueryViewComposer);
  Connect(ID_LoadShp, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnLoadShp);
  Connect(ID_VirtualShp, wxEVT_COMMAND_MENU_SELECTED,
................................................................................
          (wxObjectEventFunction) & MyFrame::OnSanitizeGeometries);
  Connect(ID_Help, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnHelp);
  Connect(wxID_ABOUT, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnAbout);
  Connect(wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnQuit);


  Connect(wxID_ANY, wxEVT_MOTION, wxMouseEventHandler(MyFrame::OnMouseMove),
          NULL, this);

//
// setting up event handlers for mouse
//
  TableTree->Connect(wxID_ANY, wxEVT_MOTION,
................................................................................
}

MyFrame::~MyFrame()
{
//
// main GUI frame destructor
//


  if (TimerAutoSave)
    {
      TimerAutoSave->Stop();
      delete TimerAutoSave;
    }
  LastDitchMemoryDbSave();
  ConfigLayout = Manager.SavePerspective();
................................................................................
  if (SqliteHandle)
    sqlite3_close(SqliteHandle);
  if (SpliteInternalCache)
    spatialite_cleanup_ex(SpliteInternalCache);
  spatialite_shutdown();
  SaveConfig();
  Manager.UnInit();


  if (BtnConnect != NULL)
    delete BtnConnect;
  if (BtnConnectReadOnly != NULL)
    delete BtnConnectReadOnly;
  if (BtnCreateNew != NULL)
    delete BtnCreateNew;
  if (BtnDisconnect != NULL)
................................................................................
    delete BtnMemDbNew;
  if (BtnMemDbClock != NULL)
    delete BtnMemDbClock;
  if (BtnMemDbSave != NULL)
    delete BtnMemDbSave;
  if (BtnVacuum != NULL)
    delete BtnVacuum;


  if (BtnSqlScript != NULL)
    delete BtnSqlScript;
  if (BtnQueryComposer != NULL)
    delete BtnQueryComposer;
  if (BtnLoadShp != NULL)
    delete BtnLoadShp;
  if (BtnVirtualShp != NULL)
................................................................................
}

void MyFrame::SaveConfig()
{
//
// saves layout configuration
//

  wxConfig *config = new wxConfig(wxT("SpatialiteGui"));
  config->Write(wxT("Layout"), ConfigLayout);
  config->Write(wxT("PaneX"), ConfigPaneX);
  config->Write(wxT("PaneY"), ConfigPaneY);
  config->Write(wxT("PaneWidth"), ConfigPaneWidth);
  config->Write(wxT("PaneHeight"), ConfigPaneHeight);
  config->Write(wxT("SqlitePath"), SqlitePath);
................................................................................
            {
              menuBar->Enable(ID_MemoryDbSave, false);
              menuBar->Enable(ID_MemoryDbClock, false);
            }
          menuBar->Enable(ID_CreateNew, false);
          menuBar->Enable(ID_Disconnect, true);
          menuBar->Enable(ID_Vacuum, true);

          menuBar->Enable(ID_SqlScript, true);
          menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
          menuBar->Enable(ID_LoadShp, true);
          menuBar->Enable(ID_VirtualShp, true);
          menuBar->Enable(ID_LoadTxt, true);
          menuBar->Enable(ID_VirtualTxt, true);
          menuBar->Enable(ID_LoadDbf, true);
................................................................................
            {
              toolBar->EnableTool(ID_MemoryDbSave, false);
              toolBar->EnableTool(ID_MemoryDbClock, false);
            }
          toolBar->EnableTool(ID_CreateNew, false);
          toolBar->EnableTool(ID_Disconnect, true);
          toolBar->EnableTool(ID_Vacuum, true);

          toolBar->EnableTool(ID_SqlScript, true);
          toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
          toolBar->EnableTool(ID_LoadShp, true);
          toolBar->EnableTool(ID_VirtualShp, true);
          toolBar->EnableTool(ID_LoadTxt, true);
          toolBar->EnableTool(ID_VirtualTxt, true);
          toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
}

void MyFrame::OnQuit(wxCommandEvent & WXUNUSED(event))
{
//
// EXIT - event handler
//
  CloseDB();
  Close(true);
}












void MyFrame::OnAttachDatabase(wxCommandEvent & WXUNUSED(event))
{
//
// Attach Database - event handler
//
  int ret;
................................................................................
              menuBar->Enable(ID_MemoryDbClock, true);
          } else
            {
              menuBar->Enable(ID_MemoryDbSave, false);
              menuBar->Enable(ID_MemoryDbClock, false);
            }
          menuBar->Enable(ID_Vacuum, true);

          menuBar->Enable(ID_SqlScript, true);
          menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
          menuBar->Enable(ID_LoadShp, true);
          menuBar->Enable(ID_VirtualShp, true);
          menuBar->Enable(ID_LoadTxt, true);
          menuBar->Enable(ID_VirtualTxt, true);
          menuBar->Enable(ID_LoadDbf, true);
................................................................................
              toolBar->EnableTool(ID_MemoryDbClock, true);
          } else
            {
              toolBar->EnableTool(ID_MemoryDbSave, false);
              toolBar->EnableTool(ID_MemoryDbClock, false);
            }
          toolBar->EnableTool(ID_Vacuum, true);

          toolBar->EnableTool(ID_SqlScript, true);
          toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
          toolBar->EnableTool(ID_LoadShp, true);
          toolBar->EnableTool(ID_VirtualShp, true);
          toolBar->EnableTool(ID_LoadTxt, true);
          toolBar->EnableTool(ID_VirtualTxt, true);
          toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
      mode2 = false;
      mode3 = false;
    }

  wxMenuBar *menuBar = GetMenuBar();
  menuBar->Enable(ID_Disconnect, mode);
  menuBar->Enable(ID_Vacuum, mode);

  menuBar->Enable(ID_SqlScript, mode);
  menuBar->Enable(ID_QueryViewComposer, mode2);
  menuBar->Enable(ID_LoadShp, mode);
  menuBar->Enable(ID_VirtualShp, mode);
  menuBar->Enable(ID_LoadTxt, mode);
  menuBar->Enable(ID_VirtualTxt, mode);
  menuBar->Enable(ID_LoadDbf, mode);
................................................................................
  menuBar->Enable(ID_SqlLog, mode);
  menuBar->Enable(ID_DbStatus, mode);
  menuBar->Enable(ID_CheckGeom, mode);
  menuBar->Enable(ID_SaneGeom, mode);
  wxToolBar *toolBar = GetToolBar();
  toolBar->EnableTool(ID_Disconnect, mode);
  toolBar->EnableTool(ID_Vacuum, mode);

  toolBar->EnableTool(ID_SqlScript, mode);
  toolBar->EnableTool(ID_QueryViewComposer, mode2);
  toolBar->EnableTool(ID_LoadShp, mode);
  toolBar->EnableTool(ID_VirtualShp, mode);
  toolBar->EnableTool(ID_LoadTxt, mode);
  toolBar->EnableTool(ID_VirtualTxt, mode);
  toolBar->EnableTool(ID_LoadDbf, mode);
................................................................................
              menuBar->Enable(ID_MemoryDbClock, true);
          } else
            {
              menuBar->Enable(ID_MemoryDbSave, false);
              menuBar->Enable(ID_MemoryDbClock, false);
            }
          menuBar->Enable(ID_Vacuum, true);

          menuBar->Enable(ID_SqlScript, true);
          menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
          menuBar->Enable(ID_LoadShp, true);
          menuBar->Enable(ID_VirtualShp, true);
          menuBar->Enable(ID_LoadTxt, true);
          menuBar->Enable(ID_VirtualTxt, true);
          menuBar->Enable(ID_LoadDbf, true);
................................................................................
              toolBar->EnableTool(ID_MemoryDbClock, true);
          } else
            {
              toolBar->EnableTool(ID_MemoryDbSave, false);
              toolBar->EnableTool(ID_MemoryDbClock, false);
            }
          toolBar->EnableTool(ID_Vacuum, true);

          toolBar->EnableTool(ID_SqlScript, true);
          toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
          toolBar->EnableTool(ID_LoadShp, true);
          toolBar->EnableTool(ID_VirtualShp, true);
          toolBar->EnableTool(ID_LoadTxt, true);
          toolBar->EnableTool(ID_VirtualTxt, true);
          toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
  menuBar->Enable(ID_CreateNew, true);
  menuBar->Enable(ID_Disconnect, false);
  menuBar->Enable(ID_MemoryDbLoad, true);
  menuBar->Enable(ID_MemoryDbNew, true);
  menuBar->Enable(ID_MemoryDbSave, false);
  menuBar->Enable(ID_MemoryDbClock, false);
  menuBar->Enable(ID_Vacuum, false);

  menuBar->Enable(ID_SqlScript, false);
  menuBar->Enable(ID_QueryViewComposer, false);
  menuBar->Enable(ID_LoadShp, false);
  menuBar->Enable(ID_VirtualShp, false);
  menuBar->Enable(ID_LoadTxt, false);
  menuBar->Enable(ID_VirtualTxt, false);
  menuBar->Enable(ID_LoadDbf, false);
................................................................................
  toolBar->EnableTool(ID_CreateNew, true);
  toolBar->EnableTool(ID_Disconnect, false);
  toolBar->EnableTool(ID_MemoryDbLoad, true);
  toolBar->EnableTool(ID_MemoryDbNew, true);
  toolBar->EnableTool(ID_MemoryDbSave, false);
  toolBar->EnableTool(ID_MemoryDbClock, false);
  toolBar->EnableTool(ID_Vacuum, false);

  toolBar->EnableTool(ID_SqlScript, false);
  toolBar->EnableTool(ID_QueryViewComposer, false);
  toolBar->EnableTool(ID_LoadShp, false);
  toolBar->EnableTool(ID_VirtualShp, false);
  toolBar->EnableTool(ID_LoadTxt, false);
  toolBar->EnableTool(ID_VirtualTxt, false);
  toolBar->EnableTool(ID_LoadDbf, false);
................................................................................
      menuBar->Enable(ID_CreateNew, false);
      menuBar->Enable(ID_Disconnect, true);
      menuBar->Enable(ID_MemoryDbLoad, false);
      menuBar->Enable(ID_MemoryDbNew, false);
      menuBar->Enable(ID_MemoryDbSave, false);
      menuBar->Enable(ID_MemoryDbClock, false);
      menuBar->Enable(ID_Vacuum, true);

      menuBar->Enable(ID_SqlScript, true);
      menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
      menuBar->Enable(ID_LoadShp, true);
      menuBar->Enable(ID_VirtualShp, true);
      menuBar->Enable(ID_LoadTxt, true);
      menuBar->Enable(ID_VirtualTxt, true);
      menuBar->Enable(ID_LoadDbf, true);
................................................................................
      toolBar->EnableTool(ID_CreateNew, false);
      toolBar->EnableTool(ID_Disconnect, true);
      toolBar->EnableTool(ID_MemoryDbLoad, false);
      toolBar->EnableTool(ID_MemoryDbNew, false);
      toolBar->EnableTool(ID_MemoryDbSave, false);
      toolBar->EnableTool(ID_MemoryDbClock, false);
      toolBar->EnableTool(ID_Vacuum, true);

      toolBar->EnableTool(ID_SqlScript, true);
      toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
      toolBar->EnableTool(ID_LoadShp, true);
      toolBar->EnableTool(ID_VirtualShp, true);
      toolBar->EnableTool(ID_LoadTxt, true);
      toolBar->EnableTool(ID_VirtualTxt, true);
      toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
          menuBar->Enable(ID_MemoryDbClock, true);
      } else
        {
          menuBar->Enable(ID_MemoryDbSave, false);
          menuBar->Enable(ID_MemoryDbClock, false);
        }
      menuBar->Enable(ID_Vacuum, true);

      menuBar->Enable(ID_SqlScript, true);
      menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
      menuBar->Enable(ID_LoadShp, true);
      menuBar->Enable(ID_VirtualShp, true);
      menuBar->Enable(ID_LoadTxt, true);
      menuBar->Enable(ID_VirtualTxt, true);
      menuBar->Enable(ID_LoadDbf, true);
................................................................................
          toolBar->EnableTool(ID_MemoryDbClock, true);
      } else
        {
          toolBar->EnableTool(ID_MemoryDbSave, false);
          toolBar->EnableTool(ID_MemoryDbClock, false);
        }
      toolBar->EnableTool(ID_Vacuum, true);

      toolBar->EnableTool(ID_SqlScript, true);
      toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
      toolBar->EnableTool(ID_LoadShp, true);
      toolBar->EnableTool(ID_VirtualShp, true);
      toolBar->EnableTool(ID_LoadTxt, true);
      toolBar->EnableTool(ID_VirtualTxt, true);
      toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
  menuBar->Enable(ID_CreateNew, false);
  menuBar->Enable(ID_Disconnect, true);
  menuBar->Enable(ID_MemoryDbLoad, false);
  menuBar->Enable(ID_MemoryDbNew, false);
  menuBar->Enable(ID_MemoryDbSave, true);
  menuBar->Enable(ID_MemoryDbClock, true);
  menuBar->Enable(ID_Vacuum, true);

  menuBar->Enable(ID_SqlScript, true);
  menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
  menuBar->Enable(ID_LoadShp, true);
  menuBar->Enable(ID_VirtualShp, true);
  menuBar->Enable(ID_LoadTxt, true);
  menuBar->Enable(ID_VirtualTxt, true);
  menuBar->Enable(ID_LoadDbf, true);
................................................................................
  toolBar->EnableTool(ID_CreateNew, false);
  toolBar->EnableTool(ID_Disconnect, true);
  toolBar->EnableTool(ID_MemoryDbLoad, false);
  toolBar->EnableTool(ID_MemoryDbNew, false);
  toolBar->EnableTool(ID_MemoryDbSave, true);
  toolBar->EnableTool(ID_MemoryDbClock, true);
  toolBar->EnableTool(ID_Vacuum, true);

  toolBar->EnableTool(ID_SqlScript, true);
  toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
  toolBar->EnableTool(ID_LoadShp, true);
  toolBar->EnableTool(ID_VirtualShp, true);
  toolBar->EnableTool(ID_LoadTxt, true);
  toolBar->EnableTool(ID_VirtualTxt, true);
  toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
                  totalPages - totalPages2);
          msg += wxString::FromUTF8(dummy);
        }
      wxMessageBox(msg, wxT("spatialite_gui"), wxOK | wxICON_INFORMATION, this);
    }
  ::wxEndBusyCursor();
}











































char *MyFrame::ReadSqlLine(FILE * in, int *len, int *eof)
{
//
// reading an SQL script line
//
  int c;
................................................................................
                                   int Quality, int TileWidth, int TileHeight,
                                   bool NotGeoreferenced, int Srid,
                                   double HorzResolution, double VertResolution,
                                   wxString NoData, bool StrictResolution,
                                   bool MixedResolutions, bool InputPaths,
                                   bool MD5, bool Summary, int RedBand,
                                   int GreenBand, int BlueBand, int NIRband,
                                   bool AutoNDVI)
{
//
// actual creation of a Raster Coverage 
//
  int ret;
  const char *sql;
  char *errMsg = NULL;
................................................................................
  sqlite3_stmt *stmt = NULL;
  char *err_msg = NULL;
  int strict_resolution = 0;
  int mixed_resolutions = 0;
  int section_paths = 0;
  int section_md5 = 0;
  int section_summary = 0;

  rl2PalettePtr palette = NULL;
  rl2PixelPtr no_data = NULL;
  bool retval = false;
  char *dummy;

// starting a transaction 
  ret = sqlite3_exec(SqliteHandle, "BEGIN", NULL, NULL, &errMsg);
................................................................................
    mixed_resolutions = 1;
  if (InputPaths)
    section_paths = 1;
  if (MD5)
    section_md5 = 1;
  if (Summary)
    section_summary = 1;



  if (rl2_create_dbms_coverage
      (SqliteHandle, CoverageName.ToUTF8(), SampleType, PixelType, NumBands,
       Compression, Quality, TileWidth, TileHeight, Srid, HorzResolution,
       VertResolution, no_data, palette, strict_resolution, mixed_resolutions,
       section_paths, section_md5, section_summary) != RL2_OK)
    {
      wxMessageBox(wxT("ERROR: unable to create Raster Coverage ") +
                   CoverageName, wxT("spatialite_gui"), wxOK | wxICON_ERROR,
                   this);
      return false;
    }
  if (PixelType == RL2_PIXEL_MULTIBAND)
................................................................................
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("BEGIN error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
// just in case, attempting to (re)create raster meta-tables
  ret =
    sqlite3_exec(SqliteHandle, "SELECT CreateStylingTables()", NULL,
                 NULL, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("CreateStylingTables() error: ") +
                   wxString::FromUTF8(errMsg), wxT("spatialite_gui"),
................................................................................
  sql += dbAlias2 + wxT("\".geometry_columns WHERE spatial_index_enabled = 1");
  xsql = (char *) malloc((sql.Len() * 4) + 1);
  strcpy(xsql, sql.ToUTF8());
  int ret = sqlite3_get_table(SqliteHandle, xsql, &results,
                              &rows, &columns, &errMsg);
  free(xsql);
  if (ret != SQLITE_OK)



    return false;

  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          name = results[(i * columns) + 0];
................................................................................
            }
        }
      sqlite3_free_table(results);
    }
  if (ExistsVectorCoverages())
    {
      // fetching Vector Coverages
      sql =
        wxT("SELECT c.coverage_name, g.srid FROM main.vector_coverages AS c ");
      sql += wxT("JOIN geometry_columns AS g ON (");
      sql += wxT("Lower(c.f_table_name) = Lower(g.f_table_name) AND ");
      sql += wxT("Lower(c.f_geometry_column) = Lower(g.f_geometry_column))");
















      xsql = (char *) malloc((sql.Len() * 4) + 1);
      strcpy(xsql, sql.ToUTF8());
      int ret = sqlite3_get_table(SqliteHandle, xsql, &results,
                                  &rows, &columns, &errMsg);
      free(xsql);
      if (ret != SQLITE_OK)
        {
................................................................................
      if (rows < 1)
        ;
      else
        {
          for (i = 1; i <= rows; i++)
            {
              // adding some Vector Coverage

              const char *name = results[(i * columns) + 0];
              int srid = atoi(results[(i * columns) + 1]);

              VectorCoverageSet coverage(name, srid);
              TableTree->AddVectorCoverage(&coverage);
            }
        }
      sqlite3_free_table(results);
    }
// fetching persistent tables and views
  sql =
................................................................................
  wxTreeItemId rootTopologies =
    TableTree->AppendItem(db, wxT("Topology-Geometry"));
  wxTreeItemId rootNetworks =
    TableTree->AppendItem(db, wxT("Topology-Network"));
  wxTreeItemId rootRasterCoverages =
    TableTree->AppendItem(db, wxT("Raster Coverages"));
  wxTreeItemId rootVectorCoverages =
    TableTree->AppendItem(db, wxT("VectorRaster Coverages"));
  wxTreeItemId rootWMS =
    TableTree->AppendItem(db, wxT("Registered WMS layers"));
  wxTreeItemId rootMetadata = TableTree->AppendItem(db, wxT("Metadata"));
  wxTreeItemId rootInternal = TableTree->AppendItem(db, wxT("Internal Data"));
  wxTreeItemId rootSpatialIndex =
    TableTree->AppendItem(db, wxT("Spatial Index"));
  TableTree->SetItemImage(rootUserData, 17);
................................................................................
  TableTree->SetItemImage(rootVectorCoverages, 24);
  TableTree->SetItemImage(rootWMS, 26);
  TableTree->SetItemImage(rootStyling, 17);
  TableTree->SetItemImage(rootIsoMetadata, 17);
  TableTree->SetItemImage(rootMetadata, 17);
  TableTree->SetItemImage(rootInternal, 17);
  TableTree->SetItemImage(rootSpatialIndex, 17);














  RootNodes nodes =
    RootNodes(dbAlias, rootUserData, rootTopologies, rootNetworks,
              rootRasterCoverages, rootVectorCoverages, rootStyling, rootWMS,
              rootIsoMetadata, rootMetadata, rootInternal, rootSpatialIndex);
  if (ExistsTopologies(dbAlias))
    {
      // fetching topologies
................................................................................
              // adding some Topology
              const char *name = results[(i * columns) + 0];
              int srid = atoi(results[(i * columns) + 1]);
              bool hasZ = false;
              if (atoi(results[(i * columns) + 2]))
                hasZ = true;
              TopoGeoSet topology(dbAlias.ToUTF8(), name, srid, hasZ);
              TableTree->AddAltTopology(rootTopologies, &topology);
            }
        }
      sqlite3_free_table(results);
    }
  if (ExistsNetworks(dbAlias))
    {
      // fetching topologies
................................................................................
              if (atoi(results[(i * columns) + 1]))
                spatial = true;
              int srid = atoi(results[(i * columns) + 2]);
              bool hasZ = false;
              if (atoi(results[(i * columns) + 3]))
                hasZ = true;
              TopoNetSet network(name, spatial, srid, hasZ);
              TableTree->AddAltNetwork(rootNetworks, &network);
            }
        }
      sqlite3_free_table(results);
    }
  if (ExistsRasterCoverages(dbAlias))
    {
      // fetching Raster Coverages
................................................................................
        {
          for (i = 1; i <= rows; i++)
            {
              // adding some Raster Coverage
              const char *name = results[(i * columns) + 0];
              int srid = atoi(results[(i * columns) + 1]);
              RasterCoverageSet coverage(name, srid);
              TableTree->AddAltRasterCoverage(rootRasterCoverages, &coverage);

            }
        }
      sqlite3_free_table(results);
    }
  if (ExistsVectorCoverages(dbAlias))
    {
      // fetching Vector Coverages
      wxString dbAlias2 = dbAlias;
      DoubleQuoted(dbAlias2);
      sql =
        wxT("SELECT c.coverage_name, g.srid FROM \"") + dbAlias2 +
        wxT("\".vector_coverages AS c ");
      sql += wxT("JOIN ") + dbAlias2 + wxT(".geometry_columns AS g ON (");
      sql += wxT("Lower(c.f_table_name) = Lower(g.f_table_name) AND ");
      sql += wxT("Lower(c.f_geometry_column) = Lower(g.f_geometry_column))");




















      xsql = (char *) malloc((sql.Len() * 4) + 1);
      strcpy(xsql, sql.ToUTF8());
      int ret = sqlite3_get_table(SqliteHandle, xsql, &results,
                                  &rows, &columns, &errMsg);
      free(xsql);
      if (ret != SQLITE_OK)
        {
................................................................................
      if (rows < 1)
        ;
      else
        {
          for (i = 1; i <= rows; i++)
            {
              // adding some Vector Coverage

              const char *name = results[(i * columns) + 0];
              int srid = atoi(results[(i * columns) + 1]);

              VectorCoverageSet coverage(name, srid);
              TableTree->AddAltVectorCoverage(rootVectorCoverages, &coverage);

            }
        }
      sqlite3_free_table(results);
    }
// fetching tables and views
  sql = wxT("SELECT name, sql, type FROM \"");
  wxString dbAlias2 = dbAlias;

#include "icons/attach.xpm"
#include "icons/sql_log.xpm"
#include "icons/db_status.xpm"
#include "icons/checkgeom.xpm"
#include "icons/sanegeom.xpm"
#include "icons/wfs.xpm"
#include "icons/dxf.xpm"
#include "icons/map_go.xpm"
#include "icons/security_lock.xpm"
#include "icons/security_relaxed.xpm"
#include "icons/security_rdonly.xpm"


#if defined(_WIN32) && !defined(__MINGW32__)
#define unlink	_unlink
................................................................................
//
// main GUI frame constructor
//
  setlocale(LC_ALL, "");
// forcing DECIMAL POINT IS COMMA
  setlocale(LC_NUMERIC, "C");

  MapPanel = NULL;
  Old_SPATIALITE_SECURITY_ENV = NULL;
  RL2MaxThreads = 1;
  wxImage::AddHandler(new wxPNGHandler);
  MemoryDatabase = false;
  AutoSaveInterval = 0;
  LastTotalChanges = 0;
  TimerAutoSave = NULL;
................................................................................
  BtnAttach = new wxBitmap(attach_xpm);
  BtnSqlLog = new wxBitmap(sql_log_xpm);
  BtnDbStatus = new wxBitmap(db_status_xpm);
  BtnCheckGeom = new wxBitmap(checkgeom_xpm);
  BtnSaneGeom = new wxBitmap(sanegeom_xpm);
  BtnWFS = new wxBitmap(wfs_xpm);
  BtnDXF = new wxBitmap(dxf_xpm);
  BtnMap = new wxBitmap(map_go_xpm);

//
// setting up the application icon
//      
  wxIcon MyIcon(icon_xpm);
  SetIcon(MyIcon);

................................................................................
  menuItem->SetBitmap(*BtnDisconnect);
  menuFile->Append(menuItem);
  menuItem =
    new wxMenuItem(menuFile, ID_Vacuum,
                   wxT("&Optimizing current SQLite DB [VACUUM]"));
  menuItem->SetBitmap(*BtnVacuum);
  menuFile->Append(menuItem);
  menuItem = new wxMenuItem(menuFile, ID_Attach, wxT("&Attach DataBase"));
  menuItem->SetBitmap(*BtnAttach);
  menuFile->Append(menuItem);
  menuFile->AppendSeparator();
  menuItem =
    new wxMenuItem(menuFile, ID_MapPanel, wxT("Map &Panel"), wxT("Map &Panel"),
                   wxITEM_CHECK);
  menuFile->Append(menuItem);
  menuFile->AppendSeparator();
  wxMenu *advancedMenu = new wxMenu();
  menuItem =
    new wxMenuItem(advancedMenu, ID_SqlScript, wxT("&Execute SQL script"));
  menuItem->SetBitmap(*BtnSqlScript);
  advancedMenu->Append(menuItem);
  advancedMenu->AppendSeparator();
................................................................................
  menuItem->SetBitmap(*BtnSrids);
  advancedMenu->Append(menuItem);
  menuItem =
    new wxMenuItem(advancedMenu, ID_Charset, wxT("&Default Output Charset"));
  menuItem->SetBitmap(*BtnCharset);
  advancedMenu->Append(menuItem);
  menuFile->AppendSubMenu(advancedMenu, wxT("&Advanced"));




  menuFile->AppendSeparator();
  menuItem =
    new wxMenuItem(menuFile, ID_SqlLog, wxT("&SQL Log"), wxT("&SQL Log"),
                   wxITEM_CHECK);
  menuFile->Append(menuItem);
  menuItem = new wxMenuItem(menuFile, ID_DbStatus, wxT("&DB Status"));
  menuFile->Append(menuItem);
................................................................................
  menuItem->SetBitmap(*BtnAbout);
  menuFile->Append(menuItem);
  menuFile->AppendSeparator();
  menuItem = new wxMenuItem(menuFile, wxID_EXIT, wxT("&Quit"));
  menuItem->SetBitmap(*BtnExit);
  menuFile->Append(menuItem);
  wxMenuBar *menuBar = new wxMenuBar;
  menuBar->Append(menuFile, wxT("&Menu"));
  SetMenuBar(menuBar);

//
// setting up menu initial state 
//
  menuBar->Enable(ID_Disconnect, false);
  menuBar->Enable(ID_MemoryDbClock, false);
  menuBar->Enable(ID_MemoryDbSave, false);
  menuBar->Enable(ID_Vacuum, false);
  menuBar->Enable(ID_MapPanel, false);
  menuBar->Enable(ID_SqlScript, false);
  menuBar->Enable(ID_QueryViewComposer, false);
  menuBar->Enable(ID_LoadShp, false);
  menuBar->Enable(ID_VirtualShp, false);
  menuBar->Enable(ID_LoadTxt, false);
  menuBar->Enable(ID_VirtualTxt, false);
  menuBar->Enable(ID_LoadDbf, false);
................................................................................
                   wxT("Saving the current MEMORY-DB"));
  toolBar->AddTool(ID_Disconnect, wxT("Disconnecting current SQLite DB"),
                   *BtnDisconnect, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Disconnecting current SQLite DB"));
  toolBar->AddTool(ID_Vacuum, wxT("Optimizing current SQLite DB [VACUUM]"),
                   *BtnVacuum, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Optimizing current SQLite DB [VACUUM]"));

  toolBar->AddTool(ID_Attach, wxT("Attach DataBase"),
                   *BtnAttach, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Attach DataBase"));
  toolBar->AddTool(ID_MapPanel, wxT("Map Panel"),
                   *BtnMap, wxNullBitmap, wxITEM_CHECK, wxT("Map Panel"));
  toolBar->AddTool(ID_SqlLog, wxT("SQL Log"),
                   *BtnSqlLog, wxNullBitmap, wxITEM_CHECK, wxT("SQL Log"));
  toolBar->AddTool(ID_DbStatus, wxT("DB Status"),
                   *BtnDbStatus, wxNullBitmap, wxITEM_NORMAL, wxT("DB Status"));

  toolBar->AddTool(ID_CheckGeom, wxT("Check Geometries"),
                   *BtnCheckGeom, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Check Geometries"));
  toolBar->AddTool(ID_SaneGeom, wxT("Sanitize Geometries"), *BtnSaneGeom,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Sanitize Geometries"));

  toolBar->AddTool(ID_SqlScript, wxT("Execute SQL script"), *BtnSqlScript,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Execute SQL script"));

  toolBar->AddTool(ID_QueryViewComposer, wxT("Query/View Composer"),
                   *BtnQueryComposer, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Query/View Composer"));

  toolBar->AddTool(ID_LoadShp, wxT("Load Shapefile"), *BtnLoadShp, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Load Shapefile"));
  toolBar->AddTool(ID_VirtualShp, wxT("Virtual Shapefile"), *BtnVirtualShp,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Virtual Shapefile"));

  toolBar->AddTool(ID_LoadTxt, wxT("Load CSV/TXT"), *BtnLoadTxt, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Load CSV/TXT"));
  toolBar->AddTool(ID_VirtualTxt, wxT("Virtual CSV/TXT"), *BtnVirtualTxt,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Virtual CSV/TXT"));

  toolBar->AddTool(ID_LoadDbf, wxT("Load DBF"), *BtnLoadDbf, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Load DBF"));
  toolBar->AddTool(ID_VirtualDbf, wxT("Virtual DBF"), *BtnVirtualDbf,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Virtual DBF"));

  toolBar->AddTool(ID_LoadXL, wxT("Load XLS"), *BtnLoadXL, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Load XLS"));
  toolBar->AddTool(ID_VirtualXL, wxT("Virtual XLS"), *BtnVirtualXL,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Virtual XLS"));

  toolBar->AddTool(ID_Network, wxT("Build Network"), *BtnNetwork, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Build Network"));

  toolBar->AddTool(ID_Exif, wxT("Import EXIF photos"), *BtnExif, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Import EXIF photos"));
  toolBar->AddTool(ID_GpsPics, wxT("Import GPS photos"), *BtnGpsPics,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Import GPS photos"));
  toolBar->AddTool(ID_LoadXml, wxT("Import XML Documents"), *BtnLoadXml,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Import XML Documents"));
  toolBar->AddTool(ID_WFS, wxT("Import data from WFS datasource"), *BtnWFS,
                   wxNullBitmap, wxITEM_NORMAL,
                   wxT("Import data from WFS datasource"));
  toolBar->AddTool(ID_DXF, wxT("Import DXF drawings"), *BtnDXF, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Import DXF drawings"));

  toolBar->AddTool(ID_Srids, wxT("Search SRID by name"), *BtnSrids,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Search SRID by name"));

  toolBar->AddTool(ID_Charset, wxT("Default Output Charset"), *BtnCharset,
                   wxNullBitmap, wxITEM_NORMAL, wxT("Default Output Charset"));

  toolBar->AddTool(ID_Help, wxT("Help"), *BtnHelp, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Help"));
  toolBar->AddTool(wxID_ABOUT, wxT("About ..."), *BtnAbout, wxNullBitmap,
                   wxITEM_NORMAL, wxT("About ..."));

  toolBar->AddTool(wxID_EXIT, wxT("Quit"), *BtnExit, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Quit"));
  toolBar->Realize();
  SetToolBar(toolBar);

//
// setting up the toolbar initial state
//
  toolBar->EnableTool(ID_Disconnect, false);
  toolBar->EnableTool(ID_MemoryDbClock, false);
  toolBar->EnableTool(ID_MemoryDbSave, false);
  toolBar->EnableTool(ID_Vacuum, false);
  toolBar->EnableTool(ID_MapPanel, false);
  toolBar->EnableTool(ID_SqlScript, false);
  toolBar->EnableTool(ID_QueryViewComposer, false);
  toolBar->EnableTool(ID_LoadShp, false);
  toolBar->EnableTool(ID_VirtualShp, false);
  toolBar->EnableTool(ID_LoadTxt, false);
  toolBar->EnableTool(ID_VirtualTxt, false);
  toolBar->EnableTool(ID_LoadDbf, false);
................................................................................
          (wxObjectEventFunction) & MyFrame::OnMemoryDbNew);
  Connect(ID_MemoryDbClock, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnMemoryDbClock);
  Connect(ID_MemoryDbSave, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnMemoryDbSave);
  Connect(ID_Vacuum, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnVacuum);
  Connect(ID_MapPanel, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnMapPanel);
  Connect(ID_SqlScript, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnSqlScript);
  Connect(ID_QueryViewComposer, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnQueryViewComposer);
  Connect(ID_LoadShp, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnLoadShp);
  Connect(ID_VirtualShp, wxEVT_COMMAND_MENU_SELECTED,
................................................................................
          (wxObjectEventFunction) & MyFrame::OnSanitizeGeometries);
  Connect(ID_Help, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnHelp);
  Connect(wxID_ABOUT, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnAbout);
  Connect(wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyFrame::OnQuit);
  Connect(wxID_ANY, wxEVT_CLOSE_WINDOW,
          (wxObjectEventFunction) & MyFrame::OnClose);
  Connect(wxID_ANY, wxEVT_MOTION, wxMouseEventHandler(MyFrame::OnMouseMove),
          NULL, this);

//
// setting up event handlers for mouse
//
  TableTree->Connect(wxID_ANY, wxEVT_MOTION,
................................................................................
}

MyFrame::~MyFrame()
{
//
// main GUI frame destructor
//
  if (MapPanel != NULL)
    MapPanel->ParentQuit();
  if (TimerAutoSave)
    {
      TimerAutoSave->Stop();
      delete TimerAutoSave;
    }
  LastDitchMemoryDbSave();
  ConfigLayout = Manager.SavePerspective();
................................................................................
  if (SqliteHandle)
    sqlite3_close(SqliteHandle);
  if (SpliteInternalCache)
    spatialite_cleanup_ex(SpliteInternalCache);
  spatialite_shutdown();
  SaveConfig();
  Manager.UnInit();
  if (MapPanel != NULL)
    MapPanel->ParentQuit();
  if (BtnConnect != NULL)
    delete BtnConnect;
  if (BtnConnectReadOnly != NULL)
    delete BtnConnectReadOnly;
  if (BtnCreateNew != NULL)
    delete BtnCreateNew;
  if (BtnDisconnect != NULL)
................................................................................
    delete BtnMemDbNew;
  if (BtnMemDbClock != NULL)
    delete BtnMemDbClock;
  if (BtnMemDbSave != NULL)
    delete BtnMemDbSave;
  if (BtnVacuum != NULL)
    delete BtnVacuum;
  if (BtnMap != NULL)
    delete BtnMap;
  if (BtnSqlScript != NULL)
    delete BtnSqlScript;
  if (BtnQueryComposer != NULL)
    delete BtnQueryComposer;
  if (BtnLoadShp != NULL)
    delete BtnLoadShp;
  if (BtnVirtualShp != NULL)
................................................................................
}

void MyFrame::SaveConfig()
{
//
// saves layout configuration
//

  wxConfig *config = new wxConfig(wxT("SpatialiteGui"));
  config->Write(wxT("Layout"), ConfigLayout);
  config->Write(wxT("PaneX"), ConfigPaneX);
  config->Write(wxT("PaneY"), ConfigPaneY);
  config->Write(wxT("PaneWidth"), ConfigPaneWidth);
  config->Write(wxT("PaneHeight"), ConfigPaneHeight);
  config->Write(wxT("SqlitePath"), SqlitePath);
................................................................................
            {
              menuBar->Enable(ID_MemoryDbSave, false);
              menuBar->Enable(ID_MemoryDbClock, false);
            }
          menuBar->Enable(ID_CreateNew, false);
          menuBar->Enable(ID_Disconnect, true);
          menuBar->Enable(ID_Vacuum, true);
          menuBar->Enable(ID_MapPanel, true);
          menuBar->Enable(ID_SqlScript, true);
          menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
          menuBar->Enable(ID_LoadShp, true);
          menuBar->Enable(ID_VirtualShp, true);
          menuBar->Enable(ID_LoadTxt, true);
          menuBar->Enable(ID_VirtualTxt, true);
          menuBar->Enable(ID_LoadDbf, true);
................................................................................
            {
              toolBar->EnableTool(ID_MemoryDbSave, false);
              toolBar->EnableTool(ID_MemoryDbClock, false);
            }
          toolBar->EnableTool(ID_CreateNew, false);
          toolBar->EnableTool(ID_Disconnect, true);
          toolBar->EnableTool(ID_Vacuum, true);
          toolBar->EnableTool(ID_MapPanel, true);
          toolBar->EnableTool(ID_SqlScript, true);
          toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
          toolBar->EnableTool(ID_LoadShp, true);
          toolBar->EnableTool(ID_VirtualShp, true);
          toolBar->EnableTool(ID_LoadTxt, true);
          toolBar->EnableTool(ID_VirtualTxt, true);
          toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
}

void MyFrame::OnQuit(wxCommandEvent & WXUNUSED(event))
{
//
// EXIT - event handler
//

  Close(true);
}

void MyFrame::OnClose(wxCloseEvent & event)
{
//
// immedtiately before closing the main window
//
  wxString db_path = SqlitePath;
  CloseDB();
  SqlitePath = db_path;
  Destroy();
}

void MyFrame::OnAttachDatabase(wxCommandEvent & WXUNUSED(event))
{
//
// Attach Database - event handler
//
  int ret;
................................................................................
              menuBar->Enable(ID_MemoryDbClock, true);
          } else
            {
              menuBar->Enable(ID_MemoryDbSave, false);
              menuBar->Enable(ID_MemoryDbClock, false);
            }
          menuBar->Enable(ID_Vacuum, true);
          menuBar->Enable(ID_MapPanel, true);
          menuBar->Enable(ID_SqlScript, true);
          menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
          menuBar->Enable(ID_LoadShp, true);
          menuBar->Enable(ID_VirtualShp, true);
          menuBar->Enable(ID_LoadTxt, true);
          menuBar->Enable(ID_VirtualTxt, true);
          menuBar->Enable(ID_LoadDbf, true);
................................................................................
              toolBar->EnableTool(ID_MemoryDbClock, true);
          } else
            {
              toolBar->EnableTool(ID_MemoryDbSave, false);
              toolBar->EnableTool(ID_MemoryDbClock, false);
            }
          toolBar->EnableTool(ID_Vacuum, true);
          toolBar->EnableTool(ID_MapPanel, true);
          toolBar->EnableTool(ID_SqlScript, true);
          toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
          toolBar->EnableTool(ID_LoadShp, true);
          toolBar->EnableTool(ID_VirtualShp, true);
          toolBar->EnableTool(ID_LoadTxt, true);
          toolBar->EnableTool(ID_VirtualTxt, true);
          toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
      mode2 = false;
      mode3 = false;
    }

  wxMenuBar *menuBar = GetMenuBar();
  menuBar->Enable(ID_Disconnect, mode);
  menuBar->Enable(ID_Vacuum, mode);
  menuBar->Enable(ID_MapPanel, mode);
  menuBar->Enable(ID_SqlScript, mode);
  menuBar->Enable(ID_QueryViewComposer, mode2);
  menuBar->Enable(ID_LoadShp, mode);
  menuBar->Enable(ID_VirtualShp, mode);
  menuBar->Enable(ID_LoadTxt, mode);
  menuBar->Enable(ID_VirtualTxt, mode);
  menuBar->Enable(ID_LoadDbf, mode);
................................................................................
  menuBar->Enable(ID_SqlLog, mode);
  menuBar->Enable(ID_DbStatus, mode);
  menuBar->Enable(ID_CheckGeom, mode);
  menuBar->Enable(ID_SaneGeom, mode);
  wxToolBar *toolBar = GetToolBar();
  toolBar->EnableTool(ID_Disconnect, mode);
  toolBar->EnableTool(ID_Vacuum, mode);
  toolBar->EnableTool(ID_MapPanel, mode);
  toolBar->EnableTool(ID_SqlScript, mode);
  toolBar->EnableTool(ID_QueryViewComposer, mode2);
  toolBar->EnableTool(ID_LoadShp, mode);
  toolBar->EnableTool(ID_VirtualShp, mode);
  toolBar->EnableTool(ID_LoadTxt, mode);
  toolBar->EnableTool(ID_VirtualTxt, mode);
  toolBar->EnableTool(ID_LoadDbf, mode);
................................................................................
              menuBar->Enable(ID_MemoryDbClock, true);
          } else
            {
              menuBar->Enable(ID_MemoryDbSave, false);
              menuBar->Enable(ID_MemoryDbClock, false);
            }
          menuBar->Enable(ID_Vacuum, true);
          menuBar->Enable(ID_MapPanel, true);
          menuBar->Enable(ID_SqlScript, true);
          menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
          menuBar->Enable(ID_LoadShp, true);
          menuBar->Enable(ID_VirtualShp, true);
          menuBar->Enable(ID_LoadTxt, true);
          menuBar->Enable(ID_VirtualTxt, true);
          menuBar->Enable(ID_LoadDbf, true);
................................................................................
              toolBar->EnableTool(ID_MemoryDbClock, true);
          } else
            {
              toolBar->EnableTool(ID_MemoryDbSave, false);
              toolBar->EnableTool(ID_MemoryDbClock, false);
            }
          toolBar->EnableTool(ID_Vacuum, true);
          toolBar->EnableTool(ID_MapPanel, true);
          toolBar->EnableTool(ID_SqlScript, true);
          toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
          toolBar->EnableTool(ID_LoadShp, true);
          toolBar->EnableTool(ID_VirtualShp, true);
          toolBar->EnableTool(ID_LoadTxt, true);
          toolBar->EnableTool(ID_VirtualTxt, true);
          toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
  menuBar->Enable(ID_CreateNew, true);
  menuBar->Enable(ID_Disconnect, false);
  menuBar->Enable(ID_MemoryDbLoad, true);
  menuBar->Enable(ID_MemoryDbNew, true);
  menuBar->Enable(ID_MemoryDbSave, false);
  menuBar->Enable(ID_MemoryDbClock, false);
  menuBar->Enable(ID_Vacuum, false);
  menuBar->Enable(ID_MapPanel, false);
  menuBar->Enable(ID_SqlScript, false);
  menuBar->Enable(ID_QueryViewComposer, false);
  menuBar->Enable(ID_LoadShp, false);
  menuBar->Enable(ID_VirtualShp, false);
  menuBar->Enable(ID_LoadTxt, false);
  menuBar->Enable(ID_VirtualTxt, false);
  menuBar->Enable(ID_LoadDbf, false);
................................................................................
  toolBar->EnableTool(ID_CreateNew, true);
  toolBar->EnableTool(ID_Disconnect, false);
  toolBar->EnableTool(ID_MemoryDbLoad, true);
  toolBar->EnableTool(ID_MemoryDbNew, true);
  toolBar->EnableTool(ID_MemoryDbSave, false);
  toolBar->EnableTool(ID_MemoryDbClock, false);
  toolBar->EnableTool(ID_Vacuum, false);
  toolBar->EnableTool(ID_MapPanel, false);
  toolBar->EnableTool(ID_SqlScript, false);
  toolBar->EnableTool(ID_QueryViewComposer, false);
  toolBar->EnableTool(ID_LoadShp, false);
  toolBar->EnableTool(ID_VirtualShp, false);
  toolBar->EnableTool(ID_LoadTxt, false);
  toolBar->EnableTool(ID_VirtualTxt, false);
  toolBar->EnableTool(ID_LoadDbf, false);
................................................................................
      menuBar->Enable(ID_CreateNew, false);
      menuBar->Enable(ID_Disconnect, true);
      menuBar->Enable(ID_MemoryDbLoad, false);
      menuBar->Enable(ID_MemoryDbNew, false);
      menuBar->Enable(ID_MemoryDbSave, false);
      menuBar->Enable(ID_MemoryDbClock, false);
      menuBar->Enable(ID_Vacuum, true);
      menuBar->Enable(ID_MapPanel, true);
      menuBar->Enable(ID_SqlScript, true);
      menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
      menuBar->Enable(ID_LoadShp, true);
      menuBar->Enable(ID_VirtualShp, true);
      menuBar->Enable(ID_LoadTxt, true);
      menuBar->Enable(ID_VirtualTxt, true);
      menuBar->Enable(ID_LoadDbf, true);
................................................................................
      toolBar->EnableTool(ID_CreateNew, false);
      toolBar->EnableTool(ID_Disconnect, true);
      toolBar->EnableTool(ID_MemoryDbLoad, false);
      toolBar->EnableTool(ID_MemoryDbNew, false);
      toolBar->EnableTool(ID_MemoryDbSave, false);
      toolBar->EnableTool(ID_MemoryDbClock, false);
      toolBar->EnableTool(ID_Vacuum, true);
      toolBar->EnableTool(ID_MapPanel, true);
      toolBar->EnableTool(ID_SqlScript, true);
      toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
      toolBar->EnableTool(ID_LoadShp, true);
      toolBar->EnableTool(ID_VirtualShp, true);
      toolBar->EnableTool(ID_LoadTxt, true);
      toolBar->EnableTool(ID_VirtualTxt, true);
      toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
          menuBar->Enable(ID_MemoryDbClock, true);
      } else
        {
          menuBar->Enable(ID_MemoryDbSave, false);
          menuBar->Enable(ID_MemoryDbClock, false);
        }
      menuBar->Enable(ID_Vacuum, true);
      menuBar->Enable(ID_MapPanel, true);
      menuBar->Enable(ID_SqlScript, true);
      menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
      menuBar->Enable(ID_LoadShp, true);
      menuBar->Enable(ID_VirtualShp, true);
      menuBar->Enable(ID_LoadTxt, true);
      menuBar->Enable(ID_VirtualTxt, true);
      menuBar->Enable(ID_LoadDbf, true);
................................................................................
          toolBar->EnableTool(ID_MemoryDbClock, true);
      } else
        {
          toolBar->EnableTool(ID_MemoryDbSave, false);
          toolBar->EnableTool(ID_MemoryDbClock, false);
        }
      toolBar->EnableTool(ID_Vacuum, true);
      toolBar->EnableTool(ID_MapPanel, true);
      toolBar->EnableTool(ID_SqlScript, true);
      toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
      toolBar->EnableTool(ID_LoadShp, true);
      toolBar->EnableTool(ID_VirtualShp, true);
      toolBar->EnableTool(ID_LoadTxt, true);
      toolBar->EnableTool(ID_VirtualTxt, true);
      toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
  menuBar->Enable(ID_CreateNew, false);
  menuBar->Enable(ID_Disconnect, true);
  menuBar->Enable(ID_MemoryDbLoad, false);
  menuBar->Enable(ID_MemoryDbNew, false);
  menuBar->Enable(ID_MemoryDbSave, true);
  menuBar->Enable(ID_MemoryDbClock, true);
  menuBar->Enable(ID_Vacuum, true);
  menuBar->Enable(ID_MapPanel, true);
  menuBar->Enable(ID_SqlScript, true);
  menuBar->Enable(ID_QueryViewComposer, HasViewsMetadata());
  menuBar->Enable(ID_LoadShp, true);
  menuBar->Enable(ID_VirtualShp, true);
  menuBar->Enable(ID_LoadTxt, true);
  menuBar->Enable(ID_VirtualTxt, true);
  menuBar->Enable(ID_LoadDbf, true);
................................................................................
  toolBar->EnableTool(ID_CreateNew, false);
  toolBar->EnableTool(ID_Disconnect, true);
  toolBar->EnableTool(ID_MemoryDbLoad, false);
  toolBar->EnableTool(ID_MemoryDbNew, false);
  toolBar->EnableTool(ID_MemoryDbSave, true);
  toolBar->EnableTool(ID_MemoryDbClock, true);
  toolBar->EnableTool(ID_Vacuum, true);
  toolBar->EnableTool(ID_MapPanel, true);
  toolBar->EnableTool(ID_SqlScript, true);
  toolBar->EnableTool(ID_QueryViewComposer, HasViewsMetadata());
  toolBar->EnableTool(ID_LoadShp, true);
  toolBar->EnableTool(ID_VirtualShp, true);
  toolBar->EnableTool(ID_LoadTxt, true);
  toolBar->EnableTool(ID_VirtualTxt, true);
  toolBar->EnableTool(ID_LoadDbf, true);
................................................................................
                  totalPages - totalPages2);
          msg += wxString::FromUTF8(dummy);
        }
      wxMessageBox(msg, wxT("spatialite_gui"), wxOK | wxICON_INFORMATION, this);
    }
  ::wxEndBusyCursor();
}

void MyFrame::MapPanelClosing()
{
//
// the Map Panel is closing
//
  MapPanel = NULL;
  wxMenuBar *menuBar = GetMenuBar();
  wxToolBar *toolBar = GetToolBar();
  menuBar->Check(ID_MapPanel, false);
  toolBar->ToggleTool(ID_MapPanel, false);
}

void MyFrame::OnMapPanel(wxCommandEvent & WXUNUSED(event))
{
//
// Opening / Closing the Map Panel
//
  if (MapPanel == NULL)
    {
      // opening the Map Panel
      MapPanel = new MyMapPanel(this, wxT("SpatiaLiteMap"),
                                wxPoint(0, 0), wxSize(640, 480));
      MapPanel->Show(true);
  } else
    {
      // closing the Map Panel
      MapPanel->Show(false);
      MapPanel->Close(true);
    }
  wxMenuBar *menuBar = GetMenuBar();
  wxToolBar *toolBar = GetToolBar();
  if (MapPanel == NULL)
    {
      menuBar->Check(ID_MapPanel, false);
      toolBar->ToggleTool(ID_MapPanel, false);
  } else
    {
      menuBar->Check(ID_MapPanel, true);
      toolBar->ToggleTool(ID_MapPanel, true);
    }
}

char *MyFrame::ReadSqlLine(FILE * in, int *len, int *eof)
{
//
// reading an SQL script line
//
  int c;
................................................................................
                                   int Quality, int TileWidth, int TileHeight,
                                   bool NotGeoreferenced, int Srid,
                                   double HorzResolution, double VertResolution,
                                   wxString NoData, bool StrictResolution,
                                   bool MixedResolutions, bool InputPaths,
                                   bool MD5, bool Summary, int RedBand,
                                   int GreenBand, int BlueBand, int NIRband,
                                   bool AutoNDVI, bool isQueryable)
{
//
// actual creation of a Raster Coverage 
//
  int ret;
  const char *sql;
  char *errMsg = NULL;
................................................................................
  sqlite3_stmt *stmt = NULL;
  char *err_msg = NULL;
  int strict_resolution = 0;
  int mixed_resolutions = 0;
  int section_paths = 0;
  int section_md5 = 0;
  int section_summary = 0;
  int queryable = 0;
  rl2PalettePtr palette = NULL;
  rl2PixelPtr no_data = NULL;
  bool retval = false;
  char *dummy;

// starting a transaction 
  ret = sqlite3_exec(SqliteHandle, "BEGIN", NULL, NULL, &errMsg);
................................................................................
    mixed_resolutions = 1;
  if (InputPaths)
    section_paths = 1;
  if (MD5)
    section_md5 = 1;
  if (Summary)
    section_summary = 1;
  if (isQueryable)
    queryable = 1;

  if (rl2_create_dbms_coverage
      (SqliteHandle, CoverageName.ToUTF8(), SampleType, PixelType, NumBands,
       Compression, Quality, TileWidth, TileHeight, Srid, HorzResolution,
       VertResolution, no_data, palette, strict_resolution, mixed_resolutions,
       section_paths, section_md5, section_summary, queryable) != RL2_OK)
    {
      wxMessageBox(wxT("ERROR: unable to create Raster Coverage ") +
                   CoverageName, wxT("spatialite_gui"), wxOK | wxICON_ERROR,
                   this);
      return false;
    }
  if (PixelType == RL2_PIXEL_MULTIBAND)
................................................................................
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("BEGIN error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
// just in case, attempting to (re)create styling meta-tables
  ret =
    sqlite3_exec(SqliteHandle, "SELECT CreateStylingTables()", NULL,
                 NULL, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("CreateStylingTables() error: ") +
                   wxString::FromUTF8(errMsg), wxT("spatialite_gui"),
................................................................................
  sql += dbAlias2 + wxT("\".geometry_columns WHERE spatial_index_enabled = 1");
  xsql = (char *) malloc((sql.Len() * 4) + 1);
  strcpy(xsql, sql.ToUTF8());
  int ret = sqlite3_get_table(SqliteHandle, xsql, &results,
                              &rows, &columns, &errMsg);
  free(xsql);
  if (ret != SQLITE_OK)
    {
      if (results != NULL)
        sqlite3_free_table(results);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          name = results[(i * columns) + 0];
................................................................................
            }
        }
      sqlite3_free_table(results);
    }
  if (ExistsVectorCoverages())
    {
      // fetching Vector Coverages
      sql = wxT("SELECT 'table', c.coverage_name, g.srid, g.geometry_type ");
      sql += wxT("FROM main.vector_coverages AS c ");
      sql += wxT("JOIN main.geometry_columns AS g ON (");
      sql += wxT("Lower(c.f_table_name) = Lower(g.f_table_name) AND ");
      sql += wxT("Lower(c.f_geometry_column) = Lower(g.f_geometry_column)) ");
      sql += wxT("UNION ");
      sql += wxT("SELECT 'view', c.coverage_name, g.srid, g.geometry_type ");
      sql += wxT("FROM main.vector_coverages AS c ");
      sql += wxT("JOIN main.views_geometry_columns AS v ON ");
      sql += wxT("(Lower(c.view_name) = Lower(v.view_name) AND ");
      sql += wxT("Lower(c.view_geometry) = Lower(v.view_geometry)) ");
      sql += wxT("JOIN main.geometry_columns AS g ON ");
      sql += wxT("(Lower(v.f_table_name) = Lower(g.f_table_name) AND ");
      sql += wxT("Lower(v.f_geometry_column) = Lower(g.f_geometry_column)) ");
      sql += wxT("UNION ");
      sql += wxT("SELECT 'shp', c.coverage_name, v.srid, v.geometry_type ");
      sql += wxT("FROM main.vector_coverages AS c ");
      sql += wxT("JOIN main.virts_geometry_columns AS v ON ");
      sql += wxT("(Lower(c.virt_name) = Lower(v.virt_name) AND ");
      sql += wxT("Lower(c.virt_geometry) = Lower(v.virt_geometry)) ");
      sql += wxT("ORDER BY 2");
      xsql = (char *) malloc((sql.Len() * 4) + 1);
      strcpy(xsql, sql.ToUTF8());
      int ret = sqlite3_get_table(SqliteHandle, xsql, &results,
                                  &rows, &columns, &errMsg);
      free(xsql);
      if (ret != SQLITE_OK)
        {
................................................................................
      if (rows < 1)
        ;
      else
        {
          for (i = 1; i <= rows; i++)
            {
              // adding some Vector Coverage
              const char *prefix = results[(i * columns) + 0];
              const char *name = results[(i * columns) + 1];
              int srid = atoi(results[(i * columns) + 2]);
              int type = atoi(results[(i * columns) + 3]);
              VectorCoverageSet coverage(prefix, name, srid, type);
              TableTree->AddVectorCoverage(&coverage);
            }
        }
      sqlite3_free_table(results);
    }
// fetching persistent tables and views
  sql =
................................................................................
  wxTreeItemId rootTopologies =
    TableTree->AppendItem(db, wxT("Topology-Geometry"));
  wxTreeItemId rootNetworks =
    TableTree->AppendItem(db, wxT("Topology-Network"));
  wxTreeItemId rootRasterCoverages =
    TableTree->AppendItem(db, wxT("Raster Coverages"));
  wxTreeItemId rootVectorCoverages =
    TableTree->AppendItem(db, wxT("Vector Coverages"));
  wxTreeItemId rootWMS =
    TableTree->AppendItem(db, wxT("Registered WMS layers"));
  wxTreeItemId rootMetadata = TableTree->AppendItem(db, wxT("Metadata"));
  wxTreeItemId rootInternal = TableTree->AppendItem(db, wxT("Internal Data"));
  wxTreeItemId rootSpatialIndex =
    TableTree->AppendItem(db, wxT("Spatial Index"));
  TableTree->SetItemImage(rootUserData, 17);
................................................................................
  TableTree->SetItemImage(rootVectorCoverages, 24);
  TableTree->SetItemImage(rootWMS, 26);
  TableTree->SetItemImage(rootStyling, 17);
  TableTree->SetItemImage(rootIsoMetadata, 17);
  TableTree->SetItemImage(rootMetadata, 17);
  TableTree->SetItemImage(rootInternal, 17);
  TableTree->SetItemImage(rootSpatialIndex, 17);
  TableTree->SetItemData(rootUserData, (wxTreeItemData *) (new MyObject(true)));
  TableTree->SetItemData(rootTopologies,
                         (wxTreeItemData *) (new MyObject(true)));
  TableTree->SetItemData(rootNetworks, (wxTreeItemData *) (new MyObject(true)));
  TableTree->SetItemData(rootRasterCoverages,
                         (wxTreeItemData *) (new MyObject(true)));
  TableTree->SetItemData(rootVectorCoverages,
                         (wxTreeItemData *) (new MyObject(true)));
  TableTree->SetItemData(rootWMS, (wxTreeItemData *) (new MyObject(true)));
  TableTree->SetItemData(rootStyling, (wxTreeItemData *) (new MyObject(true)));
  TableTree->SetItemData(rootMetadata, (wxTreeItemData *) (new MyObject(true)));
  TableTree->SetItemData(rootInternal, (wxTreeItemData *) (new MyObject(true)));
  TableTree->SetItemData(rootSpatialIndex,
                         (wxTreeItemData *) (new MyObject(true)));
  RootNodes nodes =
    RootNodes(dbAlias, rootUserData, rootTopologies, rootNetworks,
              rootRasterCoverages, rootVectorCoverages, rootStyling, rootWMS,
              rootIsoMetadata, rootMetadata, rootInternal, rootSpatialIndex);
  if (ExistsTopologies(dbAlias))
    {
      // fetching topologies
................................................................................
              // adding some Topology
              const char *name = results[(i * columns) + 0];
              int srid = atoi(results[(i * columns) + 1]);
              bool hasZ = false;
              if (atoi(results[(i * columns) + 2]))
                hasZ = true;
              TopoGeoSet topology(dbAlias.ToUTF8(), name, srid, hasZ);
              TableTree->AddAltTopology(rootTopologies, dbAlias, &topology);
            }
        }
      sqlite3_free_table(results);
    }
  if (ExistsNetworks(dbAlias))
    {
      // fetching topologies
................................................................................
              if (atoi(results[(i * columns) + 1]))
                spatial = true;
              int srid = atoi(results[(i * columns) + 2]);
              bool hasZ = false;
              if (atoi(results[(i * columns) + 3]))
                hasZ = true;
              TopoNetSet network(name, spatial, srid, hasZ);
              TableTree->AddAltNetwork(rootNetworks, dbAlias, &network);
            }
        }
      sqlite3_free_table(results);
    }
  if (ExistsRasterCoverages(dbAlias))
    {
      // fetching Raster Coverages
................................................................................
        {
          for (i = 1; i <= rows; i++)
            {
              // adding some Raster Coverage
              const char *name = results[(i * columns) + 0];
              int srid = atoi(results[(i * columns) + 1]);
              RasterCoverageSet coverage(name, srid);
              TableTree->AddAltRasterCoverage(rootRasterCoverages, dbAlias,
                                              &coverage);
            }
        }
      sqlite3_free_table(results);
    }
  if (ExistsVectorCoverages(dbAlias))
    {
      // fetching Vector Coverages
      wxString dbAlias2 = dbAlias;
      DoubleQuoted(dbAlias2);
      sql =
        wxT("SELECT 'table', c.coverage_name, g.srid, g.geometry_type FROM \"")
        + dbAlias2 + wxT("\".vector_coverages AS c ");
      sql += wxT("JOIN \"") + dbAlias2 + wxT("\".geometry_columns AS g ON (");
      sql += wxT("Lower(c.f_table_name) = Lower(g.f_table_name) AND ");
      sql += wxT("Lower(c.f_geometry_column) = Lower(g.f_geometry_column)) ");
      sql += wxT("UNION ");
      sql +=
        wxT("SELECT 'view', c.coverage_name, g.srid, g.geometry_type FROM \"") +
        dbAlias2 + wxT("\".vector_coverages AS c ");
      sql +=
        wxT("JOIN \"") + dbAlias2 + wxT("\".views_geometry_columns AS v ON (");
      sql += wxT("Lower(c.view_name) = Lower(v.view_name) AND ");
      sql += wxT("Lower(c.view_geometry) = Lower(v.view_geometry))");
      sql += wxT("JOIN \"") + dbAlias2 + wxT("\".geometry_columns AS g ON (");
      sql += wxT("Lower(v.f_table_name) = Lower(g.f_table_name) AND ");
      sql += wxT("Lower(v.f_geometry_column) = Lower(g.f_geometry_column)) ");
      sql += wxT("UNION ");
      sql +=
        wxT("SELECT 'shp', c.coverage_name, v.srid, v.geometry_type FROM \"") +
        dbAlias2 + wxT("\".vector_coverages AS c ");
      sql +=
        wxT("JOIN \"") + dbAlias2 + wxT("\".virts_geometry_columns AS v ON (");
      sql += wxT("Lower(c.virt_name) = Lower(v.virt_name) AND ");
      sql += wxT("Lower(c.virt_geometry) = Lower(v.virt_geometry))");
      sql += wxT("ORDER BY 2");
      xsql = (char *) malloc((sql.Len() * 4) + 1);
      strcpy(xsql, sql.ToUTF8());
      int ret = sqlite3_get_table(SqliteHandle, xsql, &results,
                                  &rows, &columns, &errMsg);
      free(xsql);
      if (ret != SQLITE_OK)
        {
................................................................................
      if (rows < 1)
        ;
      else
        {
          for (i = 1; i <= rows; i++)
            {
              // adding some Vector Coverage
              const char *prefix = results[(i * columns) + 0];
              const char *name = results[(i * columns) + 1];
              int srid = atoi(results[(i * columns) + 2]);
              int type = atoi(results[(i * columns) + 3]);
              VectorCoverageSet coverage(prefix, name, srid, type);
              TableTree->AddAltVectorCoverage(rootVectorCoverages, dbAlias,
                                              &coverage);
            }
        }
      sqlite3_free_table(results);
    }
// fetching tables and views
  sql = wxT("SELECT name, sql, type FROM \"");
  wxString dbAlias2 = dbAlias;

# Makefile ( Mingw & wxwidgets) for spatialite-GUI

SRC = Main.cpp TableTree.cpp QueryView.cpp ResultSetView.cpp BlobExplorer.cpp \
	Dialogs.cpp Shapefiles.cpp Network.cpp Exif.cpp TextCsv.cpp \
	Objects.cpp QueryViewComposer.cpp MalformedGeoms.cpp DialogsGraph.cpp \
	Raster.cpp Styles.cpp RasterSymbolizers.cpp VectorSymbolizers1.cpp \
	VectorSymbolizers2.cpp Wfs.cpp SqlFilterComposer.cpp \

	win_resource/resource.rc
OBJ = Main.o TableTree.o QueryView.o ResultSetView.o BlobExplorer.o \
	Dialogs.o Shapefiles.o Network.o Exif.o TextCsv.o Objects.o \
	QueryViewComposer.o MalformedGeoms.o DialogsGraph.o \
	Raster.o Styles.o RasterSymbolizers.o VectorSymbolizers1.o \
	VectorSymbolizers2.o Wfs.o SqlFiltersComposer.o \

	win_resource/resource.o 
EXE = ./static_bin/spatialite_gui.exe
INCLUDE = Classdef.h 

# Define default flags:
CXXFLAGS = $(shell wx-config --cxxflags)
LIB = -Wl,--subsystem,windows /usr/local/lib/libwx_mswu-3.0.a \
................................................................................
	$(CXX) -c Objects.cpp $(CXXFLAGS) $(EXTRAFLAGS)

QueryViewComposer.o: QueryViewComposer.cpp $(INCLUDE)
	$(CXX) -c QueryViewComposer.cpp $(CXXFLAGS) $(EXTRAFLAGS)

MalformedGeoms.o: MalformedGeoms.cpp $(INCLUDE)
	$(CXX) -c MalformedGeoms.cpp $(CXXFLAGS) $(EXTRAFLAGS)












			
win_resource/resource.o: win_resource/resource.rc
	$(REZ) -i win_resource/resource.rc -o win_resource/resource.o 

# Makefile ( Mingw & wxwidgets) for spatialite-GUI

SRC = Main.cpp TableTree.cpp QueryView.cpp ResultSetView.cpp BlobExplorer.cpp \
	Dialogs.cpp Shapefiles.cpp Network.cpp Exif.cpp TextCsv.cpp \
	Objects.cpp QueryViewComposer.cpp MalformedGeoms.cpp DialogsGraph.cpp \
	Raster.cpp Styles.cpp RasterSymbolizers.cpp VectorSymbolizers1.cpp \
	VectorSymbolizers2.cpp Wfs.cpp SqlFilterComposer.cpp \
	WmsDialog.cpp LayerTree.cpp MapPanel.cpp MapView.cpp \
	win_resource/resource.rc
OBJ = Main.o TableTree.o QueryView.o ResultSetView.o BlobExplorer.o \
	Dialogs.o Shapefiles.o Network.o Exif.o TextCsv.o Objects.o \
	QueryViewComposer.o MalformedGeoms.o DialogsGraph.o \
	Raster.o Styles.o RasterSymbolizers.o VectorSymbolizers1.o \
	VectorSymbolizers2.o Wfs.o SqlFiltersComposer.o \
	WmsDialog.o LayerTree.o MapPanel.o MapView.o \
	win_resource/resource.o 
EXE = ./static_bin/spatialite_gui.exe
INCLUDE = Classdef.h 

# Define default flags:
CXXFLAGS = $(shell wx-config --cxxflags)
LIB = -Wl,--subsystem,windows /usr/local/lib/libwx_mswu-3.0.a \
................................................................................
	$(CXX) -c Objects.cpp $(CXXFLAGS) $(EXTRAFLAGS)

QueryViewComposer.o: QueryViewComposer.cpp $(INCLUDE)
	$(CXX) -c QueryViewComposer.cpp $(CXXFLAGS) $(EXTRAFLAGS)

MalformedGeoms.o: MalformedGeoms.cpp $(INCLUDE)
	$(CXX) -c MalformedGeoms.cpp $(CXXFLAGS) $(EXTRAFLAGS)

WmsDialog.o: WmsDialog.cpp $(INCLUDE)
	$(CXX) -c WmsDialog.cpp $(CXXFLAGS) $(EXTRAFLAGS)

LayerTree.o: LayerTree.cpp $(INCLUDE)
	$(CXX) -c TableTree.cpp $(CXXFLAGS) $(EXTRAFLAGS)

MapPanel.o: MapPanel.cpp $(INCLUDE)
	$(CXX) -c MapPanel.cpp $(CXXFLAGS) $(EXTRAFLAGS)

MapView.o: MapView.cpp $(INCLUDE)
	$(CXX) -c MapView.cpp $(CXXFLAGS) $(EXTRAFLAGS)
			
win_resource/resource.o: win_resource/resource.rc
	$(REZ) -i win_resource/resource.rc -o win_resource/resource.o 

spatialite_gui_SOURCES = Classdef.h BlobExplorer.cpp \
	Dialogs.cpp DialogsGraph.cpp WmsDialog.cpp Exif.cpp \
	Main.cpp MalformedGeoms.cpp Network.cpp \
	Objects.cpp QueryView.cpp QueryViewComposer.cpp \
	ResultSetView.cpp Shapefiles.cpp TableTree.cpp \
	TextCsv.cpp Wfs.cpp Raster.cpp Styles.cpp \
	RasterSymbolizers.cpp VectorSymbolizers1.cpp \
	VectorSymbolizers2.cpp SqlFiltersComposer.cpp


LDADD = @WX_LIBS@ @LIBSPATIALITE_LIBS@ \
	@LIBRASTERLITE2_LIBS@ @LIBFREEXL_LIBS@ @LIBXML2_LIBS@ -lgeos_c

EXTRA_DIST = Makefile-static-MinGW \
        Makefile-static-Linux \
        Makefile-static-MacOsX \
        indent_me

AUTOMAKE_OPTIONS = dist-zip foreign

SUBDIRS = icons win_resource mac_resource gnome_resource

spatialite_gui_SOURCES = Classdef.h BlobExplorer.cpp \
	Dialogs.cpp DialogsGraph.cpp WmsDialog.cpp Exif.cpp \
	Main.cpp MalformedGeoms.cpp Network.cpp \
	Objects.cpp QueryView.cpp QueryViewComposer.cpp \
	ResultSetView.cpp Shapefiles.cpp TableTree.cpp \
	TextCsv.cpp Wfs.cpp Raster.cpp Styles.cpp \
	RasterSymbolizers.cpp VectorSymbolizers1.cpp \
	VectorSymbolizers2.cpp SqlFiltersComposer.cpp \
	MapPanel.cpp MapView.cpp LayerTree.cpp

LDADD = @WX_LIBS@ @LIBSPATIALITE_LIBS@ \
	@LIBRASTERLITE2_LIBS@ @LIBFREEXL_LIBS@ @LIBXML2_LIBS@ -lgeos_c

EXTRA_DIST = Makefile-static-MinGW \
        Makefile-static-Linux \
        Makefile-static-MacOsX \
        indent_me

AUTOMAKE_OPTIONS = dist-zip foreign

SUBDIRS = icons win_resource mac_resource gnome_resource

	DialogsGraph.$(OBJEXT) WmsDialog.$(OBJEXT) Exif.$(OBJEXT) \
	Main.$(OBJEXT) MalformedGeoms.$(OBJEXT) Network.$(OBJEXT) \
	Objects.$(OBJEXT) QueryView.$(OBJEXT) \
	QueryViewComposer.$(OBJEXT) ResultSetView.$(OBJEXT) \
	Shapefiles.$(OBJEXT) TableTree.$(OBJEXT) TextCsv.$(OBJEXT) \
	Wfs.$(OBJEXT) Raster.$(OBJEXT) Styles.$(OBJEXT) \
	RasterSymbolizers.$(OBJEXT) VectorSymbolizers1.$(OBJEXT) \
	VectorSymbolizers2.$(OBJEXT) SqlFiltersComposer.$(OBJEXT)

spatialite_gui_OBJECTS = $(am_spatialite_gui_OBJECTS)
spatialite_gui_LDADD = $(LDADD)
spatialite_gui_DEPENDENCIES =
AM_V_lt = $(am__v_lt_@AM_V@)
am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
am__v_lt_0 = --silent
am__v_lt_1 = 
................................................................................
spatialite_gui_SOURCES = Classdef.h BlobExplorer.cpp \
	Dialogs.cpp DialogsGraph.cpp WmsDialog.cpp Exif.cpp \
	Main.cpp MalformedGeoms.cpp Network.cpp \
	Objects.cpp QueryView.cpp QueryViewComposer.cpp \
	ResultSetView.cpp Shapefiles.cpp TableTree.cpp \
	TextCsv.cpp Wfs.cpp Raster.cpp Styles.cpp \
	RasterSymbolizers.cpp VectorSymbolizers1.cpp \
	VectorSymbolizers2.cpp SqlFiltersComposer.cpp


LDADD = @WX_LIBS@ @LIBSPATIALITE_LIBS@ \
	@LIBRASTERLITE2_LIBS@ @LIBFREEXL_LIBS@ @LIBXML2_LIBS@ -lgeos_c

EXTRA_DIST = Makefile-static-MinGW \
        Makefile-static-Linux \
        Makefile-static-MacOsX \
................................................................................
distclean-compile:
	-rm -f *.tab.c

@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BlobExplorer.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Dialogs.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DialogsGraph.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Exif.Po@am__quote@

@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Main.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MalformedGeoms.Po@am__quote@


@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Network.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Objects.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/QueryView.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/QueryViewComposer.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Raster.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/RasterSymbolizers.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ResultSetView.Po@am__quote@
................................................................................
	|| find "$(distdir)" -type d ! -perm -755 \
		-exec chmod u+rwx,go+rx {} \; -o \
	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
	|| chmod -R a+r "$(distdir)"
dist-gzip: distdir
	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
	$(am__post_remove_distdir)

dist-bzip2: distdir
	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
	$(am__post_remove_distdir)

dist-lzip: distdir
................................................................................
	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
	$(am__post_remove_distdir)

dist-shar: distdir
	@echo WARNING: "Support for shar distribution archives is" \
	               "deprecated." >&2
	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
	$(am__post_remove_distdir)
dist-zip: distdir
	-rm -f $(distdir).zip
	zip -rq $(distdir).zip $(distdir)
	$(am__post_remove_distdir)

dist dist-all:
................................................................................

# This target untars the dist file and tries a VPATH configuration.  Then
# it guarantees that the distribution is self-contained by making another
# tarfile.
distcheck: dist
	case '$(DIST_ARCHIVES)' in \
	*.tar.gz*) \
	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
	*.tar.bz2*) \
	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
	*.tar.lz*) \
	  lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
	*.tar.xz*) \
	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
	*.tar.Z*) \
	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
	*.shar.gz*) \
	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\
	*.zip*) \
	  unzip $(distdir).zip ;;\
	esac
	chmod -R a-w $(distdir)
	chmod u+w $(distdir)
	mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
	chmod a-w $(distdir)

	DialogsGraph.$(OBJEXT) WmsDialog.$(OBJEXT) Exif.$(OBJEXT) \
	Main.$(OBJEXT) MalformedGeoms.$(OBJEXT) Network.$(OBJEXT) \
	Objects.$(OBJEXT) QueryView.$(OBJEXT) \
	QueryViewComposer.$(OBJEXT) ResultSetView.$(OBJEXT) \
	Shapefiles.$(OBJEXT) TableTree.$(OBJEXT) TextCsv.$(OBJEXT) \
	Wfs.$(OBJEXT) Raster.$(OBJEXT) Styles.$(OBJEXT) \
	RasterSymbolizers.$(OBJEXT) VectorSymbolizers1.$(OBJEXT) \
	VectorSymbolizers2.$(OBJEXT) SqlFiltersComposer.$(OBJEXT) \
	MapPanel.$(OBJEXT) MapView.$(OBJEXT) LayerTree.$(OBJEXT)
spatialite_gui_OBJECTS = $(am_spatialite_gui_OBJECTS)
spatialite_gui_LDADD = $(LDADD)
spatialite_gui_DEPENDENCIES =
AM_V_lt = $(am__v_lt_@AM_V@)
am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
am__v_lt_0 = --silent
am__v_lt_1 = 
................................................................................
spatialite_gui_SOURCES = Classdef.h BlobExplorer.cpp \
	Dialogs.cpp DialogsGraph.cpp WmsDialog.cpp Exif.cpp \
	Main.cpp MalformedGeoms.cpp Network.cpp \
	Objects.cpp QueryView.cpp QueryViewComposer.cpp \
	ResultSetView.cpp Shapefiles.cpp TableTree.cpp \
	TextCsv.cpp Wfs.cpp Raster.cpp Styles.cpp \
	RasterSymbolizers.cpp VectorSymbolizers1.cpp \
	VectorSymbolizers2.cpp SqlFiltersComposer.cpp \
	MapPanel.cpp MapView.cpp LayerTree.cpp

LDADD = @WX_LIBS@ @LIBSPATIALITE_LIBS@ \
	@LIBRASTERLITE2_LIBS@ @LIBFREEXL_LIBS@ @LIBXML2_LIBS@ -lgeos_c

EXTRA_DIST = Makefile-static-MinGW \
        Makefile-static-Linux \
        Makefile-static-MacOsX \
................................................................................
distclean-compile:
	-rm -f *.tab.c

@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BlobExplorer.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Dialogs.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DialogsGraph.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Exif.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LayerTree.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Main.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MalformedGeoms.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MapPanel.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MapView.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Network.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Objects.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/QueryView.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/QueryViewComposer.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Raster.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/RasterSymbolizers.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ResultSetView.Po@am__quote@
................................................................................
	|| find "$(distdir)" -type d ! -perm -755 \
		-exec chmod u+rwx,go+rx {} \; -o \
	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
	|| chmod -R a+r "$(distdir)"
dist-gzip: distdir
	tardir=$(distdir) && $(am__tar) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).tar.gz
	$(am__post_remove_distdir)

dist-bzip2: distdir
	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
	$(am__post_remove_distdir)

dist-lzip: distdir
................................................................................
	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
	$(am__post_remove_distdir)

dist-shar: distdir
	@echo WARNING: "Support for shar distribution archives is" \
	               "deprecated." >&2
	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
	shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).shar.gz
	$(am__post_remove_distdir)
dist-zip: distdir
	-rm -f $(distdir).zip
	zip -rq $(distdir).zip $(distdir)
	$(am__post_remove_distdir)

dist dist-all:
................................................................................

# This target untars the dist file and tries a VPATH configuration.  Then
# it guarantees that the distribution is self-contained by making another
# tarfile.
distcheck: dist
	case '$(DIST_ARCHIVES)' in \
	*.tar.gz*) \
	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).tar.gz | $(am__untar) ;;\
	*.tar.bz2*) \
	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
	*.tar.lz*) \
	  lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
	*.tar.xz*) \
	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
	*.tar.Z*) \
	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
	*.shar.gz*) \
	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\
	*.zip*) \
	  unzip $(distdir).zip ;;\
	esac
	chmod -R a-w $(distdir)
	chmod u+w $(distdir)
	mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
	chmod a-w $(distdir)

/
*/

#include "Classdef.h"

#include "wx/clipbrd.h"
#include "wx/colordlg.h"


#if defined(_WIN32) || defined (__MINGW32__)
#define FORMAT_64	"%I64d"
#else
#define FORMAT_64	"%lld"
#endif

................................................................................
{
//
// all done: 
//
  //wxDialog::EndModal(wxID_OK);
  Destroy();
}

/
*/

#include "Classdef.h"

#include "wx/clipbrd.h"
#include "wx/colordlg.h"
#include "wx/spinctrl.h"

#if defined(_WIN32) || defined (__MINGW32__)
#define FORMAT_64	"%I64d"
#else
#define FORMAT_64	"%lld"
#endif

................................................................................
{
//
// all done: 
//
  //wxDialog::EndModal(wxID_OK);
  Destroy();
}

void MyFrame::DoCreateTopoGeo()
{
//
// creating a new Topology-Geometry
//
  CreateTopoGeoDialog dlg;
  dlg.Create(this);
  int ret = dlg.ShowModal();
  if (ret == wxID_OK)
    {
      const char *sql;
      wxString name = dlg.GetTopologyName();
      int srid = dlg.GetSrid();
      bool has_z = dlg.Is3D();
      double tolerance = dlg.GetTolerance();
      if (tolerance > 0.0)
        sql = "SELECT CreateTopology(?, ?, ?, ?)";
      else
        sql = "SELECT CreateTopology(?, ?, ?)";
      sqlite3_stmt *stmt;
      int ret = sqlite3_prepare_v2(SqliteHandle, sql, strlen(sql), &stmt, NULL);
      if (ret != SQLITE_OK)
        {
          const char *msg = sqlite3_errmsg(SqliteHandle);
          wxMessageBox(wxT("ERROR - CreateTopology: ") +
                       wxString::FromUTF8(msg), wxT("spatialite_gui"),
                       wxOK | wxICON_ERROR, this);
          return;
        }
      sqlite3_reset(stmt);
      sqlite3_clear_bindings(stmt);
      char *xname = (char *) malloc((name.Len() * 4) + 1);
      strcpy(xname, name.ToUTF8());
      sqlite3_bind_text(stmt, 1, xname, strlen(xname), free);
      sqlite3_bind_int(stmt, 2, srid);
      if (has_z)
        sqlite3_bind_int(stmt, 3, 1);
      else
        sqlite3_bind_int(stmt, 3, 0);
      if (tolerance > 0)
        sqlite3_bind_double(stmt, 4, tolerance);
      int valid = 0;
      while (1)
        {
          ret = sqlite3_step(stmt);
          if (ret == SQLITE_DONE)
            break;
          if (ret == SQLITE_ROW)
            {
              if (sqlite3_column_type(stmt, 0) == SQLITE_INTEGER)
                valid = sqlite3_column_int(stmt, 0);
          } else
            {
              const char *msg = sqlite3_errmsg(SqliteHandle);
              wxMessageBox(wxT("ERROR - CreateTopology: ") +
                           wxString::FromUTF8(msg), wxT("spatialite_gui"),
                           wxOK | wxICON_ERROR, this);
              break;
            }
        }
      sqlite3_finalize(stmt);
      if (valid)
        wxMessageBox(wxT("Topology-Geometry succesfully created."),
                     wxT("spatialite_gui"), wxOK | wxICON_INFORMATION, this);
      else
        wxMessageBox(wxT("Topology-Geometry creation failed."),
                     wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      return;
    }
}

bool CreateTopoGeoDialog::Create(MyFrame * parent)
{
//
// creating the dialog
//
  MainFrame = parent;
  HasZ = false;
  if (wxDialog::Create(parent, wxID_ANY,
                       wxT("Creating a new Topology-Geometry")) == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
// centers the dialog window
  Centre();
  return true;
}

void CreateTopoGeoDialog::CreateControls()
{
//
// creating individual control and setting initial values
//
  wxBoxSizer *topSizer = new wxBoxSizer(wxVERTICAL);
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// first row: Topology Name
  wxBoxSizer *nameSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(nameSizer, 0, wxALIGN_CENTRE_VERTICAL | wxALL, 0);
  wxStaticText *nameLabel =
    new wxStaticText(this, wxID_STATIC, wxT("Topology &Name:"));
  nameSizer->Add(nameLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *nameCtrl = new wxTextCtrl(this, ID_TOPO_NAME, wxT(""),
                                        wxDefaultPosition, wxSize(300, 22));
  nameSizer->Add(nameCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// second row: SRID
  wxBoxSizer *sridSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(sridSizer, 0, wxALIGN_LEFT | wxALL, 0);
  wxStaticText *sridLabel = new wxStaticText(this, wxID_STATIC, wxT("&SRID:"));
  sridSizer->Add(sridLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxSpinCtrl *sridCtrl = new wxSpinCtrl(this, ID_TOPO_SRID, wxEmptyString,
                                        wxDefaultPosition, wxSize(80, 20),
                                        wxSP_ARROW_KEYS, -1, 1000000, -1);
  sridSizer->Add(sridCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 1);
// third row: Has Z
  wxBoxSizer *hasZSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(hasZSizer, 0, wxALIGN_LEFT | wxALL, 0);
  wxString dims[2];
  dims[0] = wxT("&2D");
  dims[1] = wxT("&3D");
  wxRadioBox *hasZBox = new wxRadioBox(this, ID_TOPO_3D,
                                       wxT("Dimensions"),
                                       wxDefaultPosition,
                                       wxDefaultSize, 2,
                                       dims, 1,
                                       wxRA_SPECIFY_ROWS);
  hasZSizer->Add(hasZBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  hasZBox->SetSelection(0);
// fourth row: Tolerance
  wxBoxSizer *tolSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(tolSizer, 0, wxALIGN_CENTRE_VERTICAL | wxALL, 0);
  wxStaticText *tolLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Tolerance:"));
  tolSizer->Add(tolLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *tolCtrl = new wxTextCtrl(this, ID_TOPO_TOLERANCE, wxT(""),
                                       wxDefaultPosition, wxSize(150, 22));
  tolSizer->Add(tolCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&Create"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
  btnBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// appends event handler for OK button
  Connect(wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED,
          (wxObjectEventFunction) & CreateTopoGeoDialog::OnOk);
}

void CreateTopoGeoDialog::OnOk(wxCommandEvent & WXUNUSED(event))
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_TOPO_NAME);
  wxSpinCtrl *sridCtrl = (wxSpinCtrl *) FindWindow(ID_TOPO_SRID);
  wxRadioBox *hasZBox = (wxRadioBox *) FindWindow(ID_TOPO_3D);
  wxTextCtrl *tolCtrl = (wxTextCtrl *) FindWindow(ID_TOPO_TOLERANCE);
  wxString str = nameCtrl->GetValue().Trim();
  TopologyName = str.Trim(false);
  if (TopologyName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Topology Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  Srid = sridCtrl->GetValue();
  if (hasZBox->GetSelection() == 1)
    HasZ = true;
  else
    HasZ = false;
  wxString tol = tolCtrl->GetValue();
  if (tol.ToDouble(&Tolerance) == false)
    {
      wxMessageBox(wxT("invalid Tolerance value"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (Tolerance < 0.0)
    {
      wxMessageBox(wxT("Tolerance should be a positive value"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  wxDialog::EndModal(wxID_OK);
}

void MyFrame::DoCreateTopoNet()
{
//
// creating a new Topology-Network
//
  CreateTopoNetDialog dlg;
  dlg.Create(this);
  int ret = dlg.ShowModal();
  if (ret == wxID_OK)
    {
      const char *sql;
      wxString name = dlg.GetNetworkName();
      bool is_spatial = dlg.IsSpatial();
      int srid = dlg.GetSrid();
      bool has_z = dlg.Is3D();
      bool coincident = dlg.AllowsCoincident();
      if (is_spatial == false)
        sql = "SELECT CreateNetwork(?, 0)";
      else
        sql = "SELECT CreateNetwork(?, 1, ?, ?, ?)";
      sqlite3_stmt *stmt;
      int ret = sqlite3_prepare_v2(SqliteHandle, sql, strlen(sql), &stmt, NULL);
      if (ret != SQLITE_OK)
        {
          const char *msg = sqlite3_errmsg(SqliteHandle);
          wxMessageBox(wxT("ERROR - CreateNetwork: ") +
                       wxString::FromUTF8(msg), wxT("spatialite_gui"),
                       wxOK | wxICON_ERROR, this);
          return;
        }
      sqlite3_reset(stmt);
      sqlite3_clear_bindings(stmt);
      char *xname = (char *) malloc((name.Len() * 4) + 1);
      strcpy(xname, name.ToUTF8());
      sqlite3_bind_text(stmt, 1, xname, strlen(xname), free);
      if (is_spatial)
        {
          sqlite3_bind_int(stmt, 2, srid);
          if (has_z)
            sqlite3_bind_int(stmt, 3, 1);
          else
            sqlite3_bind_int(stmt, 3, 0);
          if (coincident)
            sqlite3_bind_int(stmt, 4, 1);
          else
            sqlite3_bind_int(stmt, 4, 0);
        }
      int valid = 0;
      while (1)
        {
          ret = sqlite3_step(stmt);
          if (ret == SQLITE_DONE)
            break;
          if (ret == SQLITE_ROW)
            {
              if (sqlite3_column_type(stmt, 0) == SQLITE_INTEGER)
                valid = sqlite3_column_int(stmt, 0);
          } else
            {
              const char *msg = sqlite3_errmsg(SqliteHandle);
              wxMessageBox(wxT("ERROR - CreateNetwork: ") +
                           wxString::FromUTF8(msg), wxT("spatialite_gui"),
                           wxOK | wxICON_ERROR, this);
              break;
            }
        }
      sqlite3_finalize(stmt);
      if (valid)
        wxMessageBox(wxT("Topology-Network succesfully created."),
                     wxT("spatialite_gui"), wxOK | wxICON_INFORMATION, this);
      else
        wxMessageBox(wxT("Topology-Network creation failed."),
                     wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      return;
    }
}

bool CreateTopoNetDialog::Create(MyFrame * parent)
{
//
// creating the dialog
//
  MainFrame = parent;
  Spatial = true;
  HasZ = false;
  if (wxDialog::Create(parent, wxID_ANY,
                       wxT("Creating a new Topology-Network")) == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
// centers the dialog window
  Centre();
  return true;
}

void CreateTopoNetDialog::CreateControls()
{
//
// creating individual control and setting initial values
//
  wxBoxSizer *topSizer = new wxBoxSizer(wxVERTICAL);
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// first row: Network Name
  wxBoxSizer *nameSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(nameSizer, 0, wxALIGN_CENTRE_VERTICAL | wxALL, 0);
  wxStaticText *nameLabel =
    new wxStaticText(this, wxID_STATIC, wxT("Network &Name:"));
  nameSizer->Add(nameLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *nameCtrl = new wxTextCtrl(this, ID_TOPO_NAME, wxT(""),
                                        wxDefaultPosition, wxSize(300, 22));
  nameSizer->Add(nameCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// second row: Spatial Network
  wxBoxSizer *spatSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(spatSizer, 0, wxALIGN_CENTRE_VERTICAL | wxALL, 0);
  wxCheckBox *spatCtrl =
    new wxCheckBox(this, ID_TOPO_SPATIAL, wxT("&Spatial Network"));
  spatCtrl->SetValue(true);
  spatSizer->Add(spatCtrl, 0, wxALIGN_LEFT | wxALL, 1);
// third row: SRID
  wxBoxSizer *sridSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(sridSizer, 0, wxALIGN_LEFT | wxALL, 0);
  wxStaticText *sridLabel = new wxStaticText(this, wxID_STATIC, wxT("&SRID:"));
  sridSizer->Add(sridLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxSpinCtrl *sridCtrl = new wxSpinCtrl(this, ID_TOPO_SRID, wxEmptyString,
                                        wxDefaultPosition, wxSize(80, 20),
                                        wxSP_ARROW_KEYS, -1, 1000000, -1);
  sridSizer->Add(sridCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 1);
// fourth row: Has Z
  wxBoxSizer *hasZSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(hasZSizer, 0, wxALIGN_LEFT | wxALL, 0);
  wxString dims[2];
  dims[0] = wxT("&2D");
  dims[1] = wxT("&3D");
  wxRadioBox *hasZBox = new wxRadioBox(this, ID_TOPO_3D,
                                       wxT("Dimensions"),
                                       wxDefaultPosition,
                                       wxDefaultSize, 2,
                                       dims, 1,
                                       wxRA_SPECIFY_ROWS);
  hasZSizer->Add(hasZBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  hasZBox->SetSelection(0);
// fifth row: Allow Coincident
  wxBoxSizer *coinSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(coinSizer, 0, wxALIGN_CENTRE_VERTICAL | wxALL, 0);
  wxCheckBox *coinCtrl =
    new wxCheckBox(this, ID_TOPO_COINCIDENT, wxT("&Allow Coincident items)"));
  coinCtrl->SetValue(true);
  coinSizer->Add(coinCtrl, 0, wxALIGN_LEFT | wxALL, 1);
// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&Create"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
  btnBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// appends event handler for OK button
  Connect(wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED,
          (wxObjectEventFunction) & CreateTopoNetDialog::OnOk);
// appends event handlers for radio buttons etc
  Connect(ID_TOPO_SPATIAL, wxEVT_COMMAND_CHECKBOX_CLICKED,
          (wxObjectEventFunction) & CreateTopoNetDialog::OnSpatialChanged);
}

void CreateTopoNetDialog::OnSpatialChanged(wxCommandEvent & WXUNUSED(event))
{
//
// Spatial / Logical
//
  wxCheckBox *spatCtrl = (wxCheckBox *) FindWindow(ID_TOPO_SPATIAL);
  wxSpinCtrl *sridCtrl = (wxSpinCtrl *) FindWindow(ID_TOPO_SRID);
  wxRadioBox *hasZCtrl = (wxRadioBox *) FindWindow(ID_TOPO_3D);
  wxCheckBox *coinCtrl = (wxCheckBox *) FindWindow(ID_TOPO_COINCIDENT);
  if (Spatial == true)
    {
      Spatial = false;
      spatCtrl->SetValue(false);
      sridCtrl->Enable(false);
      hasZCtrl->Enable(false);
      coinCtrl->Enable(false);
  } else
    {
      Spatial = true;
      spatCtrl->SetValue(true);
      sridCtrl->Enable(true);
      hasZCtrl->Enable(true);
      coinCtrl->Enable(true);
    }
}

void CreateTopoNetDialog::OnOk(wxCommandEvent & WXUNUSED(event))
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_TOPO_NAME);
  wxCheckBox *spatCtrl = (wxCheckBox *) FindWindow(ID_TOPO_SPATIAL);
  wxSpinCtrl *sridCtrl = (wxSpinCtrl *) FindWindow(ID_TOPO_SRID);
  wxRadioBox *hasZBox = (wxRadioBox *) FindWindow(ID_TOPO_3D);
  wxCheckBox *coinCtrl = (wxCheckBox *) FindWindow(ID_TOPO_COINCIDENT);
  wxString str = nameCtrl->GetValue().Trim();
  NetworkName = str.Trim(false);
  if (NetworkName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Network Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (spatCtrl->GetValue() == true)
    Spatial = true;
  else
    Spatial = false;
  Srid = sridCtrl->GetValue();
  if (hasZBox->GetSelection() == 1)
    HasZ = true;
  else
    HasZ = false;
  if (coinCtrl->GetValue() == true)
    Coincident = true;
  else
    Coincident = false;
  wxDialog::EndModal(wxID_OK);
}

/*
/ MapPanel.cpp
/ the Map Panel of spatialite_gui  - a SQLite /SpatiaLite GUI tool
/
/ version 2.0, 2017 January 8
/
/ Author: Sandro Furieri a-furieri@lqt.it
/
/ Copyright (C) 2017  Alessandro Furieri
/
/    This program is free software: you can redistribute it and/or modify
/    it under the terms of the GNU General Public License as published by
/    the Free Software Foundation, either version 3 of the License, or
/    (at your option) any later version.
/
/    This program is distributed in the hope that it will be useful,
/    but WITHOUT ANY WARRANTY; without even the implied warranty of
/    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
/    GNU General Public License for more details.
/
/    You should have received a copy of the GNU General Public License
/    along with this program.  If not, see <http://www.gnu.org/licenses/>.
/
*/

#include "Classdef.h"

#include "wx/menu.h"
#include "wx/aboutdlg.h"
#include "wx/config.h"

#include "icons/icon_map.xpm"
#include "icons/linestrings_on.xpm"
#include "icons/linestrings_off.xpm"
#include "icons/points_on.xpm"
#include "icons/points_off.xpm"
#include "icons/polygons_on.xpm"
#include "icons/polygons_off.xpm"
#include "icons/vector.xpm"
#include "icons/vector_off.xpm"
#include "icons/topo_geo.xpm"
#include "icons/topo_geo_off.xpm"
#include "icons/topo_net.xpm"
#include "icons/topo_net_off.xpm"
#include "icons/coverage.xpm"
#include "icons/coverage_off.xpm"
#include "icons/wms.xpm"
#include "icons/wms_off.xpm"
#include "icons/icon_info.xpm"
#include "icons/map_add.xpm"
#include "icons/center.xpm"
#include "icons/identify.xpm"
#include "icons/zoom_in.xpm"
#include "icons/zoom_out.xpm"
#include "icons/user_scale.xpm"
#include "icons/pan.xpm"
#include "icons/printer.xpm"
#include "icons/about.xpm"
#include "icons/exit.xpm"

MyMapPanel::MyMapPanel(MyFrame * parent, const wxString & title,
                       const wxPoint & pos,
                       const wxSize & size):wxFrame((wxFrame *) NULL, -1, title,
                                                    pos, size)
{
//
// Map Panel frame constructor
//
  Parent = parent;

//
// setting up the application icon
//      
  wxIcon MyIcon(icon_map_xpm);
  SetIcon(MyIcon);

  BtnAddLayer = new wxBitmap(map_add_xpm);
  BtnCenter = new wxBitmap(center_xpm);
  BtnIdentify = new wxBitmap(identify_xpm);
  BtnZoomIn = new wxBitmap(zoom_in_xpm);
  BtnZoomOut = new wxBitmap(zoom_out_xpm);
  BtnUserScale = new wxBitmap(user_scale_xpm);
  BtnPan = new wxBitmap(pan_xpm);
  BtnPrinter = new wxBitmap(printer_xpm);
  BtnAbout = new wxBitmap(about_xpm);
  BtnExit = new wxBitmap(exit_xpm);

//
// setting up panes
//
  LayerTree = new MyLayerTree(this);
  MapView = new MyMapView(this);
  Manager.SetManagedWindow(this);
  wxAuiPaneInfo paneView = wxAuiPaneInfo().Centre();
  paneView.Name(wxT("map_view"));
  paneView.CaptionVisible(false);
  paneView.Floatable(true);
  paneView.Dockable(true);
  paneView.Movable(true);
  paneView.Gripper(false);
  paneView.CloseButton(false);
  Manager.AddPane(MapView, paneView);
  wxAuiPaneInfo paneTree = wxAuiPaneInfo().Left();
  paneTree.Name(wxT("tree_view"));
  paneTree.DefaultPane();
  paneTree.CaptionVisible(false);
  paneTree.Floatable(true);
  paneTree.Dockable(true);
  paneTree.Movable(true);
  paneTree.Gripper(true);
  paneTree.CloseButton(false);
  paneTree.BestSize(wxSize(200, 480));
  Manager.AddPane(LayerTree, paneTree, wxPoint(0, 10));
  Manager.Update();
  Centre();
  //ClearLayerTree();

//
// setting up the status bar
//
  wxStatusBar *statusBar = new wxStatusBar(this);
  statusBar->SetFieldsCount(4);
  int fldWidth[4];
  fldWidth[0] = -1;
  fldWidth[1] = -1;
  fldWidth[2] = -1;
  fldWidth[3] = -1;
  statusBar->SetStatusWidths(4, fldWidth);
  SetStatusBar(statusBar);

//
// setting up the menu bar
//
  wxMenu *menuFile = new wxMenu;
  wxMenuItem *menuItem;
  menuItem = new wxMenuItem(menuFile, ID_AddLayer, wxT("Add a Map &Layer"));
  menuItem->SetBitmap(*BtnAddLayer);
  menuFile->Append(menuItem);
  menuFile->AppendSeparator();
  menuItem = new wxMenuItem(menuFile, ID_Center, wxT("Zoom to &Full Extent"));
  menuItem->SetBitmap(*BtnCenter);
  menuFile->Append(menuItem);
  menuItem =
    new wxMenuItem(menuFile, ID_ZoomIn, wxT("Zoom &In"), wxT(""), wxITEM_RADIO);
  menuFile->Append(menuItem);
  menuItem =
    new wxMenuItem(menuFile, ID_ZoomOut,
                   wxT("Zoom &Out"), wxT(""), wxITEM_RADIO);
  menuFile->Append(menuItem);
  menuItem = new wxMenuItem(menuFile, ID_UserScale, wxT("User defined &Scale"));
  menuItem->SetBitmap(*BtnUserScale);
  menuFile->Append(menuItem);
  menuItem =
    new wxMenuItem(menuFile, ID_Pan, wxT("&Pan"), wxT(""), wxITEM_RADIO);
  menuFile->Append(menuItem);
  menuItem =
    new wxMenuItem(menuFile, ID_Identify,
                   wxT("Identify"), wxT(""), wxITEM_RADIO);
  menuFile->Append(menuItem);
  menuFile->AppendSeparator();
  menuItem = new wxMenuItem(menuFile, ID_Printer, wxT("&Printer"));
  menuItem->SetBitmap(*BtnPrinter);
  menuFile->Append(menuItem);
  menuFile->AppendSeparator();
  menuItem = new wxMenuItem(menuFile, wxID_ABOUT, wxT("&About ..."));
  menuItem->SetBitmap(*BtnAbout);
  menuFile->Append(menuItem);
  menuFile->AppendSeparator();
  menuItem = new wxMenuItem(menuFile, wxID_EXIT, wxT("&Quit"));
  menuItem->SetBitmap(*BtnExit);
  menuFile->Append(menuItem);
  wxMenuBar *menuBar = new wxMenuBar;
  menuBar->Append(menuFile, wxT("&Menu"));
  SetMenuBar(menuBar);

//
// setting up menu initial state 
//
  menuBar->Enable(ID_AddLayer, true);
  menuBar->Enable(ID_Center, false);
  menuBar->Enable(ID_Identify, false);
  menuBar->Enable(ID_ZoomIn, false);
  menuBar->Enable(ID_ZoomOut, false);
  menuBar->Enable(ID_UserScale, false);
  menuBar->Enable(ID_Pan, false);
  menuBar->Enable(ID_Printer, false);

//
// setting up the toolbar
//      
  wxToolBar *toolBar = CreateToolBar();
  toolBar->AddTool(ID_AddLayer, wxT("Add a Map Layer"),
                   *BtnAddLayer, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Add a Map Layer"));
  toolBar->AddSeparator();
  toolBar->AddTool(ID_Center, wxT("Zoom to Full Extent"),
                   *BtnCenter, wxNullBitmap, wxITEM_NORMAL,
                   wxT("Zoom to Full Extent"));
  toolBar->AddTool(ID_ZoomIn, wxT("Zoom In"), *BtnZoomIn, wxNullBitmap,
                   wxITEM_RADIO, wxT("Zoom In"));
  toolBar->AddTool(ID_ZoomOut, wxT("Zoom Out"), *BtnZoomOut, wxNullBitmap,
                   wxITEM_RADIO, wxT("Zoom Out"));
  toolBar->AddTool(ID_UserScale, wxT("User defined Scale"), *BtnUserScale,
                   wxNullBitmap, wxITEM_RADIO, wxT("User defined Scale"));
  toolBar->AddTool(ID_Pan, wxT("Pan"), *BtnPan, wxNullBitmap, wxITEM_RADIO,
                   wxT("Pan"));
  toolBar->AddTool(ID_Identify, wxT("Identify"), *BtnIdentify, wxNullBitmap,
                   wxITEM_RADIO, wxT("Identify"));
  toolBar->AddSeparator();
  toolBar->AddTool(ID_Printer, wxT("Printer"),
                   *BtnPrinter, wxNullBitmap, wxITEM_NORMAL, wxT("Printer"));
  toolBar->AddSeparator();
  toolBar->AddTool(wxID_ABOUT, wxT("About ..."), *BtnAbout, wxNullBitmap,
                   wxITEM_NORMAL, wxT("About ..."));
  toolBar->AddSeparator();
  toolBar->AddTool(wxID_EXIT, wxT("Quit"), *BtnExit, wxNullBitmap,
                   wxITEM_NORMAL, wxT("Quit"));
  toolBar->Realize();
  SetToolBar(toolBar);

//
// setting up the toolbar initial state
//
  toolBar->EnableTool(ID_AddLayer, true);
  toolBar->EnableTool(ID_Center, false);
  toolBar->EnableTool(ID_Identify, false);
  toolBar->EnableTool(ID_ZoomIn, false);
  toolBar->EnableTool(ID_ZoomOut, false);
  toolBar->EnableTool(ID_UserScale, false);
  toolBar->EnableTool(ID_Pan, false);
  toolBar->EnableTool(ID_Printer, false);

//
// setting up event handlers for menu and toolbar
//
  Connect(ID_AddLayer, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnAddLayer);
  Connect(ID_Center, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnCenter);
  Connect(ID_Identify, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnIdentify);
  Connect(ID_ZoomIn, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnZoomIn);
  Connect(ID_ZoomOut, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnZoomOut);
  Connect(ID_UserScale, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnUserScale);
  Connect(ID_Pan, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnPan);
  Connect(ID_Printer, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnPrinter);
  Connect(wxID_ABOUT, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnAbout);
  Connect(wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED,
          (wxObjectEventFunction) & MyMapPanel::OnQuit);
}

MyMapPanel::~MyMapPanel()
{
//
// Map Panel frame destructor
//
  if (Parent != NULL)
    Parent->MapPanelClosing();
  Manager.UnInit();
  if (BtnAddLayer != NULL)
    delete BtnAddLayer;
  if (BtnCenter != NULL)
    delete BtnCenter;
  if (BtnIdentify != NULL)
    delete BtnIdentify;
  if (BtnZoomIn != NULL)
    delete BtnZoomIn;
  if (BtnZoomOut != NULL)
    delete BtnZoomOut;
  if (BtnUserScale != NULL)
    delete BtnUserScale;
  if (BtnPan != NULL)
    delete BtnPan;
  if (BtnPrinter != NULL)
    delete BtnPrinter;
  if (BtnAbout != NULL)
    delete BtnAbout;
  if (BtnExit != NULL)
    delete BtnExit;
}

void MyMapPanel::UpdateTools()
{
//
// updating the Tools State
//
  wxMenuBar *menuBar = GetMenuBar();
  menuBar->Enable(ID_AddLayer, true);
  if (MapView->IsValidMap() == false)
    {
      menuBar->Enable(ID_Center, false);
      menuBar->Enable(ID_ZoomIn, false);
      menuBar->Enable(ID_ZoomOut, false);
      menuBar->Enable(ID_UserScale, false);
      menuBar->Enable(ID_Pan, false);
      menuBar->Enable(ID_Identify, false);
      menuBar->Enable(ID_Printer, false);
  } else
    {
      menuBar->Enable(ID_Center, true);
      menuBar->Enable(ID_ZoomIn, true);
      menuBar->Enable(ID_ZoomOut, true);
      menuBar->Enable(ID_UserScale, true);
      menuBar->Enable(ID_Pan, true);
      if (MapView->CanIdentify() == true)
        menuBar->Enable(ID_Identify, true);
      else
        menuBar->Enable(ID_Identify, false);
      menuBar->Enable(ID_Printer, true);
    }

  wxToolBar *toolBar = GetToolBar();
  toolBar->EnableTool(ID_AddLayer, true);
  if (MapView->IsValidMap() == false)
    {
      toolBar->EnableTool(ID_Center, false);
      toolBar->EnableTool(ID_ZoomIn, false);
      toolBar->EnableTool(ID_ZoomOut, false);
      toolBar->EnableTool(ID_UserScale, false);
      toolBar->EnableTool(ID_Pan, false);
      toolBar->EnableTool(ID_Identify, false);
      toolBar->EnableTool(ID_Printer, false);
  } else
    {
      toolBar->EnableTool(ID_Center, true);
      toolBar->EnableTool(ID_ZoomIn, true);
      toolBar->EnableTool(ID_ZoomOut, true);
      toolBar->EnableTool(ID_UserScale, true);
      toolBar->EnableTool(ID_Pan, true);
      if (MapView->CanIdentify() == true)
        toolBar->EnableTool(ID_Identify, true);
      else
        toolBar->EnableTool(ID_Identify, false);
      toolBar->EnableTool(ID_Printer, true);
    }

  if (MapView->IsValidMap() == false)
    {
      IsIdentify = false;
      IsZoomIn = false;
      IsZoomOut = false;
      IsPan = false;
  } else
    {
      if (IsIdentify == false && IsPan == false && IsZoomOut == false)
        IsZoomIn = true;
      if (IsIdentify == true)
        {
          menuBar->Check(ID_Identify, true);
          toolBar->ToggleTool(ID_Identify, true);
        }
      if (IsPan == true)
        {
          menuBar->Check(ID_Pan, true);
          toolBar->ToggleTool(ID_Pan, true);
        }
      if (IsZoomIn == true)
        {
          menuBar->Check(ID_ZoomIn, true);
          toolBar->ToggleTool(ID_ZoomIn, true);
        }
      if (IsZoomOut == true)
        {
          menuBar->Check(ID_ZoomOut, true);
          toolBar->ToggleTool(ID_ZoomOut, true);
        }
    }
}

void MyMapPanel::OnAddLayer(wxCommandEvent & WXUNUSED(event))
{
//
// adding a Map Layer
//
  AddMapLayerDialog dlg;
  dlg.Create(this);
  int ret = dlg.ShowModal();
  if (ret == wxID_OK)
    {
      MapView->PrepareMap();
    }
}

void MyMapPanel::OnCenter(wxCommandEvent & WXUNUSED(event))
{
//
// resetting to Full Extent
//
  //MapView->SetFullExtent();
  MapView->PrepareMap();
}

void MyMapPanel::OnIdentify(wxCommandEvent & WXUNUSED(event))
{
//
// current map click is: Identify
//
  wxMenuBar *menuBar = GetMenuBar();
  wxToolBar *toolBar = GetToolBar();
  if (IsIdentify == false)
    {
      if (menuBar)
        menuBar->Check(ID_Identify, true);
      if (toolBar)
        toolBar->ToggleTool(ID_Identify, true);
      IsIdentify = true;
      IsZoomIn = false;
      IsZoomOut = false;
      IsPan = false;
    }
}

void MyMapPanel::OnZoomIn(wxCommandEvent & WXUNUSED(event))
{
//
// current map click is: ZoomIn
//
  wxMenuBar *menuBar = GetMenuBar();
  wxToolBar *toolBar = GetToolBar();
  if (IsZoomIn == false)
    {
      menuBar->Check(ID_ZoomIn, true);
      if (toolBar)
        toolBar->ToggleTool(ID_ZoomIn, true);
      IsIdentify = false;
      IsZoomIn = true;
      IsZoomOut = false;
      IsPan = false;
    }
}

void MyMapPanel::OnZoomOut(wxCommandEvent & WXUNUSED(event))
{
//
// current map click is: ZoomOut
//
  wxMenuBar *menuBar = GetMenuBar();
  wxToolBar *toolBar = GetToolBar();
  if (IsZoomOut == false)
    {
      if (menuBar)
        menuBar->Check(ID_ZoomOut, true);
      if (toolBar)
        toolBar->ToggleTool(ID_ZoomOut, true);
      IsIdentify = false;
      IsZoomIn = false;
      IsZoomOut = true;
      IsPan = false;
    }
}

void MyMapPanel::OnUserScale(wxCommandEvent & WXUNUSED(event))
{
//
// User selected Scale
//
}

void MyMapPanel::OnPrinter(wxCommandEvent & WXUNUSED(event))
{
//
// Printer
//
}

void MyMapPanel::OnPan(wxCommandEvent & WXUNUSED(event))
{
//
// current map click is: Pan
//
  wxMenuBar *menuBar = GetMenuBar();
  wxToolBar *toolBar = GetToolBar();
  if (IsPan == false)
    {
      if (menuBar)
        menuBar->Check(ID_Pan, true);
      if (toolBar)
        toolBar->ToggleTool(ID_Pan, true);
      IsIdentify = false;
      IsZoomIn = false;
      IsZoomOut = false;
      IsPan = true;
    }
}

void MyMapPanel::OnAbout(wxCommandEvent & WXUNUSED(event))
{
//
// ABOUT dialog - event handler
//
  char ver[128];
  wxAboutDialogInfo dlg;
  dlg.SetIcon(wxIcon(icon_info_xpm));
  dlg.SetName(wxT("spatialite_gui"));
  const char *version = VERSION;
  dlg.SetVersion(wxString::FromUTF8(version));
  wxString str = wxT("a GUI-tool for SQLite / SpatiaLite\n\n");
  sprintf(ver, "%d.%d.%d", wxMAJOR_VERSION, wxMINOR_VERSION, wxRELEASE_NUMBER);
  strcpy(ver, spatialite_target_cpu());
  str += wxT("Target CPU ") + wxString::FromUTF8(ver) + wxT("\n");
  dlg.SetDescription(str);
  dlg.SetCopyright(wxT("by Alessandro Furieri - 2008/2014"));
  dlg.SetWebSite(wxT("http://www.gaia-gis.it"));
  wxString license =
    wxT("This program is free software; you can redistribute it\n");
  license +=
    wxT("and/or modify it under the terms of the GNU General Public License\n");
  license += wxT("(GPL) as published by the Free Software Foundation\n\n");
  license +=
    wxT
    ("A copy of the GPL can be found at\nhttp://www.gnu.org/licenses/gpl.txt");
  dlg.SetLicense(license);
  ::wxAboutBox(dlg);
}

void MyMapPanel::ParentQuit()
{
//
// the Parent is quitting
//
  Parent = NULL;
  Close(true);
}

void MyMapPanel::OnQuit(wxCommandEvent & WXUNUSED(event))
{
//
// EXIT - event handler
//
  Close(true);
}

void MyBitmapCellRenderer::Draw(wxGrid & grid, wxGridCellAttr & attr,
                                wxDC & dc, const wxRect & rect, int row,
                                int col, bool isSelected)
{
// drawing a Graphic cell
  if (col == row && isSelected)
    row = col;                  // silencing stupid compiler warnings about unused args

  wxBitmap bmp = wxBitmap(Graphic);
  wxColour color = attr.GetBackgroundColour();
  if (grid.IsEnabled() == false)
    {
      color = wxSystemSettings::GetColour(wxSYS_COLOUR_MENU);
      wxImage img = Graphic.ConvertToGreyscale();
      bmp = wxBitmap(img);
    }
  dc.SetBrush(wxBrush(color));
  dc.SetPen(*wxTRANSPARENT_PEN);
  dc.DrawRectangle(rect);
  int x = (rect.GetWidth() - bmp.GetWidth()) / 2;
  int y = (rect.GetHeight() - bmp.GetHeight()) / 2;
  dc.DrawBitmap(bmp, rect.x + x, rect.y + y, true);
}

bool AddMapLayerDialog::Create(MyMapPanel * parent)
{
//
// creating the dialog
//
  MapPanel = parent;
  First = NULL;
  Last = NULL;
  if (wxDialog::Create(parent, wxID_ANY, wxT("Add Map Layer(s)")) == false)
    return false;
// populates individual controls
  DoLoadVectorCoverages();
  DoLoadTopoGeoCoverages();
  DoLoadTopoNetCoverages();
  DoLoadRasterCoverages();
  DoLoadWmsCoverages();
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
// centers the dialog window
  Centre();
  return true;
}

void AddMapLayerDialog::CreateControls()
{
//
// creating individual control and setting initial values
//
  wxBoxSizer *topSizer = new wxBoxSizer(wxVERTICAL);
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// first row: Layers list
  wxBoxSizer *listSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(listSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  Layers =
    new wxGrid(this, ID_LAYERS_LIST, wxDefaultPosition, wxSize(700, 400));
  int count = 0;
  LayerListItem *pL = First;
  while (pL)
    {
      // counting how many layers are there
      count++;
      pL = pL->GetNext();
    }
  Layers->CreateGrid(count, 5, wxGrid::wxGridSelectRows);
  Layers->SetColLabelValue(0, wxT("DB"));
  Layers->SetColLabelValue(1, wxT("Type"));
  Layers->SetColLabelValue(2, wxT("Name"));
  Layers->SetColLabelValue(3, wxT("Title"));
  Layers->SetColLabelValue(4, wxT("Abstract"));
  count = 0;
  wxString cell;
  pL = First;
  while (pL)
    {
      // feeding grid rows
      MyBitmapCellRenderer *renderer = new MyBitmapCellRenderer;
      wxBitmap bmp;
      switch (pL->GetLayerType())
        {
          case MAP_LAYER_VECTOR:
            switch (pL->GetGeometryType())
              {
                case 1:
                case 1001:
                case 2001:
                case 3001:
                case 4:
                case 1004:
                case 2004:
                case 3004:
                  bmp = wxBitmap(points_on_xpm);
                  break;
                case 2:
                case 1002:
                case 2002:
                case 3002:
                case 5:
                case 1005:
                case 2005:
                case 3005:
                  bmp = wxBitmap(linestrings_on_xpm);
                  break;
                case 3:
                case 1003:
                case 2003:
                case 3003:
                case 6:
                case 1006:
                case 2006:
                case 3006:
                  bmp = wxBitmap(polygons_on_xpm);
                  break;
                default:
                  bmp = wxBitmap(vector_xpm);
                  break;
              }
            break;
          case MAP_LAYER_TOPOLOGY:
            bmp = wxBitmap(topo_geo_xpm);
            break;
          case MAP_LAYER_NETWORK:
            bmp = wxBitmap(topo_net_xpm);
            break;
          case MAP_LAYER_RASTER:
            bmp = wxBitmap(coverage_xpm);
            break;
          case MAP_LAYER_WMS:
            bmp = wxBitmap(wms_xpm);
            break;
          default:
            pL = pL->GetNext();
            continue;
        };
      renderer->SetGraphic(bmp);
      Layers->SetCellValue(count, 0, pL->GetDbPrefix());
      Layers->SetCellRenderer(count, 1, renderer);
      if (pL->GetLayerType() == MAP_LAYER_VECTOR)
        {
          wxString prefixName = pL->GetLayerPrefix();
          prefixName += wxT(".");
          prefixName += pL->GetLayerName();
          Layers->SetCellValue(count, 2, prefixName);
      } else
        Layers->SetCellValue(count, 2, pL->GetLayerName());
      Layers->SetCellValue(count, 3, pL->GetTitle());
      Layers->SetCellValue(count, 4, pL->GetAbstract());
      count++;
      pL = pL->GetNext();
    }
  Layers->SetRowLabelSize(wxGRID_AUTOSIZE);
  Layers->AutoSize();
  Layers->EnableEditing(false);
  listSizer->Add(Layers, 0, wxALIGN_RIGHT | wxALL, 5);
// OK - CANCEL buttons
  wxBoxSizer *okCancelBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(okCancelBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&OK"));
  okCancelBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
  okCancelBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// appends event handler for OK button
  Connect(wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED,
          (wxObjectEventFunction) & AddMapLayerDialog::OnOk);
}

void AddMapLayerDialog::FlushList()
{
// resetting the Layers List
  LayerListItem *pL;
  LayerListItem *pLn;
  pL = First;
  while (pL)
    {
      pLn = pL->GetNext();
      delete pL;
      pL = pLn;
    }
  First = NULL;
  Last = NULL;
}

LayerListItem::LayerListItem(wxString & db_prefix, int layer_type,
                             wxString & name, wxString & title,
                             wxString & abstract, bool queryable)
{
// ctor - Raster or WMS Layer
  DbPrefix = db_prefix;
  if (layer_type == MAP_LAYER_RASTER || layer_type == MAP_LAYER_WMS)
    LayerType = layer_type;
  else
    LayerType = MAP_LAYER_UNKNOWN;
  LayerName = name;
  Title = title;
  Abstract = abstract;
  f_table_name = NULL;
  f_geometry_column = NULL;
  topology_name = NULL;
  network_name = NULL;
  GeometryType = -1;
  HasZ = false;
  NativeSrid = -1;
  Queryable = queryable;
  Editable = false;
  SpatialIndex = false;
  Next = NULL;
}

LayerListItem::LayerListItem(wxString & db_prefix, wxString & layer_prefix,
                             wxString & name, wxString & title,
                             wxString & abstract, const char *table_name,
                             const char *geometry_column, int geom_type,
                             int srid, bool queryable, bool editable,
                             bool spatial_index)
{
// ctor - Vector Layer
  int len;
  DbPrefix = db_prefix;
  LayerPrefix = layer_prefix;
  LayerType = MAP_LAYER_VECTOR;
  LayerName = name;
  Title = title;
  Abstract = abstract;
  len = strlen(table_name);
  f_table_name = (char *) malloc(len + 1);
  strcpy(f_table_name, table_name);
  len = strlen(geometry_column);
  f_geometry_column = (char *) malloc(len + 1);
  strcpy(f_geometry_column, geometry_column);
  topology_name = NULL;
  network_name = NULL;
  GeometryType = geom_type;
  HasZ = false;
  NativeSrid = srid;
  Queryable = queryable;
  Editable = editable;
  SpatialIndex = spatial_index;
  Next = NULL;
}

LayerListItem::LayerListItem(wxString & db_prefix, int type, wxString & name,
                             wxString & title, wxString & abstract,
                             const char *topo_name, bool has_z, int srid,
                             bool queryable, bool editable)
{
// ctor - TopoGeo or TopoNet Layer
  int len;
  DbPrefix = db_prefix;
  if (type == MAP_LAYER_TOPOLOGY || type == MAP_LAYER_NETWORK)
    LayerType = type;
  else
    LayerType = MAP_LAYER_UNKNOWN;
  LayerName = name;
  Title = title;
  Abstract = abstract;
  f_table_name = NULL;
  f_geometry_column = NULL;
  if (type == MAP_LAYER_TOPOLOGY)
    {
      len = strlen(topo_name);
      topology_name = (char *) malloc(len + 1);
      strcpy(topology_name, topo_name);
  } else
    topology_name = NULL;
  if (type == MAP_LAYER_NETWORK)
    {
      len = strlen(topo_name);
      network_name = (char *) malloc(len + 1);
      strcpy(network_name, topo_name);
  } else
    network_name = NULL;
  GeometryType = -1;
  HasZ = has_z;
  NativeSrid = srid;
  Queryable = queryable;
  Editable = editable;
  SpatialIndex = false;
  Next = NULL;
}

LayerListItem::~LayerListItem()
{
// dtor
  if (f_table_name != NULL)
    free(f_table_name);
  if (f_geometry_column != NULL)
    free(f_geometry_column);
  if (topology_name != NULL)
    free(topology_name);
  if (network_name != NULL)
    free(network_name);
}

void AddMapLayerDialog::AddLayer2List(wxString & db_prefix, int layer_type,
                                      wxString & name, wxString & title,
                                      wxString & abstract, bool queryable)
{
// adding a layer item to the list
  LayerListItem *pL =
    new LayerListItem(db_prefix, layer_type, name, title, abstract, queryable);
  if (First == NULL)
    First = pL;
  if (Last != NULL)
    Last->SetNext(pL);
  Last = pL;
}

void AddMapLayerDialog::AddLayer2List(wxString & db_prefix,
                                      wxString & layer_prefix, wxString & name,
                                      wxString & title, wxString & abstract,
                                      const char *f_table_name,
                                      const char *f_geometry_column,
                                      int geom_type, int srid, bool queryable,
                                      bool editable, bool spatial_index)
{
// adding a layer item to the list
  LayerListItem *pL =
    new LayerListItem(db_prefix, layer_prefix, name, title, abstract,
                      f_table_name, f_geometry_column,
                      geom_type, srid, queryable, editable, spatial_index);
  if (First == NULL)
    First = pL;
  if (Last != NULL)
    Last->SetNext(pL);
  Last = pL;
}

void AddMapLayerDialog::AddLayer2List(wxString & db_prefix, int layer_type,
                                      wxString & name, wxString & title,
                                      wxString & abstract,
                                      const char *topo_name, bool has_z,
                                      int srid, bool queryable, bool editable)
{
// adding a layer item to the list
  LayerListItem *pL =
    new LayerListItem(db_prefix, layer_type, name, title, abstract, topo_name,
                      has_z, srid,
                      queryable, editable);
  if (First == NULL)
    First = pL;
  if (Last != NULL)
    Last->SetNext(pL);
  Last = pL;
}

bool AddMapLayerDialog::DoCheckGeometryColumns(const char *db_prefix)
{
// checking GEOMETRY_COLUMNS for validity
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  bool ok_table_name = false;
  bool ok_geometry_column = false;
  bool ok_geometry_type = false;
  bool ok_srid = false;
  bool ok_spatial_index = false;
  char *qprefix = gaiaDoubleQuotedSql(db_prefix);
  char *sql =
    sqlite3_mprintf("PRAGMA \"%s\".table_info(geometry_columns)", qprefix);
  free(qprefix);
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          if (strcasecmp(value, "f_table_name") == 0)
            ok_table_name = true;
          if (strcasecmp(value, "f_geometry_column") == 0)
            ok_geometry_column = true;
          if (strcasecmp(value, "geometry_type") == 0)
            ok_geometry_type = true;
          if (strcasecmp(value, "srid") == 0)
            ok_srid = true;
          if (strcasecmp(value, "spatial_index_enabled") == 0)
            ok_spatial_index = true;
        }
    }
  sqlite3_free_table(results);
  if (ok_table_name && ok_geometry_column && ok_geometry_type && ok_srid
      && ok_spatial_index)
    return true;
  return false;
}

bool AddMapLayerDialog::DoCheckViewsGeometryColumns(const char *db_prefix)
{
// checking VIEWS_GEOMETRY_COLUMNS for validity
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  bool ok_view_name = false;
  bool ok_view_geometry = false;
  bool ok_view_rowid = false;
  bool ok_f_table_name = false;
  bool ok_f_geometry_column = false;
  bool ok_read_only = false;
  char *qprefix = gaiaDoubleQuotedSql(db_prefix);
  char *sql =
    sqlite3_mprintf("PRAGMA \"%s\".table_info(views_geometry_columns)",
                    qprefix);
  free(qprefix);
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          if (strcasecmp(value, "view_name") == 0)
            ok_view_name = true;
          if (strcasecmp(value, "view_geometry") == 0)
            ok_view_geometry = true;
          if (strcasecmp(value, "view_rowid") == 0)
            ok_view_rowid = true;
          if (strcasecmp(value, "f_table_name") == 0)
            ok_f_table_name = true;
          if (strcasecmp(value, "f_geometry_column") == 0)
            ok_f_geometry_column = true;
          if (strcasecmp(value, "read_only") == 0)
            ok_read_only = true;
        }
    }
  sqlite3_free_table(results);
  if (ok_view_name && ok_view_geometry && ok_view_rowid && ok_f_table_name
      && ok_f_geometry_column && ok_read_only)
    return true;
  return false;
}

bool AddMapLayerDialog::DoCheckVirtsGeometryColumns(const char *db_prefix)
{
// checking VIRTS_GEOMETRY_COLUMNS for validity
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  bool ok_virt_name = false;
  bool ok_virt_geometry = false;
  bool ok_geometry_type = false;
  bool ok_srid = false;
  char *qprefix = gaiaDoubleQuotedSql(db_prefix);
  char *sql =
    sqlite3_mprintf("PRAGMA \"%s\".table_info(virts_geometry_columns)",
                    qprefix);
  free(qprefix);
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          if (strcasecmp(value, "virt_name") == 0)
            ok_virt_name = true;
          if (strcasecmp(value, "virt_geometry") == 0)
            ok_virt_geometry = true;
          if (strcasecmp(value, "geometry_type") == 0)
            ok_geometry_type = true;
          if (strcasecmp(value, "srid") == 0)
            ok_srid = true;
        }
    }
  sqlite3_free_table(results);
  if (ok_virt_name && ok_virt_geometry && ok_geometry_type && ok_srid)
    return true;
  return false;
}

bool AddMapLayerDialog::DoCheckVectorCoverages(const char *db_prefix)
{
// checking VECTOR_COVERAGES for validity
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  bool ok_coverage_name = false;
  bool ok_table_name = false;
  bool ok_geometry_column = false;
  bool ok_topology_name = false;
  bool ok_network_name = false;
  bool ok_view_name = false;
  bool ok_view_geometry = false;
  bool ok_virt_name = false;
  bool ok_virt_geometry = false;
  bool ok_geo_minx = false;
  bool ok_geo_miny = false;
  bool ok_geo_maxx = false;
  bool ok_geo_maxy = false;
  bool ok_ext_minx = false;
  bool ok_ext_miny = false;
  bool ok_ext_maxx = false;
  bool ok_ext_maxy = false;
  bool ok_title = false;
  bool ok_abstract = false;
  bool ok_queryable = false;
  bool ok_editable = false;
  char *qprefix = gaiaDoubleQuotedSql(db_prefix);
  char *sql =
    sqlite3_mprintf("PRAGMA \"%s\".table_info(vector_coverages)", qprefix);
  free(qprefix);
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          if (strcasecmp(value, "coverage_name") == 0)
            ok_coverage_name = true;
          if (strcasecmp(value, "f_table_name") == 0)
            ok_table_name = true;
          if (strcasecmp(value, "f_geometry_column") == 0)
            ok_geometry_column = true;
          if (strcasecmp(value, "topology_name") == 0)
            ok_topology_name = true;
          if (strcasecmp(value, "network_name") == 0)
            ok_network_name = true;
          if (strcasecmp(value, "view_name") == 0)
            ok_view_name = true;
          if (strcasecmp(value, "view_geometry") == 0)
            ok_view_geometry = true;
          if (strcasecmp(value, "virt_name") == 0)
            ok_virt_name = true;
          if (strcasecmp(value, "virt_geometry") == 0)
            ok_virt_geometry = true;
          if (strcasecmp(value, "geo_minx") == 0)
            ok_geo_minx = true;
          if (strcasecmp(value, "geo_miny") == 0)
            ok_geo_miny = true;
          if (strcasecmp(value, "geo_maxx") == 0)
            ok_geo_maxx = true;
          if (strcasecmp(value, "geo_maxy") == 0)
            ok_geo_maxy = true;
          if (strcasecmp(value, "extent_minx") == 0)
            ok_ext_minx = true;
          if (strcasecmp(value, "extent_miny") == 0)
            ok_ext_miny = true;
          if (strcasecmp(value, "extent_maxx") == 0)
            ok_ext_maxx = true;
          if (strcasecmp(value, "extent_maxy") == 0)
            ok_ext_maxy = true;
          if (strcasecmp(value, "title") == 0)
            ok_title = true;
          if (strcasecmp(value, "abstract") == 0)
            ok_abstract = true;
          if (strcasecmp(value, "is_queryable") == 0)
            ok_queryable = true;
          if (strcasecmp(value, "is_editable") == 0)
            ok_editable = true;
        }
    }
  sqlite3_free_table(results);
  if (ok_coverage_name && ok_table_name && ok_geometry_column
      && ok_topology_name && ok_network_name && ok_view_name && ok_view_geometry
      && ok_virt_name && ok_virt_geometry && ok_geo_minx && ok_geo_miny
      && ok_geo_maxx && ok_geo_maxy && ok_ext_minx && ok_ext_miny && ok_ext_maxx
      && ok_ext_maxy && ok_title && ok_abstract && ok_queryable && ok_editable)
    return true;
  return false;
}

bool AddMapLayerDialog::DoCheckTopologies(const char *db_prefix)
{
// checking TOPOLOGIES for validity
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  bool ok_topology_name = false;
  bool ok_srid = false;
  bool ok_has_z = false;
  char *qprefix = gaiaDoubleQuotedSql(db_prefix);
  char *sql = sqlite3_mprintf("PRAGMA \"%s\".table_info(topologies)", qprefix);
  free(qprefix);
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          if (strcasecmp(value, "topology_name") == 0)
            ok_topology_name = true;
          if (strcasecmp(value, "srid") == 0)
            ok_srid = true;
          if (strcasecmp(value, "has_z") == 0)
            ok_has_z = true;
        }
    }
  sqlite3_free_table(results);
  if (ok_topology_name && ok_srid && ok_has_z)
    return true;
  return false;
}

bool AddMapLayerDialog::DoCheckNetworks(const char *db_prefix)
{
// checking NETWORKS for validity
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  bool ok_network_name = false;
  bool ok_srid = false;
  bool ok_has_z = false;
  char *qprefix = gaiaDoubleQuotedSql(db_prefix);
  char *sql = sqlite3_mprintf("PRAGMA \"%s\".table_info(networks)", qprefix);
  free(qprefix);
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          if (strcasecmp(value, "network_name") == 0)
            ok_network_name = true;
          if (strcasecmp(value, "srid") == 0)
            ok_srid = true;
          if (strcasecmp(value, "has_z") == 0)
            ok_has_z = true;
        }
    }
  sqlite3_free_table(results);
  if (ok_network_name && ok_srid && ok_has_z)
    return true;
  return false;
}

bool AddMapLayerDialog::DoCheckRasterCoverages(const char *db_prefix)
{
// checking RASTER_COVERAGES for validity
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  bool ok_coverage_name = false;
  bool ok_title = false;
  bool ok_abstract = false;
  bool ok_queryable = false;
  char *qprefix = gaiaDoubleQuotedSql(db_prefix);
  char *sql =
    sqlite3_mprintf("PRAGMA \"%s\".table_info(raster_coverages)", qprefix);
  free(qprefix);
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          if (strcasecmp(value, "coverage_name") == 0)
            ok_coverage_name = true;
          if (strcasecmp(value, "title") == 0)
            ok_title = true;
          if (strcasecmp(value, "abstract") == 0)
            ok_abstract = true;
          if (strcasecmp(value, "is_queryable") == 0)
            ok_queryable = true;
        }
    }
  sqlite3_free_table(results);
  if (ok_coverage_name && ok_title && ok_abstract && ok_queryable)
    return true;
  return false;
}

bool AddMapLayerDialog::DoCheckWmsCoverages(const char *db_prefix)
{
// checking WMS_GETMAP for validity
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  bool ok_layer_name = false;
  bool ok_title = false;
  bool ok_abstract = false;
  bool ok_queryable = false;
  char *qprefix = gaiaDoubleQuotedSql(db_prefix);
  char *sql = sqlite3_mprintf("PRAGMA \"%s\".table_info(wms_getmap)", qprefix);
  free(qprefix);
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          if (strcasecmp(value, "layer_name") == 0)
            ok_layer_name = true;
          if (strcasecmp(value, "title") == 0)
            ok_title = true;
          if (strcasecmp(value, "abstract") == 0)
            ok_abstract = true;
          if (strcasecmp(value, "is_queryable") == 0)
            ok_queryable = true;
        }
    }
  sqlite3_free_table(results);
  if (ok_layer_name && ok_title && ok_abstract && ok_queryable)
    return true;
  return false;
}

char *AddMapLayerDialog::QueryVectorCoverages(const char *db_prefix,
                                              const char *old_sql)
{
// GeoTable Vector Coverages - composing the SQL query
  char *sql = NULL;
  char *qprefix;

  if (DoCheckVectorCoverages(db_prefix) == false
      || DoCheckGeometryColumns(db_prefix) == false)
    {
      if (old_sql != NULL)
        return sqlite3_mprintf("%s", old_sql);
      else
        return NULL;
    }

  qprefix = gaiaDoubleQuotedSql(db_prefix);
  if (old_sql == NULL)
    {
      sql = sqlite3_mprintf("SELECT %Q AS db_prefix, 'table' AS prefix, "
                            "v.coverage_name, v.title, v.abstract, v.is_queryable, v.is_editable, "
                            "v.f_table_name, v.f_geometry_column, g.srid, g.geometry_type, "
                            "g.spatial_index_enabled FROM \"%s\".vector_coverages AS v "
                            "JOIN \"%s\".geometry_columns AS g ON (v.f_table_name = g.f_table_name AND "
                            "v.f_geometry_column = g.f_geometry_column) "
                            "WHERE v.topology_name IS NULL AND v.network_name IS NULL",
                            db_prefix, qprefix, qprefix);
  } else
    {
      sql =
        sqlite3_mprintf("%s\nUNION\nSELECT %Q AS db_prefix, 'table' AS prefix, "
                        "v.coverage_name, v.title, v.abstract, v.is_queryable, v.is_editable, "
                        "v.f_table_name, v.f_geometry_column, g.srid, g.geometry_type, "
                        "g.spatial_index_enabled FROM \"%s\".vector_coverages AS v "
                        "JOIN \"%s\".geometry_columns AS g ON (v.f_table_name = g.f_table_name AND "
                        "v.f_geometry_column = g.f_geometry_column) "
                        "WHERE v.topology_name IS NULL AND v.network_name IS NULL",
                        old_sql, db_prefix, qprefix, qprefix);
    }
  free(qprefix);
  return sql;
}

char *AddMapLayerDialog::QuerySpatialViewCoverages(const char *db_prefix,
                                                   const char *old_sql)
{
// SpatialView Vector Coverages - composing the SQL query
  char *sql = NULL;
  char *qprefix;

  if (DoCheckVectorCoverages(db_prefix) == false
      || DoCheckViewsGeometryColumns(db_prefix) == false
      || DoCheckGeometryColumns(db_prefix) == false)
    {
      if (old_sql != NULL)
        return sqlite3_mprintf("%s", old_sql);
      else
        return NULL;
    }

  qprefix = gaiaDoubleQuotedSql(db_prefix);
  if (old_sql == NULL)
    {
      sql = sqlite3_mprintf("SELECT %Q AS db_prefix, 'view' AS prefix, "
                            "v.coverage_name, v.title, v.abstract, v.is_queryable, v.is_editable, "
                            "v.view_name, v.view_geometry, g.srid, g.geometry_type, g.spatial_index_enabled "
                            "FROM \"%s\".vector_coverages AS v "
                            "JOIN \"%s\".views_geometry_columns AS x ON (v.view_name = x.view_name AND "
                            "v.view_geometry = x.view_geometry) "
                            "JOIN \"%s\".geometry_columns AS g ON (x.f_table_name = g.f_table_name AND "
                            "x.f_geometry_column = g.f_geometry_column) "
                            "WHERE v.view_name IS NOT NULL AND v.view_geometry IS NOT NULL",
                            db_prefix, qprefix, qprefix, qprefix);
  } else
    {
      sql =
        sqlite3_mprintf("%s\nUNION\nSELECT %Q AS db_prefix, 'view' AS prefix, "
                        "v.coverage_name, v.title, v.abstract, v.is_queryable, v.is_editable, "
                        "v.view_name, v.view_geometry, g.srid, g.geometry_type, g.spatial_index_enabled "
                        "FROM \"%s\".vector_coverages AS v "
                        "JOIN \"%s\".views_geometry_columns AS x ON (v.view_name = x.view_name AND "
                        "v.view_geometry = x.view_geometry) "
                        "JOIN \"%s\".geometry_columns AS g ON (x.f_table_name = g.f_table_name AND "
                        "x.f_geometry_column = g.f_geometry_column) "
                        "WHERE v.view_name IS NOT NULL AND v.view_geometry IS NOT NULL",
                        old_sql, db_prefix, qprefix, qprefix, qprefix);
    }
  free(qprefix);
  return sql;
}

char *AddMapLayerDialog::QueryVirtualShapeCoverages(const char *db_prefix,
                                                    const char *old_sql)
{
// VirtualShape Vector Coverages - composing the SQL query
  char *sql = NULL;
  char *qprefix;

  if (DoCheckVectorCoverages(db_prefix) == false
      || DoCheckVirtsGeometryColumns(db_prefix) == false)
    {
      if (old_sql != NULL)
        return sqlite3_mprintf("%s", old_sql);
      else
        return NULL;
    }

  qprefix = gaiaDoubleQuotedSql(db_prefix);
  if (old_sql == NULL)
    {
      sql = sqlite3_mprintf("SELECT %Q AS db_prefix, 'shp' AS prefix, "
                            "c.coverage_name, c.title, c.abstract, c.is_queryable, 0, v.virt_name, "
                            "v.virt_geometry, v.srid, v.geometry_type, 0 "
                            "FROM \"%s\".vector_coverages AS c "
                            "JOIN \"%s\".virts_geometry_columns AS v ON (c.virt_name = v.virt_name "
                            "AND c.virt_geometry = v.virt_geometry) "
                            "WHERE c.virt_name IS NOT NULL AND c.virt_geometry IS NOT NULL",
                            db_prefix, qprefix, qprefix);
  } else
    {
      sql =
        sqlite3_mprintf("%s\nUNION\nSELECT %Q AS db_prefix, 'shp' AS prefix, "
                        "c.coverage_name, c.title, c.abstract, c.is_queryable, 0, v.virt_name, "
                        "v.virt_geometry, v.srid, v.geometry_type, 0 "
                        "FROM \"%s\".vector_coverages AS c "
                        "JOIN \"%s\".virts_geometry_columns AS v ON (c.virt_name = v.virt_name "
                        "AND c.virt_geometry = v.virt_geometry) "
                        "WHERE c.virt_name IS NOT NULL AND c.virt_geometry IS NOT NULL",
                        old_sql, db_prefix, qprefix, qprefix);
    }
  free(qprefix);
  return sql;
}

char *AddMapLayerDialog::QueryTopoGeoCoverages(const char *db_prefix,
                                               const char *old_sql)
{
// TopoGeo Vector Coverages - composing the SQL query
  char *sql = NULL;
  char *qprefix;

  if (DoCheckVectorCoverages(db_prefix) == false
      || DoCheckTopologies(db_prefix) == false)
    {
      if (old_sql != NULL)
        return sqlite3_mprintf("%s", old_sql);
      else
        return NULL;
    }

  qprefix = gaiaDoubleQuotedSql(db_prefix);
  if (old_sql == NULL)
    {
      sql = sqlite3_mprintf("SELECT %Q AS db_prefix, "
                            "v.coverage_name, v.title, v.abstract, v.is_queryable, v.is_editable, "
                            "t.topology_name, t.srid, t.has_z "
                            "FROM \"%s\".vector_coverages AS v "
                            "JOIN \"%s\".topologies AS t ON (v.topology_name = t.topology_name) "
                            "WHERE v.topology_name IS NOT NULL AND v.network_name IS NULL",
                            db_prefix, qprefix, qprefix);
  } else
    {
      sql = sqlite3_mprintf("%s\nUNION\nSELECT %Q AS db_prefix, "
                            "v.coverage_name, v.title, v.abstract, v.is_queryable, v.is_editable, "
                            "t.topology_name, t.srid, t.has_z "
                            "FROM \"%s\".vector_coverages AS v "
                            "JOIN \"%s\".topologies AS t ON (v.topology_name = t.topology_name) "
                            "WHERE v.topology_name IS NOT NULL AND v.network_name IS NULL",
                            old_sql, db_prefix, qprefix, qprefix);
    }
  free(qprefix);
  return sql;
}

char *AddMapLayerDialog::QueryTopoNetCoverages(const char *db_prefix,
                                               const char *old_sql)
{
// TopoNet Vector Coverages - composing the SQL query
  char *sql = NULL;
  char *qprefix;

  if (DoCheckVectorCoverages(db_prefix) == false
      || DoCheckNetworks(db_prefix) == false)
    {
      if (old_sql != NULL)
        return sqlite3_mprintf("%s", old_sql);
      else
        return NULL;
    }

  qprefix = gaiaDoubleQuotedSql(db_prefix);
  if (old_sql == NULL)
    {
      sql = sqlite3_mprintf("SELECT %Q AS db_prefix, "
                            "v.coverage_name, v.title, v.abstract, v.is_queryable, v.is_editable, "
                            "n.network_name, n.srid, n.has_z "
                            "FROM \"%s\".vector_coverages AS v "
                            "JOIN \"%s\".networks AS n ON (v.network_name = n.network_name) "
                            "WHERE v.topology_name IS NULL AND v.network_name IS NOT NULL",
                            db_prefix, qprefix, qprefix);
  } else
    {
      sql = sqlite3_mprintf("%s\nUNION\nSELECT %Q AS db_prefix, "
                            "v.coverage_name, v.title, v.abstract, v.is_queryable, v.is_editable, "
                            "n.network_name, n.srid, n.has_z "
                            "FROM \"%s\".vector_coverages AS v "
                            "JOIN \"%s\".networks AS n ON (v.network_name = n.network_name) "
                            "WHERE v.topology_name IS NULL AND v.network_name IS NOT NULL",
                            old_sql, db_prefix, qprefix, qprefix);
    }
  free(qprefix);
  return sql;
}

char *AddMapLayerDialog::QueryRasterCoverages(const char *db_prefix,
                                              const char *old_sql)
{
// Raster Coverages - composing the SQL query
  char *sql = NULL;
  char *qprefix;

  if (DoCheckRasterCoverages(db_prefix) == false)
    {
      if (old_sql != NULL)
        return sqlite3_mprintf("%s", old_sql);
      else
        return NULL;
    }

  qprefix = gaiaDoubleQuotedSql(db_prefix);
  if (old_sql == NULL)
    {
      sql = sqlite3_mprintf("SELECT %Q AS db_prefix, "
                            "coverage_name, title, abstract, is_queryable "
                            "FROM \"%s\".raster_coverages ", db_prefix,
                            qprefix);
  } else
    {
      sql = sqlite3_mprintf("%s\nUNION\nSELECT %Q AS db_prefix, "
                            "coverage_name, title, abstract, is_queryable "
                            "FROM \"%s\".raster_coverages ", old_sql, db_prefix,
                            qprefix);
    }
  free(qprefix);
  return sql;
}

char *AddMapLayerDialog::QueryWmsCoverages(const char *db_prefix,
                                           const char *old_sql)
{
// WMS Coverages - composing the SQL query
  char *sql = NULL;
  char *qprefix;

  if (DoCheckWmsCoverages(db_prefix) == false)
    {
      if (old_sql != NULL)
        return sqlite3_mprintf("%s", old_sql);
      else
        return NULL;
    }

  qprefix = gaiaDoubleQuotedSql(db_prefix);
  if (old_sql == NULL)
    {
      sql = sqlite3_mprintf("SELECT %Q AS db_prefix, "
                            "layer_name, title, abstract, is_queryable "
                            "FROM \"%s\".wms_getmap ", db_prefix, qprefix);
  } else
    {
      sql = sqlite3_mprintf("%s\nUNION\nSELECT %Q AS db_prefix, "
                            "layer_name, title, abstract, is_queryable "
                            "FROM \"%s\".wms_getmap ", old_sql, db_prefix,
                            qprefix);
    }
  free(qprefix);
  return sql;
}

void AddMapLayerDialog::DoLoadVectorCoverages()
{
// populating the layers list (Vector Coverages)
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;
  char *sql2 = NULL;
  char *sql_save = NULL;

  sql = "pragma database_list";
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          // searching for GeoTables
          sql_save = sql2;
          sql2 = QueryVectorCoverages(value, sql_save);
          if (sql_save != NULL)
            sqlite3_free(sql_save);
          // searching for SpatialViews
          sql_save = sql2;
          sql2 = QuerySpatialViewCoverages(value, sql_save);
          if (sql_save != NULL)
            sqlite3_free(sql_save);
          // searching for VirtualShapes
          sql_save = sql2;
          sql2 = QueryVirtualShapeCoverages(value, sql_save);
          if (sql_save != NULL)
            sqlite3_free(sql_save);
        }
    }
  sqlite3_free_table(results);
  if (sql2 == NULL)
    return;

  sql_save = sql2;
  sql2 =
    sqlite3_mprintf("%s\nORDER BY v.coverage_name, db_prefix, prefix",
                    sql_save);
  sqlite3_free(sql_save);
  ret = sqlite3_get_table(sqlite, sql2, &results, &rows, &columns, &errMsg);
  sqlite3_free(sql2);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString db_prefix = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString prefix = wxString::FromUTF8(value);
          value = results[(i * columns) + 2];
          wxString name = wxString::FromUTF8(value);
          value = results[(i * columns) + 3];
          wxString title = wxString::FromUTF8(value);
          value = results[(i * columns) + 4];
          wxString abstract = wxString::FromUTF8(value);
          bool queryable = false;
          value = results[(i * columns) + 5];
          if (atoi(value))
            queryable = true;
          bool editable = false;
          value = results[(i * columns) + 6];
          if (atoi(value))
            editable = true;
          const char *f_table_name = results[(i * columns) + 7];
          const char *f_geometry_column = results[(i * columns) + 8];
          value = results[(i * columns) + 9];
          int srid = atoi(value);
          value = results[(i * columns) + 10];
          int geom_type = atoi(value);
          bool spatial_index = false;
          value = results[(i * columns) + 11];
          if (atoi(value) == 1)
            spatial_index = true;
          AddLayer2List(db_prefix, prefix, name, title, abstract, f_table_name,
                        f_geometry_column, geom_type, srid, queryable,
                        editable, spatial_index);
        }
    }
  sqlite3_free_table(results);
}

void AddMapLayerDialog::DoLoadTopoGeoCoverages()
{
// populating the layers list (TopoGeo Coverages)
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;
  char *sql2 = NULL;
  char *sql_save = NULL;

  sql = "pragma database_list";
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          sql_save = sql2;
          sql2 = QueryTopoGeoCoverages(value, sql_save);
          if (sql_save != NULL)
            sqlite3_free(sql_save);
        }
    }
  sqlite3_free_table(results);
  if (sql2 == NULL)
    return;

  sql_save = sql2;
  sql2 = sqlite3_mprintf("%s\nORDER BY v.coverage_name, db_prefix", sql_save);
  sqlite3_free(sql_save);
  ret = sqlite3_get_table(sqlite, sql2, &results, &rows, &columns, &errMsg);
  sqlite3_free(sql2);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString db_prefix = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString name = wxString::FromUTF8(value);
          value = results[(i * columns) + 2];
          wxString title = wxString::FromUTF8(value);
          value = results[(i * columns) + 3];
          wxString abstract = wxString::FromUTF8(value);
          bool queryable = false;
          value = results[(i * columns) + 4];
          if (atoi(value))
            queryable = true;
          bool editable = false;
          value = results[(i * columns) + 5];
          if (atoi(value))
            editable = true;
          const char *topology_name = results[(i * columns) + 6];
          bool has_z = false;
          value = results[(i * columns) + 7];
          if (atoi(value))
            has_z = true;
          value = results[(i * columns) + 8];
          int srid = atoi(value);
          AddLayer2List(db_prefix, MAP_LAYER_TOPOLOGY, name, title, abstract,
                        topology_name, has_z, srid, queryable, editable);
        }
    }
  sqlite3_free_table(results);
}

void AddMapLayerDialog::DoLoadTopoNetCoverages()
{
// populating the layers list (TopoNet Coverages)
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;
  char *sql2 = NULL;
  char *sql_save = NULL;

  sql = "pragma database_list";
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          sql_save = sql2;
          sql2 = QueryTopoNetCoverages(value, sql_save);
          if (sql_save != NULL)
            sqlite3_free(sql_save);
        }
    }
  sqlite3_free_table(results);
  if (sql2 == NULL)
    return;

  sql_save = sql2;
  sql2 = sqlite3_mprintf("%s\nORDER BY v.coverage_name, db_prefix", sql_save);
  sqlite3_free(sql_save);
  ret = sqlite3_get_table(sqlite, sql2, &results, &rows, &columns, &errMsg);
  sqlite3_free(sql2);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString db_prefix = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString name = wxString::FromUTF8(value);
          value = results[(i * columns) + 2];
          wxString title = wxString::FromUTF8(value);
          value = results[(i * columns) + 3];
          wxString abstract = wxString::FromUTF8(value);
          bool queryable = false;
          value = results[(i * columns) + 4];
          if (atoi(value))
            queryable = true;
          bool editable = false;
          value = results[(i * columns) + 5];
          if (atoi(value))
            editable = true;
          const char *network_name = results[(i * columns) + 6];
          bool has_z = false;
          value = results[(i * columns) + 7];
          if (atoi(value))
            has_z = true;
          value = results[(i * columns) + 8];
          int srid = atoi(value);
          AddLayer2List(db_prefix, MAP_LAYER_NETWORK, name, title, abstract,
                        network_name, has_z, srid, queryable, editable);
        }
    }
  sqlite3_free_table(results);
}

void AddMapLayerDialog::DoLoadRasterCoverages()
{
// populating the layers list (Raster Coverages)
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;
  char *sql2 = NULL;
  char *sql_save = NULL;

  sql = "pragma database_list";
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          sql_save = sql2;
          sql2 = QueryRasterCoverages(value, sql_save);
          if (sql_save != NULL)
            sqlite3_free(sql_save);
        }
    }
  sqlite3_free_table(results);
  if (sql2 == NULL)
    return;

  sql_save = sql2;
  sql2 = sqlite3_mprintf("%s\nORDER BY coverage_name, db_prefix", sql_save);
  sqlite3_free(sql_save);
  ret = sqlite3_get_table(sqlite, sql2, &results, &rows, &columns, &errMsg);
  sqlite3_free(sql2);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString db_prefix = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString name = wxString::FromUTF8(value);
          value = results[(i * columns) + 2];
          wxString title = wxString::FromUTF8(value);
          value = results[(i * columns) + 3];
          wxString abstract = wxString::FromUTF8(value);
          bool queryable = false;
          value = results[(i * columns) + 4];
          if (atoi(value))
            queryable = true;
          AddLayer2List(db_prefix, MAP_LAYER_RASTER, name, title, abstract,
                        queryable);
        }
    }
  sqlite3_free_table(results);
}

void AddMapLayerDialog::DoLoadWmsCoverages()
{
// populating the layers list (WMS Coverages)
  sqlite3 *sqlite = MapPanel->GetSqlite();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;
  char *sql2 = NULL;
  char *sql_save = NULL;

  sql = "pragma database_list";
  int ret = sqlite3_get_table(sqlite, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 1];
          sql_save = sql2;
          sql2 = QueryWmsCoverages(value, sql_save);
          if (sql_save != NULL)
            sqlite3_free(sql_save);
        }
    }
  sqlite3_free_table(results);
  if (sql2 == NULL)
    return;

  sql_save = sql2;
  sql2 = sqlite3_mprintf("%s\nORDER BY layer_name, db_prefix", sql_save);
  sqlite3_free(sql_save);
  ret = sqlite3_get_table(sqlite, sql2, &results, &rows, &columns, &errMsg);
  sqlite3_free(sql2);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString db_prefix = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString name = wxString::FromUTF8(value);
          value = results[(i * columns) + 2];
          wxString title = wxString::FromUTF8(value);
          value = results[(i * columns) + 3];
          wxString abstract = wxString::FromUTF8(value);
          bool queryable = false;
          value = results[(i * columns) + 4];
          if (atoi(value))
            queryable = true;
          AddLayer2List(db_prefix, MAP_LAYER_WMS, name, title, abstract,
                        queryable);
        }
    }
  sqlite3_free_table(results);
}

void AddMapLayerDialog::OnOk(wxCommandEvent & WXUNUSED(event))
{
//
// all done: 
//
  wxDialog::EndModal(wxID_OK);
}

/*
/ MapView.cpp
/ the Map View of spatialite_gui  - a SQLite /SpatiaLite GUI tool
/
/ version 2.0, 2017 January 8
/
/ Author: Sandro Furieri a-furieri@lqt.it
/
/ Copyright (C) 2017  Alessandro Furieri
/
/    This program is free software: you can redistribute it and/or modify
/    it under the terms of the GNU General Public License as published by
/    the Free Software Foundation, either version 3 of the License, or
/    (at your option) any later version.
/
/    This program is distributed in the hope that it will be useful,
/    but WITHOUT ANY WARRANTY; without even the implied warranty of
/    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
/    GNU General Public License for more details.
/
/    You should have received a copy of the GNU General Public License
/    along with this program.  If not, see <http://www.gnu.org/licenses/>.
/
*/

#include "Classdef.h"

#include "icons/crosshair.xpm"

MyMapView::MyMapView(MyMapPanel * parent, wxWindowID id):
wxPanel(parent, id, wxDefaultPosition, wxSize(440, 480),
        wxBORDER_SUNKEN | wxWANTS_CHARS)
{
//
// constructor: a frame to show the Map
//
  MapPanel = parent;
  Invalidate();

  BitmapWidth = wxSystemSettings::GetMetric(wxSYS_SCREEN_X);
  BitmapHeight = wxSystemSettings::GetMetric(wxSYS_SCREEN_Y);
  MapBitmap = wxBitmap(BitmapWidth, BitmapHeight, -1);
  ScreenBitmap = wxBitmap(BitmapWidth, BitmapHeight, -1);

  wxImage crossImage = wxBitmap(crosshair_xpm).ConvertToImage();
#ifdef __WXMSW__
// setting up a WINDOWS cursor
  crossImage.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, 8);
  crossImage.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, 8);
  CursorCross = wxCursor(crossImage);
#else
#ifdef __WXMAC__
// setting up a MacOsX cursor
  crossImage.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, 8);
  crossImage.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, 8);
  CursorCross = wxCursor(crossImage);
#else
// setting up an UNIX -likecursor
  int row;
  int col;
  unsigned short bits[16];
  unsigned short mask[16];
  for (row = 0; row < 16; row++)
    {
      bits[row] = 0x0000;
      mask[row] = 0x0000;
      for (col = 0; col < 16; col++)
        {
          unsigned char pixel = crossImage.GetRed(col, row);
          if (pixel == 0)
            {
              switch (col)
                {
                  case 0:
                    bits[row] |= 0x8000;
                    break;
                  case 1:
                    bits[row] |= 0x4000;
                    break;
                  case 2:
                    bits[row] |= 0x2000;
                    break;
                  case 3:
                    bits[row] |= 0x1000;
                    break;
                  case 4:
                    bits[row] |= 0x0800;
                    break;
                  case 5:
                    bits[row] |= 0x0400;
                    break;
                  case 6:
                    bits[row] |= 0x0200;
                    break;
                  case 7:
                    bits[row] |= 0x0100;
                    break;
                  case 8:
                    bits[row] |= 0x0080;
                    break;
                  case 9:
                    bits[row] |= 0x0040;
                    break;
                  case 10:
                    bits[row] |= 0x0020;
                    break;
                  case 11:
                    bits[row] |= 0x0010;
                    break;
                  case 12:
                    bits[row] |= 0x0008;
                    break;
                  case 13:
                    bits[row] |= 0x0004;
                    break;
                  case 14:
                    bits[row] |= 0x0002;
                    break;
                  case 15:
                    bits[row] |= 0x0001;
                    break;
                };
              switch (col)
                {
                  case 0:
                    mask[row] |= 0x8000;
                    break;
                  case 1:
                    mask[row] |= 0x4000;
                    break;
                  case 2:
                    mask[row] |= 0x2000;
                    break;
                  case 3:
                    mask[row] |= 0x1000;
                    break;
                  case 4:
                    mask[row] |= 0x0800;
                    break;
                  case 5:
                    mask[row] |= 0x0400;
                    break;
                  case 6:
                    mask[row] |= 0x0200;
                    break;
                  case 7:
                    mask[row] |= 0x0100;
                    break;
                  case 8:
                    mask[row] |= 0x0080;
                    break;
                  case 9:
                    mask[row] |= 0x0040;
                    break;
                  case 10:
                    mask[row] |= 0x0020;
                    break;
                  case 11:
                    mask[row] |= 0x0010;
                    break;
                  case 12:
                    mask[row] |= 0x0008;
                    break;
                  case 13:
                    mask[row] |= 0x0004;
                    break;
                  case 14:
                    mask[row] |= 0x0002;
                    break;
                  case 15:
                    mask[row] |= 0x0001;
                    break;
                };
            }
          if (pixel == 255)
            {
              switch (col)
                {
                  case 0:
                    mask[row] |= 0x8000;
                    break;
                  case 1:
                    mask[row] |= 0x4000;
                    break;
                  case 2:
                    mask[row] |= 0x2000;
                    break;
                  case 3:
                    mask[row] |= 0x1000;
                    break;
                  case 4:
                    mask[row] |= 0x0800;
                    break;
                  case 5:
                    mask[row] |= 0x0400;
                    break;
                  case 6:
                    mask[row] |= 0x0200;
                    break;
                  case 7:
                    mask[row] |= 0x0100;
                    break;
                  case 8:
                    mask[row] |= 0x0080;
                    break;
                  case 9:
                    mask[row] |= 0x0040;
                    break;
                  case 10:
                    mask[row] |= 0x0020;
                    break;
                  case 11:
                    mask[row] |= 0x0010;
                    break;
                  case 12:
                    mask[row] |= 0x0008;
                    break;
                  case 13:
                    mask[row] |= 0x0004;
                    break;
                  case 14:
                    mask[row] |= 0x0002;
                    break;
                  case 15:
                    mask[row] |= 0x0001;
                    break;
                };
            }
        }
    }
  CursorCross =
    wxCursor((char *) bits, 16, 16, 8, 8, (char *) mask, wxWHITE, wxBLACK);
#endif
#endif
  CursorHand = wxCursor(wxCURSOR_HAND);
  SetCursor(CursorCross);

// setting up event handlers
  Connect(wxID_ANY, wxEVT_ERASE_BACKGROUND,
          (wxObjectEventFunction) & MyMapView::OnEraseBackground);
  Connect(wxID_ANY, wxEVT_SIZE, (wxObjectEventFunction) & MyMapView::OnSize);
  Connect(wxID_ANY, wxEVT_PAINT, (wxObjectEventFunction) & MyMapView::OnPaint);
}

MyMapView::~MyMapView()
{
}

void MyMapView::OnSize(wxSizeEvent & WXUNUSED(event))
{
//
// this window has changed its size
//

// refreshing the map
  /*
     if (PrintInProgress == true)
     return;
     if (DownloadInProgress == true)
     PendingWmsAbort = true;
     PendingOnSize = true;
     if (ProgressControl != NULL)
     {
     // resizing the Progress control
     wxRect rect;
     if (MainFrame->GetProgressRect(rect) == true)
     ProgressControl->SetSize(rect);
     }
     PrepareMap();
     ResetMarker();
     if (IdentifyPanel != NULL)
     IdentifyPanel->Reset();
   */
}

void MyMapView::OnPaint(wxPaintEvent & WXUNUSED(event))
{
//
// this window needs to be repainted
//
  wxPaintDC dc(this);
  if (ValidMap == false)
    {
      // no map: black background
      wxSize sz = GetClientSize();
      dc.SetBrush(wxBrush(wxColour(128, 110, 96), wxSOLID));
      dc.SetPen(wxPen(wxColour(0, 0, 0), 1));
      dc.DrawRectangle(0, 0, sz.GetWidth(), sz.GetHeight());
      dc.SetBrush(wxNullBrush);
      dc.SetPen(wxNullPen);
  } else if (dc.IsOk() && ScreenBitmap.IsOk())
    {
      wxMemoryDC *memDC = new wxMemoryDC(ScreenBitmap);
      dc.Blit(0, 0, BitmapWidth, BitmapHeight, memDC, 0, 0);
      delete memDC;
    }
  //MainFrame->UpdateMapCRS();
}

void MyMapView::Invalidate()
{
// resetting to initial state
  ValidMap = false;
  /*
     ActiveLayer = NULL;
     DragStartX = -1;
     DragStartY = -1;
     LastDragX = -1;
     LastDragY = -1;
     if (UpdateTimer)
     {
     UpdateTimer->Stop();
     delete UpdateTimer;
     }
     UpdateTimer = NULL;
     if (TimerMouseWheel)
     {
     TimerMouseWheel->Stop();
     delete TimerMouseWheel;
     }
     TimerMouseWheel = NULL;
     if (TimerDynamic)
     {
     TimerDynamic->Stop();
     delete TimerDynamic;
     }
     TimerDynamic = NULL;
     WheelTics = 0;
   */
}

void MyMapView::PrepareMap()
{
//
// draws the MapBitmap
//
}

void MyMapView::ResetMapLayers()
{
//
// resetting the Map Layer list
//
  FirstLayer = NULL;
  LastLayer = NULL;
}

void MyMapView::ReinsertMapLayer(MapLayer * lyr)
{
//
// reinserting yet again a Map Layer (Tree new order)
//
  lyr->SetPrev(NULL);
  lyr->SetNext(NULL);
  if (FirstLayer == NULL)
    FirstLayer = lyr;
  lyr->SetPrev(LastLayer);
  if (LastLayer != NULL)
    LastLayer->SetNext(lyr);
  LastLayer = lyr;
}

void MyMapView::RemoveMapLayer(MapLayer * layer)
{
//
// removing a Map layer
//
  if (ActiveLayer == layer)
    ActiveLayer = NULL;
  if (layer->GetPrev() != NULL)
    layer->GetPrev()->SetNext(layer->GetNext());
  if (layer->GetNext() != NULL)
    layer->GetNext()->SetPrev(layer->GetPrev());
  if (FirstLayer == layer)
    FirstLayer = layer->GetNext();
  if (LastLayer == layer)
    LastLayer = layer->GetPrev();
  delete layer;
}

bool MyMapView::CanIdentify()
{
//
// test if Identify could be currently be enabled
//
  if (ActiveLayer == NULL)
    return false;
  if (ActiveLayer->IsVisible() == 0)
    return false;
  return true;
}

/
/    You should have received a copy of the GNU General Public License
/    along with this program.  If not, see <http://www.gnu.org/licenses/>.
/
*/

#include "Classdef.h"














































MyObject::MyObject(int type, wxString & name)
{
//
// constructor - TreeItemData
//
  Type = type;
  Name = name;
  Column = wxT("");
  DbAlias = wxT("");
  Temporary = false;
  Coverage = false;
  Topology = false;

}

MyObject::MyObject(int type, wxString & name, bool tmp, bool coverage,
                   bool topology)
{
//
// constructor - TreeItemData
................................................................................
  Type = type;
  Name = name;
  Column = wxT("");
  DbAlias = wxT("");
  Temporary = tmp;
  Coverage = coverage;
  Topology = topology;















}

MyObject::MyObject(int type, wxString & name, wxString & column)
{
//
// constructor - TreeItemData
//
  Type = type;
  Name = name;
  Column = column;
  DbAlias = wxT("");
  Temporary = false;
  Coverage = false;

}

MyObject::MyObject(int type, bool WXUNUSED(attached), wxString & dbAlias,
                   wxString & name, bool coverage, bool topology)
{
//
// constructor - TreeItemData
................................................................................
  Type = type;
  Name = name;
  Column = wxT("");
  DbAlias = dbAlias;
  Temporary = false;
  Coverage = coverage;
  Topology = topology;

}

void MyVariant::Copy(MyVariant * other)
{
// 
// transfers a BLOB value
//
................................................................................
MyPieChartLabel *MyPieChartLabels::GetRightLabel(int idx)
{
// return a Right Label pointer by index
  if (idx >= 0 && idx < NumRightLabels)
    return *(RightLabels + idx);
  return NULL;
}
























TopoGeo::TopoGeo(MyTableTree * tree, wxTreeItemId & root,
                 wxString & db_prefix, wxString & name, int srid, bool has_z)
{
// constructor: TopoGeo Tree Node
  DbHandle = tree->GetSQLiteHandle();
  DbPrefix = db_prefix;
................................................................................
  xname += wxString::FromUTF8(bufSrid);
  if (has_z == true)
    xname += wxT(" 3D");
  else
    xname += wxT(" 2D");
  TopologyNode = tree->AppendItem(root, xname);
  tree->SetItemImage(TopologyNode, 20);




  Next = NULL;
}

bool TopoGeo::CheckTopoFeature(wxString & table)
{
// checking if some table is a TopoFeatures table
  char topo_name[1024];
................................................................................
      delete pT;
      pT = pTn;
    }
  First = NULL;
  Last = NULL;
  Count = 0;
}














void TopoGeoList::Add(class MyTableTree * tree, wxTreeItemId & root,
                      wxString & db_prefix, wxString & name, int srid,
                      bool has_z)
{
// inserting a TopoGeo into the list
  TopoGeo *pT = new TopoGeo(tree, root, db_prefix, name, srid, has_z);
................................................................................
  return NULL;
}

TopoNet::TopoNet(MyTableTree * tree, wxTreeItemId & root,
                 wxString & name, bool spatial, int srid, bool has_z)
{
// constructor: TopoNet Tree Node





























  Name = name;
  wxString xname;
  char bufSrid[64];
  xname = Name;
  if (spatial == false)
    xname += wxT(" - Logical Network");
  else
................................................................................
      if (has_z == true)
        xname += wxT(" 3D");
      else
        xname += wxT(" 2D");
    }
  NetworkNode = tree->AppendItem(root, xname);
  tree->SetItemImage(NetworkNode, 25);




  Next = NULL;
}

wxTreeItemId *TopoNet::Check(wxString & table)
{
// checking if some table belongs to this TopoNet
  wxString cfr = Name + wxT("_link");
................................................................................
  Count++;
  if (First == NULL)
    First = pT;
  if (Last != NULL)
    Last->SetNext(pT);
  Last = pT;
}















wxTreeItemId *TopoNetList::FindNode(wxString & table)
{
// searching corresponding TopoNet Node (if any)
  TopoNet *pT = First;
  while (pT)
    {
................................................................................
  return NULL;
}

RasterCoverage::RasterCoverage(MyTableTree * tree, wxTreeItemId & root,
                               wxString & coverage, int srid)
{
// constructor: Raster Coverage Tree Node

  Name = coverage;
  wxString xname;
  char bufSrid[64];
  xname = Name;
  sprintf(bufSrid, " [SRID=%d]", srid);
  xname += wxString::FromUTF8(bufSrid);
  CoverageNode = tree->AppendItem(root, xname);
  tree->SetItemImage(CoverageNode, 22);

  Next = NULL;
}




















VectorCoverage::VectorCoverage(MyTableTree * tree, wxTreeItemId & root,
























































                               wxString & coverage, int srid)
{
// constructor: Vector Coverage Tree Node

  Name = coverage;
  wxString xname;
  char bufSrid[64];
  xname = Name;
  sprintf(bufSrid, " [SRID=%d]", srid);
  xname += wxString::FromUTF8(bufSrid);
  CoverageNode = tree->AppendItem(root, xname);





































  tree->SetItemImage(CoverageNode, 24);


  Next = NULL;
}

wxTreeItemId *RasterCoverage::Check(wxString & table, bool * tile_data)
{
// checking if some table belongs to this Raster Coverage
  *tile_data = false;
................................................................................
  Count++;
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}














wxTreeItemId *RasterCoverageList::FindNode(wxString & table, bool * tile_data)
{
// searching corresponding RasterCoverage Node (if any)
  RasterCoverage *pC = First;
  while (pC)
    {
................................................................................
    }
  First = NULL;
  Last = NULL;
  Count = 0;
}

void VectorCoverageList::Add(class MyTableTree * tree, wxTreeItemId & root,
















                             wxString & coverage, int srid)
{
// inserting a Vector Coverage into the list
  VectorCoverage *pC = new VectorCoverage(tree, root, coverage, srid);

  Count++;
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}
................................................................................
// constructor
  Name = wxString::FromUTF8(name);
  Spatial = spatial;
  Srid = srid;
  HasZ = has_z;
}

VectorCoverageSet::VectorCoverageSet(const char *name, int srid)

{
// constructor

  Name = wxString::FromUTF8(name);
  Srid = srid;

}

RasterCoverageSet::RasterCoverageSet(const char *name, int srid)
{
// constructor
  Name = wxString::FromUTF8(name);
  Srid = srid;

/
/    You should have received a copy of the GNU General Public License
/    along with this program.  If not, see <http://www.gnu.org/licenses/>.
/
*/

#include "Classdef.h"

MyObject::MyObject(bool attached)
{
//
// constructor - TreeItemData
//
  Type = MY_ROOT_NODE;
  Name = wxT("");
  Column = wxT("");
  DbAlias = wxT("");
  Temporary = false;
  Coverage = false;
  Topology = false;
  RootAttached = attached;
}

MyObject::MyObject(wxString & coverage)
{
//
// constructor - TreeItemData
//
  Type = MY_COVERAGE;
  Name = coverage;
  Column = wxT("");
  DbAlias = wxT("");
  Temporary = false;
  Coverage = false;
  Topology = false;
  RootAttached = false;
}

MyObject::MyObject(wxString & db_alias, wxString & coverage)
{
//
// constructor - TreeItemData
//
  Type = MY_COVERAGE;
  Name = coverage;
  Column = wxT("");
  DbAlias = db_alias;
  Temporary = false;
  Coverage = false;
  Topology = false;
  RootAttached = true;
}

MyObject::MyObject(int type, wxString & name)
{
//
// constructor - TreeItemData
//
  Type = type;
  Name = name;
  Column = wxT("");
  DbAlias = wxT("");
  Temporary = false;
  Coverage = false;
  Topology = false;
  RootAttached = false;
}

MyObject::MyObject(int type, wxString & name, bool tmp, bool coverage,
                   bool topology)
{
//
// constructor - TreeItemData
................................................................................
  Type = type;
  Name = name;
  Column = wxT("");
  DbAlias = wxT("");
  Temporary = tmp;
  Coverage = coverage;
  Topology = topology;
  RootAttached = false;
}

MyObject::MyObject(int type, wxString & db_alias, wxString & name, bool temp)
{
//
// constructor - TreeItemData
//
  Type = type;
  Name = name;
  Column = wxT("");
  DbAlias = db_alias;
  Temporary = temp;
  Coverage = false;
  RootAttached = false;
}

MyObject::MyObject(int type, wxString & name, wxString & column)
{
//
// constructor - TreeItemData
//
  Type = type;
  Name = name;
  Column = column;
  DbAlias = wxT("");
  Temporary = false;
  Coverage = false;
  RootAttached = false;
}

MyObject::MyObject(int type, bool WXUNUSED(attached), wxString & dbAlias,
                   wxString & name, bool coverage, bool topology)
{
//
// constructor - TreeItemData
................................................................................
  Type = type;
  Name = name;
  Column = wxT("");
  DbAlias = dbAlias;
  Temporary = false;
  Coverage = coverage;
  Topology = topology;
  RootAttached = true;
}

void MyVariant::Copy(MyVariant * other)
{
// 
// transfers a BLOB value
//
................................................................................
MyPieChartLabel *MyPieChartLabels::GetRightLabel(int idx)
{
// return a Right Label pointer by index
  if (idx >= 0 && idx < NumRightLabels)
    return *(RightLabels + idx);
  return NULL;
}

TopoGeo::TopoGeo(MyTableTree * tree, wxTreeItemId & root,
                 wxString & name, int srid, bool has_z)
{
// constructor: TopoGeo Tree Node
  DbHandle = tree->GetSQLiteHandle();
  DbPrefix = wxT("");
  Name = name;
  wxString xname;
  char bufSrid[64];
  xname = Name;
  sprintf(bufSrid, " [SRID=%d]", srid);
  xname += wxString::FromUTF8(bufSrid);
  if (has_z == true)
    xname += wxT(" 3D");
  else
    xname += wxT(" 2D");
  TopologyNode = tree->AppendItem(root, xname);
  tree->SetItemImage(TopologyNode, 20);
  tree->SetItemData(TopologyNode,
                    (wxTreeItemData *) (new MyObject(MY_TOPO_GEO, Name)));
  Next = NULL;
}

TopoGeo::TopoGeo(MyTableTree * tree, wxTreeItemId & root,
                 wxString & db_prefix, wxString & name, int srid, bool has_z)
{
// constructor: TopoGeo Tree Node
  DbHandle = tree->GetSQLiteHandle();
  DbPrefix = db_prefix;
................................................................................
  xname += wxString::FromUTF8(bufSrid);
  if (has_z == true)
    xname += wxT(" 3D");
  else
    xname += wxT(" 2D");
  TopologyNode = tree->AppendItem(root, xname);
  tree->SetItemImage(TopologyNode, 20);
  tree->SetItemData(TopologyNode,
                    (wxTreeItemData *) (new
                                        MyObject(MY_TOPO_GEO, db_prefix, Name,
                                                 false)));
  Next = NULL;
}

bool TopoGeo::CheckTopoFeature(wxString & table)
{
// checking if some table is a TopoFeatures table
  char topo_name[1024];
................................................................................
      delete pT;
      pT = pTn;
    }
  First = NULL;
  Last = NULL;
  Count = 0;
}

void TopoGeoList::Add(class MyTableTree * tree, wxTreeItemId & root,
                      wxString & name, int srid, bool has_z)
{
// inserting a TopoGeo into the list
  TopoGeo *pT = new TopoGeo(tree, root, name, srid, has_z);
  Count++;
  if (First == NULL)
    First = pT;
  if (Last != NULL)
    Last->SetNext(pT);
  Last = pT;
}

void TopoGeoList::Add(class MyTableTree * tree, wxTreeItemId & root,
                      wxString & db_prefix, wxString & name, int srid,
                      bool has_z)
{
// inserting a TopoGeo into the list
  TopoGeo *pT = new TopoGeo(tree, root, db_prefix, name, srid, has_z);
................................................................................
  return NULL;
}

TopoNet::TopoNet(MyTableTree * tree, wxTreeItemId & root,
                 wxString & name, bool spatial, int srid, bool has_z)
{
// constructor: TopoNet Tree Node
  DbPrefix = wxT("");
  Name = name;
  wxString xname;
  char bufSrid[64];
  xname = Name;
  if (spatial == false)
    xname += wxT(" - Logical Network");
  else
    {
      sprintf(bufSrid, " [SRID=%d]", srid);
      xname += wxString::FromUTF8(bufSrid);
      if (has_z == true)
        xname += wxT(" 3D");
      else
        xname += wxT(" 2D");
    }
  NetworkNode = tree->AppendItem(root, xname);
  tree->SetItemImage(NetworkNode, 25);
  tree->SetItemData(NetworkNode,
                    (wxTreeItemData *) (new MyObject(MY_TOPO_NET, Name)));
  Next = NULL;
}

TopoNet::TopoNet(MyTableTree * tree, wxTreeItemId & root,
                 wxString & dbPrefix, wxString & name, bool spatial, int srid,
                 bool has_z)
{
// constructor: TopoNet Tree Node
  DbPrefix = dbPrefix;
  Name = name;
  wxString xname;
  char bufSrid[64];
  xname = Name;
  if (spatial == false)
    xname += wxT(" - Logical Network");
  else
................................................................................
      if (has_z == true)
        xname += wxT(" 3D");
      else
        xname += wxT(" 2D");
    }
  NetworkNode = tree->AppendItem(root, xname);
  tree->SetItemImage(NetworkNode, 25);
  tree->SetItemData(NetworkNode,
                    (wxTreeItemData *) (new
                                        MyObject(MY_TOPO_NET, DbPrefix, Name,
                                                 false)));
  Next = NULL;
}

wxTreeItemId *TopoNet::Check(wxString & table)
{
// checking if some table belongs to this TopoNet
  wxString cfr = Name + wxT("_link");
................................................................................
  Count++;
  if (First == NULL)
    First = pT;
  if (Last != NULL)
    Last->SetNext(pT);
  Last = pT;
}

void TopoNetList::Add(class MyTableTree * tree, wxTreeItemId & root,
                      wxString & dbPrefix, wxString & name, bool spatial,
                      int srid, bool has_z)
{
// inserting a TopoNet into the list
  TopoNet *pT = new TopoNet(tree, root, dbPrefix, name, spatial, srid, has_z);
  Count++;
  if (First == NULL)
    First = pT;
  if (Last != NULL)
    Last->SetNext(pT);
  Last = pT;
}

wxTreeItemId *TopoNetList::FindNode(wxString & table)
{
// searching corresponding TopoNet Node (if any)
  TopoNet *pT = First;
  while (pT)
    {
................................................................................
  return NULL;
}

RasterCoverage::RasterCoverage(MyTableTree * tree, wxTreeItemId & root,
                               wxString & coverage, int srid)
{
// constructor: Raster Coverage Tree Node
  DbPrefix = wxT("");
  Name = coverage;
  wxString xname;
  char bufSrid[64];
  xname = Name;
  sprintf(bufSrid, " [SRID=%d]", srid);
  xname += wxString::FromUTF8(bufSrid);
  CoverageNode = tree->AppendItem(root, xname);
  tree->SetItemImage(CoverageNode, 22);
  tree->SetItemData(CoverageNode, (wxTreeItemData *) (new MyObject(coverage)));
  Next = NULL;
}

RasterCoverage::RasterCoverage(MyTableTree * tree, wxTreeItemId & root,
                               wxString & dbPrefix, wxString & coverage,
                               int srid)
{
// constructor: Raster Coverage Tree Node
  DbPrefix = dbPrefix;
  Name = coverage;
  wxString xname;
  char bufSrid[64];
  xname = Name;
  sprintf(bufSrid, " [SRID=%d]", srid);
  xname += wxString::FromUTF8(bufSrid);
  CoverageNode = tree->AppendItem(root, xname);
  tree->SetItemImage(CoverageNode, 22);
  tree->SetItemData(CoverageNode,
                    (wxTreeItemData *) (new MyObject(dbPrefix, coverage)));
  Next = NULL;
}

VectorCoverage::VectorCoverage(MyTableTree * tree, wxTreeItemId & root,
                               wxString & prefix, wxString & coverage, int srid,
                               int type)
{
// constructor: Vector Coverage Tree Node
  DbPrefix = wxT("");
  Name = coverage;
  wxString xname;
  char bufSrid[64];
  xname = prefix + wxT(".") + Name;
  sprintf(bufSrid, " [SRID=%d]", srid);
  xname += wxString::FromUTF8(bufSrid);
  CoverageNode = tree->AppendItem(root, xname);
  int index = 24;
  switch (type)
    {
      case 1:
      case 1001:
      case 2001:
      case 3001:
      case 4:
      case 1004:
      case 2004:
      case 3004:
        index = 27;
        break;
      case 2:
      case 1002:
      case 2002:
      case 3002:
      case 5:
      case 1005:
      case 2005:
      case 3005:
        index = 28;
        break;
      case 3:
      case 1003:
      case 2003:
      case 3003:
      case 6:
      case 1006:
      case 2006:
      case 3006:
        index = 29;
        break;
      default:
        index = 24;
        break;
    };
  tree->SetItemImage(CoverageNode, index);
  tree->SetItemData(CoverageNode, (wxTreeItemData *) (new MyObject(coverage)));
  Next = NULL;
}

VectorCoverage::VectorCoverage(MyTableTree * tree, wxTreeItemId & root,
                               wxString & dbPrefix, wxString & prefix,
                               wxString & coverage, int srid, int type)
{
// constructor: Vector Coverage Tree Node
  DbPrefix = dbPrefix;
  Name = coverage;
  wxString xname;
  char bufSrid[64];
  xname = prefix + wxT(".") + Name;
  sprintf(bufSrid, " [SRID=%d]", srid);
  xname += wxString::FromUTF8(bufSrid);
  CoverageNode = tree->AppendItem(root, xname);
  int index = 24;
  switch (type)
    {
      case 1:
      case 1001:
      case 2001:
      case 3001:
      case 4:
      case 1004:
      case 2004:
      case 3004:
        index = 27;
        break;
      case 2:
      case 1002:
      case 2002:
      case 3002:
      case 5:
      case 1005:
      case 2005:
      case 3005:
        index = 28;
        break;
      case 3:
      case 1003:
      case 2003:
      case 3003:
      case 6:
      case 1006:
      case 2006:
      case 3006:
        index = 29;
        break;
      default:
        index = 24;
        break;
    };
  tree->SetItemImage(CoverageNode, index);
  tree->SetItemData(CoverageNode,
                    (wxTreeItemData *) (new MyObject(dbPrefix, coverage)));
  Next = NULL;
}

wxTreeItemId *RasterCoverage::Check(wxString & table, bool * tile_data)
{
// checking if some table belongs to this Raster Coverage
  *tile_data = false;
................................................................................
  Count++;
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}

void RasterCoverageList::Add(class MyTableTree * tree, wxTreeItemId & root,
                             wxString & dbPrefix, wxString & coverage, int srid)
{
// inserting a Raster Coverage into the list
  RasterCoverage *pC = new RasterCoverage(tree, root, dbPrefix, coverage, srid);
  Count++;
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}

wxTreeItemId *RasterCoverageList::FindNode(wxString & table, bool * tile_data)
{
// searching corresponding RasterCoverage Node (if any)
  RasterCoverage *pC = First;
  while (pC)
    {
................................................................................
    }
  First = NULL;
  Last = NULL;
  Count = 0;
}

void VectorCoverageList::Add(class MyTableTree * tree, wxTreeItemId & root,
                             wxString & prefix, wxString & coverage, int srid,
                             int type)
{
// inserting a Vector Coverage into the list
  VectorCoverage *pC =
    new VectorCoverage(tree, root, prefix, coverage, srid, type);
  Count++;
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}

void VectorCoverageList::Add(class MyTableTree * tree, wxTreeItemId & root,
                             wxString & dbPrefix, wxString & prefix,
                             wxString & coverage, int srid, int type)
{
// inserting a Vector Coverage into the list
  VectorCoverage *pC =
    new VectorCoverage(tree, root, dbPrefix, prefix, coverage, srid, type);
  Count++;
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}
................................................................................
// constructor
  Name = wxString::FromUTF8(name);
  Spatial = spatial;
  Srid = srid;
  HasZ = has_z;
}

VectorCoverageSet::VectorCoverageSet(const char *prefix, const char *name,
                                     int srid, int type)
{
// constructor
  Prefix = wxString::FromUTF8(prefix);
  Name = wxString::FromUTF8(name);
  Srid = srid;
  GeometryType = type;
}

RasterCoverageSet::RasterCoverageSet(const char *name, int srid)
{
// constructor
  Name = wxString::FromUTF8(name);
  Srid = srid;

    new wxBitmapButton(this, ID_SQL_FILTER, wxBitmap(filter_xpm),
                       wxPoint(340, 38), wxSize(32, 32));
  BtnSqlFilter->SetToolTip(wxT("Apply/Remove SQL filters"));
  BtnSqlFilter->Enable(false);
  BtnSqlErase =
    new wxBitmapButton(this, ID_SQL_ERASE, wxBitmap(sql_erase_xpm),
                       wxPoint(340, 70), wxSize(32, 32));
  BtnSqlErase->SetToolTip(wxT("Clean SQL query"));
  BtnSqlErase->Enable(true);
  BtnSqlAbort =
    new wxBitmapButton(this, ID_SQL_ABORT, wxBitmap(sql_abort_xpm),
                       wxPoint(340, 102), wxSize(32, 32));
  BtnSqlAbort->SetBitmapDisabled(wxBitmap(sql_abort_no_xpm));
  BtnSqlAbort->SetToolTip(wxT("Abort SQL query"));
  BtnHistoryBack =
................................................................................
    return true;
  if (str.CmpNoCase(wxT("WMS_RegisterGetMap")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_UnRegisterGetMap")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_SetGetMapInfos")) == 0)
    return true;


  if (str.CmpNoCase(wxT("WMS_SetGetMapOptions")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_RegisterSetting")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_UnRegisterSetting")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_DefaultSetting")) == 0)
................................................................................
  if (str.CmpNoCase(wxT("WMS_UnRegisterRefSys")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_DefaultRefSys")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_GetMapRequestURL")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_GetFeatureInfoRequestURL")) == 0)








    return true;
  if (str.CmpNoCase(wxT("GeometryConstraints")) == 0)
    return true;
  if (str.CmpNoCase(wxT("CheckSpatialMetaData")) == 0)
    return true;
  if (str.CmpNoCase(wxT("AutoFDOStart")) == 0)
    return true;
................................................................................
  if (str.CmpNoCase(wxT("CreateMetaCatalogTables")) == 0)
    return true;
  if (str.CmpNoCase(wxT("UpdateMetaCatalogStatistics")) == 0)
    return true;
  if (str.CmpNoCase(wxT("CreateStylingTables")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_RegisterVectorCoverage")) == 0)
    return true;








  if (str.CmpNoCase(wxT("SE_UnregisterVectorCoverage")) == 0)


    return true;
  if (str.CmpNoCase(wxT("SE_SetVectorCoverageInfos")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_RegisterVectorCoverageSrid")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_UnregisterVectorCoverageSrid")) == 0)
    return true;
................................................................................
  if (str.CmpNoCase(wxT("PointOnSurface")) == 0)
    return true;
  if (str.CmpNoCase(wxT("ST_PointOnSurface")) == 0)
    return true;
  if (str.CmpNoCase(wxT("Area")) == 0)
    return true;
  if (str.CmpNoCase(wxT("ST_Area")) == 0)


    return true;
  if (str.CmpNoCase(wxT("ExteriorRing")) == 0)
    return true;
  if (str.CmpNoCase(wxT("ST_ExteriorRing")) == 0)
    return true;
  if (str.CmpNoCase(wxT("NumInteriorRing")) == 0)
    return true;
................................................................................
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_RemoveDanglingNodes")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_NewEdgeHeal")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_ModEdgeHeal")) == 0)
    return true;




  if (str.CmpNoCase(wxT("TopoGeo_Clone")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_GetEdgeSeed")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_GetFaceSeed")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_UpdateSeeds")) == 0)
................................................................................
    return true;
  if (str.CmpNoCase(wxT("RL2_DropRasterCoverage")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SetRasterCoverageInfos")) == 0)
    return true;
  if (str.CmpNoCase(wxT("RL2_SetRasterCoverageInfos")) == 0)
    return true;




  if (str.CmpNoCase(wxT("SetRasterCoverageDefaultBands")) == 0)
    return true;
  if (str.CmpNoCase(wxT("RL2_SetRasterCoverageDefaultBands")) == 0)
    return true;
  if (str.CmpNoCase(wxT("EnableRasterCoverageAutoNDVI")) == 0)
    return true;
  if (str.CmpNoCase(wxT("RL2_EnableRasterCoverageAutoNDVI")) == 0)

    new wxBitmapButton(this, ID_SQL_FILTER, wxBitmap(filter_xpm),
                       wxPoint(340, 38), wxSize(32, 32));
  BtnSqlFilter->SetToolTip(wxT("Apply/Remove SQL filters"));
  BtnSqlFilter->Enable(false);
  BtnSqlErase =
    new wxBitmapButton(this, ID_SQL_ERASE, wxBitmap(sql_erase_xpm),
                       wxPoint(340, 70), wxSize(32, 32));
  BtnSqlErase->SetToolTip(wxT("Clear SQL query"));
  BtnSqlErase->Enable(true);
  BtnSqlAbort =
    new wxBitmapButton(this, ID_SQL_ABORT, wxBitmap(sql_abort_xpm),
                       wxPoint(340, 102), wxSize(32, 32));
  BtnSqlAbort->SetBitmapDisabled(wxBitmap(sql_abort_no_xpm));
  BtnSqlAbort->SetToolTip(wxT("Abort SQL query"));
  BtnHistoryBack =
................................................................................
    return true;
  if (str.CmpNoCase(wxT("WMS_RegisterGetMap")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_UnRegisterGetMap")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_SetGetMapInfos")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_SetGetMapCopyright")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_SetGetMapOptions")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_RegisterSetting")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_UnRegisterSetting")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_DefaultSetting")) == 0)
................................................................................
  if (str.CmpNoCase(wxT("WMS_UnRegisterRefSys")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_DefaultRefSys")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_GetMapRequestURL")) == 0)
    return true;
  if (str.CmpNoCase(wxT("WMS_GetFeatureInfoRequestURL")) == 0)
    return true;
  if (str.CmpNoCase(wxT("RegisterDataLicense")) == 0)
    return true;
  if (str.CmpNoCase(wxT("UnRegisterDataLicense")) == 0)
    return true;
  if (str.CmpNoCase(wxT("RenameDataLicense")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SetDataLicenseUrl")) == 0)
    return true;
  if (str.CmpNoCase(wxT("GeometryConstraints")) == 0)
    return true;
  if (str.CmpNoCase(wxT("CheckSpatialMetaData")) == 0)
    return true;
  if (str.CmpNoCase(wxT("AutoFDOStart")) == 0)
    return true;
................................................................................
  if (str.CmpNoCase(wxT("CreateMetaCatalogTables")) == 0)
    return true;
  if (str.CmpNoCase(wxT("UpdateMetaCatalogStatistics")) == 0)
    return true;
  if (str.CmpNoCase(wxT("CreateStylingTables")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_RegisterVectorCoverage")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_RegisterSpatialViewCoverage")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_RegisterVirtualShapeCoverage")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_RegisterTopoGeoCoverage")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_RegisterTopoNetCoverage")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_UnregisterVectorCoverage")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_SetVectorCoverageCopyright")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_SetVectorCoverageInfos")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_RegisterVectorCoverageSrid")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SE_UnregisterVectorCoverageSrid")) == 0)
    return true;
................................................................................
  if (str.CmpNoCase(wxT("PointOnSurface")) == 0)
    return true;
  if (str.CmpNoCase(wxT("ST_PointOnSurface")) == 0)
    return true;
  if (str.CmpNoCase(wxT("Area")) == 0)
    return true;
  if (str.CmpNoCase(wxT("ST_Area")) == 0)
    return true;
  if (str.CmpNoCase(wxT("Circularity")) == 0)
    return true;
  if (str.CmpNoCase(wxT("ExteriorRing")) == 0)
    return true;
  if (str.CmpNoCase(wxT("ST_ExteriorRing")) == 0)
    return true;
  if (str.CmpNoCase(wxT("NumInteriorRing")) == 0)
    return true;
................................................................................
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_RemoveDanglingNodes")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_NewEdgeHeal")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_ModEdgeHeal")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_NewEdgesSplit")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_ModEdgesSplit")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_Clone")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_GetEdgeSeed")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_GetFaceSeed")) == 0)
    return true;
  if (str.CmpNoCase(wxT("TopoGeo_UpdateSeeds")) == 0)
................................................................................
    return true;
  if (str.CmpNoCase(wxT("RL2_DropRasterCoverage")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SetRasterCoverageInfos")) == 0)
    return true;
  if (str.CmpNoCase(wxT("RL2_SetRasterCoverageInfos")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SetRasterCoverageCopyright")) == 0)
    return true;
  if (str.CmpNoCase(wxT("RL2_SetRasterCoverageCopyright")) == 0)
    return true;
  if (str.CmpNoCase(wxT("SetRasterCoverageDefaultBands")) == 0)
    return true;
  if (str.CmpNoCase(wxT("RL2_SetRasterCoverageDefaultBands")) == 0)
    return true;
  if (str.CmpNoCase(wxT("EnableRasterCoverageAutoNDVI")) == 0)
    return true;
  if (str.CmpNoCase(wxT("RL2_EnableRasterCoverageAutoNDVI")) == 0)

  wxSpinCtrl *heightCtrl = new wxSpinCtrl(this, ID_CVG_HEIGHT, wxEmptyString,
                                          wxDefaultPosition, wxSize(60, 20),
                                          wxSP_ARROW_KEYS,
                                          256, 1024, 512);
  heightCtrl->Enable(false);
  tileHSizer->Add(heightCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// sixth row, column #2: SRID


  wxBoxSizer *sridBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  mixSizer->Add(sridBoxSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 0);
  wxStaticBox *sridBox = new wxStaticBox(this, wxID_STATIC,
                                         wxT("Georeferencing"),
                                         wxDefaultPosition,
                                         wxDefaultSize);
  wxBoxSizer *geoSizer = new wxStaticBoxSizer(sridBox, wxVERTICAL);
  sridBoxSizer->Add(geoSizer, 0, wxALIGN_RIGHT | wxALL, 5);
  wxBoxSizer *norefSizer = new wxBoxSizer(wxHORIZONTAL);
................................................................................
  sridSizer->Add(sridLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  int srid = 0;
  wxSpinCtrl *sridCtrl = new wxSpinCtrl(this, ID_CVG_SRID, wxEmptyString,
                                        wxDefaultPosition, wxSize(80, 20),
                                        wxSP_ARROW_KEYS,
                                        -1, 1000000, srid);
  sridSizer->Add(sridCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);














// sixth row, column #3: Pixel Resolution
  wxBoxSizer *resBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  mixSizer->Add(resBoxSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 0);
  wxStaticBox *resBox = new wxStaticBox(this, wxID_STATIC,
                                        wxT("Pixel Resolution"),
                                        wxDefaultPosition,
                                        wxDefaultSize);
................................................................................
  else
    MD5 = false;
  wxCheckBox *summaryCtrl = (wxCheckBox *) FindWindow(ID_CVG_SUMMARY);
  if (summaryCtrl->IsChecked() == true)
    Summary = true;
  else
    Summary = false;





  wxDialog::EndModal(wxID_OK);
  return;
}

bool ImportRasterDialog::Create(MyFrame * parent, wxString & coverage,
                                wxArrayString & paths, wxString & path,
                                wxString & title, wxString & abstract,
................................................................................
    new wxStaticText(this, wxID_STATIC, wxT("Import &File(s):"));
  fileSizer->Add(fileLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *filesCtrl = new wxTextCtrl(this, wxID_ANY, Path,
                                         wxDefaultPosition, wxSize(600, 60),
                                         wxTE_MULTILINE | wxTE_READONLY);
  fileSizer->Add(filesCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// eighth  row: Import Options
  int space_sz = 35;
  wxBoxSizer *optBoxSizer = new wxBoxSizer(wxVERTICAL);
  boxSizer->Add(optBoxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxStaticBox *optBox = new wxStaticBox(this, wxID_STATIC,
                                        wxT("Import Options"),
                                        wxDefaultPosition,
                                        wxDefaultSize);
  wxBoxSizer *optSizer = new wxStaticBoxSizer(optBox, wxHORIZONTAL);
................................................................................
  optSizer->AddSpacer(space_sz);
  wxCheckBox *forceSridCtrl = new wxCheckBox(this, ID_LOAD_FORCE_SRID,
                                             wxT("Forced SRID value"),
                                             wxDefaultPosition, wxDefaultSize);
  forceSridCtrl->SetValue(false);
  sridSizer->Add(forceSridCtrl, 0, wxALIGN_LEFT | wxALL, 5);
  wxSpinCtrl *sridCtrl = new wxSpinCtrl(this, ID_LOAD_SRID, wxEmptyString,
                                        wxDefaultPosition, wxSize(60, 20),
                                        wxSP_ARROW_KEYS, -1, 1000000, Srid);
  sridCtrl->Enable(false);
  sridSizer->Add(sridCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 1);
  wxCheckBox *worldCtrl = new wxCheckBox(this, ID_LOAD_WITH_WORLDFILE,
                                         wxT("With WorldFile support"),
                                         wxDefaultPosition, wxDefaultSize);
  worldCtrl->SetValue(false);
................................................................................
                 ("You could now eventually consider to execute VACUUM in order to reclaim the unused disk space."),
                 wxT("spatialite_gui"), wxOK | wxICON_INFORMATION, this);
  else
    wxMessageBox(wxT("Failure: some unexpected error occurred"),
                 wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
  wxDialog::EndModal(wxID_CANCEL);
}












































































































































































































































bool VectorUnregisterDialog::Create(MyFrame * parent, wxString & coverage,
                                    wxString & title, wxString & abstract,
                                    wxString & type)
{
//
// creating the dialog

  wxSpinCtrl *heightCtrl = new wxSpinCtrl(this, ID_CVG_HEIGHT, wxEmptyString,
                                          wxDefaultPosition, wxSize(60, 20),
                                          wxSP_ARROW_KEYS,
                                          256, 1024, 512);
  heightCtrl->Enable(false);
  tileHSizer->Add(heightCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// sixth row, column #2: SRID
  wxBoxSizer *sridQueryableSizer = new wxBoxSizer(wxVERTICAL);
  mixSizer->Add(sridQueryableSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 0);
  wxBoxSizer *sridBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  sridQueryableSizer->Add(sridBoxSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 0);
  wxStaticBox *sridBox = new wxStaticBox(this, wxID_STATIC,
                                         wxT("Georeferencing"),
                                         wxDefaultPosition,
                                         wxDefaultSize);
  wxBoxSizer *geoSizer = new wxStaticBoxSizer(sridBox, wxVERTICAL);
  sridBoxSizer->Add(geoSizer, 0, wxALIGN_RIGHT | wxALL, 5);
  wxBoxSizer *norefSizer = new wxBoxSizer(wxHORIZONTAL);
................................................................................
  sridSizer->Add(sridLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  int srid = 0;
  wxSpinCtrl *sridCtrl = new wxSpinCtrl(this, ID_CVG_SRID, wxEmptyString,
                                        wxDefaultPosition, wxSize(80, 20),
                                        wxSP_ARROW_KEYS,
                                        -1, 1000000, srid);
  sridSizer->Add(sridCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// sixth row, column #2/bis: queryable
  wxBoxSizer *radioSizer = new wxBoxSizer(wxHORIZONTAL);
  sridQueryableSizer->Add(radioSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxString yesno[2];
  yesno[0] = wxT("&No");
  yesno[1] = wxT("&Yes");
  wxRadioBox *queryableBox = new wxRadioBox(this, ID_CVG_QUERYABLE,
                                            wxT("Is &Queryable"),
                                            wxDefaultPosition,
                                            wxDefaultSize, 2,
                                            yesno, 1,
                                            wxRA_SPECIFY_ROWS);
  radioSizer->Add(queryableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  queryableBox->SetSelection(1);
// sixth row, column #3: Pixel Resolution
  wxBoxSizer *resBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  mixSizer->Add(resBoxSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 0);
  wxStaticBox *resBox = new wxStaticBox(this, wxID_STATIC,
                                        wxT("Pixel Resolution"),
                                        wxDefaultPosition,
                                        wxDefaultSize);
................................................................................
  else
    MD5 = false;
  wxCheckBox *summaryCtrl = (wxCheckBox *) FindWindow(ID_CVG_SUMMARY);
  if (summaryCtrl->IsChecked() == true)
    Summary = true;
  else
    Summary = false;
  wxRadioBox *queryableBox = (wxRadioBox *) FindWindow(ID_CVG_QUERYABLE);
  if (queryableBox->GetSelection() == 1)
    Queryable = true;
  else
    Queryable = false;
  wxDialog::EndModal(wxID_OK);
  return;
}

bool ImportRasterDialog::Create(MyFrame * parent, wxString & coverage,
                                wxArrayString & paths, wxString & path,
                                wxString & title, wxString & abstract,
................................................................................
    new wxStaticText(this, wxID_STATIC, wxT("Import &File(s):"));
  fileSizer->Add(fileLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *filesCtrl = new wxTextCtrl(this, wxID_ANY, Path,
                                         wxDefaultPosition, wxSize(600, 60),
                                         wxTE_MULTILINE | wxTE_READONLY);
  fileSizer->Add(filesCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// eighth  row: Import Options
  int space_sz = 25;
  wxBoxSizer *optBoxSizer = new wxBoxSizer(wxVERTICAL);
  boxSizer->Add(optBoxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxStaticBox *optBox = new wxStaticBox(this, wxID_STATIC,
                                        wxT("Import Options"),
                                        wxDefaultPosition,
                                        wxDefaultSize);
  wxBoxSizer *optSizer = new wxStaticBoxSizer(optBox, wxHORIZONTAL);
................................................................................
  optSizer->AddSpacer(space_sz);
  wxCheckBox *forceSridCtrl = new wxCheckBox(this, ID_LOAD_FORCE_SRID,
                                             wxT("Forced SRID value"),
                                             wxDefaultPosition, wxDefaultSize);
  forceSridCtrl->SetValue(false);
  sridSizer->Add(forceSridCtrl, 0, wxALIGN_LEFT | wxALL, 5);
  wxSpinCtrl *sridCtrl = new wxSpinCtrl(this, ID_LOAD_SRID, wxEmptyString,
                                        wxDefaultPosition, wxSize(80, 20),
                                        wxSP_ARROW_KEYS, -1, 1000000, Srid);
  sridCtrl->Enable(false);
  sridSizer->Add(sridCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 1);
  wxCheckBox *worldCtrl = new wxCheckBox(this, ID_LOAD_WITH_WORLDFILE,
                                         wxT("With WorldFile support"),
                                         wxDefaultPosition, wxDefaultSize);
  worldCtrl->SetValue(false);
................................................................................
                 ("You could now eventually consider to execute VACUUM in order to reclaim the unused disk space."),
                 wxT("spatialite_gui"), wxOK | wxICON_INFORMATION, this);
  else
    wxMessageBox(wxT("Failure: some unexpected error occurred"),
                 wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
  wxDialog::EndModal(wxID_CANCEL);
}

bool RasterInfosDialog::Create(MyFrame * parent, wxString & coverage)
{
//
// creating the dialog
//
  MainFrame = parent;
  int pos = coverage.Find(wxT(" [SRID="));
  if (pos != wxNOT_FOUND)
    CoverageName = coverage.Left(pos);
  else
    CoverageName = coverage;
  if (DoReadCoverage() == false)
    return false;
  if (wxDialog::Create(parent, wxID_ANY, wxT("Edit Raster Coverage Infos"))
      == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
// centers the dialog window
  Centre();
  int count = 0;
  return true;
}

void RasterInfosDialog::CreateControls()
{
//
// creating individual control and setting initial values
//
  wxBoxSizer *topSizer = new wxBoxSizer(wxVERTICAL);
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// first row: the Coverage Name
  wxBoxSizer *nameSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(nameSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *nameLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Coverage Name:"));
  nameSizer->Add(nameLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *nameCtrl = new wxTextCtrl(this, ID_CVG_NAME, CoverageName,
                                        wxDefaultPosition, wxSize(550, 22));
  nameSizer->Add(nameCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// second row: the Coverage Title
  wxBoxSizer *titleSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(titleSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *titleLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Title:"));
  titleSizer->Add(titleLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *titleCtrl = new wxTextCtrl(this, ID_CVG_TITLE, Title,
                                         wxDefaultPosition, wxSize(550, 22));
  titleSizer->Add(titleCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// third row: the Coverage Abstract
  wxBoxSizer *absSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(absSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *absLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Abstract:"));
  absSizer->Add(absLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *abstractCtrl = new wxTextCtrl(this, ID_CVG_ABSTRACT, Abstract,
                                            wxDefaultPosition, wxSize(550, 60),
                                            wxTE_MULTILINE);
  absSizer->Add(abstractCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fourth row: queryable
  wxBoxSizer *radioSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(radioSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxString yesno[2];
  yesno[0] = wxT("&No");
  yesno[1] = wxT("&Yes");
  wxRadioBox *queryableBox = new wxRadioBox(this, ID_CVG_QUERYABLE,
                                            wxT("Is &Queryable"),
                                            wxDefaultPosition,
                                            wxDefaultSize, 2,
                                            yesno, 1,
                                            wxRA_SPECIFY_ROWS);
  radioSizer->Add(queryableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  if (IsQueryable == false)
    queryableBox->SetSelection(0);
  else
    queryableBox->SetSelection(1);
// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&OK"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
  btnBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// appends event handler for OK button
  Connect(wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED,
          (wxObjectEventFunction) & RasterInfosDialog::OnOk);
}

bool RasterInfosDialog::DoReadCoverage()
{
// will retrieve to read the given Coverage definition
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  char *sql;
  char cvg[1024];
  int count = 0;

  wxCharBuffer buffer = CoverageName.ToUTF8();
  sprintf(cvg, "%s", buffer.data());
  sql =
    sqlite3_mprintf
    ("SELECT title, abstract, is_queryable "
     "FROM raster_coverages WHERE Lower(coverage_name) = Lower(%Q)", cvg);
  int ret = sqlite3_get_table(MainFrame->GetSqlite(), sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          Title = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          Abstract = wxString::FromUTF8(value);
          value = results[(i * columns) + 2];
          if (atoi(value) == 0)
            IsQueryable = false;
          else
            IsQueryable = true;
          count++;
        }
    }
  sqlite3_free_table(results);
  if (count == 1)
    return true;
  return false;
}

void RasterInfosDialog::DoUpdateCoverage()
{
// will retrieve to update the given Coverage definition
  int ret;
  sqlite3_stmt *stmt = NULL;
  char *dummy;
  const char *sql = "SELECT RL2_SetRasterCoverageInfos(?, ?, ?, ?)";
  ret =
    sqlite3_prepare_v2(MainFrame->GetSqlite(), sql, strlen(sql), &stmt, NULL);
  if (ret != SQLITE_OK)
    {
      const char *msg = sqlite3_errmsg(MainFrame->GetSqlite());
      wxMessageBox(wxT("ERROR - SetRasterCoverageInfos: ") +
                   wxString::FromUTF8(msg), wxT("spatialite_gui"),
                   wxOK | wxICON_ERROR, this);
      return;
    }
  sqlite3_reset(stmt);
  sqlite3_clear_bindings(stmt);
  dummy = (char *) malloc((CoverageName.Len() * 4) + 1);
  strcpy(dummy, CoverageName.ToUTF8());
  sqlite3_bind_text(stmt, 1, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((Title.Len() * 4) + 1);
  strcpy(dummy, Title.ToUTF8());
  sqlite3_bind_text(stmt, 2, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((Abstract.Len() * 4) + 1);
  strcpy(dummy, Abstract.ToUTF8());
  sqlite3_bind_text(stmt, 3, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  if (IsQueryable == false)
    sqlite3_bind_int(stmt, 4, 0);
  else
    sqlite3_bind_int(stmt, 4, 1);
  ret = sqlite3_step(stmt);
  if (ret == SQLITE_DONE || ret == SQLITE_ROW)
    ;
  else
    {
      const char *msg = sqlite3_errmsg(MainFrame->GetSqlite());
      wxMessageBox(wxT("ERROR - SetRasterCoverageInfos: ") +
                   wxString::FromUTF8(msg), wxT("spatialite_gui"),
                   wxOK | wxICON_ERROR, this);
    }
  sqlite3_finalize(stmt);
}

void RasterInfosDialog::OnOk(wxCommandEvent & WXUNUSED(event))
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_CVG_NAME);
  wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_CVG_TITLE);
  wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_CVG_ABSTRACT);
  wxRadioBox *queryableBox = (wxRadioBox *) FindWindow(ID_CVG_QUERYABLE);
  wxString str = nameCtrl->GetValue().Trim();
  CoverageName = str.Trim(false);
  if (CoverageName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Coverage Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = titleCtrl->GetValue().Trim();
  Title = str.Trim(false);
  if (Title.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Title !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = absCtrl->GetValue().Trim();
  Abstract = str.Trim(false);
  if (Abstract.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Abstract !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (queryableBox->GetSelection() == 1)
    IsQueryable = true;
  else
    IsQueryable = false;
  DoUpdateCoverage();
  wxDialog::EndModal(wxID_OK);
}

bool VectorUnregisterDialog::Create(MyFrame * parent, wxString & coverage,
                                    wxString & title, wxString & abstract,
                                    wxString & type)
{
//
// creating the dialog

    ThreadParams.Abort();
}

const char *MyResultSetView::CleanSqlTail(const char *dirty)
{
// strips any leading white-space
  const char *p = dirty;
  while (p != '\0')
    {
      if (*p == ' ')
        {
          p++;
          continue;
        }
      if (*p == '\t')

    ThreadParams.Abort();
}

const char *MyResultSetView::CleanSqlTail(const char *dirty)
{
// strips any leading white-space
  const char *p = dirty;
  while (*p != '\0')
    {
      if (*p == ' ')
        {
          p++;
          continue;
        }
      if (*p == '\t')

      pC = pC->GetNext();
    }
}

void CandidateVectorCoveragesList::MarkRasterCoverage(wxString & table,
                                                      wxString & geometry)
{
// marking a some table related to an already registered Raster Coverage
  CandidateVectorCoverage *pC;
  pC = First;
  while (pC != NULL)
    {
      if (pC->GetTableName().CmpNoCase(table) == 0
          && pC->GetGeometryColumn().CmpNoCase(geometry) == 0)
        {
          pC->MarkRasterCoverage();
          break;
        }
      pC = pC->GetNext();
    }
}





































CandidateVectorCoveragesList *MyFrame::FindUnregisteredVectorCoverages()
{
// will retrieve all not yet registered Geometries
  CandidateVectorCoveragesList *list = new CandidateVectorCoveragesList();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;

// retrieving all entries from GEOMETRY_COLUMNS
  sql =
    "SELECT f_table_name, f_geometry_column, srid, geometry_type "
    "FROM geometry_columns " "ORDER BY f_table_name, f_geometry_column";

















































































































































































































































































































































































































































































































































  int ret = sqlite3_get_table(SqliteHandle, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
................................................................................
                break;
            };
          list->Add(table, geometry, srid, type);
        }
    }
  sqlite3_free_table(results);

// marking any already registered Vector Coverage
  sql = "SELECT f_table_name, f_geometry_column FROM vector_coverages";

  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
................................................................................
          wxString table = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString geometry = wxString::FromUTF8(value);
          list->MarkVectorCoverage(table, geometry);
        }
    }
  sqlite3_free_table(results);


// marking any table related to an already registered Raster Coverage
  sql = "SELECT coverage_name FROM raster_coverages";





























































































  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
................................................................................
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString table = wxString::FromUTF8(value) + wxT("_sections");
          wxString geometry = wxT("geometry");
          list->MarkRasterCoverage(table, geometry);
          table = wxString::FromUTF8(value) + wxT("_tiles");
          list->MarkRasterCoverage(table, geometry);

        }
    }
  sqlite3_free_table(results);
  return list;
}

bool MyFrame::DoRegisterVectorCoverage(wxString & name, wxString & table,
                                       wxString & geometry, wxString & title,
                                       wxString & abstract)

{
//
// attempting to register a Vector Coverage
//
  char *dummy;
  sqlite3_stmt *stmt = NULL;
  const char *sql = "SELECT SE_RegisterVectorCoverage(?, ?, ?, ?, ?)";























































































































  int ret = sqlite3_prepare_v2(SqliteHandle, sql, strlen(sql),
                               &stmt, NULL);
  if (ret != SQLITE_OK)
    return false;

  sqlite3_reset(stmt);
  sqlite3_clear_bindings(stmt);
................................................................................
  strcpy(dummy, title.ToUTF8());
  sqlite3_bind_text(stmt, 4, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((abstract.Len() * 4) + 1);
  strcpy(dummy, abstract.ToUTF8());
  sqlite3_bind_text(stmt, 5, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);






























































































































































































































  ret = sqlite3_step(stmt);
  if (ret == SQLITE_DONE || ret == SQLITE_ROW)
    ;
  else
    {
      sqlite3_finalize(stmt);
      return false;
................................................................................

bool VectorCoverageStylesDialog::Create(MyFrame * parent, wxString & coverage)
{
//
// creating the dialog
//
  MainFrame = parent;







  int pos = coverage.Find(wxT(" [SRID="));
  if (pos != wxNOT_FOUND)
    CoverageName = coverage.Left(pos);
  else
    CoverageName = coverage;
  List = MainFrame->FindVectorCoverageStyles(CoverageName);
  if (wxDialog::Create(parent, wxID_ANY,
................................................................................
bool VectorRegisterDialog::Create(MyFrame * parent)
{
//
// creating the dialog
//
  MainFrame = parent;
  List = MainFrame->FindUnregisteredVectorCoverages();
  if (wxDialog::Create(parent, wxID_ANY, wxT("Register Vector Coverage"))
      == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
................................................................................
// centers the dialog window
  Centre();
  int count = 0;
  CandidateVectorCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true && pC->IsRasterCoverage() != true)

        count++;
      pC = pC->GetNext();
    }
  if (count == 0)
    {
      wxButton *ok = (wxButton *) FindWindow(wxID_OK);
      ok->Enable(false);
................................................................................
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// a GRID to show results
  wxBoxSizer *gridBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(gridBoxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxStaticBox *gridBox = new wxStaticBox(this, wxID_STATIC,
                                         wxT("Candidate Vector Coverages"),

                                         wxDefaultPosition,
                                         wxDefaultSize);
  wxBoxSizer *GridSizer = new wxStaticBoxSizer(gridBox, wxVERTICAL);
  gridBoxSizer->Add(GridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
  wxBoxSizer *gridSizer = new wxBoxSizer(wxHORIZONTAL);
  GridSizer->Add(gridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  GridCtrl =
    new wxGrid(this, ID_VECTOR_GRID, wxDefaultPosition, wxSize(640, 200));
  int count = 0;
  CandidateVectorCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true && pC->IsRasterCoverage() != true)

        count++;
      pC = pC->GetNext();
    }
  GridCtrl->CreateGrid(count, 4, wxGrid::wxGridSelectRows);
  GridCtrl->SetColLabelValue(0, wxT("f_table_name"));
  GridCtrl->SetColLabelValue(1, wxT("f_geometry_column"));
  GridCtrl->SetColLabelValue(2, wxT("SRID"));
................................................................................
  count = 0;
  char dummy[1024];
  wxString cell;
  pC = List->GetFirst();
  while (pC)
    {
      // feeding grid rows
      if (pC->IsVectorCoverage() != true && pC->IsRasterCoverage() != true)

        {
          sprintf(dummy, "%d", count + 1);
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetRowLabelValue(count, cell);
          GridCtrl->SetCellValue(count, 0, pC->GetTableName());
          GridCtrl->SetCellValue(count, 1, pC->GetGeometryColumn());
          sprintf(dummy, "%d", pC->GetSrid());
................................................................................
  wxStaticText *absLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Abstract:"));
  absSizer->Add(absLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *abstractCtrl = new wxTextCtrl(this, ID_VECTOR_ABSTRACT, wxT(""),
                                            wxDefaultPosition, wxSize(550, 60),
                                            wxTE_MULTILINE);
  absSizer->Add(abstractCtrl, 0, wxALIGN_RIGHT | wxALL, 5);



























// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&Register"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
................................................................................
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
  wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
  wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);


  wxString str = nameCtrl->GetValue().Trim();
  CoverageName = str.Trim(false);
  if (CoverageName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Coverage Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
................................................................................
    {
      wxString msg =
        wxT("You must select just a single Candidate to be registered !!!\n");
      msg += wxT("Multiple selection is not supported");
      wxMessageBox(msg, wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































  wxDialog::EndModal(wxID_OK);
}

bool ReloadVectorStyleDialog::Create(MyFrame * parent, wxString & path)
{
//
// creating the dialog
................................................................................

bool VectorSRIDsDialog::Create(MyFrame * parent, wxString & coverage)
{
//
// creating the dialog
//
  MainFrame = parent;







  int pos = coverage.Find(wxT(" [SRID="));
  if (pos != wxNOT_FOUND)
    CoverageName = coverage.Left(pos);
  else
    CoverageName = coverage;
  List = MainFrame->FindVectorAlternativeSRIDs(CoverageName);
  if (wxDialog::Create(parent, wxID_ANY,
................................................................................

bool VectorKeywordsDialog::Create(MyFrame * parent, wxString & coverage)
{
//
// creating the dialog
//
  MainFrame = parent;







  int pos = coverage.Find(wxT(" [SRID="));
  if (pos != wxNOT_FOUND)
    CoverageName = coverage.Left(pos);
  else
    CoverageName = coverage;
  List = MainFrame->FindVectorKeywords(CoverageName);
  if (wxDialog::Create(parent, wxID_ANY,
................................................................................
      path = params->GetPathByIndex(i);
      params->SetCurrentPath(path);
      report = wxT("Loading and Validating: ") + path;
      evt_start.SetString(report);
      params->GetDlg()->GetEventHandler()->AddPendingEvent(evt_start);
      clock_start = clock();
      wxString abstract;
      if (params->
          GetMainFrame()->ValidateExternalGraphicResource(path.ToUTF8(), &blob,
                                                          &blob_size,
                                                          abstract) == true)
        {
          wxFileName fn(path);
          wxString xlink_href =
            wxT("http://www.utopia.gov/") + fn.GetFullName();
          wxString filename = fn.GetFullName();
          wxString title = fn.GetName();
          if (params->
              GetDlg()->RegisterExternalGraphic(stmt, xlink_href.ToUTF8(),
                                                title.ToUTF8(),
                                                abstract.ToUTF8(),
                                                filename.ToUTF8(), blob,
                                                blob_size) != true)
            {
              params->SetError();
              goto error;
            }
          clock_end = clock();
          seconds =
            (double) (clock_end - clock_start) / (double) CLOCKS_PER_SEC;

      pC = pC->GetNext();
    }
}

void CandidateVectorCoveragesList::MarkRasterCoverage(wxString & table,
                                                      wxString & geometry)
{
// marking some table related to a Raster Coverage
  CandidateVectorCoverage *pC;
  pC = First;
  while (pC != NULL)
    {
      if (pC->GetTableName().CmpNoCase(table) == 0
          && pC->GetGeometryColumn().CmpNoCase(geometry) == 0)
        {
          pC->MarkRasterCoverage();
          break;
        }
      pC = pC->GetNext();
    }
}

void CandidateVectorCoveragesList::MarkTopoGeoCoverage(wxString & table,
                                                       wxString & geometry)
{
// marking some table related to Topology-Geometry
  CandidateVectorCoverage *pC;
  pC = First;
  while (pC != NULL)
    {
      if (pC->GetTableName().CmpNoCase(table) == 0
          && pC->GetGeometryColumn().CmpNoCase(geometry) == 0)
        {
          pC->MarkTopoGeoCoverage();
          break;
        }
      pC = pC->GetNext();
    }
}

void CandidateVectorCoveragesList::MarkTopoNetCoverage(wxString & table,
                                                       wxString & geometry)
{
// marking some table related to Topology-Network
  CandidateVectorCoverage *pC;
  pC = First;
  while (pC != NULL)
    {
      if (pC->GetTableName().CmpNoCase(table) == 0
          && pC->GetGeometryColumn().CmpNoCase(geometry) == 0)
        {
          pC->MarkTopoNetCoverage();
          break;
        }
      pC = pC->GetNext();
    }
}

CandidateVectorCoveragesList *MyFrame::FindUnregisteredVectorCoverages()
{
// will retrieve all not yet registered GeoTables
  CandidateVectorCoveragesList *list = new CandidateVectorCoveragesList();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;

// retrieving all entries from GEOMETRY_COLUMNS
  sql =
    "SELECT f_table_name, f_geometry_column, srid, geometry_type "
    "FROM geometry_columns ORDER BY f_table_name, f_geometry_column";
  int ret = sqlite3_get_table(SqliteHandle, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString table = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString geometry = wxString::FromUTF8(value);
          value = results[(i * columns) + 2];
          int srid = atoi(value);
          value = results[(i * columns) + 3];
          int gtype = atoi(value);
          wxString type = wxT("***  UNKNOWN  ***");
          switch (gtype)
            {
              case 0:
              case 1000:
              case 2000:
              case 3000:
                type = wxT("GEOMETRY");
                break;
              case 1:
              case 1001:
              case 2001:
              case 3001:
                type = wxT("POINT");
                break;
              case 2:
              case 1002:
              case 2002:
              case 3002:
                type = wxT("LINESTRING");
                break;
              case 3:
              case 1003:
              case 2003:
              case 3003:
                type = wxT("POLYGON");
                break;
              case 4:
              case 1004:
              case 2004:
              case 3004:
                type = wxT("MULTIPOINT");
                break;
              case 5:
              case 1005:
              case 2005:
              case 3005:
                type = wxT("MULTILINESTRING");
                break;
              case 6:
              case 1006:
              case 2006:
              case 3006:
                type = wxT("MULTIPOLYGON");
                break;
              case 7:
              case 1007:
              case 2007:
              case 3007:
                type = wxT("GEOMETRYCOLLECTION");
                break;
              default:
                type = wxT("***  UNKNOWN  ***");
                break;
            };
          switch (gtype)
            {
              case 0:
              case 1:
              case 2:
              case 3:
              case 4:
              case 5:
              case 6:
              case 7:
                type += wxT(" XY");
                break;
              case 1000:
              case 1001:
              case 1002:
              case 1003:
              case 1004:
              case 1005:
              case 1006:
              case 1007:
                type += wxT(" XYZ");
                break;
              case 2000:
              case 2001:
              case 2002:
              case 2003:
              case 2004:
              case 2005:
              case 2006:
              case 2007:
                type += wxT(" XYM");
                break;
              case 3000:
              case 3001:
              case 3002:
              case 3003:
              case 3004:
              case 3005:
              case 3006:
              case 3007:
                type += wxT(" XYZM");
                break;
            };
          list->Add(table, geometry, srid, type);
        }
    }
  sqlite3_free_table(results);

// marking any already registered Vector Coverage
  sql = "SELECT f_table_name, f_geometry_column FROM vector_coverages "
    "WHERE f_table_name IS NOT NULL AND f_geometry_column IS NOT NULL";
  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString table = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString geometry = wxString::FromUTF8(value);
          list->MarkVectorCoverage(table, geometry);
        }
    }
  sqlite3_free_table(results);

// marking any table related to some Raster Coverage
  sql = "SELECT coverage_name FROM raster_coverages";
  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString table = wxString::FromUTF8(value) + wxT("_sections");
          wxString geometry = wxT("geometry");
          list->MarkRasterCoverage(table, geometry);
          table = wxString::FromUTF8(value) + wxT("_tiles");
          list->MarkRasterCoverage(table, geometry);
        }
    }
  sqlite3_free_table(results);

// marking any table related to some Topology-Geometry
  sql = "SELECT topology_name FROM topologies";
  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString table = wxString::FromUTF8(value) + wxT("_face");
          wxString geometry = wxT("mbr");
          list->MarkTopoGeoCoverage(table, geometry);
          geometry = wxT("geom");
          table = wxString::FromUTF8(value) + wxT("_node");
          list->MarkTopoGeoCoverage(table, geometry);
          table = wxString::FromUTF8(value) + wxT("_edge");
          list->MarkTopoGeoCoverage(table, geometry);
          table = wxString::FromUTF8(value) + wxT("_seeds");
          list->MarkTopoGeoCoverage(table, geometry);
        }
    }
  sqlite3_free_table(results);

// marking any table related to some Topology-Network
  sql = "SELECT network_name FROM networks";
  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString table = wxString::FromUTF8(value) + wxT("_link");
          wxString geometry = wxT("geometry");
          list->MarkTopoNetCoverage(table, geometry);
          table = wxString::FromUTF8(value) + wxT("_node");
          list->MarkTopoNetCoverage(table, geometry);
          table = wxString::FromUTF8(value) + wxT("_seeds");
          list->MarkTopoNetCoverage(table, geometry);
        }
    }
  sqlite3_free_table(results);
  return list;
}

CandidateSpatialViewCoveragesList::~CandidateSpatialViewCoveragesList()
{
// destructor
  CandidateSpatialViewCoverage *pC;
  CandidateSpatialViewCoverage *pCn;
  pC = First;
  while (pC != NULL)
    {
      pCn = pC->GetNext();
      delete pC;
      pC = pCn;
    }
}

void CandidateSpatialViewCoveragesList::Add(wxString & view_name,
                                            wxString & geometry, int srid,
                                            wxString & type)
{
// inserting a new candidate Vector Coverage - SpatialView
  CandidateSpatialViewCoverage *pC =
    new CandidateSpatialViewCoverage(view_name, geometry, srid, type);
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}

void CandidateSpatialViewCoveragesList::MarkVectorCoverage(wxString & view,
                                                           wxString & geometry)
{
// marking an already registered Vector Coverage
  CandidateSpatialViewCoverage *pC;
  pC = First;
  while (pC != NULL)
    {
      if (pC->GetViewName().CmpNoCase(view) == 0
          && pC->GetViewGeometry().CmpNoCase(geometry) == 0)
        {
          pC->MarkVectorCoverage();
          break;
        }
      pC = pC->GetNext();
    }
}

CandidateSpatialViewCoveragesList
  * MyFrame::FindUnregisteredSpatialViewCoverages()
{
// will retrieve all not yet registered SpatialViews
  CandidateSpatialViewCoveragesList *list =
    new CandidateSpatialViewCoveragesList();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;

// retrieving all entries from VIEWS_GEOMETRY_COLUMNS
  sql =
    "SELECT v.view_name, v.view_geometry, g.srid, g.geometry_type "
    "FROM views_geometry_columns AS v "
    "JOIN geometry_columns AS g ON (Lower(v.f_table_name) = Lower(g.f_table_name) "
    "AND Lower(v.f_geometry_column) = Lower(g.f_geometry_column)) "
    "ORDER BY v.view_name, v.view_geometry";
  int ret = sqlite3_get_table(SqliteHandle, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString view = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString geometry = wxString::FromUTF8(value);
          value = results[(i * columns) + 2];
          int srid = atoi(value);
          value = results[(i * columns) + 3];
          int gtype = atoi(value);
          wxString type = wxT("***  UNKNOWN  ***");
          switch (gtype)
            {
              case 0:
              case 1000:
              case 2000:
              case 3000:
                type = wxT("GEOMETRY");
                break;
              case 1:
              case 1001:
              case 2001:
              case 3001:
                type = wxT("POINT");
                break;
              case 2:
              case 1002:
              case 2002:
              case 3002:
                type = wxT("LINESTRING");
                break;
              case 3:
              case 1003:
              case 2003:
              case 3003:
                type = wxT("POLYGON");
                break;
              case 4:
              case 1004:
              case 2004:
              case 3004:
                type = wxT("MULTIPOINT");
                break;
              case 5:
              case 1005:
              case 2005:
              case 3005:
                type = wxT("MULTILINESTRING");
                break;
              case 6:
              case 1006:
              case 2006:
              case 3006:
                type = wxT("MULTIPOLYGON");
                break;
              case 7:
              case 1007:
              case 2007:
              case 3007:
                type = wxT("GEOMETRYCOLLECTION");
                break;
              default:
                type = wxT("***  UNKNOWN  ***");
                break;
            };
          switch (gtype)
            {
              case 0:
              case 1:
              case 2:
              case 3:
              case 4:
              case 5:
              case 6:
              case 7:
                type += wxT(" XY");
                break;
              case 1000:
              case 1001:
              case 1002:
              case 1003:
              case 1004:
              case 1005:
              case 1006:
              case 1007:
                type += wxT(" XYZ");
                break;
              case 2000:
              case 2001:
              case 2002:
              case 2003:
              case 2004:
              case 2005:
              case 2006:
              case 2007:
                type += wxT(" XYM");
                break;
              case 3000:
              case 3001:
              case 3002:
              case 3003:
              case 3004:
              case 3005:
              case 3006:
              case 3007:
                type += wxT(" XYZM");
                break;
            };
          list->Add(view, geometry, srid, type);
        }
    }
  sqlite3_free_table(results);

// marking any already registered SpatialView Coverage
  sql = "SELECT view_name, view_geometry FROM vector_coverages "
    "WHERE view_name IS NOT NULL AND view_geometry IS NOT NULL";
  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString table = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString geometry = wxString::FromUTF8(value);
          list->MarkVectorCoverage(table, geometry);
        }
    }
  sqlite3_free_table(results);
  return list;
}

CandidateVirtualShapeCoveragesList::~CandidateVirtualShapeCoveragesList()
{
// destructor
  CandidateVirtualShapeCoverage *pC;
  CandidateVirtualShapeCoverage *pCn;
  pC = First;
  while (pC != NULL)
    {
      pCn = pC->GetNext();
      delete pC;
      pC = pCn;
    }
}

void CandidateVirtualShapeCoveragesList::Add(wxString & virt_name,
                                             wxString & geometry, int srid,
                                             wxString & type)
{
// inserting a new candidate Vector Coverage - VirtualShape
  CandidateVirtualShapeCoverage *pC =
    new CandidateVirtualShapeCoverage(virt_name, geometry, srid, type);
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}

void CandidateVirtualShapeCoveragesList::MarkVectorCoverage(wxString & table,
                                                            wxString & geometry)
{
// marking an already registered Vector Coverage
  CandidateVirtualShapeCoverage *pC;
  pC = First;
  while (pC != NULL)
    {
      if (pC->GetVirtName().CmpNoCase(table) == 0
          && pC->GetVirtGeometry().CmpNoCase(geometry) == 0)
        {
          pC->MarkVectorCoverage();
          break;
        }
      pC = pC->GetNext();
    }
}

CandidateVirtualShapeCoveragesList
  * MyFrame::FindUnregisteredVirtualShapeCoverages()
{
// will retrieve all not yet registered VirtualShape
  CandidateVirtualShapeCoveragesList *list =
    new CandidateVirtualShapeCoveragesList();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;

// retrieving all entries from VIERTS_GEOMETRY_COLUMNS
  sql =
    "SELECT virt_name, virt_geometry, srid, geometry_type "
    "FROM virts_geometry_columns AS v " "ORDER BY virt_name, v.virt_geometry";
  int ret = sqlite3_get_table(SqliteHandle, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
................................................................................
                break;
            };
          list->Add(table, geometry, srid, type);
        }
    }
  sqlite3_free_table(results);

// marking any already registered VirtualShape Coverage
  sql = "SELECT virt_name, virt_geometry FROM vector_coverages "
    "WHERE virt_name IS NOT NULL AND virt_geometry IS NOT NULL";
  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
................................................................................
          wxString table = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          wxString geometry = wxString::FromUTF8(value);
          list->MarkVectorCoverage(table, geometry);
        }
    }
  sqlite3_free_table(results);
  return list;
}



CandidateTopoGeoCoveragesList::~CandidateTopoGeoCoveragesList()
{
// destructor
  CandidateTopoGeoCoverage *pC;
  CandidateTopoGeoCoverage *pCn;
  pC = First;
  while (pC != NULL)
    {
      pCn = pC->GetNext();
      delete pC;
      pC = pCn;
    }
}

void CandidateTopoGeoCoveragesList::Add(wxString & topology, int srid,
                                        wxString & dimensions, double tolerance)
{
// inserting a new candidate TopoGeo Coverage
  CandidateTopoGeoCoverage *pC =
    new CandidateTopoGeoCoverage(topology, srid, dimensions, tolerance);
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}

void CandidateTopoGeoCoveragesList::MarkVectorCoverage(wxString & topology)
{
// marking an already registered TopoGeo Coverage
  CandidateTopoGeoCoverage *pC;
  pC = First;
  while (pC != NULL)
    {
      if (pC->GetTopologyName().CmpNoCase(topology) == 0)
        {
          pC->MarkVectorCoverage();
          break;
        }
      pC = pC->GetNext();
    }
}

CandidateTopoGeoCoveragesList *MyFrame::FindUnregisteredTopoGeoCoverages()
{
// will retrieve all not yet registered Topology-Geometries
  CandidateTopoGeoCoveragesList *list = new CandidateTopoGeoCoveragesList();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;

// retrieving all entries from TOPOLOGIES
  sql =
    "SELECT topology_name, srid, has_z, tolerance "
    "FROM topologies ORDER BY topology_name";
  int ret = sqlite3_get_table(SqliteHandle, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString topology = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          int srid = atoi(value);
          wxString dimensions = wxT("2D");
          value = results[(i * columns) + 2];
          if (atoi(value))
            dimensions = wxT("3D");
          value = results[(i * columns) + 3];
          double tolerance = atof(value);
          list->Add(topology, srid, dimensions, tolerance);
        }
    }
  sqlite3_free_table(results);

// marking any already registered Vector Coverage
  sql = "SELECT topology_name FROM vector_coverages "
    "WHERE topology_name IS NOT NULL";
  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
................................................................................
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];



          wxString topology = wxString::FromUTF8(value);

          list->MarkVectorCoverage(topology);
        }
    }
  sqlite3_free_table(results);
  return list;
}

bool MyFrame::DoRegisterVectorCoverage(wxString & name, wxString & table,
                                       wxString & geometry, wxString & title,
                                       wxString & abstract, bool isQueryable,
                                       bool isEditable)
{
//
// attempting to register a Vector Coverage - SpatialTable
//
  char *dummy;
  sqlite3_stmt *stmt = NULL;
  const char *sql = "SELECT SE_RegisterVectorCoverage(?, ?, ?, ?, ?, ?, ?)";
  int ret = sqlite3_prepare_v2(SqliteHandle, sql, strlen(sql),
                               &stmt, NULL);
  if (ret != SQLITE_OK)
    return false;

  sqlite3_reset(stmt);
  sqlite3_clear_bindings(stmt);
  dummy = (char *) malloc((name.Len() * 4) + 1);
  strcpy(dummy, name.ToUTF8());
  sqlite3_bind_text(stmt, 1, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((table.Len() * 4) + 1);
  strcpy(dummy, table.ToUTF8());
  sqlite3_bind_text(stmt, 2, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((geometry.Len() * 4) + 1);
  strcpy(dummy, geometry.ToUTF8());
  sqlite3_bind_text(stmt, 3, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((title.Len() * 4) + 1);
  strcpy(dummy, title.ToUTF8());
  sqlite3_bind_text(stmt, 4, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((abstract.Len() * 4) + 1);
  strcpy(dummy, abstract.ToUTF8());
  sqlite3_bind_text(stmt, 5, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  if (isQueryable == false)
    sqlite3_bind_int(stmt, 6, 0);
  else
    sqlite3_bind_int(stmt, 6, 1);
  if (isEditable == false)
    sqlite3_bind_int(stmt, 7, 0);
  else
    sqlite3_bind_int(stmt, 7, 1);
  ret = sqlite3_step(stmt);
  if (ret == SQLITE_DONE || ret == SQLITE_ROW)
    ;
  else
    {
      sqlite3_finalize(stmt);
      return false;
    }
  sqlite3_finalize(stmt);
  return true;
}

bool MyFrame::DoRegisterSpatialViewCoverage(wxString & name, wxString & view,
                                            wxString & geometry,
                                            wxString & title,
                                            wxString & abstract,
                                            bool isQueryable, bool isEditable)
{
//
// attempting to register a Vector Coverage - SpatialView
//
  char *dummy;
  sqlite3_stmt *stmt = NULL;
  const char *sql =
    "SELECT SE_RegisterSpatialViewCoverage(?, ?, ?, ?, ?, ?, ?)";
  int ret = sqlite3_prepare_v2(SqliteHandle, sql, strlen(sql),
                               &stmt, NULL);
  if (ret != SQLITE_OK)
    return false;

  sqlite3_reset(stmt);
  sqlite3_clear_bindings(stmt);
  dummy = (char *) malloc((name.Len() * 4) + 1);
  strcpy(dummy, name.ToUTF8());
  sqlite3_bind_text(stmt, 1, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((view.Len() * 4) + 1);
  strcpy(dummy, view.ToUTF8());
  sqlite3_bind_text(stmt, 2, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((geometry.Len() * 4) + 1);
  strcpy(dummy, geometry.ToUTF8());
  sqlite3_bind_text(stmt, 3, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((title.Len() * 4) + 1);
  strcpy(dummy, title.ToUTF8());
  sqlite3_bind_text(stmt, 4, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((abstract.Len() * 4) + 1);
  strcpy(dummy, abstract.ToUTF8());
  sqlite3_bind_text(stmt, 5, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  if (isQueryable == false)
    sqlite3_bind_int(stmt, 6, 0);
  else
    sqlite3_bind_int(stmt, 6, 1);
  if (isEditable == false)
    sqlite3_bind_int(stmt, 7, 0);
  else
    sqlite3_bind_int(stmt, 7, 1);
  ret = sqlite3_step(stmt);
  if (ret == SQLITE_DONE || ret == SQLITE_ROW)
    ;
  else
    {
      sqlite3_finalize(stmt);
      return false;
    }
  sqlite3_finalize(stmt);
  return true;
}

bool MyFrame::DoRegisterVirtualShapeCoverage(wxString & name, wxString & table,
                                             wxString & geometry,
                                             wxString & title,
                                             wxString & abstract,
                                             bool isQueryable)
{
//
// attempting to register a Vector Coverage - VirtualShape
//
  char *dummy;
  sqlite3_stmt *stmt = NULL;
  const char *sql = "SELECT SE_RegisterVirtualShapeCoverage(?, ?, ?, ?, ?, ?)";
  int ret = sqlite3_prepare_v2(SqliteHandle, sql, strlen(sql),
                               &stmt, NULL);
  if (ret != SQLITE_OK)
    return false;

  sqlite3_reset(stmt);
  sqlite3_clear_bindings(stmt);
................................................................................
  strcpy(dummy, title.ToUTF8());
  sqlite3_bind_text(stmt, 4, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((abstract.Len() * 4) + 1);
  strcpy(dummy, abstract.ToUTF8());
  sqlite3_bind_text(stmt, 5, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  if (isQueryable == false)
    sqlite3_bind_int(stmt, 6, 0);
  else
    sqlite3_bind_int(stmt, 6, 1);
  ret = sqlite3_step(stmt);
  if (ret == SQLITE_DONE || ret == SQLITE_ROW)
    ;
  else
    {
      sqlite3_finalize(stmt);
      return false;
    }
  sqlite3_finalize(stmt);
  return true;
}

bool MyFrame::DoRegisterTopoGeoCoverage(wxString & name, wxString & topology,
                                        wxString & title, wxString & abstract,
                                        bool isQueryable, bool isEditable)
{
//
// attempting to register a TopoGeo Coverage
//
  char *dummy;
  sqlite3_stmt *stmt = NULL;
  const char *sql = "SELECT SE_RegisterTopoGeoCoverage(?, ?, ?, ?, ?, ?)";
  int ret = sqlite3_prepare_v2(SqliteHandle, sql, strlen(sql),
                               &stmt, NULL);
  if (ret != SQLITE_OK)
    return false;

  sqlite3_reset(stmt);
  sqlite3_clear_bindings(stmt);
  dummy = (char *) malloc((name.Len() * 4) + 1);
  strcpy(dummy, name.ToUTF8());
  sqlite3_bind_text(stmt, 1, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((topology.Len() * 4) + 1);
  strcpy(dummy, topology.ToUTF8());
  sqlite3_bind_text(stmt, 2, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((title.Len() * 4) + 1);
  strcpy(dummy, title.ToUTF8());
  sqlite3_bind_text(stmt, 3, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((abstract.Len() * 4) + 1);
  strcpy(dummy, abstract.ToUTF8());
  sqlite3_bind_text(stmt, 4, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  if (isQueryable == false)
    sqlite3_bind_int(stmt, 5, 0);
  else
    sqlite3_bind_int(stmt, 5, 1);
  if (isEditable == false)
    sqlite3_bind_int(stmt, 6, 0);
  else
    sqlite3_bind_int(stmt, 6, 1);
  ret = sqlite3_step(stmt);
  if (ret == SQLITE_DONE || ret == SQLITE_ROW)
    ;
  else
    {
      sqlite3_finalize(stmt);
      return false;
    }
  sqlite3_finalize(stmt);
  return true;
}

CandidateTopoNetCoveragesList::~CandidateTopoNetCoveragesList()
{
// destructor
  CandidateTopoNetCoverage *pC;
  CandidateTopoNetCoverage *pCn;
  pC = First;
  while (pC != NULL)
    {
      pCn = pC->GetNext();
      delete pC;
      pC = pCn;
    }
}

void CandidateTopoNetCoveragesList::Add(wxString & network, int srid,
                                        wxString & dimensions)
{
// inserting a new candidate TopoNet Coverage
  CandidateTopoNetCoverage *pC =
    new CandidateTopoNetCoverage(network, srid, dimensions);
  if (First == NULL)
    First = pC;
  if (Last != NULL)
    Last->SetNext(pC);
  Last = pC;
}

void CandidateTopoNetCoveragesList::MarkVectorCoverage(wxString & network)
{
// marking an already registered TopoNet Coverage
  CandidateTopoNetCoverage *pC;
  pC = First;
  while (pC != NULL)
    {
      if (pC->GetNetworkName().CmpNoCase(network) == 0)
        {
          pC->MarkVectorCoverage();
          break;
        }
      pC = pC->GetNext();
    }
}

CandidateTopoNetCoveragesList *MyFrame::FindUnregisteredTopoNetCoverages()
{
// will retrieve all not yet registered Topology-Networks
  CandidateTopoNetCoveragesList *list = new CandidateTopoNetCoveragesList();
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  const char *sql;

// retrieving all entries from NETWORKS
  sql = "SELECT network_name, srid, has_z FROM networks ORDER BY network_name";
  int ret = sqlite3_get_table(SqliteHandle, sql, &results,
                              &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString topology = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          int srid = atoi(value);
          wxString dimensions = wxT("2D");
          value = results[(i * columns) + 2];
          if (atoi(value))
            dimensions = wxT("3D");
          list->Add(topology, srid, dimensions);
        }
    }
  sqlite3_free_table(results);

// marking any already registered Vector Coverage
  sql = "SELECT network_name FROM vector_coverages "
    "WHERE network_name IS NOT NULL";
  ret = sqlite3_get_table(SqliteHandle, sql, &results,
                          &rows, &columns, &errMsg);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return list;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          wxString topology = wxString::FromUTF8(value);
          list->MarkVectorCoverage(topology);
        }
    }
  sqlite3_free_table(results);
  return list;
}

bool MyFrame::DoRegisterTopoNetCoverage(wxString & name, wxString & network,
                                        wxString & title, wxString & abstract,
                                        bool isQueryable, bool isEditable)
{
//
// attempting to register a TopoNet Coverage
//
  char *dummy;
  sqlite3_stmt *stmt = NULL;
  const char *sql = "SELECT SE_RegisterTopoNetCoverage(?, ?, ?, ?, ?, ?)";
  int ret = sqlite3_prepare_v2(SqliteHandle, sql, strlen(sql),
                               &stmt, NULL);
  if (ret != SQLITE_OK)
    return false;

  sqlite3_reset(stmt);
  sqlite3_clear_bindings(stmt);
  dummy = (char *) malloc((name.Len() * 4) + 1);
  strcpy(dummy, name.ToUTF8());
  sqlite3_bind_text(stmt, 1, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((network.Len() * 4) + 1);
  strcpy(dummy, network.ToUTF8());
  sqlite3_bind_text(stmt, 2, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((title.Len() * 4) + 1);
  strcpy(dummy, title.ToUTF8());
  sqlite3_bind_text(stmt, 3, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((abstract.Len() * 4) + 1);
  strcpy(dummy, abstract.ToUTF8());
  sqlite3_bind_text(stmt, 4, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  if (isQueryable == false)
    sqlite3_bind_int(stmt, 5, 0);
  else
    sqlite3_bind_int(stmt, 5, 1);
  if (isEditable == false)
    sqlite3_bind_int(stmt, 6, 0);
  else
    sqlite3_bind_int(stmt, 6, 1);
  ret = sqlite3_step(stmt);
  if (ret == SQLITE_DONE || ret == SQLITE_ROW)
    ;
  else
    {
      sqlite3_finalize(stmt);
      return false;
................................................................................

bool VectorCoverageStylesDialog::Create(MyFrame * parent, wxString & coverage)
{
//
// creating the dialog
//
  MainFrame = parent;
  wxString clean;
  if (coverage.StartsWith(wxT("table."), &clean))
    coverage = clean;
  else if (coverage.StartsWith(wxT("view."), &clean))
    coverage = clean;
  else if (coverage.StartsWith(wxT("shp."), &clean))
    coverage = clean;
  int pos = coverage.Find(wxT(" [SRID="));
  if (pos != wxNOT_FOUND)
    CoverageName = coverage.Left(pos);
  else
    CoverageName = coverage;
  List = MainFrame->FindVectorCoverageStyles(CoverageName);
  if (wxDialog::Create(parent, wxID_ANY,
................................................................................
bool VectorRegisterDialog::Create(MyFrame * parent)
{
//
// creating the dialog
//
  MainFrame = parent;
  List = MainFrame->FindUnregisteredVectorCoverages();
  if (wxDialog::Create(parent, wxID_ANY, wxT("Register SpatialTable Coverage"))
      == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
................................................................................
// centers the dialog window
  Centre();
  int count = 0;
  CandidateVectorCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true && pC->IsRasterCoverage() != true
          && pC->IsTopoGeo() != true && pC->IsTopoNet() != true)
        count++;
      pC = pC->GetNext();
    }
  if (count == 0)
    {
      wxButton *ok = (wxButton *) FindWindow(wxID_OK);
      ok->Enable(false);
................................................................................
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// a GRID to show results
  wxBoxSizer *gridBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(gridBoxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxStaticBox *gridBox = new wxStaticBox(this, wxID_STATIC,
                                         wxT
                                         ("Candidate SpatialTable Coverages"),
                                         wxDefaultPosition,
                                         wxDefaultSize);
  wxBoxSizer *GridSizer = new wxStaticBoxSizer(gridBox, wxVERTICAL);
  gridBoxSizer->Add(GridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
  wxBoxSizer *gridSizer = new wxBoxSizer(wxHORIZONTAL);
  GridSizer->Add(gridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  GridCtrl =
    new wxGrid(this, ID_VECTOR_GRID, wxDefaultPosition, wxSize(640, 200));
  int count = 0;
  CandidateVectorCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true && pC->IsRasterCoverage() != true
          && pC->IsTopoGeo() != true && pC->IsTopoNet() != true)
        count++;
      pC = pC->GetNext();
    }
  GridCtrl->CreateGrid(count, 4, wxGrid::wxGridSelectRows);
  GridCtrl->SetColLabelValue(0, wxT("f_table_name"));
  GridCtrl->SetColLabelValue(1, wxT("f_geometry_column"));
  GridCtrl->SetColLabelValue(2, wxT("SRID"));
................................................................................
  count = 0;
  char dummy[1024];
  wxString cell;
  pC = List->GetFirst();
  while (pC)
    {
      // feeding grid rows
      if (pC->IsVectorCoverage() != true && pC->IsRasterCoverage() != true
          && pC->IsTopoGeo() != true && pC->IsTopoNet() != true)
        {
          sprintf(dummy, "%d", count + 1);
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetRowLabelValue(count, cell);
          GridCtrl->SetCellValue(count, 0, pC->GetTableName());
          GridCtrl->SetCellValue(count, 1, pC->GetGeometryColumn());
          sprintf(dummy, "%d", pC->GetSrid());
................................................................................
  wxStaticText *absLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Abstract:"));
  absSizer->Add(absLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *abstractCtrl = new wxTextCtrl(this, ID_VECTOR_ABSTRACT, wxT(""),
                                            wxDefaultPosition, wxSize(550, 60),
                                            wxTE_MULTILINE);
  absSizer->Add(abstractCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fifth row: queryable / editable
  wxBoxSizer *radioSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(radioSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxString yesno[2];
  yesno[0] = wxT("&No");
  yesno[1] = wxT("&Yes");
  wxRadioBox *queryableBox = new wxRadioBox(this, ID_VECTOR_QUERYABLE,
                                            wxT("Is &Queryable"),
                                            wxDefaultPosition,
                                            wxDefaultSize, 2,
                                            yesno, 1,
                                            wxRA_SPECIFY_ROWS);
  radioSizer->Add(queryableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  queryableBox->SetSelection(1);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  wxRadioBox *editableBox = new wxRadioBox(this, ID_VECTOR_EDITABLE,
                                           wxT("Is &Editable"),
                                           wxDefaultPosition,
                                           wxDefaultSize, 2,
                                           yesno, 1,
                                           wxRA_SPECIFY_ROWS);
  radioSizer->Add(editableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  editableBox->SetSelection(1);

// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&Register"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
................................................................................
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
  wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
  wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
  wxRadioBox *queryableBox = (wxRadioBox *) FindWindow(ID_VECTOR_QUERYABLE);
  wxRadioBox *editableBox = (wxRadioBox *) FindWindow(ID_VECTOR_EDITABLE);
  wxString str = nameCtrl->GetValue().Trim();
  CoverageName = str.Trim(false);
  if (CoverageName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Coverage Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
................................................................................
    {
      wxString msg =
        wxT("You must select just a single Candidate to be registered !!!\n");
      msg += wxT("Multiple selection is not supported");
      wxMessageBox(msg, wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (queryableBox->GetSelection() == 1)
    Queryable = true;
  else
    Queryable = false;
  if (editableBox->GetSelection() == 1)
    Editable = true;
  else
    Editable = false;
  wxDialog::EndModal(wxID_OK);
}

bool SpatialViewRegisterDialog::Create(MyFrame * parent)
{
//
// creating the dialog
//
  MainFrame = parent;
  List = MainFrame->FindUnregisteredSpatialViewCoverages();
  if (wxDialog::Create(parent, wxID_ANY, wxT("Register SpatialView Coverage"))
      == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
// centers the dialog window
  Centre();
  int count = 0;
  CandidateSpatialViewCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true)
        count++;
      pC = pC->GetNext();
    }
  if (count == 0)
    {
      wxButton *ok = (wxButton *) FindWindow(wxID_OK);
      ok->Enable(false);
      wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
      nameCtrl->Enable(false);
      wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
      titleCtrl->Enable(false);
      wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
      absCtrl->Enable(false);
      wxMessageBox(wxT
                   ("There are no possible Candidates to be eventually registered"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
    }
  return true;
}

void SpatialViewRegisterDialog::CreateControls()
{
//
// creating individual control and setting initial values
//
  wxBoxSizer *topSizer = new wxBoxSizer(wxVERTICAL);
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// a GRID to show results
  wxBoxSizer *gridBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(gridBoxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxStaticBox *gridBox = new wxStaticBox(this, wxID_STATIC,
                                         wxT("Candidate SpatialView Coverages"),
                                         wxDefaultPosition,
                                         wxDefaultSize);
  wxBoxSizer *GridSizer = new wxStaticBoxSizer(gridBox, wxVERTICAL);
  gridBoxSizer->Add(GridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
  wxBoxSizer *gridSizer = new wxBoxSizer(wxHORIZONTAL);
  GridSizer->Add(gridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  GridCtrl =
    new wxGrid(this, ID_VECTOR_GRID, wxDefaultPosition, wxSize(640, 200));
  int count = 0;
  CandidateSpatialViewCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true)
        count++;
      pC = pC->GetNext();
    }
  GridCtrl->CreateGrid(count, 4, wxGrid::wxGridSelectRows);
  GridCtrl->SetColLabelValue(0, wxT("view_name"));
  GridCtrl->SetColLabelValue(1, wxT("view_geometry"));
  GridCtrl->SetColLabelValue(2, wxT("SRID"));
  GridCtrl->SetColLabelValue(3, wxT("GeometryType"));
  count = 0;
  char dummy[1024];
  wxString cell;
  pC = List->GetFirst();
  while (pC)
    {
      // feeding grid rows
      if (pC->IsVectorCoverage() != true)
        {
          sprintf(dummy, "%d", count + 1);
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetRowLabelValue(count, cell);
          GridCtrl->SetCellValue(count, 0, pC->GetViewName());
          GridCtrl->SetCellValue(count, 1, pC->GetViewGeometry());
          sprintf(dummy, "%d", pC->GetSrid());
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetCellValue(count, 2, cell);
          GridCtrl->SetCellAlignment(count, 2, wxALIGN_RIGHT, wxALIGN_CENTRE);
          GridCtrl->SetCellValue(count, 3, pC->GetGeometryType());
          count++;
        }
      pC = pC->GetNext();
    }
  GridCtrl->SetRowLabelSize(wxGRID_AUTOSIZE);
  GridCtrl->AutoSize();
  GridCtrl->EnableEditing(false);
  gridSizer->Add(GridCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// second row: the Coverage Name
  wxBoxSizer *nameSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(nameSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *nameLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Coverage Name:"));
  nameSizer->Add(nameLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *nameCtrl = new wxTextCtrl(this, ID_VECTOR_COVERAGE, wxT(""),
                                        wxDefaultPosition, wxSize(550, 22));
  nameSizer->Add(nameCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// third row: the Coverage Title
  wxBoxSizer *titleSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(titleSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *titleLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Title:"));
  titleSizer->Add(titleLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *titleCtrl = new wxTextCtrl(this, ID_VECTOR_TITLE, wxT(""),
                                         wxDefaultPosition, wxSize(550, 22));
  titleSizer->Add(titleCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fourth row: the Coverage Abstract
  wxBoxSizer *absSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(absSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *absLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Abstract:"));
  absSizer->Add(absLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *abstractCtrl = new wxTextCtrl(this, ID_VECTOR_ABSTRACT, wxT(""),
                                            wxDefaultPosition, wxSize(550, 60),
                                            wxTE_MULTILINE);
  absSizer->Add(abstractCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fifth row: queryable / editable
  wxBoxSizer *radioSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(radioSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxString yesno[2];
  yesno[0] = wxT("&No");
  yesno[1] = wxT("&Yes");
  wxRadioBox *queryableBox = new wxRadioBox(this, ID_VECTOR_QUERYABLE,
                                            wxT("Is &Queryable"),
                                            wxDefaultPosition,
                                            wxDefaultSize, 2,
                                            yesno, 1,
                                            wxRA_SPECIFY_ROWS);
  radioSizer->Add(queryableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  queryableBox->SetSelection(1);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  wxRadioBox *editableBox = new wxRadioBox(this, ID_VECTOR_EDITABLE,
                                           wxT("Is &Editable"),
                                           wxDefaultPosition,
                                           wxDefaultSize, 2,
                                           yesno, 1,
                                           wxRA_SPECIFY_ROWS);
  radioSizer->Add(editableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  editableBox->SetSelection(1);

// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&Register"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
  btnBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// appends event handler for OK button
  Connect(wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED,
          (wxObjectEventFunction) & SpatialViewRegisterDialog::OnOk);
}

void SpatialViewRegisterDialog::OnOk(wxCommandEvent & WXUNUSED(event))
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
  wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
  wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
  wxRadioBox *queryableBox = (wxRadioBox *) FindWindow(ID_VECTOR_QUERYABLE);
  wxRadioBox *editableBox = (wxRadioBox *) FindWindow(ID_VECTOR_EDITABLE);
  wxString str = nameCtrl->GetValue().Trim();
  CoverageName = str.Trim(false);
  if (CoverageName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Coverage Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = titleCtrl->GetValue().Trim();
  Title = str.Trim(false);
  if (Title.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Title !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = absCtrl->GetValue().Trim();
  Abstract = str.Trim(false);
  if (Abstract.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Abstract !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  int selCount = 0;
  for (int i = 0; i < GridCtrl->GetNumberRows(); i++)
    {
      if (GridCtrl->IsInSelection(i, 0) == true)
        {
          ViewName = GridCtrl->GetCellValue(i, 0);
          ViewGeometry = GridCtrl->GetCellValue(i, 1);
          selCount++;
        }
    }
  if (selCount < 1)
    {
      wxMessageBox(wxT("You must select a Candidate to be registered !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (selCount > 1)
    {
      wxString msg =
        wxT("You must select just a single Candidate to be registered !!!\n");
      msg += wxT("Multiple selection is not supported");
      wxMessageBox(msg, wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (queryableBox->GetSelection() == 1)
    Queryable = true;
  else
    Queryable = false;
  if (editableBox->GetSelection() == 1)
    Editable = true;
  else
    Editable = false;
  wxDialog::EndModal(wxID_OK);
}

bool VirtualShapeRegisterDialog::Create(MyFrame * parent)
{
//
// creating the dialog
//
  MainFrame = parent;
  List = MainFrame->FindUnregisteredVirtualShapeCoverages();
  if (wxDialog::Create(parent, wxID_ANY, wxT("Register VirtualShape Coverage"))
      == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
// centers the dialog window
  Centre();
  int count = 0;
  CandidateVirtualShapeCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true)
        count++;
      pC = pC->GetNext();
    }
  if (count == 0)
    {
      wxButton *ok = (wxButton *) FindWindow(wxID_OK);
      ok->Enable(false);
      wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
      nameCtrl->Enable(false);
      wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
      titleCtrl->Enable(false);
      wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
      absCtrl->Enable(false);
      wxMessageBox(wxT
                   ("There are no possible Candidates to be eventually registered"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
    }
  return true;
}

void VirtualShapeRegisterDialog::CreateControls()
{
//
// creating individual control and setting initial values
//
  wxBoxSizer *topSizer = new wxBoxSizer(wxVERTICAL);
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// a GRID to show results
  wxBoxSizer *gridBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(gridBoxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxStaticBox *gridBox = new wxStaticBox(this, wxID_STATIC,
                                         wxT
                                         ("Candidate VirtualShape Coverages"),
                                         wxDefaultPosition,
                                         wxDefaultSize);
  wxBoxSizer *GridSizer = new wxStaticBoxSizer(gridBox, wxVERTICAL);
  gridBoxSizer->Add(GridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
  wxBoxSizer *gridSizer = new wxBoxSizer(wxHORIZONTAL);
  GridSizer->Add(gridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  GridCtrl =
    new wxGrid(this, ID_VECTOR_GRID, wxDefaultPosition, wxSize(640, 200));
  int count = 0;
  CandidateVirtualShapeCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true)
        count++;
      pC = pC->GetNext();
    }
  GridCtrl->CreateGrid(count, 4, wxGrid::wxGridSelectRows);
  GridCtrl->SetColLabelValue(0, wxT("virt_name"));
  GridCtrl->SetColLabelValue(1, wxT("virt_geometry"));
  GridCtrl->SetColLabelValue(2, wxT("SRID"));
  GridCtrl->SetColLabelValue(3, wxT("GeometryType"));
  count = 0;
  char dummy[1024];
  wxString cell;
  pC = List->GetFirst();
  while (pC)
    {
      // feeding grid rows
      if (pC->IsVectorCoverage() != true)
        {
          sprintf(dummy, "%d", count + 1);
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetRowLabelValue(count, cell);
          GridCtrl->SetCellValue(count, 0, pC->GetVirtName());
          GridCtrl->SetCellValue(count, 1, pC->GetVirtGeometry());
          sprintf(dummy, "%d", pC->GetSrid());
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetCellValue(count, 2, cell);
          GridCtrl->SetCellAlignment(count, 2, wxALIGN_RIGHT, wxALIGN_CENTRE);
          GridCtrl->SetCellValue(count, 3, pC->GetGeometryType());
          count++;
        }
      pC = pC->GetNext();
    }
  GridCtrl->SetRowLabelSize(wxGRID_AUTOSIZE);
  GridCtrl->AutoSize();
  GridCtrl->EnableEditing(false);
  gridSizer->Add(GridCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// second row: the Coverage Name
  wxBoxSizer *nameSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(nameSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *nameLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Coverage Name:"));
  nameSizer->Add(nameLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *nameCtrl = new wxTextCtrl(this, ID_VECTOR_COVERAGE, wxT(""),
                                        wxDefaultPosition, wxSize(550, 22));
  nameSizer->Add(nameCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// third row: the Coverage Title
  wxBoxSizer *titleSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(titleSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *titleLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Title:"));
  titleSizer->Add(titleLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *titleCtrl = new wxTextCtrl(this, ID_VECTOR_TITLE, wxT(""),
                                         wxDefaultPosition, wxSize(550, 22));
  titleSizer->Add(titleCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fourth row: the Coverage Abstract
  wxBoxSizer *absSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(absSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *absLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Abstract:"));
  absSizer->Add(absLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *abstractCtrl = new wxTextCtrl(this, ID_VECTOR_ABSTRACT, wxT(""),
                                            wxDefaultPosition, wxSize(550, 60),
                                            wxTE_MULTILINE);
  absSizer->Add(abstractCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fifth row: queryable
  wxBoxSizer *radioSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(radioSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxString yesno[2];
  yesno[0] = wxT("&No");
  yesno[1] = wxT("&Yes");
  wxRadioBox *queryableBox = new wxRadioBox(this, ID_VECTOR_QUERYABLE,
                                            wxT("Is &Queryable"),
                                            wxDefaultPosition,
                                            wxDefaultSize, 2,
                                            yesno, 1,
                                            wxRA_SPECIFY_ROWS);
  radioSizer->Add(queryableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  queryableBox->SetSelection(1);

// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&Register"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
  btnBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// appends event handler for OK button
  Connect(wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED,
          (wxObjectEventFunction) & VirtualShapeRegisterDialog::OnOk);
}

void VirtualShapeRegisterDialog::OnOk(wxCommandEvent & WXUNUSED(event))
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
  wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
  wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
  wxRadioBox *queryableBox = (wxRadioBox *) FindWindow(ID_VECTOR_QUERYABLE);
  wxString str = nameCtrl->GetValue().Trim();
  CoverageName = str.Trim(false);
  if (CoverageName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Coverage Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = titleCtrl->GetValue().Trim();
  Title = str.Trim(false);
  if (Title.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Title !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = absCtrl->GetValue().Trim();
  Abstract = str.Trim(false);
  if (Abstract.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Abstract !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  int selCount = 0;
  for (int i = 0; i < GridCtrl->GetNumberRows(); i++)
    {
      if (GridCtrl->IsInSelection(i, 0) == true)
        {
          VirtName = GridCtrl->GetCellValue(i, 0);
          VirtGeometry = GridCtrl->GetCellValue(i, 1);
          selCount++;
        }
    }
  if (selCount < 1)
    {
      wxMessageBox(wxT("You must select a Candidate to be registered !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (selCount > 1)
    {
      wxString msg =
        wxT("You must select just a single Candidate to be registered !!!\n");
      msg += wxT("Multiple selection is not supported");
      wxMessageBox(msg, wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (queryableBox->GetSelection() == 1)
    Queryable = true;
  else
    Queryable = false;
  wxDialog::EndModal(wxID_OK);
}

bool TopoGeoRegisterDialog::Create(MyFrame * parent)
{
//
// creating the dialog
//
  MainFrame = parent;
  List = MainFrame->FindUnregisteredTopoGeoCoverages();
  if (wxDialog::Create(parent, wxID_ANY,
                       wxT("Register Topology-Geometry Coverage")) == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
// centers the dialog window
  Centre();
  int count = 0;
  CandidateTopoGeoCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true)
        count++;
      pC = pC->GetNext();
    }
  if (count == 0)
    {
      wxButton *ok = (wxButton *) FindWindow(wxID_OK);
      ok->Enable(false);
      wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
      nameCtrl->Enable(false);
      wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
      titleCtrl->Enable(false);
      wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
      absCtrl->Enable(false);
      wxMessageBox(wxT
                   ("There are no possible Candidates to be eventually registered"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
    }
  return true;
}

void TopoGeoRegisterDialog::CreateControls()
{
//
// creating individual control and setting initial values
//
  wxBoxSizer *topSizer = new wxBoxSizer(wxVERTICAL);
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// a GRID to show results
  wxBoxSizer *gridBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(gridBoxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxStaticBox *gridBox = new wxStaticBox(this, wxID_STATIC,
                                         wxT
                                         ("Candidate Topology-Geometry Coverages"),
                                         wxDefaultPosition,
                                         wxDefaultSize);
  wxBoxSizer *GridSizer = new wxStaticBoxSizer(gridBox, wxVERTICAL);
  gridBoxSizer->Add(GridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
  wxBoxSizer *gridSizer = new wxBoxSizer(wxHORIZONTAL);
  GridSizer->Add(gridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  GridCtrl =
    new wxGrid(this, ID_VECTOR_GRID, wxDefaultPosition, wxSize(640, 200));
  int count = 0;
  CandidateTopoGeoCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true)
        count++;
      pC = pC->GetNext();
    }
  GridCtrl->CreateGrid(count, 4, wxGrid::wxGridSelectRows);
  GridCtrl->SetColLabelValue(0, wxT("topology_name"));
  GridCtrl->SetColLabelValue(1, wxT("SRID"));
  GridCtrl->SetColLabelValue(2, wxT("Dimensions"));
  GridCtrl->SetColLabelValue(3, wxT("Tolerance"));
  count = 0;
  char dummy[1024];
  wxString cell;
  pC = List->GetFirst();
  while (pC)
    {
      // feeding grid rows
      if (pC->IsVectorCoverage() != true)
        {
          sprintf(dummy, "%d", count + 1);
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetRowLabelValue(count, cell);
          GridCtrl->SetCellValue(count, 0, pC->GetTopologyName());
          sprintf(dummy, "%d", pC->GetSrid());
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetCellValue(count, 1, cell);
          GridCtrl->SetCellAlignment(count, 1, wxALIGN_RIGHT);
          GridCtrl->SetCellValue(count, 2, pC->GetDimensions());
          sprintf(dummy, "%1.9f", pC->GetTolerance());
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetCellValue(count, 3, cell);
          GridCtrl->SetCellAlignment(count, 3, wxALIGN_RIGHT);
          count++;
        }
      pC = pC->GetNext();
    }
  GridCtrl->SetRowLabelSize(wxGRID_AUTOSIZE);
  GridCtrl->AutoSize();
  GridCtrl->EnableEditing(false);
  gridSizer->Add(GridCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// second row: the Coverage Name
  wxBoxSizer *nameSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(nameSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *nameLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Coverage Name:"));
  nameSizer->Add(nameLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *nameCtrl = new wxTextCtrl(this, ID_VECTOR_COVERAGE, wxT(""),
                                        wxDefaultPosition, wxSize(550, 22));
  nameSizer->Add(nameCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// third row: the Coverage Title
  wxBoxSizer *titleSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(titleSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *titleLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Title:"));
  titleSizer->Add(titleLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *titleCtrl = new wxTextCtrl(this, ID_VECTOR_TITLE, wxT(""),
                                         wxDefaultPosition, wxSize(550, 22));
  titleSizer->Add(titleCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fourth row: the Coverage Abstract
  wxBoxSizer *absSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(absSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *absLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Abstract:"));
  absSizer->Add(absLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *abstractCtrl = new wxTextCtrl(this, ID_VECTOR_ABSTRACT, wxT(""),
                                            wxDefaultPosition, wxSize(550, 60),
                                            wxTE_MULTILINE);
  absSizer->Add(abstractCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fifth row: queryable / editable
  wxBoxSizer *radioSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(radioSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxString yesno[2];
  yesno[0] = wxT("&No");
  yesno[1] = wxT("&Yes");
  wxRadioBox *queryableBox = new wxRadioBox(this, ID_VECTOR_QUERYABLE,
                                            wxT("Is &Queryable"),
                                            wxDefaultPosition,
                                            wxDefaultSize, 2,
                                            yesno, 1,
                                            wxRA_SPECIFY_ROWS);
  radioSizer->Add(queryableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  queryableBox->SetSelection(1);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  wxRadioBox *editableBox = new wxRadioBox(this, ID_VECTOR_EDITABLE,
                                           wxT("Is &Editable"),
                                           wxDefaultPosition,
                                           wxDefaultSize, 2,
                                           yesno, 1,
                                           wxRA_SPECIFY_ROWS);
  radioSizer->Add(editableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  editableBox->SetSelection(1);

// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&Register"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
  btnBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// appends event handler for OK button
  Connect(wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED,
          (wxObjectEventFunction) & TopoGeoRegisterDialog::OnOk);
}

void TopoGeoRegisterDialog::OnOk(wxCommandEvent & WXUNUSED(event))
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
  wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
  wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
  wxRadioBox *queryableBox = (wxRadioBox *) FindWindow(ID_VECTOR_QUERYABLE);
  wxRadioBox *editableBox = (wxRadioBox *) FindWindow(ID_VECTOR_EDITABLE);
  wxString str = nameCtrl->GetValue().Trim();
  CoverageName = str.Trim(false);
  if (CoverageName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Coverage Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = titleCtrl->GetValue().Trim();
  Title = str.Trim(false);
  if (Title.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Title !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = absCtrl->GetValue().Trim();
  Abstract = str.Trim(false);
  if (Abstract.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Abstract !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  int selCount = 0;
  for (int i = 0; i < GridCtrl->GetNumberRows(); i++)
    {
      if (GridCtrl->IsInSelection(i, 0) == true)
        {
          TopologyName = GridCtrl->GetCellValue(i, 0);
          selCount++;
        }
    }
  if (selCount < 1)
    {
      wxMessageBox(wxT("You must select a Candidate to be registered !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (selCount > 1)
    {
      wxString msg =
        wxT("You must select just a single Candidate to be registered !!!\n");
      msg += wxT("Multiple selection is not supported");
      wxMessageBox(msg, wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (queryableBox->GetSelection() == 1)
    Queryable = true;
  else
    Queryable = false;
  if (editableBox->GetSelection() == 1)
    Editable = true;
  else
    Editable = false;
  wxDialog::EndModal(wxID_OK);
}

bool TopoNetRegisterDialog::Create(MyFrame * parent)
{
//
// creating the dialog
//
  MainFrame = parent;
  List = MainFrame->FindUnregisteredTopoNetCoverages();
  if (wxDialog::Create(parent, wxID_ANY,
                       wxT("Register Topology-Network Coverage")) == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
// centers the dialog window
  Centre();
  int count = 0;
  CandidateTopoNetCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true)
        count++;
      pC = pC->GetNext();
    }
  if (count == 0)
    {
      wxButton *ok = (wxButton *) FindWindow(wxID_OK);
      ok->Enable(false);
      wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
      nameCtrl->Enable(false);
      wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
      titleCtrl->Enable(false);
      wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
      absCtrl->Enable(false);
      wxMessageBox(wxT
                   ("There are no possible Candidates to be eventually registered"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
    }
  return true;
}

void TopoNetRegisterDialog::CreateControls()
{
//
// creating individual control and setting initial values
//
  wxBoxSizer *topSizer = new wxBoxSizer(wxVERTICAL);
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// a GRID to show results
  wxBoxSizer *gridBoxSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(gridBoxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxStaticBox *gridBox = new wxStaticBox(this, wxID_STATIC,
                                         wxT
                                         ("Candidate Topology-Network Coverages"),
                                         wxDefaultPosition,
                                         wxDefaultSize);
  wxBoxSizer *GridSizer = new wxStaticBoxSizer(gridBox, wxVERTICAL);
  gridBoxSizer->Add(GridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
  wxBoxSizer *gridSizer = new wxBoxSizer(wxHORIZONTAL);
  GridSizer->Add(gridSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  GridCtrl =
    new wxGrid(this, ID_VECTOR_GRID, wxDefaultPosition, wxSize(640, 200));
  int count = 0;
  CandidateTopoNetCoverage *pC = List->GetFirst();
  while (pC)
    {
      // counting how many lines are there
      if (pC->IsVectorCoverage() != true)
        count++;
      pC = pC->GetNext();
    }
  GridCtrl->CreateGrid(count, 3, wxGrid::wxGridSelectRows);
  GridCtrl->SetColLabelValue(0, wxT("network_name"));
  GridCtrl->SetColLabelValue(1, wxT("SRID"));
  GridCtrl->SetColLabelValue(2, wxT("Dimensions"));
  count = 0;
  char dummy[1024];
  wxString cell;
  pC = List->GetFirst();
  while (pC)
    {
      // feeding grid rows
      if (pC->IsVectorCoverage() != true)
        {
          sprintf(dummy, "%d", count + 1);
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetRowLabelValue(count, cell);
          GridCtrl->SetCellValue(count, 0, pC->GetNetworkName());
          sprintf(dummy, "%d", pC->GetSrid());
          cell = wxString::FromUTF8(dummy);
          GridCtrl->SetCellValue(count, 1, cell);
          GridCtrl->SetCellAlignment(count, 1, wxALIGN_RIGHT);
          GridCtrl->SetCellValue(count, 2, pC->GetDimensions());
          count++;
        }
      pC = pC->GetNext();
    }
  GridCtrl->SetRowLabelSize(wxGRID_AUTOSIZE);
  GridCtrl->AutoSize();
  GridCtrl->EnableEditing(false);
  gridSizer->Add(GridCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// second row: the Coverage Name
  wxBoxSizer *nameSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(nameSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *nameLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Coverage Name:"));
  nameSizer->Add(nameLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *nameCtrl = new wxTextCtrl(this, ID_VECTOR_COVERAGE, wxT(""),
                                        wxDefaultPosition, wxSize(550, 22));
  nameSizer->Add(nameCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// third row: the Coverage Title
  wxBoxSizer *titleSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(titleSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *titleLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Title:"));
  titleSizer->Add(titleLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *titleCtrl = new wxTextCtrl(this, ID_VECTOR_TITLE, wxT(""),
                                         wxDefaultPosition, wxSize(550, 22));
  titleSizer->Add(titleCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fourth row: the Coverage Abstract
  wxBoxSizer *absSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(absSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *absLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Abstract:"));
  absSizer->Add(absLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *abstractCtrl = new wxTextCtrl(this, ID_VECTOR_ABSTRACT, wxT(""),
                                            wxDefaultPosition, wxSize(550, 60),
                                            wxTE_MULTILINE);
  absSizer->Add(abstractCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fifth row: queryable / editable
  wxBoxSizer *radioSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(radioSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxString yesno[2];
  yesno[0] = wxT("&No");
  yesno[1] = wxT("&Yes");
  wxRadioBox *queryableBox = new wxRadioBox(this, ID_VECTOR_QUERYABLE,
                                            wxT("Is &Queryable"),
                                            wxDefaultPosition,
                                            wxDefaultSize, 2,
                                            yesno, 1,
                                            wxRA_SPECIFY_ROWS);
  radioSizer->Add(queryableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  queryableBox->SetSelection(1);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  wxRadioBox *editableBox = new wxRadioBox(this, ID_VECTOR_EDITABLE,
                                           wxT("Is &Editable"),
                                           wxDefaultPosition,
                                           wxDefaultSize, 2,
                                           yesno, 1,
                                           wxRA_SPECIFY_ROWS);
  radioSizer->Add(editableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  editableBox->SetSelection(1);

// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&Register"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
  btnBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// appends event handler for OK button
  Connect(wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED,
          (wxObjectEventFunction) & TopoNetRegisterDialog::OnOk);
}

void TopoNetRegisterDialog::OnOk(wxCommandEvent & WXUNUSED(event))
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
  wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
  wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
  wxRadioBox *queryableBox = (wxRadioBox *) FindWindow(ID_VECTOR_QUERYABLE);
  wxRadioBox *editableBox = (wxRadioBox *) FindWindow(ID_VECTOR_EDITABLE);
  wxString str = nameCtrl->GetValue().Trim();
  CoverageName = str.Trim(false);
  if (CoverageName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Coverage Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = titleCtrl->GetValue().Trim();
  Title = str.Trim(false);
  if (Title.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Title !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = absCtrl->GetValue().Trim();
  Abstract = str.Trim(false);
  if (Abstract.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Abstract !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  int selCount = 0;
  for (int i = 0; i < GridCtrl->GetNumberRows(); i++)
    {
      if (GridCtrl->IsInSelection(i, 0) == true)
        {
          NetworkName = GridCtrl->GetCellValue(i, 0);
          selCount++;
        }
    }
  if (selCount < 1)
    {
      wxMessageBox(wxT("You must select a Candidate to be registered !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (selCount > 1)
    {
      wxString msg =
        wxT("You must select just a single Candidate to be registered !!!\n");
      msg += wxT("Multiple selection is not supported");
      wxMessageBox(msg, wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (queryableBox->GetSelection() == 1)
    Queryable = true;
  else
    Queryable = false;
  if (editableBox->GetSelection() == 1)
    Editable = true;
  else
    Editable = false;
  wxDialog::EndModal(wxID_OK);
}

bool VectorInfosDialog::Create(MyFrame * parent, wxString & coverage)
{
//
// creating the dialog
//
  MainFrame = parent;
  wxString clean;
  if (coverage.StartsWith(wxT("table."), &clean))
    coverage = clean;
  else if (coverage.StartsWith(wxT("view."), &clean))
    coverage = clean;
  else if (coverage.StartsWith(wxT("shp."), &clean))
    coverage = clean;
  int pos = coverage.Find(wxT(" [SRID="));
  if (pos != wxNOT_FOUND)
    CoverageName = coverage.Left(pos);
  else
    CoverageName = coverage;
  if (DoReadCoverage() == false)
    return false;
  if (wxDialog::Create(parent, wxID_ANY, wxT("Edit Vector Coverage Infos"))
      == false)
    return false;
// populates individual controls
  CreateControls();
// sets dialog sizer
  GetSizer()->Fit(this);
  GetSizer()->SetSizeHints(this);
// centers the dialog window
  Centre();
  int count = 0;
  return true;
}

void VectorInfosDialog::CreateControls()
{
//
// creating individual control and setting initial values
//
  wxBoxSizer *topSizer = new wxBoxSizer(wxVERTICAL);
  this->SetSizer(topSizer);
  wxBoxSizer *boxSizer = new wxBoxSizer(wxVERTICAL);
  topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5);
// first row: the Coverage Name
  wxBoxSizer *nameSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(nameSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *nameLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Coverage Name:"));
  nameSizer->Add(nameLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *nameCtrl = new wxTextCtrl(this, ID_VECTOR_COVERAGE, CoverageName,
                                        wxDefaultPosition, wxSize(550, 22));
  nameSizer->Add(nameCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// second row: the Coverage Title
  wxBoxSizer *titleSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(titleSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *titleLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Title:"));
  titleSizer->Add(titleLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *titleCtrl = new wxTextCtrl(this, ID_VECTOR_TITLE, Title,
                                         wxDefaultPosition, wxSize(550, 22));
  titleSizer->Add(titleCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// third row: the Coverage Abstract
  wxBoxSizer *absSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(absSizer, 0, wxALIGN_RIGHT | wxALL, 0);
  wxStaticText *absLabel =
    new wxStaticText(this, wxID_STATIC, wxT("&Abstract:"));
  absSizer->Add(absLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxTextCtrl *abstractCtrl = new wxTextCtrl(this, ID_VECTOR_ABSTRACT, Abstract,
                                            wxDefaultPosition, wxSize(550, 60),
                                            wxTE_MULTILINE);
  absSizer->Add(abstractCtrl, 0, wxALIGN_RIGHT | wxALL, 5);
// fourth row: queryable / editable
  wxBoxSizer *radioSizer = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(radioSizer, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxString yesno[2];
  yesno[0] = wxT("&No");
  yesno[1] = wxT("&Yes");
  wxRadioBox *queryableBox = new wxRadioBox(this, ID_VECTOR_QUERYABLE,
                                            wxT("Is &Queryable"),
                                            wxDefaultPosition,
                                            wxDefaultSize, 2,
                                            yesno, 1,
                                            wxRA_SPECIFY_ROWS);
  radioSizer->Add(queryableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  if (IsQueryable == false)
    queryableBox->SetSelection(0);
  else
    queryableBox->SetSelection(1);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  radioSizer->AddSpacer(25);
  wxRadioBox *editableBox = new wxRadioBox(this, ID_VECTOR_EDITABLE,
                                           wxT("Is &Editable"),
                                           wxDefaultPosition,
                                           wxDefaultSize, 2,
                                           yesno, 1,
                                           wxRA_SPECIFY_ROWS);
  radioSizer->Add(editableBox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  if (IsEditable == false)
    editableBox->SetSelection(0);
  else
    editableBox->SetSelection(1);
// buttons
  wxBoxSizer *btnBox = new wxBoxSizer(wxHORIZONTAL);
  boxSizer->Add(btnBox, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
  wxButton *ok = new wxButton(this, wxID_OK, wxT("&OK"));
  btnBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  wxButton *cancel = new wxButton(this, wxID_CANCEL, wxT("&Cancel"));
  btnBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// appends event handler for OK button
  Connect(wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED,
          (wxObjectEventFunction) & VectorInfosDialog::OnOk);
}

bool VectorInfosDialog::DoReadCoverage()
{
// will retrieve to read the given Coverage definition
  int i;
  char **results;
  int rows;
  int columns;
  char *errMsg = NULL;
  char *value;
  char *sql;
  char cvg[1024];
  int count = 0;

  wxCharBuffer buffer = CoverageName.ToUTF8();
  sprintf(cvg, "%s", buffer.data());
  sql =
    sqlite3_mprintf
    ("SELECT title, abstract, is_queryable, is_editable "
     "FROM vector_coverages WHERE Lower(coverage_name) = Lower(%Q)", cvg);
  int ret = sqlite3_get_table(MainFrame->GetSqlite(), sql, &results,
                              &rows, &columns, &errMsg);
  sqlite3_free(sql);
  if (ret != SQLITE_OK)
    {
      wxMessageBox(wxT("SQLite SQL error: ") + wxString::FromUTF8(errMsg),
                   wxT("spatialite_gui"), wxOK | wxICON_ERROR, this);
      sqlite3_free(errMsg);
      return false;
    }
  if (rows < 1)
    ;
  else
    {
      for (i = 1; i <= rows; i++)
        {
          value = results[(i * columns) + 0];
          Title = wxString::FromUTF8(value);
          value = results[(i * columns) + 1];
          Abstract = wxString::FromUTF8(value);
          value = results[(i * columns) + 2];
          if (atoi(value) == 0)
            IsQueryable = false;
          else
            IsQueryable = true;
          value = results[(i * columns) + 3];
          if (atoi(value) == 0)
            IsEditable = false;
          else
            IsEditable = true;
          count++;
        }
    }
  sqlite3_free_table(results);
  if (count == 1)
    return true;
  return false;
}

void VectorInfosDialog::DoUpdateCoverage()
{
// will retrieve to update the given Coverage definition
  int ret;
  sqlite3_stmt *stmt = NULL;
  char *dummy;
  const char *sql = "SELECT SE_SetVectorCoverageInfos(?, ?, ?, ?, ?)";
  ret =
    sqlite3_prepare_v2(MainFrame->GetSqlite(), sql, strlen(sql), &stmt, NULL);
  if (ret != SQLITE_OK)
    {
      const char *msg = sqlite3_errmsg(MainFrame->GetSqlite());
      wxMessageBox(wxT("ERROR - SetVectorCoverageInfos: ") +
                   wxString::FromUTF8(msg), wxT("spatialite_gui"),
                   wxOK | wxICON_ERROR, this);
      return;
    }
  sqlite3_reset(stmt);
  sqlite3_clear_bindings(stmt);
  dummy = (char *) malloc((CoverageName.Len() * 4) + 1);
  strcpy(dummy, CoverageName.ToUTF8());
  sqlite3_bind_text(stmt, 1, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((Title.Len() * 4) + 1);
  strcpy(dummy, Title.ToUTF8());
  sqlite3_bind_text(stmt, 2, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  dummy = (char *) malloc((Abstract.Len() * 4) + 1);
  strcpy(dummy, Abstract.ToUTF8());
  sqlite3_bind_text(stmt, 3, dummy, -1, SQLITE_TRANSIENT);
  free(dummy);
  if (IsQueryable == false)
    sqlite3_bind_int(stmt, 4, 0);
  else
    sqlite3_bind_int(stmt, 4, 1);
  if (IsEditable == false)
    sqlite3_bind_int(stmt, 5, 0);
  else
    sqlite3_bind_int(stmt, 5, 1);
  ret = sqlite3_step(stmt);
  if (ret == SQLITE_DONE || ret == SQLITE_ROW)
    ;
  else
    {
      const char *msg = sqlite3_errmsg(MainFrame->GetSqlite());
      wxMessageBox(wxT("ERROR - SetVectorCoverageInfos: ") +
                   wxString::FromUTF8(msg), wxT("spatialite_gui"),
                   wxOK | wxICON_ERROR, this);
    }
  sqlite3_finalize(stmt);
}

void VectorInfosDialog::OnOk(wxCommandEvent & WXUNUSED(event))
{
//
// all done: 
//
  wxTextCtrl *nameCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_COVERAGE);
  wxTextCtrl *titleCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_TITLE);
  wxTextCtrl *absCtrl = (wxTextCtrl *) FindWindow(ID_VECTOR_ABSTRACT);
  wxRadioBox *queryableBox = (wxRadioBox *) FindWindow(ID_VECTOR_QUERYABLE);
  wxRadioBox *editableBox = (wxRadioBox *) FindWindow(ID_VECTOR_EDITABLE);
  wxString str = nameCtrl->GetValue().Trim();
  CoverageName = str.Trim(false);
  if (CoverageName.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Coverage Name !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = titleCtrl->GetValue().Trim();
  Title = str.Trim(false);
  if (Title.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Title !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  str = absCtrl->GetValue().Trim();
  Abstract = str.Trim(false);
  if (Abstract.Len() == 0)
    {
      wxMessageBox(wxT("You must specify some Abstract !!!"),
                   wxT("spatialite_gui"), wxOK | wxICON_WARNING, this);
      return;
    }
  if (queryableBox->GetSelection() == 1)
    IsQueryable = true;
  else
    IsQueryable = false;
  if (editableBox->GetSelection() == 1)
    IsEditable = true;
  else
    IsEditable = false;
  DoUpdateCoverage();
  wxDialog::EndModal(wxID_OK);
}

bool ReloadVectorStyleDialog::Create(MyFrame * parent, wxString & path)
{
//
// creating the dialog
................................................................................

bool VectorSRIDsDialog::Create(MyFrame * parent, wxString & coverage)
{
//
// creating the dialog
//
  MainFrame = parent;
  wxString clean;
  if (coverage.StartsWith(wxT("table."), &clean))
    coverage = clean;
  else if (coverage.StartsWith(wxT("view."), &clean))
    coverage = clean;
  else if (coverage.StartsWith(wxT("shp."), &clean))
    coverage = clean;
  int pos = coverage.Find(wxT(" [SRID="));
  if (pos != wxNOT_FOUND)
    CoverageName = coverage.Left(pos);
  else
    CoverageName = coverage;
  List = MainFrame->FindVectorAlternativeSRIDs(CoverageName);
  if (wxDialog::Create(parent, wxID_ANY,
................................................................................

bool VectorKeywordsDialog::Create(MyFrame * parent, wxString & coverage)
{
//
// creating the dialog
//
  MainFrame = parent;
  wxString clean;
  if (coverage.StartsWith(wxT("table."), &clean))
    coverage = clean;
  else if (coverage.StartsWith(wxT("view."), &clean))
    coverage = clean;
  else if (coverage.StartsWith(wxT("shp."), &clean))
    coverage = clean;
  int pos = coverage.Find(wxT(" [SRID="));
  if (pos != wxNOT_FOUND)
    CoverageName = coverage.Left(pos);
  else
    CoverageName = coverage;
  List = MainFrame->FindVectorKeywords(CoverageName);
  if (wxDialog::Create(parent, wxID_ANY,
................................................................................
      path = params->GetPathByIndex(i);
      params->SetCurrentPath(path);
      report = wxT("Loading and Validating: ") + path;
      evt_start.SetString(report);
      params->GetDlg()->GetEventHandler()->AddPendingEvent(evt_start);
      clock_start = clock();
      wxString abstract;
      if (params->GetMainFrame()->
          ValidateExternalGraphicResource(path.ToUTF8(), &blob, &blob_size,

                                          abstract) == true)
        {
          wxFileName fn(path);
          wxString xlink_href =
            wxT("http://www.utopia.gov/") + fn.GetFullName();
          wxString filename = fn.GetFullName();
          wxString title = fn.GetName();
          if (params->GetDlg()->
              RegisterExternalGraphic(stmt, xlink_href.ToUTF8(), title.ToUTF8(),

                                      abstract.ToUTF8(), filename.ToUTF8(),

                                      blob, blob_size) != true)
            {
              params->SetError();
              goto error;
            }
          clock_end = clock();
          seconds =
            (double) (clock_end - clock_start) / (double) CLOCKS_PER_SEC;