Namespace LemonEdge.Client.Core.Views.Core

Classes

AuditHistoryToolWindow

The tool window Item used to display a AuditHistory tool window

BaseDefaultSingleViewController<T>

The core controller for handling the IBaseDefaultSingleView<T> view

This is the main controller for creating a view with custom controls for editing any specified entity of type T

Both this controller and the BaseGridController view have a similar mechanism for creating controls dynamically within the UI

BaseDefaultSingleViewCustomController<T>

The system controller used for automatically creating a IBaseDefaultSingleView<T> according to a ICustomView definition

Uses the SingleViewControllerCustomViewParams parameter for the view to determine the ICustomView to load the defintion of

BaseDefaultSingleViewExtenderController<DISPLAYTYPE, EXTENDEDTYPE>

The core controller for providing a IBaseDefaultSingleView<T> against an entity that extends (IsTypeExtender) another type

If the DISPLAYTYPE does not exist this will temporarily create one and only add it to pending changes when the user actually modifies the temporary item itself

BaseEntityDefaultSingleViewInstanceEnumerator

The ViewDescriptorEnumerator for the IBaseDefaultSingleView<T>

BaseGridAnyRelatedAnyCollectionController<T>

The base generic grid controller which works with the IBaseGridAnyRelatedCollection<T> view and displays an entity type as rows in the grid that are all related to an other object

This is the main base controller for creating grids, and dynamically creating their columns, for any entity in the system that is related to another object. It is different from BaseGridRelatedAnyCollectionController<SI, T> or BaseGridRelatedCollectionController<SI, T> as that single item type must be the same, where as this can have a parent that can be of different types allowing it to work against any entity parent

Both this controller and the BaseDefaultSingleViewController<T> view have a similar mechanism for creating controls dynamically within the UI

BaseGridAnyRelatedCollectionController<T>

The base generic grid controller which works with the IBaseGridAnyRelatedCollection<T> view and displays an entity type as rows in the grid that are all related to an other object

Both this controller and the BaseDefaultSingleViewController<T> view have a similar mechanism for creating controls dynamically within the UI

BaseGridController

The base non-type generic version of BaseGridControllerAny<T>/BaseGridController<T> which works with the IBaseGrid<T> view

This is the main base controller for creating grids, and dynamically creating their columns, for any object in the system

Both this controller and the BaseDefaultSingleViewController<T> view have a similar mechanism for creating controls dynamically within the UI

BaseGridController<T>

The base generic grid controller which works with the IBaseGrid<T> view and displays an entity type as rows in the grid

This is the main base controller for creating grids, and dynamically creating their columns, for any entity in the system. The BaseGridControllerAny<T> is used objects that are not entities inheriting from IBaseEntity

Both this controller and the BaseDefaultSingleViewController<T> view have a similar mechanism for creating controls dynamically within the UI

BaseGridControllerAny<T>

The base generic grid controller which works with the IBaseGrid<T> view and displays any type of object as rows in the grid

This is the main base controller for creating grids, and dynamically creating their columns, for any object in the system. The BaseGridController<T> is used specifically for entities inheriting from IBaseEntity

Both this controller and the BaseDefaultSingleViewController<T> view have a similar mechanism for creating controls dynamically within the UI

BaseGridControllerWrapper<TWrapper, TMain, TPivot>

The base wrapper grid controller which works with the IBaseGridWrapperCollection<TWrapper, TMain, TPivot> view displaying wrapped items with pivotted columns in the wrapper

This is the main controller for creating grids of any wrapped item in the system that holds pivotted columns of another item in the system

Both this controller and the BaseDefaultSingleViewController<T> view have a similar mechanism for creating controls dynamically within the UI

BaseGridCustomController<T>

The system controller used for automatically creating a IBaseGrid<T> according to a ICustomGrid definition

Uses the GridViewControllerCustomViewParams parameter for the view to determine the ICustomGrid to load the defintion of

BaseGridEntityCollectionViewInstanceEnumerator

The ViewDescriptorEnumerator for the IBaseGrid<T>

BaseGridRelatedAnyCollectionController<SI, T>

