Common implmentation for Controls implementing IAjaxContainerControl interface. Usage is to implement IAjaxContainerControl and forward every method in that interface to this class. All AjaxContainer Controls supports partial rendering by supporting the ForceAnUpdate method and related method TrackControlAdditions which means that the user can only render new controls that are appended on the control when needed. Examples of controls using this class is Panel, HybridPanelBase and MultiView

This is the worker class used by Gaia Ajax Controls to initialize the ajax machinery. It handles state, rendering, callbacks, general inclusion of resources and more.

Usage is to implement IAjaxControl and write forward calls in that interface to this class.

An EffectEvent is a client side "event" dispatched by a Gaia Control or navtive DOM element For example the Window supports events like Appearing, Closing, Minimizing, etc and these effect events all have custom properties passed into the event arguments on the client. To properly connect an Effect to one of these pure client side events you should add the effect to the Effect collection of the control and also use an effect event to tie them together. The available effect events are commonly made available as static functions on the control itself.

The AjaxEffectEvent factory is used to create common Effect events where mostly the functionName and the afterFinish parameter is in use. This allows you to more easily create required Effect Events.

Attribute class for telling the Gaia Core Runtime that a property is serializable. Usage is to submit the JavaScript "setter method" as JSMethodName part of the Attribute. Then when the property is changed during an Ajax Callback the framework itself will handle serializing the new value back to the client.

Abstract base class for all AjaxSerializable attributes.

Apply attribute to the property the value of which needs to be formatted as an Url. The value will be formatted using Control.ResolveClientUrl method.

This class implements IAspect and can be used as the base class for creating your own Aspects. If you want to be able to bind your aspects to members (ie. properties, events) you need to inherit from this class so that the sender argument get's correct.

Contains equality operators to avoid duplicate aspects. Inherit from this class if you don't plan to add your own equality checks.

This is the worker class used by Aspectable Gaia Controls. It's primary responsibility is to handle Aspects. Usage is to implement IAjaxControl and forward every method in that interface to this class.

Aspect class for making elements clickable. Element you attach this Aspect to can be clicked with the mouse even though they're not "natively" clickable elements. When clicked you will be able to trap that event on the server through the Clicked of the DblClicked event. Both single clicks and double clicks are supported, you can choose which of the two (or both) you wish to trap for the widget you attach this aspect to.

EventArgs for Clicked and the DblClicked events. Notice here that you do have access to the x and y coordinate of the place the mouse cursor was at when the event was raised.

Helper class to make registering of ParentControl abstracted while adding Aspects into a Control

Aspect class for making elements draggable or movable. Element you attach this Aspect to can be dragged around on screen with mouse. See AspectDroppable for how to make it possible to track specific places they are dropped.

Aspect class for making elements droppable. Element you attach this Aspect to can "catch" Drop events from other Draggable elements that have the same Accept string.

EventArgs class for the Dropped Event.

Generic Aspect with Generic Events. This aspect is used to handle some scenarios the other aspects where not designed to handle but which we didn't feel justified creating explicit aspect for. E.g. "blur" and "focus" on widgets can be handled with this Aspect.

AspectHoverable can dispatch server events on true MouseOver/MouseOut events for a control. It automatically takes care of the bubbling problem and only dispatches the event if you have subscribed to it and if it actually is a true MouseOver of that Element.
Also notice that the MouseOver and MouseOut events for many of the Gaia Ajax controls actually use AspectHoverable under the hood by using AspectBindings. In many cases it's more appropriate to use those events directly instead of adding the Aspect.

EventArgs for the Hover Event

Aspect class for making elements trap the key clicking events. Element you attach this Aspect will raise the KeyPressed Event when a key is clicked while widget have focus.
Making key shortcuts available for your end users can increase the productivity typical of repeating operations. Currently the key events listen on any Gaia input control like TextBox, DropDownList that currently have focus.

Represents a Key with its modifiers (shift, control, etc...)

EventArgs for the KeyDown and KeyUp Events.

Key code filters used with KeyUp and/or KeyDown events.

EventArgs for the KeyPressed Event.

Character filter used with KeyPress event.

Base class for all filters which support key event suppression. Suppression may include default action and/or event propogation preventions.

