Click or drag to resize

NetQuarry Namespace

NetQuarry is an enterprise application software platform for Microsoft.NET. It is comprised of pre-built software, metadata and tools designed to help professional software teams develop significantly better enterprise and hosted business applications. Developers using NetQuarry will deliver everything faster (less time and manpower equals less cost).

  • Rapid Prototypes (five to ninety days)
  • Initial functional applications that perform like highly mature ISV solutions
  • Subsequent versions and improvements without major rewrites.

And the applications developed on NetQuarry will perform better in a demanding hosted and enterprise environment.

Key Benefits:

  • Rapid results/development cycle
  • High product functionality with low project execution risk
  • Low ownership cost
  • Low maintenance cost
  • Low hardware cost
  • Rich functionality for customization

NetQuarry provides a foundation of functionality common to virtually all enterprise class applications. The common functionality includes data binding, database virtualization, OS-virtualization, searching, filtering, user interface (UI), security / permissioning, and numerous other commonly required capabilities. In each case the features are designed with great attention to the enterprise-class foundation, and with the knowledge of what custom applications, the developers and users of those applications really need.

One of the key concepts of the NetQuarry product is its extensibility. Although from past experience we understand most of the commonly required features; we also know that we cannot anticipate or accommodate all custom application needs. For this reason NetQuarry provides a comprehensive extension model. This model allows extension to the basic functionality through creation of .NET-compatible components that are configured into the system to respond to system events. This model makes NetQuarry an excellent platform not just for new application development, but also for Enterprise Application Integration (EAI). Using NetQuarry, multiple external applications can be integrated into a single front-end. In addition, because of the meta-data used to specify Business Objects in NetQuarry, NetQuarry can provide SOAP and Service Oriented Architecture (SOA) definitions.

Some of the most signficant objects in the platform are:

  • IAppContext - The application context object.
  • IDatabase - The database object.
  • IMapper - The Object Relational Mapping (ORM) object generally corresponding to a table or view.
  • IField - Items within an IMapper generally corresponding to a table/view column.
  • PageInfo - The application page defintion object.
  • PageElementInfo - Items within a PageInfo object corresponding to various data display elements on the page.
  • Navigator - An object describing navigation a collection of links within the application.
  • NavTarget - The individual navigation items within an Navigator.
  • IExtension - The primary event-based programming object interface.
Public classAccessibility
Helper class for accessibility, in particular for screen readers used by the visually impaired.
Public classAdHocReport
A helper class for working with ad hoc list reports.
Public classAfterAuthenticateEventArgs
The event arguments provided during the ApplicationAfterAuthenticate event. Note that older versions of the platform only provided an EAPEventArgs object so application extensions derived from ApplicationExtensionBase will need to coerce the event args appropriately.
Public classAjaxRequestEventArgs
Event args for the mapper RowAjaxRequest event.
Public classAppContext

The Application context object holds information that is used throughout each page (or server) request. The Application is available to all objects, either as a direct parameter or property on an existing object. The Application object is created as the first object in any request, and when possible it is cached for performance purposes.

Public classAppContextExtensions
Extension methods for IAppContext objects. Note that extension methods can be implemented to support null instances.
Public classAppContextInitOptions
Additional options to be used in Init(AppContextInitOptions) to initialize an IAppContext application context.
Public classApplicationAlertArgs
Event arguments provided to the ApplicationAlert event. See also Alert(IAppContext, ApplicationAlertArgs).
Public classApplicationExtensionBase
Serves as a base class for extensions that handle application events.
Public classApplicationExtensionMethods
Application context extension methods
Public classApplicationMapperLoadArgs
Event arguments provided to the ApplicationMapperLoad event. At this time there are no event-specific arguments in use and this class is provided for forward compatibility. See also MapperLoad(IAppContext, ApplicationMapperLoadArgs).
Public classApplicationMessageArgs
Public classApplicationPageArgs
Event arguments provided to the PageInit(IAppContext, ApplicationPageArgs) event. Note that this corresponds to the ApplicationPageInit event.
Public classApplicationPageHtmlArgs
Event arguments provided to the PageHtml(IAppContext, ApplicationPageHtmlArgs) event. Note that this corresponds to the ApplicationPageHtml event.
Public classApplicationPasswordArgs
Public classApplicationSendMailArgs
Arguments sent to the Before/After Send events on the application.
Public classApplicationVoiceArgs
Arguments sent to the application extension related to Twilio voice events ApplicationVoiceDial and ApplicationVoiceStatus. See also ITwilioVoice.
Public classApplicationWebhookArgs
Event arguments provided to the ApplicationWebhook event. See also Webhook(IAppContext, ApplicationWebhookArgs).
Public classAssemblyLoadFail
Exception raised when a failure is encountered while loading a component.
Public classAuthenticationFailedArgs
Event arguments provided to the AuthenticationFailed(IAppContext, AuthenticationFailedArgs) event. Note that this corresponds to the ApplicationAuthenticationFailed event.
Public classBeforeAuthenticateEventArgs
Event arguments passed to the BeforeAuthenticate event.
Public classBeforeLoadProfilesEventArgs
Event arguments passed to the BeforeLoadProfiles event.
Public classBreadcrumb
A breadcrumb object roughly mimicing the platform javascript breadcrumb object.
Public classBreadcrumbs
The collection of navigation history Breadcrumb objects. Breadcrumbs are normally automatically constructed by the platform to represent a navigation history. Your application can handle the ApplicationBreadcrumbs event to create a custom breadcrumb trail. One example of a custom breadcrumb trail would be a breadcrumb trail representing the application's object hierarchy rather than a navigation history.
Public classBreadcrumbsEventArgs
Event args for use with the ApplicationBreadcrumbs event. See Breadcrumbs(IAppContext, BreadcrumbsEventArgs) for more information.
Public classBrowserInfo
Holds information about the browser.
Public classCacheManager
Manages caching of operational data, particularly for mappers.
Public classCacheManagerParams
An object to contain any and all the Caching parameters required for setting up mapper caching.
Public classCollectionExtensions
Extension methods for the generic collections.
Public classComponentInfo
A ComponentInfo holds information about a component.
Public classComponentInfos
Holds a collection of ComponentInfo objects. This collection is created on the IAppContext object during initialization.
Public classComponentInfosFactory
Factory for creating a populated ComponentInfos collection. If possible, the collection is populated from cache.
Public classConsoleEventArgs
Base class for all IConsoleTemplate page events.
Public classConsolePanes
A collection of IConsolePane objects.
Public classConsolePlus
Extension methods for standard system Console. Ideally we would provide C# extension methods to the system Console class, but since the system Console class is a static class, extension methods are not supported by C#.
Public classConsoleUtils
Helper utility class for working with IConsoleTemplate pages.
Public classContextFactory
Helper class to create a valid application context object for a remote handler
Public classContextFactoryCacheSettings
Handles caching for the IAppContext created by the ContextFactory.
Public classDatabase
The Database object simplifies development tasks that implement common data access functionality.
Public classDatabases
Holds a collection of IDatabase objects.
Public classDatabaseSpace
Describes the space taken up by a database table as obtained from TableSpace(String, DatabaseSpaceOptions, String).
Public classDataRowExtension
Helper extension methods for DataRow objects. These methods mostly provide for safe data extraction.
Public classDateFilter
Helper class to handle building a date filter.
Public classDateTimeExtensions
DateTime extension methods.
Public classDebugUserDataItem
A UserData name/value item for viewing in the debugger.
Public classDebugUserDataList
A list of UserData name/value pairs for viewing in the debugger.
Public classDevLog
The DevLog handles writing to the current application's log file.
Public classDevLogEntry
A DevLog entry descriptor.
Public classDevLogReader
A class for reading a page from the devlog.
Public classDevStrings
Provides non-localized strings for developer-only functionality.
Public classDiffTagger
Helper class for marking up diff entries with appropriate tags.
Public classDisposableObject
Holds a reference to a disposable object.
Public classDisposableObjects
Holds a list of tracked disposable objects.
Public classDocumentOptions
Serves as document output options for generic print document.
Public classEAPActionException
This exception is used to signal that the exception is the result of a user action even though it was encountered in an area of code where errors would typically be presented in-line (e.g. rendering console pane content) and that, as such, the exception should be handled as a normal user error. This typically means presenting the user with an error alert or message box. Note that an EAPActionException may be used as a wrapper around a non-action exception to signal that the inner exception was encountered in such an area. The IsActionError flag is always set by this class's constructors.
Public classEAPAuditExportEventArgs
Event args for use with the AuditExport mapper event.
Public classEAPAuditMessageEventArgs
Event arguments for use with the AuditMessage event.
Public classEAPBootstrapUtils
Utility methods for working with different versions of Bootstrap CSS. These utilities are intended to ease support for different versions of Bootstrap using the same code base. The need for this class was driven by the breaking changes introduced in Bootstrap 4 over Bootstrap 3, see for information about the changes and migration.
Public classEAPCollectionBase
Provides the abstract (MustInherit in Visual Basic) base class for a key/value based collection that implements IList. This class is the base class for all of the public collections in the EAP.
Public classEAPCommandEventArgs
Holds event arguments for the MapperCommand event.
Public classEAPConvert
Utility methods for converting data.
Public classEAPCtrlUtils
Utility methods for working with .Net controls.
Public classEAPCustomEventArgs
Represents event arguments for the Custom event.
Public classEAPEncode
Utility methods for encoding data.
Public classEAPEventArgs
EAPEventArgs is the base class for classes containing event data. Events are fired on many objects through an IExtension object.
Public classEAPException
A basic platform application error. This class and its derivations allow an exception to carry additional information: DeveloperMessage.
Public classEAPFileDownloadEventArgs
Event arguments for the FileDownloadIMapper event.
Public classEAPNullArgException
A replacement class for the .Net ArgumentNullException that supports a developer message.
Public classEAPObjectCache
Singleton class that implements a generic cache collection. Writes to the internal collection are locked and can only be done by one thread at a time. Reads are not locked.
Public classEAPPageCommandEventArgs
Arguments sent to a PageCommand (fired on page extensions only)
Public classEAPQueryErrorEventArgs
Holds event arguments for the MapperQueryError event.
Public classEAPSchedulerEventArgs
Arguments for Scheduler page events
Public classEAPScriptException
A platform scripting error raised when some kind of script evaluation fails. The error message may include sensitive information and may require suppression along the lines of SQL error message suppression.
Public classEAPSecurityException
A platform security error.
Public classEAPSQLComplexityException
This exception is used to identify SQL errors caused by SQL complexity, rather than a syntax error, in order to provide better error message for users.
Public classEAPTimeoutException
This exception is used to identify timeout exception, particularly from SQL queries, in order to provide better error message for users.
Public classEAPTLSCache
Derived class from NetQuarry Properties to store Cached DBLookupCache(String, String, String, DataFuncOptions, String, String) results.
Public classEAPUtil
The most commonly used utility functions in the NetQuarry platform. Note that there are useful utilties methods spread around a number of different classes. In many cases the utilities are maintained in classes with specific, related functionality. However, mostly for historical reasons, some utility methods are in different classes for no logical reason!