The base generic grid controller which works with the IBaseGridRelatedCollection<SI, T> view and displays an object type as rows in the grid that are all related to an other entity

This is the main base controller for creating grids, and dynamically creating their columns, for any object in the system that is related to another entity. It is different from BaseGridRelatedCollectionController<SI, T> as that only displays entities, and BaseGridControllerAny<T> as that can have multiple different types of parent it is related to where as this must be of type SI

Both this controller and the BaseDefaultSingleViewController<T> view have a similar mechanism for creating controls dynamically within the UI

BaseGridRelatedCollectionController<SI, T>

The base generic grid controller which works with the IBaseGridRelatedCollection<SI, T> view and displays an entity type as rows in the grid that are all related to an other entity

This is the main base controller for creating grids, and dynamically creating their columns, for any entity in the system that is related to another entity. It is different from BaseGridRelatedAnyCollectionController<SI, T> as that can display any object, and BaseGridControllerAny<T> as that can have multiple different types of parent it is related to where as this must be of type SI

Both this controller and the BaseDefaultSingleViewController<T> view have a similar mechanism for creating controls dynamically within the UI

BaseTreeViewController<T>

The controller for handling the IBaseTreeView<T> view

This controller/view allows the selection of entities of type T that can be used for sub-views accessing the SelectedItemForSubViews.

Thus all areas grids can be used (such as the default lookup views for selecting items for single lookup controls) this view can also be used instead

BaseTreeViewRelatedController<SI, T>

A base controller for handling the IBaseTreeView<T> view for all entities related to a parent item

ChartViewController

The controller for handling the IChartBase view

ChartViewResultParams

The parameters for the IChartBase view and ChartViewController, indicating what chart to execute

CollectionItem

The base item that is used for an Item in a DisplayableItemDescriptorForCollection<T> instance

This item simply indicates that this is the type of entity to be loaded as a collection - it does not load anything itself so has no cost. That is the responsibility of the views in the IModelLayoutDisplayer for this item

CollectionItem<T>

The item that is used for an Item in a DisplayableItemDescriptorForCollection<T> instance

The entity type T will be displayed as a collection

CommentsToolWindow

The tool window Item used to display a Comments tool window

ControlDisplayInfo

A complete control definition of the type of control that should be dynamically created in the client application UI via the IBaseGrid<T>, IBaseDefaultSingleView<T>, and IParamSingleViewer<T> views

ControlDisplayInfoFormulaResult

The class passed to controls that display a ControlDisplayInfo set to hold the result of a formula value

ControlDisplayInfoLight

A light weight version of the ControlDisplayInfo that holds the most commonly used properties

The system uses this in a number of places to provide quick definitions for controls to use in a view. The system can the expand these into actual ControlDisplayInfo instances as required

ControlDisplayVisibilityInfo

A class that details which column is currently visible in a IBaseGrid<T>, as users can hide/show all columns

CustomFormatHelper

A helper class for returning the correct .net culture string format for the specified ui CustomDateTimeFormat

CustomSettingsItem

The base item that is used for an Item in a DisplayableItemDescriptorForCustomSettings instance

This custom item provides all the overrides to the properties the DisplayableItemDescriptor is responsible for so you have complete control of how to display any custom object

Should be marked with a CustomSettingsItemLayoutInfoAttribute

CustomSettingsItemLayoutInfoAttribute

Used with any type inheriting CustomSettingsItem to indicate the valid types of layouts it can be displayed against

DashboardDisplayerItem

The item that is used for an Item in a DisplayableItemDescriptorForCustomSettings instance

This item specifies that we want to load a custom layout which can display any custom design - a homepage/dashboard

DataSourceSearchDisplayerItem

The item that is used for an Item in a DisplayableItemDescriptorForCustomSettings instance

This item specifies that we want to load the Data Source Search functionality that has custom views for running a aspecific custom query and displaying the results to the user

This item also has a custom DataSourceSearchParam associated parameter for default initial search parameters

DataSourceSearchParam