Aspect for making Widgets Modal by obscuring the entire surface on the screen. If you attach this to a widget and you make the widget visible during a callback then only that widget (and widgets with higher z-index) will be "accessible" to be clicked by the end user since all other widgets will be "obscured" by a DIV which will fill up the entire viewport of the browser.

Modality is something that previously only was available when developing Windows Forms applications, but now with Gaia Ajax it's made available as an Aspect which you can attach to almost all Gaia Controls via the Aspects collection

It can be customized with a Color and Opacity by using an overloaded ctor

The Window has the Modal property which is automatically adding the Aspect for you if set to true.

Aspect class for trapping MouseMove Events on elements. You would think that this is *impossible* online since it would result in something similar to a DOS attack on the server, however the polling time can be configured.

EventArgs for the MouseMove Event

Aspect class for making elements resizable. With this aspect you can make ANY widget resizable by dragging its borders. Events will be raised (if subscribed to) on the server when the Widget has been resized by the user.

Aspect class for tracking "scroll events" on widgets. Widgets you attach this aspect to can raise the Scroll event when the user scrolls the widget. Either when scrolling to the bottom or when scrolling at all.

EventArgs for the Scroll Event

Aspect for specializing UpdateControls for specific widgets. If some widget needs special UpdateControl capabilities then use this one. The existance of this aspect will override the Manager.Instance.UpdateControl property but only for the specific widget owning this Aspect.
This is a useful feature when you only have a few time consuming functions and/or you want to display a local update control near that particular control.

Class that encapsulates initialization and destruction logic as a unit and deterministically executes them by exploiting the "using" or "IDisposable" pattern.

This class is very useful for having code executes by guarantee at some specific point in your sequence. If you have two or three operations which are completely dependant upon the order of execution in addition to that you also need guarantees that all three things should execute then this class is just what you need.

Represents a field that is displayed as text in a data-bound control.

The BrowserHistory Control allows you to add states to your application by using the AddHistory function. When the user clicks back in the browser, the state info will be passed to the server in the Navigated event. This is an Ajax request where you can restore the state of your application based on this information.

EventArgs used when the Navigated event fires. Here you will get access to the Token that was used as a bookmark in the browser history. From that you can restore state.

The Gaia Ajax Button displays a push button control on the Web page. It inherits from the ASP.NET Button, and has built-in Ajax behaviour.

Represents a field that is displayed as a button in a data-bound control.

The Gaia Ajax CheckBox displays a check box that allows the user to select a true or false condition. It inherits from the ASP.NET CheckBox, and has built-in Ajax behaviour.

Represents a Boolean field that is displayed as a check box in a data-bound control.

The Gaia Ajax CheckBoxList creates a multi selection check box group that can be dynamically created by binding the control to a data source. It inherits from the ASP.NET CheckBoxList, and has built-in Ajax behaviour.

Various ClientSide utilities to modify DOM from the server.

Represents a special field that displays command buttons to perform selecting, editing, inserting, or deleting operations in a data-bound control.

Compares the value entered by the user in an input control with the value entered in another input control, or with a constant value.

The ComposeXhtml is a helper class for creating xhtml compliant markup as string values. The ToString() and Write() functions take either an XhtmlTagFactory or XhtmlTextWriter input parameter in a delegate.

This control collection works on top of an existing collection and will shadow controls of a specific type. It will make combination controls like TreeViewItem have a collection of normal childcontrols and the specific TreeViewItems childcontrols.

A special control collection wrapper that works on top of an existing controls collection and only return the controls of the specified generic type parameter. This collection will shadow all other controls and will be perceived non existant in the collection.

An abstract control collection wrapper that implements ICollection over a normal control collection. The wrapper will only work on top of an existing ControlCollection and you can create a custom implementation in a derived class. Examples include ControlCollectionOf and ControlCollectionExcept

Css Helper class

todo: write documentation

The Gaia Ajax DropDownlist represents a control that allows the user to select a single item from a drop-down list. It inherits from the ASP.NET Button, and has built-in Ajax behaviour.

A Gaia Ajax DynamicImage can be thought of like a "normal" image except that it has no src attribute. Instead it has the capability of "dynamically render" its image through a publically available event. The DynamicImage has an event called RetrieveImage which will be called when it's time to "update" the image control with new "image data". From this event you can construct a System.Drawing.Bitmap object which will be rendered onto the surface of your DynamicImage. This makes it very easy to e.g. create a Captcha Control or render images which only exist in your database etc.

