| MgAgfReaderWriter | Used to translate an MgGeometry object into into an MgByteReader object and to do the reverse translation |
| MgAggregateGeometry | MgAggregateGeometry is an abstract base class for all of the geometry types that are composed of a set of aggregated geometry objects |
| MgAllProviderConnectionsUsedException | Thrown when the server cannot create another connection to the FDO provider |
| MgApplicationException | Base class for all exceptions representing an application error |
| MgArcSegment | MgArcSegment is a curve segment defined in terms of a start point, end point, and a control point |
| MgArgumentOutOfRangeException | Thrown when the value of an argument is outside the allowable range of values as defined by the invoked method |
| MgArrayTypeMismatchException | Thrown when an attempt is made to store an element of the wrong type within an array |
| MgAuthenticationFailedException | Thrown when authentication with the MapGuide site server fails |
| MgBatchPropertyCollection | MgBatchPropertyCollection represents a collection of properties. Properties are name/value pairs used for specifying the values of properties |
| MgBlobProperty | Stores BLOB (Binary Large Object) data with an associated key name |
| MgBooleanProperty | Stores boolean data with an associated key name |
| MgByteProperty | Stores a single BYTE of data with an associated key name |
| MgByteReader | Reads data from a byte source. Once read, the data in the reader cannot be reread |
| MgByteSink | MgByteSink is a used to write the content of a MgByteReader object to a file. MgByteSink is, like MgByteReader, inherently read-only |
| MgByteSource | Represents a source of byte data with a specific content type |
| MgClassDefinition | Defines a feature class belonging to a schema |
| MgClassDefinitionCollection | ClassDefinitionCollection represents a collection of class definitions in a feature schema |
| MgClassNotFoundException | Thrown when attempting to create an invalid class |
| MgClobProperty | Stores CLOB (Character Large Object) data with an associated key name |
| MgCollection | MgCollection is an abstract class for defining standard collection access for all collection classes |
| MgColor | This class stores Alpha, Red, Green and Blue component of a Color |
| MgConfigurationException | Thrown when an error occurs in a configuration file, possibly due to invalid parameters or a missing file |
| MgConnectionFailedException | Thrown when a connection to a server cannot be established |
| MgConnectionNotOpenException | Thrown when attempting to execute a service method without a valid connection |
| MgCoordinate | MgCoordinate is an abstract base class used to represent the Cartesian coordinates of a geometry |
| MgCoordinateCollection | MgCoordinateCollection provides support for defining an ordered set of coordinates |
| MgCoordinateDimension | MgCoordinateDimension defines a set of integer constants which can be OR'd together to specify the dimensionality of an MgCoordinate instance |
| MgCoordinateIterator | The class MgCoordinateIterator supports iteration over the coordinates of a geometry or path instruction |
| MgCoordinateSpace | Specifies the coordinate space for feature geometry returned from QueryFeatures. Can also specify that only non-geometric data should be returned by QueryFeature |
| MgCoordinateSystem | |
| MgCoordinateSystemCache | |
| MgCoordinateSystemCatalog | Defines and manages the physical location of coordinate system data files |
| MgCoordinateSystemCategory | Defines a category of coordinate systems |
| MgCoordinateSystemCategoryDictionary | Basic functionality for the coordinate system category dictionary |
| MgCoordinateSystemCodeFormat | Defines constants used to indicate the WKT flavor |
| MgCoordinateSystemComputationFailedException | Thrown when a coordinate system computation fails |
| MgCoordinateSystemConversionFailedException | Thrown when a coordinate system conversion fails |
| MgCoordinateSystemDatum | |
| MgCoordinateSystemDatumDictionary | Basic functionality for the datum dictionary |
| MgCoordinateSystemDictionary | Basic functionality for the coordinate system dictionary |
| MgCoordinateSystemDictionaryBase | Basic functionality for all kinds of dictionaries |
| MgCoordinateSystemDictionaryUtility | Basic functionality for all kinds of dictionaries |
| MgCoordinateSystemEllipsoid | Defines a coordinate system ellipsoid |
| MgCoordinateSystemEllipsoidDictionary | Basic functionality for the ellipsoid dictionary |
| MgCoordinateSystemEnum | |
| MgCoordinateSystemEnumInteger32 | |
| MgCoordinateSystemErrorCode | Defines various error codes returned by the Coordinate System API |
| MgCoordinateSystemFactory | Supports the creation of MgCoordinateSystem objects based on a OpenGIS Well-Known Text (WKT) definition of the coordinate system. This class is the main entry point for accessing assorted classes and functionalities of the Coordinate System API |
| MgCoordinateSystemFilter | |
| MgCoordinateSystemFilterInteger32 | |
| MgCoordinateSystemFormatConverter | |
| MgCoordinateSystemGeodeticAnalyticalTransformationMethod | This class defines the currently supported transformation methods for analytical geodetic transformations as they can be read via the MgCoordinateSystemGeodeticTransformDefDictionary. That is, the constants defined below are only valid for MgCoordinateSystemGeodeticTransformDef instances of type MgCoordinateSystemGeodeticTransformDefType.Analytical |
| MgCoordinateSystemGeodeticAnalyticalTransformDefParams | This class holds all parameters that are specific to analytical geodetic transformation methods, e.g. geocentric transformation, molodensky etc |
| MgCoordinateSystemGeodeticDirection | This class contains the constants for all current transformation definition types |
| MgCoordinateSystemGeodeticInterpolationTransformDefParams | This class holds all parameters that are specific to grid-file based transformation. That is, where the actual datum shift value for a coordinate is determined by interpolating between grid point values as defined in the respective grid file(s) |
| MgCoordinateSystemGeodeticMultipleRegressionTransformationMethod | This class defines the currently supported transformation methods for multiple regression geodetic transformations as they can be read via the MgCoordinateSystemGeodeticTransformDefDictionary. That is, the constants defined below are only valid for MgCoordinateSystemGeodeticTransformDef instances of type MgCoordinateSystemGeodeticTransformDefType.MultipleRegression |
| MgCoordinateSystemGeodeticMultipleRegressionTransformDefParams | This class holds all parameters that are specific to the multiple regression transformation method |
| MgCoordinateSystemGeodeticPath | A geodetic (transformation) path allows to concatenate multiple geodetic transformations. For example, converting between 2 datums cannot be achieved by doing 1 datum shift only but requires to do 1 or more datums shifts in between |
| MgCoordinateSystemGeodeticPathDictionary | The MgCoordinateSystemGeodeticPathDictionary provides access to all geodetic transformation path definitions as defined in the dictionary file this instance reads from / writes to |
| MgCoordinateSystemGeodeticPathElement | A geodetic transformation path element describes a single transformation step within a series of concatenated steps that eventually form a geodetic (transformation) path |
| MgCoordinateSystemGeodeticStandaloneTransformationMethod | This class defines all transformation methods that are built into the transformation engine. That is, when creating such a geodetic transformation the API client cannot specify any parameters because they are well known and are available to the engine already. The constants defined below are only valid for MgCoordinateSystemGeodeticTransformDef instances of type MgCoordinateSystemGeodeticTransformDefType.Standalone |
| MgCoordinateSystemGeodeticStandaloneTransformDefParams | This class (indirectly) describes the parameters of a geodetic transformation method that's built into the transformation engine. Hence, it does not allow for setting any parameters. Only the well known code can be set/get via (Set/Get)TransformationMethod |
| MgCoordinateSystemGeodeticTransformation | An instance of this class allow a caller do perform a geodetic transformation (datum shift). That is, this class does not operate on coordinate system level, but rather on datum level |
| MgCoordinateSystemGeodeticTransformationMethod | Defines the type of a geodetic transformation method |
| MgCoordinateSystemGeodeticTransformDef | An instance of this class describes a geodetic transformation with all its parameters as it is defined in the dictionary file. The actual transformation operation is performed by the MgCoordinateSystemGeodeticTransformation objects that's being returned by the CreateTransformation method |
| MgCoordinateSystemGeodeticTransformDefDictionary | The MgCoordinateSystemGeodeticTransformDefDictionary provides access to all geodetic transformation definitions as defined in the dictionary file this instance reads from / writes to |
| MgCoordinateSystemGeodeticTransformDefParams | Common base class for all geodetic transformation parameters |
| MgCoordinateSystemGeodeticTransformDefType | This class contains the constants for all current transformation definition types |
| MgCoordinateSystemGeodeticTransformGridFile | The MgCoordinateSystemGeodeticInterpolationTransformDefParams parameter class requires instances of MgCoordinateSystemGeodeticTransformGridFile to be set via its SetGridFiles method. An MgCoordinateSystemGeodeticTransformGridFile object simply describes the grid file rather than containing the (grid file) information itself |
| MgCoordinateSystemGeodeticTransformGridFileFormat | This class contains the constants for all currently supported grid file formats |
| MgCoordinateSystemGridBase | Abstract base class for all grid generation objects (generic and specialized) |
| MgCoordinateSystemGridBoundary | This object is used to maintain the definition of the boundary of a specific grid or graticule. Externally, a MgCoordinateSystemGridBoundary object will be in viewport coordinates. Internally, objects of this type are often used to the carry grid boundaries in grid coordinates, and also greographic coordinates |
| MgCoordinateSystemGridGeneric | Generic grid generation object |
| MgCoordinateSystemGridLine | An MgCoordinateSystemGridLine object is a grid value (as a double) and a collection of line strings, where each individual line string being considered a grid line segment. All line strings in the collection are in the viewport coordinate system. The value returned by GetGridOrientation indicates the nature of the grid line in grid coordinates (i.e. easting or northing) |
| MgCoordinateSystemGridLineCollection | |
| MgCoordinateSystemGridOrientation | An enumeration of the supported values for the m_Orientation member of several objects related to grids and graticules |
| MgCoordinateSystemGridRegion | An MgCoordinateSystemGridRegion object consists of a label and a polygon. The polygon is always in the viewport coordinate system. Such an object is used, for example, to label and delineate an MGRS 100Km UTM grid zone |
| MgCoordinateSystemGridRegionCollection | |
| MgCoordinateSystemGridSpecializationType | An enumeration of the various types of specialized grids/graticules currently supported. A specialized grid is one for which specific standards exist to which the results of this feature are compliant with. A generic grid is a simple non-standardized grid of a coordinate system drawn in a viewport based on another coordinate system |
| MgCoordinateSystemGridSpecification | MgCoordinateSystemGridSpecification is an object that is used to convey all the parameters necessary for the generation of a grid/graticule lumped into a single object for convenience. Thus, adding a parameter determined to be necessary at a later time does not alter a lot of calling sequences |
| MgCoordinateSystemGridTick | |
| MgCoordinateSystemGridTickCollection | |
| MgCoordinateSystemInitializationFailedException | The exception is thrown when the coordinate system initialization fails |
| MgCoordinateSystemLoadFailedException | The exception is thrown when the coordinate system load fails |
| MgCoordinateSystemMathComparator | A mathematical comparator used to detemerine equality between two different coordinate systems, datums or ellipsoids |
| MgCoordinateSystemMeasure | Provides operations for measuring the distance between 2 coordinates and the azimuth of 2 coordinates as well as calculating a coordinate position given an initial coordinate, an azimuth, and a distance |
| MgCoordinateSystemMeasureFailedException | Thrown when a coordinate system measurement fails |
| MgCoordinateSystemMgrs | This object carries most, if not all, intelligence specific to the MGRS (Military Grid Reference System) grid standard. It can be used at two distinct levels, depending upon how it is manufactured |
| MgCoordinateSystemMgrsGridLevel | Defines constants used to indicate the MGRS grid level |
| MgCoordinateSystemMgrsGridSquarePosition | MgCoordinateSystemMgrsGridSquarePosition defines enumerated values used to specify the the location desired relative to the subject MGRS grid sqaure when evaluating an MGRS string |
| MgCoordinateSystemMgrsLetteringScheme | Defines constants used to indicate the MGRS lettering scheme |
| MgCoordinateSystemProjectionCode | Defines coordinate system projection codes |
| MgCoordinateSystemProjectionFormatType | Defines the type of projection format |
| MgCoordinateSystemProjectionInformation | Represents information about a coordinate system projection |
| MgCoordinateSystemProjectionLogicalType | Defines the logical types of a coordinate system projection |
| MgCoordinateSystemProjectionParameterType | Defines the types of coordinate system projection parameters |
| MgCoordinateSystemTransform | Provides operations for transforming coordinates from one coordinate system to another |
| MgCoordinateSystemTransformFailedException | Thrown when a coordinate system transform fails |
| MgCoordinateSystemType | Defines constants used to indicate the type of a coordinate system |
| MgCoordinateSystemUnitCode | Defines the various coordinate system unit codes |
| MgCoordinateSystemUnitInformation | Represents information about a coordinate system unit |
| MgCoordinateSystemUnitType | Defines the types of coordinate system units |
| MgCoordinateSystemWktFlavor | Defines constants used to indicate the WKT flavor |
| MgCoordinateXY | MgCoordinateXY is a concrete class derived from the abstract class MgCoordinate |
| MgCoordinateXYM | MgCoordinateXYM is a concrete class derived from the abstract class MgCoordinate |
| MgCoordinateXYZ | MgCoordinateXYZ is a concrete class derived from the abstract class MgCoordinate |
| MgCoordinateXYZM | MgCoordinateXYZM is a concrete class derived from the abstract class MgCoordinate |
| MgCurve | MgCurve is an abstract base class. MgCurveString and MgLineString are concrete classes derived from MgCurve |
| MgCurvePolygon | An MgCurvePolygon is a region, defined by 1 exterior boundary and 0 or more interior boundaries |
| MgCurvePolygonCollection | MgCurvePolygonCollection provides support for defining an ordered set of curve polygons |
| MgCurveRing | MgCurveRing is a geometry component used in the construction of MgCurvePolygon objects |
| MgCurveRingCollection | MgCurveRingCollection provides support for defining an ordered set of curve rings |
| MgCurveSegment | MgCurveSegment is an abstract base class |
| MgCurveSegmentCollection | MgCurveSegmentCollection provides support for defining an ordered set of curve segments |
| MgCurveString | An MgCurveString is composed of one or more curve segments |
| MgCurveStringCollection | MgCurveStringCollection provides support for defining an ordered set of curve strings |
| MgDataPropertyDefinition | Defines a data property belonging to a feature class |
| MgDataReader | Provides a forward-only, read-only iterator for reading computed data retrieved from a datastore |
| MgDateTime | MgDateTime is used to store dates, times, or both |
| MgDateTimeException | Thrown when an error occurs in a date/time routine |
| MgDateTimeProperty | Stores MgDateTime data with an associated key name |
| MgDbException | Thrown when Berkeley DB encounters an error |
| MgDbXmlException | Thrown when Berkeley DB XML encounters an error |
| MgDecryptionException | Thrown when a decryption error occurs |
| MgDeleteFeatures | A feature command that features from a datastore. The feature class name and filter text define feature(s) to delete. This class is added to an MgFeatureCommandCollection object, which is then passed in a call to the MgFeatureService::UpdateFeatures method |
| MgDirectoryNotFoundException | Thrown when a directory cannot be found |
| MgDisposable | |
| MgDivideByZeroException | Thrown when there is an attempt to divide an integral or decimal value by zero |
| MgDomainException | Thrown when a value is used outside of its domain of definition |
| MgDoubleProperty | Stores double precision floating point data with an associated key name. An instance of this class can be stored in an MgPropertyCollection object. The key name can be used to retrieve the instance from the property collection |
| MgDrawingService | Allows low level access to DWF™ (Design Web Format™) data stored in a resource repository as part of a drawing source |
| MgDuplicateDirectoryException | Thrown when attempting to create a directory that already exists |
| MgDuplicateFileException | Thrown when attempting to create a file that already exists |
| MgDuplicateGroupException | Thrown when attempting to add a user group that already exists |
| MgDuplicateNameException | Thrown when a duplicate object name is encountered during an add/insert operation in a collection |
| MgDuplicateObjectException | Thrown when a duplicate object is found |
| MgDuplicateParameterException | Thrown when a duplicate parameter is found |
| MgDuplicateRepositoryException | Thrown when a duplicate repository name is found during a create or update operation |
| MgDuplicateResourceDataException | Thrown when duplicate resource data is found during a set operation |
| MgDuplicateResourceException | Thrown when a duplicate resource name is found during an add or update operation |
| MgDuplicateRoleException | Thrown when a duplicate role is found |
| MgDuplicateServerException | Thrown when a duplicate server is found |
| MgDuplicateSessionException | Thrown when a duplicate session is found |
| MgDuplicateUserException | Thrown when attempting to add a user ID that already exists |
| MgDwfException | Wrapper for DWF toolkit exceptions |
| MgDwfSectionNotFoundException | Thrown when a DWF section is not found |
| MgDwfSectionResourceNotFoundException | Thrown when a DWF section resource is not found |
| MgDwfVersion | Specifies the DWF schema and file version for all Mapping Service operations |
| MgEmptyFeatureSetException | Thrown when an empty feature set is found |
| MgEncryptionException | Thrown when an encryption error is encountered |
| MgEndOfStreamException | Thrown when attempting to read past the end of a stream |
| MgEnvelope | MgEnvelope represents a bounding box defined in terms of a lower left coordinate and an upper right coordinate |
| MgEvaluationExpiredException | Thrown when an evaluation has expired |
| MgException | Base class for exceptions |
| MgFdoException | Thrown when FDO encounters an error |
| MgFeatureAggregateOptions | Use this class to set the filter criteria used to select groups of features from a datastore or for restricting the values returned to be unique |
| MgFeatureCommand | Is the abstract base class for feature command classes: MgDeleteFeatures, MgInsertFeatures, and MgUpdateFeatures |
| MgFeatureCommandCollection | Represents a collection of feature commands |
| MgFeatureCommandType | Is a set of constants used to specify the type of an MgFeatureCommand object |
| MgFeatureGeometricType | Is a set of constants specifying the dimensions of geometries which can be stored in a geometry property |
| MgFeatureInformation | Information about features |
| MgFeatureProperty | Stores MgFeatureReader data with an associated key name |
| MgFeaturePropertyType | Defines names for the different types of property definitions. See MgPropertyDefinition::GetPropertyType |
| MgFeatureQueryOptions | Use this class to set filter criteria for selecting features from a datastore. Read the discussion of filters and expressions . An instance of this class is an argument to MgFeatureService::SelectFeatures(). This is the base class for MgFeatureAggregateOptions |
| MgFeatureReader | Provides a forward-only, read-only iterator for reading features selected from the FDO Provider by the MgFeatureService::SelectFeatures() method call |
| MgFeatureSchema | Contains one or more feature class definitions, which specify the structure of feature data in a datastore |
| MgFeatureSchemaCollection | FeatureSchemaCollection represents a collection of feature schemas |
| MgFeatureService | Provides an abstraction layer for the storage and retrieval of feature data in a technology-independent way. The API lets you determine what storage technologies are available and what capabilities they have. Access to the storage technology is modeled as a connection. For example, you can connect to a file and do simple insertions or connect to a relational database and do transaction-based operations |
| MgFeatureServiceException | Thrown when FeatureService encounters a problem |
| MgFeatureSourceParams | Is a virtual base class for feature source parameters used with MgFeatureSource::CreateFeatureSource. This class cannot be instantiated directly |
| MgFeatureSpatialOperations | Is a set of constants used to type spatial operations |
| MgFileFeatureSourceParams | Contains the parameters used to create a file-based feature source |
| MgFileIoException | Thrown when a file I/O error occurs |
| MgFileNotFoundException | Thrown when attempting to access a file that cannot be found |
| MgGeometricDimension | MgGeometricDimension defines enumerated values used to specify the dimension of a geometry |
| MgGeometricEntity | MgGeometricEntity is an abstract base class that is the root of all geometry and geometry component classes |
| MgGeometricPropertyDefinition | Defines a geometric property belonging to a feature class |
| MgGeometry | MgGeometry is an abstract base class for all of the geometry types |
| MgGeometryCollection | MgGeometryCollection provides support for defining an ordered set of geometry objects |
| MgGeometryComponent | MgGeometryComponent is the base class for all of the geometry component types, namely, MgArcSegment, MgCurveRing, MgLinearRing, and MgLinearSegment |
| MgGeometryComponentType | MgGeometryComponentType defines a set of integer constants used to signify the type of a geometry component instance |
| MgGeometryException | Thrown when an error occurs calculating geometry |
| MgGeometryFactory | Used to construct objects whose classes are derived from MgGeometry |
| MgGeometryProperty | Stores MgByteReader data with an associated key name |
| MgGeometryType | MgGeometryType defines integer constants used to signify the derived type of an MgGeometry instance |
| MgGeometryTypeInfo | Defines a list of geometric types. This is typically used for geometric property description |
| MgGridDensityException | Thrown when an error occurs in a date/time routine |
| MgGroupNotFoundException | Thrown when a specified group cannot be found |
| MgGuardDisposable | |
| MgImageFormats | Image formats supported by the rendering service |
| MgIndexOutOfRangeException | Thrown when attempting to access an element of an array with an index that is outside the bounds of the array |
| MgInsertFeatures | Creates an insert feature data command. You must add this command to an MgFeatureCommandCollection object and pass the latter in a call to MgFeatureService::UpdateFeatures |
| MgInt16Property | Stores Int16 data with an associated key name |
| MgInt32Property | Stores Int32 data with an associated key name |
| MgInt64Property | Stores Int64 data with an associated key name |
| MgIntCollection | This class represents a collection of integers. The integers are owned and managed by the collection |
| MgInvalidArgumentException | Thrown when a method is called with an invalid argument |
| MgInvalidCastException | Thrown when attempting an invalid type cast or explicit conversion |
| MgInvalidCoordinateSystemException | Thrown when the Coordinate System API encounters a problem |
| MgInvalidCoordinateSystemTypeException | Thrown when the coordinate system type is invalid |
| MgInvalidCoordinateSystemUnitsException | Thrown when the coordinate system units are invalid |
| MgInvalidDwfPackageException | Thrown when a DWF package is not valid |
| MgInvalidDwfSectionException | Thrown when an invalid section in a DWF is found |
| MgInvalidFeatureSourceException | Thrown when FeatureService encounters a problem |
| MgInvalidIpAddressException | Thrown when an IP address is invalid |
| MgInvalidLayerDefinitionException | Thrown when a layer definition resource is invalid |
| MgInvalidLicenseException | Thrown when an invalid license is detected |
| MgInvalidLogEntryException | Thrown when a log entry does not correspond with the expected format |
| MgInvalidMapDefinitionException | Thrown when a map definition resource is invalid |
| MgInvalidMimeTypeException | Thrown when an invalid mime type is detected |
| MgInvalidOperationException | Thrown when a method call is invalid for the object's current state |
| MgInvalidOperationVersionException | Thrown when a version is invalid for the given operation |
| MgInvalidPasswordException | Thrown when a password is rejected because it does not match its corresponding user credentials or it is invalid for some other reason |
| MgInvalidPrintLayoutFontSizeUnitsException | Thrown when the font size units in a PrintLayout resource document are not valid |
| MgInvalidPrintLayoutPositionUnitsException | Thrown when the position units in a PrintLayout resource document are not valid |
| MgInvalidPrintLayoutSizeUnitsException | Thrown when the size units in a PrintLayout resource document are not valid |
| MgInvalidPropertyTypeException | Thrown when an invalid property type is used |
| MgInvalidRepositoryNameException | Thrown when a repository name is invalid |
| MgInvalidRepositoryTypeException | Thrown when a repository type is invalid |
| MgInvalidResourceDataNameException | Thrown when a resource data name is invalid |
| MgInvalidResourceDataTypeException | Thrown when a resource data type is invalid |
| MgInvalidResourceNameException | Thrown when a resource name is invalid |
| MgInvalidResourcePathException | Thrown when a resource path is invalid |
| MgInvalidResourcePreProcessingTypeException | Thrown when a resource pre-processing type is invalid |
| MgInvalidResourceTypeException | Thrown when a resource type is invalid |
| MgInvalidSerialNumberException | Thrown when an evaluation has expired |
| MgInvalidServerNameException | Thrown when a server name is invalid |
| MgInvalidStreamHeaderException | Thrown when a stream header is invalid |
| MgInvalidSymbolDefinitionException | Thrown when a symbol definition resource is invalid |
| MgInvalidWatermarkDefinitionException | Thrown when a watermark definition resource is invalid |
| MgIoException | Thrown when an I/O error occurs |
| MgKmlService | This class provides services to retrieve KML documents |
| MgLayer | Gets and sets properties of a layer |
| MgLayerBase | Gets and sets properties of a layer |
| MgLayerCollection | Manipulates collections of MgLayerBase objects |
| MgLayerGroup | Manipulates the properties of a layer group |
| MgLayerGroupCollection | Manipulates collections of MgLayerGroup objects |
| MgLayerGroupType | MgLayerGroupType defines integer constants used to identify the type of a layer group |
| MgLayerNotFoundException | Thrown when a requested layer cannot be found or does not exist |
| MgLayerType | MgLayerType defines integer constants used to identify the type of a layer |
| MgLayout | Specifies the ResourceId of the PrintLayout to use for a particular map, the title and the type of units to use in the layout |
| MgLengthException | Thrown when a length of some item does not match the expected length |
| MgLicenseException | Thrown when MapGuide has an invalid license |
| MgLicenseExpiredException | Thrown when a license has expired |
| MgLinearRing | An MgLinearRing is a geometry component |
| MgLinearRingCollection | MgLinearRingCollection provides support for defining an ordered set of linear rings |
| MgLinearSegment | MgLinearSegment is a geometry component used in the construction of MgCurveString geometries and MgCurveRing geometry components |
| MgLineString | An MgLineString is a curve with linear interpolation between points |
| MgLineStringCollection | MgLineStringCollection provides support for defining an ordered set of line strings |
| MgLockFeatures | Creates an insert feature data command. You must add this command to an MgFeatureCommandCollection object and pass the latter in a call to MgFeatureService::UpdateFeatures |
| MgLogicException | Thrown to report errors presumably detectable before the program executes, such as violations of logical preconditions |
| MgLogOpenFailedException | Thrown when a log file could not be opened |
| MgLongTransactionReader | Provides forward-only, read-only functionality for describing a set of long transactions that exist in the feature source |
| MgMap | Defines the runtime state of a map |
| MgMapBase | Defines the runtime state of a map |
| MgMapCollection | Manipulates collections of MgMapBase objects |
| MgMappingService | Performs map related operations such as getting an eMap DWF representing a map or updates to a map, or querying features from maps or layers of a map |
| MgMapPlot | Allows the developer to specify the map, the view of the map, the plot specification, and the layout for one sheet within a call to GenerateMultiPlot |
| MgMapPlotCollection | Manipulates collections of MgMapPlot objects |
| MgMapPlotInstruction | MgMapPlotInstruction defines enumerated values used to indicate whether the plot should be based on the center and scale of the map, an overridden center and scale, or an overridden extent |
| MgMeasure | MgMeasure is an abstract class that can be implemented to provide non-linear measurement for geometry operations |
| MgMimeType | Mime types for data to be sent to clients |
| MgMultiCurvePolygon | An MgMultiCurvePolygon is a two-dimensional aggregate geometry whose elements are MgCurvePolygon geometries |
| MgMultiCurveString | An MgMultiCurveString is a one-dimensional aggregate geometry whose elements are MgCurveString geometries |
| MgMultiGeometry | An MgMultiGeometry is a heterogeneous aggregate of one or more MgGeometry objects |
| MgMultiLineString | An MgMultiLineString is a one-dimensional aggregate geometry whose elements are MgLineString geometries |
| MgMultiPoint | An MgMultiPoint is a 0 dimensional aggregate geometry whose elements are MgPoint geometries |
| MgMultiPolygon | An MgMultiPolygon is a two-dimensional aggregate geometry whose elements are MgPolygon geometries |
| MgNamedSerializable | |
| MgNotFiniteNumberException | Thrown when a floating-point value is positive infinity, negative infinity, or Not-a-Number (NaN) |
| MgNotImplementedException | Thrown when an operation that has not been implemented yet is invoked |
| MgNullableProperty | This is the base class for all properties which can have NULL values. If a property value is NULL, there is no value, and a call to the GetValue() method throws an exception |
| MgNullArgumentException | Thrown when a null argument is passed to a method that expects a non-null value |
| MgNullPropertyValueException | Thrown when a property value is null |
| MgNullReferenceException | Thrown when there is an attempt to dereference a null object reference |
| MgObject | |
| MgObjectNotFoundException | Thrown when attempting to access an object that cannot be found |
| MgObjectPropertyDefinition | Defines a feature property which contains one or more objects whose type is a feature class. If there is more than one object, an identity property is defined that is used to select an object from the collection |
| MgObjectPropertyType | Defines the type of an MgObjectPropertionDefinition object property, that is, whether the property contains a single feature class object, or an unordered or ordered collection of them |
| MgOperationProcessingException | Thrown when the server encounters a problem that prevents the processing of an operation |
| MgOrderingOption | Defines a type used to specify the order in which features are returned by MgFeatureService::SelectFeatures. This type is used as an argument to the MgFeatureQueryOptions::SetOrderingFilter |
| MgOutOfMemoryException | Thrown when required memory cannot be allocated |
| MgOutOfRangeException | Thrown when a parameter value passed to a method is not in the valid range specified by its documentation |
| MgOverflowException | Thrown when an arithmetic, casting, or conversion operation in a checked context results in an overflow |
| MgPageUnitsType | Defines page size units for the Mapping Service |
| MgParameter | Value for a particular parameter. Instances of this class are used to specify a value to bind to a parameter when a command is executed. Typically, it is used to bind parameters to the SQL command |
| MgParameterCollection | MgParameterCollection represents a collection of parameters. All parameters contained in an instance of a parameter collection are objects whose base class is MgParameter. A call to a parameter object's GetType() method returns one of the integer constants defined in class MgPropertyType. This collection does not allow duplicate key names |
| MgParameterDirection | The MgParameterDirection defines integer constants used to signify the direction in which a parameter value will be used within the context of a FDO Command |
| MgPathTooLongException | Thrown when a pathname is longer than the system-defined maximum length |
| MgPermissionDeniedException | Thrown when the system denies access because the user does not have read and/or write permission on a resource |
| MgPlatformNotSupportedException | Thrown when a feature does not run on a particular platform |
| MgPlotSpecification | Specifies the size and format of the ePlot sheet to be created by the Mapping Service operations |
| MgPoint | An MgPoint is a 0-dimensional geometry and represents a single location in coordinate space |
| MgPointCollection | MgPointCollection provides support for defining an ordered set of points |
| MgPolygon | An MgPolygon is a region, defined by 1 exterior boundary and 0 or more interior boundaries |
| MgPolygonCollection | MgPolygonCollection provides support for defining an ordered set of polygons |
| MgPortNotAvailableException | Thrown when the server is not online |
| MgPrintToScaleModeNotSelectedException | Thrown when attempting to retrieve the plot scale, but the PlotMode_PrintToScale mode is not selected |
| MgProfilingService | This class provides services to profile exsiting MapGuide APIs |
| MgProperty | A base class for MgNullableProperty, which is the base class for all of the concrete property classes, for example, MgBooleanProperty and a base class for MgPropertyDefinition, which is the base class for all of the concrete property definition classes, for example, MgDataPropertyDefinition |
| MgPropertyCollection | MgPropertyCollection represents a collection of properties. All properties contained in an instance of a property collection are objects whose base class is MgProperty and whose derived class is one of the classes referenced in the topic Feature Properties . A call to a property object's GetPropertyType() method returns one of the integer constants defined in class MgPropertyType. This collection does not allow duplicate key names |
| MgPropertyDefinition | Defines the base class for the concrete property definition classes which are used to create data, geometric, object, and raster property definitions |
| MgPropertyDefinitionCollection | This class contains property definitions for a feature class and makes up a portion of the complete feature class definition |
| MgPropertyType | Defines the names for the various property types |
| MgRasterDataModelType | Enumerated values used to determine the type of units for plot decorations (scale bar) |
| MgRasterProperty | Stores MgRaster data with an associated key name |
| MgRasterPropertyDefinition | Defines a feature property which contains a raster image |
| MgRasterTransformationNotSupportedException | Thrown when a raster image from a layer is using a different coordinate system than the map |
| MgReader | Provides a forward-only, read-only iterator for reading data. You must call ReadNext before you can access any data. This is a base class for MgDataReader, MgFeatureReader, and MgSqlDataReader |
| MgReaderType | Type of reader represented by an MgReader |
| MgReadOnlyLayerCollection | Provides read only access to a collection of MgLayerBase objects |
| MgRegion | MgRegion is an abstract base class The concrete classes are MgPolygon and MgCurvePolygon |
| MgRenderingOptions | Options for Rendering Service |
| MgRenderingService | This class provides services to render a map into an image |
| MgRepositoryCreationFailedException | Thrown when creation of a repository fails |
| MgRepositoryNotFoundException | Thrown when a requested repository is not found |
| MgRepositoryNotOpenException | Thrown when a requested repository is not open |
| MgRepositoryOpenFailedException | Thrown when a repository database cannot be opened |
| MgRepositoryType | Defines names for the different types of repositories |
| MgResource | The abstract base class for all resource types |
| MgResourceBusyException | Thrown when a requested resource is busy |
| MgResourceDataName | Defines reserved names for resource data |
| MgResourceDataNotFoundException | Thrown when requested resource data is not found |
| MgResourceDataType | Defines the different types of resource data |
| MgResourceIdentifier | Creates and manipulates resource identifiers |
| MgResourceNotFoundException | Thrown when a requested resource is not found |
| MgResourcePermission | Types of resource permissions |
| MgResourceService | Enables you to manipulate repositories and resources |
| MgResourcesException | Thrown when an error occurs with the resources |
| MgResourcesLoadFailedException | Thrown when an error occurs loading resources |
| MgResourceTag | Substitution tags used within the XML file for a resource |
| MgResourceTagNotFoundException | Thrown when a resource tag is not found |
| MgResourceType | Defines names for the different types of resources |
| MgResourceUnmanagedDataType | Types of unmanaged data that can be returned |
| MgRing | |
| MgRoleNotFoundException | Thrown when a specified role cannot be found |
| MgRuntimeException | Thrown when an internal runtime error occurs |
| MgSelection | |
| MgSelectionBase | |
| MgSerializable | |
| MgServerNotFoundException | Thrown when a server cannot be found |
| MgServerNotOnlineException | Thrown when a server is not online |
| MgService | Class Service Base class for all services APIs |
| MgServiceNotAvailableException | Thrown when an invoked service is not available yet |
| MgServiceNotSupportedException | Thrown when an invoked service is not supported |
| MgServiceType | Service types for Platform services |
| MgSessionExpiredException | Thrown when a session has expired |
| MgSessionNotFoundException | Thrown when a session could not be found |
| MgSingleProperty | Stores single precision floating point data with an associated key name |
| MgSite | The Site Service contains one class, MgSite |
| MgSiteConnection | |
| MgSiteInfo | |
| MgSiteManager | |
| MgSpatialContextExtentType | The SpatialContextExtentType enumeration defines how the extent of a context should be handled by the provider |
| MgSpatialContextReader | Provides forward-only, read-only functionality for enumerating spatial context information retrieved from a feature source |
| MgSqlDataReader | Provides a forward-only, read-only iterator for reading data returned by a call to MgFeatureService::ExecuteSqlQuery |
| MgSqlResult | The SqlReader interface provides a forward-only, read-only iterator for reading relational table data. The initial position of the SqlReader interface is prior to the first item. Thus, you must call ReadNext to begin accessing any data. |
| MgStreamIoException | Thrown when low-level stream I/O problems occur during communication between server and web-tier |
| MgStringCollection | This class represents a collection of strings. The collection maintains its own copy of strings |
| MgStringProperty | Stores string data with an associated key name |
| MgStylizeLayerFailedException | Thrown when a stylize layer fails |
| MgSystemException | Base class for all exceptions representing a system error |
| MgTemporaryFileNotAvailableException | Thrown when a temporary file is not available |
| MgThirdPartyException | Base class for third party exceptions |
| MgTileService | This class provides services to render a map into an image |
| MgTransaction | MgTransaction represents a transaction to be performed in a DataStore. If the transaction is time out, commit or rollback a transaction will result in one exception MgFeatureServiceException thrown |
| MgTransform | MgTransform is an abstract class that can be implemented to provide linear or projected coordinate transformations. There are currently no concrete classes |
| MgUnauthorizedAccessException | Thrown when the system denies access because of an I/O error or a specific type of security error |
| MgUnclassifiedException | Thrown when the server or web-tier does not know the cause of the actual problem |
| MgUnderflowException | Thrown when an arithmetic underflow occurs |
| MgUnitType | MgUnitType defines enumerated values used to determine the type of units for plot decorations (scale bar) |
| MgUnknownTileProviderException | Thrown when a tile set definition contains an unknown tile provider |
| MgUnlockFeatures | Creates an unlock feature command. You must add this command to an MgFeatureCommandCollection object and pass the latter in a call to MgFeatureService::UpdateFeatures |
| MgUnsupportedProviderThreadModelException | Thrown when the server does not support the FDO provider thread model |
| MgUnsupportedTileProviderException | Thrown when a new MgMap is created from a Map Definition that references a Tile Set Definition that uses an unsupported tile provider |
| MgUpdateFeatures | Creates an update feature data command. You must add this command to an MgFeatureCommandCollection object and pass the latter in a call to MgFeatureService::UpdateFeatures |
| MgUriFormatException | Thrown when an invalid Uniform Resource Identifier (URI) is detected |
| MgUserInformation | This class manages user information |
| MgUserNotFoundException | Thrown when a user is not found |
| MgWarnings | Exposes non-critical warning messages from services |
| MgWebActions | Enumeration of all the possible actions that can be executed from the viewer |
| MgWebBufferCommand | |
| MgWebCommand | |
| MgWebCommandCollection | |
| MgWebCommandWidget | |
| MgWebContextMenu | |
| MgWebFlyoutWidget | |
| MgWebGetPrintablePageCommand | |
| MgWebHelpCommand | |
| MgWebInformationPane | |
| MgWebInvokeScriptCommand | |
| MgWebInvokeUrlCommand | |
| MgWebLayout | |
| MgWebMeasureCommand | |
| MgWebPrintCommand | |
| MgWebSearchCommand | |
| MgWebSelectWithinCommand | |
| MgWebSeparatorWidget | |
| MgWebTargetType | Types of UI target for a command |
| MgWebTargetViewerType | Types of target viewer |
| MgWebTaskBar | |
| MgWebTaskBarWidget | |
| MgWebTaskButtonType | Types of task buttons |
| MgWebTaskPane | |
| MgWebToolBar | |
| MgWebUiPane | |
| MgWebUiSizablePane | |
| MgWebUiTargetCommand | |
| MgWebViewOptionsCommand | |
| MgWebWidget | |
| MgWebWidgetCollection | |
| MgWebWidgetType | Types of UI Widget |
| MgWktReaderWriter | Translates a string in AGF (Autodesk Geometry Format) Text format into an MgGeometry object and vice versa. See the AGF Text topic. |
| MgXmlException | Thrown when an error occurs while processing XML |
| MgXmlParserException | Wrapper for exceptions thrown from the Xerces XML parser |
1.8.0 