See the following classes for more useful utilities:

  • EAPConvert - Utility methods for converting data.
  • EAPCtrlUtils - Utility methods for working with .Net controls.
  • EAPEncode - Utility methods for encoding data.
  • HttpUtility - Helper utility class for HTTP based code.
  • ImageUtils - Utility functions for manipulating images.
  • MailUtils - Various utility methods for working with email.
  • MapperUtils - Utility class providing helper methods for working with IMapper objects.
  • MathUtils - General-purpose math utilities.
  • StringUtils - General-purpose string utilities.
  • TagUtils - Utility code for generating HTML element strings.
Public classEAPVersion
A Version is a named identifier declared in metadata used to control aspects of the application.
Public classEAPVersions
A collection of EAPVersion objects. The primary use of this collection is to store application versions and is available via the Versions collection on the IAppContext application object. Typically versions are maintained in the NetQuarry Studio, but they may be set programmatically.
Public classEAPVersionsFactory
Factory for creating a populated EAPVersions collection. If possible, the collection is populated from cache.
Public classEmbeddedParser
This class manages and parses platform embedded functions. Embedded functions are a sort of simple macro language and are typically used in SQL statements for elements that need to be represented in meta-data, but resolved at the time the SQL statement is executed.

The basic format for an embedded function inside an expression (e.g. a SQL statement) is !fnXXX[flags](params) where ALL embedded functions must start with "!fn" (case-sensitive), be followed by the function name (also case-sensitive), optionally followed by activation flags (currently only "$" is supported indicating that the result should be AnsiQuoted), followed by an open parenthesis and closing parenthesis between which a set of comma-separated parameters may optionally be specified. For example, !fnBitTest(0x00000002, 1) tests whether or not the 1st bit (0-indexed) is set (which it is in this case) and evaluates to 1 if so, else 0.

The parser includes a set of intrinsic functions:

  • fnAppCacheVer - Return the application version number string. The returned format is ver=xxx, where xxx is the application version in production mode, or a timestamp otherwise.
  • fnAppProperty - The value of the specified application property.
  • fnBitTest - Tests for a bit being set. Evaluates to zero if not set. Format is: fnBitTest(value, bitnum) where bitnum is the 0-based index of the bit to test.
  • fnCacheVer - Return a version number for managing included javascript, or style sheets. Ensures the latest versions of files using this function will be up to date and never stale.
  • fnCulture - The name of the current Culture for the current user.
  • fnCultureBase - The name of the current base Culture for the current user (e.g. 'en' for any English language culture).
  • fnDBLookup - Looks up a value in the database. Format is: fnDBLookup(col, table, where). This provides similar functionality to the DBLookup(String, String, String) function.
  • fnFormat - Format data. Format is: fnFormat(value, datatype, format) where datatype is currently limited to d=date/time and format is a standard .Net formatting string.
  • fnNamedFilter - Takes a string that refers to a name of a named filter.
  • fnNewGUID - Generates a new GUID. An optional format parameter may be specified.
  • fnNow - The current date/time with optional timezone defaulting to user's local timezone.
  • fnNowAdd - The current date/time with the specified offset in the form fnNowAdd(period [,count [,timezone]]) where period is one of y, M, d, H, m, s, or f, and defaulting to user's local timezone.
  • fnNowAddUTC - The current date/time in UTC with the specified offset in the form fnNowAddUTC(period [,count]) where period is one of y, M, d, H, m, s, f.
  • fnNowUTC - The current date/time in UTC.
  • fnProfilesFilter - Returns the IN clause formatted string for all of the current user's profiles.
  • fnProxyUserID - The Proxy ID for the current user context.
  • fnTenantID - The value of Session.TenantID.
  • fnTimePeriod - Takes a datetime column name and required time period keyword (e.g. today, yesterday).
  • fnTimePeriodUTC - Takes a UTC datetime column name and required time period keyword (e.g. today, yesterday).
  • fnToday - The current date (with 00:00:00 time component) with optional offset and timezone in the form fnToday([period [,count [,timezone]]]) where period is one of y, M, d, H, m, s, or f, and defaulting to user's local timezone.
  • fnUserGUID - The GUID for the current user.
  • fnUserID - The ID for the current user.
  • fnUserName - The name of the current user.

In addition to these intinsic functions, the parser supports application-specific static substitution functions and dynamic functions. Functions can be registered programmatically by calling RegisterFunction(String, String, String) on the parser or by calling RegisterEmbeddedFunction(String, String, String) on the application.

Static substitution functions can be specified in meta-data via the NetQuarry studio by creating Session Properties and setting the GenEmbeddedFunc attribute on each. Dynamic functions can be configured in meta-data as well by setting up FunctionParser Components. FunctionParser components implement the IFunctionParser interface. The IFunctionParser interface allows the platform to interrogate the component in order to determine which functions it supports and to invoke those functions when encountered during embedded function resolution.

Public classEventBulkContext
The context of the current bulk operation (e.g. a bulk insert, update or delete). This context is normally available in any event's EAPEventArgs parameter.
Public classEventInfo
Defines an Event. Events are registered actions that are carried out by a particular handler.
Public classEventInfos
Defines a collection of EventInfo objects.
Public classExceptionExtensions
Exception extension methods.
Public classExpressionParser
Helper class for working with field reference expressions.