Passed to RetrieveImage event when an Image is needed for you DynamicImage object

Base class for Effects. note: This class has not been marked abstract for backwards compatibility. Ideally you should not use the ctor, but rather construct each individual effect descendant directly. For example new EffectShow, new EffectHide,

Collection of Effects.

Composite builder block for Ajax Effect Controls keeping track of the Effects collection. Don't forget to forward calls to the OnPreRender method() for script inclusion.

Contains Utility methods for working with Effects in your application.

The Gaia Ajax Configuration class

Gaia Base Control, useful if you need to create your own Ajax Control and don't want to start from scratch. If inheriting from this class you get a LOT for free when creating your own "custom extension widgets". This class inherits from the System.Web.UI.Control and is useful if you create "invisible" Ajax Controls like for instance our Timer control which is inheriting from this class. It might also be a useful base class for your extension controls if you don't need the overhead from the System.Web.UI.WebControls.WebControl class like style collection, Border, BackgroundColor and so on. It is our most lightweight Ajax Extension Control base class. Very useful class if you need to implement your own Ajax Extensions Controls with as few lines of code as possible.

Gaia Base WebControl, useful if you need to create your own Ajax Control and don't want to start from scratch. By inheriting from this class you can with extremely few lines of code implement your own Ajax Extension WebControl. Note that this is the *exact* counterpart to the GaiaControl except that this one inherits from ASP.NET WebControl instead of ASP.NET Control which means you can create Ajax Controls with Style collection, Border, Color, Font properties and so on. If you need a more "lightweight" Ajax Control then you probably should rather inherit from GaiaControl instead.

Generic Controls Collection

The Gaia Ajax GridView displays the values of a data source in a table where each column represents a field and each row represents a record. It inherits from the ASP.NET GridView, and has built-in Ajax behaviour.

Ajaxified GridViewRow

The Gaia Ajax HiddenField depresents a hidden field used to store a non-displayed value. It inherits from the ASP.NET Button, and has built-in Ajax behaviour.

Special Controls Collection for Hybrid Controls. It will only return the user defined custom controls and not the controls that are part of the composition. You can also use this collection wrapper if you need to filter your custom controls somehow. Just pass in a reference to the collection of controls that should be filtered out.

Base class for "hybrid controls". A HybridControl is an Ajax Control which have child widgets inside of it which are "part of the widget". E.g. the Window is a good example of such a control since it has both "normal" child controls which you can add to yourself in addition to that some of the controls (close button, maximize etc) are part of the widget itself. Use this class as base class if you intend to create such controls yourself.

Gaia Ajax Image displays an image on a Web page. It inherits from the ASP.NET Image, and has built-in Ajax behaviour.

Gaia Ajax ImageButton displays an image and responds to mouse clicks on the image. It inherits from the ASP.NET ImageButton, and has built-in Ajax behaviour.

Represents a field that is displayed as an image in a data-bound control.

The Gaia Ajax Image displays an image on a page. When a hot spot region defined within the ImageMap control is clicked, the control either generates an Ajax callback (postback) to the server or navigates to a specified URL. It inherits from the ASP.NET ImageMap, and has built-in Ajax behaviour.

The Gaia Ajax Label displays text on a Web page. It inherits from the ASP.NET Label, and has built-in Ajax behaviour.

The Gaia Ajax LinkButton displays a hyperlink-style button control on a Web page. It inherits from the ASP.NET LinkButton, and has built-in Ajax behaviour.

The Gaia Ajax ListBox creates a single-selection or multiselection list box. It inherits from the ASP.NET ListBox, and has built-in Ajax behaviour.

This is the "Manager" of Gaia Ajax Widgets. Basically contains lots of nice to have methods like IsAjaxCallback end so on. The Manager is also responsible for rendering the updates back to the HTTP Response Class is a Singleton which means you cannot instantiate object of it but you can access the only object in existence from the static Instance property of the class.

Attribute to mark a Method as valid for an Ajax method invocation. Without this attribute no method can be called from JavaScript on the client side. Used by Control Developers to create extension controls with support from calling methods from the server which maps back to methods on the client side.

Base EventArgs for Mouse related events

