Click or drag to resize

NetQuarry.Data Namespace


The NetQuarry Enterprise Application Platform (EAP) allows you to build and deploy n-tiered, enterprise quality applications. The EAP sits on the Microsoft .NET common language runtime and provides rich functionality at all layers of an application.

The NetQuarry EAP does not generate code, rather, it uses the NetQuarry Core Runtime, custom configuration, metadata, and developer coded extensions to construct world class, quality applications.

Data Sources

Business applications depend on data. Increasingly, this data comes from multiple data “sources” across the enterprise. These sources of data may exist in relational databases such as Oracle, Microsoft SQL Server, or IBM DB2. Some of the sources of data, however, exist as Web Services, XML documents, or remote procedure calls. NetQuarry makes aggregating disparate data into a single, functional user interface simple and fast.


Extensions are a key concept of the NetQuarry platform. Extensions are libraries that receive events from the running application objects. For example, when a record in a page is changed, the IMapper representing that data fires update events (notifications) through all of the extensions configured (via metadata) on that object.

This is a powerful programming pattern that is extremely simple for application developers, even those unfamiliar with Microsoft .NET to quickly grasp and master.

To create an extension, the developer can run a wizard from the Studio that allows them to specify the name, location, language (C#, VB.NET), and which objects they want to attach the extension.

Some objects support the idea of “global” extensions (e.g. Mapper-based objects). A global extension is automatically attached to all objects of a particular class. This is particularly useful for functionality such as auditing and summary information handling.

Extensions must implement a known interface (IExtension) or derive from a provided base class. The most common type of extension is the mapper extension which typically derives from MapperExtensionKernel or TypedMapperExtension). Most non-declarative business logic is implemented in mapper extensions. Most applications also include a small number of page extensions (derived from PageExtensionBase for handling wizard and console page events, and a single application extension (derived from ApplicationExtensionBase).

The following example shows an extension that handles a RowBeforeUpdate event on a Mapper.
using System;
using NetQuarry;        // Include the NetQuarry objects

namespace XCustomer
    public class XExt : MapperExtensionKernel
        public XExt() {}

           public override void RowBeforeUpdate(IMapper sender, NQEventArgs e)
            IField        fld = sender.Fields["forecast_discount_amount"];

            if (System.Convert.ToInt32(fld.Value) > 10)
                fld.Value = 10;

Handling business logic using this methodology is both simple and robust. Extensions can be reused across multiple objects, they can be debugged interactively using Visual Studio, and they hide the complexity of the infrastructure from the application developer allowing them to concentrate on the task of building business applications.


A Mapper (IMapper) is the primary means of mapping object-oriented programming objects to data sources managed by relational databases or other sources of data. A Mapper provides 2-way (Read and Write) access to the underlying Data Source.

There are several subclasses of the Mapper object. The most important are the MapperDatasheet and MapperDetail. Each provides an implementation that uses the data in the Mapper to render a view of the data using HTML.

Application (IAppContext)

The Application object holds information that is used throughout each page (or server) request. The Application is available to all objects, most importantly the extensions. The Application object is created as the first object in any request, and when possible it is cached for performance purposes.

The Application object handles connecting to the authentication provider, authenticating the user, checking object permissions for that user, storing user (UserContext) information, holding the list of available PageInfo objects, and connecting to the metadata (Repository) data source. It also has a collection of DataSources specified in metadata.

More than one Application object may be specified in metadata, and connecting to an application allows the user to see more than one “view” of an implemented NetQuarry application.

Pages and Templates

A Page is the smallest object that renders user interface. Some pages display data from a IMapper, while others allow the user to perform a quick search, quick creation of an object, or perform some sort of navigation.

A Template is a code-based layout of one or more areas (called Slots). Each slot in a template is specified using a Page property at design time.

Properties and TextItems

Many NetQuarry platform objects support a collection of custom Properties. Properties are fields of information that varies between objects and object instances. Most properties are loaded from the metadata when the object is created. A property that is loaded from metadata has an associated parameter object (a metadata only object) defined in the metadata. Properties can be added at runtime or design time. At design time, parameters form the definition for the NetQuarry studio’s property sheet.

TextItems are similar to properties but hold only strings. Additionally, each TextItem object is specific to a locale (or culture). At runtime, Textitems are loaded for the current user’s culture. If there is no string for the type of text for the current culture, the default culture is used. All strings used in the platform are represented as TextItems. This provides a simple way to support multiple user languages (cultures) on a single site, with a single codebase.

Properties and TextItems provide programmatic access to virtually all meta-data associated with an object.


The platform is proactively logging a rich set of data to help the developer diagnose problems during development and runtime. Additionally, the developer can use the built-in object called DevLog to add messages to the log.

Using Mappers

If you create a resource that has a connection to a database (IDatabase) object such as a Mapper, you must close the Mapper before exiting the procedure.


Generated TypedMapper derived classes are useful when manipulating a mapper and you would like to treat it more like a type-safe object. They are also useful as a base class for higher level business objects that you may require in your extensions. A TypedMapper has a Get and Set property for every field defined in the mapper. If you have fields with an include flavor you may need to add a Get and Set property in your derived class as the generator will not pickup these fields.

You typically use a TypedMapper in your extensions. You can create a TypedMapper and attach it to the sender (IMapper) of the event or you can use the TypedMapper derivative to create a new mapper - either for the purpose of creating a new row or reading/updating an existing one. Connecting a TypedMapper via one of the constructors or TypedMapper.Attach is very inexpensive and generally a safer way to work with a mapper. You should, however, use good judgement when creating a new instance of a TypedMapper as a query of the operational database is generally required.

Generating TypedMappers

To generate typed mappers you run the command line utility EAP.Tools.CodeGen.EXE installed in the <application root>/bin folder. The utility takes the following arguments (the first argument (-AppID) is required):

  1. -AppID:<appid> - the ID for your application.
  2. -CamelCase - (optional) include this to convert property names to a CamelCase representation. By default, property names are the same as the mapper field's key name
  3. -NullableNumerics - (optional) include this to declare the numeric field properties as Nullable. By default, numeric properties are defined as their value types and 0 (or false) is returned if the value is null.
  4. -NoNullStrings - (optional) include this to force string properties to return an empty string instead of null when the field value is null. By default, null values are returned as null strings.
You must create a config section in the EAP.Tools.CodeGen.exe.config with the options. Example:
    <section name="IssueTrak" type="System.Configuration.NameValueSectionHandler" />

 <!-- connection strings -->
 <add key="repository_connect" value="Provider=SQLOLEDB;Data Source=.;Initial Catalog=issues_meta;Integrated Security=SSPI" />    
 <add key="IssueTrak_connect" value="Provider=SQLOLEDB;Data Source=.;Initial Catalog=issues_data;Integrated Security=SSPI" />

 <!-- optional, normally set by the web application context -->
 <add key="RootPath" value="c:\inetpub\wwwroot" />
 <add key="RootURL" value="http://localhost" />

 <!-- full path to the file to be generated -->
 <add key="GeneratedFileName" value="C:\NetQuarry\IssueTrak\Source\Data\Generated\TypedMappers.cs" />
 <!-- namespace to use for the generated TypedMapper classes -->
 <add key="Namespace" value="IssueTrak.Data" />


EAP.Tools.CodeGen -AppID:%APP_KEY% -CamelCase -NoNullStrings

Public classBeforeRequeryArgs
The event args for the MapperBeforeRequery event.
When DataProvided is set the MapperBeforeRequery event is only fired when there's a cache miss or ForceMapperBeforeRequery is set.
Public classBuildFilterArgs
The event args for the FieldBuildFilter event.
Public classCheckList
A check list control for use as the control for Multiselect IField objects. This control presents a scrollable list of HTML checkboxes for client-side manipulation, but stores its value as a semi-colon separated list of values in a child TextBox control.
Public classChooser
A list-based selector control rendered as two side-by-side lists, one with unselected items and the other with selected items. The control is derived from a standard .Net ListBox and transformed to its Chooser presentation via jQuery. The original jQuery script was obtained from, source:, licensed source:
Public classCommandEventArgs
Event args for MapperCommands collection events.
Public classCreateControlArgs
The event args for the FieldCreateControl event. Typically the extension calls the SetCellType(CellTypes, Int32) method to dynamically specify the CellType for the field. When used in this manner the field object then perform normal control creation and configuration based on that CellTypes. The extension can instead, or also, set the BaseControl to provide a custom WebControl in which case it is the extension's responsibilty to create the control and provide initial configuration.

When determining what CellTypes and/or WebControl to use, the extension should heed the CreationFlags which provide the context for the control's use and, if a control is created by the extension, set that controls's value to the value provided by Value, if any.

See also FieldCreateControl(IField, CreateControlArgs).
Public classCSV
Utility class to create a DataTable from a comma separated values file.
Public classDataExportHelper
A class that can be used to help aid the non-mapper-command-specific items when it comes to the DataExport services.
Public classDataExportMapperHelper
A class added so that the actual act of adding + handling the Mapper portions of the Data Export services could be abstracted. This way, we can reuse the ExcelExport code without having to duplicate code.
Public classDuplicateRecordException
The exception that is thrown when an attempt is made to save a record that fails the duplicate check (per the field DupeCheck attribute).
Public classExecSQLArgs
The event args for the MapperExecSQL and RowExecSQL events. The SQL to be executed is included in the event args and can be modified by the receiving extension.
Public classExpressionParser Obsolete.
Helper class for working with field reference expressions. Note that this class is deprecated and use of NetQuarry.ExpressionParser is preferred.
Public classField
This is the standard implementation of the IField interface. For documentation purposes, you should generally refer to the IField documentation. Note that the Field implementation is a thin veneer on top of the FieldKernel class. At this time there are no other standard implementations of that interface.
Public classFieldAnomalyArgs
The event args for the FieldAnomaly event.
Public classFieldButtonClickArgs
The optional event args for the FieldButtonClick event. Currently this object is provided to the FieldButtonClick event only for AJAX button clicks. For other cases where the FieldButtonClick event is fired, EAPEventArgs is provided. See also FieldButtonClick(IField, EAPEventArgs).
Public classFieldConfirmArgs
Event args for the mapper FieldConfirm event.
Public classFieldInterfaceExtensions
Helper extension methods for the IField interface.
Public classFieldKernel
FieldKernel is an abstract class implementing the IField interface. This class implements virtually all the functionality required of an object implementing the IField interface and is the base class for the Field class, the standard field implementation. Fields are hosted in the IMapper.Fields collection and rarely used outside that context. That is, you will rarely instantiate a field object directly. Rather you will almost always obtain a field object from its mapper. For documentation purposes, you should generally refer to the IField documentation.
Protected classFieldKernelFilterDesc
Descriptor for a filter constructed by the field via GenFilterClause().
Protected classFieldKernelNavInfo
Describes an object that contains navigation information for a field link.
Public classFieldNotFound
Exception thrown when specified field is not found in the collection.
Public classFieldRefExprException
The exception that is thrown when a non-fatal field reference error occurs.
Public classCode exampleFields
Provides a collection for an IMapper.Fields collection of IField objects. The string index is the IField.Key and is treated case-insensitively.

Commonly used features of the collection are:

Public classFieldsMap
A collection used to map a set of IField.Key values each to a Fields collection.
Public classFilterException
The exception that is thrown when a non-fatal filter error occurs.
Public classFlavorsMap
Helper class for mapper custom flavor names from the Flavors enum to mapper-specific flavor names. Note that the ability to display custom flavor names is only used for debugging and is non-essential.
Public classGroupingInfo
Provides grouping information about a mapper. This object populated by the mapper in response to a GroupingInfo command.
Public classImmediateSave
Support utility code for ImmediateSave handling.
Public classInvalidFieldValue
Exception thrown when an IField validation test fails.
Public classInvalidMapperMovement
Exception thrown when an invalid mapper record movement is attempted.
Public classMapFieldSig
Helper class for managing a field reference. Used, with encryption, in immediate save AJAX calls.
Public classMapper
A Mapper is the primary means of mapping object-oriented programming objects to data sources managed by relational databases or other sources of data. A Mapper provides 2-way (Read and Write) access to the underlying Data Source. Several classes implement the IMapper interface:
  • Mapper - Basic mapper intended for programmatic use (with no UI).
  • MapperList - Basic list mapper intended for programmatic use (with no UI).
  • MapperDetail - Standard editable single-item detail UI mapper.
  • MapperDatasheet - Standard list UI mapper.
Public classMapperBuildFilterArgs
The event args for the MapperBuildFilter event.
Public classCode exampleMapperCommand
Describes a command added to a page by a Mapper extension.
Public classMapperCommands
A collection of MapperCommand commands attached to a mapper. Note that the primary index into the collection is the ID not the Command. Use Find(String, CommandFindType) to access the command by Command. Typically these commands are invoked by calling DoCommand(String, Int32, Object).
Public classMapperErrorContext
This class acts as a container for returning error information from certain mapper exec commands. Used with RecordCountSafe to return any error information.
Public classMapperExtensionBase
Abstract base class for mapper extensions. This class is provided primarily for internal use and custom application extensions should not normally derive from this class, but rather from MapperExtensionKernel for untyped extensions or TypedMapperExtensionT for typed extensions. As with all extensions and extension base classes, the class implements the IExtension interface and response to ExtensionEvents.
Public classMapperExtensionKernel
The base class for an IMapper extension used to handle mapper ExtensionEvents. Type-safe extension can be created using the TypedMapperExtensionT generic base class. As with all extensions and extension base classes, the class implements the IExtension interface and responds to ExtensionEvents. For each mapper event a virtual method is provided that your extension can override to handle the event. Note that all the base implementations are empty so there is never a need to call the base class method. That is, for example, your override of RowBeforeInsert(IMapper, EAPEventArgs) never needs to call this class's RowBeforeInsert(IMapper, EAPEventArgs). However, if you override the HandleEvent(ExtensionEvents, Object, EAPEventArgs) method you must call the base class method if you don't handle the event.

In addition to the dedicated mapper event virtual methods (e.g. RowCurrent(IMapper, EAPEventArgs)), there are virtual methods you can override for other events: Custom(Object, EAPCustomEventArgs) for custom events, and Other(Object, EAPEventArgs) for other, unexpected events.

The general sequence of events for rendering a mapper is:
The general sequence of events for saving a mapper is:
Public classMapperExtensions
Entensions for various classes to make them easier to use with a mapper.
Public classMapperFilter
A MapperFilter is a specification for filtering an IMapper query. In almost all cases a MapperFilter is a SQL filter clause (a WHERE clause without the keyword WHERE) stored in Clause. One exception to this is Full-Text Search filters (FTS) which have a null/empty Clause and store their filter information in FullTextSearchValue.

These filters are applied to a mapper in order to restrict the set of records obtained when the IMapper requeries. Individual filters are replaceable, updateable, and removeable. Typically each filter provides a different type of functionality such as security (ForSecurity), user filtering (ForUser) and often with separate filters for each field criterium.

Public classMapperFilters
A collection of MapperFilter objects. MapperFilter objects are used to filter an IMapper in order to restrict the rows queried by the mapper. Filters managed in the Studio are stored in the xot_filters table. Filters for a particular mapper object are stored in its Filters collection, the only real use of this collection object.
Public classMapperKernel

A Mapper is the primary means of mapping object-oriented programming objects to data sources managed by relational databases or other sources of data. A Mapper provides 2-way (Read and Write) access to the underlying Data Source.

MapperKernel is the base class used by all types of mappers.

Public classMapperList
This is a basic list mapper having no UI of its own.
Public classMapperPurposes
Constants for use with Purpose. Although Purpose is freeform and may contain application-specific values, this class of contants provides the set of standard values. Note that in many cases Purpose is not set.
Public classMapperUtils
Utility class used by both MapperDetail and MapperDatasheet.
Public classMaxLengthExceededException
Exception thrown when a mapper save is attempted and one or more fields have values exceeding the field's MaxLength property.
Public classMissingMapper
Exception thrown when specified mapper definition is not found.
Public classMissingRequiredFields
Exception thrown when one or more required fields aren't populated.
Public classOptimisticLockCollision
Exception thrown when optimistic locking is specified and an update is attempted on an row that has changed since originally queried.
Public classOrderingList
A list control for IField objects allowing a user to order (sort) items. This control presents a list of HTML List Item (LI) elements for client-side manipulation, but stores its value as a semi-colon separated list of values in a child TextBox control. This control requires the jQuery UI javascript library.
Public classRelatedMapperContext
Provides for context information for a mapper relationship. Currently the only relationship built into the platform is that between a mapper and its parent. An example of such a relationship is a mapper in the bottom pane of a subform template with its ParentContext being that of the mapper in the top pane.
Public classSchemaInfo
Holds information about a column in a DataReader. Typically maintained in a SchemaInfoCollection collection.
Public classSchemaInfoCollection
Contains a collection of SchemaInfo column description objects loaded from an IDataReader object. Generally you obtain a SchemaInfoCollection from GetSchemaInfo(String, SchemaInfoType).
Public classShadowFiltering
A helper class for use by IField objects to implement standard ShadowColumn fields implementing one of the ShadowAlgorithm algorithms.
Public classSignaturePad
Control for displaying and capturing a signature using the browser's pointing device. Based on:
Public classTableInfo
Holds information about a table.
Public classTableInfos
A collection of TableInfo objects
Public classCode exampleTypedMapper
Represents the base class for generated TypedMapper classes. A TypedMapper provides a type-safe implementation of an IMapper based on its meta-data.
Public classTypedMapperExtensionT
The base class for an extension associated with a generated TypedMapper. As with all extensions and extension base classes, the class implements the IExtension interface and response to ExtensionEvents. See MapperExtensionKernel for more information about mapper events and mapper event sequences.
Public classUnknownCommand
Exception thrown when an unknown command is specified to a mapper.
Public interfaceIDataField
Interface allowing basic IField support for custom controls that manipulate an unbound data item in addition to the typicaly bound data item (Value).
Public interfaceIField
Defines an individual field in a mapper. Mappers implement the IMapper interface and are the platform's implementation of an Object Relational Mapper (ORM). The mapper acts as a sophisticated RecordSet that performs database binding and exposes data from the database for programmatic manipulation and display.

The mapper contains a set of fields in its IMapper.Fields collection (a Fields collection object). Each field typically corresponds to a column in the mapper's underlying view. However multiple fields can be mapped to a single column (using the AliasName property) and a field can be marked as ExcludeFromSelect to indicate that there is no corresponding column in the view.

The field object is used to read, insert, and update column values via the Value property. It is also used to manage presentation layer information and to expose all the field's meta-data settings.

Each field has a specified CellTypes that dictates its basic UI implementation. A set of FieldAttrs provide high-level control over field behaviour.

The Field's Exec(FieldExecCmds, Int32, Object) method exposes additional functionality via FieldExecCmds.

Fields are often referenced in expressions using field references. Field reference expressions are handled by the ExpressionParser class and can be resolve by calling ResolveExpression(IMapper, String, ExpressionResolutionFlags).

Public interfaceIFieldControl
Interface allowing basic IField support for custom controls.
Public interfaceIFieldWidget
Describes an object that implements a field widget interface.
Public interfaceIListField
Interface allowing basic IField support for custom controls that deal with list data.
Public interfaceIMapper
A Mapper is the primary means of mapping object-oriented programming objects to data sources managed by relational databases or other sources of data. A Mapper provides 2-way (Read and Write) access to the underlying Data Source.

Among the most important aspects of a mapper are:

There are several implementations of mappers that implement this interface and all of which derive from MapperKernel which implements all the common functionality:
  • Mapper - Basic mapper intended for programmatic use (with no UI).
  • MapperList - Basic list mapper intended for programmatic use (with no UI).
  • MapperDetail - Standard editable single-item detail UI mapper.
  • MapperDatasheet - Standard list UI mapper.
In most cases you will want a TypedMapper for each mapper manipulated programmatically. A TypedMapper provides a type-safe implementation of a mapper based on its meta-data.
By default a mapper is forward-only and uses an ADO DataReader for efficent cursor-based access to large sets of data. Set the BiDirectional attribute to cause the mapper to read the queried data into an internal DataTable and provide forward and backward movement.
Typically a mapper query is performed against a table or view, however, it is possible to configure a mapper to use a Stored Procedure as the source for its data by setting the mapper's QuerySQL property. When specified, QuerySQL will override the mapper's View (which, though ignored, must still be specified) when the mapper queries for its data during Requery(RequeryHints). A typical Stored Procedure QuerySQL looks like:

spMyData [[PREFILTER]], [[FILTER]], [[OPTIONS]], [[SORT]], [[TOPN]], <params>.

Stored Procedure parameters may be passed in any order, are resolved for embedded functions using the EmbeddedParser, and may optionally include any or all of these predefined parameter markers that will be replaced by the mapper when the Stored Procedure is called. Note that all markers are case-sensitive.
  • [[PREFILTER]] - The SQL WHERE clause (without "WHERE"), constructed by the mapper, to be applied to the intermediate Stored Procedure result. Only those MapperFilter items in the mapper's MapperFilters collection marked with PreFilter will be included in this clause. Typically a MapperFilter is marked as PreFilter because is was generated from a IField marked as PreFilter (e.g. from the FBF). This should be a string type (e.g. nvarchar) with a minimum sugested length of 2000 characters, or better yet, unlimited length (e.g. nvarchar(max)).
  • [[FILTER]] - The SQL WHERE clause (without "WHERE"), constructed by the mapper, to be applied to the final Stored Procedure result. Only those MapperFilter items in the mapper's MapperFilters collection not marked with PreFilter will be included in this clause. This should be a string type (e.g. nvarchar) with a minimum sugested length of 2000 characters, or better yet, unlimited length (e.g. nvarchar(max)).
  • [[OPTIONS]] - Options from QuerySqlOptions telling the Stored Procedure what kind of data to return. This is an int type.
  • [[SORT]] - The SQL ORDER BY clause (without "ORDER BY") constructed by the mapper. This should be a string type (e.g. nvarchar) with a minimum sugested length of 200 characters, or better yet, unlimited length (e.g. nvarchar(max)).
  • [[TOPN]] - The TOP(N) value specifying that only the first N records should be returned or -1 if no limit. This is an int type.
Public interfaceITypedMapperExtensionMarker
Marker interface allowing mapper to determine if extension is implemented as a TypedMapperExtension.
Public delegateCommandEventHandler
Fired when an event occurs in the MapperCommands collection.
Public delegateFieldsFieldNotFoundEvent
Prototype for methods handling the OnFieldNotFound event.
Public enumerationAggregateDisplay
Options specifying how the mapper should display aggregate data. This is specified using the mapper "AggregateDisplay" property. Note that displaying aggregate data requires an additional query which may have a performance impact on the application. If so desired, he developer can use the persistence options to reduce this impact by making sure that users don't turn on aggregate display permanently.

When aggregates are enabled you can specify the type of aggregation to use on each field by setting its AggregateType. Unless ExplicitFieldsOnly is specified, fields without an explicit AggregateType setting will default to an aggregation based primarily on the field's OleDbType and CellType and whether or not it has a Picklist. Typically the only non-None default is to use Sum for numeric fields.

When aggregates are enabled on a datasheet with grouping applied aggregates, in addition to ovreal aggregates, aggregates will be displayed for each grouping .

Public enumerationAggregateQueryExprFlags
Flags for use with the AggregateQueryExpr.
Public enumerationAggregateType
Aggregate types specifying what type of aggregation should be used, per field, in the aggregate row of a Datasheet.
Public enumerationBeforeRequeryHints
Hints provided during the MapperBeforeRequery event in BeforeRequeryArgs.Hints.
Public enumerationButtonScriptAddOptions
Options for used to modify how button script is added. Used with ButtonScriptAdd.
Public enumerationButtonType
Specifies the way buttons are presented in (list) datasheet and detail forms. Overall application behaviour can be specified using the studio's ButtonType property on an application. This default behaviour can be overridden setting the same property on a particular field in the studio. If no setting is specified, the platform defaults to ListLinkDetailButton.
Public enumerationCacheDataAttrs
Options for controlling data caching behavior.
Public enumerationCaptionFlags
Public enumerationCascadedTextOptions
Public enumerationCellButtonAttrs
Cell attributes specific to Button cells.
Public enumerationCellCheckBoxAttrs
Cell attributes specific to CheckBox cells.
Public enumerationCellChooserAttrs
Cell attributes specific to Chooser cells.
Public enumerationCellComboBoxAttrs
Cell attributes specific to ComboBox cells.
Public enumerationCellCurrencyAttrs
Cell attributes specific to Currency cells.
Public enumerationCellDatePickerAttrs
Cell attributes specific to DatePicker cells.
Public enumerationCellDateTimePickerAttrs
Cell attributes specific to DateTimePicker cells.
Public enumerationCellEmailAddrAttrs
Cell attributes specific to DatePicker cells.
Public enumerationCellFilePathAttrs
Cell attributes specific to FilePath cells.
Public enumerationCellFileUploaderAttrs
Cell attributes specific to FileUploader cells.
Public enumerationCellFindAttrs
Cell attributes specific to Find cells.
Public enumerationCellGroupBoxAttrs
Cell attributes specific to GroupBox cells.
Public enumerationCellHtmlAttrs
Cell attributes specific to Html cells.
Public enumerationCellIconAttrs
Cell attributes specific to Icon cells.
Public enumerationCellLabelAttrs
Cell attributes specific to Label cells.
Public enumerationCellLinkAttrs
Cell attributes specific to Link cells.
Public enumerationCellListBoxAttrs
Cell attributes specific to ListBox cells.
Public enumerationCellMapperSummaryAttrs
Cell attributes specific to MapperSummary cells.
Public enumerationCellMultiSelectAttrs
Cell attributes specific to MultiSelect cells.
Public enumerationCellPasswordAttrs
Cell attributes specific to Password cells.
Public enumerationCellPictureAttrs
Cell attributes specific to Picture cells.
Public enumerationCellRadioButtonsAttrs
Cell attributes specific to RadioButtons cells.
Public enumerationCellRatingIconAttrs
Cell attributes specific to RatingIcon cells.
Public enumerationCellSecureTextAttrs
Cell atrributes specific to SecureText cells.
Public enumerationCellSignatureAttrs
Cell attributes specific to Signature cells.
Public enumerationCellTextBoxAttrs
Cell attributes specific to TextBox cells.
Public enumerationCellTextWithWidgetAttrs
Cell attributes specific to TextWithWidget cells.
Public enumerationCellTimeDurationAttrs
Cell attributes specific to TimeDuration cells.
Public enumerationCellTimePickerAttrs
Cell attributes specific to TimePicker cells.
Public enumerationCellTreeAttrs
Cell attributes specific to Tree cells.
Public enumerationCellTypes
A field's CellType specifies how the field is used. For dynamically created pages the CellType is used to determine what type of control to instantiate to represent the IField in the UI. Certain properties configurable via the studio are CellType-specific (see CellTypeAttributes). In particular, many cell types have a set of CellType-specific attributes associated with them. Such attributes are named Cell<celltype>Attrs.
Public enumerationCellUrlAttrs
Cell attributes specific to Url cells.
Public enumerationCellWebSiteAttrs
Cell attributes specific to WebSite cells.
Public enumerationCommandFindType
Find types for use with Find(String, CommandFindType) to find specific commands in a MapperCommands collection.
Public enumerationControlBindingFlags
Option flags for use with ControlBind.
Public enumerationControlCreationFlags
Option flags for use with CreateControl.
Public enumerationControlValueGetFlags
Option flags for use with ControlValueGet.
Public enumerationControlValueSetFlags
Options for use with ControlValueSet and the field's internal SetCtrlValue(WebControl, ControlValueSetFlags) method.
Public enumerationConversionScriptOptions
Options specifying what kind of conversion script should be generated, for use with GenConversionScript.
Public enumerationConvertValOpts
Options for the ConvertValue command.
Public enumerationDatasheetLayoutAttrs
Attributes controlling certain aspects of datasheet layout.
Public enumerationDatasheetNavAttrs
Attributes controlling certain navigation behaviours in datasheets.
Public enumerationDatasheetPagingStyle
Paging styles supported by the datasheet. This can be changed app-wide by setting the datasheet_PagingStyle See RowsPerPagePosition regarding positioning of Row Per Page buttons.
Public enumerationDataTableRetrievalFlags
DataTable retrieval flags for use with IMapper.Exec(MapperExecCmds.RetrieveDataTable, DataTableRetrievalFlags).
Public enumerationDispTextFlags
Option flags for use with DisplayTextGet(DispTextFlags).
Public enumerationEditableFieldReplacementOptions
Public enumerationExecSQLArgsExecuteStatementType
Execution types.
Public enumerationExpandTemplateFlags
Flags to modify the behavior of the MapperExec command, ExpandTemplate ExpandTemplate.
Public enumerationExpressionResolutionFlags
Public enumerationFieldAnomaly
Anomalous conditions that may be detected during mapper operations and causing FieldAnomaly events to be fired. A FieldAnomaly event will be fired for each anomaly detected. Currently these anomalies are only detected during attempts to save. During the event the anomaly being experienced is specified in the FieldAnomalyArgs provided during the event.
Public enumerationFieldAttrs
Field attributes are used to control overall behaviour of an IField via its Attributes property. Attributes may be combined by ORing values together.
Public enumerationFieldBehaviorOptions
Options specifying general IField behaviour.
Public enumerationFieldCapabilities
Field capabilities that can be ascertained using the Supports(FieldCapabilities) method.
Public enumerationFieldDeleteBehavior
Delete behaviour settings for IMapper object.
Public enumerationFieldDiffOptions
Options for use when "diff'ing" IField new vs. old value via DiffValues.
Public enumerationFieldDisplayFormat
Identifies the IField display format based on the field's data type, CellTypes and other relevant settings.
Public enumerationFieldExecCmds
Public enumerationFieldExportAttrs
Attributes specifying how an IField is to be handled during an export (e.g. to Excel).
Public enumerationFieldExpressionAttrs
Attributes used when resolving field reference expressions. Each of these attributes corresponds to a modifier flag character. See the ExpressionParser class for more information about field references.
  • [$keyname] - DisplayText - Use the field's display text rather than its raw value (obtained via DisplayTextGet(DispTextFlags)).
  • ['keyname] - AnsiQuote - AnsiQuote the value using AnsiQuote(String).
  • [`keyname] - DoubleQuote - Enclose the field value in double-quote '"' characters (this is a back-tick character).
  • [#keyname] - Numeric - The value is a numeric value and should be rendered as zero "0" if the value is null/empty.
  • [<keyname] - UseOldValue - Use the OldValue if the field is dirty.
  • [&keyname] - UseCaption - Use the field's Caption instead of its value.
  • [?keyname] - EscapeForUrl - The field's value should be escaped for use in a URL using ForUrl(String).
  • [@keyname] - EscapeForHtml - The field's value should be escaped for use in HTML using ForHtml(String).
  • [^keyname] - ApplyDefault - Use the field's DefaultValue if the field's value is null/empty.
  • [+keyname] - EscapeForXML - The field's value should be escaped for use in XML using ForXml(String).
  • [*keyname] - RawValue - Use the field's raw value (obtained via Value), implied if no other option specified.
  • [~keyname] - ClientElement - Renders as a javascript expression accessing the field. Often combined with either '$' or '*' attributes to obtain the client-side display or raw values respectively.
  • [:keyname] - Optional - Value is optional and should default to zero or empty string, as appropriate.
  • [-keyname] - Guid - The value is a GUID value and should be rendered as the zero GUID "{00000000-0000-0000-0000-000000000000}" if the value is null/empty.
Public enumerationFieldFilterFlags
Option flags for use with FilterClause.
Public enumerationFieldFilterOptions
Options specifying IField filtering availability and behaviour.
Public enumerationFieldFindType
Find types for use with Find(String, FieldFindType, FindBehaviour) to find specific fields in a Fields collection.
Public enumerationFieldFormatFlags
Flags for use with FormatValue.
Public enumerationFieldGroupingAttrs
Attributes specifying how mapper grouping should be performed on a specific field. Grouping can also be controlled at the IMapper level using MapperGroupingAttrs. See the Customize Datasheet Grouping wiki article for more information.
Public enumerationFieldImportAttrs
Attributes specifying how an IField is to be handled during an import.
Public enumerationFieldListOptions
Options affecting behaviour of IField objects in list views.
Public enumerationFieldPositionOptions
Options used to control how an IField is positioned.
Public enumerationFieldRawStringFlags
Flags for use with the ValueToRawString.
Public enumerationFieldSecurityAttrs
Security attributes for field-level, role-independent security configuration. These attributes have the biggest impact, and are commonly used, in "strict" mode, see IsStrictMode.
Public enumerationFieldSubsetType
Type of subset to obtain from a Fields collection using Subset(FieldSubsetType, Object).
Public enumerationFieldTableAttrs
Attributes specifying how the corresponding Table should be handled. Typically applies to fields marked PK only.
Public enumerationFieldValidationRule
A field validation rule can be specified to add additional data-specific field validation. In some-cases the validation may be server-side only.
Public enumerationFileUploadSources
Specifies the source(s) for uploading images via a FileUploader field when specified in the field's FileUploadSource property.
Public enumerationFilterDescOptions
Options specifying how a filter description is to be composed.
Public enumerationFilterFlags
Flags specifying additional information about a MapperFilter in a MapperFilters collection.
Public enumerationFindBehaviour
Options specifying how Find(String, FieldFindType, FindBehaviour) should behave.
Public enumerationFindFullTextSearch
Options for supporting Full-Text Search on Find and MultiFind.
Public enumerationFlavors
Flavors are used to include/exclude particular IFields on a mapper based on mapper context. The IncludeFlavor and/or ExcludeFlavor can be set in meta-data. When the mapper loads its fields, the mapper's Flavor value is used in conjunction with each field's IncludeFlavor and ExcludeFlavor to determine if the field should be included or excluded from the mapper instance.
Public enumerationFullTextSearchAttributes
Flags used to control the behaviour of IMapper Full-Text Search.
Public enumerationGenSelectFlags
Flags to modify the behavior of the MapperExec command, GenerateSelectSQL GenerateSelectSQL.
Public enumerationGetFieldListOpts
Options for use with GetFieldList(GetFieldListOpts).
Public enumerationGetFilterFlags
Flags specifying how a filter is to be built.
Public enumerationGetValFlags
Option flags for use with GetValue(GetValFlags, Object). In general these flags may be combined except where more than one of the flags uses the param parameter.
Public enumerationHoverSummaryFlags
Options for use with HoverSummaryScript.
Public enumerationHTMLSummaryFlags
Flags used to control how an HTML summary is generated. Among other uses, these flags are passed in the flags parameter when calling Exec(MapperExecCmds, Enum, Object) with the Caption command.
Public enumerationKeyDisplayCollectionFlags
Flags to modify the behavior of the MapperExec command, KeyDisplayCollectionGet KeyDisplayCollectionGet
Public enumerationLabelFlags
Option flags for use with LabelText and CreateLabel.
Public enumerationLabelOptions
Options used to control how an IField's label is rendered.
Public enumerationLinkBehaviorAttributes
Options specifying IField link behaviour.
Public enumerationLinkForNavFlags
IField.Exec flags to use with LinkForNav.
Public enumerationMapperAttrs
MapperAttributes are used to control overall behaviour of the IMapper.
Public enumerationMapperBindFlags
Public enumerationMapperCapabilities
Mapper capabilities that can be ascertained using the IsConfiguredFor(MapperCapabilities) method.
Public enumerationMapperCloneFlags
Options for the Clone(IMapper, MapperCloneFlags) method.
Public enumerationMapperCommandLocation
Specifies the location of the command. A command added to a mapper can exist either on the "More" menu or the toolbar. If you specifiy that the command should be located on the toolbar, then you must provide an image for the command. Images should be relative to the root path.
Public enumerationMapperDiagnosticOptions
Options for use with Diagnose.
Public enumerationMapperExecCmds
Public enumerationMapperExecFlags
General purpose flags for use with various MapperExecCmds.
Public enumerationMapperFilterAttrs
MapperFilter attributes extracted from the xmt_filters.attr_bits column. All filters loaded from this table are marked as static. Depending on the attributes set, a filter may also be marked as a Security filter.
Public enumerationMapperFilterType
The type of filter that is being constructed.
Public enumerationMapperGroupingAttrs
Attributes specifying how mapper grouping should be performed. Grouping can also be controlled at the IField level using FieldGroupingAttrs. See the Customize Datasheet Grouping wiki article for more information.
Protected enumerationMapperKernelMapperProcessing
Describes the internal processing state of the mapper.
Protected enumerationMapperKernelMapperState
Describes the internal state of the mapper.
Protected enumerationMapperKernelPopulateFlags
Modifier flags used by MapperKernel.PopulateFromSource
Protected enumerationMapperKernelRequeryFlags
Public enumerationMapperLinkFlags
Flags used to control the behaviour of IMapper.Exec(MapperExecCmds.Link, MapperLinkFlags).
Public enumerationMapperLoadFlags
Public enumerationMapperMode
Mapper mode specifies how the mapper is being used and controls the overall look and behaviour of the mapper.
Public enumerationMapperNofications
Notifications sent by a mapper to its fields to apprise them of current mapper actions/state.
Public enumerationMapperPerformanceOpts
Options for tuning IMapper performance.
Public enumerationMapperRequestAction
Actions for use in IsRequestAction used to determine if the mapper is currently performing a specific HttpRequest action.
Public enumerationMapperSaveOptions
Options for overriding standard IMapper save functionality when calling Save(MapperSaveOptions).
Public enumerationMapperTestOptions
Options for use with Test.
Public enumerationMapperTruncateBehavior
Behavior of the mapper when fields exceed their length.
Public enumerationMapperTweaks
A grab bag of hacks and tweaks providing workarounds to unusual mapper problems. Use with caution.
Public enumerationMoveReason
Specifies the reason for a relative move
Public enumerationOperationType
The different types of operations that a mapper can perform.
Public enumerationPicklistFillFlags
Option flags for use with PicklistFillCtrl.
Public enumerationPicklistReplaceOptions
Options for use with PicklistReplace.
Public enumerationQuerySqlOptions
Option flags passed in the [[OPTIONS]] parameter to an IMapper object QuerySQL. QuerySQL is typically a Stored Procedure expression.
Public enumerationRequeryHints
Hints provided to Requery(RequeryHints).
Public enumerationRollupOptions
Options for rollup mappers. Use the ConsoleDatasheet_RollupFields property for setting up a rollup.
Public enumerationRowCountAlgorithm
Various row count algorithms supported by the MapperDatasheet. Generally the datasheet will use internal logic to select an algorithm, but a specific algorigthm may be specified.
Public enumerationRowDigestFlags
Options for the RowDigest(RowDigestFlags) method.
Public enumerationRowReorderOptions
Options for modifying how datasheet row-reordering works. Use the ConsoleDatasheet_OrderingField property for setting up row reordering.
Public enumerationRowsPerPagePosition
Options for positioning datasheet Rows-Per-Page buttons. If available, the button are normally presented at the bottom of the datasheet next to the pager buttons. This can be changed app-wide by setting the datasheet_RowsPerPagePositionDatasheet feature. See DatasheetPagingStyle regarding different datasheet paging styles.
Public enumerationSavedFilterApplyOptions
Flags specifying the behavior of how a saved filter is applied to a mapper.
Public enumerationSaveFilterOptions
Options used with the FilterSave command.
Public enumerationSetFieldListOpts
Options for use with SetFieldList(String, SetFieldListOpts). Note that this enum is provided for future use and no options are specified at this time.
Public enumerationSetValFlags
Option flags for use with SetValue(Object, SetValFlags, Object).
Public enumerationShadowAlgorithm
This field is being used as a ShadowColumn and the ShadowAlgorithm specifies how shadow data is to be maintained and filtered/sorted against.
Public enumerationShadowAttrs
This field is using a ShadowColumn and these attributes specify how that ShadowColumn is to be used.
Public enumerationSizingSchemes
Schemes for column width sizing.
Public enumerationSQLValueFlags
Option flags for use with SQLValue(SQLValueFlags, Object).
Public enumerationTabOrderAttrs
Flags used to control how the mapper assigns automatic TabIndex ordering to fields in a detail form. Note that these only apply when NoTabOrdering is not set.
Public enumerationTabOrderRestrictions
Options available through the TabOrderRestrictions Accessibility feature to improve screen reader behaviour.
Public enumerationToolTipOptions
Option specifying how IField.ToolTip should be handled.
Public enumerationValueConversionFlags
Provided for future use with ToDisplayText(Object, ValueConversionFlags) and ToValue(String, ValueConversionFlags). At this time no flags are defined.
Public enumerationWizardSummaryFlags
Flags used to control the behaviour of the wizard summary. The enum is based on the HTMLSummaryFlags, but includes only a subset of those enumeration items and includes several with the opposite sense such that the typically desired wizard behaviour results when no flags are set.
Public enumerationWPEnvironment
Describes the environment in which the FieldWidget is operating.