The custom search parameter for the DataSourceSearchDisplayerItem used in the DisplayableItemDescriptorForCustomSettings displayable item descriptor

DataSourceSearchParamController

The controller for editing the DataSourceSearchParam in a popup single parameter window

DataSourcesToolWindow

The tool window Item used to display a DataSources tool window

DisplayableItemDescriptor

This is the main class that is always passed to a ModelLayoutDisplayerController to be displayed by that layout displayer

This wraps the item to be displayed with other properties such as if its read-only, the context (IEntityUpdater), label/icon info, etc

Inheriting display descriptors all serve different purposes, allowing behaviour such as collection displays (DisplayableItemDescriptorForCollection<T>), single entity item displays (DisplayableItemDescriptorSingle<T>), tool window displays (DisplayableItemDescriptorForToolWindow), and custom displays (DisplayableItemDescriptorForCustomSettings)

DisplayableItemDescriptorForCollection<T>

The DisplayableItemDescriptor for an item that should display a collection of entity types

The Item is not the entity collection itself, that is loaded by the views however they like, simply a CollectionItem class that represents what type of collection should be loaded and displayed

DisplayableItemDescriptorForCollectionParams

Optional paramaters that can be associated with the ItemParams for a DisplayableItemDescriptorForCollection<T>

These provide extra settings for filtering the displayed collection to a set of specific entities

DisplayableItemDescriptorForCustomSettings

The DisplayableItemDescriptor for a custom item of any type

The Item is a CustomSettingsItem class that represents the item, label, image, and layout that should be used for loading and displaying this item

This allows you to completely define custom objects (that do not even derive from IBaseEntity), all that can operate within a custom defined layout

DisplayableItemDescriptorForToolWindow

The DisplayableItemDescriptor for a tool window item that typically displays items relevant to the active IModelLayoutDisplayer it is working against

The Item is not the active layout displayer, that is loaded by the tool window views however they like (usually inheriting ModelToolWindowController), simply a ToolWindowItem class that represents what type of tool window should be loaded and displayed

DisplayableItemDescriptorSingle<T>

The DisplayableItemDescriptor for an instance of an entity type T

The Item is the entity itself

DocumentsToolWindow

The tool window Item used to display a Documents tool window

EntityTagsToolWindow

The tool window Item used to display a EntityTags tool window

GridColumnGroup

A class used to represent the possible grouping headers for columns in the IBaseGrid<T> itself

This is heiarchical allowing multiple grouping levels

Columns within the Columns() definition can refer to the UniqueKey to indicate which column header grouping they should reside within

GridViewControllerCustomViewParams

The parameters for the IBaseGrid<T> when used with a BaseGridCustomController<T> indicating which ICustomGrid definition should be loaded in the view itself

GridViewControllerCustomViewParamsController

The controller for editing the GridViewControllerCustomViewParams in a popup single parameter window

We do not need an associated IViewSerializedParamDefaultEditor implementation as this is a standard popup single parameter editor. We only need that if it has a custom editor

HasVersionController<T>

The default controller for an entity that implements IHasVersion

Provides version information and controls

ImageViewParams

The parameters for the IImageView view and ImageController, indicating what chart to execute

ImageViewSerializedParamController

The controller for editing any ImageViewParams in a popup parameter window

ItemTasksToolWindow

The tool window Item used to display a ItemTasks tool window

LayoutChangeEventArgs

The event arguments for a LayoutChangedEvent

LayoutDisplayerToolWindow

The tool window Item used to display a LayoutDesigner tool window

LayoutSubViewItemChangedEventArgs

The settings used for the LayoutSubViewItemChangedEvent delegate for describing the new item that is the output of a view that all its sub views can now use

LayoutTabChangedEventArgs

The settings used for the LayoutTabChangedEvent delegate for describing the active tab that has changed in the layout

MessageSerializedParamController

The controller for editing any MessageViewParams in a popup parameter window

MessageViewParams

The parameters for the IMessageView view and MessageController, indicating what message to display

ModelLayoutDisplayerController

The main controller for any IModelLayoutDisplayer ui cclient application component that contains a custom layout and is responsible for displaying and working with an item