The Gaia Ajax MultiView represents a control that acts as a container for a group of View controls. It inherits from the ASP.NET MultiView, and has built-in Ajax behaviour.
It is often a better alternative than using panels, because it will help you to only display one View at the time.

The Gaia Ajax Panel represents a control that acts as a container for other controls. It inherits from the ASP.NET Panel, and has built-in Ajax behaviour.

Helper class for injecting changes back to the client and/or rendering the changes back to the client after changes have occured in a Gaia Ajax Callback.

Event argument used when OnChildSnapshotTaken is called.

Helper class for detecting changes in ListControl.Items Collection. Used by Control Developers only.

Helper class for detecting changes in ListControl.Items Collection. Used by Control Developers only.

Helper class for injecting changes back to the client and/or rendering the changes back to the client after changes have occured in a Gaia Ajax Callback.

The Gaia Ajax RadioButton represents a single radio button control. It inherits from the ASP.NET RadioButton, and has built-in Ajax behaviour.

The Gaia Ajax RadioButtonList represents a list control that encapsulates a group of radio button controls. It inherits from the ASP.NET RadioButtonList, and has built-in Ajax behaviour.

todo: write documentation

Renders a clientside representation of the aspect with construction and options/parameters. It has a nice syntax and allow you to do chaining of function calls. Use this one if you create your own Ajax Extension Controls.

Renders a clientside representation of the control with construction, options/parameters, event observations and rendering of aspects. It has a nice syntax and allow you to do chaining of function calls. Use this one if you create your own Ajax Extension Controls.

Script Builder for Effects. Simplifies generating error free JavaScript code for use in Gaia

Core Abstract Builder class for clientside object construction. Offers a nice convenient syntax for initializing clientside objects like controls, aspects and effects

todo: write documentation

todo: write documentation

This little State Utility is used on statebags to get and set values. It will by default return generic default values for structs or you can provide custom default values. When the value is set to a default value it will not be persisted in the statebag.

The Gaia Ajax TextBox displays a text box control for user input. It inherits from the ASP.NET TextBox, and has built-in Ajax behaviour.

This is our Ajax Timer Control. The Gaia Ajax Timer will poll the server raising an event handler every n'th second according to which interval you have configured it to do so. It can be disabled and enabled from the server and from the Event Handler you can do whatever you wish with other controls on the page. Including creating new controls and update existing ones.

todo: write documentation

Key filter interface

Extends IButtonControl interface by requiring implementors to support ajax related properties

This interface defines that a Gaia Control is a container widget which means it can contain child controls. Examples of such Controls are Panel, MultiView etc.

Implement this interface on any control where you need to interface with the Gaia Ajax Control Engine.

Interface for all ajax controls, which do not render a root element

Interface all aspects must implement

Implemented by Controls to which Aspects can be attached

Implemented on Effect explicitly to make a cleaner API when working with effects.

Interface applied to Effect Containers for accessing the Child Effects

This interface is used by ExtensionControlDesigner to explicitely ask the control implementing it, to set it pre render defaults when appropriate

This interface helps you add up custom rendering logic to the PropertyStateManagerControl class so that you may add up rendering logic to complex for the AjaxSerializableAttribute to handle itself.

The ISkinControl applies default skins to Gaia Controls if a CssClass or StylesheetTheme is not applied.

Delegate specifying a delegate which will be called when clearing of the dirtyness of some properties during LoadPostData() may be nesseccary

Delegate that identifies the LoadPostData method which exists on Control. Used in combination with ExecuteLoadPostData.

Callback method type

The RenderStringDelegateFactory is used as input parameter to functions where it's useful to have access to the XhtmlTagFactory

The RenderStringDelegateStream is used as input parameter to functions where you need access to the Stream. Used in Gaia.WebWidgets.AjaxControl

The RenderStringDelegateTextWriter is used as input parameter to functions where you need access to the TextWriter. Used in Gaia.WebWidgets.AjaxContainerControl

GenericEvent Enum, defines what type of event on the client-side you are interested in trapping.

Common KeyCodes.

Denotes through which borders or their combination(s) control can be resized.

Specifies in what direction or combination of directions scrolling should be trapped.

How to flush image back to Client

The type of effect to execute

Supported properties dirtyness of which can be cleared using ClearDirty() method

Event Enumerations for the Observe function.