Field references can be used throughout platform applications with an expression containing markers for IField values of the form [<flags><key>] where <key> is a field Key and <flags> are zero or more modifier flag characters (see the corresponding FieldExpressionAttrs flags) specifing how the field value is to be represented:

  • $ - DisplayText - Use the field's display text rather than its raw value (obtained via DisplayTextGet(DispTextFlags)).
  • ' - AnsiQuote - AnsiQuote the value using AnsiQuote(String) (this is a single-tick character).
  • ` - DoubleQuote - Enclose the field value in double-quote '"' characters (this is a back-tick character).
  • # - Numeric - The value is a numeric value and should be rendered as zero "0" if the value is null/empty.
  • < - UseOldValue - Use the OldValue if the field is dirty.
  • & - UseCaption - Use the field's Caption instead of its value.
  • ? - EscapeForUrl - The field's value should be escaped for use in a URL using ForUrl(String).
  • @ - EscapeForHtml - The field's value should be escaped for use in HTML using ForHtml(String).
  • ^ - ApplyDefault - Use the field's DefaultValue if the field's value is null/empty.
  • + - EscapeForXML - The field's value should be escaped for use in XML using ForXml(String).
  • * - RawValue - Use the field's value (obtained via Value), implied if no other option specified.
  • ~ - 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.
  • : - Optional - Value is optional and should default to zero or empty string, as appropriate.
  • - - 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.

Field references are sometimes used in conjunction with "!fn" Embedded Functions which are resolved by the EmbeddedParser.

Public classExtensionBase
Serves as a base class for type-specfic extensions. In general, you should use the specfic classes that derive from this class (ApplicationExtensionBase, for example) and not derive from this class directly.
Public classExtensionCancel
The exception that is thrown when Cancel is returned as an extension status
Public classExtensionCommandArgs
The command args for the ExtensionCommand event. Note that at this time the ExtensionCommand event command is intended for internal use and no provision is made in the standard extension bases classes for handling it easily.
Public classExtensionException
The exception that is thrown when a non-fatal extension error occurs
Public classExtensionInfo
An ExtensionInfo holds information about an extension for use in the Extensions collection.
Public classExtensionInfos
Represents a collection of ExtensionInfo objects.
Public classExtensionLoadFail
Exception thrown when an extension load fails.
Public classExtensions
The extensions collection is used to manage IExtension objects hooked to a particular object. The most common such object is an IMapper object. Extension events are fired through the collection and the collection ensures that all appropriate extensions receive the event and that the results are returned to the object firing the event.

Extensions are called in Priority order from highest Priority number to lowest. Note, however, that Priority is only enforced internally during FireEvent(ExtensionEvents, Object, EAPEventArgs). The extensions in the collection are not organized in any particular order so you should not assume an order when iterating through the collection using foreach or accessing an extension by index.

Public classFailedImportItem
Filed import item descriptor for use with LogFailedImportItem(IAppContext, FailedImportItem) and corresponding to the xot_failed_import_item_log table.
Public classFavorite
Holds a simple favorite (bookmark to a page, url, or report)
Public classFavorites
Holds a collection of favorite objects
Public classFeature
A Feature describes a feature and it's current state. Each Feature has a set of properties used to specify the behaviour of that Feature. The features are maintained in a Features collection accessible via Features.
See featureProperties for a description of the available features and their properties.
Public classFeatures
Holds a collection of Feature objects. Each Feature has a set of properties used to specify the behaviour of that Feature. The application's Features collection is accessible via Features.
See featureProperties for a description of the available features and their properties.
Public classFieldAjaxSaveEventArgs
Event args for the mapper FieldAjaxSave event.
Public classFilterHelper
A helper class use for mapper (and possibly other) filtering. The class includes support for filtering keyword localization.
Public classFilteringExtensions
Ths class provides extension methods for filtering objects.
Public classFilterKeyword
A filtering keyword descriptor.
Public classFilterKeywords
The collection of localized filtering keyword objects.
Public classFilterSchema
Extracted version-specific schema information relevant to the SavedFilter class (generally regarding the xot_saved_filters table.
Public classFilterSyms
The set of known, culture-independent filter symbols. These correspond with matching items in the FilterOp enumeration.
Public classFilterWidgetDate
Generates HTML for a FilterWidget to use with date fields.
Public classFilterWidgetNumber
Generates HTML for a FilterWidget to use with numeric fields.
Public classFilterWidgetTimeOnly
Generates HTML for a FilterWidget to use with time-only fields.
Public classFireAndForgetCountHelper
a helper object for returning accurate status information about FireAndForget counts
Public classFooterOptions
Serves as document footer output options for generic print document.
Public classFTPFileTransferResult
Class that records the status of each file transferred in an FTP session
Public classGuidExtensions
Guid extension methods.
Public classHandleEventArgs
Public classHeaderOptions
Serves as document header output options for generic print document.
Public classHelpStringAttribute
Provides a HelpString attribute for enumeration items. This allows a helpstring to be obtained programmatically using reflection.
Public classHtmlNodeExtensions
Extends HtmlNode class to provide helper methods
Public classHtmlToText
Helper class for converting HTML to a readable text representation.
Public classHttpContextExtensions
Extension methods for the HttpContext object.
Public classHttpHandlerBase
Base class for building HttpHandlers.
Public classIconManager
A helper class for managing per-application customization of platform icons. The customized images are loaded from the application's IconsFeature, see Features. Note that at this time there is no support for icon localization.
Public classImageUtils
Utility functions for manipulating images.
Public classImportBulkContext
Bulk context used by WizSimpleImport (and possibly other import mechanisms) to provide context during both the import validation phase and the import insert phase.
Public classImportUtils
Utility code used to support data imports.
Public classInstalledLocale
Implementation of the Installed locale meta item.
Public classInstalledLocales
A collection of InstalledLocale objects used to host the set of installed locales for the application.
Public classJSHelper
This class is a helper class to facilitate the use of the platform javascript utility code. That code is primarly contained in EAPUtils js.
Public classJSHelperCDN
Provides javascript references to standard javascript components via an online Content Delivery Network (CDN) such as Google.
Public classJSHelperLinkRef
Internal helper object for adding link references to the page.
Public classJsonSerializer
Helper class for building Javascript JSON (JavaScript Object Notation) AJAX responses.
Public classLargeFormException
This exception is thrown when .Net rejects a posted back form due to the form having an excessive number of form variables. When .Net detects an excessive number of form variables it calls its ThrowIfMaxHttpCollectionKeysExceeded() method as a safeguard against a possible denial of service (DOS) attack. On 12/29/2011 Microsoft put out a security update (MS11-100) that puts a default limit of 1,000 on form variables. This should generally be sufficient, but can be overridden by modifying the app's web.config to add a aspnet:MaxHttpCollectionKeys key to the appSettings section. For example: <add key="aspnet:MaxHttpCollectionKeys" value="2000" />
Public classMathUtils
General-purpose math utilities.
Public classMessagePop
Provides information regarding how to configure a client-side msgpop popup. By default the popup will have a caption area, a content area, and OK and Cancel buttons. Currently a MessagePop object is provided in the event args of the FieldConfirm event where it is used to allow the extension to configure the popup.

At a minimum a Caption and Message (or HTML) should be provided.

Public classMetaTableInfo
Describes a table from the xmt_tables metadata object.
Public classMetaTableInfos
Defines a collection of MetaTableInfo objects.
Public classMissingPageException
Specifies an exception to handle a missing page (MOP).
Public classMissingTemplateException
Specifies an exception to handle a missing template.
Public classModuleInfo
A ModuleInfo object holds the metadata representation at runtime of the modules that could be used in an application. A module is represented by it's ModuleKey. The collection is loaded once (at startup) and used throughout the life of the application.
Public classModuleInfos
The collection of ModuleInfo objects.
Public classModuleInfosFactory
Factory for creating ModuleInfos collection.
Public classNamedFilter
A NamedFilter holds information about a named filter. See NamedFilters for more information on the purpose and use of named filters.
Public classCode exampleNamedFilters
The collection of NamedFilter objects. The filters are loaded in Priority order with higher Priority filters replacing lower Priority filters of the same Name (that is, higher Priority filters take precedence over lower Priority filters). There are a number of common uses for named filters:
  • Specify a filter in one place that can be used throughout the application.
  • Implement role-based filtering where some roles have different data visibility than other roles per Priority.
In general, named filters are applied using a NamedFilter marker of the form !fnNamedFilter(<name>), for example !fnNamedFilter(HighPriorityItems).
For example, you can create two filters with the name where one has a restrictive filter clause and the other has a placeholder clause (e.g. "1=1"). By giving all roles access to the restrictive filter, but only certain roles access to the placeholder filter and by setting the Priority for the placeholder filter HIGHER than the restrictive filter, you can give those certain roles unlimited access while restricting access for all other roles.
Public classNameValueDictionary
Safe wrapper for a NameValueCollection
Public classNavHelper
A helper class for working with Navigator and NavTarget objects.
Public classNavigator
A Navigator holds an instance of a navigator (toolbar, subform, menu, ...) containing a collection of NavTarget objects.
Public classNavigators
A collection of Navigator objects.
Public classNavigatorsFactory
Factory for creating and populating a Navigators collection.
Public classNavTarget
Represents a single NavTarget. NavTarget objects are contained in Navigator objects.
Public classNavTargets
Holds a collection of NavTarget navigator items.
Public classNavTargetTypes
This is a helper class essentially providing a string enum (.Net doesn't support enumations of strings) of the valid values for TargetType for a NavTarget on a Navigator.
Public classNQCryptDecrypt
Static helper class for symetric encryption. Encryption is performed using 256-bit Advanced Encryption Standard (AES) encryption. AES is also known by its original name, Rijndael. AES is currently used because it is a strong encryption that is widely accepted and its implementation is available on all platforms.
Public classNVCollectionExts
Helper extension methods for the NameValueCollection class.
Public classOptionalDSLinkWidget
The OptionalElementWidget for Datasheet top links.
Public classOptionalElementWidget
Base class for classes used to return JSON response to a request for an optional element widget.
Public classOptionalFieldWidget
The OptionalElementWidget for datasheet fields.
Public classOptionalLinkWidget
The OptionalElementWidget for MiniNav links.
Public classOptionalPaneWidget
The OptionalElementWidget for console panes.
Public classOptionalTabWidget
The OptionalElementWidget for TabbedSubformTemplate subform tabs.
Public classOptionGroupAdapter
A DropDownList adapter to add OptGroup support to HTML SELECT tags. The group to which each item belongs should be specifed by adding a "Group" attribute to that ListItem with the group text as its value.
Public classPageElementInfo
A PageElementInfo describes an element of a page. Page elements make up multi-part pages for templates like the WizTemplate.aspx. Each page is defined by a PageInfo object which has a Elements collection holding its elements.
Public classPageElementInfos
Holds a collection of PageElementInfo objects. This collection is primarily used for the Elements colleciton on a PageInfo object. When loaded via Load(IAppContext, PageInfo), the collection load its elements by Order, lowest to highest. If, while loading, multiple elements are encountered with the same Name then the first such element of equal priorty is retained and subsequent such elements ignored (that is lower order elements are favored). Priority is determined by the IsHigherPriorityThan(PageElementInfo) which favors tenant-specific pages and elements.
Public classPageElementInfoSortOnOrder
An IComparer object to allow sorting of PageElementInfos collection by sort order.
Public classPageElementMetaInfos
Class indexed by page_element_info_id (text guid)
Public classPageElementMetaInfosCollection
Collection of PageElementMetaInfos indexed by page_id
Public classPageExtensionBase
Base class for page extensions. Page extensions implement the IExtension interface and response to ExtensionEvents. For the different page event sequences see Remarks, below.
Public classPageInfo
A PageInfo object holds the metadata representation at runtime of the potential pages that could be used in an application. A Page is represented by it's MOP (module ID). The collection is loaded once (at startup) and used throughout the life of the application.

Page Overloading can achieved by specifying Device and/or Priority. When a user logs in with roles that allow access to multiple pages with the same MOP then Device and Priority are used to determine which of these pages is to be used. If a particular Device matches the current device then that page is favored. If multiple pages with the same (or no) Device are available then Priority is used to disambiguate with the highest Priority number favored.

Public classPageInfos
A collection of PageInfo objects. The primary use of this collection is the collection of all available pages in an application, accessible from the IAppContext object via PageInfos. Pages in the collection are uniquely identified by their MOP.
Public classPageInfosFactory
Factory for creating and populating a PageInfos collection.
Public classPageTargetTypes
A Helper class to formally define the strings that represent page action navigation options.
Public classPageTextHelper
Helper Class for IWizPage Derived classes to utilize Cascaded Text
Public classPasswordChangeEventArgs
Event arguments passed to the OnPasswordChange event.
Public classPicklist
Holds a collection of PicklistItem objects for use in an IField object. The set of picklists available in the application is available via the Picklists collection.
Public classPicklistCountries
An Intrinsic type Picklist handler for countries as provided by the Windows System.Globalization.CultureInfo object.
Public classPicklistCultures
An Intrinsic type Picklist handler for cultures as provided by the Windows System.Globalization.CultureInfo object.
Public classPicklistCurrencies
An Intrinsic type Picklist handler for currencies as provided by the Windows System.Globalization.CultureInfo and RegionInfo objects.
Public classPicklistDays
An Intrinsic type Picklist handler for days of the week names as provided by Windows System.Globalization for the current date culture.
Public classPicklistDynamic
The base class for all Picklist implementations of type Custom and Intrinsic. Custom and Intrinsic picklists are populated programmatically on demand.
Public classPicklistError
Defines an exception thrown by a Picklist.
Public classPicklistItem
Holds a single row in a Picklist. A pick list contains a collection of PicklistItem objects.
Public classPicklistItemInfo
Holds information about a Picklist (loaded from metadata) stored in the picklist's ItemInfo property.
Public classPicklistItemInfos
A collection of PicklistItemInfo objects.
Public classPicklistMonths
An Intrinsic type Picklist handler for month names as provided by Windows System.Globalization for the current date culture.
Public classPicklists
Holds a list of Picklist objects, lazy-loaded as they are required. Internally, this class holds a PicklistItemInfos collection to allow access to the metadata. The set of picklists available in the application is available via the Picklists collection.
Public classPicklistTimezones
An Intrinsic type Picklist handler for timezones as obtained from the Windows registry and managed by the platform TimeZones collection.
Public classPlatformCookies
The names of cookies used by the platform.
Public classPluginPreRenderEventArgs
Public classPostalCode
Utility class for working with zip codes and other postal codes.
Public classPreferenceFactory
Factory for creating and populating a Properties collection that represents preferences.
Public classProperties
A collection of Property objects.
Public classPropertiesFactory
Factory for creating and populating a Properties collection.
Public classProperty
An object container used by many of the objects in the NetQuarry platform. Most significant objects in the application include a Properties collection. Many of the Property items in those collections are loaded from meta-data. In this manner virtually all meta-data settings configuration in the platform studio are also available at runtime. In addition to exposing meta-data from the repository, Properties collections are used by platform objects to manage and/or expose certain internal information and can be used similarly by application-specific code such sa mapper extensions.

Note most objects having Properties collections also have TextItems collections that include named text items localized to the user's culture. As with the Properties collections, TextItems collections are loaded from meta-data and expose meta-data maintained by the studio.

Among the most important objects having Properties collections are:

Public classQString
A class for managing a QueryString. The class is based on the Properties collection to allow for easy parameter replacement.
Public classQueryStringExtractor
Helper class for extracting common platform information from a querystring.
Public classReport
Report objects are used to manage reports such as Crystal or SQL-Server Reporting Services reports.
Public classReportConfigException
The exception that is thrown when a report configuration error is detected.
Public classReports
The collection of application Report objects.
Public classReqParams
This is a helper class essentially providing a string enum (.Net doesn't support enumations of strings) of the various HTTP request parameters used by the platform. Note that this list is not exhaustive.
Public classRequestExtensions
Helper extension methods for the HttpRequest class.
Public classRequestHelper
Helper class for working with platform requests.
Public classRGB
This class can be used to manipulate RBG colors.
Public classRowDrilldownArgs
Event arguments provided in the RowDrilldown event.
Public classRowSourceFilterWidget
Control that functions as a filter for a control with a Picklist.
Public classRowValidateArgs
Event arguments provided in the RowValidate event.
Public classSavedFilter
Holds information about a filter. These are commonly used to store IMapper filtering. SavedFilters are stored in the xot_saved_filter table in the relevant database and exposed via the IAppContext.Filters collection.

SavedFilters may be static or dynamic:

  • Dynamic - Dynamic filters are the most common and default filter type. Dynamic filters use a SQL WHERE clause that is applied to the mapper's query. The filter is dynamic because the resulting records may change due to changes in those records' data.
  • Static - Static filters always filter on the same set of keys and so the resulting records are always the same. These keys are stored in the xot_saved_filter_keys table in the operational database and associated with a specific SavedFilter. In the case of a static filter, the SavedFilter Filter will be a subquery against that table.
You can convert a Dynamic filter to a Static filter using one of the Convert(IAppContext, IDatabase, SaveFilterConvertOptions, Int32) overloads. At this time it is not possible to convert a Static filter to Dynamic filter.

You can obtain a SavedFilter from an IMapper using the FilterSave command. This will cause the mapper to created a SavedFilter reflecting its current filtering including any FullTextSearchValue. It will also include a comprehensive Description for the filter. You can apply a SavedFilter to an IMapper using the SavedFilterApply command. This will apply the Filter clause as well as any FullTextSearchValue.

SavedFilters provide a safe way to include mapper filtering in a URL. You can use one of the RegisterReqFilter overloads to save a filter clause to the operational database and return a unique signature that can be included as the value for the standard flt parameter in a navigation url. Filters referenced in this manner can be included in a URL without risk of a SQL injection attack. You can use one of the ExtractFilterFromReq overloads to obtain a SavedFilter from a registered filter query parameter.

Public classSavedFilters
A collection of SavedFilter objects.
Public classCode exampleScheduledHandler
Base class to use when implementing a scheduled task.
Public classSerializableDictionaryTKey, TVal
A generic dictionary base class that is serializable.
Public classSession
The Session allows typed access to specified application properties. This class is generated by the code generation facilities available in NetQuarry.
Public classSessionParameterNames
Holds string constant values for all of the properties that are to be accessed in this object.
Public classShortUrl Obsolete.
Provides a way to shorten a URL using the API
Public classSignatureToImage
A supplemental class for Signature Pad ( that generates an image of the signature's JSON output server-side using C#. Alternately, you can provide a name and generate an image that resembles a signature from a font. Similar to Signature to Image PHP (
Public classSQLDeleter
Class to manage building a SQL delete statement generically across all DBMS types.
Public classSQLInserter
Class to manage building a SQL insert statement generically across all DBMS types.
Public classSQLSelectInto
Class to manage building a SQL "INSERT INTO ... SELECT ... FROM" statement generically across all DBMS types.
Public classSQLSelectParser
Class used to parse a SQL SELECT statement into its constituent elements, allow examination and/or modification of those elements, and support constructing an updated SQL SELECT statement from those, possibly modified, elements. The class is appropriate for dissecting a moderately complex SQL SELECT statement to view/modify the FROM clause and/or ORDER BY clause and is currently used by picklist FilterWidgets. The following more complex features of a SQL SELECT statement are not handled at this time:
  • UNION operator
  • INTO clause
Public classSQLUpdater
Class to manage building a SQL update statement generically across all DBMS types.
Public classCode exampleSQLUpserter
Class to manage building a statement for a SQL upsert (update or insert) using a MERGE statement. Tested only for SQL-Server which requires SQL-Server 2008/2008R2 or later for MERGE support. An upsert operation allows you to perform an INSERT if a matching record (or records) is not found and an UPDATE if a match is found. This is more efficient than performing a SELECT to determine existence followed by an INSERT or UPDATE as appropriate because it uses the SQL MERGE statement. For MERGE statement syntax, see MERGE (Transact-SQL).
Public classStringExtensions
String extension methods.
Public classStringList
A type-safe list of strings.
Public classStringMap
A basic, type-safe string-to-string mapping collection.
Public classStringSet
A set of strings.
Public classStringTokenizer
Implements a StringTools.StringTokenizer class for splitting a string into substrings using a set of delimiters.
Public classStringUtils
General-purpose string utilities.
Public classTagUtils
Utility code for generating HTML tags.
Public classCode exampleTemplate
A Template is a fragment or file used to build a localized string for various uses.

One of the most common uses for templates is as the basis for the body of an email message. To see an example of how to use a Template see IEmailService.

The most common format for a template is HTML, but, depending on how it is being used, any text format is supported. Templates support substitution markers whose name/value pairs are typically provided in a NameValueCollection when the template is resolved using one of the various Replace or Expand methods.

The markers may take two forms:

When populated from a IMapper default markers will, by default, be substitued using the DisplayText of the corresponding IField (obtained via DisplayTextGet(DispTextFlags)). However, an optional marker prefix may be included to specify otherwise (see TemplateNodeMarker). For example, {{&first_name}} would mean that the marker should be replaced with the HTML-escapted text for the "first_name" field's caption.

  • & - Caption: Use the field's Caption.
  • * - RawValue: Use the field raw value.
  • + - ImmediateEdit: Substitute for use with ImmediateEdit. This only applies to page content, but not to email templates and similar.
  • / - NavLink: Substitute with a field's NavLink. NavLink marks should not be escaped (that is, always use the '[[]]' delimiters).
  • % - Template: Substitute with the expanded content of the specified inner template. Template marks should generally not be escaped (that is, generally use the '[[]]' delimiters). A template marker may optionally include a set of name/value pairs used in expanding the inner template. Any name/value pairs provided will override the corresponding of name/value pairs provided to the outer template. The syntax for a template reference is %<template-name>[:name1=value1;name2=value2...] (wrapped in an outer [[]] or {{}}). A colon is used to separate the optional name/value list, a semi-color separates each name/value pair, and an equals sign separates each name from its value.
  • # - Numeric: Substitute with a numeric field's raw value or 0 (zero) when null/empty.
  • = - HasValue: Substitute with "1" or "" (empty string) depending on whether or not the field's DisplayText has a non-null/non-blank value.

Templates are commonly used for the following purposes:

Templates also support events fired to TemplateExtensionBase components:

Here is an example of a simple email template including substituion markers:
Dear {{first_name}} {{last_name}},
<br />
Thank you contacting us regarding interest in our {{product_name}} product.  One of our sales people will contact
you shortly to help you with any questions you may have and to aid in ordering.
<br />
Additional information is available at [[product_url]].
<br />
<br />
Public classTemplateExtensionBase
The recommended base class for all Template extensions.
Public classTemplateField
A field associated with a Template and typically used to map fields in the Template to a corresponding IField objects in a IMapper. A Template's fields are mantained in its TemplateFields collection.
Public classTemplateFields
Holds a collection of TemplateField objects associated with a Template. A Template can have localized text for various uses including use with email and simple reports.
Public classTemplateNode
Class representation of a Node that is parsed from a Template's text.
Public classTemplateNodeMarker
This class serves as a sort of enumeration of template marker prefix characters. These characters are used to determine the TemplateNodeType. For example, a marker like {{&first_name}} indicates that the marker should be replaced by the HTML-escaped caption for the referenced IField.
Public classTemplateNodes
The collection of TemplateNode objects describing the template.
Public classTemplates
Holds a collection of Template objects. Templates have localized text for various uses including email and simple reports. Note that the collection is indexed by Name.
Public classTextItem
Implements the ITextItem interface
Public classTextItems
A collection of TextItem objects used to host the (potentially) localized text for a particular object.
Public classThresholdLogger
Creates a simple way to log a timer message to the devlog if, and only if, a timing Threshold is exceeded. Use the TimerLogger to log bracketed timing entries without thresholding.
Public classTimePeriod
Descriptor for a known date/time period used in filtering.
Public classTimePeriods
The collection of known, localized date/time periods.
Public classTimerLogger
Creates a simple way to log a timer message to the devlog. The logger writes bracketing start and stop entries in the devlog. The two entries are tied together with a bracketingID that can be used to identify a particular entry's matching entry via the F8 key. Entries are logged with Info severity unless a Warning threshold is provided in the Stop(String, Double) call.

In order to avoid cluttering up the devlog, it is sometimes desirable to write a timer entry if, and only if, some timing threshold is exceeded. Use the ThresholdLogger for this purpose.

Public classTimeSpanExtensions
TimeSpan extension methods.
Public classTimeZone
Class which holds information about a TimeZone. Both a name and a TimeZoneInfo are included.
Public classTimeZones
A collection of TimeZone objects indexed by their timezone IDs.

Typically you should obtain a TimeZones collection from the application via TimeZones. That collection is constructed by the application at startup and properly loaded from the registry.

In addition to the timezones loaded from the server's Windows registry, a number of special timezones are predefined in the collection:

  • 0 - The Coordinated Universal Time (UTC), or Zulu timezone (like GMT, but does not adjust for Daylight Savings), UTCTimeZone.
  • . - User local timezime (if known), UserLocalTimeZone.
  • -1 - User local timezime (if known), same as "." used where a numeric value is required.
  • -2 - Server local timezime (if known), ServerLocalTimeZone.
Numeric values for the most commonly used timezones are defined as constants in TimeZonesZones.

To perform a timezone conversion between arbitrary timezones you can use Convert(String, String, DateTime) or Convert(Int32, Int32, DateTime) which will return a date/time even if one or both timezones are unknown (in which case the date/time value is returned without any conversion). For more more control you can first get the source TimeZone and call Convert(TimeZone, DateTime) providing the destination TimeZone.

Note that timezone conversion always requires the date/time value to have both a date and time component.
Public classTimeZonesZones
The platform TimeZone fixed ID values for common timezones. For long-existing Windows timezones, these ID's are derived from the Microsoft Time Zone Index Values from the Windows registry, see For such timezones the platform timezone ID can be obtained from the Windows timezone index by adding 100, for example, the Windows timezone index for U.S. Pacific Time is 4 and the corresponding platform timezone ID is 104.
Public classTwoFactorAuthenticationArgs
Public classUIHiddenAttribute
Marks an enumeration item as one that should not be exposed via the UI (e.g. in the studio properties enum editor).
Public classUnixDateTimeConverter
Converter to take UNIX timestamp and convert to NULLABLE DateTime type. Example: 1487207985 --> 02/16/2017 1:19am (UTC).
Public classValidationUtils
General-purpose server-side value validation utilities.
Public classValidBitsAttribute
Provides a ValidBits attribute for enumerations. This facilitates runtime detection of unknown enumeration item use via the DevLogUnknownBits() method.
Public classWebServiceEventArgs
Arguments for WebService events
Public classWizardCommandEventArgs
Event argument provided during WizardCommand events.
Public classWizardCompleteEventArgs
Event argument provided during WizardComplete events.
Public classWizardDataExchangeArgs
Event arguments provided during WizardDataExchange events.
Public classWizardEventArgs
Base class for all wizard events.
Public classWizardFinalSaveEventArgs
Event argument provided during WizardBeforeFinalSave events.
Public classWizardPageEventArgs
Event arguments provided during IWizPage events.
Public classWizCompletedPageInfo
Describes a completed wizard page in an IWizardTemplate wizard and accessible via CompletedPages. In the case of a completed page from another wizard instance that chained to this wizard, only the StepCaption will be available and Info will be null.
Public classWizCompletedPageInfos
A collection of WizCompletedPageInfo objects representing the set of completed wizard pages in an IWizardTemplate wizard. These completed pages can result from the current wizard instance or a previous wizard instance that chained to the current instance. In the case of a completed IWizPage from another wizard instance that chained to this wizard, only the StepCaption will be available and Info will be null.
Public classWizContainerEventArgs
Event argument provided during WizardPaneBeforeLayout events.
Public classWizContainerPanes
A collection of IConsolePane objects.
Public classWizOrderedPanes
A collection of IWizContainerPane objects order by ascending Order.
Public classWizPageBase
Provides a base class for a UserControl that is part of a wizard. You can also create a wizard PageElementInfo renderer by deriving from WizPageKernel which also implements the IWizPage interface (as required by all wizard page renderers), but does not derive from System.Web.UI.UserControl.
Public classWizPageData
Helper class for managing a wizard's UserData. The IWizardTemplate uses the UserData collection to mananage data across wizard pages. This class provides a number of useful facilities based around the idea of accessing the data by InstanceName. Note that all values are stored as strings.

These factilities fall into the following groups:

Public classWizPageExtensions
Extension methods for IWizPage objects. These methods are implemented as extensions because there are a relatively large number of object implementing IWizPage which cannot inherit functionality because they derive from different base classes.
Public classWizPageKernel
Provides an abstract base class for a UserControl that is part of a wizard. You can also create a wizard PageElementInfo renderer by deriving from WizPageBase which also implements the IWizPage interface (as required by all wizard page renderers), but derives from System.Web.UI.UserControl.
Public classXmlUtils
General-purpose utilities for manipulating XML.
Public classZipInfo
Zip code information class normally obtained by calling LookupZipInfo().
Public structureSystemTime
A structure (similiar to the DateTime structure) that is used for performing calculations of the differences it time between various time zones. This is the equivalent of the SYSTEMTIME structure in the Windows API.
Public structureTimeZoneInfo
Structure which contains the equivalent of the TIME_ZONE_INFORMATION structure in the Windows API.
Public interfaceIAppContext

The Application context object holds information that is used throughout each page (or server) request. The Application is available to all objects, either as a direct parameter or property on an existing object. The Application object is created as the first object in any request, and when possible it is cached for performance purposes. The application hosts extensions and fires various application ExtensionEvents to those extensions. The normal IAppContext implementation is provided by the AppContext object.

The following properties are commonly accessed:

The following methods are commonly used:

In addition to the properties and methods directly exposed via the interface, a number of additional commands, identified by AppExecCmds, are available via the Exec(Enum, Int32, Object) method.

Public interfaceICacheable
Defines the ICacheable interface. Objects that implment this interface require handling during cache.
Public interfaceICmdHandler
ICmdHandler interface. An object that implements the ICmdHandler interface can be scheduled using the task scheduler.
Public interfaceIConsolePane
Public interface for individual panes in an IConsoleTemplate page. Each pane corresponds to one PageElementInfo in the console's Elements collection. Each pane has a header implementing the IConsolePaneHeader object accessed via the pane's PaneHeader property.
Public interfaceIConsolePaneHeader
The interface implemented by the IConsolePane header on IConsoleTemplate pages accessible via the pane's PaneHeader property.
Public interfaceIConsolePaneRenderer
This interface may optionally be implemented by console pane renderers for tighter interaction with the console page.
Public interfaceIConsoleTemplate
Public interface for the ConsoleTemplate pages. A console includes a collection of IConsolePane objects. Each pane has a Renderer UserControl (derived from the EAPControlBase class) and typically an IMapper available from the pane's MapperObject property. The console is expected to have exactly one "main" pane available from the MainPane property. Each pane corresponds to one PageElementInfo in the Elements collection of the console's PageInfo.

Console pages can generally be of two types:

  • Main - Console pages presenting panes filtered relative to the main pane (using each pane's ParentViewKeySource. and ViewKey). An example would be a company page, commonly named somethig like company!main, showing the company detail and list of related items for that company such as employees, clients, and projects.
  • Dashboard - Console pages presenting panes not filtered on the main pane. Often dashboard consoles present groups actions and of links to various parts of the application.

By default the console page presents all panes that are visible at one time. However, the console also supports Pane Navigation whereby only one pane marked with the PaneNavigation attribute, the Active Pane, is shown at one time. When Pane Navigation is in use the default Active Pane is specified by the HomePane.

For an overview of console page events see PageExtensionBase.
Public interfaceCode exampleIDatabase
The Database object simplifies development tasks that implement common data access functionality. The standard implementation of this interface is the Database object.
Public interfaceIEAPBase
Describes a common interface for objects.
Public interfaceIEAPExtendedException
Interface used some platform exception objects to provided extended exception information. Primarily used by EAPException.
Public interfaceIEventHandler
Defines an interface that handles an event.
Public interfaceIExtension
Extensions allow extended standard and custom functionality to be configured on a object within the application, generally on mappers. Extension objects implement this interface and respond to interesting events by manipulating the object firing the event or otherwise acting based on the object. Extensions receive standard events as defined in ExtensionEvents and can receive custom events corresponding to the range of custom events defined in ExtensionEvents.

The three most common types of extension, from most to least common are:

Public interfaceIFileConverter
This is the interface used by the PDFConverter service. It is used to convert files from one type to another. One of the most common uses is to convert HTML text to a PDF file. You can use the IPDFDocument for Template to PDF conversion.
Public interfaceIFTP
FTP Interface for either FTP or SFTP support
Public interfaceIFunctionParser
Components implement this interface in order to provide resolution for custom embedded functions. See EmbeddedParser for more information on embedded functions.
Public interfaceIFunctionParser2
This is an extension interface to the IFunctionParser interface to provide additional functionality. To use this interface the function parser must also implement the IFunctionParser interface.
Public interfaceINavRenderer
This interface is implemented by certain navigation renderers, currently the WizMiniNav and MiniNavCtrl components. Components implementing this interface support programmatic modifications to their navigation elements.
Public interfaceIPageFixedPurpose
An interface for pages not implementing IPageTemplate, but that still need to expose certain common functionality.

Some examples of pages implementing this interface, but not IPageTemplate are:

  • Find - Provides a mechanism for a finding a single record and relating it to another record.
  • MultiFind - Provides a mechanism for a finding one or more records and relating it/them to another record.
Public interfaceIPageTemplate
The standard interface for page templates. See IPageTemplate2, supported by some page templates, for access to extended capabilities. See IPageFixedPurpose, support by certain other pages.

By far the most common page templates are:

  • TabbedSubformTemplate - Provides a horizontally split screen with a bottom pane presenting multiple tabs related to the data in the top pane.
  • ExpandedSubformTemplate - Provides a horizontally split screen with a bottom pane vertically presenting multiple expandable items related to the data in the top pane.
  • WizTemplate - Implements IWizardTemplate and provides a multi-page wizard typically used for creating one or more new items.
  • ConsoleTemplate - Implements IConsoleTemplate and provides a user console with multiple data panes manipulable by the user (non-Bootstrap applications).
  • BootConsoleTemplate - Implements IConsoleTemplate and provides a user console with multiple data panes manipulable by the user (Bootstrap applications).
Public interfaceIPageTemplate2
Supported by page templates with extended capabilities. See IPageTemplate for access to standard features.
Public interfaceIPDFDocument
Interface for the platform Template to PDF converter. Use the IFileConverter with the PDFConverter service for converting HTML to a PDF file.
Public interfaceIRenderer
The interface used to expose EAPControlBase functionality. Common renderers include:
  • dsctrl - The traditional Datasheet.
  • ConsoleDatasheet - The Datasheet intended for use in a console page.
  • MiniList - A lightweight, static Datasheet.
  • phantomdetail - The traditional, editable detail.
  • MiniDetail - A Template-driven, mostly read-only detail.
  • ConsoleDetail - The detail intended for use in a console page.
  • LiteralContent - Static content, possibly from a Template.
  • MiniNav - A list of navigation elements.
  • BootRepeater - Renders each records as a block in the console page.
Public interfaceISupportsDebugInfo
Deprecated -- Implement the ISupportsDebugInfo2 instead. For backward comptibility The ISupportsDebugInfo definition is still provided, but is no longer called.
Public interfaceISupportsDebugInfo2
Indicates that an object supports registering debug information on a page.
Public interfaceIToggler
The toggler control presents a small button (by default a plus/minus) allowing the user to hide/unhide the associated control via javascript. The associated control is typically a DIV (.Net Panel).

There are currently two implementations of IToggler:

  • Toggler - The original platform toggler WebControl.
  • TogglerB - The new toggler WebControl implemented using standard Bootstrap CSS and javascript.

Public interfaceIWizardTemplate
Implemented by the wizard template which coordinates wizard pages for a wizard instance. For an overview of wizard page events see PageExtensionBase.
Public interfaceIWizContainer
This interface is implemented by IWizPage pages that contain other wizard subpages.
Public interfaceIWizContainerPane
Interface for panes contained in IWizContainer wizard pages.
Public interfaceIWizHeader
Defines a common interface for a UserControl used in a WizardHeader slot. Components in that slot may optionally implement this interface. If so implemented, the wizard will make appropriate calls to the interface. The renderer used in the wizard's Header slot must be derived from Sytsem.Web.UI.UserControl and generally should implement IWizHeader in order to obtain the header's wizard context. Note that at this time the wizard supports hosting only a single Header slot on a page (if multiple are specified one will be chosen arbitrarily).
Public interfaceIWizPage
Defines a common interface for a UserControl that is part of an IWizardTemplate.
Public interfaceIWizPageDesigner
Defines a common interface for a wizard page UserControl that supports the IWizPage interface AND extended capabilities. This interface is intended for internal use only and is subject to change. It's name is historical in nature and misleading as it is no longer constricted to controls that support a designer. Use the AllowDesign to determine this rather than just testing for interface support.
Public delegateEmbeddedParserParseMethod
Delegate used internally for predefined dynamic functions.
Public enumerationAdHocListAttrs
Attributes specific to a particular ad hoc list report instance.
Public enumerationAlphaFilterAttrs
Attributes for the AlphaFilter links on a datasheet
Public enumerationAnchorFlags
Option flags provided to TagAnchor(String, String, String, String, String, AnchorFlags) to specifiy how the HTML A (anchor) tag is rendered.
Public enumerationAppAppearance
Options controlling overall application appearance.
Public enumerationAppExecCmds
Public enumerationAppLayoutOptions
Options controlling overall application layout.
Public enumerationApplicationAttrs
Defines the attributes for an IAppContext object.
Public enumerationApplicationLoadFlags
Behavior flags for CreateInstance(String, String, String, Properties) and when creating an application via ContextFactory.
Public enumerationApplicationMessageArgsMessageStatusCode
Status of the SMS message.
Public enumerationAppServerEnvironment
Server environments as obtained from GetServerEnvironment.
Public enumerationAppType
The application type. A formal application type has been introduced in v4.5.2 and at this implementation is still only partially complete. Use AppTypeGet and AppTypeSet to get/set the application type on a particular IAppContext instance.
Public enumerationAppUIStyle
Specifies the application user interface (UI) style. Currently this is specified by the AppUIStyleUIFeature.
Public enumerationAuthenticationFlags
Options providing additional information about how user authentication should be performed. The flags are used with Authenticate(String, Int64) , Authenticate(String, String, NameValueCollection, Int64), and AuthenticateUser(String, String, String, Int32).
Public enumerationBookmarkAttrs
Attributes used in the xot_bookmarks.attr_bits column.
Public enumerationBootModalOptions
Options for use with the OpenBootModal(IAppContext, String, BootModalOptions) method.
Public enumerationBootstrapBreakpoints
Bootstrap breakpoints.
Public enumerationBootstrapPanelComponent
Bootstrap panel components. In Bootstrap 3 this is the panel concept, but in Bootstrap 4 it has been combined with other concepts into the card concept
Public enumerationBootstrapTableBorder
Bootstrap table border styles
Public enumerationBootstrapTableOptions
Bootstrap table design options
Public enumerationBootstrapTheme
Bootstrap theme styling
Public enumerationBrowserCapabilities
Browser capabilities that can be ascertained using the Supports(BrowserCapabilities) method.
Public enumerationBrowserEngine
Specifies the Browser Engine. This is a less fine grained
Public enumerationBrowserLoggingAttrs
Specifies behavior attributes for managing how browser history is logged.
Public enumerationBrowserPlatformType
Platform type of the browser
Public enumerationBrowserSupport
The platform support level for the current browser.
Public enumerationBrowserType
Specifies the type of the browser
Public enumerationCarouselAttrs
Options for controlling BootCarousel and RecordSlider presentation and behaviour.
Public enumerationChkFlags
Option flags provided to TagCheck(String, String, ChkFlags) to specifiy how the HTML INPUT (type=check) tag is rendered.
Public enumerationCloneStatusAttrs
Attributes that denote the clone status of a clonable object
Public enumerationCmdHandlerAttrs
Attributes that modify the behavior of a command handler.
Public enumerationCollectionAddFlags
Add modifiers.
Public enumerationCompatibilityOptions
Backward compatibility behaviour options for the application.
Public enumerationComponentAttrs
ComponentInfo attributes.
Public enumerationComponentInfoFindType
Find type enums
Public enumerationComponentLoadOptions
Options affecting how components are dynamically loaded in LoadComponent(String, String, ComponentLoadOptions).
Public enumerationCompressionLevel
The rendered file image compression level
Public enumerationConsoleOptions
Options for use with IConsoleTemplate. Currently used for the UI Feature to allow for system-wide Console configuration.
Public enumerationConsolePaneAttrs
Attributes specifying IConsolePane characteristics.
Public enumerationConsoleTemplateDisplayAttrs
Attributes that modify IConsoleTemplate pages.
Public enumerationConstructLinkOptions
Options available to the EAPUtil.ConstructLink() method.
Public enumerationContentResolution
Type of content to use (low resolution or high) on the Template.
Public enumerationConversionOutputType
The type of file to output
Public enumerationConversionSourceType
The input source type
Public enumerationCrumbFlags
Flags for managing breadcrumbs.
Public enumerationCSRFValidationOptions
Options provided to the ValidateCSRFToken(String, CSRFValidationOptions) method.
Public enumerationDatabaseAttrs
Database Attributes.
Public enumerationDatabaseExceptionTypes
Public enumerationDatabaseExecCommands
Public enumerationDatabaseOpenOptions
Public enumerationDatabaseSpaceOptions
Public enumerationDataFuncOptions
Public enumerationDBMSType
The database type.
Public enumerationDebugAttrs
Defines the debug attributes for an IAppContext object
Public enumerationDeveloperFeatureAttrs
A grab bag of feature attributes to turn on, to assist in tracking down certain problems. Setting developer features may actually have a performance impact on the system and should only be used temporarily.
Public enumerationDeviceClass
Browser device classes primarily driven by form-factor. May be uesr-selectable (e.g. on Andriod devices).
Public enumerationDevLogOptions
Options for InitNew
Public enumerationDiffCountOptions
Options used when determining difference count between two strings.
Public enumerationDiffOptions
Options used when diffing string.
Public enumerationDrilldownAttrs
Attribute bits for Drilldown options.
Public enumerationEAPVersionsBaseVersions
Attributes that denote the clone status of a clonable object
Public enumerationEnableRuleOptions
Public enumerationEventInfoAttrs
Attributes specific to EventInfo objects.
Public enumerationExcelExportAttrs
Attributes for controlling the behavior of Excel Export. These mainly manage the behavior for offline exports.
Public enumerationExcelExportLoggingBehavior
Attributes to control specific behavior of how an export is logged
Public enumerationExcelExportMode
Options affecting how to determine whether an Excel export is executed online, or offline.
Public enumerationExcelExportOfflineReasons
Attributes to record the reason why an export was forced into offline mode
Public enumerationExcelExportStatus
Tracks the status of an offline Excel export.
Public enumerationExcelImportMode
Options affecting how to determine whether an Excel export can be executed offline.
Public enumerationExcelImportQueueAttrs
Attributes for controlling the behavior of Excel Import queue functionality.
Public enumerationExcelImportStatus
Tracks the status of an offline Excel import.
Public enumerationExcelImportTemplateAttrs
Attributes for controlling behavior of Excel Import Templates
Public enumerationExceptionOptions
Options used to specify additional characteristics about an exception. Use by exception classes implementing IEAPExtendedException, primarily used by EAPException.
Public enumerationExecuteOptions
Public enumerationExecuteThroughAdapterAttrs
Public enumerationExportAuditAttrs
Specifies what type(s) of audit to perform on export.
Public enumerationExportAuditType
The different types of export audits we keep track of in the xot_audit_export table.
Public enumerationExportCommandOptions
Options affecting how export commands are presented and handled.
Public enumerationExtensionAttrs
These attributes specify how a particular mapper IExtension is to be handled on an object.
Public enumerationExtensionCmd
Commands that can be issued to extensions in a ExtensionCommandArgs object using the ExtensionCommand event. Note that at this time these commands are intended for internal use and no provision is made in the standard extension bases classes for handling them easily. However, these commands may be issued easily enoungh. For example, mapper.Extensions.FireEvent(ExtensionEvents.ExtensionCommand, map, new ExtensionCommandArgs(ExtensionCmd.DoNotLogRowCurrent)); which would command all extensions on the mapper to NOT log their RowCurrent events to the DevLog.
Public enumerationExtensionEvents
Events fired to extensions implementing IExtension. Event args will vary by event. Note that EventBulkContext is normally available in any event's Event args, but only meaningful when a bulk operation is in process.
Public enumerationExtensionFindType
Specifies the type of find to perform on the Extensions collection using the method.
Public enumerationExtensionType
Extension type enumeration.
Public enumerationExtInfo
Extension information item idenfier.
Public enumerationExtResults
Results to be returned as a result of an IExtension event. It is set in the EAPEventArgs.Result object provided by the event.
Public enumerationExtsExecCmds
Commands for use with the Extensions.Exec() method.
Public enumerationFailedSqlLoggingAttrs
Specifies what kind of logging should be performed to the xot_failed_sql_log. This is specified in the FailedSqlLoggingAttrsloggingFeature.
Public enumerationFeatureAttrs
Attributes specific to features
Public enumerationFileHandlingAttrs
Application-wide settings for controlling file handling.
Public enumerationFilterAttributes
Attributes for SavedFilter objects.
Public enumerationFilterConjunction
The set of known filter conjunction types.
Public enumerationFilterDateFlags
Flags specifying how a filter should be constructed.
Public enumerationFilterFindOptions
Options affecting SavedFilters.Find behaviour.
Public enumerationFilterFindType
Type of find to use in SavedFilters.Find().
Public enumerationFilterKeywordRules
Rules for how a particular filter keyword is used.
Public enumerationFilterOp
The enumeration of known filtering operations. These correspond with matching FilterSyms string constants.
Public enumerationFireAndForgetCountHelperFireAndForgetStatus
The status of a FireAndForgetCount.
Public enumerationFireAndForgetOptions
Public enumerationFireEventStatus
Status set in the event arguments.
Public enumerationFormatExceptionOptions
Public enumerationFTPCreateDisposition
Denotes how file creation is managed in FTP transfers
Public enumerationFTPFileTransferAttributes
Modified behavior of an FTP file transfer session
Public enumerationFTPFileTransferDirection
Denotes the direction for an FTP File Transfer
Public enumerationFTPRemoteAccessMode
File access mode to file on remote server
Public enumerationGenNavAttrs
Public enumerationGetListOptions
Options for the GetList(String, GetListOptions) method.
Public enumerationGetPageFlags
Options controlling how to obtain PageInfo information.
Public enumerationGlobalSearchAttrs
Defines the attributes for global search in the single frame master.
Public enumerationGoogleAnalyticsOptions
Controls behavior for Google Analytics
Public enumerationImgFlags
Option flags provided to TagImg(String, String, String, String, ImgFlags) to specifiy how the HTML IMG tag (generally as used as a button) is rendered.
Public enumerationImplicitVocabLocations
ImplicitVocabLocations - attributes that apply to implicit vocab support on objects other than just field captions
Public enumerationImportAttrs
General import attributes for use with the import wizard.
Public enumerationImportWizardAttrs
Attributes that modify the behavior of import wizard pages (not page elements) ImportWizardAttrs ).
Public enumerationInplaceDialogAttrs
Attributes used with various PopupManagement feature items to specify how in-place dialogs should be handled.
Public enumerationInputStreamType
Describes the format of the assoicated input stream.
Public enumerationInputTagTypes
Override types for the TYPE attribute of HTML5 INPUT tags. These provides for enhanced features on supporting browsers degrading to basic textbox support on older browsers.
Public enumerationIntrinsicPicklists
Identifies the set of available intrinsic Picklist implementations.
Public enumerationLayoutControlAttrs
Attributes controlling the behaviour of layout controls.
Public enumerationLocaleSetting
An enum listing the possible places a Locale override could be coming from
Public enumerationLogCategory
Describes the category of the message.
Public enumerationLoginItemAttrs
Attributes controlling the behaviour of a login item.
Public enumerationLogMessageLevel
enum LogMessage Level
Public enumerationMapperExportOptions
Options affecting how mapper data is exported.
Public enumerationMapperSummaryAttrs
Options controlling how a MapperSummary component (not a MapperSummary field) renders its summary.
Public enumerationMetadataCacheOptions
Options controlling metadata caching.
Public enumerationMiniDetailAttrs
Options for controlling MiniDetail behaviour.
Public enumerationMinIEVersion
The minimum version of Internet Explorer that must be supported. This is a primary factor in determining which version of jQuery to use (unless overridden by the jQueryPathCompatibilityFeature). Used in the MinIEVersionCompatibilityFeature.
Public enumerationMiniNavAttrs
Options for controlling MiniNav behaviour.
Public enumerationNamedFilterAttrs
Attributes that apply to a NamedFilter.
Public enumerationNavAttrs
Attribute bits for Navigators.
Public enumerationNavigateAttrs
Specifies different behavior for the NavigateNavigate(String, String, String, String, NavigateAttrs, String) method on the AppContext object.
Public enumerationNavLoadOptions
Navigator load options.
Public enumerationNavLoadTypes
Specifies the meaning of the string used to load the navigator object.
Public enumerationNavTargetAttrs
Attribute bits for NavTargets.
Public enumerationNavTargetFindType
Specifies the type of find to perform on the NavTargets collection.
Public enumerationNumWordOpts
Options for converting numbers to words using the NumToWords(IAppContext, Int32, NumWordOpts) method.
Public enumerationNVMergeOptions
Options for use with NvCollectionExts extensions to the .Net NamedValueCollection class.
Public enumerationObjectPermissions
Defines the possible permission attributes for an object. Note that not all of the attributes apply to all object types.
Public enumerationOptElementFlags
Flags used to describe an optional element.
Public enumerationPageDisplayAttrs
Attributes that modify the page display.
Public enumerationPageElementAttrs
Attributes that apply to PageElements
Public enumerationPageElementInfoFindType
Used in Find(String, PageElementInfoFindType) to specify the type of search.
Public enumerationPageElementPermissionsLevel
Used by the PageElementPermissionsLevel property of the Compatibility feature to specify the ObjectPermissions available for use on a PageElementInfo object in an application. For historical reasons the default level is Read. In order to upgrade an existing application to use ReadWrite you should perform the following steps:
  1. Check in all meta-data changes as the conversion process may alter existing meta-data.
  2. Check out all meta-data in prepartion for the conversion.
  3. Run the nq_add_pei_permissions.sql script against the repository to perform the conversion.
  4. Check in altered .meta files.
  5. Set the PageElementPermissionsLevel property of the Compatibility feature and check in the modified .meta file.
If the conversion process is not performed then page elements that have been explicitly permissioned will lose the Insert/Write/Delete permissions.
Public enumerationPageElementVisibility
Possible values for the PageElement.Visibility property on console page elements.
Public enumerationPageFindType
Methods to use when finding a page using the Find(String, PageFindType) method.
Public enumerationPageInfoAttrs
Attributes of a PageInfo object.
Public enumerationPageOrientation
Page Orientation
Public enumerationPagePopupType
Specifies the type of popup page.
Public enumerationPageSize
Page size
Public enumerationPageTypesAllowed
Specifies the types of pages where certain functionality is available.
Public enumerationPaneNavAttrs
Attributes controlling the behaviour of navigation links on a IConsolePane.
Public enumerationParameterAttrs
Attributes specific to parameters
Public enumerationParamMask
A mask of bits for identifing missing or superfluous Exec parameters.
Public enumerationPasswordRuleValidationOpts
Options for use in validating a password using the ValidatePasswordRules command to apply a custom PasswordRuleRegEx or the default rule is no custom rule is specified.
Public enumerationPDFOutputOpts
Public enumerationPicklistAttrs
Attributes affecting Picklist behaviour.
Public enumerationPicklistFlushOptions
Options for use with Flush(PicklistFlushOptions).
Public enumerationPicklistItemAttrs
Attributes for individual PicklistItem objects.
Public enumerationPicklistItemStatus
Identifies the state of a particular picklist item in the live Picklist instance.
Public enumerationPicklistTagStringFlags
Flags used to hint on requested format for tag string in calls to GetTagString(String, String, PicklistTagStringFlags) method.
Public enumerationPicklistType
The type of the Picklist. A Picklist can be one type only.
Public enumerationPolicyAttrs
Attributes that apply to a policy
Public enumerationPopupOpts
Option flags for use with navigation to popup pages.
Public enumerationPostalCodeSearchOptions
Options used when searching for zip codes.
Public enumerationPostBackSource
Specifies the source for the PostBack as sent to the IWizardTemplate and accessible there via PostSource.
Public enumerationPreferenceLevelInfoAttrs
Attributes that modify the behavior of a PreferenceLevelInfo object
Public enumerationPropertyAttrs
Property.Attributes values
Public enumerationPropertyLoadFlags
Properties.Load modifiers
Public enumerationPropExportFlags
Flags for Properties.ExportTagString()
Public enumerationPropSortType
The types of sorting available using Properties.SortByValue().
Public enumerationReadableAuditAttrs
Specifies behavior attributes to override the default auditing behavior.
Public enumerationRepeaterAttrs
Options for controlling BootRepeater presentation and behaviour.
Public enumerationReplaceOptions
Options specifying how to perform string replacement.
Public enumerationReportAttrs
Attributes controlling report behaviour.
Public enumerationReportFindType
Used to specify how a Report is to be found in a Reports collection using Reports.Find.
Public enumerationReportTypes
Report types. Note that ReportTypes below 100 are intended to be presented in the standard Report List. Those 100 and greater are intended for other uses.
Public enumerationResolveOptions
Public enumerationSaveFilterConvertOptions
Options specifying the behaviour of Convert(IAppContext, IDatabase, SaveFilterConvertOptions).
Public enumerationScheduledHandlerRunDays
Days that a scheduled task should execute.
Public enumerationSchedulerNavigation
Command from the RadScheduler renderer during navigation
Public enumerationSchedulerView
The view of the current scheduler.
Public enumerationSchemaInfoType
Schema object types used in obtaining schema information from a database view GetSchemaInfo(String, SchemaInfoType).
Public enumerationSplitOptions
Options specifying how to split a string.
Public enumerationSQLColumnFlags
Flags for use when adding columns in SQL helper classes.
Public enumerationSQLHelperFlags
Flags specifying how a SQL statement is to be constructed by the SQL helper classes.
Public enumerationSqlServerErrorNumbers
An enumeration of specific SQL-Server error numbers. See for a list of SQL-Server error codes.
Public enumerationStatusMsgOptions
Options for use with the StatusMsgJS(String, StatusMsgOptions) method. These options may be combined using bit-wise OR.
Public enumerationStringComparisonTypes
String comparison types, often used in conjunction with System.StringComparison to provide a wide variety of string comparision options.
Public enumerationSubformAttrs
Attributes that apply to subforms.
Public enumerationSubformDisplayAttrs
Display attributes that apply to subforms.
Public enumerationSupportType
Specifies the type of support for a particular feature.
Public enumerationSystemFunctionType
The System Function Type. Declares a set of types that refer to some area of system functionality that can have a specific datasource. Use GetSystemFunctionDatasource to get the database object for a specific syustem function such as request logging, auditing, task logging
Public enumerationTagImportAttrs
Attributes specifying how TagString imports are to be handled. Provide for future use.
Public enumerationTemplateAttrs
Attributes that apply to a Template. Templates are typically stored in meta-data and/or operational data and accessed via the application's Templates collection.
Public enumerationTemplateFieldAttrs
Attributes that apply to a TemplateField.
Public enumerationTemplateFileType
Template file's type.
Public enumerationTemplateFindType
Search mechanisms available for use with Find(String, TemplateFindType).
Public enumerationTemplateNodeType
Type of Template Node as used in NodeType.
Public enumerationTemplateReplaceFlags
Public enumerationTextItemAttrs
TextItem.Attributes values
Public enumerationTextJustification
The jstification of the document text
Public enumerationTextLoadFlags
TextItems.Load modifiers
Public enumerationTextTypeAttrs
TextTypeAttrs - attributes that apply to the type of text
Public enumerationTimeDirs
Identifies time/date offset direction when parsing date/time value strings. For example, the direction "next month" for would be TimeDirs.Next while that for "prev year" would be TimeDirs.Last.
Public enumerationTimePeriodType
Identifies type of time/date period when parsing date/time value strings.
Public enumerationTimeZoneFindType
Find types for use with TimeZones.Find() to find a specific timezone in athe collection.
Public enumerationTimeZoneSetFlags
Flags use in conjunction with IAppContext.Exec(AppExecCmds.UserTimeZoneSet).
Public enumerationToolbarDisplayAttrs
Display Attributes for a page's toolbar.
Public enumerationTriState
A true/false/unknown tri-state enum.
Public enumerationUICommandAttrs
Modifier flags for UI commands.
Public enumerationUpsertRoles
Options specifing what role(s) this column takes in the MERGE statement used by the SQLUpserter. It is common for a particular column to take part in multiple roles in a single upsert.
Public enumerationUrlLinkType
Public enumerationViewStateStorageOptions
Options that control the view state storage.
Public enumerationWakeUpFlags
Modifier flags for WakeUp(WakeUpFlags).
Public enumerationWindowOpenOptions
Option flags for use with WindowOpenFeatures().
Public enumerationWizardButtons
Specifies the buttons to display on the IWizardTemplate.
Public enumerationWizAttrs
Attributes that apply to wizard pages, IWizardTemplate (for attributes for wizard page elements see WizPageAttrs). Set in the Studio using the WizardAttributes property and accessed programmatically via WizardAttributes.
Public enumerationWizDataExchangeType
Identifies the type of data transfer for which a WizardDataExchange event is being fired.
Public enumerationWizEditListOptions
Wizard editable list page options.
Public enumerationWizListOptions
Wizard list page options.
Public enumerationWizNavAttrs
Attributes controlling IWizardTemplate navigation.
Public enumerationWizNavigations
Wizard navigation destinations for use with Navigate(WizNavigations, Boolean, String) which is used to perform programmatic navigation from a wizard during a wizart event. The avaliable destinations include the wizard's FinishTarget, CancelTarget, as well as specific PageTargetTypes. Note that typically Navigate(WizNavigations, Boolean, String) is not used and the wizard is allowed to perform its normal cancel or finish navigation per its CancelTarget or FinishTarget, respectively.
Public enumerationWizPageAttrs
Flags specifying the behaviour of an IWizPage element.
Public enumerationWizPageSelectors
Attributes controlling record selectors on IWizardTemplate list pages.
Public enumerationWizQuestionnaireAttrs
Options controlling how a WizQuestionnaire page behaves.
See Also