ModelLayoutHostController

The main controller for any IModelLayouHost view which can contain multiple instances of IModelLayoutDisplayer

ModelToolWindowController

An base controller for any view that is purely hosted within a tool window (see https://web.lemonedge.com/help/tool-windows/) and works against a ToolWindowItem

ModelViewController

The base controller to be used against all IModelView views in the system

NotificationsToolWindow

The tool window Item used to display a Notifications tool window

PermissionsToolWindow

The tool window Item used to display a Permissions tool window

PivotViewController

The controller for handling the IPivotBase view

PivotViewResultParams

The parameters for the IPivotBase view and PivotViewController, indicating what pivot to execute

SchemaDisplayerItem

The item that is used for an Item in a DisplayableItemDescriptorForCustomSettings instance

This item specifies that we want to load the schema layout for displaying the database schema for all entities in the system

SingleViewControllerCustomViewParams

The parameters for the IBaseDefaultSingleView<T> when used with a BaseDefaultSingleViewCustomController<T> indicating which ICustomView definition should be loaded in the view itself

SingleViewControllerViewParamsController

The controller for editing the SingleViewControllerCustomViewParams in a popup single parameter window

We do not need an associated IViewSerializedParamDefaultEditor implementation as this is a standard popup single parameter editor. We only need that if it has a custom editor

ToolWindowItem

The base item that is used for an Item in a DisplayableItemDescriptorForToolWindow instance

This item simply indicates that this is the type of tool window to be loaded - it does not load anything itself so has no cost. That is the responsibility of the views in the IModelLayoutDisplayer for this tool window (which typically work against the active IModelLayoutDisplayer)

All implementations must also have a parameterless constructor so the system can determine the different types of layouts this DisplayableItemDescriptorForToolWindow supports (through an internal IDisplayableDescriptorPossibleLayouts implementation)

ToolWindowItemForSingleTabOrGridSelectedItem

The base item that is used for an Item in a DisplayableItemDescriptorForToolWindow instance that works against either the IModelLayoutDisplayer main displayed item, or the current selected item within a grid within the layout

ViewDescriptorAttribute

The attribute against any IModelView interface that defines a view that can be created in a client application within a layout. This attribute can be used multiple times to describe multiple different view descriptor instances that are valid for a view.

This attribute provides the equivelant of the ViewDescriptorInstance used to describe the IModelView this attribute is against

Alternatively it provides a type that inherits ViewDescriptorEnumerator that itself returns a list of all the possible ViewDescriptorInstance that can be used against this view.

This is typically used to provide a seperate ViewDescriptor for each entity it can work against, or if the IModelView has a generic argument it may enumerate all the possible types in the parameters, etc.

These instances are used by the layout designer to display to the user valid views that can be added against a layout

ViewDescriptorEnumerator

A class that provides an enumeration of all possible view descriptor instances for a specific IModelView

This can be referenced in the ViewDescriptorAttribute for a IModelView

ViewDescriptorInstance

A class responsible for holding the description of an instance of a IModelView to be created within a layout

This includes an custom parameters for the view itself along with parameters for the type of view

ViewSerializedParam

The root parameter type that all Param must inherit from. By default all views have this parameter type.

Custom types can be provided for by marking a IModelView with a ViewDescriptorEnumerator which specifies the parameter type for each ViewDescriptorInstance it returns

They can also be specified using the ViewSerializedParamAttribute which a ViewDescriptorEnumerator can use, such as with the IBaseGrid<T> enumerator which looks for this attribute to create custom parameters for the view descriptor instance

ViewSerializedParamAttribute

An attribute that can be placed against a view controller to indicate the type of parameter (inheriting from ViewSerializedParam) the view itself uses

Typically this can be indicated using the ViewDescriptorAttribute against the IModelView itself using the ViewDescriptorEnumerator option

However for views that are generic, although the view maybe the same there maybe many different parameter types depending on the generic type

For instance the BaseGridController<T> works with the IBaseGrid<T> view. Any implementation of the controller can be marked with this attribute so the ViewDescriptorEnumerator can retrieve the correct parameter type for that grid controller

You can use this in your own ViewDescriptorEnumerator, or against any grid controller which already looks for this attribute. i.e. the SQLWrapperResultsController uses this to specify it uses the SQLWrapperResultsViewParams

ViewSerializedParamController

This is the controller for editing all ViewSerializedParam parameters stored against a Param

This is accessible to the user when using the LayoutDesigner and editing the properties of any view

This controller also provides a way to edit the custom properties of any parameter that inherits from ViewSerializedParam

WatchersToolWindow

The tool window Item used to display a Watchers tool window

Interfaces

IBaseDefaultSingleView<T>

The standard single entity item view that can dynamically create appropriate controls as required from an implementation of the BaseDefaultSingleViewController<T>

This is the core view for creating views for any entity in the system

Both this view and the IBaseGrid<T> view have a similar mechanism for creating controls dynamically within the UI

IBaseGrid

A common set of functionality that is not type specific that the IBaseGrid<T> view implements in order to be accessibly without knowing the generic type the grid works with

IBaseGrid<T>

The standard object grid view that can dynamically create appropriate columns as required from an implementation of the BaseGridController<T>

This is the core view for creating grids for any object in the system

Both this view and the IBaseDefaultSingleView<T> view have a similar mechanism for creating controls dynamically within the UI

IBaseGridAnyRelatedAnyCollection<T>

The standard base grid view implementation for displaying entity items related to a main object, and that inherits all the functionality of dynamically creating apropriate columns from the IBaseGrid<T>

This is the core view for creating grids of any entity in the system that are related to another object in the system. It is different from IBaseGridRelatedCollection<SI, T> as that single item type must be the same, where as this can have a parent that can be of different types allowing it to owkr against any entity parent

Both this view and the IBaseDefaultSingleView<T> view have a similar mechanism for creating controls dynamically within the UI

IBaseGridAnyRelatedCollection<T>

Both this view and the IBaseDefaultSingleView<T> view have a similar mechanism for creating controls dynamically within the UI

IBaseGridController

A common interface that all implementations of BaseGridController provide access to which manipulate the IBaseGrid<T> view

IBaseGridRelatedCollection<SI, T>

The standard base grid view implementation for displaying entity items related to another entity item, and that inherits all the functionality of dynamically creating apropriate columns from the IBaseGrid<T>

This is the core view for creating grids of any entity in the system that are related to another entity in the system, it is different from IBaseGridAnyRelatedCollection<T> as that can have multiple different types of parent it is related to where as this must be of type SI

Both this view and the IBaseDefaultSingleView<T> view have a similar mechanism for creating controls dynamically within the UI

IBaseGridWrapperCollection<TWrapper, TMain, TPivot>

The standard base grid view implementation for displaying wrapped items with pivotted columns in the wrapper, and that inherits all the functionality of dynamically creating apropriate columns from the IBaseGrid<T>

This is the core view for creating grids of any wrapped item in the system that holds pivotted columns of another item in the system

Both this view and the IBaseDefaultSingleView<T> view have a similar mechanism for creating controls dynamically within the UI

IBaseTreeView<T>

The standard tree view used by the BaseTreeViewController<T> for displaying a heirarchical set of data as a tree view

IBaseTreeViewWithExpansion<T>

Optionally enhances the IBaseTreeView<T> with the capability to fully expand all tree nodes at once

IChartBase

The standard chart view used by the ChartViewController for displaying a pre-configured chart from IChart

Uses the ChartViewResultParams parameter type for the view

ICollectionExportable

An interface that allows a controller the possibility of implementing that determines what can be exported from the controller when the ExportData command is used

Grid controllers implement this to allow the export of just the data in the grid rather than re-running data from the server

ICustomSettingsItemLayoutInfoParameters

An implementation that provides all possible parameters for a custom layout.

Specifed from CustomSettingsItemLayoutInfoAttribute

IDisplayableDescriptorPossibleLayouts

An interface that must be implemented by a constructable class for each DisplayableItemDescriptor implementation detailing the possible layout combinations that it works with

IImageView

The standard message used by the ImageController for displaying a pre-configured image to the user

Uses the ImageViewParams parameter type for the view

ILayoutDesignConfigure

If the client application IModelLayoutDisplayer also implements this interface then that allows the user to configure the layouts using the LayoutDesigner (https://web.lemonedge.com/help/tool-window-layout-designer/)

This enables the designer to manipulate the layout by adding/removing/moving/changing views and tabs within the layout itself

ILockable

A UI interface used for processors (BaseTransactionProcessor and others) to ensure controls are locked as appropriate

IMessageView

The standard message used by the MessageController for displaying a pre-configured message to the user

Uses the MessageViewParams parameter type for the view

IModelLayouHost

The main interface for hosting multiple IModelLayoutDisplayer instances. The IMainform implements this too as the main display for hosting multiple IModelLayoutDisplayer instances

IModelLayoutCommon

A common interface implemented by the IModelLayouHost and IModelLayoutDisplayer for displaying items, closing, and getting the root host instance

IModelLayoutDisplayer

The main interface for hosting a layout responsible for displaying a DisplayableItemDescriptor to the user

This is presented via a custom layout either generated (ILayoutGenerator), or loaded (ILayout), to arrange and display all the relevant views to the user

This displayer is responsible for passing the correct data in to each view to be displayed and controlling their interactions

IModelSingleLayoutDisplayer

The main interface for popup windows that also implement the IModelLayouHost but are not the IMainform

Instead they are used purely as a host of a single IModelLayoutDisplayer in a popup window, and are not capable of displaying multiple displayers unlike the main application itself

IModelView

The base interface all UI views within a layout must implement within any client application.

Views are created by the CreateView(ViewDescriptorInstance) client implementation that creates the specific UI components according to the type of application

All views belong to a layout, see https://web.lemonedge.com/help/layouts/ for more information

IModelViewController

The base interface for a controller of any IModelView

IPivotBase

The standard pivot view used by the PivotViewController for displaying a pre-configured pivot from a IPivot

Uses the PivotViewResultParams parameter type for the view

IRelatedItemQueryFilterInterceptor

An interface that provides the ability for a dependant IAddIn to customize the filters that occur on controls in standard system views.

The standard system views that look for any implementation of this interface are:

Allocation Rules: Requires a ForEntityType of IAllocationAmount to alter the entities allowed for the allocation amount entity id lookup
Gl Posting Allocations: Requires a ForEntityType of IGLPostingAllocated to alter the entities allowed for the gl posting allocation entity id lookup
Transaction Value Allocations: Requires a ForEntityType of ITransactionAllocated to alter the entities allowed for the transaction allocation entity id lookup
Period End Adjusted Data Items: Requires a ForEntityType of ICapitalAccountDataItem to alter the entities allowed for the capital account data item entity id lookup
Transfer View: Requires a ForEntityType of ITransfer to alter the entities allowed for the transfer source entity id lookup
Transfer Target View: Requires a ForEntityType of ITransferTargetPartner to alter the entities allowed for the transfer target entity id lookup

IViewSerializedParamDefaultEditor

If a IModelView has any parameters (defined using Param) the type must inherit ViewSerializedParam

By default it is assumed the parameters have an associated ParamSingleViewerController<T> and the system presents a popup editor using that

This interface provides a custom way of editing those parameters with a custom parameter view. In order for the system to always be able to edit these parameters from anywhere the IViewSerializedParamDefaultEditor<T> should be implemented

IViewSerializedParamDefaultEditor<T>

If a IModelView has any parameters (defined using Param) the type must inherit ViewSerializedParam

By default it is assumed the parameters have an associated ParamSingleViewerController<T> and the system presents a popup editor using that

This interface provides a custom way of editing those parameters with a custom parameter view.

Enums

CustomDateTimeFormat

An enumeration of the custom date time formats that can be used as a Format in the controls dynamically created in the client ui

LayoutChangeType

The type of layout change within a IModelLayouHost

Namespace LemonEdge.Client.Core.Views.Core

Classes

Interfaces

Enums

Delegates