// GlobalMapperInterface.h - interface for Global Mapper DLL exports // // Developed by: Mike Childs // Started: 5/16/03 #if defined(_MSC_VER) && (_MSC_VER >= 1020) #pragma once #endif #ifndef _GLOBALMAPPERINTERFACE_H_ #define _GLOBALMAPPERINTERFACE_H_ /*-------------------------------------------------------------------- GENERAL INCLUDES --------------------------------------------------------------------*/ #include "GlobalMapperTypes.h" #include "FeatureClass.h" #include "ProjectionTypes.h" #include // Make sure the whole thing is packed to 8 byte structure alignment // like the SDK expects #pragma pack( push, 8 ) /*-------------------------------------------------------------------- LITERAL CONSTANTS --------------------------------------------------------------------*/ #define GM_MAX_NON_REGISTERED_VECTOR_IDX 5 /*-------------------------------------------------------------------- TYPES --------------------------------------------------------------------*/ // Error codes typedef uint32 GM_Error_t32; enum { GM_Error_None = 0, GM_Error_InvalidLayer = 1, // The provided layer is not open GM_Error_InvalidParam = 2, // A parameter was invalid GM_Error_LoadError = 3, // Unable to load layer GM_Error_MultipleLayers = 4, // Multiple layers were found in the file being loaded (call GM_LoadLayerList instead) GM_Error_CollarSetup = 5, // Unable to automatically crop the collar GM_Error_DrawError = 6, // An unknown error occured drawing the layer(s) GM_Error_ExportError = 7, // An unknown error occured exporting the layer(s) GM_Error_NothingToExport = 8, // No data was available to export GM_Error_InvalidFormat = 9, // An invalid export format was specified GM_Error_RectifyError = 10, // An error occured rectifying the image GM_Error_NotSupported = 11, // The operation is not supported for the layer GM_Error_NotRegistered = 12, // No registry key was found to enable this functionality GM_Error_NoDataAtLocation = 13, // No data was found at the specified location GM_Error_OutOfMemory = 14, // Not enough memory to complete the requested operation GM_Error_Projection = 15, // An error occured projecting a coordinate GM_Error_NoProjectionSet = 16, // No view/export projection is currently set GM_Error_ViewShedCalc = 17, // An error occurred performing the view shed analysis GM_Error_OperationCanceled = 18, // The user canceled the operation GM_Error_TerraServerConnect = 19, // A connection to the TerraService could not be established GM_Error_TerraServerBadTheme = 20, // No TerraServer theme with the theme name provided could be found GM_Error_GenerateContours = 21, // An error occurred generating the contours GM_Error_NotRasterLayer = 22, // The layer provided is not a raster or elevation layer GM_Error_InvalidPackage = 23, // The provided handle is not a valid package GM_Error_InvalidFeatureIndex = 24, // There was no feature at the given index in the layer GM_Error_InvalidDrawStyle = 25, // The drawing style passed in is not valid GM_Error_InvalidSymbolName = 26, // The symbol name provided does not match any available point symbols GM_Error_SymbolAlreadyCreated = 27, // The symbol name specified has already been added GM_Error_MissingFile = 28, // The file specified could not be found GM_Error_GPSDataNotValid = 29, // The GPS data requested does not currently have a valid value available GM_Error_GPSAlreadyTracking = 30, // A GPS device is already being tracked, call GM_GPSStopTracking GM_Error_VolumeCalcFailed = 31, // An error occurred calculating the volume GM_Error_InvalidHoleIndex = 32, // The area does not have a hole at the index provided GM_Error_InvalidMapIndex = 33, // There is no map at the given index in the map catalog GM_Error_3DNotOpen = 34, // No 3D view window is currently open GM_Error_3DLibraryNotFound = 35, // The ExternalViewerIntf.dll library was not found GM_Error_3DLibraryBadInterface = 36,// The ExternalViewerIntf.dll library did not have the proper interface GM_Error_3DCreateError = 37, // Unexpected error creating 3D view GM_Error_3DSetViewError = 38, // Unexpected error setting 3D view GM_Error_NothingFound = 39, // No features were found within the search area GM_Error_SearchError = 40, // Unexpected search area GM_Error_LowMemory = 41, // Some data was not drawn due to low available memory GM_Error_NotElevationLayer = 42, // The layer provided is not an elevation layer GM_Error_FileAlreadyInCatalog = 43, // The provided file was already in the map catalog to which it was being added. GM_Error_TypeAlreadyExists = 44, // The provided type name was already used by an existing type GM_Error_DatumAlreadyExists = 45, // A built-in datum with the given name already exists GM_Error_UnknownEllipsoid = 46, // The ellipsoid name provided does not match a known ellipsoid GM_Error_GridError = 47, // Error generating grid from 3D vector data GM_Error_NumCodes, GM_Error_NotImplemented = 0xFFFF // The given function hasn't been implemented yet }; // Flags describing the type of feature class (i.e. area, point, or line) to work on typedef uint8 GM_FeatureClassType_t8; enum { GM_FeatureClass_Area, // The feature class is for an area feature GM_FeatureClass_Line, // The feature class is for a line feature GM_FeatureClass_Point, // The feature class is for a point feature GM_FeatureClass_NumTypes }; // Flags when loading new layres typedef uint32 GM_LoadFlags_t32; enum { GM_LoadFlags_HideProgress = 0x00000001, // Don't show load progress GM_LoadFlags_NoProjPrompt = 0x00000002, // Don't prompt the user for unknown projections GM_LoadFlags_UseDefaultProj = 0x00000004, // Use default projection if none provided GM_LoadFlags_HideWarnings = 0x00000008, // Hide any load warnings (load errors will still be displayed) GM_LoadFlags_HideUnknownPrompt = 0x00000010, // Do not prompt the user to select the file type for unknown file formats GM_LoadFlags_UseDefaultPos = 0x00000020, // Use default positioning if none provided (raster files only) GM_LoadFlags_HideAllPrompts = 0x00000040, // Use the default value for any prompts that display during the load }; // List of supported raster export types typedef uint32 GM_RasterExportFormat_t32; enum { GM_Export_GeoTIFF, // GeoTIFF format GM_Export_JPG, // JPG format GM_Export_PNG, // PNG format GM_Export_Erdas_Imagine, // Erdas Imagine IMG format GM_Export_BMP, // BMP (Windows) format GM_Export_ECW, // ECW format GM_Export_NumRasterFormats }; // List of supported elevation export types typedef uint32 GM_ElevationExportFormat_t32; enum { GM_Export_GMG, // Global Mapper Grid format GM_Export_BIL, // BIL format GM_Export_Erdas_Elevation, // Erdas Imagine IMG format with elevation data GM_Export_Surfer_ASCII, // Surfer ASCII Grid GM_Export_Surfer_Binary_v6, // Surfer Binary Grid v6 GM_Export_Surfer_Binary_v7, // Surfer Binary Grid v7 GM_Export_DEM, // USGS ASCII DEM format GM_Export_XYZ_ASCII_Grid, // XYZ ASCII Grid file GM_Export_Arc_ASCII_Grid, // Arc Info ASCII Grid format GM_Export_ElevGeoTIFF, // Vertical GeoTIFF format GM_Export_NumElevationFormats }; // List of supported vector export types typedef uint32 GM_VectorExportFormat_t32; enum { GM_Export_DXF, // DXF format - use GM_ExportOptsDXF_t for parameter to GM_ExportVector (can be NULL) GM_Export_Shapefile, // Shapefile format - use GM_ExportOptsSHP_t for parameter to GM_ExportVector (can be NULL) GM_Export_KML, // KML format - use GM_ExportOptsKML_t for parameter to GM_ExportVector (can be NULL) - pass .KMZ filename to create KMZ file GM_Export_MapInfo_MIF, // MapInfo MIF/MID format - pass NULL for parameter to GM_ExportVector GM_Export_MapInfo_TAB, // MapInfo TAB/MAP format - pass NULL for parameter to GM_ExportVector GM_Export_WaspMap, // WaSP Map format - pass NULL for parameter to GM_ExportVector GM_Export_SimpleText, // Simple ASCII Text file format - use GM_ExportOptsSimpleText_t for parameter to GM_ExportVector (can be NULL) GM_Export_CSV, // CSV file format - pass NULL for parameter to GM_ExportVector GM_Export_NumVectorFormats }; // List of supported web export types typedef uint32 GM_WebExportFormat_t32; enum { GM_Export_GoogleMaps, // Google Maps format GM_Export_VirtualEarth, // Virtual Earth format GM_Export_KMLRaster, // KML/KMZ raster format GM_Export_NumWebFormats }; // Flags for raster (i.e. GeoTIFF, JPG) image and elevation grid export typedef uint32 GM_RasterExportFlags_t32; enum { GM_ExportFlags_GenWorldFile = 0x00000001, // Generate a world file GM_ExportFlags_GenPRJFile = 0x00000002, // Generate a projection (PRJ) file GM_ExportFlags_GenTABFile = 0x00000004, // Generate a MapInfo TAB file GM_ExportFlags_Grayscale = 0x00000008, // Generate a grayscale image (raster only) GM_ExportFlags_Palette = 0x00000010, // Generate a paletted image (raster only) GM_ExportFlags_HideProgress = 0x00000020, // Don't show export progress GM_ExportFlags_JPGinTIFF = 0x00000040, // Create a JPG compressed GeoTIFF file (GM_Export_GeoTIFF format only) GM_ExportFlags_FillSmallGaps= 0x00000080, // Fill small gaps in data when exporting elevation data GM_ExportFlags_AllowLossy = 0x00000100, // Allow lossy export to GMG GM_ExportFlags_16BitSamples = 0x00000200, // Use signed 16-bit integer elevation values (GM_Export_BIL and GM_Export_Erdas_Elevation formats only) GM_ExportFlags_UseLZW = 0x00000400, // Use LZW compression for GeoTIFF file (GM_Export_GeoTIFF format only) GM_ExportFlags_NoTransparent= 0x00000800, // Don't mark background pixels transparent for PNG file (GM_Export_PNG format only) GM_ExportFlags_AddAlpha = 0x00001000, // Add an alpha channel to formats that support it (need for GM_Export_GeoTIFF [24-bit only], enabled by default for GM_Export_PNG) }; // Flags for vector (i.e. DXF, Shapefile) export typedef uint32 GM_VectorExportFlags_t32; enum { GM_VectorExportFlags_GenPRJFile = 0x00000001, // Generate a projection (PRJ) file GM_VectorExportFlags_HideProgress = 0x00000002, // Don't show export progress GM_VectorExportFlags_ExportAreas = 0x00000004, // Export area features GM_VectorExportFlags_ExportLines = 0x00000008, // Export line features GM_VectorExportFlags_ExportPoints = 0x00000010, // Export point/text features GM_VectorExportFlags_ExportAttrs = 0x00000020, // Export feature attributes (when applicable) GM_VectorExportFlags_Export3D = 0x00000040, // Export 3D features if applicable GM_VectorExportFlags_NoHeaderRow = 0x00000080, // Don't include a header row (GM_Export_CSV only) GM_VectorExportFlags_IncludeLatLonCols = 0x00000100, // Include latitude and longitude columns (GM_Export_CSV only) GM_VectorExportFlags_ExportAll = GM_VectorExportFlags_ExportAreas | GM_VectorExportFlags_ExportLines | GM_VectorExportFlags_ExportPoints, }; // Flags for package export typedef uint32 GM_PackageExportFlags_t32; enum { GM_ExportPackage_LatLongWGS84 = 0x00000001, // Export data in lat/lon/WGS84 coordinates rather than native projection of each layer GM_ExportPackage_DoublePrecision = 0x00000002, // Use double-precision coordinates for vector data. GM_ExportPackage_DiscardAttributes = 0x00000004, // Discard vector feature attributes GM_ExportPackage_HideProgress = 0x00000008, // Don't show export progress GM_ExportPackage_KeepAllStyles = 0x00000010, // Keep all style information, even if features are using default style }; // List of supported grid layouts for GM_CreateCustomElevGridLayer typedef uint8 GM_GridLayout_t8; enum { GM_GridLayout_SInt16 = 0, // Each sample is a signed 16-bit integer GM_GridLayout_SInt32 = 1, // Each sample is a signed 32-bit integer GM_GridLayout_Float = 2, // Each sample is an IEEE 32-bit floating point number GM_GridLayout_NumLayouts }; // Flags to control the GM_DrawLayerList and GM_DrawPackageList operations typedef uint32 GM_DrawFlags_t32; enum { GM_DrawFlags_BestRasterLayers = 0x00000001, // Only draw the best raster layers for this zoom scale GM_DrawFlags_BestRasterLayersHiRes = 0x00000003, // Same as GM_DrawFlags_BestRasterLayers, only it shows higher resolution layers a bit sooner GM_DrawFlags_LowResRasterLayers = 0x00000002, // Only draw the lowest resolution raster layers GM_DrawFlags_HiResRasterLayers = 0x00000004, // Only draw the highest resolution raster layers GM_DrawFlags_EraseBackground = 0x00000100, // Erase the background with the current background color (GM_SetBackgroundColor) GM_DrawFlags_HideAreas = 0x00000200, // Do not draw any area features from vector layers GM_DrawFlags_HideLines = 0x00000400, // Do not draw any line features from vector layers GM_DrawFlags_HidePoints = 0x00000800, // Do not draw any point features from vector layers GM_DrawFlags_SeparateVectorLayers = 0x00001000, // Draw each vector separately rather than drawing all at once. GM_DrawFlags_HideLabels = 0x00002000, // Do not label any rendered features GM_DrawFlags_DontMaintainAspectRatio= 0x00004000, // Do NOT maintain the aspect ratio when drawing (this allows stretched views) GM_DrawFlags_HidePartialLabels = 0x00008000, // Hide labels that are not entirely in the draw window GM_DrawFlags_ShowRenderProgress = 0x00010000, // Show render progress dialog or call progress callback if provided GM_DrawFlags_HideExtraIconText = 0x00020000, // Hide any extra text shown below road icons GM_DrawFlags_HideNonIconRoadLabels = 0x00040000, // Hide any road line labels that are not iconized GM_DrawFlags_RenderVertices = 0x00080000, // Render vertices for area and line features GM_DrawFlags_IncrementalRender = 0x00100000, // Do an incremental render so that draw progress can be seen as layers complete rendering GM_DrawFlags_NoAutoInterpolation = 0x00200000, // Disable automatic interpolation of rasters at intermediate zoom ranges (results in faster renders w/ less quality) // Definitions for masks of various option bits GM_DrawFlags_RasterMask = 0x00000007, // Mask for raster draw options }; // Flags to control the GM_FindNearestFeatures function typedef uint32 GM_FindFlags_t32; enum { GM_FindFlags_FindAreas = 0x00000001, // Search area features GM_FindFlags_FindLines = 0x00000002, // Search line features GM_FindFlags_FindPoints = 0x00000004, // Search point features GM_FindFlags_GetAllFeatures = 0x00000008, // Return all features in bounds (ignore search radius) // Definitions for masks of various option bits GM_FindFlags_FindAll = 0x00000007, // Mask for search all feature class (areas, lines, and points) }; // Flags to control the behavior of path profile/line of sight analysis typedef uint32 GM_PathProfileLOSFlags_t32; enum { GM_PathProfile_LOSValid = 0x00000001, // Perform line-of-sight analysis GM_PathProfile_LOSIgnoreEndpoints = 0x00000002, // Ignore endpoints when performing line-of-sight analysis (i.e. end points can't block line of sight) GM_PathProfile_LOSFromHeightAbsolute= 0x00000004, // Line-of-sight from height is absolute height above sea level rather than height above ground GM_PathProfile_LOSToHeightAbsolute = 0x00000008, // Line-of-sight to height is absolute height above sea level rathern than height above ground GM_PathProfile_IgnoreEarthCurvature = 0x00000010, // Ignore earth curvature in any line-of-sight analysis }; // List of supported color formats for GM_DrawLayerListToMemory typedef uint32 GM_ColorFormat_t32; enum { GM_ColorFormat_32Bit_ABGR = 0, // 32-bit color (alpha, blue, green, red) GM_ColorFormat_32Bit_ARGB = 1, // 32-bit color (alpha, red, green, blue) GM_ColorFormat_16Bit_565 = 2, // 16-bit color (5 bits red, 6 bits green, 5 bits blue) GM_ColorFormat_NumFormats }; // List of supported elevation units typedef sint8 GM_ElevUnits_t8; enum { GM_ElevUnit_Meters = 0, GM_ElevUnit_Decimeters = 1, GM_ElevUnit_Centimeters = 2, GM_ElevUnit_Millimeters = 3, GM_ElevUnit_Feet = 4, GM_ElevUnit_Decifeet = 5, GM_ElevUnit_Inches = 6, GM_ElevUnit_Centifeet = 7, GM_ElevUnit_NumUnits }; // List of flags for selecting a projection typedef uint32 GM_SelectProjFlags_t32; enum { GM_SelectProj_NoInterplanetaryDatums = 0x00000001, // do not display interplanetary datums in projection selection dialog }; // This type is used to reference a single layer loaded by the DLL. typedef void* GM_LayerHandle_t32; // This type is used to reference a single package loaded by the DLL typedef void* GM_PackageHandle_t32; // This enumeration lists the ways that line and area labels can be // exported to DXF files. typedef uint8 GM_ExportOptsDXFLabels_t8; enum { GM_ExportDXF_NoLabels, // No line or area feature labels will be exported GM_ExportDXF_LabelsAsPoints,// Line and area feature labels will be exported as separate text entities GM_ExportDXF_LabelsAsAttrs, // Line and area feature labels will be exported as attributes of those entities GM_ExportDXF_LabelsNumOpts }; // This type is used to describe custom export options for DXF vector exports typedef struct { float mTenPointFontHeight; // Height (in ground units) to use for 10 pt label fonts (other sizes will be scaled appropriately) GM_ExportOptsDXFLabels_t8 mLabelType; // Export setting for area and line feature labels boolean mUseLabelsForLayers; // Use feature labels, if present, for layer names rather than feature types/descriptions boolean mUseZeroWidthLines; // Export all lines as 0 width to prevent compatibility problems with some software } GM_ExportOptsDXF_t; // This type is used to describe custom export options for KML vector exports. // To create a KMZ file, pass a filename with a .kmz extension to the GM_ExportVector function. typedef struct { float mAreaOpacity; // area translucency - percent (0.0 - 100.0) bool mAreaDisplayAtElev; // display area features at feature elevation bool mAreaElevsRelative; // area elevations relative to ground (only valid if mAreaDisplayAtElev set) bool mExtrudeAreas; // extrude 3D areas to make 3D shapes like buildings (only valid if mAreaDisplayAtElev set) bool mLineDisplayAtElev; // display line features at feature elevation bool mLineElevsRelative; // line elevations relative to ground (only valid if mLineDisplayAtElev set) bool mHidePointsInitially; // initially hide point features when displayed in Google Earth } GM_ExportOptsKML_t; // This type is used to describe custom export options for Shapefile vector exports typedef struct { boolean mAddLabelAttr; // include the display label as a LABEL attribute if present boolean mAddLayerAttr; // add LAYER and GM_TYPE attribute values } GM_ExportOptsSHP_t; // This type is used to describe custom export options for Simple Text vector exports typedef struct { const char* mCoordSep; // coordinate separator (use NULL for default of comma) const char* mFeatureSep; // feature separator (use NULL for default of blank line) boolean mAddStyleAttrs; // include style attributes if attributes are included boolean mYCoordFirst; // export Y/latitude/northing before X/longitude/easting uint8 mReserved1; // reserved (for padding), must be 0 uint8 mReserved2; // reserved (for padding), must be 0 } GM_ExportOptsSimpleText_t; // This describes a single point location typedef struct { double mX; // X (or longitude) coordinate double mY; // Y (or latitude) coordinate } GM_Point_t; // This type describes a bounding rectangle in world coordinates typedef struct { double mMinX; // Minimum x/easting/longitude coordinate double mMinY; // Minimum y/northing/latitude coordinate double mMaxX; // Maximum x/easting/longitude coordinate double mMaxY; // Maximum y/northing/latitude coordinate } GM_Rectangle_t; // This type describes a bounding rectangle in pixel coordinates typedef struct { sint32 mLeft; // Left coordinate of rectangle sint32 mRight; // Right coordinate of rectangle sint32 mTop; // Top coordinate of rectangle sint32 mBottom;// Bottom coordinate of rectangle } GM_PixelRect_t; // This type is used when rectifying imagery typedef struct { double mPixelX; // x pixel coordinate of GCP double mPixelY; // y pixel coordinate of GCP (top is 0, increases down) double mGroundX; // x ground coordinate of GCP (in provided projection) double mGroundY; // y ground coordinate of GCP (in provided projection) } GM_GroundControlPoint_t; // This type is used to represent a single attribute value pair typedef struct { char* mName; // Name of the attribute char* mVal; // Value of the attribute } GM_AttrValue_t; // This type is used when returning information about a layer typedef struct { char* mDescription; // Description string GM_Rectangle_t mNativeRect; // Bounding rect of layer in native coordinates GM_Rectangle_t mGlobalRect; // Bounding rect of layer in global coordinates uint32 mPixelWidth; // RASTER/ELEV ONLY: Number of pixels wide layer is uint32 mPixelHeight; // RASTER/ELEV ONLY: Number of pixels tall layer is GM_Projection_t mNativeProj; // Native projection of layer GM_GroundControlPoint_t* mControlPoints; // RASTER ONLY: Ground control points list uint32 mNumGCPs; // RASTER ONLY: Number of ground control points in list float mMinElevation; // ELEV ONLY: Minimum elevation in meters float mMaxElevation; // ELEV ONLY: Maximum elevation in meters uint32 mNumAreas; // VECTOR ONLY: Number of area features uint32 mNumLines; // VECTOR ONLY: Number of line features uint32 mNumPoints; // VECTOR ONLY: Number of point features double mPixelSizeX; // RASTER/ELEV ONLY: Pixel size in meters in the x direction double mPixelSizeY; // RASTER/ELEV ONLY: Pixel size in meters in the y direction boolean mHasRasterData; // Does this layer have raster or elevation data? boolean mEnabled; // Is this layer enabled for display or it it hidden? boolean mHasVectorData; // Does this layer have vector data (the features counts can all be 0 for things like map catalogs) boolean mUsedDefaultPos; // RASTER/ELEV ONLY: Was the default position used for this layer since the file could not be automatically positioned? char* mFilename; // Filename from which layer was loaded (if this is an archive file, like .zip, then the name of the actual loaded file will be in mArchiveFilename char* mArchiveFilename; // Filename within archive file (e.g. .zip or .tar.gz) from which layer was loaded, if any (might be NULL) char* mTypeName; // Layer type name uint32 mGlobalPixelWidth; // RASTER/ELEV ONLY: Approximate number of pixels required in width for a 1:1 pixel mapping in the current projection uint32 mGlobalPixelHeight; // RASTER/ELEV ONLY: Approximate number of pixels required in height for a 1:1 pixel mapping in the current projection GM_AttrValue_t* mMetadataList; // List of metadata attributes and values for the layer uint32 mMetadataListSize; // Number of entries in mMetadataList } GM_LayerInfo_t; // This type is used when returning a color typedef struct { uint8 mRed; // Red component of color uint8 mGreen; // Green component of color uint8 mBlue; // Blue component of color } GM_Color_t; // This type represents the different font background options typedef uint8 GM_FontBackground_t8; enum { GM_Font_BgAuto = 0, // Automatically choose transparent or opaque background (all transparent except when centered on line) GM_Font_BgOpaque = 1, // Fill label background with current background color GM_Font_BgTransparent = 2, // Make label background transparent }; // This type is used to describe a font used for rendering text typedef struct { const char* mFaceName; // name of font face used COLORREF mColor; // RGB color of font uint16 mWeight; // weight of font (use Win32 constants, like FW_BOLD, FW_THIN, FW_NORMAL, etc.) uint8 mPointSize; // font point size (set mFixedHgt value to non-zero to use fixed height) boolean mItalicize; // draw text with italics? boolean mUnderline; // underline text? boolean mStrikeout; // strikeout text? uint8 mCharset; // character set (use OEM_CHARSET for default behavior) GM_FontBackground_t8 mBgMode; // background fill mode (i.e. opaque or transparent) float mFixedHgt; // fixed height of font in meters (use 0.0 for normal point-size font) } GM_FontDef_t; // This type is used to describe a style used for drawing an area feature // and its label (if any) typedef struct { GM_PenStyle_t16 mBorderPenStyle; // border pen style (i.e. solid, dash, etc.) uint16 mBorderPenWidth; // width to draw border pen in COLORREF mBorderPenColor; // color to use for border pen COLORREF mBrushColor; // color of brush to fill area with (when applicable to brush style). The color is defined as ARGB where the upper 8 bits are alpha. The exception is a value of 0 in the A is treated as no alpha. GM_BrushStyle_t16 mBrushStyle; // style of brush to fill area with boolean mDrawLabel; // render the label for this area if there is one boolean mDrawLabelAlways; // render the label for this area even if it collides with another display label GM_FontDef_t mFont; // font to use to render label } GM_AreaStyle_t; // This type is used to describe a style used for drawing a line feature // and its label (if any) typedef struct { GM_PenStyle_t16 mPenStyle; // pen style (i.e. solid, dash, etc.) uint16 mPenWidth; // width to draw pen in COLORREF mPenColor; // color to use for pen boolean mDrawLabel; // render the label for this line if there is one boolean mDrawLabelAlways; // render the label for this line even if it collides with another display label boolean mDrawLabelOnLine; // render the label for this line (if any) directly on the line rather than offset from it uint8 mReserved; // must be 0 GM_FontDef_t mFont; // font to use to render label sint32 mLabelSegment; // segment number (1-based) on which to render label (use 0 to use default label placement) } GM_LineStyle_t; // This type is used to describe a style used for drawing a point feature // and its label (if any) typedef struct { const char* mSymbolName; // name of symbol GM_FontDef_t mFont; // font to use to render label boolean mDrawLabel; // render the label for this point if there is one boolean mDrawLabelAlways; // render the label for this point even if it collides with another display label } GM_PointStyle_t; // This type is used as the base for any vector feature information typedef struct { char* mName; // Name of the feature char* mDesc; // Description of the feature FeatureClass_t16 mClass; // Global Mapper classification assigned to the feature GM_AttrValue_t* mAttrList; // List of attributes associated with feature uint16 mNumAttrs; // Number of attributes in mAttrList } GM_VectorFeature_t; // This type is used to store information about holes within area features typedef struct { GM_Point_t* mPoints; // List of points in the hole in global coordinates uint32 mNumPoints; // Number of points in the list } GM_HoleInArea_t; // This type is used to return information about area features typedef struct { GM_VectorFeature_t mFeatureInfo; // General feature info GM_Point_t* mPointList; // List of points in the area (global coordinates when getting, native when adding feature) uint32 mNumPoints; // Number of points in the list GM_HoleInArea_t* mHoleList; // List of holes in the area uint32 mNumHoles; // Number of holes in the list of holes GM_AreaStyle_t mAreaStyle; // Area render style float* mVertexElevList;// Optional list of elevations for each point in area. If present, must have values } GM_AreaFeature_t; // This type is used to return information about line features typedef struct { GM_VectorFeature_t mFeatureInfo; // General feature info GM_Point_t* mPointList; // List of points in the line (global coordinates when getting, native when adding feature) uint32 mNumPoints; // Number of points in the list GM_LineStyle_t mLineStyle; // Line render style float* mVertexElevList;// Optional list of elevations for each point in line. If present, must have values } GM_LineFeature_t; // This type is used to return information about point features typedef struct { GM_VectorFeature_t mFeatureInfo; // General feature info GM_Point_t mPos; // Location of the point (global coordinates when getting, native when adding feature) GM_PointStyle_t mPointStyle; // Point render style (symbol and font) } GM_PointFeature_t; // This type is used to return information about a given feature classification typedef struct { boolean mIsEnabled; // Is display of this class enabled? const char* mDesc; // Description string for this feature } GM_FeatureClassInfo_t; // This type is used to return information about found features typedef struct { GM_LayerHandle_t32 mLayer; // Layer the feature is in GM_FeatureClassType_t8 mFeatureClassType; // Type of feature class (area, point, line) uint32 mFeatureIndex; // Index of feature in layer uint32 mDistance; // Distance in pixels of feature from search location } GM_FoundFeature_t; // This type is used to provide the parameters for performing a view shed // analysis typedef struct { uint32 mSize; // Size of structure float mAngleEnd; // End angle in radians for radar sweep float mAngleStart; // Start angle in radians for radar sweep double mAtmosphericCorr; // Atmospheric correction value (1.0 for none) GM_Point_t mCenterPoint; // Center point in global coordinates COLORREF mColor; // Color to display view shed data in const char* mDesc; // View shed description double mRadius; // Search radius in meters double* mReceiverAngle; // Angle (in degrees) above horizon to test at (NULL for none) float mReceiverHeight; // Height at which transmitter must be visible boolean mReceiverHeightAbs; // Is the receiver height absolute or relative to the ground? boolean mShowHiddenPoints; // Make hidden points visible instead of viewable points. boolean mShowProgress; // Display view shed calculation progress? float mTransmitterHeight; // Transmitter height in meters boolean mTransmitterHeightAbs; // Is the transmitter height absolute or relative to the ground? boolean mUseEarthCurvature; // Use the curvature of the earth in the analysis? boolean mVectorElevsAbs; // Are vector elevations absolute (i.e. relative to sea level) or relative to ground level? GM_LayerHandle_t32* mVectorLayerList; // List of vector layers to use features with elevation attributes from uint32 mVectorLayerListCnt;// Number of vector layers in list double mXSpacing; // X sample spacing (use 0.0 for default spacing) double mYSpacing; // Y sample spacing (use 0.0 for default spacing) GM_Rectangle_t* mFilterRect; // Optional rectangle for filtering view shed to a certain area of interest double* mReceiverAngleEnd; // Angle (in degrees) above horizon to stop test at (NULL for none) - if this and mReceiverAngle are provided, an angle range view shed test is done (like a flashlight beam) double mFresnelFreq; // Frequency (in GHz) to use for testing clearance of first Fresnel zone (use 0.0 to not do Fresnel testing) double mFresnelPctClear; // Percentage of first Fresnel zone that must be clear of obstacles (use 0.6 for 60%). If 0 is specified, the default of 60% is used. } GM_ViewShedParams_t; // This type is used to provide the parameters for generating contours typedef struct { uint32 mSize; // Size of structure const char* mDesc; // Contour layer description GM_Rectangle_t mContourBounds; // Bounds of contour lines to create. Pass empty rectangle to use entirety of passed in layer(s). float mContourInterval; // Contour interval boolean mIntervalInFeet; // Set to TRUE if the contour interval is in feet rather than meters boolean mGenerateAreas; // Generate iso-height areas in addition to contour lines boolean mGenerateSpotElevs; // Generate spot elevation points at minimum and maximum elevations boolean mNumberOnlyLabels; // Only include the value (and not the units string) in the contour labels boolean mShowProgress; // Display contour generation progress dialog boolean mDisableSmoothing; // Do not smooth the generated contour lines to improve their appearance double mXSpacing; // Sample spacing in the x direction double mYSpacing; // Sample spacing in the y direction double mSimpThreshold; // Simplification threshold, use 0.0 for no simplification } GM_ContourParams_t; // This type is used to provide the parameters for calculating path profiles and // performing line of sight analysis typedef struct { uint32 mSize; // IN: Size of structure GM_PathProfileLOSFlags_t32 mFlags; // IN: Flags controlling behavior double mStartX; // IN: Start X coord in current projection double mStartY; // IN: Start Y coord in current projection double mEndX; // IN: End X coord in current projection double mEndY; // IN: End Y coord in current projection float* mElevList; // OUT: Buffer to hold list of elevations (set to NULL if you don't care) uint32 mListSize; // IN: Number of elevations to retrieve float mDfltElev; // IN: Elev to use when none could be found char* mDetailsStr; // OUT: String containing path details (set to NULL if you don't care) uint32 mDetailsStrMaxLen; // IN: Maximum length of details string double mAtmosphericCorr; // IN: Atmospheric correction for LOS (1.3333 is standard for radio waves, 1.0 is no correction) float mLOSFromHeight; // IN: Line-of-sight from height in meters float mLOSToHeight; // IN: Line-of-sight to height in meters float mLOSMinClearance; // OUT: Minimum line-of-sight clearance in meters (will be negative if the line of sight is not clear) GM_Point_t mLOSMinClearancePos;// OUT: Location of minimum line-of-sight clearance double mFresnelFreq; // IN: Frequency (in GHz) to use for testing clearance of first Fresnel zone (use 0.0 to not do Fresnel testing) double mFresnelPctClear; // IN: Percentage of first Fresnel zone that must be clear of obstacles (use 0.6 for 60%). If 0 is specified, the default of 60% is used. } GM_PathProfileLOSParams_t; // This type is used to provide the parameters for calculating cut-and-fill volumes // within an area feature typedef struct { uint32 mSize; // Size of structure const GM_Point_t* mPoints; // List of points in area in global coordinate system uint32 mNumPoints; // Number of points in mPoints float mCutHeight; // Cut height in meters above sea level double mXSpacing; // Sample spacing in the x direction in global units double mYSpacing; // Sample spacing in the y direction in global units } GM_AreaVolumeParams_t; // This type is used to provide the parameters for calculating cut-and-fill volumes // along a line feature typedef struct { uint32 mSize; // Size of structure const GM_Point_t* mPoints; // List of points in line in global coordinate system float* mCutHeights; // Cut heights for each point in meters uint32 mNumPoints; // Number of points in mPoints and mCutHeights boolean mCutHeightsAbsolute;// Are the cut heights in mCutHeights relative to sea level (TRUE) or ground level (FALSE) double mCorridorWidth; // Width (i.e. diameter) in meters of corridor around line in which to calculate volume double mXSpacing; // Sample spacing in the x direction in global units double mYSpacing; // Sample spacing in the y direction in global units } GM_LineVolumeParams_t; // This type represents the display options available for raster and elevation layers typedef struct { uint32 mSize; // Size of structure boolean mAutoAdjustContrast; // Automatically adjust contrast boolean mAutoClipCollar; // Automatically crop off a DRG, BSB, or other known collar boundary uint8 mColorIntensity; // Color intensity (0-20). Lower values are lighter, higher values are darker. boolean mInterpolatePixels; // Smooth pixels by using bilinear interpolation. boolean mTextureMap; // Texture map this raster layer over any underlying elevation layers. uint16 mTranslucency; // Translucency level of layer (0 - completely see-through, 512 - completely opaque) boolean mTransparent; // Is layer transparent? COLORREF mTransparentColor; // Color to make transparent uint8 mTransparentColorDist; // Fuzzy transparency support. Distance from transparent color to treat nearby colors transparent. sint8 mRedAdjustPercent; // Percentage to adjust red color channel by (-100 to 100) sint8 mGreenAdjustPercent; // Percentage to adjust red color channel by (-100 to 100) sint8 mBlueAdjustPercent; // Percentage to adjust red color channel by (-100 to 100) } GM_RasterDisplayOptions_t; // This type represents any adjustments to apply to elevation values within a // gridded elevation layer. typedef struct { float mOffset; // Offset to apply to elevations in meters double mScale; // Scale factor to apply boolean mClampVals; // Clamp out of range values to specified min/max boolean mMinValid; // Is the new minimum elevation valid float mMinElev; // Minimum valid elevation (meters) boolean mMaxValid; // Is the new maximum elevation valid float mMaxElev; // Maximum valid elevation (meters) boolean mVoidValid; // Is the void elevation value valid? GM_ElevUnits_t8 mElevUnits; // Native elevation units for file. float mVoidElev; // Elevation to use for void values const char* mLayerShader; // Name of elevation shader to use for layer (NULL for default shared shader) } GM_ElevationOverrides_t; // This type represents the display options available for the built-in elevation shaders typedef struct { uint32 mSize; // Size of structure COLORREF mDaylightShaderColor; // Surface color for daylight shader COLORREF mGradientShaderLoColor; // Min elevation color for gradient shader COLORREF mGradientShaderHiColor; // Max elevation color for gradient shader COLORREF mSlopeShaderMinColor; // Min slope color for slope shader float mSlopeShaderMinSlope; // Min slope for slope shader COLORREF mSlopeShaderMaxColor; // Max slope color for slope shader float mSlopeShaderMaxSlope; // Max slope for slope shader double mHSVShaderLoColorStart; // HSV Shader - Low Color Start in Degrees (0-360) double mHSVShaderSaturation; // HSV Shader - Saturation (0-1) double mHSVShaderValue; // HSV Shader - Value (0-1) double mHSVShaderRange; // HSV Shader - Range (>1) boolean mHSVShaderReverse; // HSV Shader - Reverse Colors uint8 mReserved[3]; // Reserved padding bytes } GM_ShaderOptions_t; typedef uint8 GM_MapCatalogDisplayType_t8; enum { GM_MapCatalog_DisplayTypePercent, GM_MapCatalog_DisplayTypePixelSize, GM_MapCatalog_DisplayTypeScale, GM_MapCatalog_DisplayTypeScaleRange, GM_MapCatalog_NumDisplayTypes }; // This type represents information about a map catalog. Use GM_GetLayerInfo // for more generic information, like bounds. typedef struct { uint32 mSize; // Size of structure uint32 mNumMaps; // Number of maps in catalog. boolean mHideBounds; // Hide layer bounds when not drawing data GM_MapCatalogDisplayType_t8 mDisplayType; // Controls when layers in catalog are displayed uint8 mReserved[2]; // Reserved for future use, must be 0 double mDisplayValue; // First value related to display type double mDisplayValue2; // Second value for range of scales } GM_MapCatalogInfo_t; // This is a set of bit flags for custom raster layers typedef uint32 GM_RasterLayoutFlags_t32; enum { GM_RasterLayout_BGROrder = 0x00000001, // Color bands are in order BGR rather than RGB GM_RasterLayout_AlphaPresent= 0x00000002, // An alpha band is present. Use mAlphaBandIdx in GM_RasterLayout_t to specify band index. GM_RasterLayout_CopyData = 0x00000004, // Make copy of data so that caller doesn't have to keep buffer around }; // This type represents layout information for a new custom raster layer typedef struct { GM_RasterLayoutFlags_t32 mFlags; // General flags for layout. GM_Point_t mTopLeft; // Ground coordinates of top left sample double mXPixelSize; // Size of each pixel in the x direction double mYPixelSize; // Size of each pixel in the y direction sint32 mPixelWidth; // Number of pixels in the x direction sint32 mPixelHeight; // Number of pixels in the y direction uint32 mNumBands; // Number of bands of data (usually 1 for grayscale or 3 for RGB) uint32 mBitsPerBand; // Number of bits per band of data (usually 8) uint32 mBytesPerRow; // Number of bytes per row of data in data buffer. If 0 this will be calculated for you. COLORREF* mPalette; // Array of colors for palette (set to NULL for no palette) uint32 mPaletteSize; // Number of colors in palette uint32 mAlphaBandIdx; // 0-based alpha channel band index (usually 0 or 3). Ignored unless GM_RasterLayout_AlphaPresent flag is set. } GM_RasterLayout_t; // Type listing available coordinate delimeters for ASCII import typedef uint8 GM_AsciiCoordDelim_t8; enum { GM_AsciiDelim_AutoDetect = 0, GM_AsciiDelim_Comma = 1, GM_AsciiDelim_Whitespace = 2, GM_AsciiDelim_Semicolon = 3, GM_AsciiDelim_Tab = 4, GM_AsciiDelim_NumTypes }; // Type listing available import types for ASCII import typedef uint8 GM_AsciiImportType_t8; enum { GM_AsciiImport_PointOnly = 0, // create point features for every encountered coordinate GM_AsciiImport_Vector = 1, // create area, line, and point features GM_AsciiImport_Elevation = 2, // triangulate and grid point cooridnates to generate an elevation grid GM_AsciiImport_NumTypes }; // This type represents layout information for a generic ASCII import typedef struct { GM_AsciiImportType_t8 mImportType; // specify import type GM_AsciiCoordDelim_t8 mCoordDelim; // sepcify coordinate delimeter boolean mYCoordFirst; // is Y coordinate first or X coordinate? boolean mIncludeCoordAttrs; // include attributes from coordinate lines boolean mColumnHeadersInFirstRow; // is the first row of the file column headers? (like for CSV files) boolean mIncludeElevCoords; // is the 3rd coordinate column an elevation or Z value? Must be TRUE for eAsciiImportElevation import type. uint8 mColumnsToSkip; // columns to skip before reaching coordinate columns uint8 mReserved; // reserved, must be 0 const char* mCoordLinePrefix; // prefix to look for at beginning of coordinate lines (default to NULL or empty) AreaFeatureClass_t16 mAreaType; // area type to assign to imported created area features LineFeatureClass_t16 mLineType; // line type to assign to imported created line features PointFeatureClass_t16 mPointType; // point type to assign to imported point features boolean mIgnoreZeroElevations; // ignore features with an elevation of zero boolean mFillToBounds; // fill grid to full bounds of data (i.e. don't constrict to convex hull) double mOffsetX; // offset to apply to X coordinates double mOffsetY; // offset to apply to Y coordinates double mOffsetZ; // offset to apply to Z coordinates double mScaleX; // Scale to apply to X coordinates (default is 1.0) double mScaleY; // Scale to apply to Y coordinates (default is 1.0) double mScaleZ; // Scale to apply to Z coordinates (default is 1.0) double mNoDataDistanceFactor; // tightness factor to use when gridding 3D data. Use 0.0 for default. uint8* mBreakOnColumnIdx; // index of column to break features on when value changes. Pass NULL for default break behavior. } GM_AsciiFormatInfo_t; // This type represents the different flags available for elevation grid generation typedef uint32 GM_GridGenFlags_t32; enum { GM_GridGen_NoConstraints = 0x00000001, // Don't treat area and line boundaries as constraints (i.e. break lines) GM_GridGen_FlattenAreas = 0x00000002, // Flatten 3D areas GM_GridGen_FillToBounds = 0x00000004, // Fill the grid to the full bounding rectangle of the input data and not just to the convex hull GM_GridGen_IgnoreZeroElevs = 0x00000008, // Don't use features with an elevation value of 0 GM_GridGen_HeightsRelative = 0x00000010, // Vector elevations are relative to underlying terrain data (if loaded) }; // This type represents the input needed for gridding a set of vector data typedef struct { const char* mDesc; // Grid description GM_GridGenFlags_t32 mFlags; // Flags for grid generation double mXRes; // X resolution (in current proj units) to generate grid at (use 0.0 for auto-spacing determination) double mYRes; // Y resolution (in current proj units) to generate grid at (use 0.0 for auto-spacing determination) UNIT mElevUnits; // Units to generate grid at (elevation values in other units will be converted as needed) const GM_Rectangle_t* mBounds; // Bounding box to grid to in current proj units. Pass NULL to use the combined bounds of all input layers (the default). double mTightnessMult; // Grid tightness multiplier (multiplies resolution) for discarding values far from a sample. Default of zero discards nothing. } GM_GridGenSetup_t; // This type represents the different available datum transformation methods typedef uint32 GM_DatumXForm_t32; enum { GM_Datum_Molodensky = 0, // 3-parameter Molodensky datum transformation GM_Datum_BursaWolfe = 1, // 7-parameter Bursa-Wolfe datum transformation GM_Datum_NumXFormMethods }; // This type represents information about a datum typedef struct { GM_DatumXForm_t32 mMethod; // Transformation method const char* mDatumName; // Name of datum const char* mEllipsoidName; // Name of ellipsoid this datum is based on double mDeltaX; // Delta X in meters double mDeltaY; // Delta Y in meters double mDeltaZ; // Delta Z in meters double mScale; // Scale factor (GM_Datum_BursaWolfe only) double mRotX; // Rotation in X in arc seconds (GM_Datum_BursaWolfe only) double mRotY; // Rotation in Y in arc seconds (GM_Datum_BursaWolfe only) double mRotZ; // Rotation in Z in arc seconds (GM_Datum_BursaWolfe only) double mPrimeMeridian; // Prime meridian for datum (0.0 for Greenwich) const char* mPrimeMeridianName; // Optional name of prime meridian } GM_DatumInfo_t; // This type represents a single elevation/color pair for a custom shader typedef struct { float mElev; // Elevation value in meters COLORREF mColor; // Color value } GM_ElevColor_t; // This type represents flags available for custom shaders typedef uint32 GM_CustomShaderFlags_t32; enum { GM_CustomShader_DontBlend = 0x00000001, // Don't blend colors between elevation values GM_CustomShader_StretchToRange = 0x00000002, // Stretch custom shader to cover valid elevation range }; // This type represents a custom elevation shader typedef struct { const char* mShaderName; // Name to use for the shader GM_CustomShaderFlags_t32 mFlags; // Shader flags uint32 mNumElevs; // Number of elevation/color pairs GM_ElevColor_t* mElevColorList; // List of elevation/color pairs for shader } GM_CustomShader_t; // This type represents flags available for web format exports typedef uint32 GM_WebExportFlags_t32; enum { GM_WebExport_NoTransparency = 0x00000001, // Don't use transparency in exported files GM_WebExport_DisplayResults = 0x00000002, // Automatically load the results in a web browser/viewer GM_WebExport_HideProgress = 0x00000004, // Don't show export progress GM_WebExport_AddScaleBar = 0x00000008, // Add scale bar control (Google Maps only) GM_WebExport_AddMapTypeControl = 0x00000010, // Add map type selector control (Google Maps only) GM_WebExport_AddOverviewMap = 0x00000020, // Add overview map control (Google Maps only) GM_WebExport_AutoGrid = 0x00000040, // Automatically grid for display (KML only - super overlays) }; // This type represents the options when exporting to a web format typedef struct { const char* mMapName; // Name to use for map set sint32 mMaxZoomLevel; // Maximum zoom level to export at uint32 mNumZoomLevels; // Number of zoom levels to export GM_RasterExportFormat_t32 mFormat; // Image format GM_WebExportFlags_t32 mFlags; // Export flags const char* mApiKey; // API key (used for Google Maps export) const char* mBgMapName; // Background map name (used for Google Maps export, ie. G_NORMAL_MAP, G_SATELLITE_MAP, etc.) double mTranslucency; // Translucency setting for new map (0.0 - 1.0). 1.0 is opaque. If 0.0 is provided, it will be assumed to be 1.0. double mXRes; // X resolution in arc degrees for export (KML only, default of 0.0 is full resolution) double mYRes; // Y resolution in arc degrees for export (KML only, default of 0.0 is full resolution) } GM_WebFormatExportOpts_t; // Callback for displaying error and warning messages. typedef void (__stdcall *GM_MessageCallbackFunc) ( const char* aMessageText ); // Callback for selecting a projection. Return TRUE if the projection structure // has been filled in and should be used. Return FALSE if the load should be // aborted. typedef boolean (__stdcall *GM_QueryProjectionCallbackFunc) ( GM_Projection_t* aProj, // OUT: projection structure to fill in const GM_Point_t* aInitialPos, // IN: optional coordinate in projection of layer to give hint as to what projection might be GM_ElevUnits_t8* aElevUnits // OU: optional, set to elevation units to use for layer if applicable and not NULL ); /*-------------------------------------------------------------------- MACROS --------------------------------------------------------------------*/ // Define a macro for determining how the exported functions should be declared. // This will vary depending on whether you're creating the DLL or using it. #if defined( GM_BUILDING_DLL ) #define GM_DLL_EXPORTED __declspec(dllexport) #elif defined( GM_BUILD_IN_PLACE ) #define GM_DLL_EXPORTED #else #define GM_DLL_EXPORTED __declspec(dllimport) #endif #ifdef __cplusplus extern "C" { #endif /*-------------------------------------------------------------------- LAYER LOAD FUNCTIONS --------------------------------------------------------------------*/ // Closes a previously opened layer. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CloseLayer ( GM_LayerHandle_t32 aLayer ); // Closes a previously opened package that was opened with the GM_LoadPackage function GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ClosePackage ( GM_PackageHandle_t32 aPackage ); // Flushes any in-memory cache for the layer (mainly useful in low-memory environments) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_FlushLayerCache ( GM_LayerHandle_t32 aLayer ); // Returns a const pointer to information about the specified layer. Returns // NULL if the layer is not loaded. GM_DLL_EXPORTED const GM_LayerInfo_t* __stdcall GM_GetLayerInfo ( GM_LayerHandle_t32 aLayer ); // Returns a list of the layers that are in a given package. The pointer // returned is temporary and will become invalid with the next call to this function. GM_DLL_EXPORTED GM_LayerHandle_t32* __stdcall GM_GetPackageLayerList ( GM_PackageHandle_t32 aPackage, // IN: package to get list of layers from uint32* aLayerCount // OUT: Number of layers in returned list ); // Loads a new layer from a simple ASCII text file file. A pointer to the layer is // stored for use in later calls. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_LoadGenericAsciiTextLayer ( const char* aFilename, // IN: filename of ASCII file to load GM_LayerHandle_t32* aLayer, // OUT: layer handle for loaded layer GM_LoadFlags_t32 aLoadFlags, // IN: load flags const GM_AsciiFormatInfo_t* aFormatInfo,// IN: optional format info (use NULL to prompt user) const GM_Projection_t* aProj // IN: optional projection to use for file (use NULL to prompt user) ); // Loads a new layer from a file. A pointer to the layer is stored for // use in later calls. This function is deprecated. You should use // GM_LoadLayerList or GM_LoadLayerListEx instead. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_LoadLayer ( const char* aFilename, GM_LayerHandle_t32* aLayer, GM_LoadFlags_t32 aLoadFlags ); // Loads layer(s) from a file. A pointer to a list containing handles // to the loaded layers is returned. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_LoadLayerList ( const char* aFilename, GM_LayerHandle_t32** aLayerList, uint32* aNumLoadedLayers, GM_LoadFlags_t32 aLoadFlags ); // Loads layer(s) from a file. A pointer to a list containing handles // to the loaded layers is returned. Additional load options can be // specified using the aExtraLoadOptions string. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_LoadLayerListEx ( const char* aFilename, GM_LayerHandle_t32** aLayerList, uint32* aNumLoadedLayers, GM_LoadFlags_t32 aLoadFlags, const char* aExtraLoadOptions ); // Loads a new Global Mapper package (.gmp) file. You can also load package files // with the GM_LoadLayerList command if you don't need to operate on the package // as a whole. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_LoadPackage ( const char* aFilename, GM_PackageHandle_t32* aPackage, GM_LoadFlags_t32 aLoadFlags ); // Loads a new layer from a file. A pointer to the layer is stored for // use in later calls. The layer will be rectified using the ground // control points and projection provided. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_LoadRectifiedLayer ( const char* aFilename, GM_LayerHandle_t32* aLayer, GM_LoadFlags_t32 aLoadFlags, const GM_GroundControlPoint_t* aGCPList, uint32 aNumGCPs, const GM_Projection_t* aProj ); // Loads data from the TerraServer, including DRG, DOQ, and urban area imagery // (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_LoadTerraServerLayer ( const char* aThemeName, // in: name of the theme or WMS source to load ("drg", "doq", etc.) or NULL to ask user const GM_Rectangle_t* aLatLonRect,// in: lat/lon rect to import (NULL to ask user) GM_LayerHandle_t32* aLayer // out: handle to loaded TerraServer layer ); // Repositions/reprojects a previously loaded raster layer. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_RepositionLayer ( GM_LayerHandle_t32 aLayer, const GM_GroundControlPoint_t* aGCPList, uint32 aNumGCPs, const GM_Projection_t* aProj ); /*-------------------------------------------------------------------- DISPLAY OPTIONS/DRAWING FUNCTIONS --------------------------------------------------------------------*/ // Adds a new custom shader for possible use for elevation layer display GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_AddCustomShader ( const GM_CustomShader_t* aShader, // in: shader to add uint32 aReserved // reserved, must be 0 ); // Turn automatic collar cropping on or off for a layer. This function is deprecated. // You should use GM_SetRasterDisplayOptions instead. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CropLayerCollar ( GM_LayerHandle_t32 aLayer, // in: Layer to crop collar from boolean aCropCollar // in: Crop the collar? (TRUE or FALSE) ); // Draws grid lines (either lat/lon or in the view projection) for the // specified location. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_DrawGridLines ( HDC aDC, // Device context to draw to boolean aLatLonGrid, // Draw a lat/lon grid or a view projection grid double aGridSpacing, // Grid spacing (use 0.0 for default) const GM_Rectangle_t* aWorldBounds, // World bounds to draw or NULL for all sint32 aLeftPixel, // Left pixel coordinate to draw to sint32 aTopPixel, // Top pixel coordinate to draw to sint32 aPixelWidth, // Width in pixels to draw sint32 aPixelHeight // Height in pixels to draw ); // Draws grid lines (either lat/lon or in the view projection) for the // specified location. This version can override the default extents of the grid // lines to be whatever they'd like rather than the bounds of all loaded data. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_DrawGridLinesEx ( HDC aDC, // Device context to draw to boolean aLatLonGrid, // Draw a lat/lon grid or a view projection grid double aGridSpacing, // Grid spacing (use 0.0 for default) const GM_Rectangle_t* aWorldBounds, // World bounds to draw or NULL for all sint32 aLeftPixel, // Left pixel coordinate to draw to sint32 aTopPixel, // Top pixel coordinate to draw to sint32 aPixelWidth, // Width in pixels to draw sint32 aPixelHeight, // Height in pixels to draw const GM_Rectangle_t* aMaxGridBounds // Maximum grid bounds (NULL for loaded data bounds) ); // Draws the specified portion of the specified layer to the device context. // If no layer is explicitly specified, all loaded layers will be drawn. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_DrawLayer ( HDC aDC, // Device context to draw to GM_LayerHandle_t32 aLayer, // Layer to draw or NULL for all const GM_Rectangle_t* aWorldBounds, // World bounds to draw or NULL for all sint32 aLeftPixel, // Left pixel coordinate to draw to sint32 aTopPixel, // Top pixel coordinate to draw to sint32 aPixelWidth, // Width in pixels to draw sint32 aPixelHeight // Height in pixels to draw ); // Draws the specified portion of the specified layers to the device context. // If no layers are explicitly specified, all loaded layers will be drawn. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_DrawLayerList ( HDC aDC, // Device context to draw to GM_LayerHandle_t32* aLayerList, // List of layers to draw or NULL for all uint32 aLayerCount, // Number of layers in list (0 for all) GM_DrawFlags_t32 aDrawFlags, // Flags controlling how the draw is performed const GM_Rectangle_t* aWorldBounds, // World bounds to draw or NULL for all sint32 aLeftPixel, // Left pixel coordinate to draw to sint32 aTopPixel, // Top pixel coordinate to draw to sint32 aPixelWidth, // Width in pixels to draw sint32 aPixelHeight // Height in pixels to draw ); // Draws the specified portion of the specified layers to the provided memory // buffer. If no layers are explicitly specified, all loaded layers will be drawn. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_DrawLayerListToMemory ( GM_LayerHandle_t32* aLayerList, // List of layers to draw or NULL for all uint32 aLayerCount, // Number of layers in list (0 for all) GM_DrawFlags_t32 aDrawFlags, // Flags controlling how the draw is performed const GM_Rectangle_t* aWorldBounds, // World bounds to draw or NULL for all GM_ColorFormat_t32 aColorFormat, // Color format used in data buffer sint32 aPixelWidth, // Width in pixels to draw sint32 aPixelHeight, // Height in pixels to draw void* aDataBuf, // Buffer to hold output color data sint32 aRowWidthBytes // Width of a single row in the array in bytes ); // Draws the specified portion of the specified packages to the device context. // If no packages are explicitly specified, all loaded packages will be drawn. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_DrawPackageList ( HDC aDC, // Device context to draw to GM_PackageHandle_t32* aPackageList, // List of packages to draw or NULL for all uint32 aPackageCount, // Number of packages in list (0 for all) GM_DrawFlags_t32 aDrawFlags, // Flags controlling how the draw is performed const GM_Rectangle_t* aWorldBounds, // World bounds to draw or NULL for all sint32 aLeftPixel, // Left pixel coordinate to draw to sint32 aTopPixel, // Top pixel coordinate to draw to sint32 aPixelWidth, // Width in pixels to draw sint32 aPixelHeight // Height in pixels to draw ); // Retrieves the elevation adjusment options to use for a given elevation layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetElevationOverrides ( GM_LayerHandle_t32 aLayer, // in: layer to get options for GM_ElevationOverrides_t* aOptions // out: elevation adjustments ); // Return the scale value (i.e. 24000.0 for 1:24K) that data was last rendered at GM_DLL_EXPORTED double __stdcall GM_GetLastDrawnScale ( HDC aDC // Device context that was drawn to ); // Retrieves the options to use when displaying the given raster layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetRasterDisplayOptions ( GM_LayerHandle_t32 aLayer, // in: layer to get options for GM_RasterDisplayOptions_t* aOptions // out: display options for raster layer ); // Retrieves the options to use for the elevation shaders GM_DLL_EXPORTED const GM_ShaderOptions_t* __stdcall GM_GetShaderDisplayOptions ( void ); // Retrieves the options to use when displaying gridded elevation data. GM_DLL_EXPORTED const GM_VerticalDisplayOptions_t* __stdcall GM_GetVerticalDisplayOptions ( void ); // Sets the color to be used for background pixels when drawing and exporting GM_DLL_EXPORTED COLORREF __stdcall GM_SetBackgroundColor ( COLORREF aBgColor ); // Sets the elevation adjustment values to use for a given elevation layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetElevationOverrides ( GM_LayerHandle_t32 aLayer, // in: layer to set options for const GM_ElevationOverrides_t* aOptions // in: elevation adjustment options for raster layer ); // Sets whether or not a given layer is enabled for display. If disabled, the // layer will never be drawn or used as input for other translucent or // texture-mapped layers. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetLayerEnabled ( GM_LayerHandle_t32 aLayer, // layer to enable or disable boolean aEnable // enable or disable the layer? ); // Allows for drawing data with a direction other than north to the top of // the screen for most projections. A value of 0.0 is the default and // implies no rotation. Technically, the orientation value is the number // of degrees to rotate the rendered data counter-clockwise. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetOrientation ( double aOrientation // Orientation of bitmap (0 is north up, 90 is east up, 180 is south up, 270 is west up) ); // Sets the options to use when displaying the given raster layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetRasterDisplayOptions ( GM_LayerHandle_t32 aLayer, // in: layer to set options for const GM_RasterDisplayOptions_t* aOptions // in: display options for raster layer ); // Sets the options to use for the elevation shaders (call GM_GetShaderDisplayOptions to initialize) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetShaderDisplayOptions ( const GM_ShaderOptions_t* aOptions // in: shader display options ); // Specifies the extra scaling factor to apply to line widths, point symbols, and // fonts when drawing. This is useful when printing to try and keep vector features // the same size as displayed. GM_DLL_EXPORTED float __stdcall GM_SetVectorDrawScale ( float aDrawScale // in: scale factor to apply to line widths, symbols, and fonts ); // Sets the options to use when displaying gridded elevation data. If you're not // going to change everything, it's suggested that you first call // GM_GetVerticalDisplayOptions to initialize the structure to the current // settings. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetVerticalDisplayOptions ( const GM_VerticalDisplayOptions_t* aVertDispOpts ); /*-------------------------------------------------------------------- COORDINATE CONVERSION/MEASUREMENT FUNCTIONS --------------------------------------------------------------------*/ // Calculates the bearing in radians between two points. The points // can either be specified as lat/lon values or in the current projection. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CalcBearing ( double aFromX, // IN: start X/longitude coordinate double aFromY, // IN: start Y/latitude coordinate double aToX, // IN: stop X/longitude coordinate double aToY, // IN: stop Y/latitude coordinate boolean aLatLon, // IN: TRUE - coordinates are lat/lon, FALSE - coordinates are in the current projection? double* aBearing // OUT: bearing in radians between the points ); // Calculates the great-circle distance in meters between two points. The points // can either be specified as lat/lon values or in the current projection. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CalcDistance ( double aFromX, // IN: start X/longitude coordinate double aFromY, // IN: start Y/latitude coordinate double aToX, // IN: stop X/longitude coordinate double aToY, // IN: stop Y/latitude coordinate boolean aLatLon, // IN: TRUE - coordinates are lat/lon, FALSE - coordinates are in the current projection? double* aDist // OUT: distance in meters between the points ); // Calculates the enclosed area of a region in square meters. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CalcEnclosedArea ( const GM_Point_t* aPtList, // IN: list of points defining area uint32 aNumPoints, // IN: number of points in list const GM_Projection_t* aProj, // IN: projection of points in list (use NULL for current projection returned by GM_GetProjection) double* aArea // OUT: enclosed area in square meters ); // Calculates the location of a new point projected from a start point along // a given bearing. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CalcProjectedLocation ( double aFromX, // IN: start X/longitude coordinate double aFromY, // IN: start Y/latitude coordinate double aBearing, // IN: bearing in degrees to project along (0 is north, 90 is east, 180 is south, 270 is west) double aDist, // IN: distance to project along bearing in meters double* aToX, // OUT: stop X/longitude coordinate double* aToY, // OUT: stop Y/latitude coordinate boolean aLatLon // IN: TRUE - coordinates are lat/lon, FALSE - coordinates are in the current projection ); // Calculate the rectangle in global coordinates required to draw at the provided // scale to the given device of the given size. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CalcScaleRectangle ( const GM_Point_t* aCenterPoint, // IN: Center point in global coordinates double aScale, // IN: Scale to calculate at (i.e. for 1:24K, pass 24000.0) HDC aDC, // IN: Device context that will be drawn to sint32 aPixWidth, // IN: pixel width sint32 aPixHeight, // IN: pixel height GM_Rectangle_t* aScaleRect // OUT: rectangle at given scale ); // Calculates the width and height of a rectangle in the current projection. The // rectangle can either be specified or the last drawn rectangle can be used. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CalcWorldRectSize ( const GM_Rectangle_t* aWorldBounds, // IN: World bounds to calc size of or NULL for last drawn double* aWidthMeters, // OUT: Width of rectangle in meters double* aHeightMeters // OUT: Height of rectangle in meters ); // Convert a coordinate between the current projection and a pixel coordinate. // The conversion space can be either the last drawn coordinate space or // the caller can provide the coordinate space to work in. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ConvertCoordGroundToPixel ( double aGroundX, // IN: X Coord in current projection double aGroundY, // IN: Y Coord in current projection sint32* aPixelX, // OUT: X Coord in pixel space sint32* aPixelY, // OUT: Y Coord in pixel space const GM_Rectangle_t* aWorldBounds, // IN: World bounds to convert from or NULL for last drawn const GM_PixelRect_t* aPixelRect // IN: Pixel bounds to convert from or NULL for last drawn ); // Convert a coordinate between the current projection and a pixel coordinate. // The conversion space can be either the last drawn coordinate space or // the caller can provide the coordinate space to work in. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ConvertCoordGroundToPixelWithOrientation ( double aGroundX, // IN: X Coord in current projection double aGroundY, // IN: Y Coord in current projection sint32* aPixelX, // OUT: X Coord in pixel space sint32* aPixelY, // OUT: Y Coord in pixel space const GM_Rectangle_t* aWorldBounds, // IN: World bounds to convert from or NULL for last drawn const GM_PixelRect_t* aPixelRect, // IN: Pixel bounds to convert from or NULL for last drawn double aOrientation // IN Orientation of coordinate space to use (0 is north up, 90 is east up, 180 is south up, 270 is west up) ); // Convert a coordinate between pixel space and the current projection. // The conversion space can be either the last drawn coordinate space or // the caller can provide the coordinate space to work in. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ConvertCoordPixelToGround ( sint32 aPixelX, // IN: X Coord in pixel space sint32 aPixelY, // IN: Y Coord in pixel space double* aGroundX, // OUT: X Coord in current projection double* aGroundY, // OUT: Y Coord in current projection const GM_Rectangle_t* aWorldBounds, // IN: World bounds to convert from or NULL for last drawn const GM_PixelRect_t* aPixelRect // IN: Pixel bounds to convert from or NULL for last drawn ); // Convert a coordinate between pixel space and the current projection. // The conversion space can be either the last drawn coordinate space or // the caller can provide the coordinate space to work in. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ConvertCoordPixelToGroundWithOrientation ( sint32 aPixelX, // IN: X Coord in pixel space sint32 aPixelY, // IN: Y Coord in pixel space double* aGroundX, // OUT: X Coord in current projection double* aGroundY, // OUT: Y Coord in current projection const GM_Rectangle_t* aWorldBounds, // IN: World bounds to convert from or NULL for last drawn const GM_PixelRect_t* aPixelRect, // IN: Pixel bounds to convert from or NULL for last drawn double aOrientation // IN Orientation of coordinate space to use (0 is north up, 90 is east up, 180 is south up, 270 is west up) ); /*-------------------------------------------------------------------- PROJECTION/DATUM FUNCTIONS --------------------------------------------------------------------*/ // Adds a new custom datum with the given parameters GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_AddCustomDatum ( const GM_DatumInfo_t* aDatumInfo, // IN: Information about datum transformation to add DATUM* aDatumCode // OUT: Datum code assigned to new custom datum ); // Retrieves a list of all available projections and their available parameters, datums, units, etc. GM_DLL_EXPORTED const GM_ProjectionInfo_t* __stdcall GM_GetAvailableProjectionList ( uint32* aProjCnt // OUT: Number of projections returned in list ); // Retrieves the global projection that is being used for all // rendering and exporting. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetProjection ( GM_Projection_t* aProj // OUT: Current view/export projection ); // Initializes a GM_Projection_t structure from a projection (PRJ, Ozi .map, etc.) file. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_LoadProjectionFile ( const char* aFilename, // filename of projection file to load GM_Projection_t* aProj // buffer in which to place decoded projection. ); // Initializes a GM_Projection_t structure from an EPSG code GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_LoadProjectionFromEPSGCode ( uint32 aEpsgCode, // IN: EPSG code to get projection from GM_Projection_t* aProj // OUT: buffer in which to place decoded projection. ); // Retrieves the underlying base projection that forms the basis for a given projection. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ProjectionGetBase ( const GM_Projection_t* aProjIn, // IN: projection to convert from (NULL for current) GM_Projection_t* aProjBase // OUT: projection on which the input projection is based ); // Projects a point from one projection to another GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ProjectPoint ( double aXIn, // IN: X coordinate of input point double aYIn, // IN: Y coordinate of input point double* aXOut, // OUT: X coordinate of output point double* aYOut, // OUT: Y coordinate of output point const GM_Projection_t* aProjIn, // IN: projection to convert from (NULL for current) const GM_Projection_t* aProjOut // IN: projection to convert to (NULL for current) ); // Projects a rectangle from one projection to another GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ProjectRectangle ( const GM_Rectangle_t* aRectIn, // IN: Rectangle to convert in input projection GM_Rectangle_t* aRectOut, // OUT: Rectangle in output projection const GM_Projection_t* aProjIn, // IN: projection to convert from (NULL for current) const GM_Projection_t* aProjOut // IN: projection to convert to (NULL for current) ); // Saves a GM_Projection_t structure to a projection (PRJ) file. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SaveProjectionToFile ( const char* aFilename, // filename of projection file to save to const GM_Projection_t* aProj, // projection to save uint32 aReserved // reserved for future use, must be 0 ); // Displays the projection selection dialog to allow the user to select a // projection GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SelectProjection ( GM_Projection_t* aSelProj, // out: projection selected by user const GM_Projection_t* aInitProj // in: initial projection to use (NULL for default) ); // Displays the projection selection dialog to allow the user to select a // projection GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SelectProjectionEx ( GM_Projection_t* aSelProj, // out: projection selected by user const GM_Projection_t* aInitProj, // in: initial projection to use (NULL for default) const POINT* aDlgPos, // in: position of top left corner (in screen coordinates) for projection dialog (NULL for default) GM_SelectProjFlags_t32 aFlags, // in: additional flags for projection selection void* aReserved // in: reserved for future use (must be NULL) ); // Sets the function to call to select a projection for a layer when being // loaded if the projection for that layer cannot be automatically determined. // If a callback is provided, it will be called rather than the projection // selection dialog being displayed. GM_DLL_EXPORTED void __stdcall GM_SetQueryProjectionCallback ( GM_QueryProjectionCallbackFunc aCallbackFunc ); // Sets the new projection. This is the projection that all draws and // exports will be done in. It is also the projection that all world bound // rectangles will be in. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetProjection ( const GM_Projection_t* aProj ); /*-------------------------------------------------------------------- EXPORT FUNCTIONS --------------------------------------------------------------------*/ // Exports one or more layers to a new gridded elevation file (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ExportElevation ( const char* aFilename, // Name of new file to create GM_ElevationExportFormat_t32 aFormat, // Format to export GM_LayerHandle_t32 aLayer, // Layer to export or NULL for all const GM_Rectangle_t* aWorldBounds, // World bounds to export or NULL for all sint32 aPixelWidth, // Width in samples of new image sint32 aPixelHeight, // Height in samples of new image GM_RasterExportFlags_t32 aFlags, // Export flags GM_ElevUnits_t8 aElevUnits // Elevation units for export, if applicable ); // Exports one or more layers to a new package file (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ExportPackage ( const char* aFilename, // Name of new file to create GM_LayerHandle_t32* aLayerList, // List of layers to export or NULL for all uint32 aLayerCount, // Number of layers in list (0 for all) const GM_Rectangle_t* aWorldBounds, // World bounds to export or NULL for all double aSimpThreshold, // Simplification threshold, use 0.0 for no simplification GM_PackageExportFlags_t32 aFlags // Export flags ); // Exports one or more layers to a new raster file (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ExportRaster ( const char* aFilename, // Name of new file to create GM_RasterExportFormat_t32 aFormat, // Format to export GM_LayerHandle_t32 aLayer, // Layer to export or NULL for all const GM_Rectangle_t* aWorldBounds, // World bounds to export or NULL for all sint32 aPixelWidth, // Width in pixels of new image sint32 aPixelHeight, // Height in pixels of new image GM_RasterExportFlags_t32 aFlags // Export flags ); // Exports one or more layers to a new raster file (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ExportRasterEx ( const char* aFilename, // Name of new file to create GM_RasterExportFormat_t32 aFormat, // Format to export GM_LayerHandle_t32* aLayerList, // List of layers to export or NULL for all uint32 aLayerCount, // Number of layers in list (0 for all) const GM_Rectangle_t* aWorldBounds, // World bounds to export or NULL for all sint32 aPixelWidth, // Width in pixels of new image sint32 aPixelHeight, // Height in pixels of new image GM_RasterExportFlags_t32 aFlags, // Export flags const char* aExtraFlags // Additional text-based flags for some formats (use NULL for defaults) ); // Exports one or more layers to a new raster file (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ExportRasterFromBitmap ( const char* aFilename, // Name of new file to create HBITMAP aBitmap, // Handle to bitmap to export HDC aDC, // Handle to compatible device context GM_RasterExportFormat_t32 aFormat, // Format to export const GM_Rectangle_t* aWorldBounds, // World bounds of bitmap or NULL for last drawn GM_RasterExportFlags_t32 aFlags // Export flags ); // Exports one or more layers to a new vector file (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ExportVector ( const char* aFilename, // Name of new file to create GM_VectorExportFormat_t32 aFormat, // Format to export GM_LayerHandle_t32 aLayer, // Layer to export or NULL for all const GM_Rectangle_t* aWorldBounds, // World bounds to export or NULL for all GM_VectorExportFlags_t32 aFlags, // Export flags void* aFormatOptions // Format-specific options (NULL for defaults) ); // Exports one or more layers to a new web format file (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_ExportWebFormat ( const char* aFilename, // Name of HTML/XML file to create GM_WebExportFormat_t32 aWebFormat, // Format to export GM_LayerHandle_t32* aLayerList, // List of layers to export or NULL for all uint32 aLayerCount, // Number of layers in list (0 for all) const GM_Rectangle_t* aWorldBounds, // World bounds to export or NULL for all const GM_WebFormatExportOpts_t* aExportOpts, // Export options void* aReserved // Reserved for future use, must be NULL ); /*-------------------------------------------------------------------- RASTER/ELEVATION LAYER QUERY FUNCTIONS --------------------------------------------------------------------*/ // Retrieves the color at a given location from a provided layer or from the // list of currently loaded raster and elevation layers (topmost layer first). GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetLocationColor ( GM_LayerHandle_t32 aLayer, // IN: Layer to get color from or NULL for topmost double aXCoord, // IN: X coord in current projection double aYCoord, // IN: Y coord in current projection GM_Color_t* aColor // OUT: Color of pixel at location ); // Retrieves the elevation at a given location from a provided layer or from the // list of currently loaded elevation layers (topmost elevation layer first). GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetLocationElevation ( GM_LayerHandle_t32 aLayer, // IN: Layer to get elevation from or NULL for topmost double aXCoord, // IN: X coord in current projection double aYCoord, // IN: Y coord in current projection float* aElev // OUT: Elevation at location in meters ); // Retrieves the color at a given pixel location in the provided layer. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetPixelColor ( GM_LayerHandle_t32 aLayer, // IN: Layer to get color from sint32 aRow, // IN: Y coord of pixel (0 is topmost) sint32 aCol, // IN: X coord of pixel (0 is leftmost) GM_Color_t* aColor // OUT: Color of pixel at location ); // Retrieves the elevation at a given pixel location in the provided layer. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetPixelElevation ( GM_LayerHandle_t32 aLayer, // IN: Layer to get elevation from sint32 aRow, // IN: Y coord of pixel (0 is topmost) sint32 aCol, // IN: X coord of pixel (0 is leftmost) float* aElev // OUT: Elevation at location in meters ); /*-------------------------------------------------------------------- VECTOR LAYER QUERY FUNCTIONS --------------------------------------------------------------------*/ // Finds the address closest to the search location GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_FindNearestAddress ( const GM_Point_t* aSearchPt, // IN: Search location in current view projection (as returned by GM_SetProjection) GM_LayerHandle_t32* aLayerList, // IN: List of layers to search or NULL for all vector layers uint32 aLayerCount, // IN: Number of layers in list (0 for all) char* aAddressStr, // I/O: Buffer to hold string for nearest address uint32 aMaxAddressLen, // IN: Maximum length of string to store in output double aMaxDistMeters, // IN: Maximum distance in meters to search around search point void* aReserved // IN: Reserved for later use, must be NULL (0) ); // Finds features within so many pixels of a given pixel location. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_FindNearestFeatures ( const GM_Point_t* aPixelSearchPt, // IN: Search location in pixel coordinates GM_LayerHandle_t32* aLayerList, // IN: List of layers to search or NULL for all vector layers uint32 aLayerCount, // IN: Number of layers in list (0 for all) GM_FindFlags_t32 aFindFlags, // IN: Flags controlling how the find is performed const GM_Rectangle_t* aWorldBounds, // IN: World bounds for search space or NULL for last drawn const GM_PixelRect_t* aPixelRect, // IN: Pixel bounds for search space or NULL for last drawn GM_FoundFeature_t* aNearestFeatures, // OUT: List of nearest features uint32 aMaxFeatures, // IN: Max number of nearest features to find uint32* aFoundFeatureCnt, // OUT: Number of nearest features returned in list uint32 aMaxDistPixels // IN: Max distance in pixels to search ); // Frees the resources used by the given area feature GM_DLL_EXPORTED void __stdcall GM_FreeAreaFeature ( GM_AreaFeature_t* aAreaFeature // Area feature to free ); // Frees the resources used by the given line feature GM_DLL_EXPORTED void __stdcall GM_FreeLineFeature ( GM_LineFeature_t* aLineFeature // Line feature to free ); // Frees the resources used by the given point feature GM_DLL_EXPORTED void __stdcall GM_FreePointFeature ( GM_PointFeature_t* aPointFeature // Point feature to free ); // Retrieves the area feature at the given index from the layer GM_DLL_EXPORTED GM_AreaFeature_t* __stdcall GM_GetAreaFeature ( GM_LayerHandle_t32 aLayer, // Layer to get area from uint32 aAreaIndex // Index of area feature to retrieve ); // Retrieves the line at the given index from the layer GM_DLL_EXPORTED GM_LineFeature_t* __stdcall GM_GetLineFeature ( GM_LayerHandle_t32 aLayer, // Layer to get line from uint32 aLineIndex // Index of line feature to retrieve ); // Retrieves the point feature at the given index from the layer GM_DLL_EXPORTED GM_PointFeature_t* __stdcall GM_GetPointFeature ( GM_LayerHandle_t32 aLayer, // Layer to get point from uint32 aPointIndex // Index of point feature to retrieve ); /*-------------------------------------------------------------------- VECTOR LAYER EDIT FUNCTIONS --------------------------------------------------------------------*/ // Changes the delete status of the area, line, or point feature at the given // index in the layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_DeleteFeature ( GM_LayerHandle_t32 aLayer, // IN: Layer the point is in GM_FeatureClassType_t8 aFeatureClassType, // IN: Type of feature class (area, point, line) uint32 aFeatureIndex, // IN: Index of feature in layer boolean aDelete // IN: Use TRUE to mark as deleted, FALSE to clear delete flag ); // Queries the delete status of the area, line, or point feature at the given // index in the layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_IsFeatureDeleted ( GM_LayerHandle_t32 aLayer, // IN: Layer the point is in GM_FeatureClassType_t8 aFeatureClassType, // IN: Type of feature class (area, point, line) uint32 aFeatureIndex, // IN: Index of feature in layer boolean* aIsDeleted // OUT: Returns TRUE if marked as deleted, FALSE if not ); // Sets the list of point locations to use for a given area feature GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetAreaFeaturePointList ( GM_LayerHandle_t32 aLayer, // Layer the area is in uint32 aAreaIndex, // Index of area in layer uint32 aHoleIndex, // Index of hole to apply locations to (0 for main parent area, 1 for first hole, etc.) const GM_Point_t* aPointList, // New list of points for area uint32 aPointCount, // Number of points in list (must be >= 3) boolean aPosInLayerCoords // Are the position in the layer coordinate system or the current coordinate system? ); // Sets the list of attribute/values to use for the specified feature. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetFeatureAttrList ( GM_LayerHandle_t32 aLayer, // IN: Layer the feature is in GM_FeatureClassType_t8 aFeatureClassType, // IN: Type of feature class (area, point, line) uint32 aFeatureIndex, // IN: Index of feature in layer const GM_AttrValue_t* aAttrList, // IN: New list of attributes to associate with feature uint16 aNumAttrs // IN: Number of attributes in aAttrList ); // Sets the classification to use for the given feature. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetFeatureClass ( GM_LayerHandle_t32 aLayer, // IN: Layer the feature is in GM_FeatureClassType_t8 aFeatureClassType, // IN: Type of feature class (area, point, line) uint32 aFeatureIndex, // IN: Index of feature in layer FeatureClass_t16 aFeatureClass // IN: New feature class to assign to feature ); // Sets the display label to use for the feature. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetFeatureLabel ( GM_LayerHandle_t32 aLayer, // IN: Layer the feature is in GM_FeatureClassType_t8 aFeatureClassType, // IN: Type of feature class (area, point, line) uint32 aFeatureIndex, // IN: Index of feature in layer const char* aLabel // IN: New display label for feature. ); // Sets the description for the layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetLayerDescription ( GM_LayerHandle_t32 aLayer, // layer to set description for const char* aDesc // description to use (pass NULL to restore default) ); // Sets the name of the attribute to use for setting the display label of // features within this layer. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetLayerLabelAttribute ( GM_LayerHandle_t32 aLayer, // Layer to modify labels for const char* aAttrName, // Name of attribute to use for naming labels uint32 aReserved // Reserved value for future expansion (must be zero) ); // Sets the list of point locations to use for a given line feature GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetLineFeaturePointList ( GM_LayerHandle_t32 aLayer, // Layer the line is in uint32 aLineIndex, // Index of line in layer const GM_Point_t* aPointList, // New list of points for line uint32 aPointCount, // Number of points in list (must be >= 2) boolean aPosInLayerCoords // Are the position in the layer coordinate system or the current coordinate system? ); // Sets the location to use for a given point feature GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetPointFeaturePosition ( GM_LayerHandle_t32 aLayer, // Layer the point is in uint32 aPointIndex, // Index of point in layer const GM_Point_t* aPosition, // New location of point boolean aPosInLayerCoords // Is the position in the layer coordinate system or the current coordinate system? ); /*-------------------------------------------------------------------- VECTOR DRAWING STYLE/TYPE FUNCTIONS --------------------------------------------------------------------*/ // Adds a new custom area classification. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_AddCustomAreaClass ( const char* aName, // IN: Custom type name const GM_AreaStyle_t* aStyle, // IN: Default draw style for features of this type AreaFeatureClass_t16* aFeatureCode // OUT: Classification code for new type ); // Adds a new custom line classification. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_AddCustomLineClass ( const char* aName, // IN: Custom type name const GM_LineStyle_t* aStyle, // IN: Default draw style for features of this type LineFeatureClass_t16* aFeatureCode // OUT: Classification code for new type ); // Adds a new custom point classification. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_AddCustomPointClass ( const char* aName, // IN: Custom type name const GM_PointStyle_t* aStyle, // IN: Default draw style for features of this type PointFeatureClass_t16* aFeatureCode // OUT: Classification code for new type ); // Adds a new custom symbol that can be used when drawing point features // (see the GM_SetPointFeatureDrawStyle function) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_AddCustomSymbol ( const char* aSymbolFilename, // Full path to symbol file (BMP or ICO) const char* aSymbolName // Text name to use when referring to the symbol ); // Sets the default drawing style to use for a given area feature classification GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetAreaFeatureClassDrawStyle ( AreaFeatureClass_t16 aFeatureClass, // IN: Feature class to get draw style for GM_AreaStyle_t* aAreaStyle // OUT: Current draw style for area classification ); // Returns the list of available symbol names GM_DLL_EXPORTED char** __stdcall GM_GetAvailableSymbolNames ( uint32* aNumSymbols // OUT: Number of symbols in returned list ); // Sets the default drawing style to use for a given line feature classification GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetLineFeatureClassDrawStyle ( LineFeatureClass_t16 aFeatureClass, // IN: Feature class to get draw style for GM_LineStyle_t* aLineStyle // OUT: Current draw style for line classification ); // Sets the default drawing style to use for a given point feature classification GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetPointFeatureClassDrawStyle ( PointFeatureClass_t16 aFeatureClass, // IN: Feature class to get draw style for GM_PointStyle_t* aPointStyle // OUT: Current draw style for point classification ); // Displays a dialog allowing the user to graphically select an area style (not available on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SelectAreaStyle ( GM_AreaStyle_t* aAreaStyle // IN/OUT: Area style buffer - make sure to initialize before passing in ); // Displays a dialog allowing the user to graphically select a line style (not available on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SelectLineStyle ( GM_LineStyle_t* aLineStyle // IN/OUT: Line style buffer - make sure to initialize before passing in ); // Sets the default drawing style to use for a given area feature classification GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetAreaFeatureClassDrawStyle ( AreaFeatureClass_t16 aFeatureClass, // IN: Feature class to set draw style for const GM_AreaStyle_t* aAreaStyle // IN: New style to use for area class (NULL to reset to default) ); // Sets the drawing style to use for a given area feature GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetAreaFeatureDrawStyle ( GM_LayerHandle_t32 aLayer, // Layer the area is in uint32 aAreaIndex, // Index of area in layer const GM_AreaStyle_t* aAreaStyle // New style to use for area ); // Sets the default drawing style to use for a given line feature classification GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetLineFeatureClassDrawStyle ( LineFeatureClass_t16 aFeatureClass, // IN: Feature class to set draw style for const GM_LineStyle_t* aLineStyle // IN: New style to use for line class (NULL to reset to default) ); // Sets the drawing style to use for a given line feature GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetLineFeatureDrawStyle ( GM_LayerHandle_t32 aLayer, // Layer the line is in uint32 aLineIndex, // Index of line in layer const GM_LineStyle_t* aLineStyle // New style to use for line ); // Sets the default drawing style to use for a given point feature classification GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetPointFeatureClassDrawStyle ( PointFeatureClass_t16 aFeatureClass, // IN: Feature class to set draw style for const GM_PointStyle_t* aPointStyle // IN: New style to use for point class (NULL to reset to default) ); // Sets the drawing style to use for a given point feature GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetPointFeatureDrawStyle ( GM_LayerHandle_t32 aLayer, // Layer the point is in uint32 aPointIndex, // Index of point in layer const GM_PointStyle_t* aPointStyle // New style to use for point ); /*-------------------------------------------------------------------- VECTOR FEATURE FILTERING FUNCTIONS --------------------------------------------------------------------*/ // Retrieves information about a given feature class GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetFeatureClassInfo ( FeatureClass_t16 aFeatureClass, // IN: Feature class to get info for GM_FeatureClassType_t8 aFeatureClassType, // IN: Type of feature class (area, point, line) GM_FeatureClassInfo_t* aFeatureClassInfo // OUT: Info about the feature class ); // Enables or disables the display of the given feature class. The previous // enable/disable state is returned. GM_DLL_EXPORTED boolean __stdcall GM_SetFeatureClassEnabled ( FeatureClass_t16 aFeatureClass, // IN: Feature class to get info for GM_FeatureClassType_t8 aFeatureClassType, // IN: Type of feature class (area, point, line) boolean aEnable // IN: Enable or disable the feature class ); /*-------------------------------------------------------------------- SURFACE ANALYSIS FUNCTIONS --------------------------------------------------------------------*/ // Performs a view-shed analysis on loaded elevation data (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CalcViewShed ( GM_LayerHandle_t32 aLayer, // IN: Layer to get elevations from or NULL for topmost layer at each point const GM_ViewShedParams_t* aViewShedParms, // IN: Parameters for creating view shed GM_LayerHandle_t32* aViewShedLayer // OUT: Created view shed layer ); // Calculates the cut-and-fill volumes along a given line (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CalcVolumeAlongLine ( GM_LayerHandle_t32 aLayer, // IN: Layer to get elevations from or NULL for topmost layer at each point const GM_LineVolumeParams_t* aVolumeParms, // IN: Parameters for line volume calculation double* aCutVolume, // OUT: Cut volume in cubic meters double* aFillVolume // OUT: Fill volume in cubic meters ); // Calculates the cut-and-fill volumes within a given area (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_CalcVolumeOfArea ( GM_LayerHandle_t32 aLayer, // IN: Layer to get elevations from or NULL for topmost layer at each point const GM_AreaVolumeParams_t* aVolumeParms, // IN: Parameters for area volume calculation double* aCutVolume, // OUT: Cut volume in cubic meters double* aFillVolume // OUT: Fill volume in cubic meters ); // Generates contours for the given layer(s) (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GenerateContours ( GM_LayerHandle_t32 aLayer, // IN: Layer to get elevations from or NULL for topmost layer at each point const GM_ContourParams_t* aContourParms, // IN: Parameters for generating contours GM_LayerHandle_t32* aContourLayer // OUT: Created view shed layer ); // Generates an elevation grid by triangulating and gridding 3D vector layers (not implemented on WinCE) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GenerateElevationGrid ( GM_LayerHandle_t32* aLayerList, // IN: List of layers to use or NULL for all uint32 aLayerCount, // IN: Number of layers in list (0 for all) const GM_GridGenSetup_t* aGridSetup, // IN: Grid setup parameters (pass NULL for default options) GM_LayerHandle_t32* aGridLayer, // OUT: Created grid layer GM_LayerHandle_t32* aTinLayer // OUT: Created TIN area layer (optional, set to NULL if you don't want) ); // Retrieves a list of elevations along a path in the provided layer or from // the list of currently loaded elevation layers (topmost elevation layer first). GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetPathProfile ( GM_LayerHandle_t32 aLayer, // IN: Layer to get elevation from or NULL for topmost double aStartX, // IN: Start X coord in current projection double aStartY, // IN: Start Y coord in current projection double aEndX, // IN: End X coord in current projection double aEndY, // IN: End Y coord in current projection float* aElevList, // OUT: Buffer to hold list of elevations uint32 aListSize, // IN: Number of elevations to retrieve float aDfltElev // IN: Elev to use when none could be found ); // Retrieves a list of elevations along a path in the provided layer or from // the list of currently loaded elevation layers (topmost elevation layer first). // Can also perform a line-of-sight calculation and return additional information // about a 3D path (not implemented on WinCE). GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_GetPathProfileLOS ( GM_LayerHandle_t32 aLayer, // IN: Layer to get elevation from or NULL for topmost GM_PathProfileLOSParams_t* aParams // IN/OUT: Calculation parameters ); /*-------------------------------------------------------------------- MAP CATALOG FUNCTIONS --------------------------------------------------------------------*/ // Adds a new map to the map catalog from a file on disk GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_MapCatalogAddFile ( GM_LayerHandle_t32 aCatalogLayer, // IN: Handle to map catalog layer (either from loading or GM_CreateMapCatalog) const char* aFilename // IN: Filename of map to add to the catalog ); // Adds a new map to the map catalog from a loaded layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_MapCatalogAddLayer ( GM_LayerHandle_t32 aCatalogLayer, // IN: Handle to map catalog layer (either from loading or GM_CreateMapCatalog) GM_LayerHandle_t32 aMapLayer // IN: Handle of loaded map layer to add to the catalog ); // Creates a new map catalog layer for adding map layers to GM_DLL_EXPORTED GM_LayerHandle_t32 __stdcall GM_MapCatalogCreate ( const char* aDescription, // IN: Description to use for layer (can be NULL to use default) const GM_Projection_t* aProj // IN: Native projection of new layer (NULL for Geographic/WGS84/Arc Degrees) ); // Retrieves information and statistics about the catalog (use GM_GetLayerInfo for generic information) GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_MapCatalogGetInfo ( GM_LayerHandle_t32 aCatalogLayer, // IN: Handle to map catalog layer (either from loading or GM_CreateMapCatalog) GM_MapCatalogInfo_t* aCatalogInfo // OUT: Structure holding catalog information ); // Retrieves information about a map in a catalog (use GM_GetMapCatalogInfo to get the map count) GM_DLL_EXPORTED const GM_LayerInfo_t* __stdcall GM_MapCatalogGetMapInfo ( GM_LayerHandle_t32 aCatalogLayer, // IN: Handle to map catalog layer (either from loading or GM_CreateMapCatalog) uint32 aMapIndex // IN: Index of map (0-based) to get info about ); // Removes the map at the given index from the catalog GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_MapCatalogRemoveMap ( GM_LayerHandle_t32 aCatalogLayer, // IN: Handle to map catalog layer (either from loading or GM_CreateMapCatalog) uint32 aMapIndex // IN: Index of map (0-based) to remove from map catalog ); // Saves a map catalog layer to a file on disk GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_MapCatalogSave ( GM_LayerHandle_t32 aCatalogLayer, // IN: Handle to map catalog layer (either from loading or GM_CreateMapCatalog) const char* aFilename // IN: Filename to save map catalog to ); // Sets when the layers in a map catalog should be displayed GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_MapCatalogSetDisplayInfo ( GM_LayerHandle_t32 aCatalogLayer, // IN: Handle to map catalog layer (either from loading or GM_CreateMapCatalog) GM_MapCatalogDisplayType_t8 aDisplayType, // IN: Controls when layers in catalog are displayed double aDisplayValue, // IN: First value related to display type double aDisplayValue2, // IN: Optional second value for range of scales (use 0.0 if doesn't apply) boolean aHideBounds // IN: Hide layer bounds when not drawing a layer? ); /*-------------------------------------------------------------------- CUSTOM LAYER AND FEATURE CREATION FUNCTIONS --------------------------------------------------------------------*/ // Adds an area feature to a loaded vector layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_AddAreaToVectorLayer ( GM_LayerHandle_t32 aLayer, // IN: Layer to add area to const GM_AreaFeature_t* aArea, // IN: Area feature to add boolean aUseDefaultStyle // IN: Use default drawing style and font for type rather than style in type structure? ); // Adds a line feature to a loaded vector layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_AddLineToVectorLayer ( GM_LayerHandle_t32 aLayer, // IN: Layer to add line to const GM_LineFeature_t* aLine, // IN: Line feature to add boolean aUseDefaultStyle // IN: Use default drawing style and font for type rather than style in type structure? ); // Adds a point feature to a loaded vector layer GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_AddPointToVectorLayer ( GM_LayerHandle_t32 aLayer, // IN: Layer to add point to const GM_PointFeature_t* aPoint, // IN: Point feature to add boolean aUseDefaultStyle// IN: Use default symbol and font for type rather than style in type structure? ); // Creates a new custom layer for an in-memory elevation grid (not implemented on WinCE) GM_DLL_EXPORTED GM_LayerHandle_t32 __stdcall GM_CreateCustomElevGridLayer ( const char* aDescription, // IN: Description to use for layer (can be NULL to use default) const GM_Projection_t* aProj, // IN: Native projection of new layer const GM_Point_t* aTopLeft, // IN: Ground coordinates of top left sample double aXSampleSize, // IN: Size of each grid cell in the x direction double aYSampleSize, // IN: Size of each grid cell in the y direction sint32 aNumSamplesX, // IN: Number of samples in the x direction sint32 aNumSamplesY, // IN: Number of samples in the y direction const void* aElevGrid, // IN: Grid of elevation values in row-major order GM_GridLayout_t8 aGridLayout, // IN: Layout of elevation grid float aNoDataValue // IN: Value of samples for which the value isn't known (i.e. -9999.9) ); // Creates a new custom layer for an in-memory raster grid (not implemented on WinCE) GM_DLL_EXPORTED GM_LayerHandle_t32 __stdcall GM_CreateCustomRasterLayer ( const char* aDescription, // IN: Description to use for layer (can be NULL to use default) const GM_Projection_t* aProj, // IN: Native projection of new layer const GM_RasterLayout_t* aRasterLayout, // IN: Raster layer layout const void* aDataBuf // IN: Grid of raster data values in row-major order ); // Creates a new custom layer for adding vector features to GM_DLL_EXPORTED GM_LayerHandle_t32 __stdcall GM_CreateCustomVectorLayer ( const char* aDescription, // IN: Description to use for layer (can be NULL to use default) const GM_Projection_t* aProj // IN: Native projection of new layer ); /*-------------------------------------------------------------------- UTILITY FUNCTIONS --------------------------------------------------------------------*/ // Returns a string containing the filter to use in a Windows file open // dialog box for all of the types supported for loading from this DLL. GM_DLL_EXPORTED const char* __stdcall GM_GetFilterString ( void ); // Returns the date that this SDK was built. Use this to provide more resolution // for beta releases than GM_GetSDKVersion provides. GM_DLL_EXPORTED time_t __stdcall GM_GetSDKBuildDate ( void ); // Returns the version of this SDK. The version is obtained by taking the // major version number times 100 and adding the minor version number. For // example, version 1.04 would be returned as 104. GM_DLL_EXPORTED uint32 __stdcall GM_GetSDKVersion ( void ); // Returns TRUE if the current user is registered or currently using a demo // license. GM_DLL_EXPORTED boolean __stdcall GM_IsRegistered ( void ); // Displays a file dialog that allows the user to select a file to load. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SelectFile ( char* aFilename, // buffer in which to place selected filename (must be at least _MAX_PATH characters in length) const char* aFilterStr, // filter string for open dialog (NULL for default) const char* aInitialDir,// initial directory to start in (NULL for current) HWND aParentWnd // handle to parent window for file selection dialog ); // Sets the function to call to display error and warning messages generated // during SDK operations. If a message callback is provided, a message // dialog will not be shown, instead the callback function will be called // with the error or warning message that would have been displayed. GM_DLL_EXPORTED void __stdcall GM_SetMessageCallback ( GM_MessageCallbackFunc aCallbackFunc ); // Sets the function to call to report the progress of an operation, like // the loading of a file. If a progress callback is provided, a progress // dialog will not be shown, instead the callback function will be called. GM_DLL_EXPORTED void __stdcall GM_SetProgressCallback ( GM_ProgressCallbackFunc aCallbackFunc ); // Sets the registration name and code to use for this instance of the DLL. // This can be used rather than the GMDLL_regkey.txt file to supply the // registration information. Will return GM_Error_NotRegistered if the key // is not valid for the name. GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetRegistrationInfo ( const char* aRegName, // name provided for the registration information uint32 aRegKey // registration key ); // Sets the base registry key from which settings should be stored/read. Settings // will be stored in and read from "HKEY_CURRENT_USER\Software\\Global Mapper". GM_DLL_EXPORTED GM_Error_t32 __stdcall GM_SetRegistryKey ( const char* aKeyName // location in registry under which to store settings ); // Restore structure alignment to its old value #pragma pack( pop ) #ifdef __cplusplus } #endif #endif // end of file GlobalMaperInterface.h